durable_streams-rails 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e6aafc0e3245798247add32c7232b17e7c54384f9ffbd58eaad6dcb64acd85b
-  data.tar.gz: 5729cbb4cc772f1c4bf44c343294a28ecd43a3b2990846984b77ae6bf2d3f25e
+  metadata.gz: 5c2dc408918802eb41264671f804a2bcee440341b56b53ef2f1e58fa77b84708
+  data.tar.gz: '0496a9b62af4f8ed219f0f6d31df0da2e7f6c6b9ee871de91b11acc1cce8d707'
 SHA512:
-  metadata.gz: 18f62ee08b52c3246844d1432c9e9890070a32f48ab84cad3f24e3af45cbdc254a737ed2ac67a7be2691e74c914fe90f80940ff4ad451ea7b86a36a043bc2ee2
-  data.tar.gz: fd42543375e15f3ec827e0b7699e60f60bc4785562a8e91c6a2ce168ce5a78e3f099e1cc211f7861294f54569417931c01287917913f75ac37cee1ba884ab7e2
+  metadata.gz: b4c1e809fdf66dd7b648156d5574c61f8d5ca47c365c60fd2eb4c5366fc7f87ec46bdbae0c32f848c7ef1f60863c9b96f2b5a706c9baff05f2dee082284a3e24
+  data.tar.gz: e41d5c76287f2ccbcf8a3224bb654b40087468d84796bc5c69ed9f37f7425b49a36450bf9e4bf0daec522aaeb9bff3152adc65fb531526b748296e4ea16f2a22

data/README.md

@@ -157,7 +157,7 @@ txid = comment.stream_upsert_to post
 comment.stream_delete_to post
 ```
 
-Asynchronous (via `DurableStreams::BroadcastJob`):
+Asynchronous (via `DurableStreams::Rails::BroadcastJob`):
 
 ```ruby
 comment.stream_insert_later_to post
@@ -210,7 +210,7 @@ end
 The gem provides test helpers that mirror Turbo's `assert_turbo_stream_broadcasts`. They are
 automatically included in `ActiveSupport::TestCase` via the engine.
 
-During tests, `DurableStreams::Testing` intercepts all broadcasts at the transport layer —
+During tests, `DurableStreams::Rails::Testing` intercepts all broadcasts at the transport layer —
 events are captured in-memory instead of being sent to the stream server. This means tests
 verify the Rails integration (DSL wiring, event shape, callbacks, jobs, suppression) without
 requiring a running Durable Streams server. Same pattern as Turbo, where `ActionCable::TestHelper`
@@ -249,13 +249,13 @@ This gem mirrors `turbo-rails` 1:1 in structure and design:
 
 | Turbo Rails | Durable Streams Rails | Role |
 |---|---|---|
-| `Turbo::Streams::StreamName` | `DurableStreams::StreamName` | Name generation (private `stream_name_from`) |
-| `Turbo::Streams::Broadcasts` | `DurableStreams::Broadcasts` | Flatten/compact guards, serialization, transport |
+| `Turbo::Streams::StreamName` | `DurableStreams::Rails::StreamName` | Name generation (private `stream_name_from`) |
+| `Turbo::Streams::Broadcasts` | `DurableStreams::Rails::Broadcasts` | Flatten/compact guards, serialization, transport |
 | `Turbo::StreamsChannel` | `DurableStreams` module | Entry point (extends StreamName + Broadcasts) |
-| `Turbo::Broadcastable` | `DurableStreams::Broadcastable` | Model concern, delegates to module |
-| `Turbo::Streams::ActionBroadcastJob` | `DurableStreams::BroadcastJob` | Async job, delegates to module |
-| `ActionCable::TestHelper` | `DurableStreams::Testing` | Test transport interception |
-| `Turbo::Broadcastable::TestHelper` | `DurableStreams::Broadcastable::TestHelper` | Test assertions |
+| `Turbo::Broadcastable` | `DurableStreams::Rails::Broadcastable` | Model concern, delegates to module |
+| `Turbo::Streams::ActionBroadcastJob` | `DurableStreams::Rails::BroadcastJob` | Async job, delegates to module |
+| `ActionCable::TestHelper` | `DurableStreams::Rails::Testing` | Test transport interception |
+| `Turbo::Broadcastable::TestHelper` | `DurableStreams::Rails::Broadcastable::TestHelper` | Test assertions |
 
 The key architectural difference: Turbo broadcasts HTML fragments over WebSockets (Action Cable).
 This gem broadcasts JSON State Protocol events over HTTP/SSE (Durable Streams).

