igniter 0.3.1 → 0.4.0

data/lib/igniter/integrations/rails/generators/install/install_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Igniter
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        source_root File.expand_path("templates", __dir__)
+        desc "Creates an Igniter initializer in your application."
+
+        def copy_initializer
+          template "igniter.rb.tt", "config/initializers/igniter.rb"
+        end
+
+        def create_contracts_directory
+          empty_directory "app/contracts"
+          create_file "app/contracts/.keep"
+        end
+
+        def show_readme
+          say "", :green
+          say "✓ Igniter installed!", :green
+          say ""
+          say "Next steps:"
+          say "  1. Configure your store in config/initializers/igniter.rb"
+          say "  2. Generate a contract: rails g igniter:contract YourContractName"
+          say ""
+        end
+      end
+    end
+  end
+end

data/lib/igniter/integrations/rails/railtie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "igniter.configure_store" do
+        # Auto-configure store based on available adapters unless already set
+        next if Igniter.instance_variable_defined?(:@execution_store)
+
+        Igniter.execution_store =
+          if defined?(Redis) && ::Rails.application.config.respond_to?(:redis)
+            Igniter::Runtime::Stores::RedisStore.new(::Redis.current)
+          else
+            Igniter::Runtime::Stores::MemoryStore.new
+          end
+      end
+
+      initializer "igniter.load_contracts" do
+        ::Rails.autoloaders.main.on_load("ApplicationContract") do
+          # Hook point for future eager loading of compiled contracts
+        end
+      end
+    end
+  end
+end

data/lib/igniter/integrations/rails/webhook_concern.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Rails
+    # Controller mixin for delivering external events to running contracts.
+    #
+    # Usage:
+    #   class WebhooksController < ApplicationController
+    #     include Igniter::Rails::WebhookHandler
+    #
+    #     def stripe
+    #       deliver_event_for(
+    #         OrderContract,
+    #         event:            :stripe_payment_succeeded,
+    #         correlation_from: { order_id: params[:metadata][:order_id] },
+    #         payload:          params.to_unsafe_h
+    #       )
+    #     end
+    #   end
+    module WebhookHandler
+      def deliver_event_for(contract_class, event:, correlation_from:, payload: nil, store: nil) # rubocop:disable Metrics/MethodLength
+        payload_data = payload || (respond_to?(:params) ? params.to_unsafe_h : {})
+        correlation = extract_correlation(correlation_from)
+
+        contract_class.deliver_event(
+          event,
+          correlation: correlation,
+          payload: payload_data,
+          store: store || Igniter.execution_store
+        )
+
+        head :ok
+      rescue Igniter::ResolutionError => e
+        render json: { error: e.message }, status: :unprocessable_entity
+      end
+
+      private
+
+      def extract_correlation(source)
+        case source
+        when Hash then source.transform_keys(&:to_sym)
+        when Symbol then { source => params[source] }
+        when Array then source.each_with_object({}) { |k, h| h[k.to_sym] = params[k] }
+        else source.to_h.transform_keys(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/igniter/integrations/rails.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "igniter"
+require_relative "rails/railtie" if defined?(::Rails::Railtie)
+require_relative "rails/contract_job"
+require_relative "rails/webhook_concern"
+require_relative "rails/cable_adapter"
+
+module Igniter
+  module Rails
+  end
+end

data/lib/igniter/model/await_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Model
+    class AwaitNode < Node
+      attr_reader :event_name
+
+      def initialize(id:, name:, event_name:, path: nil, metadata: {})
+        super(
+          id: id,
+          kind: :await,
+          name: name,
+          path: path || name.to_s,
+          dependencies: [],
+          metadata: metadata
+        )
+        @event_name = event_name.to_sym
+      end
+    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)
@@ -310,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

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