statesman-solid_objects 0.1.0

data/lib/statesman/solid_objects/execution.rb

@@ -0,0 +1,95 @@
+# rbs_inline: enabled
+
+module Statesman
+  module SolidObjects
+    class Execution
+      # @rbs @arguments: Hash[String, untyped]
+      # @rbs @context: untyped
+      # @rbs @definition: Registration
+      # @rbs @parent: untyped
+      # @rbs @write_started: bool
+
+      # @rbs () -> Execution?
+      def self.current
+        ActiveSupport::IsolatedExecutionState[:statesman_solid_objects_execution]
+      end
+
+      # @rbs (Hash[String, untyped], untyped) -> void
+      def initialize(arguments, context)
+        @arguments = arguments
+        @context = context
+        @definition = SolidObjects.registrations.fetch(arguments.fetch("registration"))
+        @parent = @definition.parent_class.find(arguments.fetch("parent_id"))
+        @write_started = false
+      end
+
+      # @rbs () -> void
+      def call
+        within do
+          machine = definition.machine(parent)
+          if arguments.fetch("operation") == "initialize_state"
+            persist(machine, "", definition.machine_class.initial_state, {})
+          else
+            machine.transition_to!(arguments.fetch("to"), arguments.fetch("metadata"))
+          end
+        end
+      rescue Statesman::TransitionFailedError, Statesman::GuardFailedError => error
+        code = error.is_a?(Statesman::GuardFailedError) ? "guard_failed" : "transition_failed"
+        raise ::SolidObjects::Rejected.new(code:, message: error.message, details: { from: error.from, to: error.to })
+      end
+
+      # @rbs () -> nil
+      def after_commit
+        within do
+          transition = definition.history(parent).find_by!(sort_key: arguments.fetch("sort_key"))
+          definition.machine(parent).execute(:after_commit, arguments.fetch("from"), transition.to_state, transition)
+        end
+        nil
+      end
+
+      # @rbs (Registration, untyped) -> bool
+      def matches?(registration, record)
+        registration == definition && record.instance_of?(parent.class) && record.id == parent.id
+      end
+
+      # @rbs (untyped, String, String, Hash[untyped, untyped]) -> untyped
+      def persist(observer, from, to, metadata)
+        unless !@write_started && context.is_a?(::SolidObjects::CommitActionContext) && ActiveRecord::Base.connection.transaction_open?
+          raise ArgumentError, "callback transitions require a new actor message"
+        end
+        @write_started = true
+
+        transition = definition.history(parent).build(
+          to_state: to, metadata:, sort_key: arguments.fetch("sort_key"), most_recent: true
+        )
+        observer.execute(:before, from, to, transition)
+        previous_value = definition.transition_class.columns_hash.fetch("most_recent").null ? nil : false
+        definition.history(parent).where(most_recent: true).update_all(most_recent: previous_value)
+        transition.save!
+        observer.execute(:after, from, to, transition)
+        return transition if definition.after_commit == :effect
+
+        connection = ActiveRecord::Base.connection
+        connection.add_transaction_record(
+          Statesman::Adapters::ActiveRecordAfterCommitWrap.new(connection) do
+            within { observer.execute(:after_commit, from, to, transition) }
+          end
+        )
+        transition
+      end
+
+      private
+
+      attr_reader :arguments, :context, :definition, :parent
+
+      # @rbs () { () -> untyped } -> untyped
+      def within
+        previous = self.class.current
+        ActiveSupport::IsolatedExecutionState[:statesman_solid_objects_execution] = self
+        yield
+      ensure
+        ActiveSupport::IsolatedExecutionState[:statesman_solid_objects_execution] = previous
+      end
+    end
+  end
+end

data/lib/statesman/solid_objects/registration.rb

@@ -0,0 +1,53 @@
+# rbs_inline: enabled
+
+module Statesman
+  module SolidObjects
+    class Registration
+      # @rbs @name: String
+      # @rbs @parent_class: untyped
+      # @rbs @transition_class: untyped
+      # @rbs @machine_class: untyped
+      # @rbs @association: Symbol
+      # @rbs @after_commit: Symbol
+
+      attr_reader :name, :parent_class, :transition_class, :machine_class, :association, :after_commit
+
+      # @rbs (name: String, parent_class: untyped, transition_class: untyped, machine_class: untyped, association: Symbol, ?after_commit: Symbol) -> void
+      def initialize(name:, parent_class:, transition_class:, machine_class:, association:, after_commit: :inline)
+        raise ArgumentError, "after_commit must be :inline or :effect" unless [ :inline, :effect ].include?(after_commit)
+
+        @name = name
+        @parent_class = parent_class
+        @transition_class = transition_class
+        @machine_class = machine_class
+        @association = association
+        @after_commit = after_commit
+        pool = ActiveRecord::Base.connection_pool
+        unless [ parent_class, transition_class, ::SolidObjects::Record ].all? { |model| model.connection_pool.equal?(pool) }
+          raise ArgumentError, "parent, transition, and actor models must use the same connection pool"
+        end
+        freeze
+      end
+
+      # @rbs (untyped) -> String
+      def actor_id(parent)
+        unless parent.is_a?(parent_class) && parent.persisted?
+          raise ArgumentError, "parent must be a persisted #{parent_class.name}"
+        end
+        JSON.generate([ parent_class.base_class.name, parent.id.to_s ])
+      end
+
+      # @rbs (untyped) -> untyped
+      def history(parent)
+        parent.public_send(association).reorder(:sort_key)
+      end
+
+      # @rbs (untyped, ?authorization_context: untyped, **untyped) -> untyped
+      def machine(parent, authorization_context: nil, **options)
+        actor_id(parent)
+        machine_class.new(parent, **options, transition_class:, association_name: association,
+          solid_objects_registration: name, authorization_context:)
+      end
+    end
+  end
+end

