igniter 0.5.0 → 0.5.2

data/lib/igniter/compiler/compiled_graph.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    class CompiledGraph
-      attr_reader :name, :nodes, :nodes_by_id, :nodes_by_name, :nodes_by_path, :outputs, :outputs_by_name, :resolution_order, :dependents
-
-      def initialize(name:, nodes:, outputs:, resolution_order:, dependents:)
-        @name = name
-        @nodes = nodes.freeze
-        @nodes_by_id = nodes.each_with_object({}) { |node, memo| memo[node.id] = node }.freeze
-        @nodes_by_name = nodes.each_with_object({}) { |node, memo| memo[node.name] = node }.freeze
-        @nodes_by_path = nodes.each_with_object({}) { |node, memo| memo[node.path] = node }.freeze
-        @outputs = outputs.freeze
-        @outputs_by_name = outputs.each_with_object({}) { |node, memo| memo[node.name] = node }.freeze
-        @resolution_order = resolution_order.freeze
-        @dependents = dependents.transform_values(&:freeze).freeze
-        freeze
-      end
-
-      def fetch_node_by_id(id)
-        @nodes_by_id.fetch(id)
-      end
-
-      def fetch_node(name)
-        @nodes_by_name.fetch(name.to_sym)
-      end
-
-      def node?(name)
-        @nodes_by_name.key?(name.to_sym)
-      end
-
-      def fetch_node_by_path(path)
-        @nodes_by_path.fetch(path.to_s)
-      end
-
-      def fetch_output(name)
-        @outputs_by_name.fetch(name.to_sym)
-      end
-
-      def output?(name)
-        @outputs_by_name.key?(name.to_sym)
-      end
-
-      def fetch_dependency(name)
-        return fetch_node(name) if node?(name)
-        return fetch_output(name) if output?(name)
-
-        raise KeyError, "Unknown dependency '#{name}'"
-      end
-
-      def await_nodes
-        @nodes.select { |n| n.kind == :await }
-      end
-
-      def to_h
-        {
-          name: name,
-          nodes: nodes.map do |node|
-            base = {
-              id: node.id,
-              kind: node.kind,
-              name: node.name,
-              path: node.path,
-              dependencies: node.dependencies
-            }
-            if node.kind == :composition
-              base[:contract] = node.contract_class.name
-              base[:inputs] = node.input_mapping
-            end
-            if node.kind == :branch
-              base[:selector] = node.selector_dependency
-              base[:depends_on] = node.context_dependencies if node.context_dependencies.any?
-              base[:cases] = node.cases.map { |entry| { match: entry[:match], contract: entry[:contract].name } }
-              base[:default_contract] = node.default_contract.name
-              base[:inputs] = node.input_mapping
-              base[:mapper] = node.input_mapper.to_s if node.input_mapper?
-            end
-            if node.kind == :collection
-              base[:with] = node.source_dependency
-              base[:depends_on] = node.context_dependencies if node.context_dependencies.any?
-              base[:each] = node.contract_class.name
-              base[:key] = node.key_name
-              base[:mode] = node.mode
-              base[:mapper] = node.input_mapper.to_s if node.input_mapper?
-            end
-            base[:event] = node.event_name if node.kind == :await
-            base
-          end,
-          outputs: outputs.map do |output|
-            {
-              name: output.name,
-              path: output.path,
-              source: output.source
-            }
-          end,
-          resolution_order: resolution_order.map(&:name)
-        }
-      end
-
-      def to_text
-        Extensions::Introspection::GraphFormatter.to_text(self)
-      end
-
-      def to_schema
-        {
-          name: name,
-          inputs: nodes.select { |node| node.kind == :input }.map do |node|
-            {
-              name: node.name,
-              type: node.type,
-              required: node.required?,
-              default: (node.default if node.default?),
-              metadata: node.metadata.reject { |key, _| key == :source_location || key == :type || key == :required || key == :default }
-            }.compact
-          end,
-          compositions: nodes.select { |node| node.kind == :composition }.map do |node|
-            {
-              name: node.name,
-              contract: node.contract_class,
-              inputs: node.input_mapping,
-              metadata: node.metadata.reject { |key, _| key == :source_location }
-            }
-          end,
-          awaits: nodes.select { |node| node.kind == :await }.map do |node|
-            {
-              name: node.name,
-              event: node.event_name,
-              metadata: node.metadata.reject { |key, _| key == :source_location }
-            }
-          end,
-          branches: nodes.select { |node| node.kind == :branch }.map do |node|
-            {
-              name: node.name,
-              with: node.selector_dependency,
-              depends_on: node.context_dependencies,
-              inputs: node.input_mapping,
-              map_inputs: (node.input_mapper if node.input_mapper?),
-              cases: node.cases.map { |entry| { on: entry[:match], contract: entry[:contract] } },
-              default: node.default_contract,
-              metadata: node.metadata.reject { |key, _| key == :source_location }
-            }
-          end,
-          collections: nodes.select { |node| node.kind == :collection }.map do |node|
-            {
-              name: node.name,
-              with: node.source_dependency,
-              depends_on: node.context_dependencies,
-              each: node.contract_class,
-              key: node.key_name,
-              mode: node.mode,
-              map_inputs: (node.input_mapper if node.input_mapper?),
-              metadata: node.metadata.reject { |key, _| key == :source_location }
-            }
-          end,
-          computes: nodes.select { |node| node.kind == :compute }.map do |node|
-            {
-              name: node.name,
-              depends_on: node.dependencies,
-              executor: node.executor_key,
-              call: (node.callable unless node.executor_key),
-              metadata: node.metadata.reject { |key, _| %i[source_location executor_key].include?(key) }
-            }.compact
-          end,
-          outputs: outputs.map do |output|
-            {
-              name: output.name,
-              from: output.source,
-              metadata: output.metadata.reject { |key, _| %i[source_location type].include?(key) }
-            }.compact
-          end
-        }
-      end
-
-      def to_mermaid
-        Extensions::Introspection::GraphFormatter.to_mermaid(self)
-      end
-    end
-  end
-end

