Refactor generic mapper associations and update Gemfile for local path, enhance validation services

Author: Knerio

Gemfile

@@ -79,7 +79,7 @@ gem 'good_job', '~> 4.0'
 gem 'rotp'
 
 gem 'grpc', '~> 1.67'
-gem 'tucana', '0.0.29'
+gem 'tucana', '0.0.0', path: '../tucana/build/ruby'
 
 gem 'code0-identities', '~> 0.0.1'
 

Gemfile.lock

@@ -1,3 +1,9 @@
+PATH
+  remote: ../tucana/build/ruby
+  specs:
+    tucana (0.0.0)
+      grpc (~> 1.64)
+
 GEM
   remote: https://rubygems.org/
   specs:
@@ -362,8 +368,6 @@ GEM
     test-prof (1.4.4)
     thor (1.3.2)
     timeout (0.4.3)
-    tucana (0.0.29)
-      grpc (~> 1.64)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.6.0)
@@ -416,7 +420,7 @@ DEPENDENCIES
   simplecov (~> 0.22.0)
   simplecov-cobertura (~> 2.1)
   test-prof (~> 1.0)
-  tucana (= 0.0.29)
+  tucana (= 0.0.0)!
   tzinfo-data
 
 RUBY VERSION

app/models/data_type_identifier.rb

@@ -4,9 +4,9 @@ class DataTypeIdentifier < ApplicationRecord
   belongs_to :data_type, optional: true, inverse_of: :data_type_identifiers
   belongs_to :generic_type, optional: true, inverse_of: :data_type_identifiers
   belongs_to :runtime, inverse_of: :data_type_identifiers
-  belongs_to :generic_mapper, class_name: 'GenericMapper', optional: true, inverse_of: :sources
+  belongs_to :generic_mapper, class_name: 'GenericMapper', optional: true, inverse_of: :source
   belongs_to :function_generic_mapper, class_name: 'FunctionGenericMapper',
-                                       optional: true, inverse_of: :sources
+                                       optional: true, inverse_of: :source
 
   has_many :child_types, class_name: 'DataType', inverse_of: :parent_type
 

app/models/function_definition.rb

@@ -4,6 +4,9 @@ class FunctionDefinition < ApplicationRecord
   belongs_to :runtime_function_definition
   belongs_to :return_type, class_name: 'DataTypeIdentifier', optional: true
 
+  has_many :generic_combination_strategies,
+           class_name: 'GenericCombinationStrategy', inverse_of: :function_generic_mapper
+
   has_many :names, -> { by_purpose(:name) }, class_name: 'Translation', as: :owner, inverse_of: :owner
   has_many :descriptions, -> { by_purpose(:description) }, class_name: 'Translation', as: :owner, inverse_of: :owner
   has_many :documentations, -> { by_purpose(:documentation) }, class_name: 'Translation', as: :owner, inverse_of: :owner

app/models/function_generic_mapper.rb

@@ -6,7 +6,9 @@ class FunctionGenericMapper < ApplicationRecord
   belongs_to :runtime_parameter_definition, class_name: 'RuntimeParameterDefinition', optional: true,
                                             inverse_of: :function_generic_mappers
 
-  has_many :sources, class_name: 'DataTypeIdentifier', inverse_of: :function_generic_mapper
+  has_many :source, class_name: 'DataTypeIdentifier', inverse_of: :function_generic_mapper
+  has_many :generic_combination_strategies,
+           class_name: 'GenericCombinationStrategy', inverse_of: :function_generic_mapper
 
   validates :target, presence: true
 end

app/models/generic_combination_strategy.rb

@@ -6,7 +6,8 @@ class GenericCombinationStrategy < ApplicationRecord
     or: 2,
   }.with_indifferent_access
 
-  belongs_to :generic_mapper
+  belongs_to :generic_mapper, optional: true, inverse_of: :generic_combination_strategies
+  belongs_to :function_generic_mapper, optional: true, inverse_of: :generic_combination_strategies
 
   enum :type, TYPES, prefix: :type
 end

app/models/generic_mapper.rb

@@ -5,7 +5,7 @@ class GenericMapper < ApplicationRecord
   belongs_to :runtime, inverse_of: :generic_mappers
   belongs_to :runtime_parameter_definition, optional: true, inverse_of: :generic_mappers
 
-  has_many :sources, class_name: 'DataTypeIdentifier', inverse_of: :generic_mapper
+  has_many :source, class_name: 'DataTypeIdentifier', inverse_of: :generic_mapper
   has_many :generic_combination_strategies, class_name: 'GenericCombinationStrategy', inverse_of: :generic_mapper
 
   validates :target, presence: true

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

