igniter 0.2.0 → 0.3.0

data/examples/collection_partial_failure.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "igniter"
+
+class TechnicianAvailabilityContract < Igniter::Contract
+  define do
+    input :technician_id
+    input :active
+
+    guard :active_technician, with: :active, eq: true, message: "Technician inactive"
+
+    compute :summary, with: %i[technician_id active_technician] do |technician_id:, active_technician:|
+      active_technician
+      { id: technician_id, status: "available" }
+    end
+
+    output :summary
+  end
+end
+
+class TechnicianAvailabilityBatchContract < Igniter::Contract
+  define do
+    input :technician_inputs, type: :array
+
+    collection :technicians,
+      with: :technician_inputs,
+      each: TechnicianAvailabilityContract,
+      key: :technician_id,
+      mode: :collect
+
+    output :technicians
+  end
+end
+
+contract = TechnicianAvailabilityBatchContract.new(
+  technician_inputs: [
+    { technician_id: 1, active: true },
+    { technician_id: 2, active: false },
+    { technician_id: 3, active: true }
+  ]
+)
+
+result = contract.result.technicians
+
+puts "summary=#{result.summary.inspect}"
+puts "items_summary=#{result.items_summary.inspect}"
+puts "failed_items=#{result.failed_items.inspect}"
+puts "---"
+puts contract.diagnostics_text

data/examples/marketing_ergonomics.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "igniter"
+
+OUTBOX = []
+
+class MarketingQuoteContract < Igniter::Contract
+  define do
+    input :service, type: :string
+    input :zip_code, type: :string
+
+    const :vendor_id, "eLocal"
+
+    scope :routing do
+      map :trade_name, from: :service do |service:|
+        %w[heating cooling ventilation air_conditioning].include?(service.downcase) ? "HVAC" : service
+      end
+    end
+
+    scope :pricing do
+      lookup :trade, with: :trade_name do |trade_name:|
+        { name: trade_name, base_bid: trade_name == "HVAC" ? 45.0 : 25.0 }
+      end
+    end
+
+    namespace :validation do
+      guard :zip_supported, with: :zip_code, in: %w[60601 10001], message: "Unsupported zip"
+    end
+
+    compute :quote, with: %i[vendor_id trade zip_supported zip_code] do |vendor_id:, trade:, zip_supported:, zip_code:|
+      zip_supported
+      {
+        vendor_id: vendor_id,
+        trade: trade[:name],
+        zip_code: zip_code,
+        bid: trade[:base_bid]
+      }
+    end
+
+    expose :quote, as: :response
+  end
+
+  on_success :response do |value:, **|
+    OUTBOX << {
+      vendor_id: value[:vendor_id],
+      zip_code: value[:zip_code]
+    }
+  end
+end
+
+contract = MarketingQuoteContract.new(service: "heating", zip_code: "60601")
+
+puts contract.explain_plan
+puts "---"
+puts "response=#{contract.result.response.inspect}"
+puts "outbox=#{OUTBOX.inspect}"

