solid_objects 0.3.0 → 0.4.0

data/lib/solid_objects/component_registration.rb

@@ -0,0 +1,117 @@
+# rbs_inline: enabled
+
+require "uri"
+
+module SolidObjects
+  class ComponentRegistration
+    # @rbs @reference: Reference
+    # @rbs @component_name: String
+    # @rbs @dependencies: Array[String]
+    # @rbs @instance_id: Integer
+    # @rbs @revision: Integer
+    # @rbs @refresh_path: String
+    # @rbs @token: String
+
+    attr_reader :reference,
+      :component_name,
+      :dependencies,
+      :instance_id,
+      :revision,
+      :refresh_path,
+      :token
+
+    # @rbs (reference: Reference, component_name: String, dependencies: Array[String], instance_id: Integer, revision: Integer, refresh_path: String, token: String) -> void
+    def initialize(
+      reference:,
+      component_name:,
+      dependencies:,
+      instance_id:,
+      revision:,
+      refresh_path:,
+      token:
+    )
+      @reference = reference
+      @component_name = component_name
+      @dependencies = dependencies.freeze
+      @instance_id = instance_id
+      @revision = revision
+      @refresh_path = refresh_path
+      @token = token
+    end
+
+    class << self
+      # @rbs (reference: Reference, component_name: String, dependencies: Array[String], snapshot: ActorSnapshot, refresh_path: String) -> ComponentRegistration
+      def issue(reference:, component_name:, dependencies:, snapshot:, refresh_path:)
+        token = ComponentToken.generate(
+          reference:,
+          component_name:,
+          dependencies:,
+          instance_id: snapshot.instance_id,
+          revision: snapshot.revision,
+          refresh_path:
+        )
+        new(
+          reference:,
+          component_name:,
+          dependencies:,
+          instance_id: snapshot.instance_id,
+          revision: snapshot.revision,
+          refresh_path:,
+          token:
+        )
+      end
+
+      # @rbs (String) -> ComponentRegistration
+      def from_token(token)
+        payload = ComponentToken.verify(token)
+        reference = Reference.new(
+          actor_type: payload.fetch("actor_type"),
+          actor_id: payload.fetch("actor_id")
+        )
+        dependencies = payload.fetch("dependencies")
+        validate_dependencies!(reference, dependencies)
+        new(
+          reference:,
+          component_name: payload.fetch("component_name"),
+          dependencies:,
+          instance_id: payload.fetch("instance_id"),
+          revision: payload.fetch("revision"),
+          refresh_path: payload.fetch("refresh_path"),
+          token:
+        )
+      rescue UnknownActorType, UnknownComponentDependency => error
+        raise InvalidComponentToken, error.message
+      end
+
+      private
+
+      # @rbs (Reference, Array[String]) -> void
+      def validate_dependencies!(reference, dependencies)
+        actor_class = SolidObjects.registry.fetch(reference.actor_type)
+        observables = actor_class.definition.observables
+        unknown = dependencies.find do |dependency|
+          !observables.key?(dependency.to_sym)
+        end
+        return unless unknown
+
+        raise UnknownComponentDependency,
+          "unknown observable dependency #{unknown.inspect} for #{reference.actor_type}"
+      end
+    end
+
+    # @rbs () -> Array[Integer]
+    def revision_key
+      [ instance_id, revision ]
+    end
+
+    # @rbs (Integer, Integer) -> String
+    def refresh_url(instance_id, revision)
+      query = URI.encode_www_form(
+        token:,
+        instance_id:,
+        revision:
+      )
+      "#{refresh_path}?#{query}"
+    end
+  end
+end

data/lib/solid_objects/component_renderer.rb

