Add validation services for data types and node functions, enhance input types, and update JSON schemas

Author: Knerio

Gemfile

@@ -89,3 +89,6 @@ gem 'pry-byebug', '~> 3.10'
 gem 'code0-zero_track', '0.0.4'
 
 gem 'image_processing', '>= 1.2'
+
+
+gem "json-schema", "~> 5.1"

Gemfile.lock

@@ -72,6 +72,8 @@ GEM
       securerandom (>= 0.3)
       tzinfo (~> 2.0, >= 2.0.5)
       uri (>= 0.13.1)
+    addressable (2.8.7)
+      public_suffix (>= 2.0.2, < 7.0)
     ast (2.4.3)
     base64 (0.2.0)
     bcrypt (3.1.20)
@@ -154,6 +156,9 @@ GEM
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
     json (2.12.0)
+    json-schema (5.1.1)
+      addressable (~> 2.8)
+      bigdecimal (~> 3.1)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     logger (1.7.0)
@@ -212,6 +217,7 @@ GEM
     psych (5.2.6)
       date
       stringio
+    public_suffix (6.0.2)
     puma (6.6.0)
       nio4r (~> 2.0)
     raabro (1.4.0)
@@ -389,6 +395,7 @@ DEPENDENCIES
   graphql (~> 2.1)
   grpc (~> 1.67)
   image_processing (>= 1.2)
+  json-schema (~> 5.1)
   lograge (~> 0.14.0)
   pg (~> 1.1)
   pry (~> 0.14.2)

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

@@ -9,10 +9,39 @@ class Create < BaseMutation
 
           field :flow, Types::FlowType, null: true, description: 'The newly created flow.'
 
+          argument :project_id, Types::GlobalIdType[NamespaceProject], required: true,
+                   description: 'The ID of the project to which the flow belongs to'
+
           argument :flow, Types::Input::FlowInputType
 
-          def resolve(namespace_id:, **params)
-            # TODO
+          def resolve(project_id:, flow:, **params)
+            create_params = {}
+
+
+            project = SagittariusSchema.object_from_id(project_id)
+
+            if project.nil?
+              return error('Invalid project id')
+            end
+
+            input_type = SagittariusSchema.object_from_id(flow.input_type)
+
+            if input_type.nil?
+              return error('Invalid input type id')
+            end
+
+
+
+
+
+
+          end
+
+          def error(message)
+            {
+              flow: nil,
+              errors: [create_message_error(message)]
+            }
           end
         end
       end

app/graphql/sagittarius_schema.rb

@@ -51,6 +51,15 @@ def self.object_from_id(global_id, query_ctx = nil)
   rescue ActiveRecord::RecordNotFound
     nil
   end
+
+  def self.object_from_id_or_error(global_id)
+    obj = object_from_id(global_id)
+    if obj.nil?
+
+    end
+    obj
+  end
+
   # rubocop:enable Lint/UnusedMethodArgument
 end
 # rubocop:enable GraphQL/MaxDepthSchema

app/graphql/types/base_input_object.rb

@@ -3,5 +3,9 @@
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject
     argument_class Types::BaseArgument
+
+    def self.require_one_of(arguments)
+      validates required: { one_of: arguments, message: "Only one of #{arguments.inspect} should be provided" }
+    end
   end
 end

app/graphql/types/input/flow_input_type.rb

@@ -5,16 +5,16 @@ module Input
     class FlowInputType < Types::BaseInputObject
       description 'Input type for creating or updating a flow'
 
-      argument :input_type_id, ID, required: false,
-                                   description: 'The ID of the input data type'
-      argument :return_type_id, ID, required: false,
-                                    description: 'The ID of the return data type'
+      argument :input_type, Types::GlobalIdType[::DataType], required: false,
+               description: 'The ID of the input data type'
+      argument :return_type, Types::GlobalIdType[::DataType], required: false,
+               description: 'The ID of the return data type'
       argument :settings, [Types::Input::FlowSettingInputType], required: false,
