historiographer 4.4.1 → 4.4.3

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: 2024_11_19_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"
 
@@ -42,6 +42,14 @@ ActiveRecord::Schema[7.1].define(version: 2024_11_19_000000) do
     t.index ["deleted_at"], name: "index_authors_on_deleted_at"
   end
 
+  create_table "bylines", force: :cascade do |t|
+    t.string "name", null: false
+    t.integer "author_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["author_id"], name: "index_bylines_on_author_id"
+  end
+
   create_table "comment_histories", force: :cascade do |t|
     t.integer "comment_id", null: false
     t.integer "post_id"
@@ -99,57 +107,26 @@ ActiveRecord::Schema[7.1].define(version: 2024_11_19_000000) do
   end
 
   create_table "easy_ml_column_histories", force: :cascade do |t|
-    t.integer "column_id", null: false
-    t.string "name", null: false
-    t.string "data_type", null: false
-    t.string "column_type"
+    t.integer "easy_ml_column_id", null: false
+    t.string "name"
+    t.string "data_type"
     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 ["column_id"], name: "index_easy_ml_column_histories_on_column_id"
+    t.index ["easy_ml_column_id"], name: "index_easy_ml_column_histories_on_easy_ml_column_id"
     t.index ["history_ended_at"], name: "index_easy_ml_column_histories_on_history_ended_at"
     t.index ["history_started_at"], name: "index_easy_ml_column_histories_on_history_started_at"
-    t.index ["history_user_id"], name: "index_easy_ml_column_histories_on_history_user_id"
     t.index ["snapshot_id"], name: "index_easy_ml_column_histories_on_snapshot_id"
   end
 
   create_table "easy_ml_columns", force: :cascade do |t|
-    t.string "name", null: false
-    t.string "data_type", null: false
-    t.string "column_type"
-    t.datetime "created_at", null: false
-    t.datetime "updated_at", null: false
-  end
-
-  create_table "ml_model_histories", force: :cascade do |t|
-    t.integer "ml_model_id", null: false
-    t.string "name"
-    t.string "model_type"
-    t.jsonb "parameters"
-    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_ml_model_histories_on_history_ended_at"
-    t.index ["history_started_at"], name: "index_ml_model_histories_on_history_started_at"
-    t.index ["history_user_id"], name: "index_ml_model_histories_on_history_user_id"
-    t.index ["ml_model_id"], name: "index_ml_model_histories_on_ml_model_id"
-    t.index ["model_type"], name: "index_ml_model_histories_on_model_type"
-    t.index ["snapshot_id"], name: "index_ml_model_histories_on_snapshot_id"
-  end
-
-  create_table "ml_models", force: :cascade do |t|
     t.string "name"
-    t.string "model_type"
-    t.jsonb "parameters"
+    t.string "data_type"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
-    t.index ["model_type"], name: "index_ml_models_on_model_type"
   end
 
   create_table "post_histories", force: :cascade do |t|
@@ -166,7 +143,6 @@ ActiveRecord::Schema[7.1].define(version: 2024_11_19_000000) do
     t.datetime "history_ended_at", precision: nil
     t.integer "history_user_id"
     t.string "snapshot_id"
-    t.string "type"
     t.index ["author_id"], name: "index_post_histories_on_author_id"
     t.index ["deleted_at"], name: "index_post_histories_on_deleted_at"
     t.index ["enabled"], name: "index_post_histories_on_enabled"
@@ -187,17 +163,17 @@ ActiveRecord::Schema[7.1].define(version: 2024_11_19_000000) do
     t.datetime "deleted_at", precision: nil
     t.datetime "created_at", precision: nil, null: false
     t.datetime "updated_at", precision: nil, null: false
-    t.string "type"
     t.index ["author_id"], name: "index_posts_on_author_id"
     t.index ["deleted_at"], name: "index_posts_on_deleted_at"
     t.index ["enabled"], name: "index_posts_on_enabled"
     t.index ["live_at"], name: "index_posts_on_live_at"
-    t.index ["type"], name: "index_posts_on_type"
   end
 
   create_table "project_file_histories", force: :cascade do |t|
     t.integer "project_file_id", null: false
+    t.integer "project_id"
     t.string "name", null: false
+    t.string "content"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
     t.datetime "history_started_at", null: false
@@ -208,13 +184,17 @@ ActiveRecord::Schema[7.1].define(version: 2024_11_19_000000) do
     t.index ["history_started_at"], name: "index_project_file_histories_on_history_started_at"
     t.index ["history_user_id"], name: "index_project_file_histories_on_history_user_id"
     t.index ["project_file_id"], name: "index_project_file_histories_on_project_file_id"
