sequel_mapper 0.0.1 → 0.0.3

data/lib/sequel_mapper/configurations/conventional_association_configuration.rb

@@ -0,0 +1,187 @@
+require "sequel_mapper/query_order"
+
+module SequelMapper
+  module Configurations
+    require "sequel_mapper/one_to_many_association"
+    require "sequel_mapper/many_to_many_association"
+    require "sequel_mapper/many_to_one_association"
+    require "sequel_mapper/collection_mutability_proxy"
+    require "sequel_mapper/queryable_lazy_dataset_loader"
+    require "sequel_mapper/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)
+        @datastore = datastore
+      end
+
+      attr_reader :local_mapping_name, :local_mapping, :mappings, :datastore
+      private     :local_mapping_name, :local_mapping, :mappings, :datastore
+
+      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,
+          key: :id,
+          order_fields: [],
+          order_direction: "ASC",
+        }
+
+        specified = {
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+          order_fields: order_fields,
+          order_direction: order_direction,
+        }.reject { |_k,v|
+          v == DEFAULT
+        }
+
+        config = defaults.merge(specified)
+        associated_mapping_name = config.fetch(:mapping_name)
+        associated_mapping = mappings.fetch(associated_mapping_name)
+
+        local_mapping.add_association(
+          association_name,
+          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,
+        }
+
+        specified = {
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+        }.reject { |_k,v|
+          v == DEFAULT
+        }
+
+        config = defaults.merge(specified)
+
+        associated_mapping_name = config.fetch(:mapping_name)
+        associated_mapping = mappings.fetch(associated_mapping_name)
+
+        local_mapping.add_association(
+          association_name,
+          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)
+        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,
+          order_fields: [],
+          order_direction: "ASC",
+        }
+
+        specified = {
+          mapping_name: mapping_name,
+          key: key,
+          association_key: association_key,
+          foreign_key: foreign_key,
+          association_foreign_key: association_foreign_key,
+          order_fields: order_fields,
+          order_direction: order_direction,
+        }.reject { |_k,v|
+          v == DEFAULT
+        }
+
+        config = defaults.merge(specified)
+        associated_mapping = mappings.fetch(config.fetch(:mapping_name))
+
+        if through_mapping_name == DEFAULT
+          through_mapping_name = [
+            associated_mapping.name,
+            local_mapping.name,
+          ].sort.join("_to_").to_sym
+        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],
+          )
+
+        local_mapping.add_association(
+          association_name,
+          has_many_through_mapper(**config)
+        )
+      end
+
+      private
+
+      def has_many_mapper(mapping_name:, key:, foreign_key:, order_fields:, order_direction:)
+        OneToManyAssociation.new(
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+          order: query_order(order_fields, order_direction),
+          proxy_factory: collection_proxy_factory,
+        )
+      end
+
+      def belongs_to_mapper(mapping_name:, key:, foreign_key:)
+        ManyToOneAssociation.new(
+          mapping_name: mapping_name,
+          foreign_key: foreign_key,
+          key: key,
+          proxy_factory: single_object_proxy_factory,
+        )
+      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:)
+        ManyToManyAssociation.new(
+          mapping_name: mapping_name,
+          key: key,
+          foreign_key: foreign_key,
+          association_key: association_key,
+          association_foreign_key: association_foreign_key,
+          join_mapping_name: through_mapping_name,
+          join_dataset: through_dataset,
+          proxy_factory: collection_proxy_factory,
+          order: query_order(order_fields, order_direction),
+        )
+      end
+
+      def single_object_proxy_factory
+        ->(query:, loader:, preloaded_data:) {
+          LazyObjectProxy.new(
+            ->{ loader.call(query.first) },
+            preloaded_data,
+          )
+        }
+      end
+
+      def collection_proxy_factory
+        ->(query:, loader:, mapping_name:) {
+          CollectionMutabilityProxy.new(
+            QueryableLazyDatasetLoader.new(
+              query,
+              loader,
+              mappings.fetch(mapping_name).subsets,
+            )
+          )
+        }
+      end
+
+      def query_order(fields, direction)
+        QueryOrder.new(fields: fields, direction: direction)
+      end
+    end
+  end
+end

data/lib/sequel_mapper/configurations/conventional_configuration.rb

