solid_objects 0.1.0

data/Rakefile

@@ -0,0 +1,40 @@
+# rbs_inline: enabled
+
+require "bundler/gem_tasks"
+require "fileutils"
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << "test"
+  task.pattern = "test/**/*_test.rb"
+end
+
+desc "Generate RBS signatures from inline annotations"
+task :rbs do
+  FileUtils.rm_rf(File.expand_path("sig/generated", __dir__))
+  sh "bundle exec rbs-inline --base lib --base app --output sig/generated lib app"
+  FileUtils.rm_f(File.expand_path("sig/generated/lib/generators/solid_objects/templates/solid_objects.rbs", __dir__))
+  sh "bundle exec rbs -I sig/generated -I sig/support validate"
+end
+
+desc "Run Standard Ruby"
+task :standard do
+  sh "bundle exec standardrb"
+end
+
+desc "Run Solid Queue's RuboCop policy"
+task :rubocop do
+  sh "bundle exec rubocop"
+end
+
+desc "Type-check generated inline RBS signatures"
+task :steep do
+  sh "bundle exec steep check"
+end
+
+desc "Scan the Rails engine for security warnings"
+task :security do
+  sh "bundle exec brakeman --force --no-pager -q ."
+end
+
+task default: %i[test standard rubocop rbs steep security]

data/app/controllers/solid_objects/application_controller.rb

@@ -0,0 +1,23 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+    before_action :authorize_administration!
+
+    private
+
+    # @rbs () -> void
+    def authorize_administration!
+      authorized = SolidObjects.configuration.authorize_administration.call(
+        action: action_name,
+        resource: controller_name,
+        resource_id: params[:id],
+        authorization_context: self
+      )
+      return if authorized
+
+      raise Unauthorized, "actor administration is not authorized"
+    end
+  end
+end

data/app/controllers/solid_objects/dead_letters_controller.rb

@@ -0,0 +1,23 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class DeadLettersController < ApplicationController
+    # @rbs () -> void
+    def index
+      @dead_letters = DeadLetter.order(last_failed_at: :desc, id: :desc).limit(250)
+      respond_to do |format|
+        format.html
+        format.json { render json: @dead_letters }
+      end
+    end
+
+    # @rbs () -> void
+    def retry
+      message_reference = SolidObjects.dead_letters.retry(
+        params[:id].to_i,
+        authorization_context: self
+      )
+      redirect_to dead_letters_path, notice: "Retried as message #{message_reference.id}"
+    end
+  end
+end

data/app/controllers/solid_objects/instances_controller.rb

@@ -0,0 +1,29 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class InstancesController < ApplicationController
+    # @rbs () -> void
+    def index
+      @instances = Instance.order(updated_at: :desc, id: :desc).limit(250)
+      respond_to do |format|
+        format.html
+        format.json { render json: @instances }
+      end
+    end
+
+    # @rbs () -> void
+    def show
+      @instance = Instance.find(params[:id])
+      @messages = @instance.messages.order(sequence: :desc).limit(250)
+      respond_to do |format|
+        format.html
+        format.json do
+          render json: {
+            instance: @instance,
+            messages: @messages
+          }
+        end
+      end
+    end
+  end
+end

data/app/helpers/solid_objects/actor_helper.rb

@@ -0,0 +1,25 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  module ActorHelper
+    # @rbs (Reference, ?authorization_context: untyped) { (ActorView) -> untyped } -> untyped
+    def solid_object(reference, authorization_context: self, &block)
+      actor = ActorView.new(
+        reference:,
+        view_context: self,
+        authorization_context:
+      )
+      subscription = tag.turbo_cable_stream_source(
+        channel: "SolidObjects::ActorChannel",
+        token: StreamToken.generate(reference)
+      )
+      content = capture(actor, &block)
+
+      content_tag(
+        :div,
+        safe_join([ subscription, content ]),
+        id: DomIdentity.scope(reference)
+      )
+    end
+  end
+end

data/app/models/solid_objects/broadcast.rb

@@ -0,0 +1,10 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Broadcast < Record
+    self.table_name = SolidObjects.table_name(:broadcasts)
+
+    belongs_to :message, class_name: "SolidObjects::Message"
+    belongs_to :instance, class_name: "SolidObjects::Instance"
+  end
+end

data/app/models/solid_objects/claimed_message.rb

@@ -0,0 +1,14 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ClaimedMessage < Record
+    self.table_name = SolidObjects.table_name(:claimed_messages)
+
+    belongs_to :message, class_name: "SolidObjects::Message", inverse_of: :claimed_message
+    belongs_to :instance, class_name: "SolidObjects::Instance", inverse_of: :claimed_messages
+    belongs_to :process_record,
+      class_name: "SolidObjects::Process",
+      foreign_key: :process_id,
+      optional: true
+  end
+end

data/app/models/solid_objects/dead_letter.rb

