separate_history 0.1.0

data/lib/generators/separate_history/model/model_generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module SeparateHistory
+  module Generators
+    class ModelGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      argument :name, type: :string
+
+      def create_migration_file
+        # if exists history class, skip migration and tell run seperate_histaor:migration name
+        if Object.const_defined?(history_class_name)
+          say_status :skipped, "History class #{history_class_name} already exists. "\
+            "Run `rails g separate_history:migration #{name}` to create a migration for it.", :yellow
+          nil
+        else
+          migration_template "migration.rb.erb", "db/migrate/create_#{file_name}_history.rb"
+          say_status :created, "Migration for #{history_class_name} created successfully.", :green
+        end
+      end
+
+      def create_model_file
+        @original_class = name.classify.constantize
+        template "model.rb.erb", "app/models/#{file_name}_history.rb"
+      end
+
+      private
+
+      def file_name
+        name.underscore
+      end
+
+      def history_class_name
+        "#{name}History"
+      end
+    end
+  end
+end

data/lib/generators/separate_history/model/templates/migration.rb.erb

@@ -0,0 +1,13 @@
+class Create<%= class_name %>History < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :<%= table_name.pluralize %>_histories do |t|
+      t.bigint :original_id
+      # Add columns from the original table here
+      t.string :event
+      t.datetime :history_created_at
+      t.datetime :history_updated_at
+    end
+
+    add_index :<%= table_name.pluralize %>_histories, :original_id
+  end
+end

data/lib/generators/separate_history/model/templates/model.rb.erb

@@ -0,0 +1,13 @@
+class <%= class_name%>History < ApplicationRecord
+  include SeparateHistory::History
+  belongs_to :original, class_name: '<%= @original_class.name %>', foreign_key: 'original_id'
+
+  # Add any additional associations or validations here
+
+  # Example validation
+  validates :event, presence: true
+  validates :history_created_at, presence: true
+  validates :history_updated_at, presence: true
+
+  # Add any custom methods or scopes here
+end

data/lib/generators/separate_history/scan/scan_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module SeparateHistory
+  module Generators
+    class ScanGenerator < Rails::Generators::Base
+      def scan_models
+        Rails.application.eager_load!
+        models = ActiveRecord::Base.descendants.select do |model|
+          model.respond_to?(:separate_history_options)
+        end
+
+        if models.any?
+          say "Models with has_separate_history:", :green
+          models.each do |m|
+            say "- #{m.name}", :cyan
+            options = m.separate_history_options
+            events = options[:events] || []
+            if events.any?
+              say "  Supported events: #{events.join(", ")}", :magenta
+            else
+              say "  Supported events: (none specified) [default is all]", :yellow
+            end
+          end
+        else
+          say "No models found with has_separate_history.", :yellow
+        end
+      end
+    end
+  end
+end

data/lib/generators/separate_history/sync/sync_generator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module SeparateHistory
+  module Generators
+    class SyncGenerator < ActiveRecord::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+      argument :name, type: :string
+
+      def create_migration_file
+        @model_class = name.classify.constantize
+        @history_table_name = "#{name.underscore}_histories"
+
+        check_for_mismatched_columns
+
+        @missing_columns = find_missing_columns
+
+        if @missing_columns.any?
+          migration_template "migration.rb.erb", "db/migrate/sync_#{file_name}_history.rb"
+        else
+          say_status :skipped, "No new columns to add for #{name}", :green
+        end
+      end
+
+      private
+
+      def check_for_mismatched_columns
+        original_cols = @model_class.columns.index_by(&:name)
+        history_cols = ActiveRecord::Base.connection.columns(@history_table_name).index_by(&:name)
+
+        mismatched = []
+        (original_cols.keys & history_cols.keys).each do |col|
+          if original_cols[col].type != history_cols[col].type
+            mismatched << "- '#{col}' is '#{original_cols[col].type}' in original table but '#{history_cols[col].type}' in history table."
+          end
+        end
+
+        return unless mismatched.any?
+
+        say_status :warning, "Mismatched column types detected for #{name}:", :yellow
+        mismatched.each { |m| say m, :yellow }
+      end
+
+      def find_missing_columns
+        original_columns = @model_class.column_names
+        history_columns = ActiveRecord::Base.connection.columns(@history_table_name).map(&:name)
+
+        (original_columns - history_columns) - ["id"]
+      end
+
+      def file_name
+        name.underscore
+      end
+    end
+  end
+end

data/lib/generators/separate_history/sync/templates/migration.rb.erb

@@ -0,0 +1,18 @@
+class Sync<%= class_name %>History < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+<% @missing_columns.each do |column_name| %>
+    <% column = @model_class.columns.find { |c| c.name == column_name } %>
+    <% 
+      # Build column options hash manually for Rails 6+ compatibility
+      options = {}
+      options[:limit] = column.limit if column.limit
+      options[:precision] = column.precision if column.precision
+      options[:scale] = column.scale if column.scale
+      options[:null] = column.null unless column.null
+      options[:default] = column.default if column.default
+      options_str = options.any? ? ", #{options.map{|k,v| "#{k}: #{v.inspect}"}.join(', ')}" : ""
+    %>
+    add_column :<%= @history_table_name %>, :<%= column.name %>, :<%= column.type %><%= options_str %>
+<% end %>
+  end
+end

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

