rom-sql 1.3.5 → 2.0.0.beta1

data/spec/integration/plugins/auto_restrictions_spec.rb

@@ -39,16 +39,5 @@ RSpec.describe 'Plugins / :auto_restrictions', seeds: true do
 
       include_context 'auto-generated restriction view'
     end
-
-    it 'raises error when enabled w/o a schema' do
-      expect {
-        conf.relation(:tasks) do
-          use :auto_restrictions
-        end
-      }.to raise_error(
-             ROM::Plugins::Relation::SQL::AutoRestrictions::EmptySchemaError,
-             "ROM::Relation[Tasks] relation has no schema. Make sure :auto_restrictions is enabled after defining a schema"
-           )
-    end
   end
 end

data/spec/integration/relation_schema_spec.rb

@@ -19,6 +19,30 @@ RSpec.describe 'Inferring schema from database' do
     end
 
     context 'defining associations', seeds: false do
+      let(:config) { TestConfiguration.new(:sql, conn) }
+      let(:container) { ROM.container(config) }
+
+      let(:user_associations) do
+        config.relation(:accounts) { schema(infer: true) }
+        config.relation(:cards) { schema(infer: true) }
+        config.register_relation(Test::Users)
+        container.relations[:users].associations
+      end
+
+      let(:post_associations) do
+        config.relation(:tags) { schema(infer: true) }
+        config.relation(:posts_tags) { schema(infer: true) }
+        config.register_relation(Test::Posts)
+        container.relations[:posts].associations
+      end
+
+      let(:tag_associations) do
+        config.relation(:posts) { schema(infer: true) }
+        config.relation(:posts_tags) { schema(infer: true) }
+        config.register_relation(Test::Tags)
+        container.relations[:tags].associations
+      end
+
       it "allows defining a one-to-many" do
         class Test::Posts < ROM::Relation[:sql]
           schema(:posts) do
@@ -28,9 +52,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::OneToMany.new(:posts, :tags)
+        assoc = ROM::Associations::Definitions::OneToMany.new(:posts, :tags)
 
-        expect(Test::Posts.associations[:tags]).to eql(assoc)
+        expect(post_associations[:tags].definition).to eql(assoc)
       end
 
       it "allows defining a one-to-many using has_many shortcut" do
@@ -42,9 +66,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::OneToMany.new(:posts, :tags)
+        assoc = ROM::Associations::Definitions::OneToMany.new(:posts, :tags)
 
-        expect(Test::Posts.associations[:tags]).to eql(assoc)
+        expect(post_associations[:tags].definition).to eql(assoc)
       end
 
       it "allows defining a one-to-one" do
@@ -56,9 +80,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::OneToOne.new(:users, :accounts)
+        assoc = ROM::Associations::Definitions::OneToOne.new(:users, :accounts)
 
-        expect(Test::Users.associations[:accounts]).to eql(assoc)
+        expect(user_associations[:accounts].definition).to eql(assoc)
       end
 
       it "allows defining a one-to-one using has_one shortcut" do
@@ -70,10 +94,10 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::OneToOne.new(:users, :accounts, as: :account)
+        assoc = ROM::Associations::Definitions::OneToOne.new(:users, :accounts, as: :account)
 
-        expect(Test::Users.associations[:account]).to eql(assoc)
-        expect(Test::Users.associations[:account].target).to be_aliased
+        expect(user_associations[:account].definition).to eql(assoc)
+        expect(user_associations[:account].definition.target).to be_aliased
       end
 
       it "allows defining a one-to-one using has_one shortcut with an alias" do
@@ -85,10 +109,10 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::OneToOne.new(:users, :accounts, as: :user_account)
+        assoc = ROM::Associations::Definitions::OneToOne.new(:users, :accounts, as: :user_account)
 
-        expect(Test::Users.associations[:user_account]).to eql(assoc)
-        expect(Test::Users.associations[:user_account].target).to be_aliased
+        expect(user_associations[:user_account].definition).to eql(assoc)
+        expect(user_associations[:user_account].definition.target).to be_aliased
       end
 
       it "allows defining a one-to-one-through" do
@@ -100,9 +124,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::OneToOneThrough.new(:users, :cards, through: :accounts)
+        assoc = ROM::Associations::Definitions::OneToOneThrough.new(:users, :cards, through: :accounts)
 
-        expect(Test::Users.associations[:cards]).to eql(assoc)
+        expect(user_associations[:cards].definition).to eql(assoc)
       end
 
       it "allows defining a many-to-one" do
@@ -114,9 +138,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :posts)
+        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts)
 
-        expect(Test::Tags.associations[:posts]).to eql(assoc)
+        expect(tag_associations[:posts].definition).to eql(assoc)
       end
 
       it "allows defining a many-to-one using belongs_to shortcut" do
@@ -128,9 +152,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :posts, as: :post)
+        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts, as: :post)
 
-        expect(Test::Tags.associations[:post]).to eql(assoc)
+        expect(tag_associations[:post].definition).to eql(assoc)
       end
 
       it "allows defining a many-to-one using belongs_to shortcut" do
