table_sync 5.1.0 → 6.0

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/version.rb

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

data/lib/table_sync.rb

@@ -8,39 +8,62 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/numeric/time"
 
 module TableSync
+  require_relative "table_sync/event"
   require_relative "table_sync/utils"
   require_relative "table_sync/version"
   require_relative "table_sync/errors"
+
   require_relative "table_sync/instrument"
   require_relative "table_sync/instrument_adapter/active_support"
+
   require_relative "table_sync/naming_resolver/active_record"
   require_relative "table_sync/naming_resolver/sequel"
+
+  require_relative "table_sync/orm_adapter/base"
+  require_relative "table_sync/orm_adapter/active_record"
+  require_relative "table_sync/orm_adapter/sequel"
+
   require_relative "table_sync/receiving"
   require_relative "table_sync/publishing"
 
+  require_relative "table_sync/setup/base"
+  require_relative "table_sync/setup/active_record"
+  require_relative "table_sync/setup/sequel"
+
   class << self
-    attr_accessor :publishing_job_class_callable
+    attr_accessor :raise_on_empty_message
+    attr_accessor :single_publishing_job_class_callable
     attr_accessor :batch_publishing_job_class_callable
     attr_accessor :routing_key_callable
     attr_accessor :exchange_name
-    attr_accessor :routing_metadata_callable
+    attr_accessor :headers_callable
     attr_accessor :notifier
+
     attr_reader :orm
     attr_reader :publishing_adapter
     attr_reader :receiving_model
+    attr_reader :setup
 
-    def sync(klass, **opts)
-      publishing_adapter.setup_sync(klass, opts)
+    def sync(object_class, **options)
+      setup.new(
+        object_class: object_class,
+        on: options[:on],
+        if_condition: options[:if],
+        unless_condition: options[:unless],
+        debounce_time: options[:debounce_time],
+      ).register_callbacks
     end
 
     def orm=(val)
       case val
       when :active_record
-        @publishing_adapter = Publishing::ORMAdapter::ActiveRecord
-        @receiving_model = Receiving::Model::ActiveRecord
+        @publishing_adapter = TableSync::ORMAdapter::ActiveRecord
+        @receiving_model    = Receiving::Model::ActiveRecord
+        @setup              = TableSync::Setup::ActiveRecord
       when :sequel
-        @publishing_adapter = Publishing::ORMAdapter::Sequel
-        @receiving_model = Receiving::Model::Sequel
+        @publishing_adapter = TableSync::ORMAdapter::Sequel
+        @receiving_model    = Receiving::Model::Sequel
+        @setup              = TableSync::Setup::Sequel
       else
         raise ORMNotSupported.new(val.inspect)
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_sync
 version: !ruby/object:Gem::Version
-  version: 5.1.0
+  version: '6.0'
 platform: ruby
 authors:
 - Umbrellio
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-09 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: memery
@@ -271,19 +271,37 @@ files:
 - docs/message_protocol.md
 - docs/notifications.md
 - docs/publishing.md
+- docs/publishing/configuration.md
+- docs/publishing/manual.md
+- docs/publishing/publishers.md
 - docs/receiving.md
 - lib/table_sync.rb
 - lib/table_sync/errors.rb
+- lib/table_sync/event.rb
 - lib/table_sync/instrument.rb
 - lib/table_sync/instrument_adapter/active_support.rb
 - lib/table_sync/naming_resolver/active_record.rb
 - lib/table_sync/naming_resolver/sequel.rb
+- lib/table_sync/orm_adapter/active_record.rb
+- lib/table_sync/orm_adapter/base.rb
+- lib/table_sync/orm_adapter/sequel.rb
 - lib/table_sync/publishing.rb
