durable_streams-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee437ac73b405cba8114f0a9b38a69f20a70fceb86aa80998b82396af577b133
+  data.tar.gz: ce7306811c5b50cab5490102353399a2e14ca1bf23564c93931c0d5344f656b5
+SHA512:
+  metadata.gz: 7dba804eeefe0a329b0cc314cfcd595982a0d3eaf5b7e359fd5816998f14668ff28453017c826e7f3cc693c5065e20a81ab68b4cb995c7424da27cbc3956b50f
+  data.tar.gz: 71f865a9adec22871977e3e97b7cf2ce4ac7a3d5902f6e0583737c3388c93b257b98ee96240613ca2a9e1829aadb8bcb22ed27796e90508a5f9a9b93415e7d25

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) tokimonki
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/setup"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/app/jobs/durable_streams/broadcast_job.rb

@@ -0,0 +1,9 @@
+# The job that powers all the <tt>stream_*_later_to</tt> broadcasts available in <tt>DurableStreams::Broadcastable</tt>.
+class DurableStreams::BroadcastJob < ActiveJob::Base
+  discard_on ActiveJob::DeserializationError
+  retry_on DurableStreams::ConnectionError, wait: :polynomially_longer, attempts: 10
+
+  def perform(stream_name, type:, key:, value:, operation:)
+    DurableStreams.broadcast_event_to stream_name, type: type, key: key, value: value, operation: operation
+  end
+end

data/app/models/concerns/durable_streams/broadcastable.rb