data/app/controllers/durable_streams/rails/auth_controller.rb

@@ -0,0 +1,27 @@
+module DurableStreams
+  module Rails
+    class AuthController < ActionController::API
+      def verify
+        if request.headers["X-Forwarded-Uri"]
+          stream_name ? head(:ok) : head(:unauthorized)
+        elsif valid_server_api_key?
+          head :ok
+        else
+          head :unauthorized
+        end
+      end
+
+      private
+        def stream_name
+          DurableStreams.verify_signed_url(request.headers["X-Forwarded-Uri"])
+        end
+
+        def valid_server_api_key?
+          if auth_header = request.headers["Authorization"]
+            auth_header.start_with?("Bearer ") &&
+              ActiveSupport::SecurityUtils.secure_compare(auth_header.delete_prefix("Bearer "), DurableStreams.server_api_key)
+          end
+        end
+    end
+  end
+end

data/app/jobs/durable_streams/rails/broadcast_job.rb

@@ -0,0 +1,13 @@
+# The job that powers all the <tt>stream_*_later_to</tt> broadcasts available in <tt>DurableStreams::Rails::Broadcastable</tt>.
+module DurableStreams
+  module Rails
+    class 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
+  end
+end

data/app/models/concerns/durable_streams/{broadcastable.rb → rails/broadcastable.rb}

@@ -47,7 +47,7 @@
 #   Comment.suppressing_streams do
 #     Comment.create!(post: post) # This won't broadcast the insert event
 #   end
-module DurableStreams::Broadcastable
+module DurableStreams::Rails::Broadcastable
   extend ActiveSupport::Concern
 
   included do
@@ -155,7 +155,7 @@ module DurableStreams::Broadcastable
     stream_delete_to self
   end
 
-  # Same as <tt>#stream_insert_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  # Same as <tt>#stream_insert_to</tt> but run asynchronously via a <tt>DurableStreams::Rails::BroadcastJob</tt>.
   def stream_insert_later_to(*streamables)
     DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :insert)) unless suppressed_streams?
   end
@@ -165,7 +165,7 @@ module DurableStreams::Broadcastable
     stream_insert_later_to self
   end
 
-  # Same as <tt>#stream_update_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  # Same as <tt>#stream_update_to</tt> but run asynchronously via a <tt>DurableStreams::Rails::BroadcastJob</tt>.
   def stream_update_later_to(*streamables)
     DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :update)) unless suppressed_streams?
   end
@@ -175,7 +175,7 @@ module DurableStreams::Broadcastable
     stream_update_later_to self
   end
 
-  # Same as <tt>#stream_upsert_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  # Same as <tt>#stream_upsert_to</tt> but run asynchronously via a <tt>DurableStreams::Rails::BroadcastJob</tt>.
   def stream_upsert_later_to(*streamables)
     DurableStreams.broadcast_event_later_to(*streamables, **stream_event_attributes(operation: :upsert)) unless suppressed_streams?
   end
@@ -185,7 +185,7 @@ module DurableStreams::Broadcastable
     stream_upsert_later_to self
   end
 
-  # Same as <tt>#stream_delete_to</tt> but run asynchronously via a <tt>DurableStreams::BroadcastJob</tt>.
+  # Same as <tt>#stream_delete_to</tt> but run asynchronously via a <tt>DurableStreams::Rails::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

data/config/routes.rb

@@ -1,3 +1,3 @@
-Rails.application.routes.draw do
-  get "durable_streams/auth/verify", to: "durable_streams/auth#verify", as: :durable_streams_auth_verify
+::Rails.application.routes.draw do
+  get "durable_streams/auth/verify", to: "durable_streams/rails/auth#verify", as: :durable_streams_auth_verify
 end if DurableStreams.draw_routes

