table_sync 4.2.1 → 6.0

data/docs/receiving.md

@@ -68,7 +68,7 @@ The method receives following arguments
 - `events` - array of supported events (optional)
 - `block` - configuration block with options (optional)
 
-This method implements logic of mapping `source` to `to_table` (or to `to_model`) and allows customizing 
+This method implements logic of mapping `source` to `to_table` (or to `to_model`) and allows customizing
 the event handling logic with provided block.
 You can use one `source` for a lot of `to_table` or `to_moel`.
 
@@ -235,12 +235,13 @@ default value is `false`
 Proc that is used to wrap the receiving logic by custom block of code.
 
 ```ruby
-wrap_receiving do |data:, target_keys:, version_key:, default_values: {}, &receiving_logic|
+wrap_receiving do |data:, target_keys:, version_key:, default_values: {}, event:, &receiving_logic|
   receiving_logic.call
   return makes no sense
 end
 ```
 
+event option is current fired event
 default value is `proc { |&block| block.call }`
 
 #### before_update
@@ -262,15 +263,17 @@ end
 Perform code after updated data was committed.
 
 ```ruby
-after_commit_on_update do |data:, target_keys:, version_key:, default_values:|
+after_commit_on_update do |data:, target_keys:, version_key:, default_values:, results:|
   return makes no sense
 end
 
-after_commit_on_update do |data:, target_keys:, version_key:, default_values:|
+after_commit_on_update do |data:, target_keys:, version_key:, default_values:, results:|
   return makes no sense
 end
 ```
 
+- `results` - returned value from `model.upsert`
+
 Сan be defined several times. Execution order guaranteed.
 
 #### before_destroy
@@ -292,15 +295,17 @@ end
 Perform code after destroyed data was committed.
 
 ```ruby
-after_commit_on_destroy do |data:, target_keys:, version_key:|
+after_commit_on_destroy do |data:, target_keys:, version_key:, results:|
   return makes no sense
 end
 
-after_commit_on_destroy do |data:, target_keys:, version_key:|
+after_commit_on_destroy do |data:, target_keys:, version_key:, results:|
   return makes no sense
 end
 ```
 
+- `results` - returned value from `model.destroy`
+
 Сan be defined several times. Execution order guaranteed.
 
 ### Custom model

data/lib/table_sync/errors.rb

@@ -3,6 +3,35 @@
 module TableSync
   Error = Class.new(StandardError)
 
+  NoObjectsForSyncError = Class.new(Error)
+
+  class EventError < Error
+    def initialize(event)
+      super(<<~MSG.squish)
+        Event #{event.inspect} is invalid.#{' '}
+        Expected: #{TableSync::Event::VALID_RAW_EVENTS.inspect}.
+      MSG
+    end
+  end
+
+  class NoPrimaryKeyError < Error
+    def initialize(object_class, object_data, primary_key_columns)
+      super(<<~MSG.squish)
+        Can't find or init an object of #{object_class} with #{object_data.inspect}.
+        Incomplete primary key! object_data must contain: #{primary_key_columns.inspect}.
+      MSG
+    end
+  end
+
+  class NoCallableError < Error
+    def initialize(type)
+      super(<<~MSG.squish)
+        Can't find callable for #{type}!
+        Please initialize TableSync.#{type}_callable with the correct proc!
+      MSG
+    end
+  end
+
   class UpsertError < Error
     def initialize(data:, target_keys:, result:)
       super("data: #{data.inspect}, target_keys: #{target_keys.inspect}, result: #{result.inspect}")
@@ -25,28 +54,6 @@ module TableSync
     end
   end
 
-  # @api public
-  # @since 2.2.0
-  PluginError = Class.new(Error)
-
-  # @api public
-  # @since 2.2.0
-  class UnregisteredPluginError < PluginError
-    # @param plugin_name [Any]
-    def initialize(plugin_name)
-      super("#{plugin_name} plugin is not registered")
-    end
-  end
-
-  # @api public
-  # @since 2.2.0
-  class AlreadyRegisteredPluginError < PluginError
-    # @param plugin_name [Any]
-    def initialize(plugin_name)
-      super("#{plugin_name} plugin already exists")
-    end
-  end
-
   class InterfaceError < Error
     def initialize(object, method_name, parameters, description)
       parameters = parameters.map do |parameter|
