historiographer 4.4.2 → 4.4.3

data/spec/db/migrate/20250826000003_create_test_website_histories.rb

@@ -0,0 +1,19 @@
+class CreateTestWebsiteHistories < ActiveRecord::Migration[7.0]
+  def change
+    create_table :test_website_histories do |t|
+      t.integer :test_website_id, null: false
+      t.string :name
+      t.integer :user_id
+      t.timestamps
+      t.datetime :history_started_at, null: false
+      t.datetime :history_ended_at
+      t.integer :history_user_id
+      t.string :snapshot_id
+      
+      t.index :test_website_id
+      t.index :history_started_at
+      t.index :history_ended_at
+      t.index :snapshot_id
+    end
+  end
+end

data/spec/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.1].define(version: 2025_08_25_000000) do
+ActiveRecord::Schema[7.1].define(version: 2025_08_26_000003) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
 
@@ -345,6 +345,50 @@ ActiveRecord::Schema[7.1].define(version: 2025_08_25_000000) do
     t.index ["test_category_id"], name: "index_test_category_histories_on_test_category_id"
   end
 
+  create_table "test_user_histories", force: :cascade do |t|
+    t.integer "test_user_id", null: false
+    t.string "name"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.datetime "history_started_at", null: false
+    t.datetime "history_ended_at"
+    t.integer "history_user_id"
+    t.string "snapshot_id"
+    t.index ["history_ended_at"], name: "index_test_user_histories_on_history_ended_at"
+    t.index ["history_started_at"], name: "index_test_user_histories_on_history_started_at"
+    t.index ["snapshot_id"], name: "index_test_user_histories_on_snapshot_id"
+    t.index ["test_user_id"], name: "index_test_user_histories_on_test_user_id"
+  end
+
+  create_table "test_users", force: :cascade do |t|
+    t.string "name"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "test_website_histories", force: :cascade do |t|
+    t.integer "test_website_id", null: false
+    t.string "name"
+    t.integer "user_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.datetime "history_started_at", null: false
+    t.datetime "history_ended_at"
+    t.integer "history_user_id"
+    t.string "snapshot_id"
+    t.index ["history_ended_at"], name: "index_test_website_histories_on_history_ended_at"
+    t.index ["history_started_at"], name: "index_test_website_histories_on_history_started_at"
+    t.index ["snapshot_id"], name: "index_test_website_histories_on_snapshot_id"
+    t.index ["test_website_id"], name: "index_test_website_histories_on_test_website_id"
+  end
+
+  create_table "test_websites", force: :cascade do |t|
+    t.string "name"
+    t.integer "user_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
   create_table "thing_with_compound_index_histories", force: :cascade do |t|
     t.integer "thing_with_compound_index_id", null: false
     t.string "key"

data/spec/historiographer_spec.rb

@@ -1071,4 +1071,168 @@ describe Historiographer do
       expect { article.snapshot }.to_not raise_error
     end
   end