@@ -0,0 +1,13 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class DeadLetter < Record
+    self.table_name = SolidObjects.table_name(:dead_letters)
+
+    belongs_to :message, class_name: "SolidObjects::Message", inverse_of: :dead_letter
+    belongs_to :instance, class_name: "SolidObjects::Instance"
+    belongs_to :retried_message,
+      class_name: "SolidObjects::Message",
+      optional: true
+  end
+end

data/app/models/solid_objects/effect.rb

@@ -0,0 +1,10 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Effect < Record
+    self.table_name = SolidObjects.table_name(:effects)
+
+    belongs_to :message, class_name: "SolidObjects::Message"
+    belongs_to :instance, class_name: "SolidObjects::Instance"
+  end
+end

data/app/models/solid_objects/instance.rb

@@ -0,0 +1,93 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Instance < Record
+    self.table_name = SolidObjects.table_name(:instances)
+
+    belongs_to :activation_owner,
+      class_name: "SolidObjects::Process",
+      optional: true,
+      inverse_of: :instances
+    has_many :messages,
+      class_name: "SolidObjects::Message",
+      inverse_of: :instance,
+      dependent: :destroy
+    has_many :ready_messages,
+      class_name: "SolidObjects::ReadyMessage",
+      inverse_of: :instance,
+      dependent: :destroy
+    has_many :claimed_messages,
+      class_name: "SolidObjects::ClaimedMessage",
+      inverse_of: :instance,
+      dependent: :destroy
+
+    before_validation :supply_defaults
+
+    validates :actor_type, :actor_id, presence: true, length: { maximum: 191 }
+
+    class << self
+      # @rbs (?actor_type: String?) -> ActiveRecord::Relation[Instance]
+      def active(actor_type: nil)
+        relation = where(paused_at: nil)
+        actor_type ? relation.where(actor_type:) : relation
+      end
+
+      # @rbs (quiet_for: Numeric, ?now: Time) -> ActiveRecord::Relation[Instance]
+      def without_pending_work(quiet_for:, now: SolidObjects.database_adapter.database_now)
+        cutoff = now - quiet_for
+        where("COALESCE(last_used_at, created_at) <= ?", cutoff)
+          .where.not(id: ReadyMessage.select(:instance_id))
+          .where.not(id: ClaimedMessage.select(:instance_id))
+          .where.not(
+            id: Reminder.where(status: "scheduled").select(:instance_id)
+          )
+      end
+
+      # @rbs (actor_type: String, owner: ActiveRecord::Relation[untyped] | Class) -> ActiveRecord::Relation[Instance]
+      def orphaned(actor_type:, owner:)
+        owner_relation = owner.is_a?(ActiveRecord::Relation) ? owner : owner.all
+        owner_class = owner_relation.klass
+        owner_table = owner_class.arel_table
+        owner_primary_key = owner_table[owner_class.primary_key]
+        cast_type = Arel::Nodes::SqlLiteral.new(owner_id_cast_type)
+        cast_id = Arel::Nodes::NamedFunction.new(
+          "CAST",
+          [ Arel::Nodes::As.new(owner_primary_key, cast_type) ]
+        )
+        owner_ids = owner_relation
+          .except(:select)
+          .select(cast_id)
+
+        where(actor_type:).where.not(actor_id: owner_ids)
+      end
+
+      # @rbs (actor_type: String, actor_ids: Array[String]) -> Hash[String, Hash[String, untyped]]
+      def states_for(actor_type:, actor_ids:)
+        where(actor_type:, actor_id: actor_ids)
+          .pluck(:actor_id, :state)
+          .to_h
+      end
+
+      private
+
+      # @rbs () -> String
+      def owner_id_cast_type
+        case connection.adapter_name
+        when /mysql/i
+          "CHAR"
+        when /postgres/i
+          "VARCHAR"
+        else
+          "TEXT"
+        end
+      end
+    end
+
+    private
+
+    # @rbs () -> void
+    def supply_defaults
+      self.state ||= {}
+    end
+  end
+end

data/app/models/solid_objects/message.rb

@@ -0,0 +1,53 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Message < Record
+    self.table_name = SolidObjects.table_name(:messages)
+
+    belongs_to :instance, class_name: "SolidObjects::Instance", inverse_of: :messages
+    has_one :ready_message,
+      class_name: "SolidObjects::ReadyMessage",
+      inverse_of: :message,
+      dependent: :destroy
+    has_one :claimed_message,
+      class_name: "SolidObjects::ClaimedMessage",
+      inverse_of: :message,
+      dependent: :destroy
+    has_one :dead_letter,
+      class_name: "SolidObjects::DeadLetter",
+      inverse_of: :message,
+      dependent: :destroy
+
+    before_validation :supply_defaults
+
+    validates :message_kind, inclusion: { in: %w[tell ask internal] }
+
+    # @rbs () -> bool
+    def ready?
+      ready_message.present?
+    end
+
+    # @rbs () -> bool
+    def claimed?
+      claimed_message.present?
+    end
+
+    # @rbs () -> bool
+    def completed?
+      completed_at.present?
+    end
+
+    # @rbs () -> bool
+    def dead?
+      dead_letter.present?
+    end
+
+    private
+
+    # @rbs () -> void
+    def supply_defaults
+      self.arguments ||= {}
+      self.available_at ||= enqueued_at || Time.current
+    end
+  end
+end

