table_sync 2.1.0 → 4.1.1

data/lib/table_sync/config.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync
-  class Config
-    attr_reader :model, :events, :callback_registry
-
-    def initialize(model:, events: nil)
-      @model = model
-      @events = events.nil? ? nil : [events].flatten.map(&:to_sym)
-
-      @callback_registry = CallbackRegistry.new
-
-      # initialize default options
-      only(model.columns)
-      mapping_overrides({})
-      additional_data({})
-      default_values({})
-      @rest_key = :rest
-      @version_key = :version
-      @first_sync_time_key = nil
-      @on_destroy = nil
-      @wrap_receiving = nil
-      target_keys(model.primary_keys)
-    end
-
-    # add_option implements the following logic
-    # config.option - get value
-    # config.option(args) - set static value
-    # config.option { ... } - set proc as value
-    def self.add_option(name, &option_block)
-      ivar = "@#{name}".to_sym
-
-      # default option handler (empty handler)
-      # handles values when setting options
-      option_block ||= proc { |value| value }
-
-      define_method(name) do |*args, &block|
-        # logic for each option
-        if args.empty? && block.nil? # case for config.option, just return ivar
-          instance_variable_get(ivar)
-        elsif block # case for config.option { ... }
-          # get named parameters (parameters with :keyreq) from proc-value
-          params = block.parameters.map { |param| param[0] == :keyreq ? param[1] : nil }.compact
-
-          # wrapper for proc-value, this wrapper receives all params (model, version, project_id...)
-          # and filters them for proc-value
-          unified_block = proc { |hash = {}| block.call(hash.slice(*params)) }
-
-          # set wrapped proc-value as ivar value
-          instance_variable_set(ivar, unified_block)
-        else # case for config.option(args)
-          # call option_block with args as params and set ivar to result
-          instance_variable_set(ivar, instance_exec(*args, &option_block))
-        end
-      end
-    end
-
-    def allow_event?(name)
-      return true if events.nil?
-      events.include?(name)
-    end
-
-    def before_commit(on:, &block)
-      callback_registry.register_callback(block, kind: :before_commit, event: on.to_sym)
-    end
-
-    def after_commit(on:, &block)
-      callback_registry.register_callback(block, kind: :after_commit, event: on.to_sym)
-    end
-
-    def on_destroy(&block)
-      block_given? ? @on_destroy = block : @on_destroy
-    end
-
-    def wrap_receiving(&block)
-      block_given? ? @wrap_receiving = block : @wrap_receiving
-    end
-
-    check_and_set_column_key = proc do |key|
-      key = key.to_sym
-      raise "#{model.inspect} doesn't have key: #{key}" unless model.columns.include?(key)
-      key
-    end
-
-    set_column_keys = proc do |*keys|
-      [keys].flatten.map { |k| instance_exec(k, &check_and_set_column_key) }
-    end
-
-    add_option(:only, &set_column_keys)
-    add_option(:target_keys, &set_column_keys)
-    add_option(:rest_key) do |value|
-      value ? instance_exec(value, &check_and_set_column_key) : nil
-    end
-    add_option(:version_key, &check_and_set_column_key)
-    add_option(:first_sync_time_key) do |value|
-      value ? instance_exec(value, &check_and_set_column_key) : nil
-    end
-
-    add_option(:mapping_overrides)
-    add_option(:additional_data)
-    add_option(:default_values)
-    add_option(:partitions)
-    add_option(:skip)
-  end
-end

data/lib/table_sync/config/callback_registry.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::Config::CallbackRegistry
-  CALLBACK_KINDS = %i[after_commit before_commit].freeze
-  EVENTS = %i[create update destroy].freeze
-
-  InvalidCallbackKindError = Class.new(ArgumentError)
-  InvalidEventError = Class.new(ArgumentError)
-
-  def initialize
-    @callbacks = CALLBACK_KINDS.map { |event| [event, make_event_hash] }.to_h
-  end
-
-  def register_callback(callback, kind:, event:)
-    validate_callback_kind!(kind)
-    validate_event!(event)
-
-    callbacks.fetch(kind)[event] << callback
-  end
-
-  def get_callbacks(kind:, event:)
-    validate_callback_kind!(kind)
-    validate_event!(event)
-
-    callbacks.fetch(kind).fetch(event, [])
-  end
-
-  private
-
-  attr_reader :callbacks
-
-  def make_event_hash
-    Hash.new { |hsh, key| hsh[key] = [] }
-  end
-
-  def validate_callback_kind!(kind)
-    unless CALLBACK_KINDS.include?(kind)
-      raise(
-        InvalidCallbackKindError,
-        "Invalid callback kind: #{kind.inspect}. Valid kinds are #{CALLBACK_KINDS.inspect}",
-      )
-    end
-  end
-
-  def validate_event!(event)
-    unless EVENTS.include?(event)
-      raise(
-        InvalidEventError,
-        "Invalid event: #{event.inspect}. Valid events are #{EVENTS.inspect}",
-      )
-    end
-  end
-end

