historiographer 4.1.14 → 4.3.0

data/historiographer.gemspec

@@ -0,0 +1,136 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: historiographer 4.3.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "historiographer".freeze
+  s.version = "4.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["brettshollenberger".freeze]
+  s.date = "2025-08-21"
+  s.description = "Creates separate tables for each history table".freeze
+  s.email = "brett.shollenberger@gmail.com".freeze
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    ".ruby-version",
+    ".standalone_migrations",
+    "Gemfile",
+    "Gemfile.lock",
+    "Guardfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "historiographer-4.1.12.gem",
+    "historiographer-4.1.13.gem",
+    "historiographer-4.1.14.gem",
+    "historiographer.gemspec",
+    "init.rb",
+    "instructions/implementation.md",
+    "instructions/todo.md",
+    "lib/historiographer.rb",
+    "lib/historiographer/configuration.rb",
+    "lib/historiographer/history.rb",
+    "lib/historiographer/history_migration.rb",
+    "lib/historiographer/history_migration_mysql.rb",
+    "lib/historiographer/mysql_migration.rb",
+    "lib/historiographer/postgres_migration.rb",
+    "lib/historiographer/relation.rb",
+    "lib/historiographer/safe.rb",
+    "lib/historiographer/silent.rb",
+    "lib/historiographer/version.rb",
+    "spec/db/database.yml",
+    "spec/db/migrate/20161121212228_create_posts.rb",
+    "spec/db/migrate/20161121212229_create_post_histories.rb",
+    "spec/db/migrate/20161121212230_create_authors.rb",
+    "spec/db/migrate/20161121212231_create_author_histories.rb",
+    "spec/db/migrate/20161121212232_create_users.rb",
+    "spec/db/migrate/20171011194624_create_safe_posts.rb",
+    "spec/db/migrate/20171011194715_create_safe_post_histories.rb",
+    "spec/db/migrate/20191024142304_create_thing_with_compound_index.rb",
+    "spec/db/migrate/20191024142352_create_thing_with_compound_index_history.rb",
+    "spec/db/migrate/20191024203106_create_thing_without_history.rb",
+    "spec/db/migrate/20221018204220_create_silent_posts.rb",
+    "spec/db/migrate/20221018204255_create_silent_post_histories.rb",
+    "spec/db/migrate/20241109182017_create_comments.rb",
+    "spec/db/migrate/20241109182020_create_comment_histories.rb",
+    "spec/db/migrate/20241119000000_create_datasets.rb",
+    "spec/db/migrate/2025082100000_create_projects.rb",
+    "spec/db/migrate/2025082100001_create_project_files.rb",
+    "spec/db/schema.rb",
+    "spec/factories/post.rb",
+    "spec/historiographer_spec.rb",
+    "spec/models/application_record.rb",
+    "spec/models/author.rb",
+    "spec/models/author_history.rb",
+    "spec/models/comment.rb",
+    "spec/models/comment_history.rb",
+    "spec/models/easy_ml/column.rb",
+    "spec/models/easy_ml/column_history.rb",
+    "spec/models/post.rb",
+    "spec/models/post_history.rb",
+    "spec/models/project.rb",
+    "spec/models/project_file.rb",
+    "spec/models/project_file_history.rb",
+    "spec/models/project_history.rb",
+    "spec/models/safe_post.rb",
+    "spec/models/safe_post_history.rb",
+    "spec/models/silent_post.rb",
+    "spec/models/silent_post_history.rb",
+    "spec/models/thing_with_compound_index.rb",
+    "spec/models/thing_with_compound_index_history.rb",
+    "spec/models/thing_without_history.rb",
+    "spec/models/user.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = "http://github.com/brettshollenberger/historiographer".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "3.2.22".freeze
+  s.summary = "Create histories of your ActiveRecord tables".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency(%q<activerecord>.freeze, [">= 6"])
+    s.add_runtime_dependency(%q<activerecord-import>.freeze, [">= 0"])
+    s.add_runtime_dependency(%q<activesupport>.freeze, [">= 0"])
+    s.add_runtime_dependency(%q<rails>.freeze, [">= 6"])
+    s.add_runtime_dependency(%q<rollbar>.freeze, [">= 0"])
+    s.add_development_dependency(%q<mysql2>.freeze, ["= 0.5"])
+    s.add_development_dependency(%q<paranoia>.freeze, [">= 0"])
+    s.add_development_dependency(%q<pg>.freeze, [">= 0"])
+    s.add_development_dependency(%q<pry>.freeze, [">= 0"])
+    s.add_development_dependency(%q<standalone_migrations>.freeze, [">= 0"])
+    s.add_development_dependency(%q<timecop>.freeze, [">= 0"])
+    s.add_development_dependency(%q<jeweler>.freeze, [">= 0"])
+    s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
+  else
+    s.add_dependency(%q<activerecord>.freeze, [">= 6"])
+    s.add_dependency(%q<activerecord-import>.freeze, [">= 0"])
+    s.add_dependency(%q<activesupport>.freeze, [">= 0"])
+    s.add_dependency(%q<rails>.freeze, [">= 6"])
+    s.add_dependency(%q<rollbar>.freeze, [">= 0"])
+    s.add_dependency(%q<mysql2>.freeze, ["= 0.5"])
+    s.add_dependency(%q<paranoia>.freeze, [">= 0"])
+    s.add_dependency(%q<pg>.freeze, [">= 0"])
+    s.add_dependency(%q<pry>.freeze, [">= 0"])
+    s.add_dependency(%q<standalone_migrations>.freeze, [">= 0"])
+    s.add_dependency(%q<timecop>.freeze, [">= 0"])
+    s.add_dependency(%q<jeweler>.freeze, [">= 0"])
+    s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+  end
+end
+

