realm-rom 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 631dd7891edbda2e66cc9d812434d1a2036197f80be79e25ea061d2f37b8f2d6
-  data.tar.gz: 7d71ebd4ebc9d465fb36ee1d7b93b87d30166c635569aed0b0df9a1a425e3f08
+  metadata.gz: 443eba2e7ede9e2162eb8cbaa4324c6db29ba1bee69426a1e053629451957e94
+  data.tar.gz: 91c1ab5cf3f6b79f5205a25df6626b9c9164e4127569d984b66136887e564835
 SHA512:
-  metadata.gz: b9a81123cb1e55f7c9173a2d4edd8e0da6a30d15f606d74789f64c7fb52aab3ff9f64fc4629371938ee1fd076d5557c48187f2a1bb6e23c982e7d2b573216901
-  data.tar.gz: c2d44929520091709e83469ff68b2cdc52995eb5faa22dd4be223d7a083309b12597b4260f4063bfa23f7af978fd65654910282e2fd219ca9737301df7eaa668
+  metadata.gz: b6f8acb1cce4429e5e9b386aae5259bce4108ad001225004b88125c9bfaf3089bd89b4b494af7eaa40a2f988b2821d79e1252758898342e7312a6453c27610f9
+  data.tar.gz: 25920069362c88a229b32f555deadf380bbfc90df38cba030b3b20239329f39109437a0ff477ce8bebc1170a23593b0c736b73e238806381153d0bdbeb24c7ab

data/lib/realm-rom.rb

@@ -0,0 +1,16 @@
+# rubocop:disable Naming/FileName
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore(__FILE__)
+loader.inflector.inflect('rom' => 'ROM')
+loader.setup
+
+require 'realm-core'
+require 'rom'
+require 'rom-sql'
+require 'realm/rom/plugin'
+
+# rubocop:enable Naming/FileName

data/lib/realm/rom/gateway.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Realm
+  module ROM
+    class Gateway
+      def initialize(url:, root_module:, class_path:, migration_path:, **)
+        @url = url
+        @root_module = root_module
+        @class_path = class_path
+        @migration_path = migration_path
+      end
+
+      def health
+        issues = []
+        issues << 'Cannot connect to db' unless default_gateway.connection.test_connection
+        issues << 'Pending migrations' if default_gateway.migrator.pending?
+        HealthStatus.from_issues(issues)
+      end
+
+      def method_missing(...)
+        client.send(...)
+      end
+
+      def respond_to_missing?(...)
+        client.respond_to?(...)
+      end
+
+      private
+
+      def client
+        @client ||= ::ROM.container(config)
+      end
+
+      def config
+        ::ROM::Configuration.new(:sql, @url, **config_options).tap do |config|
+          config.auto_registration(@class_path, namespace: @root_module.to_s)
+        end
+      end
+
+      def config_options
+        { search_path: @root_module.to_s.underscore, migrator: { path: @migration_path } }
+      end
+
+      def default_gateway
+        client.gateways[:default]
+      end
+    end
+  end
+end

data/lib/realm/rom/plugin.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Realm
+  module ROM
+    class Plugin < Realm::Plugin
+      def self.setup(config, container)
+        return unless config.persistence_gateway[:type] == :rom
+
+        gateway = Gateway.new(config.persistence_gateway)
+        container.register('persistence.gateway', gateway)
+        container.register(:rom, gateway) # for backward compatibility as we access it a lot in tests
+      end
+    end
+  end
+end

data/lib/realm/rom/rake_tasks.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'rake'
+
+module Realm
+  module ROM
+    module RakeTasks
+      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/MethodLength
+      def self.setup(engine_name, engine_root: Rails.root.join('engines', engine_name.to_s),
+                     db_url: ENV['DATABASE_URL'])
+        return unless db_url
+
+        options = { search_path: engine_name.to_s, migrator: { path: "#{engine_root}/db/migrate" } }
+        config = ::ROM::Configuration.new(:sql, db_url, options)
+        gateway = config.gateways[:default]
+
+        Rake.application.in_namespace(:db) do
+          Rake::Task.define_task(:init_schema) do
+            gateway.run "CREATE SCHEMA IF NOT EXISTS \"#{engine_name}\""
+            puts "<= #{engine_name}:db:init_schema executed"
+          end
+
+          Rake::Task.define_task(:drop_schema) do
+            gateway.run "DROP SCHEMA \"#{engine_name}\" CASCADE"
+            puts "<= #{engine_name}:db:drop_schema executed"
+          end
+
+          Rake.application.last_description = 'Perform migration reset (full erase and migration up)'
+          Rake::Task.define_task(:reset) do
+            gateway.run_migrations(target: 0)
+            gateway.run_migrations
+            puts "<= #{engine_name}:db:reset executed"
+          end
+
+          Rake.application.last_description = 'Migrate the database (options [version_number])]'
+          Rake::Task.define_task(:migrate, %i[version]) do |_, args|
+            version = args[:version]
+
+            if version.nil?
+              gateway.run_migrations
+              puts "<= #{engine_name}:db:migrate executed"
+            else
+              gateway.run_migrations(target: version.to_i)
+              puts "<= #{engine_name}:db:migrate version=[#{version}] executed"
+            end
+          end
+
+          Rake.application.last_description = 'Perform migration down (removes all tables)'
+          Rake::Task.define_task(:clean) do
+            gateway.run_migrations(target: 0)
+            puts "<= #{engine_name}:db:clean executed"
+          end
+
+          Rake.application.last_description = 'Create a migration (parameters: NAME, VERSION)'
+          Rake::Task.define_task(:create_migration, %i[name version]) do |_, args|
+            name, version = args.values_at(:name, :version)
+
+            if name.nil?
+              puts "No NAME specified. Example usage:
+                `rake #{engine_name}:db:create_migration[create_users]`"
+              exit
+            end
+
+            path = gateway.migrator.create_file(*[name, version].compact)
+            puts "<= migration file created #{path}"
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/MethodLength
+    end
+  end
+end

