table_sync 5.1.0 → 6.0

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

data/lib/table_sync/publishing/message/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Message
+  class Base
+    include Tainbox
+
+    attr_reader :objects
+
+    attribute :object_class
+    attribute :original_attributes
+    attribute :event
+
+    def initialize(params)
+      super(params)
+
+      @objects = find_or_init_objects
+
+      raise TableSync::NoObjectsForSyncError if objects.empty? && TableSync.raise_on_empty_message
+    end
+
+    def publish
+      return if original_attributes.blank?
+
+      Rabbit.publish(message_params)
+
+      notify!
+    end
+
+    def empty?
+      objects.empty?
+    end
+
+    def find_or_init_objects
+      TableSync::Publishing::Helpers::Objects.new(
+        object_class: object_class, original_attributes: original_attributes, event: event,
+      ).construct_list
+    end
+
+    # MESSAGE PARAMS
+
+    def message_params
+      params.merge(data: data)
+    end
+
+    def data
+      TableSync::Publishing::Data::Objects.new(
+        objects: objects, event: event,
+      ).construct
+    end
+
+    # :nocov:
+    def params
+      raise NotImplementedError
+    end
+    # :nocov:
+
+    # NOTIFY
+
+    def notify!
+      TableSync::Instrument.notify(
+        table: model_naming.table,
+        schema: model_naming.schema,
+        event: event,
+        direction: :publish,
+        count: objects.count,
+      )
+    end
+
+    def model_naming
+      TableSync.publishing_adapter.model_naming(objects.first.object_class)
+    end
+  end
+end

data/lib/table_sync/publishing/message/batch.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Message
+  class Batch < Base
+    attribute :headers
+    attribute :routing_key
+
+    def params
+      TableSync::Publishing::Params::Batch.new(
+        object_class: object_class, headers: headers, routing_key: routing_key,
+      ).construct
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Message
+  class Raw
+    include Tainbox
+
+    attribute :object_class
+    attribute :original_attributes
+    attribute :routing_key
+    attribute :headers
+
+    attribute :event
+
+    def publish
+      Rabbit.publish(message_params)
+
+      notify!
+    end
+
+    # NOTIFY
+
+    def notify!
+      TableSync::Instrument.notify(
+        table: model_naming.table,
+        schema: model_naming.schema,
+        event: event,
+        count: original_attributes.count,
+        direction: :publish,
+      )
+    end
+
+    def model_naming
+      TableSync.publishing_adapter.model_naming(object_class.constantize)
+    end
+
+    # MESSAGE PARAMS
+
+    def message_params
+      params.merge(data: data)
+    end
+
+    def data
+      TableSync::Publishing::Data::Raw.new(
+        object_class: object_class, attributes_for_sync: original_attributes, event: event,
+      ).construct
+    end
+
+    def params
+      TableSync::Publishing::Params::Raw.new(
+        object_class: object_class, routing_key: routing_key, headers: headers,
+      ).construct
+    end
+  end
+end

data/lib/table_sync/publishing/message/single.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Message
+  class Single < Base
+    def object
+      objects.first
+    end
+
+    def params
+      TableSync::Publishing::Params::Single.new(object: object).construct
+    end
+  end
+end

data/lib/table_sync/publishing/params/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Params
+  class Base
+    DEFAULT_PARAMS = {
+      confirm_select: true,
+      realtime: true,
+      event: :table_sync,
+    }.freeze
+
+    def construct
+      DEFAULT_PARAMS.merge(
+        routing_key: routing_key,
+        headers: headers,
+        exchange_name: exchange_name,
+      )
+    end
+
+    private
+
+    def calculated_routing_key
+      if TableSync.routing_key_callable
+        TableSync.routing_key_callable.call(object_class, attributes_for_routing_key)
+      else
+        raise TableSync::NoCallableError.new("routing_key")
+      end
+    end
+
+    def calculated_headers
+      if TableSync.headers_callable
+        TableSync.headers_callable.call(object_class, attributes_for_headers)
+      else
+        raise TableSync::NoCallableError.new("headers")
+      end
+    end
+
+    # NOT IMPLEMENTED
+
+    # name of the model being synced in the string format
+    # :nocov:
+    def object_class
+      raise NotImplementedError
+    end
+
+    def routing_key
+      raise NotImplementedError
+    end
+
+    def headers
+      raise NotImplementedError
+    end
+
+    def exchange_name
+      raise NotImplementedError
+    end
+
+    def attributes_for_routing_key
+      raise NotImplementedError
+    end
+
+    def attributes_for_headers
+      raise NotImplementedError
+    end
+    # :nocov:
+  end
+end

data/lib/table_sync/publishing/params/batch.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Params
+  class Batch < Base
+    include Tainbox
+
+    attribute :object_class
+
+    attribute :exchange_name, default: -> { TableSync.exchange_name }
+    attribute :routing_key,   default: -> { calculated_routing_key }
+    attribute :headers,       default: -> { calculated_headers }
+
+    private
+
+    def attributes_for_routing_key
+      {}
+    end
+
+    def attributes_for_headers
+      {}
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Params
+  class Raw < Batch
+    # FOR NAMING CONSISTENCY
+  end
+end

data/lib/table_sync/publishing/params/single.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TableSync::Publishing::Params
+  class Single < Base
+    attr_reader :object, :routing_key, :headers
+
+    def initialize(object:)
+      @object      = object
+      @routing_key = calculated_routing_key
+      @headers     = calculated_headers
+    end
+
+    private
+
+    def object_class
+      object.object_class.name
+    end
+
+    def attributes_for_routing_key
+      object.attributes_for_routing_key
+    end
+
+    def attributes_for_headers
+      object.attributes_for_headers
+    end
+
+    def exchange_name
+      TableSync.exchange_name
+    end
+  end
+end

