table_sync 2.3.0 → 4.0.0

data/lib/table_sync/{model → receiving/model}/active_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module TableSync::Model
+module TableSync::Receiving::Model
   class ActiveRecord
     class AfterCommitWrap
       def initialize(&block)
@@ -52,27 +52,29 @@ module TableSync::Model
       SQL
     end
 
-    def upsert(data:, target_keys:, version_key:, first_sync_time_key:, default_values:)
-      data = Array.wrap(data)
+    def upsert(data:, target_keys:, version_key:, default_values:)
+      result = data.map do |datum|
+        conditions = datum.select { |k| target_keys.include?(k) }
 
-      result = transaction do
-        data.map do |datum|
-          conditions = datum.select { |k| target_keys.include?(k) }
+        row = raw_model.lock("FOR NO KEY UPDATE").where(conditions)
 
-          row = raw_model.lock("FOR NO KEY UPDATE").find_by(conditions)
-          if row
-            next if datum[version_key] <= row[version_key]
+        if row.to_a.size > 1
+          raise TableSync::UpsertError.new(data: datum, target_keys: target_keys, result: row)
+        end
 
-            row.update!(datum)
-          else
-            create_data = default_values.merge(datum)
-            create_data[first_sync_time_key] = Time.current if first_sync_time_key
-            row = raw_model.create!(create_data)
-          end
+        row = row.first
 
-          row_to_hash(row)
-        end.compact
-      end
+        if row
+          next if datum[version_key] <= row[version_key]
+
+          row.update!(datum)
+        else
+          create_data = default_values.merge(datum)
+          row = raw_model.create!(create_data)
+        end
+
+        row_to_hash(row)
+      end.compact
 
       TableSync::Instrument.notify(table: model_naming.table, schema: model_naming.schema,
                                    event: :update, count: result.count, direction: :receive)
@@ -80,10 +82,22 @@ module TableSync::Model
       result
     end
 
