hoardable 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c4bc9bc4cdd73263a6afe5551b59f085cbf7dc3877e472df8abdba62f5fcbd6
-  data.tar.gz: 7aa8ea828b2f6083a80c93e34a1fcc5756508db15f2a317dc95bfea2ae8b1e28
+  metadata.gz: 1cd77fbd3d35df59423ba95f7286703ae0d3b0f78bd9097b3574c713c38aa4c7
+  data.tar.gz: d5971e9daf59a9fa5343c13e389b20fc5b6ff193b398d05c958f34dfd056d0cb
 SHA512:
-  metadata.gz: 915cba36e937b34667b2ad31ae8dd780224a417669a6bb3c1abdfb2c8a19c10525e7d29a0a4f264aa475362f9b823104bd5a40d71bfc01848db2eb6a463f7c1d
-  data.tar.gz: ab0faaab94b03c5b6452b7aad505e16b4bb98538ae8649cfd65e17d397e3d917e6e61c752ed39b820dc30d72503e993ec5d6fbe353391c29025759a4bedeff74
+  metadata.gz: 5de03adf485f38e3ee3a24999bf770d92792404894529a5317f9788d15b784c0bcd9aa28b3d2966340a1244296cdc7b4ebe6fdccd6791172b44ca498c4bf5fca
+  data.tar.gz: a39bd22b66c727ec791e704ec3b24592c068dd2eb29ae0fa7d70a440073bd6d635fd7f24f12d3ba34bf05976b311bab9ec6a5a6fdf9f9069311347d89ae8f8c0

data/.rubocop.yml

@@ -10,5 +10,9 @@ Metrics/ClassLength:
   Exclude:
     - 'test/**/*.rb'
 
+Metrics/BlockLength:
+  Exclude:
+    - 'test/**/*.rb'
+
 Style/DocumentDynamicEvalDefinition:
   Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 ## [Unreleased]
 
+- Stability is coming.
+
+## [0.8.0] - 2022-10-01
+
+- **Breaking Change** - Due to the performance benefit of using `insert` for database injection of
+  versions, and a personal opinion that only an `after_versioned` hook might be needed, the
+  `before_versioned` and `around_versioned` ActiveRecord hooks are removed.
+
+- **Breaking Change** - Another side effect of the performance benefit gained by using `insert` is
+  that a source model will need to be reloaded before a call to `versions` on it can access the
+  latest version after an `update` on the source record.
+
+- **Breaking Change** - Previously the inherited `_versions` tables did not have a unique index on
+  the ID column, though it still pulled from the same sequence as the parent table. Prior to version
+  0.4.0 though, it was possible to have multiple trashed versions with the same ID. Adding unique
+  indexes to version tables prior to version 0.4.0 could result in issues.
+
+## [0.7.0] - 2022-09-29
+
+- **Breaking Change** - Continuing along with the change below, the `foreign_key` on the `_versions`
+  tables is now changed to `hoardable_source_id` instead of the i18n model name dervied foreign key.
+  The intent is to never leave room for conflict of foreign keys for existing relationships. This
+  can be resolved by renaming the foreign key columns from their i18n model name derived column
+  names to `hoardable_source_id`, i.e. `rename_column :post_versions, :post_id, :hoardable_source_id`.
+
+## [0.6.0] - 2022-09-28
+
+- **Breaking Change** - Previously, a source model would `has_many :versions` with an inverse
+  relationship based on the i18n interpreted name of the source model. Now it simply `has_many
+  :versions, inverse_of :hoardable_source` to not potentially conflict with previously existing
+  relationships.
+
 ## [0.5.0] - 2022-09-25
 
 - **Breaking Change** - Untrashing a version will now insert a version for the untrash event with

data/Gemfile

@@ -2,6 +2,7 @@
 
 source 'https://rubygems.org'
 
+gem 'benchmark-ips', '~> 2.10'
 gem 'debug', '~> 1.6'
 gem 'minitest', '~> 5.0'
 gem 'rake', '~> 13.0'

data/README.md

