terrestrial 0.3.0 → 0.5.0

data/lib/terrestrial/record.rb

@@ -0,0 +1,106 @@
+require "forwardable"
+require "set"
+
+module Terrestrial
+  class Record
+    extend Forwardable
+
+    def initialize(mapping, attributes)
+      @mapping = mapping
+      @attributes = attributes
+    end
+
+    attr_reader :mapping, :attributes
+    def_delegators :to_h, :fetch
+
+    def namespace
+      mapping.namespace
+    end
+
+    def if_upsert(&block)
+      self
+    end
+
+    def if_delete(&block)
+      self
+    end
+
+    def updatable?
+      updatable_attributes.any?
+    end
+
+    def updatable_attributes
+      attributes.reject { |k, _v| non_updatable_fields.include?(k) }
+    end
+
+    def keys
+      attributes.keys
+    end
+
+    def identity_values
+      identity.values
+    end
+
+    def identity
+      attributes.select { |k,_v| identity_fields.include?(k) }
+    end
+
+    def identity_fields
+      mapping.primary_key
+    end
+
+    def merge(more_attributes)
+      new_with_attributes(attributes.merge(more_attributes))
+    end
+
+    def merge!(more_attributes)
+      attributes.merge!(more_attributes)
+    end
+
+    def reject(&block)
+      new_with_attributes(updatable_attributes.reject(&block).merge(identity))
+    end
+
+    def to_h
+      attributes.to_h
+    end
+
+    def empty?
+      updatable_attributes.empty?
+    end
+
+    def subset?(other_record)
+      mapping == other_record.mapping &&
+        to_set.subset?(other_record.to_set)
+    end
+
+    def deep_clone
+      new_with_attributes(Marshal.load(Marshal.dump(attributes)))
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        [other.mapping, other.attributes] == [mapping, attributes]
+    end
+
+    protected
+
+    def to_set
+      Set.new(attributes.to_a)
+    end
+
+    private
+
+    def non_updatable_fields
+      identity_fields + mapping.database_owned_fields + nil_fields_expecting_default_value
+    end
+
+    def nil_fields_expecting_default_value
+      mapping.database_default_fields.select { |k| attributes[k].nil? }
+    end
+
+    def new_with_attributes(new_attributes)
+      self.class.new(mapping, new_attributes)
+    end
+  end
+end

data/lib/terrestrial/relation_mapping.rb

@@ -1,29 +1,38 @@
 require "terrestrial/error"
-require "terrestrial/upserted_record"
+require "terrestrial/upsert_record"
 require "terrestrial/deleted_record"
 
 module Terrestrial
   class RelationMapping
-    def initialize(name:, namespace:, fields:, primary_key:, factory:, serializer:, associations:, subsets:)
+    def initialize(name:, namespace:, fields:, database_owned_fields:, database_default_fields:, primary_key:, factory:, serializer:, associations:, subsets:, observers:)
       @name = name
       @namespace = namespace
       @fields = fields
+      @database_owned_fields = database_owned_fields
+      @database_default_fields = database_default_fields
       @primary_key = primary_key
       @factory = factory
       @serializer = serializer
       @associations = associations
       @subsets = subsets
+      @observers = observers
+
+      @incoming_foreign_keys = []
     end
 
-    attr_reader :name, :namespace, :fields, :primary_key, :factory, :serializer, :associations, :subsets
-    private :factory, :serializer
+    attr_reader :name, :namespace, :fields, :database_owned_fields, :database_default_fields, :primary_key, :factory, :serializer, :associations, :subsets, :created_at_field, :updated_at_field, :observers
+    private :factory, :serializer, :observers
 
     def add_association(name, new_association)
       @associations = associations.merge(name => new_association)
     end
 
+    def register_foreign_key(fk)
+      @incoming_foreign_keys += fk
+    end
+
     def load(record)
-      factory.call(record)
+      factory.call(reject_non_factory_fields(record))
     rescue => e
       raise LoadError.new(namespace, factory, record, e)
     end
@@ -31,8 +40,11 @@ module Terrestrial
     def serialize(object, depth, foreign_keys = {})
       object_attributes = serializer.call(object)
 
+      record = upsertable_record(object, object_attributes, depth, foreign_keys)
+      observers.each { |o| o.post_serialize(self, object, record) }
+
       [
-        record(object_attributes, depth, foreign_keys),
+        record,
         extract_associations(object_attributes)
       ]
     rescue => e
@@ -45,12 +57,20 @@ module Terrestrial
       [deleted_record(object_attributes, depth)]
     end
 
+    def post_save(object, record, new_attributes)
+      new_record = upsertable_record(object, new_attributes, 0, {})
+
+      observers.each { |o| o.post_save(self, object, record, new_record) }
+
+      record.merge!(new_attributes)
+    end
+
     private
 