+    t.index ["project_id"], name: "index_project_file_histories_on_project_id"
     t.index ["snapshot_id"], name: "index_project_file_histories_on_snapshot_id"
   end
 
   create_table "project_files", force: :cascade do |t|
+    t.bigint "project_id"
     t.string "name", null: false
+    t.string "content"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.index ["project_id"], name: "index_project_files_on_project_id"
   end
 
   create_table "project_histories", force: :cascade do |t|
@@ -319,6 +299,96 @@ ActiveRecord::Schema[7.1].define(version: 2024_11_19_000000) do
     t.index ["live_at"], name: "index_silent_posts_on_live_at"
   end
 
+  create_table "test_article_histories", force: :cascade do |t|
+    t.integer "test_article_id", null: false
+    t.string "title"
+    t.integer "test_category_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_article_histories_on_history_ended_at"
+    t.index ["history_started_at"], name: "index_test_article_histories_on_history_started_at"
+    t.index ["snapshot_id"], name: "index_test_article_histories_on_snapshot_id"
+    t.index ["test_article_id"], name: "index_test_article_histories_on_test_article_id"
+  end
+
+  create_table "test_articles", force: :cascade do |t|
+    t.string "title"
+    t.integer "test_category_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "test_categories", force: :cascade do |t|
+    t.string "name"
+    t.integer "test_articles_count", default: 0
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+  end
+
+  create_table "test_category_histories", force: :cascade do |t|
+    t.integer "test_category_id", null: false
+    t.string "name"
+    t.integer "test_articles_count", default: 0
+    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_category_histories_on_history_ended_at"
+    t.index ["history_started_at"], name: "index_test_category_histories_on_history_started_at"
+    t.index ["snapshot_id"], name: "index_test_category_histories_on_snapshot_id"
+    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

@@ -898,7 +898,7 @@ describe Historiographer do
 
     it 'establishes correct foreign key for history association' do
       col_history = column.histories.first
-      expect(col_history.class.history_foreign_key).to eq('column_id')
+      expect(col_history.class.history_foreign_key).to eq('easy_ml_column_id')
       expect(col_history).to be_a(EasyML::ColumnHistory)
     end
 
@@ -917,4 +917,322 @@ describe Historiographer do
       expect(column.histories.last.name).to eq('feature_2')
     end
   end