@@ -0,0 +1,37 @@
+class Create<%= history_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :<%= history_table_name %> do |t|
+<% original_columns.each do |column| -%>
+      <%- 
+  # Handle both ActiveRecord column objects and hash format
+  if column.respond_to?(:type)
+    # ActiveRecord column object
+    column_type = column.type
+    column_name = column.name
+    options = {
+      limit: column.limit,
+      precision: column.precision,
+      scale: column.scale,
+      null: true, # Force null to be true for all columns
+      default: column.default
+    }.compact
+    options[:null] = true
+    options_string = options.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+  else
+    # Hash format
+    column_type = column[:type]
+    column_name = column[:name]
+    options_string = "null: true"
+  end
+-%>
+      t.<%= column_type %> :<%= column_name %><%= ", #{options_string}" if options_string.present? %>
+<% end -%>
+      t.integer :original_id, null: false
+      t.string :event, null: false
+      t.datetime :history_created_at, null: false
+      t.datetime :history_updated_at, null: false
+
+      t.index :original_id
+    end
+  end
+end

data/lib/separate_history/core.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "separate_history/model"
+require "separate_history/history"
+module SeparateHistory
+  module Core
+    extend ActiveSupport::Concern
+
+    def has_separate_history(options = {})
+      raise ArgumentError, "has_separate_history can not be called on an abstract class" if abstract_class?
+      raise ArgumentError, "Options :only and :except can not be used together" if options[:only] && options[:except]
+
+      valid_options = %i[only except history_class_name events track_changes]
+      invalid_options = options.keys - valid_options
+      raise ArgumentError, "Invalid options: #{invalid_options.join(", ")}" if invalid_options.any?
+
+      options[:track_changes] = false if options[:track_changes].nil?
+      unless options[:track_changes].is_a?(TrueClass) || options[:track_changes].is_a?(FalseClass)
+        raise ArgumentError, "track_changes must be true or false"
+      end
+
+      supported_events = %i[create update destroy]
+      if options[:events]
+        events = Array(options[:events])
+        invalid_events = events - supported_events
+        raise ArgumentError, "Invalid events: #{invalid_events.join(", ")}" if invalid_events.any?
+      end
+
+      cattr_accessor :separate_history_options
+      self.separate_history_options = options
+
+      class << self
+        # Returns the history class (e.g., UserHistory for User)
+        def history_class
+          history_class_name = separate_history_options.fetch(:history_class_name, "#{name}History")
+          history_class_name.safe_constantize
+        end
+
+        # Returns the snapshot of the record as it was at or before the given timestamp
+        def history_for(id, timestamp = Time.current)
+          history_class.where(original_id: id)
+                       .where(history_updated_at: ..timestamp)
+                       .order(history_updated_at: :desc, id: :desc)
+                       .first
+        end
+
+        # Alias for readability: get the state of a record as of a point in time
+        def history_as_of(id, timestamp)
+          history_for(id, timestamp)
+        end
+
+        # Returns true if any history exists for the given record ID
+        def history_exists_for?(id)
+          history_class.where(original_id: id).exists?
+        end
+
+        # Returns all history records for the given record ID, ordered by update time
+        def all_history_for(id)
+          history_class.where(original_id: id)
+                       .order(history_updated_at: :asc, id: :asc)
+        end
+
+        # Returns the most recent history record for the given record ID
+        def latest_history_for(id)
+          history_class.where(original_id: id)
+                       .order(history_updated_at: :desc, id: :desc)
+                       .first
+        end
+
+        # Deletes all history for the given record ID.
+        # Requires force: true to prevent accidental destruction.
+        def clear_history_for(id, force:)
+          raise ArgumentError, "Force must be true to clear history." unless force
+
+          history_class.where(original_id: id).delete_all
+        end
+
+        # clear all history for all records of this model
+        def clear_all_history(force:)
+          raise ArgumentError, "Force must be true to clear all history." unless force
+
+          history_class.delete_all
+        end
+      end
+
+      history_class_name = options.fetch(:history_class_name, "#{name}History")
+      history_table_name = history_class_name.tableize
+      association_name   = name.demodulize.underscore.to_sym
+
+      # Main association
+      # Main association for accessing all history records
+      has_many history_table_name.to_sym,
+               class_name: history_class_name,
+               foreign_key: :original_id,
+               inverse_of: association_name
+
+      # Alias association for convenience (points to the same records)
+      alias_method :separate_histories, history_table_name.to_sym
+
+      history_class = history_class_name.safe_constantize
+      if history_class
+        # Set up the belongs_to association on the history class
+        unless history_class.reflect_on_association(association_name)
+          history_class.belongs_to association_name,
+                                   class_name: name,
+                                   foreign_key: :original_id,
+                                   inverse_of: history_table_name.to_sym,
+                                   optional: true
+        end
+
+        history_class.include SeparateHistory::History
+      end
+
+      # Model-level events support
+      events = Array(options[:events] || supported_events)
+      events.each do |event|
+        next unless supported_events.include?(event)
+
+        after_commit :"record_history_#{event}", on: event
+      end
+
+      include SeparateHistory::Model
+      SeparateHistory.track_model(self)
+    end
+  end
+end