data/lib/table_sync/publishing/raw.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class TableSync::Publishing::Raw
+  include Tainbox
+
+  attribute :object_class
+  attribute :original_attributes
+
+  attribute :routing_key
+  attribute :headers
+
+  attribute :event, default: :update
+
+  def publish_now
+    message.publish
+  end
+
+  def message
+    TableSync::Publishing::Message::Raw.new(attributes)
+  end
+end

data/lib/table_sync/publishing/single.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class TableSync::Publishing::Single
+  include Tainbox
+  include Memery
+
+  attribute :object_class
+  attribute :original_attributes
+  attribute :debounce_time
+
+  attribute :event, Symbol, default: :update
+
+  # expect job to have perform_at method
+  # debounce destroyed event
+  # because otherwise update event could be sent after destroy
+  def publish_later
+    return if debounce.skip?
+
+    job.perform_at(job_attributes)
+
+    debounce.cache_next_sync_time
+  end
+
+  def publish_now
+    message.publish unless message.empty?
+  end
+
+  memoize def message
+    TableSync::Publishing::Message::Single.new(attributes)
+  end
+
+  memoize def debounce
+    TableSync::Publishing::Helpers::Debounce.new(
+      object_class: object_class,
+      needle: message.object.needle,
+      debounce_time: debounce_time,
+      event: event,
+    )
+  end
+
+  private
+
+  # JOB
+
+  def job
+    if TableSync.single_publishing_job_class_callable
+      TableSync.single_publishing_job_class_callable.call
+    else
+      raise TableSync::NoCallableError.new("single_publishing_job_class")
+    end
+  end
+
+  def job_attributes
+    attributes.merge(
+      original_attributes: serialized_original_attributes,
+      perform_at: debounce.next_sync_time,
+    )
+  end
+
+  def serialized_original_attributes
+    TableSync::Publishing::Helpers::Attributes
+      .new(original_attributes)
+      .serialize
+  end
+end

data/lib/table_sync/publishing.rb

@@ -2,10 +2,25 @@
 
 module TableSync
   module Publishing
-    require_relative "publishing/base_publisher"
-    require_relative "publishing/publisher"
-    require_relative "publishing/batch_publisher"
-    require_relative "publishing/orm_adapter/active_record"
-    require_relative "publishing/orm_adapter/sequel"
+    require_relative "publishing/data/objects"
+    require_relative "publishing/data/raw"
+
+    require_relative "publishing/helpers/attributes"
+    require_relative "publishing/helpers/debounce"
+    require_relative "publishing/helpers/objects"
+
+    require_relative "publishing/params/base"
+    require_relative "publishing/params/batch"
+    require_relative "publishing/params/raw"
+    require_relative "publishing/params/single"
+
+    require_relative "publishing/message/base"
+    require_relative "publishing/message/batch"
+    require_relative "publishing/message/raw"
+    require_relative "publishing/message/single"
+
+    require_relative "publishing/batch"
+    require_relative "publishing/raw"
+    require_relative "publishing/single"
   end
 end

data/lib/table_sync/receiving/config.rb

@@ -4,20 +4,22 @@ module TableSync::Receiving
   class Config
     attr_reader :model, :events
 
-    def initialize(model:, events: AVAILABLE_EVENTS)
+    def initialize(model:, events: TableSync::Event::VALID_RESOLVED_EVENTS)
       @model = model
 
       @events = [events].flatten.map(&:to_sym)
 
-      unless @events.all? { |event| AVAILABLE_EVENTS.include?(event) }
-        raise TableSync::UndefinedEvent.new(events)
-      end
+      raise TableSync::UndefinedEvent.new(events) if invalid_events.any?
 
       self.class.default_values_for_options.each do |ivar, default_value_generator|
         instance_variable_set(ivar, default_value_generator.call(self))
       end
     end
 
+    def invalid_events
+      events - TableSync::Event::VALID_RESOLVED_EVENTS
+    end
+
     class << self
       attr_reader :default_values_for_options
 

data/lib/table_sync/receiving/handler.rb

@@ -44,14 +44,18 @@ class TableSync::Receiving::Handler < Rabbit::EventHandler
     super(Array.wrap(data[:attributes]))
   end
 
-  def event=(name)
-    name = name.to_sym
-    raise TableSync::UndefinedEvent.new(event) unless %i[update destroy].include?(name)
-    super(name)
+  def event=(event_name)
+    event_name = event_name.to_sym
+
+    if event_name.in?(TableSync::Event::VALID_RESOLVED_EVENTS)
+      super(event_name)
+    else
+      raise TableSync::UndefinedEvent.new(event)
+    end
   end
 
-  def model=(name)
-    super(name.to_s)
+  def model=(model_name)
+    super(model_name.to_s)
   end
 
   def configs

data/lib/table_sync/receiving.rb

@@ -2,8 +2,6 @@
 
 module TableSync
   module Receiving
-    AVAILABLE_EVENTS = [:update, :destroy].freeze
-
     require_relative "receiving/config"
     require_relative "receiving/config_decorator"
     require_relative "receiving/dsl"

data/lib/table_sync/setup/active_record.rb

@@ -0,0 +1,22 @@
+# frozen-string_literal: true
+
+module TableSync::Setup
+  class ActiveRecord < Base
+    private
+
+    def define_after_commit(event)
+      options = options_exposed_for_block
+
+      object_class.after_commit(on: event) do
+        if instance_eval(&options[:if]) && !instance_eval(&options[:unless])
+          TableSync::Publishing::Single.new(
+            object_class: self.class.name,
+            original_attributes: attributes,
+            event: event,
+            debounce_time: options[:debounce_time],
+          ).publish_later
+        end
+      end
+    end
+  end
+end