@@ -142,9 +166,9 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :posts, as: :post_tag)
+        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts, as: :post_tag)
 
-        expect(Test::Tags.associations[:post_tag]).to eql(assoc)
+        expect(tag_associations[:post_tag].definition).to eql(assoc)
       end
 
       it "allows defining a many-to-many" do
@@ -156,23 +180,23 @@ RSpec.describe 'Inferring schema from database' do
           end
         end
 
-        assoc = ROM::SQL::Association::ManyToMany.new(:posts, :tags, through: :posts_tags)
+        assoc = ROM::Associations::Definitions::ManyToMany.new(:posts, :tags, through: :posts_tags)
 
-        expect(Test::Posts.associations[:tags]).to eql(assoc)
+        expect(post_associations[:tags].definition).to eql(assoc)
       end
 
       it "allows defining a many-to-one with a custom name" do
         class Test::Tags < ROM::Relation[:sql]
           schema(:tags) do
             associations do
-              many_to_one :published_posts, relation: :posts
+              many_to_one :posts, as: :published_posts
             end
           end
         end
 
-        assoc = ROM::SQL::Association::ManyToOne.new(:tags, :published_posts, relation: :posts)
+        assoc = ROM::Associations::Definitions::ManyToOne.new(:tags, :posts, as: :published_posts)
 
-        expect(Test::Tags.associations[:published_posts]).to eql(assoc)
+        expect(tag_associations[:published_posts].definition).to eql(assoc)
       end
     end
   end

data/spec/integration/schema/inferrer/postgres_spec.rb

@@ -63,7 +63,7 @@ RSpec.describe 'ROM::SQL::Schema::PostgresInferrer', :postgres do
              jsonb_data: ROM::SQL::Types::PG::JSONB.optional.meta(name: :jsonb_data, source: source),
              money: ROM::SQL::Types::Decimal.meta(name: :money, source: source),
              tags: ROM::SQL::Types::PG::Array('text').optional.meta(name: :tags, source: source),
-             tag_ids: ROM::SQL::Types::PG::Array('bigint').optional.meta(name: :tag_ids, source: source),
+             tag_ids: ROM::SQL::Types::PG::Array('biging').optional.meta(name: :tag_ids, source: source),
              color: ROM::SQL::Types::String.enum(*colors).optional.meta(name: :color, source: source),
              ip: ROM::SQL::Types::PG::IPAddress.optional.meta(
                name: :ip,

data/spec/integration/schema/inferrer_spec.rb

@@ -39,12 +39,6 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
         let(:source) { ROM::Relation::Name[:tasks] }
 
         it 'can infer attributes for dataset' do |ex|
-          if mysql?(ex)
-            indexes = { index: %i(user_id).to_set }
-          else
-            indexes = {}
-          end
-
           expect(schema.to_h).
             to eql(
                  id: ROM::SQL::Types::Serial.meta(name: :id, source: source),
@@ -53,8 +47,7 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
                    name: :user_id,
                    foreign_key: true,
                    source: source,
-                   target: :users,
-                   **indexes
+                   target: :users
                  )
                )
         end
@@ -189,11 +182,11 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
         inferrable_relations.concat %i(people)
       end
 
-      let(:relation) { container.relation(:people) }
+      let(:relation) { container.relations[:people] }
 
       before do
         conf.relation(:people) do
-          schema(dataset, infer: true)
+          schema(infer: true)
         end
 
         conf.commands(:people) do
@@ -356,20 +349,16 @@ RSpec.describe 'Schema inference for common datatypes', seeds: false do
 
           index %i(bar baz), name: :composite_idx
         end
+
+        conf.relation(:test_inferrence) { schema(infer: true) }
       end
 
       let(:dataset) { :test_inferrence }
       let(:source) { ROM::Relation::Name[dataset] }
 
       it 'infers types with indices' do
-        int = ROM::SQL::Types::Int
-        expect(schema.to_h).
-          to eql(
-               id: int.meta(name: :id, source: source, primary_key: true),
-               foo: int.optional.meta(name: :foo, source: source, index: %i(foo_idx).to_set),
-               bar: int.meta(name: :bar, source: source, index: %i(bar_idx composite_idx).to_set),
-               baz: int.meta(name: :baz, source: source, index: %i(baz1_idx baz2_idx).to_set)
-             )
+        expect(schema.indexes.map(&:name)).
+          to match_array(%i(foo_idx bar_idx baz1_idx baz2_idx composite_idx))
       end
     end
   end

data/spec/integration/setup_spec.rb

@@ -8,6 +8,10 @@ RSpec.describe 'ROM.container' do
           primary_key :id
           column :name, String
         end
+
+        conf.relation(:dragons) do
+          schema(infer: true)
+        end
       end
     end
 

data/spec/integration/{plugins/auto_wrap_spec.rb → wrap_spec.rb}

@@ -1,12 +1,12 @@
-RSpec.describe 'Plugins / :auto_wrap' do
+RSpec.describe ROM::SQL::Wrap do
   with_adapters do
     include_context 'users and tasks'
 
-    describe '#for_wrap' do
+    describe '#wrap' do
       shared_context 'joined tuple' do
