solid_objects 0.1.0

data/lib/solid_objects.rb

@@ -0,0 +1,118 @@
+# rbs_inline: enabled
+
+require "active_record"
+require "active_support"
+require "active_support/core_ext/numeric/bytes"
+require "active_support/core_ext/numeric/time"
+require "active_support/isolated_execution_state"
+require "active_support/notifications"
+require "json"
+require "logger"
+require "securerandom"
+
+require "solid_objects/version"
+require "solid_objects/errors"
+require "solid_objects/configuration"
+require "solid_objects/instrumentation"
+require "solid_objects/log_subscriber"
+require "solid_objects/serialization"
+require "solid_objects/context"
+require "solid_objects/actor_registry"
+require "solid_objects/state"
+require "solid_objects/actor_definition"
+require "solid_objects/actor"
+require "solid_objects/reference"
+require "solid_objects/message_reference"
+require "solid_objects/dead_letter_manager"
+require "solid_objects/stream_name"
+require "solid_objects/dom_identity"
+require "solid_objects/stream_token"
+require "solid_objects/turbo_stream_renderer"
+require "solid_objects/actor_snapshot"
+require "solid_objects/actor_view"
+require "solid_objects/action_cable_broadcast_adapter"
+require "solid_objects/wake_up"
+require "solid_objects/effect_registry"
+require "solid_objects/lease"
+require "solid_objects/lease_renewer"
+require "solid_objects/worker"
+require "solid_objects/effect_executor"
+require "solid_objects/reminder_scheduler"
+require "solid_objects/broadcast_executor"
+require "solid_objects/supervisor"
+require "solid_objects/engine" if defined?(Rails::Engine)
+
+module SolidObjects
+  extend Instrumentation
+
+  class << self
+    # @rbs () -> Configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # @rbs () { (Configuration) -> void } -> Configuration
+    def configure
+      yield configuration
+      configuration.validate!
+    end
+
+    # @rbs () -> ActorRegistry
+    def registry
+      @registry ||= ActorRegistry.new
+    end
+
+    # @rbs () -> EffectRegistry
+    def effect_registry
+      @effect_registry ||= EffectRegistry.new
+    end
+
+    # @rbs (String | Symbol) { (Hash[String, untyped], EffectContext) -> untyped } -> Proc
+    def register_effect(name, &handler)
+      effect_registry.register(name, handler)
+    end
+
+    # @rbs () -> Client
+    def client
+      require "solid_objects/client"
+      @client ||= Client.new
+    end
+
+    # @rbs () -> DeadLetterManager
+    def dead_letters
+      @dead_letters ||= DeadLetterManager.new
+    end
+
+    # @rbs (String | Symbol) -> String
+    def table_name(name)
+      "#{configuration.table_name_prefix}#{name}"
+    end
+
+    # @rbs (String, Class) -> Class
+    def register_actor(type, actor_class)
+      registry.register(type, actor_class)
+    end
+
+    # @rbs () -> void
+    def reset!
+      @configuration = Configuration.new
+      @registry = ActorRegistry.new
+      @client = nil
+      @database_adapter = nil
+      @wake_up = nil
+      @effect_registry = EffectRegistry.new
+      @dead_letters = nil
+    end
+
+    # @rbs () -> DatabaseAdapter
+    def database_adapter
+      require "solid_objects/database_adapter"
+      @database_adapter ||= DatabaseAdapter.for(SolidObjects::Record.connection)
+    end
+
+    # @rbs () -> WakeUp
+    def wake_up
+      @wake_up ||= configuration.wake_up_adapter || WakeUp.new
+    end
+  end
+end

data/sig/generated/controllers/solid_objects/application_controller.rbs

@@ -0,0 +1,10 @@
+# Generated from app/controllers/solid_objects/application_controller.rb with RBS::Inline
+
+module SolidObjects
+  class ApplicationController < ActionController::Base
+    private
+
+    # @rbs () -> void
+    def authorize_administration!: () -> void
+  end
+end

data/sig/generated/controllers/solid_objects/dead_letters_controller.rbs

@@ -0,0 +1,11 @@
+# Generated from app/controllers/solid_objects/dead_letters_controller.rb with RBS::Inline
+
+module SolidObjects
+  class DeadLettersController < ApplicationController
+    # @rbs () -> void
+    def index: () -> void
+
+    # @rbs () -> void
+    def retry: () -> void
+  end
+end

data/sig/generated/controllers/solid_objects/instances_controller.rbs