data/init.rb

@@ -0,0 +1,18 @@
+require "yaml"
+
+Bundler.require(:default, :development, :test)
+
+Dir.glob(File.expand_path("lib/**/*.rb")).each do |file|
+  require file
+end
+
+database_config = YAML.load(File.open(File.expand_path("spec/db/database.yml")).read)
+
+env = ENV["HISTORIOGRAPHER_ENV"] || "development"
+
+db_env_config = database_config[env]
+
+if defined?(ActiveRecord::Base)
+  # new settings as specified here: https://devcenter.heroku.com/articles/concurrency-and-database-connections
+  ActiveRecord::Base.establish_connection(db_env_config)
+end

data/instructions/implementation.md

@@ -0,0 +1,282 @@
+# Single Table Inheritance (STI) Implementation for Historiographer
+
+You are assisting with a Rails gem called Historiographer. Your role is to make precise, surgical edits to the codebase based on specific tasks. The project has a complex architecture with interdependent components, so caution is required.
+
+## Overview
+
+This document outlines the steps needed to properly implement Single Table Inheritance (STI) for the Historiographer gem, following Rails best practices. The current implementation has a complex method forwarding mechanism that can lead to subtle bugs. We need to refactor this to use a clean, standard Rails STI approach within separate inheritance hierarchies.
+
+## Current State Analysis
+
+The current implementation has the following issues:
+
+1. History classes implement a complex method delegation approach using `method_missing` and dynamic method definition
+2. STI is partially implemented but doesn't correctly handle the inheritance hierarchy within history classes
+3. The `type` column isn't properly set or managed according to Rails STI conventions
+4. Method delegation between original and history models is overly complex and error-prone
+
+## Implementation Requirements
+
+1. User can define a `type` for their class, and that will be used to identify the STI class
+2. The `type` should be a string, and the default value should be the class name
+3. When a user creates a new instance, the `type` should be set to the class name automatically
+4. STI subclasses should automatically inherit from their parent class
+5. History classes should maintain a parallel inheritance hierarchy to original classes
+6. When finding a history instance, it should automatically instantiate the correct subclass based on `type`
+7. Implement clean method delegation from history classes to original models
+
+## Implementation Approach: STI Within History Models
+
+We will implement STI separately within original models and history models, maintaining two parallel inheritance hierarchies:
+
+1. **Original Models Hierarchy**: `PrivatePost < Post < ActiveRecord::Base`
+2. **History Models Hierarchy**: `PrivatePostHistory < PostHistory < ActiveRecord::Base`
+
+This approach follows Rails conventions within each table while providing a clean way to implement method delegation between related models.
+
+## Implementation Steps
+
+### 1. Update `Historiographer::History` Module
+
+#### Changes Required:
+
+- Implement a clean method delegation system using `method_missing`
+- Support proper STI inheritance within history models
+- Ensure history classes correctly set and manage their `type` column
+- Maintain table separation between original and history models
+
+```ruby
+module Historiographer
+  module History
+    extend ActiveSupport::Concern
+
+    included do |base|
+      clear_validators! if respond_to?(:clear_validators!)
+
+      # Current scope for finding the most recent history
+      scope :current, -> { where(history_ended_at: nil).order(id: :desc) }
+
+      # Determine original class name
+      cattr_accessor :original_class_name
+      self.original_class_name = base.name.gsub(/History$/, '')
+
+      # Setup inheritance column for history classes
+      if self.original_class_name.constantize.respond_to?(:inheritance_column)
+        original_inheritance_column = self.original_class_name.constantize.inheritance_column
+        self.inheritance_column = original_inheritance_column
+      end
+
+      # Set up user association
+      unless self.original_class_name.constantize.ancestors.include?(Historiographer::Silent)
+        belongs_to :user, foreign_key: :history_user_id
+      end
+
+      # Ensure we can't destroy history records
+      before_destroy { |record| raise "Cannot destroy history records" }
+
+      # Handle type column for history classes
+      after_initialize do
+        # Set type to the history class if not already set
+        if self.type.nil? || !self.type.ends_with?('History')
+          self.type = self.class.name
+        end
+      end
+
+      # Setup class accessors for delegation
+      cattr_accessor :delegated_methods
+      self.delegated_methods = []
+    end
+
+    # Method delegation system
+    def method_missing(method, *args, &block)
+      # Try to find the original record to delegate to
+      foreign_key = self.class.determine_foreign_key
+      original_record = self.class.original_class_name.constantize.find_by(id: send(foreign_key))
+
+      if original_record && original_record.respond_to?(method)
+        # Cache the method for future calls
+        self.class.delegate_method(method)
+        # Call the method on the original record
+        original_record.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      # Check if the original class responds to this method
+      foreign_key = self.class.determine_foreign_key
+      original_record = self.class.original_class_name.constantize.find_by(id: send(foreign_key))
+      original_record&.respond_to?(method, include_private) || super
+    end
+
+    class_methods do
+      # Method to delegate methods from original class
+      def delegate_method(method_name)
+        return if method_defined?(method_name) || delegated_methods.include?(method_name.to_sym)
+
+        delegated_methods << method_name.to_sym
+
+        define_method(method_name) do |*args, &block|
+          foreign_key = self.class.determine_foreign_key
+          original_record = self.class.original_class_name.constantize.find_by(id: send(foreign_key))
+
+          if original_record
+            original_record.send(method_name, *args, &block)
+          else
+            raise NoMethodError, "undefined method `#{method_name}' for #{self}"
+          end
+        end
+      end
+
+      # Determine the foreign key based on the original class
+      def determine_foreign_key
+        association_name = self.original_class_name.split("::").last.underscore
+        "#{association_name}_id"
+      end
+    end
+
+    # Prevent destroying history records
+    def destroy
+      false
+    end
+
+    def destroy!
+      false
+    end
+
+    # Other existing scopes and methods...
+  end
+end
+```
+
+### 2. Update Original Model STI Support in `Historiographer` Module
+
+#### Changes Required:
+
+- Ensure proper type column handling in original models
+- Support proper mapping between original and history class hierarchy
+- Handle custom inheritance columns
+
+```ruby
+module Historiographer
+  extend ActiveSupport::Concern
+
+  included do |base|
+    # Existing code...
+
+    # Set default type for original models
+    if base.respond_to?(:inheritance_column) && base.column_names.include?(base.inheritance_column)
+      before_validation do
+        self[self.class.inheritance_column] ||= self.class.name
+      end
+    end
+
+    # Ensure history class creation supports STI
+    class_name = "#{base.name}History"
+
+    begin
+      history_class = class_name.constantize
+    rescue NameError
+      # Get the base table name without _histories suffix
+      base_table = base.table_name.singularize.sub(/_histories$/, '')
+
+      # Find the correct parent history class for STI
+      if base.superclass != ActiveRecord::Base && base.superclass.include?(Historiographer)
+        parent_history_class_name = "#{base.superclass.name}History"
+        begin
+          parent_history_class = parent_history_class_name.constantize
+        rescue NameError
+          parent_history_class = ActiveRecord::Base
+        end
+      else
+        parent_history_class = ActiveRecord::Base
+      end
+
+      # Create history class with proper inheritance
+      history_class_initializer = Class.new(parent_history_class) do
+        self.table_name = "#{base_table}_histories"
+        include Historiographer::History
+
+        # Set original class name for delegation
+        self.original_class_name = base.name
+
+        # Handle inheritance column
+        if base.respond_to?(:inheritance_column)
+          self.inheritance_column = base.inheritance_column
+        end
+      end
+
+      # Register the new class in the proper namespace
+      module_parts = class_name.split('::')
+      final_class_name = module_parts.pop
+
+      # Find or create module nesting
+      parent_module = Object
+      module_parts.each do |part|
+        parent_module = if parent_module.const_defined?(part)
+                        parent_module.const_get(part)
+                      else
+                        parent_module.const_set(part, Module.new)
+                      end
+      end
+
+      # Define the history class
+      history_class = parent_module.const_set(final_class_name, history_class_initializer)
+    end
+
+    # Existing code...
+  end
+
+  # Add helper methods for STI
+  module ClassMethods
+    def history_class_for_type(type_value)
+      if type_value.present?
+        "#{type_value}History".constantize
+      else
+        "#{self.name}History".constantize
+      end
+    rescue NameError
+      history_class
+    end
+  end
+
+  # Instance methods related to history and STI
+  def create_history(snapshot_id: nil)
+    # Use the correct history class based on the current type
+    type_column = self.class.inheritance_column
+    current_type = self[type_column] || self.class.name
+
+    begin
+      specific_history_class = self.class.history_class_for_type(current_type)
+    rescue NameError
+      specific_history_class = self.class.history_class
+    end
+
+    # Create history record with the proper type
+    history_record = record_history(specific_history_class, snapshot_id: snapshot_id)
+    history_record
+  end
+end
+```
+
+## Migration Testing Requirements
+
+1. Create comprehensive test cases for STI behavior in original and history models
+2. Test inheritance between original models (e.g., `PrivatePost < Post`)
+3. Test inheritance between history models (e.g., `PrivatePostHistory < PostHistory`)
+4. Test method delegation from history models to original models
+5. Test custom inheritance columns
+6. Test namespaced models
+7. Verify proper handling of the `type` column in both original and history tables
+
+## Backward Compatibility
+
+To ensure backward compatibility:
+
+1. Maintain existing history table structures
+2. Ensure old history records continue to work with the new implementation
+3. Support the same public API for accessing history records
+4. Handle existing applications that may have customized history class behavior
+
+By implementing STI separately within original and history models, we maintain Rails conventions while providing clean method delegation between related models.

data/instructions/todo.md

@@ -0,0 +1,96 @@
+## Context
+
+You are assisting with a Rails gem called Historiographer. Your role is to make precise, surgical edits to the codebase based on specific tasks. The project has a complex architecture with interdependent components, so caution is required.
+
+## Task:
+
+We are going to PROPERLY implement Single Table Inheritance (STI) for Historiographer, in line with Rails best practices.
+
+There is some existing code in here that implements STI, but it is not done correctly. We need to fix that.
+
+## Requirements:
+
+1. User can define a `type` for their class, and that will be used to identify the STI class
+2. In keeping with STI conventions, the `type` should be a string, and the default value should be the class name
+3. When a user creates a new instance of a class, the `type` should be set to the class name, and the class should automatically inherit the STI class
+
+In historiographer, we use a `histories` table for each model, for example:
+
+datasources => datasource_histories
+
+With STI, it is okay for us to have:
+
+class Datasource < ActiveRecord::Base
+def refresh # implemented in sub-classes
+end
+end
+
+class S3Datasource < Datasource
+def refresh
+s3.refresh
+end
+end
+
+class DatasourceHistory < Datasource
+end
+
+class S3DatasourceHistory < DatasourceHistory
+end
+
+4. But the STI class should automatically inherit the STI class, allowing it to use methods defined on the STI class, meaning that S3DatasourceHistory should have access to the `refresh` method that uses s3
+
+5. When we find an instance of DatasourceHistory, it should automatically give us the S3DatasourceHistory class if the `type` is "S3Datasource"
+
+6. The History classes currently have a VERY tricky and complicated way of doing STI that allows them to both act as proper history classes, and "proxy all requests" to the original class. This causes complicated and subtle bugs, and we need to fix that. I would assume that we should do this by inheriting from the original class, which will handle regular inheritance... but then we maybe need to include Historiographer::History to gain access to the history functionality.
+
+7. Implement tests which verify that the STI is working correctly, and that History objects can properly call all methods on the original class.
+
+## Rules
+
+### Do No Harm
+
+- Do not remove any code that seems to be irrelevant to your task. You do not have full context of the application, so you should err on the side of NOT removing code, unless the code is clearly duplication.
+- Preserve existing formatting, naming conventions, and code style whenever possible.
+- Keep changes minimal and focused on the specific task at hand.
+
+### Before Starting
+
+- Look for any files you might need to understand the context better
+- If you have any questions, DO NOT WRITE CODE. Ask the question. I will be happy to answer all your questions to your satisfaction before you start.
+- Measure twice, cut once!
+- Understand the full impact of your changes before implementing them.
+
+### Working Process
+
+1. **Analyze First**: Carefully review the code before suggesting any changes.
+2. **Ask Questions**: If anything is unclear, ask before proceeding.
+3. **Plan Your Approach**: Outline your intended changes before executing them.
+4. **Make Minimal Changes**: Focus only on what's needed for the task.
+5. **Explain Your Changes**: Document what you've done and why.
+
+## Technology-Specific Guidelines
+
+### Rails
+
+- Be aware of model associations and their dependencies.
+- Don't alter database migrations unless specifically asked.
+- Pay attention to Rails conventions and patterns in the existing code.
+- Be cautious when modifying controllers that might affect multiple views.
+
+## Common Pitfalls to Avoid
+
+- Adding unnecessary abstractions or "improvements" beyond the scope of the task
+- Rewriting functional code in your preferred style when it's not needed
+- Making major architectural changes when only small fixes are required
+- Assuming you understand the full context of the application
+- Using libraries or approaches not already in use in the project
+
+## Communication Guidelines
+
+- Be specific about what you're changing and why
+- If you're uncertain about something, ask first
+- Identify potential risks or side effects of your changes
+- If you spot issues unrelated to your task, note them separately without fixing them
+- Provide clear explanations of your thought process
+
+Remember: Your primary goal is to complete the specific task assigned with minimal disruption to the existing codebase. Quality and precision are more important than clever or extensive changes.

data/lib/historiographer/history.rb

@@ -179,11 +179,6 @@ module Historiographer
         belongs_to association_name, class_name: foreign_class_name
       end
 
-      # Enable STI for history classes
-      if foreign_class.sti_enabled?
-        self.inheritance_column = 'type'
-      end
-
       # Ensure we can't destroy history records
       before_destroy { |record| raise "Cannot destroy history records" }
 
@@ -312,19 +307,9 @@ module Historiographer
         return @history_foreign_key if @history_foreign_key
 
         # CAN THIS BE TABLE OR MODEL?
-        @history_foreign_key = sti_base_class.name.singularize.foreign_key
+        @history_foreign_key = original_class.base_class.name.singularize.foreign_key
       end
 
-      def sti_base_class
-        return @sti_base_class if @sti_base_class
-
-        base_name = name.gsub(/History$/, '')
-        base_class = base_name.constantize
-        while base_class.superclass != ActiveRecord::Base
-          base_class = base_class.superclass
-        end
-        @sti_base_class = base_class
-      end
     end
 
     def original_class
@@ -343,10 +328,6 @@ module Historiographer
       attrs = attributes.clone
       # attrs[original_class.primary_key] = attrs[self.class.history_foreign_key]
 
-      if original_class.sti_enabled?
-        # Remove History suffix from type if present
-        attrs[original_class.inheritance_column] = attrs[original_class.inheritance_column]&.gsub(/History$/, '')
-      end
 
       # Manually handle creating instance WITHOUT running find or initialize callbacks
       # We will manually run callbacks below

data/lib/historiographer/version.rb

@@ -1,3 +1,3 @@
 module Historiographer
-  VERSION = "4.1.14"
+  VERSION = "4.1.16"
 end

data/lib/historiographer.rb

@@ -78,6 +78,7 @@ module Historiographer
   extend ActiveSupport::Concern
 
   class HistoryUserIdMissingError < StandardError; end
+  class HistoryInsertionError < StandardError; end
 
   UTC = Time.now.in_time_zone('UTC').time_zone
 
@@ -190,9 +191,6 @@ module Historiographer
       
       history_class_initializer = Class.new(ActiveRecord::Base) do
         self.table_name = "#{base_table}_histories"
-        
-        # Handle STI properly
-        self.inheritance_column = base.inheritance_column if base.sti_enabled?
       end
 
       # Split the class name into module parts and the actual class name
@@ -295,10 +293,11 @@ module Historiographer
         existing_snapshot = history_class.where(foreign_key => attrs[primary_key], snapshot_id: snapshot_id)
         return if existing_snapshot.present?
 
-        null_snapshot = history_class.where(foreign_key => attrs[primary_key], snapshot_id: nil)
+        null_snapshot = history_class.where(foreign_key => attrs[primary_key], snapshot_id: nil).first
         snapshot = nil
         if null_snapshot.present?
-          snapshot = null_snapshot.update(snapshot_id: snapshot_id)
+          null_snapshot.update(snapshot_id: snapshot_id)
+          snapshot = null_snapshot
         else
           snapshot = record_history(snapshot_id: snapshot_id)
         end
@@ -344,12 +343,6 @@ module Historiographer
       attrs.merge!(foreign_key => attrs['id'], history_started_at: now, history_user_id: history_user_id)
       attrs.merge!(snapshot_id: snapshot_id) if snapshot_id.present?
 
-      # For STI, ensure we use the correct history class type
-      if self.class.sti_enabled?
-        type_column = self.class.inheritance_column
-        attrs[type_column] = "#{self.class.name}History"
-      end
-
       attrs = attrs.except('id')
       attrs.stringify_keys!
 
@@ -385,6 +378,29 @@ module Historiographer
 
       if history_class.history_foreign_key.present? && history_class.present?
         result = history_class.insert_all([attrs])
+        
+        # Check if the insertion was successful
+        if result.rows.empty?
+          # insert_all returned empty rows, likely due to a duplicate/conflict
+          # Try to find the existing record that prevented insertion
+          foreign_key = history_class.history_foreign_key
+          existing_history = history_class.where(
+            foreign_key => attrs[foreign_key],
+            history_started_at: attrs['history_started_at']
+          ).first
+          
+          if existing_history
+            # A duplicate history already exists (race condition or retry)
+            # This is acceptable - return the existing history
+            Rails.logger.warn("Duplicate history detected for #{self.class.name} ##{id} at #{attrs['history_started_at']}. Using existing history record ##{existing_history.id}.") if Rails.logger
+            current_history.update_columns(history_ended_at: now) if current_history.present?
+            return existing_history
+          else
+            # No rows inserted and can't find an existing record - this is unexpected
+            raise HistoryInsertionError, "Failed to insert history record for #{self.class.name} ##{id}, and no existing history was found. This may indicate a database constraint preventing insertion."
+          end
+        end
+        
         inserted_id = result.rows.first.first if history_class.primary_key == 'id'
         instance = history_class.find(inserted_id)
         current_history.update_columns(history_ended_at: now) if current_history.present?
@@ -434,9 +450,6 @@ module Historiographer
       @historiographer_mode || Historiographer::Configuration.mode
     end
 
-    def sti_enabled?
-      columns.map(&:name).include?(inheritance_column)
-    end
   end
 
   def is_history_class?