sequel_mapper 0.0.1 → 0.0.3

data/lib/sequel_mapper/many_to_one_association.rb

@@ -0,0 +1,60 @@
+require "sequel_mapper/dataset"
+
+module SequelMapper
+  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
+
+    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, &block)
+      collection.flat_map { |object|
+        block.call(mapping_name, object, _foreign_key_does_not_go_here = {})
+          .flat_map { |associated_record|
+            foreign_key_pair = {
+              foreign_key => associated_record.fetch(key),
+            }
+
+            [
+              associated_record,
+              parent_record.merge(foreign_key_pair),
+            ]
+          }
+      }
+    end
+    alias_method :delete, :dump
+
+    private
+
+    def foreign_key_value(record)
+      record.fetch(foreign_key)
+    end
+  end
+end

data/lib/sequel_mapper/mapper_facade.rb

@@ -0,0 +1,180 @@
+require "sequel_mapper/graph_serializer"
+require "sequel_mapper/graph_loader"
+
+module SequelMapper
+  class MapperFacade
+    def initialize(mappings:, mapping_name:, datastore:, dataset:, identity_map:, dirty_map:)
+      @mappings = mappings
+      @mapping_name = mapping_name
+      @datastore = datastore
+      @dataset = dataset
+      @identity_map = identity_map
+      @dirty_map = dirty_map
+      @eager_data = {}
+    end
+
+    attr_reader :mappings, :mapping_name, :datastore, :dataset, :identity_map, :dirty_map
+    private     :mappings, :mapping_name, :datastore, :dataset, :identity_map, :dirty_map
+
+    def save(graph)
+      record_dump = graph_serializer.call(mapping_name, graph)
+
+      object_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
+
+    include Enumerable
+    def each(&block)
+      dataset
+        .map { |record|
+          graph_loader.call(mapping_name, record, Hash[@eager_data])
+        }
+        .each(&block)
+    end
+
+    def eager_load(association_name_map)
+      @eager_data = eager_load_the_things(mapping, dataset, association_name_map)
+
+      self
+    end
+
+    def delete(object)
+      object_dump_pipeline.call(
+        graph_serializer.call(mapping_name, object)
+          .take(1)
+          .map { |record|
+            DeletedRecord.new(record.namespace, record.identity)
+          }
+      )
+    end
+
+    private
+
+    def eager_load_the_things(mapping, parent_dataset, association_name_map)
+      association_name_map
+        .flat_map { |name, deeper_association_names|
+          association = mapping.associations.fetch(name)
+          association_mapping = mappings.fetch(association.mapping_name)
+          association_namespace = association_mapping.namespace
+          association_dataset = get_eager_dataset(association, association_namespace, parent_dataset)
+
+          [
+            [[mapping.name, name] , association_dataset]
+          ] + eager_load_the_things(association_mapping, association_dataset, deeper_association_names)
+        }
+    end
+
+    def get_eager_dataset(association, association_namespace, parent_dataset)
+        association.eager_superset(
+          datastore[association_namespace],
+          parent_dataset,
+        )
+    end
+
+    def new_with_dataset(new_dataset)
+      self.class.new(
+        dataset: new_dataset,
+        mappings: mappings,
+        mapping_name: mapping_name,
+        datastore: datastore,
+        identity_map: identity_map,
+        dirty_map: dirty_map,
+      )
+    end
+
+    def graph_serializer
+      GraphSerializer.new(mappings: mappings)
+    end
+
+    def graph_loader
+      GraphLoader.new(
+        datasets: datastore,
+        mappings: mappings,
+        object_load_pipeline: object_load_pipeline,
+      )
+    end
+
+    def object_load_pipeline
+      ->(mapping, record, other_attrs = {}) {
+        [
+          record_factory(mapping),
+          dirty_map.method(:load),
+          ->(r) { identity_map.call(r, mapping.factory.call(r.merge(other_attrs))) },
+        ].reduce(record) { |agg, operation|
+          operation.call(agg)
+        }
+      }
+    end
+
+    def object_dump_pipeline
+      ->(records) {
+        [
+          :uniq.to_proc,
+          ->(rs) { rs.select { |r| dirty_map.dirty?(r) } },
+          ->(rs) {
+            rs.each { |r|
+              r.if_upsert(&method(:upsert_record))
+               .if_delete(&method(:delete_record))
+            }
+          },
+        ].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)]
+          }
+        ]
+
+        SequelMapper::UpsertedRecord.new(
+          mapping.namespace,
+          identity,
+          record_hash,
+        )
+      }
+    end
+
+    def mapping
+      mappings.fetch(mapping_name)
+    end
+
+    def upsert_record(record)
+      # TODO I doubt this is really more performant but fewer queries register :)
+      row_count = datastore[record.namespace]
+        .where(record.identity)
+        .update(record.to_h)
+
+      if row_count < 1
+        row_count = datastore[record.namespace].insert(record.to_h)
+      end
+
+      row_count
+    end
+
+    def delete_record(record)
+      datastore[record.namespace].where(record.identity).delete
+    end
+  end
+end