@@ -0,0 +1,11 @@
+# Generated from app/controllers/solid_objects/instances_controller.rb with RBS::Inline
+
+module SolidObjects
+  class InstancesController < ApplicationController
+    # @rbs () -> void
+    def index: () -> void
+
+    # @rbs () -> void
+    def show: () -> void
+  end
+end

data/sig/generated/helpers/solid_objects/actor_helper.rbs

@@ -0,0 +1,8 @@
+# Generated from app/helpers/solid_objects/actor_helper.rb with RBS::Inline
+
+module SolidObjects
+  module ActorHelper
+    # @rbs (Reference, ?authorization_context: untyped) { (ActorView) -> untyped } -> untyped
+    def solid_object: (Reference, ?authorization_context: untyped) { (ActorView) -> untyped } -> untyped
+  end
+end

data/sig/generated/lib/generators/solid_objects/install_generator.rbs

@@ -0,0 +1,13 @@
+# Generated from lib/generators/solid_objects/install_generator.rb with RBS::Inline
+
+module SolidObjects
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      # @rbs () -> void
+      def copy_initializer: () -> void
+
+      # @rbs () -> void
+      def copy_migrations: () -> void
+    end
+  end
+end

data/sig/generated/lib/solid_objects/action_cable_broadcast_adapter.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/solid_objects/action_cable_broadcast_adapter.rb with RBS::Inline
+
+module SolidObjects
+  class ActionCableBroadcastAdapter
+    # @rbs (Broadcast) -> void
+    def call: (Broadcast) -> void
+  end
+end

data/sig/generated/lib/solid_objects/activation.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/solid_objects/activation.rb with RBS::Inline
+
+module SolidObjects
+  class Activation
+    @pass_exhausted: bool
+
+    @last_used_at: Float
+
+    @actor: Actor
+
+    @actor_class: Class
+
+    @lease: Lease
+
+    attr_reader lease: untyped
+
+    attr_reader actor: untyped
+
+    # @rbs (lease: Lease) -> void
+    def initialize: (lease: Lease) -> void
+
+    # @rbs () -> Integer
+    def drain: () -> Integer
+
+    # @rbs () -> bool
+    def ready?: () -> bool
+
+    # @rbs () -> bool
+    def pass_exhausted?: () -> bool
+
+    # @rbs () -> bool
+    def idle?: () -> bool
+
+    # @rbs () -> void
+    def renew_lease: () -> void
+
+    # @rbs () -> bool
+    def lease_renewal_due?: () -> bool
+
+    # @rbs () -> void
+    def yield_ready_messages: () -> void
+
+    # @rbs (Hash[String, untyped]) -> void
+    def restore_state: (Hash[String, untyped]) -> void
+
+    # @rbs () -> void
+    def deactivate: () -> void
+
+    private
+
+    attr_reader actor_class: untyped
+
+    # @rbs (Instance) -> Actor
+    def build_actor: (Instance) -> Actor
+
+    # @rbs () -> Message?
+    def claim_next_message: () -> Message?
+
+    # @rbs (Instance) -> void
+    def recover_stale_claim: (Instance) -> void
+
+    # @rbs () -> Float
+    def monotonic_now: () -> Float
+  end
+end

data/sig/generated/lib/solid_objects/activation_manager.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/solid_objects/activation_manager.rb with RBS::Inline
+
+module SolidObjects
+  class ActivationManager
+    @owner_id: String
+
+    @database_adapter: DatabaseAdapter
+
+    # @rbs (owner_id: String, ?database_adapter: DatabaseAdapter) -> void
+    def initialize: (owner_id: String, ?database_adapter: DatabaseAdapter) -> void
+
+    # @rbs () -> Activation?
+    def claim_next: () -> Activation?
+
+    private
+
+    attr_reader owner_id: untyped
+
+    attr_reader database_adapter: untyped
+
+    # @rbs (Time) -> Array[Integer]
+    def candidate_instance_ids: (Time) -> Array[Integer]
+
+    # @rbs (Time) -> Array[Integer]
+    def ready_instance_ids: (Time) -> Array[Integer]
+
+    # @rbs (Time) -> Array[Integer]
+    def claimed_instance_ids: (Time) -> Array[Integer]
+
+    # @rbs (Instance, Time) -> bool
+    def claimable?: (Instance, Time) -> bool
+
+    # @rbs () -> String
+    def available_lease_sql: () -> String
+  end
+end

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

