dbee 2.0.2 → 3.0.0

data/lib/dbee/model/relationships.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'relationships/basic'
+require_relative '../util/make_keyed_by'
+
+module Dbee
+  class Model
+    # Top-level class that allows for the making of relationships.
+    class Relationships
+      acts_as_hashable_factory
+      extend Dbee::Util::MakeKeyedBy
+
+      register 'basic', Basic
+      register '',      Basic # When type is not present this will be the default
+    end
+  end
+end

data/lib/dbee/model/relationships/basic.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  class Model
+    class Relationships
+      # A relationship from one model to another.
+      class Basic
+        acts_as_hashable
+
+        attr_reader :constraints, :model, :name
+
+        def initialize(name:, constraints: [], model: nil)
+          @name = name
+          raise ArgumentError, 'name is required' if name.to_s.empty?
+
+          @constraints = Constraints.array(constraints || []).uniq
+          @model = model
+
+          freeze
+        end
+
+        def model_name
+          model || name
+        end
+
+        def hash
+          [self.class.hash, name.hash, constraints.hash, model.hash].hash
+        end
+
+        def ==(other)
+          other.instance_of?(self.class) &&
+            other.name == name &&
+            other.constraints == constraints &&
+            other.model == model
+        end
+        alias eql? ==
+      end
+    end
+  end
+end

data/lib/dbee/query.rb

@@ -21,37 +21,39 @@ module Dbee
     extend Forwardable
     acts_as_hashable
 
-    class NoFieldsError < StandardError; end
-
-    attr_reader :fields, :filters, :limit, :sorters
-
-    def_delegator :fields, :sort, :sorted_fields
-
-    def_delegator :filters, :sort, :sorted_filters
-
-    def_delegator :sorters, :sort, :sorted_sorters
-
-    def initialize(fields:, filters: [], limit: nil, sorters: [])
-      @fields = Field.array(fields)
-
-      # If no fields were passed into a query then we will have no data to return.
-      # Let's raise a hard error here and let the consumer deal with it since this may
-      # have implications in downstream SQL generators.
-      raise NoFieldsError if @fields.empty?
-
-      @filters  = Filters.array(filters).uniq
-      @limit    = limit.to_s.empty? ? nil : limit.to_i
-      @sorters  = Sorters.array(sorters).uniq
+    attr_reader :fields,
+                :filters,
+                :from,
+                :limit,
+                :sorters
+
+    def_delegator :fields,   :sort, :sorted_fields
+    def_delegator :filters,  :sort, :sorted_filters
+    def_delegator :sorters,  :sort, :sorted_sorters
+
+    def initialize(
+      fields: [],
+      from: nil,
+      filters: [],
+      limit: nil,
+      sorters: []
+    )
+      @fields  = Field.array(fields)
+      @filters = Filters.array(filters).uniq
+      @from    = from.to_s
+      @limit   = limit.to_s.empty? ? nil : limit.to_i
+      @sorters = Sorters.array(sorters).uniq
 
       freeze
     end
 
     def ==(other)
       other.instance_of?(self.class) &&
+        other.limit == limit &&
+        other.from == from &&
         other.sorted_fields == sorted_fields &&
         other.sorted_filters == sorted_filters &&
-        other.sorted_sorters == sorted_sorters &&
-        other.limit == limit
+        other.sorted_sorters == sorted_sorters
     end
     alias eql? ==
 
@@ -62,7 +64,11 @@ module Dbee
     private
 
     def key_paths
-      (fields.map(&:key_path) + filters.map(&:key_path) + sorters.map(&:key_path))
+      (
+        fields.flat_map(&:key_paths) +
+        filters.map(&:key_path) +
+        sorters.map(&:key_path)
+      )
     end
   end
 end

data/lib/dbee/query/field.rb

@@ -15,24 +15,50 @@ module Dbee
     class Field
       acts_as_hashable
 
-      attr_reader :key_path, :display
+      module Aggregator
+        AVE   = :ave
+        COUNT = :count
+        MAX   = :max
+        MIN   = :min
+        SUM   = :sum
+      end
+      include Aggregator
+
+      attr_reader :aggregator, :display, :filters, :key_path
 
-      def initialize(key_path:, display: nil)
+      def initialize(key_path:, aggregator: nil, display: nil, filters: [])
         raise ArgumentError, 'key_path is required' if key_path.to_s.empty?
 
