durable_streams-rails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee437ac73b405cba8114f0a9b38a69f20a70fceb86aa80998b82396af577b133
-  data.tar.gz: ce7306811c5b50cab5490102353399a2e14ca1bf23564c93931c0d5344f656b5
+  metadata.gz: 486bb79705018c3e6bfbdaa56f2b072b0ac3781c54e07a9cc16c62e9834bfed9
+  data.tar.gz: 9f73ab9352ba33d19eb079503d04a865567eb0cddb4810acba6e223d8b9de461
 SHA512:
-  metadata.gz: 7dba804eeefe0a329b0cc314cfcd595982a0d3eaf5b7e359fd5816998f14668ff28453017c826e7f3cc693c5065e20a81ab68b4cb995c7424da27cbc3956b50f
-  data.tar.gz: 71f865a9adec22871977e3e97b7cf2ce4ac7a3d5902f6e0583737c3388c93b257b98ee96240613ca2a9e1829aadb8bcb22ed27796e90508a5f9a9b93415e7d25
+  metadata.gz: 86aae6ff003e0f17253c8efa06780b0cabb18a58f6c0aad1abd0373c85797db95ce08ecc42785d72ffb3a46c756a0702324df9f0fa4f50dc751e1f1ff375a5ae
+  data.tar.gz: 44c1c3aac3c5a9d0d96e76cd39e80471d2796dae296cbb60c1fc73bc46b8f63fdcea1d2cfb4d1a270639b3c8318b6716f98e322cfce289a7ee0bc22099903cd0

data/README.md

