solid_objects 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 935a2d2bb12fbc5b39121fe44004d0cc0671c3bef82012cf9b024089c3546ac9
-  data.tar.gz: 15de97ea8547bfb552ae848b2ae523fdd6c48a557313ba3fd87d931ee770f9b1
+  metadata.gz: 28a727648d2afc1ed0cd5be03fd624617db444bf173b289327d8c69e2a4abf80
+  data.tar.gz: 0f3bb956b7dcda6f993c92d3ce7f24a3ecf93caf0435030fe2e44955eb581c22
 SHA512:
-  metadata.gz: 6633846db212684a9e6d687f76e559cd51448171bd9e067534024e9a067534f1ff7eab223e3c1ab80b7a02765b909a324f2dbb9b1f527e5846d933de5b3639c7
-  data.tar.gz: ce930198b48379439c4947dd41ea5d3a0577ad8ce49eb1513715075ccf23c03b23237bcee77f06a898ea5460b83e3bf6b0c8a54f7b9c16e03c159c2572a03306
+  metadata.gz: 6d5ffbb3074eff11b32966560a2ca42dca37dc7c8c9cf1725a9965a40815752379be88f18b6b0b184592931d180f7248d6c01e5344be2b79a29cdde5377ab23f
+  data.tar.gz: ca700bcc8d86a6939c462be3003b0e649c6a2611289b12064dda9d0f6e3f844cc332e479b355b248e0a97c9073e537b1b99a8ae0cfd7ac454b170bd03bbd9a71

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 0.10.1 - 2026-08-10
+
+- Support Trilogy. Adapter selection matched the client name rather than the
+  protocol, and Trilogy reports `"Trilogy"`, so every Solid Objects call raised
+  `UnsupportedDatabase: unsupported database adapter "Trilogy"` on a database
+  the gem fully supports. Adapter names now resolve through one table of
+  families, `DatabaseAdapter.family`, used by adapter selection, owner-id
+  casting, and wake-up adapter selection alike, so a client cannot be accepted
+  in one place and rejected in another.
+- Compare reconciliation owner ids in the column's own collation.
+  `Instance.orphaned` cast owner primary keys to `CHAR`, and a cast result
+  carries the connection collation rather than the column's. MySQL refuses to
+  compare two collations, so the query raised `Illegal mix of collations`
+  whenever the two differed. That is a property of the client rather than the
+  schema: mysql2 negotiates the database default while Trilogy negotiates
+  `utf8mb4_general_ci`. A mysql2 application that set `collation:` in
+  `database.yml` could already hit this.
+- Recognise a statement interruption from any MySQL client. A synchronous
+  deadline is enforced by asking the server to interrupt the statement, and the
+  interruption was matched only through mysql2's `error_number`. Trilogy names
+  it `error_code`, so a deadline surfaced as a raw
+  `ActiveRecord::StatementTimeout` instead of `SyncEnqueueTimeout`. Both names
+  are read, and Active Record's own classification is trusted first.
+- Run the MySQL suite against both mysql2 and Trilogy in CI, and key
+  adapter-specific test skips to the database family rather than the client
+  name, so a Trilogy run no longer silently skips every MySQL test.
+
 ## 0.10.0 - 2026-08-10
 
 - Report a denied CLI command as a policy decision rather than a crash.

data/README.md

@@ -956,7 +956,8 @@ shutdown, retention, and backup guidance.
 Solid Objects supports:
 
 - PostgreSQL 14 or newer
-- MySQL 8.0 or newer using InnoDB
+- MySQL 8.0 or newer using InnoDB, through either the `mysql2` or `trilogy`
+  client
 - SQLite 3.35 or newer
 
 PostgreSQL and MySQL use `FOR UPDATE SKIP LOCKED` when claiming hot-table rows.

data/app/models/solid_objects/instance.rb

@@ -56,7 +56,7 @@ module SolidObjects
         )
         owner_ids = owner_relation
           .except(:select)
-          .select(cast_id)
+          .select(collated(cast_id))
 
         where(actor_type:).where.not(actor_id: owner_ids)
       end
@@ -70,12 +70,39 @@ module SolidObjects
 
       private
 
+      # A cast result carries the connection collation, not the column's, and
+      # MySQL refuses to compare two collations. Which collation a connection
+      # uses is a property of the client rather than the schema: mysql2
+      # negotiates the database default while Trilogy negotiates
+      # utf8mb4_general_ci, so the comparison is pinned to the column's own.
+      # @rbs (untyped) -> untyped
+      def collated(node)
+        collation = owner_id_collation
+        return node unless collation
+
+        Arel::Nodes::InfixOperation.new(
+          "COLLATE",
+          node,
+          Arel::Nodes::SqlLiteral.new(collation)
+        )
+      end
+
+      # @rbs () -> String?
+      def owner_id_collation
+        return nil unless DatabaseAdapter.family(connection) == :mysql
+
+        collation = columns_hash["actor_id"]&.collation
+        return nil unless collation&.match?(/\A[a-zA-Z0-9_]+\z/)
+
+        collation
+      end
+
       # @rbs () -> String
       def owner_id_cast_type
