solid_objects 0.13.3 → 0.14.1

data/examples/at_least_once/demo.rb

@@ -0,0 +1,92 @@
+# rbs_inline: enabled
+
+# An executable proof for the at-least-once clause: a contract clause
+# nobody can observe firing is decoration. Run with:
+#
+#   bundle exec rake at_least_once
+#
+# Phase one crashes an effect worker between the external sink write and
+# the acknowledgement, restarts one, and shows the sink reading 2 with
+# deduplication off. Both deliveries carry the same stable effect id.
+# Phase two repeats the crash with a guard on that id; the sink reads 1.
+# The actor state commits exactly once in both phases.
+
+require_relative "boot"
+require_relative "actor"
+require_relative "sink"
+require "fileutils"
+require "json"
+require "rbconfig"
+require "tmpdir"
+
+directory = Dir.mktmpdir("solid_objects_at_least_once_")
+database_path = File.join(directory, "state.sqlite3")
+AtLeastOnceBoot.call(database_path)
+
+# @rbs (String message) -> void
+def prove(message)
+  raise "proof failed: #{message}" unless yield
+end
+
+# @rbs (String actor_id) -> void
+def stage_one_delivery(actor_id)
+  DeliveryCounter.ref(actor_id).async.deliver
+  worker = SolidObjects::Worker.new
+  begin
+    worker.run_until_idle
+  ensure
+    worker.stop
+  end
+end
+
+# @rbs (database_path: String, sink_path: String, mode: String, deduplication: String) -> Integer?
+def run_effect_worker(database_path:, sink_path:, mode:, deduplication:)
+  script = File.expand_path("effect_worker.rb", __dir__)
+  pid = Process.spawn(
+    RbConfig.ruby, script, database_path, sink_path, mode, deduplication,
+    chdir: AtLeastOnceBoot::ROOT
+  )
+  _pid, status = Process.wait2(pid)
+  status.exitstatus
+end
+
+# @rbs (database_path: String, sink_path: String, deduplication: String) -> void
+def crash_then_recover(database_path:, sink_path:, deduplication:)
+  crash = run_effect_worker(database_path:, sink_path:, mode: "crash", deduplication:)
+  prove("the first delivery crashed before acknowledgement") { crash == 1 }
+  sleep 0.4
+  recovery = run_effect_worker(database_path:, sink_path:, mode: "complete", deduplication:)
+  prove("the second delivery completed and acknowledged") { recovery == 0 }
+end
+
+begin
+  sink_off = File.join(directory, "sink-dedup-off.json")
+  stage_one_delivery("dedup-off")
+  crash_then_recover(database_path:, sink_path: sink_off, deduplication: "off")
+  deliveries = AtLeastOnceSink.read(sink_off)
+  effect_ids = deliveries.map { |delivery| delivery.fetch("effect_id") }
+  state_off = SolidObjects::Instance.find_by!(actor_id: "dedup-off").state.fetch("count")
+  prove("the state commit happened exactly once") { state_off == 1 }
+  prove("the sink observed the duplicate") { deliveries.length == 2 }
+  prove("both deliveries carried the same stable effect id") { effect_ids.uniq.length == 1 }
+
+  sink_on = File.join(directory, "sink-dedup-on.json")
+  stage_one_delivery("dedup-on")
+  crash_then_recover(database_path:, sink_path: sink_on, deduplication: "on")
+  guarded = AtLeastOnceSink.read(sink_on)
+  state_on = SolidObjects::Instance.find_by!(actor_id: "dedup-on").state.fetch("count")
+  prove("the state commit happened exactly once") { state_on == 1 }
+  prove("the stable effect id absorbed the duplicate") { guarded.length == 1 }
+
+  puts JSON.pretty_generate(
+    duplicate: {
+      state_commits: state_off,
+      sink_deliveries: deliveries.length,
+      same_effect_id: effect_ids.uniq.length == 1,
+      attempts: deliveries.map { |delivery| delivery.fetch("attempt") }
+    },
+    remedy: { state_commits: state_on, sink_deliveries: guarded.length }
+  )
+ensure
+  FileUtils.remove_entry(directory) if directory
+end

data/examples/at_least_once/effect_worker.rb