@@ -0,0 +1,202 @@
+# Durable Streams can be broadcast directly from models that include this module (automatically
+# done for Active Records via the engine). This makes it convenient to execute both synchronous
+# and asynchronous State Protocol broadcasts from callbacks or controllers. Here's an example:
+#
+#   class Comment < ApplicationRecord
+#     belongs_to :post
+#
+#     after_create_commit :broadcast_later
+#
+#     private
+#       def broadcast_later
+#         stream_insert_later_to post
+#       end
+#   end
+#
+# This broadcasts a State Protocol insert event to the stream derived from the post association.
+# All clients subscribed to that stream will receive the event as an SSE message.
+#
+# There are four basic operations you can broadcast: <tt>insert</tt>, <tt>update</tt>, <tt>upsert</tt>,
+# and <tt>delete</tt>. As a rule, you should use the <tt>_later</tt> versions when broadcasting within
+# a real-time path, like a controller or model callback, since those go through a background job.
+#
+# == Declarative streaming
+#
+# For the common case of broadcasting creates, updates, and destroys, you can use the class-level
+# <tt>streams_to</tt> declaration:
+#
+#   class Comment < ApplicationRecord
+#     belongs_to :post
+#     streams_to :post
+#   end
+#
+# This is equivalent to registering +after_create_commit+, +after_update_commit+, and
+# +after_destroy_commit+ callbacks that broadcast the appropriate State Protocol events.
+#
+# When the stream target is the model itself, use the self-targeting <tt>streams</tt> declaration:
+#
+#   class Board < ApplicationRecord
+#     streams
+#   end
+#
+# == Suppressing broadcasts
+#
+# Sometimes, you need to disable broadcasts in certain scenarios. You can use <tt>.suppressing_streams</tt>
+# to create execution contexts where broadcasts are disabled:
+#
+#   Comment.suppressing_streams do
+#     Comment.create!(post: post) # This won't broadcast the insert event
+#   end
+module DurableStreams::Broadcastable
+  extend ActiveSupport::Concern
+
+  included do
+    thread_mattr_accessor :suppressed_streams, instance_accessor: false
+    delegate :suppressed_streams?, to: "self.class"
+  end
+
+  module ClassMethods
+    # Configures the model to broadcast creates, updates, and destroys to a stream name derived at runtime by the
+    # <tt>stream</tt> symbol invocation. Examples:
+    #
+    #   class Comment < ApplicationRecord
+    #     belongs_to :post
+    #     streams_to :post
+    #   end
+    #
+    #   class Comment < ApplicationRecord
+    #     belongs_to :post
+    #     streams_to ->(comment) { [ comment.post, :comments ] }
+    #   end
+    def streams_to(stream)
+      after_create_commit  -> { stream_insert_later_to(stream.try(:call, self) || send(stream)) }
+      after_update_commit  -> { stream_update_later_to(stream.try(:call, self) || send(stream)) }
+      after_destroy_commit -> { stream_delete_later_to(stream.try(:call, self) || send(stream)) }
+    end
+
+    # Same as <tt>#streams_to</tt>, but the designated stream is automatically set to the current model,
+    # which can be overridden by passing <tt>stream</tt>. Examples:
+    #
+    #   class Board < ApplicationRecord
+    #     streams
+    #   end
+    #
+    #   class Board < ApplicationRecord
+    #     streams "boards"
+    #   end
+    def streams(stream = model_name.plural)
+      after_create_commit  -> { stream_insert_later_to(stream) }
+      after_update_commit  -> { stream_update_later }
+      after_destroy_commit -> { stream_delete_later }
+    end
+
+    # Executes +block+ preventing both synchronous and asynchronous broadcasts from this model.
+    def suppressing_streams(&block)
+      original, self.suppressed_streams = self.suppressed_streams, true
+      yield
+    ensure
+      self.suppressed_streams = original
+    end
+
+    def suppressed_streams?
+      suppressed_streams
+    end
+  end
+
+  # Broadcast a State Protocol insert event to the stream identified by the passed <tt>streamables</tt>.
+  # Returns the +txid+ that can be used for optimistic update confirmation. Example:
+  #
+  #   # Broadcasts {"type":"message","key":"5","value":{...},"headers":{"operation":"insert"}}
+  #   txid = message.stream_insert_to post, :messages
+  #   render json: { txid: txid }
+  def stream_insert_to(*streamables)
+    DurableStreams.broadcast_event_to(*streamables, **stream_event_attributes(operation: :insert)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_insert_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_insert
+    stream_insert_to self
+  end
+
+  # Broadcast a State Protocol update event to the stream identified by the passed <tt>streamables</tt>. Example:
+  #
+  #   message.stream_update_to post
+  def stream_update_to(*streamables)
+    DurableStreams.broadcast_event_to(*streamables, **stream_event_attributes(operation: :update)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_update_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_update
+    stream_update_to self
+  end
+
+  # Broadcast a State Protocol upsert event to the stream identified by the passed <tt>streamables</tt>. Example:
+  #
+  #   message.stream_upsert_to post
+  def stream_upsert_to(*streamables)
+    DurableStreams.broadcast_event_to(*streamables, **stream_event_attributes(operation: :upsert)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_upsert_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_upsert
+    stream_upsert_to self
+  end
+
+  # Broadcast a State Protocol delete event to the stream identified by the passed <tt>streamables</tt>.
+  # The value is nil — only the key is needed for deletes. Example:
+  #
+  #   message.stream_delete_to post
+  def stream_delete_to(*streamables)
+    DurableStreams.broadcast_event_to(*streamables, **stream_event_attributes(operation: :delete, value: nil)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_delete_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_delete
+    stream_delete_to self
+  end
+
+  # Same as <tt>#stream_insert_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  def stream_insert_later_to(*streamables)
+    DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :insert)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_insert_later_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_insert_later
+    stream_insert_later_to self
+  end
+
+  # Same as <tt>#stream_update_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  def stream_update_later_to(*streamables)
+    DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :update)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_update_later_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_update_later
+    stream_update_later_to self
+  end
+
+  # Same as <tt>#stream_upsert_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  def stream_upsert_later_to(*streamables)
+    DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :upsert)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_upsert_later_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_upsert_later
+    stream_upsert_later_to self
+  end
+
+  # Same as <tt>#stream_delete_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  def stream_delete_later_to(*streamables)
+    DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :delete, value: nil)) unless suppressed_streams?
+  end
+
+  # Same as <tt>#stream_delete_later_to</tt>, but the designated stream is automatically set to the current model.
+  def stream_delete_later
+    stream_delete_later_to self
+  end
+
+  private
+    def stream_event_attributes(operation:, value: as_json)
+      { type: model_name.singular, key: id.to_s, value: value, operation: operation }
+    end
+end

