ledger_sync-domains 1.0.0.rc4 → 1.0.0.rc6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98a9a322cfce591cdeed882ba3759de892d83285750060039705ef2ca639e57b
-  data.tar.gz: 8382121c87166d2c09ff841a9e2eb9b42ac51ee83a021f9281b1ecb8736043c5
+  metadata.gz: b26c844bc9d5327343fc366e9854181829cc53f9b06c2d2de0e8fcd9f0a34d81
+  data.tar.gz: 858fd914201d49fc83d24476997f6c2ae8e96d8e627bbc10507ed3e4015826ed
 SHA512:
-  metadata.gz: ce9543df99e765a129f1e489fb50c426ff4bf204af1580e4e0d68eb18cf8c453dd681cd645d47b4c0d91f4f3f5d010c5136a961f023f08cab2937337ca592662
-  data.tar.gz: 1b0ee50fa56bc4412bc13b7f398ea88d7d2366e0df2811d9bc6d895d071aaf7e3b0dfcdec6068d182d56edfd1493d4bcc1289c759884583335d75b0d710d1d65
+  metadata.gz: baba4dde6e0410790569e69df334e7b0891d9d7aa649a500bdd30cca130735604f654f98d2f341d82f1bf60586ed2705e5cb5ca52e8446f8a007c7c69c70de7e
+  data.tar.gz: 11b56944c28b7b200117875564ea2eaa7a25b0af883beb5c2ac9db5e66f1f0040c1895abc3ac1b109d8ab70367d023842d8fa828cc50a4c7a0f6c0b97247589e

data/.github/workflows/ruby.yml

@@ -0,0 +1,36 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ["2.7", "3.0"]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+        # change this to (see https://github.com/ruby/setup-ruby#versioning):
+        # uses: ruby/setup-ruby@v1
+        uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Rspec
+        run: bundle exec rspec
+      - name: Rubocop
+        run: bundle exec rubocop

data/.gitignore

@@ -9,3 +9,4 @@
 
 # rspec failure tracking
 .rspec_status
+.byebug_history

data/.rubocop.yml

@@ -1,5 +1,14 @@
+inherit_mode:
+  merge:
+    - Exclude
+
 AllCops:
-  TargetRubyVersion: 3.0
+  TargetRubyVersion: 2.7
+  Exclude:
+  - "Gemfile"
+  - "Rakefile"
+  - "bin/**/*"
+  - "spec/**/*"
 
 Style/StringLiterals:
   Enabled: true

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.2

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [1.0.0.rc5] - 2012-12-16
+
+- Fix: Bring back Resource to pre-defined operations
+
+## [1.0.0.rc5] - 2021-11-05
+
+- Add: Introduce Serializer::Relation to proxy AR Queries
+- Refactor Struct out of Serializer
+
+## [1.0.0.rc4] - 2021-09-23
+
+- Add: Additional operations
+
 ## [1.0.0.rc3] - 2021-09-06
 
 - Fix: Operation::Transition uses correct module name

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ledger_sync-domains (1.0.0.rc4)
+    ledger_sync-domains (1.0.0.rc6)
       ledger_sync (~> 2.2.0)
 
 GEM
@@ -69,8 +69,8 @@ GEM
       faraday-rack (~> 1.0)
       multipart-post (>= 1.2, < 3)
       ruby2_keywords (>= 0.0.4)
-    faraday-detailed_logger (2.3.0)
-      faraday (>= 0.8, < 2)
+    faraday-detailed_logger (2.4.2)
+      faraday (>= 0.16, < 2)
     faraday-em_http (1.0.0)
     faraday-em_synchrony (1.0.0)
     faraday-excon (1.1.0)
@@ -79,15 +79,15 @@ GEM
     faraday-net_http_persistent (1.2.0)
     faraday-patron (1.0.0)
     faraday-rack (1.0.0)