+
+  describe 'Foreign key handling' do
+    before(:all) do
+      # Ensure test tables exist
+      unless ActiveRecord::Base.connection.table_exists?(:test_users)
+        ActiveRecord::Base.connection.create_table :test_users do |t|
+          t.string :name
+          t.timestamps
+        end
+      end
+      
+      unless ActiveRecord::Base.connection.table_exists?(:test_user_histories)
+        ActiveRecord::Base.connection.create_table :test_user_histories do |t|
+          t.integer :test_user_id, null: false
+          t.string :name
+          t.timestamps
+          t.datetime :history_started_at, null: false
+          t.datetime :history_ended_at
+          t.integer :history_user_id
+          t.string :snapshot_id
+          
+          t.index :test_user_id
+          t.index :history_started_at
+          t.index :history_ended_at
+          t.index :snapshot_id
+        end
+      end
+      
+      unless ActiveRecord::Base.connection.table_exists?(:test_websites)
+        ActiveRecord::Base.connection.create_table :test_websites do |t|
+          t.string :name
+          t.integer :user_id
+          t.timestamps
+        end
+      end
+      
+      unless ActiveRecord::Base.connection.table_exists?(:test_website_histories)
+        ActiveRecord::Base.connection.create_table :test_website_histories do |t|
+          t.integer :test_website_id, null: false
+          t.string :name
+          t.integer :user_id
+          t.timestamps
+          t.datetime :history_started_at, null: false
+          t.datetime :history_ended_at
+          t.integer :history_user_id
+          t.string :snapshot_id
+          
+          t.index :test_website_id
+          t.index :history_started_at
+          t.index :history_ended_at
+          t.index :snapshot_id
+        end
+      end
+    end
+    
+    describe 'belongs_to associations on history models' do
+      it 'does not raise error about wrong column when accessing belongs_to associations' do
+        # This is the core issue: when a history model has a belongs_to association,
+        # it should not use the foreign key as the primary key for lookups
+        
+        # Create a user
+        user = TestUser.create!(name: 'Test User', history_user_id: 1)
+        
+        # Create a website belonging to the user
+        website = TestWebsite.create!(
+          name: 'Test Website',
+          user_id: user.id,
+          history_user_id: 1
+        )
+        
+        # Get the website history
+        website_history = TestWebsiteHistory.last
+        
+        # The history should have the correct user_id
+        expect(website_history.user_id).to eq(user.id)
+        
+        # The belongs_to association should work without errors
+        # Previously this would fail with "column users.user_id does not exist"
+        # because it was using primary_key: :user_id instead of the default :id
+        expect { website_history.user }.not_to raise_error
+      end
+      
+      it 'allows direct creation of history records with foreign keys' do
+        user = TestUser.create!(name: 'Another User', history_user_id: 1)
+        
+        # Create history attributes like in the original error case
+        attrs = {
+          "name" => "test.example",
+          "user_id" => user.id,
+          "created_at" => Time.now,
+          "updated_at" => Time.now,
+          "test_website_id" => 100,
+          "history_started_at" => Time.now,
+          "history_user_id" => 1,
+          "snapshot_id" => SecureRandom.uuid
+        }
+        
+        # This should not raise an error about test_users.user_id not existing
+        # The original bug was that it would look for test_users.user_id instead of test_users.id
+        expect { TestWebsiteHistory.create!(attrs) }.not_to raise_error
+        
+        history = TestWebsiteHistory.last
+        expect(history.user_id).to eq(user.id)
+      end
+    end
+    
+    describe 'snapshot associations with history models' do
+      it 'correctly filters associations by snapshot_id when using custom association methods' do
+        # First create regular history records
+        user = TestUser.create!(name: 'User One', history_user_id: 1)
+        website = TestWebsite.create!(
+          name: 'Website One',
+          user_id: user.id,
+          history_user_id: 1
+        )
+        
+        # Check that regular histories were created
+        expect(TestUserHistory.count).to eq(1)
+        expect(TestWebsiteHistory.count).to eq(1)
+        
+        # Now create snapshot histories directly (simulating what snapshot would do)
+        snapshot_id = SecureRandom.uuid
+        
+        # Create user history with snapshot
+        user_snapshot = TestUserHistory.create!(
+          test_user_id: user.id,
+          name: user.name,
+          created_at: user.created_at,
+          updated_at: user.updated_at,
+          history_started_at: Time.now,
+          history_user_id: 1,
+          snapshot_id: snapshot_id
+        )
+        
+        # Create website history with snapshot
+        website_snapshot = TestWebsiteHistory.create!(
+          test_website_id: website.id,
+          name: website.name,
+          user_id: user.id,
+          created_at: website.created_at,
+          updated_at: website.updated_at,
+          history_started_at: Time.now,
+          history_user_id: 1,
+          snapshot_id: snapshot_id
+        )
+        
+        # Now test that the association filtering works
+        # The website history's user association should find the user history with the same snapshot_id
+        user_from_association = website_snapshot.user
+        
+        # Since user association points to history when snapshots are involved,
+        # it should return the TestUserHistory with matching snapshot_id
+        if user_from_association.is_a?(TestUserHistory)
+          expect(user_from_association.snapshot_id).to eq(snapshot_id)
+          expect(user_from_association.name).to eq('User One')
+        else
+          # If it returns the regular TestUser (non-history), that's also acceptable
+          # as long as it doesn't error
+          expect(user_from_association).to be_a(TestUser)
+          expect(user_from_association.name).to eq('User One')
+        end
+      end
+    end
+  end
 end