@@ -0,0 +1,82 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ComponentRenderer
+    # @rbs @snapshot: ActorSnapshot
+    # @rbs @component_name: String
+    # @rbs @dependencies: Array[String]
+    # @rbs @view_context: untyped
+    # @rbs @authorization_context: untyped
+
+    # @rbs (snapshot: ActorSnapshot, component_name: String, dependencies: Array[String], view_context: untyped, authorization_context: untyped) -> void
+    def initialize(
+      snapshot:,
+      component_name:,
+      dependencies:,
+      view_context:,
+      authorization_context:
+    )
+      @snapshot = snapshot
+      @component_name = component_name
+      @dependencies = dependencies
+      @view_context = view_context
+      @authorization_context = authorization_context
+    end
+
+    # @rbs () -> untyped
+    def call
+      [ component_name, *dependencies ].uniq.each do |authorization_name|
+        authorize_read!(authorization_name)
+      end
+      actor = ComponentView.new(
+        snapshot:,
+        dependencies:,
+        authorization_context:
+      )
+      view_context.render(
+        partial: default_partial,
+        locals: {
+          actor:,
+          authorization_context:
+        }
+      )
+    rescue ActionView::MissingTemplate
+      raise UnknownComponent,
+        "unknown component #{component_name.inspect} for #{snapshot.reference.actor_type}"
+    rescue ActionView::Template::Error => error
+      raise error.cause if error.cause.is_a?(SolidObjects::Error)
+
+      raise
+    end
+
+    private
+
+    attr_reader :snapshot,
+      :component_name,
+      :dependencies,
+      :view_context,
+      :authorization_context
+
+    # @rbs (String) -> void
+    def authorize_read!(observable_name)
+      authorized = SolidObjects.configuration.authorize_query.call(
+        actor_type: snapshot.reference.actor_type,
+        actor_id: snapshot.reference.actor_id,
+        message_name: observable_name,
+        arguments: {},
+        authorization_context:
+      )
+      return if authorized
+
+      raise Unauthorized, "actor component query is not authorized"
+    end
+
+    # @rbs () -> String
+    def default_partial
+      actor_name = snapshot.actor_class.name
+      raise InvalidActor, "anonymous actors cannot render reactive components" unless actor_name
+
+      "actors/#{actor_name.underscore}/#{component_name}"
+    end
+  end
+end

data/lib/solid_objects/component_subscriptions.rb

@@ -0,0 +1,109 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ComponentSubscriptions
+    MAXIMUM_COMPONENTS = 50
+    MAXIMUM_SERIALIZED_BYTES = 1_048_576
+
+    # @rbs @registrations: Array[ComponentRegistration]
+    # @rbs @revisions: Hash[String, Array[Integer]]
+
+    # @rbs (String?, reference: Reference) -> ComponentSubscriptions
+    def self.parse(serialized, reference:)
+      return new([]) unless serialized
+      unless serialized.is_a?(String) &&
+          serialized.bytesize <= MAXIMUM_SERIALIZED_BYTES
+        raise InvalidComponentToken, "invalid actor component registrations"
+      end
+
+      tokens = JSON.parse(serialized)
+      unless tokens.is_a?(Array) &&
+          tokens.length <= MAXIMUM_COMPONENTS &&
+          tokens.all? { |token| token.is_a?(String) }
+        raise InvalidComponentToken, "invalid actor component registrations"
+      end
+
+      registrations = tokens.map do |token|
+        ComponentRegistration.from_token(token).tap do |registration|
+          validate_identity!(registration, reference)
+        end
+      end
+      if registrations.map(&:component_name).uniq.length != registrations.length
+        raise InvalidComponentToken, "duplicate actor component registration"
+      end
+
+      new(registrations)
+    end
+
+    # @rbs (Array[ComponentRegistration]) -> void
+    def initialize(registrations)
+      @registrations = registrations
+      @revisions = registrations.to_h do |registration|
+        [ registration.component_name, registration.revision_key ]
+      end
+    end
+
+    # @rbs (Hash[String, untyped]) -> Array[String]
+    def refreshes_for(invalidation)
+      observable_name = invalidation.fetch("observable_name")
+      instance_id = invalidation.fetch("instance_id")
+      revision = invalidation.fetch("revision")
+      registrations.filter_map do |registration|
+        next unless registration.dependencies.include?(observable_name)
+        next unless newer_revision?(
+          registration.component_name,
+          instance_id,
+          revision
+        )
+
+        refresh(registration, instance_id, revision)
+      end
+    end
+
+    # @rbs (ActorSnapshot) -> Array[String]
+    def reconnect_refreshes(snapshot)
+      registrations.filter_map do |registration|
+        next unless newer_revision?(
+          registration.component_name,
+          snapshot.instance_id,
+          snapshot.revision
+        )
+
+        refresh(registration, snapshot.instance_id, snapshot.revision)
+      end
+    end
+
+    class << self
+      private
+
+      # @rbs (ComponentRegistration, Reference) -> void
+      def validate_identity!(registration, reference)
+        return if registration.reference.actor_type == reference.actor_type &&
+          registration.reference.actor_id == reference.actor_id
+
+        raise InvalidComponentToken,
+          "actor component identity does not match its subscription"
+      end
+    end
+
+    private
+
+    attr_reader :registrations, :revisions
+
+    # @rbs (ComponentRegistration, Integer, Integer) -> String
+    def refresh(registration, instance_id, revision)
+      revisions[registration.component_name] = [ instance_id, revision ]
+      TurboStreamRenderer.component_refresh(
+        registration,
+        instance_id,
+        revision
+      )
+    end
+
+    # @rbs (String, Integer, Integer) -> bool
+    def newer_revision?(component_name, instance_id, revision)
+      current = revisions.fetch(component_name)
+      (current <=> [ instance_id, revision ]) == -1
+    end
+  end
+end

