rom-repository 0.2.0 → 0.3.0

data/spec/integration/command_macros_spec.rb

@@ -0,0 +1,175 @@
+RSpec.describe ROM::Repository, '.command' do
+  include_context 'database'
+  include_context 'relations'
+
+  it 'allows configuring a create command' do
+    repo = Class.new(ROM::Repository[:users]) do
+      commands :create
+    end.new(rom)
+
+    user = repo.create(name: 'Jane')
+
+    expect(user.id).to_not be(nil)
+    expect(user.name).to eql('Jane')
+  end
+
+  it 'allows configuring an update and delete commands' do
+    repo = Class.new(ROM::Repository[:users]) do
+      commands :create, update: :by_pk, delete: :by_pk
+    end.new(rom)
+
+    user = repo.create(name: 'Jane')
+
+    repo.update(user.id, name: 'Jane Doe')
+
+    user = repo.users.by_pk(user.id).one
+
+    expect(user.name).to eql('Jane Doe')
+
+    repo.delete(user.id)
+
+    expect(repo.users.by_pk(user.id).one).to be(nil)
+  end
+
+  it 'configures an update command with custom restriction' do
+    repo = Class.new(ROM::Repository[:users]) do
+      commands update: :by_name
+    end.new(rom)
+
+    repo.relations.users.insert(name: 'Jade')
+
+    user = repo.update('Jade', name: 'Jade Doe')
+    expect(user.name).to eql('Jade Doe')
+
+    expect(repo.update('Oops', name: 'Jade')).to be(nil)
+  end
+
+  it 'allows to configure update command without create one' do
+    repo = Class.new(ROM::Repository[:users]) do
+      commands update: :by_pk
+    end.new(rom)
+
+    user = repo.command(create: :users)[name: 'Jane']
+
+    repo.update(user.id, name: 'Jane Doe')
+
+    updated_user = repo.users.by_pk(user.id).one
+
+    expect(updated_user.name).to eql('Jane Doe')
+  end
+
+  it 'allows defining a single command with multiple views' do
+    repo = Class.new(ROM::Repository[:users]) do
+      commands :create, update: [:by_pk, :by_name]
+    end.new(rom)
+
+    user = repo.create(name: 'Jane')
+
+    repo.update_by_pk(user.id, name: 'Jane Doe')
+    user = repo.users.by_pk(user.id).one
+    expect(user.name).to eql('Jane Doe')
+
+    repo.update_by_name(user.name, name: 'Jane')
+    user = repo.users.by_pk(user.id).one
+    expect(user.name).to eql('Jane')
+  end
+
+  it 'uses a mapper built from AST by default' do
+    repo = Class.new(ROM::Repository[:users]) do
+      commands :create
+    end.new(rom)
+
+    user = repo.create(name: 'Jane')
+
+    expect(user).to be_kind_of ROM::Struct
+
+    struct_definition = [:users, [:header, [[:attribute, :id], [:attribute, :name]]]]
+    expect(user).to be_an_instance_of ROM::Repository::StructBuilder.cache[struct_definition.hash]
+  end
+
+  describe 'using plugins' do
+    include_context 'plugins'
+
+    before do
+      conn.alter_table :users do
+        add_column :created_at, :timestamp, null: false
+        add_column :updated_at, :timestamp, null: false
+      end
+    end
+
+    it 'allows to use plugins in generated commands' do
+      repo = Class.new(ROM::Repository[:users]) do
+        commands :create, update: :by_pk, use: :timestamps
+      end.new(rom)
+
+      user = repo.create(name: 'Jane')
+      expect(user.created_at).to be_within(1).of Time.now
+      expect(user.created_at).to eql(user.updated_at)
+
+      repo.update(user.id, **user, name: 'Jane Doe')
+      updated_user = repo.users.by_pk(user.id).one
+      expect(updated_user.created_at).to eql(user.created_at)
+      expect(updated_user.updated_at).to be > updated_user.created_at
+    end
+
+    it 'allows to use several plugins' do
+      repo = Class.new(ROM::Repository[:users]) do
+        commands :create, use: %i(upcase_name timestamps)
+      end.new(rom)
+
+      user = repo.create(name: 'Jane')
+      expect(user.created_at).to be_within(1).of Time.now
+      expect(user.name).to eql('JANE')
+    end
+  end
+
+  describe 'using custom mappers' do
+    before do
+      configuration.mappers do
+        register :users,
+                 name_list: -> users { users.map { |u| u[:name] } },
+                 id_list: -> users { users.map { |u| u[:id] } }
+      end
+    end
+
+    it 'allows to use named mapper in commands' do
+      repo = Class.new(ROM::Repository[:users]).new(rom)
+
+      name = repo.command(create: :users, mapper: :name_list).call(name: 'Jane')
+
+      expect(name).to eql('Jane')
+    end
+
+    it 'caches command pipeline using mapper option' do
+      repo = Class.new(ROM::Repository[:users]).new(rom)
+
+      c1 = repo.command(create: :users, mapper: :name_list)
+      c2 = repo.command(create: :users, mapper: :name_list)
+      c3 = repo.command(create: :users, mapper: :id_list)
+
+      name = c1.call(name: 'Jane')
+      id = c3.call(name: 'John')
+
+      expect(c1).to be c2
+      expect(c3).not_to be c1
+
+      expect(name).to eql('Jane')
+      expect(id).to eql(2)
+    end
+
+    it 'allows to set a mapper with a class-level macro' do
+      repo = Class.new(ROM::Repository[:users]) do
+        commands :create, update: :by_pk, delete: :by_pk, mapper: :name_list
+      end.new(rom)
+
+      name = repo.create(name: 'Jane')
+      expect(name).to eql('Jane')
+
+      updated_name = repo.update(1, name: 'Jane Doe')
+      expect(updated_name).to eql('Jane Doe')
+
+      deleted_name = repo.delete(1)
+      expect(deleted_name).to eql('Jane Doe')
+    end
+  end
+end

