table_sync 1.13.1 → 4.0.0

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

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-class TableSync::ReceivingHandler < Rabbit::EventHandler
-  extend TableSync::DSL
-
-  attribute :event
-  attribute :model
-  attribute :version
-
-  def call
-    raise TableSync::UndefinedConfig.new(model) if configs.blank?
-
-    configs.each do |config|
-      next unless config.allow_event?(event)
-
-      data = processed_data(config)
-      next if data.empty?
-
-      case event
-      when :update
-        config.model.transaction do
-          config.update(data)
-        end
-      when :destroy
-        config.destroy(data.values.first)
-      else
-        raise "Unknown event: #{event}"
-      end
-    end
-  end
-
-  private
-
-  def data=(data)
-    @data = data[:attributes]
-  end
-
-  def event=(name)
-    super(name.to_sym)
-  end
-
-  def model=(name)
-    super(name.to_s)
-  end
-
-  def configs
-    @configs ||= self.class.configs[model]
-                     &.map { |c| ::TableSync::ConfigDecorator.new(c, self) }
-  end
-
-  def processed_data(config)
-    parts = config.partitions&.transform_keys { |k| config.model.class.new(k) } ||
-            { config.model => Array.wrap(data) }
-
-    parts.transform_values! do |data_part|
-      data_part.map do |row|
-        original_row_for_data = row.dup
-        row = row.dup
-
-        config.mapping_overrides.each do |before, after|
-          row[after] = row.delete(before)
-        end
-
-        only = config.only
-        row, missed = row.partition { |key, _| key.in?(only) }.map(&:to_h)
-
-        row.deep_merge!(config.rest_key => missed) if config.rest_key
-        row[config.version_key] = version
-
-        row.merge!(config.additional_data(original_row_for_data))
-
-        row unless config.skip(original_row_for_data)
-      end.compact.presence
-    end.compact
-  end
-end