data/lib/statesman/solid_objects/version.rb

@@ -0,0 +1,8 @@
+# rbs_inline: enabled
+
+module Statesman
+  module SolidObjects
+    # @rbs VERSION: String
+    VERSION = "0.1.0"
+  end
+end

data/lib/statesman/solid_objects.rb

@@ -0,0 +1,38 @@
+# rbs_inline: enabled
+
+require "solid_objects"
+require "statesman"
+require "statesman/adapters/active_record"
+require_relative "solid_objects/version"
+require_relative "solid_objects/registration"
+require_relative "solid_objects/execution"
+require_relative "solid_objects/actor"
+require_relative "solid_objects/adapter"
+
+module Statesman
+  module SolidObjects
+    # @rbs @registrations: Hash[String, Registration]
+
+    # @rbs () -> Hash[String, Registration]
+    def self.registrations
+      @registrations ||= {}
+    end
+
+    # @rbs (String | Symbol, **untyped) -> Registration
+    def self.register(name, **options)
+      registrations[name.to_s] = Registration.new(name: name.to_s, **options)
+    end
+
+    # @rbs () -> void
+    def self.install
+      ::SolidObjects.registry.register(Actor.actor_type, Actor)
+      ::SolidObjects.register_commit_action(:statesman_transition) do |arguments, context|
+        Execution.new(arguments, context).call
+      end
+      ::SolidObjects.register_effect(:statesman_after_commit) do |arguments, context|
+        Execution.new(arguments, context).after_commit
+      end
+      Statesman.configure { storage_adapter(Adapter) }
+    end
+  end
+end

data/lib/statesman-solid_objects.rb

@@ -0,0 +1,3 @@
+# rbs_inline: enabled
+
+require_relative "statesman/solid_objects"

data/sig/generated/statesman/solid_objects/actor.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/statesman/solid_objects/actor.rb with RBS::Inline
+
+module Statesman
+  module SolidObjects
+    class Actor < ::SolidObjects::Actor
+      # @rbs (registration: String, parent_id: String, to: String, metadata: Hash[String, untyped]) -> Integer
+      def transition: (registration: String, parent_id: String, to: String, metadata: Hash[String, untyped]) -> Integer
+
+      # @rbs (registration: String, parent_id: String) -> Integer
+      def initialize_state: (registration: String, parent_id: String) -> Integer
+
+      private
+
+      # @rbs (Registration, String) -> untyped
+      def parent_for: (Registration, String) -> untyped
+
+      # @rbs (Registration, untyped, String, Hash[String, untyped], from: String, operation: String) -> Integer
+      def stage_transition: (Registration, untyped, String, Hash[String, untyped], from: String, operation: String) -> Integer
+    end
+  end
+end

data/sig/generated/statesman/solid_objects/adapter.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/statesman/solid_objects/adapter.rb with RBS::Inline
+
+module Statesman
+  module SolidObjects
+    class Adapter
+      @transition_class: untyped
+
+      @parent_model: untyped
+
+      @observer: untyped
+
+      @definition: Registration
+
+      @authorization_context: untyped
+
+      attr_reader transition_class: untyped
+
+      attr_reader parent_model: untyped
+
+      # @rbs (untyped, untyped, untyped, ?Hash[Symbol, untyped]) -> void
+      def initialize: (untyped, untyped, untyped, ?Hash[Symbol, untyped]) -> void
+
+      # @rbs (String | Symbol | nil, String | Symbol, ?Hash[untyped, untyped]) -> untyped
+      def create: (String | Symbol | nil, String | Symbol, ?Hash[untyped, untyped]) -> untyped
+
+      # @rbs (?force_reload: bool) -> untyped
+      def last: (?force_reload: bool) -> untyped
+
+      # @rbs (?force_reload: bool) -> Array[untyped]
+      def history: (?force_reload: bool) -> Array[untyped]
+
+      # @rbs () -> nil
+      def reset: () -> nil
+
+      private
+
+      attr_reader definition: untyped
+
+      # @rbs () -> Integer
+      def next_sort_key: () -> Integer
+
+      # @rbs () -> Execution?
+      def execution: () -> Execution?
+
+      # @rbs (String) -> void
+      def authorize_read: (String) -> void
+    end
+  end
+end

