activerecord-bitemporal 5.3.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c660ad9554b7d5285a28f3efcd6a6c10e2b5e45b6922956e37f931ae807ba483
-  data.tar.gz: 24646d6dc75344e11f613f70c7847639f8c86524ce3d1b178f4abb69dc60694f
+  metadata.gz: 7676d93276c1c24acbb001b135c344b94d3b0b8084d2ef17423c238b5e06bfaf
+  data.tar.gz: f07cc0d7a716c99d3d85f352588309351b3ed408e6ddec5ad153096dd2310786
 SHA512:
-  metadata.gz: 39e0aea4e39482bcb929d0df586232413193f57a232ca7b2b928ca9aaef90d84fa88fc1edb925bcbff466864314beafa69e9caf36057ba7f4529019791d33698
-  data.tar.gz: 84bc4e20042ffb77c2f317fcf6ce85b1b469edb338ec0a1346a9dd0008d1b01e49037503124778144521704ed97af904632bf91f424acc41448968d4beba0a5b
+  metadata.gz: 95b6ea9e934a5818d3fc3e0409faef14bde66aeafbd0a0a168a1649e3b88ed6a11a0e8174094f7527ae4ba47076449db17a17597b83587a8986815af458b6c19
+  data.tar.gz: ece5cc5e3a8846f6495b63b30eb35eb4648e95b712e582b72fa67dafd1cfe9af1384737a11cf272d06cf73ed9e9121a674a6e0ea90434edb77d1715603cf7ffe