-    faraday_middleware (1.1.0)
+    faraday_middleware (1.2.0)
       faraday (~> 1.0)
     fingerprintable (1.2.1)
       colorize
     i18n (1.8.10)
       concurrent-ruby (~> 1.0)
-    ledger_sync (2.2.0)
+    ipaddr (1.2.3)
+    ledger_sync (2.2.3)
       activemodel
-      colorize
       dry-schema (~> 1.5.4)
       dry-validation (~> 1.5.6)
       faraday
@@ -98,19 +98,21 @@ GEM
       openssl (~> 2.2.0)
       pd_ruby
       rack (~> 2.2.3)
+      rainbow (~> 3.0)
       resonad
       simply_serializable (>= 1.5.1)
     minitest (5.14.4)
     multipart-post (2.1.1)
-    nokogiri (1.12.4-x86_64-linux)
+    nokogiri (1.12.5-x86_64-linux)
       racc (~> 1.4)
-    openssl (2.2.0)
+    openssl (2.2.1)
+      ipaddr
     parallel (1.20.1)
     parser (3.0.2.0)
       ast (~> 2.4.1)
     pd_ruby (0.2.3)
       colorize
-    racc (1.5.2)
+    racc (1.6.0)
     rack (2.2.3)
     rainbow (3.0.0)
     rake (13.0.6)
@@ -163,4 +165,4 @@ DEPENDENCIES
   rubocop (~> 1.7)
 
 BUNDLED WITH
-   2.2.15
+   2.2.26

data/README.md

@@ -6,7 +6,7 @@ LedgerSync has been developed to handle cross-service (API) communication in ele
 
 Operations are great to ensure there is single point to perform specific action. If the return object is regular ActiveRecord Model object, there is nothing that stops developer from accessing cross-domain relationship, updating it or calling another action on it. You can have rubocop scanning through the code and screaming every time it finds something fishy, or you can just stop passing ActiveRecord objects around. And that is where `LedgerSync::Serializer` comes handy. It gives you simple way to define how your object should look towards specific domain. Instead of passing ruby hash(es), you work with `OpenStruct` objects that supports relationships.  
 
-Use LedgerSync Operations to trigger actions from other domains and LedgerSync Serializers to pass around serialized objects instead of ActiveRecord Models. ActiveRecord Models are compatible with LedgerSync Resources and can be serialized to OpenStruct objects automatically. 
+Use `LedgerSync::Operation` to trigger actions from other domains and `LedgerSync::Serializer` to pass around serialized objects instead of ActiveRecord Models. ActiveRecord Models are compatible with LedgerSync Resources and can be serialized to OpenStruct objects automatically. 
 
 ## Installation
 
@@ -27,9 +27,41 @@ Or install it yourself as:
 ## Usage
 
 LedgerSync comes with 3 components.
-1. Resource
-2. Serializers
-3. Operations
+1. Registration
+2. Resource
+3. Serializers
+4. Operations
+
+### Register your engines
+
+`LedgerSync::Domains` requires little configuration so it can properly pick up domains and their namespace. While `LedgerSync::Domains` is not required to be used with Rails, it is the most expected usecase. THe problem with Rails (and possibly other codebases) is that the `MainApp` does not have a module namespace and referencing it from other domain operations is not as simple. There are two methods to help you register.
+
+#### Register your Main App
+
+`register_main_domain` creates a domain with name `:main` without any `base_module`. This way you can reference `MainApp` as `domain: :main` and serializers/operations will be picked up from there.
+
+```ruby
+# config/application.rb
+module DropBot
+  class Application < Rails::Application
+    LedgerSync::Domains.register_main_domain
+    # ...
+  end
+end
+```
+
+#### Register your Engine
+
+`register_domain` creates a domain with your own `name` and your own `base_module`. Lets say you place your engines under `engines` folder and you just created `billing` engine. To register it as a domain, update your `engine.rb` file. After that use it in your operations as `domain: :engine`. You can pass in string or symbol.
+```ruby
+# engines/billing/lib/billing/engine.rb
+module Billing
+  class Engine < ::Rails::Engine
+    isolate_namespace Billing
+    LedgerSync::Domains.register_domain(:billing, base_module: Billing)
+  end
+end
+```
 
 ### Resource/Model
 