data/spec/integration/command_spec.rb

@@ -0,0 +1,224 @@
+RSpec.describe ROM::Repository, '#command' do
+  include_context 'database'
+  include_context 'relations'
+  include_context 'repo'
+
+  context 'accessing custom command from the registry' do
+    before do
+      configuration.commands(:users) do
+        define(:upsert, type: ROM::SQL::Commands::Create)
+        define(:create)
+      end
+
+      configuration.commands(:tasks) do
+        define(:create)
+      end
+    end
+
+    it 'returns registered command' do
+      expect(repo.command(:users).upsert).to be(rom.command(:users).upsert)
+      expect(repo.command(:users)[:upsert]).to be(rom.command(:users).upsert)
+    end
+
+    it 'exposes command builder DSL' do
+      command = repo.command.create(user: :users) { |user| user.create(:tasks) }
+
+      expect(command).to be_instance_of(ROM::Command::Graph)
+    end
+  end
+
+  context ':create' do
+    it 'builds Create command for a relation' do
+      create_user = repo.command(create: :users)
+
+      user = create_user.call(name: 'Jane Doe')
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane Doe')
+    end
+
+    it 'uses schema_hash for command input' do
+      create_user = repo.command(create: :users)
+      expect(create_user.input).to eql(repo.users.schema_hash)
+    end
+
+    it 'caches commands' do
+      create_user = -> { repo.command(create: :users) }
+
+      expect(create_user.()).to be(create_user.())
+    end
+
+    it 'builds Create command for a relation graph with one-to-one' do
+      create_user = repo.command(
+        :create,
+        repo.users.combine_children(one: repo.tasks)
+      )
+
+      user = create_user.call(name: 'Jane Doe', task: { title: 'Task one' })
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane Doe')
+      expect(user.task.title).to eql('Task one')
+    end
+
+    it 'builds Create command for a deeply nested relation graph' do
+      create_user = repo.command(
+        :create,
+        repo.users.combine_children(one: repo.tasks.combine_children(many: repo.tags))
+      )
+
+      user = create_user.call(
+        name: 'Jane Doe', task: { title: 'Task one', tags: [{ name: 'red' }] }
+      )
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane Doe')
+      expect(user.task.title).to eql('Task one')
+      expect(user.task.tags).to be_instance_of(Array)
+      expect(user.task.tags.first.name).to eql('red')
+    end
+
+    it 'builds Create command for a relation graph with one-to-many' do
+      create_user = repo.command(
+        :create,
+        repo.users.combine_children(many: repo.tasks)
+      )
+
+      user = create_user.call(name: 'Jane Doe', tasks: [{ title: 'Task one' }])
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane Doe')
+      expect(user.tasks).to be_instance_of(Array)
+      expect(user.tasks.first.title).to eql('Task one')
+    end
+
+    it 'builds Create command for a deeply nested graph with one-to-many' do
+      create_user = repo.command(
+        :create,
+        repo.aggregate(many: repo.tasks.combine_children(many: repo.tags))
+      )
+
+      user = create_user.call(
+        name: 'Jane',
+        tasks: [{ title: 'Task', tags: [{ name: 'red' }]}]
+      )
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane')
+      expect(user.tasks).to be_instance_of(Array)
+      expect(user.tasks.first.title).to eql('Task')
+      expect(user.tasks.first.tags).to be_instance_of(Array)
+      expect(user.tasks.first.tags.first.name).to eql('red')
+    end
+
+    it 'builds Create command for a deeply nested graph with many-to-one & one-to-many' do
+      create_user = repo.command(
+        :create,
+        repo.aggregate(one: repo.tasks.combine_children(many: repo.tags))
+      )
+
+      user = create_user.call(
+        name: 'Jane', task: { title: 'Task', tags: [{ name: 'red' }, { name: 'blue' }] }
+      )
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane')
+      expect(user.task.title).to eql('Task')
+      expect(user.task.tags).to be_instance_of(Array)
+      expect(user.task.tags.size).to be(2)
+      expect(user.task.tags[0].name).to eql('red')
+      expect(user.task.tags[1].name).to eql('blue')
+    end
+
+    it 'builds Create command for a deeply nested graph with many-to-one' do
+      create_user = repo.command(
+        :create,
+        repo.aggregate(one: repo.tasks.combine_children(one: repo.tags))
+      )
+
+      user = create_user.call(
+        name: 'Jane', task: { title: 'Task', tag: { name: 'red' } }
+      )
+
+      expect(user.id).to_not be(nil)
+      expect(user.name).to eql('Jane')
+      expect(user.task.id).to_not be(nil)
+      expect(user.task.title).to eql('Task')
+      expect(user.task.tag.id).to_not be(nil)
+      expect(user.task.tag.name).to eql('red')
+    end
+
+    it 'builds Create command for a nested graph with many-to-many' do
+      user = repo.command(:create, repo.users).(name: 'Jane')
+
+      create_post = repo.command(
+        :create, repo.posts.combine_children(many: { labels: repo.labels })
+      )
+
+      post = create_post.call(
+        author_id: user.id, title: 'Jane post', labels: [{ name: 'red' }]
+      )
+
+      expect(post.labels.size).to be(1)
+    end
+
+    context 'relation with a custom dataset name' do
+      it 'allows configuring a create command' do
+        create_comment = comments_repo.command(create: :comments)
+
+        comment = create_comment.(author: 'gerybabooma', body: 'DIS GUY MUST BE A ALIEN OR SUTIN')
+
+        expect(comment.message_id).to eql(1)
+        expect(comment.author).to eql('gerybabooma')
+        expect(comment.body).to eql('DIS GUY MUST BE A ALIEN OR SUTIN')
+      end
+
+      it 'allows configuring a create command with aliased one-to-many' do
+        pending 'custom association names in the input are not yet support'
+
+        create_comment = comments_repo.command(:create, comments_repo.comments.combine(:emotions))
+
+        comment = create_comment.(author: 'Jane',
+                                  body: 'Hello Joe',
+                                  emotions: [{ author: 'Joe' }])
+
+        expect(comment.message_id).to eql(1)
+        expect(comment.author).to eql('Jane')
+        expect(comment.body).to eql('Hello Joe')
+        expect(comment.emotions.size).to eql(1)
+        expect(comment.emotions[0].author).to eql('Joe')
+      end
+    end
+  end
+
+  context ':update' do
+    it 'builds Update command for a relation' do
+      repo.users.insert(id: 3, name: 'Jane')
+
+      update_user = repo.command(:update, repo.users)
+
+      user = update_user.by_pk(3).call(name: 'Jane Doe')
+
+      expect(user.id).to be(3)
+      expect(user.name).to eql('Jane Doe')
+    end
+  end
+
+  context ':delete' do
+    it 'builds Delete command for a relation' do
+      repo.users.insert(id: 3, name: 'Jane')
+
+      delete_user = repo.command(:delete, repo.users)
+
+      delete_user.by_pk(3).call
+
+      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

