logidze 0.12.0 → 1.0.0.rc1

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

@@ -0,0 +1,41 @@
+class <%= @migration_class_name %> < ActiveRecord::Migration[5.0]
+  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,8 +29,8 @@ 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"
@@ -31,13 +39,19 @@ module Logidze
                             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?
 
@@ -75,14 +89,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 +109,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[5.0]
+  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,31 +20,43 @@ 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_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
 
     # Temporary disable DB triggers.
     #
     # @example
     #   Logidze.without_logging { Post.update_all(active: true) }
     def without_logging
+      with_logidze_setting("logidze.disabled", "on") { yield }
+    end
+
+    # Instructure Logidze to create a full snapshot for the new versions, not a diff
+    #
+    # @example
+    #   Logidze.with_full_snapshot { post.touch }
+    def with_full_snapshot
+      with_logidze_setting("logidze.full_snapshot", "on") { yield }
+    end
+
+    private
+
+    def with_logidze_setting(name, value)
       ActiveRecord::Base.transaction do
-        ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO on;"
+        ActiveRecord::Base.connection.execute "SET LOCAL #{name} TO #{value};"
         res = yield
-        ActiveRecord::Base.connection.execute "SET LOCAL logidze.disabled TO DEFAULT;"
+        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
 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

@@ -5,10 +5,7 @@ module Logidze
     extend ActiveSupport::Concern
 
     included do
-      if Rails::VERSION::MAJOR == 4
-        require "logidze/ignore_log_data/ignored_columns"
-        attribute :log_data, ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb.new
-      elsif Rails::VERSION::MAJOR == 5
+      if Rails::VERSION::MAJOR == 5
         require "logidze/ignore_log_data/cast_attribute_patch"
         include CastAttributePatch
       end

data/lib/logidze/model.rb

@@ -3,43 +3,28 @@
 require "active_support"
 
 module Logidze
-  module Deprecations # :nodoc:
-    def self.show_ts_deprecation_for(meth)
-      warn(
-        "[Deprecation] Usage of #{meth}(time) will be removed in the future releases, "\
-        "use #{meth}(time: ts) instead"
-      )
-    end
-  end
+  using RubyNext
 
   # Extends model with methods to browse history
   module Model
-    require "logidze/history/type" if Rails::VERSION::MAJOR >= 5
+    require "logidze/history/type"
 
     extend ActiveSupport::Concern
 
     included do
-      if Rails::VERSION::MAJOR < 5
-        serialize :log_data, Logidze::History
-      else
-        attribute :log_data, Logidze::History::Type.new
-      end
+      attribute :log_data, Logidze::History::Type.new
 
       delegate :version, to: :log_data, prefix: "log"
     end
 
     module ClassMethods # :nodoc:
       # Return records reverted to specified time
-      def at(ts = nil, time: nil, version: nil)
-        Deprecations.show_ts_deprecation_for(".at") if ts
-        time ||= ts
-        all.map { |record| record.at(time: time, version: version) }.compact
+      def at(time: nil, version: nil)
+        all.to_a.filter_map { |record| record.at(time: time, version: version) }
       end
 
       # Return changes made to records since specified time
-      def diff_from(ts = nil, time: nil, version: nil)
-        Deprecations.show_ts_deprecation_for(".diff_from") if ts
-        time ||= ts
+      def diff_from(time: nil, version: nil)
         all.map { |record| record.diff_from(time: time, version: version) }
       end
 
@@ -58,6 +43,28 @@ module Logidze
       def reset_log_data
         without_logging { update_all(log_data: nil) }
       end
+
+      # Initialize log_data with the current state if it's null
+      def create_logidze_snapshot(timestamp: nil, only: nil, except: nil)
+        args = ["'null'"]
+
+        args[0] = "'#{timestamp}'" if timestamp
+
+        columns = only || except
+
+        if columns
+          args[1] = "'{#{columns.join(",")}}'"
+          args[2] = only ? "true" : "false"
+        end
+
+        without_logging do
+          where(log_data: nil).update_all(
+            <<~SQL
+              log_data = logidze_snapshot(to_jsonb(#{quoted_table_name}), #{args.join(", ")})
+            SQL
+          )
+        end
+      end
     end
 
     # Use this to convert Ruby time to milliseconds
@@ -69,14 +76,15 @@ module Logidze
     # If time/version is less then the first version, then return nil.
     # If time/version is greater then the last version, then return self.
     # rubocop: disable Metrics/MethodLength
-    def at(ts = nil, time: nil, version: nil)
-      Deprecations.show_ts_deprecation_for("#at") if ts
-
+    def at(time: nil, version: nil)
       return at_version(version) if version
 
-      time ||= ts
       time = parse_time(time)
 
+      unless log_data
+        return Logidze.return_self_if_log_data_is_empty ? self : nil
+      end
+
       return nil unless log_data.exists_ts?(time)
 
       if log_data.current_ts?(time)
@@ -91,12 +99,11 @@ module Logidze
     # rubocop: enable Metrics/MethodLength
 
     # Revert record to the version at specified time (without saving to DB)
-    def at!(ts = nil, time: nil, version: nil)
-      Deprecations.show_ts_deprecation_for("#at!") if ts
-
+    def at!(time: nil, version: nil)
       return at_version!(version) if version
 
-      time ||= ts
+      raise ArgumentError, "#log_data is empty" unless log_data
+
       time = parse_time(time)
 
       return self if log_data.current_ts?(time)
@@ -119,6 +126,8 @@ module Logidze
 
     # Revert record to the specified version (without saving to DB)
     def at_version!(version)
+      raise ArgumentError, "#log_data is empty" unless log_data
+
       return self if log_data.version == version
       return false unless log_data.find_by_version(version)
 
@@ -131,13 +140,11 @@ module Logidze
     #
     #   post.diff_from(time: 2.days.ago) # or post.diff_from(version: 2)
     #   #=> { "id" => 1, "changes" => { "title" => { "old" => "Hello!", "new" => "World" } } }
-    def diff_from(ts = nil, version: nil, time: nil)
-      Deprecations.show_ts_deprecation_for("#diff_from") if ts
-      time ||= ts
+    def diff_from(version: nil, time: nil)
       time = parse_time(time) if time
-      changes = log_data.diff_from(time: time, version: version).tap do |v|
+      changes = log_data&.diff_from(time: time, version: version)&.tap do |v|
         deserialize_changes!(v)
-      end
+      end || {}
 
       changes.delete_if { |k, _v| deleted_column?(k) }
 
@@ -206,7 +213,7 @@ module Logidze
 
     # Loads log_data field from the database, stores to the attributes hash and returns it
     def reload_log_data
-      self.log_data = self.class.where(self.class.primary_key => id).pluck(:log_data).first
+      self.log_data = self.class.where(self.class.primary_key => id).pluck("#{self.class.table_name}.log_data").first
     end
 
     # Nullify log_data column for a single record
@@ -214,6 +221,12 @@ module Logidze
       self.class.without_logging { update_column(:log_data, nil) }
     end
 
+    def create_logidze_snapshot!(**opts)
+      self.class.where(self.class.primary_key => id).create_logidze_snapshot(**opts)
+
+      reload_log_data
+    end
+
     protected
 
     def apply_diff(version, diff)