data/spec/integration/historiographer_safe_integration_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+
+RSpec.describe 'Historiographer::Safe Integration' do
+  # This test reproduces the exact error from a real Rails app where:
+  # 1. WebsiteHistory is defined first and includes Historiographer::History
+  # 2. Website is defined later and includes Historiographer::Safe
+  # 3. The error occurs because foreign_class.constantize fails when Website isn't loaded yet
+  
+  context 'when history class is loaded before the main model' do
+    before(:each) do
+      # Ensure clean state
+      Object.send(:remove_const, :RealAppWebsite) if defined?(RealAppWebsite)
+      Object.send(:remove_const, :RealAppWebsiteHistory) if defined?(RealAppWebsiteHistory)
+      
+      # Create the tables
+      ActiveRecord::Base.connection.create_table :real_app_websites, force: true do |t|
+        t.string :name
+        t.integer :project_id
+        t.integer :user_id
+        t.integer :template_id
+        t.timestamps
+      end
+      
+      ActiveRecord::Base.connection.create_table :real_app_website_histories, force: true do |t|
+        t.integer :real_app_website_id, null: false
+        t.string :name
+        t.integer :project_id
+        t.integer :user_id
+        t.integer :template_id
+        t.datetime :created_at, null: false
+        t.datetime :updated_at, null: false
+        t.datetime :history_started_at, null: false
+        t.datetime :history_ended_at
+        t.integer :history_user_id
+        t.string :snapshot_id
+        t.string :thread_id
+      end
+      
+      ActiveRecord::Base.connection.add_index :real_app_website_histories, :real_app_website_id
+      ActiveRecord::Base.connection.add_index :real_app_website_histories, :history_started_at
+      ActiveRecord::Base.connection.add_index :real_app_website_histories, :history_ended_at
+    end
+    
+    after(:each) do
+      # Clean up tables
+      ActiveRecord::Base.connection.drop_table :real_app_website_histories if ActiveRecord::Base.connection.table_exists?(:real_app_website_histories)
+      ActiveRecord::Base.connection.drop_table :real_app_websites if ActiveRecord::Base.connection.table_exists?(:real_app_websites)
+      
+      # Clean up constants
+      Object.send(:remove_const, :RealAppWebsiteHistory) if defined?(RealAppWebsiteHistory)
+      Object.send(:remove_const, :RealAppWebsite) if defined?(RealAppWebsite)
+    end
+    
+    it 'handles history class being defined before the main model exists' do
+      # This is the exact scenario from the error report:
+      # WebsiteHistory is loaded/required first (common in Rails autoloading)
+      
+      expect {
+        class RealAppWebsiteHistory < ApplicationRecord
+          self.table_name = 'real_app_website_histories'
+          include Historiographer::History
+        end
+      }.not_to raise_error
+      
+      # At this point, RealAppWebsite doesn't exist yet
+      # The history class should handle this gracefully
+      expect(RealAppWebsiteHistory.foreign_class).to be_nil
+      
+      # Now define the main model (simulating Rails autoloading it later)
+      class RealAppWebsite < ApplicationRecord
+        self.table_name = 'real_app_websites'
+        include Historiographer::Safe
+      end
+      
+      # After the main model is defined, foreign_class should resolve
+      expect(RealAppWebsiteHistory.foreign_class).to eq(RealAppWebsite)
+      
+      # And all functionality should work
+      website = RealAppWebsite.create!(name: 'Test Site', history_user_id: 1)
+      expect(website.histories.count).to eq(1)
+      
+      history = website.histories.first
+      expect(history).to be_a(RealAppWebsiteHistory)
+      expect(history.real_app_website_id).to eq(website.id)
+      expect(history.name).to eq('Test Site')
+    end
+    
+    it 'allows history class to define associations even when parent model is not loaded' do
+      # Define a Deploy model for association testing
+      ActiveRecord::Base.connection.create_table :deploys, force: true do |t|
+        t.integer :real_app_website_history_id
+        t.string :status
+        t.timestamps
+      end
+      
+      class Deploy < ApplicationRecord
+        self.table_name = 'deploys'
+      end
+      
+      # Define history class with associations before main model exists
+      expect {
+        class RealAppWebsiteHistory < ApplicationRecord
+          self.table_name = 'real_app_website_histories'
+          include Historiographer::History
+          
+          # This should work even though RealAppWebsite doesn't exist yet
+          has_many :deploys, foreign_key: :real_app_website_history_id, dependent: :destroy
+        end
+      }.not_to raise_error
+      
+      # Now define the main model
+      class RealAppWebsite < ApplicationRecord
+        self.table_name = 'real_app_websites'
+        include Historiographer::Safe
+      end
+      
+      # Test that associations work
+      website = RealAppWebsite.create!(name: 'Test Site', history_user_id: 1)
+      history = website.histories.first
+      
+      deploy = Deploy.create!(real_app_website_history_id: history.id, status: 'pending')
+      expect(history.deploys).to include(deploy)
+      
+      # Clean up
+      ActiveRecord::Base.connection.drop_table :deploys
+      Object.send(:remove_const, :Deploy)
+    end
+    
+    it 'supports after_initialize Rails hook when available' do
+      # Simulate Rails being available with after_initialize
+      rails_app = double('Rails App')
+      config = double('Rails Config')
+      allow(config).to receive(:after_initialize).and_yield
+      allow(rails_app).to receive(:config).and_return(config)
+      allow(Rails).to receive(:application).and_return(rails_app)
+      
+      # Define history class
+      class RealAppWebsiteHistory < ApplicationRecord
+        self.table_name = 'real_app_website_histories'
+        include Historiographer::History
+      end
+      
+      # Define main model
+      class RealAppWebsite < ApplicationRecord
+        self.table_name = 'real_app_websites'
+        include Historiographer::Safe
+      end
+      
+      # The after_initialize should have set up associations
+      expect(RealAppWebsiteHistory).to respond_to(:setup_history_associations)
+      expect { RealAppWebsiteHistory.setup_history_associations }.not_to raise_error
+    end
+  end
+end

