luna_park 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41e8a50e90bb5016f430dc2073ffa3875f70d87f9202487623196feb7954c630
-  data.tar.gz: fb1bb8ce6e7d840bccc7b0ea15b9c88a54c93a2acbdf4d76c482de05a5063c8c
+  metadata.gz: 3491b1852cab029d5f1b60cdc9ff638e2eac71a1d366e1463e31b7c6a4afa127
+  data.tar.gz: f0b5abc0af74a11ac5d6e392def3daa5e565ac7ba5033315981013dae3f0734a
 SHA512:
-  metadata.gz: '075301879b59ac53b9881a398715ac4ea1b071b5c581fdb1046ca57f7ddea9450360ddd57fac674c2c1fc9b28838ad55cfd0dcab494e380b4b94188e2acba879'
-  data.tar.gz: 7bf3b42b59dbed4b81e77f23a9f51a4bcca4699f98310a9bdb2d5a8b5385f50862f2f215be780832104fa983df3c1851c8165f4353fd9718d26b06b34dc87325
+  metadata.gz: 25f821e41e63fcb3bfcc8744ea203b861360126cc7edc12f5032e7153831a514e527ef80e8453fc5b8f24e5bf5f458c88226f1103ab8bcf85249222d4c7355b5
+  data.tar.gz: 903dd8923a134ea14d8f3611e3c803989f976f923e5b251cc65e47bef6cecc923173ae6654f2361ac2cc49190231d7d24c427d4144720abdbd9d0368b5ae386b

data/.rubocop.yml

@@ -50,7 +50,7 @@ Style/Documentation:
   Enabled: false
 
 Naming/MethodParameterName:
-  AllowedNames: io, id, to, by, on, in, at, ip, db, pk, fk
+  AllowedNames: io, id, to, by, on, in, at, ip, db, pk, fk, ds
 
 # TODO: поговорить с Филиппом про attr
 Layout/EmptyLinesAroundAttributeAccessor:

data/CHANGELOG.md

@@ -4,13 +4,36 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.12.0] - 2023-02-23
+## [0.13.0] - 2023-06-06
 Changed
+- `Extensions::Repositories::Postgres::Delete` returns boolean
+- DataMapper became more safe: it will raise `MoreThanOneRecord` if `#read_one` received array with multiple items,
+  so it will show you your critical logic mistake
+
+Added
+- `DataMapper.mapper` now can receive block instead of class, to describe anonymous mapper;
+  default parent can be customized by defining `base_anonymous_mapper` method
+- `DataMapper.entity` now have second argument to customize `coercion` - you can use your own Entity class (even Dry Struct)
+- DataMapper became more safe: it will not try to transform hash of attributes to array of pairs
+- Postgres extension `Create` now will set `updated_at` and `created_at` if exists
+- Postgres extension `Update` now will set `updated_at` if exists
+- Postgres extension `Read` now have default `#scope` abstract method to handle scoping options
+- Postgres extension `Read` now have `#transaction` method
+- Postgres extension `Read` now have `#lock(pk, &block)` method and `#lock!(pk, &block)`
+- each Repository NotFound exception now have its own exception class, inherited from common NotFound exception
+- `LunaPark::Mappers::Codirectional` now available as default mapper `LunaPark::Mapper`
+- `LunaPark::Mappers::Codirectional` now can have nested mappers, and can be configured for arrays
+
+Fixed
+- DataMapper configuration (entity, mapper) now can be inherited. NotFound error also will be inherited.
+
+## [0.12.0] - 2023-02-23
+Added
 - Added `TaggedLog`
 
 ## [0.11.7] - 2022-10-07
 Changed
-- Added `formatter` to `Notifiers::Log`. Using `format` in initializer is now deprecated.
+- Added `formatter` to `Notifiers::Log`. Usage of `format` in initializer is now deprecated.
 
 ## [0.11.6] - 2021-10-06
 Changed
@@ -21,7 +44,7 @@ Added
 - add short alias for exceptions (`i18n:` instead of `i18n_key:`)
 
 ## [0.11.5] - 2022-09-27
