terrestrial 0.1.0 → 0.1.1

data/lib/terrestrial/lazy_object_proxy.rb

@@ -0,0 +1,55 @@
+module Terrestrial
+  class LazyObjectProxy
+    include ShortInspectionString
+
+    def initialize(object_loader, key_fields)
+      @object_loader = object_loader
+      @key_fields = key_fields
+      @lazy_object = nil
+    end
+
+    attr_reader :object_loader
+    private     :object_loader
+
+    def method_missing(method_id, *args, &block)
+      if args.empty? && __key_fields.include?(method_id)
+        __key_fields.fetch(method_id)
+      else
+        lazy_object.public_send(method_id, *args, &block)
+      end
+    end
+
+    def loaded?
+      !!@lazy_object
+    end
+
+    def __getobj__
+      lazy_object
+    end
+
+    def each_loaded(&block)
+      [self].each(&block)
+    end
+
+    def __key_fields
+      @key_fields
+    end
+
+    private
+
+    def respond_to_missing?(method_id, _include_private = false)
+      __key_fields.include?(method_id) || lazy_object.respond_to?(method_id)
+    end
+
+    def lazy_object
+      @lazy_object ||= object_loader.call
+    end
+
+    def inspectable_properties
+      [
+        :key_fields,
+        :lazy_object,
+      ]
+    end
+  end
+end

data/lib/terrestrial/many_to_many_association.rb

@@ -0,0 +1,138 @@
+require "forwardable"
+require "terrestrial/dataset"
+
+module Terrestrial
+  class ManyToManyAssociation
+    def initialize(mapping_name:, join_mapping_name:, foreign_key:, key:, proxy_factory:, association_foreign_key:, association_key:, order:)
+      @mapping_name = mapping_name
+      @join_mapping_name = join_mapping_name
+      @foreign_key = foreign_key
+      @key = key
+      @proxy_factory = proxy_factory
+      @association_foreign_key = association_foreign_key
+      @association_key = association_key
+      @order = order
+    end
+
+    def mapping_names
+      [mapping_name, join_mapping_name]
+    end
+
+    attr_reader :mapping_name, :join_mapping_name
+
+    attr_reader :foreign_key, :key, :proxy_factory, :association_key, :association_foreign_key, :order
+    private     :foreign_key, :key, :proxy_factory, :association_key, :association_foreign_key, :order
+
+    def build_proxy(data_superset:, loader:, record:)
+      proxy_factory.call(
+        query: build_query(data_superset, record),
+        loader: ->(record_list) {
+          record = record_list.first
+          join_records = record_list.last
+
+          loader.call(record, join_records)
+        },
+        mapping_name: mapping_name,
+      )
+    end
+
+    def eager_superset((superset, join_superset), (associated_dataset))
+      join_data = Dataset.new(
+        join_superset
+          .where(foreign_key => associated_dataset.select(association_key))
+          .to_a
+      )
+
+      eager_superset = Dataset.new(
+        superset.where(key => join_data.select(association_foreign_key)).to_a
+      )
+
+      [
+        eager_superset,
+        join_data,
+      ]
+    end
+
+    def build_query((superset, join_superset), parent_record)
+      ids = join_superset
+              .where(foreign_key => foreign_key_value(parent_record))
+              .select(association_foreign_key)
+
+      order
+        .apply(
+          superset.where(
+            key => ids
+          )
+        )
+        .lazy.map { |record|
+          [record, [foreign_keys(parent_record, record)]]
+        }
+    end
+
+    def dump(parent_record, collection, depth, &block)
+      flat_list_of_records_and_join_records(parent_record, collection, depth, &block)
+    end
+
+    def extract_foreign_key(_record)
+      {}
+    end
+
+    def delete(parent_record, collection, depth, &block)
+      flat_list_of_just_join_records(parent_record, collection, depth, &block)
+    end
+
+    private
+
+    def flat_list_of_records_and_join_records(parent_record, collection, depth, &block)
+      record_join_record_pairs(parent_record, collection, depth, &block).flatten(1)
+    end
+
+    def flat_list_of_just_join_records(parent_record, collection, depth, &block)
+      record_join_record_pairs(parent_record, collection, depth, &block)
+        .map { |(_records, join_records)| join_records }
+        .flatten(1)
+    end
+
+    def record_join_record_pairs(parent_record, collection, depth, &block)
+      (collection || []).map { |associated_object|
+        record, *other_join_records = block.call(
+          mapping_name,
+          associated_object,
+          no_foreign_key = {},
+          depth + depth_modifier,
+        )
+
+        fks = foreign_keys(parent_record, record)
+        join_record_depth = depth + join_record_depth_modifier
+
+        join_records = block.call(
+          join_mapping_name,
+          fks,
+          fks,
+          join_record_depth
+        ).flatten(1)
+
+        [record] + other_join_records + join_records
+      }
+    end
+
+    def foreign_keys(parent_record, record)
+      {
+        foreign_key => foreign_key_value(parent_record),
+        association_foreign_key => record.fetch(association_key),
+      }
+    end
+
+    def foreign_key_value(record)
+      record.fetch(key)
+    end
+
+    def depth_modifier
+      0
+    end
+
+    def join_record_depth_modifier
+      +1
+    end
+  end
+end