-                                                         description: 'The settings of the flow'
+               description: 'The settings of the flow'
       argument :starting_node, Types::Input::NodeFunctionInputType, required: true,
-                                                             description: 'The starting node of the flow'
-      argument :type, String, required: true,
-                              description: 'The identifier of the flow type'
+               description: 'The starting node of the flow'
+      argument :type, Types::GlobalIdType[::FlowType], required: true,
+               description: 'The identifier of the flow type'
     end
   end
 end

app/graphql/types/input/flow_setting_input_type.rb

@@ -5,7 +5,10 @@ module Input
     class FlowSettingInputType < Types::BaseInputObject
       description 'Input type for flow settings'
 
-      argument :value, GraphQL::Types::JSON, required: true,
+      argument :flow_setting_id, String, required: true,
+                                              description: 'The identifier of the flow setting'
+
+      argument :object, GraphQL::Types::JSON, required: true,
                                              description: 'The value of the flow setting'
     end
   end

app/graphql/types/input/node_function_definition_input_type.rb

@@ -5,8 +5,9 @@ module Input
     class NodeFunctionInputType < Types::BaseInputObject
       description 'Input type for a Node Function'
 
-      argument :function, Types::Input::NodeFunctionDefinitionInputType, required: true,
-                                                                  description: 'The definition of the Node Function'
+      argument :runtime_function_id, Types::GlobalIdType[::RuntimeFunctionDefinition],
+               required: true, description: 'The identifier of the Runtime Function Definition'
+
       argument :next_node, Types::Input::NodeFunctionInputType, required: false,
                                                          description: 'The next Node Function in the flow'
       argument :parameters, [Types::Input::NodeParameterInputType], required: true,

app/graphql/types/input/node_function_input_type.rb

@@ -5,8 +5,9 @@ module Input
     class NodeParameterInputType < Types::BaseInputObject
       description 'Input type for Node parameter'
 
-      argument :definition, Types::Input::NodeParameterDefinitionInputType, required: true,
-                                                                     description: 'The definition of the parameter'
+      argument :runtime_parameter_definition_id, Types::GlobalIdType[::RuntimeParameterDefinition],
+                required: true, description: 'The identifier of the Runtime Parameter Definition'
+
       argument :value, Types::Input::NodeParameterValueInputType, required: false,
                                                            description: 'The value of the parameter'
     end

app/graphql/types/input/node_parameter_definition_input_type.rb

@@ -11,6 +11,10 @@ class NodeParameterValueInputType < Types::BaseInputObject
                                                      description: 'The literal value of the parameter'
       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]
+
+
     end
   end
 end

app/graphql/types/input/node_parameter_input_type.rb

@@ -9,12 +9,23 @@ class DataTypeRule < ApplicationRecord
     regex: 5,
   }.with_indifferent_access
 
-  enum :variant, VARIANTS, prefix: :types
+  enum :variant, VARIANTS, prefix: :variant
 
   belongs_to :data_type, inverse_of: :rules
 
   validates :variant, presence: true,
-                      inclusion: {
-                        in: VARIANTS.keys.map(&:to_s),
-                      }
+            inclusion: {
+              in: VARIANTS.keys.map(&:to_s),
+            }
+
+  validates :config, if: :variant_contains_key?, 'sagittarius/validators/json_schema': { filename: 'data_types/DataTypeContainsKeyRuleConfig', hash_conversion: true }
+
+  validates :config, if: :variant_contains_type?, 'sagittarius/validators/json_schema': { filename: 'data_types/DataTypeContainsTypeRuleConfig', hash_conversion: true }
+
+  validates :config, if: :variant_item_of_collection?, 'sagittarius/validators/json_schema': { filename: 'data_types/DataTypeItemOfCollectionRuleConfig', hash_conversion: true }
+
+  validates :config, if: :variant_number_range?, 'sagittarius/validators/json_schema': { filename: 'data_types/DataTypeNumberRangeRuleConfig', hash_conversion: true }
+
+  validates :config, if: :variant_regex?, 'sagittarius/validators/json_schema': { filename: 'data_types/DataTypeRegexRuleConfig', hash_conversion: true }
+
 end