data/lib/separate_history/history.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module SeparateHistory
+  module History
+    extend ActiveSupport::Concern
+
+    def manipulated?
+      return false unless respond_to?(:history_created_at) && respond_to?(:history_updated_at)
+
+      history_updated_at.to_i != history_created_at.to_i
+    end
+  end
+end

data/lib/separate_history/model.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module SeparateHistory
+  module Model
+    extend ActiveSupport::Concern
+
+    # Manually create a history snapshot for this record
+    def snapshot_history
+      _create_history_record("snapshot")
+    end
+
+    # Check if any history exists for this instance
+    def history?
+      self.class.history_class.where(original_id: id).exists?
+    end
+
+    # Get the snapshot of this record at or before the given timestamp
+    def history_as_of(timestamp)
+      self.class.history_for(id, timestamp)
+    end
+
+    # Get all historical versions of this record
+    def all_history
+      self.class.all_history_for(id)
+    end
+
+    # Get the latest snapshot of this record
+    def latest_history
+      self.class.latest_history_for(id)
+    end
+
+    # Delete this record’s history (requires force: true)
+    def clear_history(force:)
+      raise ArgumentError, "Force must be true to clear history." unless force
+
+      self.class.history_class.where(original_id: id).delete_all
+    end
+
+    private
+
+    def record_history_create
+      _create_history_record("create")
+    end
+
+    def record_history_update
+      _create_history_record("update") if _tracked_attributes_changed?
+    end
+
+    def record_history_destroy
+      _create_history_record("destroy")
+    end
+
+    def _create_history_record(event)
+      attrs = attributes_for_history(event)
+      history_class.create!(attrs)
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless e.message.match?(/Table '.*' doesn't exist/)
+
+      raise "History table `#{history_class.table_name}` is missing. " \
+            "Run `rails g separate_history:model #{self.class.name}` to create it."
+    end
+
+    def attributes_for_history(event)
+      options = self.class.separate_history_options
+
+      attrs = if options[:track_changes] && event == "update"
+                saved_changes.transform_values(&:last).with_indifferent_access
+              else
+                attributes.dup
+              end
+
+      # For track_changes, we need to ensure original_id is set properly
+      # since saved_changes doesn't include the id attribute
+      attrs["original_id"] = if options[:track_changes] && event == "update"
+                               id
+                             else
+                               attrs.delete("id")
+                             end
+      attrs["event"] = event.to_s
+
+      # attrs["history_created_at"] = attrs.delete("created_at") if attrs.key?("created_at")
+      # attrs["history_updated_at"] = attrs.delete("updated_at") if attrs.key?("updated_at")
+
+      attrs["history_created_at"] = Time.now
+      attrs["history_updated_at"] = Time.now
+
+      if options[:only]
+        allowed_keys = options[:only].map(&:to_s) + %w[original_id event history_created_at history_updated_at]
+        attrs.slice!(*allowed_keys)
+      elsif options[:except]
+        options[:except].each { |key| attrs.delete(key.to_s) }
+      end
+
+      # remove columns that are not present in the history table
+      history_columns = history_class.column_names
+      attrs.select! { |key, _| history_columns.include?(key) }
+      attrs
+    end
+
+    def _tracked_attributes_changed?
+      # If track_changes is true, we always want to record the update
+      # because the point is to track only the changed attributes
+      return true if self.class.separate_history_options[:track_changes]
+
+      if self.class.separate_history_options[:only].nil? && self.class.separate_history_options[:except].nil?
+        return true
+      end
+
+      tracked_columns = if self.class.separate_history_options[:only]
+                          self.class.separate_history_options[:only].map(&:to_s)
+                        else
+                          self.class.column_names - self.class.separate_history_options[:except].map(&:to_s)
+                        end
+      (saved_changes.keys & tracked_columns).any?
+    end
+
+    def history_class
+      history_class_name = self.class.separate_history_options.fetch(:history_class_name, "#{self.class.name}History")
+      @history_class ||= history_class_name.constantize
+    end
+  end
+end

data/lib/separate_history/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module SeparateHistory
+  class Railtie < ::Rails::Railtie
+    initializer "separate_history.initialize" do
+      ActiveSupport.on_load(:active_record) do
+        extend SeparateHistory::Core
+      end
+    end
+  end
+end

data/lib/separate_history/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SeparateHistory
+  VERSION = "0.1.0"
+end

data/lib/separate_history.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "separate_history/version"
+require "separate_history/core"
+
+module SeparateHistory
+  class Error < StandardError; end
+
+  @tracked_models = []
+
+  def self.track_model(model)
+    @tracked_models << model unless @tracked_models.include?(model)
+  end
+
+  def self.tracked_models
+    @tracked_models.sort_by(&:name)
+  end
+end
+
+require "separate_history/railtie" if defined?(Rails::Railtie)

data/sig/separate_history.rbs

@@ -0,0 +1,4 @@
+module SeparateHistory
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end