data/lib/realm/rom/read_only_relation_wrapper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Realm
+  module ROM
+    class ReadOnlyRelationWrapper
+      FORBIDDEN_METHODS = (::ROM::SQL::Relation::Writing.instance_methods(false) + [:command]).freeze
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def method_missing(symbol, *args)
+        raise Persistence::RelationIsReadOnly, @relation if FORBIDDEN_METHODS.include?(symbol)
+
+        @relation.send(symbol, *args)
+      end
+
+      def respond_to_missing?(symbol)
+        !FORBIDDEN_METHODS.include?(symbol) && @relation.respond_to?(symbol)
+      end
+    end
+  end
+end

data/lib/realm/rom/read_only_repository_wrapper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Realm
+  module ROM
+    class ReadOnlyRepositoryWrapper
+      def initialize(repo)
+        @repo = repo.clone
+        @repo.define_singleton_method(:root) { ReadOnlyRelationWrapper.new(super()) }
+      end
+
+      def method_missing(name, *args, &block)
+        @repo.send(name, *args, &block)
+      rescue Persistence::RelationIsReadOnly
+        raise Persistence::RepositoryIsReadOnly, @repo
+      end
+
+      def respond_to_missing?(*args)
+        @repo.respond_to?(*args)
+      end
+    end
+  end
+end

data/lib/realm/rom/repository.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'rom-repository'
+
+module Realm
+  module ROM
+    class Repository < ::ROM::Repository::Root
+      # Prevents leaking of persistence details into business logic
+      class Isolated
+        def initialize(repo)
+          @repo = repo
+        end
+
+        def method_missing(*args, &block)
+          result = @repo.send(*args, &block)
+          result.is_a?(::ROM::Relation) ? result.to_a : result
+        rescue ::ROM::SQL::UniqueConstraintError
+          raise Realm::Persistence::Conflict
+        end
+
+        def respond_to_missing?(*args)
+          @repo.respond_to?(*args)
+        end
+      end
+
+      def self.new(*)
+        Isolated.new(super)
+      end
+
+      def self.repo_name(value = :not_provided)
+        @repo_name = value.to_sym unless value == :not_provided
+        @repo_name = name.demodulize.underscore unless defined?(@repo_name)
+        @repo_name
+      end
+
+      def readonly
+        @readonly ||= ROM::ReadOnlyRepositoryWrapper.new(self)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: realm-rom
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - developers@reevoo.com
@@ -156,8 +156,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
-- Rakefile
+- lib/realm-rom.rb
+- lib/realm/rom/gateway.rb
+- lib/realm/rom/plugin.rb
+- lib/realm/rom/rake_tasks.rb
+- lib/realm/rom/read_only_relation_wrapper.rb
+- lib/realm/rom/read_only_repository_wrapper.rb
+- lib/realm/rom/repository.rb
 homepage:
 licenses:
 - MIT

data/README.md

@@ -1,40 +0,0 @@
-# Realm
-
-Domain layer framework following Domain-driven/CQRS design principles.
-
-[![Build status](https://badge.buildkite.com/346cce75f6c31e0a41bb98b198e85eb6b722243624459fad9c.svg)](https://buildkite.com/reevoo/realm)
-
-## Service layers
-
-We follow the standard MVC design pattern of Rails but giving the model layer more structure and guidance regarding where
-to put your code. The model is split into domain layer (using our [Realm](https://github.com/reevoo/smart-mono/tree/master/gems/realm) library)
-and persistence layer (using [ROM](https://rom-rb.org/) library). The individual components are explained in the following section.
-
-![Service layers](https://confluence-connect.gliffy.net/embed/image/d02d04b1-5e40-415f-b7ba-3a631efa9bf3.png?utm_medium=live&utm_source=custom)
-
-Advanced components are shown in lighter color, those will be needed only later on as the service domain logic grows.
-
-## Model layer components
-
-![Service external components](https://confluence-connect.gliffy.net/embed/image/c593fcc2-304e-47c3-8e3c-b0cc09e0ed54.png?utm_medium=live&utm_source=custom)
-
-Each service has one **domain** module which consists of multiple [**aggregate**](https://martinfowler.com/bliki/DDD_Aggregate.html) modules.
-Aggregate is a cluster of domain objects that can be treated as a single unit. The only way for outer world to communicate
-with aggregate is by **queries** and **commands**. Query exposes aggregate's internal state and command changes it.
-The state of an aggregate is represented by tree of **entities** with one being the aggregate root and zero or more dependent
-entities with *belongs_to* relation to the root entity. The state of an aggregate (entity tree) is persisted
-and retrieved by **repository**. There is generally one repository per aggregate unless we split the read/write
-(query/command) persistence model for that particular domain. The repository uses **relations** to access the database
-tables. Each relation class represents one table.
-
-
-## Where to put my code as it grows?
-
-TODO
-
-
-## Roadmap
-
-- [ ] Support Ruby 3
-- [ ] Make it work outside of Rails engines
-- [ ] Support multiple persistence gateways in one runtime

data/Rakefile

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Realm'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-require 'bundler/gem_tasks'