rom-repository 0.3.1 → 1.0.0.beta1

data/lib/rom/repository/root.rb

@@ -1,3 +1,5 @@
+require 'dry/core/class_attributes'
+
 module ROM
   class Repository
     # A specialized repository type dedicated to work with a root relation
@@ -27,7 +29,7 @@ module ROM
     #
     # @api public
     class Root < Repository
-      extend ClassMacros
+      extend Dry::Core::ClassAttributes
 
       defines :root
 
@@ -70,11 +72,7 @@ module ROM
       #
       # @api public
       def aggregate(*args)
-        if args[0].is_a?(Hash) && args.size == 1
-          root.combine_children(args[0])
-        else
-          root.combine(*args)
-        end
+        root.combine(*args)
       end
 
       # @overload changeset(name, *args)

data/lib/rom/repository/session.rb

@@ -0,0 +1,55 @@
+require 'dry/equalizer'
+
+module ROM
+  class Session
+    include Dry::Equalizer(:queue, :status)
+
+    attr_reader :repo
+
+    attr_reader :queue
+
+    attr_reader :status
+
+    def initialize(repo)
+      @repo = repo
+      @status = :pending
+      initialize_queue!
+    end
+
+    def add(changeset)
+      queue << changeset
+      self
+    end
+
+    def commit!
+      queue.map(&:command).compact.each(&:call)
+
+      @status = :success
+
+      self
+    rescue => e
+      @status = :failure
+      raise e
+    ensure
+      initialize_queue!
+    end
+
+    def pending?
+      status.equal?(:pending)
+    end
+
+    def success?
+      status.equal?(:success)
+    end
+
+    def failure?
+      status.equal?(:failure)
+    end
+
+    private
+
+    def initialize_queue!
+      @queue = []
+    end
+  end
+end

data/lib/rom/repository/struct_builder.rb

@@ -1,24 +1,26 @@
-require 'rom/struct'
-
-require 'rom/support/cache'
-require 'rom/support/constants'
-require 'rom/support/class_builder'
+require 'dry/core/inflector'
+require 'dry/core/cache'
+require 'dry/core/class_builder'
 
-require 'rom/repository/struct_attributes'
+require 'rom/struct'
+require 'rom/schema/type'
 
 module ROM
   class Repository
     # @api private
     class StructBuilder
-      extend Cache
+      extend Dry::Core::Cache
 
       def call(*args)
         fetch_or_store(*args) do
           name, header = args
+          attributes = visit(header).compact
 
-          build_class(name) { |klass|
-            klass.send(:include, StructAttributes.new(visit(header)))
-          }
+          build_class(name, ROM::Struct) do |klass|
+            attributes.each do |(name, type)|
+              klass.attribute(name, type)
+            end
+          end
         end
       end
       alias_method :[], :call
@@ -35,20 +37,30 @@ module ROM
       end
 
       def visit_relation(node)
-        relation_name, meta, * = node
-        meta[:combine_name] || relation_name.relation
+        relation_name, meta, header = node
+        name = meta[:combine_name] || relation_name.relation
+
+        model = call(name, header)
+
+        if meta[:combine_type] == :many
+          [name, Types::Array.member(model)]
+        else
+          [name, model.optional]
+        end
       end
 
-      def visit_attribute(node)
-        node
+      def visit_attribute(attr)
+        unless attr.foreign_key?
+          [attr.aliased? && !attr.wrapped? ? attr.alias : attr.name, attr.type]
+        end
       end
 
-      def build_class(name, &block)
-        ROM::ClassBuilder.new(name: class_name(name), parent: Struct).call(&block)
+      def build_class(name, parent, &block)
+        Dry::Core::ClassBuilder.new(name: class_name(name), parent: parent).call(&block)
       end
 
       def class_name(name)
-        "ROM::Struct[#{Inflector.classify(Inflector.singularize(name))}]"
+        "ROM::Struct[#{Dry::Core::Inflector.classify(Dry::Core::Inflector.singularize(name))}]"
       end
     end
   end

data/lib/rom/repository/version.rb

@@ -1,5 +1,5 @@
 module ROM
   class Repository
-    VERSION = '0.3.1'.freeze
+    VERSION = '1.0.0.beta1'.freeze
   end
 end

data/lib/rom/struct.rb

@@ -1,37 +1,28 @@
+require 'dry/struct'
+
 module ROM
   # Simple data-struct
   #
   # By default mappers use this as the model
   #
   # @api public
