Merge pull request #762 from code0-tech/756-fix-unlimited-nested-parameters

fix unlimited nested parameters

Author: Taucher2003

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

@@ -24,22 +24,10 @@ def resolve(project_id:, flow:, **_params)
               }
             end
 
-            flow_type = SagittariusSchema.object_from_id(flow.type)
-            if flow_type.nil?
-              return {
-                flow: nil,
-                errors: [create_error(:flow_type_not_found, 'Invalid flow type id')],
-              }
-            end
-
             ::Namespaces::Projects::Flows::CreateService.new(
               current_authentication,
               namespace_project: project,
-              flow_type: flow_type,
-              starting_node_id: flow.starting_node_id,
-              nodes: flow.nodes,
-              flow_settings: flow.settings || [],
-              name: flow.name
+              flow_input: flow
             ).execute.to_mutation_response(success_key: :flow)
           end
         end

app/graphql/types/flow_type.rb

@@ -28,7 +28,7 @@ class FlowType < Types::BaseObject
     field :nodes, Types::NodeFunctionType.connection_type,
           null: false,
           description: 'Nodes of the flow',
-          method: :collect_node_functions
+          method: :node_functions
 
     expose_abilities %i[
       delete_flow

app/graphql/types/input/node_parameter_value_input_type.rb

@@ -5,14 +5,14 @@ module Input
     class NodeParameterValueInputType < Types::BaseInputObject
       description 'Input type for parameter value'
 
-      argument :function_value, Types::Input::NodeFunctionInputType,
-               required: false, description: 'The function value of the parameter'
       argument :literal_value, GraphQL::Types::JSON,
                required: false, description: 'The literal value of the parameter'
+      argument :node_function_id, Types::GlobalIdType[::NodeFunction],
+               required: false, description: 'The function value of the parameter as an id'
       argument :reference_value, Types::Input::ReferenceValueInputType,
                required: false, description: 'The reference value of the parameter'
 
-      require_one_of %i[function_value literal_value reference_value]
+      require_one_of %i[node_function_id literal_value reference_value]
     end
   end
 end

app/graphql/types/node_function_id_wrapper_type.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Types
+  class NodeFunctionIdWrapperType < Types::BaseObject
+    description 'Represents a Node Function id wrapper.'
+
+    authorize :read_flow
+    id_field NodeFunction
+  end
+end

app/graphql/types/node_parameter_value_type.rb

@@ -4,15 +4,15 @@ module Types
   class NodeParameterValueType < Types::BaseUnion
     description 'Represents a parameter value for a node.'
 
-    possible_types Types::LiteralValueType, Types::ReferenceValueType, Types::NodeFunctionType,
-                   description: 'The value can be a literal, a reference, or a node function.'
+    possible_types Types::LiteralValueType, Types::ReferenceValueType, Types::NodeFunctionIdWrapperType,
+                   description: 'The value can be a literal, a reference, or a node function id.'
 
     def self.resolve_type(object, _context)
       case object
       when ReferenceValue
         Types::ReferenceValueType
       when NodeFunction
-        Types::NodeFunctionType
+        Types::NodeFunctionIdWrapperType
       else
         Types::LiteralValueType
       end

app/models/flow.rb

@@ -5,9 +5,10 @@ class Flow < ApplicationRecord
   belongs_to :flow_type
   belongs_to :input_type, class_name: 'DataType', optional: true
   belongs_to :return_type, class_name: 'DataType', optional: true
-  belongs_to :starting_node, class_name: 'NodeFunction'
+  belongs_to :starting_node, class_name: 'NodeFunction', optional: true
 
   has_many :flow_settings, class_name: 'FlowSetting', inverse_of: :flow
+  has_many :node_functions, class_name: 'NodeFunction', inverse_of: :flow
 
   validates :name, presence: true,
                    allow_blank: false,
@@ -23,26 +24,7 @@ def to_grpc
       return_type_identifier: return_type&.identifier,
       settings: flow_settings.map(&:to_grpc),
       starting_node_id: starting_node.id,
-      node_functions: collect_node_functions.map(&:to_grpc)
+      node_functions: node_functions.map(&:to_grpc)
     )
   end
