igniter 0.5.0 → 0.5.2

data/lib/igniter/runtime/collection_result.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Runtime
-    class CollectionResult
-      Item = Struct.new(:key, :status, :result, :error, keyword_init: true) do
-        def succeeded?
-          status == :succeeded
-        end
-
-        def failed?
-          status == :failed
-        end
-
-        def to_h
-          {
-            key: key,
-            status: status,
-            result: serialize_result(result),
-            error: serialize_error(error)
-          }.compact
-        end
-
-        private
-
-        def serialize_result(value)
-          case value
-          when Runtime::Result
-            value.to_h
-          else
-            value
-          end
-        end
-
-        def serialize_error(value)
-          return nil unless value
-
-          {
-            type: value.class.name,
-            message: value.message,
-            context: value.respond_to?(:context) ? value.context : {}
-          }
-        end
-      end
-
-      attr_reader :items, :mode
-
-      def initialize(items:, mode:)
-        @items = items.freeze
-        @mode = mode.to_sym
-      end
-
-      def [](key)
-        items.fetch(key)
-      end
-
-      def keys
-        items.keys
-      end
-
-      def successes
-        items.select { |_key, item| item.succeeded? }
-      end
-
-      def failures
-        items.select { |_key, item| item.failed? }
-      end
-
-      def items_summary
-        items.transform_values do |item|
-          {
-            status: item.status,
-            error: item.error&.message
-          }.compact
-        end
-      end
-
-      def failed_items
-        failures.transform_values do |item|
-          {
-            type: item.error.class.name,
-            message: item.error.message,
-            context: item.error.respond_to?(:context) ? item.error.context : {}
-          }
-        end
-      end
-
-      def to_h
-        items.transform_values(&:to_h)
-      end
-
-      def summary
-        {
-          mode: mode,
-          total: items.size,
-          succeeded: successes.size,
-          failed: failures.size,
-          status: failures.empty? ? :succeeded : :partial_failure
-        }
-      end
-
-      def as_json(*)
-        {
-          mode: mode,
-          summary: summary,
-          items: to_h
-        }
-      end
-    end
-  end
-end

data/lib/igniter/runtime/deferred_result.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module Igniter
-  module Runtime
-    class DeferredResult
-      attr_reader :token, :payload, :source_node, :waiting_on
-
-      def initialize(token:, payload: {}, source_node: nil, waiting_on: nil)
-        @token = token
-        @payload = payload.freeze
-        @source_node = source_node&.to_sym
-        @waiting_on = waiting_on&.to_sym
-      end
-
-      def self.build(token: nil, payload: {}, source_node: nil, waiting_on: nil)
-        new(
-          token: token || SecureRandom.uuid,
-          payload: payload,
-          source_node: source_node,
-          waiting_on: waiting_on
-        )
-      end
-
-      def to_h
-        {
-          token: token,
-          payload: payload,
-          source_node: source_node,
-          waiting_on: waiting_on
-        }.compact
-      end
-
-      def as_json(*)
-        to_h
-      end
-    end
-  end
-end

data/lib/igniter/runtime/execution.rb