data/lib/durable_streams/broadcastable/test_helper.rb

@@ -0,0 +1,157 @@
+module DurableStreams
+  module Broadcastable
+    module TestHelper
+      extend ActiveSupport::Concern
+
+      included do
+        include DurableStreams::StreamName
+
+        setup    { DurableStreams::Testing.install! }
+        teardown { DurableStreams::Testing.reset! }
+      end
+
+      # Asserts that State Protocol events were broadcast to a stream
+      #
+      # ==== Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   stream name, or the name itself
+      # * <tt>&block</tt> optional block executed before the
+      #   assertion
+      #
+      # ==== Options
+      #
+      # * <tt>count:</tt> the number of events that are expected to be broadcast
+      #
+      # Asserts events were broadcast:
+      #
+      #     comment = Comment.find(1)
+      #     comment.stream_insert_to comment.post
+      #
+      #     assert_stream_broadcasts comment.post
+      #
+      # Asserts that two events were broadcast:
+      #
+      #     comment = Comment.find(1)
+      #     comment.stream_insert_to comment.post
+      #     comment.stream_update_to comment.post
+      #
+      #     assert_stream_broadcasts comment.post, count: 2
+      #
+      # You can pass a block to run before the assertion:
+      #
+      #     comment = Comment.find(1)
+      #
+      #     assert_stream_broadcasts comment.post do
+      #       comment.stream_insert_to comment.post
+      #     end
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the stream name:
+      #
+      #     post = Post.find(1)
+      #
+      #     assert_stream_broadcasts post do
+      #       post.comments.create!(body: "Hello")
+      #     end
+      #
+      def assert_stream_broadcasts(stream_name_or_object, count: nil, &block)
+        payloads = capture_stream_broadcasts(stream_name_or_object, &block)
+        stream_name = stream_name_from(stream_name_or_object)
+
+        if count.nil?
+          assert_not_empty payloads, "Expected at least one broadcast on #{stream_name.inspect}, but there were none"
+        else
+          broadcasts = "Durable Stream broadcast".pluralize(count)
+
+          assert count == payloads.count, "Expected #{count} #{broadcasts} on #{stream_name.inspect}, but there were #{payloads.count}"
+        end
+      end
+
+      # Asserts that no State Protocol events were broadcast to a stream
+      #
+      # ==== Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   stream name, or the name itself
+      # * <tt>&block</tt> optional block executed before the
+      #   assertion
+      #
+      # Asserts that no events were broadcast:
+      #
+      #     assert_no_stream_broadcasts "messages" do
+      #       # do something other than broadcast to "messages"
+      #     end
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the stream name:
+      #
+      #     post = Post.find(1)
+      #
+      #     assert_no_stream_broadcasts post do
+      #       # do something other than broadcast to post's stream
+      #     end
+      #
+      def assert_no_stream_broadcasts(stream_name_or_object, &block)
+        block&.call
+
+        stream_name = stream_name_from(stream_name_or_object)
+        payloads = stream_broadcasts_for(stream_name)
+
+        assert payloads.empty?, "Expected no broadcasts on #{stream_name.inspect}, but there were #{payloads.count}"
+      end
+
+      # Captures any State Protocol events that were broadcast to a stream
+      #
+      # ==== Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   stream name, or the name itself
+      # * <tt>&block</tt> optional block to capture broadcasts during execution
+      #
+      # Returns any events that have been broadcast as an Array of parsed JSON hashes
+      #
+      #     comment = Comment.find(1)
+      #     comment.stream_insert_to comment.post
+      #     comment.stream_update_to comment.post
+      #
+      #     events = capture_stream_broadcasts comment.post
+      #
+      #     assert_equal "insert", events.first["headers"]["operation"]
+      #     assert_equal "update", events.second["headers"]["operation"]
+      #
+      # You can pass a block to limit the scope of the broadcasts being captured:
+      #
+      #     comment = Comment.find(1)
+      #
+      #     events = capture_stream_broadcasts comment.post do
+      #       comment.stream_insert_to comment.post
+      #     end
+      #
+      #     assert_equal "insert", events.first["headers"]["operation"]
+      #
+      def capture_stream_broadcasts(stream_name_or_object, &block)
+        stream_name = stream_name_from(stream_name_or_object)
+
+        if block_given?
+          before = stream_broadcasts_for(stream_name).size
+          block.call
+          stream_broadcasts_for(stream_name)[before..]
+        else
+          stream_broadcasts_for(stream_name)
+        end
+      end
+
+      private
+        def stream_broadcasts_for(stream_name)
+          DurableStreams::Testing.messages_for(stream_name).map do |message|
+            if message.is_a?(String)
+              JSON.parse(message)
+            else
+              message
+            end
+          end
+        end
+    end
+  end
+end

