rom-sql 0.3.2 → 0.4.0.beta1

data/lib/rom/sql/relation/associations.rb

@@ -0,0 +1,104 @@
+module ROM
+  module SQL
+    class Relation < ROM::Relation
+      module Associations
+        # Join configured association.
+        #
+        # Uses INNER JOIN type.
+        #
+        # @example
+        #
+        #   setup.relation(:tasks)
+        #
+        #   setup.relations(:users) do
+        #     one_to_many :tasks, key: :user_id
+        #
+        #     def with_tasks
+        #       association_join(:tasks, select: [:title])
+        #     end
+        #   end
+        #
+        # @api public
+        def association_join(name, options = {})
+          graph_join(name, :inner, options)
+        end
+
+        # Join configured association
+        #
+        # Uses LEFT JOIN type.
+        #
+        # @example
+        #
+        #   setup.relation(:tasks)
+        #
+        #   setup.relations(:users) do
+        #     one_to_many :tasks, key: :user_id
+        #
+        #     def with_tasks
+        #       association_left_join(:tasks, select: [:title])
+        #     end
+        #   end
+        #
+        # @api public
+        def association_left_join(name, options = {})
+          graph_join(name, :left_outer, options)
+        end
+
+        # @api private
+        def graph_join(name, join_type, options = {})
+          assoc = model.association_reflection(name)
+
+          key = assoc[:key]
+          type = assoc[:type]
+
+          if type == :many_to_many
+            select = options[:select] || {}
+            graph_join_many_to_many(name, assoc, select)
+          else
+            graph_join_other(name, key, type, join_type, options)
+          end
+        end
+
+        # @api private
+        def graph(*args)
+          __new__(dataset.__send__(__method__, *args))
+        end
+
+        private
+
+        def graph_join_many_to_many(name, assoc, select)
+          l_select, r_select =
+            if select.is_a?(Hash)
+              [select[assoc[:join_table]] || [], select[name]]
+            else
+              [[], select]
+            end
+
+          l_graph = graph(
+            assoc[:join_table],
+            { assoc[:left_key] => primary_key },
+            select: l_select, implicit_qualifier: self.name
+          )
+
+          l_graph.graph(
+            name, { primary_key => assoc[:right_key] }, select: r_select
+          )
+        end
+
+        def graph_join_other(name, key, type, join_type, options)
+          join_keys =
+            if type == :many_to_one
+              { primary_key => key }
+            else
+              { key => primary_key }
+            end
+
+          graph(
+            name, join_keys,
+            options.merge(join_type: join_type, implicit_qualifier: self.name)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/relation/class_methods.rb

@@ -0,0 +1,47 @@
+module ROM
+  module SQL
+    class Relation < ROM::Relation
+      module ClassMethods
+        def inherited(klass)
+          klass.class_eval do
+            class << self
+              attr_reader :model, :associations
+            end
+          end
+          klass.instance_variable_set('@model', Class.new(Sequel::Model))
+          klass.instance_variable_set('@associations', [])
+          super
+        end
+
+        def one_to_many(name, options)
+          associations << [__method__, name, options.merge(relation: name)]
+        end
+
+        def many_to_many(name, options = {})
+          associations << [__method__, name, options.merge(relation: name)]
+        end
+
+        def many_to_one(name, options = {})
+          new_options = options.merge(relation: Inflector.pluralize(name).to_sym)
+          associations << [__method__, name, new_options]
+        end
+
+        def finalize(relations, relation)
+          model.set_dataset(relation.dataset)
+          model.dataset.naked!
+
+          associations.each do |*args, options|
+            model = relation.model
+            other = relations[options.fetch(:relation)].model
+
+            model.public_send(*args, options.merge(class: other))
+          end
+
+          model.freeze
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/relation/inspection.rb

@@ -0,0 +1,16 @@
+module ROM
+  module SQL
+    class Relation < ROM::Relation
+      module Inspection
+        def model
+          self.class.model
+        end
+
+        # @api private
+        def primary_key
+          model.primary_key
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/repository.rb

@@ -0,0 +1,59 @@
+require 'logger'
+
+require 'rom/repository'
+require 'rom/sql/commands'
+
+module ROM
+  module SQL
+    class Repository < ROM::Repository
+      attr_reader :logger, :schema
+
+      def self.database_file?(scheme)
+        scheme.to_s.include?('sqlite')
+      end
+
+      def initialize(uri, options = {})
+        @connection = ::Sequel.connect(uri.to_s, options)
+        @schema = connection.tables
+      end
+
+      def disconnect
+        connection.disconnect
+      end
+
+      def [](name)
+        connection[name]
+      end
+
+      def use_logger(logger)
+        @logger = logger
+        connection.loggers << logger
+      end
+
+      def dataset(table)
+        connection[table]
+      end
+
+      def dataset?(name)
+        schema.include?(name)
+      end
+
+      def extend_command_class(klass, dataset)
+        type = dataset.db.database_type
+
+        if type == :postgres
+          ext =
+            if klass < Commands::Create
+              Commands::Postgres::Create
+            elsif klass < Commands::Update
+              Commands::Postgres::Update
+            end
+
+          klass.send(:include, ext) if ext
+        end
+
+        klass
+      end
+    end
+  end
+end

data/lib/rom/sql/support/rails_log_subscriber.rb

@@ -19,7 +19,7 @@ module ROM
           name = color(name, :magenta, true)
         end
 
-        debug "   #{name}  #{sql}  #{binds}"
+        debug "  #{name}  #{sql}  #{binds}"
       end
 
       def odd?

data/lib/rom/sql/tasks/migration_tasks.rake

@@ -0,0 +1,56 @@
+require "pathname"
+require "fileutils"
+
+namespace :db do
+  desc "Perform migration reset (full erase and migration up)"
+  task reset: :load_setup do
+    ROM::SQL::Migration.run(target: 0)
+    ROM::SQL::Migration.run
+    puts "<= db:reset executed"
+  end
+
+  desc "Migrate the database (options [version_number])]"
+  task :migrate, [:version] => :load_setup do |_, args|
+    version = args[:version]
+    if version.nil?
+      ROM::SQL::Migration.run
+      puts "<= db:migrate executed"
+    else
+      ROM::SQL::Migration.run(target: version.to_i)
+      puts "<= db:migrate version=[#{version}] executed"
+    end
+  end
+
+  desc "Perform migration down (erase all data)"
+  task clean: :load_setup do
+    ROM::SQL::Migration.run(target: 0)
+    puts "<= db:clean executed"
+  end
+
+  desc "Create a migration (parameters: NAME, VERSION)"
+  task :create_migration, [:name, :version] => :load_setup do |_, args|
+    name, version = args[:name], args[:version]
+
+    if name.nil?
+      puts "No NAME specified. Example usage:
+        `rake db:create_migration[create_users]`"
+      exit
+    end
+
+    version ||= Time.now.utc.strftime("%Y%m%d%H%M%S")
+
+    filename = "#{version}_#{name}.rb"
+    dirname  = ROM::SQL::Migration.path
+    path     = File.join(dirname, filename)
+
+    FileUtils.mkdir_p(dirname)
+    File.write path, <<-MIGRATION
+ROM::SQL::Migration.create do
+  change do
+  end
+end
+    MIGRATION
+
+    puts path
+  end
+end

data/lib/rom/sql/version.rb

@@ -1,5 +1,5 @@
 module ROM
   module SQL
-    VERSION = "0.3.2".freeze
+    VERSION = "0.4.0.beta1".freeze
   end
 end

data/rom-sql.gemspec

@@ -18,11 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "sequel", "~> 4.17"
+  spec.add_runtime_dependency "sequel", "~> 4.18"
   spec.add_runtime_dependency "equalizer", "~> 0.0", ">= 0.0.9"
-  spec.add_runtime_dependency "rom", "~> 0.5", ">= 0.5.0"
+  spec.add_runtime_dependency "rom", "~> 0.6.0.beta1"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rubocop", "~> 0.28.0"
 end

data/spec/integration/commands/create_spec.rb

@@ -1,15 +1,25 @@
 require 'spec_helper'
+require 'virtus'
 
 describe 'Commands / Create' do
-  include_context 'users and tasks'
+  include_context 'database setup'
 
   subject(:users) { rom.commands.users }
 
   before do
-    setup.relation(:users)
+    class Params
+      include Virtus.model
+
+      attribute :name
+
+      def self.[](input)
+        new(input)
+      end
+    end
 
     setup.commands(:users) do
       define(:create) do
+        input Params
         result :one
       end
 
@@ -17,33 +27,81 @@ describe 'Commands / Create' do
         result :many
       end
     end
+
+    setup.relation(:users)
+  end
+
+  context '#transaction' do
+    it 'create record if nothing was raised' do
+      result = users.create.transaction {
+        users.create.call(name: 'Jane')
+      }
+
+      expect(result.value).to eq(id: 1, name: 'Jane')
+    end
+
+    it 'allows for nested transactions' do
+      result = users.create.transaction {
+        users.create.transaction {
+          users.create.call(name: 'Jane')
+        }
+      }
+
+      expect(result.value).to eq(id: 1, name: 'Jane')
+    end
+
+    it 'create nothing if anything was raised' do
+      result = users.create.transaction(rollback: :always) {
+        users.create.call(name: 'Jane')
+      }
+
+      expect(result.value).to be_nil
+    end
+
+    it 'create nothing if anything was raised in any nested transaction' do
+      expect {
+        expect {
+          users.create.transaction {
+            users.create.call(name: 'John')
+            users.create.transaction {
+              users.create.call(name: 'Jane')
+              raise Exception
+            }
+          }
+        }.to raise_error(Exception)
+      }.to_not change { rom.relations.users.count }
+    end
   end
 
   it 'returns a single tuple when result is set to :one' do
-    result = users.try { create(id: 2, name: 'Jane') }
+    result = users.try { users.create.call(name: 'Jane') }
 
-    expect(result.value).to eql(id: 2, name: 'Jane')
+    expect(result.value).to eql(id: 1, name: 'Jane')
   end
 
   it 'returns tuples when result is set to :many' do
     result = users.try do
-      create_many([{ id: 2, name: 'Jane' }, { id: 3, name: 'Jack' }])
+      users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
     end
 
     expect(result.value.to_a).to match_array([
-      { id: 2, name: 'Jane' }, { id: 3, name: 'Jack' }
+      { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
     ])
   end
 
   it 'handles not-null constraint violation error' do
-    result = users.try { create(id: nil, name: 'Jane') }
+    result = users.try { users.create.call(name: nil) }
 
     expect(result.error).to be_instance_of(ROM::SQL::ConstraintError)
     expect(result.error.message).to match(/not-null/)
   end
 
   it 'handles uniqueness constraint violation error' do
-    result = users.try { create(id: 3, name: 'Piotr') }
+    result = users.try {
+      users.create.call(name: 'Jane')
+    } >-> user {
+      users.try { users.create.call(name: user[:name]) }
+    }
 
     expect(result.error).to be_instance_of(ROM::SQL::ConstraintError)
     expect(result.error.message).to match(/unique/)

data/spec/integration/commands/delete_spec.rb

@@ -21,16 +21,35 @@ describe 'Commands / Delete' do
     rom.relations.users.insert(id: 2, name: 'Jane')
   end
 
+  context '#transaction' do
+    it 'delete in normal way if no error raised' do
+      expect {
+        users.delete.transaction do
+          users.delete.by_name('Jane').call
+        end
+      }.to change { rom.relations.users.count }.by(-1)
+    end
+
+    it 'delete nothing if error was raised' do
+      expect {
+        users.delete.transaction do
+          users.delete.by_name('Jane').call
+          raise ROM::SQL::Rollback
+        end
+      }.to_not change { rom.relations.users.count }
+    end
+  end
+
   it 'raises error when tuple count does not match expectation' do
-    result = users.try { delete }
+    result = users.try { users.delete.call }
 
     expect(result.value).to be(nil)
     expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
   end
 
   it 'deletes all tuples in a restricted relation' do
-    result = users.try { delete(:by_name, 'Jane') }
+    result = users.try { users.delete.by_name('Jane').call }
 
-    expect(result.value).to eql({ id: 2, name: 'Jane' })
+    expect(result.value).to eql(id: 2, name: 'Jane')
   end
 end