solid_objects 0.1.0

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

@@ -0,0 +1,60 @@
+# Generated from lib/solid_objects/executor.rb with RBS::Inline
+
+module SolidObjects
+  class Executor
+    @message: Message
+
+    @activation: Activation
+
+    # @rbs (activation: Activation, message: Message) -> void
+    def initialize: (activation: Activation, message: Message) -> void
+
+    # @rbs () -> bool
+    def call: () -> bool
+
+    private
+
+    attr_reader activation: untyped
+
+    attr_reader message: untyped
+
+    # @rbs () -> Actor
+    def actor: () -> Actor
+
+    # @rbs (Hash[String, untyped]) -> void
+    def ensure_query_did_not_mutate_state!: (Hash[String, untyped]) -> void
+
+    # @rbs (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
+    def changed_observables: (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
+
+    # @rbs (untyped, Hash[String, untyped]) -> void
+    def complete: (untyped, Hash[String, untyped]) -> void
+
+    # @rbs (Message, Instance, Array[Actor::EffectIntent]) -> Array[Effect]
+    def enqueue_effects: (Message, Instance, Array[Actor::EffectIntent]) -> Array[Effect]
+
+    # @rbs (Instance, Array[Actor::ReminderIntent]) -> void
+    def schedule_reminders: (Instance, Array[Actor::ReminderIntent]) -> void
+
+    # @rbs (Message, Instance, Array[Actor::OutboundMessageIntent]) -> Array[Effect]
+    def enqueue_actor_messages: (Message, Instance, Array[Actor::OutboundMessageIntent]) -> Array[Effect]
+
+    # @rbs (Message, Instance, Hash[String, untyped]) -> void
+    def enqueue_broadcasts: (Message, Instance, Hash[String, untyped]) -> void
+
+    # @rbs (Exception) -> void
+    def fail_message: (Exception) -> void
+
+    # @rbs () -> ClaimedMessage
+    def matching_claim!: () -> ClaimedMessage
+
+    # @rbs (Exception) -> Hash[String, untyped]
+    def serialized_error: (Exception) -> Hash[String, untyped]
+
+    # @rbs (Message, Hash[String, untyped], Time) -> DeadLetter
+    def create_dead_letter: (Message, Hash[String, untyped], Time) -> DeadLetter
+
+    # @rbs () -> Hash[Symbol, untyped]
+    def instrumentation_payload: () -> Hash[Symbol, untyped]
+  end
+end

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

@@ -0,0 +1,8 @@
+# Generated from lib/solid_objects/instrumentation.rb with RBS::Inline
+
+module SolidObjects
+  module Instrumentation
+    # @rbs (Symbol, **untyped) { (Hash[Symbol, untyped]) -> untyped } -> untyped
+    def instrument: (Symbol, **untyped) { (Hash[Symbol, untyped]) -> untyped } -> untyped
+  end
+end

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

@@ -0,0 +1,57 @@
+# Generated from lib/solid_objects/lease.rb with RBS::Inline
+
+module SolidObjects
+  class Lease
+    # @rbs (instance: Instance, owner_id: String, now: Time, ?duration: Numeric, database_adapter: DatabaseAdapter) -> Lease?
+    def self.claim: (instance: Instance, owner_id: String, now: Time, database_adapter: DatabaseAdapter, ?duration: Numeric) -> Lease?
+
+    # @rbs (instance_id: Integer, owner_id: String, ?duration: Numeric, ?database_adapter: DatabaseAdapter) -> Lease?
+    def self.acquire: (instance_id: Integer, owner_id: String, ?duration: Numeric, ?database_adapter: DatabaseAdapter) -> Lease?
+
+    # @rbs (Instance, String, Time) -> bool
+    private def self.held_by_another_live_owner?: (Instance, String, Time) -> bool
+
+    @instance_id: Integer
+
+    @owner_id: String
+
+    @generation: Integer
+
+    @expires_at: Time
+
+    @database_adapter: DatabaseAdapter
+
+    attr_reader instance_id: untyped
+
+    attr_reader owner_id: untyped
+
+    attr_reader generation: untyped
+
+    attr_reader expires_at: untyped
+
+    # @rbs (instance_id: Integer, owner_id: String, generation: Integer, expires_at: Time, database_adapter: DatabaseAdapter) -> void
+    def initialize: (instance_id: Integer, owner_id: String, generation: Integer, expires_at: Time, database_adapter: DatabaseAdapter) -> void
+
+    # @rbs (?duration: Numeric) -> Lease
+    def renew: (?duration: Numeric) -> Lease
+
+    # @rbs () -> bool
+    def release: () -> bool
+
+    # @rbs () { (Instance) -> untyped } -> untyped
+    def fenced_transaction: () { (Instance) -> untyped } -> untyped
+
+    private
+
+    attr_reader database_adapter: untyped
+
+    # @rbs () -> Instance
+    def locked_owned_instance!: () -> Instance
+
+    # @rbs (Instance) -> bool
+    def owned_generation?: (Instance) -> bool
+
+    # @rbs (Instance, Time) -> void
+    def verify_unexpired!: (Instance, Time) -> void
+  end
+end

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

@@ -0,0 +1,42 @@
+# Generated from lib/solid_objects/lease_renewer.rb with RBS::Inline
+
+module SolidObjects
+  class LeaseRenewer
+    @activation: Activation
+
+    @process_registry: ProcessRegistry
+
+    @mutex: Thread::Mutex
+
+    @condition: Thread::ConditionVariable
+
+    @stopped: bool
+
+    @thread: Thread?
+
+    # @rbs (activation: Activation, process_registry: ProcessRegistry) -> void
+    def initialize: (activation: Activation, process_registry: ProcessRegistry) -> void
+
+    # @rbs () { () -> untyped } -> untyped
+    def around: () { () -> untyped } -> untyped
+
+    private
+
+    attr_reader activation: untyped
+
+    attr_reader process_registry: untyped
+
+    attr_reader mutex: untyped
+
+    attr_reader condition: untyped
+
+    # @rbs () -> void
+    def start: () -> void
+
+    # @rbs () -> bool
+    def wait_for_interval: () -> bool
+
+    # @rbs () -> void
+    def stop: () -> void
+  end
+end

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

@@ -0,0 +1,11 @@
+# Generated from lib/solid_objects/log_subscriber.rb with RBS::Inline
+
+module SolidObjects
+  module LogSubscriber
+    # @rbs () -> void
+    def self.install: () -> void
+
+    # @rbs () -> void
+    def self.uninstall: () -> void
+  end
+end

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

@@ -0,0 +1,46 @@
+# Generated from lib/solid_objects/mailbox.rb with RBS::Inline
+
+module SolidObjects
+  class Mailbox
+    INSTANCE_RETRY_LIMIT: ::Integer
+
+    @database_adapter: DatabaseAdapter
+
+    # @rbs (?database_adapter: DatabaseAdapter) -> void
+    def initialize: (?database_adapter: DatabaseAdapter) -> void
+
+    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, ?available_at: Time?, idempotency_key: String?) -> MessageReference
+    def enqueue: (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, idempotency_key: String?, ?available_at: Time?) -> MessageReference
+
+    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, ?available_at: Time?, idempotency_key: String?, ?actor_class: Class?) -> Message
+    def enqueue_in_transaction: (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, idempotency_key: String?, ?available_at: Time?, ?actor_class: Class?) -> Message
+
+    # @rbs (Message) -> void
+    def announce: (Message) -> void
+
+    private
+
+    attr_reader database_adapter: untyped
+
+    # @rbs () { () -> Message } -> Message
+    def with_instance_retry: () { () -> Message } -> Message
+
+    # @rbs (Reference, Class) -> Instance
+    def find_or_create_instance: (Reference, Class) -> Instance
+
+    # @rbs (Instance, String?) -> Message?
+    def find_idempotent_message: (Instance, String?) -> Message?
+
+    # @rbs (Message, Symbol | String, String, untyped) -> Message
+    def validate_idempotent_message!: (Message, Symbol | String, String, untyped) -> Message
+
+    # @rbs (Instance) -> void
+    def enforce_mailbox_limit!: (Instance) -> void
+
+    # @rbs (Instance, Reference, Symbol | String, untyped, kind: String, available_at: Time?, idempotency_key: String?) -> Message
+    def create_message: (Instance, Reference, Symbol | String, untyped, kind: String, available_at: Time?, idempotency_key: String?) -> Message
+
+    # @rbs (Time?, Time) -> Time
+    def normalize_availability: (Time?, Time) -> Time
+  end
+end

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