@@ -1,416 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Runtime
-    class Execution
-      attr_reader :compiled_graph, :contract_instance, :inputs, :cache, :events, :audit, :runner_strategy, :max_workers, :store
-
-      def initialize(compiled_graph:, contract_instance:, inputs:, runner: :inline, max_workers: nil, store: nil)
-        @compiled_graph = compiled_graph
-        @contract_instance = contract_instance
-        @runner_strategy = runner
-        @max_workers = max_workers
-        @store = store
-        @events = Events::Bus.new
-        @input_validator = InputValidator.new(compiled_graph, execution_id: @events.execution_id)
-        @inputs = @input_validator.normalize_initial_inputs(inputs)
-        @cache = Cache.new
-        @audit = Extensions::Auditing::Timeline.new(self)
-        @events.subscribe(@audit)
-        @resolver = Resolver.new(self)
-        @planner = Planner.new(self)
-        @runner = RunnerFactory.build(@runner_strategy, self, resolver: @resolver, max_workers: @max_workers, store: @store)
-        @invalidator = Invalidator.new(self)
-      end
-
-      def resolve_output(name)
-        output = compiled_graph.fetch_output(name)
-        with_execution_lifecycle([output.source_root]) do
-          run_targets([output.source_root])
-          resolve_exported_output(output)
-        end
-      end
-
-      def resolve(name)
-        @resolver.resolve(name)
-      end
-
-      def resolve_all
-        output_sources = @planner.targets_for_outputs
-
-        with_execution_lifecycle(output_sources) do
-          run_targets(output_sources)
-          compiled_graph.outputs.each { |output_node| resolve_output_value(output_node) }
-          self
-        end
-      end
-
-      def update_inputs(new_inputs)
-        symbolize_keys(new_inputs).each do |name, value|
-          @input_validator.validate_update!(name, value)
-
-          @inputs[name] = value
-          input_node = compiled_graph.fetch_node(name)
-          cache.write(NodeState.new(node: input_node, status: :succeeded, value: value, invalidated_by: name))
-          @events.emit(:input_updated, node: input_node, status: :succeeded, payload: { value: value })
-          @invalidator.invalidate_from(name)
-        end
-
-        self
-      end
-
-      # Returns the DiffState for an incremental collection node (created on first access).
-      # Persists across update_inputs calls for the lifetime of this Execution.
-      def diff_state_for(node_name)
-        @diff_states ||= {}
-        @diff_states[node_name.to_sym] ||= Igniter::Dataflow::DiffState.new
-      end
-
-
-      # Returns the AggregateState for an aggregate node (created on first access).
-      # Persists across update_inputs calls for the lifetime of this Execution.
-      def aggregate_state_for(node_name)
-        @aggregate_states ||= {}
-        @aggregate_states[node_name.to_sym] ||= begin
-          node = compiled_graph.fetch_node(node_name)
-          Igniter::Dataflow::AggregateState.new(node.operator)
-        end
-      end
-
-      def resume(node_name, value:)
-        node = compiled_graph.fetch_node(node_name)
-        current = cache.fetch(node.name)
-        raise ResolutionError, "Node '#{node_name}' is not pending" unless current&.pending?
-
-        cache.write(NodeState.new(node: node, status: :succeeded, value: value))
-        @events.emit(:node_resumed, node: node, status: :succeeded, payload: { resumed: true })
-        @invalidator.invalidate_from(node.name)
-        persist_runtime_state!
-        self
-      end
-
-      def resume_by_token(token, value:)
-        node_name = pending_node_name_for_token(token)
-        raise ResolutionError, "No pending node found for token '#{token}'" unless node_name
-
-        resume(node_name, value: value)
-      end
-
-      def success?
-        resolve_all
-        !failed? && !pending?
-      end
-
-      def failed?
-        resolve_all
-        cache.values.any?(&:failed?)
-      end
-
-      def pending?
-        resolve_all
-        cache.values.any?(&:pending?)
-      end
-
-      def states
-        Extensions::Introspection::RuntimeFormatter.states(self)
-      end
-
-      def explain_output(name)
-        Extensions::Introspection::RuntimeFormatter.explain_output(self, name)
-      end
-
-      def diagnostics
-        Diagnostics::Report.new(self)
-      end
-
-      def plan(output_names = nil)
-        @planner.plan(output_names)
-      end
-
-      def explain_plan(output_names = nil)
-        Extensions::Introspection::PlanFormatter.to_text(self, output_names)
-      end
-
-      def to_h
-        {
-          graph: compiled_graph.name,
-          execution_id: events.execution_id,
-          inputs: inputs.dup,
-          runner: runner_strategy,
-          max_workers: max_workers,
-          success: success?,
-          failed: cache.values.any?(&:failed?),
-          pending: cache.values.any?(&:pending?),
-          plan: plan,
-          states: states,
-          event_count: events.events.size
-        }
-      end
-
-      def as_json(*)
-        to_h.merge(
-          events: events.events.map(&:as_json)
-        )
-      end
-
-      def snapshot(include_resolution: true)
-        resolve_pending_safe if include_resolution
-
-        {
-          graph: compiled_graph.name,
-          execution_id: events.execution_id,
-          runner: runner_strategy,
-          max_workers: max_workers,
-          inputs: inputs.dup,
-          states: serialize_states,
-          events: events.events.map(&:as_json)
-        }
-      end
-
-      def restore!(snapshot)
-        @inputs.replace(symbolize_keys(value_from(snapshot, :inputs) || {}))
-        cache.restore!(deserialize_states(value_from(snapshot, :states) || {}))
-        events.restore!(events: value_from(snapshot, :events) || [], execution_id: value_from(snapshot, :execution_id))
-        audit.restore!(events.events)
-        self
-      end
-
-      private
-
-      def with_execution_lifecycle(node_names)
-        if resolution_required_for_any?(node_names)
-          @events.emit(:execution_started, payload: { graph: compiled_graph.name, targets: node_names.map(&:to_sym) })
-          begin
-            result = yield
-            persist_runtime_state!
-            @events.emit(:execution_finished, payload: { graph: compiled_graph.name, targets: node_names.map(&:to_sym) })
-            result
-          rescue StandardError => e
-            @events.emit(
-              :execution_failed,
-              status: :failed,
-              payload: {
-                graph: compiled_graph.name,
-                targets: node_names.map(&:to_sym),
-                error: e.message
-              }
-            )
-            persist_runtime_state!
-            raise
-          end
-        else
-          yield
-        end
-      end
-
-      def resolution_required_for_any?(node_names)
-        node_names.any? do |node_name|
-          state = cache.fetch(node_name)
-          state.nil? || state.stale?
-        end
-      end
-
-      def symbolize_keys(hash)
-        hash.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
-      end
-
-      public
-
-      def fetch_input!(name)
-        @input_validator.fetch_value!(name, @inputs)
-      end
-
-      private
-
-      def resolve_exported_output(output)
-        state = @resolver.resolve(output.source_root)
-        raise state.error if state.failed?
-        return state.value if state.pending?
-
-        return state.value unless output.composition_output?
-
-        state.value.public_send(output.child_output_name)
-      end
-
-      def run_targets(node_names)
-        @runner.run(node_names)
-      end
-
-      def persist_runtime_state!
-        return unless @runner.respond_to?(:persist!)
-
-        @runner.persist!
-      end
-
-      def pending_node_name_for_token(token)
-        source_match = cache.values.find do |state|
-          state.pending? &&
-            state.value.is_a?(Runtime::DeferredResult) &&
-            state.value.token == token &&
-            state.value.source_node == state.node.name
-        end
-        return source_match.node.name if source_match
-
-        cache.values.find do |state|
-          state.pending? &&
-            state.value.is_a?(Runtime::DeferredResult) &&
-            state.value.token == token
-        end&.node&.name
-      end
-
-      def resolve_pending_safe
-        resolve_all
-      rescue Igniter::Error
-        nil
-      end
-
-      def serialize_states
-        cache.to_h.each_with_object({}) do |(node_name, state), memo|
-          memo[node_name] = {
-            status: state.status,
-            version: state.version,
-            value_version: state.value_version,
-            resolved_at: state.resolved_at&.iso8601,
-            invalidated_by: state.invalidated_by,
-            value: serialize_state_value(state.value),
-            error: serialize_state_error(state.error),
-            dep_snapshot: state.dep_snapshot
-          }
-        end
-      end
-
-      def deserialize_states(snapshot_states)
-        snapshot_states.each_with_object({}) do |(node_name, state_data), memo|
-          node = compiled_graph.fetch_node(node_name)
-          raw_dep_snapshot = state_data[:dep_snapshot] || state_data["dep_snapshot"]
-          dep_snapshot = raw_dep_snapshot&.transform_keys(&:to_sym)
-          memo[node.name] = NodeState.new(
-            node: node,
-            status: (state_data[:status] || state_data["status"]).to_sym,
-            value: deserialize_state_value(node, state_data[:value] || state_data["value"]),
-            error: deserialize_state_error(state_data[:error] || state_data["error"]),
-            version: state_data[:version] || state_data["version"],
-            value_version: state_data[:value_version] || state_data["value_version"],
-            resolved_at: deserialize_time(state_data[:resolved_at] || state_data["resolved_at"]),
-            invalidated_by: (state_data[:invalidated_by] || state_data["invalidated_by"])&.to_sym,
-            dep_snapshot: dep_snapshot
-          )
-        end
-      end
-
-      def serialize_state_value(value)
-        case value
-        when Runtime::DeferredResult
-          { type: :deferred, data: value.as_json }
-        when Runtime::Result
-          {
-            type: :result_snapshot,
-            snapshot: value.execution.snapshot(include_resolution: false)
-          }
-        when Runtime::CollectionResult
-          {
-            type: :collection_result,
-            mode: value.mode,
-            items: value.items.transform_values do |item|
-              {
-                key: item.key,
-                status: item.status,
-                result: serialize_state_value(item.result),
-                error: serialize_state_error(item.error)
-              }
-            end
-          }
-        else
-          value
-        end
-      end
-
-      def deserialize_state_value(node, value)
-        if value.is_a?(Hash) && (value[:type] || value["type"])&.to_sym == :deferred
-          data = value[:data] || value["data"] || {}
-          return Runtime::DeferredResult.build(
-            token: data[:token] || data["token"],
-            payload: data[:payload] || data["payload"] || {},
-            source_node: data[:source_node] || data["source_node"],
-            waiting_on: data[:waiting_on] || data["waiting_on"]
-          )
-        end
-
-        if value.is_a?(Hash) && (value[:type] || value["type"])&.to_sym == :result_snapshot
-          snapshot = value[:snapshot] || value["snapshot"] || {}
-          if node.kind == :composition
-            child_contract = node.contract_class.restore(snapshot)
-            return child_contract.result
-          end
-
-          if node.kind == :branch
-            snapshot_graph = snapshot[:graph] || snapshot["graph"]
-            contract_class = node.possible_contracts.find { |candidate| candidate.compiled_graph.name == snapshot_graph }
-            return value unless contract_class
-
-            child_contract = contract_class.restore(snapshot)
-            return child_contract.result
-          end
-
-          if node.kind == :collection
-            child_contract = node.contract_class.restore(snapshot)
-            return child_contract.result
-          end
-        end
-
-        if value.is_a?(Hash) && (value[:type] || value["type"])&.to_sym == :collection_result
-          items = (value[:items] || value["items"] || {}).each_with_object({}) do |(key, item), memo|
-            memo[key.is_a?(String) && key.match?(/\A\d+\z/) ? key.to_i : key] = Runtime::CollectionResult::Item.new(
-              key: item[:key] || item["key"] || key,
-              status: (item[:status] || item["status"]).to_sym,
-              result: deserialize_state_value(node, item[:result] || item["result"]),
-              error: deserialize_state_error(item[:error] || item["error"])
-            )
-          end
-          return Runtime::CollectionResult.new(
-            items: items,
-            mode: (value[:mode] || value["mode"] || :collect).to_sym
-          )
-        end
-
-        value
-      end
-
-      def serialize_state_error(error)
-        return nil unless error
-
-        {
-          type: error.class.name,
-          message: error.message,
-          context: error.respond_to?(:context) ? error.context : {}
-        }
-      end
-
-      def deserialize_state_error(error_data)
-        return nil unless error_data
-
-        ResolutionError.new(
-          error_data[:message] || error_data["message"],
-          context: error_data[:context] || error_data["context"] || {}
-        )
-      end
-
-      def deserialize_time(value)
-        case value
-        when Time
-          value
-        when String
-          Time.iso8601(value)
-        else
-          value || Time.now.utc
-        end
-      end
-
-      def value_from(data, key)
-        data[key] || data[key.to_s]
-      end
-
-      alias_method :resolve_output_value, :resolve_exported_output
-    end
-  end
-end

