igniter 0.5.1 → 0.5.2

data/packages/igniter-core/lib/igniter/core/dsl/schema_builder.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module DSL
-    class SchemaBuilder
-      def self.compile(schema, name: nil)
-        new(schema, name: name).compile
-      end
-
-      def initialize(schema, name: nil)
-        @schema = symbolize(schema)
-        @name = name || @schema[:name] || "AnonymousContract"
-      end
-
-      def compile
-        schema = @schema
-
-        ContractBuilder.compile(name: @name) do
-          Array(schema[:inputs]).each do |input_config|
-            config = input_config
-            input(
-              config.fetch(:name),
-              type: config[:type],
-              required: config[:required],
-              default: config.fetch(:default, ContractBuilder::UNDEFINED_INPUT_DEFAULT),
-              **config.fetch(:metadata, {})
-            )
-          end
-
-          Array(schema[:compositions]).each do |composition_config|
-            config = composition_config
-            compose(
-              config.fetch(:name),
-              contract: config.fetch(:contract),
-              inputs: config.fetch(:inputs),
-              **config.fetch(:metadata, {})
-            )
-          end
-
-          Array(schema[:computes]).each do |compute_config|
-            config = compute_config
-            options = {
-              depends_on: Array(config.fetch(:depends_on)).map(&:to_sym)
-            }
-            options[:call] = config[:call] if config.key?(:call)
-            options[:executor] = config[:executor] if config.key?(:executor)
-            compute(config.fetch(:name), **options, **config.fetch(:metadata, {}))
-          end
-
-          Array(schema[:outputs]).each do |output_config|
-            config = output_config
-            output(config.fetch(:name), from: config[:from], **config.fetch(:metadata, {}))
-          end
-        end
-      end
-
-      private
-
-      def symbolize(value)
-        case value
-        when Hash
-          value.each_with_object({}) do |(key, nested), memo|
-            memo[key.to_sym] = symbolize(nested)
-          end
-        when Array
-          value.map { |item| symbolize(item) }
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/dsl.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "dsl/contract_builder"
-require_relative "dsl/schema_builder"
-
-module Igniter
-  module DSL
-  end
-end

data/packages/igniter-core/lib/igniter/core/dto/record.rb

