igniter 0.3.0 → 0.4.0

data/lib/igniter/model/branch_node.rb

@@ -3,10 +3,10 @@
 module Igniter
   module Model
     class BranchNode < Node
-      attr_reader :selector_dependency, :cases, :default_contract, :input_mapping
+      attr_reader :selector_dependency, :cases, :default_contract, :input_mapping, :context_dependencies, :input_mapper
 
-      def initialize(id:, name:, selector_dependency:, cases:, default_contract:, input_mapping:, path: nil, metadata: {})
-        dependencies = ([selector_dependency] + input_mapping.values).uniq
+      def initialize(id:, name:, selector_dependency:, cases:, default_contract:, input_mapping:, context_dependencies: [], input_mapper: nil, path: nil, metadata: {})
+        dependencies = ([selector_dependency] + input_mapping.values + context_dependencies).uniq
 
         super(
           id: id,
@@ -21,12 +21,18 @@ module Igniter
         @cases = cases.map { |entry| normalize_case(entry) }.freeze
         @default_contract = default_contract
         @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
+        @context_dependencies = Array(context_dependencies).map(&:to_sym).freeze
+        @input_mapper = input_mapper
       end
 
       def possible_contracts
         (cases.map { |entry| entry[:contract] } + [default_contract]).uniq
       end
 
+      def input_mapper?
+        !input_mapper.nil?
+      end
+
       private
 
       def normalize_case(entry)

data/lib/igniter/model/collection_node.rb

@@ -3,15 +3,15 @@
 module Igniter
   module Model
     class CollectionNode < Node
-      attr_reader :source_dependency, :contract_class, :key_name, :mode
+      attr_reader :source_dependency, :contract_class, :key_name, :mode, :context_dependencies, :input_mapper
 
-      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, path: nil, metadata: {})
+      def initialize(id:, name:, source_dependency:, contract_class:, key_name:, mode:, context_dependencies: [], input_mapper: nil, path: nil, metadata: {})
         super(
           id: id,
           kind: :collection,
           name: name,
           path: (path || name),
-          dependencies: [source_dependency],
+          dependencies: [source_dependency, *context_dependencies],
           metadata: metadata
         )
 
@@ -19,6 +19,12 @@ module Igniter
         @contract_class = contract_class
         @key_name = key_name.to_sym
         @mode = mode.to_sym
+        @context_dependencies = Array(context_dependencies).map(&:to_sym)
+        @input_mapper = input_mapper
+      end
+
+      def input_mapper?
+        !input_mapper.nil?
       end
     end
   end

data/lib/igniter/model/remote_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    # Represents a node that executes a contract on a remote igniter-server node.
+    # The result is the outputs hash returned by the remote contract.
+    class RemoteNode < Node
+      attr_reader :contract_name, :node_url, :input_mapping, :timeout
+
+      def initialize(id:, name:, contract_name:, node_url:, input_mapping:, timeout: 30, path: nil, metadata: {})
+        super(
+          id: id,
+          kind: :remote,
+          name: name,
+          path: path || name.to_s,
+          dependencies: input_mapping.values.map(&:to_sym),
+          metadata: metadata
+        )
+        @contract_name = contract_name.to_s
+        @node_url      = node_url.to_s
+        @input_mapping = input_mapping.transform_keys(&:to_sym).transform_values(&:to_sym).freeze
+        @timeout       = Integer(timeout)
+      end
+    end
+  end
+end

data/lib/igniter/model.rb

@@ -8,6 +8,8 @@ require_relative "model/composition_node"
 require_relative "model/branch_node"
 require_relative "model/collection_node"
 require_relative "model/output_node"
+require_relative "model/await_node"
+require_relative "model/remote_node"
 
 module Igniter
   module Model

data/lib/igniter/runtime/execution.rb

@@ -11,10 +11,10 @@ module Igniter
         @runner_strategy = runner
         @max_workers = max_workers
         @store = store
-        @input_validator = InputValidator.new(compiled_graph)
+        @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
-        @events = Events::Bus.new
         @audit = Extensions::Auditing::Timeline.new(self)
         @events.subscribe(@audit)
         @resolver = Resolver.new(self)

data/lib/igniter/runtime/input_validator.rb

@@ -3,8 +3,9 @@
 module Igniter
   module Runtime
     class InputValidator
-      def initialize(compiled_graph)
+      def initialize(compiled_graph, execution_id: nil)
         @compiled_graph = compiled_graph