app/graphql/types/input/node_parameter_value_input_type.rb

@@ -0,0 +1,32 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "$id": "https://example.com/schemas/DataTypeIdentifier.json",
+  "title": "DataTypeIdentifier",
+  "type": "object",
+  "oneOf": [
+    {
+      "required": ["data_type_identifier"],
+      "properties": {
+        "data_type_identifier": {
+          "type": "string"
+        }
+      }
+    },
+    {
+      "required": ["generic_type"],
+      "properties": {
+        "generic_type": {
+          "$ref": "GenericType.json"
+        }
+      }
+    },
+    {
+      "required": ["generic_key"],
+      "properties": {
+        "generic_key": {
+          "type": "string"
+        }
+      }
+    }
+  ]
+}

app/models/data_type_rule.rb

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "$id": "https://example.com/schemas/GenericMapper.json",
+  "title": "GenericMapper",
+  "type": "object",
+  "required": ["source", "target"],
+  "properties": {
+    "source": {
+      "$ref": "DataTypeIdentifier.json"
+    },
+    "target": {
+      "type": "string"
+    }
+  }
+}

app/models/json_schemas/DataTypeContainsKeyRuleConfig.json:Zone.Identifier

@@ -0,0 +1,18 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "$id": "https://example.com/schemas/GenericType.json",
+  "title": "GenericType",
+  "type": "object",
+  "required": ["data_type_identifier", "generic_mappers"],
+  "properties": {
+    "data_type_identifier": {
+      "type": "string"
+    },
+    "generic_mappers": {
+      "type": "array",
+      "items": {
+        "$ref": "GenericMapper.json"
+      }
+    }
+  }
+}

app/models/json_schemas/DataTypeContainsTypeRuleConfig.json:Zone.Identifier

@@ -0,0 +1,15 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "$id": "https://example.com/schemas/DataTypeContainsKeyRuleConfig.json",
+  "title": "DataTypeContainsKeyRuleConfig",
+  "type": "object",
+  "required": ["key", "data_type_identifier"],
+  "properties": {
+    "key": {
+      "type": "string"
+    },
+    "data_type_identifier": {
+      "$ref": "../DataTypeIdentifier.json"
+    }
+  }
+}

app/models/json_schemas/DataTypeIdentifier.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "DataTypeContainsTypeRuleConfig",
+  "type": "object",
+  "required": ["data_type_identifier"],
+  "properties": {
+    "data_type_identifier": { "$ref": "../DataTypeIdentifier.json" }
+  }
+}

app/models/json_schemas/DataTypeIdentifier.json:Zone.Identifier

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "DataTypeItemOfCollectionRuleConfig",
+  "type": "object",
+  "required": [
+    "items"
+  ],
+  "properties": {
+    "items": {
+      "type": "array",
+      "items": {}
+    }
+  }
+}

app/models/json_schemas/DataTypeItemOfCollectionRuleConfig.json:Zone.Identifier

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "DataTypeNumberRangeRuleConfig",
+  "type": "object",
+  "required": ["from", "to"],
+  "properties": {
+    "from": { "type": "integer" },
+    "to": { "type": "integer" },
+    "steps": { "type": "integer" }
+  }
+}

app/models/json_schemas/DataTypeNumberRangeRuleConfig.json:Zone.Identifier

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "DataTypeRegexRuleConfig",
+  "type": "object",
+  "required": [
+    "pattern"
+  ],
+  "properties": {
+    "pattern": {
+      "type": "string"
+    }
+  }
+}

app/models/json_schemas/DataTypeRegexRuleConfig.json:Zone.Identifier

@@ -6,6 +6,21 @@ class NodeFunction < ApplicationRecord
 
   has_many :node_parameters, inverse_of: :function_value
 
+
+  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
+      end
+    end
+  end
+
   def to_grpc
     Tucana::NodeFunction.new(
       data_base_id: id,