dbee 2.1.0.pre.alpha → 3.1.0

data/lib/dbee.rb

@@ -13,11 +13,15 @@ require 'forwardable'
 
 require_relative 'dbee/base'
 require_relative 'dbee/constant_resolver'
+require_relative 'dbee/dsl_schema_builder'
 require_relative 'dbee/key_chain'
 require_relative 'dbee/key_path'
 require_relative 'dbee/model'
-require_relative 'dbee/query'
 require_relative 'dbee/providers'
+require_relative 'dbee/query'
+require_relative 'dbee/schema'
+require_relative 'dbee/schema_creator'
+require_relative 'dbee/schema_from_tree_based_model'
 
 # Top-level namespace that provides the main public API.
 module Dbee
@@ -31,16 +35,11 @@ module Dbee
       @inflector ||= Dry::Inflector.new
     end
 
-    def sql(model, query, provider)
-      query = Query.make(query)
-      model =
-        if model.is_a?(Hash) || model.is_a?(Model)
-          Model.make(model)
-        else
-          model.to_model(query.key_chain)
-        end
+    def sql(schema_or_model, query_input, provider)
+      raise ArgumentError, 'a provider is required' unless provider
 
-      provider.sql(model, query)
+      schema_compat = SchemaCreator.new(schema_or_model, query_input)
+      provider.sql(schema_compat.schema, schema_compat.query)
     end
   end
 end

data/spec/dbee/base_spec.rb

@@ -11,52 +11,17 @@ require 'spec_helper'
 require 'fixtures/models'
 
 describe Dbee::Base do
-  describe '#to_model' do
-    it 'compiles correctly' do
-      model_name      = 'Theaters, Members, and Movies'
-      expected_config = yaml_fixture('models.yaml')[model_name]
+  describe '.to_schema' do
+    it 'passes the keychain and model to DslSchemaBuilder' do
+      key_chain = Dbee::KeyChain.new
 
-      expected_model = Dbee::Model.make(expected_config)
+      schema_builder_double = double(Dbee::DslSchemaBuilder)
+      expect(Dbee::DslSchemaBuilder).to receive(:new).with(Models::A, key_chain).and_return(
+        schema_builder_double
+      )
+      expect(schema_builder_double).to receive(:to_schema)
 
-      key_paths = %w[
-        members.demos.phone_numbers.a
-        members.movies.b
-        members.favorite_comic_movies.c
-        members.favorite_mystery_movies.d
-        members.favorite_comedy_movies.e
-        parent_theater.members.demos.phone_numbers.f
-        parent_theater.members.movies.g
-        parent_theater.members.favorite_comic_movies.h
-        parent_theater.members.favorite_mystery_movies.i
-        parent_theater.members.favorite_comedy_movies.j
-      ]
-
-      key_chain = Dbee::KeyChain.new(key_paths)
-
-      actual_model = Models::Theater.to_model(key_chain)
-
-      expect(actual_model).to eq(expected_model)
-    end
-
-    it 'honors key_chain to flatten cyclic references' do
-      model_name      = 'Cycle Example'
-      expected_config = yaml_fixture('models.yaml')[model_name]
-
-      expected_model = Dbee::Model.make(expected_config)
-
-      key_paths = %w[
-        b1.c.a.z
-        b1.d.a.y
-        b2.c.a.x
-        b2.d.a.w
-        b2.d.a.b1.c.z
-      ]
-
-      key_chain = Dbee::KeyChain.new(key_paths)
-
-      actual_model = Cycles::A.to_model(key_chain)
-
-      expect(actual_model).to eq(expected_model)
+      Models::A.to_schema(key_chain)
     end
   end
 
@@ -72,32 +37,4 @@ describe Dbee::Base do
       expect(Models::E.inherited_table_name).to eq('table_set_to_e')
     end
   end
