igniter 0.4.5 → 0.5.1

data/lib/igniter/runtime/resolver.rb

@@ -1,520 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module Runtime
-    class Resolver
-      def initialize(execution)
-        @execution = execution
-      end
-
-      def resolve(node_name)
-        node = @execution.compiled_graph.fetch_node(node_name)
-        resolution_status, cached = @execution.cache.begin_resolution(node)
-        return cached if resolution_status == :cached
-
-        @execution.events.emit(:node_started, node: node, status: :running)
-
-        state = case node.kind
-                when :input
-                  resolve_input(node)
-                when :compute
-                  resolve_compute(node)
-                when :composition
-                  resolve_composition(node)
-                when :branch
-                  resolve_branch(node)
-                when :collection
-                  resolve_collection(node)
-                when :effect
-                  resolve_effect(node)
-                when :await
-                  resolve_await(node)
-                when :remote
-                  resolve_remote(node)
-                else
-                  raise ResolutionError, "Unsupported node kind: #{node.kind}"
-                end
-
-        @execution.cache.write(state)
-        emit_resolution_event(node, state)
-        state
-      rescue PendingDependencyError => e
-        state = NodeState.new(
-          node: node,
-          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))
-        @execution.cache.write(state)
-        @execution.events.emit(:node_failed, node: node, status: :failed, payload: { error: state.error.message })
-        state
-      end
-
-      private
-
-      def resolve_input(node)
-        NodeState.new(node: node, status: :succeeded, value: @execution.fetch_input!(node.name))
-      end
-
-      def resolve_effect(node)
-        dependencies = node.dependencies.each_with_object({}) do |dep, memo|
-          memo[dep] = resolve_dependency_value(dep)
-        end
-
-        value = node.adapter_class.new(
-          execution: @execution,
-          contract: @execution.contract_instance
-        ).call(**dependencies)
-
-        NodeState.new(node: node, status: :succeeded, value: value)
-      end
-
-      def resolve_await(node)
-        deferred = Runtime::DeferredResult.build(
-          payload: { event: node.event_name },
-          source_node: node.name,
-          waiting_on: node.name
-        )
-        raise PendingDependencyError.new(deferred, "Waiting for external event '#{node.event_name}'")
-      end
-
-      def resolve_remote(node) # rubocop:disable Metrics/MethodLength
-        unless defined?(Igniter::Server::Client)
-          raise ResolutionError,
-                "remote: nodes require `require 'igniter/server'` (server integration not loaded)"
-        end
-
-        inputs = node.input_mapping.each_with_object({}) do |(child_input, dep_name), memo|
-          memo[child_input] = resolve_dependency_value(dep_name)
-        end
-
-        client   = Igniter::Server::Client.new(node.node_url, timeout: node.timeout)
-        response = client.execute(node.contract_name, inputs: inputs)
-
-        case response[:status]
-        when :succeeded
-          NodeState.new(node: node, status: :succeeded, value: response[:outputs])
-        when :failed
-          error_message = response.dig(:error, :message) || response.dig(:error, "message")
-          raise ResolutionError,
-                "Remote #{node.contract_name}@#{node.node_url}: #{error_message}"
-        else
-          raise ResolutionError,
-                "Remote #{node.contract_name}@#{node.node_url}: unexpected status '#{response[:status]}'"
-        end
-      rescue Igniter::Server::Client::ConnectionError => e
-        raise ResolutionError, "Cannot reach #{node.node_url}: #{e.message}"
-      end
-
-      def resolve_compute(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        # Running state preserves dep_snapshot + value_version from the stale state.
-        # These are used for memoization (skip recompute) and value backdating.
-        running_state = @execution.cache.fetch(node.name)
-        old_dep_snapshot = running_state&.dep_snapshot
-        old_value = running_state&.value
-        old_value_version = running_state&.value_version || 0
-
-        # Resolve all dependencies (may recursively recompute upstream nodes).
-        dependencies = node.dependencies.each_with_object({}) do |dependency_name, memo|
-          memo[dependency_name] = resolve_dependency_value(dependency_name)
-        end
-
-        # Build snapshot of current dep value_versions (only regular nodes, not outputs).
-        current_dep_snapshot = build_dep_snapshot(node)
-
-        # Memoization: if all dep value_versions are unchanged, skip the compute entirely.
-        if old_dep_snapshot && old_value && old_value_version.positive? &&
-           dep_snapshot_match?(current_dep_snapshot, old_dep_snapshot)
-          @execution.events.emit(:node_skipped, node: node, status: :succeeded,
-                                                payload: { reason: :deps_unchanged })
-          return NodeState.new(node: node, status: :succeeded, value: old_value,
-                               value_version: old_value_version,
-                               dep_snapshot: current_dep_snapshot)
-        end
-
-        value = call_compute(node.callable, dependencies)
-        if deferred_result?(value)
-          return NodeState.new(node: node, status: :pending,
-                               value: normalize_deferred_result(value, node))
-        end
-
-        value = normalize_guard_value(node, value)
-
-        # Value backdating: if the output is unchanged, preserve value_version so that
-        # downstream nodes whose dep_snapshots reference this node won't see it as changed.
-        if old_value && old_value_version.positive? && value == old_value
-          @execution.events.emit(:node_backdated, node: node, status: :succeeded,
-                                                  payload: { reason: :value_unchanged })
-          return NodeState.new(node: node, status: :succeeded, value: value,
-                               value_version: old_value_version,
-                               dep_snapshot: current_dep_snapshot)
-        end
-
-        NodeState.new(node: node, status: :succeeded, value: value,
-                      dep_snapshot: current_dep_snapshot)
-      end
-
-      def call_compute(callable, dependencies)
-        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)
-        raise ResolutionError, "Unsupported callable: #{callable.class}" unless callable.respond_to?(:call)
-
-        callable.call(**dependencies)
-      end
-
-      def resolve_composition(node)
-        child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
-          memo[child_input_name] = resolve_dependency_value(dependency_name)
-        end
-
-        child_contract = node.contract_class.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 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?
-
-          if dependency_state.pending?
-            raise PendingDependencyError.new(dependency_state.value,
-                                             context: pending_context(dependency_state.node))
-          end
-
-          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, 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 %i[composition branch].include?(node.kind)
-        return {} unless state.value.is_a?(Igniter::Runtime::Result)
-
-        {
-          child_execution_id: state.value.execution.events.execution_id,
-          child_graph: state.value.execution.compiled_graph.name
-        }
-      end
-
-      def normalize_error(error, node)
-        return error if error.is_a?(Igniter::Error)
-
-        ResolutionError.new(
-          error.message,
-          context: {
-            graph: @execution.compiled_graph.name,
-            node_id: node.id,
-            node_name: node.name,
-            node_path: node.path,
-            source_location: node.source_location,
-            execution_id: @execution.events.execution_id
-          }
-        )
-      end
-
-      def build_dep_snapshot(node)
-        node.dependencies.each_with_object({}) do |dep_name, memo|
-          next unless @execution.compiled_graph.node?(dep_name)
-
-          dep_state = @execution.cache.fetch(dep_name.to_sym)
-          memo[dep_name] = dep_state&.value_version
-        end
-      end
-
-      def dep_snapshot_match?(current, old)
-        return false if current.size != old.size
-
-        current.all? { |name, vv| old[name] == vv }
-      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 = {})
-        items = items.to_a if node.input_mapper? && items.is_a?(Hash)
-
-        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) do
-            raise CollectionKeyError.new("Collection '#{node.name}' item is missing key '#{node.key_name}'",
-                                         context: collection_context(node))
-          end
-        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/stores/redis_store.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Igniter
-  module Runtime
-    module Stores
-      class RedisStore
-        def initialize(redis:, namespace: "igniter:executions")
-          @redis = redis
-          @namespace = namespace
-        end
-
-        def save(snapshot, correlation: nil, graph: nil) # rubocop:disable Lint/UnusedMethodArgument
-          execution_id = snapshot[:execution_id] || snapshot["execution_id"]
-          @redis.set(redis_key(execution_id), JSON.generate(snapshot))
-          execution_id
-        end
-
-        def find_by_correlation(graph:, correlation:)
-          raise NotImplementedError, "find_by_correlation is not implemented for RedisStore"
-        end
-
-        def list_all(graph: nil)
-          raise NotImplementedError, "list_all is not implemented for RedisStore"
-        end
-
-        def list_pending(graph: nil)
-          raise NotImplementedError, "list_pending is not implemented for RedisStore"
-        end
-
-        def fetch(execution_id)
-          payload = @redis.get(redis_key(execution_id))
-          raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'" unless payload
-
-          JSON.parse(payload)
-        end
-
-        def delete(execution_id)
-          @redis.del(redis_key(execution_id))
-        end
-
-        def exist?(execution_id)
-          result = @redis.exists?(redis_key(execution_id))
-          result == true || result.to_i.positive?
-        end
-
-        private
-
-        def redis_key(execution_id)
-          "#{@namespace}:#{execution_id}"
-        end
-      end
-    end
-  end
-end