@@ -0,0 +1,40 @@
+# rbs_inline: enabled
+
+require_relative "boot"
+require_relative "actor"
+require_relative "sink"
+
+database_path, sink_path, mode, deduplication = ARGV
+raise ArgumentError, "usage: effect_worker.rb DATABASE SINK crash|complete on|off" unless deduplication
+
+AtLeastOnceBoot.call(database_path.to_s)
+
+SolidObjects.register_effect(:record) do |_arguments, context|
+  AtLeastOnceSink.record(
+    path: sink_path.to_s,
+    effect_id: context.id,
+    attempt: context.attempt,
+    deduplication: deduplication.to_sym
+  )
+  # A crash between the external write and the acknowledgement: the sink
+  # has the delivery, the effect row never completes.
+  Process.exit!(1) if mode == "crash"
+  nil
+end
+
+# Production runs this on the dead-process-cleanup interval; the demo runs
+# it once, after the liveness threshold, to release the crashed claim.
+SolidObjects::ProcessRegistry.cleanup_dead
+
+effect_executor = SolidObjects::EffectExecutor.new
+begin
+  worked = false
+  200.times do
+    worked = effect_executor.run_once
+    break if worked
+    sleep 0.01
+  end
+  raise "no effect became claimable" unless worked
+ensure
+  effect_executor.stop
+end

data/examples/at_least_once/sink.rb

@@ -0,0 +1,27 @@
+# rbs_inline: enabled
+
+require "json"
+
+# The external system in the at-least-once demo: a JSON file that records
+# every delivery it accepts. With deduplication :off it accepts everything,
+# which makes an at-least-once duplicate visible. With deduplication :on it
+# accepts each stable effect id once, which is the documented remedy.
+module AtLeastOnceSink
+  # @rbs (String path) -> Array[Hash[String, untyped]]
+  def self.read(path)
+    JSON.parse(File.read(path))
+  rescue Errno::ENOENT
+    []
+  end
+
+  # @rbs (path: String, effect_id: String, attempt: Integer, deduplication: Symbol) -> bool
+  def self.record(path:, effect_id:, attempt:, deduplication:)
+    deliveries = read(path)
+    seen = deliveries.any? { |delivery| delivery.fetch("effect_id") == effect_id }
+    return false if deduplication == :on && seen
+
+    deliveries << { "effect_id" => effect_id, "attempt" => attempt }
+    File.write(path, JSON.pretty_generate(deliveries))
+    true
+  end
+end

data/lib/generators/solid_objects/templates/solid_objects.rb

@@ -37,7 +37,7 @@ SolidObjects.configure do |configuration|
   #
   # Prefer policies that bind actor_type and actor_id to a trusted
   # authorization_context. See:
-  # https://github.com/cardmagic/solid_objects/blob/main/docs/authorization.md
+  # https://github.com/cardmagic/solid-objects-ruby/blob/main/docs/authorization.md
   # and run:
   #
   #   bin/rails solid_objects:doctor
@@ -49,6 +49,22 @@ SolidObjects.configure do |configuration|
   configuration.authorize_subscription = ->(**) { false }
   configuration.authorize_administration = ->(**) { false }
 
+  # The engine route POST /solid_objects/transmit ingests transmit envelopes
+  # from another Solid Objects runtime. It stays denied until its callers are
+  # authenticated, because the ingest skips authorize_message by design:
+  #
+  # configuration.authorize_transmission = lambda do |envelope:, authorization_context:|
+  #   ActiveSupport::SecurityUtils.secure_compare(
+  #     authorization_context.request.headers["Authorization"].to_s,
+  #     "Bearer #{Rails.application.credentials.transmit_token}"
+  #   )
+  # end
+  #
+  # When the sending runtime names actor types differently, map them here:
+  #
+  # configuration.transmission_actor_type_resolver = ->(actor_type) { actor_type.sub("browser-", "server-") }
+  configuration.authorize_transmission = ->(**) { false }
+
   # Configure component_authorization_context to return the authenticated
   # principal used for reactive component refreshes.
 

data/lib/solid_objects/actor.rb

@@ -190,6 +190,17 @@ module SolidObjects
       nil
     end
 