data/lib/durable_streams/rails/broadcastable/test_helper.rb

@@ -0,0 +1,159 @@
+module DurableStreams
+  module Rails
+    module Broadcastable
+      module TestHelper
+        extend ActiveSupport::Concern
+
+        included do
+          include DurableStreams::Rails::StreamName
+
+          setup    { DurableStreams::Rails::Testing.install! }
+          teardown { DurableStreams::Rails::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::Rails::Testing.messages_for(stream_name).map do |message|
+              if message.is_a?(String)
+                JSON.parse(message)
+              else
+                message
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/durable_streams/{broadcasts.rb → rails/broadcasts.rb}

@@ -1,10 +1,10 @@
 # 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
+# See <tt>DurableStreams::Rails::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
+module DurableStreams::Rails::Broadcasts
   def broadcast_event_to(*streamables, type:, key:, value:, operation:)
     streamables.flatten!
     streamables.compact_blank!
@@ -29,7 +29,7 @@ module DurableStreams::Broadcasts
     streamables.compact_blank!
 
     if streamables.present?
-      DurableStreams::BroadcastJob.perform_later \
+      DurableStreams::Rails::BroadcastJob.perform_later \
         stream_name_from(streamables),
         type: type, key: key, value: value, operation: operation.to_s
     end
@@ -46,8 +46,8 @@ module DurableStreams::Broadcasts
 
   private
     def append_to_stream(stream_name, message)
-      if DurableStreams::Testing.recording?
-        DurableStreams::Testing.record(stream_name, message)
+      if DurableStreams::Rails::Testing.recording?
+        DurableStreams::Rails::Testing.record(stream_name, message)
       else
         stream(stream_name).append(message)
       end

data/lib/durable_streams/rails/engine.rb

@@ -0,0 +1,71 @@
+require "rails/engine"
+
+module DurableStreams
+  module Rails
+    class Engine < ::Rails::Engine
+      isolate_namespace DurableStreams::Rails
+      config.durable_streams = ActiveSupport::OrderedOptions.new
+      config.autoload_once_paths = %W[
+        #{root}/app/controllers
+        #{root}/app/models
+        #{root}/app/models/concerns
+        #{root}/app/jobs
+      ]
+
+      # If the parent application does not use Active Job, app/jobs cannot
+      # be eager loaded, because it references the ActiveJob constant.
+      initializer "durable_streams_rails.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_rails.broadcastable" do
+        ActiveSupport.on_load(:active_record) do
+          if defined?(ActiveJob)
+            include DurableStreams::Rails::Broadcastable
+          end
+        end
+      end
+
+      initializer "durable_streams_rails.configs" do
+        config.after_initialize do |app|
+          DurableStreams.draw_routes = app.config.durable_streams.draw_routes != false
+        end
+      end
+
+      initializer "durable_streams_rails.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_rails.server_api_key" do
+        config.after_initialize do
+          DurableStreams.server_api_key =
+            config.durable_streams.server_api_key ||
+            ::Rails.application.key_generator.generate_key("durable_streams/server_api_key").unpack1("H*")
+
+          if DurableStreams.base_url.present?
+            DurableStreams.configure do |c|
+              c.base_url = DurableStreams.base_url
+              c.default_headers = { "Authorization" => "Bearer #{DurableStreams.server_api_key}" }
+            end
+          end
+        end
+      end
+
+      # No Action Cable dependency -- load test helpers directly.
+      initializer "durable_streams_rails.test_assertions" do
+        ActiveSupport.on_load(:active_support_test_case) do
+          if defined?(ActiveJob)
+            require "durable_streams/rails/broadcastable/test_helper"
+            include DurableStreams::Rails::Broadcastable::TestHelper
+          end
+        end
+      end
+    end
+  end
+end

data/lib/durable_streams/rails/server_config.rb

@@ -0,0 +1,64 @@
+require "yaml"
+require "erb"
+
+module DurableStreams
+  module Rails
+    class ServerConfig
+      TEMPLATE = ERB.new(<<~'CADDYFILE', trim_mode: "-")
+        {
+        	admin off
+        <%- unless @config["domain"] -%>
+        	auto_https off
+        <%- end -%>
+        }
+
+        <%= address %> {
+        	route <%= route_path %> {
+        		forward_auth <%= auth["url"] %> {
+        			uri <%= auth["path"] %>
+        <%- copy_headers.each do |header| -%>
+        			copy_headers <%= header %>
+        <%- end -%>
+        		}
+        		durable_streams<%= storage_block %>
+        	}
+        }
+      CADDYFILE
+
+      def self.generate(config_path, environment)
+        new(config_path, environment).generate
+      end
+
+      def initialize(config_path, environment)
+        @config = YAML.load_file(config_path, aliases: true).fetch(environment)
+      end
+
+      def generate
+        TEMPLATE.result(binding)
+      end
+
+      private
+        def address
+          @config["domain"] || ":#{@config.fetch("port", 4437)}"
+        end
+
+        def route_path
+          @config.fetch("route", "/v1/streams/*")
+        end
+
+        def auth
+          @config.fetch("auth")
+        end
+
+        def copy_headers
+          auth.fetch("copy_headers", [ "Cookie" ])
+        end
+
+        def storage_block
+          if dir = @config.dig("storage", "data_dir")
+            " {\n\t\t\tdata_dir #{dir}\n\t\t}"
+          end
+        end
+    end
+  end
+end

data/lib/durable_streams/{stream_name.rb → rails/stream_name.rb}

@@ -2,7 +2,7 @@
 # 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
+module DurableStreams::Rails::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

data/lib/durable_streams/{testing.rb → rails/testing.rb}

@@ -1,12 +1,12 @@
 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.
+# Activated by <tt>DurableStreams::Rails::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
+module DurableStreams::Rails::Testing
   thread_mattr_accessor :messages
 
   class << self

data/lib/durable_streams/rails/version.rb

@@ -0,0 +1,5 @@
+module DurableStreams
+  module Rails
+    VERSION = "0.3.0"
+  end
+end

data/lib/durable_streams-rails.rb

@@ -1,14 +1,14 @@
 require "durable_streams"
-require "durable_streams/stream_name"
-require "durable_streams/broadcasts"
-require "durable_streams/testing"
-require "durable_streams/engine"
+require "durable_streams/rails/stream_name"
+require "durable_streams/rails/broadcasts"
+require "durable_streams/rails/testing"
+require "durable_streams/rails/engine"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
 module DurableStreams
   extend ActiveSupport::Autoload
-  extend DurableStreams::StreamName
-  extend DurableStreams::Broadcasts
+  extend DurableStreams::Rails::StreamName
+  extend DurableStreams::Rails::Broadcasts
 
   mattr_accessor :base_url
   mattr_accessor :draw_routes, default: true
@@ -55,7 +55,7 @@ module DurableStreams
       # Idempotent — the server returns 200 when the stream already exists with matching config.
       # Skipped during tests (no server) and when base_url is not configured.
       def ensure_stream_exists(stream_name)
-        return if DurableStreams::Testing.recording?
+        return if DurableStreams::Rails::Testing.recording?
 
         stream(stream_name).create_stream(content_type: "application/json")
       rescue DurableStreams::StreamExistsError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: durable_streams-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - tokimonki
@@ -48,18 +48,18 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/controllers/durable_streams/auth_controller.rb
-- app/jobs/durable_streams/broadcast_job.rb
-- app/models/concerns/durable_streams/broadcastable.rb
+- app/controllers/durable_streams/rails/auth_controller.rb
+- app/jobs/durable_streams/rails/broadcast_job.rb
+- app/models/concerns/durable_streams/rails/broadcastable.rb
 - config/routes.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/server_config.rb
-- lib/durable_streams/stream_name.rb
-- lib/durable_streams/testing.rb
-- lib/durable_streams/version.rb
+- lib/durable_streams/rails/broadcastable/test_helper.rb
+- lib/durable_streams/rails/broadcasts.rb
+- lib/durable_streams/rails/engine.rb
+- lib/durable_streams/rails/server_config.rb
+- lib/durable_streams/rails/stream_name.rb
+- lib/durable_streams/rails/testing.rb
+- lib/durable_streams/rails/version.rb
 - lib/generators/durable_streams/install/USAGE
 - lib/generators/durable_streams/install/install_generator.rb
 - lib/generators/durable_streams/install/templates/bin/durable-streams.tt

data/app/controllers/durable_streams/auth_controller.rb

@@ -1,25 +0,0 @@
-module DurableStreams
-  class AuthController < ActionController::API
-    def verify
-      if request.headers["X-Forwarded-Uri"]
-        stream_name ? head(:ok) : head(:unauthorized)
-      elsif valid_server_api_key?
-        head :ok
-      else
-        head :unauthorized
-      end
-    end
-
-    private
-      def stream_name
-        DurableStreams.verify_signed_url(request.headers["X-Forwarded-Uri"])
-      end
-
-      def valid_server_api_key?
-        if auth_header = request.headers["Authorization"]
-          auth_header.start_with?("Bearer ") &&
-            ActiveSupport::SecurityUtils.secure_compare(auth_header.delete_prefix("Bearer "), DurableStreams.server_api_key)
-        end
-      end
-  end
-end

data/app/jobs/durable_streams/broadcast_job.rb

@@ -1,9 +0,0 @@
-# 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/lib/durable_streams/broadcastable/test_helper.rb

@@ -1,157 +0,0 @@
-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/engine.rb

@@ -1,70 +0,0 @@
-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/controllers
-      #{root}/app/models
-      #{root}/app/models/concerns
-      #{root}/app/jobs
-    )
-
-    # If the parent application does not use Active Job, app/jobs cannot
-    # be eager loaded, because it references the ActiveJob constant.
-    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.configs" do
-      config.after_initialize do |app|
-        DurableStreams.draw_routes = app.config.durable_streams.draw_routes != false
-      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.server_api_key" do
-      config.after_initialize do
-        DurableStreams.server_api_key =
-          config.durable_streams.server_api_key ||
-          Rails.application.key_generator.generate_key("durable_streams/server_api_key").unpack1("H*")
-
-        if DurableStreams.base_url.present?
-          DurableStreams.configure do |c|
-            c.base_url = DurableStreams.base_url
-            c.default_headers = { "Authorization" => "Bearer #{DurableStreams.server_api_key}" }
-          end
-        end
-      end
-    end
-
-    # No Action Cable dependency -- load test helpers directly.
-    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/server_config.rb