data/examples/ringcentral_routing.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+require "igniter"
+require "pp"
+
+class InboundCallContract < Igniter::Contract
+  define do
+    input :session_id, type: :string
+    input :direction, type: :string
+    input :from, type: :string
+    input :to, type: :string
+    input :start_time, type: :string
+
+    compute :summary, with: %i[session_id from to start_time] do |session_id:, from:, to:, start_time:|
+      {
+        session_id: session_id,
+        direction: "Inbound",
+        customer_phone: from,
+        lookup_phone: from,
+        dialed_phone: to,
+        started_at: start_time
+      }
+    end
+
+    output :summary
+  end
+end
+
+class OutboundCallContract < Igniter::Contract
+  define do
+    input :session_id, type: :string
+    input :direction, type: :string
+    input :from, type: :string
+    input :to, type: :string
+    input :start_time, type: :string
+
+    compute :summary, with: %i[session_id from to start_time] do |session_id:, from:, to:, start_time:|
+      {
+        session_id: session_id,
+        direction: "Outbound",
+        customer_phone: to,
+        lookup_phone: to,
+        operator_phone: from,
+        started_at: start_time
+      }
+    end
+
+    output :summary
+  end
+end
+
+class UnknownDirectionContract < Igniter::Contract
+  define do
+    input :session_id, type: :string
+    input :direction, type: :string
+    input :from, type: :string
+    input :to, type: :string
+    input :start_time, type: :string
+
+    compute :summary, with: %i[session_id direction] do |session_id:, direction:|
+      {
+        session_id: session_id,
+        direction: direction,
+        ignored: true
+      }
+    end
+
+    output :summary
+  end
+end
+
+class CallEventContract < Igniter::Contract
+  define do
+    input :session_id, type: :string
+    input :direction, type: :string
+    input :from, type: :string
+    input :to, type: :string
+    input :start_time, type: :string
+
+    branch :call_context, with: :direction, inputs: {
+      session_id: :session_id,
+      direction: :direction,
+      from: :from,
+      to: :to,
+      start_time: :start_time
+    } do
+      on "Inbound", contract: InboundCallContract
+      on "Outbound", contract: OutboundCallContract
+      default contract: UnknownDirectionContract
+    end
+
+    export :summary, from: :call_context
+  end
+end
+
+class CallConnectedContract < Igniter::Contract
+  define do
+    input :extension_id, type: :integer
+    input :active_calls, type: :array
+    input :telephony_status, type: :string
+
+    guard :has_calls, with: :active_calls, message: "No active calls" do |active_calls:|
+      active_calls.any?
+    end
+
+    map :call_inputs, from: :active_calls do |active_calls:|
+      active_calls.map do |call|
+        {
+          session_id: call.fetch("telephonySessionId"),
+          direction: call.fetch("direction"),
+          from: call.fetch("from"),
+          to: call.fetch("to"),
+          start_time: call.fetch("startTime")
+        }
+      end
+    end
+
+    collection :calls,
+      with: :call_inputs,
+      each: CallEventContract,
+      key: :session_id,
+      mode: :collect
+
+    compute :call_summaries, with: :calls do |calls:|
+      calls.successes.values.map { |item| item.result.summary }
+    end
+
+    compute :routing_summary, with: %i[calls call_summaries extension_id telephony_status has_calls] do |calls:, call_summaries:, extension_id:, telephony_status:, has_calls:|
+      has_calls
+      {
+        extension_id: extension_id,
+        telephony_status: telephony_status,
+        total_calls: calls.summary[:total],
+        succeeded_calls: calls.summary[:succeeded],
+        failed_calls: calls.summary[:failed],
+        inbound_calls: call_summaries.count { |item| item[:direction] == "Inbound" },
+        outbound_calls: call_summaries.count { |item| item[:direction] == "Outbound" },
+        ignored_calls: call_summaries.count { |item| item[:ignored] }
+      }
+    end
+
+    output :calls
+    output :routing_summary
+  end
+end
+
+class NoCallContract < Igniter::Contract
+  define do
+    input :extension_id, type: :integer
+    input :telephony_status, type: :string
+    input :active_calls, type: :array
+
+    compute :routing_summary, with: %i[extension_id telephony_status] do |extension_id:, telephony_status:|
+      {
+        extension_id: extension_id,
+        telephony_status: telephony_status,
+        clear_operator: true
+      }
+    end
+
+    output :routing_summary
+  end
+end
+
+class RingingContract < Igniter::Contract
+  define do
+    input :extension_id, type: :integer
+    input :telephony_status, type: :string
+    input :active_calls, type: :array
+
+    compute :routing_summary, with: %i[extension_id telephony_status] do |extension_id:, telephony_status:|
+      {
+        extension_id: extension_id,
+        telephony_status: telephony_status,
+        ringing: true
+      }
+    end
+
+    output :routing_summary
+  end
+end
+
+class UnknownStatusContract < Igniter::Contract
+  define do
+    input :extension_id, type: :integer
+    input :telephony_status, type: :string
+    input :active_calls, type: :array
+
+    compute :routing_summary, with: %i[extension_id telephony_status] do |extension_id:, telephony_status:|
+      {
+        extension_id: extension_id,
+        telephony_status: telephony_status,
+        ignored_status: true
+      }
+    end
+
+    output :routing_summary
+  end
+end
+
+class RingcentralWebhookContract < Igniter::Contract
+  define do
+    input :payload
+
+    scope :parse do
+      map :body, from: :payload do |payload:|
+        payload.fetch("body", {})
+      end
+
+      map :telephony_status, from: :body do |body:|
+        body["telephonyStatus"]
+      end
+
+      map :extension_id, from: :body do |body:|
+        body["extensionId"]
+      end
+
+      map :active_calls, from: :body do |body:|
+        body["activeCalls"] || []
+      end
+    end
+
+    branch :status_route, with: :telephony_status, inputs: {
+      extension_id: :extension_id,
+      telephony_status: :telephony_status,
+      active_calls: :active_calls
+    } do
+      on "CallConnected", contract: CallConnectedContract
+      on "NoCall", contract: NoCallContract
+      on "Ringing", contract: RingingContract
+      default contract: UnknownStatusContract
+    end
+
+    export :routing_summary, from: :status_route
+    output :status_route
+  end
+end
+
+payload = {
+  "body" => {
+    "extensionId" => 62872332031,
+    "telephonyStatus" => "CallConnected",
+    "activeCalls" => [
+      {
+        "from" => "+18009066027",
+        "to" => "+16199627154",
+        "direction" => "Outbound",
+        "startTime" => "2024-04-01T16:18:13.553Z",
+        "telephonySessionId" => "s-outbound-1"
+      },
+      {
+        "from" => "+13125550100",
+        "to" => "+18009066027",
+        "direction" => "Inbound",
+        "startTime" => "2024-04-01T16:19:10.000Z",
+        "telephonySessionId" => "s-inbound-2"
+      },
+      {
+        "from" => "+13125550199",
+        "to" => "+18009066027",
+        "direction" => "Parked",
+        "startTime" => "2024-04-01T16:20:00.000Z",
+        "telephonySessionId" => "s-unknown-3"
+      }
+    ]
+  }
+}
+
+contract = RingcentralWebhookContract.new(payload: payload)
+
+puts contract.explain_plan
+puts "---"
+puts "routing_summary=#{contract.result.routing_summary.inspect}"
+puts "status_route_branch=#{contract.events.find { |event| event.type == :branch_selected }.payload[:matched_case]}"
+puts "child_collection_summary=#{contract.result.status_route.calls.summary.inspect}"
+puts "child_diagnostics_status=#{contract.result.status_route.execution.diagnostics.to_h[:status]}"
+pp contract.result.status_route.calls.as_json