data/lib/table_sync/config_decorator.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync
-  # rubocop:disable Style/MissingRespondToMissing, Style/MethodMissingSuper
-  class ConfigDecorator
-    include ::TableSync::EventActions
-    extend Forwardable
-
-    def_delegators :@config, :on_destroy, :wrap_receiving
-
-    def initialize(config, handler)
-      @config = config
-      @handler = handler
-    end
-
-    def method_missing(name, *args)
-      value = @config.send(name)
-
-      if value.is_a?(Proc)
-        value.call(
-          event: @handler.event,
-          model: @handler.model,
-          version: @handler.version,
-          project_id: @handler.project_id,
-          data: @handler.data,
-          current_row: args.first,
-        )
-      else
-        value
-      end
-    end
-
-    def allow_event?(event)
-      @config.allow_event?(event)
-    end
-  end
-  # rubocop:enable Style/MissingRespondToMissing, Style/MethodMissingSuper
-end

data/lib/table_sync/dsl.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync
-  module DSL
-    def inherited(klass)
-      klass.instance_variable_set(:@configs, configs.deep_dup)
-      super
-    end
-
-    def configs
-      @configs ||= Hash.new { |hash, key| hash[key] = [] }
-    end
-
-    def receive(source, to_table:, events: nil, &block)
-      config = ::TableSync::Config.new(
-        model: TableSync.orm.model.new(to_table),
-        events: events,
-      )
-
-      config.instance_exec(&block) if block
-
-      configs[source.to_s] << config
-    end
-  end
-end

data/lib/table_sync/event_actions.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync
-  module EventActions
-    def update(data)
-      data.each_value do |attribute_set|
-        attribute_set.each do |attributes|
-          prevent_incomplete_event!(attributes)
-        end
-      end
-
-      with_wrapping(DataWrapper::Update.new(data)) do
-        process_upsert(data)
-      end
-    end
-
-    def destroy(data)
-      attributes = data.first || {}
-      target_attributes = attributes.select { |key, _value| target_keys.include?(key) }
-      prevent_incomplete_event!(target_attributes)
-
-      with_wrapping(DataWrapper::Destroy.new(attributes)) do
-        process_destroy(attributes, target_attributes)
-      end
-    end
-
-    def process_upsert(data) # rubocop:disable Metrics/MethodLength
-      model.transaction do
-        args = {
-          data: data,
-          target_keys: target_keys,
-          version_key: version_key,
-          first_sync_time_key: first_sync_time_key,
-          default_values: default_values,
-        }
-
-        @config.callback_registry.get_callbacks(kind: :before_commit, event: :update).each do |cb|
-          cb[data.values.flatten]
-        end
-
-        results = data.reduce([]) do |upserts, (part_model, part_data)|
-          upserts + part_model.upsert(**args, data: part_data)
-        end
-
-        return if results.empty?
-        raise TableSync::UpsertError.new(**args) unless expected_update_result?(results)
-
-        @config.model.after_commit do
-          @config.callback_registry.get_callbacks(kind: :after_commit, event: :update).each do |cb|
-            cb[results]
-          end
-        end
-      end
-    end
-
-    def process_destroy(attributes, target_attributes)
-      model.transaction do
-        @config.callback_registry.get_callbacks(kind: :before_commit, event: :destroy).each do |cb|
-          cb[attributes]
-        end
-
-        if on_destroy
-          results = on_destroy.call(attributes: attributes, target_keys: target_keys)
-        else
-          results = model.destroy(target_attributes)
-          return if results.empty?
-          raise TableSync::DestroyError.new(target_attributes) if results.size != 1
-        end
-
-        @config.model.after_commit do
-          @config.callback_registry.get_callbacks(kind: :after_commit, event: :destroy).each do |cb|
-            cb[results]
-          end
-        end
-      end
-    end
-
-    def with_wrapping(data = {}, &block)
-      if @config.wrap_receiving
-        @config.wrap_receiving.call(data, block)
-      else
-        yield
-      end
-    end
-
-    def expected_update_result?(query_results)
-      query_results.uniq { |d| d.slice(*target_keys) }.size == query_results.size
-    end
-
-    def prevent_incomplete_event!(attributes)
-      unless target_keys.all?(&attributes.keys.method(:include?))
-        raise TableSync::UnprovidedEventTargetKeysError.new(target_keys, attributes)
-      end
-    end
-  end
-end

