logidze 0.10.0 → 1.1.0

data/lib/generators/logidze/install/templates/migration_fx.rb.erb

@@ -0,0 +1,41 @@
+class <%= @migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+  <%- if update? -%>
+    reversible do |dir|
+      dir.up do
+        # Drop legacy functions (<1.0)
+        execute <<~SQL
+          DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb);
+          DROP FUNCTION IF EXISTS logidze_snapshot(jsonb);
+          DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb, text[]);
+          DROP FUNCTION IF EXISTS logidze_snapshot(jsonb, text[]);
+          DROP FUNCTION IF EXISTS logidze_version(bigint, jsonb, timestamp with time zone, text[]);
+          DROP FUNCTION IF EXISTS logidze_snapshot(jsonb, text, text[]);
+          DROP FUNCTION IF EXISTS logidze_exclude_keys(jsonb, VARIADIC text[]);
+          DROP FUNCTION IF EXISTS logidze_compact_history(jsonb);
+        SQL
+      end
+    end
+
+  <%- end -%>
+  <%- function_definitions.each do |f| -%>
+    <%- previous_version = previous_version_for(f.name) -%>
+    <%- if previous_version -%>
+      <%- if previous_version != f.version -%>
+    update_function :<%= f.name %>, version: <%= f.version %>, revert_to_version: <%= previous_version %>
+      <%- end -%>
+    <%- else -%>
+    reversible do |dir|
+      dir.up do
+        create_function :<%= f.name %>, version: <%= f.version %>
+      end
+
+      dir.down do
+        execute "DROP FUNCTION IF EXISTS <%= f.name %>(<%= f.signature %>) CASCADE"
+      end
+    end
+
+    <%- end -%>
+  <%- end -%>
+  end
+end

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

@@ -2,11 +2,19 @@
 
 require "rails/generators"
 require "rails/generators/active_record/migration/migration_generator"
+require_relative "../inject_sql"
+require_relative "../fx_helper"
+
+using RubyNext
 
 module Logidze
   module Generators
     class ModelGenerator < ::ActiveRecord::Generators::Base # :nodoc:
+      include InjectSql
+      include FxHelper
+
       source_root File.expand_path("templates", __dir__)
+      source_paths << File.expand_path("triggers", __dir__)
 
       class_option :limit, type: :numeric, optional: true, desc: "Specify history size limit"
 
@@ -21,23 +29,31 @@ module Logidze
 
       class_option :path, type: :string, optional: true, desc: "Specify path to the model file"
 
-      class_option :blacklist, type: :array, optional: true
-      class_option :whitelist, type: :array, optional: true
+      class_option :except, type: :array, optional: true
+      class_option :only, type: :array, optional: true
 
       class_option :timestamp_column, type: :string, optional: true,
                                       desc: "Specify timestamp column"
 
+      class_option :name, type: :string, optional: true, desc: "Migration name"
+
       class_option :update, type: :boolean, optional: true,
                             desc: "Define whether this is an update migration"
 
       def generate_migration
-        if options[:blacklist] && options[:whitelist]
-          warn "Use only one: --whitelist or --blacklist"
+        if options[:except] && options[:only]
+          warn "Use only one: --only or --except"
           exit(1)
         end
         migration_template "migration.rb.erb", "db/migrate/#{migration_file_name}"
       end
 
+      def generate_fx_trigger
+        return unless fx?
+
+        template "logidze.sql", "db/triggers/logidze_on_#{table_name}_v#{next_version.to_s.rjust(2, "0")}.sql"
+      end
+
       def inject_logidze_to_model
         return if update?
 
@@ -48,6 +64,8 @@ module Logidze
 
       no_tasks do
         def migration_name
+          return options[:name] if options[:name].present?
+
           if update?
             "update_logidze_for_#{plural_table_name}"
           else
@@ -75,14 +93,13 @@ module Logidze
           options[:update]
         end
 
-        def columns_blacklist
-          array = if !options[:whitelist]
-            options[:blacklist]
-          else
-            class_name.constantize.column_names - options[:whitelist]
-          end
+        def filtered_columns
+          format_pgsql_array(options[:only] || options[:except])
+        end
 
