dexkit 0.8.0 → 0.10.0

data/lib/dex/test_helpers.rb

@@ -1,148 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "test_log"
+require_relative "operation/test_helpers"
+require_relative "event/test_helpers"
 
 module Dex
-  module TestWrapper
-    @_installed = false
-
-    class << self
-      def install!
-        return if @_installed
-
-        Dex::Operation.prepend(self)
-        @_installed = true
-      end
-
-      def installed?
-        @_installed
-      end
-
-      # Stub registry
-
-      def stubs
-        @_stubs ||= {}
-      end
-
-      def find_stub(klass)
-        stubs[klass]
-      end
-
-      def register_stub(klass, **options)
-        stubs[klass] = options
-      end
-
-      def clear_stub(klass)
-        stubs.delete(klass)
-      end
-
-      def clear_all_stubs!
-        stubs.clear
-      end
-    end
-
-    def call
-      stub = Dex::TestWrapper.find_stub(self.class)
-      return _test_apply_stub(stub) if stub
-
-      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      result = nil
-      err = nil
-
-      begin
-        result = super
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        err = e
-        raise
-      ensure
-        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
-        _test_record_to_log(result, err, duration)
-      end
-
-      result
-    end
-
-    private
-
-    def _test_apply_stub(stub)
-      if stub[:error]
-        err_opts = stub[:error]
-        case err_opts
-        when Symbol
-          raise Dex::Error.new(err_opts)
-        when Hash
-          raise Dex::Error.new(err_opts[:code], err_opts[:message], details: err_opts[:details])
-        end
-      else
-        stub[:returns]
-      end
-    end
-
-    def _test_safe_params
-      respond_to?(:to_h) ? to_h : {}
-    rescue
-      {}
-    end
-
-    def _test_record_to_log(result, err, duration)
-      safe_result = if err
-        dex_err = if err.is_a?(Dex::Error)
-          err
-        else
-          Dex::Error.new(:exception, err.message, details: { exception_class: err.class.name })
-        end
-        Dex::Operation::Err.new(dex_err)
-      else
-        Dex::Operation::Ok.new(result)
-      end
-
-      entry = Dex::TestLog::Entry.new(
-        type: "Operation",
-        name: self.class.name || self.class.to_s,
-        operation_class: self.class,
-        params: _test_safe_params,
-        result: safe_result,
-        duration: duration,
-        caller_location: caller_locations(4, 1)&.first
-      )
-      Dex::TestLog.record(entry)
-    end
-  end
-
   module TestHelpers
-    extend Dex::Concern
-
     def self.included(base)
-      Dex::TestWrapper.install!
-      super
-    end
-
-    def setup
-      super
-      Dex::TestLog.clear!
-      Dex::TestWrapper.clear_all_stubs!
-    end
-
-    module ClassMethods
-      def testing(klass)
-        @_dex_test_subject = klass
-      end
-
-      def _dex_test_subject
-        return @_dex_test_subject if defined?(@_dex_test_subject) && @_dex_test_subject
-
-        superclass._dex_test_subject if superclass.respond_to?(:_dex_test_subject)
-      end
-    end
-
-    private
-
-    def _dex_test_subject
-      self.class._dex_test_subject
+      base.include(Dex::Operation::TestHelpers)
+      base.include(Dex::Event::TestHelpers)
     end
   end
 end
-
-require_relative "test_helpers/execution"
-require_relative "test_helpers/assertions"
-require_relative "test_helpers/stubbing"

data/lib/dex/test_log.rb

@@ -2,7 +2,18 @@
 
 module Dex
   module TestLog
-    Entry = Data.define(:type, :name, :operation_class, :params, :result, :duration, :caller_location)
+    Entry = Data.define(
+      :type,
+      :name,
+      :operation_class,
+      :params,
+      :result,
+      :duration,
+      :caller_location,
+      :execution_id,
+      :trace_id,
+      :trace
+    )
 
     @_entries = []
     @_mutex = Mutex.new
