igniter 0.2.0

data/lib/igniter/runtime/input_validator.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class InputValidator
+      SUPPORTED_TYPES = {
+        integer: Integer,
+        float: Float,
+        numeric: Numeric,
+        string: String,
+        boolean: :boolean,
+        array: Array,
+        hash: Hash,
+        symbol: Symbol
+      }.freeze
+
+      def initialize(compiled_graph)
+        @compiled_graph = compiled_graph
+      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?
+
+          inputs[node.name] = node.default
+        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)
+        return input_node.default if input_node.default?
+        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 supported_type?(input_node.type)
+          raise input_error(input_node, "Unsupported input type '#{input_node.type}' for '#{input_node.name}'")
+        end
+
+        return if type_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 supported_type?(type)
+        SUPPORTED_TYPES.key?(type.to_sym)
+      end
+
+      def type_match?(type, value)
+        matcher = SUPPORTED_TYPES.fetch(type.to_sym)
+        return value == true || value == false if matcher == :boolean
+
+        value.is_a?(matcher)
+      end
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) { |(key, value), memo| memo[key.to_sym] = value }
+      end
+
+      def input_error(input_node, message)
+        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
+          }
+        )
+      end
+    end
+  end
+end

data/lib/igniter/runtime/invalidator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class Invalidator
+      def initialize(execution)
+        @execution = execution
+      end
+
+      def invalidate_from(node_name)
+        queue = @execution.compiled_graph.dependents.fetch(node_name.to_sym, []).dup
+        seen = {}
+
+        until queue.empty?
+          dependent_name = queue.shift
+          next if seen[dependent_name]
+
+          seen[dependent_name] = true
+          dependent_node = @execution.compiled_graph.fetch_node(dependent_name)
+          stale_state = @execution.cache.stale!(dependent_node, invalidated_by: node_name.to_sym)
+
+          if stale_state
+            @execution.events.emit(
+              :node_invalidated,
+              node: dependent_node,
+              status: :stale,
+              payload: { cause: node_name.to_sym }
+            )
+            emit_output_invalidations_for(dependent_node.name, node_name)
+          end
+
+          queue.concat(@execution.compiled_graph.dependents.fetch(dependent_name, []))
+        end
+      end
+
+      private
+
+      def emit_output_invalidations_for(source_name, cause_name)
+        @execution.compiled_graph.outputs.each do |output_node|
+          next unless output_node.source == source_name.to_sym
+
+          @execution.events.emit(
+            :node_invalidated,
+            node: output_node,
+            status: :stale,
+            payload: { cause: cause_name.to_sym }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime/node_state.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class NodeState
+      attr_reader :node, :status, :value, :error, :version, :resolved_at, :invalidated_by
+
+      def initialize(node:, status:, value: nil, error: nil, version: nil, resolved_at: Time.now.utc, invalidated_by: nil)
+        @node = node
+        @status = status
+        @value = value
+        @error = error
+        @version = version
+        @resolved_at = resolved_at
+        @invalidated_by = invalidated_by
+      end
+
+      def stale?
+        status == :stale
+      end
+
+      def succeeded?
+        status == :succeeded
+      end
+
+      def failed?
+        status == :failed
+      end
+    end
+  end
+end

data/lib/igniter/runtime/resolver.rb

@@ -0,0 +1,114 @@
+# 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)
+        cached = @execution.cache.fetch(node.name)
+        return cached if cached && !cached.stale?
+
+        @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)
+                else
+                  raise ResolutionError, "Unsupported node kind: #{node.kind}"
+                end
+
+        @execution.cache.write(state)
+        @execution.events.emit(
+          state.failed? ? :node_failed : :node_succeeded,
+          node: node,
+          status: state.status,
+          payload: success_payload(node, 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_compute(node)
+        dependencies = node.dependencies.each_with_object({}) do |dependency_name, memo|
+          dependency_state = resolve(dependency_name)
+          raise dependency_state.error if dependency_state.failed?
+
+          memo[dependency_name] = dependency_state.value
+        end
+
+        value = call_compute(node.callable, dependencies)
+        NodeState.new(node: node, status: :succeeded, value: value)
+      end
+
+      def call_compute(callable, dependencies)
+        case callable
+        when Proc
+          callable.call(**dependencies)
+        when Symbol, String
+          @execution.contract_instance.public_send(callable.to_sym, **dependencies)
+        else
+          raise ResolutionError, "Unsupported callable: #{callable.class}"
+        end
+      end
+
+      def resolve_composition(node)
+        child_inputs = node.input_mapping.each_with_object({}) do |(child_input_name, dependency_name), memo|
+          dependency_state = resolve(dependency_name)
+          raise dependency_state.error if dependency_state.failed?
+
+          memo[child_input_name] = dependency_state.value
+        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 success_payload(node, state)
+        return {} unless node.kind == :composition
+        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
+          }
+        )
+      end
+    end
+  end
+end

