activerecord-connection-tz 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d5ef49ac42955d476269f8702a521271591abd43f0dea2b7dfbd0c5d168e855d
+  data.tar.gz: 2f8d972eb058c16c06ba1ed3851e366f2758047444d151af0664644ae9375455
+SHA512:
+  metadata.gz: ba880a8c2ed7274946327afd0087e1f50aa4454fe217547d3cc1256884fdbe7135f84c0805b55b814d543cc7d72ef9b9d669ef6b4e5a1bcc4c5a074704ac1f4e
+  data.tar.gz: 03c838ee16bbaa223403a5bd0c7d58c4e44104b19cc16d9ac64ed17aae4ffe21c97a12c5403ada924ffb658e5c07126af9a94ed5fba8dd5d0789a4ee53f91178

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## [0.1.0] - 2026-05-10
+
+- Initial release

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,110 @@
+# ActiveRecord Connection TZ
+
+> ⚠️ **Early stage (v0.1.0):** This gem is still being refined. APIs, configuration details, and supported surfaces may change before the first stable release.
+
+## Overview
+
+`activerecord-connection-tz` helps Rails applications use **mixed-timezone MySQL connections** in the same process.
+
+It is designed for cases where one connection follows a UTC contract while another connection needs temporal values to be interpreted with a different configured timezone.
+
+The gem applies connection-scoped handling through `database.yml`, so the tagged connection can:
+
+- set the MySQL session `time_zone`
+- replace `datetime` / `time` / `timestamp` casting on a per-connection basis
+- preserve fractional-second precision when writing temporal values
+- work with both `mysql2` and `trilogy`
+
+## Installation
+
+Add the gem together with the adapter gem you use:
+
+```ruby
+# Gemfile
+gem 'activerecord-connection-tz'
+gem 'mysql2' # or gem 'trilogy'
+```
+
+And then execute:
+
+```sh
+bundle install
+```
+
+## Quick start
+
+The gem activates automatically for connections that declare `connection_tz` in `database.yml`.
+
+```yml
+production:
+  primary:
+    adapter: mysql2
+    database: primary_db
+
+  legacy_tokyo:
+    adapter: mysql2
+    database: legacy_db
+    connection_tz:
+      time_zone: Asia/Tokyo
+```
+
+No model-level or attribute-level wiring is required for the tagged connection.
+
+For transition-free zones such as `Asia/Tokyo`, the gem can derive the MySQL session `time_zone` automatically from `time_zone`.
+
+For zones with DST or other offset transitions, set `mysql_session_time_zone` explicitly:
+
+```yml
+production:
+  legacy_new_york:
+    adapter: mysql2
+    database: legacy_db
+    connection_tz:
+      time_zone: America/New_York
+      mysql_session_time_zone: America/New_York
+```
+
+If those DST-style zones use `TIMESTAMP` columns, prefer a **named MySQL timezone** such as `America/New_York` instead of a fixed offset such as `-05:00`. A fixed offset can skew `TIMESTAMP` reads across DST boundaries because MySQL converts `TIMESTAMP` values through the session timezone, while `DATETIME` values are not affected by that limitation.
+
+## Documentation
+
+For runnable Rails examples and setup notes, see **[examples/README.md](examples/README.md)**.
+
+The examples cover:
+
+- Rails 7.1 / 8.0 / 8.1
+- mysql2 and trilogy side by side
+- shared MySQL 8 Docker setup
+- UTC `primary` plus a tagged connection interpreted with another timezone
+
+## Requirements
+
+- Ruby 3.2+
+- Active Record 7.1 - 8.1
+- MySQL 5.7+ (or a compatible server with fractional-second precision support)
+- `mysql2` or `trilogy`
+
+## Development
+
+```sh
+bundle install
+bundle exec rbs collection install
+bundle exec rspec
+bundle exec rubocop
+bundle exec rake sig:generate
+bundle exec rake typecheck
+```
+
+To build the gem locally:
+
+```sh
+gem build activerecord-connection-tz.gemspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shoma07/activerecord-connection-tz.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/lib/active_record_connection_tz/adapters/mysql2.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_support/lazy_load_hooks'
+
+module ActiveRecordConnectionTz
+  module Adapters
+    module Mysql2
+      class << self
+        #: () -> void
+        def install!
+          Shared.install!(adapter_module: self, hook_name: :active_record_mysql2adapter)
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        #: () -> void
+        def disable_temporal_cast
+          # Use the adapter's public accessor even though it marks the raw
+          # connection as touched; this runs during configure_connection and
+          # avoids reaching into the adapter's ivar directly.
+          raw_connection.query_options[:cast] = false
+        end
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/adapters/shared.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'active_support/lazy_load_hooks'
+
+module ActiveRecordConnectionTz
+  module Adapters
+    module Shared
+      class << self
+        #: (adapter_module: Module, hook_name: Symbol) -> void
+        def install!(adapter_module:, hook_name:)
+          return if adapter_module.instance_variable_get(:@installed)
+
+          instance_methods = adapter_module.const_get(:InstanceMethods, false)
+
+          ActiveSupport.on_load(hook_name) do
+            singleton_class.prepend(Shared::ClassMethods) unless singleton_class < Shared::ClassMethods
+            prepend(Shared::InstanceMethods) unless self < Shared::InstanceMethods
+            prepend(instance_methods) unless self < instance_methods
+          end
+
+          adapter_module.instance_variable_set(:@installed, true)
+        end
+      end
+
+      module ClassMethods
+        #: (emulate_booleans: bool, ?default_timezone: untyped, ?connection_tz: Hash[untyped, untyped]?) -> ActiveRecord::Type::TypeMap
+        def extended_type_map(emulate_booleans:, default_timezone: nil, connection_tz: nil)
+          super(default_timezone: default_timezone, emulate_booleans: emulate_booleans).tap do |map|
+            next unless connection_tz
+
+            settings = ConnectionSettings.new(connection_tz)
+            time_zone = settings.time_zone || raise(ConfigurationError, 'connection_tz time_zone must be present')
+            Types.register_mysql_temporal_types!(map, time_zone: time_zone)
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        #: () -> untyped
+        def configure_connection
+          settings = connection_tz_settings
+          @config = settings.apply_mysql_variables(@config)
+          super
+
+          disable_temporal_cast if settings.enabled?
+        end
+
+        #: () -> untyped
+        def extended_type_map_key
+          settings = connection_tz_settings
+          return super unless settings.enabled?
+
+          (super || { emulate_booleans: emulate_booleans }).merge(connection_tz: settings.type_map_key)
+        end
+
+        #: (untyped value) -> untyped
+        def quoted_date(value)
+          settings = connection_tz_settings
+          return super unless settings.enabled? && value.acts_like?(:time)
+
+          # `enabled?` guarantees the configured timezone is present for this connection.
+          # The `|| raise` keeps Steep narrowed from `ActiveSupport::TimeZone?`.
+          time_zone = settings.time_zone || raise(ConfigurationError, 'connection_tz time_zone must be present')
+          TemporalFormatter.quoted_date(value, time_zone: time_zone)
+        end
+
+        #: (untyped value) -> untyped
+        def quoted_time(value)
+          settings = connection_tz_settings
+          return super unless settings.enabled? && value.acts_like?(:time)
+
+          # `enabled?` guarantees the configured timezone is present for this connection.
+          # The `|| raise` keeps Steep narrowed from `ActiveSupport::TimeZone?`.
+          time_zone = settings.time_zone || raise(ConfigurationError, 'connection_tz time_zone must be present')
+          TemporalFormatter.quoted_time(value, time_zone: time_zone)
+        end
+
+        #: () -> ConnectionSettings
+        def connection_tz_settings
+          # Active Record keeps the connection configuration in `@config`
+          # without exposing a stable reader on the adapter instance.
+          @connection_tz_settings ||= ConnectionSettings.from_config(@config)
+        end
+
+        #: () -> void
+        def disable_temporal_cast
+          raise NotImplementedError, "#{self.class} must implement #disable_temporal_cast"
+        end
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/adapters/trilogy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_support/lazy_load_hooks'
+
+module ActiveRecordConnectionTz
+  module Adapters
+    module Trilogy
+      class << self
+        #: () -> void
+        def install!
+          Shared.install!(adapter_module: self, hook_name: :active_record_trilogyadapter)
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        #: () -> void
+        def disable_temporal_cast
+          # Use the adapter's public accessor even though it marks the raw
+          # connection as touched; this runs during configure_connection and
+          # avoids reaching into the adapter's ivar directly.
+          raw_connection.query_flags &= ~::Trilogy::QUERY_FLAGS_CAST
+        end
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/connection_settings.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module ActiveRecordConnectionTz
+  class ConnectionSettings
+    KEY = 'connection_tz' #: String
+    private_constant :KEY
+
+    # Range used to detect whether a timezone stays fixed-offset for the practical
+    # lifetime of MySQL TIMESTAMP data, starting at the Unix epoch and extending
+    # slightly beyond 2038 to give the transition check some future slack.
+    AUTO_SESSION_TIME_ZONE_FROM = Time.utc(1970, 1, 1).freeze #: Time
+    private_constant :AUTO_SESSION_TIME_ZONE_FROM
+
+    AUTO_SESSION_TIME_ZONE_TO = Time.utc(2050, 1, 1).freeze #: Time
+    private_constant :AUTO_SESSION_TIME_ZONE_TO
+
+    attr_reader :time_zone_name #: String?
+    attr_reader :explicit_mysql_session_time_zone #: String?
+
+    class << self
+      #: (Hash[untyped, untyped] config) -> ConnectionSettings
+      def from_config(config)
+        new(config[KEY] || config[KEY.to_sym])
+      end
+    end
+
+    #: (Hash[untyped, untyped]? raw) -> void
+    def initialize(raw)
+      raw = normalize_hash(raw)
+
+      @time_zone_name = raw.fetch('time_zone', nil)
+      @explicit_mysql_session_time_zone = raw.fetch('mysql_session_time_zone', nil)
+    end
+
+    #: () -> bool
+    def enabled?
+      !time_zone_name.to_s.empty?
+    end
+
+    #: () -> ActiveSupport::TimeZone?
+    def time_zone
+      return unless enabled?
+
+      # `enabled?` guarantees `time_zone_name` is present here.
+      # The `|| raise` keeps Steep's type narrowed from `String?` to `String`.
+      name = time_zone_name || raise(ConfigurationError, 'connection_tz time_zone must be present')
+
+      @time_zone ||= ActiveSupport::TimeZone[name] || raise(
+        ConfigurationError,
+        "Unknown connection_tz time_zone: #{name.inspect}"
+      )
+    end
+
+    #: () -> Hash[String, String]?
+    def type_map_key
+      return unless enabled?
+
+      # `enabled?` guarantees `time_zone_name` is present here.
+      # The `|| raise` keeps Steep's type narrowed from `String?` to `String`.
+      name = time_zone_name || raise(ConfigurationError, 'connection_tz time_zone must be present')
+
+      {
+        'time_zone' => name
+      }
+    end
+
+    #: () -> String?
+    def mysql_session_time_zone
+      explicit_mysql_session_time_zone || auto_mysql_session_time_zone
+    end
+
+    #: (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+    def apply_mysql_variables(config)
+      return config unless enabled?
+
+      variables = normalize_hash(config['variables'] || config[:variables], context: 'connection_tz.variables')
+      return config if variables['time_zone']
+
+      session_time_zone = mysql_session_time_zone || raise(
+        ConfigurationError,
+        "connection_tz time_zone #{time_zone_name.inspect} is not fixed-offset " \
+        'between 1970 and 2050; set mysql_session_time_zone explicitly'
+      )
+
+      variables['time_zone'] = session_time_zone
+
+      config.merge(variables: variables.dup, 'variables' => variables.dup)
+    end
+
+    private
+
+    #: () -> String?
+    def auto_mysql_session_time_zone
+      return unless fixed_offset_time_zone?
+
+      # `fixed_offset_time_zone?` already confirms the setting is enabled.
+      # Keep the `|| raise` so Steep narrows `ActiveSupport::TimeZone?`.
+      zone = time_zone || raise(ConfigurationError, 'connection_tz time_zone must be present')
+
+      format_utc_offset(zone.utc_offset)
+    end
+
+    #: () -> bool
+    def fixed_offset_time_zone?
+      zone = time_zone
+      return false unless zone
+
+      zone.tzinfo.transitions_up_to(AUTO_SESSION_TIME_ZONE_TO, AUTO_SESSION_TIME_ZONE_FROM).empty?
+    end
+
+    #: (Integer offset_seconds) -> String
+    def format_utc_offset(offset_seconds)
+      sign = offset_seconds.negative? ? '-' : '+'
+      hours, remainder = offset_seconds.abs.divmod(3600)
+
+      format('%<sign>s%<hours>02d:%<minutes>02d', sign:, hours:, minutes: remainder / 60)
+    end
+
+    #: (untyped value, ?context: String) -> Hash[String, untyped]
+    def normalize_hash(value, context: 'connection_tz configuration')
+      return {} if value.nil?
+      unless value.is_a?(Hash)
+        raise ConfigurationError,
+              "#{context} must be a Hash, got #{value.class} (#{value.inspect})"
+      end
+
+      value.transform_keys(&:to_s)
+    end
+  end
+end

data/lib/active_record_connection_tz/temporal_formatter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecordConnectionTz
+  module TemporalFormatter
+    class << self
+      #: (Time | DateTime | ActiveSupport::TimeWithZone value, time_zone: ActiveSupport::TimeZone) -> String
+      def quoted_date(value, time_zone:)
+        zoned = value.in_time_zone(time_zone)
+        result = zoned.strftime('%Y-%m-%d %H:%M:%S')
+        return "#{result}.#{format('%06d', zoned.usec)}" if zoned.usec.positive?
+
+        result
+      end
+
+      #: (Time | DateTime | ActiveSupport::TimeWithZone value, time_zone: ActiveSupport::TimeZone) -> String
+      def quoted_time(value, time_zone:)
+        # Use the same stable anchor date ActiveRecord::Type::Time conventionally relies on for TIME values.
+        quoted_date(value.change(year: 2000, month: 1, day: 1), time_zone: time_zone).sub(/\A\d{4}-\d{2}-\d{2} /, '')
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/temporal_parser.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecordConnectionTz
+  module TemporalParser
+    # Treat MySQL year-zero and zero/partial-zero dates as nil instead of passing invalid dates to TimeZone parsing.
+    ZERO_DATETIME = /\A(?:0000-\d{2}-\d{2}|\d{4}-(?:00-\d{2}|\d{2}-00))/ #: Regexp
+    private_constant :ZERO_DATETIME
+
+    class << self
+      #: (String? value, time_zone: ActiveSupport::TimeZone) -> ActiveSupport::TimeWithZone?
+      def parse_datetime(value, time_zone:)
+        return if value.nil? || value == '' || value.match?(ZERO_DATETIME)
+
+        time_zone.parse(value)
+      end
+
+      #: (String? value, time_zone: ActiveSupport::TimeZone) -> ActiveSupport::TimeWithZone?
+      def parse_time(value, time_zone:)
+        return if value.nil? || value == ''
+
+        time_zone.parse("2000-01-01 #{value}")
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/types/zoned_date_time.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveRecordConnectionTz
+  module Types
+    class ZonedDateTime < ActiveRecord::Type::DateTime
+      include ZonedTemporal
+
+      #: (untyped value) -> untyped
+      def cast(value)
+        # ActiveRecord::Type::DateTime#cast converts TimeWithZone to DateTime,
+        # dropping the original zone. Keep already-zoned values intact.
+        return value if value.is_a?(ActiveSupport::TimeWithZone)
+        return super unless value.is_a?(String)
+
+        parse_string(value)
+      end
+
+      private
+
+      #: (String value) -> ActiveSupport::TimeWithZone?
+      def parse_string(value)
+        TemporalParser.parse_datetime(value, time_zone: time_zone)
+      end
+
+      #: (untyped casted) -> String
+      def quote_casted(casted)
+        TemporalFormatter.quoted_date(casted, time_zone: time_zone)
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/types/zoned_temporal.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveRecordConnectionTz
+  module Types
+    # @rbs module-self ActiveModel::Type::Value
+    module ZonedTemporal
+      attr_reader :time_zone #: ActiveSupport::TimeZone
+
+      #: (time_zone: ActiveSupport::TimeZone) -> void
+      def initialize(time_zone:)
+        super()
+        @time_zone = time_zone
+      end
+
+      #: (untyped value) -> untyped
+      def deserialize(value)
+        return super unless value.is_a?(String)
+
+        parse_string(value)
+      end
+
+      #: (untyped value) -> untyped
+      def serialize(value)
+        serialize_temporal(value)
+      end
+
+      #: (untyped value) -> untyped
+      def serialize_cast_value(value) # :nodoc:
+        serialize_temporal(value)
+      end
+
+      private
+
+      #: (untyped value) -> untyped
+      def serialize_temporal(value)
+        casted = cast(value)
+        return if casted.nil?
+        return casted unless casted.acts_like?(:time)
+
+        quote_casted(casted)
+      end
+
+      #: (String _value) -> untyped
+      def parse_string(_value)
+        raise NotImplementedError, "#{self.class} must implement #parse_string"
+      end
+
+      #: (untyped _value) -> String
+      def quote_casted(_value)
+        raise NotImplementedError, "#{self.class} must implement #quote_casted"
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/types/zoned_time.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecordConnectionTz
+  module Types
+    class ZonedTime < ActiveRecord::Type::Time
+      include ZonedTemporal
+
+      #: (untyped value) -> untyped
+      def cast(value)
+        return super unless value.is_a?(String)
+
+        parse_string(value)
+      end
+
+      private
+
+      #: (String value) -> ActiveSupport::TimeWithZone?
+      def parse_string(value)
+        TemporalParser.parse_time(value, time_zone: time_zone)
+      end
+
+      #: (untyped casted) -> String
+      def quote_casted(casted)
+        TemporalFormatter.quoted_time(casted, time_zone: time_zone)
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'types/zoned_temporal'
+require_relative 'types/zoned_date_time'
+require_relative 'types/zoned_time'
+
+module ActiveRecordConnectionTz
+  module Types
+    class << self
+      #: (ActiveRecord::Type::TypeMap map, time_zone: ActiveSupport::TimeZone) -> void
+      def register_mysql_temporal_types!(map, time_zone:)
+        map.register_type(/\Adatetime\b/i) { |_sql_type| ZonedDateTime.new(time_zone: time_zone) }
+        map.register_type(/\Atime\b/i) { |_sql_type| ZonedTime.new(time_zone: time_zone) }
+        map.alias_type(/\Atimestamp\b/i, 'datetime')
+      end
+    end
+  end
+end

data/lib/active_record_connection_tz/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRecordConnectionTz
+  VERSION = '0.1.0' #: String
+end

data/lib/active_record_connection_tz.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/lazy_load_hooks'
+require 'active_record'
+
+require_relative 'active_record_connection_tz/version'
+require_relative 'active_record_connection_tz/connection_settings'
+require_relative 'active_record_connection_tz/temporal_formatter'
+require_relative 'active_record_connection_tz/temporal_parser'
+require_relative 'active_record_connection_tz/types'
+require_relative 'active_record_connection_tz/adapters/shared'
+require_relative 'active_record_connection_tz/adapters/mysql2'
+require_relative 'active_record_connection_tz/adapters/trilogy'
+
+module ActiveRecordConnectionTz
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  INSTALL_MUTEX = Mutex.new #: Mutex
+  private_constant :INSTALL_MUTEX
+
+  class << self
+    #: () -> void
+    def install!
+      return if @installed
+
+      INSTALL_MUTEX.synchronize do
+        return if @installed
+
+        Adapters::Mysql2.install!
+        Adapters::Trilogy.install!
+        @installed = true
+      end
+    end
+
+    #: () -> bool
+    def installed?
+      @installed == true
+    end
+  end
+end
+
+ActiveRecordConnectionTz.install!

data/lib/activerecord-connection-tz.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'active_record_connection_tz'

data/sig/active_record_connection_tz/adapters.rbs

@@ -0,0 +1,34 @@
+module ActiveRecordConnectionTz
+  module Adapters
+    interface _SharedClassMethodsHost
+      def extended_type_map: (emulate_booleans: bool, ?default_timezone: untyped, ?connection_tz: Hash[untyped, untyped]?) -> ActiveRecord::Type::TypeMap
+    end
+
+    interface _SharedInstanceMethodsHost
+      def config: () -> Hash[untyped, untyped]
+      def configure_connection: () -> untyped
+      def extended_type_map_key: () -> untyped
+      def quoted_date: (untyped value) -> untyped
+      def quoted_time: (untyped value) -> untyped
+      def emulate_booleans: () -> bool
+    end
+
+    module Shared
+      module ClassMethods : _SharedClassMethodsHost
+      end
+
+      module InstanceMethods : _SharedInstanceMethodsHost
+      end
+    end
+
+    module Mysql2
+      module InstanceMethods : ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
+      end
+    end
+
+    module Trilogy
+      module InstanceMethods : ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
+      end
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/adapters/mysql2.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/active_record_connection_tz/adapters/mysql2.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Adapters
+    module Mysql2
+      # : () -> void
+      def self.install!: () -> void
+
+      module InstanceMethods
+        private
+
+        # : () -> void
+        def disable_temporal_cast: () -> void
+      end
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/adapters/shared.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/active_record_connection_tz/adapters/shared.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Adapters
+    module Shared
+      # : (adapter_module: Module, hook_name: Symbol) -> void
+      def self.install!: (adapter_module: Module, hook_name: Symbol) -> void
+
+      module ClassMethods
+        # : (emulate_booleans: bool, ?default_timezone: untyped, ?connection_tz: Hash[untyped, untyped]?) -> ActiveRecord::Type::TypeMap
+        def extended_type_map: (emulate_booleans: bool, ?default_timezone: untyped, ?connection_tz: Hash[untyped, untyped]?) -> ActiveRecord::Type::TypeMap
+      end
+
+      module InstanceMethods
+        private
+
+        # : () -> untyped
+        def configure_connection: () -> untyped
+
+        # : () -> untyped
+        def extended_type_map_key: () -> untyped
+
+        # : (untyped value) -> untyped
+        def quoted_date: (untyped value) -> untyped
+
+        # : (untyped value) -> untyped
+        def quoted_time: (untyped value) -> untyped
+
+        # : () -> ConnectionSettings
+        def connection_tz_settings: () -> ConnectionSettings
+
+        # : () -> void
+        def disable_temporal_cast: () -> void
+      end
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/adapters/trilogy.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/active_record_connection_tz/adapters/trilogy.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Adapters
+    module Trilogy
+      # : () -> void
+      def self.install!: () -> void
+
+      module InstanceMethods
+        private
+
+        # : () -> void
+        def disable_temporal_cast: () -> void
+      end
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/connection_settings.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/active_record_connection_tz/connection_settings.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  class ConnectionSettings
+    KEY: String
+
+    # Range used to detect whether a timezone stays fixed-offset for the practical
+    # lifetime of MySQL TIMESTAMP data, starting at the Unix epoch and extending
+    # slightly beyond 2038 to give the transition check some future slack.
+    AUTO_SESSION_TIME_ZONE_FROM: Time
+
+    AUTO_SESSION_TIME_ZONE_TO: Time
+
+    attr_reader time_zone_name: String?
+
+    attr_reader explicit_mysql_session_time_zone: String?
+
+    # : (Hash[untyped, untyped] config) -> ConnectionSettings
+    def self.from_config: (Hash[untyped, untyped] config) -> ConnectionSettings
+
+    # : (Hash[untyped, untyped]? raw) -> void
+    def initialize: (Hash[untyped, untyped]? raw) -> void
+
+    # : () -> bool
+    def enabled?: () -> bool
+
+    # : () -> ActiveSupport::TimeZone?
+    def time_zone: () -> ActiveSupport::TimeZone?
+
+    # : () -> Hash[String, String]?
+    def type_map_key: () -> Hash[String, String]?
+
+    # : () -> String?
+    def mysql_session_time_zone: () -> String?
+
+    # : (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+    def apply_mysql_variables: (Hash[untyped, untyped] config) -> Hash[untyped, untyped]
+
+    private
+
+    # : () -> String?
+    def auto_mysql_session_time_zone: () -> String?
+
+    # : () -> bool
+    def fixed_offset_time_zone?: () -> bool
+
+    # : (Integer offset_seconds) -> String
+    def format_utc_offset: (Integer offset_seconds) -> String
+
+    # : (untyped value, ?context: String) -> Hash[String, untyped]
+    def normalize_hash: (untyped value, ?context: String) -> Hash[String, untyped]
+  end
+end

data/sig/generated/active_record_connection_tz/temporal_formatter.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/active_record_connection_tz/temporal_formatter.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module TemporalFormatter
+    # : (Time | DateTime | ActiveSupport::TimeWithZone value, time_zone: ActiveSupport::TimeZone) -> String
+    def self.quoted_date: (Time | DateTime | ActiveSupport::TimeWithZone value, time_zone: ActiveSupport::TimeZone) -> String
+
+    # : (Time | DateTime | ActiveSupport::TimeWithZone value, time_zone: ActiveSupport::TimeZone) -> String
+    def self.quoted_time: (Time | DateTime | ActiveSupport::TimeWithZone value, time_zone: ActiveSupport::TimeZone) -> String
+  end
+end

data/sig/generated/active_record_connection_tz/temporal_parser.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/active_record_connection_tz/temporal_parser.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module TemporalParser
+    # Treat MySQL year-zero and zero/partial-zero dates as nil instead of passing invalid dates to TimeZone parsing.
+    ZERO_DATETIME: Regexp
+
+    # : (String? value, time_zone: ActiveSupport::TimeZone) -> ActiveSupport::TimeWithZone?
+    def self.parse_datetime: (String? value, time_zone: ActiveSupport::TimeZone) -> ActiveSupport::TimeWithZone?
+
+    # : (String? value, time_zone: ActiveSupport::TimeZone) -> ActiveSupport::TimeWithZone?
+    def self.parse_time: (String? value, time_zone: ActiveSupport::TimeZone) -> ActiveSupport::TimeWithZone?
+  end
+end

data/sig/generated/active_record_connection_tz/types/zoned_date_time.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/active_record_connection_tz/types/zoned_date_time.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Types
+    class ZonedDateTime < ActiveRecord::Type::DateTime
+      include ZonedTemporal
+
+      # : (untyped value) -> untyped
+      def cast: (untyped value) -> untyped
+
+      private
+
+      # : (String value) -> ActiveSupport::TimeWithZone?
+      def parse_string: (String value) -> ActiveSupport::TimeWithZone?
+
+      # : (untyped casted) -> String
+      def quote_casted: (untyped casted) -> String
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/types/zoned_temporal.rbs

@@ -0,0 +1,33 @@
+# Generated from lib/active_record_connection_tz/types/zoned_temporal.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Types
+    # @rbs module-self ActiveModel::Type::Value
+    module ZonedTemporal : ActiveModel::Type::Value
+      attr_reader time_zone: ActiveSupport::TimeZone
+
+      # : (time_zone: ActiveSupport::TimeZone) -> void
+      def initialize: (time_zone: ActiveSupport::TimeZone) -> void
+
+      # : (untyped value) -> untyped
+      def deserialize: (untyped value) -> untyped
+
+      # : (untyped value) -> untyped
+      def serialize: (untyped value) -> untyped
+
+      # : (untyped value) -> untyped
+      def serialize_cast_value: (untyped value) -> untyped
+
+      private
+
+      # : (untyped value) -> untyped
+      def serialize_temporal: (untyped value) -> untyped
+
+      # : (String _value) -> untyped
+      def parse_string: (String _value) -> untyped
+
+      # : (untyped _value) -> String
+      def quote_casted: (untyped _value) -> String
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/types/zoned_time.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/active_record_connection_tz/types/zoned_time.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Types
+    class ZonedTime < ActiveRecord::Type::Time
+      include ZonedTemporal
+
+      # : (untyped value) -> untyped
+      def cast: (untyped value) -> untyped
+
+      private
+
+      # : (String value) -> ActiveSupport::TimeWithZone?
+      def parse_string: (String value) -> ActiveSupport::TimeWithZone?
+
+      # : (untyped casted) -> String
+      def quote_casted: (untyped casted) -> String
+    end
+  end
+end

data/sig/generated/active_record_connection_tz/types.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/active_record_connection_tz/types.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  module Types
+    # : (ActiveRecord::Type::TypeMap map, time_zone: ActiveSupport::TimeZone) -> void
+    def self.register_mysql_temporal_types!: (ActiveRecord::Type::TypeMap map, time_zone: ActiveSupport::TimeZone) -> void
+  end
+end

data/sig/generated/active_record_connection_tz/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/active_record_connection_tz/version.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  VERSION: String
+end

data/sig/generated/active_record_connection_tz.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/active_record_connection_tz.rb with RBS::Inline
+
+module ActiveRecordConnectionTz
+  class Error < StandardError
+  end
+
+  class ConfigurationError < Error
+  end
+
+  INSTALL_MUTEX: Mutex
+
+  # : () -> void
+  def self.install!: () -> void
+
+  # : () -> bool
+  def self.installed?: () -> bool
+end

data/sig/generated/activerecord-connection-tz.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/activerecord-connection-tz.rb with RBS::Inline
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-connection-tz
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- shoma07
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+description: |-
+  Provides connection-scoped timezone handling for applications that need to read and write
+  temporal columns with a configured timezone without per-attribute wiring.
+email:
+- 23730734+shoma07@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/active_record_connection_tz.rb
+- lib/active_record_connection_tz/adapters/mysql2.rb
+- lib/active_record_connection_tz/adapters/shared.rb
+- lib/active_record_connection_tz/adapters/trilogy.rb
+- lib/active_record_connection_tz/connection_settings.rb
+- lib/active_record_connection_tz/temporal_formatter.rb
+- lib/active_record_connection_tz/temporal_parser.rb
+- lib/active_record_connection_tz/types.rb
+- lib/active_record_connection_tz/types/zoned_date_time.rb
+- lib/active_record_connection_tz/types/zoned_temporal.rb
+- lib/active_record_connection_tz/types/zoned_time.rb
+- lib/active_record_connection_tz/version.rb
+- lib/activerecord-connection-tz.rb
+- sig/active_record_connection_tz/adapters.rbs
+- sig/generated/active_record_connection_tz.rbs
+- sig/generated/active_record_connection_tz/adapters/mysql2.rbs
+- sig/generated/active_record_connection_tz/adapters/shared.rbs
+- sig/generated/active_record_connection_tz/adapters/trilogy.rbs
+- sig/generated/active_record_connection_tz/connection_settings.rbs
+- sig/generated/active_record_connection_tz/temporal_formatter.rbs
+- sig/generated/active_record_connection_tz/temporal_parser.rbs
+- sig/generated/active_record_connection_tz/types.rbs
+- sig/generated/active_record_connection_tz/types/zoned_date_time.rbs
+- sig/generated/active_record_connection_tz/types/zoned_temporal.rbs
+- sig/generated/active_record_connection_tz/types/zoned_time.rbs
+- sig/generated/active_record_connection_tz/version.rbs
+- sig/generated/activerecord-connection-tz.rbs
+homepage: https://github.com/shoma07/activerecord-connection-tz
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/shoma07/activerecord-connection-tz
+  source_code_uri: https://github.com/shoma07/activerecord-connection-tz/tree/v0.1.0
+  changelog_uri: https://github.com/shoma07/activerecord-connection-tz/blob/v0.1.0/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Connection-scoped timezone handling for mixed-timezone Active Record apps
+test_files: []