@@ -42,14 +53,61 @@ module Dex
         return "No operations called." if entries.empty?
 
         lines = ["Operations called (#{entries.size}):"]
-        entries.each_with_index do |entry, i|
+        nodes = entries.each_with_index.map { |entry, index| { entry: entry, index: index } }
+        by_id = nodes.to_h { |node| [node[:entry].execution_id, node] }
+        children = Hash.new { |hash, key| hash[key] = [] }
+        roots = []
+
+        nodes.each do |node|
+          parent_id = _parent_operation_id(node[:entry])
+          if parent_id && by_id[parent_id]
+            children[parent_id] << node
+          else
+            roots << node
+          end
+        end
+
+        counter = 0
+        render = lambda do |node, depth|
+          counter += 1
+          entry = node[:entry]
           status = entry.result.ok? ? "OK" : "ERR(#{entry.result.code})"
           duration_ms = entry.duration ? format("%.1fms", entry.duration * 1000) : "n/a"
-          lines << "  #{i + 1}. #{entry.name} [#{status}] #{duration_ms}"
-          lines << "     params: #{entry.params.inspect}" unless entry.params.nil? || entry.params.empty?
+          indent = "   " * depth
+          id = entry.execution_id ? " (#{_display_id(entry.execution_id)})" : ""
+
+          lines << "  #{indent}#{counter}. #{entry.name}#{id} [#{status}] #{duration_ms}"
+          lines << "  #{indent}   params: #{entry.params.inspect}" unless entry.params.nil? || entry.params.empty?
+
+          children.fetch(entry.execution_id, []).sort_by { |child| child[:index] }.each do |child|
+            render.call(child, depth + 1)
+          end
         end
+
+        roots.sort_by { |node| node[:index] }.each { |node| render.call(node, 0) }
         lines.join("\n")
       end
+
+      private
+
+      def _frame_type(frame)
+        return unless frame
+
+        (frame[:type] || frame["type"])&.to_sym
+      end
+
+      def _display_id(id)
+        prefix, suffix = id.to_s.split("_", 2)
+        return id.to_s unless suffix
+
+        "#{prefix}_#{suffix[0, 7]}"
+      end
+
+      def _parent_operation_id(entry)
+        frames = Array(entry.trace)[0...-1]
+        parent = frames.reverse.find { |frame| _frame_type(frame) == :operation }
+        parent && (parent[:id] || parent["id"])
+      end
     end
   end
 end