data/lib/igniter/compiler/graph_compiler.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "tsort"
-
-module Igniter
-  module Compiler
-    class GraphCompiler
-      include TSort
-
-      def self.call(graph)
-        new(graph).call
-      end
-
-      def initialize(graph)
-        @graph = graph
-      end
-
-      def call
-        validator = Validator.call(@graph)
-        @nodes_by_name = validator.runtime_nodes_by_name
-        @outputs_by_name = validator.outputs.each_with_object({}) { |output, memo| memo[output.name] = output }
-
-        CompiledGraph.new(
-          name: @graph.name,
-          nodes: validator.runtime_nodes,
-          outputs: validator.outputs,
-          resolution_order: tsort,
-          dependents: build_dependents
-        )
-      end
-
-      private
-
-      def runtime_nodes
-        @runtime_nodes ||= @graph.nodes.reject { |node| node.kind == :output }
-      end
-
-      def build_dependents
-        runtime_nodes.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |node, memo|
-          node.dependencies.each do |dependency_name|
-            memo[dependency_source_name(dependency_name)] << node.name
-          end
-        end
-      end
-
-      def tsort_each_node(&block)
-        runtime_nodes.each(&block)
-      end
-
-      def tsort_each_child(node, &block)
-        node.dependencies.each do |dependency_name|
-          block.call(@nodes_by_name.fetch(dependency_source_name(dependency_name)))
-        end
-      end
-
-      def dependency_source_name(dependency_name)
-        output = @outputs_by_name[dependency_name.to_sym]
-        return output.source_root if output
-
-        dependency_name
-      end
-
-      def tsort
-        super
-      rescue TSort::Cyclic => e
-        raise CycleError, e.message
-      end
-    end
-  end
-end

