Merge pull request #1160 from code0-tech/#1126-add-definition-source

add definition source

Author: raphael-goetz

app/models/runtime_module.rb

@@ -22,6 +22,7 @@ class RuntimeModule < ApplicationRecord
   validates :documentation, length: { maximum: 200 }, exclusion: { in: [nil] }
   validates :author, length: { maximum: 200 }, exclusion: { in: [nil] }
   validates :icon, length: { maximum: 100 }
+  validates :definition_source, length: { maximum: 50 }
 
   validate :validate_version
 

app/models/sub_flow.rb

@@ -14,12 +14,20 @@ def function_identifier
   end
 
   def to_grpc
-    Tucana::Shared::SubFlow.new(
+    grpc_sub_flow = Tucana::Shared::SubFlow.new(
       starting_node_id: starting_node_id,
-      function_identifier: function_identifier,
       signature: signature,
       settings: sub_flow_settings.map(&:to_grpc)
     )
+    if function_definition.present?
+      function_args = { function_identifier: function_identifier }
+      definition_source = function_definition.runtime_function_definition.definition_source
+      function_args[:definition_source] = definition_source if definition_source.present?
+
+      grpc_sub_flow.function = Tucana::Shared::SubFlow::SubFlowFunction.new(**function_args)
+    end
+
+    grpc_sub_flow
   end
 
   private

app/services/runtimes/grpc/modules/update_service.rb

@@ -57,6 +57,7 @@ def update_modules(t)
             module_record.author = grpc_module.author
             module_record.icon = grpc_module.icon
             module_record.version = grpc_module.version
+            module_record.definition_source = grpc_module.definition_source
             module_record.names = update_translations(grpc_module.name, module_record.names)
             module_record.descriptions = update_translations(grpc_module.description, module_record.descriptions)
 

app/services/velorum/generation_flow_serializer.rb

@@ -75,7 +75,12 @@ def prepare_definition_ids
         runtime_name = if definition.respond_to?(:runtime_function_definition)
                          definition.runtime_function_definition&.runtime_name
                        end
+        definition_source = definition.runtime_function_definition&.definition_source
         function_definitions_by_runtime_id[runtime_name] ||= definition if runtime_name.present?
+        if definition_source.present?
+          function_definitions_by_runtime_id[[definition.identifier, definition_source]] ||= definition
+          function_definitions_by_runtime_id[[runtime_name, definition_source]] ||= definition if runtime_name.present?
+        end
       end
     end
 
@@ -176,11 +181,15 @@ def reference_path_to_h(path)
     end
 
     def sub_flow_to_h(sub_flow)
-      function_definition = function_definition_for_identifier(sub_flow.function_identifier)
-      if runtime.present? && sub_flow.function_identifier.present? && function_definition.nil?
+      sub_flow_function = sub_flow.function if sub_flow.execution_reference == :function
+      function_identifier = sub_flow_function&.function_identifier
+      definition_source = sub_flow_function.definition_source if sub_flow_function&.has_definition_source?
+      function_definition = function_definition_for_identifier(function_identifier, definition_source)
+      if runtime.present? && function_identifier.present? && function_definition.nil?
         raise_unresolved_definition(
           'Generated sub-flow function definition is unknown',
-          function_identifier: sub_flow.function_identifier
+          function_identifier: function_identifier,
+          definition_source: definition_source
         )
       end
 
@@ -251,7 +260,11 @@ def function_definition_for(node)
       function_definition_for_identifier(node.runtime_function_id)
     end
 
-    def function_definition_for_identifier(identifier)
+    def function_definition_for_identifier(identifier, definition_source = nil)
+      return if identifier.blank?
+
+      return function_definitions_by_runtime_id[[identifier, definition_source]] if definition_source.present?
+
       function_definitions_by_runtime_id[identifier]
     end
 

db/migrate/20260725170000_add_definition_source_to_runtime_modules.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddDefinitionSourceToRuntimeModules < Code0::ZeroTrack::Database::Migration[1.0]
+  def change
+    add_column :runtime_modules, :definition_source, :text, limit: 50
+  end
+end

db/schema_migrations/20260725170000

@@ -0,0 +1 @@
+541adfd19676c98dbebc7109fbc7f86f0fda1e2243b8ecf40275d4b8efb271d5

db/structure.sql

@@ -956,8 +956,10 @@ CREATE TABLE runtime_modules (
     version text NOT NULL,
     created_at timestamp with time zone NOT NULL,
     updated_at timestamp with time zone NOT NULL,
+    definition_source text,
     CONSTRAINT check_1a843f8ec6 CHECK ((char_length(identifier) <= 50)),
     CONSTRAINT check_3f8395fc6a CHECK ((char_length(icon) <= 100)),
+    CONSTRAINT check_436ae79860 CHECK ((char_length(definition_source) <= 50)),
     CONSTRAINT check_59e12f7f02 CHECK ((char_length(author) <= 200)),
     CONSTRAINT check_d169c23c07 CHECK ((char_length(documentation) <= 200))
 );

spec/factories/runtime_modules.rb

@@ -10,5 +10,6 @@
     author { '' }
     icon { nil }
     version { '0.0.0' }
+    definition_source { 'taurus' }
   end
 end

spec/models/runtime_module_spec.rb

@@ -25,6 +25,7 @@
     it { is_expected.to validate_length_of(:documentation).is_at_most(200) }
     it { is_expected.to validate_length_of(:author).is_at_most(200) }
     it { is_expected.to validate_length_of(:icon).is_at_most(100) }
+    it { is_expected.to validate_length_of(:definition_source).is_at_most(50) }
 
     describe '#validate_version' do
       it 'adds an error if version is blank' do

spec/models/sub_flow_spec.rb

@@ -20,4 +20,24 @@
       expect(sub_flow.errors[:base]).to include('Exactly one of starting_node or function_definition must be present')
     end
   end
+
+  describe '#to_grpc' do
+    it 'serializes a function reference with its definition source' do
+      runtime_function_definition = create(:runtime_function_definition, definition_source: 'taurus')
+      function_definition = create(
+        :function_definition,
+        runtime: runtime_function_definition.runtime,
+        runtime_function_definition: runtime_function_definition
+      )
+      sub_flow = create(:sub_flow, starting_node: nil, function_definition: function_definition)
+
+      grpc_sub_flow = sub_flow.to_grpc
+
+      expect(grpc_sub_flow.function).to have_attributes(
+        function_identifier: function_definition.identifier,
+        definition_source: 'taurus'
+      )
+      expect(grpc_sub_flow.function.has_definition_source?).to be(true)
+    end
+  end
 end