data/lib/igniter/server/client.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json"
-require "uri"
-
-module Igniter
-  module Server
-    # HTTP client for calling remote igniter-server nodes.
-    # Uses only stdlib (Net::HTTP + JSON), no external gems required.
-    class Client
-      class Error < Igniter::Server::Error; end
-      class ConnectionError < Error; end
-      class RemoteError < Error; end
-
-      def initialize(base_url, timeout: 30)
-        @base_url = base_url.chomp("/")
-        @timeout  = timeout
-      end
-
-      # Execute a contract on the remote node synchronously.
-      #
-      # Returns a symbolized hash:
-      #   { status: :succeeded, execution_id: "uuid", outputs: { result: 42 } }
-      #   { status: :failed,    execution_id: "uuid", error: { message: "..." } }
-      #   { status: :pending,   execution_id: "uuid", waiting_for: ["event"] }
-      def execute(contract_name, inputs: {})
-        response = post(
-          "/v1/contracts/#{uri_encode(contract_name)}/execute",
-          { inputs: inputs }
-        )
-        symbolize_response(response)
-      end
-
-      # Deliver an event to a pending distributed workflow on the remote node.
-      def deliver_event(contract_name, event:, correlation:, payload: {})
-        response = post(
-          "/v1/contracts/#{uri_encode(contract_name)}/events",
-          { event: event, correlation: correlation, payload: payload }
-        )
-        symbolize_response(response)
-      end
-
-      # Fetch execution status by ID.
-      def status(execution_id)
-        symbolize_response(get("/v1/executions/#{uri_encode(execution_id)}"))
-      end
-
-      # Check remote node health.
-      def health
-        get("/v1/health")
-      end
-
-      private
-
-      def post(path, body)
-        uri  = build_uri(path)
-        http = build_http(uri)
-        req  = Net::HTTP::Post.new(uri.path, json_headers)
-        req.body = JSON.generate(body)
-        parse_response(http.request(req))
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout => e
-        raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
-      end
-
-      def get(path)
-        uri  = build_uri(path)
-        http = build_http(uri)
-        req  = Net::HTTP::Get.new(uri.path, json_headers)
-        parse_response(http.request(req))
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout => e
-        raise ConnectionError, "Cannot connect to #{@base_url}: #{e.message}"
-      end
-
-      def build_uri(path)
-        URI.parse("#{@base_url}#{path}")
-      end
-
-      def build_http(uri)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl      = uri.scheme == "https"
-        http.read_timeout = @timeout
-        http.open_timeout = 10
-        http
-      end
-
-      def json_headers
-        { "Content-Type" => "application/json", "Accept" => "application/json" }
-      end
-
-      def parse_response(response)
-        body = begin
-          JSON.parse(response.body.to_s)
-        rescue JSON::ParserError
-          {}
-        end
-        raise RemoteError, "Remote error #{response.code}: #{body["error"]}" unless response.is_a?(Net::HTTPSuccess)
-
-        body
-      end
-
-      def symbolize_response(hash)
-        {
-          status: hash["status"]&.to_sym,
-          execution_id: hash["execution_id"],
-          outputs: symbolize_keys(hash["outputs"] || {}),
-          waiting_for: hash["waiting_for"] || [],
-          error: hash["error"]
-        }
-      end
-
-      def symbolize_keys(hash)
-        return hash unless hash.is_a?(Hash)
-
-        hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
-      end
-
-      def uri_encode(str)
-        URI.encode_uri_component(str.to_s)
-      end
-    end
-  end
-end