data/lib/igniter/compiler/compiled_graph.rb

@@ -38,6 +38,17 @@ module Igniter
         @outputs_by_name.fetch(name.to_sym)
       end
 
+      def output?(name)
+        @outputs_by_name.key?(name.to_sym)
+      end
+
+      def fetch_dependency(name)
+        return fetch_node(name) if node?(name)
+        return fetch_output(name) if output?(name)
+
+        raise KeyError, "Unknown dependency '#{name}'"
+      end
+
       def to_h
         {
           name: name,
@@ -53,6 +64,18 @@ module Igniter
               base[:contract] = node.contract_class.name
               base[:inputs] = node.input_mapping
             end
+            if node.kind == :branch
+              base[:selector] = node.selector_dependency
+              base[:cases] = node.cases.map { |entry| { match: entry[:match], contract: entry[:contract].name } }
+              base[:default_contract] = node.default_contract.name
+              base[:inputs] = node.input_mapping
+            end
+            if node.kind == :collection
+              base[:with] = node.source_dependency
+              base[:each] = node.contract_class.name
+              base[:key] = node.key_name
+              base[:mode] = node.mode
+            end
             base
           end,
           outputs: outputs.map do |output|
@@ -70,6 +93,65 @@ module Igniter
         Extensions::Introspection::GraphFormatter.to_text(self)
       end
 
+      def to_schema
+        {
+          name: name,
+          inputs: nodes.select { |node| node.kind == :input }.map do |node|
+            {
+              name: node.name,
+              type: node.type,
+              required: node.required?,
+              default: (node.default if node.default?),
+              metadata: node.metadata.reject { |key, _| key == :source_location || key == :type || key == :required || key == :default }
+            }.compact
+          end,
+          compositions: nodes.select { |node| node.kind == :composition }.map do |node|
+            {
+              name: node.name,
+              contract: node.contract_class,
+              inputs: node.input_mapping,
+              metadata: node.metadata.reject { |key, _| key == :source_location }
+            }
+          end,
+          branches: nodes.select { |node| node.kind == :branch }.map do |node|
+            {
+              name: node.name,
+              with: node.selector_dependency,
+              inputs: node.input_mapping,
+              cases: node.cases.map { |entry| { on: entry[:match], contract: entry[:contract] } },
+              default: node.default_contract,
+              metadata: node.metadata.reject { |key, _| key == :source_location }
+            }
+          end,
+          collections: nodes.select { |node| node.kind == :collection }.map do |node|
+            {
+              name: node.name,
+              with: node.source_dependency,
+              each: node.contract_class,
+              key: node.key_name,
+              mode: node.mode,
+              metadata: node.metadata.reject { |key, _| key == :source_location }
+            }
+          end,
+          computes: nodes.select { |node| node.kind == :compute }.map do |node|
+            {
+              name: node.name,
+              depends_on: node.dependencies,
+              executor: node.executor_key,
+              call: (node.callable unless node.executor_key),
+              metadata: node.metadata.reject { |key, _| %i[source_location executor_key].include?(key) }
+            }.compact
+          end,
+          outputs: outputs.map do |output|
+            {
+              name: output.name,
+              from: output.source,
+              metadata: output.metadata.reject { |key, _| %i[source_location type].include?(key) }
+            }.compact
+          end
+        }
+      end
+
       def to_mermaid
         Extensions::Introspection::GraphFormatter.to_mermaid(self)
       end

data/lib/igniter/compiler/graph_compiler.rb

@@ -18,6 +18,7 @@ module Igniter
       def call
         validator = Validator.call(@graph)
         @nodes_by_name = validator.runtime_nodes_by_name
+        @outputs_by_name = validator.outputs.each_with_object({}) { |output, memo| memo[output.name] = output }
 
         CompiledGraph.new(
           name: @graph.name,
@@ -36,7 +37,9 @@ module Igniter
 
       def build_dependents
         runtime_nodes.each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |node, memo|
-          node.dependencies.each { |dependency_name| memo[dependency_name] << node.name }
+          node.dependencies.each do |dependency_name|
+            memo[dependency_source_name(dependency_name)] << node.name
+          end
         end
       end
 
@@ -46,10 +49,17 @@ module Igniter
 
       def tsort_each_child(node, &block)
         node.dependencies.each do |dependency_name|
-          block.call(@nodes_by_name.fetch(dependency_name))
+          block.call(@nodes_by_name.fetch(dependency_source_name(dependency_name)))
         end
       end
 
+      def dependency_source_name(dependency_name)
+        output = @outputs_by_name[dependency_name.to_sym]
+        return output.source_root if output
+
+        dependency_name
+      end
+
       def tsort
         super
       rescue TSort::Cyclic => e

data/lib/igniter/compiler/type_resolver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    class TypeResolver
+      def self.call(graph, name)
+        new(graph).call(name)
+      end
+
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def call(name)
+        if @graph.output?(name)
+          resolve_output(@graph.fetch_output(name))
+        else
+          resolve_node(@graph.fetch_node(name))
+        end
+      end
+
+      private
+
+      def resolve_output(output)
+        return output.type if output.type
+
+        if output.composition_output?
+          composition = @graph.fetch_node(output.source_root)
+          child_graph = composition.contract_class.compiled_graph
+          self.class.call(child_graph, output.child_output_name)
+        else
+          resolve_node(@graph.fetch_node(output.source))
+        end
+      end
+
+      def resolve_node(node)
+        case node.kind
+        when :input
+          node.type
+        when :compute
+          node.type
+        when :composition
+          :result
+        when :branch
+          :result
+        when :collection
+          :array
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/igniter/compiler/validation_context.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    class ValidationContext
+      attr_reader :graph, :runtime_nodes_by_name, :outputs_by_name
+
+      def initialize(graph)
+        @graph = graph
+        @runtime_nodes_by_name = {}
+        @outputs_by_name = {}
+      end
+
+      def runtime_nodes
+        @runtime_nodes ||= graph.nodes.reject { |node| node.kind == :output }
+      end
+
+      def outputs
+        @outputs ||= graph.nodes.select { |node| node.kind == :output }
+      end
+
+      def build_indexes!
+        runtime_nodes.each { |node| @runtime_nodes_by_name[node.name] = node }
+        outputs.each { |output| @outputs_by_name[output.name] = output }
+      end
+
+      def dependency_resolvable?(dependency_name)
+        runtime_nodes_by_name.key?(dependency_name.to_sym) || outputs_by_name.key?(dependency_name.to_sym)
+      end
+
+      def node?(name)
+        runtime_nodes_by_name.key?(name.to_sym)
+      end
+
+      def output?(name)
+        outputs_by_name.key?(name.to_sym)
+      end
+
+      def fetch_node(name)
+        runtime_nodes_by_name.fetch(name.to_sym)
+      end
+
+      def fetch_output(name)
+        outputs_by_name.fetch(name.to_sym)
+      end
+
+      def validation_error(node, message)
+        ValidationError.new(
+          message,
+          context: {
+            graph: 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/compiler/validation_pipeline.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Compiler
+    class ValidationPipeline
+      DEFAULT_VALIDATORS = [
+        Validators::UniquenessValidator,
+        Validators::OutputsValidator,
+        Validators::DependenciesValidator,
+        Validators::TypeCompatibilityValidator,
+        Validators::CallableValidator
+      ].freeze
+
+      def self.call(context, validators: DEFAULT_VALIDATORS)
+        new(context, validators: validators).call
+      end
+
+      def initialize(context, validators:)
+        @context = context
+        @validators = validators
+      end
+
+      def call
+        @context.build_indexes!
+        @validators.each { |validator| validator.call(@context) }
+        @context
+      end
+    end
+  end
+end