@@ -37,11 +37,11 @@ RSpec.describe 'Repository with multi-adapters configuration' do
         end
       end
 
-      class Repository < ROM::Repository
-        relations :sql_users, :memory_tasks
+      class Repository < ROM::Repository[:sql_users]
+        relations :memory_tasks
 
         def users_with_tasks(id)
-          sql_users.where(id: id).combine_children(many: { tasks: memory_tasks })
+          aggregate(many: { tasks: memory_tasks }).where(id: id)
         end
       end
     end

data/spec/integration/repository_spec.rb

@@ -8,12 +8,24 @@ RSpec.describe 'ROM repository' do
     expect(repo.all_users.to_a).to match_array([jane, joe])
   end
 
+  it 'can be used with a custom mapper' do
+    expect(repo.all_users_as_users.to_a).to match_array([
+      Test::Models::User.new(jane),
+      Test::Models::User.new(joe)
+    ])
+  end
+
   it 'loads a relation by an association' do
     expect(repo.tasks_for_users(repo.all_users)).to match_array([jane_task, joe_task])
   end
 
   it 'loads a combine relation with one parent' do
-    expect(repo.task_with_user.first).to eql(task_with_user)
+    task = repo.task_with_user.first
+
+    expect(task.id).to eql(task_with_user.id)
+    expect(task.title).to eql(task_with_user.title)
+    expect(task.user.id).to eql(task_with_user.user.id)
+    expect(task.user.name).to eql(task_with_user.user.name)
   end
 
   it 'loads a combine relation with one parent with custom tuple key' do