-
-  describe 'partitioners' do
-    it 'honors partitioners on a root model' do
-      model_name      = 'Partitioner Example 1'
-      expected_config = yaml_fixture('models.yaml')[model_name]
-      expected_model = Dbee::Model.make(expected_config)
-
-      key_paths = %w[id]
-      key_chain = Dbee::KeyChain.new(key_paths)
-
-      actual_model = PartitionerExamples::Dog.to_model(key_chain)
-
-      expect(actual_model).to eq(expected_model)
-    end
-
-    it 'honors partitioners on a child model' do
-      model_name      = 'Partitioner Example 2'
-      expected_config = yaml_fixture('models.yaml')[model_name]
-      expected_model = Dbee::Model.make(expected_config)
-
-      key_paths = %w[id dogs.id]
-      key_chain = Dbee::KeyChain.new(key_paths)
-
-      actual_model = PartitionerExamples::Owner.to_model(key_chain)
-
-      expect(actual_model).to eq(expected_model)
-    end
-  end
 end

data/spec/dbee/constant_resolver_spec.rb

@@ -9,23 +9,28 @@
 
 require 'spec_helper'
 
-describe Dbee::ConstantResolver do
-  module A
-    class B; end
-    class E; end
-  end
-
+# rubocop:disable Lint/EmptyClass
+# These are intentionally empty to keep the tests focused.
+module A
   class B; end
 
-  module C
-    class D; end
-    class E; end
+  class E; end
+end
+
+class B; end
 
-    module F
-      class G; end
-    end
+module C
+  class D; end
+
+  class E; end
+
+  module F
+    class G; end
   end
+end
+# rubocop:enable Lint/EmptyClass
 
+describe Dbee::ConstantResolver do
   it 'resolves nested constant with the same as an ancestor constants sibling' do
     expect(subject.constantize('A::B')).to eq(::A::B)
   end

data/spec/dbee/dsl_schema_builder_spec.rb

@@ -0,0 +1,106 @@
+# 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 'spec_helper'
+require 'fixtures/models'
+
+describe Dbee::DslSchemaBuilder do
+  specify 'theaters example' do
+    model_name      = 'Theaters, Members, and Movies from DSL'
+    expected_config = yaml_fixture('models.yaml')[model_name]
+
+    expected_schema = Dbee::Schema.new(expected_config)
+
+    key_paths = %w[
+      members.a
+      members.demos.phone_numbers.a
+      members.movies.b
+      members.favorite_comic_movies.c
+      members.favorite_mystery_movies.d
+      members.favorite_comedy_movies.e
+      parent_theater.members.demos.phone_numbers.f
+      parent_theater.members.movies.g
+      parent_theater.members.favorite_comic_movies.h
+      parent_theater.members.favorite_mystery_movies.i
+      parent_theater.members.favorite_comedy_movies.j
+    ]
+
+    key_chain = Dbee::KeyChain.new(key_paths)
+
+    actual_schema = Models::Theater.to_schema(key_chain)
+    expect(actual_schema).to eq(expected_schema)
+  end
+
+  it 'honors key_chain to flatten cyclic references' do
+    model_name      = 'Cycle Example'
+    expected_config = yaml_fixture('models.yaml')[model_name]
+
+    expected_schema = Dbee::Schema.new(expected_config)
+
+    key_paths = %w[
+      b1.c.a.z
+      b1.d.a.y
+      b2.c.a.x
+      b2.d.a.w
+      b2.d.a.b1.c.z
+    ]
+
+    key_chain = Dbee::KeyChain.new(key_paths)
+
+    actual_schema = Cycles::A.to_schema(key_chain)
+    expect(actual_schema).to eq(expected_schema)
+  end
+
+  describe 'partitioners' do
+    it 'honors partitioners on a root model' do
+      model_name      = 'Partitioner Example 1'
+      expected_config = yaml_fixture('models.yaml')[model_name]
+      expected_schema = Dbee::Schema.new(expected_config)
+
+      key_paths = %w[id]
+      key_chain = Dbee::KeyChain.new(key_paths)
+
+      actual_schema = PartitionerExamples::Dog.to_schema(key_chain)
+
+      expect(actual_schema).to eq(expected_schema)
+    end
+
+    it 'honors partitioners on a child model' do
+      model_name      = 'Partitioner Example 2'
+      expected_config = yaml_fixture('models.yaml')[model_name]
+      expected_schema = Dbee::Schema.new(expected_config)
+
+      key_paths = %w[id dogs.id]
+      key_chain = Dbee::KeyChain.new(key_paths)
+
+      actual_schema = PartitionerExamples::Owner.to_schema(key_chain)
+
+      expect(actual_schema).to eq(expected_schema)
+    end
+  end
+
+  context 'README examples' do
+    specify 'code-first and configuration-first models are equal' do
+      config        = yaml_fixture('models.yaml')['Readme']
+      config_schema = Dbee::Schema.new(config)
+
+      key_chain = Dbee::KeyChain.new(%w[
+                                       patients.a
+                                       patients.notes.b
+                                       patients.work_phone_number.c
+                                       patients.cell_phone_number.d
+                                       patients.fax_phone_number.e
+                                     ])
+
+      code_schema = ReadmeDataModels::Practice.to_schema(key_chain)
+
+      expect(config_schema).to eq(code_schema)
+    end
+  end
+end