@@ -0,0 +1,274 @@
+# Durable Streams Rails
+
+Durable Streams integration for Rails. Stream State Protocol events from your models to clients
+over SSE with the same developer experience as Turbo Broadcasts — but with offset-based
+resumability, persistent event logs, and no WebSocket infrastructure.
+
+```ruby
+class Comment < ApplicationRecord
+  belongs_to :post
+  streams_to :post
+end
+```
+
+That's it. Creates, updates, and destroys are broadcast as State Protocol events to all clients
+subscribed to the post's stream. No manual stream management, no JSON serialization, no offset
+tracking.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "durable_streams-rails"
+```
+
+Run the install generator:
+
+```bash
+bin/rails generate durable_streams:install
+```
+
+This creates:
+
+- `config/initializers/durable_streams.rb` — sets the stream server URL
+- `config/durable_streams.yml` — server configuration (per environment)
+- `bin/durable-streams` — binstub that auto-downloads and runs the server binary
+- Updates `Procfile.dev` with a `streams:` entry
+- Updates `.gitignore` to exclude `bin/dist/`
+
+### Pin a server version
+
+```bash
+bin/rails generate durable_streams:install --version=0.1.0
+```
+
+### Disable route auto-mounting
+
+The gem auto-mounts the auth verification endpoint at `/durable_streams/auth/verify`.
+To disable:
+
+```ruby
+# config/initializers/durable_streams.rb
+Rails.application.config.durable_streams.draw_routes = false
+```
+
+## Configuration
+
+The server reads `config/durable_streams.yml`:
+
+```yaml
+default: &default
+  port: 4437
+  # route: /v1/streams/*
+  auth:
+    url: http://localhost:3000
+    path: /durable_streams/auth/verify
+    copy_headers:
+      - Cookie
+
+development:
+  <<: *default
+
+production:
+  <<: *default
+  domain: streams.example.com
+  auth:
+    url: https://app.example.com
+    path: /durable_streams/auth/verify
+    copy_headers:
+      - Cookie
+      - Authorization
+  storage:
+    data_dir: /var/data/durable-streams
+```
+
+Power users can bypass the YAML entirely:
+
+```bash
+DURABLE_STREAMS_CONFIG=/path/to/Caddyfile bin/durable-streams
+```
+
+## Deployment with Kamal
+
+The server binary runs as a separate role in the same Docker image — same pattern as Solid Queue:
+
+```yaml
+# config/deploy.yml
+servers:
+  web:
+    cmd: bin/rails server
+  jobs:
+    cmd: bin/jobs
+  streams:
+    cmd: bin/durable-streams
+```
+
+Pre-download the binary during Docker build:
+
+```dockerfile
+RUN bin/rails durable_streams:download
+```
+
+Or set a specific version:
+
+```dockerfile
+RUN DURABLE_STREAMS_VERSION=0.1.0 bin/rails durable_streams:download
+```
+
+## Usage
+
+### Declarative streaming
+
+Stream to an association:
+
+```ruby
+class Comment < ApplicationRecord
+  belongs_to :post
+  streams_to :post
+end
+```
+
+Stream to self:
+
+```ruby
+class Board < ApplicationRecord
+  streams
+end
+```
+
+With a proc for custom stream targets:
+
+```ruby
+class Comment < ApplicationRecord
+  belongs_to :post
+  streams_to ->(comment) { [comment.post, :comments] }
+end
+```
+
+### Instance methods
+
+Synchronous (returns `txid` for optimistic update confirmation):
+
+```ruby
+txid = comment.stream_insert_to post
+txid = comment.stream_update_to post
+txid = comment.stream_upsert_to post
+comment.stream_delete_to post
+```
+
+Asynchronous (via `DurableStreams::BroadcastJob`):
+
+```ruby
+comment.stream_insert_later_to post
+comment.stream_update_later_to post
+comment.stream_upsert_later_to post
+comment.stream_delete_later_to post
+```
+
+Self-targeting (streams to the model itself):
+
+```ruby
+comment.stream_insert          # same as stream_insert_to(self)
+comment.stream_update_later    # same as stream_update_later_to(self)
+```
+
+### Direct broadcasting
+
+For non-ActiveRecord use cases (presence, typing indicators):
+
+```ruby
+DurableStreams.broadcast_to(room, :presence,
+  type: "presence",
+  key: user.id.to_s,
+  value: { id: user.id, name: user.name },
+  headers: { operation: "insert" }
+)
+```
+
+### Signed stream URLs
+
+Generate signed, expirable URLs for client SSE connections:
+
+```ruby
+url = DurableStreams.signed_stream_url(room, :messages)
+# => "http://localhost:4437/v1/streams/gid://app/Room/1/messages?token=eyJ..."
+
+url = DurableStreams.signed_stream_url(room, :messages, expires_in: 1.hour)
+```
+
+### Suppressing broadcasts
+
+```ruby
+Comment.suppressing_streams do
+  Comment.create!(post: post) # no broadcast
+end
+```
+
+## Testing
+
+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 —
+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`
+captures broadcasts without a WebSocket connection.
+
+```ruby
+class CommentTest < ActiveSupport::TestCase
+  test "creating comment streams to post" do
+    assert_stream_broadcasts @post, count: 1 do
+      @post.comments.create!(body: "Hello")
+    end
+  end
+
+  test "capture stream events" do
+    events = capture_stream_broadcasts @post do
+      @post.comments.create!(body: "Hello")
+    end
+
+    assert_equal "insert", events.first["headers"]["operation"]
+    assert_equal "Hello", events.first["value"]["body"]
+  end
+
+  test "no broadcasts when suppressed" do
+    assert_no_stream_broadcasts @post do
+      Comment.suppressing_streams do
+        @post.comments.create!(body: "Silent")
+      end
+    end
+  end
+end
+```
+
+## Architecture
+
+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::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 |
+
+The key architectural difference: Turbo broadcasts HTML fragments over WebSockets (Action Cable).
+This gem broadcasts JSON State Protocol events over HTTP/SSE (Durable Streams).
+
+## Dependencies
+
+- [`durable_streams`](https://github.com/tokimonki/durable_streams) — Ruby client for the Durable Streams protocol (resolved automatically via RubyGems)
+- `railties` >= 8.0
+
+## Future
+
+Brewing secretly — an async-backed durable streams server inside Rails.
+
+## License
+
+MIT

data/Rakefile

@@ -1,10 +1,19 @@
 require "bundler/setup"
+require "bundler/gem_tasks"
 require "rake/testtask"
 
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
-  t.pattern = "test/**/*_test.rb"
+  t.test_files = FileList["test/**/*_test.rb"]
   t.verbose = false
 end
 
-task default: :test
+task :test_prereq do
+  puts "Preparing test database"
+  `cd test/dummy && RAILS_ENV=test bin/rails db:migrate`
+end
+
+task default: [ :test_prereq, :test ]

data/app/controllers/durable_streams/auth_controller.rb

@@ -0,0 +1,24 @@
+module DurableStreams
+  class AuthController < ActionController::API
+    def verify
+      if stream_name
+        head :ok
+      else
+        head :unauthorized
+      end
+    end
+
+    private
+      def stream_name
+        if token = extract_token
+          DurableStreams.verified_stream_name(token)
+        end
+      end
+
+      def extract_token
+        if uri = request.headers["X-Forwarded-Uri"]
+          DurableStreams.extract_token_from_url(uri)
+        end
+      end
+  end
+end

data/config/routes.rb

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

data/lib/durable_streams/engine.rb

@@ -6,11 +6,14 @@ module 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")
@@ -25,14 +28,21 @@ module DurableStreams
       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 ||
+          config.durable_streams.signed_stream_verifier_key ||
           Rails.application.key_generator.generate_key("durable_streams/signed_stream_verifier_key")
       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)