-        @key_path = KeyPath.get(key_path)
-        @display = (display.to_s.empty? ? key_path : display).to_s
+        @aggregator = aggregator ? Aggregator.const_get(aggregator.to_s.upcase.to_sym) : nil
+        @display    = (display.to_s.empty? ? key_path : display).to_s
+        @filters    = Filters.array(filters).uniq
+        @key_path   = KeyPath.get(key_path)
 
         freeze
       end
 
+      def filters?
+        filters.any?
+      end
+
+      def aggregator?
+        !aggregator.nil?
+      end
+
       def hash
-        "#{key_path}#{display}".hash
+        [
+          aggregator,
+          display,
+          filters,
+          key_path
+        ].hash
       end
 
       def ==(other)
         other.instance_of?(self.class) &&
+          other.aggregator == aggregator &&
           other.key_path == key_path &&
+          other.filters == filters &&
           other.display == display
       end
       alias eql? ==
@@ -40,6 +66,10 @@ module Dbee
       def <=>(other)
         "#{key_path}#{display}" <=> "#{other.key_path}#{other.display}"
       end
+
+      def key_paths
+        [key_path] + filters.map(&:key_path)
+      end
     end
   end
 end

data/lib/dbee/schema.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  # A schema represents an entire graph of related models.
+  class Schema
+    attr_reader :models
+
+    extend Forwardable
+    def initialize(schema_config)
+      @models_by_name = Model.make_keyed_by(:name, schema_config)
+
+      freeze
+    end
+
+    # Given a Dbee::Model and Dbee::KeyPath, this returns a list of
+    # Dbee::Relationship and Dbee::Model tuples that lie on the key path.
+    # The returned list is a two dimensional array in
+    # the form of <tt>[[relationship, model], [relationship2, model2]]</tt>,
+    # etc. The relationships and models correspond to each ancestor part of the
+    # key path.
+    #
+    # The key_path argument can be either a Dbee::KeyPath or an array of
+    # string ancestor names.
+    #
+    # An exception is raised of the provided key_path contains relationship
+    # names that do not exist in this schema.
+    def expand_query_path(model, key_path, query_path = [])
+      ancestors = key_path.respond_to?(:ancestor_names) ? key_path.ancestor_names : key_path
+      relationship_name = ancestors.first
+      return query_path unless relationship_name
+
+      relationship = relationship_for_name!(model, relationship_name)
+      join_model = model_for_name!(relationship.model_name)
+      expand_query_path(
+        join_model,
+        ancestors.drop(1),
+        query_path + [[relationship_for_name!(model, relationship_name), join_model]]
+      )
+    end
+
+    def model_for_name!(model_name)
+      models_by_name[model_name.to_s] || raise(Model::ModelNotFoundError, model_name)
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) && other.send(:models_by_name) == models_by_name
+    end
+    alias eql? ==
+
+    private
+
+    attr_reader :models_by_name
+
+    def relationship_for_name!(model, rel_name)
+      model.relationship_for_name(rel_name) ||
+        raise("model '#{model.name}' does not have a '#{rel_name}' relationship")
+    end
+  end
+end