+    # @rbs () -> OperationDispatcher
+    def transmit
+      OperationDispatcher.new(
+        actor_type: self.class.actor_type,
+        handlers: self.class.definition.messages
+      ) do |operation, arguments|
+        emit(Transmission::EFFECT_NAME, operation: operation.to_s, arguments:)
+        nil
+      end
+    end
+
     # @rbs (Symbol | String, **untyped) -> nil
     def commit_action(name, **arguments)
       CommitActionIntent.new(

data/lib/solid_objects/actor_channel.rb

@@ -4,6 +4,14 @@ require "action_cable"
 
 module SolidObjects
   class ActorChannel < ActionCable::Channel::Base
+    REJECT_REASONS = {
+      UnknownActorType => "unregistered_actor_type",
+      InvalidStreamToken => "invalid_stream_token",
+      InvalidComponentToken => "invalid_component_token",
+      JSON::ParserError => "malformed_component_registration",
+      KeyError => "missing_subscription_parameter"
+    }.freeze
+
     # @rbs () -> void
     def subscribed
       identity = StreamToken.verify(params.fetch("token"))
@@ -15,7 +23,9 @@ module SolidObjects
         actor_id:,
         authorization_context: connection
       )
-      return reject unless authorized
+      unless authorized
+        return reject_and_report("unauthorized", actor_type:, actor_id:)
+      end
 
       @reference = Reference.new(actor_type:, actor_id:)
       @scalar_observables = identity["observables"]
@@ -43,8 +53,8 @@ module SolidObjects
       JSON::ParserError,
       InvalidStreamToken,
       InvalidComponentToken,
-      UnknownActorType
-      reject
+      UnknownActorType => error
+      reject_and_report(reject_reason(error), actor_type:, actor_id:, error:)
     end
 
     private
@@ -54,6 +64,26 @@ module SolidObjects
       :scalar_observables,
       :payload_names
 
+    # The exception message stays out of the payload, because a component or
+    # payload error can carry actor state into logs.
+    # @rbs (String, actor_type: String?, actor_id: String?, ?error: Exception?) -> void
+    def reject_and_report(reason, actor_type:, actor_id:, error: nil)
+      SolidObjects.instrument(
+        :"subscription.rejected",
+        reason:,
+        actor_type:,
+        actor_id:,
+        error_class: error&.class&.name
+      )
+      reject
+    end
+
+    # @rbs (Exception) -> String
+    def reject_reason(error)
+      match = REJECT_REASONS.find { |error_class, _| error.is_a?(error_class) }
+      match ? match.last : "invalid_subscription"
+    end
+
     # @rbs (String) -> void
     def receive_broadcast(stream)
       invalidation = TurboStreamRenderer.invalidation(stream)

data/lib/solid_objects/configuration.rb

@@ -47,6 +47,8 @@ module SolidObjects
     # @rbs @authorize_destroy: Proc
     # @rbs @authorize_subscription: Proc
     # @rbs @authorize_administration: Proc
+    # @rbs @authorize_transmission: Proc
+    # @rbs @transmission_actor_type_resolver: Proc
 
     attr_accessor :table_name_prefix,
       :polling_interval,
@@ -92,7 +94,9 @@ module SolidObjects
       :authorize_query,
       :authorize_destroy,
       :authorize_subscription,
-      :authorize_administration
+      :authorize_administration,
+      :authorize_transmission,
+      :transmission_actor_type_resolver
 
     # @rbs @additional_components: Array[untyped]
     attr_reader :additional_components
@@ -148,6 +152,8 @@ module SolidObjects
       @authorize_destroy = ->(**) { false }
       @authorize_subscription = ->(**) { false }
       @authorize_administration = ->(**) { false }
+      @authorize_transmission = ->(**) { false }
+      @transmission_actor_type_resolver = ->(actor_type) { actor_type }
       @additional_components = []
     end
 

data/lib/solid_objects/engine.rb

@@ -15,6 +15,10 @@ module SolidObjects
       SolidObjects::LogSubscriber.install
     end
 
+    initializer "solid_objects.actors" do |application|
+      application.config.to_prepare { ApplicationActorLoader.new.call }
+    end
+
     initializer "solid_objects.database", after: :load_config_initializers do
       ActiveSupport.on_load(:active_record) do
         require RECORD_PATH

data/lib/solid_objects/errors.rb