data/lib/dex/trace.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+module Dex
+  module Trace
+    FIBER_KEY = :_dex_trace
+    FRAME_TYPES = %i[actor operation handler].freeze
+
+    class << self
+      def start(actor: nil, trace_id: nil)
+        previous = _dump_state
+        _set_state(trace_id: (trace_id || Dex::Id.generate("tr_")).to_s, frames: [], event_context: nil)
+        _state[:frames] << _normalize_actor(actor) if actor
+        yield
+      ensure
+        _restore_state(previous)
+      end
+
+      def ensure_started!(trace_id: nil)
+        return false if active?
+
+        _state[:trace_id] = (trace_id || Dex::Id.generate("tr_")).to_s
+        true
+      end
+
+      def active?
+        !trace_id.nil?
+      end
+
+      def with_frame(frame)
+        auto_started = ensure_started!
+        pushed = false
+        push(frame)
+        pushed = true
+        yield
+      ensure
+        pop if pushed
+        stop! if auto_started
+      end
+
+      def with_event_context(event)
+        auto_started = ensure_started!(trace_id: event.trace_id)
+        previous = _state[:event_context]
+        _state[:event_context] = _build_event_context(event)
+        yield
+      ensure
+        _state[:event_context] = previous
+        stop! if auto_started
+      end
+
+      def restore_event_context(event_id:, trace_id:, event_class: nil, event_ancestry: [])
+        previous = _dump_state
+        effective_trace_id = trace_id&.to_s || _state[:trace_id]
+        _set_state(
+          trace_id: effective_trace_id,
+          frames: _normalize_frames(_state[:frames]),
+          event_context: {
+            id: event_id&.to_s,
+            trace_id: effective_trace_id,
+            event_class: event_class,
+            event_ancestry: Array(event_ancestry).compact.map(&:to_s)
+          }
+        )
+        yield
+      ensure
+        _restore_state(previous)
+      end
+
+      def push(frame)
+        _state[:frames] << _normalize_frame(frame)
+      end
+
+      def pop
+        _state[:frames].pop
+      end
+
+      def current
+        _deep_copy(_state[:frames])
+      end
+
+      def trace_id
+        _state[:trace_id]
+      end
+
+      def current_id
+        _state[:frames].last&.dig(:id)
+      end
+
+      def actor
+        frame = _state[:frames].find { |entry| entry[:type] == :actor }
+        frame ? _deep_copy(frame) : nil
+      end
+
+      def current_event_id
+        current_event_context&.dig(:id)
+      end
+
+      def current_event_context
+        context = _state[:event_context]
+        return _deep_copy(context) if context
+
+        handler = _state[:frames].reverse.find { |frame| frame[:type] == :handler && frame[:event_id] }
+        return nil unless handler
+
+        {
+          id: handler[:event_id],
+          trace_id: trace_id,
+          event_class: handler[:event_class],
+          event_ancestry: _deep_copy(Array(handler[:event_ancestry]))
+        }
+      end
+
+      def dump
+        return nil unless active?
+
+        data = {
+          trace_id: trace_id,
+          frames: current
+        }
+        data[:event_context] = _deep_copy(_state[:event_context]) if _state[:event_context]
+        data
+      end
+
+      def restore(data)
+        return yield unless data
+
+        previous = _dump_state
+        _set_state(
+          trace_id: _fetch(data, :trace_id)&.to_s,
+          frames: _normalize_frames(_fetch(data, :frames)),
+          event_context: _normalize_event_context(_fetch(data, :event_context))
+        )
+        yield
+      ensure
+        _restore_state(previous)
+      end
+
+      def to_s
+        current.filter_map { |frame| _format_frame(frame) }.join(" > ")
+      end
+
+      def clear!
+        Fiber[FIBER_KEY] = nil
+      end
+      alias_method :stop!, :clear!
+
+      private
+
+      def _state
+        Fiber[FIBER_KEY] ||= { trace_id: nil, frames: [], event_context: nil }
+      end
+
+      def _set_state(trace_id:, frames:, event_context:)
+        Fiber[FIBER_KEY] = {
+          trace_id: trace_id,
+          frames: frames,
+          event_context: event_context
+        }
+      end
+
+      def _dump_state
+        state = _state
+        return nil unless state[:trace_id] || !state[:frames].empty? || state[:event_context]
+
+        {
+          trace_id: state[:trace_id],
+          frames: _deep_copy(state[:frames]),
+          event_context: _deep_copy(state[:event_context])
+        }
+      end
+
+      def _restore_state(state)
+        if state
+          _set_state(
+            trace_id: state[:trace_id],
+            frames: _normalize_frames(state[:frames]),
+            event_context: _normalize_event_context(state[:event_context])
+          )
+        else
+          clear!
+        end
+      end
+
+      def _normalize_frames(frames)
+        Array(frames).map { |frame| _normalize_frame(frame) }
+      end
+
+      def _normalize_actor(actor)
+        raise ArgumentError, "actor must be a Hash" unless actor.is_a?(Hash)
+
+        normalized = _symbolize(actor)
+        actor_type = normalized[:type]
+        raise ArgumentError, "actor must include :type" if actor_type.nil? || actor_type.to_s.strip.empty?
+
+        frame = { type: :actor, actor_type: actor_type.to_s }
+        frame[:id] = normalized[:id].to_s if normalized.key?(:id) && !normalized[:id].nil?
+
+        normalized.each do |key, value|
+          next if %i[type id].include?(key)
+
+          frame[key] = _deep_copy(value)
+        end
+
+        frame
+      end
+
+      def _normalize_frame(frame)
+        raise ArgumentError, "trace frame must be a Hash" unless frame.is_a?(Hash)
+
+        normalized = _symbolize(frame)
+        type = normalized[:type]&.to_sym
+        raise ArgumentError, "trace frame type is required" unless type
+        raise ArgumentError, "unknown trace frame type: #{type.inspect}" unless FRAME_TYPES.include?(type)
+
+        normalized[:type] = type
+        normalized[:id] = normalized[:id].to_s if normalized.key?(:id) && !normalized[:id].nil?
+        normalized[:actor_type] = normalized[:actor_type].to_s if normalized.key?(:actor_type) && !normalized[:actor_type].nil?
+        normalized[:event_id] = normalized[:event_id].to_s if normalized.key?(:event_id) && !normalized[:event_id].nil?
+        normalized[:event_ancestry] = Array(normalized[:event_ancestry]).compact.map(&:to_s) if normalized.key?(:event_ancestry)
+        normalized
+      end
+
+      def _normalize_event_context(context)
+        return nil unless context
+
+        {
+          id: _fetch(context, :id)&.to_s,
+          trace_id: _fetch(context, :trace_id)&.to_s,
+          event_class: _fetch(context, :event_class),
+          event_ancestry: Array(_fetch(context, :event_ancestry)).compact.map(&:to_s)
+        }
+      end
+
+      def _build_event_context(event)
+        {
+          id: event.id.to_s,
+          trace_id: event.trace_id.to_s,
+          event_class: event.class.name,
+          event_ancestry: Array(event.metadata.event_ancestry).compact.map(&:to_s)
+        }
+      end
+
+      def _symbolize(hash)
+        hash.each_with_object({}) do |(key, value), result|
+          result[key.respond_to?(:to_sym) ? key.to_sym : key] = _deep_copy(value)
+        end
+      end
+
+      def _deep_copy(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, nested), result| result[key] = _deep_copy(nested) }
+        when Array
+          value.map { |nested| _deep_copy(nested) }
+        else
+          value
+        end
+      end
+
+      def _fetch(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+
+      def _format_frame(frame)
+        case frame[:type]
+        when :actor
+          return nil unless frame[:actor_type]
+
+          frame[:id] ? "#{frame[:actor_type]}:#{frame[:id]}" : frame[:actor_type]
+        when :operation
+          name = frame[:class] || "Operation"
+          id = _display_id(frame[:id])
+          id ? "#{name}(#{id})" : name
+        when :handler
+          event_class = frame[:event_class] || "Event"
+          handler_name = frame[:class] || "Handler"
+          id = _display_id(frame[:id])
+          id ? "[#{event_class}] #{handler_name}(#{id})" : "[#{event_class}] #{handler_name}"
+        end
+      end
+
+      def _display_id(id)
+        return nil unless id
+
+        prefix, suffix = id.split("_", 2)
+        return id[0, 10] unless suffix
+
+        "#{prefix}_#{suffix[0, 7]}"
+      end
+    end
+  end
+end

data/lib/dex/type_coercion.rb

@@ -64,7 +64,10 @@ module Dex
         return _serialize_value(type.type, value) if type.is_a?(Literal::Types::NilableType)
 
         ref = _find_ref_type(type)
-        return value.id if ref
+        if ref
+          serialized_id = value.id
+          return serialized_id.respond_to?(:as_json) ? serialized_id.as_json : serialized_id
+        end
 
         value.respond_to?(:as_json) ? value.as_json : value
       end

data/lib/dex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dex
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

data/lib/dexkit.rb

@@ -5,15 +5,12 @@ require "zeitwerk"
 require "literal"
 require "time"
 
-loader = Zeitwerk::Loader.for_gem
-loader.ignore("#{__dir__}/dex")
-loader.setup
-
 require_relative "dex/version"
 require_relative "dex/concern"
 require_relative "dex/ref_type"
 require_relative "dex/type_coercion"
 require_relative "dex/props_setup"
+require_relative "dex/context_dsl"
 require_relative "dex/context_setup"
 require_relative "dex/error"
 require_relative "dex/settings"
@@ -21,6 +18,8 @@ require_relative "dex/pipeline"
 require_relative "dex/executable"
 require_relative "dex/registry"
 require_relative "dex/type_serializer"
+require_relative "dex/id"
+require_relative "dex/trace"
 require_relative "dex/operation"
 require_relative "dex/event"
 require_relative "dex/tool"
@@ -29,7 +28,8 @@ require_relative "dex/query"
 
 module Dex
   class Configuration
-    attr_accessor :record_class, :transaction_adapter, :event_store, :event_context, :restore_event_context
+    attr_accessor :record_class, :event_store, :event_context, :restore_event_context
+    attr_reader :transaction_adapter
 
     def initialize
       @record_class = nil
@@ -38,6 +38,10 @@ module Dex
       @event_context = nil
       @restore_event_context = nil
     end
+
+    def transaction_adapter=(adapter)
+      @transaction_adapter = Operation::TransactionAdapter.normalize_name(adapter)
+    end
   end
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dexkit
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Jacek Galanciak
@@ -161,11 +161,14 @@ files:
 - LICENSE.txt
 - README.md
 - Untitled
+- gemfiles/mongoid_no_ar.gemfile
+- gemfiles/mongoid_no_ar.gemfile.lock
 - guides/llm/EVENT.md
 - guides/llm/FORM.md
 - guides/llm/OPERATION.md
 - guides/llm/QUERY.md
 - lib/dex/concern.rb
+- lib/dex/context_dsl.rb
 - lib/dex/context_setup.rb
 - lib/dex/error.rb
 - lib/dex/event.rb
@@ -176,13 +179,17 @@ files:
 - lib/dex/event/metadata.rb
 - lib/dex/event/processor.rb
 - lib/dex/event/suppression.rb
+- lib/dex/event/test_helpers.rb
+- lib/dex/event/test_helpers/assertions.rb
 - lib/dex/event/trace.rb
 - lib/dex/event_test_helpers.rb
-- lib/dex/event_test_helpers/assertions.rb
 - lib/dex/executable.rb
 - lib/dex/form.rb
+- lib/dex/form/context.rb
+- lib/dex/form/export.rb
 - lib/dex/form/nesting.rb
 - lib/dex/form/uniqueness_validator.rb
+- lib/dex/id.rb
 - lib/dex/match.rb
 - lib/dex/operation.rb
 - lib/dex/operation/async_proxy.rb
@@ -200,12 +207,18 @@ files:
 - lib/dex/operation/rescue_wrapper.rb
 - lib/dex/operation/result_wrapper.rb
 - lib/dex/operation/safe_wrapper.rb
+- lib/dex/operation/test_helpers.rb
+- lib/dex/operation/test_helpers/assertions.rb
+- lib/dex/operation/test_helpers/execution.rb
+- lib/dex/operation/test_helpers/stubbing.rb
+- lib/dex/operation/trace_wrapper.rb
 - lib/dex/operation/transaction_adapter.rb
 - lib/dex/operation/transaction_wrapper.rb
 - lib/dex/pipeline.rb
 - lib/dex/props_setup.rb
 - lib/dex/query.rb
 - lib/dex/query/backend.rb
+- lib/dex/query/export.rb
 - lib/dex/query/filtering.rb
 - lib/dex/query/sorting.rb
 - lib/dex/railtie.rb
@@ -213,11 +226,9 @@ files:
 - lib/dex/registry.rb
 - lib/dex/settings.rb
 - lib/dex/test_helpers.rb
-- lib/dex/test_helpers/assertions.rb
-- lib/dex/test_helpers/execution.rb
-- lib/dex/test_helpers/stubbing.rb
 - lib/dex/test_log.rb
 - lib/dex/tool.rb
+- lib/dex/trace.rb
 - lib/dex/type_coercion.rb
 - lib/dex/type_serializer.rb
 - lib/dex/version.rb