@@ -54,7 +61,9 @@ module TableSync
 
         case type
         when :req
+          #:nocov:
           name.to_s
+          #:nocov:
         when :keyreq
           "#{name}:"
         when :block

data/lib/table_sync/event.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class TableSync::Event
+  attr_reader :event
+
+  UPSERT_EVENTS          = %i[create update].freeze
+  VALID_RESOLVED_EVENTS  = %i[update destroy].freeze
+  VALID_RAW_EVENTS       = %i[create update destroy].freeze
+
+  def initialize(event)
+    @event = event
+
+    validate!
+  end
+
+  def validate!
+    raise TableSync::EventError.new(event) unless event.in?(VALID_RAW_EVENTS)
+  end
+
+  def resolve
+    destroy? ? :destroy : :update
+  end
+
+  def metadata
+    { created: event == :create }
+  end
+
+  def destroy?
+    event == :destroy
+  end
+
+  def upsert?
+    event.in?(UPSERT_EVENTS)
+  end
+end

data/lib/table_sync/orm_adapter/active_record.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TableSync::ORMAdapter
+  class ActiveRecord < Base
+    def find
+      @object = object_class.find_by(needle)
+
+      super
+    end
+
+    def init
+      @object = object_class.new(object_data)
+
+      super
+    end
+
+    def attributes
+      object.attributes.symbolize_keys
+    end
+
+    def self.model_naming(object_class)
+      TableSync::NamingResolver::ActiveRecord.new(table_name: object_class.table_name)
+    end
+  end
+end

data/lib/table_sync/orm_adapter/base.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module TableSync::ORMAdapter
+  class Base
+    attr_reader :object, :object_class, :object_data
+
+    def initialize(object_class, object_data)
+      @object_class = object_class
+      @object_data  = object_data.symbolize_keys
+
+      validate!
+    end
+
+    # VALIDATE
+
+    def validate!
+      if (primary_key_columns - object_data.keys).any?
+        raise TableSync::NoPrimaryKeyError.new(object_class, object_data, primary_key_columns)
+      end
+    end
+
+    # FIND OR INIT OBJECT
+
+    def init
+      self
+    end
+
+    def find
+      self
+    end
+
+    def needle
+      object_data.slice(*primary_key_columns)
+    end
+
+    # ATTRIBUTES
+
+    def attributes_for_update
+      if object.respond_to?(:attributes_for_sync)
+        object.attributes_for_sync
+      else
+        attributes
+      end
+    end
+
+    def attributes_for_destroy
+      if object.respond_to?(:attributes_for_destroy)
+        object.attributes_for_destroy
+      else
+        needle
+      end
+    end
+
+    def attributes_for_routing_key
+      if object.respond_to?(:attributes_for_routing_key)
+        object.attributes_for_routing_key
+      else
+        attributes
+      end
+    end
+
+    def attributes_for_headers
+      if object.respond_to?(:attributes_for_headers)
+        object.attributes_for_headers
+      else
+        attributes
+      end
+    end
+
+    def primary_key_columns
+      Array.wrap(object_class.primary_key).map(&:to_sym)
+    end
+
+    # MISC
+
+    def empty?
+      object.nil?
+    end
+
+    # NOT IMPLEMENTED
+
+    # :nocov:
+    def attributes
+      raise NotImplementedError
+    end
+
+    def self.model_naming
+      raise NotImplementedError
+    end
+    # :nocov:
+  end
+end

data/lib/table_sync/orm_adapter/sequel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TableSync::ORMAdapter
+  class Sequel < Base
+    def attributes
+      object.values
+    end
+
+    def init
+      @object = object_class.new(object_data.except(*primary_key_columns))
+
+      @object.set_fields(needle, needle.keys)
+
+      super
+    end
+
+    def find
+      @object = object_class.find(needle)
+
+      super
+    end
+
+    def self.model_naming(object_class)
+      TableSync::NamingResolver::Sequel.new(
+        table_name: object_class.table_name, db: object_class.db,
+      )
+    end
+  end
+end