@@ -19,6 +19,9 @@ module SolidObjects
   class UnknownMessage < Error
   end
 
+  class InvalidTransmission < Error
+  end
+
   class InvalidPayload < Error
   end
 

data/lib/solid_objects/transmission.rb

@@ -0,0 +1,139 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  module Transmission
+    REQUIRED_FIELDS = %w[effectId actorType actorId operation].freeze
+    IDEMPOTENCY_PREFIX = "transmit:"
+    EFFECT_NAME = "solid-objects.transmit"
+    UNDELIVERED_STATUSES = %w[pending processing].freeze
+
+    class << self
+      # @rbs (untyped envelope, ?resolve_actor_type: ^(String) -> (String | Symbol), ?mailbox: Mailbox, ?actor_loader: ^() -> bool) -> MessageReference
+      def receive(envelope, resolve_actor_type: :itself.to_proc, mailbox: Mailbox.new, actor_loader: method(:load_application_actors))
+        validate!(envelope)
+
+        actor_type = resolve_actor_type.call(envelope["actorType"]).to_s
+        actor_class = fetch_actor_class(actor_type, actor_loader)
+        operation = envelope["operation"].to_sym
+        unless actor_class.definition.messages.key?(operation)
+          raise UnknownMessage, "unknown operation #{envelope["operation"].inspect}"
+        end
+
+        mailbox.enqueue(
+          reference: Reference.new(actor_type:, actor_id: envelope["actorId"]),
+          operation:,
+          arguments: envelope.fetch("arguments", {}),
+          delivery_mode: "internal",
+          idempotency_key: "#{IDEMPOTENCY_PREFIX}#{envelope["effectId"]}"
+        )
+      end
+
+      # @rbs (effect_name: String, arguments: Hash[String, untyped], context: EffectContext, deliver: Proc) -> nil
+      def deliver_through(effect_name:, arguments:, context:, deliver:)
+        staged_envelope(
+          arguments,
+          effect_id: context.id,
+          actor_type: context.actor_type,
+          actor_id: context.actor_id
+        )
+        undelivered_envelopes_through(effect_name:, context:).each do |envelope|
+          deliver.call(envelope)
+        end
+        nil
+      end
+
+      private
+
+      # @rbs (String, ^() -> bool) -> Class
+      def fetch_actor_class(actor_type, actor_loader)
+        SolidObjects.registry.fetch(actor_type)
+      rescue UnknownActorType
+        raise unless actor_loader.call
+
+        SolidObjects.registry.fetch(actor_type)
+      end
+
+      # @rbs () -> bool
+      def load_application_actors
+        return false unless defined?(Rails.application) && Rails.application
+
+        ApplicationActorLoader.new.call
+        true
+      end
+
+      # @rbs (Hash[String, untyped], effect_id: String, actor_type: String, actor_id: String) -> Hash[String, untyped]
+      def staged_envelope(arguments, effect_id:, actor_type:, actor_id:)
+        operation = arguments["operation"]
+        unless operation.is_a?(String) && !operation.empty?
+          raise InvalidTransmission, "transmit effect arguments require a non-empty operation"
+        end
+
+        target_arguments = arguments["arguments"]
+        target_arguments = {} if target_arguments.nil?
+        unless target_arguments.is_a?(Hash)
+          raise InvalidTransmission, %(transmit effect arguments must hold a JSON object in "arguments")
+        end
+
+        target_type = arguments["actorType"].nil? ? actor_type : arguments["actorType"]
+        target_id = arguments["actorId"].nil? ? actor_id : arguments["actorId"]
+        { "actorType" => target_type, "actorId" => target_id }.each do |field, value|
+          next if value.is_a?(String) && !value.empty?
+
+          raise InvalidTransmission, "transmit effect #{field} must be a non-empty string"
+        end
+
+        {
+          "effectId" => effect_id,
+          "actorType" => target_type,
+          "actorId" => target_id,
+          "operation" => operation,
+          "arguments" => target_arguments
+        }
+      end
+
+      # @rbs (effect_name: String, context: EffectContext) -> Array[Hash[String, untyped]]
+      def undelivered_envelopes_through(effect_name:, context:)
+        source_sequence = Message.find(context.source_message_id).sequence
+        effects = Effect
+          .joins(:message)
+          .where(name: effect_name, status: UNDELIVERED_STATUSES)
+          .merge(
+            Message.where(
+              actor_type: context.actor_type,
+              actor_id: context.actor_id,
+              sequence: ..source_sequence
+            )
+          )
+          .order(Message.arel_table[:sequence].asc, :id)
+
+        effects.filter_map do |effect|
+          staged_envelope(
+            effect.arguments,
+            effect_id: effect.effect_id,
+            actor_type: context.actor_type,
+            actor_id: context.actor_id
+          )
+        rescue InvalidTransmission
+          nil
+        end
+      end
+
+      # @rbs (untyped) -> void
+      def validate!(envelope)
+        raise InvalidTransmission, "envelope must be a JSON object" unless envelope.is_a?(Hash)
+
+        REQUIRED_FIELDS.each do |field|
+          value = envelope[field]
+          next if value.is_a?(String) && !value.empty?
+
+          raise InvalidTransmission, "envelope field #{field.inspect} must be a non-empty string"
+        end
+
+        arguments = envelope.fetch("arguments", {})
+        return if arguments.is_a?(Hash)
+
+        raise InvalidTransmission, %(envelope field "arguments" must be a JSON object)
+      end
+    end
+  end
+end