-
-  def collect_node_functions
-    sql = <<-SQL
-        WITH RECURSIVE node_function_tree AS (
-          SELECT *
-          FROM node_functions
-          WHERE id = ? -- base case
-          UNION ALL
-          SELECT nf.*
-          FROM node_functions nf
-            INNER JOIN node_function_tree nf_tree
-              ON nf.id = nf_tree.next_node_id
-        )
-
-        SELECT DISTINCT * FROM node_function_tree ORDER BY id
-    SQL
-
-    NodeFunction.find_by_sql([sql, starting_node_id])
-  end
 end

app/models/node_function.rb

@@ -3,48 +3,28 @@
 class NodeFunction < ApplicationRecord
   belongs_to :runtime_function, class_name: 'RuntimeFunctionDefinition'
   belongs_to :next_node, class_name: 'NodeFunction', optional: true
+  belongs_to :flow, class_name: 'Flow'
 
-  has_one :previous_node, class_name: 'NodeFunction', foreign_key: :next_node_id, inverse_of: :next_node
-  has_one :flow, class_name: 'Flow', inverse_of: :starting_node
+  has_one :previous_node,
+          class_name: 'NodeFunction',
+          foreign_key: :next_node_id,
+          inverse_of: :next_node
 
-  has_many :node_parameter_values, class_name: 'NodeParameter', inverse_of: :function_value
-  has_many :node_parameters, class_name: 'NodeParameter', inverse_of: :node_function
+  has_many :node_parameter_values,
+           class_name: 'NodeParameter',
+           inverse_of: :function_value
 
-  validate :validate_recursion, if: :next_node_changed?
+  has_many :node_parameters,
+           class_name: 'NodeParameter',
+           inverse_of: :node_function
 
-  def resolve_flow
-    sql = <<-SQL
-        WITH RECURSIVE node_function_tree AS (
-          SELECT *
-          FROM node_functions
-          WHERE id = ? -- base case
-          UNION ALL
-          SELECT nf.*
-          FROM node_functions nf
-            INNER JOIN node_function_tree nf_tree
-              ON nf.next_node_id = nf_tree.id
-        )
-
-        SELECT f.*
-        FROM flows f
-        WHERE f.starting_node_id IN (
-          SELECT id FROM node_function_tree
-        )
-        ORDER BY f.id
-    SQL
-
-    flows = Flow.find_by_sql([sql, id])
-
-    raise 'Multiple flows found' if flows.count > 1
-
-    flows.first
-  end
+  validate :validate_recursion, if: :next_node_changed?
 
   def validate_recursion
     current_node = self
+
     until current_node.next_node.nil?
       current_node = current_node.next_node
-
       if current_node == self
         errors.add(:next_node, :recursion)
         break

app/policies/node_function_policy.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class NodeFunctionPolicy < BasePolicy
-  delegate { subject.resolve_flow }
+  delegate { subject.flow }
 end

app/services/namespaces/projects/flows/create_service.rb

@@ -7,12 +7,12 @@ class CreateService
         include Sagittarius::Database::Transactional
         include FlowServiceHelper
 
-        attr_reader :current_authentication, :namespace_project, :params
+        attr_reader :current_authentication, :namespace_project, :flow_input
 
-        def initialize(current_authentication, namespace_project:, **params)
+        def initialize(current_authentication, namespace_project:, flow_input:)
           @current_authentication = current_authentication
           @namespace_project = namespace_project
-          @params = params
+          @flow_input = flow_input
         end
 
         def execute
@@ -26,53 +26,29 @@ def execute
               error_code: :no_primary_runtime
             )
           end
-
           transactional do |t|
-            settings = []
-            if params.key?(:flow_settings)
-              params[:flow_settings].each do |graphql_setting|
-                setting = FlowSetting.new(flow_setting_id: graphql_setting.flow_setting_identifier,
-                                          object: graphql_setting.value)
-                if setting.invalid?
-                  t.rollback_and_return! ServiceResponse.error(
-                    message: 'Invalid flow setting',
-                    error_code: :invalid_flow_setting,
-                    details: setting.errors
-                  )
-                end
-
-                settings << setting
-              end
-              params[:flow_settings] = settings
-            end
-
-            if params.key?(:starting_node_id)
-              params[:starting_node] = create_node_function(params[:starting_node_id], params[:nodes], t)
-
-              params.delete(:starting_node_id)
-              params.delete(:nodes)
-            end
+            flow_type = FlowType.find_by(id: flow_input.type.model_id, runtime_id: namespace_project.primary_runtime.id)
 