-    def record(attributes, depth, foreign_keys)
-      UpsertedRecord.new(
-        namespace,
-        primary_key,
+    def upsertable_record(object, attributes, depth, foreign_keys)
+      UpsertRecord.new(
+        self,
+        object,
         select_mapped_fields(attributes).merge(foreign_keys),
         depth,
       )
@@ -58,8 +78,7 @@ module Terrestrial
 
     def deleted_record(attributes, depth)
       DeletedRecord.new(
-        namespace,
-        primary_key,
+        self,
         attributes,
         depth,
       )
@@ -76,5 +95,17 @@ module Terrestrial
     def select_mapped_fields(attributes)
       attributes.select { |name, _value| fields.include?(name) }
     end
+
+    def reject_non_factory_fields(attributes)
+      attributes.reject { |name, _value| (@incoming_foreign_keys + local_foreign_keys).include?(name) }
+    end
+
+    def factory_fields
+      @factory_fields ||= fields - (local_foreign_keys + @incoming_foreign_keys)
+    end
+
+    def local_foreign_keys
+      @local_foreign_keys ||= associations.values.flat_map(&:local_foreign_keys)
+    end
   end
 end

data/lib/terrestrial/relational_store.rb

@@ -7,7 +7,7 @@ module Terrestrial
     include Enumerable
     include InspectionString
 
-    def initialize(mappings:, mapping_name:, datastore:, dataset:, load_pipeline:, dump_pipeline:)
+    def initialize(mappings:, mapping_name:, datastore:, load_pipeline:, dump_pipeline:, dataset: nil)
       @mappings = mappings
       @mapping_name = mapping_name
       @datastore = datastore
@@ -17,17 +17,33 @@ module Terrestrial
       @eager_data = {}
     end
 
-    attr_reader :mappings, :mapping_name, :datastore, :dataset, :load_pipeline, :dump_pipeline
-    private     :mappings, :mapping_name, :datastore, :dataset, :load_pipeline, :dump_pipeline
+    attr_reader :mappings, :mapping_name, :datastore, :load_pipeline, :dump_pipeline
+    private     :mappings, :mapping_name, :datastore, :load_pipeline, :dump_pipeline
 
     def save(graph)
-      record_dump = graph_serializer.call(mapping_name, graph)
+      record_dump = serialize_graph(graph)
 
       dump_pipeline.call(record_dump)
 
       self
     end
 
+    def changes_sql(graph)
+      changes(graph).map { |record|
+        datastore.changes_sql(record)
+      }
+    end
+
+    def changes(graph)
+      changes, _ = dump_pipeline
+        .take_until(:remove_unchanged_fields)
+        .call(
+          serialize_graph(graph)
+        )
+
+      changes
+    end
+
     def all
       self
     end
@@ -58,22 +74,20 @@ module Terrestrial
       self
     end
 
-    def delete(object, cascade: false)
+    def delete(object)
       dump_pipeline.call(
-        graph_serializer.call(mapping_name, object)
+        serialize_graph(object)
           .select { |record| record.depth == 0 }
           .reverse
           .take(1)
-          .map { |record|
-            DeletedRecord.new(record.namespace, record.identity)
-          }
+          .map { |record| DeletedRecord.new(mapping, record.attributes, 0) }
       )
     end
 
     private
 
-    def mapping
-      mappings.fetch(mapping_name)
+    def serialize_graph(graph)
+      graph_serializer.call(mapping_name, graph)
     end
 
     def eager_load_associations(mapping, parent_dataset, association_name_map)
@@ -136,6 +150,14 @@ module Terrestrial
       )
     end
 
