igniter 0.2.0 → 0.3.1

data/lib/igniter/runtime/input_validator.rb

@@ -3,17 +3,6 @@
 module Igniter
   module Runtime
     class InputValidator
-      SUPPORTED_TYPES = {
-        integer: Integer,
-        float: Float,
-        numeric: Numeric,
-        string: String,
-        boolean: :boolean,
-        array: Array,
-        hash: Hash,
-        symbol: Symbol
-      }.freeze
-
       def initialize(compiled_graph)
         @compiled_graph = compiled_graph
       end
@@ -104,26 +93,15 @@ module Igniter
         return if value.nil?
         return unless input_node.type
 
-        unless supported_type?(input_node.type)
+        unless TypeSystem.supported?(input_node.type)
           raise input_error(input_node, "Unsupported input type '#{input_node.type}' for '#{input_node.name}'")
         end
 
-        return if type_match?(input_node.type, value)
+        return if TypeSystem.match?(input_node.type, value)
 
         raise input_error(input_node, "Input '#{input_node.name}' must be of type #{input_node.type}, got #{value.class}")
       end
 
-      def supported_type?(type)
-        SUPPORTED_TYPES.key?(type.to_sym)
-      end
-
-      def type_match?(type, value)
-        matcher = SUPPORTED_TYPES.fetch(type.to_sym)
-        return value == true || value == false if matcher == :boolean
-
-        value.is_a?(matcher)
-      end
-
       def symbolize_keys(hash)
         hash.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
       end

data/lib/igniter/runtime/invalidator.rb

@@ -37,7 +37,7 @@ module Igniter
 
       def emit_output_invalidations_for(source_name, cause_name)
         @execution.compiled_graph.outputs.each do |output_node|