-- lib/table_sync/publishing/base_publisher.rb
-- lib/table_sync/publishing/batch_publisher.rb
-- lib/table_sync/publishing/orm_adapter/active_record.rb
-- lib/table_sync/publishing/orm_adapter/sequel.rb
-- lib/table_sync/publishing/publisher.rb
+- lib/table_sync/publishing/batch.rb
+- lib/table_sync/publishing/data/objects.rb
+- lib/table_sync/publishing/data/raw.rb
+- lib/table_sync/publishing/helpers/attributes.rb
+- lib/table_sync/publishing/helpers/debounce.rb
+- lib/table_sync/publishing/helpers/objects.rb
+- lib/table_sync/publishing/message/base.rb
+- lib/table_sync/publishing/message/batch.rb
+- lib/table_sync/publishing/message/raw.rb
+- lib/table_sync/publishing/message/single.rb
+- lib/table_sync/publishing/params/base.rb
+- lib/table_sync/publishing/params/batch.rb
+- lib/table_sync/publishing/params/raw.rb
+- lib/table_sync/publishing/params/single.rb
+- lib/table_sync/publishing/raw.rb
+- lib/table_sync/publishing/single.rb
 - lib/table_sync/receiving.rb
 - lib/table_sync/receiving/config.rb
 - lib/table_sync/receiving/config_decorator.rb
@@ -291,6 +309,9 @@ files:
 - lib/table_sync/receiving/handler.rb
 - lib/table_sync/receiving/model/active_record.rb
 - lib/table_sync/receiving/model/sequel.rb
+- lib/table_sync/setup/active_record.rb
+- lib/table_sync/setup/base.rb
+- lib/table_sync/setup/sequel.rb
 - lib/table_sync/utils.rb
 - lib/table_sync/utils/interface_checker.rb
 - lib/table_sync/utils/proc_array.rb

data/lib/table_sync/publishing/base_publisher.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::Publishing::BasePublisher
-  include Memery
-
-  BASE_SAFE_JSON_TYPES = [NilClass, String, TrueClass, FalseClass, Numeric, Symbol].freeze
-  NOT_MAPPED = Object.new
-
-  private
-
-  attr_accessor :object_class
-
-  # @!method job_callable
-  # @!method job_callable_error_message
-  # @!method attrs_for_callables
-  # @!method attrs_for_routing_key
-  # @!method attrs_for_metadata
-  # @!method attributes_for_sync
-
-  memoize def current_time
-    Time.current
-  end
-
-  memoize def primary_keys
-    Array(object_class.primary_key).map(&:to_sym)
-  end
-
-  memoize def attributes_for_sync_defined?
-    object_class.method_defined?(:attributes_for_sync)
-  end
-
-  def resolve_routing_key
-    routing_key_callable.call(object_class.name, attrs_for_routing_key)
-  end
-
-  def metadata
-    TableSync.routing_metadata_callable&.call(object_class.name, attrs_for_metadata)
-  end
-
-  def confirm?
-    @confirm
-  end
-
-  def routing_key_callable
-    return TableSync.routing_key_callable if TableSync.routing_key_callable
-    raise "Can't publish, set TableSync.routing_key_callable"
-  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
-    else
-      filter_safe_for_serialization(value)
-    end
-  end
-
-  def object_mapped?(object)
-    object != NOT_MAPPED
-  end
-
-  def job_class
-    job_callable ? job_callable.call : raise(job_callable_error_message)
-  end
-
-  def publishing_data
-    {
-      model: object_class.try(:table_sync_model_name) || object_class.name,
-      attributes: attributes_for_sync,
-      version: current_time.to_f,
-    }
-  end
-
-  def params
-    params = {
-      event: :table_sync,
-      data: publishing_data,
-      confirm_select: confirm?,
-      routing_key: routing_key,
-      realtime: true,
-      headers: metadata,
-    }
-
-    params[:exchange_name] = TableSync.exchange_name if TableSync.exchange_name
-
-    params
-  end
-end