-  class Struct
-    # Coerces a struct to a hash
-    #
-    # @return [Hash]
-    #
-    # @api private
-    def to_hash
-      to_h
-    end
-
-    # Reads an attribute value
-    #
-    # @param name [Symbol] The name of the attribute
+  class Struct < Dry::Struct
+    # Returns a short string representation
     #
-    # @return [Object]
+    # @return [String]
     #
     # @api public
-    def [](name)
-      __send__(name)
+    def to_s
+      "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
     end
 
-    # Returns a short string representation
+    # Return attribute value
     #
-    # @return [String]
+    # @param [Symbol] name The attribute name
     #
     # @api public
-    def to_s
-      "#<#{self.class}:0x#{(object_id << 1).to_s(16)}>"
+    def fetch(name)
+      __send__(name)
     end
   end
 end

data/rom-repository.gemspec

@@ -15,9 +15,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
-  gem.add_runtime_dependency 'rom', '~> 2.0'
-  gem.add_runtime_dependency 'rom-support', '~> 2.0'
-  gem.add_runtime_dependency 'rom-mapper', '~> 0.4'
+  gem.add_runtime_dependency 'rom', '~> 3.0.0.beta'
+  gem.add_runtime_dependency 'rom-mapper', '~> 0.5.0.beta'
+  gem.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.1'
+  gem.add_runtime_dependency 'dry-struct', '~> 0.1'
 
   gem.add_development_dependency 'rake', '~> 11.2'
   gem.add_development_dependency 'rspec', '~> 3.5'

data/spec/integration/command_macros_spec.rb

@@ -81,9 +81,12 @@ RSpec.describe ROM::Repository, '.command' do
 
     user = repo.create(name: 'Jane')
 
-    expect(user).to be_kind_of ROM::Struct
+    expect(user).to be_kind_of Dry::Struct
+
+    struct_definition = [:users, [:header, [
+                                    [:attribute, repo.users.schema[:id]],
+                                    [:attribute, repo.users.schema[:name]]]]]
 
-    struct_definition = [:users, [:header, [[:attribute, :id], [:attribute, :name]]]]
     expect(user).to be_an_instance_of ROM::Repository::StructBuilder.cache[struct_definition.hash]
   end
 

data/spec/integration/command_spec.rb

@@ -215,10 +215,4 @@ RSpec.describe ROM::Repository, '#command' do
       expect(repo.users.by_pk(3).one).to be(nil)
     end
   end
-
-  it 'raises error when unsupported type is used' do
-    expect { repo.command(:oops, repo.users) }.to raise_error(
-      ArgumentError, /oops/
-    )
-  end
 end

data/spec/integration/multi_adapter_spec.rb

@@ -15,21 +15,24 @@ RSpec.describe 'Repository with multi-adapters configuration' do
   before do
     module Test
       class Users < ROM::Relation[:sql]
-        dataset :users
-        register_as :sql_users
         gateway :default
+        schema(:users, infer: true)
+        register_as :sql_users
       end
 
       class Tasks < ROM::Relation[:memory]
-        dataset :tasks
+        schema(:tasks) do
+          attribute :user_id, ROM::Types::Int
+          attribute :title, ROM::Types::String
+        end
+
         register_as :memory_tasks
         gateway :memory
 
-        use :view
         use :key_inference
 
         view(:base, [:user_id, :title]) do
-          project(:user_id, :title)
+          self
         end
 
         def for_users(users)

data/spec/integration/repository_spec.rb

@@ -47,7 +47,23 @@ RSpec.describe 'ROM repository' do
   end
 
   it 'loads nested combined relations' do
-    expect(repo.users_with_tasks_and_tags.first.to_h).to eql(user_with_task_and_tags.to_h)
+    user = repo.users_with_tasks_and_tags.first
+
+    expect(user.id).to be(1)
+    expect(user.name).to eql('Jane')
+    expect(user.all_tasks.size).to be(1)
+    expect(user.all_tasks[0].id).to be(2)
+    expect(user.all_tasks[0].title).to eql('Jane Task')
+    expect(user.all_tasks[0].tags.size).to be(1)
+    expect(user.all_tasks[0].tags[0].name).to eql('red')
+  end
+
+  it 'loads nested combined relations using configured associations' do
+    jane = repo.users_with_posts_and_their_labels.first
+
+    expect(jane.posts.size).to be(1)
+    expect(jane.posts.map(&:title)).to eql(['Hello From Jane'])
+    expect(jane.posts.flat_map(&:labels).flat_map(&:name)).to eql(%w(red blue))
   end
 
   it 'loads a wrapped relation' do
@@ -105,6 +121,22 @@ RSpec.describe 'ROM repository' do
     expect(post.labels.map(&:name)).to eql(%w(red blue))
   end
 