-          format_pgsql_array(array)
+        def include_columns
+          return unless options[:only] || options[:except]
+          options[:only].present?
         end
 
         def timestamp_column
@@ -96,12 +113,35 @@ module Logidze
           options[:debounce_time]
         end
 
+        def previous_version
+          @previous_version ||= all_triggers.filter_map { |path| Regexp.last_match[1].to_i if path =~ %r{logidze_on_#{table_name}_v(\d+).sql} }.max
+        end
+
+        def next_version
+          previous_version&.next || 1
+        end
+
+        def all_triggers
+          @all_triggers ||=
+            begin
+              res = nil
+              in_root do
+                res = if File.directory?("db/triggers")
+                  Dir.entries("db/triggers")
+                else
+                  []
+                end
+              end
+              res
+            end
+        end
+
         def logidze_logger_parameters
-          format_pgsql_args(limit, timestamp_column, columns_blacklist, debounce_time)
+          format_pgsql_args(limit, timestamp_column, filtered_columns, include_columns, debounce_time)
         end
 
         def logidze_snapshot_parameters
-          format_pgsql_args("to_jsonb(t)", timestamp_column, columns_blacklist)
+          format_pgsql_args("to_jsonb(t)", timestamp_column, filtered_columns, include_columns)
         end
 
         def format_pgsql_array(ruby_array)

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

@@ -1,43 +1,64 @@
-class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
-  require 'logidze/migration'
-  include Logidze::Migration
-
-  def up
-    <% if update? %>
-    execute "DROP TRIGGER logidze_on_<%= table_name %> on <%= table_name %>;"
-    <% elsif !only_trigger? %>
+class <%= @migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+<%- unless update? || only_trigger? -%>
     add_column :<%= table_name %>, :log_data, :jsonb
-    <% end %>
+<%- end -%>
 
-    execute <<-SQL
-      CREATE TRIGGER logidze_on_<%= table_name %>
-      BEFORE UPDATE OR INSERT ON <%= table_name %> FOR EACH ROW
-      WHEN (coalesce(#{current_setting('logidze.disabled')}, '') <> 'on')
-      EXECUTE PROCEDURE logidze_logger(<%= logidze_logger_parameters %>);
-    SQL
+<%- if fx? -%>
+  <%- if previous_version -%>
+    update_trigger :logidze_on_<%= table_name %>, on: :<%= table_name %>, version: <%= next_version %>, revert_to_version: <%= previous_version %>
+  <%- else -%>
+    reversible do |dir|
+      dir.up do
+    <%- if update? -%>
+        # Drop legacy trigger if any (<1.0)
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
 
-    <% if backfill? %>
-    execute <<-SQL
-      UPDATE <%= table_name %> as t
-      SET log_data = logidze_snapshot(<%= logidze_snapshot_parameters %>);
-    SQL
-    <% end %>
-  end
+    <%- end -%>
+        create_trigger :logidze_on_<%= table_name %>, on: :<%= table_name %>
+      end
+
+      dir.down do
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+      end
+    end
+  <%- end -%>
+<%- else -%>
+    reversible do |dir|
+      dir.up do
+  <%- if update? -%>
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+
+  <%- end -%>
+        execute <<~SQL
+<%= inject_sql("logidze.sql", indent: 10) %>
+        SQL
+      end
 
-  def down
-    <% if update? %>
-    # NOTE: We have no idea on how to revert the migration
-    # ('cause we don't know the previous trigger params),
-    # but you can do that on your own.
-    # 
-    # Uncomment this line if you want to raise an error.
-    # raise ActiveRecord::IrreversibleMigration
-    <% else %>
-    execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+      dir.down do
+  <%- if update? -%>
+        # NOTE: We have no idea on how to revert the migration
+        # ('cause we don't know the previous trigger params),
+        # but you can do that on your own.
+        #
+        # Uncomment this line if you want to raise an error.
+        # raise ActiveRecord::IrreversibleMigration
+  <%- else -%>
+        execute "DROP TRIGGER IF EXISTS logidze_on_<%= table_name %> on <%= table_name %>;"
+  <%- end -%>
+      end
+    end
+<%- end -%>
+<%- if backfill? -%>
 
-    <% if !only_trigger? %>
-    remove_column :<%= table_name %>, :log_data
-    <% end %>
-    <% end %>
+    reversible do |dir|
+      dir.up do
+        execute <<~SQL
+          UPDATE <%= table_name %> as t
+          SET log_data = logidze_snapshot(<%= logidze_snapshot_parameters %>);
+        SQL
+      end
+    end
+<%- end -%>
   end
 end

data/lib/generators/logidze/model/triggers/logidze.sql

@@ -0,0 +1,6 @@
+CREATE TRIGGER logidze_on_<%= table_name %>
+BEFORE UPDATE OR INSERT ON <%= table_name %> FOR EACH ROW
+WHEN (coalesce(current_setting('logidze.disabled', true), '') <> 'on')
+-- Parameters: history_size_limit (integer), timestamp_column (text), filtered_columns (text[]),
+-- include_columns (boolean), debounce_time_ms (integer)
+EXECUTE PROCEDURE logidze_logger(<%= logidze_logger_parameters %>);

data/lib/logidze.rb

@@ -5,6 +5,7 @@ require "logidze/version"
 # Logidze provides tools for adding in-table JSON-based audit to DB tables
 # and ActiveRecord extensions to work with changes history.
 module Logidze
+  require "ruby-next"
   require "logidze/history"
   require "logidze/model"
   require "logidze/versioned_association"
@@ -19,48 +20,53 @@ module Logidze
   class << self
     # Determines if Logidze should append a version to the log after updating an old version.
     attr_accessor :append_on_undo
-
-    attr_writer :associations_versioning
-
-    def associations_versioning
-      @associations_versioning || false
-    end
-
+    # Determines whether associations versioning is enabled or not
+    attr_accessor :associations_versioning
     # Determines if Logidze should exclude log data from SELECT statements
-    attr_writer :ignore_log_data_by_default
-
-    def ignore_log_data_by_default
-      @ignore_log_data_by_default || false
-    end
-
-    attr_writer :force_load_log_data
-
-    def force_load_log_data
-      @force_load_log_data || false
-    end
+    attr_accessor :ignore_log_data_by_default
+    # Whether #at should return self or nil when log_data is nil
+    attr_accessor :return_self_if_log_data_is_empty
+    # Determines what Logidze should do when upgrade is needed (:raise | :warn | :ignore)
+    attr_reader :on_pending_upgrade
 
     # Temporary disable DB triggers.
     #
     # @example
     #   Logidze.without_logging { Post.update_all(active: true) }
     def without_logging
-      ActiveRecord::Base.transaction do
-        ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO on;"
-        res = yield
-        ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO DEFAULT;"
-        res
-      end
+      with_logidze_setting("logidze.disabled", "on") { yield }
     end
 
-    # Temporary turn off ignore_log_data_by_default config
+    # Instruct Logidze to create a full snapshot for the new versions, not a diff
     #
     # @example
-    #   Logidze.with_log_data { Post.update_all(active: true) }
-    def with_log_data
-      Logidze.force_load_log_data = true
-      yield
-    ensure
-      Logidze.force_load_log_data = false
+    #   Logidze.with_full_snapshot { post.touch }
+    def with_full_snapshot
+      with_logidze_setting("logidze.full_snapshot", "on") { yield }
+    end
+
+    def on_pending_upgrade=(mode)
+      if %i[raise warn ignore].exclude? mode
+        raise ArgumentError, "Unknown on_pending_upgrade option `#{mode.inspect}`. Expecting :raise, :warn or :ignore"
+      end
+      @on_pending_upgrade = mode
+    end
+
+    private
+
+    def with_logidze_setting(name, value)
+      ActiveRecord::Base.transaction do
+        ActiveRecord::Base.connection.execute "SET LOCAL #{name} TO #{value};"
+        res = yield
+        ActiveRecord::Base.connection.execute "SET LOCAL #{name} TO DEFAULT;"
+        res
+      end
     end
   end
+
+  self.append_on_undo = false
+  self.associations_versioning = false
+  self.ignore_log_data_by_default = false
+  self.return_self_if_log_data_is_empty = true
+  self.on_pending_upgrade = :ignore
 end

data/lib/logidze/engine.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
 require "logidze"
+require "logidze/utils/check_pending"
 
 module Logidze
   class Engine < Rails::Engine # :nodoc:
+    config.logidze = Logidze
+
     initializer "extend ActiveRecord with Logidze" do |_app|
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Base.send :include, Logidze::HasLogidze
       end
     end
+
+    initializer "check Logidze function versions" do |app|
+      if config.logidze.on_pending_upgrade != :ignore
+        ActiveSupport.on_load(:active_record) do
+          app.config.app_middleware.use Logidze::Utils::CheckPending
+        end
+      end
+    end
   end
 end

data/lib/logidze/has_logidze.rb

@@ -10,19 +10,17 @@ module Logidze
     module ClassMethods # :nodoc:
       # Include methods to work with history.
       #
-      def has_logidze(ignore_log_data: nil)
-        include Logidze::Model
+      def has_logidze(ignore_log_data: Logidze.ignore_log_data_by_default)
         include Logidze::IgnoreLogData
+        include Logidze::Model
 
         @ignore_log_data = ignore_log_data
+
+        self.ignored_columns += ["log_data"] if @ignore_log_data
       end
 
       def ignores_log_data?
-        if @ignore_log_data.nil? && Logidze.ignore_log_data_by_default
-          !Logidze.force_load_log_data
-        else
-          @ignore_log_data
-        end
+        @ignore_log_data
       end
     end
   end

data/lib/logidze/history.rb

@@ -17,15 +17,6 @@ module Logidze
     delegate :size, to: :versions
     delegate :responsible_id, :meta, to: :current_version
 
-    ### Rails 4 ###
-    def self.dump(object)
-      ActiveSupport::JSON.encode(object)
-    end
-
-    def self.load(json)
-      new(json) if json.present?
-    end
-
     def initialize(data)
       @data = data
     end
@@ -108,7 +99,7 @@ module Logidze
 
     # Return nearest (from the bottom) version to the specified time
     def find_by_time(time)
-      versions.reverse.find { |v| v.time <= time }
+      versions.reverse_each.find { |v| v.time <= time }
     end
 
     def dup

data/lib/logidze/ignore_log_data.rb

@@ -1,57 +1,22 @@
 # frozen_string_literal: true
 
-require "logidze/ignore_log_data/association"
-
 module Logidze
   module IgnoreLogData # :nodoc:
     extend ActiveSupport::Concern
 
     included do
-      if Rails::VERSION::MAJOR == 4
-        require "logidze/ignore_log_data/ignored_columns"
-      else
-        if Rails::VERSION::MAJOR == 5
-          require "logidze/ignore_log_data/cast_attribute_patch"
-          include CastAttributePatch
-        end
-
-        require "logidze/ignore_log_data/missing_attribute_patch"
-        include MissingAttributePatch
-
-        require "logidze/ignore_log_data/default_scope_patch"
-        include DefaultScopePatch
+      if Rails::VERSION::MAJOR == 5
+        require "logidze/ignore_log_data/cast_attribute_patch"
+        include CastAttributePatch
       end
 
-      self.ignored_columns += ["log_data"]
-
       scope :with_log_data, lambda {
         if ignored_columns == ["log_data"]
-          select("*")
+          select(arel_table[Arel.star])
         else
-          select(column_names + ["log_data"])
+          select(column_names + [arel_table[:log_data]])
         end
       }
     end
-
-    module ClassMethods # :nodoc:
-      def self.default_scope
-        ignores_log_data? ? super : super.with_log_data
-      end
-    end
-
-    def association(name)
-      association = super
-
-      should_load_log_data =
-        attributes["log_data"] &&
-        association.klass.respond_to?(:has_logidze?) &&
-        !association.singleton_class.include?(Logidze::IgnoreLogData::Association)
-
-      return association unless should_load_log_data
-
-      association.singleton_class.prepend(Logidze::IgnoreLogData::Association)
-
-      association
-    end
   end
 end