@@ -0,0 +1,269 @@
+require "sequel_mapper/configurations/conventional_association_configuration"
+require "sequel_mapper/relation_mapping"
+require "sequel_mapper/subset_queries_proxy"
+require "sequel_mapper/struct_factory"
+
+module SequelMapper
+  module Configurations
+    require "active_support/inflector"
+    class Inflector
+      include ActiveSupport::Inflector
+    end
+
+    INFLECTOR = Inflector.new
+
+    require "fetchable"
+    class ConventionalConfiguration
+      include Fetchable
+
+      def initialize(datastore)
+        @datastore = datastore
+        @overrides = {}
+        @subset_queries = {}
+        @associations_by_mapping = {}
+      end
+
+      attr_reader :datastore, :mappings
+      private     :datastore, :mappings
+
+      def [](mapping_name)
+        mappings[mapping_name]
+      end
+
+      def setup_mapping(mapping_name, &block)
+        @associations_by_mapping[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)
+
+        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 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
+
+      def add_override(mapping_name, attrs)
+        overrides = @overrides.fetch(mapping_name, {}).merge(attrs)
+
+        @overrides.store(mapping_name, overrides)
+      end
+
+      def add_subset(mapping_name, subset_name, block)
+        @subset_queries.store(
+          mapping_name,
+          @subset_queries.fetch(mapping_name, {}).merge(
+            subset_name => block,
+          )
+        )
+      end
+
+      def association_configurator(mappings, mapping_name)
+        ConventionalAssociationConfiguration.new(
+          mapping_name,
+          mappings,
+          datastore,
+        )
+      end
+
+      def generate_mappings
+        Hash[
+          tables
+            .map { |table_name|
+              mapping_name, overrides = overrides_for_table(table_name)
+
+              [
+                mapping_name,
+                mapping(
+                  **default_mapping_args(table_name, mapping_name).merge(overrides)
+                ),
+              ]
+            }
+        ].tap { |mappings|
+          generate_associations_config(mappings)
+        }
+      end
+
+      def generate_associations_config(mappings)
+        # TODO: the ConventionalAssociationConfiguration takes all the mappings
+        # 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)
+              .public_send(assoc_type, *assoc_args)
+          end
+        end
+      end
+
+      def default_mapping_args(table_name, mapping_name)
+        {
+          name: mapping_name,
+          relation_name: table_name,
+          fields: get_fields(table_name),
+          primary_key: get_primary_key(table_name),
+          factory: ok_if_it_doesnt_exist_factory(mapping_name),
+          serializer: hash_coercion_serializer,
+          associations: {},
+          subsets: subset_queries_proxy(@subset_queries.fetch(mapping_name, {})),
+        }
+      end
+
+      def overrides_for_table(table_name)
+        mapping_name, overrides = @overrides
+          .find { |(_mapping_name, config)|
+            table_name == config.fetch(:relation_name, nil)
+          } || [table_name, @overrides.fetch(table_name, {})]
+
+        [mapping_name, consolidate_overrides(overrides)]
+      end
+
+      def consolidate_overrides(opts)
+        new_opts = opts.dup
+
+        if new_opts.has_key?(:class_name)
+          new_opts.merge!(factory: string_to_factory(new_opts.fetch(:class_name)))
+          new_opts.delete(:class_name)
+        end
+
+        if new_opts.has_key?(:class)
+          new_opts.merge!(factory: class_to_factory(new_opts.fetch(:class)))
+          new_opts.delete(:class)
+        end
+
+        new_opts
+      end
+
+      def get_fields(table_name)
+        datastore[table_name].columns
+      end
+
+      def get_primary_key(table_name)
+        datastore.schema(table_name)
+          .select { |field_name, properties|
+            properties.fetch(:primary_key)
+          }
+          .map { |field_name, _| field_name }
+      end
+
+      def tables
+        (datastore.tables - [:schema_migrations])
+      end
+
+      def hash_coercion_serializer
+        ->(o) { o.to_h }
+      end
+
+      def subset_queries_proxy(subset_map)
+        SubsetQueriesProxy.new(subset_map)
+      end
+
+      def mapping(name:, relation_name:, primary_key:, factory:, serializer:, fields:, associations:, subsets:)
+        RelationMapping.new(
+          name: name,
+          namespace: relation_name,
+          primary_key: primary_key,
+          factory: factory,
+          serializer: serializer,
+          fields: fields,
+          associations: associations,
+          subsets: subsets,
+        )
+      end
+
+      FactoryNotFoundError = Class.new(StandardError) do
+        def initialize(specified)
+          @specified = specified
+        end
+
+        def message
+          "Could not find factory for #{@specified}"
+        end
+      end
+
+      def raise_if_not_found_factory(name)
+        ->(attrs) {
+          class_to_factory(string_to_class(name)).call(attrs)
+        }
+      end
+
+      def ok_if_it_doesnt_exist_factory(name)
+        ->(attrs) {
+          factory = class_to_factory(string_to_class(name)) rescue nil
+          factory && factory.call(attrs)
+        }
+      end
+
+      def class_to_factory(klass)
+        if klass.ancestors.include?(Struct)
+          StructFactory.new(klass)
+        else
+          klass.method(:new)
+        end
+      end
+
+      def string_to_class(string)
+        klass_name = INFLECTOR.classify(string)
+
+        Object.const_get(klass_name)
+      end
+    end
+  end
+end