data/lib/terrestrial/many_to_one_association.rb

@@ -0,0 +1,66 @@
+require "terrestrial/dataset"
+
+module Terrestrial
+  class ManyToOneAssociation
+    def initialize(mapping_name:, foreign_key:, key:, proxy_factory:)
+      @mapping_name = mapping_name
+      @foreign_key = foreign_key
+      @key = key
+      @proxy_factory = proxy_factory
+    end
+
+    def mapping_names
+      [mapping_name]
+    end
+
+    attr_reader :mapping_name
+
+    attr_reader :foreign_key, :key, :proxy_factory
+    private     :foreign_key, :key, :proxy_factory
+
+    def build_proxy(data_superset:, loader:, record:)
+      proxy_factory.call(
+        query: build_query(data_superset, record),
+        loader: loader,
+        preloaded_data: {
+          key => foreign_key_value(record),
+        },
+      )
+    end
+
+    def eager_superset((superset), (associated_dataset))
+      [
+        Dataset.new(
+          superset.where(key => associated_dataset.select(foreign_key)).to_a
+        )
+      ]
+    end
+
+    def build_query((superset), record)
+      superset.where(key => foreign_key_value(record))
+    end
+
+    def dump(parent_record, collection, depth, &block)
+      collection.flat_map { |object|
+        block.call(mapping_name, object, _foreign_key_does_not_go_here = {}, depth + depth_modifier)
+      }
+    end
+    alias_method :delete, :dump
+
+    def extract_foreign_key(record)
+      {
+        foreign_key => record.fetch(key),
+      }
+    end
+
+    private
+
+    def foreign_key_value(record)
+      record.fetch(foreign_key)
+    end
+
+    def depth_modifier
+      -1
+    end
+  end
+end

data/lib/terrestrial/mapper_facade.rb

@@ -0,0 +1,137 @@
+require "terrestrial/graph_serializer"
+require "terrestrial/graph_loader"
+
+module Terrestrial
+  class MapperFacade
+    include Enumerable
+
+    def initialize(mappings:, mapping_name:, datastore:, dataset:, load_pipeline:, dump_pipeline:)
+      @mappings = mappings
+      @mapping_name = mapping_name
+      @datastore = datastore
+      @dataset = dataset
+      @load_pipeline = load_pipeline
+      @dump_pipeline = dump_pipeline
+      @eager_data = {}
+    end
+
+    attr_reader :mappings, :mapping_name, :datastore, :dataset, :load_pipeline, :dump_pipeline
+    private     :mappings, :mapping_name, :datastore, :dataset, :load_pipeline, :dump_pipeline
+
+    def save(graph)
+      record_dump = graph_serializer.call(mapping_name, graph)
+
+      dump_pipeline.call(record_dump)
+
+      self
+    end
+
+    def all
+      self
+    end
+
+    def where(query)
+      new_with_dataset(
+        dataset.where(query)
+      )
+    end
+
+    def subset(name, *params)
+      new_with_dataset(
+        mapping.subsets.execute(dataset, name, *params)
+      )
+    end
+
+    def each(&block)
+      dataset
+        .map { |record|
+          graph_loader.call(mapping_name, record, @eager_data)
+        }
+        .each(&block)
+    end
+
+    def eager_load(association_name_map)
+      @eager_data = eager_load_associations(mapping, dataset, association_name_map)
+
+      self
+    end
+
+    def delete(object, cascade: false)
+      dump_pipeline.call(
+        graph_serializer.call(mapping_name, object)
+          .select { |record| record.depth == 0 }
+          .reverse
+          .take(1)
+          .map { |record|
+            DeletedRecord.new(record.namespace, record.identity)
+          }
+      )
+    end
+
+    private
+
+    def mapping
+      mappings.fetch(mapping_name)
+    end
+
+    def eager_load_associations(mapping, parent_dataset, association_name_map)
+      Hash[
+        association_name_map.map { |name, deeper_association_names|
+          association = mapping.associations.fetch(name)
+          association_mapping = mappings.fetch(association.mapping_name)
+          association_dataset = get_eager_dataset(association, parent_dataset)
+
+          [
+            name,
+            {
+              superset: association_dataset,
+              associations: eager_load_associations(
+                association_mapping,
+                association_dataset,
+                deeper_association_names,
+              ),
+            }
+          ]
+        }
+      ]
+    end
+
+    def get_eager_dataset(association, parent_dataset)
+      association.eager_superset(
+        association_root_datasets(association),
+        parent_dataset,
+      )
+    end
+
+    def association_root_datasets(association)
+      association
+        .mapping_names
+        .map { |name| mappings.fetch(name) }
+        .map(&:namespace)
+        .map { |ns| datastore[ns] }
+    end
+
+    def new_with_dataset(new_dataset)
+      self.class.new(
+        dataset: new_dataset,
+        mappings: mappings,
+        mapping_name: mapping_name,
+        datastore: datastore,
+        load_pipeline: load_pipeline,
+        dump_pipeline: dump_pipeline,
+      )
+    end
+
+    def graph_serializer
+      GraphSerializer.new(mappings: mappings)
+    end
+
+    def graph_loader
+      GraphLoader.new(
+        datasets: datastore,
+        mappings: mappings,
+        object_load_pipeline: load_pipeline,
+      )
+    end
+  end
+end