-        it 'returns joined tuples' do
+        it 'returns nested tuples' do
           task_with_user = tasks
-            .for_wrap({ id: :user_id }, name)
+            .wrap(name)
             .where { id.qualified.is(2) }
             .one
 
@@ -17,7 +17,7 @@ RSpec.describe 'Plugins / :auto_wrap' do
 
         it 'works with by_pk' do
           task_with_user = tasks
-                             .for_wrap({ id: :user_id }, users.name.relation)
+                             .wrap(name)
                              .by_pk(1)
                              .one
 
@@ -26,42 +26,17 @@ RSpec.describe 'Plugins / :auto_wrap' do
         end
       end
 
-      context 'when parent relation is registered under dataset name' do
-        before do
-          conf.relation(:tasks) { schema(infer: true) }
-          conf.relation(:users) { schema(infer: true) }
-        end
-
-        include_context 'joined tuple' do
-          let(:name) { :users }
-        end
-      end
-
-      context 'when parent relation is registered under a custom name' do
-        before do
-          conf.relation(:tasks) { schema(infer: true) }
-          conf.relation(:authors) { schema(:users, infer: true) }
-        end
-
-        include_context 'joined tuple' do
-          let(:users) { relations[:authors] }
-          let(:name) { :authors}
-        end
-      end
-
       context 'using association with inferred relation name' do
         before do
           conf.relation(:tasks) do
+            auto_map false
+
             schema(infer: true) do
               associations do
                 belongs_to :user
               end
             end
           end
-
-          conf.relation(:users) do
-            schema(infer: true)
-          end
         end
 
         include_context 'joined tuple' do
@@ -72,16 +47,14 @@ RSpec.describe 'Plugins / :auto_wrap' do
       context 'using association with an alias' do
         before do
           conf.relation(:tasks) do
+            auto_map false
+
             schema(infer: true) do
               associations do
                 belongs_to :users, as: :assignee
               end
             end
           end
-
-          conf.relation(:users) do
-            schema(infer: true)
-          end
         end
 
         include_context 'joined tuple' do
@@ -92,6 +65,8 @@ RSpec.describe 'Plugins / :auto_wrap' do
       context 'using association with an aliased relation' do
         before do
           conf.relation(:tasks) do
+            auto_map false
+
             schema(infer: true) do
               associations do
                 belongs_to :users, as: :assignee, relation: :people
@@ -100,6 +75,8 @@ RSpec.describe 'Plugins / :auto_wrap' do
           end
 
           conf.relation(:people) do
+            auto_map false
+
             schema(:users, infer: true)
           end
         end

data/spec/shared/accounts.rb

@@ -32,6 +32,10 @@ RSpec.shared_context 'accounts' do
       Integer :card_id
       String :service
     end
+
+    conf.relation(:accounts) { schema(infer: true) }
+    conf.relation(:cards) { schema(infer: true) }
+    conf.relation(:subscriptions) { schema(infer: true) }
   end
 
   before do |example|

data/spec/shared/database_setup.rb

@@ -29,13 +29,14 @@ RSpec.shared_context 'database setup' do
   let(:conn) { Sequel.connect(uri) }
   let(:database_type) { conn.database_type }
   let(:inferrable_relations) { [] }
-  let(:conf) { ROM::Configuration.new(:sql, conn, inferrable_relations: inferrable_relations) }
+  let(:conf) { TestConfiguration.new(:sql, conn) }
   let(:container) { ROM.container(conf) }
   let(:relations) { container.relations }
   let(:commands) { container.commands }
 
   before do
     conn.loggers << LOGGER
+    inferrable_relations.each { |name| conf.relation(name) { schema(infer: true) } }
   end
 
   after do

data/spec/shared/notes.rb

@@ -17,5 +17,7 @@ RSpec.shared_context 'notes' do
       DateTime :completed_at
       Date :written
     end
+
+    conf.relation(:notes) { schema(infer: true) }
   end
 end

data/spec/shared/posts.rb

@@ -10,6 +10,8 @@ RSpec.shared_context 'posts' do
       String :title
       String :body
     end
+
+    conf.relation(:posts) { schema(infer: true) }
   end
 
   before do |example|

data/spec/shared/puppies.rb

@@ -9,5 +9,7 @@ RSpec.shared_context 'puppies' do
       String :name, null: false
       boolean :cute, null: false, default: true
     end
+
+    conf.relation(:puppies) { schema(infer: true) }
   end
 end

data/spec/shared/relations.rb

@@ -2,7 +2,7 @@ RSpec.shared_context 'relations' do
   include_context 'users and tasks'
 
   before do
-    conf.relation(:users)
-    conf.relation(:tasks)
+    conf.relation(:users) { schema(infer: true) }
+    conf.relation(:tasks) { schema(infer: true) }
   end
 end

data/spec/shared/users.rb

@@ -19,6 +19,8 @@ RSpec.shared_context 'users' do
       String :name, text: false, null: false
       check { char_length(name) > 2 } if ctx.postgres?(example)
     end
+
+    conf.relation(:users) { schema(infer: true) }
   end
 
   before do |example|