data/spec/internal/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/spec/internal/app/models/deploy.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Deploy < ApplicationRecord
+  belongs_to :website_history
+end

data/spec/internal/app/models/user.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class User < ApplicationRecord
+end

data/spec/internal/app/models/website.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Website < ApplicationRecord
+  include Historiographer::Safe
+end

data/spec/internal/app/models/website_history.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class WebsiteHistory < ApplicationRecord
+  include Historiographer::History
+  
+  has_many :deploys
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,9 @@
+test:
+  adapter: postgresql
+  database: historiographer_combustion_test
+  username: <%= ENV['DB_USERNAME'] || 'postgres' %>
+  password: <%= ENV['DB_PASSWORD'] || '' %>
+  host: <%= ENV['DB_HOST'] || 'localhost' %>
+  port: <%= ENV['DB_PORT'] || 5432 %>
+  pool: 5
+  timeout: 5000

data/spec/internal/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 1) do
+  # Website table - the main model
+  create_table :websites, force: true do |t|
+    t.string :name
+    t.integer :project_id
+    t.integer :user_id
+    t.integer :template_id
+    t.timestamps
+  end
+
+  # Website history table
+  create_table :website_histories, force: true do |t|
+    t.integer :website_id, null: false
+    t.string :name
+    t.integer :project_id  
+    t.integer :user_id
+    t.integer :template_id
+    t.datetime :created_at, null: false
+    t.datetime :updated_at, null: false
+    t.datetime :history_started_at, null: false
+    t.datetime :history_ended_at
+    t.integer :history_user_id
+    t.string :snapshot_id
+    t.string :thread_id
+  end
+
+  add_index :website_histories, :website_id
+  add_index :website_histories, :history_started_at
+  add_index :website_histories, :history_ended_at
+  add_index :website_histories, :history_user_id
+  add_index :website_histories, :snapshot_id
+  add_index :website_histories, [:thread_id], unique: true, name: 'index_website_histories_on_thread_id'
+
+  # Deploy table - to test associations on history models
+  create_table :deploys, force: true do |t|
+    t.integer :website_history_id
+    t.string :status
+    t.timestamps
+  end
+
+  # User table
+  create_table :users, force: true do |t|
+    t.string :name
+    t.timestamps
+  end
+end

data/spec/models/test_user.rb

@@ -0,0 +1,4 @@
+class TestUser < ApplicationRecord
+  include Historiographer
+  has_many :test_websites, foreign_key: 'user_id'
+end

data/spec/models/test_user_history.rb

@@ -0,0 +1,3 @@
+class TestUserHistory < ApplicationRecord
+  include Historiographer::History
+end

data/spec/models/test_website.rb