@@ -1,62 +0,0 @@
-require "yaml"
-require "erb"
-
-module DurableStreams
-  class ServerConfig
-    TEMPLATE = ERB.new(<<~'CADDYFILE', trim_mode: "-")
-      {
-      	admin off
-      <%- unless @config["domain"] -%>
-      	auto_https off
-      <%- end -%>
-      }
-
-      <%= address %> {
-      	route <%= route_path %> {
-      		forward_auth <%= auth["url"] %> {
-      			uri <%= auth["path"] %>
-      <%- copy_headers.each do |header| -%>
-      			copy_headers <%= header %>
-      <%- end -%>
-      		}
-      		durable_streams<%= storage_block %>
-      	}
-      }
-    CADDYFILE
-
-    def self.generate(config_path, environment)
-      new(config_path, environment).generate
-    end
-
-    def initialize(config_path, environment)
-      @config = YAML.load_file(config_path, aliases: true).fetch(environment)
-    end
-
-    def generate
-      TEMPLATE.result(binding)
-    end
-
-    private
-      def address
-        @config["domain"] || ":#{@config.fetch("port", 4437)}"
-      end
-
-      def route_path
-        @config.fetch("route", "/v1/streams/*")
-      end
-
-      def auth
-        @config.fetch("auth")
-      end
-
-      def copy_headers
-        auth.fetch("copy_headers", [ "Cookie" ])
-      end
-
-      def storage_block
-        if dir = @config.dig("storage", "data_dir")
-          " {\n\t\t\tdata_dir #{dir}\n\t\t}"
-        end
-      end
-  end
-end

data/lib/durable_streams/version.rb

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