Refactor flow creation and validation services, enhance error handling, and update input types, add more specs

Author: Knerio

app/graphql/mutations/namespaces/projects/flows/delete.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Mutations
+  module Namespaces
+    module Projects
+      module Flows
+        class Delete < BaseMutation
+          description 'Deletes a namespace project.'
+
+          field :flow, Types::FlowType, null: true, description: 'The deleted flow.'
+
+          argument :flow_id, Types::GlobalIdType[::Flow],
+                   description: 'The id of the flow which will be deleted'
+
+          def resolve(flow_id:)
+            flow = SagittariusSchema.object_from_id(flow_id)
+
+            if flow.nil?
+              return { flow: nil,
+                       errors: [create_message_error('Invalid flow')] }
+            end
+
+            ::Namespaces::Projects::Flows::DeleteService.new(
+              current_authentication,
+              flow
+            ).execute.to_mutation_response(success_key: :flow)
+          end
+        end
+      end
+    end
+  end
+end

app/graphql/types/input/data_type_identifier_input_type.rb

@@ -5,7 +5,7 @@ module Input
     class DataTypeIdentifierInputType < Types::BaseInputObject
       description 'Input type for data type identifier'
 
-      argument :data_type_id, Types::GlobalIdType[::DataTypeIdentifier], required: false,
+      argument :data_type_id, Types::GlobalIdType[::DataType], required: false,
                                                                          description: 'Data type ID'
       argument :generic_key, String, required: false,
                                      description: 'Generic key value'

app/graphql/types/input/data_type_type_input.rb

@@ -27,7 +27,7 @@ def grpc_stream(method)
       end
       define_singleton_method("end_#{method}") do |runtime_id|
         ActiveRecord::Base.connection.raw_connection
-                          .exec("NOTIFY grpc_streams, '#{self.class},#{method},#{runtime_id},end'")
+                          .exec("NOTIFY grpc_streams, '#{self},#{method},#{runtime_id},end'")
       end
     end
   end

app/graphql/types/input/rules/data_type_rule_contains_key_config_input_type.rb

@@ -21,21 +21,25 @@ def execute
 
           transactional do |t|
             settings = []
-            params[:settings].each do |graphql_setting|
-              setting = FlowSetting.new(flow_setting_id: graphql_setting.flow_setting_id,
-                                        object: graphql_setting.object)
-              next if setting.valid?
-
-              t.rollback_and_return! ServiceResponse.error(
-                message: 'Invalid flow setting',
-                payload: setting.errors
-              )
-              settings << setting
+            if params.key?(:settings)
+              params[:settings].each do |graphql_setting|
+                setting = FlowSetting.new(flow_setting_id: graphql_setting.flow_setting_id,
+                                          object: graphql_setting.object)
+                next if setting.valid?
+
+                t.rollback_and_return! ServiceResponse.error(
+                  message: 'Invalid flow setting',
+                  payload: setting.errors
+                )
+                settings << setting
+              end
+              params[:settings] = settings
             end
-            params[:settings] = settings
 
-            node = create_node_function(params[:starting_node], t)
-            params[:starting_node] = node
+            if params.key?(:starting_node) && params[:starting_node].is_a?(Types::Input::NodeFunctionInputType)
+              node = create_node_function(params[:starting_node], t)
+              params[:starting_node] = node
+            end
 
             flow = Flow.create(project: namespace_project, **params)
             unless flow.persisted?

app/graphql/types/input/rules/data_type_rule_contains_type_config_input_type.rb

@@ -5,20 +5,21 @@ module Projects
     module Flows
       module Validation
         module DataType
-          class GenericDataTypeIdentifierValidationService
+          class DataTypeIdentifierValidationService
             include Code0::ZeroTrack::Loggable
             include Sagittarius::Database::Transactional
 
-            attr_reader :current_authentication, :flow, :data_type_identifier
+            attr_reader :current_authentication, :flow, :node, :data_type_identifier
 
-            def initialize(current_authentication, flow, data_type_identifier)
+            def initialize(current_authentication, flow, node, data_type_identifier)
               @current_authentication = current_authentication
               @flow = flow
+              @node = node
               @data_type_identifier = data_type_identifier
             end
 
             def execute
-              logger.debug("Validating flow_type: #{data_type_identifier.inspect} for flow: #{flow.id}")
+              logger.debug("Validating data_type_identifier: #{data_type_identifier.id} for flow: #{flow.id}")
 
               transactional do |t|
                 if data_type_identifier.invalid?
@@ -33,13 +34,6 @@ def execute
                     )
                   )
                 end
-                if data_type_identifier.data_type.present?
-                  DataTypeValidationService.new(
-                    current_authentication,
-                    flow,
-                    data_type_identifier.data_type
-                  ).execute
-                end
                 if data_type_identifier.runtime != flow.project.primary_runtime
                   logger.debug(message: 'Data type identifier runtime mismatch',
                                primary_runtime: flow.project.primary_runtime.id,
@@ -53,6 +47,33 @@ def execute
                     )
                   )
                 end
+
+                if data_type_identifier.generic_key.present?
+                  unless node.runtime_function.generic_keys.include?(data_type_identifier.generic_key)
+                    t.rollback_and_return!(
+                      ServiceResponse.error(
+                        message: "Data type identifier #{data_type_identifier.id} " \
+                                 'does not have a generic key which exists in the node function ' \
+                                 "#{node.runtime_function.generic_keys}",
+                        payload: :generic_key_not_found
+                      )
+                    )
+                  end
+                elsif data_type_identifier.generic_type.present?
+                  ::NodeFunction::GenericTypeValidationService.new(
+                    current_authentication,
+                    flow,
+                    data_type_identifier.generic_type
+                  ).execute
+                elsif data_type_identifier.data_type.present?
+                  DataTypeValidationService.new(
+                    current_authentication,
+                    flow,
+                    data_type_identifier.data_type
+                  ).execute
+                end
+
+                nil
               end
             end
           end

app/graphql/types/input/rules/data_type_rule_input_type.rb

@@ -19,12 +19,12 @@ def initialize(current_authentication, flow, parameter, generic_mapper)
             end
 
             def execute
-              logger.debug("Validating node function: #{parameter.inspect} for flow: #{flow.id}")
+              logger.debug("Validating generic mapper: #{generic_mapper.inspect} for flow: #{flow.id}")
 
               transactional do |t|
                 target = generic_mapper.target
 
-                # Validate the target
+                # Validate the target the identifier gets validated later
                 unless parameter.generic_type.data_type.generic_keys.has?(target)
                   t.rollback_and_return!(
                     ServiceResponse.error(
@@ -35,11 +35,10 @@ def execute
                   )
                 end
 
-                ::DataType::GenericMapperDataTypeIdentifierValidationService.new(
+                ::DataType::DataTypeIdentifierValidationService.new(
                   current_authentication,
                   flow,
-                  parameter,
-                  generic_mapper,
+                  parameter.node_function,
                   generic_mapper.source
                 ).execute
               end