data/lib/igniter/compiler/type_resolver.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    class TypeResolver
-      def self.call(graph, name)
-        new(graph).call(name)
-      end
-
-      def initialize(graph)
-        @graph = graph
-      end
-
-      def call(name)
-        if @graph.output?(name)
-          resolve_output(@graph.fetch_output(name))
-        else
-          resolve_node(@graph.fetch_node(name))
-        end
-      end
-
-      private
-
-      def resolve_output(output)
-        return output.type if output.type
-
-        if output.composition_output?
-          composition = @graph.fetch_node(output.source_root)
-          child_graph = composition.contract_class.compiled_graph
-          self.class.call(child_graph, output.child_output_name)
-        else
-          resolve_node(@graph.fetch_node(output.source))
-        end
-      end
-
-      def resolve_node(node)
-        case node.kind
-        when :input
-          node.type
-        when :compute
-          node.type
-        when :composition
-          :result
-        when :branch
-          :result
-        when :collection
-          :array
-        else
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/igniter/compiler/validation_context.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    class ValidationContext
-      attr_reader :graph, :runtime_nodes_by_name, :outputs_by_name
-
-      def initialize(graph)
-        @graph = graph
-        @runtime_nodes_by_name = {}
-        @outputs_by_name = {}
-      end
-
-      def runtime_nodes
-        @runtime_nodes ||= graph.nodes.reject { |node| node.kind == :output }
-      end
-
-      def outputs
-        @outputs ||= graph.nodes.select { |node| node.kind == :output }
-      end
-
-      def build_indexes!
-        runtime_nodes.each { |node| @runtime_nodes_by_name[node.name] = node }
-        outputs.each { |output| @outputs_by_name[output.name] = output }
-      end
-
-      def dependency_resolvable?(dependency_name)
-        runtime_nodes_by_name.key?(dependency_name.to_sym) || outputs_by_name.key?(dependency_name.to_sym)
-      end
-
-      def node?(name)
-        runtime_nodes_by_name.key?(name.to_sym)
-      end
-
-      def output?(name)
-        outputs_by_name.key?(name.to_sym)
-      end
-
-      def fetch_node(name)
-        runtime_nodes_by_name.fetch(name.to_sym)
-      end
-
-      def fetch_output(name)
-        outputs_by_name.fetch(name.to_sym)
-      end
-
-      def validation_error(node, message)
-        ValidationError.new(
-          message,
-          context: {
-            graph: graph.name,
-            node_id: node.id,
-            node_name: node.name,
-            node_path: node.path,
-            source_location: node.source_location
-          }
-        )
-      end
-    end
-  end
-end

data/lib/igniter/compiler/validation_pipeline.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    class ValidationPipeline
-      DEFAULT_VALIDATORS = [
-        Validators::UniquenessValidator,
-        Validators::OutputsValidator,
-        Validators::DependenciesValidator,
-        Validators::TypeCompatibilityValidator,
-        Validators::CallableValidator,
-        Validators::AwaitValidator,
-        Validators::RemoteValidator
-      ].freeze
-
-      def self.call(context, validators: DEFAULT_VALIDATORS)
-        new(context, validators: validators).call
-      end
-
-      def initialize(context, validators:)
-        @context = context
-        @validators = validators
-      end
-
-      def call
-        @context.build_indexes!
-        @validators.each { |validator| validator.call(@context) }
-        @context
-      end
-    end
-  end
-end

data/lib/igniter/compiler/validator.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    class Validator
-      def self.call(graph)
-        new(graph).call
-      end
-
-      def initialize(graph)
-        @graph = graph
-      end
-
-      def call
-        ValidationPipeline.call(ValidationContext.new(@graph))
-      end
-    end
-  end
-end

data/lib/igniter/compiler/validators/await_validator.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    module Validators
-      class AwaitValidator
-        def self.call(context)
-          new(context).call
-        end
-
-        def initialize(context)
-          @context = context
-        end
-
-        def call
-          await_nodes = @context.runtime_nodes.select { |n| n.kind == :await }
-          return if await_nodes.empty?
-
-          validate_correlation_keys_as_inputs!(await_nodes)
-          validate_unique_event_names!(await_nodes)
-        end
-
-        private
-
-        def validate_correlation_keys_as_inputs!(await_nodes) # rubocop:disable Metrics/AbcSize
-          correlation_keys = @context.graph.metadata[:correlation_keys] || []
-          return if correlation_keys.empty?
-
-          input_names = @context.runtime_nodes.select { |n| n.kind == :input }.map(&:name)
-          missing = correlation_keys.reject { |key| input_names.include?(key.to_sym) }
-          return if missing.empty?
-
-          raise @context.validation_error(
-            await_nodes.first,
-            "Correlation keys #{missing.inspect} must be declared as inputs"
-          )
-        end
-
-        def validate_unique_event_names!(await_nodes)
-          event_names = await_nodes.map(&:event_name)
-          duplicates = event_names.select { |e| event_names.count(e) > 1 }.uniq
-          return if duplicates.empty?
-
-          node = await_nodes.find { |n| duplicates.include?(n.event_name) }
-          raise @context.validation_error(
-            node,
-            "Duplicate await event names: #{duplicates.inspect}"
-          )
-        end
-      end
-    end
-  end
-end