@@ -35,10 +47,93 @@ RSpec.describe 'ROM repository' do
   end
 
   it 'loads nested combined relations' do
-    expect(repo.users_with_tasks_and_tags.first).to eql(user_with_task_and_tags)
+    expect(repo.users_with_tasks_and_tags.first.to_h).to eql(user_with_task_and_tags.to_h)
   end
 
   it 'loads a wrapped relation' do
     expect(repo.tag_with_wrapped_task.first).to eql(tag_with_task)
   end
+
+  it 'loads an aggregate via custom fks' do
+    jane = repo.aggregate(many: repo.posts).where(name: 'Jane').one
+
+    expect(jane.posts.size).to be(1)
+    expect(jane.posts.first.title).to eql('Hello From Jane')
+  end
+
+  it 'loads an aggregate via assoc name' do
+    jane = repo.aggregate(:posts).where(name: 'Jane').one
+
+    expect(jane.posts.size).to be(1)
+    expect(jane.posts.first.title).to eql('Hello From Jane')
+  end
+
+  it 'loads an aggregate with multiple associations' do
+    jane = repo.aggregate(:posts, :labels).where(name: 'Jane').one
+
+    expect(jane.posts.size).to be(1)
+    expect(jane.posts.first.title).to eql('Hello From Jane')
+
+    expect(jane.labels.size).to be(2)
+    expect(jane.labels[0].name).to eql('red')
+    expect(jane.labels[1].name).to eql('blue')
+  end
+
+  it 'loads a parent via custom fks' do
+    post = repo.posts.combine(:author).where(title: 'Hello From Jane').one
+
+    expect(post.title).to eql('Hello From Jane')
+    expect(post.author.name).to eql('Jane')
+  end
+
+  it 'loads aggregate through many-to-many via custom options' do
+    post = repo.posts
+      .combine_children(many: repo.labels)
+      .where(title: 'Hello From Jane')
+      .one
+
+    expect(post.title).to eql('Hello From Jane')
+    expect(post.labels.size).to be(2)
+    expect(post.labels.map(&:name)).to eql(%w(red blue))
+  end
+
+  it 'loads aggregate through many-to-many association' do
+    post = repo.posts.combine(:labels).where(title: 'Hello From Jane').one
+
+    expect(post.title).to eql('Hello From Jane')
+    expect(post.labels.size).to be(2)
+    expect(post.labels.map(&:name)).to eql(%w(red blue))
+  end
+
+  context 'not common naming conventions' do
+    it 'still loads nested relations' do
+      comments = comments_repo.comments_with_likes.to_a
+
+      expect(comments.size).to be(2)
+      expect(comments[0].author).to eql('Jane')
+      expect(comments[0].likes[0].author).to eql('Joe')
+      expect(comments[0].likes[1].author).to eql('Anonymous')
+      expect(comments[1].author).to eql('Joe')
+      expect(comments[1].likes[0].author).to eql('Jane')
+    end
+
+    it 'loads nested relations by association name' do
+      comments = comments_repo.comments_with_emotions.to_a
+
+      expect(comments.size).to be(2)
+      expect(comments[0].emotions[0].author).to eql('Joe')
+      expect(comments[0].emotions[1].author).to eql('Anonymous')
+    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)
+
+      repo = Class.new(ROM::Repository[:dummy]).new(rom)
+      expect(repo.dummy.to_a).to eql([])
+    end
+  end
 end

data/spec/integration/root_repository_spec.rb