data/CHANGELOG.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## 6.1.0
+
+### Breaking Changed
+
+### Added
+
+- [Support GlobalID integration #176](https://github.com/kufu/activerecord-bitemporal/pull/176)
+
+### Changed
+
+- [Add explicit activesupport dependency #208](https://github.com/kufu/activerecord-bitemporal/pull/208)
+- [Improve ValidDatetimeRangeError message with better grammar and context #207](https://github.com/kufu/activerecord-bitemporal/pull/207)
+- [Delay execution of ActiveRecord::Base-related processing #189](https://github.com/kufu/activerecord-bitemporal/pull/189)
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Chores
+
+- [Bump ruby/setup-ruby from 1.263.0 to 1.265.0 #223](https://github.com/kufu/activerecord-bitemporal/pull/223)
+- [Update gemspec files to avoid using git #222](https://github.com/kufu/activerecord-bitemporal/pull/222)
+- [Bump ruby/setup-ruby from 1.257.0 to 1.263.0 #221](https://github.com/kufu/activerecord-bitemporal/pull/221)
+- [Add CodeSpell workflow for spell checking in pull requests #220](https://github.com/kufu/activerecord-bitemporal/pull/220)
+- [Configure dependabot cooldown period to 3 days #219](https://github.com/kufu/activerecord-bitemporal/pull/219)
+- [Bump ruby/setup-ruby from 1.255.0 to 1.257.0 #218](https://github.com/kufu/activerecord-bitemporal/pull/218)
+- [Bump actions/checkout from 4.2.2 to 5.0.0 #215](https://github.com/kufu/activerecord-bitemporal/pull/215)
+- [Bump ruby/setup-ruby from 1.254.0 to 1.255.0 #214](https://github.com/kufu/activerecord-bitemporal/pull/214)
+- [Bump ruby/setup-ruby from 1.247.0 to 1.254.0 #213](https://github.com/kufu/activerecord-bitemporal/pull/213)
+- [Bump ruby/setup-ruby from 1.247.0 to 1.253.0 #212](https://github.com/kufu/activerecord-bitemporal/pull/212)
+- [Setup RuboCop #211](https://github.com/kufu/activerecord-bitemporal/pull/211)
+- [Bump ruby/setup-ruby from 1.245.0 to 1.247.0 #210](https://github.com/kufu/activerecord-bitemporal/pull/210)
+- [Using Trusted Publishing for RubyGems.org. #209](https://github.com/kufu/activerecord-bitemporal/pull/209)
+- [Bump ruby/setup-ruby from 1.244.0 to 1.245.0 #206](https://github.com/kufu/activerecord-bitemporal/pull/206)
+
+## 6.0.0
+
+### Breaking Changed
+
+- [Add Ruby 3.4 and remove Ruby 3.0 in CI #185](https://github.com/kufu/activerecord-bitemporal/pull/185)
+- [Drop support Rails 6.1 #192](https://github.com/kufu/activerecord-bitemporal/pull/192)
+
+### Added
+
+- [CI against Rails 7.2 #164](https://github.com/kufu/activerecord-bitemporal/pull/164)
+- [Support custom column names for valid time in .bitemporalize #200](https://github.com/kufu/activerecord-bitemporal/pull/200)
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+- [Prevent where clauses from ignored by `ignore_valid_datetime` #190](https://github.com/kufu/activerecord-bitemporal/pull/190)
+
+### Chores
+
+- [Add a note to the README that PostgreSQL is required to run the tests. #188](https://github.com/kufu/activerecord-bitemporal/pull/188)
+- [Remove specs for Rails 5.x #191](https://github.com/kufu/activerecord-bitemporal/pull/191)
+- [Update auto assign member #193](https://github.com/kufu/activerecord-bitemporal/pull/193)
+- [Pin GitHub Actions dependencies to specific commit hashes #194](https://github.com/kufu/activerecord-bitemporal/pull/194)
+- [Bump ruby/setup-ruby from 1.227.0 to 1.229.0 #195](https://github.com/kufu/activerecord-bitemporal/pull/195)
+- [Bump ruby/setup-ruby from 1.229.0 to 1.233.0 #197](https://github.com/kufu/activerecord-bitemporal/pull/197)
+- [Bump ruby/setup-ruby from 1.233.0 to 1.235.0 #198](https://github.com/kufu/activerecord-bitemporal/pull/198)
+- [Bump ruby/setup-ruby from 1.235.0 to 1.237.0 #199](https://github.com/kufu/activerecord-bitemporal/pull/199)
+- [Bump ruby/setup-ruby from 1.237.0 to 1.238.0 #201](https://github.com/kufu/activerecord-bitemporal/pull/201)
+- [Bump ruby/setup-ruby from 1.238.0 to 1.242.0 #202](https://github.com/kufu/activerecord-bitemporal/pull/202)
+- [Bump ruby/setup-ruby from 1.242.0 to 1.244.0 #203](https://github.com/kufu/activerecord-bitemporal/pull/203)
+- [Update auto assign member #204](https://github.com/kufu/activerecord-bitemporal/pull/204)
+
 ## 5.3.0
 
 ### Added

data/README.md

@@ -711,7 +711,7 @@ Employee.where(bitemporal_id: employee.bitemporal_id)
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. And start PostgreSQL on port 5432. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/lib/activerecord-bitemporal/bitemporal.rb

@@ -1,20 +1,8 @@
 # frozen_string_literal: true
 
+require "activerecord-bitemporal/bitemporal_checker"
 module ActiveRecord
   module Bitemporal
-    module BitemporalChecker
-      refine ::Class do
-        def bi_temporal_model?
-          include?(ActiveRecord::Bitemporal)
-        end
-      end
-
-      refine ::ActiveRecord::Relation do
-        def bi_temporal_model?
-          klass.include?(ActiveRecord::Bitemporal)
-        end
-      end
-    end
     using BitemporalChecker
 
     module Optionable
@@ -313,7 +301,7 @@ module ActiveRecord
       def _create_record(attribute_names = self.attribute_names)
         bitemporal_assign_initialize_value(valid_datetime: self.valid_datetime)
 
-        ActiveRecord::Bitemporal.valid_at!(self.valid_from) {
+        ActiveRecord::Bitemporal.valid_at!(self[valid_from_key]) {
           super()
         }
       end
@@ -346,8 +334,8 @@ module ActiveRecord
           # update 後に新しく生成したインスタンスのデータを移行する
           @_swapped_id_previously_was = swapped_id
           @_swapped_id = after_instance.swapped_id
-          self.valid_from = after_instance.valid_from
-          self.valid_to = after_instance.valid_to
+          self[valid_from_key] = after_instance[valid_from_key]
+          self[valid_to_key] = after_instance[valid_to_key]
           self.transaction_from = after_instance.transaction_from
           self.transaction_to = after_instance.transaction_to
 
@@ -373,14 +361,14 @@ module ActiveRecord
             # force_update の場合は削除時の状態の履歴を残さない
             unless force_update?
               # 削除時の状態を履歴レコードとして保存する
-              duplicated_instance.valid_to = target_datetime
+              duplicated_instance[valid_to_key] = target_datetime
               duplicated_instance.transaction_from = operated_at
               duplicated_instance.save_without_bitemporal_callbacks!(validate: false)
               if @destroyed
                 @_swapped_id_previously_was = swapped_id
                 @_swapped_id = duplicated_instance.swapped_id
-                self.valid_from = duplicated_instance.valid_from
-                self.valid_to = duplicated_instance.valid_to
+                self[valid_from_key] = duplicated_instance[valid_from_key]
+                self[valid_to_key] = duplicated_instance[valid_to_key]
                 self.transaction_from = duplicated_instance.transaction_from
                 self.transaction_to = duplicated_instance.transaction_to
               end
@@ -393,6 +381,7 @@ module ActiveRecord
       rescue => e
         @destroyed = false
         @_association_destroy_exception = ActiveRecord::RecordNotDestroyed.new("Failed to destroy the record: class=#{e.class}, message=#{e.message}", self)
+        @_association_destroy_exception.set_backtrace(e.backtrace)
         false
       end
 
@@ -411,55 +400,29 @@ module ActiveRecord
       module ::ActiveRecord::Persistence
         # MEMO: Must be override ActiveRecord::Persistence#reload
         alias_method :active_record_bitemporal_original_reload, :reload unless method_defined? :active_record_bitemporal_original_reload
-        if Gem::Version.new("7.0.0.alpha") <= ActiveRecord.version
-          def reload(options = nil)
-            return active_record_bitemporal_original_reload(options) unless self.class.bi_temporal_model?
-
-            self.class.connection.clear_query_cache
-
-            fresh_object =
-              ActiveRecord::Bitemporal.with_bitemporal_option(**bitemporal_option) {
-                if apply_scoping?(options)
-                  _find_record(options)
-                else
-                  self.class.unscoped { self.class.bitemporal_default_scope.scoping { _find_record(options) } }
-                end
-              }
+        def reload(options = nil)
+          return active_record_bitemporal_original_reload(options) unless self.class.bi_temporal_model?
 
-            @association_cache = fresh_object.instance_variable_get(:@association_cache)
-            @attributes = fresh_object.instance_variable_get(:@attributes)
-            @new_record = false
-            @previously_new_record = false
-            # NOTE: Hook to copying swapped_id
-            @_swapped_id_previously_was = nil
-            @_swapped_id = fresh_object.swapped_id
-            @previously_force_updated = false
-            self
-          end
-        else
-          def reload(options = nil)
-            return active_record_bitemporal_original_reload(options) unless self.class.bi_temporal_model?
-
-            self.class.connection.clear_query_cache
-
-            fresh_object =
-              ActiveRecord::Bitemporal.with_bitemporal_option(**bitemporal_option) {
-                if options && options[:lock]
-                  self.class.unscoped { self.class.lock(options[:lock]).bitemporal_default_scope.find(id) }
-                else
-                  self.class.unscoped { self.class.bitemporal_default_scope.find(id) }
-                end
-              }
+          self.class.connection.clear_query_cache
 
-            @attributes = fresh_object.instance_variable_get(:@attributes)
-            @new_record = false
-            @previously_new_record = false
-            # NOTE: Hook to copying swapped_id
-            @_swapped_id_previously_was = nil
-            @_swapped_id = fresh_object.swapped_id
-            @previously_force_updated = false
-            self
-          end
+          fresh_object =
+            ActiveRecord::Bitemporal.with_bitemporal_option(**bitemporal_option) {
+              if apply_scoping?(options)
+                _find_record(options)
+              else
+                self.class.unscoped { self.class.bitemporal_default_scope.scoping { _find_record(options) } }
+              end
+            }
+
+          @association_cache = fresh_object.instance_variable_get(:@association_cache)
+          @attributes = fresh_object.instance_variable_get(:@attributes)
+          @new_record = false
+          @previously_new_record = false
+          # NOTE: Hook to copying swapped_id
+          @_swapped_id_previously_was = nil
+          @_swapped_id = fresh_object.swapped_id
+          @previously_force_updated = false
+          self
         end
       end
 
@@ -467,7 +430,7 @@ module ActiveRecord
 
       def bitemporal_assign_initialize_value(valid_datetime:, current_time: Time.current)
         # 自身の `valid_from` を設定
-        self.valid_from = valid_datetime || current_time if self.valid_from == ActiveRecord::Bitemporal::DEFAULT_VALID_FROM
+        self[valid_from_key] = valid_datetime || current_time if self[valid_from_key] == ActiveRecord::Bitemporal::DEFAULT_VALID_FROM
 
         self.transaction_from = current_time if self.transaction_from == ActiveRecord::Bitemporal::DEFAULT_TRANSACTION_FROM
 
@@ -485,7 +448,7 @@ module ActiveRecord
       def bitemporal_build_update_records(valid_datetime:, current_time: Time.current, force_update: false)
         target_datetime = valid_datetime || current_time
         # NOTE: force_update の場合は自身のレコードを取得するような時間を指定しておく
-        target_datetime = valid_from_changed? ? valid_from_was : valid_from if force_update
+        target_datetime = attribute_changed?(valid_from_key) ? attribute_was(valid_from_key) : self[valid_from_key] if force_update
 
         # 対象基準日において有効なレコード
         # NOTE: 論理削除対象
@@ -516,26 +479,32 @@ module ActiveRecord
           current_valid_record.assign_transaction_to(current_time)
 
           # 以前の履歴データは valid_to を詰めて保存
-          before_instance.valid_to = target_datetime
+          before_instance[valid_to_key] = target_datetime
           if before_instance.valid_from_cannot_be_greater_equal_than_valid_to
-            raise ValidDatetimeRangeError.new("valid_from #{before_instance.valid_from} can't be greater equal than valid_to #{before_instance.valid_to}")
+            message = "#{valid_from_key} #{before_instance[valid_from_key]} can't be " \
+                      "greater than or equal to #{valid_to_key} #{before_instance[valid_to_key]} " \
+                      "for #{self.class} with bitemporal_id=#{bitemporal_id}"
+            raise ValidDatetimeRangeError.new(message)
           end
           before_instance.transaction_from = current_time
 
           # 以降の履歴データは valid_from と valid_to を調整して保存する
-          after_instance.valid_from = target_datetime
-          after_instance.valid_to = current_valid_record.valid_to
+          after_instance[valid_from_key] = target_datetime
+          after_instance[valid_to_key] = current_valid_record[valid_to_key]
           if after_instance.valid_from_cannot_be_greater_equal_than_valid_to
-            raise ValidDatetimeRangeError.new("valid_from #{after_instance.valid_from} can't be greater equal than valid_to #{after_instance.valid_to}")
+            message = "#{valid_from_key} #{after_instance[valid_from_key]} can't be " \
+                      "greater than or equal to #{valid_to_key} #{after_instance[valid_to_key]} " \
+                      "for #{self.class} with bitemporal_id=#{bitemporal_id}"
+            raise ValidDatetimeRangeError.new(message)
           end
           after_instance.transaction_from = current_time
 
         # 有効なレコードがない場合
         else
           # 一番近い未来にある Instance を取ってきて、その valid_from を valid_to に入れる
-          nearest_instance = self.class.where(bitemporal_id: bitemporal_id).valid_from_gt(target_datetime).ignore_valid_datetime.order(valid_from: :asc).first
+          nearest_instance = self.class.where(bitemporal_id: bitemporal_id).ignore_valid_datetime.valid_from_gt(target_datetime).order(valid_from_key => :asc).first
           if nearest_instance.nil?
-            message = "Update failed: Couldn't find #{self.class} with 'bitemporal_id'=#{self.bitemporal_id} and 'valid_from' < #{target_datetime}"
+            message = "Update failed: Couldn't find #{self.class} with 'bitemporal_id'=#{self.bitemporal_id} and '#{valid_from_key}' > #{target_datetime}"
             raise ActiveRecord::RecordNotFound.new(message, self.class, "bitemporal_id", self.bitemporal_id)
           end
 
@@ -546,8 +515,8 @@ module ActiveRecord
           before_instance = nil
 
           # 以降の履歴データは valid_from と valid_to を調整して保存する
-          after_instance.valid_from = target_datetime
-          after_instance.valid_to = nearest_instance.valid_from
+          after_instance[valid_from_key] = target_datetime
+          after_instance[valid_to_key] = nearest_instance[valid_from_key]
           after_instance.transaction_from = current_time
         end
 
@@ -569,7 +538,7 @@ module ActiveRecord
 
         target_datetime = record.valid_datetime || Time.current
 
-        valid_from = record.valid_from.yield_self { |valid_from|
+        valid_from = record[record.valid_from_key].yield_self { |valid_from|
           # NOTE: valid_from が初期値の場合は現在の時間を基準としてバリデーションする
           # valid_from が初期値の場合は Persistence#_create_record に Time.current が割り当てられる為
           # バリデーション時と生成時で若干時間がずれてしまうことには考慮する
@@ -586,17 +555,17 @@ module ActiveRecord
         }
 
         # MEMO: `force_update` does not refer to `valid_datetime`
-        valid_from = record.valid_from if record.force_update?
+        valid_from = record[record.valid_from_key] if record.force_update?
 
-        valid_to = record.valid_to.yield_self { |valid_to|
+        valid_to = record[record.valid_to_key].yield_self { |valid_to|
           # NOTE: `cover?` may give incorrect results, when the time zone is not UTC and `valid_from` is date type
           #   Therefore, cast to type of `valid_from`
-          record_valid_time = finder_class.type_for_attribute(:valid_from).cast(record.valid_datetime)
+          record_valid_time = finder_class.type_for_attribute(record.valid_from_key).cast(record.valid_datetime)
           # レコードを更新する時に valid_datetime が valid_from ~ valid_to の範囲外だった場合、
           #   一番近い未来の履歴レコードを参照して更新する
           # という仕様があるため、それを考慮して valid_to を設定する
-          if (record_valid_time && (record.valid_from...record.valid_to).cover?(record_valid_time)) == false && (record.persisted?)
-            finder_class.ignore_valid_datetime.where(bitemporal_id: record.bitemporal_id).valid_from_gteq(target_datetime).order(valid_from: :asc).first.valid_from
+          if (record_valid_time && (record[record.valid_from_key]...record[record.valid_to_key]).cover?(record_valid_time)) == false && (record.persisted?)
+            finder_class.ignore_valid_datetime.where(bitemporal_id: record.bitemporal_id).valid_from_gteq(target_datetime).order(record.valid_from_key => :asc).first[record.valid_from_key]
           else
             valid_to
           end

data/lib/activerecord-bitemporal/bitemporal_checker.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Bitemporal
+    module BitemporalChecker
+      refine ::Class do
+        def bi_temporal_model?
+          include?(ActiveRecord::Bitemporal)
+        end
+      end
+
+      refine ::ActiveRecord::Relation do
+        def bi_temporal_model?
+          klass.include?(ActiveRecord::Bitemporal)
+        end
+      end
+    end
+  end
+end

data/lib/activerecord-bitemporal/bitemporalize.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ActiveRecord::Bitemporal::Bitemporalize
+  using Module.new {
+    refine ::ActiveRecord::Base do
+      class << ::ActiveRecord::Base
+        def prepend_relation_delegate_class(mod)
+          relation_delegate_class(ActiveRecord::Relation).prepend mod
+          relation_delegate_class(ActiveRecord::AssociationRelation).prepend mod
+        end
+      end
+    end
+  }
+
+  module ClassMethods
+    include ActiveRecord::Bitemporal::Relation::Finder
+
+    def bitemporal_id_key
+      'bitemporal_id'
+    end
+
+    # Override ActiveRecord::Core::ClassMethods#cached_find_by_statement
+    # `.find_by` not use caching
+    def cached_find_by_statement(key, &block)
+      ActiveRecord::StatementCache.create(connection, &block)
+    end
+
+    def inherited(klass)
+      super
+      klass.prepend_relation_delegate_class ActiveRecord::Bitemporal::Relation
+      klass.relation_delegate_class(ActiveRecord::Associations::CollectionProxy).prepend ActiveRecord::Bitemporal::CollectionProxy
+      if relation_delegate_class(ActiveRecord::Relation).ancestors.include? ActiveRecord::Bitemporal::Relation::MergeWithExceptBitemporalDefaultScope
+        klass.relation_delegate_class(ActiveRecord::Relation).prepend ActiveRecord::Bitemporal::Relation::MergeWithExceptBitemporalDefaultScope
+      end
+    end
+  end
+
+  module InstanceMethods
+    include ActiveRecord::Bitemporal::Persistence
+
+    def swap_id!(without_clear_changes_information: false)
+      @_swapped_id_previously_was = nil
+      @_swapped_id = self.id
+      self.id = self.send(bitemporal_id_key)
+      clear_attribute_changes([:id]) unless without_clear_changes_information
+    end
+
+    def swapped_id
+      @_swapped_id || self.id
+    end
+
+    def swapped_id_previously_was
+      @_swapped_id_previously_was
+    end
+
+    def bitemporal_id_key
+      self.class.bitemporal_id_key
+    end
+
+    def bitemporal_ignore_update_columns
+      []
+    end
+
+    def id_in_database
+      swapped_id.presence || super
+    end
+
+    def previously_force_updated?
+      @previously_force_updated
+    end
+
+    def valid_from_cannot_be_greater_equal_than_valid_to
+      if self[valid_from_key] && self[valid_to_key] && self[valid_from_key] >= self[valid_to_key]
+        errors.add(valid_from_key, "can't be greater equal than #{valid_to_key}")
+      end
+    end
+
+    def transaction_from_cannot_be_greater_equal_than_transaction_to
+      if transaction_from && transaction_to && transaction_from >= transaction_to
+        errors.add(:transaction_from, "can't be greater equal than transaction_to")
+      end
+    end
+  end
+
+  def bitemporalize(
+    enable_strict_by_validates_bitemporal_id: false,
+    enable_default_scope: true,
+    enable_merge_with_except_bitemporal_default_scope: false,
+    valid_from_key: :valid_from,
+    valid_to_key: :valid_to
+  )
+    return if ancestors.include? InstanceMethods
+
+    extend ClassMethods
+    include InstanceMethods
+    include ActiveRecord::Bitemporal
+    include ActiveRecord::Bitemporal::Scope
+    include ActiveRecord::Bitemporal::Callbacks
+    prepend ActiveRecord::Bitemporal::GlobalID if defined?(::GlobalID)
+
+    if enable_merge_with_except_bitemporal_default_scope
+      relation_delegate_class(ActiveRecord::Relation).prepend ActiveRecord::Bitemporal::Relation::MergeWithExceptBitemporalDefaultScope
+    end
+
+    if enable_default_scope
+      default_scope {
+        bitemporal_default_scope
+      }
+    end
+
+    after_create do
+      # MEMO: #update_columns is not call #_update_row (and validations, callbacks)
+      update_columns(bitemporal_id_key => swapped_id) unless send(bitemporal_id_key)
+      swap_id!(without_clear_changes_information: true)
+      @previously_force_updated = false
+    end
+
+    after_find do
+      self.swap_id! if self.send(bitemporal_id_key).present?
+      @previously_force_updated = false
+    end
+
+    self.class_attribute :valid_from_key, :valid_to_key, instance_writer: false
+    self.valid_from_key = valid_from_key.to_s
+    self.valid_to_key = valid_to_key.to_s
+    attribute valid_from_key, default: ActiveRecord::Bitemporal::DEFAULT_VALID_FROM
+    attribute valid_to_key, default: ActiveRecord::Bitemporal::DEFAULT_VALID_TO
+    attribute :transaction_from, default: ActiveRecord::Bitemporal::DEFAULT_TRANSACTION_FROM
+    attribute :transaction_to, default: ActiveRecord::Bitemporal::DEFAULT_TRANSACTION_TO
+
+    # Callback hook to `validates :xxx, uniqueness: true`
+    const_set(:UniquenessValidator, Class.new(ActiveRecord::Validations::UniquenessValidator) {
+      prepend ActiveRecord::Bitemporal::Uniqueness
+    })
+
+    # validations
+    validates valid_from_key, presence: true
+    validates valid_to_key, presence: true
+    validates :transaction_from, presence: true
+    validates :transaction_to, presence: true
+    validate :valid_from_cannot_be_greater_equal_than_valid_to
+    validate :transaction_from_cannot_be_greater_equal_than_transaction_to
+
+    validates bitemporal_id_key, uniqueness: true, allow_nil: true, strict: enable_strict_by_validates_bitemporal_id
+
+    prepend_relation_delegate_class ActiveRecord::Bitemporal::Relation
+    relation_delegate_class(ActiveRecord::Associations::CollectionProxy).prepend ActiveRecord::Bitemporal::CollectionProxy
+  end
+end

data/lib/activerecord-bitemporal/global_id.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+begin
+  require "globalid"
+rescue LoadError
+  # If GlobalID is not available, we skip the GlobalID integration.
+  return
+end
+
+module ActiveRecord
+  module Bitemporal
+    module GlobalID
+      include ::GlobalID::Identification
+
+      def to_global_id(options = {})
+        super(options.merge(app: "bitemporal"))
+      end
+      alias to_gid to_global_id
+
+      class BitemporalLocator < ::GlobalID::Locator::BaseLocator
+        private
+
+        # @override https://github.com/rails/globalid/blob/v1.2.1/lib/global_id/locator.rb#L203
+        def primary_key(model_class)
+          model_class.respond_to?(:bitemporal_id_key) ? model_class.bitemporal_id_key : :id
+        end
+      end
+    end
+  end
+end
+
+# BiTemporal Data Model requires default scope, so `UnscopedLocator` cannot be used.
+GlobalID::Locator.use :bitemporal, ActiveRecord::Bitemporal::GlobalID::BitemporalLocator.new

data/lib/activerecord-bitemporal/scope.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "activerecord-bitemporal/bitemporal_checker"
+
 module ActiveRecord::Bitemporal
   module NodeBitemporalInclude
     refine String do
@@ -86,9 +88,9 @@ module ActiveRecord::Bitemporal
 
       refine Relation do
         def bitemporal_clause(table_name = klass.table_name)
-          node_hash = where_clause.bitemporal_query_hash("valid_from", "valid_to", "transaction_from", "transaction_to")
-          valid_from = node_hash.dig(table_name, "valid_from", 1)
-          valid_to   = node_hash.dig(table_name, "valid_to", 1)
+          node_hash = where_clause.bitemporal_query_hash(valid_from_key, valid_to_key, "transaction_from", "transaction_to")
+          valid_from = node_hash.dig(table_name, valid_from_key, 1)
+          valid_to   = node_hash.dig(table_name, valid_to_key, 1)
           transaction_from = node_hash.dig(table_name, "transaction_from", 1)
           transaction_to   = node_hash.dig(table_name, "transaction_to", 1)
           {
@@ -255,19 +257,24 @@ module ActiveRecord::Bitemporal
             rewhere(table[attr_name].public_send(operator, predicate_builder.build_bind_attribute(attr_name, value)))
           end
 
-          %i(valid_from valid_to transaction_from transaction_to).each { |column|
+          [
+            [:valid_from, "\#{valid_from_key}"], # Evaluate `valid_from/to_key` at runtime using `\#`
+            [:valid_to, "\#{valid_to_key}"],
+            [:transaction_from, "transaction_from"],
+            [:transaction_to, "transaction_to"]
+          ].each { |column, column_name|
             module_eval <<-STR, __FILE__, __LINE__ + 1
               def _ignore_#{column}
-                unscope(where: :"\#{table.name}.#{column}")
-                  .tap { |relation| relation.unscope!(where: bitemporal_value[:through].arel_table["#{column}"]) if bitemporal_value[:through] }
+                unscope(where: :"\#{table.name}.#{column_name}")
+                  .tap { |relation| relation.unscope!(where: bitemporal_value[:through].arel_table["#{column_name}"]) if bitemporal_value[:through] }
               end
 
               def _except_#{column}
                 return self unless where_clause.send(:predicates).find { |node|
-                  node.bitemporal_include?("\#{table.name}.#{column}")
+                  node.bitemporal_include?("\#{table.name}.#{column_name}")
                 }
                 _ignore_#{column}.tap { |relation|
-                  relation.unscope_values.reject! { |query| query.equal_attribute_name("\#{table.name}.#{column}") }
+                  relation.unscope_values.reject! { |query| query.equal_attribute_name("\#{table.name}.#{column_name}") }
                 }
               end
             STR
@@ -281,8 +288,8 @@ module ActiveRecord::Bitemporal
               module_eval <<-STR, __FILE__, __LINE__ + 1
                 def _#{column}_#{op}(datetime)
                   target_datetime = datetime&.in_time_zone || Time.current
-                  bitemporal_rewhere_bind("#{column}", :#{op}, target_datetime)
-                    .tap { |relation| break relation.bitemporal_rewhere_bind("#{column}", :#{op}, target_datetime, bitemporal_value[:through].arel_table) if bitemporal_value[:through] }
+                  bitemporal_rewhere_bind("#{column_name}", :#{op}, target_datetime)
+                    .tap { |relation| break relation.bitemporal_rewhere_bind("#{column_name}", :#{op}, target_datetime, bitemporal_value[:through].arel_table) if bitemporal_value[:through] }
                 end
               STR
             }
@@ -428,17 +435,17 @@ module ActiveRecord::Bitemporal
         # beginless range
         if begin_
           # from < valid_to
-          relation = relation.bitemporal_where_bind("valid_to", :gt, begin_.in_time_zone.to_datetime)
+          relation = relation.bitemporal_where_bind(valid_to_key, :gt, begin_.in_time_zone.to_datetime)
         end
 
         # endless range
         if end_
           if range.exclude_end?
             # valid_from < to
-            relation = relation.bitemporal_where_bind("valid_from", :lt, end_.in_time_zone.to_datetime)
+            relation = relation.bitemporal_where_bind(valid_from_key, :lt, end_.in_time_zone.to_datetime)
           else
             # valid_from <= to
-            relation = relation.bitemporal_where_bind("valid_from", :lteq, end_.in_time_zone.to_datetime)
+            relation = relation.bitemporal_where_bind(valid_from_key, :lteq, end_.in_time_zone.to_datetime)
           end
         end
 
@@ -453,14 +460,14 @@ module ActiveRecord::Bitemporal
         begin_, end_ = range.begin, range.end
 
         if begin_
-          relation = relation.bitemporal_where_bind("valid_from", :gteq, begin_.in_time_zone.to_datetime)
+          relation = relation.bitemporal_where_bind(valid_from_key, :gteq, begin_.in_time_zone.to_datetime)
         end
 
         if end_
           if range.exclude_end?
             raise 'Range with excluding end is not supported'
           else
-            relation = relation.bitemporal_where_bind("valid_to", :lteq, end_.in_time_zone.to_datetime)
+            relation = relation.bitemporal_where_bind(valid_to_key, :lteq, end_.in_time_zone.to_datetime)
           end
         end
 
@@ -476,10 +483,10 @@ module ActiveRecord::Bitemporal
           ignore_valid_datetime.bitemporal_for(*ids)
         }
         def self.bitemporal_most_future(id)
-          bitemporal_histories(id).order(valid_from: :asc).last
+          bitemporal_histories(id).order(valid_from_key => :asc).last
         end
         def self.bitemporal_most_past(id)
-          bitemporal_histories(id).order(valid_from: :asc).first
+          bitemporal_histories(id).order(valid_from_key => :asc).first
         end
       end
     end