data/lib/solid_objects/version.rb

@@ -1,5 +1,5 @@
 # rbs_inline: enabled
 
 module SolidObjects
-  VERSION = "0.13.3"
+  VERSION = "0.14.1"
 end

data/lib/solid_objects.rb

@@ -63,6 +63,8 @@ require "solid_objects/lease_renewer"
 # was reachable only through the caller path, so requiring the gem was not
 # enough to run a role that uses it.
 require "solid_objects/mailbox"
+require "solid_objects/application_actor_loader"
+require "solid_objects/transmission"
 require "solid_objects/worker"
 require "solid_objects/effect_executor"
 require "solid_objects/reminder_scheduler"
@@ -100,6 +102,20 @@ module SolidObjects
       effect_registry.register(name, handler)
     end
 
+    # @rbs (?effect_name: String | Symbol) { (Hash[String, untyped]) -> untyped } -> Proc
+    def register_transmit(effect_name: Transmission::EFFECT_NAME, &deliver)
+      raise ArgumentError, "register_transmit requires a delivery block" unless deliver
+
+      register_effect(effect_name) do |arguments, context|
+        Transmission.deliver_through(
+          effect_name: effect_name.to_s,
+          arguments:,
+          context:,
+          deliver:
+        )
+      end
+    end
+
     # @rbs () -> CommitActionRegistry
     def commit_action_registry
       @commit_action_registry ||= CommitActionRegistry.new

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

@@ -0,0 +1,13 @@
+# Generated from app/controllers/solid_objects/transmissions_controller.rb with RBS::Inline
+
+module SolidObjects
+  class TransmissionsController < ActionController::API
+    # @rbs () -> void
+    def create: () -> void
+
+    private
+
+    # @rbs (untyped) -> bool
+    def authorized_transmission?: (untyped) -> bool
+  end
+end

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

@@ -161,6 +161,9 @@ module SolidObjects
     # @rbs (Symbol | String, ?on_success: Symbol | String?, ?on_failure: Symbol | String?, **untyped) -> nil
     def emit: (Symbol | String, ?on_success: Symbol | String?, ?on_failure: Symbol | String?, **untyped) -> nil
 
+    # @rbs () -> OperationDispatcher
+    def transmit: () -> OperationDispatcher
+
     # @rbs (Symbol | String, **untyped) -> nil
     def commit_action: (Symbol | String, **untyped) -> nil
 

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

@@ -2,6 +2,8 @@
 
 module SolidObjects
   class ActorChannel < ActionCable::Channel::Base
+    REJECT_REASONS: untyped
+
     # @rbs () -> void
     def subscribed: () -> void
 
@@ -15,6 +17,14 @@ module SolidObjects
 
     attr_reader payload_names: untyped
 
+    # The exception message stays out of the payload, because a component or
+    # payload error can carry actor state into logs.
+    # @rbs (String, actor_type: String?, actor_id: String?, ?error: Exception?) -> void
+    def reject_and_report: (String, actor_type: String?, actor_id: String?, ?error: Exception?) -> void
+
+    # @rbs (Exception) -> String
+    def reject_reason: (Exception) -> String
+
     # @rbs (String) -> void
     def receive_broadcast: (String) -> void
 

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

