terrestrial 0.3.0 → 0.5.0

data/spec/readme_examples_spec.rb

@@ -10,7 +10,7 @@ require "support/object_store_setup"
 require "support/seed_data_setup"
 require "terrestrial"
 
-RSpec.describe "README examples" do
+RSpec.describe "README examples", backend: "sequel" do
   readme_contents = File.read("README.md")
 
   code_samples = readme_contents

data/spec/sequel_query_efficiency_spec.rb

@@ -13,11 +13,17 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
   let(:user) { user_query.first }
 
   context "when loading the root node" do
+    before { preload_user_store_to_avoid_counting_startup_queries }
+
     it "only performs one read" do
       expect {
-        user
+        user_query.first
       }.to change { query_counter.read_count }.by(1)
     end
+
+    def preload_user_store_to_avoid_counting_startup_queries
+      user_store
+    end
   end
 
   context "when traversing associations (lazily)" do
@@ -89,20 +95,17 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
         user.email = modified_email
       end
 
-      it "performs 1 update" do
+      it "performs 1 write" do
         expect {
           user_store.save(user)
-        }.to change { query_counter.update_count }.by(1)
+        }.to change { query_counter.write_count }.by(1)
       end
 
       it "sends only the updated fields to the datastore" do
         user_store.save(user)
-        update_sql = query_counter.updates.last
+        upsert_sql = query_counter.upserts.last
 
-        # TODO: SQL parser?
-        expect(update_sql).to eq(
-          %{UPDATE "users" SET "email" = '#{modified_email}' WHERE ("id" = '#{user.id}')}
-        )
+        expect(upsert_sql).not_to include(user.first_name, user.last_name)
       end
     end
   end
@@ -117,7 +120,7 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
     it "performs 1 update" do
       expect {
         user_store.save(user)
-      }.to change { query_counter.update_count }.by(1)
+      }.to change { query_counter.write_count }.by(1)
     end
 
     it "performs 0 deletes" do
@@ -126,7 +129,7 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
       }.to change { query_counter.delete_count }.by(0)
     end
 
-    it "performs 0 additional reads" do
+    xit "performs 0 additional reads" do
       expect {
         user_store.save(user)
       }.to change { query_counter.read_count }.by(0)
@@ -146,7 +149,7 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
       it "performs 1 write" do
         expect {
           user_store.save(user)
-        }.to change { query_counter.update_count }.by(1)
+        }.to change { query_counter.write_count }.by(1)
       end
     end
 
@@ -160,7 +163,7 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
       it "performs 1 update" do
         expect {
           user_store.save(user)
-        }.to change { query_counter.update_count }.by(1)
+        }.to change { query_counter.write_count }.by(1)
       end
     end
 
@@ -175,7 +178,7 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
       it "performs 2 updates" do
         expect {
           user_store.save(user)
-        }.to change { query_counter.update_count }.by(2)
+        }.to change { query_counter.write_count }.by(2)
       end
     end
   end
@@ -191,12 +194,12 @@ RSpec.describe "Sequel query efficiency", backend: "sequel" do
     it "performs 1 write" do
         expect {
           user_store.save(user)
-        }.to change { query_counter.update_count }.by(1)
+        }.to change { query_counter.write_count }.by(1)
     end
   end
 