data/lib/durable_streams/server_config.rb

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

@@ -19,7 +19,7 @@ module DurableStreams::Testing
     end
 
     def recording?
-      messages.present?
+      !messages.nil?
     end
 
     def record(stream_name, message)

data/lib/durable_streams/version.rb

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

data/lib/durable_streams-rails.rb

@@ -5,10 +5,12 @@ require "durable_streams/engine"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
 
 module DurableStreams
+  extend ActiveSupport::Autoload
   extend DurableStreams::StreamName
   extend DurableStreams::Broadcasts
 
   mattr_accessor :base_url
+  mattr_accessor :draw_routes, default: true
 
   class << self
     attr_writer :signed_stream_verifier_key
@@ -26,5 +28,19 @@ module DurableStreams
       token = signed_stream_verifier.generate(path, expires_in: expires_in)
       "#{base_url}/#{path}?token=#{token}"
     end
+
+    # Verifies the signed token embedded in a stream URL. Used by the auth controller
+    # to validate forward_auth requests from the Durable Streams server.
+    def verify_signed_url(url)
+      if token = extract_token_from_url(url)
+        verified_stream_name(token)
+      end
+    end
+
+    def extract_token_from_url(url)
+      if query = URI(url).query
+        Rack::Utils.parse_query(query)["token"]
+      end
+    end
   end
 end

data/lib/generators/durable_streams/install/USAGE

@@ -0,0 +1,16 @@
+Description:
+  Sets up Durable Streams for your Rails application.
+
+  Creates the server config (config/durable_streams.yml), binstub
+  (bin/durable-streams), initializer, and updates Procfile.dev.
+  The server binary downloads automatically on first run.
+
+  Set DURABLE_STREAMS_CONFIG to a file path to use a raw server
+  config instead of the YAML-based configuration.
+
+Examples:
+  bin/rails generate durable_streams:install
+
+  bin/rails generate durable_streams:install --version=0.1.0
+
+  bin/rails generate durable_streams:install --skip-procfile

data/lib/generators/durable_streams/install/install_generator.rb

@@ -0,0 +1,62 @@
+module DurableStreams
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :version,
+        type: :string,
+        desc: "Durable Streams server version (default: latest)",
+        default: "latest"
+      class_option :skip_procfile,
+        type: :boolean,
+        desc: "Skip Procfile.dev update",
+        default: false
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/durable_streams.rb"
+      end
+
+      def create_server_config
+        template "durable_streams.yml", "config/durable_streams.yml"
+      end
+
+      def create_binstub
+        template "bin/durable-streams", "bin/durable-streams"
+        chmod "bin/durable-streams", 0755, verbose: false
+      end
+
+      def update_procfile
+        return if options[:skip_procfile]
+
+        procfile = "Procfile.dev"
+        entry = "streams: bin/durable-streams\n"
+
+        if File.exist?(procfile) && !File.read(procfile).match?(/^streams:/)
+          append_file procfile, entry
+        end
+      end
+
+      def update_gitignore
+        if File.exist?(".gitignore") && !File.read(".gitignore").match?(/^bin\/dist/)
+          append_file ".gitignore", "\n# Durable Streams server binary\nbin/dist/\n"
+        end
+      end
+
+      def show_instructions
+        say ""
+        say "  Durable Streams installed!", :green
+        say ""
+        say "  Configuration: config/durable_streams.yml"
+        say "  Server binary: bin/durable-streams (auto-downloads on first run)"
+        say ""
+        say "  Start development:"
+        say "    bin/dev"
+        say ""
+        say "  Stream endpoint: http://localhost:4437/v1/streams/*"
+        say ""
+        say "  Power users: set DURABLE_STREAMS_CONFIG to use a raw server config file."
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/durable_streams/install/templates/bin/durable-streams.tt

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+APP_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+BIN_PATH="${APP_ROOT}/bin/dist/durable-streams-server"
+
+# Download if not cached
+if [ ! -x "$BIN_PATH" ]; then
+  DURABLE_STREAMS_VERSION="${DURABLE_STREAMS_VERSION:-<%= options[:version] %>}" \
+    bundle exec rails durable_streams:download
+fi
+
+# Power user: use raw config file directly
+if [ -n "${DURABLE_STREAMS_CONFIG:-}" ]; then
+  exec "$BIN_PATH" run --config "$DURABLE_STREAMS_CONFIG" "$@"
+fi
+
+# Standard: generate config from YAML
+RAILS_ENV="${RAILS_ENV:-development}"
+CONFIG_FILE="${APP_ROOT}/tmp/durable_streams.caddyfile"
+
+mkdir -p "${APP_ROOT}/tmp"
+APP_ROOT="$APP_ROOT" RAILS_ENV="$RAILS_ENV" bundle exec ruby -r durable_streams/server_config \
+  -e "puts DurableStreams::ServerConfig.generate(File.join(ENV['APP_ROOT'], 'config/durable_streams.yml'), ENV['RAILS_ENV'])" \
+  > "$CONFIG_FILE"
+
+exec "$BIN_PATH" run --config "$CONFIG_FILE" "$@"