@@ -4,8 +4,6 @@ module SolidObjects
   class Configuration
     @table_name_prefix: String
 
-    @process_alive_threshold: Float
-
     @shutdown_timeout: Float
 
     @supervisor_monitor_interval: Float
@@ -58,6 +56,10 @@ module SolidObjects
 
     @authorize_administration: Proc
 
+    @authorize_transmission: Proc
+
+    @transmission_actor_type_resolver: Proc
+
     @polling_interval: Float
 
     @idle_polling_interval: Float
@@ -92,6 +94,8 @@ module SolidObjects
 
     @process_heartbeat_interval: Float
 
+    @process_alive_threshold: Float
+
     attr_accessor table_name_prefix: untyped
 
     attr_accessor polling_interval: untyped
@@ -182,6 +186,10 @@ module SolidObjects
 
     attr_accessor authorize_administration: untyped
 
+    attr_accessor authorize_transmission: untyped
+
+    attr_accessor transmission_actor_type_resolver: untyped
+
     # @rbs @additional_components: Array[untyped]
     attr_reader additional_components: untyped
 

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

@@ -19,6 +19,9 @@ module SolidObjects
   class UnknownMessage < Error
   end
 
+  class InvalidTransmission < Error
+  end
+
   class InvalidPayload < Error
   end
 

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

@@ -0,0 +1,34 @@
+# Generated from lib/solid_objects/transmission.rb with RBS::Inline
+
+module SolidObjects
+  module Transmission
+    REQUIRED_FIELDS: untyped
+
+    IDEMPOTENCY_PREFIX: ::String
+
+    EFFECT_NAME: ::String
+
+    UNDELIVERED_STATUSES: untyped
+
+    # @rbs (untyped envelope, ?resolve_actor_type: ^(String) -> (String | Symbol), ?mailbox: Mailbox, ?actor_loader: ^() -> bool) -> MessageReference
+    def self.receive: (untyped envelope, ?resolve_actor_type: ^(String) -> (String | Symbol), ?mailbox: Mailbox, ?actor_loader: ^() -> bool) -> MessageReference
+
+    # @rbs (effect_name: String, arguments: Hash[String, untyped], context: EffectContext, deliver: Proc) -> nil
+    def self.deliver_through: (effect_name: String, arguments: Hash[String, untyped], context: EffectContext, deliver: Proc) -> nil
+
+    # @rbs (String, ^() -> bool) -> Class
+    private def self.fetch_actor_class: (String, ^() -> bool) -> Class
+
+    # @rbs () -> bool
+    private def self.load_application_actors: () -> bool
+
+    # @rbs (Hash[String, untyped], effect_id: String, actor_type: String, actor_id: String) -> Hash[String, untyped]
+    private def self.staged_envelope: (Hash[String, untyped], effect_id: String, actor_type: String, actor_id: String) -> Hash[String, untyped]
+
+    # @rbs (effect_name: String, context: EffectContext) -> Array[Hash[String, untyped]]
+    private def self.undelivered_envelopes_through: (effect_name: String, context: EffectContext) -> Array[Hash[String, untyped]]
+
+    # @rbs (untyped) -> void
+    private def self.validate!: (untyped) -> void
+  end
+end

data/sig/generated/lib/solid_objects.rbs

@@ -18,6 +18,9 @@ module SolidObjects
   # @rbs (String | Symbol) { (Hash[String, untyped], EffectContext) -> untyped } -> Proc
   def self.register_effect: (String | Symbol) { (Hash[String, untyped], EffectContext) -> untyped } -> Proc
 
+  # @rbs (?effect_name: String | Symbol) { (Hash[String, untyped]) -> untyped } -> Proc
+  def self.register_transmit: (?effect_name: String | Symbol) { (Hash[String, untyped]) -> untyped } -> Proc
+
   # @rbs () -> CommitActionRegistry
   def self.commit_action_registry: () -> CommitActionRegistry
 

data/sig/support/framework.rbs

@@ -21,6 +21,9 @@ end
 module ActionController
   class Base
   end
+
+  class API
+  end
 end
 
 module Rails