data/lib/durable_streams/broadcasts.rb

@@ -0,0 +1,55 @@
+# Provides the broadcast actions in synchronous and asynchronous form for the <tt>DurableStreams</tt> module.
+# See <tt>DurableStreams::Broadcastable</tt> for the user-facing API that invokes these methods with most of the
+# paperwork filled out already.
+#
+# Can be used directly using something like <tt>DurableStreams.broadcast_event_to :room, type: "message", key: "5",
+# value: { content: "Hello" }, operation: :insert</tt>.
+module DurableStreams::Broadcasts
+  def broadcast_event_to(*streamables, type:, key:, value:, operation:)
+    streamables.flatten!
+    streamables.compact_blank!
+
+    if streamables.present?
+      txid = SecureRandom.uuid
+
+      append_to_stream(
+        stream_name_from(streamables),
+        JSON.generate({
+          type: type, key: key, value: value,
+          headers: { operation: operation, txid: txid }
+        })
+      )
+
+      txid
+    end
+  end
+
+  def broadcast_event_later_to(*streamables, type:, key:, value:, operation:)
+    streamables.flatten!
+    streamables.compact_blank!
+
+    if streamables.present?
+      DurableStreams::BroadcastJob.perform_later \
+        stream_name_from(streamables),
+        type: type, key: key, value: value, operation: operation.to_s
+    end
+  end
+
+  def broadcast_to(*streamables, **payload)
+    streamables.flatten!
+    streamables.compact_blank!
+
+    if streamables.present?
+      append_to_stream(stream_name_from(streamables), JSON.generate(payload))
+    end
+  end
+
+  private
+    def append_to_stream(stream_name, message)
+      if DurableStreams::Testing.recording?
+        DurableStreams::Testing.record(stream_name, message)
+      else
+        stream(stream_name).append(message)
+      end
+    end
+end

data/lib/durable_streams/engine.rb

@@ -0,0 +1,45 @@
+require "rails/engine"
+
+module DurableStreams
+  class Engine < Rails::Engine
+    isolate_namespace DurableStreams
+    config.eager_load_namespaces << DurableStreams
+    config.durable_streams = ActiveSupport::OrderedOptions.new
+    config.autoload_once_paths = %W(
+      #{root}/app/models
+      #{root}/app/models/concerns
+      #{root}/app/jobs
+    )
+
+    initializer "durable_streams.no_active_job", before: :set_eager_load_paths do
+      unless defined?(ActiveJob)
+        Rails.autoloaders.once.do_not_eager_load("#{root}/app/jobs")
+      end
+    end
+
+    initializer "durable_streams.broadcastable" do
+      ActiveSupport.on_load(:active_record) do
+        if defined?(ActiveJob)
+          include DurableStreams::Broadcastable
+        end
+      end
+    end
+
+    initializer "durable_streams.signed_stream_verifier_key" do
+      config.after_initialize do
+        DurableStreams.signed_stream_verifier_key =
+          config.durable_streams&.signed_stream_verifier_key ||
+          Rails.application.key_generator.generate_key("durable_streams/signed_stream_verifier_key")
+      end
+    end
+
+    initializer "durable_streams.test_assertions" do
+      ActiveSupport.on_load(:active_support_test_case) do
+        if defined?(ActiveJob)
+          require "durable_streams/broadcastable/test_helper"
+          include DurableStreams::Broadcastable::TestHelper
+        end
+      end
+    end
+  end
+end

data/lib/durable_streams/stream_name.rb