data/lib/table_sync/publishing/batch_publisher.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::Publishing::BatchPublisher < TableSync::Publishing::BasePublisher
-  def initialize(object_class, original_attributes_array, **options)
-    @original_attributes_array = original_attributes_array.map do |hash|
-      filter_safe_for_serialization(hash.deep_symbolize_keys)
-    end
-
-    @object_class             = object_class.constantize
-    @confirm                  = options[:confirm] || true
-    @routing_key              = options[:routing_key] || resolve_routing_key
-    @push_original_attributes = options[:push_original_attributes] || false
-    @headers                  = options[:headers]
-    @event                    = options[:event] || :update
-  end
-
-  def publish
-    enqueue_job
-  end
-
-  def publish_now
-    return unless need_publish?
-    Rabbit.publish(params)
-
-    model_naming = TableSync.publishing_adapter.model_naming(object_class)
-    TableSync::Instrument.notify table: model_naming.table, schema: model_naming.schema,
-                                 event: event,
-                                 count: publishing_data[:attributes].size, direction: :publish
-  end
-
-  private
-
-  attr_reader :original_attributes_array, :routing_key, :headers, :event
-
-  def push_original_attributes?
-    @push_original_attributes
-  end
-
-  def need_publish?
-    (push_original_attributes? && original_attributes_array.present?) || objects.present?
-  end
-
-  memoize def objects
-    needles.map { |needle| TableSync.publishing_adapter.find(object_class, needle) }.compact
-  end
-
-  def job_callable
-    TableSync.batch_publishing_job_class_callable
-  end
-
-  def job_callable_error_message
-    "Can't publish, set TableSync.batch_publishing_job_class_callable"
-  end
-
-  def attrs_for_callables
-    {}
-  end
-
-  def attrs_for_routing_key
-    {}
-  end
-
-  def attrs_for_metadata
-    {}
-  end
-
-  def params
-    {
-      **super,
-      headers: headers,
-    }
-  end
-
-  def needles
-    original_attributes_array.map { |original_attributes| original_attributes.slice(*primary_keys) }
-  end
-
-  def publishing_data
-    {
-      **super,
-      event: event,
-      metadata: {},
-    }
-  end
-
-  def attributes_for_sync
-    return original_attributes_array if push_original_attributes?
-
-    objects.map do |object|
-      if attributes_for_sync_defined?
-        object.attributes_for_sync
-      else
-        TableSync.publishing_adapter.attributes(object)
-      end
-    end
-  end
-
-  def enqueue_job
-    job_class.perform_later(
-      object_class.name,
-      original_attributes_array,
-      enqueue_additional_options,
-    )
-  end
-
-  def enqueue_additional_options
-    { confirm: confirm?, push_original_attributes: push_original_attributes? }
-  end
-end

data/lib/table_sync/publishing/orm_adapter/active_record.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync::Publishing::ORMAdapter
-  module ActiveRecord
-    module_function
-
-    def model_naming(object)
-      ::TableSync::NamingResolver::ActiveRecord.new(table_name: object.table_name)
-    end
-
-    def find(dataset, conditions)
-      dataset.find_by(conditions)
-    end
-
-    def attributes(object)
-      object.attributes
-    end
-
-    def setup_sync(klass, opts)
-      debounce_time = opts.delete(:debounce_time)
-
-      klass.instance_exec do
-        { create: :created, update: :updated, destroy: :destroyed }.each do |event, state|
-          after_commit(on: event, **opts) do
-            TableSync::Publishing::Publisher.new(self.class.name, attributes,
-                                                 state: state, debounce_time: debounce_time).publish
-          end
-        end
-      end
-    end
-  end
-end

data/lib/table_sync/publishing/orm_adapter/sequel.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync::Publishing::ORMAdapter
-  module Sequel
-    module_function
-
-    def model_naming(object)
-      ::TableSync::NamingResolver::Sequel.new(table_name: object.table_name, db: object.db)
-    end
-
-    def find(dataset, conditions)
-      dataset.find(conditions)
-    end
-
-    def attributes(object)
-      object.values
-    end
-
-    def setup_sync(klass, opts)
-      if_predicate     = to_predicate(opts.delete(:if), true)
-      unless_predicate = to_predicate(opts.delete(:unless), false)
-      debounce_time    = opts.delete(:debounce_time)
-
-      if opts.any?
-        raise "Only :if, :skip_debounce and :unless options are currently " \
-              "supported for Sequel hooks"
-      end
-
-      register_callbacks(klass, if_predicate, unless_predicate, debounce_time)
-    end
-
-    def to_predicate(val, default)
-      return val.to_proc if val.respond_to?(:to_proc)
-
-      -> (*) { default }
-    end
-
-    def register_callbacks(klass, if_predicate, unless_predicate, debounce_time)
-      { create: :created, update: :updated, destroy: :destroyed }.each do |event, state|
-        klass.send(:define_method, :"after_#{event}") do
-          if instance_eval(&if_predicate) && !instance_eval(&unless_predicate)
-            db.after_commit do
-              TableSync::Publishing::Publisher.new(
-                self.class.name,
-                values,
-                state: state,
-                debounce_time: debounce_time,
-              ).publish
-            end
-          end
-
-          super()
-        end
-      end
-    end
-  end
-end