-        case connection.adapter_name
-        when /mysql/i
+        case DatabaseAdapter.family(connection)
+        when :mysql
           "CHAR"
-        when /postgres/i
+        when :postgresql
           "VARCHAR"
         else
           "TEXT"

data/docs/architecture.md

@@ -41,6 +41,10 @@ The host application owns:
 ## Database coordination adapters
 
 Solid Objects supports PostgreSQL 14+, MySQL 8.0+ with InnoDB, and SQLite 3.35+.
+MySQL is reached through either the `mysql2` or `trilogy` client. Adapter names
+are client names rather than protocol names, so every decision that depends on
+the database resolves through `DatabaseAdapter.family` rather than matching an
+adapter name in place.
 
 One adapter capability object is selected from the Active Record connection. It supplies claim locking and database-time expressions. Unsupported adapter families fail when first used. Minimum server-version and storage-engine checks are documented operating requirements; automatic boot-time enforcement and classified contention retries remain hardening work.
 

data/docs/local-testing.md

@@ -48,10 +48,17 @@ docker run -d --name so-redis -p 6380:6379 redis:7-alpine
 SOLID_OBJECTS_DATABASE_URL=mysql2://solid_objects:solid_objects@127.0.0.1:3307/solid_objects_test \
   bundle exec rake test
 