@@ -0,0 +1,37 @@
+# Generated from lib/solid_objects/message_reference.rb with RBS::Inline
+
+module SolidObjects
+  class MessageReference
+    # @rbs (Message) -> MessageReference
+    def self.from_message: (Message) -> MessageReference
+
+    @id: Integer
+
+    @request_id: String
+
+    @actor_type: String
+
+    @actor_id: String
+
+    @sequence: Integer
+
+    attr_reader id: untyped
+
+    attr_reader request_id: untyped
+
+    attr_reader actor_type: untyped
+
+    attr_reader actor_id: untyped
+
+    attr_reader sequence: untyped
+
+    # @rbs (id: Integer, request_id: String, actor_type: String, actor_id: String, sequence: Integer) -> void
+    def initialize: (id: Integer, request_id: String, actor_type: String, actor_id: String, sequence: Integer) -> void
+
+    # @rbs () -> String
+    def status: () -> String
+
+    # @rbs () -> untyped
+    def result: () -> untyped
+  end
+end

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

@@ -0,0 +1,46 @@
+# Generated from lib/solid_objects/process_registry.rb with RBS::Inline
+
+module SolidObjects
+  class ProcessRegistry
+    # @rbs (?now: Time) -> Integer
+    def self.cleanup_dead: (?now: Time) -> Integer
+
+    # @rbs (Process, ?now: Time) -> bool
+    def self.deregister: (Process, ?now: Time) -> bool
+
+    # @rbs (Process, Time) -> void
+    private def self.cleanup_process: (Process, Time) -> void
+
+    @process_record: Process?
+
+    @last_heartbeat_at: Float?
+
+    attr_reader process_record: untyped
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs (?kind: String, ?metadata: Hash[String | Symbol, untyped]) -> Process
+    def register: (?kind: String, ?metadata: Hash[String | Symbol, untyped]) -> Process
+
+    # @rbs () -> bool
+    def heartbeat: () -> bool
+
+    # @rbs () -> bool
+    def start_draining: () -> bool
+
+    # @rbs () -> bool
+    def stop: () -> bool
+
+    private
+
+    # @rbs () -> Hash[Symbol, String]
+    def default_metadata: () -> Hash[Symbol, String]
+
+    # @rbs () -> bool
+    def heartbeat_recent?: () -> bool
+
+    # @rbs () -> Float
+    def monotonic_now: () -> Float
+  end
+end

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

