solid_objects 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17e88ea06322a5e262d146e3d96a0b0d54d2339d46c6681a2fdb0f8d244a3640
-  data.tar.gz: d33b76b4e741921b4e199f3f91af652c06217960606dc7e3e95a03b28d34d3db
+  metadata.gz: b7fee6db10af36996dbe9c8484fab405b53e2463a3fd7d2f7414310fedab68d5
+  data.tar.gz: 8b71bb8fbf0dc0359ce8a00097428dbbcd189e4d2b4071ba0339b9c3ec1cd933
 SHA512:
-  metadata.gz: 0a217bfdb8454acbf7caa7a153095455e8b421aab4ebc7a16be056efa49db78bc4e0c452f50e24c04f1aad5177aafdb16ebff67a974618a0134c302581edf85a
-  data.tar.gz: 284a15eb44417ebaad3ec0ccad3b180999ed94df9d7ca73b74fcc70ed136f3458613ecbadb99115f13e93310d684a0451a62f6887dd7b0c2bdcf1af14ade2fcf
+  metadata.gz: 62f2ce7ecfa4899f82af3682c5a8fb97d7005e6ba9152a8a63433b2ec345d2edc3d795c29a7f6de24d25f275afd4857986ed34302359d0f3aab018f936656acd
+  data.tar.gz: 2114e1d8b7757bf598562fba6e1b8ecafeea852d6925a5161f74b1dcab6dab9b5750ca71327b0cfa23b927869cbeee348f1bd6d03cbfc5d964d2bfd53a625435

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.9.0 - 2026-08-10
+
+- Add a browser test suite running the refresh modules against real Chromium and
+  a real Turbo build, covering `component_refresh.js`, which previously had no
+  tests at all. Every batching defect that reached production passed the jsdom
+  suite, because jsdom cannot model Turbo applying a morph, task boundaries
+  between socket deliveries, or abort semantics.
+- Verify the database server. Each adapter reports its version against the
+  oldest one Solid Objects is exercised against, PostgreSQL 13, MySQL 8.0, and
+  SQLite 3.35, and MySQL additionally confirms that Solid Objects tables use
+  InnoDB, since a non-transactional engine would silently break fenced commits.
+  The doctor reports this as `database_server` and warns rather than failing:
+  refusing to run on an untested server would be a worse failure than running
+  on one.
+- Add `SolidObjects::WakeUpAdapters::Redis`, an optional cross-process wake-up
+  using Redis publish and subscribe. This is the option for MySQL, which has no
+  notification primitive. Measured cross-process wake-up latency drops from
+  103.8 ms to 5.7 ms at p50. One background subscription per process fans out to
+  every waiting role in memory. The `redis` gem is not a dependency of this gem,
+  and `WakeUpAdapters.for` does not select it, so adopting Redis stays explicit.
+
 ## 0.8.0 - 2026-08-10
 
 - Replace a supervised role whose thread died. A role that raised left its

data/docs/local-testing.md