data/lib/table_sync/publishing/batch.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class TableSync::Publishing::Batch
+  include Tainbox
+
+  attribute :object_class
+  attribute :original_attributes
+
+  attribute :routing_key
+  attribute :headers
+
+  attribute :event, default: :update
+
+  def publish_later
+    job.perform_later(job_attributes)
+  end
+
+  def publish_now
+    message.publish
+  end
+
+  def message
+    TableSync::Publishing::Message::Batch.new(attributes)
+  end
+
+  alias_method :publish_async, :publish_later
+
+  private
+
+  # JOB
+
+  def job
+    if TableSync.batch_publishing_job_class_callable
+      TableSync.batch_publishing_job_class_callable.call
+    else
+      raise TableSync::NoCallableError.new("batch_publishing_job_class")
+    end
+  end
+
+  def job_attributes
+    attributes.merge(
+      original_attributes: serialized_original_attributes,
+    )
+  end
+
+  def serialized_original_attributes
+    original_attributes.map do |set_of_attributes|
+      TableSync::Publishing::Helpers::Attributes
+        .new(set_of_attributes)
+        .serialize
+    end
+  end
+end

data/lib/table_sync/publishing/data/objects.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Data
+  class Objects
+    attr_reader :objects, :event
+
+    def initialize(objects:, event:)
+      @objects = objects
+      @event   = TableSync::Event.new(event)
+    end
+
+    def construct
+      {
+        model: model,
+        attributes: attributes_for_sync,
+        version: version,
+        event: event.resolve,
+        metadata: event.metadata,
+      }
+    end
+
+    private
+
+    def model
+      if object_class.respond_to?(:table_sync_model_name)
+        object_class.table_sync_model_name
+      else
+        object_class.name
+      end
+    end
+
+    def version
+      Time.current.to_f
+    end
+
+    def object_class
+      objects.first.object_class
+    end
+
+    def attributes_for_sync
+      objects.map do |object|
+        if event.destroy?
+          object.attributes_for_destroy
+        else
+          object.attributes_for_update
+        end
+      end
+    end
+  end
+end

data/lib/table_sync/publishing/data/raw.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Data
+  class Raw
+    attr_reader :object_class, :attributes_for_sync, :event
+
+    def initialize(object_class:, attributes_for_sync:, event:)
+      @object_class = object_class
+      @attributes_for_sync = attributes_for_sync
+      @event = TableSync::Event.new(event)
+    end
+
+    def construct
+      {
+        model: object_class,
+        attributes: attributes_for_sync,
+        version: version,
+        event: event.resolve,
+        metadata: event.metadata,
+      }
+    end
+
+    def version
+      Time.current.to_f
+    end
+  end
+end

data/lib/table_sync/publishing/helpers/attributes.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Helpers
+  class Attributes
+    BASE_SAFE_JSON_TYPES = [
+      NilClass,
+      String,
+      TrueClass,
+      FalseClass,
+      Numeric,
+      Symbol,
+    ].freeze
+
+    # add custom seializables?
+
+    NOT_MAPPED = Object.new
+
+    attr_reader :attributes
+
+    def initialize(attributes)
+      @attributes = attributes.deep_symbolize_keys
+    end
+
+    def serialize
+      filter_safe_for_serialization(attributes)
+    end
+
+    def filter_safe_for_serialization(object)
+      case object
+      when Array
+        object.each_with_object([]) do |value, memo|
+          value = filter_safe_for_serialization(value)
+          memo << value if object_mapped?(value)
+        end
+      when Hash
+        object.each_with_object({}) do |(key, value), memo|
+          key = filter_safe_for_serialization(key)
+          value = filter_safe_hash_values(value)
+          memo[key] = value if object_mapped?(key) && object_mapped?(value)
+        end
+      when Float::INFINITY
+        NOT_MAPPED
+      when *BASE_SAFE_JSON_TYPES
+        object
+      else # rubocop:disable Lint/DuplicateBranch
+        NOT_MAPPED
+      end
+    end
+
+    def filter_safe_hash_values(value)
+      case value
+      when Symbol
+        value.to_s # why?
+      else
+        filter_safe_for_serialization(value)
+      end
+    end
+
+    def object_mapped?(object)
+      object != NOT_MAPPED
+    end
+  end
+end