@@ -134,7 +134,7 @@ def get_data_type_identifier(identifier)
             mappers = identifier.generic_type.mappers.map do |mapper|
               GenericMapper.create(
                 generic_mapper_id: mapper.generic_mapper_id,
-                sources: mapper.sources,
+                source: mapper.source,
                 target: mapper.target
               )
             end

app/services/namespaces/projects/flows/validation/node_function/generic_mapper_validation_service.rb

@@ -35,7 +35,11 @@ def execute
                   )
                 end
 
-                generic_mapper.sources.each do |source|
+                generic_mapper.generic_combination_strategies.each do |_strategy|
+                  # TODO: idk
+                end
+
+                generic_mapper.source.each do |source|
                   Namespaces::Projects::Flows::Validation::DataType::DataTypeIdentifierValidationService.new(
                     current_authentication,
                     flow,

app/services/runtimes/data_types/update_service.rb

@@ -32,14 +32,14 @@ def execute
 
       def sort_data_types(data_types)
         # types without parent are already "in order" because they don't have a dependency
-        sorted_types = data_types.reject { |dt| dt.parent_type_identifier.present? }
+        sorted_types = data_types.reject { |dt| dt.parent_type.present? }
         unsorted_types = data_types - sorted_types
 
         unsorted_types.size.times do
           # find the next datatype that doesn't have a dependency on an unsorted type
           next_datatype = unsorted_types.find do |to_sort|
             unsorted_types.none? do |to_search|
-              to_sort.parent_type_identifier == to_search.identifier
+              to_sort.parent_type&.data_type_identifier == to_search.identifier
             end
           end
           sorted_types << next_datatype
@@ -49,20 +49,69 @@ def sort_data_types(data_types)
         sorted_types + unsorted_types # any unsorted types also need to be processed. They might still fail validations
       end
 
-      def update_datatype(data_type, _t)
+      def update_datatype(data_type, t)
         db_object = DataType.find_or_initialize_by(runtime: current_runtime, identifier: data_type.identifier)
         db_object.removed_at = nil
         db_object.variant = data_type.variant.to_s.downcase
-        if data_type.parent_type_identifier.present?
-          # db_object.parent_type = find_datatype(data_type.parent_type_identifier, t)
-          # TODO: wait for parenttype get properly introduced in grpc
-        end
+        db_object.parent_type = find_data_type_identifier(data_type.parent_type, t) if data_type.parent_type.present?
         db_object.rules = update_rules(data_type.rules, db_object)
         db_object.names = update_translations(data_type.name, db_object.names)
         db_object.generic_keys = data_type.generic_keys.to_a
         db_object.save
       end
 
+      def find_data_type_identifier(identifier, t)
+        if identifier.data_type_identifier.present?
+          return create_data_type_identifier(t, data_type_id: find_datatype(identifier.data_type_identifier, t).id)
+        end
+
+        if identifier.generic_type.present?
+          data_type = find_datatype(identifier.generic_type.data_type_identifier, t)
+
+          generic_type = GenericType.find_by(
+            runtime_id: current_runtime.id,
+            data_type: data_type
+          )
+          if generic_type.nil?
+            generic_type = GenericType.create(
+              runtime_id: current_runtime.id,
+              data_type: data_type
+            )
+          end
+
+          if generic_type.nil?
+            t.rollback_and_return! ServiceResponse.error(
+              message: "Could not find generic type with identifier #{identifier.generic_type.data_type_identifier}",
+              payload: :no_generic_type_for_identifier
+            )
+          end
+
+          generic_type.assign_attributes(generic_mappers: update_mappers(identifier.generic_type.generic_mappers, nil,
+                                                                         t))
+
+          return create_data_type_identifier(t, generic_type_id: generic_type.id)
+        end
+        return create_data_type_identifier(t, generic_key: identifier.generic_key) if identifier.generic_key.present?
+
+        raise ArgumentError, "Invalid identifier: #{identifier.inspect}"
+      end
+
+      def create_data_type_identifier(t, **kwargs)
+        data_type_identifier = DataTypeIdentifier.find_by(runtime_id: current_runtime.id, **kwargs)
+        if data_type_identifier.nil?
+          data_type_identifier = DataTypeIdentifier.create_or_find_by(runtime_id: current_runtime.id, **kwargs)
+        end
+
+        if data_type_identifier.nil?
+          t.rollback_and_return! ServiceResponse.error(
+            message: "Could not find datatype identifier with #{kwargs}",
+            payload: :no_datatype_identifier_for_generic_key
+          )
+        end
+
+        data_type_identifier
+      end
+
       def find_datatype(identifier, t)
         data_type = DataType.find_or_initialize_by(runtime: current_runtime, identifier: identifier)