+SOLID_OBJECTS_DATABASE_URL=trilogy://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
 ```
 
+Run both MySQL clients. They report different adapter names, negotiate
+different connection collations, and name the same error code differently, so a
+pass on one says nothing about the other. Recreate the database between them.
+
 Stop them with `docker rm -f so-mysql so-redis`.
 
 ## Recreating a database between runs

data/docs/roadmap.md

@@ -45,7 +45,9 @@
   shutdown is requested, and dead process records plus expired message and
   process history are pruned on their own intervals without an application
   scheduling its own job
-- SQLite, PostgreSQL, and MySQL integration suites
+- SQLite, PostgreSQL, and MySQL integration suites, with MySQL run against both
+  the `mysql2` and `trilogy` clients because an adapter name, a connection
+  collation, and an error code name all differ between them
 - 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,

data/lib/solid_objects/database_adapter.rb

@@ -7,15 +7,35 @@ module SolidObjects
     TRANSACTION_CLOCK = :solid_objects_transaction_clock
     TRANSACTION_CLOCK_SCOPE = :solid_objects_transaction_clock_scope
 
+    # An adapter name is a client name, not a protocol name. Trilogy reports
+    # "Trilogy" while speaking MySQL, so a pattern that only knows the mysql2
+    # gem rejects a database Solid Objects fully supports. Every decision that
+    # depends on the database goes through this one table, so a client cannot
+    # be accepted in one place and rejected in another.
+    FAMILIES = {
+      postgresql: /postgres/i,
+      mysql: /mysql|trilogy/i,
+      sqlite: /sqlite/i
+    }.freeze
+
     class << self
+      # @rbs (untyped) -> Symbol?
+      def family(connection)
+        adapter_name = connection.adapter_name
+        FAMILIES.each do |family, pattern|
+          return family if adapter_name.match?(pattern)
+        end
+        nil
+      end
+
       # @rbs (untyped) -> DatabaseAdapter
       def for(connection)
-        case connection.adapter_name
-        when /postgres/i
+        case family(connection)
+        when :postgresql
           DatabaseAdapters::Postgresql.new(connection)
-        when /mysql/i
+        when :mysql
           DatabaseAdapters::Mysql.new(connection)
-        when /sqlite/i
+        when :sqlite
           DatabaseAdapters::Sqlite.new(connection)
         else
           raise UnsupportedDatabase, "unsupported database adapter #{connection.adapter_name.inspect}"

data/lib/solid_objects/database_adapters/mysql.rb

@@ -3,6 +3,8 @@
 module SolidObjects
   module DatabaseAdapters
     class Mysql < DatabaseAdapter
+      MAXIMUM_EXECUTION_TIME_EXCEEDED = 3024
+
       # @rbs () -> bool
       def supports_skip_locked?
         true
@@ -78,19 +80,33 @@ module SolidObjects
         end
       end
 
+      # A deadline is enforced by asking the server to interrupt the statement,
+      # so recognising that interruption is what turns it back into a timeout
+      # the caller asked for. Active Record classifies it for every client, and
+      # the raw code is the fallback: mysql2 names it `error_number` and
+      # Trilogy names it `error_code`, so both are read.
       # @rbs (Exception) -> bool
       def deadline_error?(error)
         return false unless SyncDeadline.active?
         return true if error.is_a?(ActiveRecord::LockWaitTimeout)
+        return true if error.is_a?(ActiveRecord::StatementTimeout)
 
         cause = error
         while cause
-          return true if cause.respond_to?(:error_number) && cause.error_number == 3024
+          return true if error_code(cause) == MAXIMUM_EXECUTION_TIME_EXCEEDED
 
           cause = cause.cause
         end
         false
       end
+
+      # @rbs (Exception) -> Integer?
+      def error_code(error)
+        return error.error_number if error.respond_to?(:error_number)
+        return error.error_code if error.respond_to?(:error_code)
+
+        nil
+      end
     end
   end
 end

data/lib/solid_objects/version.rb

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

data/lib/solid_objects/wake_up_adapters.rb

@@ -15,7 +15,7 @@ module SolidObjects
     #
     # @rbs (?untyped) -> untyped
     def for(connection = Record.connection)
-      return Postgresql.new if connection.adapter_name.match?(/postgres/i)
+      return Postgresql.new if DatabaseAdapter.family(connection) == :postgresql
 
       WakeUp.new
     end

data/lib/solid_objects.rb

@@ -46,6 +46,7 @@ require "solid_objects/state_snapshot"
 require "solid_objects/actor_view"
 require "solid_objects/actor_channel"
 require "solid_objects/action_cable_broadcast_adapter"
+require "solid_objects/database_adapter"
 require "solid_objects/wake_up"
 require "solid_objects/wake_up_adapters/postgresql"
 require "solid_objects/wake_up_adapters/redis"

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

@@ -6,6 +6,16 @@ module SolidObjects
 
     TRANSACTION_CLOCK_SCOPE: ::Symbol
 
+    # An adapter name is a client name, not a protocol name. Trilogy reports
+    # "Trilogy" while speaking MySQL, so a pattern that only knows the mysql2
+    # gem rejects a database Solid Objects fully supports. Every decision that
+    # depends on the database goes through this one table, so a client cannot
+    # be accepted in one place and rejected in another.
+    FAMILIES: untyped
+
+    # @rbs (untyped) -> Symbol?
+    def self.family: (untyped) -> Symbol?
+
     # @rbs (untyped) -> DatabaseAdapter
     def self.for: (untyped) -> DatabaseAdapter
 

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

@@ -3,6 +3,8 @@
 module SolidObjects
   module DatabaseAdapters
     class Mysql < DatabaseAdapter
+      MAXIMUM_EXECUTION_TIME_EXCEEDED: ::Integer
+
       # @rbs () -> bool
       def supports_skip_locked?: () -> bool
 
@@ -28,8 +30,16 @@ module SolidObjects
       # @rbs (untyped) { () -> untyped } -> untyped
       def with_transaction_deadline: (untyped) { () -> untyped } -> untyped
 
+      # A deadline is enforced by asking the server to interrupt the statement,
+      # so recognising that interruption is what turns it back into a timeout
+      # the caller asked for. Active Record classifies it for every client, and
+      # the raw code is the fallback: mysql2 names it `error_number` and
+      # Trilogy names it `error_code`, so both are read.
       # @rbs (Exception) -> bool
       def deadline_error?: (Exception) -> bool
+
+      # @rbs (Exception) -> Integer?
+      def error_code: (Exception) -> Integer?
     end
   end
 end

data/sig/generated/models/solid_objects/instance.rbs

@@ -14,6 +14,17 @@ module SolidObjects
     # @rbs (actor_type: String, actor_ids: Array[String]) -> Hash[String, Hash[String, untyped]]
     def self.states_for: (actor_type: String, actor_ids: Array[String]) -> Hash[String, Hash[String, untyped]]
 
+    # A cast result carries the connection collation, not the column's, and
+    # MySQL refuses to compare two collations. Which collation a connection
+    # uses is a property of the client rather than the schema: mysql2
+    # negotiates the database default while Trilogy negotiates
+    # utf8mb4_general_ci, so the comparison is pinned to the column's own.
+    # @rbs (untyped) -> untyped
+    private def self.collated: (untyped) -> untyped
+
+    # @rbs () -> String?
+    private def self.owner_id_collation: () -> String?
+
     # @rbs () -> String
     private def self.owner_id_cast_type: () -> String
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Lucas Carlson
@@ -248,6 +248,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: trilogy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
 description: 'The Cloudflare Durable Objects programming model for Rails: addressable
   objects with durable state, ordered mailboxes, fenced activation, per-object alarms,
   transactional effects, and reactive ERB. It runs on MySQL, PostgreSQL, and SQLite