@@ -0,0 +1,91 @@
+# Local testing
+
+The default suite runs against SQLite and needs nothing extra:
+
+```bash
+bundle exec rake
+```
+
+Everything below is optional. Each adapter and each optional service skips its
+tests when the service is absent, so a missing container degrades coverage
+rather than breaking the run. That is convenient, and it is also a trap: a
+skipped test looks identical to a passing one in the summary line. Check the
+skip count when a change touches an adapter.
+
+## PostgreSQL
+
+```bash
+brew services start postgresql@17
+createuser -h 127.0.0.1 -s solid_objects
+psql -h 127.0.0.1 -d postgres -c "ALTER USER solid_objects WITH PASSWORD 'solid_objects';"
+createdb -h 127.0.0.1 -O solid_objects solid_objects_test
+
+SOLID_OBJECTS_DATABASE_URL=postgresql://solid_objects:solid_objects@127.0.0.1:5432/solid_objects_test \
+  bundle exec rake test
+```
+
+Running this locally is worth the setup: it is what caught the PostgreSQL
+version comparison reading a packed integer, where `170010` compared greater
+than any minimum and made the check useless on the adapter it mattered most for.
+
+## MySQL and Redis in Docker
+
+These use non-default ports so they cannot collide with a MySQL or Redis that
+another project is already running:
+
+```bash
+docker run -d --name so-mysql -p 3307:3306 \
+  -e MYSQL_ROOT_PASSWORD=solid_objects \
+  -e MYSQL_DATABASE=solid_objects_test \
+  -e MYSQL_USER=solid_objects \
+  -e MYSQL_PASSWORD=solid_objects \
+  mysql:8
+
+docker run -d --name so-redis -p 6380:6379 redis:7-alpine
+```
+
+```bash
+SOLID_OBJECTS_DATABASE_URL=mysql2://solid_objects:solid_objects@127.0.0.1:3307/solid_objects_test \
+  bundle exec rake test
+
+SOLID_OBJECTS_REDIS_URL=redis://127.0.0.1:6380/15 \
+  bundle exec rake test TEST=test/integration/redis_wake_up_test.rb
+```
+
+Stop them with `docker rm -f so-mysql so-redis`.
+
+## Recreating a database between runs
+
+The test helper migrates unconditionally, so a second run against a database
+that already has the tables fails with a duplicate-table error rather than a
+test failure. Recreate first:
+
+```bash
+dropdb -h 127.0.0.1 solid_objects_test && createdb -h 127.0.0.1 -O solid_objects solid_objects_test
+
+docker exec so-mysql mysql -u root -psolid_objects \
+  -e "DROP DATABASE IF EXISTS solid_objects_test; CREATE DATABASE solid_objects_test;
+      GRANT ALL ON solid_objects_test.* TO 'solid_objects'@'%';"
+```
+
+## Rails and Ruby span
+
+`RAILS_VERSION` pins the Rails line the gemspec advertises:
+
+```bash
+RAILS_VERSION=8.0 bundle install
+RAILS_VERSION=8.0 bundle exec rake test
+```
+
+## Browser modules
+
+```bash
+npm install
+npm test                                  # jsdom, fast
+npx playwright install chromium
+npm run test:browser                      # real Chromium and a real Turbo build
+```
+
+The jsdom suite covers logic; the browser suite covers integration with Turbo.
+Both matter: every batching defect that reached production passed the jsdom
+suite alone.

data/docs/realtime.md

@@ -128,8 +128,21 @@ configuration.wake_up_adapter = SolidObjects::WakeUpAdapters.for
 default on SQLite and MySQL, so the same line is safe across adapters. Name
 `SolidObjects::WakeUpAdapters::Postgresql.new` directly to require it.
 
-MySQL has no notification primitive, so MySQL applications keep polling and tune
-`polling_interval`.
+MySQL has no notification primitive. MySQL applications either keep polling and
+tune `polling_interval`, or configure the Redis adapter:
+
+```ruby
+configuration.wake_up_adapter = SolidObjects::WakeUpAdapters::Redis.new(
+  url: ENV["REDIS_URL"]
+)
+```
+
+Measured latency for a cross-process wake-up drops from 103.8 ms to 5.7 ms at
+p50. The `redis` gem is not a dependency of this gem, so applications add it
+themselves. One background subscription per process fans out to every waiting
+role in memory, rather than one connection per thread, and `WakeUpAdapters.for`
+does not select it: Redis is infrastructure this gem otherwise does not require,
+so choosing it is explicit.
 
 Measured latency for a cross-process wake-up drops from 103.7 ms to 2.9 ms at
 p50. The adapter keeps `polling_interval` as the upper bound: a missed or failed

data/docs/roadmap.md

@@ -24,6 +24,9 @@
 - Reconciliation read APIs
 - Installation doctor, authorization reference, fit guide, and legacy-state
   migration cookbook
+- Database server verification: each adapter reports its version against a
+  tested minimum, MySQL confirms Solid Objects tables use InnoDB, and the
+  doctor warns rather than refusing to run on an untested server
 - Handler Active Record write isolation, same-database commit actions, ambient
   transaction rejection, adapter lock/query deadlines, bounded SQLite lock
   retries outside those deadlines, structured sync timeout diagnostics, and
@@ -36,14 +39,18 @@
 - SQLite, PostgreSQL, and MySQL integration suites
 - Opt-in cross-process wake-up on PostgreSQL through `WakeUpAdapters.for`, with
   a listening connection per waiting thread and release on supervisor shutdown