-            flow = Flow.create(project: namespace_project, **params)
-            unless flow.persisted?
+            if flow_type.nil?
               t.rollback_and_return! ServiceResponse.error(
-                message: 'Failed to create flow',
-                error_code: :invalid_flow,
-                details: flow.errors
+                message: 'Invalid flow type for the project runtime',
+                error_code: :invalid_flow_type
               )
             end
 
-            res = Validation::ValidationService.new(current_authentication, flow).execute
-
-            if res.error?
-              t.rollback_and_return! ServiceResponse.error(
-                message: 'Flow validation failed',
-                error_code: :flow_validation_failed,
-                details: res.payload
-              )
-            end
+            flow = Flow.new(
+              project: namespace_project,
+              name: flow_input.name,
+              flow_type: flow_type,
+              input_type: flow_type.input_type,
+              return_type: flow_type.return_type
+            )
 
-            UpdateRuntimesForProjectJob.perform_later(namespace_project.id)
+            UpdateService.new(
+              current_authentication,
+              flow,
+              flow_input
+            ).update_flow(t)
 
             AuditService.audit(
               :flow_created,
@@ -87,98 +63,6 @@ def execute
             ServiceResponse.success(message: 'Created new flow', payload: flow)
           end
         end
-
-        def create_node_function(node_function_id, input_nodes, t)
-          node_function = input_nodes.find { |n| n.id == node_function_id }
-
-          runtime_function_definition = namespace_project.primary_runtime.runtime_function_definitions.find_by(
-            id: node_function.runtime_function_id.model_id
-          )
-          if runtime_function_definition.nil?
-            t.rollback_and_return! ServiceResponse.error(
-              message: 'Invalid runtime function id',
-              error_code: :invalid_runtime_function_id
-            )
-          end
-
-          params = []
-          node_function.parameters.each do |parameter|
-            runtime_parameter = runtime_function_definition.parameters.find_by(
-              id: parameter.runtime_parameter_definition_id.model_id
-            )
-            if runtime_parameter.nil?
-              t.rollback_and_return! ServiceResponse.error(
-                message: 'Invalid runtime parameter id',
-                error_code: :invalid_runtime_parameter_id
-              )
-            end
-
-            if parameter.value.literal_value.present?
-              params << NodeParameter.create(
-                runtime_parameter: runtime_parameter,
-                literal_value: parameter.value.literal_value
-              )
-              next
-            end
-            if parameter.value.function_value.present?
-              # A little bit hacky but okay
-              params << NodeParameter.create(
-                runtime_parameter: runtime_parameter,
-                function_value: create_node_function(
-                  parameter.value.function_value.id,
-                  [parameter.value.function_value], t
-                )
-              )
-              next
-            end
-
-            # This will be broken, because we cant reference nodes that arent created yet
-            # And we will need to put all parameter nodes inside the flowinput.nodes
-            # So we can reference them here because we will not recursively search for them
-            referenced_node = NodeFunction.joins(:runtime_function).find_by(
-              id: parameter.value.reference_value.node_function_id.model_id,
-              runtime_function_definitions: { runtime_id: namespace_project.primary_runtime.id }
-            )
-
-            if referenced_node.nil?
-              t.rollback_and_return! ServiceResponse.error(
-                message: 'Referenced node function not found',
-                error_code: :referenced_value_not_found
-              )
-            end
-
-            params << NodeParameter.create(
-              runtime_parameter: runtime_parameter,
-              reference_value: ReferenceValue.create(
-                node_function: referenced_node,
-                data_type_identifier: get_data_type_identifier(
-                  namespace_project.primary_runtime,
-                  parameter.value.reference_value.data_type_identifier,
-                  t
-                ),
-                depth: parameter.value.reference_value.depth,
-                node: parameter.value.reference_value.node,
-                scope: parameter.value.reference_value.scope,
-                reference_paths: parameter.value.reference_value.reference_paths.map do |path|
-                  ReferencePath.create(
-                    path: path.path,
-                    array_index: path.array_index
-                  )
-                end
-              )
-            )
-          end
-
-          next_node = if node_function.next_node_id.present?
-                        create_node_function(node_function.next_node_id, input_nodes, t)
-                      end
-
-          NodeFunction.create(
-            next_node: next_node,
-            runtime_function: runtime_function_definition,
-            node_parameters: params
-          )
-        end
       end
     end
   end