+        @execution_id = execution_id
       end
 
       def normalize_initial_inputs(raw_inputs)
@@ -106,7 +107,7 @@ module Igniter
         hash.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
       end
 
-      def input_error(input_node, message)
+      def input_error(input_node, message) # rubocop:disable Metrics/MethodLength
         InputError.new(
           message,
           context: {
@@ -114,7 +115,8 @@ module Igniter
             node_id: input_node.id,
             node_name: input_node.name,
             node_path: input_node.path,
-            source_location: input_node.source_location
+            source_location: input_node.source_location,
+            execution_id: @execution_id
           }
         )
       end

data/lib/igniter/runtime/resolver.rb

@@ -25,6 +25,10 @@ module Igniter
                   resolve_branch(node)
                 when :collection
                   resolve_collection(node)
+                when :await
+                  resolve_await(node)
+                when :remote
+                  resolve_remote(node)
                 else
                   raise ResolutionError, "Unsupported node kind: #{node.kind}"
                 end
@@ -59,6 +63,43 @@ module Igniter
         NodeState.new(node: node, status: :succeeded, value: @execution.fetch_input!(node.name))
       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)
         dependencies = node.dependencies.each_with_object({}) do |dependency_name, memo|
           memo[dependency_name] = resolve_dependency_value(dependency_name)
@@ -123,10 +164,18 @@ module Igniter
 
         raise BranchSelectionError, "Branch '#{node.name}' has no matching case and no default" unless selected_contract
 
-        child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
-          memo[child_input_name] = resolve_dependency_value(dependency_name)
+        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,
@@ -147,9 +196,22 @@ module Igniter
         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)
-        normalized_items = normalize_collection_items(node, items)
+        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|
@@ -289,7 +351,8 @@ module Igniter
             node_id: node.id,
             node_name: node.name,
             node_path: node.path,
-            source_location: node.source_location
+            source_location: node.source_location,
+            execution_id: @execution.events.execution_id
           }
         )
       end
@@ -310,7 +373,11 @@ module Igniter
         )
       end
 
-      def normalize_collection_items(node, items)
+      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}",
@@ -318,7 +385,13 @@ module Igniter
           )
         end
 
-        items.each do |item|
+        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(
@@ -327,8 +400,18 @@ module Igniter
           )
         end
 
-        ensure_unique_collection_keys!(node, items)
-        items.map { |item| item.transform_keys(&:to_sym) }
+        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)

data/lib/igniter/runtime/stores/active_record_store.rb

@@ -12,7 +12,7 @@ module Igniter
           @snapshot_column = snapshot_column.to_sym
         end
 
-        def save(snapshot)
+        def save(snapshot, correlation: nil, graph: nil) # rubocop:disable Lint/UnusedMethodArgument
           execution_id = snapshot[:execution_id] || snapshot["execution_id"]
           record = @record_class.find_or_initialize_by(@execution_id_column => execution_id)
           record.public_send(:"#{@snapshot_column}=", JSON.generate(snapshot))
@@ -20,6 +20,18 @@ module Igniter
           execution_id
         end
 
+        def find_by_correlation(graph:, correlation:)
+          raise NotImplementedError, "find_by_correlation is not implemented for ActiveRecordStore"
+        end
+
+        def list_all(graph: nil)
+          raise NotImplementedError, "list_all is not implemented for ActiveRecordStore"
+        end
+
+        def list_pending(graph: nil)
+          raise NotImplementedError, "list_pending is not implemented for ActiveRecordStore"
+        end
+
         def fetch(execution_id)
           record = @record_class.find_by(@execution_id_column => execution_id)
           raise Igniter::ResolutionError, "No execution snapshot found for '#{execution_id}'" unless record

data/lib/igniter/runtime/stores/file_store.rb

@@ -12,12 +12,51 @@ module Igniter
           FileUtils.mkdir_p(@root)
         end
 
-        def save(snapshot)
+        def save(snapshot, correlation: nil, graph: nil)
           execution_id = snapshot[:execution_id] || snapshot["execution_id"]
-          File.write(path_for(execution_id), JSON.pretty_generate(snapshot))
+          data = snapshot.merge(
+            _graph: graph,
+            _correlation: correlation&.transform_keys(&:to_s)
+          ).compact
+          File.write(path_for(execution_id), JSON.pretty_generate(data))
           execution_id
         end
 