data/lib/solid_objects/component_token.rb

@@ -0,0 +1,139 @@
+# rbs_inline: enabled
+
+require "active_support/message_verifier"
+
+module SolidObjects
+  module ComponentToken
+    PURPOSE = "solid_objects.actor_component"
+    MAXIMUM_TOKEN_BYTES = 16_384
+    MAXIMUM_DEPENDENCIES = 50
+
+    module_function
+
+    # @rbs (reference: Reference, component_name: String, dependencies: Array[String], instance_id: Integer, revision: Integer, refresh_path: String) -> String
+    def generate(
+      reference:,
+      component_name:,
+      dependencies:,
+      instance_id:,
+      revision:,
+      refresh_path:
+    )
+      payload = {
+        "actor_type" => reference.actor_type,
+        "actor_id" => reference.actor_id,
+        "component_name" => component_name,
+        "dependencies" => dependencies,
+        "instance_id" => instance_id,
+        "revision" => revision,
+        "refresh_path" => refresh_path
+      }
+      validate_payload!(payload)
+      verifier.generate(payload, purpose: PURPOSE).tap do |token|
+        raise InvalidComponentToken, "component token is too large" if token.bytesize > MAXIMUM_TOKEN_BYTES
+      end
+    end
+
+    # @rbs (String) -> Hash[String, untyped]
+    def verify(token)
+      unless token.is_a?(String) && token.bytesize <= MAXIMUM_TOKEN_BYTES
+        raise InvalidComponentToken, "invalid actor component token"
+      end
+
+      payload = verifier.verified(token, purpose: PURPOSE)
+      validate_payload!(payload)
+      payload
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      raise InvalidComponentToken, "invalid actor component token"
+    end
+
+    # @rbs (Hash[String, untyped]) -> Hash[String, untyped]
+    def validate_payload!(payload)
+      unless payload.is_a?(Hash) &&
+          payload["actor_type"].is_a?(String) &&
+          payload["actor_id"].is_a?(String) &&
+          payload["component_name"].is_a?(String) &&
+          payload["dependencies"].is_a?(Array) &&
+          payload["instance_id"].is_a?(Integer) &&
+          payload["revision"].is_a?(Integer) &&
+          payload["refresh_path"].is_a?(String)
+        raise InvalidComponentToken, "invalid actor component token"
+      end
+
+      validate_component_name!(payload.fetch("component_name"))
+      validate_dependencies!(payload.fetch("dependencies"))
+      validate_revision!(
+        payload.fetch("instance_id"),
+        payload.fetch("revision")
+      )
+      validate_refresh_path!(payload.fetch("refresh_path"))
+      payload
+    end
+    private_class_method :validate_payload!
+
+    # @rbs (String) -> void
+    def validate_component_name!(component_name)
+      return if component_name.match?(/\A[a-zA-Z0-9_]+\z/)
+
+      raise InvalidComponentToken, "invalid actor component name"
+    end
+    private_class_method :validate_component_name!
+
+    # @rbs (Array[untyped]) -> void
+    def validate_dependencies!(dependencies)
+      valid = dependencies.any? &&
+        dependencies.length <= MAXIMUM_DEPENDENCIES &&
+        dependencies.uniq.length == dependencies.length &&
+        dependencies.all? { |dependency| dependency.is_a?(String) && dependency.match?(/\A[a-zA-Z0-9_]+\z/) }
+      return if valid
+
+      raise InvalidComponentToken, "invalid actor component dependencies"
+    end
+    private_class_method :validate_dependencies!
+
+    # @rbs (Integer, Integer) -> void
+    def validate_revision!(instance_id, revision)
+      return unless instance_id.negative? || revision.negative?
+
+      raise InvalidComponentToken, "invalid actor component revision"
+    end
+    private_class_method :validate_revision!
+
+    # @rbs (String) -> void
+    def validate_refresh_path!(refresh_path)
+      valid = refresh_path.bytesize <= 2_048 &&
+        refresh_path.start_with?("/") &&
+        !refresh_path.start_with?("//") &&
+        !refresh_path.include?("\0") &&
+        !refresh_path.include?("?") &&
+        !refresh_path.include?("#")
+      return if valid
+
+      raise InvalidComponentToken, "invalid actor component refresh path"
+    end
+    private_class_method :validate_refresh_path!
+
+    # @rbs () -> ActiveSupport::MessageVerifier
+    def verifier
+      ActiveSupport::MessageVerifier.new(
+        signing_secret,
+        digest: "SHA256",
+        serializer: JSON
+      )
+    end
+    private_class_method :verifier
+
+    # @rbs () -> String
+    def signing_secret
+      configured_secret = SolidObjects.configuration.stream_signing_secret
+      return configured_secret if configured_secret
+
+      if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+        return Rails.application.key_generator.generate_key(PURPOSE, 64)
+      end
+
+      raise ArgumentError, "configure stream_signing_secret outside a Rails application"
+    end
+    private_class_method :signing_secret
+  end
+end