@@ -0,0 +1,45 @@
+# Generated from lib/solid_objects/reference.rb with RBS::Inline
+
+module SolidObjects
+  class Reference
+    @actor_type: String
+
+    @actor_id: String
+
+    attr_reader actor_type: untyped
+
+    attr_reader actor_id: untyped
+
+    # @rbs (actor_type: String, actor_id: String) -> void
+    def initialize: (actor_type: String, actor_id: String) -> void
+
+    # @rbs (Symbol | String, ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> (MessageReference | Actor::OutboundMessageIntent)
+    def tell: (Symbol | String, ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> (MessageReference | Actor::OutboundMessageIntent)
+
+    # @rbs (Symbol | String, ?timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> untyped
+    def ask: (Symbol | String, ?timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> untyped
+
+    # @rbs (?authorization_context: untyped) -> bool
+    def destroy: (?authorization_context: untyped) -> bool
+
+    # @rbs (Symbol, *untyped, **untyped) -> untyped
+    def method_missing: (Symbol, *untyped, **untyped) -> untyped
+
+    # @rbs (Symbol, bool) -> bool
+    def respond_to_missing?: (Symbol, bool) -> bool
+
+    # @rbs () -> String
+    def to_s: () -> String
+
+    private
+
+    # @rbs (Symbol | String) -> bool
+    def actor_message?: (Symbol | String) -> bool
+
+    # @rbs (Symbol | String) -> bool
+    def actor_query?: (Symbol | String) -> bool
+
+    # @rbs () -> ActorDefinition
+    def actor_definition: () -> ActorDefinition
+  end
+end

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

@@ -0,0 +1,55 @@
+# Generated from lib/solid_objects/reminder_scheduler.rb with RBS::Inline
+
+module SolidObjects
+  class ReminderScheduler
+    @shutdown_requested: bool
+
+    @stopped: bool
+
+    @database_adapter: DatabaseAdapter
+
+    @process_registry: ProcessRegistry
+
+    # @rbs (?process_registry: ProcessRegistry, ?database_adapter: DatabaseAdapter) -> void
+    def initialize: (?process_registry: ProcessRegistry, ?database_adapter: DatabaseAdapter) -> void
+
+    # @rbs () -> bool
+    def run_once: () -> bool
+
+    # @rbs () -> void
+    def stop: () -> void
+
+    # @rbs () -> void
+    def run: () -> void
+
+    # @rbs () -> void
+    def request_shutdown: () -> void
+
+    # @rbs () -> bool
+    def stopped?: () -> bool
+
+    # @rbs () -> bool
+    def shutdown_requested?: () -> bool
+
+    private
+
+    attr_reader process_registry: untyped
+
+    attr_reader database_adapter: untyped
+
+    # @rbs () -> Reminder?
+    def claim_next: () -> Reminder?
+
+    # @rbs (Reminder) -> MessageReference?
+    def enqueue: (Reminder) -> MessageReference?
+
+    # @rbs (Reminder) -> void
+    def release: (Reminder) -> void
+
+    # @rbs (Reminder) -> void
+    def verify_claim!: (Reminder) -> void
+
+    # @rbs (Reminder, Time) -> Time
+    def next_run_at: (Reminder, Time) -> Time
+  end
+end

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

@@ -0,0 +1,31 @@
+# Generated from lib/solid_objects/serialization.rb with RBS::Inline
+
+module SolidObjects
+  module Serialization
+    MAX_NESTING: ::Integer
+
+    # @rbs (untyped, ?max_bytes: Integer?) -> untyped
+    def self.dump: (untyped, ?max_bytes: Integer?) -> untyped
+
+    # @rbs (untyped) -> untyped
+    def self.load: (untyped) -> untyped
+
+    # @rbs (untyped) -> untyped
+    def self.deep_copy: (untyped) -> untyped
+
+    # @rbs (untyped) -> untyped
+    def self.readonly_copy: (untyped) -> untyped
+
+    # @rbs (untyped) -> untyped
+    private def self.freeze_recursively: (untyped) -> untyped
+
+    # @rbs (untyped, ?depth: Integer) -> untyped
+    private def self.normalize: (untyped, ?depth: Integer) -> untyped
+
+    # @rbs (Hash[untyped, untyped], depth: Integer) -> Hash[String, untyped]
+    private def self.normalize_hash: (Hash[untyped, untyped], depth: Integer) -> Hash[String, untyped]
+
+    # @rbs (untyped) -> String
+    private def self.normalize_key: (untyped) -> String
+  end
+end

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

@@ -0,0 +1,72 @@
+# Generated from lib/solid_objects/state.rb with RBS::Inline
+
+module SolidObjects
+  class StateDefinition
+    class Attribute < Data
+      attr_reader name(): untyped
+
+      attr_reader default(): untyped
+
+      def self.new: (untyped name, untyped default) -> instance
+                  | (name: untyped, default: untyped) -> instance
+
+      def self.members: () -> [ :name, :default ]
+
+      def members: () -> [ :name, :default ]
+    end
+
+    @attributes: Hash[Symbol, Attribute]
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs (Symbol | String, ?default: untyped) -> Attribute
+    def attribute: (Symbol | String, ?default: untyped) -> Attribute
+
+    # @rbs () -> Hash[Symbol, Attribute]
+    def to_h: () -> Hash[Symbol, Attribute]
+
+    # @rbs () -> StateDefinition
+    def duplicate: () -> StateDefinition
+
+    private
+
+    attr_reader attributes: untyped
+  end
+
+  class State
+    @definition: StateDefinition
+
+    @data: Hash[String, untyped]
+
+    # @rbs (StateDefinition, Hash[String, untyped]?) -> void
+    def initialize: (StateDefinition, Hash[String, untyped]?) -> void
+
+    # @rbs () -> Hash[String, untyped]
+    def to_h: () -> Hash[String, untyped]
+
+    # @rbs (Symbol | String) -> untyped
+    def fetch: (Symbol | String) -> untyped
+
+    # @rbs (Symbol | String, untyped) -> untyped
+    def write: (Symbol | String, untyped) -> untyped
+
+    # @rbs (Symbol, *untyped) -> untyped
+    def method_missing: (Symbol, *untyped) -> untyped
+
+    # @rbs (Symbol, bool) -> bool
+    def respond_to_missing?: (Symbol, bool) -> bool
+
+    private
+
+    attr_reader definition: untyped
+
+    attr_reader data: untyped
+
+    # @rbs () -> void
+    def apply_defaults: () -> void
+
+    # @rbs (Symbol | String) -> bool
+    def defined_attribute?: (Symbol | String) -> bool
+  end
+end

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

@@ -0,0 +1,11 @@
+# Generated from lib/solid_objects/stream_name.rb with RBS::Inline
+
+module SolidObjects
+  module StreamName
+    # @rbs (Reference | Hash[String, String]) -> String
+    def self?.for: (Reference | Hash[String, String]) -> String
+
+    # @rbs (Reference | Hash[String, String]) -> Hash[String, String]
+    def self?.identity_for: (Reference | Hash[String, String]) -> Hash[String, String]
+  end
+end

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

@@ -0,0 +1,19 @@
+# Generated from lib/solid_objects/stream_token.rb with RBS::Inline
+
+module SolidObjects
+  module StreamToken
+    PURPOSE: ::String
+
+    # @rbs (Reference) -> String
+    def self?.generate: (Reference) -> String
+
+    # @rbs (String) -> Hash[String, String]
+    def self?.verify: (String) -> Hash[String, String]
+
+    # @rbs () -> ActiveSupport::MessageVerifier
+    def self?.verifier: () -> ActiveSupport::MessageVerifier
+
+    # @rbs () -> String
+    def self?.signing_secret: () -> String
+  end
+end

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

@@ -0,0 +1,38 @@
+# Generated from lib/solid_objects/supervisor.rb with RBS::Inline
+
+module SolidObjects
+  class Supervisor
+    @components: Array[Worker | EffectExecutor | ReminderScheduler | BroadcastExecutor]
+
+    @threads: Array[Thread]
+
+    @started: bool
+
+    # @rbs (?worker_count: Integer, ?effect_worker_count: Integer, ?broadcast_worker_count: Integer, ?reminder_scheduler_count: Integer) -> void
+    def initialize: (?worker_count: Integer, ?effect_worker_count: Integer, ?broadcast_worker_count: Integer, ?reminder_scheduler_count: Integer) -> void
+
+    # @rbs () -> void
+    def run: () -> void
+
+    # @rbs () -> void
+    def start: () -> void
+
+    # @rbs () -> void
+    def stop: () -> void
+
+    private
+
+    attr_reader components: untyped
+
+    attr_reader threads: untyped
+
+    # @rbs (worker_count: Integer, effect_worker_count: Integer, broadcast_worker_count: Integer, reminder_scheduler_count: Integer) -> Array[Worker | EffectExecutor | ReminderScheduler | BroadcastExecutor]
+    def build_components: (worker_count: Integer, effect_worker_count: Integer, broadcast_worker_count: Integer, reminder_scheduler_count: Integer) -> Array[Worker | EffectExecutor | ReminderScheduler | BroadcastExecutor]
+
+    # @rbs () -> void
+    def join_until_timeout: () -> void
+
+    # @rbs () -> Float
+    def monotonic_now: () -> Float
+  end
+end

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

@@ -0,0 +1,14 @@
+# Generated from lib/solid_objects/turbo_stream_renderer.rb with RBS::Inline
+
+module SolidObjects
+  module TurboStreamRenderer
+    # @rbs (Broadcast) -> String
+    def self?.observable: (Broadcast) -> String
+
+    # @rbs (Reference, Symbol | String, untyped) -> String
+    def self?.observable_value: (Reference, Symbol | String, untyped) -> String
+
+    # @rbs (untyped) -> String
+    def self?.display_value: (untyped) -> String
+  end
+end

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

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

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

@@ -0,0 +1,24 @@
+# Generated from lib/solid_objects/wake_up.rb with RBS::Inline
+
+module SolidObjects
+  class WakeUp
+    @mutex: Mutex
+
+    @condition: Thread::ConditionVariable
+
+    # @rbs () -> void
+    def initialize: () -> void
+
+    # @rbs () -> void
+    def signal: () -> void
+
+    # @rbs (timeout: Numeric) -> void
+    def wait: (timeout: Numeric) -> void
+
+    private
+
+    attr_reader mutex: untyped
+
+    attr_reader condition: untyped
+  end
+end