@@ -1,189 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  module DTO
-    class Record
-      UNSET = Object.new
-
-      class << self
-        def field(name, required: false, allow_nil: !required, default: UNSET, coerce: nil, merge: false)
-          local_fields[name.to_sym] = {
-            name: name.to_sym,
-            required: required,
-            allow_nil: allow_nil,
-            default: default,
-            coerce: coerce,
-            merge: merge
-          }.freeze
-
-          attr_reader name unless method_defined?(name)
-        end
-
-        def from_h(attributes)
-          new(**normalize_input_attributes(attributes))
-        end
-
-        def dto_fields
-          inherited_fields.merge(local_fields)
-        end
-
-        def field_names
-          dto_fields.keys.freeze
-        end
-
-        private
-
-        def inherited_fields
-          return {} unless superclass.respond_to?(:dto_fields)
-
-          superclass.dto_fields
-        end
-
-        def local_fields
-          @local_fields ||= {}
-        end
-
-        def normalize_input_attributes(attributes)
-          symbolize_hash(attributes || {})
-        end
-
-        def symbolize_hash(hash)
-          return {} unless hash.is_a?(Hash)
-
-          hash.each_with_object({}) do |(key, value), memo|
-            memo[key.to_sym] = value
-          end
-        end
-
-        def resolve_default(spec)
-          default = spec.fetch(:default, UNSET)
-          return UNSET if default.equal?(UNSET)
-
-          value = default.respond_to?(:call) ? default.call : deep_dup(default)
-          deep_freeze(value)
-        end
-
-        def coerce_field_value(spec, value)
-          coerce = spec[:coerce]
-          return value if coerce.nil?
-
-          case coerce
-          when Symbol
-            send(coerce, value)
-          else
-            coerce.arity == 2 ? coerce.call(value, spec) : coerce.call(value)
-          end
-        end
-
-        def deep_dup(value)
-          case value
-          when Hash
-            value.each_with_object({}) do |(key, nested), memo|
-              memo[deep_dup(key)] = deep_dup(nested)
-            end
-          when Array
-            value.map { |item| deep_dup(item) }
-          else
-            value.dup
-          end
-        rescue TypeError
-          value
-        end
-
-        def deep_freeze(value)
-          case value
-          when Hash
-            value.each do |key, nested|
-              deep_freeze(key)
-              deep_freeze(nested)
-            end
-          when Array
-            value.each { |item| deep_freeze(item) }
-          end
-
-          value.freeze if value.respond_to?(:freeze)
-          value
-        end
-
-        def serialize_value(value)
-          case value
-          when Record
-            value.to_h
-          when Hash
-            value.each_with_object({}) do |(key, nested), memo|
-              memo[key] = serialize_value(nested)
-            end
-          when Array
-            value.map { |item| serialize_value(item) }
-          else
-            value
-          end
-        end
-      end
-
-      def initialize(**attributes)
-        normalized = self.class.send(:normalize_input_attributes, attributes)
-        unknown_keys = normalized.keys - self.class.field_names
-        unless unknown_keys.empty?
-          raise ArgumentError, "#{self.class} received unknown fields: #{unknown_keys.map(&:inspect).join(", ")}"
-        end
-
-        self.class.dto_fields.each do |name, spec|
-          value = if normalized.key?(name)
-                    normalized[name]
-                  else
-                    self.class.send(:resolve_default, spec)
-                  end
-
-          if value.equal?(UNSET)
-            raise ArgumentError, "#{self.class} requires #{name}" if spec[:required]
-
-            value = nil
-          end
-
-          if value.nil?
-            raise ArgumentError, "#{self.class} requires #{name}" unless spec[:allow_nil]
-          else
-            value = self.class.send(:coerce_field_value, spec, value)
-            value = self.class.send(:deep_freeze, value)
-          end
-
-          instance_variable_set(:"@#{name}", value)
-        end
-
-        freeze
-      end
-
-      def with(**overrides)
-        normalized = self.class.send(:normalize_input_attributes, overrides)
-
-        merged = self.class.dto_fields.each_with_object({}) do |(name, spec), memo|
-          current = public_send(name)
-
-          if normalized.key?(name)
-            override = normalized[name]
-            memo[name] =
-              if spec[:merge] && current.respond_to?(:merge) && override.is_a?(Hash)
-                current.merge(override)
-              else
-                override
-              end
-          else
-            memo[name] = current
-          end
-        end
-
-        self.class.new(**merged)
-      end
-
-      def to_h
-        self.class.dto_fields.each_with_object({}) do |(name, _spec), memo|
-          value = public_send(name)
-          memo[name] = self.class.send(:serialize_value, value) unless value.nil?
-        end.freeze
-      end
-
-      alias attributes to_h
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/dto.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "dto/record"
-
-module Igniter
-  module DTO
-  end
-end