+  it 'loads multiple child relations' do
+    user = repo.users.combine_children(many: [repo.posts, repo.tasks]).where(name: 'Jane').one
+
+    expect(user.name).to eql('Jane')
+    expect(user.posts.size).to be(1)
+    expect(user.posts[0].title).to eql('Hello From Jane')
+    expect(user.tasks.size).to be(1)
+    expect(user.tasks[0].title).to eql('Jane Task')
+  end
+
+  it 'loads multiple parent relations' do
+    post_label = repo.posts_labels.combine_parents(one: [repo.posts]).first
+
+    expect(post_label.post.title).to eql('Hello From Jane')
+  end
+
   context 'not common naming conventions' do
     it 'still loads nested relations' do
       comments = comments_repo.comments_with_likes.to_a
@@ -126,11 +158,35 @@ RSpec.describe 'ROM repository' do
     end
   end
 
+  describe 'projecting virtual attributes' do
+    it 'loads auto-mapped structs' do
+      user = repo.users.
+               inner_join(:posts, author_id: :id).
+               select_group { [id.qualified, name.qualified] }.
+               select_append { int::count(:posts).as(:post_count) }.
+               having { count(id.qualified) >= 1 }.
+               first
+
+      expect(user.id).to be(1)
+      expect(user.name).to eql('Jane')
+      expect(user.post_count).to be(1)
+    end
+  end
+
+  describe 'projecting aliased attributes' do
+    it 'loads auto-mapped structs' do
+      user = repo.users.select { [id.aliased(:userId), name.aliased(:userName)] }.first
+
+      expect(user.userId).to be(1)
+      expect(user.userName).to eql('Jane')
+    end
+  end
+
   context 'with a table without columns' do
     before { conn.create_table(:dummy) unless conn.table_exists?(:dummy) }
 
     it 'does not fail with a weird error when a relation does not have attributes' do
-      configuration.relation(:dummy)
+      configuration.relation(:dummy) { schema(infer: true) }
 
       repo = Class.new(ROM::Repository[:dummy]).new(rom)
       expect(repo.dummy.to_a).to eql([])

data/spec/integration/root_repository_spec.rb

@@ -62,10 +62,18 @@ RSpec.describe ROM::Repository::Root do
 
         expect(user.name).to eql('Joe')
         expect(user.labels.size).to be(1)
-        expect(user.labels[0].author_id).to be(user.id)
         expect(user.labels[0].name).to eql('green')
       end
 
+      it 'builds an aggregate with nesting level = 2' do
+        user = repo.aggregate(posts: [:labels, :author]).where(name: 'Joe').one
+
+        expect(user.name).to eql('Joe')
+        expect(user.posts.size).to be(1)
+        expect(user.posts[0].title).to eql('Hello From Joe')
+        expect(user.posts[0].labels.size).to be(1)
+      end
+
       it 'builds a command from an aggregate' do
         command = repo.command(:create, repo.aggregate(:posts))
 
@@ -73,7 +81,6 @@ RSpec.describe ROM::Repository::Root do
 
         expect(result.name).to eql('Jade')
         expect(result.posts.size).to be(1)
-        expect(result.posts[0].author_id).to be(result.id)
         expect(result.posts[0].title).to eql('Jade post')
       end
 

data/spec/integration/typed_structs_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe 'ROM repository with typed structs' do
+  subject(:repo) do
+    Class.new(ROM::Repository[:books]).new(rom)
+  end
+
+  include_context 'database'
+  include_context 'seeds'
+
+  before do
+    configuration.relation(:books) do
+      schema(infer: true)
+
+      view(:index) do
+        schema { project(:id, :title, :created_at) }
+        relation { order(:title) }
+      end
+    end
+
+    rom.relations[:books].insert(title: 'Hello World', created_at: Time.now)
+  end
+
+  it 'loads typed structs' do
+    book = repo.books.index.first
+
+    expect(book).to be_kind_of(Dry::Struct)
+
+    expect(book.id).to be_kind_of(Integer)
+    expect(book.title).to eql('Hello World')
+    expect(book.created_at).to be_kind_of(Time)
+  end
+end

data/spec/shared/database.rb

@@ -48,7 +48,7 @@ RSpec.shared_context 'database' do
     conn.create_table :posts do
       primary_key :id
       foreign_key :author_id, :users, null: false, on_delete: :cascade
-      column :title, String
+      column :title, String, null: false
       column :body, String
     end
 
@@ -70,4 +70,8 @@ RSpec.shared_context 'database' do
       column :author, String
     end
   end
+
+  after do
+    rom.disconnect
+  end
 end