data/sig/generated/statesman/solid_objects/execution.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/statesman/solid_objects/execution.rb with RBS::Inline
+
+module Statesman
+  module SolidObjects
+    class Execution
+      @arguments: Hash[String, untyped]
+
+      @context: untyped
+
+      @definition: Registration
+
+      @parent: untyped
+
+      @write_started: bool
+
+      # @rbs () -> Execution?
+      def self.current: () -> Execution?
+
+      # @rbs (Hash[String, untyped], untyped) -> void
+      def initialize: (Hash[String, untyped], untyped) -> void
+
+      # @rbs () -> void
+      def call: () -> void
+
+      # @rbs () -> nil
+      def after_commit: () -> nil
+
+      # @rbs (Registration, untyped) -> bool
+      def matches?: (Registration, untyped) -> bool
+
+      # @rbs (untyped, String, String, Hash[untyped, untyped]) -> untyped
+      def persist: (untyped, String, String, Hash[untyped, untyped]) -> untyped
+
+      private
+
+      attr_reader arguments: untyped
+
+      attr_reader context: untyped
+
+      attr_reader definition: untyped
+
+      attr_reader parent: untyped
+
+      # @rbs () { () -> untyped } -> untyped
+      def within: () { () -> untyped } -> untyped
+    end
+  end
+end

data/sig/generated/statesman/solid_objects/registration.rbs

@@ -0,0 +1,43 @@
+# Generated from lib/statesman/solid_objects/registration.rb with RBS::Inline
+
+module Statesman
+  module SolidObjects
+    class Registration
+      @name: String
+
+      @parent_class: untyped
+
+      @transition_class: untyped
+
+      @machine_class: untyped
+
+      @association: Symbol
+
+      @after_commit: Symbol
+
+      attr_reader name: untyped
+
+      attr_reader parent_class: untyped
+
+      attr_reader transition_class: untyped
+
+      attr_reader machine_class: untyped
+
+      attr_reader association: untyped
+
+      attr_reader after_commit: untyped
+
+      # @rbs (name: String, parent_class: untyped, transition_class: untyped, machine_class: untyped, association: Symbol, ?after_commit: Symbol) -> void
+      def initialize: (name: String, parent_class: untyped, transition_class: untyped, machine_class: untyped, association: Symbol, ?after_commit: Symbol) -> void
+
+      # @rbs (untyped) -> String
+      def actor_id: (untyped) -> String
+
+      # @rbs (untyped) -> untyped
+      def history: (untyped) -> untyped
+
+      # @rbs (untyped, ?authorization_context: untyped, **untyped) -> untyped
+      def machine: (untyped, ?authorization_context: untyped, **untyped) -> untyped
+    end
+  end
+end

data/sig/generated/statesman/solid_objects/version.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/statesman/solid_objects/version.rb with RBS::Inline
+
+module Statesman
+  module SolidObjects
+    # @rbs VERSION: String
+    VERSION: ::String
+  end
+end

data/sig/generated/statesman/solid_objects.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/statesman/solid_objects.rb with RBS::Inline
+
+module Statesman
+  module SolidObjects
+    @registrations: Hash[String, Registration]
+
+    # @rbs () -> Hash[String, Registration]
+    def self.registrations: () -> Hash[String, Registration]
+
+    # @rbs (String | Symbol, **untyped) -> Registration
+    def self.register: (String | Symbol, **untyped) -> Registration
+
+    # @rbs () -> void
+    def self.install: () -> void
+  end
+end

data/sig/generated/statesman-solid_objects.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/statesman-solid_objects.rb with RBS::Inline
+

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: statesman-solid_objects
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Solid Objects contributors
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: solid_objects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+- !ruby/object:Gem::Dependency
+  name: statesman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.3'
+description: A registered-machine Statesman storage adapter backed by Solid Objects
+  mailboxes and transactional Active Record writes.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- docs/compatibility.md
+- docs/core-follow-up-prompt.md
+- docs/design.md
+- docs/findings.md
+- docs/prototype-plan.md
+- docs/release-plan.md
+- docs/releases.md
+- docs/verification.md
+- lib/statesman-solid_objects.rb
+- lib/statesman/solid_objects.rb
+- lib/statesman/solid_objects/actor.rb
+- lib/statesman/solid_objects/adapter.rb
+- lib/statesman/solid_objects/execution.rb
+- lib/statesman/solid_objects/registration.rb
+- lib/statesman/solid_objects/version.rb
+- sig/generated/statesman-solid_objects.rbs
+- sig/generated/statesman/solid_objects.rbs
+- sig/generated/statesman/solid_objects/actor.rbs
+- sig/generated/statesman/solid_objects/adapter.rbs
+- sig/generated/statesman/solid_objects/execution.rbs
+- sig/generated/statesman/solid_objects/registration.rbs
+- sig/generated/statesman/solid_objects/version.rbs
+homepage: https://solidobjects.dev
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Serialized Statesman transitions for Rails
+test_files: []