data/lib/sequel_mapper/one_to_many_association.rb

@@ -0,0 +1,51 @@
+require "sequel_mapper/dataset"
+
+module SequelMapper
+  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
+
+    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, &block)
+      foreign_key_pair = {
+        foreign_key => parent_record.fetch(key),
+      }
+
+      collection.flat_map { |associated_object|
+        block.call(mapping_name, associated_object, foreign_key_pair)
+      }
+    end
+    alias_method :delete, :dump
+
+    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
+  end
+end

data/lib/sequel_mapper/public_conveniencies.rb

@@ -0,0 +1,27 @@
+require "sequel_mapper/identity_map"
+require "sequel_mapper/dirty_map"
+require "sequel_mapper/mapper_facade"
+require "sequel_mapper/configurations/conventional_configuration"
+
+module SequelMapper
+  module PublicConveniencies
+    def config(database_connection)
+      Configurations::ConventionalConfiguration.new(database_connection)
+    end
+
+    def mapper(config:, name:, datastore:)
+      dataset = datastore[config.fetch(name).namespace]
+      identity_map = IdentityMap.new({})
+      dirty_map = DirtyMap.new({})
+
+      MapperFacade.new(
+        mappings: config,
+        mapping_name: name,
+        datastore: datastore,
+        dataset: dataset,
+        identity_map: identity_map,
+        dirty_map: dirty_map,
+      )
+    end
+  end
+end

data/lib/sequel_mapper/query_order.rb

@@ -0,0 +1,32 @@
+module SequelMapper
+  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/sequel_mapper/queryable_lazy_dataset_loader.rb

@@ -0,0 +1,70 @@
+require "sequel_mapper/short_inspection_string"
+
+module SequelMapper
+  class QueryableLazyDatasetLoader
+    include ShortInspectionString
+    include Enumerable
+
+    def initialize(database_enum, loader, queries)
+      @database_enum = database_enum
+      @loader = loader
+      @queries = queries
+      @loaded = false
+    end
+
+    attr_reader :database_enum, :loader, :queries
+    private     :database_enum, :loader, :queries
+
+    def where(criteria)
+      self.class.new(database_enum.where(criteria), loader, queries)
+    end
+
+    def subset(name, *params)
+      self.class.new(
+        queries.execute(database_enum, name, *params),
+        loader,
+        queries,
+      )
+    end
+
+    def each(&block)
+      enum.each(&block)
+    end
+
+    def each_loaded(&block)
+      loaded_objects.each(&block)
+    end
+
+    private
+
+    def enum
+      @enum ||= Enumerator.new { |yielder|
+        loaded_objects.each do |obj|
+          yielder.yield(obj)
+        end
+
+        loop do
+          object_enum.next.tap { |obj|
+            loaded_objects.push(obj)
+            yielder.yield(obj)
+          }
+        end
+      }
+    end
+
+    def object_enum
+      @object_enum ||= database_enum.lazy.map(&loader)
+    end
+
+    def loaded_objects
+      @loaded_objects ||= []
+    end
+
+    def inspectable_properties
+      [
+        :database_enum,
+        :loaded,
+      ]
+    end
+  end
+end

data/lib/sequel_mapper/relation_mapping.rb

@@ -0,0 +1,35 @@
+module SequelMapper
+  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
+
+    private
+
+    def new_with_associations(new_associations)
+      self.class.new(
+        name: name,
+        namespace: namespace,
+        fields: fields,
+        primary_key: primary_key,
+        factory: factory,
+        serializer: serializer,
+        associations: new_associations,
+        subsets: subsets,
+      )
+    end
+  end
+end