@@ -0,0 +1,88 @@
+RSpec.describe ROM::Repository::Root do
+  subject(:repo) do
+    Class.new(ROM::Repository[:users]) do
+      relations :tasks, :posts, :labels
+    end.new(rom)
+  end
+
+  include_context 'database'
+  include_context 'relations'
+
+  describe '.[]' do
+    it 'creates a pre-configured root repo class' do
+      klass = ROM::Repository[:users]
+
+      expect(klass.relations).to eql([:users])
+      expect(klass.root).to be(:users)
+
+      child = klass[:users]
+
+      expect(child.relations).to eql([:users])
+      expect(child.root).to be(:users)
+      expect(child < klass).to be(true)
+    end
+  end
+
+  describe 'inheritance' do
+    it 'inherits root and relations' do
+      klass = Class.new(repo.class)
+
+      expect(klass.relations).to eql([:users, :tasks, :posts, :labels])
+      expect(klass.root).to be(:users)
+    end
+
+    it 'creates base root class' do
+      klass = Class.new(ROM::Repository)[:users]
+
+      expect(klass.relations).to eql([:users])
+      expect(klass.root).to be(:users)
+    end
+  end
+
+  describe '#root' do
+    it 'returns configured root relation' do
+      expect(repo.root.relation).to be(rom.relations[:users])
+    end
+  end
+
+  describe '#aggregate' do
+    include_context 'seeds'
+
+    it 'builds an aggregate from the root relation and other relation(s)' do
+      user = repo.aggregate(many: repo.tasks).where(name: 'Jane').one
+
+      expect(user.name).to eql('Jane')
+      expect(user.tasks.size).to be(1)
+      expect(user.tasks[0].title).to eql('Jane Task')
+    end
+
+    context 'with associations' do
+      it 'builds an aggregate from a canonical association' do
+        user = repo.aggregate(:labels).where(name: 'Joe').one
+
+        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 a command from an aggregate' do
+        command = repo.command(:create, repo.aggregate(:posts))
+
+        result = command.call(name: 'Jade', posts: [{ title: 'Jade post' }])
+
+        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
+
+      it 'builds same relation as manual combine' do
+        left = repo.aggregate(:posts)
+        right = repo.users.combine_children(many: repo.posts)
+
+        expect(left.to_ast).to eql(right.to_ast)
+      end
+    end
+  end
+end

data/spec/shared/database.rb

@@ -1,13 +1,27 @@
 RSpec.shared_context 'database' do
-  let(:configuration) { ROM::Configuration.new(:sql, uri).use(:macros) }
+  let(:configuration) { ROM::Configuration.new(:sql, uri) }
   let(:conn) { configuration.gateways[:default].connection }
   let(:rom) { ROM.container(configuration) }
-  let(:uri) { 'postgres://localhost/rom_repository' }
+  let(:uri) do
+    if defined? JRUBY_VERSION
+      'jdbc:postgresql://localhost/rom_repository'
+    else
+      'postgres://localhost/rom_repository'
+    end
+  end
 
   before do
     conn.loggers << LOGGER
 
-    [:tags, :tasks, :users].each { |table| conn.drop_table?(table) }
+    [:tags, :tasks, :posts, :users, :posts_labels, :labels, :books,
+     :reactions, :messages].each { |table| conn.drop_table?(table) }
+
+    conn.create_table :books do
+      primary_key :id
+      column :title, String
+      column :created_at, Time
+      column :updated_at, Time
+    end
 
     conn.create_table :users do
       primary_key :id
@@ -25,5 +39,35 @@ RSpec.shared_context 'database' do
       foreign_key :task_id, :tasks, null: false, on_delete: :cascade
       column :name, String
     end
+
+    conn.create_table :labels do
+      primary_key :id
+      column :name, String
+    end
+
+    conn.create_table :posts do
+      primary_key :id
+      foreign_key :author_id, :users, null: false, on_delete: :cascade
+      column :title, String
+      column :body, String
+    end
+
+    conn.create_table :posts_labels do
+      foreign_key :post_id, :labels, null: false, on_delete: :cascade
+      foreign_key :label_id, :labels, null: false, on_delete: :cascade
+      primary_key [:post_id, :label_id]
+    end
+
+    conn.create_table :messages do
+      primary_key :message_id
+      column :author, String
+      column :body, String
+    end
+
+    conn.create_table :reactions do
+      primary_key :reaction_id
+      foreign_key :message_id, :messages, null: false
+      column :author, String
+    end
   end
 end