data/lib/igniter/compiler/validators/callable_validator.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Compiler
-    module Validators
-      class CallableValidator
-        def self.call(context)
-          new(context).call
-        end
-
-        def initialize(context)
-          @context = context
-        end
-
-        def call
-          @context.runtime_nodes.each do |node|
-            if node.kind == :compute
-              validate_callable_signature!(node)
-            elsif node.kind == :effect
-              validate_effect_adapter!(node)
-            end
-          end
-        end
-
-        private
-
-        def validate_effect_adapter!(node)
-          adapter = node.adapter_class
-          unless adapter.is_a?(Class) && adapter <= Igniter::Effect
-            raise @context.validation_error(
-              node,
-              "Effect '#{node.name}' adapter must be a subclass of Igniter::Effect"
-            )
-          end
-
-          validate_parameters_signature!(
-            node,
-            adapter.instance_method(:call).parameters,
-            adapter.name || "effect"
-          )
-        end
-
-        def validate_callable_signature!(node)
-          callable = node.callable
-
-          case callable
-          when Proc
-            validate_parameters_signature!(node, callable.parameters, "proc")
-          when Class
-            validate_class_callable_signature!(node, callable)
-          when Symbol, String
-            nil
-          else
-            validate_object_callable_signature!(node, callable)
-          end
-        end
-
-        def validate_class_callable_signature!(node, callable)
-          if callable <= Igniter::Executor
-            validate_executor_inputs!(node, callable)
-            validate_parameters_signature!(node, callable.instance_method(:call).parameters, callable.name || "executor")
-          elsif callable.respond_to?(:call)
-            validate_parameters_signature!(node, callable.method(:call).parameters, callable.name || "callable class")
-          else
-            raise @context.validation_error(node, "Compute '#{node.name}' class callable must respond to `.call`")
-          end
-        end
-
-        def validate_object_callable_signature!(node, callable)
-          unless callable.respond_to?(:call)
-            raise @context.validation_error(node, "Compute '#{node.name}' callable object must respond to `call`")
-          end
-
-          validate_parameters_signature!(node, callable.method(:call).parameters, callable.class.name || "callable object")
-        end
-
-        def validate_executor_inputs!(node, executor_class)
-          declared_inputs = executor_class.executor_inputs
-          required_inputs = declared_inputs.select { |_name, config| config[:required] }.keys
-          missing_dependencies = required_inputs - node.dependencies
-
-          return if missing_dependencies.empty?
-
-          raise @context.validation_error(
-            node,
-            "Compute '#{node.name}' executor requires undeclared dependencies: #{missing_dependencies.sort.join(', ')}"
-          )
-        end
-
-        def validate_parameters_signature!(node, parameters, callable_label)
-          positional_kinds = %i[req opt rest]
-          positional = parameters.select { |kind, _name| positional_kinds.include?(kind) }
-          unless positional.empty?
-            raise @context.validation_error(
-              node,
-              "Compute '#{node.name}' #{callable_label} must use keyword arguments for dependencies, got positional parameters"
-            )
-          end
-
-          accepts_any_keywords = parameters.any? { |kind, _name| kind == :keyrest }
-          accepted_keywords = parameters.select { |kind, _name| %i[key keyreq].include?(kind) }.map(&:last)
-          required_keywords = parameters.select { |kind, _name| kind == :keyreq }.map(&:last)
-
-          missing_dependencies = required_keywords - node.dependencies
-          unless missing_dependencies.empty?
-            raise @context.validation_error(
-              node,
-              "Compute '#{node.name}' #{callable_label} requires undeclared dependencies: #{missing_dependencies.sort.join(', ')}"
-            )
-          end
-
-          return if accepts_any_keywords
-
-          unknown_dependencies = node.dependencies - accepted_keywords
-          return if unknown_dependencies.empty?
-
-          raise @context.validation_error(
-            node,
-            "Compute '#{node.name}' declares unsupported dependencies for its #{callable_label}: #{unknown_dependencies.sort.join(', ')}"
-          )
-        end
-      end
-    end
-  end
-end