-    def destroy(data)
-      result = transaction do
-        row = raw_model.lock("FOR UPDATE").find_by(data)&.destroy!
-        [row_to_hash(row)]
+    def destroy(data:, target_keys:, version_key:)
+      sanitized_data = data.map { |attr| attr.select { |key, _value| target_keys.include?(key) } }
+
+      query = nil
+      sanitized_data.each_with_index do |row, index|
+        if index == 0
+          query = raw_model.lock("FOR UPDATE").where(row)
+        else
+          query = query.or(raw_model.lock("FOR UPDATE").where(row))
+        end
+      end
+
+      result = query.destroy_all.map(&method(:row_to_hash))
+
+      if result.size > data.size
+        raise TableSync::DestroyError.new(data: data, target_keys: target_keys, result: result)
       end
 
       TableSync::Instrument.notify(

data/lib/table_sync/{model → receiving/model}/sequel.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module TableSync::Model
+module TableSync::Receiving::Model
   class Sequel
     def initialize(table_name)
       @raw_model = Class.new(::Sequel::Model(table_name)).tap(&:unrestrict_primary_key)
@@ -14,8 +14,7 @@ module TableSync::Model
       [raw_model.primary_key].flatten
     end
 
-    def upsert(data:, target_keys:, version_key:, first_sync_time_key:, default_values:)
-      data = Array.wrap(data)
+    def upsert(data:, target_keys:, version_key:, default_values:)
       qualified_version = ::Sequel.qualify(table_name, version_key)
       version_condition = ::Sequel.function(:coalesce, qualified_version, 0) <
                           ::Sequel.qualify(:excluded, version_key)
@@ -24,9 +23,6 @@ module TableSync::Model
       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(
@@ -38,14 +34,23 @@ module TableSync::Model
 
       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
+    def destroy(data:, target_keys:, version_key:)
+      sanitized_data = data.map { |attr| attr.select { |key, _value| target_keys.include?(key) } }
+      sanitized_data = type_cast(sanitized_data)
+      result = dataset.returning.where(::Sequel.|(*sanitized_data)).delete
+
+      if result.size > data.size
+        raise TableSync::DestroyError.new(data: data, target_keys: target_keys, result: result)
+      end
+
       TableSync::Instrument.notify table: model_naming.table, schema: model_naming.schema,
                                    count: result.count,
                                    event: :destroy, direction: :receive
+
       result
     end
 

data/lib/table_sync/utils.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module TableSync
+  module Utils
+    require_relative "utils/proc_array"
+    require_relative "utils/proc_keywords_resolver"
+    require_relative "utils/interface_checker"
+  end
+end

data/lib/table_sync/utils/interface_checker.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# Ruby does not support interfaces, and there is no way to implement them.
+# Interfaces check a methods of a class after the initialization of the class is complete.
+# But in Ruby, the initialization of a class cannot be completed.
+# In execution time we can open any class and add some methods (monkey patching).
+# Ruby has `define_method`, singleton methods, etc.
+#
+# Duck typing is a necessary measure, the only one available in the Ruby architecture.
+#
+# Interfaces can be implemented in particular cases with tests for example.
+# But this is not suitable for gems that are used by third-party code.
+#
+# So, we still want to check interfaces and have a nice error messages,
+# even if it will be duck typing.
+#
+# Next code do this.
+
+class TableSync::Utils::InterfaceChecker
+  INTERFACES = SelfData.load
+
+  attr_reader :object
+
+  def initialize(object)
+    @object = object
+  end
+
+  def implements(interface_name)
+    INTERFACES[interface_name].each do |method_name, options|
+      unless object.respond_to?(method_name)
+        raise_error(method_name, options)
+      end
+
+      unless include?(object.method(method_name).parameters, options[:parameters])
+        raise_error(method_name, options)
+      end
+    end
+    self
+  end
+
+  private
+
+  def include?(checked, expected)
+    (filter(expected) - filter(checked)).empty?
+  end
+
+  def raise_error(method_name, options)
+    raise TableSync::InterfaceError.new(
+      object,
+      method_name,
+      options[:parameters],
+      options[:description],
+    )
+  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 }
+  end
+end
+
+__END__
+:receiving_model:
+  :upsert:
+    :parameters:
+      - - :keyreq
+        - :data
+      - - :keyreq
+        - :target_keys
+      - - :keyreq
+        - :version_key
+      - - :keyreq
+        - :default_values
+    :description: "returns an array with updated rows"
+  :columns:
+    :parameters: []
+    :description: "returns all table columns"
+  :destroy:
+    :parameters:
+      - - :keyreq
+        - :data
+      - - :keyreq
+        - :target_keys
+    :description: "returns an array with destroyed rows"
+  :transaction:
+    :parameters:
+      - - :block
+        - :block
+    :description: "implements the database transaction"
+  :after_commit:
+    :parameters:
+      - - :block
+        - :block
+    :description: "executes the block after committing the transaction"
+  :primary_keys:
+    :parameters: []
+    :description: "returns an array with the primary_keys"

data/lib/table_sync/utils/proc_array.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class TableSync::Utils::ProcArray < Proc
+  def initialize(&block)
+    @array = []
+    super(&block)
+  end
+
+  def push(&block)
+    @array.push(block)
+    self
+  end
+
+  def call(*args, &block)
+    super(@array, args, &block)
+  end
+end

data/lib/table_sync/utils/proc_keywords_resolver.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Problem:
+#
+# > fn = proc { |first| puts first  }
+# > fn.call(:first, :second, :third)
+# first
+#
+# :second and :third was ignored. It's ok.
+#
+# > fn = proc { puts "test"  }
+# > fn.call(first: :first, second: :second, third: :third)
+# test
+#
+# And it's ok.
+#
+# > fn = proc { |&block| block.call }
+# > fn.call(first: :first, second: :second, third: :third) { puts "test" }
+# test
+#
+# And this is ok too.
+#
+# > fn = proc { |first:| puts first  }
+# > fn.call(first: :first, second: :second, third: :third)
+# ArgumentError (unknown keywords: :second, :third)
+#
+# ¯\_(ツ)_/¯
+#
+# ❤ Ruby ❤
+#
+# Next code solve this problem for procs without word arguments,
+# only keywords and block.
+
+module TableSync::Utils
+  module_function
+
+  def proc_keywords_resolver(&proc_for_wrap)
+    available_keywords = proc_for_wrap.parameters
+      .select { |type, _name| type == :keyreq }
+      .map { |_type, name| name }
+
+    proc do |keywords = {}, &block|
+      proc_for_wrap.call(**keywords.slice(*available_keywords), &block)
+    end
+  end
+end

data/lib/table_sync/version.rb

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

data/table_sync.gemspec

@@ -29,10 +29,11 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "memery"
   spec.add_runtime_dependency "rabbit_messaging", "~> 0.3"
   spec.add_runtime_dependency "rails"
+  spec.add_runtime_dependency "self_data"
 
   spec.add_development_dependency "coveralls", "~> 0.8"
   spec.add_development_dependency "rspec", "~> 3.8"
-  spec.add_development_dependency "rubocop-config-umbrellio", "~> 0.81"
+  spec.add_development_dependency "rubocop-config-umbrellio"
   spec.add_development_dependency "simplecov", "~> 0.16"
 
   spec.add_development_dependency "activejob", ">= 6.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: table_sync
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Umbrellio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-22 00:00:00.000000000 Z
+date: 2020-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: memery
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: self_data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -84,16 +98,16 @@ dependencies:
   name: rubocop-config-umbrellio
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.81'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.81'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -254,35 +268,33 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- docs/development.md
-- docs/synopsis.md
+- docs/message_protocol.md
+- docs/notifications.md
+- docs/publishing.md
+- docs/receiving.md
 - lib/table_sync.rb
-- lib/table_sync/base_publisher.rb
-- lib/table_sync/batch_publisher.rb
-- lib/table_sync/config.rb
-- lib/table_sync/config/callback_registry.rb
-- lib/table_sync/config_decorator.rb
-- lib/table_sync/dsl.rb
 - lib/table_sync/errors.rb
-- lib/table_sync/event_actions.rb
-- lib/table_sync/event_actions/data_wrapper.rb
-- lib/table_sync/event_actions/data_wrapper/base.rb
-- lib/table_sync/event_actions/data_wrapper/destroy.rb
-- lib/table_sync/event_actions/data_wrapper/update.rb
 - lib/table_sync/instrument.rb
 - lib/table_sync/instrument_adapter/active_support.rb
-- lib/table_sync/model/active_record.rb
-- lib/table_sync/model/sequel.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/sequel.rb
-- lib/table_sync/plugins.rb
-- lib/table_sync/plugins/abstract.rb
-- lib/table_sync/plugins/access_mixin.rb
-- lib/table_sync/plugins/registry.rb
-- lib/table_sync/publisher.rb
-- lib/table_sync/receiving_handler.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/receiving.rb
+- lib/table_sync/receiving/config.rb
+- lib/table_sync/receiving/config_decorator.rb
+- lib/table_sync/receiving/dsl.rb
+- lib/table_sync/receiving/handler.rb
+- lib/table_sync/receiving/model/active_record.rb
+- lib/table_sync/receiving/model/sequel.rb
+- lib/table_sync/utils.rb
+- lib/table_sync/utils/interface_checker.rb
+- lib/table_sync/utils/proc_array.rb
+- lib/table_sync/utils/proc_keywords_resolver.rb
 - lib/table_sync/version.rb
 - log/.keep
 - table_sync.gemspec
@@ -305,7 +317,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.0.rc.1
 signing_key: 
 specification_version: 4
 summary: DB Table synchronization between microservices based on Model's event system