table_sync 4.2.1 → 6.0

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

@@ -31,7 +31,7 @@ class TableSync::Receiving::Handler < Rabbit::EventHandler
         params[:default_values] = config.default_values(data: data)
       end
 
-      config.wrap_receiving(**params) do
+      config.wrap_receiving(event: event, **params) do
         perform(config, params)
       end
     end
@@ -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
@@ -82,7 +86,7 @@ class TableSync::Receiving::Handler < Rabbit::EventHandler
         row[after] = row.delete(before)
       end
 
-      config.except(row: row).each(&row.method(:delete))
+      config.except(row: row).each { |x| row.delete(x) }
 
       row.merge!(config.additional_data(row: row))
 
@@ -98,7 +102,8 @@ class TableSync::Receiving::Handler < Rabbit::EventHandler
 
   def validate_data(data, target_keys:)
     data.each do |row|
-      next if target_keys.all?(&row.keys.method(:include?))
+      next if target_keys.all? { |x| row.key?(x) }
+
       raise TableSync::DataError.new(
         data, target_keys, "Some target keys not found in received attributes!"
       )
@@ -107,6 +112,17 @@ class TableSync::Receiving::Handler < Rabbit::EventHandler
     if data.uniq { |row| row.slice(*target_keys) }.size != data.size
       raise TableSync::DataError.new(data, target_keys, "Duplicate rows found!")
     end
+
+    keys_sample = data[0].keys
+    keys_diff = data.each_with_object(Set.new) do |row, set|
+      (row.keys - keys_sample | keys_sample - row.keys).each { |x| set.add(x) }
+    end
+
+    unless keys_diff.empty?
+      raise TableSync::DataError.new(data, target_keys, <<~MESSAGE)
+        Bad batch structure, check keys: #{keys_diff.to_a}
+      MESSAGE
+    end
   end
 
   def perform(config, params)

data/lib/table_sync/receiving/model/active_record.rb

@@ -96,7 +96,7 @@ module TableSync::Receiving::Model
         end
       end
 
-      result = query.destroy_all.map(&method(:row_to_hash))
+      result = query.destroy_all.map { |x| row_to_hash(x) }
 
       if result.size > data.size
         raise TableSync::DestroyError.new(data: data, target_keys: target_keys, result: result)

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

data/lib/table_sync/setup/base.rb

@@ -0,0 +1,67 @@
+# frozen-string_literal: true
+
+module TableSync::Setup
+  class Base
+    include Tainbox
+
+    EVENTS            = %i[create update destroy].freeze
+    INVALID_EVENT     = Class.new(StandardError)
+    INVALID_CONDITION = Class.new(StandardError)
+
+    attribute :object_class
+    attribute :debounce_time
+    attribute :on
+    attribute :if_condition
+    attribute :unless_condition
+
+    def initialize(attrs)
+      super(attrs)
+
+      self.on = Array.wrap(on).map(&:to_sym)
+
+      self.if_condition     ||= proc { true }
+      self.unless_condition ||= proc { false }
+
+      raise INVALID_EVENTS    unless valid_events?
+      raise INVALID_CONDITION unless valid_conditions?
+    end
+
+    def register_callbacks
+      applicable_events.each { |event| define_after_commit(event) }
+    end
+
+    private
+
+    # VALIDATION
+
+    def valid_events?
+      on.all? { |event| event.in?(EVENTS) }
+    end
+
+    def valid_conditions?
+      if_condition.is_a?(Proc) && unless_condition.is_a?(Proc)
+    end
+
+    # EVENTS
+
+    def applicable_events
+      on.presence || EVENTS
+    end
+
+    # CREATING HOOKS
+
+    # :nocov:
+    def define_after_commit(event)
+      raise NotImplementedError
+    end
+    # :nocov:
+
+    def options_exposed_for_block
+      {
+        if: if_condition,
+        unless: unless_condition,
+        debounce_time: debounce_time,
+      }
+    end
+  end
+end

data/lib/table_sync/setup/sequel.rb

@@ -0,0 +1,26 @@
+# frozen-string_literal: true
+
+module TableSync::Setup
+  class Sequel < Base
+    private
+
+    def define_after_commit(event)
+      options = options_exposed_for_block
+
+      object_class.define_method("after_#{event}".to_sym) do
+        if instance_eval(&options[:if]) && !instance_eval(&options[:unless])
+          db.after_commit do
+            TableSync::Publishing::Single.new(
+              object_class: self.class.name,
+              original_attributes: values,
+              event: event,
+              debounce_time: options[:debounce_time],
+            ).publish_later
+          end
+        end
+
+        super()
+      end
+    end
+  end
+end

data/lib/table_sync/utils/interface_checker.rb

@@ -54,8 +54,8 @@ class TableSync::Utils::InterfaceChecker
   end
 
   def filter(parameters)
-    # for req and block parameters types we can ignore names
-    parameters.map { |param| %i[req block].include?(param.first) ? [param.first] : param }
+    ignored_keys = %i[req block] # for req and block parameters types we can ignore names
+    parameters.map { |param| ignored_keys.include?(param.first) ? [param.first] : param }
   end
 end
 

data/lib/table_sync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TableSync
-  VERSION = "4.2.1"
+  VERSION = "6.0"
 end