data/app/models/solid_objects/process.rb

@@ -0,0 +1,13 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Process < Record
+    self.table_name = SolidObjects.table_name(:processes)
+
+    has_many :instances,
+      class_name: "SolidObjects::Instance",
+      foreign_key: :activation_owner_id,
+      inverse_of: :activation_owner,
+      dependent: :nullify
+  end
+end

data/app/models/solid_objects/ready_message.rb

@@ -0,0 +1,10 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ReadyMessage < Record
+    self.table_name = SolidObjects.table_name(:ready_messages)
+
+    belongs_to :message, class_name: "SolidObjects::Message", inverse_of: :ready_message
+    belongs_to :instance, class_name: "SolidObjects::Instance", inverse_of: :ready_messages
+  end
+end

data/app/models/solid_objects/record.rb

@@ -0,0 +1,17 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Record < ActiveRecord::Base
+    self.abstract_class = true
+
+    class << self
+      # @rbs () -> void
+      def configure_connection
+        connection_configuration = SolidObjects.configuration.connects_to
+        return unless connection_configuration
+
+        connects_to(**connection_configuration)
+      end
+    end
+  end
+end

data/app/models/solid_objects/reminder.rb

@@ -0,0 +1,9 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class Reminder < Record
+    self.table_name = SolidObjects.table_name(:reminders)
+
+    belongs_to :instance, class_name: "SolidObjects::Instance"
+  end
+end

data/app/views/solid_objects/dead_letters/index.html.erb

@@ -0,0 +1,26 @@
+<h1>Dead letters</h1>
+
+<table>
+  <thead>
+    <tr>
+      <th>Actor</th>
+      <th>Message</th>
+      <th>Attempts</th>
+      <th>Error</th>
+      <th>Failed</th>
+      <th></th>
+    </tr>
+  </thead>
+  <tbody>
+    <% @dead_letters.each do |dead_letter| %>
+      <tr>
+        <td><%= dead_letter.actor_type %>(<%= dead_letter.actor_id %>)</td>
+        <td><%= dead_letter.message_name %></td>
+        <td><%= dead_letter.attempts %></td>
+        <td><%= dead_letter.exception_class %>: <%= dead_letter.exception_message %></td>
+        <td><%= dead_letter.last_failed_at %></td>
+        <td><%= button_to "Retry", retry_dead_letter_path(dead_letter), method: :post %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/app/views/solid_objects/instances/index.html.erb

@@ -0,0 +1,24 @@
+<h1>Actors</h1>
+
+<table>
+  <thead>
+    <tr>
+      <th>Type</th>
+      <th>ID</th>
+      <th>State version</th>
+      <th>Generation</th>
+      <th>Last used</th>
+    </tr>
+  </thead>
+  <tbody>
+    <% @instances.each do |instance| %>
+      <tr>
+        <td><%= link_to instance.actor_type, instance_path(instance) %></td>
+        <td><%= instance.actor_id %></td>
+        <td><%= instance.state_version %></td>
+        <td><%= instance.activation_generation %></td>
+        <td><%= instance.last_used_at %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/app/views/solid_objects/instances/show.html.erb

@@ -0,0 +1,35 @@
+<h1><%= @instance.actor_type %>(<%= @instance.actor_id %>)</h1>
+
+<dl>
+  <dt>State version</dt>
+  <dd><%= @instance.state_version %></dd>
+  <dt>Activation generation</dt>
+  <dd><%= @instance.activation_generation %></dd>
+  <dt>Activation owner</dt>
+  <dd><%= @instance.activation_owner_id || "inactive" %></dd>
+</dl>
+
+<h2>State</h2>
+<pre><%= JSON.pretty_generate(@instance.state) %></pre>
+
+<h2>Recent messages</h2>
+<table>
+  <thead>
+    <tr>
+      <th>Sequence</th>
+      <th>Name</th>
+      <th>Attempts</th>
+      <th>Completed</th>
+    </tr>
+  </thead>
+  <tbody>
+    <% @messages.each do |message| %>
+      <tr>
+        <td><%= message.sequence %></td>
+        <td><%= message.message_name %></td>
+        <td><%= message.attempt_count %></td>
+        <td><%= message.completed_at %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>

data/benchmark/activation_cache.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.activation_cache

data/benchmark/ask_latency.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.ask_latency

data/benchmark/claim.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.claim

data/benchmark/cold_actors.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.cold_actors

data/benchmark/concurrent_actors.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.concurrent_actors

data/benchmark/enqueue.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.enqueue

data/benchmark/hot_actor.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.hot_actor

data/benchmark/processing.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.processing

data/benchmark/query_count.rb

@@ -0,0 +1,5 @@
+# rbs_inline: enabled
+
+require_relative "support"
+
+SolidObjectsBenchmark.query_count