terrestrial 0.3.0 → 0.5.0

data/lib/terrestrial/adapters/sequel_postgres_adapter.rb

@@ -0,0 +1,191 @@
+require "forwardable"
+require "terrestrial/adapters/abstract_adapter"
+
+module Terrestrial
+  module WrapDelegate
+    def wrap_delegators(target_name, method_names)
+      method_names.each do |method_name|
+        define_method(method_name) do |*args, &block|
+          self.class.new(
+            send(target_name).public_send(method_name, *args, &block)
+          )
+        end
+      end
+    end
+  end
+
+  module SequelDatasetComparisonLiteralAppendPatch
+    def ===(other)
+      other.is_a?(Adapters::SequelPostgresAdapter::Dataset) or
+        super
+    end
+  end
+
+  Sequel::Dataset.extend(SequelDatasetComparisonLiteralAppendPatch)
+
+  module Adapters
+    class SequelPostgresAdapter
+      extend Forwardable
+      include Adapters::AbstractAdapter
+
+      def initialize(database)
+        @database = database
+      end
+
+      attr_reader :database
+      private     :database
+
+      def_delegators :database, *[
+        :transaction,
+        :tables,
+      ]
+
+      def [](table_name)
+        Dataset.new(database[table_name])
+      end
+
+      def upsert(record)
+        row = perform_upsert_returning_row(record)
+        record.on_upsert(row)
+        nil
+      rescue Object => e
+        raise UpsertError.new(record.namespace, record.to_h, e)
+      end
+
+      def delete(record)
+        database[record.namespace].where(record.identity).delete
+      end
+
+      def changes_sql(record)
+        generate_upsert_sql(record)
+      rescue Object => e
+        raise UpsertError.new(record.namespace, record.to_h, e)
+      end
+
+      def conflict_fields(table_name)
+        primary_key(table_name)
+      end
+
+      def primary_key(table_name)
+        [database.primary_key(table_name)]
+          .compact
+          .map(&:to_sym)
+      end
+
+      def unique_indexes(table_name)
+        database.indexes(table_name).map { |_name, data|
+          data.fetch(:columns)
+        }
+      end
+
+      def relations
+        database.tables - [:schema_migrations]
+      end
+
+      def relation_fields(relation_name)
+        database[relation_name].columns
+      end
+
+      def schema(relation_name)
+        database.schema(relation_name)
+      end
+
+      private
+
+      def perform_upsert_returning_row(record)
+        sql = generate_upsert_sql(record)
+        result = database[sql]
+          .to_a
+          .fetch(0) { {} }
+      end
+
+      def generate_upsert_sql(record)
+        table_name = record.namespace
+        update_attributes = record.updatable? && record.updatable_attributes
+
+        primary_key_fields = primary_key(table_name)
+
+        missing_not_null_fields = database.schema(table_name)
+          .reject { |field_name, _| record.attributes.keys.include?(field_name) }
+          .select { |_field_name, properties|
+            allow_null = properties.fetch(:allow_null, true)
+            not_null = !allow_null
+            default = properties.fetch(:default, nil)
+            no_default = !default
+
+            not_null && no_default
+          }
+          .map(&:first)
+          .reject { |field_name| record.identity_fields.include?(field_name) }
+
+        missing_not_null_attrs = missing_not_null_fields
+          .map { |field_name| [field_name, database[table_name].select(field_name).where(record.identity)] }
+          .to_h
+
+        # TODO: investigate if failing to find a private key results in extra schema queries
+        if primary_key_fields.any?
+          if record.id?
+            conflict_fields = primary_key_fields
+          else
+            return database[table_name]
+              .returning(Sequel.lit("*"))
+              .insert_sql(record.insertable.merge(missing_not_null_attrs))
+          end
+        else
+          u_idxs = unique_indexes(table_name)
+          if u_idxs.any?
+            conflict_fields = u_idxs.first
+          end
+        end
+
+        upsert_args = { update: update_attributes }
+
+        if conflict_fields && conflict_fields.any?
+          upsert_args.merge!(target: conflict_fields)
+        end
+
+        # TODO: Use specific field list instead of Sequel.lit("*")
+        database[table_name]
+          .insert_conflict(**upsert_args)
+          .returning(Sequel.lit("*"))
+          .insert_sql(record.insertable.merge(missing_not_null_attrs))
+      end
+
+      class Dataset
+        extend Forwardable
+        extend WrapDelegate
+        include Enumerable
+
+        def initialize(dataset)
+          @dataset = dataset
+        end
+
+        attr_reader :dataset
+        private     :dataset
+
+        wrap_delegators :dataset, [
+          :select,
+          :where,
+          :clone,
+          :order,
+        ]
+
+        def_delegators :dataset, *[
+          :empty?,
+          :delete,
+          :opts,
+          :sql,
+          :reverse,
+        ]
+
+        def cache_sql?
+          false
+        end
+
+        def each(&block)
+          dataset.each(&block)
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/configurations/conventional_association_configuration.rb