data/lib/igniter/runtime/result.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Runtime
+    class Result
+      attr_reader :execution
+
+      def initialize(execution)
+        @execution = execution
+        define_output_readers!
+      end
+
+      def to_h
+        @execution.compiled_graph.outputs.each_with_object({}) do |output_node, memo|
+          memo[output_node.name] = serialize_output_value(public_send(output_node.name))
+        end
+      end
+
+      def success?
+        @execution.resolve_all
+        !failed?
+      end
+
+      def failed?
+        @execution.resolve_all
+        @execution.cache.values.any?(&:failed?)
+      end
+
+      def errors
+        @execution.resolve_all
+        @execution.cache.values.each_with_object({}) do |state, memo|
+          next unless state.failed?
+
+          memo[state.node.name] = state.error
+        end
+      end
+
+      def states
+        @execution.resolve_all
+        @execution.states
+      end
+
+      def explain(output_name)
+        @execution.resolve_output(output_name)
+        @execution.explain_output(output_name)
+      end
+
+      def as_json(*)
+        @execution.resolve_all
+
+        {
+          graph: @execution.compiled_graph.name,
+          execution_id: @execution.events.execution_id,
+          outputs: to_h,
+          success: !failed?,
+          failed: failed?,
+          errors: serialize_errors(errors),
+          states: states
+        }
+      end
+
+      private
+
+      def define_output_readers!
+        @execution.compiled_graph.outputs.each do |output_node|
+          define_singleton_method(output_node.name) do
+            @execution.resolve_output(output_node.name)
+          end
+        end
+      end
+
+      def serialize_value(value)
+        case value
+        when Result
+          value.as_json
+        when Array
+          value.map { |item| serialize_value(item) }
+        else
+          value
+        end
+      end
+
+      def serialize_output_value(value)
+        case value
+        when Result
+          value.to_h
+        when Array
+          value.map { |item| serialize_output_value(item) }
+        else
+          value
+        end
+      end
+
+      def serialize_errors(error_hash)
+        error_hash.each_with_object({}) do |(node_name, error), memo|
+          memo[node_name] = {
+            type: error.class.name,
+            message: error.message,
+            context: error.respond_to?(:context) ? error.context : {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/igniter/runtime.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "runtime/node_state"
+require_relative "runtime/cache"
+require_relative "runtime/input_validator"
+require_relative "runtime/resolver"
+require_relative "runtime/invalidator"
+require_relative "runtime/result"
+require_relative "runtime/execution"
+
+module Igniter
+  module Runtime
+  end
+end

data/lib/igniter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Igniter
+  VERSION = "0.2.0"
+end

data/lib/igniter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "igniter/version"
+require_relative "igniter/errors"
+require_relative "igniter/model"
+require_relative "igniter/compiler"
+require_relative "igniter/events"
+require_relative "igniter/runtime"
+require_relative "igniter/dsl"
+require_relative "igniter/extensions"
+require_relative "igniter/diagnostics"
+require_relative "igniter/contract"
+
+module Igniter
+  class << self
+    def compile(&block)
+      DSL::ContractBuilder.compile(&block)
+    end
+  end
+end

data/sig/igniter.rbs

@@ -0,0 +1,4 @@
+module Igniter
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: igniter
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Alexander
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Igniter provides a contract DSL, graph compiler, runtime execution engine,
+  auditing, reactivity, and introspection for business logic expressed as dependency
+  graphs.
+email:
+- alexander.s.fokin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- docs/API_V2.md
+- docs/ARCHITECTURE_V2.md
+- docs/EXECUTION_MODEL_V2.md
+- docs/IGNITER_CONCEPTS.md
+- examples/README.md
+- examples/basic_pricing.rb
+- examples/composition.rb
+- examples/diagnostics.rb
+- lib/igniter.rb
+- lib/igniter/compiler.rb
+- lib/igniter/compiler/compiled_graph.rb
+- lib/igniter/compiler/graph_compiler.rb
+- lib/igniter/compiler/validator.rb
+- lib/igniter/contract.rb
+- lib/igniter/diagnostics.rb
+- lib/igniter/diagnostics/report.rb
+- lib/igniter/dsl.rb
+- lib/igniter/dsl/contract_builder.rb
+- lib/igniter/errors.rb
+- lib/igniter/events.rb
+- lib/igniter/events/bus.rb
+- lib/igniter/events/event.rb
+- lib/igniter/extensions.rb
+- lib/igniter/extensions/auditing.rb
+- lib/igniter/extensions/auditing/timeline.rb
+- lib/igniter/extensions/introspection.rb
+- lib/igniter/extensions/introspection/graph_formatter.rb
+- lib/igniter/extensions/introspection/runtime_formatter.rb
+- lib/igniter/extensions/reactive.rb
+- lib/igniter/extensions/reactive/engine.rb
+- lib/igniter/extensions/reactive/matcher.rb
+- lib/igniter/extensions/reactive/reaction.rb
+- lib/igniter/model.rb
+- lib/igniter/model/composition_node.rb
+- lib/igniter/model/compute_node.rb
+- lib/igniter/model/graph.rb
+- lib/igniter/model/input_node.rb
+- lib/igniter/model/node.rb
+- lib/igniter/model/output_node.rb
+- lib/igniter/runtime.rb
+- lib/igniter/runtime/cache.rb
+- lib/igniter/runtime/execution.rb
+- lib/igniter/runtime/input_validator.rb
+- lib/igniter/runtime/invalidator.rb
+- lib/igniter/runtime/node_state.rb
+- lib/igniter/runtime/resolver.rb
+- lib/igniter/runtime/result.rb
+- lib/igniter/version.rb
+- sig/igniter.rbs
+homepage: https://github.com/alexander-s-f/igniter
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/alexander-s-f/igniter
+  source_code_uri: https://github.com/alexander-s-f/igniter
+  changelog_uri: https://github.com/alexander-s-f/igniter/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Declarative dependency-graph runtime for business logic
+test_files: []