data/lib/table_sync/publishing/publisher.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::Publishing::Publisher < TableSync::Publishing::BasePublisher
-  DEBOUNCE_TIME = 1.minute
-
-  # 'original_attributes' are not published, they are used to resolve the routing key
-  def initialize(object_class, original_attributes, **opts)
-    @object_class = object_class.constantize
-    @original_attributes = filter_safe_for_serialization(original_attributes.deep_symbolize_keys)
-    @confirm = opts.fetch(:confirm, true)
-    @debounce_time = opts[:debounce_time]&.seconds || DEBOUNCE_TIME
-    @state = opts.fetch(:state, :updated).to_sym
-    validate_state
-  end
-
-  def publish
-    return enqueue_job if destroyed? || debounce_time.zero?
-
-    sync_time = Rails.cache.read(cache_key) || current_time - debounce_time - 1.second
-    return if sync_time > current_time
-
-    next_sync_time = sync_time + debounce_time
-    next_sync_time <= current_time ? enqueue_job : enqueue_job(next_sync_time)
-  end
-
-  def publish_now
-    # Update request and object does not exist -> skip publishing
-    return if !object && !destroyed?
-
-    Rabbit.publish(params)
-    model_naming = TableSync.publishing_adapter.model_naming(object_class)
-    TableSync::Instrument.notify table: model_naming.table, schema: model_naming.schema,
-                                 event: event, direction: :publish
-  end
-
-  private
-
-  attr_reader :original_attributes
-  attr_reader :state
-  attr_reader :debounce_time
-
-  def attrs_for_callables
-    attributes_for_sync
-  end
-
-  def attrs_for_routing_key
-    if object.respond_to?(:attrs_for_routing_key)
-      object.attrs_for_routing_key
-    else
-      attrs_for_callables
-    end
-  end
-
-  def attrs_for_metadata
-    if object.respond_to?(:attrs_for_metadata)
-      object.attrs_for_metadata
-    else
-      attrs_for_callables
-    end
-  end
-
-  def job_callable
-    TableSync.publishing_job_class_callable
-  end
-
-  def job_callable_error_message
-    "Can't publish, set TableSync.publishing_job_class_callable"
-  end
-
-  def enqueue_job(perform_at = current_time)
-    job = job_class.set(wait_until: perform_at)
-    job.perform_later(object_class.name, original_attributes, state: state.to_s, confirm: confirm?)
-    Rails.cache.write(cache_key, perform_at)
-  end
-
-  def routing_key
-    resolve_routing_key
-  end
-
-  def publishing_data
-    {
-      **super,
-      event: event,
-      metadata: { created: created? },
-    }
-  end
-
-  memoize def attributes_for_sync
-    if destroyed?
-      if object_class.respond_to?(:table_sync_destroy_attributes)
-        object_class.table_sync_destroy_attributes(original_attributes)
-      else
-        original_attributes
-      end
-    elsif attributes_for_sync_defined?
-      object.attributes_for_sync
-    else
-      TableSync.publishing_adapter.attributes(object)
-    end
-  end
-
-  memoize def object
-    TableSync.publishing_adapter.find(object_class, needle)
-  end
-
-  def event
-    destroyed? ? :destroy : :update
-  end
-
-  def needle
-    original_attributes.slice(*primary_keys)
-  end
-
-  def cache_key
-    "#{object_class}/#{needle}_table_sync_time".delete(" ")
-  end
-
-  def destroyed?
-    state == :destroyed
-  end
-
-  def created?
-    state == :created
-  end
-
-  def validate_state
-    raise "Unknown state: #{state.inspect}" unless %i[created updated destroyed].include?(state)
-  end
-end