@@ -76,7 +76,7 @@ $ irb
 >> Post
 => Post(id: integer, body: text, user_id: integer, created_at: datetime)
 >> PostVersion
-=> PostVersion(id: integer, body: text, user_id: integer, created_at: datetime, _data: jsonb, _during: tsrange, post_id: integer)
+=> PostVersion(id: integer, body: text, user_id: integer, created_at: datetime, _data: jsonb, _during: tsrange, hoardable_source_id: integer)
 ```
 
 A `Post` now `has_many :versions`. With the default configuration, whenever an update and deletion
@@ -86,7 +86,7 @@ of a `Post` occurs, a version is created:
 post = Post.create!(title: "Title")
 post.versions.size # => 0
 post.update!(title: "Revised Title")
-post.versions.size # => 1
+post.reload.versions.size # => 1
 post.versions.first.title # => "Title"
 post.destroy!
 post.trashed? # true
@@ -102,7 +102,7 @@ If you ever need to revert to a specific version, you can call `version.revert!`
 ``` ruby
 post = Post.create!(title: "Title")
 post.update!(title: "Whoops")
-post.versions.last.revert!
+post.reload.versions.last.revert!
 post.title # => "Title"
 ```
 
@@ -134,7 +134,7 @@ If you want to look-up the version of a record at a specific time, you can use t
 ```ruby
 post.at(1.day.ago) # => #<PostVersion>
 # or you can use the scope on the version model class
-PostVersion.at(1.day.ago).find_by(post_id: post.id) # => #<PostVersion>
+PostVersion.at(1.day.ago).find_by(hoardable_source_id: post.id) # => #<PostVersion>
 ```
 
 The source model class also has an `.at` method:
@@ -182,7 +182,7 @@ Hoardable.whodunit = -> { Current.user&.id }
 # somewhere in your app code
 Current.user = User.find(123)
 post.update!(status: 'live')
-post.versions.last.hoardable_whodunit # => 123
+post.reload.versions.last.hoardable_whodunit # => 123
 ```
 
 You can also set this context manually as well, just remember to clear them afterwards.
@@ -191,7 +191,7 @@ You can also set this context manually as well, just remember to clear them afte
 Hoardable.note = "reverting due to accidental deletion"
 post.update!(title: "We’re back!")
 Hoardable.note = nil
-post.versions.last.hoardable_note # => "reverting due to accidental deletion"
+post.reload.versions.last.hoardable_note # => "reverting due to accidental deletion"
 ```
 
 A more useful pattern is to use `Hoardable.with` to set the context around a block. A good example
@@ -225,9 +225,9 @@ version.hoardable_event_uuid
 
 ### Model Callbacks
 
-Sometimes you might want to do something with a version before or after it gets inserted to the
-database. You can access it in `before/after/around_versioned` callbacks on the source record as
-`hoardable_version`. These happen around `.save`, which is enclosed in an ActiveRecord transaction.
+Sometimes you might want to do something with a version after it gets inserted to the database. You
+can access it in `after_versioned` callbacks on the source record as `hoardable_version`. These
+happen within `ActiveRecord`’s `.save`, which is enclosed in an ActiveRecord transaction.
 
 There are also `after_reverted` and `after_untrashed` callbacks available as well, which are called
 on the source record after a version is reverted or untrashed.
@@ -235,14 +235,14 @@ on the source record after a version is reverted or untrashed.
 ```ruby
 class User
   include Hoardable::Model
-  before_versioned :sanitize_version
+  after_versioned :track_versioned_event
   after_reverted :track_reverted_event
   after_untrashed :track_untrashed_event
 
   private
 
-  def sanitize_version
-    hoardable_version.sanitize_password
+  def track_versioned_event
+    track_event(:user_versioned, hoardable_version)
   end
 
   def track_reverted_event
@@ -338,14 +338,13 @@ class Post < ActiveRecord::Base
     Comment
       .version_class
       .trashed
