ledger_sync-domains 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5ee91277b3f0600c5553ce5f2183da338ef451b649bbf452a9871d9aa4048f01
+  data.tar.gz: 3723fb3b32fcdffdc87cc4355b4b898f070cac3793f9278186f55137ff123c04
+SHA512:
+  metadata.gz: 477cffd0916f91dfffcc6099758d597e8df1cb3f4b11aa0464e3e791b254bdccb2f6b0a3f53a2186298d17c8d41714925e6676f028d093af6b7430b172e414fc
+  data.tar.gz: 7b002212bff9beb39ee7b3c5fe87d6112ef56ab5f6392e7c9b2ed16e5630f3f3b5ba89efa0deba17ea912b5f289e661bf8f00e49d6d3073d781c1d3d61de4606

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+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

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Layout/LineLength:
+  Max: 100
+
+Style/Documentation:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2021-08-31
+
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ledger_sync-domains.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.7"

data/Gemfile.lock

@@ -0,0 +1,161 @@
+PATH
+  remote: .
+  specs:
+    ledger_sync-domains (1.0.0.rc1)
+      ledger_sync (~> 2.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    ast (2.4.2)
+    colorize (0.8.1)
+    concurrent-ruby (1.1.9)
+    diff-lcs (1.4.4)
+    dotenv (2.7.6)
+    dry-configurable (0.12.1)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5.0)
+    dry-container (0.8.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-core (0.7.1)
+      concurrent-ruby (~> 1.0)
+    dry-equalizer (0.3.0)
+    dry-inflector (0.2.1)
+    dry-initializer (3.0.4)
+    dry-logic (1.2.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 0.5, >= 0.5)
+    dry-schema (1.5.6)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.8, >= 0.8.3)
+      dry-core (~> 0.4)
+      dry-equalizer (~> 0.2)
+      dry-initializer (~> 3.0)
+      dry-logic (~> 1.0)
+      dry-types (~> 1.4)
+    dry-types (1.5.1)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.3)
+      dry-core (~> 0.5, >= 0.5)
+      dry-inflector (~> 0.1, >= 0.1.2)
+      dry-logic (~> 1.0, >= 1.0.2)
+    dry-validation (1.5.6)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.7, >= 0.7.1)
+      dry-core (~> 0.4)
+      dry-equalizer (~> 0.2)
+      dry-initializer (~> 3.0)
+      dry-schema (~> 1.5, >= 1.5.2)
+    faraday (1.7.1)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0.1)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.1)
+      faraday-patron (~> 1.0)
+      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-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday_middleware (1.1.0)
+      faraday (~> 1.0)
+    fingerprintable (1.2.1)
+      colorize
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    ledger_sync (2.2.0)
+      activemodel
+      colorize
+      dry-schema (~> 1.5.4)
+      dry-validation (~> 1.5.6)
+      faraday
+      faraday-detailed_logger
+      faraday_middleware
+      fingerprintable (>= 1.2.1)
+      nokogiri
+      openssl (~> 2.2.0)
+      pd_ruby
+      rack (~> 2.2.3)
+      resonad
+      simply_serializable (>= 1.5.1)
+    minitest (5.14.4)
+    multipart-post (2.1.1)
+    nokogiri (1.12.4-x86_64-linux)
+      racc (~> 1.4)
+    openssl (2.2.0)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    pd_ruby (0.2.3)
+      colorize
+    racc (1.5.2)
+    rack (2.2.3)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    resonad (1.4.0)
+    rexml (3.2.5)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    rubocop (1.20.0)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.9.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.11.0)
+      parser (>= 3.0.1.1)
+    ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
+    simply_serializable (1.5.1)
+      fingerprintable (>= 1.2.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.0.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  dotenv
+  ledger_sync-domains!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rubocop (~> 1.7)
+
+BUNDLED WITH
+   2.2.15

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Jozef Vaclavik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,254 @@
+# LedgerSync::Domains
+
+Achieving Domain Driven Design (DDD) inside of a rails application is not a simple task. Rails engines by themself provide minimal value for code isolation. There are several gems that allows you to handle cross-engine communication through service/operation/inflection classes. Unfortunately these only touches execution, but they won't help you with passing around serialized objects.
+
+LedgerSync has been developed to handle cross-service (API) communication in elegant way. Same aproach can be used for cross-domain communication.
+
+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. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ledger_sync-domains'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install ledger_sync-domains
+
+## Usage
+
+LedgerSync comes with 3 components.
+1. Resource
+2. Serializers
+3. Operations
+
+### Resource/Model
+
+While `LedgerSync::Resources` represent object from external service, in case of domains we replace this with build in ActiveRecord Models. If you wish to use `LedgerSync::Domains` outside of a rails app (there is nothing that stops you doing that), just use LedgerSync::Resource to prepare your data for Serializers.
+
+Use of ActiveRecord Models allows us to easily work with current rails data structure. Define your models as you would do in any rails application.
+
+```ruby
+class Customer < ActiveRecord::Base
+  has_many :addresses
+  belongs_to :user, class_name: 'Auth::User'
+end
+
+class Address < ActiveRecord::Base
+  belongs_to :customer
+end
+
+module Auth
+  class User < ActiveRecord::Base
+    has_many :customers
+  end
+end
+```
+
+Alternatively you can use LedgerSync::Resource class to wrap your data into Model-like objects with relationships.
+```ruby
+class Customer < LedgerSync::Resource
+  attribute :name, type: LedgerSync::Type::String
+
+  references_many :addresses, to: Address
+  references_one :user, to: Auth::User
+end
+
+class Address < LedgerSync::Resource
+  attribute :address, type: LedgerSync::Type::String
+  attribute :city, type: LedgerSync::Type::String
+  attribute :country, type: LedgerSync::Type::String
+
+  references_one :customer, to: Customer
+end
+
+module Auth
+  class User < LedgerSync::Resource
+    attribute :email, type: LedgerSync::Type::String
+
+    references_many :customers, to: Customer
+  end
+end
+```
+
+In above example(s) you can see two models `Customer` and `Address` that are part of `Main` domain, and `User` model being part of `Auth` domain. For the sake of examples, we will have also `Client` domain that consumes both resources from `Main` as well as `Auth` domain.
+
+### Serializers
+
+Next step is to serialize records from these Models/Resources. One of the concepts of DDD is to be able to present your object differently to each domain. For example `User` can exposes different set of attributes towards `Client` domain as well as `Main` domain. `LedgerSync::Serializer` allows you to define serializer for each domain and specify which attributes will be exposed towards each domain.
+
+```ruby
+module Auth
+  module Users
+    class AuthSerializer < LedgerSync::Domains::Serializer
+      attribute :email
+    end
+    
+    class ClientSerializer < LedgerSync::Domains::Serializer
+      attribute :email
+    end
+  end
+end
+
+module Addresses
+  class ClientSerializer < LedgerSync::Domains::Serializer
+    attribute :address
+    attribute :city
+    attribute :state
+  end
+end
+
+module Customers
+  class AuthSerializer < LedgerSync::Domains::Serializer
+    attribute :id, resource_attribute: :ledger_id
+    attribute :name
+    references_one :user, resource_attribute: :user,
+                          serializer: Auth::Users::AuthSerializer
+  end
+
+  class ClientSerializer < LedgerSync::Domains::Serializer
+    attribute :id, resource_attribute: :ledger_id
+    attribute :name
+    references_many :addresses, resource_attribute: :addresses,
+                                serializer: Addresses::ClientSerializer
+  end
+end
+```
+
+In above example we represent `Customer` with two serializers aimed towards two domains. `Customer::AuthSerializer` exposes customer and `user` relationship, while `Customer::ClientSerializer` exposes customer and `addresses` relationship.
+
+`LedgerSync::Domains::Serializer` serializes into `OpenStruct` object. Original resource is part of it and used to lazily load and serialize relationships. This way relationships are queried and serialized only once required. Here is quick example below.
+
+
+Here is quick example how that looks in above example.
+```ruby
+# load all above classes - watch for dependencies
+
+irb(main):001:0> user = Auth::User.new(email: 'test@ledger_sync.dev')
+=> #<Auth::User:0x00005624204f1da8 @resource_attributes=#<LedgerSync::ResourceAttributeSet:0x00005624204f1790 @attributes={:external_id=>#<L...
+irb(main):002:0> customer = Customer.new(ledger_id: '123', name: 'LedgerSync', user: user)
+=> #<Customer:0x0000562420792300 @resource_attributes=#<LedgerSync::ResourceAttributeSet:0x0000562420791dd8 @attributes={:external_id=>#<Led...
+
+irb(main):003:0> auth_customer = Customers::AuthSerializer.new.serialize(resource: customer)
+=> #<Customers::AuthStruct id="123", name="LedgerSync">
+irb(main):004:0> auth_customer.user
+=> #<Auth::Users::AuthStruct email="test@ledger_sync.dev">
+
+irb(main):005:0> client_customer = Customers::ClientSerializer.new.serialize(resource: customer)
+=> #<Customers::ClientStruct id="123", name="LedgerSync">
+irb(main):006:0> client_customer.user
+Traceback (most recent call last):
+        3: from ./bin/console:15:in `<main>'
+        2: from (irb):06:in `<main>'
+        1: from /root/.asdf/installs/ruby/3.0.0/lib/ruby/3.0.0/delegate.rb:91:in `method_missing'
+NoMethodError (undefined method `user' for #<OpenStruct id="123", name="LedgerSync">)
+irb(main):007:0> client_customer.addresses
+=> []
+```
+Above you can see that `client_customer` can't access `user` relationship, while `auth_customer` can.
+
+### Operations
+
+Operations allows you to expose actions towards other domains. Validate input based on specified contract and return result object that you can use to retrieve data or error details. Here is sample operation to fetch object by specific ID and one to deactivate an user.
+
+```ruby
+module Auth
+  module Users
+    class FindOperation < LedgerSync::Domains::Operation::Find
+      # Ha, that was easy!
+    end
+  end
+end
+
+module Auth
+  module Users
+    class DeactivateOperation
+      include LedgerSync::Domains::Operation::Mixin
+
+      class Contract < LedgerSync::Ledgers::Contract
+        params do
+          required(:id).value(:integer)
+        end
+      end
+
+      private
+
+      def operate
+        return failure('Not found') if resource.nil?
+
+        if resource.update(active: false)
+          success(serialize(resource: resource))
+        else
+          failure('Unable to deactivate')
+        end
+      end
+
+      def resource
+        @resource ||= User.find_by(id: params[:id])
+      end
+
+      def failure(message)
+        super(
+          LedgerSync::Error::OperationError.new(
+            operation: self,
+            message: message
+          )
+        )
+      end
+    end
+  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.
+
+```ruby
+irb(main):001:0> op = Auth::Users::FindOperation.new(id: 1, limit: {}, serializer: Auth::Users::ClientSerializer.new)
+=> #<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">>
+irb(main):003:0> op.result.value
+=> #<Auth::Users::ClientStruct email="test@ledger_sync.dev">
+```
+
+And thats it. Now you can use `LedgerSync` to define operations and have their results serialized against specific domain you are requesting it from.
+
+### 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.
+
+#### 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.
+
+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.
+
+The problem is when working with records within current engine where fetching data from ActiveRecord is accepted practice. There is nothing that stops you from crossing domain boundary.
+
+The obvious solution is to use Operations to work with Models within current engine as well. Serialized `OpenStruct` objects are (or try to be) compatible with ActiveRecord objects. They require almost zero changes in your templates. So think of them as drop-in replacement.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ledger_sync-domains.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ledger_sync/domains"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ledger_sync-domains.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/ledger_sync/domains/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ledger_sync-domains'
+  spec.version       = LedgerSync::Domains::VERSION
+  spec.authors       = ['Jozef Vaclavik']
+  spec.email         = ['jozef@dropbot.sh']
+
+  spec.summary       = 'LedgerSync for Domains/Engines'
+  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.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/LedgerSync/ledger_sync-domains'
+  spec.metadata['changelog_uri'] = 'https://github.com/LedgerSync/ledger_sync-domains/blob/main/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ledger_sync', '~> 2.2.0'
+  spec.add_development_dependency 'dotenv'
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../operation'
+
+module LedgerSync
+  module Domains
+    class Operation
+      class Add
+        include LedgerSync::Domains::Operation::Mixin
+
+        private
+
+        def operate
+          if resource.save
+            success
+          else
+            failure(
+              'Please review the problems below:',
+              data: serialize(resource: resource)
+            )
+          end
+        end
+
+        def resource
+          @resource ||= resource_class.new(params)
+        end
+
+        def success
+          super(
+            serialize(resource: resource)
+          )
+        end
+
+        def failure(message, data: nil)
+          super(
+              LedgerSync::Error::OperationError.new(
+                operation: self,
+                message: message,
+                response: data
+              )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../operation'
+
+module LedgerSync
+  module Domains
+    class Operation
+      class Find
+        include LedgerSync::Domains::Operation::Mixin
+
+        class Contract < LedgerSync::Ledgers::Contract
+          params do
+            required(:id).filled(:integer)
+            required(:limit).value(:hash)
+          end
+        end
+
+        private
+
+        def operate
+          if resource
+            success
+          else
+            failure('Not found')
+          end
+        end
+
+        def resource
+          @resource ||= resource_class.find_by(id: params[:id])
+        end
+
+        def success
+          super(
+            serialize(resource: resource)
+          )
+        end
+
+        def failure(message)
+          super(
+            LedgerSync::Error::OperationError.new(
+              operation: self,
+              message: message
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../operation'
+
+module LedgerSync
+  module Domains
+    class Operation
+      class Remove
+        include LedgerSync::Domains::Operation::Mixin
+
+        private
+
+        def operate
+          return failure('Resource not found') unless resource
+
+          if resource.destroy
+            success
+          else
+            failure(
+              'Please review the problems below:',
+              data: serialize(resource: resource)
+            )
+          end
+        end
+
+        def resource
+          @resource ||= resource_class.find_by(id: params[:id])
+        end
+
+        def success
+          super(
+            true
+          )
+        end
+
+        def failure(message, data: nil)
+          super(
+              LedgerSync::Error::OperationError.new(
+                operation: self,
+                message: message,
+                response: data
+              )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../operation'
+
+module LedgerSync
+  module Domains
+    class Operation
+      class Search
+        include LedgerSync::Domains::Operation::Mixin
+
+        # make kaminari work with serialized results
+        class PaginatedResult < SimpleDelegator
+          attr_accessor :next_page, :last_page, :current_page, :total_pages,
+                        :limit_value, :total_count
+
+          def self.from_result(result, items:)
+            search = new(items)
+            search.next_page = result.next_page
+            search.last_page = result.last_page?
+            search.current_page = result.current_page
+            search.total_pages = result.total_pages
+            search.total_count = result.total_count
+            search.limit_value = result.limit_value
+            search
+          end
+
+          def last_page?
+            last_page == true
+          end
+        end
+
+        class Contract < LedgerSync::Ledgers::Contract
+          params do
+            required(:query).value(:hash)
+            required(:limit).value(:hash)
+            required(:includes).value(:array)
+            required(:order).value(:string)
+            required(:page).value(:integer)
+            required(:per).value(:integer)
+          end
+        end
+
+        private
+
+        def operate
+          if resources
+            success
+          else
+            failure('Not found')
+          end
+        end
+
+        def resources # rubocop:disable Metrics/AbcSize
+          @resources ||= resource_class.where(params[:limit])
+                                       .where(params[:query])
+                                       .includes(params[:includes])
+                                       .order(params[:order])
+                                       .page(params[:page])
+                                       .per(params[:per])
+        end
+
+        def success
+          super(
+            PaginatedResult.from_result(
+              resources,
+              items: resources.map { |resource| serialize(resource: resource) }
+            )
+          )
+        end
+
+        def failure(message)
+          super(
+            LedgerSync::Error::OperationError.new(
+              operation: self,
+              message: message
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../operation'
+
+module LedgerSync
+  module Domains
+    class Resource
+      class Transition
+        include LedgerSync::Domains::Operation::Mixin
+
+        class Contract < LedgerSync::Ledgers::Contract
+          params do
+            required(:model_name).filled(:string)
+            required(:id).filled(:integer)
+            required(:event).value(:string)
+            required(:attrs).maybe(:hash)
+            required(:attrs).maybe(:array)
+          end
+        end
+
+        private
+
+        def operate
+          if resource.present?
+            if resource.send(guard_method, params[:attrs]) &&
+               resource.send(event_method, params[:attrs])
+              success
+            else
+              failure('Unable to transition')
+            end
+          else
+            failure('Not found')
+          end
+        end
+
+        def guard_method
+          "may_#{params[:event]}?"
+        end
+
+        def event_method
+          "#{params[:event]}!"
+        end
+
+        def resource
+          @resource ||= resource_class.find_by(id: params[:id])
+        end
+
+        def resource_class
+          @resource_class ||= Object.const_get(params[:model_name])
+        end
+
+        def success
+          super(
+            serialize(resource: resource)
+          )
+        end
+
+        def failure(message)
+          super(
+            LedgerSync::Error::OperationError.new(
+              operation: self,
+              message: message
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../operation'
+
+module LedgerSync
+  module Domains
+    class Operation
+      class Update
+        include LedgerSync::Domains::Operation::Mixin
+
+        private
+
+        def operate
+          return failure('Resource not found') unless resource
+
+          if resource.update(params.except(:id))
+            success
+          else
+            failure(
+              'Please review the problems below:',
+              data: serialize(resource: resource)
+            )
+          end
+        end
+
+        def resource
+          @resource ||= resource_class.find_by(id: params[:id])
+        end
+
+        def success
+          super(
+            serialize(resource: resource)
+          )
+        end
+
+        def failure(message, data: nil)
+          super(
+              LedgerSync::Error::OperationError.new(
+                operation: self,
+                message: message,
+                response: data
+              )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/operation.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Domains
+    class Operation
+      class OperationResult
+        module ResultTypeBase
+          attr_reader :meta
+
+          def self.included(base)
+            base.class_eval do
+              simply_serialize only: %i[meta]
+            end
+          end
+
+          def initialize(*args, meta: nil)
+            @meta = meta
+            super(*args)
+          end
+        end
+
+        include LedgerSync::ResultBase
+      end
+
+      module Mixin
+        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
+
+          def inferred_deserializer_class
+            const_get("#{inferred_resource_class}Deserializer")
+          end
+
+          def inferred_validation_contract_class
+            const_get("#{self}::Contract")
+          end
+        end
+
+        def self.included(base)
+          base.include SimplySerializable::Mixin
+          base.include Fingerprintable::Mixin
+          base.include LedgerSync::Error::HelpersMixin
+          base.extend ClassMethods
+
+          base.class_eval do
+            simply_serialize only: %i[
+              params
+              result
+            ]
+          end
+        end
+
+        attr_reader :params, :result
+
+        def initialize(serializer: nil, deserializer: nil, **params)
+          @serializer = serializer
+          @deserializer = deserializer
+          @params = params
+          @result = nil
+        end
+
+        def perform # rubocop:disable Metrics/MethodLength
+          if performed?
+            return failure(
+              LedgerSync::Error::OperationError::PerformedOperationError.new(
+                operation: self
+              )
+            )
+          end
+          return errors unless valid?
+
+          @result = begin
+            operate
+          rescue LedgerSync::Error => e
+            failure(e)
+          rescue StandardError => e
+            failure(e)
+          ensure
+            @performed = true
+          end
+        end
+
+        def performed?
+          @performed == true
+        end
+
+        def serialize(resource:)
+          serializer.serialize(resource: resource)
+        end
+
+        def deserializer
+          @deserializer ||= deserializer_class.new
+        end
+
+        def deserializer_class
+          @deserializer_class ||= self.class.inferred_deserializer_class
+        end
+
+        def serializer
+          @serializer ||= serializer_class.new
+        end
+
+        def serializer_class
+          @serializer_class ||= self.class.inferred_serializer_class
+        end
+
+        def resource_class
+          @resource_class ||= self.class.inferred_resource_class
+        end
+
+        # Results
+
+        def failure(error)
+          @result = OperationResult.Failure(error)
+        end
+
+        def failure?
+          result.failure?
+        end
+
+        def success(value, meta: nil)
+          @result = OperationResult.Success(value, meta: meta)
+        end
+
+        def success?
+          result.success?
+        end
+
+        def valid?
+          validate.success?
+        end
+
+        def validate
+          LedgerSync::Util::Validator.new(
+            contract: validation_contract,
+            data: params
+          ).validate
+        end
+
+        def validation_contract
+          @validation_contract ||= self.class.inferred_validation_contract_class
+        end
+
+        def errors
+          validate.validator.errors
+        end
+
+        # Comparison
+
+        def ==(other)
+          return false unless self.class == other.class
+          return false unless params == other.params
+
+          true
+        end
+
+        private
+
+        def operate
+          raise NotImplementedError, self.class.name
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/serializer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+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(struct, resource:, references:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            define_method('valid?') { resource.valid? }
+            define_method('errors') { resource.errors }
+            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)
+          end
+
+          def to_param
+            id.to_s
+          end
+
+          def persisted?
+            id.present?
+          end
+        end
+
+        name = self.class.to_s.split('::')
+        struct_name = name.pop.sub(/.*\KSerializer/, 'Struct')
+        module_name = name.empty? ? Object : Object.const_get(name.join('::'))
+        module_name.const_set(struct_name, Class.new(OpenStruct))
+
+        klass.with_lazy_references(
+          module_name.const_get(struct_name).new(hash),
+          resource: resource, references: references
+        )
+      end
+
+      def self.references
+        @references ||= []
+      end
+
+      def self.split_attributes
+        regular = []
+        references = []
+
+        attributes.each_value do |attr|
+          if attr.references_many? || attr.references_one?
+            references.push(attr)
+          else
+            regular.push(attr)
+          end
+        end
+        [regular, references]
+      end
+
+      def serialize(args = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        only_changes = args.fetch(:only_changes, false)
+        resource     = args.fetch(:resource)
+
+        ret = {}
+
+        regular, references = self.class.split_attributes
+        regular.each do |serializer_attribute|
+          if (only_changes && !resource.attribute_changed?(serializer_attribute.resource_attribute)) || # rubocop:disable Layout/LineLength
+             (serializer_attribute.if_method.present? && !send(serializer_attribute.if_method, resource: resource)) # rubocop:disable Layout/LineLength
+            next
+          end
+
+          ret = LedgerSync::Util::HashHelpers.deep_merge(
+            hash_to_merge_into: ret,
+            other_hash: serializer_attribute.hash_attribute_hash_for(resource: resource)
+          )
+        end
+        create_record_from(ret, resource: resource, references: references)
+      end
+    end
+  end
+end

data/lib/ledger_sync/domains/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  module Domains
+    VERSION = '1.0.0.rc1'
+  end
+end

data/lib/ledger_sync/domains.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'ledger_sync'
+require_relative 'domains/version'
+require_relative 'domains/serializer'
+require_relative 'domains/operation'
+require_relative 'domains/operation/add'
+require_relative 'domains/operation/find'
+require_relative 'domains/operation/remove'
+require_relative 'domains/operation/search'
+require_relative 'domains/operation/transition'
+require_relative 'domains/operation/update'
+
+module LedgerSync
+  module Domains; end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: ledger_sync-domains
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Jozef Vaclavik
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ledger_sync
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use LedgerSync Operations and Serializers for cross-domain communication.
+email:
+- jozef@dropbot.sh
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ledger_sync-domains.gemspec
+- lib/ledger_sync/domains.rb
+- lib/ledger_sync/domains/operation.rb
+- 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/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/version.rb
+homepage: https://engineering.dropbot.sh
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://engineering.dropbot.sh
+  source_code_uri: https://github.com/LedgerSync/ledger_sync-domains
+  changelog_uri: https://github.com/LedgerSync/ledger_sync-domains/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: LedgerSync for Domains/Engines
+test_files: []