@@ -186,7 +218,7 @@ module Auth
         return failure('Not found') if resource.nil?
 
         if resource.update(active: false)
-          success(serialize(resource: resource))
+          success(resource)
         else
           failure('Unable to deactivate')
         end
@@ -208,10 +240,12 @@ module Auth
   end
 end
 ```
-Successful result of an operation should be serialized resource(s). Operation by itself doesn't know what domain triggered it, and therefore you need to pass in serializer you want to use to serialize the resource. Here is how that looks for the example above.
+
+Successful result of an operation should be serialized resource(s). Operations automatically perform success result serialization for you. Any `ActiveRecord::Base` or `LedgerSync::Resource` object will be automatically serialized through matching serializer for the target domain. Any other value will remain untouched. Hashes and arrays are deep-serialized, so you can return hash or array including multiple ActiveRecord objects. Operation by itself doesn't know what domain triggered it, and therefore it requires target domain to be passed either as a module, string or symbol. Here is how that looks for the example above.
+
 
 ```ruby
-irb(main):001:0> op = Auth::Users::FindOperation.new(id: 1, limit: {}, serializer: Auth::Users::ClientSerializer.new)
+irb(main):001:0> op = Auth::Users::FindOperation.new(id: 1, limit: {}, domain: Client)
 => #<Auth::Users::FindOperation:0x0000555937876cf8 @serializer=#<Auth::Users::ClientSerializer:0x0000555937876dc0>, @deserializer=nil...
 irb(main):002:0> op.perform
 => #<LedgerSync::Domains::Operation::OperationResult::Success:0x00005559372f9d70 @meta=nil, @value=#<OpenStruct email="test@ledger_sync.dev">>
@@ -221,17 +255,33 @@ irb(main):003:0> op.result.value
 
 And thats it. Now you can use `LedgerSync` to define operations and have their results serialized against specific domain you are requesting it from.
 
+#### Internal operations
+
+Sometimes you want to create operation, that is not accessible from the rest of the app. The nature of ruby allows all defined classes be accessible from everywhere. To prevent execution of an operation from different domain, use `internal` flag when defining class.
+
+```ruby
+module Auth
+  module Users
+    class FindOperation < LedgerSync::Domains::Operation::Find
+      internal
+    end
+  end
+end
+```
+
+When performing an operation there are series of guards. First one validates if operation is allowed to be executed. That means either it is not flagged as internal operation, or target domain is same domain as module operation is defined in. If operation is not allowed to be executed, failure is returned with `LedgerSync::Domains::InternalOperationError` error.
+
 ### Cross-domain relationships
 
 One important note about relationships. Splitting your app into multiple engines is eventually gonna lead to your ActiveRecord Models to have relationships that reference Models from other engines. There are two ways how to look at this issue.
 
 #### Use of cross-domain relationships is bad
 
-In this case, you don't define them. Or if you do, you override reader method to raise exception. If `user` references `customer`, you don't access it through `user.customer`, but you retrieve it through operation `Engine::Customers::FindOperation.new(id: user.customer_id)`. This is a clean solution, but it will lead to N+1 queries.
+In this case, you don't define them. Or if you do, you override reader method to raise exception. If `user` references `customer`, you don't access it through `user.customer`, but you retrieve it through operation `Engine::Customers::FindOperation.new(id: user.customer_id, domain: 'OtherEngine')`. This is a clean solution, but it will lead to N+1 queries.
 
 #### Use of cross-domain relationships is fine
 