data/lib/generators/durable_streams/install/templates/durable_streams.yml.tt

@@ -0,0 +1,32 @@
+# Durable Streams server configuration.
+# The server binary reads this on startup via bin/durable-streams.
+#
+# Power users: set DURABLE_STREAMS_CONFIG=/path/to/config to use a
+# custom server config file directly, bypassing this YAML.
+
+default: &default
+  port: 4437
+  # route: /v1/streams/*
+  auth:
+    url: http://localhost:3000
+    path: /durable_streams/auth/verify
+    copy_headers:
+      - Cookie
+
+development:
+  <<: *default
+
+test:
+  <<: *default
+
+production:
+  <<: *default
+  domain: streams.example.com
+  auth:
+    url: https://app.example.com
+    path: /durable_streams/auth/verify
+    copy_headers:
+      - Cookie
+      - Authorization
+  storage:
+    data_dir: /var/data/durable-streams

data/lib/generators/durable_streams/install/templates/initializer.rb.tt

@@ -0,0 +1 @@
+DurableStreams.base_url = ENV.fetch("DURABLE_STREAMS_URL", "http://localhost:4437/v1/streams")

data/lib/tasks/durable_streams.rake

@@ -0,0 +1,42 @@
+namespace :durable_streams do
+  desc "Download the Durable Streams server binary for the current platform"
+  task :download do
+    version = ENV.fetch("DURABLE_STREAMS_VERSION", "latest")
+    install_dir = Rails.root.join("bin", "dist")
+    bin_path = install_dir.join("durable-streams-server")
+
+    if bin_path.exist?
+      puts "Durable Streams server already installed at #{bin_path}"
+      next
+    end
+
+    os = RbConfig::CONFIG["host_os"].then { |s|
+      if s.match?(/darwin/i) then "darwin"
+      elsif s.match?(/linux/i) then "linux"
+      else abort "Unsupported OS: #{s}"
+      end
+    }
+
+    arch = RbConfig::CONFIG["host_cpu"].then { |s|
+      case s
+      when /x86_64|amd64/ then "amd64"
+      when /aarch64|arm64/ then "arm64"
+      else abort "Unsupported architecture: #{s}"
+      end
+    }
+
+    FileUtils.mkdir_p(install_dir)
+
+    if version == "latest"
+      url = "https://github.com/durable-streams/durable-streams/releases/latest/download/durable-streams-server_#{os}_#{arch}.tar.gz"
+    else
+      url = "https://github.com/durable-streams/durable-streams/releases/download/caddy-v#{version}/durable-streams-server_#{version}_#{os}_#{arch}.tar.gz"
+    end
+
+    puts "Downloading durable-streams-server #{version} (#{os}/#{arch})..."
+    system("curl", "-sL", url, "-o", "-", out: IO.popen(["tar", "xz", "-C", install_dir.to_s], "w").fileno) ||
+      abort("Download failed")
+    FileUtils.chmod(0755, bin_path)
+    puts "Installed to #{bin_path}"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: durable_streams-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - tokimonki
@@ -27,38 +27,45 @@ dependencies:
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '7.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.1.0
+        version: '8.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
+        version: '8.0'
+description: Stream State Protocol events from Active Record models with the same
+  DX as Turbo Broadcasts — declarative streaming, automatic callbacks, and async jobs
+  — but with offset-based resumability and persistent event logs over SSE.
 email: opensource@tokimonki.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 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
+- 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/generators/durable_streams/install/USAGE
+- lib/generators/durable_streams/install/install_generator.rb
+- lib/generators/durable_streams/install/templates/bin/durable-streams.tt
+- lib/generators/durable_streams/install/templates/durable_streams.yml.tt
+- lib/generators/durable_streams/install/templates/initializer.rb.tt
+- lib/tasks/durable_streams.rake
 homepage: https://github.com/tokimonki/durable_streams-rails
 licenses:
 - MIT
@@ -70,14 +77,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Durable Streams integration for Rails
 test_files: []