data/packages/igniter-core/lib/igniter/core/effect.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "errors"
-require_relative "runtime/deferred_result"
-require_relative "executor"
-
-module Igniter
-  # Base class for side-effect adapters.
-  #
-  # An Effect is a first-class node in the computation graph that encapsulates
-  # an external interaction — database, HTTP call, cache write, queue publish, etc.
-  #
-  # Effects are declared in contracts via the `effect` DSL keyword:
-  #
-  #   class UserRepository < Igniter::Effect
-  #     effect_type :database
-  #     idempotent  false
-  #
-  #     def call(user_id:)
-  #       { id: user_id, name: DB.find(user_id) }
-  #     end
-  #
-  #     compensate do |inputs:, value:|
-  #       DB.delete(value[:id])
-  #     end
-  #   end
-  #
-  #   class MyContract < Igniter::Contract
-  #     define do
-  #       input  :user_id
-  #       effect :user_data, uses: UserRepository, depends_on: :user_id
-  #       output :user_data
-  #     end
-  #   end
-  #
-  # Effects participate fully in the graph:
-  #   - Dependency resolution and topological ordering
-  #   - Execution reports (shown as `effect:database`)
-  #   - Saga compensations (built-in or contract-level)
-  #   - Provenance tracing
-  class Effect < Executor
-    class << self
-      def inherited(subclass)
-        super
-        subclass.instance_variable_set(:@effect_type, @effect_type)
-        subclass.instance_variable_set(:@idempotent, @idempotent || false)
-        subclass.instance_variable_set(:@_built_in_compensation, @_built_in_compensation)
-      end
-
-      # Declares the category of side effect (e.g., :database, :http, :cache).
-      # Shown in execution reports as `effect:<type>`.
-      #
-      # @param value [Symbol, nil] — omit to read current value
-      # @return [Symbol]
-      def effect_type(value = nil)
-        return @effect_type || :generic if value.nil?
-
-        @effect_type = value.to_sym
-      end
-
-      # Marks this effect as idempotent — safe to retry without side effects.
-      # Informational metadata; does not change execution behaviour.
-      #
-      # @param value [Boolean]
-      def idempotent(value = true) # rubocop:disable Style/OptionalBooleanParameter
-        @idempotent = value
-      end
-
-      # @return [Boolean]
-      def idempotent?
-        @idempotent || false
-      end
-
-      # Declares a built-in compensating action for this effect.
-      #
-      # Called automatically during a Saga rollback when this effect succeeded
-      # but a downstream node failed. A contract-level `compensate :node_name`
-      # block takes precedence over the built-in one.
-      #
-      # The block receives:
-      #   inputs: — Hash of the node's dependency values when it ran
-      #   value:  — the value produced by this effect (now being undone)
-      def compensate(&block)
-        raise ArgumentError, "Effect.compensate requires a block" unless block
-
-        @_built_in_compensation = block
-      end
-
-      # @return [Proc, nil]
-      def built_in_compensation
-        @_built_in_compensation
-      end
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/effect_registry.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  # Registry for named effect adapters.
-  #
-  # Allows registering effects by symbolic keys and resolving them in the DSL:
-  #
-  #   Igniter.register_effect(:users_db, UserRepository)
-  #
-  #   # In a contract:
-  #   effect :user_data, uses: :users_db, depends_on: :user_id
-  #
-  # This decouples contracts from concrete adapter classes and enables
-  # environment-specific swaps (e.g. mock adapters in tests):
-  #
-  #   # In spec_helper.rb:
-  #   Igniter.effect_registry.clear
-  #   Igniter.register_effect(:users_db, FakeUserRepository)
-  class EffectRegistry
-    Registration = Struct.new(:key, :adapter_class, :metadata, keyword_init: true)
-
-    def initialize
-      @entries = {}
-    end
-
-    # Register an effect adapter under a symbolic key.
-    #
-    # @param key           [Symbol, String]
-    # @param adapter_class [Class] must be a subclass of Igniter::Effect
-    # @param metadata      [Hash]  optional arbitrary metadata
-    # @return [self]
-    def register(key, adapter_class, **metadata)
-      key = key.to_sym
-      unless adapter_class.is_a?(Class) && adapter_class <= Igniter::Effect
-        raise ArgumentError, "#{adapter_class.inspect} must be a subclass of Igniter::Effect"
-      end
-
-      @entries[key] = Registration.new(key: key, adapter_class: adapter_class, metadata: metadata.freeze)
-      self
-    end
-
-    # Fetch a registration by key.
-    #
-    # @param key [Symbol, String]
-    # @return [Registration]
-    # @raise [KeyError] if not registered
-    def fetch(key)
-      @entries.fetch(key.to_sym) do
-        raise KeyError,
-              "Effect '#{key}' is not registered. " \
-              "Use Igniter.register_effect(:#{key}, AdapterClass) before compiling."
-      end
-    end
-
-    # @param key [Symbol, String]
-    # @return [Boolean]
-    def registered?(key)
-      @entries.key?(key.to_sym)
-    end
-
-    # @return [Array<Registration>]
-    def all
-      @entries.values.freeze
-    end
-
-    # @return [Integer]
-    def size
-      @entries.size
-    end
-
-    # Remove all registrations. Useful in tests.
-    # @return [self]
-    def clear
-      @entries.clear
-      self
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/errors.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Igniter
-  class Error < StandardError
-    attr_reader :context
-
-    def initialize(message = nil, context: {})
-      @context = context.compact.freeze
-      super(format_message(message, @context))
-    end
-
-    def graph
-      context[:graph]
-    end
-
-    def node_id
-      context[:node_id]
-    end
-
-    def node_name
-      context[:node_name]
-    end
-
-    def node_path
-      context[:node_path]
-    end
-
-    def source_location
-      context[:source_location]
-    end
-
-    def execution_id
-      context[:execution_id]
-    end
-
-    private
-
-    def format_message(message, context) # rubocop:disable Metrics/AbcSize
-      details = []
-      details << "graph=#{context[:graph]}" if context[:graph]
-      details << "node=#{context[:node_name]}" if context[:node_name]
-      details << "path=#{context[:node_path]}" if context[:node_path]
-      details << "execution=#{context[:execution_id]}" if context[:execution_id]
-      details << "location=#{context[:source_location]}" if context[:source_location]
-
-      return message if details.empty?
-
-      "#{message} [#{details.join(", ")}]"
-    end
-  end
-
-  class CompileError < Error; end
-  class ValidationError < CompileError; end
-  class CycleError < ValidationError; end
-  class InputError < Error; end
-  class CollectionInputError < Error; end
-  class CollectionKeyError < Error; end
-  class ResolutionError < Error; end
-  class CompositionError < Error; end
-  class BranchSelectionError < Error; end
-
-  class PendingDependencyError < Error
-    attr_reader :deferred_result
-
-    def initialize(deferred_result, message = "Dependency is pending", context: {}, token: nil, source_node: nil, waiting_on: nil, payload: nil)
-      @deferred_result, resolved_message = normalize_pending_deferred(
-        deferred_result,
-        message,
-        token: token,
-        source_node: source_node,
-        waiting_on: waiting_on,
-        payload: payload
-      )
-      super(resolved_message, context: context)
-    end
-
-    private
-
-    def normalize_pending_deferred(deferred_result, message, token:, source_node:, waiting_on:, payload:)
-      deferred_class = defined?(Igniter::Runtime::DeferredResult) ? Igniter::Runtime::DeferredResult : nil
-      return [deferred_result, message] if deferred_class && deferred_result.is_a?(deferred_class)
-
-      built_deferred = deferred_class&.build(
-        token: token,
-        source_node: source_node,
-        waiting_on: waiting_on || source_node,
-        payload: payload || {}
-      )
-
-      [built_deferred || deferred_result, deferred_result]
-    end
-  end
-
-  class InvariantError < Error
-    attr_reader :violations
-
-    def initialize(message = nil, violations: [], context: {})
-      @violations = violations.freeze
-      super(message, context: context)
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/events/bus.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-
-module Igniter
-  module Events
-    class Bus
-      attr_reader :execution_id, :events
-
-      def initialize(execution_id: SecureRandom.uuid)
-        @execution_id = execution_id
-        @events = []
-        @subscribers = []
-      end
-
-      def emit(type, node: nil, status: nil, payload: {})
-        event = Event.new(
-          event_id: SecureRandom.uuid,
-          type: type,
-          execution_id: execution_id,
-          node_id: node&.id,
-          node_name: node&.name,
-          path: node&.path,
-          status: status,
-          payload: payload,
-          timestamp: Time.now.utc
-        )
-
-        @events << event
-        @subscribers.each { |subscriber| subscriber.call(event) }
-        event
-      end
-
-      def subscribe(subscriber = nil, &block)
-        @subscribers << (subscriber || block)
-      end
-
-      def restore!(events:, execution_id: nil)
-        @execution_id = execution_id if execution_id
-        @events = Array(events).map { |event| event.is_a?(Event) ? event : Event.from_h(event) }
-      end
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/events/event.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module Igniter
-  module Events
-    Event = Struct.new(
-      :event_id,
-      :type,
-      :execution_id,
-      :node_id,
-      :node_name,
-      :path,
-      :status,
-      :payload,
-      :timestamp,
-      keyword_init: true
-    ) do
-      def self.from_h(data)
-        new(
-          event_id: value_from(data, :event_id),
-          type: value_from(data, :type).to_sym,
-          execution_id: value_from(data, :execution_id),
-          node_id: value_from(data, :node_id),
-          node_name: value_from(data, :node_name)&.to_sym,
-          path: value_from(data, :path),
-          status: value_from(data, :status)&.to_sym,
-          payload: value_from(data, :payload) || {},
-          timestamp: parse_timestamp(value_from(data, :timestamp))
-        )
-      end
-
-      def to_h
-        {
-          event_id: event_id,
-          type: type,
-          execution_id: execution_id,
-          node_id: node_id,
-          node_name: node_name,
-          path: path,
-          status: status,
-          payload: payload,
-          timestamp: timestamp
-        }
-      end
-
-      def as_json(*)
-        to_h.transform_values { |value| serialize_value(value) }
-      end
-
-      private
-
-      def self.parse_timestamp(value)
-        case value
-        when Time
-          value
-        when String
-          Time.iso8601(value)
-        else
-          value
-        end
-      end
-
-      def self.value_from(data, key)
-        data[key] || data[key.to_s]
-      end
-
-      def serialize_value(value)
-        case value
-        when Time
-          value.iso8601
-        when Hash
-          value.each_with_object({}) { |(key, nested_value), memo| memo[key] = serialize_value(nested_value) }
-        when Array
-          value.map { |item| serialize_value(item) }
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/packages/igniter-core/lib/igniter/core/events.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "events/event"
-require_relative "events/bus"
-
-module Igniter
-  module Events
-  end
-end