-If you double down on getting into root of an issue, you will realize that resources reference each other is not really the source of it. The problem is that if you work with ActiveRecord objects, there is nothing stopping you from accessing related records and modifying them.
+If you try to get into the root of an issue, you will realize that resources reference each other is not really the source of it. The problem is that if you work with ActiveRecord objects, there is nothing stopping you from accessing related records and modifying them.
 
 That cannot happen when accessing objects from other domains. In that case you retrieve serialized object through operation. Accessing relationships through serialized object will always return serialized relationship.
 

data/ledger_sync-domains.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'Use LedgerSync Operations and Serializers for cross-domain communication.'
   spec.homepage      = 'https://engineering.dropbot.sh'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 3.0.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.2')
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 

data/lib/ledger_sync/domains/operation/add.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../operation'
+require_relative 'resource'
 
 module LedgerSync
   module Domains
     class Operation
-      class Add
-        include LedgerSync::Domains::Operation::Mixin
-
+      class Add < Resource
         private
 
         def operate

data/lib/ledger_sync/domains/operation/find.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../operation'
+require_relative 'resource'
 
 module LedgerSync
   module Domains
     class Operation
-      class Find
-        include LedgerSync::Domains::Operation::Mixin
-
+      class Find < Resource
         class Contract < LedgerSync::Ledgers::Contract
           params do
             required(:id).filled(:integer)

data/lib/ledger_sync/domains/operation/remove.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../operation'
+require_relative 'resource'
 
 module LedgerSync
   module Domains
     class Operation
-      class Remove
-        include LedgerSync::Domains::Operation::Mixin
-
+      class Remove < Resource
         private
 
         def operate

data/lib/ledger_sync/domains/operation/resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Domains
+    class Operation
+      class Resource
+        include LedgerSync::Domains::Operation::Mixin
+
+        def resource_class
+          @resource_class ||= inferred_resource_class
+        end
+
+        private
+
+        def inferred_resource_class
+          name = self.class.to_s.split('::')
+          name.pop # remove serializer/operation class from name
+          resource = name.pop.singularize # pluralized resource module name
+
+          self.class.const_get((name + [resource]).join('::'))
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/operation/search.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../operation'
+require_relative 'resource'
 
 module LedgerSync
   module Domains
     class Operation
-      class Search
-        include LedgerSync::Domains::Operation::Mixin
-
+      class Search < Resource
         # make kaminari work with serialized results
         class PaginatedResult < SimpleDelegator
           attr_accessor :next_page, :last_page, :current_page, :total_pages,

data/lib/ledger_sync/domains/operation/transition.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../operation'
+require_relative 'resource'
 
 module LedgerSync
   module Domains
     class Operation
-      class Transition
-        include LedgerSync::Domains::Operation::Mixin
-
+      class Transition < Resource
         class Contract < LedgerSync::Ledgers::Contract
           params do
             required(:model_name).filled(:string)

data/lib/ledger_sync/domains/operation/update.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require_relative '../operation'
+require_relative 'resource'
 
 module LedgerSync
   module Domains
     class Operation
-      class Update
-        include LedgerSync::Domains::Operation::Mixin
-
+      class Update < Resource
         private
 
         def operate

data/lib/ledger_sync/domains/operation.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
+unless Object.const_defined?('ActiveRecord')
+  # reopen AR module for non-rails apps
+  module ActiveRecord
+    module Base; end
+  end
+end
+
 module LedgerSync
   module Domains
+    class InternalOperationError < LedgerSync::Error::OperationError; end
+
     class Operation
       class OperationResult
         module ResultTypeBase
@@ -22,26 +31,16 @@ module LedgerSync
         include LedgerSync::ResultBase
       end
 
-      module Mixin
+      module Mixin # rubocop:disable Metrics/ModuleLength
         module ClassMethods
-          def inferred_resource_class
-            name = to_s.split('::')
-            name.pop # remove serializer/operation class from name
-            resource = name.pop.singularize # pluralized resource module name
-
-            const_get((name + [resource]).join('::'))
-          end
-
-          def inferred_serializer_class
-            const_get("#{inferred_resource_class}Serializer")
-          end
+          @internal = false
 