@@ -0,0 +1,24 @@
+# Stream names are how we identify which updates should go to which subscribers. Since stream names
+# are exposed directly to the client via signed URL tokens, we need to ensure that the name isn't
+# tampered with, so the names are signed upon generation and verified upon receipt. All verification
+# happens through the <tt>DurableStreams.signed_stream_verifier</tt>.
+module DurableStreams::StreamName
+  # Used by the stream auth endpoint to verify a signed stream name.
+  def verified_stream_name(signed_stream_name)
+    DurableStreams.signed_stream_verifier.verified signed_stream_name
+  end
+
+  # Used by <tt>DurableStreams.signed_stream_url</tt> to generate a signed stream name.
+  def signed_stream_name(streamables)
+    DurableStreams.signed_stream_verifier.generate stream_name_from(streamables)
+  end
+
+  private
+    def stream_name_from(streamables)
+      if streamables.is_a?(Array)
+        streamables.map  { |streamable| stream_name_from(streamable) }.join("/")
+      else
+        streamables.then { |streamable| streamable.try(:to_gid_param) || streamable.to_param }
+      end
+    end
+end

data/lib/durable_streams/testing.rb

@@ -0,0 +1,33 @@
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+
+# Intercepts stream appends during tests, similar to how <tt>ActionCable::TestHelper</tt> captures broadcasts.
+# Activated by <tt>DurableStreams::Broadcastable::TestHelper</tt> via +setup+/+teardown+ hooks.
+#
+# When installed, all calls to <tt>DurableStreams.broadcast_event_to</tt> and <tt>DurableStreams.broadcast_to</tt>
+# are recorded in memory instead of being sent to the stream server. Captured messages can be inspected via
+# <tt>messages_for</tt>.
+module DurableStreams::Testing
+  thread_mattr_accessor :messages
+
+  class << self
+    def install!
+      self.messages = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def reset!
+      self.messages = nil
+    end
+
+    def recording?
+      messages.present?
+    end
+
+    def record(stream_name, message)
+      messages[stream_name] << message if recording?
+    end
+
+    def messages_for(stream_name)
+      (messages || {})[stream_name] || []
+    end
+  end
+end

data/lib/durable_streams/version.rb

@@ -0,0 +1,3 @@
+module DurableStreams
+  RAILS_VERSION = "0.1.0"
+end

data/lib/durable_streams-rails.rb

@@ -0,0 +1,30 @@
+require "durable_streams/stream_name"
+require "durable_streams/broadcasts"
+require "durable_streams/testing"
+require "durable_streams/engine"
+require "active_support/core_ext/module/attribute_accessors_per_thread"
+
+module DurableStreams
+  extend DurableStreams::StreamName
+  extend DurableStreams::Broadcasts
+
+  mattr_accessor :base_url
+
+  class << self
+    attr_writer :signed_stream_verifier_key
+
+    def signed_stream_verifier
+      @signed_stream_verifier ||= ActiveSupport::MessageVerifier.new(signed_stream_verifier_key, digest: "SHA256", serializer: JSON)
+    end
+
+    def signed_stream_verifier_key
+      @signed_stream_verifier_key or raise ArgumentError, "DurableStreams requires a signed_stream_verifier_key"
+    end
+
+    def signed_stream_url(*streamables, expires_in: 24.hours)
+      path = stream_name_from(streamables)
+      token = signed_stream_verifier.generate(path, expires_in: expires_in)
+      "#{base_url}/#{path}?token=#{token}"
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: durable_streams-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- tokimonki
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: durable_streams
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.0
+email: opensource@tokimonki.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- app/jobs/durable_streams/broadcast_job.rb
+- app/models/concerns/durable_streams/broadcastable.rb
+- lib/durable_streams-rails.rb
+- lib/durable_streams/broadcastable/test_helper.rb
+- lib/durable_streams/broadcasts.rb
+- lib/durable_streams/engine.rb
+- lib/durable_streams/stream_name.rb
+- lib/durable_streams/testing.rb
+- lib/durable_streams/version.rb
+homepage: https://github.com/tokimonki/durable_streams-rails
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Durable Streams integration for Rails
+test_files: []