@@ -10,22 +10,22 @@ module Terrestrial
     require "terrestrial/lazy_object_proxy"
 
     class ConventionalAssociationConfiguration
-      def initialize(mapping_name, mappings, datastore)
-        @local_mapping_name = mapping_name
-        @mappings = mappings
-        @local_mapping = mappings.fetch(local_mapping_name)
+      def initialize(inflector, datastore, mapping_name, mappings)
+        @inflector = inflector
         @datastore = datastore
+        @target_mapping = mappings.fetch(mapping_name)
+        @mappings = mappings
       end
 
-      attr_reader :local_mapping_name, :local_mapping, :mappings, :datastore
-      private     :local_mapping_name, :local_mapping, :mappings, :datastore
+      attr_reader :inflector, :datastore, :target_mapping, :mappings
+      private     :inflector, :datastore, :target_mapping, :mappings
 
       DEFAULT = Module.new
 
       def has_many(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT, order_fields: DEFAULT, order_direction: DEFAULT)
         defaults = {
           mapping_name: association_name,
-          foreign_key: [INFLECTOR.singularize(local_mapping_name), "_id"].join.to_sym,
+          foreign_key: [singular_name, "_id"].join.to_sym,
           key: :id,
           order_fields: [],
           order_direction: "ASC",
@@ -45,17 +45,14 @@ module Terrestrial
         associated_mapping_name = config.fetch(:mapping_name)
         associated_mapping = mappings.fetch(associated_mapping_name)
 
-        local_mapping.add_association(
-          association_name,
-          has_many_mapper(**config)
-        )
+        has_many_mapper(**config)
       end
 
       def belongs_to(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT)
         defaults = {
           key: :id,
           foreign_key: [association_name, "_id"].join.to_sym,
-          mapping_name: INFLECTOR.pluralize(association_name).to_sym,
+          mapping_name: pluralize(association_name).to_sym,
         }
 
         specified = {
@@ -71,19 +68,17 @@ module Terrestrial
         associated_mapping_name = config.fetch(:mapping_name)
         associated_mapping = mappings.fetch(associated_mapping_name)
 
-        local_mapping.add_association(
-          association_name,
-          belongs_to_mapper(**config)
-        )
+        belongs_to_mapper(**config)
       end
 
-      def has_many_through(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT, through_mapping_name: DEFAULT, association_key: DEFAULT, association_foreign_key: DEFAULT, order_fields: DEFAULT, order_direction: DEFAULT)
+      def has_many_through(association_name, key: DEFAULT, foreign_key: DEFAULT, mapping_name: DEFAULT, through_table_name: DEFAULT, association_key: DEFAULT, association_foreign_key: DEFAULT, order_fields: DEFAULT, order_direction: DEFAULT)
+        # TODO: join_dataset as mutually exclusive option with join_table_name
         defaults = {
           mapping_name: association_name,
           key: :id,
           association_key: :id,
-          foreign_key: [INFLECTOR.singularize(local_mapping_name), "_id"].join.to_sym,
-          association_foreign_key: [INFLECTOR.singularize(association_name), "_id"].join.to_sym,
+          foreign_key: [singular_name, "_id"].join.to_sym,
+          association_foreign_key: [singularize(association_name), "_id"].join.to_sym,
           order_fields: [],
           order_direction: "ASC",
         }
@@ -101,26 +96,30 @@ module Terrestrial
         }
 
         config = defaults.merge(specified)
+
         associated_mapping = mappings.fetch(config.fetch(:mapping_name))
+        default_through_table_name = [associated_mapping.name, target_mapping.name].sort.join("_to_").to_sym
 
-        if through_mapping_name == DEFAULT
-          through_mapping_name = [
-            associated_mapping.name,
-            local_mapping.name,
-          ].sort.join("_to_").to_sym
+        if through_table_name == DEFAULT
+          through_table_name = default_through_table_name
         end
 
-        join_table_name = mappings.fetch(through_mapping_name).namespace
-        config = config
-          .merge(
-            through_mapping_name: through_mapping_name,
-            through_dataset: datastore[join_table_name.to_sym],
-          )
+        join_mapping = create_virtual_mapping(
+          default_mapping_name: default_through_table_name,
+          namespace: through_table_name,
+          primary_key: [config[:foreign_key], config[:association_foreign_key]],
+        )
+
+        mappings[join_mapping.name] = join_mapping
 
-        local_mapping.add_association(
-          association_name,
-          has_many_through_mapper(**config)
+        join_dataset = datastore[through_table_name.to_sym]
+
+        config = config.merge(
+          join_mapping_name: join_mapping.name,
+          join_dataset: join_dataset,
         )
+
+        has_many_through_mapper(**config)
       end
 
       private
@@ -144,10 +143,11 @@ module Terrestrial
         )
       end
 
-      def has_many_through_mapper(mapping_name:, key:, foreign_key:, association_key:, association_foreign_key:, through_mapping_name:, through_dataset:, order_fields:, order_direction:)
+      def has_many_through_mapper(mapping_name:, key:, foreign_key:, association_key:, association_foreign_key:, join_mapping_name:, join_dataset:, order_fields:, order_direction:)
         ManyToManyAssociation.new(
           mapping_name: mapping_name,
-          join_mapping_name: through_mapping_name,
+          join_mapping_name: join_mapping_name,
+          join_dataset: join_dataset, # TODO: this dataset is not used
           key: key,
           foreign_key: foreign_key,
           association_key: association_key,
@@ -157,6 +157,24 @@ module Terrestrial
         )
       end
 
+      def create_virtual_mapping(default_mapping_name:, namespace:, primary_key:)
+        mapping_name = "__generated_virtual_mapping_#{default_mapping_name}"
+
+        RelationMapping.new(
+          name: mapping_name,
+          namespace: namespace,
+          primary_key: primary_key,
+          factory: ->(*_) { },
+          serializer: :to_h.to_proc,
+          fields: [],
+          associations: [],
+          subsets: [],
+          database_owned_fields: [],
+          database_default_fields: [],
+          observers: [],
+        )
+      end
+
       def single_object_proxy_factory
         ->(query:, loader:, preloaded_data:) {
           LazyObjectProxy.new(
@@ -181,6 +199,18 @@ module Terrestrial
       def query_order(fields, direction)
         QueryOrder.new(fields: fields, direction: direction)
       end
+
+      def singular_name
+        inflector.singularize(target_mapping.name)
+      end
+
+      def singularize(string)
+        inflector.singularize(string)
+      end
+
+      def pluralize(string)
+        inflector.pluralize(string)
+      end
     end
   end
 end

data/lib/terrestrial/configurations/conventional_configuration.rb

@@ -1,113 +1,57 @@
+require "fetchable"
+
+require "terrestrial/configurations/mapping_config_options_proxy"
 require "terrestrial/configurations/conventional_association_configuration"
 require "terrestrial/relation_mapping"
 require "terrestrial/subset_queries_proxy"
 require "terrestrial/struct_factory"
+require "sequel/model/inflections"
 
 module Terrestrial
   module Configurations
-    require "active_support/inflector"
+
     class Inflector
-      include ActiveSupport::Inflector
+      include Sequel::Inflections
+
+      def classify(string)
+        singularize(camelize(string))
+      end
+
+      public :singularize
+      public :pluralize
     end
 
-    INFLECTOR = Inflector.new
+    Default = Module.new
 
-    require "fetchable"
     class ConventionalConfiguration
+      include Enumerable
       include Fetchable
 
-      def initialize(datastore)
+      def initialize(datastore:, clock:, dirty_map:, identity_map:, inflector: Inflector.new)
         @datastore = datastore
+        @inflector = inflector
+        @dirty_map = dirty_map
+        @identity_map = identity_map
+        @clock = clock
+
         @overrides = {}
         @subset_queries = {}
         @associations_by_mapping = {}
       end
 
-      attr_reader :datastore, :mappings
-      private     :datastore, :mappings
-
-      def [](mapping_name)
-        mappings[mapping_name]
-      end
-
-      include Enumerable
-      def each(&block)
-        mappings.each(&block)
-      end
+      attr_reader :overrides, :clock, :identity_map, :dirty_map, :datastore, :mappings, :inflector
 
       def setup_mapping(mapping_name, &block)
         @associations_by_mapping[mapping_name] ||= []
+        @overrides[mapping_name] ||= {}
 
-        block.call(
-          RelationConfigOptionsProxy.new(
-            method(:add_override).to_proc.curry.call(mapping_name),
-            method(:add_subset).to_proc.curry.call(mapping_name),
-            @associations_by_mapping.fetch(mapping_name),
-          )
-        ) if block
-
-        # TODO: more madness in this silly config this, kill it with fire.
-        explicit_settings = @overrides[mapping_name] ||= {}
-        explicit_settings[:factory] ||= raise_if_not_found_factory(mapping_name)
+        block && block.call(
+          MappingConfigOptionsProxy.new(self, mapping_name)
+        )
 
         self
       end
 
-      private
-
-      class RelationConfigOptionsProxy
-        def initialize(config_override, subset_adder, association_register)
-          @config_override = config_override
-          @subset_adder = subset_adder
-          @association_register = association_register
-        end
-
-        def relation_name(name)
-          @config_override.call(relation_name: name)
-        end
-        alias_method :table_name, :relation_name
-
-        def subset(subset_name, &block)
-          @subset_adder.call(subset_name, block)
-        end
-
-        def has_many(*args)
-          @association_register.push([:has_many, args])
-        end
-
-        def has_many_through(*args)
-          @association_register.push([:has_many_through, args])
-        end
-
-        def belongs_to(*args)
-          @association_register.push([:belongs_to, args])
-        end
-
-        def fields(field_names)
-          @config_override.call(fields: field_names)
-        end
-
-        def primary_key(field_names)
-          @config_override.call(primary_key: field_names)
-        end
-
-        def factory(callable)
-          @config_override.call(factory: callable)
-        end
-
-        def class(entity_class)
-          @config_override.call('class': entity_class)
-        end
-
-        def class_name(class_name)
-          @config_override.call(class_name: class_name)
-        end
-
-        def serializer(serializer_func)
-          @config_override.call(serializer: serializer_func)
-        end
-      end
-
       def mappings
         @mappings ||= generate_mappings
       end
@@ -127,11 +71,18 @@ module Terrestrial
         )
       end
 
+      def add_association(mapping_name, type, options)
+        @associations_by_mapping.fetch(mapping_name).push([type, options])
+      end
+
+      private
+
       def association_configurator(mappings, mapping_name)
         ConventionalAssociationConfiguration.new(
+          inflector,
+          datastore,
           mapping_name,
           mappings,
-          datastore,
         )
       end
 
@@ -140,17 +91,13 @@ module Terrestrial
           [mapping_name, {relation_name: mapping_name}.merge(consolidate_overrides(overrides))]
         }
 
-        table_mappings = (tables - @overrides.keys).map { |table_name|
-          [table_name, overrides_for_table(table_name)]
-        }
-
         Hash[
-          (table_mappings + custom_mappings).map { |(mapping_name, overrides)|
+          (custom_mappings).map { |(mapping_name, overrides)|
             table_name = overrides.fetch(:relation_name) { raise no_table_error(mapping_name) }
 
             [
               mapping_name,
-              mapping(
+              build_mapping(
                 **default_mapping_args(table_name, mapping_name).merge(overrides)
               ),
             ]
@@ -166,10 +113,16 @@ module Terrestrial
         # as a dependency and then sends mutating messages to them.
         # This mutation based approach was originally a spike but now just
         # seems totally bananas!
-        @associations_by_mapping.each do |mapping_name, associations|
-          associations.each do |(assoc_type, assoc_args)|
-            association_configurator(mappings, mapping_name)
+        @associations_by_mapping.each do |mapping_name, association_data|
+          association_data.each do |(assoc_type, assoc_args)|
+            association = association_configurator(mappings, mapping_name)
               .public_send(assoc_type, *assoc_args)
+
+            name = assoc_args.fetch(0)
+            mappings.fetch(mapping_name).add_association(name, association)
+            associated_mapping = mappings.fetch(association.mapping_name)
+
+            associated_mapping.register_foreign_key(association.outgoing_foreign_keys)
           end
         end
       end
@@ -178,9 +131,17 @@ module Terrestrial
         {
           name: mapping_name,
           relation_name: table_name,
-          fields: get_fields(table_name),
+          fields: all_available_fields(table_name),
           primary_key: get_primary_key(table_name),
-          factory: ok_if_it_doesnt_exist_factory(mapping_name),
+          use_database_id: false,
+          database_id_setter: nil,
+          database_owned_fields_setter_map: {},
+          database_default_fields_setter_map: {},
+          updated_at_field: nil,
+          updated_at_setter: nil,
+          created_at_field: nil,
+          created_at_setter: nil,
+          factory: ok_if_class_is_not_defined_factory(mapping_name),
           serializer: hash_coercion_serializer,
           associations: {},
           subsets: subset_queries_proxy(@subset_queries.fetch(mapping_name, {})),
@@ -213,31 +174,70 @@ module Terrestrial
         new_opts
       end
 
-      def get_fields(table_name)
-        datastore[table_name].columns
+      def all_available_fields(relation_name)
+        datastore.relation_fields(relation_name)
       end
 
       def get_primary_key(table_name)
         datastore.schema(table_name)
           .select { |field_name, properties|
-            properties.fetch(:primary_key)
+            properties.fetch(:primary_key, false)
           }
           .map { |field_name, _| field_name }
       end
 
+      # TODO: inconsisent naming
       def tables
-        (datastore.tables - [:schema_migrations])
+        datastore.relations
       end
 
       def hash_coercion_serializer
-        ->(o) { o.to_h }
+        HashCoercionSerializer.new
       end
 
       def subset_queries_proxy(subset_map)
         SubsetQueriesProxy.new(subset_map)
       end
 
-      def mapping(name:, relation_name:, primary_key:, factory:, serializer:, fields:, associations:, subsets:)
+      def build_mapping(name:, relation_name:, primary_key:, use_database_id:, database_id_setter:, database_owned_fields_setter_map:, database_default_fields_setter_map:, updated_at_field:, updated_at_setter:, created_at_field:, created_at_setter:, factory:, serializer:, fields:, associations:, subsets:)
+        if use_database_id
+          database_id_setter ||= object_setter(primary_key.first)
+        end
+        if created_at_field
+          created_at_field = created_at_field == Default ? :created_at : created_at_field
+          created_at_setter ||= object_setter(created_at_field)
+        end
+        if updated_at_field
+          updated_at_field = updated_at_field == Default ? :updated_at : updated_at_field
+          updated_at_setter ||= object_setter(updated_at_field)
+        end
+
+        timestamp_observer = TimestampObserver.new(
+          clock,
+          dirty_map,
+          created_at_field,
+          created_at_setter,
+          updated_at_field,
+          updated_at_setter,
+        )
+
+        database_owned_field_observers = database_owned_fields_setter_map.map { |field, setter|
+          setter ||= ->(object, value) { object.send("#{field}=", value) }
+          ArbitraryDatabaseOwnedValueObserver.new(field, setter)
+        }
+
+        database_default_field_observers = database_default_fields_setter_map.map { |field, setter|
+          setter ||= ->(object, value) { object.send("#{field}=", value) }
+          ArbitraryDatabaseDefaultValueObserver.new(field, setter)
+        }
+
+        observers = [
+          use_database_id && DatabaseIDObserver.new(database_id_setter),
+          (created_at_field || updated_at_field) && timestamp_observer,
+          *database_owned_field_observers,
+          *database_default_field_observers,
+        ].select(&:itself)
+
         RelationMapping.new(
           name: name,
           namespace: relation_name,
@@ -245,39 +245,29 @@ module Terrestrial
           factory: factory,
           serializer: serializer,
           fields: fields,
+          database_owned_fields: database_owned_fields_setter_map.keys,
+          database_default_fields: database_default_fields_setter_map.keys,
           associations: associations,
           subsets: subsets,
+          observers: observers,
         )
       end
 
-      FactoryNotFoundError = Class.new(StandardError) do
-        def initialize(specified)
-          @specified = specified
-        end
-
-        def message
-          "Could not find factory for #{@specified}"
-        end
+      def object_setter(field_name)
+        SetterMethodCaller.new(field_name)
       end
 
-      TableNameNotSpecifiedError = Class.new(StandardError) do
-        def initialize(mapping_name)
-          @message = "Error defining custom mapping `#{mapping_name}`." +
-            " You must provide the `table_name` configuration option."
-        end
+      def simple_setter_method_caller(primary_key)
+        SetterMethodCaller.new(primary_key.first)
       end
 
-      def raise_if_not_found_factory(name)
-        ->(attrs) {
-          class_to_factory(string_to_class(name)).call(attrs)
-        }
+      def class_with_same_name_as_mapping_factory(name)
+        target_class = string_to_class(name)
+        ClassFactory.new(target_class)
       end
 
-      def ok_if_it_doesnt_exist_factory(name)
-        ->(attrs) {
-          factory = class_to_factory(string_to_class(name)) rescue nil
-          factory && factory.call(attrs)
-        }
+      def ok_if_class_is_not_defined_factory(name)
+        LazyClassLookupFactory.new(class_name(name))
       end
 
       def class_to_factory(klass)
@@ -289,14 +279,180 @@ module Terrestrial
       end
 
       def string_to_class(string)
-        klass_name = INFLECTOR.classify(string)
+        Object.const_get(class_name(string))
+      end
 
-        Object.const_get(klass_name)
+      def class_name(name)
+        inflector.classify(name)
       end
 
       def no_table_error(table_name)
         TableNameNotSpecifiedError.new(table_name)
       end
+
+      class ClassFactory
+        def initialize(target_class)
+          @target_class = target_class
+        end
+
+        def call(attrs)
+          @target_class.new(attrs)
+        end
+      end
+
+      class LazyClassLookupFactory
+        def initialize(class_name)
+          @class_name = class_name
+        end
+
+        def call(attrs)
+          target_class && target_class.new(attrs)
+        end
+
+        private
+
+        def target_class
+          @target_class ||= Object.const_get(@class_name)
+        end
+      end
+
+      class HashCoercionSerializer
+        def call(object)
+          object.to_h
+        end
+      end
+
+      class TableNameNotSpecifiedError < StandardError
+        def initialize(mapping_name)
+          @message = "Error defining custom mapping `#{mapping_name}`." \
+            " You must provide the `table_name` configuration option."
+        end
+      end
+
+      class DatabaseIDObserver
+        def initialize(setter)
+          @setter = setter
+        end
+
+        attr_reader :setter
+        private :setter
+
+        def post_serialize(mapping, object, record)
+          add_database_id_container!(record)
+        end
+
+        def post_save(mapping, object, record, new_record)
+          if !record.id?
+            new_id = new_record.identity_values.first
+            record.identity_values.first.value = new_id
+            setter.call(object, new_id)
+          end
+        end
+
+        private
+
+        def add_database_id_container!(record)
+          if !record.id?
+            record.set_id(database_id_container)
+          end
+        end
+
+        def database_id_container
+          Terrestrial::DatabaseID.new
+        end
+      end
+
+      # TODO: It is very tempting to implement database generated IDs in terms of this
+      class ArbitraryDatabaseOwnedValueObserver
+        def initialize(field_name, setter)
+          @field_name = field_name
+          @setter = setter
+        end
+
+        attr_reader :field_name, :setter
+        private :field_name, :setter
+
+        def post_serialize(*_args)
+        end
+
+        def post_save(mapping, object, record, new_record)
+          setter.call(object, new_record.get(field_name))
+        end
+      end
+
+      class ArbitraryDatabaseDefaultValueObserver
+        def initialize(field_name, setter)
+          @field_name = field_name
+          @setter = setter
+        end
+
+        attr_reader :field_name, :setter
+        private :field_name, :setter
+
+        def post_serialize(*_args)
+        end
+
+        def post_save(mapping, object, record, new_record)
+          if value_changed?(new_record, record)
+            setter.call(object, new_record.get(field_name))
+          end
+        end
+
+        private
+
+        def value_changed?(new_record, old_record)
+          new_record.attributes[field_name] != old_record.attributes[field_name]
+        end
+      end
+
+      class TimestampObserver
+        def initialize(clock, dirty_map, created_at_field, created_at_setter, updated_at_field, updated_at_setter)
+          @clock = clock
+          @dirty_map = dirty_map
+          @created_at_field = created_at_field
+          @created_at_setter = created_at_setter
+          @updated_at_field = updated_at_field
+          @updated_at_setter = updated_at_setter
+        end
+
+        attr_reader :clock, :dirty_map, :created_at_field, :updated_at_field, :created_at_setter, :updated_at_setter
+        private     :clock, :dirty_map, :created_at_field, :updated_at_field, :created_at_setter, :updated_at_setter
+
+        def post_serialize(mapping, object, record)
+          time = clock.now
+
+          if created_at_field && !record.get(created_at_field)
+            record.set(created_at_field, time)
+          end
+
+          if updated_at_field && dirty_map.dirty?(record)
+            record.set(updated_at_field, time)
+          end
+        end
+
+        def post_save(mapping, object, record, new_record)
+          if created_at_field && record.fetch(created_at_field, false)
+            time = record.fetch(created_at_field)
+            created_at_setter.call(object, time)
+          end
+
+          if updated_at_field
+            time = record.get(updated_at_field)
+            updated_at_setter.call(object, time)
+          end
+        end
+      end
+
+      class SetterMethodCaller
+        def initialize(field_name)
+          raise "hell no" unless field_name
+          @setter_method = "#{field_name}="
+        end
+
+        def call(object, value)
+          object.public_send(@setter_method, value)
+        end
+      end
     end
   end
 end