data/spec/dbee/key_chain_spec.rb

@@ -78,4 +78,28 @@ describe Dbee::KeyChain do
       end
     end
   end
+
+  describe '#to_unique_ancestors collapses the KeyChain' do
+    let(:collapsed_key_chain) do
+      described_class.new([
+                            'z.b.c.d.any_column',
+                            'b.c.any_column',
+                            'any_column',
+                            '44.55.any_column'
+                          ])
+    end
+
+    specify 'the empty case' do
+      expect(described_class.new.to_unique_ancestors).to eq described_class.new
+    end
+
+    specify 'when there are no ancestors, one key path is returned' do
+      no_query_depth = described_class.new(%w[column1 column2 column3])
+      expect(no_query_depth.to_unique_ancestors).to eq described_class.new(['any_column'])
+    end
+
+    it 'returns a new KeyChain which has one KeyPath per ancestor' do
+      expect(subject.to_unique_ancestors).to eq collapsed_key_chain
+    end
+  end
 end

data/spec/dbee/model/constraints_spec.rb

@@ -9,14 +9,13 @@
 
 require 'spec_helper'
 
-describe Dbee::Model::Constraints do
-  CONSTRAINT_CONFIG = { name: :a }.freeze
-
-  CONSTRAINT_FACTORIES = {
-    Dbee::Model::Constraints::Reference => CONSTRAINT_CONFIG.merge(parent: :b, type: :reference),
-    Dbee::Model::Constraints::Static => CONSTRAINT_CONFIG.merge(value: :b, type: :static)
-  }.freeze
+CONSTRAINT_CONFIG = { name: :a }.freeze
+CONSTRAINT_FACTORIES = {
+  Dbee::Model::Constraints::Reference => CONSTRAINT_CONFIG.merge(parent: :b, type: :reference),
+  Dbee::Model::Constraints::Static => CONSTRAINT_CONFIG.merge(value: :b, type: :static)
+}.freeze
 
+describe Dbee::Model::Constraints do
   CONSTRAINT_FACTORIES.each_pair do |constant, config|
     it "should instantiate #{constant} objects" do
       expect(described_class.make(config)).to be_a(constant)

data/spec/dbee/model_spec.rb

@@ -55,77 +55,80 @@ describe Dbee::Model do
     end
   end
 