-          def inferred_deserializer_class
-            const_get("#{inferred_resource_class}Deserializer")
+          def internal
+            @internal = true
           end
 
-          def inferred_validation_contract_class
-            const_get('Contract')
+          def internal?
+            !!@internal
           end
         end
 
@@ -61,14 +60,22 @@ module LedgerSync
 
         attr_reader :params, :result
 
-        def initialize(serializer: nil, deserializer: nil, **params)
-          @serializer = serializer
-          @deserializer = deserializer
+        def initialize(domain:, **params)
+          @domain = domain
           @params = params
           @result = nil
         end
 
         def perform # rubocop:disable Metrics/MethodLength
+          unless allowed?
+            return failure(
+              LedgerSync::Domains::InternalOperationError.new(
+                operation: self,
+                message: 'Cross-domain operation execution is not allowed'
+              )
+            )
+          end
+
           if performed?
             return failure(
               LedgerSync::Error::OperationError::PerformedOperationError.new(
@@ -93,32 +100,47 @@ module LedgerSync
           end
         end
 
+        def allowed?
+          return true unless self.class.internal?
+
+          local_domain == @domain
+        end
+
         def performed?
           @performed == true
         end
 
         def serialize(resource:)
-          serializer.serialize(resource: resource)
+          serializer_for(resource: resource).serialize(resource: resource)
         end
 
-        def deserializer
-          @deserializer ||= deserializer_class.new
+        def serializer_for(resource:)
+          serializer_class_for(resource: resource).new
         end
 
-        def deserializer_class
-          @deserializer_class ||= self.class.inferred_deserializer_class
+        def serializer_class_for(resource:)
+          Object.const_get(
+            [
+              serializer_module_for(resource: resource),
+              "#{domain}Serializer"
+            ].join('::')
+          )
         end
 
-        def serializer
-          @serializer ||= serializer_class.new
+        def serializer_module_for(resource:)
+          (
+            resource.class.try(:serializer_module) || resource.class
+          ).to_s.pluralize
         end
 
-        def serializer_class
-          @serializer_class ||= self.class.inferred_serializer_class
+        def domain
+          LedgerSync::Domains.domains.module_for(domain: @domain)
         end
 
-        def resource_class
-          @resource_class ||= self.class.inferred_resource_class
+        def local_domain
+          LedgerSync::Domains.domains.domain_for(
+            base_module: self.class.to_s.split('::').first.constantize
+          )
         end
 
         # Results
@@ -132,7 +154,20 @@ module LedgerSync
         end
 
         def success(value, meta: nil)
-          @result = OperationResult.Success(value, meta: meta)
+          @result = OperationResult.Success(deep_serialize(value), meta: meta)
+        end
+
+        def deep_serialize(value)
+          case value
+          when ActiveRecord::Base, LedgerSync::Resource
+            serialize(resource: value)
+          when Hash
+            value.transform_values { deep_serialize(_1) }
+          when Array
+            value.map { deep_serialize(_1) }
+          else
+            value
+          end
         end
 
         def success?
@@ -145,13 +180,17 @@ module LedgerSync
 
         def validate
           LedgerSync::Util::Validator.new(
-            contract: validation_contract,
+            contract: validation_contract_class,
             data: params
           ).validate
         end
 
-        def validation_contract
-          @validation_contract ||= self.class.inferred_validation_contract_class
+        def validation_contract_class
+          @validation_contract_class ||= inferred_validation_contract_class
+        end
+
+        def inferred_validation_contract_class
+          self.class.const_get('Contract')
         end
 
         def errors

data/lib/ledger_sync/domains/serializer/relation.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Domains
+    class Serializer < LedgerSync::Serializer
+      class Relation
+        def initialize(serializer:, resource:, attribute:)
+          @query = resource.try(attribute)
+          @serializer = serializer
+        end
+
+        QUERY_METHODS = %w[
+          distinct distinct! eager_load eager_load! extending extending!
+          from from! group group! having having! includes includes!
+          joins joins! left_outer_joins left_outer_joins!
+          limit limit! offset offset! order order! preload preload!
+          references references! unscope unscope! where where!
+          load reload reset
+        ].freeze # lock lock!
+        READER_METHODS = %w[
+          fifth fifth! find find_by find_by! first first! forty_two forty_two!
+          fourth fourth! last last! second second! second_to_last
+          second_to_last! third third! third_to_last third_to_last!
+        ].freeze
+        READERS_METHODS = %w[find_each each map to_ary].freeze
+        # in_batches does not make sense as it renders relation
+        READERS_BATCH_METHODS = %w[find_in_batches].freeze
+        INSPECT_METHODS = %w[
+          any? blank? empty? explain many? none? one? size to_sql exists? count
+          ids maximum minimum sum none none! loaded?
+        ].freeze
+
+        QUERY_METHODS.each do |name|
+          define_method(name) do |*args|
+            @query = @query.send(name, *args)
+
+            self
+          end
+        end
+
+        READER_METHODS.each do |name|
+          define_method(name) do |*args, **params, &block|
+            item = @query.send(name, *args, **params, &block)
+
+            @serializer.serialize(resource: item)
+          end
+        end
+
+        READERS_METHODS.each do |name|
+          define_method(name) do |*args, **params, &block|
+            @query.send(name, *args, **params).map do |item|
+              resource = @serializer.serialize(resource: item)
+
+              block&.yield(resource) || resource
+            end
+          end
+        end
+
+        READERS_BATCH_METHODS.each do |name|
+          define_method(name) do |*args, **params, &block|
+            @query.send(name, *args, **params).each do |batch|
+              resources = batch.map do |item|
+                @serializer.serialize(resource: item)
+              end
+
+              block&.yield(resources)
+            end
+          end
+        end
+
+        INSPECT_METHODS.each do |name|
+          define_method(name) do |*args|
+            @query.send(name, *args)
+          end
+        end
+
+        def inspect(*_args)
+          entries = to_ary.take(11).map!(&:inspect)
+
+          entries[10] = '...' if entries.size == 11
+
+          "#<#{self.class.name} [#{entries.join(', ')}]>"
+        end
+
+        def as_json(*_args)
+          to_ary.map!(&:as_json)
+        end
+
+        # pass through Enumerable methods
+        def respond_to_missing?(name, _include_private)
+          Enumerable.instance_methods.include?(name.to_sym)
+        end
+
+        def method_missing(name, *args, **params, &block)
+          return super unless Enumerable.instance_methods.include?(name.to_sym)
+
+          to_ary.send(name, *args, **params, &block)
+        end
+
+        class SerializerReferencesOneType
+          def proxy(serializer:, resource:, attribute:)
+            item = resource.try(attribute)
+
+            serializer.serialize(resource: item)
+          end
+        end
+
+        class SerializerReferencesManyType
+          def proxy(serializer:, resource:, attribute:)
+            Relation.new(
+              serializer: serializer,
+              resource: resource,
+              attribute: attribute
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/serializer/struct.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'relation'
+
+module LedgerSync
+  module Domains
+    class Serializer < LedgerSync::Serializer
+      class Struct
+        # This is the most ruby hackery I ever did
+        # Defining Record class that inherits from SimpleDelegator is not
+        # enough. Adding methods through define_method was adding these methods
+        # to all objects created through this main class. Specifically address
+        # record has an attribute called address, which returned serialized
+        # address. This is a same approach, but with dynamic class definition
+        # to avoid defining methods in unrelated classes. We are using
+        # SimpleDelegator to delegate these methods into OpenStruct passed in.
+        # Pure hackery.
+        def self.build(hash, serializer_name, resource:, references:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          klass = Class.new(SimpleDelegator) do
+            def self.with_lazy_references(hash, struct_class:, resource:, references:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              define_method('valid?') { resource.valid? }
+              define_method('errors') { resource.errors }
+              define_method('to_hash') { hash }
+              references.each do |args|
+                define_method(args.hash_attribute) do
+                  Relation.const_get(
+                    args.type.class.to_s.split('::').last
+                  ).new.proxy(
+                    serializer: args.type.serializer.new,
+                    resource: resource,
+                    attribute: args.resource_attribute
+                  )
+                end
+              end
+
+              new(struct_class.new(hash))
+            end
+
+            def to_param
+              id.to_s
+            end
+
+            def persisted?
+              id.present?
+            end
+
+            def to_json(*args)
+              JSON.generate(to_hash, *args)
+            end
+          end
+
+          name = serializer_name.split('::')
+          class_name = name.pop.gsub(/[^0-9a-z ]/i, '').gsub(/.*\KSerializer/, '')
+          struct_name = "#{class_name}Struct"
+          module_name = name.empty? ? Object : Object.const_get(name.join('::'))
+          unless module_name.const_defined?(struct_name)
+            module_name.const_set(struct_name, Class.new(OpenStruct))
+          end
+
+          klass.with_lazy_references(
+            hash,
+            struct_class: module_name.const_get(struct_name),
+            resource: resource, references: references
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/serializer.rb

@@ -1,71 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'serializer/struct'
+
 module LedgerSync
   module Domains
     class Serializer < LedgerSync::Serializer
-      def create_record_from(hash, resource:, references:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        # This is the most ruby hackery I ever did
-        # Defining Record class that inherits from SimpleDelegator is not
-        # enough. Adding methods through define_method was adding these methods
-        # to all objects created through this main class. Specifically address
-        # record has an attribute called address, which returned serialized
-        # address. This is a same approach, but with dynamic class definition
-        # to avoid defining methods in unrelated classes. We are using
-        # SimpleDelegator to delegate these methods into OpenStruct passed in.
-        # Pure hackery.
-        klass = Class.new(SimpleDelegator) do
-          def self.with_lazy_references(hash, struct_class:, resource:, references:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-            define_method('valid?') { resource.valid? }
-            define_method('errors') { resource.errors }
-            define_method('to_hash') { hash }
-            references.each do |args|
-              define_method(args.hash_attribute) do
-                if args.references_many?
-                  resource.try(args.resource_attribute).each do |item|
-                    args.type.serializer.new.serialize(resource: item)
-                  end
-                else
-                  item = resource.try(args.resource_attribute)
-                  next if item.nil?
-
-                  args.type.serializer.new.serialize(resource: item)
-                end
-              end
-            end
-
-            new(struct_class.new(hash))
-          end
-
-          def to_param
-            id.to_s
-          end
-
-          def persisted?
-            id.present?
-          end
-
-          def to_json(*args)
-            JSON.generate(to_hash, *args)
-          end
-        end
-
-        name = self.class.to_s.split('::')
-        class_name = name.pop.gsub(/[^0-9a-z ]/i, '').gsub(/.*\KSerializer/, '')
-        struct_name = "#{class_name}Struct"
-        module_name = name.empty? ? Object : Object.const_get(name.join('::'))
-        module_name.const_set(struct_name, Class.new(OpenStruct))
-
-        klass.with_lazy_references(
-          hash,
-          struct_class: module_name.const_get(struct_name),
-          resource: resource, references: references
-        )
-      end
-
-      def self.references
-        @references ||= []
-      end
-
       def self.split_attributes
         regular = []
         references = []
@@ -98,7 +37,10 @@ module LedgerSync
             other_hash: serializer_attribute.hash_attribute_hash_for(resource: resource)
           )
         end
-        create_record_from(ret, resource: resource, references: references)
+        Serializer::Struct.build(
+          ret, self.class.to_s,
+          resource: resource, references: references
+        )
       end
     end
   end

data/lib/ledger_sync/domains/store.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Domains
+    class ConfigurationStore
+      attr_reader :configs
+
+      def initialize
+        @configs = {}
+      end
+
+      def register_domain(config:)
+        @configs[config.root_key] = config
+      end
+
+      def module_for(domain:)
+        @configs[domain]&.base_module
+      end
+
+      def domain_for(base_module:)
+        config = @configs.values.find { |c| c.base_module == base_module }
+        config ||= @configs[:main]
+
+        config.root_key
+      end
+    end
+
+    class Configuration
+      attr_accessor :name
+      attr_reader :root_key, :base_module
+
+      def initialize(root_key, base_module:)
+        @root_key = root_key.to_sym
+        @name = root_key.to_s.capitalize
+        @base_module = base_module
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/version.rb

@@ -2,6 +2,6 @@
 
 module LedgerSync
   module Domains
-    VERSION = '1.0.0.rc4'
+    VERSION = '1.0.0.rc6'
   end
 end

data/lib/ledger_sync/domains.rb

@@ -2,8 +2,10 @@
 
 require 'ledger_sync'
 require_relative 'domains/version'
+require_relative 'domains/store'
 require_relative 'domains/serializer'
 require_relative 'domains/operation'
+require_relative 'domains/operation/resource'
 require_relative 'domains/operation/add'
 require_relative 'domains/operation/find'
 require_relative 'domains/operation/remove'
@@ -12,5 +14,23 @@ require_relative 'domains/operation/transition'
 require_relative 'domains/operation/update'
 
 module LedgerSync
-  module Domains; end
+  module Domains
+    def self.domains
+      @domains ||= LedgerSync::Domains::ConfigurationStore.new
+    end
+
+    def self.register_domain(*args, **params)
+      config = LedgerSync::Domains::Configuration.new(*args, **params)
+      yield(config) if block_given?
+
+      domains.register_domain(config: config)
+    end
+
+    def self.register_main_domain
+      config = LedgerSync::Domains::Configuration.new(:main, base_module: nil)
+      config.name = 'Main'
+
+      domains.register_domain(config: config)
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ledger_sync-domains
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc4
+  version: 1.0.0.rc6
 platform: ruby
 authors:
 - Jozef Vaclavik
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-23 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ledger_sync
@@ -73,10 +73,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/main.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -91,10 +92,14 @@ files:
 - lib/ledger_sync/domains/operation/add.rb
 - lib/ledger_sync/domains/operation/find.rb
 - lib/ledger_sync/domains/operation/remove.rb
+- lib/ledger_sync/domains/operation/resource.rb
 - lib/ledger_sync/domains/operation/search.rb
 - lib/ledger_sync/domains/operation/transition.rb
 - lib/ledger_sync/domains/operation/update.rb
 - lib/ledger_sync/domains/serializer.rb
+- lib/ledger_sync/domains/serializer/relation.rb
+- lib/ledger_sync/domains/serializer/struct.rb
+- lib/ledger_sync/domains/store.rb
 - lib/ledger_sync/domains/version.rb
 homepage: https://engineering.dropbot.sh
 licenses:
@@ -103,7 +108,7 @@ metadata:
   homepage_uri: https://engineering.dropbot.sh
   source_code_uri: https://github.com/sandbite/ledger_sync-domains
   changelog_uri: https://github.com/sandbite/ledger_sync-domains/blob/main/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -111,15 +116,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 2.7.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.2.9
+signing_key: 
 specification_version: 4
 summary: LedgerSync for Domains/Engines
 test_files: []

data/.github/workflows/main.yml

@@ -1,18 +0,0 @@
-name: Ruby
-
-on: [push,pull_request]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby
-      uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: 3.0.0
-    - name: Run the default task
-      run: |
-        gem install bundler -v 2.2.15
-        bundle install
-        bundle exec rake