@@ -0,0 +1,183 @@
+# Generated from lib/solid_objects/actor.rb with RBS::Inline
+
+module SolidObjects
+  class Actor
+    class EffectIntent < Data
+      attr_reader name(): untyped
+
+      attr_reader arguments(): untyped
+
+      attr_reader success_message_name(): untyped
+
+      attr_reader failure_message_name(): untyped
+
+      def self.new: (untyped name, untyped arguments, untyped success_message_name, untyped failure_message_name) -> instance
+                  | (name: untyped, arguments: untyped, success_message_name: untyped, failure_message_name: untyped) -> instance
+
+      def self.members: () -> [ :name, :arguments, :success_message_name, :failure_message_name ]
+
+      def members: () -> [ :name, :arguments, :success_message_name, :failure_message_name ]
+    end
+
+    class ReminderIntent < Data
+      attr_reader name(): untyped
+
+      attr_reader at(): untyped
+
+      attr_reader arguments(): untyped
+
+      attr_reader interval_seconds(): untyped
+
+      attr_reader missed_policy(): untyped
+
+      def self.new: (untyped name, untyped at, untyped arguments, untyped interval_seconds, untyped missed_policy) -> instance
+                  | (name: untyped, at: untyped, arguments: untyped, interval_seconds: untyped, missed_policy: untyped) -> instance
+
+      def self.members: () -> [ :name, :at, :arguments, :interval_seconds, :missed_policy ]
+
+      def members: () -> [ :name, :at, :arguments, :interval_seconds, :missed_policy ]
+    end
+
+    class OutboundMessageIntent < Data
+      attr_reader actor_type(): untyped
+
+      attr_reader actor_id(): untyped
+
+      attr_reader message_name(): untyped
+
+      attr_reader arguments(): untyped
+
+      attr_reader available_at(): untyped
+
+      attr_reader idempotency_key(): untyped
+
+      def self.new: (untyped actor_type, untyped actor_id, untyped message_name, untyped arguments, untyped available_at, untyped idempotency_key) -> instance
+                  | (actor_type: untyped, actor_id: untyped, message_name: untyped, arguments: untyped, available_at: untyped, idempotency_key: untyped) -> instance
+
+      def self.members: () -> [ :actor_type, :actor_id, :message_name, :arguments, :available_at, :idempotency_key ]
+
+      def members: () -> [ :actor_type, :actor_id, :message_name, :arguments, :available_at, :idempotency_key ]
+    end
+
+    # @rbs (Class) -> void
+    def self.inherited: (Class) -> void
+
+    # @rbs (?String | Symbol) -> String
+    def self.actor_type: (?String | Symbol) -> String
+
+    # @rbs (Symbol | String, ?default: untyped) -> StateDefinition::Attribute
+    def self.attribute: (Symbol | String, ?default: untyped) -> StateDefinition::Attribute
+
+    # @rbs (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
+    def self.message: (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
+
+    # @rbs (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
+    def self.query: (Symbol | String) { (*untyped, **untyped) -> untyped } -> ActorDefinition::Handler
+
+    # @rbs (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
+    def self.observable: (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
+
+    # @rbs (?Integer) -> Integer
+    def self.state_version: (?Integer) -> Integer
+
+    # @rbs (from: Integer, to: Integer) { (Hash[String, untyped]) -> Hash[String, untyped] } -> ActorDefinition::StateMigration
+    def self.migrate_state: (from: Integer, to: Integer) { (Hash[String, untyped]) -> Hash[String, untyped] } -> ActorDefinition::StateMigration
+
+    # @rbs () { () -> untyped } -> Proc
+    def self.on_activate: () { () -> untyped } -> Proc
+
+    # @rbs () { () -> untyped } -> Proc
+    def self.on_deactivate: () { () -> untyped } -> Proc
+
+    # @rbs (String | Integer) -> Reference
+    def self.ref: (String | Integer) -> Reference
+
+    # @rbs () -> ActorDefinition
+    def self.definition: () -> ActorDefinition
+
+    # @rbs () -> Class
+    def self.ensure_registered!: () -> Class
+
+    # @rbs (Symbol) -> void
+    private def self.method_added: (Symbol) -> void
+
+    # @rbs () -> Hash[Symbol, bool]
+    private def self.generated_attribute_methods: () -> Hash[Symbol, bool]
+
+    # @rbs (Symbol) -> void
+    private def self.ensure_attribute_methods_available!: (Symbol) -> void
+
+    # @rbs () -> String
+    private def self.default_actor_type: () -> String
+
+    @outbound_message_intents: Array[OutboundMessageIntent]
+
+    @reminder_intents: Array[ReminderIntent]
+
+    @effect_intents: Array[EffectIntent]
+
+    @state: State
+
+    @actor_id: String
+
+    attr_reader actor_id: untyped
+
+    attr_reader state: untyped
+
+    # @rbs (actor_id: String, state: State) -> void
+    def initialize: (actor_id: String, state: State) -> void
+
+    # @rbs () -> MessageContext?
+    def current_message: () -> MessageContext?
+
+    # @rbs (Symbol | String, ?on_success: Symbol | String?, ?on_failure: Symbol | String?, **untyped) -> EffectIntent
+    def emit: (Symbol | String, ?on_success: Symbol | String?, ?on_failure: Symbol | String?, **untyped) -> EffectIntent
+
+    # @rbs (Symbol | String, at: Time, ?every: Numeric?, ?missed: Symbol | String, arguments: Hash[Symbol | String, untyped]) -> ReminderIntent
+    def schedule: (Symbol | String, at: Time, arguments: Hash[Symbol | String, untyped], ?every: Numeric?, ?missed: Symbol | String) -> ReminderIntent
+
+    # @rbs (Reference, Symbol | String, ?available_at: Time?, ?idempotency_key: String?, **untyped) -> OutboundMessageIntent
+    def send_to: (Reference, Symbol | String, ?available_at: Time?, ?idempotency_key: String?, **untyped) -> OutboundMessageIntent
+
+    # @rbs (Symbol | String, Hash[String, untyped]) -> untyped
+    def invoke: (Symbol | String, Hash[String, untyped]) -> untyped
+
+    # @rbs () -> Hash[String, untyped]
+    def observable_values: () -> Hash[String, untyped]
+
+    # @rbs () -> void
+    def activate: () -> void
+
+    # @rbs () -> void
+    def deactivate: () -> void
+
+    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
+    def stage_outbound_message: (Reference, Symbol | String, Hash[Symbol | String, untyped], idempotency_key: String?, ?available_at: Time?) -> OutboundMessageIntent
+
+    # @rbs () -> Array[EffectIntent]
+    def drain_effect_intents: () -> Array[EffectIntent]
+
+    # @rbs () -> Array[ReminderIntent]
+    def drain_reminder_intents: () -> Array[ReminderIntent]
+
+    # @rbs () -> Array[OutboundMessageIntent]
+    def drain_outbound_message_intents: () -> Array[OutboundMessageIntent]
+
+    # @rbs () -> void
+    def discard_intents: () -> void
+
+    private
+
+    attr_reader effect_intents: untyped
+
+    attr_reader reminder_intents: untyped
+
+    attr_reader outbound_message_intents: untyped
+
+    # @rbs (Hash[String, untyped]) -> Hash[Symbol, untyped]
+    def keyword_arguments: (Hash[String, untyped]) -> Hash[Symbol, untyped]
+
+    # @rbs (Symbol | String?) -> void
+    def validate_effect_callback!: (Symbol | String?) -> void
+  end
+end

data/sig/generated/lib/solid_objects/actor_channel.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/solid_objects/actor_channel.rb with RBS::Inline
+
+module SolidObjects
+  class ActorChannel < ActionCable::Channel::Base
+    # @rbs () -> void
+    def subscribed: () -> void
+  end
+end

data/sig/generated/lib/solid_objects/actor_definition.rbs

@@ -0,0 +1,117 @@
+# Generated from lib/solid_objects/actor_definition.rb with RBS::Inline
+
+module SolidObjects
+  class ActorDefinition
+    class Handler < Data
+      attr_reader name(): untyped
+
+      attr_reader block(): untyped
+
+      def self.new: (untyped name, untyped block) -> instance
+                  | (name: untyped, block: untyped) -> instance
+
+      def self.members: () -> [ :name, :block ]
+
+      def members: () -> [ :name, :block ]
+    end
+
+    class StateMigration < Data
+      attr_reader from(): untyped
+
+      attr_reader to(): untyped
+
+      attr_reader block(): untyped
+
+      def self.new: (untyped from, untyped to, untyped block) -> instance
+                  | (from: untyped, to: untyped, block: untyped) -> instance
+
+      def self.members: () -> [ :from, :to, :block ]
+
+      def members: () -> [ :from, :to, :block ]
+    end
+
+    @method_messages: Hash[Symbol, bool]
+
+    @attribute_queries: Hash[Symbol, bool]
+
+    @deactivation_hooks: Array[Proc]
+
+    @activation_hooks: Array[Proc]
+
+    @state_migrations: Array[StateMigration]
+
+    @state_version: Integer
+
+    @observables: Hash[Symbol, Handler]
+
+    @queries: Hash[Symbol, Handler]
+
+    @messages: Hash[Symbol, Handler]
+
+    @state_definition: StateDefinition
+
+    attr_reader state_definition: untyped
+
+    attr_reader messages: untyped
+
+    attr_reader queries: untyped
+
+    attr_reader observables: untyped
+
+    attr_reader state_version: untyped
+
+    attr_reader state_migrations: untyped
+
+    attr_reader activation_hooks: untyped
+
+    attr_reader deactivation_hooks: untyped
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs (Symbol | String, default: untyped) -> StateDefinition::Attribute
+    def add_attribute: (Symbol | String, default: untyped) -> StateDefinition::Attribute
+
+    # @rbs (Symbol | String, Proc) -> Handler
+    def add_message: (Symbol | String, Proc) -> Handler
+
+    # @rbs (Symbol | String, Proc) -> Handler
+    def add_query: (Symbol | String, Proc) -> Handler
+
+    # @rbs (Symbol | String, Proc?) -> Handler
+    def add_observable: (Symbol | String, Proc?) -> Handler
+
+    # @rbs (Class) -> ActorDefinition
+    def synchronize_instance_messages: (Class) -> ActorDefinition
+
+    # @rbs (Integer) -> Integer
+    def set_state_version: (Integer) -> Integer
+
+    # @rbs (Integer, Integer, Proc) -> StateMigration
+    def add_state_migration: (Integer, Integer, Proc) -> StateMigration
+
+    # @rbs (Integer, Hash[String, untyped]) -> Hash[String, untyped]
+    def migrate_state: (Integer, Hash[String, untyped]) -> Hash[String, untyped]
+
+    # @rbs () -> ActorDefinition
+    def duplicate: () -> ActorDefinition
+
+    private
+
+    attr_reader attribute_queries: untyped
+
+    attr_reader method_messages: untyped
+
+    # @rbs (Symbol) -> Handler
+    def add_method_message: (Symbol) -> Handler
+
+    # @rbs (Class) -> Array[Symbol]
+    def actor_message_method_names: (Class) -> Array[Symbol]
+
+    # @rbs (Array[Symbol]) -> void
+    def validate_attribute_methods!: (Array[Symbol]) -> void
+
+    # @rbs (Hash[Symbol, Handler], Symbol | String, Proc) -> Handler
+    def add_handler: (Hash[Symbol, Handler], Symbol | String, Proc) -> Handler
+  end
+end

data/sig/generated/lib/solid_objects/actor_registry.rbs

@@ -0,0 +1,36 @@
+# Generated from lib/solid_objects/actor_registry.rb with RBS::Inline
+
+module SolidObjects
+  class ActorRegistry
+    @actors: Hash[String, Class]
+
+    @mutex: Mutex
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs (String | Symbol, Class) -> Class
+    def register: (String | Symbol, Class) -> Class
+
+    # @rbs (String | Symbol) -> Class
+    def fetch: (String | Symbol) -> Class
+
+    # @rbs (String | Symbol) -> bool
+    def registered?: (String | Symbol) -> bool
+
+    # @rbs () -> Hash[String, Class]
+    def to_h: () -> Hash[String, Class]
+
+    private
+
+    attr_reader actors: untyped
+
+    attr_reader mutex: untyped
+
+    # @rbs (String | Symbol) -> String
+    def normalize: (String | Symbol) -> String
+
+    # @rbs (untyped) -> void
+    def validate_actor_class!: (untyped) -> void
+  end
+end

data/sig/generated/lib/solid_objects/actor_snapshot.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/solid_objects/actor_snapshot.rb with RBS::Inline
+
+module SolidObjects
+  class ActorSnapshot
+    @reference: Reference
+
+    @actor_class: Class
+
+    @actor: Actor
+
+    attr_reader reference: untyped
+
+    attr_reader actor_class: untyped
+
+    attr_reader actor: untyped
+
+    # @rbs (Reference) -> void
+    def initialize: (Reference) -> void
+
+    # @rbs () -> Hash[String, untyped]
+    def observable_values: () -> Hash[String, untyped]
+
+    private
+
+    # @rbs () -> Actor
+    def build_actor: () -> Actor
+  end
+end