+- Opt-in cross-process wake-up on Redis, the option for MySQL applications,
+  measured at 103.8 ms to 5.7 ms at p50; the `redis` gem stays outside this
+  gem's dependencies
 - Inline RBS generation/validation, Steep, Standard Ruby, Solid Queue's exact
   RuboCop policy, and a warning-free Brakeman scan
 - Compatibility CI across the supported span: Ruby 3.3 and 3.4 against Rails 8.0
   and 8.1, pinned through `RAILS_VERSION` so the advertised range is verified
   rather than assumed
-- A JavaScript suite covering the state payload and batched refresh browser
-  modules, run in CI with Node's test runner and jsdom, with every GitHub
-  Actions reference pinned to a commit SHA
+- A JavaScript suite covering every browser module, run in CI with Node's test
+  runner and jsdom, plus a browser suite running the same modules against real
+  Chromium and a real Turbo build, with every GitHub Actions reference pinned to
+  a commit SHA
 
 ## Partially implemented
 
@@ -56,7 +63,8 @@
   103.7 ms to 2.9 ms at p50. It is opt-in rather than automatic: it opens a
   connection per waiting thread outside the pool, and `LISTEN` does not survive
   a transaction-pooling proxy such as PgBouncer. MySQL has no notification
-  primitive, so MySQL applications keep polling.
+  primitive, so MySQL applications keep polling unless they configure the Redis
+  adapter.
 - Realtime: scalar and dependency-driven keyed ERB component replacement or
   morphing, personalized refresh authorization, revision fencing, coalescing,
   reconnect convergence, batched refreshes, and personalized state payloads are
@@ -68,26 +76,19 @@
   distributed per-actor rate limits and global admission control do not.
 - Administration: actor and dead-letter views plus policy hooks exist; richer
   filtering, audit records, and bulk-safe tools do not.
-- Browser module coverage: the state payload and batched refresh modules have
-  JavaScript tests; `component_refresh.js`, which drives individual morph
-  refreshes, does not.
 - Outboxes use portable status rows with polling indexes; future versions may
   introduce narrow ready/claimed membership tables for very large outboxes.
 
 ## Next milestones
 
-1. Add an optional Redis wake-up adapter, which is the remaining cross-process
-   option for MySQL. The PostgreSQL notification adapter, its latency
-   benchmark, and its concurrency tests are implemented.
-2. Add result lookup by request ID and broader deadlock retry classification.
-3. Add scheduled retention and stale-process maintenance.
-4. Add database/server-version checks and MySQL InnoDB verification at boot.
-5. Add Turbo append intents and expand reconnect coverage in a full browser.
-6. Add distributed rate limits, global admission hooks, and cache-capacity
+1. Add result lookup by request ID and broader deadlock retry classification.
+2. Add scheduled retention and stale-process maintenance.
+3. Add Turbo append intents and expand reconnect coverage in a full browser.
+4. Add distributed rate limits, global admission hooks, and cache-capacity
    eviction.
-7. Expand security scanning and run compatibility CI across supported Rails and
-   Ruby versions.
-8. Benchmark all workloads under documented hardware/database settings and
+5. Expand security scanning. Compatibility CI across supported Rails and Ruby
+   versions is implemented; Ruby 4.0 is not yet in the matrix.
+6. Benchmark all workloads under documented hardware/database settings and
    publish adapter-specific adoption measurements. Throughput, synchronous
    latency, query counts, and the three reactive delivery paths are measured on
    SQLite; adapter-specific and end-to-end browser measurements are not.

data/lib/solid_objects/database_adapter.rb

@@ -32,6 +32,43 @@ module SolidObjects
       @fixed_connection = connection_pool ? nil : connection
     end
 
+    # The oldest server the adapter has been exercised against. Reported rather
+    # than enforced: refusing to boot on an untested server would be a worse
+    # failure than running on one.
+    # @rbs () -> Gem::Version?
+    def minimum_server_version
+      nil
+    end
+
+    # @rbs () -> Gem::Version
+    def server_version
+      with_connection do |connection|
+        Gem::Version.new(connection.database_version.to_s)
+      end
+    end
+
+    # One observed version decides both the status and the message. Reading it
+    # again could let a transient failure replace an already determined result.
+    # @rbs (?Gem::Version?) -> Array[String]
+    def unsupported_server_reasons(observed = nil)
+      observed ||= server_version
+      reasons = []
+      minimum = minimum_server_version
+      if minimum && observed < minimum
+        reasons << "#{self.class.name.demodulize} #{observed} is older than " \
+          "Solid Objects requires, which is #{minimum}"
+      end
+      reasons.concat(additional_server_reasons)
+      reasons
+    rescue => error
+      [ "the database server could not be verified: #{error.class}: #{error.message}" ]
+    end
+
+    # @rbs () -> Array[String]
+    def additional_server_reasons
+      []
+    end
+
     # @rbs () -> bool
     def supports_skip_locked?
       false