data/lib/dbee/schema_creator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  # This creates a Dbee::Schema from a variety of different inputs:
+  #
+  # 1. The hash representation of a schema.
+  # 2. A Dbee::Base subclass (code based models).
+  #
+  # For backward compatibility, tree based models are also supported in the
+  # following formats:
+  #
+  # 3. The hash representation of a tree based model.
+  # 4. Dbee::Model instances in tree based form (using the deprecated constraints and models
+  #    attributes).
+  class SchemaCreator # :nodoc:
+    attr_reader :schema
+
+    # An ArgumentError is raised if the query "from" attribute differs from the name of the root
+    # model of a tree based model or if the "from" attribute is blank.
+    def initialize(schema_or_model, query)
+      @orig_query = Query.make(query) || raise(ArgumentError, 'query is required')
+      raise ArgumentError, 'a schema or model is required' unless schema_or_model
+
+      @schema = make_schema(schema_or_model)
+
+      # Note that for backward compatibility reasons, this validation does not
+      # exist in the DBee::Query class. This allows continued support for
+      # old callers who depend on the "from" field being inferred from the root
+      # tree model name.
+      raise ArgumentError, 'query requires a from model name' if expected_from_model.empty?
+
+      validate_query_from_model!
+
+      freeze
+    end
+
+    # Returns a Dbee::Query instance with a "from" attribute which is
+    # sometimes derived for tree based models.
+    def query
+      return orig_query if expected_from_model == orig_query.from
+
+      Query.new(
+        from: expected_from_model,
+        fields: orig_query.fields,
+        filters: orig_query.filters,
+        sorters: orig_query.sorters,
+        limit: orig_query.limit
+      )
+    end
+
+    private
+
+    attr_reader :orig_query, :expected_from_model
+
+    def make_schema(input)
+      @expected_from_model = orig_query.from
+
+      return input if input.is_a?(Dbee::Schema)
+
+      if input.respond_to?(:to_schema)
+        @expected_from_model = input.inflected_class_name
+        return input.to_schema(orig_query.key_chain)
+      end
+
+      model_or_schema = to_object(input)
+      if model_or_schema.is_a?(Model)
+        @expected_from_model = model_or_schema.name.to_s
+        SchemaFromTreeBasedModel.convert(model_or_schema)
+      else
+        model_or_schema
+      end
+    end
+
+    def to_object(input)
+      return input unless input.is_a?(Hash)
+
+      if tree_based_hash?(input)
+        Model.make(input)
+      else
+        Schema.new(input)
+      end
+    end
+
+    def validate_query_from_model!
+      !orig_query.from.empty? && expected_from_model.to_s != orig_query.from.to_s && \
+        raise(
+          ArgumentError,
+          "expected from model to be '#{expected_from_model}' but got '#{orig_query.from}'"
+        )
+    end
+
+    def tree_based_hash?(hash)
+      name = hash[:name] || hash['name']
+
+      # In the unlikely event that schema based hash had a model called "name",
+      # its value would either be nil or a hash.
+      name.is_a?(String) || name.is_a?(Symbol)
+    end
+  end
+end

data/lib/dbee/schema_from_tree_based_model.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  # Converts a tree based model to a Schema. Note that this results in a
+  # different but compatible schema compared to the result of generating a
+  # Dbee::Schema by calling to_schema on a Dbee::Base class. This is
+  # because converting from a tree based model is a lossy.
+  class SchemaFromTreeBasedModel # :nodoc:
+    class << self
+      def convert(tree_model)
+        Schema.new(to_graph_based_models(tree_model))
+      end
+
+      private
+
+      def to_graph_based_models(tree_model, parent_model = nil, models_attrs_by_name = {})
+        models_attrs_by_name[tree_model.name] = {
+          name: tree_model.name,
+          table: tree_model.table,
+          partitioners: tree_model.partitioners,
+          relationships: {}
+        }
+
+        parent_model && add_relationship_to_parent_model(
+          tree_model, models_attrs_by_name[parent_model.name]
+        )
+
+        tree_model.models.each do |sub_model|
+          to_graph_based_models(sub_model, tree_model, models_attrs_by_name)
+        end
+
+        models_attrs_by_name
+      end
+
+      def add_relationship_to_parent_model(model, graph_model_attrs)
+        graph_model_attrs[:relationships][model.name] = { constraints: model.constraints }
+      end
+    end
+  end
+end

data/lib/dbee/util/make_keyed_by.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  module Util
+    # Provides a "make_keyed_by" method which extends the Hashable gem's
+    # concept of a "make" method.
+    module MakeKeyedBy # :nodoc:
+      # Given a hash of hashes or a hash of values of instances of this class,
+      # a hash is returned where all of the values are instances of this class
+      # and the keys are the string versions of the original hash.
+      #
+      # An ArgumentError is raised if the value's <tt>key_attrib</tt> is not
+      # equal to the top level hash key. This ensures that the
+      # <tt>key_attrib</tt> is the same in the incoming hash and the value.
+      #
+      # This is useful for cases where it makes sense in the configuration
+      # (YAML) specification to represent certain objects in a hash structure
+      # instead of a list.
+      def make_keyed_by(key_attrib, spec_hash)
+        # Once Ruby 2.5 support is dropped, this can just use the block form of
+        # #to_h.
+        spec_hash.map do |key, spec|
+          string_key = key.to_s
+          [string_key, make_value_checking_key_attib!(key_attrib, string_key, spec)]
+        end.to_h
+      end
+
+      private
+
+      def make_value_checking_key_attib!(key_attrib, key, spec)
+        if spec.is_a?(self)
+          if spec.send(key_attrib).to_s != key
+            err_msg = "expected a #{key_attrib} of '#{key}' but got '#{spec.send(key_attrib)}'"
+            raise ArgumentError, err_msg
+          end
+          spec
+        else
+          make((spec || {}).merge(key_attrib => key))
+        end
+      end
+    end
+  end
+end