data/lib/solid_objects/component_view.rb

@@ -0,0 +1,67 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class ComponentView
+    # @rbs @snapshot: ActorSnapshot
+    # @rbs @dependencies: Array[String]
+    # @rbs @authorization_context: untyped
+
+    attr_reader :authorization_context
+
+    # @rbs (snapshot: ActorSnapshot, dependencies: Array[String], authorization_context: untyped) -> void
+    def initialize(snapshot:, dependencies:, authorization_context:)
+      @snapshot = snapshot
+      @dependencies = dependencies
+      @authorization_context = authorization_context
+    end
+
+    # @rbs () -> Reference
+    def reference
+      snapshot.reference
+    end
+
+    # @rbs () -> String
+    def actor_id
+      reference.actor_id
+    end
+
+    # @rbs () -> void
+    def state
+      raise UnknownComponentDependency,
+        "reactive components must read declared observables instead of actor.state"
+    end
+
+    # @rbs (Symbol, *untyped, **untyped) -> untyped
+    def method_missing(name, *arguments, **keywords)
+      return super unless arguments.empty? && keywords.empty?
+      return observable_value(name) if observable?(name)
+
+      super
+    end
+
+    # @rbs (Symbol, bool) -> bool
+    def respond_to_missing?(name, include_private = false)
+      observable?(name) || super
+    end
+
+    private
+
+    attr_reader :snapshot, :dependencies
+
+    # @rbs (Symbol | String) -> bool
+    def observable?(name)
+      snapshot.actor_class.definition.observables.key?(name.to_sym)
+    end
+
+    # @rbs (Symbol | String) -> untyped
+    def observable_value(name)
+      dependency = name.to_s
+      unless dependencies.include?(dependency)
+        raise UnknownComponentDependency,
+          "observable #{dependency.inspect} is not declared by this component"
+      end
+
+      snapshot.observable_value(dependency)
+    end
+  end
+end

data/lib/solid_objects/configuration.rb

@@ -34,6 +34,8 @@ module SolidObjects
     # @rbs @stream_signing_secret: String?
     # @rbs @broadcast_adapter: Proc?
     # @rbs @wake_up_adapter: untyped
+    # @rbs @component_path_resolver: Proc?
+    # @rbs @component_authorization_context: Proc
     # @rbs @authorize_message: Proc
     # @rbs @authorize_query: Proc
     # @rbs @authorize_destroy: Proc
@@ -72,6 +74,8 @@ module SolidObjects
       :stream_signing_secret,
       :broadcast_adapter,
       :wake_up_adapter,
+      :component_path_resolver,
+      :component_authorization_context,
       :authorize_message,
       :authorize_query,
       :authorize_destroy,
@@ -111,6 +115,8 @@ module SolidObjects
       @stream_signing_secret = nil
       @broadcast_adapter = nil
       @wake_up_adapter = nil
+      @component_path_resolver = nil
+      @component_authorization_context = ->(controller:) { controller }
       @logger = if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
         Rails.logger
       else
@@ -151,6 +157,12 @@ module SolidObjects
         raise ArgumentError, "actor type cannot be empty" if actor_type.to_s.empty?
         raise ArgumentError, "instance retention must be positive" unless retention.positive?
       end