data/lib/table_sync/publishing/helpers/debounce.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# CASES FOR DEBOUNCE
+
+# Cached Sync Time -> CST - time last sync has occured or next sync will occur
+# Next Sync Time   -> NST - time next sync will occur
+
+# 0
+# Condition: debounce_time is zero.
+# No debounce, sync right now.
+# Result: NST -> Time.current
+
+# 1
+# Condition: CST is empty.
+# There was no sync before. Can be synced right now.
+# Result: NST -> Time.current
+
+# 2
+# Condition: CST =< Time.current.
+# There was a sync before.
+
+# 2.1
+# Subcondition: CST + debounce_time <= Time.current
+# Enough time passed for debounce condition to be satisfied.
+# No need to wait. Can by synced right now.
+# Result: NST -> Time.current
+
+# 2.2
+# Subcondition: CST + debounce_time > Time.current
+# Debounce condition is not satisfied. Must wait till debounce period has passed.
+# Will be synced after debounce period has passed.
+# Result: NST -> CST + debounce_time
+
+# 3
+# Condition: CST > Time.current
+# Sync job has already been enqueued in the future.
+
+# 3.1
+# Subcondition: event -> update | create
+# No need to sync upsert event, since it has already enqueued sync in the future.
+# It will sync fresh version anyway.
+# NST -> Skip, no sync.
+
+# 3.2
+# Subcondition: event -> destroy
+# In this case the already enqueued job must be upsert.
+# Thus destructive sync has to send message after upsert sync.
+# NST -> CST + debounce_time
+
+module TableSync::Publishing::Helpers
+  class Debounce
+    include Memery
+
+    DEFAULT_TIME = 60
+
+    attr_reader :debounce_time, :object_class, :needle, :event
+
+    def initialize(object_class:, needle:, event:, debounce_time: nil)
+      @event         = event
+      @debounce_time = debounce_time || DEFAULT_TIME
+      @object_class  = object_class
+      @needle        = needle
+    end
+
+    def skip?
+      true if sync_in_the_future? && upsert_event? # case 3.1
+    end
+
+    memoize def next_sync_time
+      return current_time        if debounce_time.zero? # case 0
+      return current_time        if no_sync_before?     # case 1
+
+      return current_time        if sync_in_the_past? && debounce_time_passed?     # case 2.1
+      return debounced_sync_time if sync_in_the_past? && debounce_time_not_passed? # case 2.2
+
+      return debounced_sync_time if sync_in_the_future? && destroy_event? # case 3.2
+    end
+
+    # CASE 1
+    def no_sync_before?
+      cached_sync_time.nil?
+    end
+
+    # CASE 2
+    def sync_in_the_past?
+      cached_sync_time <= current_time
+    end
+
+    def debounce_time_passed?
+      cached_sync_time + debounce_time.seconds >= current_time
+    end
+
+    def debounce_time_not_passed?
+      cached_sync_time + debounce_time.seconds < current_time
+    end
+
+    # CASE 3
+    def sync_in_the_future?
+      cached_sync_time && (cached_sync_time > current_time)
+    end
+
+    def destroy_event?
+      event == :destroy
+    end
+
+    def upsert_event?
+      !destroy_event?
+    end
+
+    # MISC
+
+    def debounced_sync_time
+      cached_sync_time + debounce_time.seconds
+    end
+
+    memoize def current_time
+      Time.current
+    end
+
+    # CACHE
+
+    memoize def cached_sync_time
+      Rails.cache.read(cache_key)
+    end
+
+    def cache_next_sync_time
+      Rails.cache.write(cache_key, next_sync_time)
+    end
+
+    def cache_key
+      "#{object_class}/#{needle.values.join}_table_sync_time".delete(" ")
+    end
+  end
+end

data/lib/table_sync/publishing/helpers/objects.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Helpers
+  class Objects
+    attr_reader :object_class, :original_attributes, :event
+
+    def initialize(object_class:, original_attributes:, event:)
+      @event               = TableSync::Event.new(event)
+      @object_class        = object_class.constantize
+      @original_attributes = Array.wrap(original_attributes)
+    end
+
+    def construct_list
+      if event.destroy?
+        init_objects
+      else
+        without_empty_objects(find_objects)
+      end
+    end
+
+    private
+
+    def without_empty_objects(objects)
+      objects.reject(&:empty?)
+    end
+
+    def init_objects
+      original_attributes.map do |attrs|
+        TableSync.publishing_adapter.new(object_class, attrs).init
+      end
+    end
+
+    def find_objects
+      original_attributes.map do |attrs|
+        TableSync.publishing_adapter.new(object_class, attrs).find
+      end
+    end
+  end
+end