data/lib/igniter/runtime/input_validator.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Runtime
-    class InputValidator
-      def initialize(compiled_graph, execution_id: nil)
-        @compiled_graph = compiled_graph
-        @execution_id = execution_id
-      end
-
-      def normalize_initial_inputs(raw_inputs)
-        inputs = symbolize_keys(raw_inputs)
-
-        validate_unknown_inputs!(inputs)
-        apply_defaults(inputs)
-        validate_known_inputs!(inputs)
-
-        inputs
-      end
-
-      def validate_update!(name, value)
-        input_node = fetch_input_node(name)
-        validate_required!(input_node, value)
-        validate_type!(input_node, value)
-      end
-
-      def fetch_value!(name, inputs)
-        input_node = fetch_input_node(name)
-        value = inputs.fetch(name.to_sym) { missing_value!(input_node) }
-
-        validate_required!(input_node, value)
-        validate_type!(input_node, value)
-        value
-      end
-
-      private
-
-      def input_nodes
-        @input_nodes ||= @compiled_graph.nodes.select { |node| node.kind == :input }
-      end
-
-      def input_nodes_by_name
-        @input_nodes_by_name ||= input_nodes.each_with_object({}) { |node, memo| memo[node.name] = node }
-      end
-
-      def fetch_input_node(name)
-        input_nodes_by_name.fetch(name.to_sym)
-      rescue KeyError
-        raise InputError.new("Unknown input: #{name}", context: { graph: @compiled_graph.name, node_name: name.to_sym })
-      end
-
-      def validate_unknown_inputs!(inputs)
-        unknown = inputs.keys - input_nodes_by_name.keys
-        return if unknown.empty?
-
-        raise InputError.new(
-          "Unknown inputs: #{unknown.sort.join(', ')}",
-          context: { graph: @compiled_graph.name }
-        )
-      end
-
-      def apply_defaults(inputs)
-        input_nodes.each do |node|
-          next if inputs.key?(node.name)
-          next unless node.default?
-
-          d = node.default
-          inputs[node.name] = d.respond_to?(:call) ? d.call : d
-        end
-      end
-
-      def validate_known_inputs!(inputs)
-        inputs.each do |name, value|
-          input_node = fetch_input_node(name)
-          validate_required!(input_node, value)
-          validate_type!(input_node, value)
-        end
-      end
-
-      def missing_value!(input_node)
-        if input_node.default?
-          d = input_node.default
-          return d.respond_to?(:call) ? d.call : d
-        end
-        return nil unless input_node.required?
-
-        raise input_error(input_node, "Missing required input: #{input_node.name}")
-      end
-
-      def validate_required!(input_node, value)
-        return unless input_node.required?
-        return unless value.nil?
-
-        raise input_error(input_node, "Input '#{input_node.name}' is required")
-      end
-
-      def validate_type!(input_node, value)
-        return if value.nil?
-        return unless 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 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 symbolize_keys(hash)
-        hash.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
-      end
-
-      def input_error(input_node, message) # rubocop:disable Metrics/MethodLength
-        InputError.new(
-          message,
-          context: {
-            graph: @compiled_graph.name,
-            node_id: input_node.id,
-            node_name: input_node.name,
-            node_path: input_node.path,
-            source_location: input_node.source_location,
-            execution_id: @execution_id
-          }
-        )
-      end
-    end
-  end
-end