data/lib/terrestrial/one_to_many_association.rb

@@ -0,0 +1,66 @@
+require "terrestrial/dataset"
+
+module Terrestrial
+  class OneToManyAssociation
+    def initialize(mapping_name:, foreign_key:, key:, order:, proxy_factory:)
+      @mapping_name = mapping_name
+      @foreign_key = foreign_key
+      @key = key
+      @order = order
+      @proxy_factory = proxy_factory
+    end
+
+    def mapping_names
+      [mapping_name]
+    end
+    attr_reader :mapping_name
+
+    attr_reader :foreign_key, :key, :order, :proxy_factory
+    private     :foreign_key, :key, :order, :proxy_factory
+
+    def build_proxy(data_superset:, loader:, record:)
+     proxy_factory.call(
+        query: build_query(data_superset, record),
+        loader: loader,
+        mapping_name: mapping_name,
+      )
+    end
+
+    def dump(parent_record, collection, depth, &block)
+      foreign_key_pair = {
+        foreign_key => parent_record.fetch(key),
+      }
+
+      collection.flat_map { |associated_object|
+        block.call(mapping_name, associated_object, foreign_key_pair, depth + depth_modifier)
+      }
+    end
+    alias_method :delete, :dump
+
+    def extract_foreign_key(_record)
+      {}
+    end
+
+    def eager_superset((superset), (associated_dataset))
+      [
+        Dataset.new(
+          superset.where(
+            foreign_key => associated_dataset.select(key)
+          ).to_a
+        )
+      ]
+    end
+
+    def build_query((superset), record)
+      order.apply(
+        superset.where(foreign_key => record.fetch(key))
+      )
+    end
+
+    private
+
+    def depth_modifier
+      +1
+    end
+  end
+end

data/lib/terrestrial/public_conveniencies.rb