-  context "when traversing assocations (eagerly)" do
-    context "laoding `#all` from the object store with one assocation" do
+  context "when traversing association (eagerly)" do
+    context "laoding `#all` from the object store with one association" do
       it "performs 1 read per table rather than n + 1" do
         expect {
           user_store.eager_load(:posts => []).all.map { |user|

data/spec/spec_helper.rb

@@ -3,6 +3,8 @@ require "support/sequel_test_support"
 require "support/memory_adapter_test_support"
 require "support/blog_schema"
 
+Warning[:deprecated] = false
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
@@ -44,7 +46,10 @@ RSpec.configure do |config|
   end
 
   RSpec.shared_context "adapter setup" do
-    let(:datastore) { adapter_support.build_datastore(schema) }
+    define_method(:datastore) do
+      @datastore ||= adapter_support.build_datastore(schema)
+    end
+
     let(:query_counter) { adapter_support.query_counter }
   end
 

data/spec/support/blog_schema.rb

@@ -12,6 +12,7 @@ BLOG_SCHEMA = {
       { name: :body, type: String },
       { name: :author_id, type: String},
       { name: :created_at, type: DateTime },
+      { name: :updated_at, type: DateTime },
     ],
     comments: [
       { name: :id, type: String, options: { primary_key: true } },
@@ -24,15 +25,18 @@ BLOG_SCHEMA = {
       { name: :name, type: String },
     ],
     categories_to_posts: [
-      { name: :post_id, type: String },
-      { name: :category_id, type: String },
+      { name: :post_id, type: String, options: { null: false } },
+      { name: :category_id, type: String, options: { null: false } },
     ],
   },
+  unique_indexes: [
+    # [:categories_to_posts, :post_id, :category_id]
+  ],
   foreign_keys: [
     [:posts, :author_id, :users, :id],
     [:comments, :post_id, :posts, :id],
     [:comments, :commenter_id, :users, :id],
-    [:categories_to_posts, :post_id, :posts, :id],
+    [:categories_to_posts, :post_id, :posts, :id, on_delete: :cascade],
     [:categories_to_posts, :category_id, :categories, :id],
   ]
 }

data/spec/support/object_graph_setup.rb

@@ -8,6 +8,14 @@ RSpec.shared_context "object graph setup" do
   end
 
   def setup_circular_references_avoiding_stack_overflow
+    biscuits_post.author = hansel
+    sleep_post.author = hansel
+
+    hansel.posts = [
+      biscuits_post,
+      sleep_post,
+    ]
+
     biscuits_post_comment.commenter = hansel
     cat_biscuits_category.posts = [ biscuits_post ]
   end
@@ -26,9 +34,16 @@ RSpec.shared_context "object graph setup" do
     end
 
     def initialize(attrs)
-      members.sort == attrs.keys.sort or (
-        raise(ArgumentError.new("Expected `#{self.class.members}` got `#{attrs.keys}"))
-      )
+      if members.sort != attrs.keys.sort
+        missing = (members - attrs.keys).sort
+        unexpected = (attrs.keys - members).sort
+        raise(ArgumentError.new(
+          "#{self.class} initialized with incorrect arguments." \
+          "Missing: #{missing}. " \
+          "Unexpected: #{unexpected}. " \
+          "Received: #{attrs.keys}."
+        ))
+      end
 
       members.each { |member| send("#{member}=", attrs.fetch(member)) }
     end
@@ -43,51 +58,24 @@ RSpec.shared_context "object graph setup" do
   end
 
   User ||= PlainObject.with_members(:id, :first_name, :last_name, :email, :posts)
-  Post ||= PlainObject.with_members(:id, :subject, :body, :comments, :categories, :created_at)
+  Post ||= PlainObject.with_members(:id, :author, :subject, :body, :comments, :categories, :created_at, :updated_at)
   Comment ||= PlainObject.with_members(:id, :commenter, :body)
   Category ||= PlainObject.with_members(:id, :name, :posts)
 
-  let(:factories) {
-    {
-      users: User.method(:new),
-      posts: Post.method(:new),
-      comments: Comment.method(:new),
-      categories: Category.method(:new),
-      categories_to_posts: ->(x){x},
-      noop: ->(x){x},
-    }
-  }
-
-  let(:default_serializer) {
-    ->(fields) {
-      ->(object) {
-        Terrestrial::Serializer.new(fields, object).to_h
-      }
-    }
-  }
-
-  let(:null_serializer) {
-    ->(_fields) {
-      ->(x){x}
-    }
-  }
-
   let(:hansel) {
-    factories.fetch(:users).call(
+    User.new(
       id: "users/1",
       first_name: "Hansel",
       last_name: "Trickett",
       email: "hansel@tricketts.org",
-      posts: [
-        biscuits_post,
-        sleep_post,
-      ],
+      posts: [],
     )
   }
 
   let(:biscuits_post) {
-    factories.fetch(:posts).call(
+    Post.new(
       id: "posts/1",
+      author: nil,
       subject: "Biscuits",
       body: "I like them",
       comments: [
@@ -97,12 +85,14 @@ RSpec.shared_context "object graph setup" do
         cat_biscuits_category,
       ],
       created_at: Time.parse("2015-09-05T15:00:00+01:00"),
+      updated_at: Time.parse("2015-09-05T15:00:00+01:00"),
     )
   }
 
   let(:sleep_post) {
-    factories.fetch(:posts).call(
+    Post.new(
       id: "posts/2",
+      author: nil,
       subject: "Sleeping",
       body: "I do it three times purrr day",
       comments: [],
@@ -110,11 +100,12 @@ RSpec.shared_context "object graph setup" do
         chilling_category,
       ],
       created_at: Time.parse("2015-09-02T15:00:00+01:00"),
+      updated_at: Time.parse("2015-09-02T15:00:00+01:00"),
     )
   }
 
   let(:biscuits_post_comment) {
-    factories.fetch(:comments).call(
+    Comment.new(
       id: "comments/1",
       body: "oh noes",
       commenter: nil,
@@ -122,7 +113,7 @@ RSpec.shared_context "object graph setup" do
   }
 
   let(:cat_biscuits_category) {
-    factories.fetch(:categories).call(
+    Category.new(
       id: "categories/1",
       name: "Cat biscuits",
       posts: [],
@@ -130,7 +121,7 @@ RSpec.shared_context "object graph setup" do
   }
 
   let(:chilling_category) {
-    factories.fetch(:categories).call(
+    Category.new(
       id: "categories/2",
       name: "Chillaxing",
       posts: [],

data/spec/support/object_store_setup.rb

@@ -15,207 +15,27 @@ require "support/object_graph_setup"
 RSpec.shared_context "object store setup" do
   include_context "object graph setup"
 
+  let(:user_store) { object_store[:users] }
+
   let(:object_store) {
-    Terrestrial.object_store(mappings: mappings, datastore: datastore)
+    Terrestrial.object_store(config: mappings)
   }
 
-  let(:user_store) { object_store[:users] }
-
   let(:mappings) {
-    Hash[
-      configs.map { |name, config|
-        fields = config.fetch(:fields) + config.fetch(:associations).keys
-
-        associations = config.fetch(:associations).map { |assoc_name, assoc_config|
-          [
-            assoc_name,
-            case assoc_config.fetch(:type)
-            when :one_to_many
-              Terrestrial::OneToManyAssociation.new(
-                **assoc_defaults.merge(
-                  assoc_config.dup.tap { |h| h.delete(:type) }
-                )
-              )
-            when :many_to_one
-              Terrestrial::ManyToOneAssociation.new(
-                assoc_config.dup.tap { |h| h.delete(:type) }
-              )
-            when :many_to_many
-              Terrestrial::ManyToManyAssociation.new(
-                **assoc_defaults
-                  .merge(
-                    join_mapping_name: assoc_config.fetch(:join_mapping_name),
-                  )
-                  .merge(
-                    assoc_config.dup.tap { |h|
-                      h.delete(:type)
-                      h.delete(:join_namespace)
-                    }
-                  )
-              )
-            else
-              raise "Association type not supported"
-            end
-          ]
-        }
-
-        [
-          name,
-          Terrestrial::RelationMapping.new(
-            name: name,
-            namespace: config.fetch(:namespace),
-            fields: config.fetch(:fields),
-            primary_key: config.fetch(:primary_key),
-            serializer: serializers.fetch(config.fetch(:serializer)).call(fields),
-            associations: Hash[associations],
-            factory: factories.fetch(name),
-            subsets: Terrestrial::SubsetQueriesProxy.new(config.fetch(:subsets, {}))
-          )
-        ]
+    Terrestrial.config(datastore)
+      .setup_mapping(:users) { |users|
+        users.has_many(:posts, foreign_key: :author_id)
       }
-    ]
-  }
-
-  def assoc_defaults
-    {
-      order: Terrestrial::QueryOrder.new(fields: [], direction: "ASC")
-    }
-  end
-
-  let(:has_many_proxy_factory) {
-    ->(query:, loader:, mapping_name:) {
-      Terrestrial::CollectionMutabilityProxy.new(
-        Terrestrial::LazyCollection.new(
-          query,
-          loader,
-          mappings.fetch(mapping_name).subsets,
-        )
-      )
-    }
-  }
-
-  let(:many_to_one_proxy_factory) {
-    ->(query:, loader:, preloaded_data:) {
-      Terrestrial::LazyObjectProxy.new(
-        ->{ loader.call(query.first) },
-        preloaded_data,
-      )
-    }
-  }
-
-  let(:serializers) {
-    {
-      default: default_serializer,
-      null: null_serializer,
-    }
-  }
-
-  let(:configs) {
-    {
-      users: {
-        namespace: :users,
-        primary_key: [:id],
-        fields: [
-          :id,
-          :first_name,
-          :last_name,
-          :email,
-        ],
-        factory: :user,
-        serializer: :default,
-        associations: {
-          posts: {
-            type: :one_to_many,
-            mapping_name: :posts,
-            foreign_key: :author_id,
-            key: :id,
-            proxy_factory: has_many_proxy_factory,
-          }
-        },
-      },
-
-      posts: {
-        namespace: :posts,
-        primary_key: [:id],
-        fields: [
-          :id,
-          :subject,
-          :body,
-          :created_at,
-        ],
-        factory: :post,
-        serializer: :default,
-        associations: {
-          comments: {
-            type: :one_to_many,
-            mapping_name: :comments,
-            foreign_key: :post_id,
-            key: :id,
-            proxy_factory: has_many_proxy_factory,
-          },
-          categories: {
-            type: :many_to_many,
-            mapping_name: :categories,
-            key: :id,
-            foreign_key: :post_id,
-            association_foreign_key: :category_id,
-            association_key: :id,
-            join_mapping_name: :categories_to_posts,
-            proxy_factory: has_many_proxy_factory,
-          },
-        },
-      },
-
-      comments: {
-        namespace: :comments,
-        primary_key: [:id],
-        fields: [
-          :id,
-          :body,
-        ],
-        factory: :comment,
-        serializer: :default,
-        associations: {
-          commenter: {
-            type: :many_to_one,
-            mapping_name: :users,
-            key: :id,
-            foreign_key: :commenter_id,
-            proxy_factory: many_to_one_proxy_factory,
-          },
-        },
-      },
-
-      categories: {
-        namespace: :categories,
-        primary_key: [:id],
-        fields: [
-          :id,
-          :name,
-        ],
-        factory: :comment,
-        serializer: :default,
-        associations: {
-          posts: {
-            type: :many_to_many,
-            mapping_name: :posts,
-            key: :id,
-            foreign_key: :category_id,
-            association_foreign_key: :post_id,
-            association_key: :id,
-            join_mapping_name: :categories_to_posts,
-            proxy_factory: has_many_proxy_factory,
-          },
-        },
-      },
-
-      categories_to_posts: {
-        namespace: :categories_to_posts,
-        primary_key: [:category_id, :post_id],
-        fields: [],
-        serializer: :null,
-        associations: {},
+      .setup_mapping(:posts) { |posts|
+        posts.belongs_to(:author, mapping_name: :users)
+        posts.has_many(:comments)
+        posts.has_many_through(:categories)
+      }
+      .setup_mapping(:comments) { |comments|
+        comments.belongs_to(:commenter, mapping_name: :users)
+      }
+      .setup_mapping(:categories) { |categories|
+        categories.has_many_through(:posts)
       }
-    }
   }
 end