-      .where(post_id: id)
       .with_hoardable_event_uuid(hoardable_event_uuid)
       .find_each(&:untrash!)
   end
 end
 ```
 
-If there are models that might be related to versions that are trashed or otherwise, and/or might
+If there are models that might be related to versions that are trashed or otherwise, and/or might be
 trashed themselves, you can bypass the inherited tables query handling altogether by using the
 `return_everything` configuration variable in `Hoardable.with`. This will ensure that you always see
 all records, including update and trashed versions.

data/lib/generators/hoardable/templates/migration.rb.erb

@@ -8,11 +8,12 @@ class Create<%= class_name.singularize %>Versions < ActiveRecord::Migration[<%=
       t.tsrange :_during, null: false
       t.uuid :_event_uuid, null: false, index: true
       t.enum :_operation, enum_type: 'hoardable_operation', null: false, index: true
-      t.<%= foreign_key_type %> :<%= singularized_table_name %>_id, null: false, index: true
+      t.<%= foreign_key_type %> :hoardable_source_id, null: false, index: true
     end
+    add_index(:<%= singularized_table_name %>_versions, :id, unique: true)
     add_index(
       :<%= singularized_table_name %>_versions,
-      %i[_during <%= singularized_table_name %>_id],
+      %i[_during hoardable_source_id],
       name: 'idx_<%= singularized_table_name %>_versions_temporally'
     )
   end

data/lib/generators/hoardable/templates/migration_6.rb.erb

@@ -23,11 +23,12 @@ class Create<%= class_name.singularize %>Versions < ActiveRecord::Migration[<%=
       t.tsrange :_during, null: false
       t.uuid :_event_uuid, null: false, index: true
       t.column :_operation, :hoardable_operation, null: false, index: true
-      t.<%= foreign_key_type %> :<%= singularized_table_name %>_id, null: false, index: true
+      t.<%= foreign_key_type %> :hoardable_source_id, null: false, index: true
     end
+    add_index(:<%= singularized_table_name %>_versions, :id, unique: true)
     add_index(
       :<%= singularized_table_name %>_versions,
-      %i[_during <%= singularized_table_name %>_id],
+      %i[_during hoardable_source_id],
       name: 'idx_<%= singularized_table_name %>_versions_temporally'
     )
   end

data/lib/hoardable/associations.rb

@@ -17,9 +17,9 @@ module Hoardable
 
         define_method(trashable_relationship_name) do
           source_reflection = self.class.reflections[name.to_s]
-          version_class = source_reflection.klass.version_class
+          version_class = source_reflection.version_class
           version_class.trashed.only_most_recent.find_by(
-            version_class.hoardable_source_foreign_key => source_reflection.foreign_key
+            hoardable_source_id: source_reflection.foreign_key
           )
         end
 

data/lib/hoardable/database_client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Hoardable
+  # This is a private service class that manages the insertion of {VersionModel}s into the
+  # PostgreSQL database.
+  class DatabaseClient
+    attr_reader :source_record
+
+    def initialize(source_record)
+      @source_record = source_record
+    end
+
+    delegate :version_class, to: :source_record
+
+    def insert_hoardable_version(operation, &block)
+      version = version_class.insert(initialize_version_attributes(operation), returning: :id)
+      version_id = version[0]['id']
+      source_record.instance_variable_set('@hoardable_version', version_class.find(version_id))
+      source_record.run_callbacks(:versioned, &block)
+    end
+
+    def find_or_initialize_hoardable_event_uuid
+      Thread.current[:hoardable_event_uuid] ||= ActiveRecord::Base.connection.query('SELECT gen_random_uuid();')[0][0]
+    end
+
+    def initialize_version_attributes(operation)
+      source_record.attributes_before_type_cast.without('id').merge(
+        source_record.changes.transform_values { |h| h[0] },
+        {
+          'hoardable_source_id' => source_record.id,
+          '_event_uuid' => find_or_initialize_hoardable_event_uuid,
+          '_operation' => operation,
+          '_data' => initialize_hoardable_data.merge(changes: source_record.changes),
+          '_during' => initialize_temporal_range
+        }
+      )
+    end
+
+    def initialize_temporal_range
+      ((previous_temporal_tsrange_end || hoardable_source_epoch)..Time.now.utc)
+    end
+
+    def initialize_hoardable_data
+      DATA_KEYS.to_h do |key|
+        [key, assign_hoardable_context(key)]
+      end
+    end
+
+    def assign_hoardable_context(key)
+      return nil if (value = Hoardable.public_send(key)).nil?
+
+      value.is_a?(Proc) ? value.call : value
+    end
+
+    def unset_hoardable_version_and_event_uuid
+      source_record.instance_variable_set('@hoardable_version', nil)
+      return if source_record.class.connection.transaction_open?
+
+      Thread.current[:hoardable_event_uuid] = nil
+    end
+
+    def previous_temporal_tsrange_end
+      source_record.versions.only_most_recent.pluck('_during').first&.end
+    end
+
+    def hoardable_source_epoch
+      if source_record.class.column_names.include?('created_at')
+        source_record.created_at
+      else
+        maybe_warn_about_missing_created_at_column
+        Time.at(0).utc
+      end
+    end
+
+    def maybe_warn_about_missing_created_at_column
+      return unless source_record.class.hoardable_config[:warn_on_missing_created_at_column]
+
+      source_table_name = source_record.class.table_name
+      Hoardable.logger.info(
+        <<~LOG
+          '#{source_table_name}' does not have a 'created_at' column, so the first version’s temporal period
+          will begin at the unix epoch instead. Add a 'created_at' column to '#{source_table_name}'
+          or set 'Hoardable.warn_on_missing_created_at_column = false' to disable this message.
+        LOG
+      )
+    end
+  end
+  private_constant :DatabaseClient
+end

data/lib/hoardable/hoardable.rb

@@ -8,7 +8,7 @@ module Hoardable
 
   # Symbols for use with setting {Hoardable} configuration. See {file:README.md#configuration
   # README} for more.
-  CONFIG_KEYS = %i[enabled version_updates save_trash return_everything].freeze
+  CONFIG_KEYS = %i[enabled version_updates save_trash return_everything warn_on_missing_created_at_column].freeze
 
   VERSION_CLASS_SUFFIX = 'Version'
   private_constant :VERSION_CLASS_SUFFIX
@@ -19,6 +19,21 @@ module Hoardable
   DURING_QUERY = '_during @> ?::timestamp'
   private_constant :DURING_QUERY
 
+  HOARDABLE_CALLBACKS_ENABLED = proc do |source_model|
+    source_model.class.hoardable_config[:enabled] && !source_model.class.name.end_with?(VERSION_CLASS_SUFFIX)
+  end.freeze
+  private_constant :HOARDABLE_CALLBACKS_ENABLED
+
+  HOARDABLE_SAVE_TRASH = proc do |source_model|
+    source_model.class.hoardable_config[:save_trash]
+  end.freeze
+  private_constant :HOARDABLE_SAVE_TRASH
+
+  HOARDABLE_VERSION_UPDATES = proc do |source_model|
+    source_model.class.hoardable_config[:version_updates]
+  end.freeze
+  private_constant :HOARDABLE_VERSION_UPDATES
+
   @context = {}
   @config = CONFIG_KEYS.to_h do |key|
     [key, key != :return_everything]
@@ -59,5 +74,10 @@ module Hoardable
       @config = current_config
       @context = current_context
     end
+
+    # @!visibility private
+    def logger
+      @logger ||= ActiveSupport::TaggedLogging.new(Logger.new($stdout))
+    end
   end
 end

data/lib/hoardable/model.rb

@@ -46,7 +46,7 @@ module Hoardable
 
     included do
       include Associations
-      define_model_callbacks :versioned
+      define_model_callbacks :versioned, only: :after
       define_model_callbacks :reverted, only: :after
       define_model_callbacks :untrashed, only: :after
 

data/lib/hoardable/source_model.rb

@@ -7,6 +7,15 @@ module Hoardable
   module SourceModel
     extend ActiveSupport::Concern
 
+    # The +Version+ class instance for use within +versioned+, +reverted+, and +untrashed+ callbacks.
+    attr_reader :hoardable_version
+
+    # @!attribute [r] hoardable_event_uuid
+    #   @return [String] A postgres UUID that represents the +version+’s +ActiveRecord+ database transaction
+    # @!attribute [r] hoardable_operation
+    #   @return [String] The database operation that created the +version+ - either +update+ or +delete+.
+    delegate :hoardable_event_uuid, :hoardable_operation, to: :hoardable_version, allow_nil: true
+
     class_methods do
       # The dynamically generated +Version+ class for this model.
       def version_class
@@ -17,27 +26,27 @@ module Hoardable
     included do
       include Tableoid
 
-      around_update :insert_hoardable_version_on_update, if: %i[hoardable_callbacks_enabled hoardable_version_updates]
-      around_destroy :insert_hoardable_version_on_destroy, if: %i[hoardable_callbacks_enabled hoardable_save_trash]
-      before_destroy :delete_hoardable_versions, if: :hoardable_callbacks_enabled, unless: :hoardable_save_trash
-      after_commit :unset_hoardable_version_and_event_uuid
+      around_update(if: [HOARDABLE_CALLBACKS_ENABLED, HOARDABLE_VERSION_UPDATES]) do |_, block|
+        hoardable_client.insert_hoardable_version('update', &block)
+      end
+
+      around_destroy(if: [HOARDABLE_CALLBACKS_ENABLED, HOARDABLE_SAVE_TRASH]) do |_, block|
+        hoardable_client.insert_hoardable_version('delete', &block)
+      end
 
-      # This will contain the +Version+ class instance for use within +versioned+, +reverted+, and
-      # +untrashed+ callbacks.
-      attr_reader :hoardable_version
+      before_destroy(if: HOARDABLE_CALLBACKS_ENABLED, unless: HOARDABLE_SAVE_TRASH) do
+        versions.delete_all(:delete_all)
+      end
 
-      # @!attribute [r] hoardable_event_uuid
-      #   @return [String] A postgres UUID that represents the +version+’s +ActiveRecord+ database transaction
-      # @!attribute [r] hoardable_operation
-      #   @return [String] The database operation that created the +version+ - either +update+ or +delete+.
-      delegate :hoardable_event_uuid, :hoardable_operation, to: :hoardable_version, allow_nil: true
+      after_commit { hoardable_client.unset_hoardable_version_and_event_uuid }
 
       # Returns all +versions+ in ascending order of their temporal timeframes.
       has_many(
         :versions, -> { order('UPPER(_during) ASC') },
         dependent: nil,
         class_name: version_class.to_s,
-        inverse_of: model_name.i18n_key
+        inverse_of: :hoardable_source,
+        foreign_key: :hoardable_source_id
       )
 
       # @!scope class
@@ -47,11 +56,8 @@ module Hoardable
       # Returns instances of the source model and versions that were valid at the supplied
       # +datetime+ or +time+, all cast as instances of the source model.
       scope :at, lambda { |datetime|
-        versioned = version_class.at(datetime)
-        trashed = version_class.trashed_at(datetime)
-        foreign_key = version_class.hoardable_source_foreign_key
-        include_versions.where(id: versioned.select('id')).or(
-          where.not(id: versioned.select(foreign_key)).where.not(id: trashed.select(foreign_key))
+        include_versions.where(id: version_class.at(datetime).select('id')).or(
+          where.not(id: version_class.select(:hoardable_source_id).where(DURING_QUERY, datetime))
         )
       }
     end
@@ -70,7 +76,7 @@ module Hoardable
     def at(datetime)
       raise(Error, 'Future state cannot be known') if datetime.future?
 
-      versions.find_by(DURING_QUERY, datetime) || self
+      versions.at(datetime).first || self
     end
 
     # If a version is found at the supplied datetime, it will +revert!+ to it and return it. This
@@ -80,81 +86,15 @@ module Hoardable
     def revert_to!(datetime)
       return unless (version = at(datetime))
 
-      version.is_a?(self.class.version_class) ? version.revert! : self
-    end
-
-    private
-
-    def hoardable_callbacks_enabled
-      self.class.hoardable_config[:enabled] && !self.class.name.end_with?(VERSION_CLASS_SUFFIX)
+      version.is_a?(version_class) ? version.revert! : self
     end
 
-    def hoardable_save_trash
-      self.class.hoardable_config[:save_trash]
-    end
-
-    def hoardable_version_updates
-      self.class.hoardable_config[:version_updates]
-    end
-
-    def insert_hoardable_version_on_update(&block)
-      insert_hoardable_version('update', &block)
-    end
-
-    def insert_hoardable_version_on_destroy(&block)
-      insert_hoardable_version('delete', &block)
-    end
-
-    def insert_hoardable_version_on_untrashed
-      initialize_hoardable_version('insert').save(validate: false, touch: false)
-    end
+    delegate :version_class, to: :class
 
-    def insert_hoardable_version(operation)
-      @hoardable_version = initialize_hoardable_version(operation)
-      run_callbacks(:versioned) do
-        yield
-        hoardable_version.save(validate: false, touch: false)
-      end
-    end
-
-    def find_or_initialize_hoardable_event_uuid
-      Thread.current[:hoardable_event_uuid] ||= ActiveRecord::Base.connection.query('SELECT gen_random_uuid();')[0][0]
-    end
-
-    def initialize_hoardable_version(operation)
-      versions.new(
-        attributes_before_type_cast.without('id').merge(
-          changes.transform_values { |h| h[0] },
-          {
-            _event_uuid: find_or_initialize_hoardable_event_uuid,
-            _operation: operation,
-            _data: initialize_hoardable_data.merge(changes: changes)
-          }
-        )
-      )
-    end
-
-    def initialize_hoardable_data
-      DATA_KEYS.to_h do |key|
-        [key, assign_hoardable_context(key)]
-      end
-    end
-
-    def assign_hoardable_context(key)
-      return nil if (value = Hoardable.public_send(key)).nil?
-
-      value.is_a?(Proc) ? value.call : value
-    end
-
-    def delete_hoardable_versions
-      versions.delete_all(:delete_all)
-    end
-
-    def unset_hoardable_version_and_event_uuid
-      @hoardable_version = nil
-      return if ActiveRecord::Base.connection.transaction_open?
+    private
 
-      Thread.current[:hoardable_event_uuid] = nil
+    def hoardable_client
+      @hoardable_client ||= DatabaseClient.new(self)
     end
   end
 end

data/lib/hoardable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hoardable
-  VERSION = '0.5.0'
+  VERSION = '0.8.0'
 end

data/lib/hoardable/version_model.rb

@@ -7,18 +7,21 @@ module Hoardable
     extend ActiveSupport::Concern
 
     class_methods do
-      # Returns the foreign column that holds the reference to the source model of the version.
-      def hoardable_source_foreign_key
-        @hoardable_source_foreign_key ||= "#{superclass.model_name.i18n_key}_id"
+      # This is needed to omit the pseudo row of 'tableoid' when using +ActiveRecord+’s +insert+.
+      #
+      # @!visibility private
+      def scope_attributes
+        super.without('tableoid')
       end
     end
 
     included do
-      hoardable_source_key = superclass.model_name.i18n_key
-
       # A +version+ belongs to it’s parent +ActiveRecord+ source.
-      belongs_to hoardable_source_key, inverse_of: :versions
-      alias_method :hoardable_source, hoardable_source_key
+      belongs_to(
+        :hoardable_source,
+        inverse_of: :versions,
+        class_name: superclass.model_name
+      )
 
       self.table_name = "#{table_name.singularize}#{VERSION_TABLE_SUFFIX}"
 
@@ -27,15 +30,13 @@ module Hoardable
       alias_attribute :hoardable_event_uuid, :_event_uuid
       alias_attribute :hoardable_during, :_during
 
-      before_create :assign_temporal_tsrange
-
       # @!scope class
       # @!method trashed
       # @return [ActiveRecord<Object>]
       #
       # Returns only trashed +versions+ that are currently orphans.
       scope :trashed, lambda {
-        left_outer_joins(hoardable_source_key)
+        left_outer_joins(:hoardable_source)
           .where(superclass.table_name => { id: nil })
           .where(_operation: 'delete')
       }
@@ -90,12 +91,11 @@ module Hoardable
       raise(Error, 'Version is not trashed, cannot untrash') unless hoardable_operation == 'delete'
 
       transaction do
-        superscope = self.class.superclass.unscoped
-        superscope.insert(hoardable_source_attributes.merge('id' => hoardable_source_foreign_id))
-        superscope.find(hoardable_source_foreign_id).tap do |untrashed|
-          untrashed.send('insert_hoardable_version_on_untrashed')
-          untrashed.instance_variable_set(:@hoardable_version, self)
-          untrashed.run_callbacks(:untrashed)
+        insert_untrashed_source.tap do |untrashed|
+          untrashed.send('hoardable_client').insert_hoardable_version('insert') do
+            untrashed.instance_variable_set(:@hoardable_version, self)
+            untrashed.run_callbacks(:untrashed)
+          end
         end
       end
     end
@@ -115,34 +115,22 @@ module Hoardable
 
     # Returns the foreign reference that represents the source model of the version.
     def hoardable_source_foreign_id
-      @hoardable_source_foreign_id ||= public_send(hoardable_source_foreign_key)
+      @hoardable_source_foreign_id ||= public_send(:hoardable_source_id)
     end
 
     private
 
-    delegate :hoardable_source_foreign_key, to: :class
+    def insert_untrashed_source
+      superscope = self.class.superclass.unscoped
+      superscope.insert(hoardable_source_attributes.merge('id' => hoardable_source_foreign_id))
+      superscope.find(hoardable_source_foreign_id)
+    end
 
     def hoardable_source_attributes
       @hoardable_source_attributes ||=
         attributes_before_type_cast
-        .without(hoardable_source_foreign_key)
+        .without('hoardable_source_id')
         .reject { |k, _v| k.start_with?('_') }
     end
-
-    def previous_temporal_tsrange_end
-      hoardable_source.versions.only_most_recent.pluck('_during').first&.end
-    end
-
-    def assign_temporal_tsrange
-      range_start = (
-        previous_temporal_tsrange_end ||
-        if hoardable_source.class.column_names.include?('created_at')
-          hoardable_source.created_at
-        else
-          Time.at(0).utc
-        end
-      )
-      self._during = (range_start..Time.now.utc)
-    end
   end
 end

data/lib/hoardable.rb

@@ -4,6 +4,7 @@ require_relative 'hoardable/version'
 require_relative 'hoardable/hoardable'
 require_relative 'hoardable/tableoid'
 require_relative 'hoardable/error'
+require_relative 'hoardable/database_client'
 require_relative 'hoardable/source_model'
 require_relative 'hoardable/version_model'
 require_relative 'hoardable/model'

data/sig/hoardable.rbs

@@ -1,14 +1,19 @@
 module Hoardable
   VERSION: String
   DATA_KEYS: [:meta, :whodunit, :note, :event_uuid]
-  CONFIG_KEYS: [:enabled, :version_updates, :save_trash, :return_everything]
+  CONFIG_KEYS: [:enabled, :version_updates, :save_trash, :return_everything, :warn_on_missing_created_at_column]
   VERSION_CLASS_SUFFIX: String
   VERSION_TABLE_SUFFIX: String
   DURING_QUERY: String
+  HOARDABLE_CALLBACKS_ENABLED: ^(untyped) -> untyped
+  HOARDABLE_SAVE_TRASH: ^(untyped) -> untyped
+  HOARDABLE_VERSION_UPDATES: ^(untyped) -> untyped
   self.@context: Hash[untyped, untyped]
   self.@config: untyped
+  self.@logger: untyped
 
   def self.with: (untyped hash) -> untyped
+  def self.logger: -> untyped
 
   module Tableoid
     TABLEOID_AREL_CONDITIONS: Proc
@@ -23,59 +28,68 @@ module Hoardable
   class Error < StandardError
   end
 
+  class DatabaseClient
+    attr_reader source_model: SourceModel
+    def initialize: (SourceModel source_model) -> void
+    def insert_hoardable_version: (untyped operation) -> untyped
+    def find_or_initialize_hoardable_event_uuid: -> untyped
+    def initialize_version_attributes: (untyped operation) -> untyped
+    def initialize_temporal_range: -> Range
+    def initialize_hoardable_data: -> untyped
+    def assign_hoardable_context: (:event_uuid | :meta | :note | :whodunit key) -> nil
+    def unset_hoardable_version_and_event_uuid: -> nil
+    def previous_temporal_tsrange_end: -> untyped
+    def hoardable_source_epoch: -> Time
+    def maybe_warn_about_missing_created_at_column: -> nil
+  end
+
   module SourceModel
     include Tableoid
+    @hoardable_client: DatabaseClient
 
+    attr_reader hoardable_version: untyped
     def trashed?: -> untyped
     def at: (untyped datetime) -> SourceModel
     def revert_to!: (untyped datetime) -> SourceModel?
 
     private
-    def hoardable_callbacks_enabled: -> untyped
-    def hoardable_save_trash: -> untyped
-    def hoardable_version_updates: -> untyped
-    def insert_hoardable_version_on_update: -> untyped
-    def insert_hoardable_version_on_destroy: -> untyped
-    def insert_hoardable_version: (String operation, untyped attrs) -> untyped
-    def find_or_initialize_hoardable_event_uuid: -> untyped
-    def initialize_hoardable_version: (String operation, untyped attrs) -> untyped
-    def initialize_hoardable_data: -> untyped
-    def assign_hoardable_context: (:event_uuid | :meta | :note | :whodunit key) -> nil
-    def delete_hoardable_versions: -> untyped
-    def unset_hoardable_version_and_event_uuid: -> nil
+    def hoardable_client: -> DatabaseClient
 
     public
     def version_class: -> untyped
-    attr_reader hoardable_version: nil
   end
 
   module VersionModel
-    @hoardable_source_attributes: untyped
-    @hoardable_source_foreign_key: String
     @hoardable_source_foreign_id: untyped
+    @hoardable_source_attributes: untyped
 
     def revert!: -> untyped
     def untrash!: -> untyped
     def changes: -> untyped
+    def hoardable_source_foreign_id: -> untyped
 
     private
-    def untrashable_hoardable_source_attributes: -> untyped
+    def insert_untrashed_source: -> untyped
     def hoardable_source_attributes: -> untyped
-    def hoardable_source_foreign_key: -> String
-    def hoardable_source_foreign_id: -> untyped
-    def previous_temporal_tsrange_end: -> untyped
-    def assign_temporal_tsrange: -> Range
+
+    public
+    def scope_attributes: -> untyped
   end
 
   module Model
     include VersionModel
     include SourceModel
+    include Associations
 
     attr_reader _hoardable_config: Hash[untyped, untyped]
     def hoardable_config: (?nil hash) -> untyped
     def with_hoardable_config: (untyped hash) -> untyped
   end
 
+  module Associations
+    def belongs_to_trashable: (untyped name, ?nil scope, **untyped) -> untyped
+  end
+
   class MigrationGenerator
     @singularized_table_name: untyped
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hoardable
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.0
 platform: ruby
 authors:
 - justin talbott
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-25 00:00:00.000000000 Z
+date: 2022-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -109,6 +109,7 @@ files:
 - lib/generators/hoardable/templates/migration_6.rb.erb
 - lib/hoardable.rb
 - lib/hoardable/associations.rb
+- lib/hoardable/database_client.rb
 - lib/hoardable/error.rb
 - lib/hoardable/hoardable.rb
 - lib/hoardable/model.rb