-          next unless output_node.source == source_name.to_sym
+          next unless output_node.source_root == source_name.to_sym
 
           @execution.events.emit(
             :node_invalidated,

data/lib/igniter/runtime/job_worker.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class JobWorker
+      def initialize(contract_class, store: Igniter.execution_store)
+        @contract_class = contract_class
+        @store = store
+      end
+
+      def resume(execution_id:, token:, value:)
+        contract = @contract_class.restore_from_store(execution_id, store: @store)
+        contract.execution.resume_by_token(token, value: value)
+        contract
+      end
+    end
+  end
+end

data/lib/igniter/runtime/node_state.rb

@@ -19,6 +19,14 @@ module Igniter
         status == :stale
       end
 
+      def pending?
+        status == :pending
+      end
+
+      def running?
+        status == :running
+      end
+
       def succeeded?
         status == :succeeded
       end
@@ -26,6 +34,18 @@ module Igniter
       def failed?
         status == :failed
       end
+
+      def to_h
+        {
+          node_name: node.name,
+          status: status,
+          version: version,
+          resolved_at: resolved_at,
+          invalidated_by: invalidated_by,
+          value: value,
+          error: error
+        }
+      end
     end
   end
 end

data/lib/igniter/runtime/planner.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class Planner
+      def initialize(execution)
+        @execution = execution
+      end
+
+      def targets_for_outputs(output_names = nil)
+        selected_outputs = if output_names
+          Array(output_names).map { |name| @execution.compiled_graph.fetch_output(name) }
+        else
+          @execution.compiled_graph.outputs
+        end
+
+        selected_outputs
+          .map(&:source_root)
+          .uniq
+      end
+
+      def plan(output_names = nil)
+        targets = targets_for_outputs(output_names)
+        nodes = relevant_nodes_for(targets)
+
+        node_entries = nodes.each_with_object({}) do |node, memo|
+          memo[node.name] = plan_entry(node)
+        end
+
+        {
+          targets: targets,
+          ready: node_entries.values.select { |entry| entry[:ready] }.map { |entry| entry[:name] },
+          blocked: node_entries.values.select { |entry| entry[:blocked] }.map { |entry| entry[:name] },
+          nodes: node_entries
+        }
+      end
+
+      private
+
+      def relevant_nodes_for(targets)
+        seen = {}
+        ordered = []
+
+        targets.each do |target_name|
+          visit(@execution.compiled_graph.fetch_node(target_name), seen, ordered)
+        end
+
+        ordered
+      end
+
+      def visit(node, seen, ordered)
+        return if seen[node.name]
+
+        seen[node.name] = true
+        node.dependencies.each do |dependency_name|
+          dependency = dependency_node_for(dependency_name)
+          visit(dependency, seen, ordered)
+        end
+        ordered << node
+      end
+
+      def dependency_node_for(dependency_name)
+        dependency = @execution.compiled_graph.fetch_dependency(dependency_name)
+        return dependency if dependency.kind != :output
+
+        @execution.compiled_graph.fetch_node(dependency.source_root)
+      end
+
+      def plan_entry(node)
+        state = @execution.cache.fetch(node.name)
+        dependency_entries = node.dependencies.map { |dependency_name| dependency_entry(dependency_name) }
+        blocked_dependencies = dependency_entries.reject { |entry| entry[:satisfied] }.map { |entry| entry[:name] }
+        ready = resolution_required?(state) && blocked_dependencies.empty?
+
+        {
+          id: node.id,
+          name: node.name,
+          path: node.path,
+          kind: node.kind,
+          status: state&.status || :pending,
+          ready: ready,
+          blocked: !ready && resolution_required?(state),
+          dependencies: dependency_entries,
+          waiting_on: blocked_dependencies
+        }
+      end
+
+      def dependency_entry(dependency_name)
+        dependency = @execution.compiled_graph.fetch_dependency(dependency_name)
+        source_node = dependency.kind == :output ? @execution.compiled_graph.fetch_node(dependency.source_root) : dependency
+        state = @execution.cache.fetch(source_node.name)
+
+        {
+          name: dependency_name.to_sym,
+          source: source_node.name,
+          kind: dependency.kind,
+          status: state&.status || inferred_status(source_node),
+          satisfied: dependency_satisfied?(source_node, state)
+        }
+      end
+
+      def dependency_satisfied?(node, state)
+        case node.kind
+        when :input
+          input_available?(node)
+        else
+          state&.succeeded?
+        end
+      end
+
+      def inferred_status(node)
+        return :ready if node.kind == :input && input_available?(node)
+
+        :pending
+      end
+
+      def input_available?(node)
+        @execution.inputs.key?(node.name) || node.default?
+      end
+
+      def resolution_required?(state)
+        state.nil? || state.stale? || state.pending? || state.running?
+      end
+    end
+  end
+end

data/lib/igniter/runtime/resolver.rb

@@ -9,8 +9,8 @@ module Igniter
 
       def resolve(node_name)
         node = @execution.compiled_graph.fetch_node(node_name)
-        cached = @execution.cache.fetch(node.name)
-        return cached if cached && !cached.stale?
+        resolution_status, cached = @execution.cache.begin_resolution(node)
+        return cached if resolution_status == :cached
 
         @execution.events.emit(:node_started, node: node, status: :running)
 
@@ -21,17 +21,30 @@ module Igniter
                   resolve_compute(node)
                 when :composition
                   resolve_composition(node)
+                when :branch
+                  resolve_branch(node)
+                when :collection
+                  resolve_collection(node)
                 else
                   raise ResolutionError, "Unsupported node kind: #{node.kind}"
                 end
 
         @execution.cache.write(state)
-        @execution.events.emit(
-          state.failed? ? :node_failed : :node_succeeded,
+        emit_resolution_event(node, state)
+        state
+      rescue PendingDependencyError => e
+        state = NodeState.new(
           node: node,
-          status: state.status,
-          payload: success_payload(node, state)
+          status: :pending,
+          value: Runtime::DeferredResult.build(
+            token: e.deferred_result.token,
+            payload: e.deferred_result.payload,
+            source_node: e.deferred_result.source_node,
+            waiting_on: e.deferred_result.waiting_on || node.name
+          )
         )
+        @execution.cache.write(state)
+        @execution.events.emit(:node_pending, node: node, status: :pending, payload: pending_payload(state))
         state
       rescue StandardError => e
         state = NodeState.new(node: node, status: :failed, error: normalize_error(e, node))
@@ -48,13 +61,13 @@ module Igniter
 
       def resolve_compute(node)
         dependencies = node.dependencies.each_with_object({}) do |dependency_name, memo|
-          dependency_state = resolve(dependency_name)
-          raise dependency_state.error if dependency_state.failed?
-
-          memo[dependency_name] = dependency_state.value
+          memo[dependency_name] = resolve_dependency_value(dependency_name)
         end
 
         value = call_compute(node.callable, dependencies)
+        return NodeState.new(node: node, status: :pending, value: normalize_deferred_result(value, node)) if deferred_result?(value)
+        value = normalize_guard_value(node, value)
+
         NodeState.new(node: node, status: :succeeded, value: value)
       end
 
@@ -62,8 +75,28 @@ module Igniter
         case callable
         when Proc
           callable.call(**dependencies)
+        when Class
+          call_compute_class(callable, dependencies)
         when Symbol, String
           @execution.contract_instance.public_send(callable.to_sym, **dependencies)
+        else
+          call_compute_object(callable, dependencies)
+        end
+      end
+
+      def call_compute_class(callable, dependencies)
+        if callable <= Igniter::Executor
+          callable.new(execution: @execution, contract: @execution.contract_instance).call(**dependencies)
+        elsif callable.respond_to?(:call)
+          callable.call(**dependencies)
+        else
+          raise ResolutionError, "Unsupported callable: #{callable}"
+        end
+      end
+
+      def call_compute_object(callable, dependencies)
+        if callable.respond_to?(:call)
+          callable.call(**dependencies)
         else
           raise ResolutionError, "Unsupported callable: #{callable.class}"
         end
@@ -71,10 +104,7 @@ module Igniter
 
       def resolve_composition(node)
         child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
-          dependency_state = resolve(dependency_name)
-          raise dependency_state.error if dependency_state.failed?
-
-          memo[child_input_name] = dependency_state.value
+          memo[child_input_name] = resolve_dependency_value(dependency_name)
         end
 
         child_contract = node.contract_class.new(child_inputs)
@@ -85,8 +115,183 @@ module Igniter
         NodeState.new(node: node, status: :succeeded, value: child_contract.result)
       end
 
+      def resolve_branch(node)
+        selector_value = resolve_dependency_value(node.selector_dependency)
+        selected_case = node.cases.find { |entry| entry[:match] == selector_value }
+        selected_contract = selected_case ? selected_case[:contract] : node.default_contract
+        matched_case = selected_case ? selected_case[:match] : :default
+
+        raise BranchSelectionError, "Branch '#{node.name}' has no matching case and no default" unless selected_contract
+
+        context_values = node.context_dependencies.each_with_object({}) do |dependency_name, memo|
+          memo[dependency_name] = resolve_dependency_value(dependency_name)
+        end
+
+        child_inputs = if node.input_mapper?
+                         map_branch_inputs(node, selector_value, context_values)
+                       else
+                         node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
+                           memo[child_input_name] = resolve_dependency_value(dependency_name)
+                         end
+                       end
+
+        @execution.events.emit(
+          :branch_selected,
+          node: node,
+          status: :succeeded,
+          payload: {
+            selector: node.selector_dependency,
+            selector_value: selector_value,
+            matched_case: matched_case,
+            selected_contract: selected_contract.name || "AnonymousContract"
+          }
+        )
+
+        child_contract = selected_contract.new(child_inputs)
+        child_contract.resolve_all
+        child_error = child_contract.result.errors.values.first
+        raise child_error if child_error
+
+        NodeState.new(node: node, status: :succeeded, value: child_contract.result)
+      end
+
+      def map_branch_inputs(node, selector_value, context_values)
+        mapper = node.input_mapper
+
+        if mapper.is_a?(Symbol) || mapper.is_a?(String)
+          return @execution.contract_instance.public_send(mapper, selector: selector_value, **context_values)
+        end
+
+        mapper.call(selector: selector_value, **context_values)
+      end
+
+      def resolve_collection(node)
+        items = resolve_dependency_value(node.source_dependency)
+        context_values = node.context_dependencies.each_with_object({}) do |dependency_name, memo|
+          memo[dependency_name] = resolve_dependency_value(dependency_name)
+        end
+        normalized_items = normalize_collection_items(node, items, context_values)
+        collection_items = {}
+
+        normalized_items.each do |item_inputs|
+          item_key = extract_collection_key(node, item_inputs)
+          emit_collection_item_event(:collection_item_started, node, item_key, item_inputs: item_inputs)
+          child_contract = node.contract_class.new(item_inputs)
+          begin
+            child_contract.resolve_all
+          rescue Igniter::Error
+            nil
+          end
+          child_error = child_contract.execution.cache.values.find(&:failed?)&.error
+
+          if child_error
+            collection_items[item_key] = Runtime::CollectionResult::Item.new(
+              key: item_key,
+              status: :failed,
+              error: child_error
+            )
+            emit_collection_item_event(
+              :collection_item_failed,
+              node,
+              item_key,
+              error: child_error.message,
+              error_type: child_error.class.name,
+              child_execution_id: child_contract.execution.events.execution_id
+            )
+            raise child_error if node.mode == :fail_fast
+          else
+            collection_items[item_key] = Runtime::CollectionResult::Item.new(
+              key: item_key,
+              status: :succeeded,
+              result: child_contract.result
+            )
+            emit_collection_item_event(
+              :collection_item_succeeded,
+              node,
+              item_key,
+              child_execution_id: child_contract.execution.events.execution_id
+            )
+          end
+        end
+
+        NodeState.new(
+          node: node,
+          status: :succeeded,
+          value: Runtime::CollectionResult.new(items: collection_items, mode: node.mode)
+        )
+      end
+
+      def resolve_dependency_value(dependency_name)
+        if @execution.compiled_graph.node?(dependency_name)
+          dependency_state = resolve(dependency_name)
+          raise dependency_state.error if dependency_state.failed?
+          raise PendingDependencyError.new(dependency_state.value, context: pending_context(dependency_state.node)) if dependency_state.pending?
+
+          dependency_state.value
+        elsif @execution.compiled_graph.outputs_by_name.key?(dependency_name.to_sym)
+          output = @execution.compiled_graph.fetch_output(dependency_name)
+          value = @execution.send(:resolve_exported_output, output)
+          raise PendingDependencyError.new(value) if deferred_result?(value)
+
+          value
+        else
+          raise ResolutionError, "Unknown dependency: #{dependency_name}"
+        end
+      end
+
+      def deferred_result?(value)
+        value.is_a?(Runtime::DeferredResult)
+      end
+
+      def normalize_deferred_result(value, node)
+        Runtime::DeferredResult.build(
+          token: value.token,
+          payload: value.payload,
+          source_node: value.source_node || node.name,
+          waiting_on: value.waiting_on
+        )
+      end
+
+      def emit_resolution_event(node, state)
+        event_type =
+          if state.failed?
+            :node_failed
+          elsif state.pending?
+            :node_pending
+          else
+            :node_succeeded
+          end
+
+        payload = state.pending? ? pending_payload(state) : success_payload(node, state)
+        @execution.events.emit(event_type, node: node, status: state.status, payload: payload)
+      end
+
+      def emit_collection_item_event(type, node, item_key, payload = {})
+        @execution.events.emit(
+          type,
+          node: node,
+          payload: payload.merge(item_key: item_key)
+        )
+      end
+
+      def pending_payload(state)
+        return {} unless state.value.is_a?(Runtime::DeferredResult)
+
+        state.value.to_h
+      end
+
+      def pending_context(node)
+        {
+          graph: @execution.compiled_graph.name,
+          node_id: node.id,
+          node_name: node.name,
+          node_path: node.path,
+          source_location: node.source_location
+        }
+      end
+
       def success_payload(node, state)
-        return {} unless node.kind == :composition
+        return {} unless %i[composition branch].include?(node.kind)
         return {} unless state.value.is_a?(Igniter::Runtime::Result)
 
         {
@@ -109,6 +314,96 @@ module Igniter
           }
         )
       end
+
+      def normalize_guard_value(node, value)
+        return value unless node.respond_to?(:guard?) && node.guard?
+        return true if value
+
+        raise ResolutionError.new(
+          node.metadata[:guard_message] || "Guard '#{node.name}' failed",
+          context: {
+            graph: @execution.compiled_graph.name,
+            node_id: node.id,
+            node_name: node.name,
+            node_path: node.path,
+            source_location: node.source_location
+          }
+        )
+      end
+
+      def normalize_collection_items(node, items, context_values = {})
+        if node.input_mapper? && items.is_a?(Hash)
+          items = items.to_a
+        end
+
+        unless items.is_a?(Array)
+          raise CollectionInputError.new(
+            "Collection '#{node.name}' expects an array, got #{items.class}",
+            context: collection_context(node)
+          )
+        end
+
+        mapped_items = if node.input_mapper?
+                         items.map { |item| map_collection_item_inputs(node, item, context_values) }
+                       else
+                         items
+                       end
+
+        mapped_items.each do |item|
+          next if item.is_a?(Hash)
+
+          raise CollectionInputError.new(
+            "Collection '#{node.name}' expects item hashes, got #{item.class}",
+            context: collection_context(node)
+          )
+        end
+
+        ensure_unique_collection_keys!(node, mapped_items)
+        mapped_items.map { |item| item.transform_keys(&:to_sym) }
+      end
+
+      def map_collection_item_inputs(node, item, context_values)
+        mapper = node.input_mapper
+
+        if mapper.is_a?(Symbol) || mapper.is_a?(String)
+          return @execution.contract_instance.public_send(mapper, item: item, **context_values)
+        end
+
+        mapper.call(item: item, **context_values)
+      end
+
+      def extract_collection_key(node, item_inputs)
+        item_inputs.fetch(node.key_name)
+      rescue KeyError
+        raise CollectionKeyError.new(
+          "Collection '#{node.name}' item is missing key '#{node.key_name}'",
+          context: collection_context(node)
+        )
+      end
+
+      def ensure_unique_collection_keys!(node, items)
+        keys = items.map do |item|
+          item.fetch(node.key_name) { raise CollectionKeyError.new("Collection '#{node.name}' item is missing key '#{node.key_name}'", context: collection_context(node)) }
+        end
+
+        duplicates = keys.group_by(&:itself).select { |_key, entries| entries.size > 1 }.keys
+        return if duplicates.empty?
+
+        raise CollectionKeyError.new(
+          "Collection '#{node.name}' has duplicate keys: #{duplicates.join(', ')}",
+          context: collection_context(node)
+        )
+      end
+
+      def collection_context(node)
+        {
+          graph: @execution.compiled_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/runtime/result.rb

@@ -18,7 +18,7 @@ module Igniter
 
       def success?
         @execution.resolve_all
-        !failed?
+        !failed? && !pending?
       end
 
       def failed?
@@ -26,6 +26,11 @@ module Igniter
         @execution.cache.values.any?(&:failed?)
       end
 
+      def pending?
+        @execution.resolve_all
+        @execution.cache.values.any?(&:pending?)
+      end
+
       def errors
         @execution.resolve_all
         @execution.cache.values.each_with_object({}) do |state, memo|
@@ -52,8 +57,9 @@ module Igniter
           graph: @execution.compiled_graph.name,
           execution_id: @execution.events.execution_id,
           outputs: to_h,
-          success: !failed?,
+          success: !failed? && !pending?,
           failed: failed?,
+          pending: pending?,
           errors: serialize_errors(errors),
           states: states
         }
@@ -73,6 +79,8 @@ module Igniter
         case value
         when Result
           value.as_json
+        when CollectionResult
+          value.as_json
         when Array
           value.map { |item| serialize_value(item) }
         else
@@ -82,8 +90,12 @@ module Igniter
 
       def serialize_output_value(value)
         case value
+        when DeferredResult
+          value.as_json
         when Result
           value.to_h
+        when CollectionResult
+          value.to_h
         when Array
           value.map { |item| serialize_output_value(item) }
         else

data/lib/igniter/runtime/runner_factory.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class RunnerFactory
+      def self.build(strategy, execution, resolver:, max_workers: nil, store: nil)
+        case strategy.to_sym
+        when :inline
+          Runners::InlineRunner.new(execution, resolver: resolver, max_workers: max_workers)
+        when :store
+          Runners::StoreRunner.new(execution, resolver: resolver, store: store, max_workers: max_workers)
+        when :thread_pool
+          Runners::ThreadPoolRunner.new(execution, resolver: resolver, max_workers: max_workers)
+        else
+          raise CompileError, "Unknown execution runner strategy: #{strategy}"
+        end
+      end
+    end
+  end
+end