+    def dataset
+      @dataset ||= datastore[mapping.namespace]
+    end
+
+    def mapping
+      mappings.fetch(mapping_name)
+    end
+
     def inspectable_properties
       [
         :mapping_name,

data/lib/terrestrial/upsert_record.rb

@@ -0,0 +1,54 @@
+require "terrestrial/record"
+
+module Terrestrial
+  class UpsertRecord < Record
+    def initialize(mapping, object, attributes, depth)
+      @mapping = mapping
+      @object = object
+      @attributes = attributes
+      @depth = depth
+    end
+
+    attr_reader :mapping, :object, :attributes, :depth
+
+    def id?
+      identity_values.reject(&:nil?).any?
+    end
+
+    def set_id(id)
+      raise "Cannot use #set_id with composite key" if identity_fields.length > 1
+      merge!(identity_fields[0] => id)
+    end
+
+    def get(name)
+      fetch(name)
+    end
+
+    def set(name, value)
+      merge!(name => value)
+    end
+
+    def if_upsert(&block)
+      block.call(self)
+      self
+    end
+
+    def on_upsert(new_attributes)
+      mapping.post_save(object, self, new_attributes)
+    end
+
+    def insertable
+      to_h.reject { |k, v| v.nil? && identity_fields.include?(k) }
+    end
+
+    def include?(field_name)
+      keys.include?(field_name)
+    end
+
+    private
+
+    def new_with_attributes(new_attributes)
+      self.class.new(mapping, object, new_attributes, depth)
+    end
+  end
+end

data/lib/terrestrial/version.rb

@@ -1,3 +1,3 @@
 module Terrestrial
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/spec/automatic_timestamps_spec.rb

@@ -0,0 +1,339 @@
+require "spec_helper"
+
+require "support/have_persisted_matcher"
+require "support/object_store_setup"
+require "support/seed_data_setup"
+
+RSpec.describe "Automatic timestamps", backend: "sequel" do
+  include_context "object store setup"
+
+  before(:all) do
+    create_db_timestamp_tables
+  end
+
+  after(:all) do
+    drop_db_timestamp_tables
+  end
+
+  before(:each) do
+    clean_db_timestamp_tables
+  end
+
+  let(:user_store) {
+    object_store[:users]
+  }
+
+  let(:object_store) {
+    Terrestrial.object_store(config: with_auto_timestamps_config)
+  }
+
+  let(:user_with_post) {
+    User.new(
+      id: "users/1",
+      first_name: "Hansel",
+      last_name: "Trickett",
+      email: "hansel@tricketts.org",
+      posts: [post],
+    )
+  }
+
+  let(:post) {
+    Post.new(
+      id: "posts/1",
+      author: nil,
+      subject: "Biscuits",
+      body: "I like them",
+      comments: [],
+      categories: [],
+      updated_at: nil,
+      created_at: nil,
+    )
+  }
+
+  let(:clock) {
+    StaticClock.new(Time.parse("2020-04-20T17:00:00 UTC"))
+  }
+
+  let(:with_auto_timestamps_config) {
+    Terrestrial.config(datastore, clock: clock)
+      .setup_mapping(:users) { |users|
+        users.has_many(:posts, foreign_key: :author_id)
+      }
+      .setup_mapping(:posts) { |posts|
+        posts.relation_name(:timestamped_posts)
+        posts.created_at_timestamp
+        posts.updated_at_timestamp
+      }
+  }
+
+  context "new objects" do
+    it "adds the current time to the timestamp fields" do
+      expected_timestamp = clock.now.utc
+
+      user_store.save(user_with_post)
+
+      expect(datastore).to have_persisted(
+        :timestamped_posts,
+        hash_including(
+          created_at: expected_timestamp,
+          updated_at: expected_timestamp,
+        )
+      )
+    end
+
+    it "updates the objects with the new timestamp values" do
+      expect(post).to receive(:created_at=).with(clock.now)
+      expect(post).to receive(:updated_at=).with(clock.now)
+
+      user_store.save(user_with_post)
+    end
+  end
+
+  context "after an initial successful save of the object graph" do
+    before do
+      user_store.save(user_with_post)
+    end
+
+    context "if the clock has not yet advanced" do
+      context "when saving again without modifications" do
+        it "does not perform any more database writes" do
+          expect {
+            user_store.save(user_with_post)
+          }.not_to change { query_counter.write_count }
+        end
+
+        it "does not produce any change records" do
+          expect(user_store.changes(user_with_post)).to be_empty
+        end
+      end
+    end
+
+    context "when saving modifications and the clock has advanced" do
+      before do
+        @created_at_time = clock.now
+        clock.tick
+      end
+      let(:created_at_time) { @created_at_time }
+
+      it "persists the updated_at field at the current time" do
+        current_time = clock.now
+        post.body = post.body + " edited"
+
+        user_store.save(user_with_post)
+
+        expect(datastore).to have_persisted(
+          :timestamped_posts,
+          hash_including(
+            id: post.id,
+            body: post.body,
+            updated_at: current_time,
+          )
+        )
+      end
+
+      it "updates the object's updated_at field to the current time" do
+        current_time = clock.now
+        post.body = post.body + " edited"
+
+        expect(post).to receive(:updated_at=).with(current_time)
+
+        user_store.save(user_with_post)
+      end
+
+      it "does not change the created_at time" do
+        post.body = post.body + " edited"
+
+        user_store.save(user_with_post)
+
+        expect(datastore).to have_persisted(
+          :timestamped_posts,
+          hash_including(
+            id: post.id,
+            created_at: created_at_time,
+          )
+        )
+      end
+    end
+  end
+
+  context "user modifies a the created_at field" do
+    it "persists the user's value" do
+      party_time = Time.parse("1999-01-01t00:00:00 utc")
+      post.created_at = party_time
+      user_store.save(user_with_post)
+
+      expect(datastore).to have_persisted(
+        :timestamped_posts,
+        hash_including(
+          id: post.id,
+          created_at: party_time,
+        )
+      )
+    end
+  end
+
+  context "with user-defined timestamp callbacks" do
+    before do
+      post = user_with_post.posts.first
+      change_objects_timestamp_setter_methods(post)
+    end
+
+    let(:with_auto_timestamps_config) {
+      Terrestrial.config(datastore, clock: clock)
+        .setup_mapping(:users) { |users|
+          users.has_many(:posts, foreign_key: :author_id)
+        }
+        .setup_mapping(:posts) { |posts|
+          posts.relation_name(:timestamped_posts)
+          posts.created_at_timestamp { |object, timestamp|
+            object.unconventional_created_at = timestamp
+          }
+          posts.updated_at_timestamp { |object, timestamp|
+            object.unconventional_updated_at = timestamp
+          }
+        }
+    }
+
+    it "sets the timestamps via the callbacks" do
+      post = user_with_post.posts.first
+
+      user_store.save(user_with_post)
+
+      expect(post.created_at).to eq(clock.now)
+      expect(post.updated_at).to eq(clock.now)
+    end
+
+    xcontext "if there's an error in the callback" do
+      before do
+        post = user_with_post.posts.first
+
+        def post.unconventional_updated_at=(time)
+          raise "Original error message"
+        end
+      end
+
+      it "is caught, wrapped and re-raised" do
+        expect {
+          user_store.save(user_with_post)
+        }.to raise_error(
+          "Error running user-defined setter function defined in Terrestrial mapping lib/spec/automatic_timestamps_spec.rb:183.\n" +
+          "Got Error: Original error message"
+        )
+      end
+
+      it "raises an error which has a backtrace pointing to where the callback is invoked" do
+        begin
+          user_store.save(user_with_post)
+        rescue => e
+        ensure
+          unless e
+            raise "Failed to intentionally raise error in code under test"
+          end
+
+          puts filtered_backtrace = filter_library_code_from_backtrace(e.backtrace)
+
+          actual_setter_location = /#{__FILE__}:[0-9]+:in .unconventional_created_at=/
+
+          expected_files_and_methods = [
+            actual_setter_location,
+            /time_stamp_observer\.rb:[0-9]+:in .post_save/,
+            /relation_mapping\.rb:[0-9]+:in .post_save/,
+            /upsert_record\.rb:[0-9]+:in .on_upsert/,
+            /upsert_record\.rb:[0-9]+:in .if_upsert/,
+          ]
+
+          aggregate_failures do
+            expected_files_and_methods.each do |pattern|
+              # TODO: Seems like this should be possible with an RSpec machter for a better failure message
+              expect(filtered_backtrace.any? { |l| pattern.match(l) }).to be true
+            end
+          end
+        end
+      end
+
+      def filter_library_code_from_backtrace(backtrace)
+        backtrace
+          .reject { |l| l.include?("lib/rspec") }
+          .reject { |l| l.include?("lib/bundler") }
+          .reject { |l| l.include?("lib/sequel") }
+      end
+    end
+
+    def change_objects_timestamp_setter_methods(post)
+      def post.created_at=(_)
+        raise "Should not be called"
+      end
+      def post.updated_at=(_)
+        raise "Should not be called"
+      end
+      def post.unconventional_created_at=(time)
+        @created_at = time
+      end
+      def post.unconventional_updated_at=(time)
+        @updated_at = time
+      end
+    end
+  end
+
+  def schema
+    {
+      :tables => {
+        :timestamped_posts => [
+          {
+            :name => :id,
+            :type => String,
+            :options => {
+              :primary_key => true,
+            }
+          },
+          {
+            :name => :subject,
+            :type => String,
+          },
+          {
+            :name => :body,
+            :type => String,
+          },
+          {
+            :name => :author_id,
+            :type => String,
+          },
+          {
+            :name => :created_at,
+            :type => DateTime,
+          },
+          {
+            :name => :updated_at,
+            :type => DateTime,
+          },
+        ],
+      },
+    }
+  end
+
+  def create_db_timestamp_tables
+    Terrestrial::SequelTestSupport.create_tables(schema.fetch(:tables))
+  end
+
+  def drop_db_timestamp_tables
+    Terrestrial::SequelTestSupport.drop_tables(schema.fetch(:tables).keys)
+  end
+
+  def clean_db_timestamp_tables
+    Terrestrial::SequelTestSupport.clean_tables(schema.fetch(:tables).keys)
+  end
+
+  class StaticClock
+    def initialize(time)
+      @time = time
+    end
+
+    def now
+      @time
+    end
+
+    def tick
+      @time += 1
+    end
+  end
+end