data/lib/solid_objects/database_adapters/mysql.rb

@@ -13,6 +13,34 @@ module SolidObjects
         "FOR UPDATE SKIP LOCKED"
       end
 
+      # A non-transactional engine would silently break fenced commits, so the
+      # storage engine is verified rather than assumed.
+      # @rbs () -> Array[String]
+      def additional_server_reasons
+        tables = non_innodb_tables
+        return [] if tables.empty?
+
+        [ "these Solid Objects tables do not use InnoDB, so their commits are " \
+          "not transactional: #{tables.join(", ")}" ]
+      end
+
+      # @rbs () -> Array[String]
+      def non_innodb_tables
+        names = SolidObjects::Doctor::EXPECTED_COLUMNS.keys.map { |name| SolidObjects.table_name(name) }
+        with_connection do |connection|
+          connection.select_rows(<<~SQL.squish).filter_map { |table, engine| table if engine != "InnoDB" }
+            SELECT table_name, engine FROM information_schema.tables
+            WHERE table_schema = DATABASE()
+              AND table_name IN (#{names.map { |name| connection.quote(name) }.join(", ")})
+          SQL
+        end
+      end
+
+      # @rbs () -> Gem::Version?
+      def minimum_server_version
+        Gem::Version.new("8.0")
+      end
+
       # @rbs () -> String
       def current_time_expression
         "CURRENT_TIMESTAMP(6)"

data/lib/solid_objects/database_adapters/postgresql.rb

@@ -3,6 +3,21 @@
 module SolidObjects
   module DatabaseAdapters
     class Postgresql < DatabaseAdapter
+      # @rbs () -> Gem::Version?
+      def minimum_server_version
+        Gem::Version.new("13")
+      end
+
+      # PostgreSQL reports a packed integer, 170010 for 17.10, so comparing it
+      # directly would make every server look newer than any minimum.
+      # @rbs () -> Gem::Version
+      def server_version
+        packed = with_connection { |connection| connection.database_version.to_i }
+        return super unless packed.positive?
+
+        Gem::Version.new("#{packed / 10_000}.#{packed % 10_000}")
+      end
+
       # @rbs () -> bool
       def supports_skip_locked?
         true

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -8,6 +8,11 @@ module SolidObjects
       LOCK_RETRY_MUTEX = Thread::Mutex.new
       LOCK_RETRY_CONDITION = Thread::ConditionVariable.new
 
+      # @rbs () -> Gem::Version?
+      def minimum_server_version
+        Gem::Version.new("3.35")
+      end
+
       # @rbs () -> String
       def current_time_expression
         "STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')"

data/lib/solid_objects/doctor.rb

@@ -111,6 +111,7 @@ module SolidObjects
         configuration_check,
         schema_check,
         check_authorization,
+        check_database_server,
         schema_check.failed? ? skipped_runtime : check_runtime,
         ready_for_round_trip?(configuration_check, schema_check) ?
           check_sync_round_trip :
@@ -191,6 +192,21 @@ module SolidObjects
       pass(:authorization, "#{allowed.length} of 5 policies allowed a neutral context")
     end
 
+    # @rbs () -> Check
+    def check_database_server
+      adapter = SolidObjects.database_adapter
+      observed = adapter.server_version
+      reasons = adapter.unsupported_server_reasons(observed)
+      return warn_check(:database_server, reasons.join("; ")) unless reasons.empty?
+
+      pass(
+        :database_server,
+        "#{adapter.class.name.demodulize} #{observed} meets the tested minimum"
+      )
+    rescue => error
+      warn_check(:database_server, "#{error.class}: #{error.message}")
+    end
+
     # @rbs () -> Check
     def check_runtime
       cutoff = SolidObjects.database_adapter.database_now -

data/lib/solid_objects/version.rb

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

data/lib/solid_objects/wake_up_adapters/redis.rb

@@ -0,0 +1,183 @@
+# rbs_inline: enabled
+
+require "timeout"
+
+module SolidObjects
+  module WakeUpAdapters
+    # Wakes runtime roles across processes using Redis publish/subscribe.
+    #
+    # MySQL has no notification primitive, so this is the cross-process option
+    # for applications that cannot use PostgreSQL notifications. It is optional
+    # in every sense: the `redis` gem is not a dependency of this gem, and the
+    # polling interval remains the upper bound, so a missed or failed
+    # notification costs latency rather than correctness.
+    class Redis
+      CHANNEL = "solid_objects_wake_up"
+      FAILED_WAIT_INTERVAL = 0.05
+      SUBSCRIBE_TIMEOUT = 5.0
+
+      # @rbs @channel: String
+      # @rbs @url: String?
+      # @rbs @client: untyped
+      # @rbs @mutex: Thread::Mutex
+      # @rbs @condition: Thread::ConditionVariable
+      # @rbs @subscriber: Thread?
+      # @rbs @subscription: untyped
+      # @rbs @signalled: Integer
+
+      attr_reader :channel
+
+      # @rbs (?channel: String, ?url: String?, ?client: untyped) -> void
+      def initialize(channel: CHANNEL, url: nil, client: nil)
+        @channel = channel
+        @url = url
+        @client = client
+        @mutex = Thread::Mutex.new
+        @condition = Thread::ConditionVariable.new
+        @subscriber = nil
+        @subscription = nil
+        @signalled = 0
+        validate_client!
+      end
+
+      # @rbs () -> bool
+      def signal
+        publisher.publish(channel, "1")
+        true
+      rescue => error
+        instrument_failure(:signal, error)
+        false
+      end
+
+      # The counter is snapshotted before subscribing, and re-checked before
+      # blocking, so a signal delivered while this caller was still getting
+      # ready is observed rather than absorbed into the new baseline.
+      # @rbs (timeout: Numeric) -> bool
+      def wait(timeout:)
+        signalled = mutex.synchronize { @signalled }
+        return paced_failure(timeout) unless listen
+
+        mutex.synchronize do
+          return true unless @signalled == signalled
+
+          condition.wait(mutex, timeout.to_f)
+          @signalled != signalled
+        end
+      end
+
+      # Redis delivers to a subscribed connection only, and a subscribed
+      # connection cannot serve other callers, so one background subscription
+      # per process fans out to every waiting role in memory. Subscribing
+      # eagerly also closes the window where a signal sent during startup would
+      # be missed.
+      # @rbs () -> bool
+      def listen
+        mutex.synchronize do
+          return true if @subscriber&.alive?
+
+          ready = Queue.new
+          @subscriber = Thread.new { subscribe_loop(ready) }
+          Timeout.timeout(SUBSCRIBE_TIMEOUT) { ready.pop } == :subscribed
+        end
+      rescue => error
+        instrument_failure(:listen, error)
+        false
+      end
+
+      # @rbs () -> bool
+      def stop
+        subscriber = mutex.synchronize do
+          thread = @subscriber
+          @subscriber = nil
+          thread
+        end
+        return false unless subscriber
+
+        disconnect(@subscription)
+        subscriber.join(SUBSCRIBE_TIMEOUT)
+        subscriber.kill if subscriber.alive?
+        true
+      end
+
+      private
+
+      attr_reader :mutex, :condition, :url
+
+      # @rbs (Queue) -> void
+      def subscribe_loop(ready)
+        connection = build_client
+        @subscription = connection
+        connection.subscribe(channel) do |on|
+          on.subscribe { ready << :subscribed }
+          on.message { broadcast }
+        end
+      rescue => error
+        instrument_failure(:subscribe, error)
+        ready << :failed
+      end
+
+      # @rbs () -> void
+      def broadcast
+        mutex.synchronize do
+          @signalled += 1
+          condition.broadcast
+        end
+      end
+
+      # @rbs (Numeric) -> bool
+      def paced_failure(timeout)
+        pace_after_failure(timeout)
+        false
+      end
+
+      # @rbs () -> untyped
+      def publisher
+        @publisher ||= build_client
+      end
+
+      # @rbs () -> untyped
+      def build_client
+        return @client.call if @client.respond_to?(:call)
+
+        require "redis"
+        url ? ::Redis.new(url:) : ::Redis.new
+      rescue LoadError
+        raise ArgumentError,
+          "the redis gem is required for SolidObjects::WakeUpAdapters::Redis"
+      end
+
+      # @rbs () -> void
+      def validate_client!
+        return if @client.nil? || @client.respond_to?(:call)
+
+        raise ArgumentError, "client must respond to call and return a Redis client"
+      end
+
+      # @rbs (untyped) -> void
+      def disconnect(connection)
+        connection&.close
+      rescue
+        nil
+      end
+
+      # @rbs (Numeric) -> void
+      def pace_after_failure(timeout)
+        interval = [ timeout.to_f, FAILED_WAIT_INTERVAL ].min
+        return unless interval.positive?
+
+        sleep interval
+      end
+
+      # @rbs (Symbol, Exception) -> void
+      def instrument_failure(operation, error)
+        SolidObjects.instrument(
+          :"wake_up.failed",
+          adapter: "redis",
+          operation: operation.to_s,
+          error_class: error.class.name,
+          error_message: error.message
+        )
+      end
+    end
+  end
+end

data/lib/solid_objects.rb

@@ -47,6 +47,7 @@ require "solid_objects/actor_channel"
 require "solid_objects/action_cable_broadcast_adapter"
 require "solid_objects/wake_up"
 require "solid_objects/wake_up_adapters/postgresql"
+require "solid_objects/wake_up_adapters/redis"
 require "solid_objects/wake_up_adapters"
 require "solid_objects/effect_registry"
 require "solid_objects/commit_action_registry"

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

@@ -16,6 +16,23 @@ module SolidObjects
     # @rbs (untyped) -> void
     def initialize: (untyped) -> void
 
+    # The oldest server the adapter has been exercised against. Reported rather
+    # than enforced: refusing to boot on an untested server would be a worse
+    # failure than running on one.
+    # @rbs () -> Gem::Version?
+    def minimum_server_version: () -> Gem::Version?
+
+    # @rbs () -> Gem::Version
+    def server_version: () -> Gem::Version
+
+    # One observed version decides both the status and the message. Reading it
+    # again could let a transient failure replace an already determined result.
+    # @rbs (?Gem::Version?) -> Array[String]
+    def unsupported_server_reasons: (?Gem::Version?) -> Array[String]
+
+    # @rbs () -> Array[String]
+    def additional_server_reasons: () -> Array[String]
+
     # @rbs () -> bool
     def supports_skip_locked?: () -> bool
 

data/sig/generated/lib/solid_objects/database_adapters/mysql.rbs

@@ -9,6 +9,17 @@ module SolidObjects
       # @rbs () -> String
       def claim_lock: () -> String
 
+      # A non-transactional engine would silently break fenced commits, so the
+      # storage engine is verified rather than assumed.
+      # @rbs () -> Array[String]
+      def additional_server_reasons: () -> Array[String]
+
+      # @rbs () -> Array[String]
+      def non_innodb_tables: () -> Array[String]
+
+      # @rbs () -> Gem::Version?
+      def minimum_server_version: () -> Gem::Version?
+
       # @rbs () -> String
       def current_time_expression: () -> String
 

data/sig/generated/lib/solid_objects/database_adapters/postgresql.rbs

@@ -3,6 +3,14 @@
 module SolidObjects
   module DatabaseAdapters
     class Postgresql < DatabaseAdapter
+      # @rbs () -> Gem::Version?
+      def minimum_server_version: () -> Gem::Version?
+
+      # PostgreSQL reports a packed integer, 170010 for 17.10, so comparing it
+      # directly would make every server look newer than any minimum.
+      # @rbs () -> Gem::Version
+      def server_version: () -> Gem::Version
+
       # @rbs () -> bool
       def supports_skip_locked?: () -> bool
 

data/sig/generated/lib/solid_objects/database_adapters/sqlite.rbs

@@ -11,6 +11,9 @@ module SolidObjects
 
       LOCK_RETRY_CONDITION: untyped
 
+      # @rbs () -> Gem::Version?
+      def minimum_server_version: () -> Gem::Version?
+
       # @rbs () -> String
       def current_time_expression: () -> String
 

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

@@ -72,6 +72,9 @@ module SolidObjects
     # @rbs () -> Check
     def check_authorization: () -> Check
 
+    # @rbs () -> Check
+    def check_database_server: () -> Check
+
     # @rbs () -> Check
     def check_runtime: () -> Check
 

data/sig/generated/lib/solid_objects/wake_up_adapters/redis.rbs

@@ -0,0 +1,96 @@
+# Generated from lib/solid_objects/wake_up_adapters/redis.rb with RBS::Inline
+
+module SolidObjects
+  module WakeUpAdapters
+    # Wakes runtime roles across processes using Redis publish/subscribe.
+    #
+    # MySQL has no notification primitive, so this is the cross-process option
+    # for applications that cannot use PostgreSQL notifications. It is optional
+    # in every sense: the `redis` gem is not a dependency of this gem, and the
+    # polling interval remains the upper bound, so a missed or failed
+    # notification costs latency rather than correctness.
+    class Redis
+      CHANNEL: ::String
+
+      FAILED_WAIT_INTERVAL: ::Float
+
+      SUBSCRIBE_TIMEOUT: ::Float
+
+      @signalled: Integer
+
+      @subscription: untyped
+
+      @subscriber: Thread?
+
+      @condition: Thread::ConditionVariable
+
+      @mutex: Thread::Mutex
+
+      @client: untyped
+
+      @url: String?
+
+      @channel: String
+
+      attr_reader channel: untyped
+
+      # @rbs (?channel: String, ?url: String?, ?client: untyped) -> void
+      def initialize: (?channel: String, ?url: String?, ?client: untyped) -> void
+
+      # @rbs () -> bool
+      def signal: () -> bool
+
+      # The counter is snapshotted before subscribing, and re-checked before
+      # blocking, so a signal delivered while this caller was still getting
+      # ready is observed rather than absorbed into the new baseline.
+      # @rbs (timeout: Numeric) -> bool
+      def wait: (timeout: Numeric) -> bool
+
+      # Redis delivers to a subscribed connection only, and a subscribed
+      # connection cannot serve other callers, so one background subscription
+      # per process fans out to every waiting role in memory. Subscribing
+      # eagerly also closes the window where a signal sent during startup would
+      # be missed.
+      # @rbs () -> bool
+      def listen: () -> bool
+
+      # @rbs () -> bool
+      def stop: () -> bool
+
+      private
+
+      attr_reader mutex: untyped
+
+      attr_reader condition: untyped
+
+      attr_reader url: untyped
+
+      # @rbs (Queue) -> void
+      def subscribe_loop: (Queue) -> void
+
+      # @rbs () -> void
+      def broadcast: () -> void
+
+      # @rbs (Numeric) -> bool
+      def paced_failure: (Numeric) -> bool
+
+      # @rbs () -> untyped
+      def publisher: () -> untyped
+
+      # @rbs () -> untyped
+      def build_client: () -> untyped
+
+      # @rbs () -> void
+      def validate_client!: () -> void
+
+      # @rbs (untyped) -> void
+      def disconnect: (untyped) -> void
+
+      # @rbs (Numeric) -> void
+      def pace_after_failure: (Numeric) -> void
+
+      # @rbs (Symbol, Exception) -> void
+      def instrument_failure: (Symbol, Exception) -> void
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Lucas Carlson
@@ -319,6 +319,7 @@ files:
 - docs/development.md
 - docs/fit.md
 - docs/implementation-plan.md
+- docs/local-testing.md
 - docs/migrating-existing-state.md
 - docs/operations.md
 - docs/realtime.md
@@ -405,6 +406,7 @@ files:
 - lib/solid_objects/wake_up.rb
 - lib/solid_objects/wake_up_adapters.rb
 - lib/solid_objects/wake_up_adapters/postgresql.rb
+- lib/solid_objects/wake_up_adapters/redis.rb
 - lib/solid_objects/worker.rb
 - lib/tasks/solid_objects_tasks.rake
 - sig/generated/controllers/solid_objects/application_controller.rbs
@@ -478,6 +480,7 @@ files:
 - sig/generated/lib/solid_objects/wake_up.rbs
 - sig/generated/lib/solid_objects/wake_up_adapters.rbs
 - sig/generated/lib/solid_objects/wake_up_adapters/postgresql.rbs
+- sig/generated/lib/solid_objects/wake_up_adapters/redis.rbs
 - sig/generated/lib/solid_objects/worker.rbs
 - sig/generated/models/solid_objects/broadcast.rbs
 - sig/generated/models/solid_objects/claimed_message.rbs