+      unless component_path_resolver.nil? || component_path_resolver.respond_to?(:call)
+        raise ArgumentError, "component_path_resolver must respond to call"
+      end
+      unless component_authorization_context.respond_to?(:call)
+        raise ArgumentError, "component_authorization_context must respond to call"
+      end
 
       self
     end

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -3,11 +3,25 @@
 module SolidObjects
   module DatabaseAdapters
     class Sqlite < DatabaseAdapter
+      LOCK_RETRY_INTERVAL = 0.001
+
       # @rbs () -> String
       def current_time_expression
         "STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')"
       end
 
+      # @rbs () { () -> untyped } -> untyped
+      def transaction(&block)
+        return super unless SyncDeadline.active?
+
+        super
+      rescue DatabaseDeadlineExceeded
+        raise if SyncDeadline.expired?
+
+        sleep [ LOCK_RETRY_INTERVAL, SyncDeadline.remaining ].min
+        retry
+      end
+
       private
 
       # @rbs (untyped) { () -> untyped } -> untyped
@@ -15,9 +29,7 @@ module SolidObjects
         return yield unless SyncDeadline.active?
 
         previous_timeout = connection.select_value("PRAGMA busy_timeout").to_i
-        connection.execute(
-          "PRAGMA busy_timeout = #{SyncDeadline.remaining_milliseconds}"
-        )
+        connection.execute("PRAGMA busy_timeout = 0")
         yield
       ensure
         connection.execute("PRAGMA busy_timeout = #{previous_timeout}") if previous_timeout

data/lib/solid_objects/errors.rb

@@ -37,6 +37,18 @@ module SolidObjects
   class InvalidStreamToken < Error
   end
 
+  class InvalidComponentToken < Error
+  end
+
+  class UnknownComponent < Error
+  end
+
+  class UnknownComponentDependency < Error
+  end
+
+  class UnsupportedComponentRendering < Error
+  end
+
   class LostActivation < Error
   end
 

data/lib/solid_objects/executor.rb

@@ -98,6 +98,7 @@ module SolidObjects
         instance.update!(
           state: serialized_state,
           state_version: actor.class.state_version,
+          state_revision: locked_message.sequence,
           last_used_at: SolidObjects.database_adapter.database_now
         )
         locked_message.update!(

data/lib/solid_objects/stream_token.rb

@@ -5,33 +5,52 @@ require "active_support/message_verifier"
 module SolidObjects
   module StreamToken
     PURPOSE = "solid_objects.actor_stream"
+    MAXIMUM_OBSERVABLES = 100
 
     module_function
 
-    # @rbs (Reference) -> String
-    def generate(reference)
-      verifier.generate(
-        {
-          "actor_type" => reference.actor_type,
-          "actor_id" => reference.actor_id
-        },
-        purpose: PURPOSE
-      )
+    # @rbs (Reference, ?observables: Array[String]?) -> String
+    def generate(reference, observables: nil)
+      identity = {
+        "actor_type" => reference.actor_type,
+        "actor_id" => reference.actor_id
+      }
+      identity["observables"] = observables if observables
+      validate_identity!(identity)
+      verifier.generate(identity, purpose: PURPOSE)
     end
 
-    # @rbs (String) -> Hash[String, String]
+    # @rbs (String) -> Hash[String, untyped]
     def verify(token)
       identity = verifier.verified(token, purpose: PURPOSE)
+      validate_identity!(identity)
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      raise InvalidStreamToken, "invalid actor stream token"
+    end
+
+    # @rbs (Hash[String, untyped]) -> Hash[String, untyped]
+    def validate_identity!(identity)
       unless identity.is_a?(Hash) &&
           identity["actor_type"].is_a?(String) &&
           identity["actor_id"].is_a?(String)
         raise InvalidStreamToken, "invalid actor stream token"
       end
 
-      identity
-    rescue ActiveSupport::MessageVerifier::InvalidSignature
-      raise InvalidStreamToken, "invalid actor stream token"
+      observables = identity["observables"]
+      return identity unless observables
+
+      valid = observables.is_a?(Array) &&
+        observables.length <= MAXIMUM_OBSERVABLES &&
+        observables.uniq.length == observables.length &&
+        observables.all? do |observable|
+          observable.is_a?(String) &&
+            observable.match?(/\A[a-zA-Z0-9_]+\z/)
+        end
+      return identity if valid
+
+      raise InvalidStreamToken, "invalid actor stream observables"
     end
+    private_class_method :validate_identity!
 
     # @rbs () -> ActiveSupport::MessageVerifier
     def verifier