+
+  describe 'Non-historiographer associations' do
+    it 'preserves associations to models without history tracking' do
+      # Create an author and byline (byline has no history tracking)
+      author = Author.create!(full_name: 'Test Author', history_user_id: 1)
+      byline = Byline.create!(name: 'Test Byline', author: author)
+      
+      # The author should have the byline association
+      expect(author.bylines).to include(byline)
+      
+      # Get the author's history record
+      author_history = AuthorHistory.last
+      expect(author_history).not_to be_nil
+      
+      # The history model should still be able to access the byline (non-history model)
+      # This should work because Byline doesn't have history tracking
+      expect(author_history.bylines).to include(byline)
+      
+      # The association should point to the regular Byline model, not a history model
+      byline_association = AuthorHistory.reflect_on_association(:bylines)
+      expect(byline_association).not_to be_nil
+      expect(byline_association.klass).to eq(Byline)
+    end
+    
+    it 'handles mixed associations correctly' do
+      # Create an author with both history-tracked and non-history-tracked associations
+      author = Author.create!(full_name: 'Test Author', history_user_id: 1)
+      post = Post.create!(title: 'Test Post', body: 'Test body', author_id: author.id, history_user_id: 1)
+      comment = Comment.create!(body: 'Test comment', author_id: author.id, post_id: post.id, history_user_id: 1)
+      byline = Byline.create!(name: 'Test Byline', author: author)
+      
+      author_history = AuthorHistory.last
+      
+      # History-tracked associations should work correctly
+      # Note: For history associations, we create custom methods rather than Rails associations
+      # so they won't show up in reflect_on_all_associations
+      expect(author_history).to respond_to(:posts)
+      expect(author_history).to respond_to(:comments)
+      
+      # The methods should return history records filtered by snapshot_id
+      post_histories = PostHistory.where(author_id: author.id)
+      expect(post_histories).not_to be_empty
+      
+      # When accessing through the history model, it should filter by snapshot_id
+      author_history_posts = author_history.posts
+      expect(author_history_posts).to be_a(ActiveRecord::Relation)
+      
+      # Non-history-tracked associations should show up as regular Rails associations
+      bylines_association = AuthorHistory.reflect_on_association(:bylines)
+      expect(bylines_association).not_to be_nil
+      expect(bylines_association.klass).to eq(Byline)
+      
+      # And they should work correctly
+      expect(author_history.bylines).to include(byline)
+    end
+  end
+
+  describe 'Association options preservation' do
+    # Test with inline class definitions to ensure associations are defined properly
+    
+    before(:all) do
+      # Create test classes inline for this test
+      class TestAssocArticle < ActiveRecord::Base
+        self.table_name = 'test_articles'
+        include Historiographer
+        belongs_to :test_assoc_category, 
+                   class_name: 'TestAssocCategory',
+                   foreign_key: 'test_category_id',
+                   optional: true, 
+                   touch: true, 
+                   counter_cache: 'test_articles_count'
+      end
+      
+      class TestAssocCategory < ActiveRecord::Base
+        self.table_name = 'test_categories'
+        include Historiographer
+        has_many :test_assoc_articles, 
+                 class_name: 'TestAssocArticle',
+                 foreign_key: 'test_category_id',
+                 dependent: :restrict_with_error, 
+                 inverse_of: :test_assoc_category
+      end
+      
+      class TestAssocArticleHistory < ActiveRecord::Base
+        self.table_name = 'test_article_histories'
+        include Historiographer::History
+      end
+      
+      class TestAssocCategoryHistory < ActiveRecord::Base
+        self.table_name = 'test_category_histories'
+        include Historiographer::History
+      end
+      
+      # Manually trigger association setup since we're in a test environment
+      # Force = true because associations may have been partially set up before all models were loaded
+      TestAssocArticleHistory.setup_history_associations(true) if TestAssocArticleHistory.respond_to?(:setup_history_associations)
+      TestAssocCategoryHistory.setup_history_associations(true) if TestAssocCategoryHistory.respond_to?(:setup_history_associations)
+    end
+    
+    after(:all) do
+      Object.send(:remove_const, :TestAssocArticle) if Object.const_defined?(:TestAssocArticle)
+      Object.send(:remove_const, :TestAssocArticleHistory) if Object.const_defined?(:TestAssocArticleHistory)
+      Object.send(:remove_const, :TestAssocCategory) if Object.const_defined?(:TestAssocCategory)
+      Object.send(:remove_const, :TestAssocCategoryHistory) if Object.const_defined?(:TestAssocCategoryHistory)
+    end
+    
+    it 'preserves optional setting for belongs_to associations' do
+      # Check the original TestAssocArticle belongs_to association
+      article_association = TestAssocArticle.reflect_on_association(:test_assoc_category)
+      expect(article_association).not_to be_nil
+      expect(article_association.options[:optional]).to eq(true)
+      
+      # The TestAssocArticleHistory should have the same options
+      article_history_association = TestAssocArticleHistory.reflect_on_association(:test_assoc_category)
+      expect(article_history_association).not_to be_nil
+      expect(article_history_association.options[:optional]).to eq(true)
+    end
+    
+    it 'preserves touch and counter_cache options for belongs_to associations' do
+      article_association = TestAssocArticle.reflect_on_association(:test_assoc_category)
+      expect(article_association.options[:touch]).to eq(true)
+      expect(article_association.options[:counter_cache]).to eq('test_articles_count')
+      
+      article_history_association = TestAssocArticleHistory.reflect_on_association(:test_assoc_category)
+      expect(article_history_association).not_to be_nil
+      expect(article_history_association.options[:touch]).to eq(true)
+      expect(article_history_association.options[:counter_cache]).to eq('test_articles_count')
+    end
+    
+    it 'preserves dependent and inverse_of options for has_many associations' do
+      category_articles_association = TestAssocCategory.reflect_on_association(:test_assoc_articles)
+      expect(category_articles_association.options[:dependent]).to eq(:restrict_with_error)
+      expect(category_articles_association.options[:inverse_of]).to eq(:test_assoc_category)
+      
+      # Note: has_many associations might not be copied to history models in the same way
+      # This is expected behavior since history models typically don't need the same associations
+    end
+    
+    it 'allows creating history records with nil optional associations' do
+      # Create an article without a category (should be valid since category is optional)
+      article = TestAssocArticle.create!(title: 'Test Article without category', history_user_id: 1)
+      expect(article.test_category_id).to be_nil
+      
+      # The history record should also be created successfully
+      history = TestAssocArticleHistory.last
+      expect(history).not_to be_nil
+      expect(history.test_category_id).to be_nil
+      expect(history.test_article_id).to eq(article.id)
+
+      # Creating snapshots should work even with nil associations
+      article.snapshot
+      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