@@ -0,0 +1,139 @@
+require "terrestrial/identity_map"
+require "terrestrial/dirty_map"
+require "terrestrial/upserted_record"
+require "terrestrial/mapper_facade"
+require "terrestrial/configurations/conventional_configuration"
+
+module Terrestrial
+  module PublicConveniencies
+    def config(database_connection)
+      Configurations::ConventionalConfiguration.new(database_connection)
+    end
+
+    def mappers(mappings:, datastore:)
+      dirty_map = build_dirty_map
+      identity_map = build_identity_map
+
+      Hash[mappings.map { |name, _mapping|
+        [
+          name,
+          mapper(
+            mappings: mappings ,
+            name: name,
+            datastore: datastore,
+            identity_map: identity_map,
+            dirty_map: dirty_map,
+          )
+        ]
+      }]
+    end
+
+    private
+
+    def mapper(mappings:, name:, datastore:, identity_map:, dirty_map:)
+      dataset = datastore[mappings.fetch(name).namespace]
+
+      MapperFacade.new(
+        mappings: mappings,
+        mapping_name: name,
+        datastore: datastore,
+        dataset: dataset,
+        load_pipeline: build_load_pipeline(
+          dirty_map: dirty_map,
+          identity_map: identity_map,
+        ),
+        dump_pipeline: build_dump_pipeline(
+          dirty_map: dirty_map,
+          transaction: datastore.method(:transaction),
+          upsert: method(:upsert_record).curry.call(datastore),
+          delete: method(:delete_record).curry.call(datastore),
+        )
+      )
+    end
+
+    private
+
+    def build_identity_map(storage = {})
+      IdentityMap.new(storage)
+    end
+
+    def build_dirty_map(storage = {})
+      DirtyMap.new(storage)
+    end
+
+    def build_load_pipeline(dirty_map:, identity_map:)
+      ->(mapping, record, associated_fields = {}) {
+        [
+          record_factory(mapping),
+          dirty_map.method(:load),
+          ->(record) {
+            attributes = record.to_h.select { |k,_v|
+              mapping.fields.include?(k)
+            }
+
+            object = mapping.factory.call(attributes.merge(associated_fields))
+            identity_map.call(mapping, record, object)
+          },
+        ].reduce(record) { |agg, operation|
+          operation.call(agg)
+        }
+      }
+    end
+
+    def build_dump_pipeline(dirty_map:, transaction:, upsert:, delete:)
+      ->(records) {
+        [
+          :uniq.to_proc,
+          ->(rs) { rs.select { |r| dirty_map.dirty?(r) } },
+          ->(rs) { rs.map { |r| dirty_map.reject_unchanged_fields(r) } },
+          ->(rs) { rs.sort_by(&:depth) },
+          ->(rs) {
+            transaction.call {
+              rs.each { |r|
+                r.if_upsert(&upsert)
+                 .if_delete(&delete)
+              }
+            }
+          },
+        ].reduce(records) { |agg, operation|
+          operation.call(agg)
+        }
+      }
+    end
+
+    def record_factory(mapping)
+      ->(record_hash) {
+        identity = Hash[
+          mapping.primary_key.map { |field|
+            [field, record_hash.fetch(field)]
+          }
+        ]
+
+        UpsertedRecord.new(
+          mapping.namespace,
+          identity,
+          record_hash,
+        )
+      }
+    end
+
+    def upsert_record(datastore, record)
+      row_count = 0
+      unless record.non_identity_attributes.empty?
+        row_count = datastore[record.namespace].
+          where(record.identity).
+          update(record.non_identity_attributes)
+      end
+
+      if row_count < 1
+        row_count = datastore[record.namespace].insert(record.to_h)
+      end
+
+      row_count
+    end
+
+    def delete_record(datastore, record)
+      datastore[record.namespace].where(record.identity).delete
+    end
+  end
+end

data/lib/terrestrial/query_order.rb

@@ -0,0 +1,32 @@
+module Terrestrial
+  class QueryOrder
+    def initialize(fields:, direction:)
+      @fields = fields
+      @direction_function = get_direction_function(direction.to_s.upcase)
+    end
+
+    attr_reader :fields, :direction_function
+
+    def apply(dataset)
+      if fields.any?
+        apply_direction(dataset.order(fields))
+      else
+        dataset
+      end
+    end
+
+    private
+
+    def apply_direction(dataset)
+      direction_function.call(dataset)
+    end
+
+    # TODO: Consider a nicer API for this and push this into SequelAdapter
+    def get_direction_function(direction)
+      {
+        "ASC" => ->(x){x},
+        "DESC" => :reverse.to_proc,
+      }.fetch(direction) { raise "Unsupported sort option #{direction}. Choose one of [ASC, DESC]." }
+    end
+  end
+end

data/lib/terrestrial/relation_mapping.rb

@@ -0,0 +1,50 @@
+module Terrestrial
+  class RelationMapping
+    def initialize(name:, namespace:, fields:, primary_key:, factory:, serializer:, associations:, subsets:)
+      @name = name
+      @namespace = namespace
+      @fields = fields
+      @primary_key = primary_key
+      @factory = factory
+      @serializer = serializer
+      @associations = associations
+      @subsets = subsets
+    end
+
+    attr_reader :name, :namespace, :fields, :primary_key, :factory, :serializer, :associations, :subsets
+
+    def add_association(name, new_association)
+      @associations = associations.merge(name => new_association)
+    end
+
+    def serialize(object, depth, foreign_keys = {})
+      object_attributes = serializer.call(object)
+
+      [
+        record(object_attributes, depth, foreign_keys),
+        extract_associations(object_attributes)
+      ]
+    end
+
+    def record(attributes, depth, foreign_keys)
+      UpsertedRecord.new(
+        namespace,
+        primary_key,
+        select_mapped_fields(attributes).merge(foreign_keys),
+        depth,
+      )
+    end
+
+    def extract_associations(attributes)
+      Hash[
+        associations.map { |name, _association|
+          [ name, attributes.fetch(name) ]
+        }
+      ]
+    end
+
+    def select_mapped_fields(attributes)
+      attributes.select { |name, _value| fields.include?(name) }
+    end
+  end
+end

data/lib/terrestrial/serializer.rb

@@ -0,0 +1,18 @@
+module Terrestrial
+  class Serializer
+    def initialize(field_names, object)
+      @field_names = field_names
+      @object = object
+    end
+
+    attr_reader :field_names, :object
+
+    def to_h
+      Hash[
+        field_names.map { |field_name|
+          [field_name, object.public_send(field_name)]
+        }
+      ]
+    end
+  end
+end