-Changed
+Added
 - Added `.custom_error` method to `Extensions::HasError` to define errors with a custom superclass
 - Added `#inject` method to `Extensions::Injector` - dependencies setter that allows you to create method chains
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    luna_park (0.12.1)
+    luna_park (0.13.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/luna_park/extensions/data_mapper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'luna_park/mappers/simple'
+
 module LunaPark
   module Extensions
     # @example
@@ -20,7 +22,7 @@ module LunaPark
     #     def save(input)
     #       entity = wrap(input)
     #       row    = to_row(entity)
-    #       new_row   = products.where(id: entity.id).update(row)
+    #       new_row   = products.where(id: entity.id).returning.update(row)
     #       new_attrs = from_row(new_row)
     #       entity.set_attributes(new_attrs)
     #       entity
@@ -36,33 +38,174 @@ module LunaPark
     #     alias products dataset
     #   end
     module DataMapper
-      def self.included(base)
-        base.extend ClassMethods
-        base.include InstanceMethods
+      class << self
+        def extended(base)
+          base.include self
+        end
+
+        def included(base)
+          base.extend ClassMethods
+          base.include InstanceMethods
+
+          base.__define_constants__
+
+          defaults(base)
+        end
+
+        private
+
+        def defaults(base)
+          base.entity OpenStruct, :new
+          base.mapper LunaPark::Mappers::Simple
+        end
       end
 
       module ClassMethods
-        attr_reader :entity_class, :mapper_class
+        attr_reader :entity_class, :mapper_class, :__entity_coercion__
 
         # Configure repository
 
-        def entity(entity_class = nil)
-          @entity_class = entity_class
+        # Configure tagret entity class and coercion for it
+        #
+        # @example default coercion for entity type than responds to .call
+        #   class MyRepository
+        #     entity MyEntity
+        #   end
+        #
+        #   input = { foo: 'FOO', bar: 'BAR' }
+        #   MyRepository.new.send(:wrap, input) == MyEntity.call(input)
+        #
+        # @example default coercion for entity type than responds to .wrap
+        #   class MyRepository
+        #     entity MyEntity
+        #   end
+        #
+        #   input = { foo: 'FOO', bar: 'BAR' }
+        #   MyRepository.new.send(:wrap, input) == MyEntity.wrap(input)
+        #
+        # @example custom coercion by symbol, for entity type than responds to described_method
+        #   class MyRepository
+        #     entity MyEntity, :build
+        #   end
+        #
+        #   input = { foo: 'FOO', bar: 'BAR' }
+        #   MyRepository.new.send(:wrap, input) == MyEntity.build(input)
+        #
+        # @example custom coercion by callable object
+        #   class MyRepository
+        #     entity MyEntity, BUILD_ENTITY
+        #   end
+        #
+        #   input = { foo: 'FOO', bar: 'BAR' }
+        #   MyRepository.new.send(:wrap, input) == BUILD_ENTITY(input)
+        def entity(entity, coercion = nil)
+          @entity_class = entity
+          @__entity_coercion__ = __build_entity_coercion__(coercion)
+          @entity_class
+        end
+
+        # Configure Mapper
+        #
+        # @example With anonymous mapper
+        #   class Repository < LunaPark::Repository
+        #     mapper do
+        #       attr :foo, row: :fuu
+        #     end
+        #   end
+        #
+        #   Repository.mapper_class.to_row(foo: 'Foo') # => { fuu: 'Foo' }
+        #
+        # @example With mapper class
+        #   class Repository::Mapper < LunaPark::Mapper
+        #     attr :foo, row: :fuu
+        #   end
+        #
+        #   class Repository < LunaPark::Repository
+        #     mapper Mapper
+        #   end
+        #
+        #   Repository.new.mapper_class.to_row(foo: 'Foo') # => { fuu: 'Foo' }
+        #
+        # @example Without mapper
+        #   class Repository < LunaPark::Repository
+        #     def example_to_row(attrs)
+        #       to_row attrs
+        #     end
+        #   end
+        #
+        #   Repository.new.example_to_row(foo: 'Foo') # => { foo: 'Foo' }
+        #
+        def mapper(mapper = Undefined, &block)
+          raise ArgumentError, 'Expected mapper xOR block' unless (mapper == Undefined) ^ block.nil?
+
+          return @mapper_class = mapper if block.nil?
+
+          @mapper_class = Class.new(base_anonymous_mapper)
+          @mapper_class.class_eval(&block)
+          @mapper_class
+        end
+
+        def __build_entity_coercion__(coercion) # rubocop:disable Metrics/AbcSize
+          return entity_class.method(coercion) if coercion.is_a? Symbol
+          return coercion                      if coercion.respond_to?(:call)
+
+          raise ArgumentError, 'coercion MUST be call\'able, Symbol or nil' unless coercion.nil?
+
+          infer_entity_coercion
+        end
+
+        def infer_entity_coercion # rubocop:disable Metrics/AbcSize
+          return entity_class.method(:call) if entity_class.respond_to?(:call)
+          return entity_class.method(:wrap) if entity_class.respond_to?(:wrap)
+
+          ->(input) { entity_class.new(input.to_h) }
         end
 
-        def mapper(mapper_class = nil)
-          @mapper_class = mapper_class
+        # @abstract
+        #
+        # @example
+        #   class Transaction::Repository < LunaPark::Repository
+        #     # Parent of this mapper will be changed
+        #     mapper do
+        #       attr :foo
+        #     end
+        #
+        #     def self.base_anonymous_mapper
+        #       MyBaseMapper
+        #     end
+        #   end
+        def base_anonymous_mapper
+          LunaPark::Mappers::Codirectional
+        end
+
+        def primary_key(attr)
+          @primary_key_attr = attr
         end
 
         DEFAULT_PRIMARY_KEY = :id
 
-        def primary_key(pk = nil)
-          @db_primary_key = pk
+        def primary_key_attr
+          @primary_key_attr || DEFAULT_PRIMARY_KEY
+        end
+
+        def __define_constants__(not_found: LunaPark::Extensions::DataMapper::NotFound)
+          __define_class__ 'NotFound', not_found
         end
 
-        def db_primary_key
-          @db_primary_key || DEFAULT_PRIMARY_KEY
+        def __define_class__(name, parent)
+          klass = Class.new(parent)
+          const_set name, klass
         end
+
+        def inherited(klass)
+          klass.__define_constants__(not_found: NotFound)
+          klass.entity entity_class, __entity_coercion__
+          klass.mapper mapper_class
+          super
+        end
+
+        class Undefined; end
+        private_constant :Undefined
       end
 
       module InstanceMethods
@@ -74,22 +217,56 @@ module LunaPark
 
         # Helpers
 
+        # Repository Helpers
+
         # Get collection of entities from row
         # @example
         #   def where_type(type)
-        #     read_all products.where(type: type)
+        #     read_all scoped dataset.where(type: type)
         #   end
         def read_all(rows)
-          to_entities from_rows rows.to_a
+          to_entities from_rows __to_array__(rows)
         end
 
         # Get one entity from row
         # @example
         #   def find(id)
-        #     read_all products.where(id: id)
+        #     # limit 2 allows to check if there are more than 1 record
+        #     read_one dataset.where(id: id).limit(2)
+        #   end
+        def read_one(rows)
+          to_entity from_row __one_from__(rows)
+        end
+
+        # Get one entity from row
+        # @example
+        #   def find!(id)
+        #     read_one! dataset.where(id: id).limit(1)
+        #   end
+        def read_one!(row, not_found_by: nil, not_found_meta: nil)
+          warn 'Deprecated option #not_found_meta used' unless not_found_meta.nil?
+
+          found! read_one(row), not_found_by: not_found_by || not_found_meta
+        end
+
+        # Check if record was found
+        # @example
+        #   class MyRepository < LunaPark::Repository
+        #     def find_by_x!(x)
+        #       found! nil, not_found_by: "x: #{x}"
+        #     end
+        #   end
+        #
+        #   begin
+        #     MyRepository.new.find_by_x 'X'
+        #   rescue MyRepository::NotFound => e
+        #     raise HTTP404, "Record #{e.details[:name]} not found by #{e.details[:by]}"
         #   end
-        def read_one(row)
-          to_entity from_row row
+        #
+        def found!(value, not_found_by: nil)
+          return value unless value.nil?
+
+          raise self.class::NotFound.new name: self.class.entity_class.name, by: not_found_by
         end
 
         # Mapper helpers
@@ -100,7 +277,7 @@ module LunaPark
         #     database.insert_many(rows)
         #   end
         def to_rows(input_array)
-          mapper_class ? mapper_class.to_rows(input_array) : input_array.map(&:to_h)
+          self.class.mapper_class.to_rows(input_array)
         end
 
         # @example
@@ -109,7 +286,7 @@ module LunaPark
         #     database.insert(row)
         #   end
         def to_row(input)
-          mapper_class ? mapper_class.to_row(input) : input.to_h
+          self.class.mapper_class.to_row(input)
         end
 
         # @example
@@ -118,7 +295,7 @@ module LunaPark
         #     entities_attrs.map { |entity_attrs| Entity.new(entity_attrs) }
         #   end
         def from_rows(rows_array)
-          mapper_class ? mapper_class.from_rows(rows_array) : rows_array
+          self.class.mapper_class.from_rows(rows_array)
         end
 
         # @example
@@ -130,7 +307,7 @@ module LunaPark
           return if input.nil?
           raise ArgumentError, 'Can not be an Array' if input.is_a?(Array)
 
-          mapper_class ? mapper_class.from_row(input.to_h) : input
+          self.class.mapper_class.from_row(input.to_h)
         end
 
         # Entity construction helpers
@@ -139,7 +316,7 @@ module LunaPark
         #   to_entities(attributes_hashes) # => Array of Entity
         #   to_entities(attributes_hash)   # => Array of Entity
         def to_entities(attrs_array)
-          Array(attrs_array).map { |attrs| to_entity(attrs) }
+          __to_array__(attrs_array).map { |attrs| to_entity(attrs) }
         end
 
         # @example
@@ -147,48 +324,103 @@ module LunaPark
         def to_entity(attrs)
           return if attrs.nil?
 
-          entity_class ? entity_class.new(attrs) : attrs
+          self.class.entity_class.new(attrs)
         end
 
         # Entity wrapping helpers
 
         # @example
-        #   to_entities(attributes_hashes) # => Array of Entity
-        #   to_entities(entities)          # => Array of Entity
-        #   to_entities(entity)            # => Array of Entity
+        #   wrap_all(attributes_hashes) # => Array of Entity
+        #   wrap_all(entities)          # => Array of Entity
+        #   wrap_all(entity)            # => Array of Entity
         def wrap_all(input_array)
-          Array(input_array).map { |input| wrap(input) }
+          __to_array__(input_array).map { |input| wrap(input) }
         end
 
         # @example
-        #   to_entity(attributes_hash) # => Entity
-        #   to_entity(entity)          # => Entity
+        #   wrap(id: 42) # => <#MyEntity @id=42>
+        #   wrap(entity) # => <#MyEntity @id=42>
         def wrap(input)
           return if input.nil?
 
-          entity_class ? entity_class.wrap(input) : input
+          self.class.__entity_coercion__.call(input)
         end
 
-        # Read config
-
-        def mapper_class
-          self.class.mapper_class
+        # @example scope after query build
+        #   def all(**opts)
+        #     read_all scoped(**opts).order(:created_at)
+        #   end
+        #
+        # @example scope before query build
+        #   def all(**opts)
+        #     read_all scoped(dataset.order(:created_at), **opts)
+        #   end
+        #
+        def scoped(ds = dataset, **opts)
+          scope(ds, **opts)
         end
 
-        def entity_class
-          self.class.entity_class
+        # @abstract
+        #
+        # @example
+        #   def scope(dataset, deleted: nil, for_update: false, **scope)
+        #     ds = super(dataset, **scope)
+        #     ds = ds.for_update                  if for_update == true
+        #     ds = ds.where(deleted_at: nil)      if deleted == false
+        #     ds = ds.where.not(deleted_at: nil)  if deleted == true
+        #     ds
+        #   end
+        #
+        #   def all(**scope)
+        #     read_all scoped(**scope) # same as `scope(dataset, **scope)`
+        #   end
+        #
+        #   all                 # get all
+        #   all(deleted: false) # get not deleted
+        #   all(deleted: true)  # get deleted
+        def scope(dataset, **_scope)
+          dataset
         end
 
+        # Read config
+
         def primary_key
-          self.class.db_primary_key
+          self.class.primary_key_attr
         end
 
         # Factory Methods
 
+        # @abstract
+        #
         # Usefull for extensions
         def dataset
           raise NotImplementedError
         end
+
+        # fixes problem: `Array({ a: 1 }) # => [[:a, 1]]`
+        def __to_array__(input)
+          input.is_a?(Hash) ? [input] : Array(input)
+        end
+
+        # checks if there are only one item in the given array
+        def __one_from__(input)
+          case input
+          when Hash then input
+          else
+            array = input.is_a?(Array) ? input : Array(input)
+            raise MoreThanOneRecord.new count: array.size if array.size > 1
+
+            array.first
+          end
+        end
+      end
+
+      class NotFound < LunaPark::Errors::NotFound
+        message { |d| "#{d[:name]} (#{d[:by]})" }
+      end
+
+      class MoreThanOneRecord < LunaPark::Errors::System
+        message { |d| "Expected only one record, but there are #{d[:count]} records" }
       end
     end
   end

data/lib/luna_park/extensions/repositories/postgres/create.rb

@@ -7,9 +7,15 @@ module LunaPark
         module Create
           def create(input)
             entity = wrap(input)
-            row    = to_row(entity)
-            new_row = dataset.returning.insert(row).first
+
+            time = Time.now
+            entity.created_at = time if entity.respond_to?(:created_at)
+            entity.updated_at = time if entity.respond_to?(:updated_at)
+
+            row       = to_row(entity)
+            new_row   = dataset.returning.insert(row).first
             new_attrs = from_row(new_row)
+
             entity.set_attributes(new_attrs)
             entity
           end

data/lib/luna_park/extensions/repositories/postgres/delete.rb

@@ -6,7 +6,7 @@ module LunaPark
       module Postgres
         module Delete
           def delete(uid)
-            dataset.returning.where(primary_key => uid).delete
+            dataset.where(primary_key => uid).delete.positive?
           end
         end
       end

data/lib/luna_park/extensions/repositories/postgres/read.rb

@@ -5,56 +5,47 @@ module LunaPark
     module Repositories
       module Postgres
         module Read
-          def find!(pk_value, for_update: false)
-            ds = dataset.where(primary_key => pk_value)
-            read_one!(ds, for_update: for_update, not_found_meta: pk_value)
-          end
-
-          def find(pk_value, for_update: false)
-            ds = dataset.where(primary_key => pk_value)
-            read_one(ds, for_update: for_update)
-          end
-
           def lock!(pk_value)
-            lock(pk_value) || raise(Errors::NotFound, "#{short_class_name} (#{pk_value})")
+            transaction { yield find! pk_value, for_update: true }
           end
 
           def lock(pk_value)
-            dataset.for_update.select(primary_key).where(primary_key => pk_value).first ? true : false
+            transaction { yield find pk_value, for_update: true }
           end
 
-          def count
-            dataset.count
+          def transaction(&block)
+            dataset.transaction(&block)
           end
 
-          def all
-            read_all(dataset.order { created_at.desc })
+          def find!(pk_value, **scope)
+            found! find(pk_value, **scope), not_found_by: pk_value
           end
 
-          def last
-            to_entity from_row dataset.order(:created_at).last
+          def find(pk_value, **scope)
+            read_one scoped(**scope).where(primary_key => pk_value)
           end
 
-          private
+          def count(**scope)
+            scoped(**scope).count
+          end
 
-          def read_one!(dataset, for_update: false, not_found_meta:)
-            read_one(dataset, for_update: for_update).tap do |entity|
-              raise Errors::NotFound, "#{short_class_name} (#{not_found_meta})" if entity.nil?
-            end
+          def all(**scope)
+            read_all(scoped(**scope).order { created_at.desc })
           end
 
-          def read_one(dataset, for_update: false)
-            dataset = dataset.for_update if for_update
-            row = dataset.first
-            to_entity from_row(row)
+          def first(**scope)
+            read_one scoped(**scope).order(:created_at).first
           end
 
-          def read_all(dataset)
-            to_entities from_rows(dataset)
+          def last(**scope)
+            read_one scoped(**scope).order(:created_at).last
           end
 
-          def short_class_name
-            @short_class_name ||= self.class.name[/::(\w+)\z/, 1]
+          private
+
+          def scope(dataset, for_update: false, **_)
+            dataset = dataset.for_update if for_update
+            dataset
           end
         end
       end

data/lib/luna_park/extensions/repositories/postgres/update.rb

@@ -7,10 +7,13 @@ module LunaPark
         module Update
           def save(input)
             entity = wrap(input)
-            entity.updated_at = Time.now.utc
-            row = to_row(entity)
-            new_row = dataset.returning.where(primary_key => row[primary_key]).update(row).first
+
+            entity.updated_at = Time.now if entity.respond_to?(:updated_at)
+
+            row       = to_row(entity)
+            new_row   = dataset.where(primary_key => row[primary_key]).returning.update(row).first
             new_attrs = from_row(new_row)
+
             entity.set_attributes(new_attrs)
             entity
           end

data/lib/luna_park/mapper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require 'luna_park/mappers/codirectional'
+
+module LunaPark
+  class Mapper < Mappers::Codirectional; end
+end

data/lib/luna_park/mappers/codirectional/copyists/nested.rb

@@ -7,32 +7,46 @@ module LunaPark
         # Copyist for copiyng value between two schemas with DIFFERENT or NESTED paths
         #   (Works with only one described attribute)
         class Nested
-          def initialize(attrs_path:, row_path:)
+          def initialize(attrs_path:, row_path:, mapper:, map_array:)
             @attrs_path = attrs_path
             @row_path   = row_path
 
+            @mapper_config = mapper
+            @map_array     = map_array
+
             raise ArgumentError, 'attr path can not be nil'  if attrs_path.nil?
             raise ArgumentError, 'store path can not be nil' if row_path.nil?
+            raise ArgumentError, 'array option MUST be nil when no Mapper given' if map_array && mapper.nil?
           end
 
           def from_row(row:, attrs:)
-            copy_nested(from: row, to: attrs, from_path: @row_path, to_path: @attrs_path)
+            copy_nested(from: row, to: attrs, from_path: @row_path, to_path: @attrs_path, direction: :from_row)
           end
 
           def to_row(row:, attrs:)
-            copy_nested(from: attrs, to: row, from_path: @attrs_path, to_path: @row_path)
+            copy_nested(from: attrs, to: row, from_path: @attrs_path, to_path: @row_path, direction: :to_row)
           end
 
           private
 
-          def copy_nested(from:, to:, from_path:, to_path:)
+          def copy_nested(from:, to:, from_path:, to_path:, direction:)
             value = read(from, from_path)
 
             return if value == Undefined # omit undefined keys
 
+            value = apply_mapper(value, direction) unless mapper.nil?
+
             write(to, to_path, value)
           end
 
+          def apply_mapper(value, direction)
+            if @map_array
+              value.map { |v| mapper.public_send direction, v }
+            else
+              mapper.public_send direction, value
+            end
+          end
+
           def read(from, from_path)
             if from_path.is_a?(Array) # when given `%i[key path]` - not just `:key`
               read_nested(from, path: from_path)
@@ -82,6 +96,13 @@ module LunaPark
             path.inject(nested_hash) { |output, key| output[key] ||= {} }
           end
 
+          def mapper
+            return @mapper if instance_variable_defined?(:@mapper)
+            return @mapper = Object.const_get(@mapper_config) if @mapper_config.is_a? String
+
+            @mapper = @mapper_config
+          end
+
           class Undefined; end
 
           private_constant :Undefined

data/lib/luna_park/mappers/codirectional.rb

@@ -53,33 +53,28 @@ module LunaPark
         #   class Mappers::Transaction < LunaPark::Mappers::Codirectional
         #     attr :uid,              row: :id
         #     attr %i[charge amount], row: :charge_amount
+        #     attr :comment
         #   end
-        def attr(attr, row: nil)
-          return attrs(attr) if row.nil?
-
+        def attr(attr, row: attr, mapper: nil, array: nil)
           attr_path = to_path(attr)
           row_path  = to_path(row)
 
-          if attr_path == row_path
-            attrs(attr_path)
+          if attr_path == row_path && !attr_path.is_a?(Array)
+            slice_copyist.add_key(attr_path)
           else
-            nested_copyists << Copyists::Nested.new(attrs_path: attr_path, row_path: row_path)
+            nested_copyists << Copyists::Nested.new(
+              attrs_path: attr_path, row_path: row_path,
+              mapper: mapper, map_array: array
+            )
           end
         end
 
         # @example
         #   class Mappers::Transaction < LunaPark::Mappers::Codirectional
-        #     attrs :comment, :uid, %i[addresses home], :created_at
+        #     attrs :created_at, :updated_at, :deleted_at
         #   end
         def attrs(*common_keys)
-          common_keys.each do |common_key|
-            path = to_path(common_key)
-            if path.is_a?(Array)
-              nested_copyists << Copyists::Nested.new(attrs_path: path, row_path: path)
-            else
-              slice_copyist.add_key(path)
-            end
-          end
+          common_keys.each { |common_key| attr common_key }
         end
 
         def from_row(input)

data/lib/luna_park/mappers/errors.rb

@@ -6,7 +6,7 @@ module LunaPark
   module Mappers
     module Errors
       class NotArray < LunaPark::Errors::System
-        message { |d| "input MUST be an Array, but given #{d[:input].class} `#{d[:input].inspect}`" }
+        message { |d| "input MUST respond to #to_a, but given #{d[:input].class} `#{d[:input].inspect}`" }
       end
     end
   end

data/lib/luna_park/mappers/simple.rb

@@ -67,28 +67,30 @@ module LunaPark
         # Transforms array of rows to array of attribute hashes
         def from_rows(rows)
           return [] if rows.nil?
-          raise Errors::NotArray.new(input: rows) unless rows.is_a?(Array)
+          raise Errors::NotArray.new(input: rows) if     rows.is_a?(Hash)
+          raise Errors::NotArray.new(input: rows) unless rows.respond_to?(:to_a)
 
           rows.to_a.map { |hash| from_row(hash) }
         end
 
         ##
         # Transforms array of attribute hashes to array of rows
-        def to_rows(attr_hashes)
-          return [] if attr_hashes.nil?
-          raise Errors::NotArray.new(input: attr_hashes) unless attr_hashes.is_a?(Array)
+        def to_rows(attrs_array)
+          return [] if attrs_array.nil?
+          raise Errors::NotArray.new(input: rows)        if     attrs_array.is_a?(Hash)
+          raise Errors::NotArray.new(input: attrs_array) unless attrs_array.respond_to?(:to_a)
 
-          attr_hashes.to_a.map { |entity| to_row(entity) }
+          attrs_array.to_a.map { |entity| to_row(entity) }
         end
 
         # @abstract
-        def from_row(_row)
-          raise LunaPark::Errors::AbstractMethod
+        def from_row(row)
+          row.to_h
         end
 
         # @abstract
-        def to_row(_attrs)
-          raise LunaPark::Errors::AbstractMethod
+        def to_row(attrs)
+          attrs.to_h
         end
       end
     end

data/lib/luna_park/notifiers/tagged_log/tagged_formatter.rb

@@ -48,17 +48,17 @@ module LunaPark
           end
         end
 
-        def error_payload(e)
+        def error_payload(err) # rubocop:disable Metrics/MethodLength
           error_hash = {
-            class: e.class,
-            message: e.message
+            class: err.class,
+            message: err.message
           }
-          error_hash.merge!(backtrace: "\n" + e.backtrace.join("\n") + "\n") if e.backtrace
+          error_hash.merge!(backtrace: "\n" + err.backtrace.join("\n") + "\n") if err.backtrace
           payload = {
             error: error_hash,
             ok: false
           }
-          payload.merge!(details: e.details) if e.respond_to?(:details)
+          payload.merge!(details: err.details) if err.respond_to?(:details)
           payload
         end
 

data/lib/luna_park/notifiers/tagged_log.rb

@@ -40,7 +40,7 @@ module LunaPark
 
         def push_tags(*tags)
           tags.flatten!
-          tags.reject! { |t| t.respond_to?(:empty?) ? !!t.empty? : !t }
+          tags.reject! { |tag| tag.respond_to?(:empty?) ? tag.empty? : !tag }
           current_tags.concat tags
           tags
         end

data/lib/luna_park/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LunaPark
-  VERSION = '0.12.1'
+  VERSION = '0.13.0'
 end

data/lib/luna_park.rb

@@ -66,8 +66,7 @@ LunaPark::Tools.if_gem_installed('dry-validation', '~> 1.1') { require 'luna_par
 require 'luna_park/values/compound'
 require 'luna_park/values/single'
 require 'luna_park/values/attributable'
-require 'luna_park/mappers/simple'
-require 'luna_park/mappers/codirectional'
+require 'luna_park/mapper'
 require 'luna_park/repository'
 require 'luna_park/repositories/sequel'
 require 'luna_park/repositories/postgres'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: luna_park
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Alexander Kudrin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-02-28 00:00:00.000000000 Z
+date: 2023-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bugsnag
@@ -424,6 +424,7 @@ files:
 - lib/luna_park/http/request.rb
 - lib/luna_park/http/response.rb
 - lib/luna_park/http/send.rb
+- lib/luna_park/mapper.rb
 - lib/luna_park/mappers/codirectional.rb
 - lib/luna_park/mappers/codirectional/copyists/nested.rb
 - lib/luna_park/mappers/codirectional/copyists/slice.rb