+        def find_by_correlation(graph:, correlation:)
+          normalized = correlation.transform_keys(&:to_s)
+          each_snapshot do |data|
+            next unless data["_graph"] == graph
+
+            stored_corr = data["_correlation"] || {}
+            return data["execution_id"] if stored_corr == normalized
+          end
+          nil
+        end
+
+        def list_all(graph: nil)
+          results = []
+          each_snapshot do |data|
+            next if graph && data["_graph"] != graph
+
+            results << data["execution_id"]
+          end
+          results
+        end
+
+        def list_pending(graph: nil)
+          results = []
+          each_snapshot do |data|
+            next if graph && data["_graph"] != graph
+
+            states = data["states"] || {}
+            pending = states.any? do |_name, state|
+              (state["status"] || state[:status]).to_s == "pending"
+            end
+            results << data["execution_id"] if pending
+          end
+          results
+        end
+
         def fetch(execution_id)
           JSON.parse(File.read(path_for(execution_id)))
         rescue Errno::ENOENT
@@ -37,6 +76,15 @@ module Igniter
         def path_for(execution_id)
           File.join(@root, "#{execution_id}.json")
         end
+
+        def each_snapshot(&block)
+          Dir.glob(File.join(@root, "*.json")).each do |file|
+            data = JSON.parse(File.read(file))
+            block.call(data)
+          rescue JSON::ParserError
+            next
+          end
+        end
       end
     end
   end

data/lib/igniter/runtime/stores/memory_store.rb

@@ -6,15 +6,68 @@ module Igniter
       class MemoryStore
         def initialize
           @snapshots = {}
+          @correlation_index = {}
           @mutex = Mutex.new
         end
 
-        def save(snapshot)
+        def save(snapshot, correlation: nil, graph: nil) # rubocop:disable Metrics/MethodLength
           execution_id = snapshot[:execution_id] || snapshot["execution_id"]
-          @mutex.synchronize { @snapshots[execution_id] = deep_copy(snapshot) }
+          @mutex.synchronize do
+            @snapshots[execution_id] = deep_copy(snapshot)
+            if graph
+              @correlation_index[execution_id] = {
+                graph: graph,
+                correlation: (correlation || {}).transform_keys(&:to_sym)
+              }
+            end
+          end
           execution_id
         end
 
+        def find_by_correlation(graph:, correlation:)
+          normalized = correlation.transform_keys(&:to_sym)
+          @mutex.synchronize do
+            @correlation_index.each do |execution_id, entry|
+              next unless entry[:graph] == graph
+              return execution_id if entry[:correlation] == normalized
+            end
+            nil
+          end
+        end
+
+        def list_all(graph: nil)
+          @mutex.synchronize do
+            if graph
+              @correlation_index.select { |_id, entry| entry[:graph] == graph }.keys
+            else
+              @snapshots.keys
+            end
+          end
+        end
+
+        def list_pending(graph: nil) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          ids = @mutex.synchronize do
+            if graph
+              @correlation_index.select { |_id, entry| entry[:graph] == graph }.keys
+            else
+              @snapshots.keys
+            end
+          end
+
+          @mutex.synchronize do
+            ids.select do |id|
+              snapshot = @snapshots[id]
+              next false unless snapshot
+
+              states = snapshot[:states] || snapshot["states"] || {}
+              states.any? do |_name, state|
+                status = state[:status] || state["status"]
+                status.to_s == "pending"
+              end
+            end
+          end
+        end
+
         def fetch(execution_id)
           @mutex.synchronize { deep_copy(@snapshots.fetch(execution_id)) }
         rescue KeyError

data/lib/igniter/runtime/stores/redis_store.rb

@@ -11,12 +11,24 @@ module Igniter
           @namespace = namespace
         end
 
-        def save(snapshot)
+        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

data/lib/igniter/server/client.rb

@@ -0,0 +1,123 @@
+# 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

data/lib/igniter/server/config.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    class Config
+      attr_accessor :host, :port, :store, :logger
+      attr_reader   :registry
+
+      def initialize
+        @host     = "0.0.0.0"
+        @port     = 4567
+        @store    = Igniter::Runtime::Stores::MemoryStore.new
+        @registry = Registry.new
+        @logger   = nil
+      end
+
+      def register(name, contract_class)
+        @registry.register(name, contract_class)
+        self
+      end
+
+      def contracts=(hash)
+        hash.each { |name, klass| register(name.to_s, klass) }
+      end
+    end
+  end
+end