@@ -0,0 +1,4 @@
+class TestWebsite < ApplicationRecord
+  include Historiographer
+  belongs_to :user, class_name: 'TestUser', foreign_key: 'user_id', optional: true
+end

data/spec/models/test_website_history.rb

@@ -0,0 +1,3 @@
+class TestWebsiteHistory < ApplicationRecord
+  include Historiographer::History
+end

data/spec/rails_integration/historiographer_rails_integration_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'combustion_helper'
+
+RSpec.describe 'Historiographer Rails Integration', type: :model do
+  describe 'when WebsiteHistory is loaded before Website (Rails autoloading scenario)' do
+    it 'handles the load order gracefully' do
+      expect(defined?(WebsiteHistory)).to be_truthy
+      expect(WebsiteHistory.ancestors).to include(Historiographer::History)
+      
+      expect(defined?(Website)).to be_truthy
+      expect(Website.ancestors).to include(Historiographer::Safe)
+      
+      expect(WebsiteHistory.foreign_class).to eq(Website)
+      
+      expect(WebsiteHistory).to respond_to(:setup_history_associations)
+      expect(WebsiteHistory).to respond_to(:original_class)
+      
+      expect { WebsiteHistory.setup_history_associations }.not_to raise_error
+    end
+    
+    it 'allows creating and querying history records' do
+      user = User.create!(name: 'Test User')
+      
+      website = Website.create!(
+        name: 'Production Site',
+        project_id: 1,
+        user_id: user.id,
+        history_user_id: user.id
+      )
+      
+      expect(website.histories.count).to eq(1)
+      
+      history = website.histories.first
+      expect(history).to be_a(WebsiteHistory)
+      expect(history.website_id).to eq(website.id)
+      expect(history.name).to eq('Production Site')
+      expect(history.history_user_id).to eq(user.id)
+      expect(history.history_started_at).to be_present
+      expect(history.history_ended_at).to be_nil
+      
+      website.update!(name: 'Updated Site', history_user_id: user.id)
+      
+      expect(website.histories.count).to eq(2)
+      
+      old_history = website.histories.where.not(history_ended_at: nil).first
+      expect(old_history.name).to eq('Production Site')
+      expect(old_history.history_ended_at).to be_present
+      
+      current_history = website.histories.current.first
+      expect(current_history.name).to eq('Updated Site')
+      expect(current_history.history_ended_at).to be_nil
+    end
+    
+    it 'supports associations on history models' do
+      website = Website.create!(name: 'Deploy Test Site', history_user_id: 1)
+      history = website.histories.first
+      
+      deploy = Deploy.create!(
+        website_history_id: history.id,
+        status: 'pending'
+      )
+      
+      expect(history.deploys).to include(deploy)
+      expect(deploy.website_history).to eq(history)
+      
+      expect(history.deploys.where(status: 'pending').count).to eq(1)
+    end
+    
+    it 'handles Safe mode without requiring history_user_id after initial creation' do
+      website = Website.create!(name: 'Safe Mode Test', history_user_id: 1)
+      
+      expect { website.update!(name: 'Updated Safe Mode Test') }.not_to raise_error
+      
+      expect(website.histories.count).to eq(2)
+      
+      current_history = website.histories.current.first
+      expect(current_history.name).to eq('Updated Safe Mode Test')
+      expect(current_history.history_user_id).to eq(1)
+      
+      website.update!(name: 'Another Update', history_user_id: nil)
+      expect(website.histories.count).to eq(3)
+      newest_history = website.histories.current.first
+      expect(newest_history.history_user_id).to be_nil
+    end
+    
+    it 'properly sets up delegated methods on history instances' do
+      website = Website.create!(name: 'Method Delegation Test', history_user_id: 1)
+      history = website.histories.first
+      
+      expect(history).to respond_to(:name)
+      
+      expect(history.name).to eq('Method Delegation Test')
+    end
+  end
+  
+  describe 'Rails after_initialize hook' do
+    it 'sets up associations after Rails initialization' do
+      expect(WebsiteHistory.reflect_on_association(:website)).to be_present
+      expect(WebsiteHistory.reflect_on_association(:deploys)).to be_present
+      
+      website_association = WebsiteHistory.reflect_on_association(:website)
+      expect(website_association.class_name).to eq('Website')
+    end
+  end
+end