-  describe '#ancestors' do
-    let(:yaml_entities) { yaml_fixture('models.yaml') }
-
-    let(:entity_hash) { yaml_entities['Theaters, Members, and Movies'] }
-
-    subject { described_class.make(entity_hash) }
-
-    specify 'returns proper models' do
-      members = subject.models.first
-
-      expected_plan = {
-        %w[members] => members
+  describe '.make_keyed_by' do
+    it 'returns a hash of Models where the keys equal the names of the models' do
+      input = {
+        model1: nil,
+        model2: { table: :model2_table }
       }
-
-      plan = subject.ancestors!(%w[members])
-
-      expect(plan).to eq(expected_plan)
-    end
-
-    specify 'returns proper multi-level models' do
-      members       = subject.models.first
-      demos         = members.models.first
-      phone_numbers = demos.models.first
-
-      expected_plan = {
-        %w[members] => members,
-        %w[members demos] => demos,
-        %w[members demos phone_numbers] => phone_numbers
+      expected_result = {
+        'model1' => described_class.new(name: 'model1'),
+        'model2' => described_class.new(name: 'model2', table: 'model2_table')
       }
 
-      plan = subject.ancestors!(%w[members demos phone_numbers])
-
-      expect(plan).to eq(expected_plan)
+      expect(described_class.make_keyed_by(:name, input)).to eq expected_result
     end
-  end
-
-  describe 'equality' do
-    let(:config) { yaml_fixture('models.yaml')['Theaters, Members, and Movies'] }
 
-    subject { described_class.make(config) }
-
-    specify 'equality compares attributes' do
-      model1 = described_class.make(config)
-      model2 = described_class.make(config)
+    it 'accepts values of Dbee::Model instances' do
+      input = { model1: described_class.new(name: :model1) }
+      expected_result = { 'model1' => described_class.new(name: :model1) }
+      expect(described_class.make_keyed_by(:name, input)).to eq expected_result
+    end
 
-      expect(model1).to eq(model2)
-      expect(model1).to eql(model2)
+    it 'accepts values of Dbee::Model instances when the key attribute is a string' do
+      input = { 'model1' => described_class.new(name: 'model1') }
+      expected_result = { 'model1' => described_class.new(name: 'model1') }
+      expect(described_class.make_keyed_by(:name, input)).to eq expected_result
     end
 
-    it 'returns false unless comparing same object types' do
-      expect(subject).not_to eq(config)
-      expect(subject).not_to eq(nil)
+    it 'raises an error when the input hash key is not equal to the name of the model' do
+      input = { model1: described_class.new(name: :bogus) }
+      expect do
+        described_class.make_keyed_by(:name, input)
+      end.to raise_error ArgumentError, "expected a name of 'model1' but got 'bogus'"
     end
   end
 
-  context 'README examples' do
-    specify 'code-first and configuration-first models are equal' do
-      config        = yaml_fixture('models.yaml')['Readme']
-      config_model  = described_class.make(config)
-
-      key_chain = Dbee::KeyChain.new(%w[
-                                       patients.a
-                                       patients.notes.b
-                                       patients.work_phone_number.c
-                                       patients.cell_phone_number.d
-                                       patients.fax_phone_number.e
-                                     ])
-
-      code_model = ReadmeDataModels::Practice.to_model(key_chain)
+  describe '#to_s' do
+    it 'is represented by the model name' do
+      expect(described_class.new(name: 'foo').to_s).to eq 'foo'
+    end
+  end
 
-      expect(config_model).to eq(code_model)
+  equality_cases = {
+    tree_based: yaml_fixture('models.yaml')['Theaters, Members, and Movies Tree Based'],
+    graph_based: yaml_fixture('models.yaml')['Theaters, Members, and Movies from DSL']['theater']
+  }
+  equality_cases[:graph_based].merge!(name: 'theaters')
+  equality_cases.each do |test_case, config|
+    describe "equality for #{test_case}" do
+      let(:model1) { described_class.make(config) }
+      let(:model2) { described_class.make(config) }
+
+      subject { described_class.make(config) }
+
+      specify 'equality compares attributes' do
+        expect(model1).to eq(model2)
+        expect(model1).to eql(model2)
+      end
+
+      it 'returns false unless comparing same object types' do
+        expect(subject).not_to eq(config)
+        expect(subject).not_to eq(nil)
+      end
+
+      describe 'hash codes' do
+        specify 'are equal when objects are equal' do
+          expect(model1).to eq(model2)
+          expect(model1.hash).to eq(model2.hash)
+        end
+
+        specify 'are not equal when objects are not equal' do
+          different_model = described_class.new(name: :oddball)
+          expect(model1).not_to eq(different_model)
+          expect(model1.hash).not_to eq(different_model.hash)
+        end
+      end
     end
   end
 end

data/spec/dbee/query/filters_spec.rb

@@ -9,24 +9,23 @@
 
 require 'spec_helper'
 
-describe Dbee::Query::Filters do
-  FILTERS_CONFIG = { key_path: 'a.b.c', value: :d }.freeze
-
-  FILTER_FACTORIES = {
-    Dbee::Query::Filters::Contains => FILTERS_CONFIG.merge(type: :contains),
-    Dbee::Query::Filters::Equals => FILTERS_CONFIG.merge(type: :equals),
-    Dbee::Query::Filters::GreaterThanOrEqualTo => FILTERS_CONFIG.merge(
-      type: :greater_than_or_equal_to
-    ),
-    Dbee::Query::Filters::GreaterThan => FILTERS_CONFIG.merge(type: :greater_than),
-    Dbee::Query::Filters::LessThanOrEqualTo => FILTERS_CONFIG.merge(type: :less_than_or_equal_to),
-    Dbee::Query::Filters::LessThan => FILTERS_CONFIG.merge(type: :less_than),
-    Dbee::Query::Filters::NotContain => FILTERS_CONFIG.merge(type: :not_contain),
-    Dbee::Query::Filters::NotEquals => FILTERS_CONFIG.merge(type: :not_equals),
-    Dbee::Query::Filters::NotStartWith => FILTERS_CONFIG.merge(type: :not_start_with),
-    Dbee::Query::Filters::StartsWith => FILTERS_CONFIG.merge(type: :starts_with)
-  }.freeze
+FILTERS_CONFIG = { key_path: 'a.b.c', value: :d }.freeze
+FILTER_FACTORIES = {
+  Dbee::Query::Filters::Contains => FILTERS_CONFIG.merge(type: :contains),
+  Dbee::Query::Filters::Equals => FILTERS_CONFIG.merge(type: :equals),
+  Dbee::Query::Filters::GreaterThanOrEqualTo => FILTERS_CONFIG.merge(
+    type: :greater_than_or_equal_to
+  ),
+  Dbee::Query::Filters::GreaterThan => FILTERS_CONFIG.merge(type: :greater_than),
+  Dbee::Query::Filters::LessThanOrEqualTo => FILTERS_CONFIG.merge(type: :less_than_or_equal_to),
+  Dbee::Query::Filters::LessThan => FILTERS_CONFIG.merge(type: :less_than),
+  Dbee::Query::Filters::NotContain => FILTERS_CONFIG.merge(type: :not_contain),
+  Dbee::Query::Filters::NotEquals => FILTERS_CONFIG.merge(type: :not_equals),
+  Dbee::Query::Filters::NotStartWith => FILTERS_CONFIG.merge(type: :not_start_with),
+  Dbee::Query::Filters::StartsWith => FILTERS_CONFIG.merge(type: :starts_with)
+}.freeze
 
+describe Dbee::Query::Filters do
   FILTER_FACTORIES.each_pair do |constant, config|
     it "should instantiate #{constant} objects" do
       expect(described_class.make(config)).to be_a(constant)

data/spec/dbee/query_spec.rb

@@ -9,9 +9,64 @@
 
 require 'spec_helper'
 
+README_EXAMPLES = {
+  'Get all practices' => {
+    fields: [
+      { key_path: 'id' },
+      { key_path: 'active' },
+      { key_path: 'name' }
+    ]
+  },
+  'Get practices, limit to 2, offset by 3, and sort by name (descending) then id (ascending)' => {
+    fields: [
+      { key_path: 'id' },
+      { key_path: 'active' },
+      { key_path: 'name' }
+    ],
+    sorters: [
+      { key_path: 'name', direction: :descending },
+      { key_path: 'id' }
+    ],
+    limit: 2,
+    offset: 3
+  },
+  "Get top 5 active practices and patient whose name start with 'Sm':" => {
+    fields: [
+      { key_path: 'name', display: 'Practice Name' },
+      { key_path: 'patients.first', display: 'Patient First Name' },
+      { key_path: 'patients.middle', display: 'Patient Middle Name' },
+      { key_path: 'patients.last', display: 'Patient Last Name' }
+    ],
+    filters: [
+      { type: :equals, key_path: 'active', value: true },
+      { type: :starts_with, key_path: 'patients.last', value: 'Sm' }
+    ],
+    limit: 5
+  },
+  'Get practice IDs, patient IDs, names, and cell phone numbers that starts with 555' => {
+    fields: [
+      { key_path: 'id', display: 'Practice ID #' },
+      { key_path: 'patients.id', display: 'Patient ID #' },
+      { key_path: 'patients.first', display: 'Patient First Name' },
+      { key_path: 'patients.middle', display: 'Patient Middle Name' },
+      { key_path: 'patients.last', display: 'Patient Last Name' },
+      { key_path: 'patients.cell_phone_numbers.phone_number', display: 'Patient Cell #' }
+    ],
+    filters: [
+      { type: :equals, key_path: 'active', value: true },
+      {
+        type: :starts_with,
+        key_path: 'patients.cell_phone_numbers.phone_number',
+        value: '555'
+      }
+    ]
+  }
+}.freeze
+
 describe Dbee::Query do
   let(:config) do
     {
+      from: 'my_model',
       fields: [
         { key_path: 'matt.nick.sam', display: 'some display' },
         { key_path: 'katie' },
@@ -36,14 +91,6 @@ describe Dbee::Query do
   end
 
   describe '#initialize' do
-    it 'should raise an ArgumentError if fields keyword is missing' do
-      expect { described_class.new }.to raise_error(ArgumentError)
-    end
-
-    it 'should raise a NoFieldsError if no fields were passed in' do
-      expect { described_class.new(fields: []) }.to raise_error(Dbee::Query::NoFieldsError)
-    end
-
     it 'should remove duplicate filters (keep first instance)' do
       query_hash = {
         fields: [
@@ -124,60 +171,7 @@ describe Dbee::Query do
   end
 
   context 'README examples' do
-    EXAMPLES = {
-      'Get all practices' => {
-        fields: [
-          { key_path: 'id' },
-          { key_path: 'active' },
-          { key_path: 'name' }
-        ]
-      },
-      'Get all practices, limit to 10, and sort by name (descending) then id (ascending)' => {
-        fields: [
-          { key_path: 'id' },
-          { key_path: 'active' },
-          { key_path: 'name' }
-        ],
-        sorters: [
-          { key_path: 'name', direction: :descending },
-          { key_path: 'id' }
-        ],
-        limit: 10
-      },
-      "Get top 5 active practices and patient whose name start with 'Sm':" => {
-        fields: [
-          { key_path: 'name', display: 'Practice Name' },
-          { key_path: 'patients.first', display: 'Patient First Name' },
-          { key_path: 'patients.middle', display: 'Patient Middle Name' },
-          { key_path: 'patients.last', display: 'Patient Last Name' }
-        ],
-        filters: [
-          { type: :equals, key_path: 'active', value: true },
-          { type: :starts_with, key_path: 'patients.last', value: 'Sm' }
-        ],
-        limit: 5
-      },
-      'Get practice IDs, patient IDs, names, and cell phone numbers that starts with 555' => {
-        fields: [
-          { key_path: 'id', display: 'Practice ID #' },
-          { key_path: 'patients.id', display: 'Patient ID #' },
-          { key_path: 'patients.first', display: 'Patient First Name' },
-          { key_path: 'patients.middle', display: 'Patient Middle Name' },
-          { key_path: 'patients.last', display: 'Patient Last Name' },
-          { key_path: 'patients.cell_phone_numbers.phone_number', display: 'Patient Cell #' }
-        ],
-        filters: [
-          { type: :equals, key_path: 'active', value: true },
-          {
-            type: :starts_with,
-            key_path: 'patients.cell_phone_numbers.phone_number',
-            value: '555'
-          }
-        ]
-      }
-    }.freeze
-
-    EXAMPLES.each_pair do |name, query|
+    README_EXAMPLES.each_pair do |name, query|
       specify name do
         expect(described_class.make(query)).to be_a(described_class)
       end