data/lib/table_sync/event_actions/data_wrapper.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync::EventActions::DataWrapper
-  require_relative "data_wrapper/base"
-  require_relative "data_wrapper/destroy"
-  require_relative "data_wrapper/update"
-end

data/lib/table_sync/event_actions/data_wrapper/base.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::EventActions::DataWrapper::Base
-  include Enumerable
-
-  attr_reader :event_data
-
-  def initialize(event_data)
-    @event_data = event_data
-  end
-
-  def type
-    raise NoMethodError # NOTE: for clarity
-  end
-
-  def destroy?
-    false
-  end
-
-  def update?
-    false
-  end
-end

data/lib/table_sync/event_actions/data_wrapper/destroy.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::EventActions::DataWrapper::Destroy < TableSync::EventActions::DataWrapper::Base
-  def type
-    :destroy
-  end
-
-  def each
-    yield(event_data)
-  end
-
-  def destroy?
-    true
-  end
-
-  def update?
-    false
-  end
-end

data/lib/table_sync/event_actions/data_wrapper/update.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::EventActions::DataWrapper::Update < TableSync::EventActions::DataWrapper::Base
-  def type
-    :update
-  end
-
-  def each
-    event_data.each_pair do |model_klass, changed_models_attrs|
-      yield([model_klass, changed_models_attrs])
-    end
-  end
-
-  def destroy?
-    false
-  end
-
-  def update?
-    true
-  end
-end

data/lib/table_sync/model/sequel.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-module TableSync::Model
-  class Sequel
-    def initialize(table_name)
-      @raw_model = Class.new(::Sequel::Model(table_name)).tap(&:unrestrict_primary_key)
-    end
-
-    def columns
-      dataset.columns
-    end
-
-    def primary_keys
-      [raw_model.primary_key].flatten
-    end
-
-    def upsert(data:, target_keys:, version_key:, first_sync_time_key:, default_values:)
-      data = Array.wrap(data)
-      qualified_version = ::Sequel.qualify(table_name, version_key)
-      version_condition = ::Sequel.function(:coalesce, qualified_version, 0) <
-                          ::Sequel.qualify(:excluded, version_key)
-
-      upd_spec = update_spec(data.first.keys - target_keys)
-      data.map! { |d| default_values.merge(d) }
-
-      insert_data = type_cast(data)
-      if first_sync_time_key
-        insert_data.each { |datum| datum[first_sync_time_key] = Time.current }
-      end
-
-      result = dataset.returning
-                      .insert_conflict(
-                        target: target_keys,
-                        update: upd_spec,
-                        update_where: version_condition,
-                      )
-                      .multi_insert(insert_data)
-
-      TableSync::Instrument.notify table: model_naming.table, schema: model_naming.schema,
-                                   count: result.count, event: :update, direction: :receive
-      result
-    end
-
-    def destroy(data)
-      result = dataset.returning.where(data).delete
-      TableSync::Instrument.notify table: model_naming.table, schema: model_naming.schema,
-                                   count: result.count,
-                                   event: :destroy, direction: :receive
-      result
-    end
-
-    def transaction(&block)
-      db.transaction(&block)
-    end
-
-    def after_commit(&block)
-      db.after_commit(&block)
-    end
-
-    private
-
-    attr_reader :raw_model
-
-    def table_name
-      raw_model.table_name
-    end
-
-    def model_naming
-      ::TableSync::NamingResolver::Sequel.new(table_name: table_name, db: db)
-    end
-
-    def dataset
-      raw_model.dataset
-    end
-
-    def db
-      dataset.db
-    end
-
-    def type_cast(data)
-      data.map { |d| raw_model.new(d).values.keep_if { |k| d.key?(k) } }
-    end
-
-    def update_spec(keys)
-      keys.map { |key| [key, ::Sequel[:excluded][key]] }.to_h
-    end
-  end
-end