graphiti 1.0.alpha.18 → 1.0.alpha.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a57e6a62b24c36177cc2d7191754080204f43c3
-  data.tar.gz: 28df77df0640febe4fa4bab38ecb9f51ee0f79f6
+  metadata.gz: 87db44b8b56a2b6341dd62b0d1ef7bdf37703127
+  data.tar.gz: 934774ad413a6ac695b612253249620efc0f7c9b
 SHA512:
-  metadata.gz: 828cbf88441e63d92a056296751dc9a87ccb6dd4932946824f44ccef48ef0b828c498e0acbdc4751e89858188d4b13951d781d964d006ca8385daa343217c29f
-  data.tar.gz: 2134f9e3dcfb4209179f9c074c17b379af68b00b0182ef7a9d854644b62328ea6d5edc45925d7bf0783b833e0fd5c48166baf29c181b388f9f0442672486ecb5
+  metadata.gz: 51ca1feec8cc701fd3786449d747f5ea44f72fd4e533fcb598793f74dc550e87aaa39a53eb4144e623653503a690a25d9ce2bf84b1bae253a66d92e5d84ab2fb
+  data.tar.gz: bf9acf3ecc4b5be6db1bc9d3e46c3591b59d48391bfa941fedf3c525418e8a8d393d91fee4ba9745e25a2fda1d92fb4499f500be323a55524a8c5cee2e72b9d8

data/lib/generators/graphiti/templates/application_resource.rb.erb

@@ -9,6 +9,6 @@ class ApplicationResource < Graphiti::Resource
   # Subclasses can still override this default.
   <%- end -%>
   self.abstract_class = true
-  self.adapter = Graphiti::Adapters::ActiveRecord::Base
+  self.adapter = Graphiti::Adapters::ActiveRecord
   self.endpoint_namespace = '<%= api_namespace %>'
 end

data/lib/generators/graphiti/templates/create_request_spec.rb.erb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 RSpec.describe "<%= type %>#create", type: :request do
   subject(:make_request) do
-    jsonapi_post "/<%= api_namespace %>/v1/<%= type %>", payload
+    jsonapi_post "<%= api_namespace %>/<%= type %>", payload
   end
 
   describe 'basic create' do

data/lib/generators/graphiti/templates/destroy_request_spec.rb.erb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 RSpec.describe "<%= type %>#destroy", type: :request do
   subject(:make_request) do
-    jsonapi_delete "/<%= api_namespace %>/v1/<%= type %>/#{<%= var %>.id}"
+    jsonapi_delete "<%= api_namespace %>/<%= type %>/#{<%= var %>.id}"
   end
 
   describe 'basic destroy' do

data/lib/generators/graphiti/templates/index_request_spec.rb.erb

@@ -4,7 +4,7 @@ RSpec.describe "<%= type %>#index", type: :request do
   let(:params) { {} }
 
   subject(:make_request) do
-    jsonapi_get "/<%= api_namespace %>/v1/<%= type %>", params: params
+    jsonapi_get "<%= api_namespace %>/<%= type %>", params: params
   end
 
   describe 'basic fetch' do

data/lib/generators/graphiti/templates/show_request_spec.rb.erb

@@ -4,7 +4,7 @@ RSpec.describe "<%= type %>#show", type: :request do
   let(:params) { {} }
 
   subject(:make_request) do
-    jsonapi_get "/<%= api_namespace %>/v1/<%= type %>/#{<%= var %>.id}", params: params
+    jsonapi_get "<%= api_namespace %>/<%= type %>/#{<%= var %>.id}", params: params
   end
 
   describe 'basic fetch' do

data/lib/generators/graphiti/templates/update_request_spec.rb.erb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 RSpec.describe "<%= type %>#update", type: :request do
   subject(:make_request) do
-    jsonapi_put "/<%= api_namespace %>/v1/<%= type %>/#{<%= var %>.id}", payload
+    jsonapi_put "<%= api_namespace %>/<%= type %>/#{<%= var %>.id}", payload
   end
 
   describe 'basic update' do

data/lib/graphiti/adapters/abstract.rb

@@ -469,7 +469,7 @@ module Graphiti
 
       def activerecord_adapter
         @activerecord_adapter ||=
-          ::Graphiti::Adapters::ActiveRecord::Base.new(resource)
+          ::Graphiti::Adapters::ActiveRecord.new(resource)
       end
 
       def activerecord_associate?(parent, child, association_name)

data/lib/graphiti/adapters/active_record.rb

@@ -1,6 +1,275 @@
-require 'graphiti/adapters/active_record/base'
-require 'graphiti/adapters/active_record/inferrence'
-require 'graphiti/adapters/active_record/has_many_sideload'
-require 'graphiti/adapters/active_record/belongs_to_sideload'
-require 'graphiti/adapters/active_record/has_one_sideload'
-require 'graphiti/adapters/active_record/many_to_many_sideload'
+module Graphiti
+  module Adapters
+    class ActiveRecord < ::Graphiti::Adapters::Abstract
+      require 'graphiti/adapters/active_record/inferrence'
+      require 'graphiti/adapters/active_record/has_many_sideload'
+      require 'graphiti/adapters/active_record/belongs_to_sideload'
+      require 'graphiti/adapters/active_record/has_one_sideload'
+      require 'graphiti/adapters/active_record/many_to_many_sideload'
+
+      def self.sideloading_classes
+        {
+          has_many: Graphiti::Adapters::ActiveRecord::HasManySideload,
+          has_one: Graphiti::Adapters::ActiveRecord::HasOneSideload,
+          belongs_to: Graphiti::Adapters::ActiveRecord::BelongsToSideload,
+          many_to_many: Graphiti::Adapters::ActiveRecord::ManyToManySideload
+        }
+      end
+
+      def filter_eq(scope, attribute, value)
+        scope.where(attribute => value)
+      end
+      alias :filter_integer_eq :filter_eq
+      alias :filter_float_eq :filter_eq
+      alias :filter_big_decimal_eq :filter_eq
+      alias :filter_date_eq :filter_eq
+      alias :filter_boolean_eq :filter_eq
+
+      def filter_not_eq(scope, attribute, value)
+        scope.where.not(attribute => value)
+      end
+      alias :filter_integer_not_eq :filter_not_eq
+      alias :filter_float_not_eq :filter_not_eq
+      alias :filter_big_decimal_not_eq :filter_not_eq
+      alias :filter_date_not_eq :filter_not_eq
+      alias :filter_boolean_not_eq :filter_not_eq
+
+      def filter_string_eq(scope, attribute, value, is_not: false)
+        column = scope.klass.arel_table[attribute]
+        clause = column.lower.eq_any(value.map(&:downcase))
+        is_not ? scope.where.not(clause) : scope.where(clause)
+      end
+
+      def filter_string_eql(scope, attribute, value, is_not: false)
+        clause = { attribute => value }
+        is_not ? scope.where.not(clause) : scope.where(clause)
+      end
+
+      def filter_string_not_eq(scope, attribute, value)
+        filter_string_eq(scope, attribute, value, is_not: true)
+      end
+
+      def filter_string_not_eql(scope, attribute, value)
+        filter_string_eql(scope, attribute, value, is_not: true)
+      end
+
+      def filter_string_prefix(scope, attribute, value, is_not: false)
+        column = scope.klass.arel_table[attribute]
+        map = value.map { |v| "#{v}%" }
+        clause = column.lower.matches_any(map)
+        is_not ? scope.where.not(clause) : scope.where(clause)
+      end
+
+      def filter_string_not_prefix(scope, attribute, value)
+        filter_string_prefix(scope, attribute, value, is_not: true)
+      end
+
+      def filter_string_suffix(scope, attribute, value, is_not: false)
+        column = scope.klass.arel_table[attribute]
+        map = value.map { |v| "%#{v}" }
+        clause = column.lower.matches_any(map)
+        is_not ? scope.where.not(clause) : scope.where(clause)
+      end
+
+      def filter_string_not_suffix(scope, attribute, value)
+        filter_string_suffix(scope, attribute, value, is_not: true)
+      end
+
+      def filter_string_match(scope, attribute, value, is_not: false)
+        column = scope.klass.arel_table[attribute]
+        map = value.map { |v| "%#{v.downcase}%" }
+        clause = column.lower.matches_any(map)
+        is_not ? scope.where.not(clause) : scope.where(clause)
+      end
+
+      def filter_string_not_match(scope, attribute, value)
+        filter_string_match(scope, attribute, value, is_not: true)
+      end
+
+      def filter_gt(scope, attribute, value)
+        column = scope.klass.arel_table[attribute]
+        scope.where(column.gt_any(value))
+      end
+      alias :filter_integer_gt :filter_gt
+      alias :filter_float_gt :filter_gt
+      alias :filter_big_decimal_gt :filter_gt
+      alias :filter_datetime_gt :filter_gt
+      alias :filter_date_gt :filter_gt
+
+      def filter_gte(scope, attribute, value)
+        column = scope.klass.arel_table[attribute]
+        scope.where(column.gteq_any(value))
+      end
+      alias :filter_integer_gte :filter_gte
+      alias :filter_float_gte :filter_gte
+      alias :filter_big_decimal_gte :filter_gte
+      alias :filter_datetime_gte :filter_gte
+      alias :filter_date_gte :filter_gte
+
+      def filter_lt(scope, attribute, value)
+        column = scope.klass.arel_table[attribute]
+        scope.where(column.lt_any(value))
+      end
+      alias :filter_integer_lt :filter_lt
+      alias :filter_float_lt :filter_lt
+      alias :filter_big_decimal_lt :filter_lt
+      alias :filter_datetime_lt :filter_lt
+      alias :filter_date_lt :filter_lt
+
+      def filter_lte(scope, attribute, value)
+        column = scope.klass.arel_table[attribute]
+        scope.where(column.lteq_any(value))
+      end
+      alias :filter_integer_lte :filter_lte
+      alias :filter_float_lte :filter_lte
+      alias :filter_big_decimal_lte :filter_lte
+      alias :filter_date_lte :filter_lte
+
+      # Ensure fractional seconds don't matter
+      def filter_datetime_eq(scope, attribute, value, is_not: false)
+        ranges = value.map { |v| (v..v+1.second-0.00000001) }
+        clause = { attribute => ranges }
+        is_not ? scope.where.not(clause) : scope.where(clause)
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        filter_datetime_eq(scope, attribute, value, is_not: true)
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        value = value.map { |v| v + 1.second-0.00000001 }
+        column = scope.klass.arel_table[attribute]
+        scope.where(column.lteq_any(value))
+      end
+
+      def base_scope(model)
+        model.all
+      end
+
+      # (see Adapters::Abstract#order)
+      def order(scope, attribute, direction)
+        scope.order(attribute => direction)
+      end
+
+      # (see Adapters::Abstract#paginate)
+      def paginate(scope, current_page, per_page)
+        scope.page(current_page).per(per_page)
+      end
+
+      # (see Adapters::Abstract#count)
+      def count(scope, attr)
+        if attr.to_sym == :total
+          scope.distinct.count
+        else
+          scope.distinct.count(attr)
+        end
+      end
+
+      # (see Adapters::Abstract#average)
+      def average(scope, attr)
+        scope.average(attr).to_f
+      end
+
+      # (see Adapters::Abstract#sum)
+      def sum(scope, attr)
+        scope.sum(attr)
+      end
+
+      # (see Adapters::Abstract#maximum)
+      def maximum(scope, attr)
+        scope.maximum(attr)
+      end
+
+      # (see Adapters::Abstract#minimum)
+      def minimum(scope, attr)
+        scope.minimum(attr)
+      end
+
+      # (see Adapters::Abstract#resolve)
+      def resolve(scope)
+        scope.to_a
+      end
+
+      # Run this write request within an ActiveRecord transaction
+      # @param [Class] model_class The ActiveRecord class we are saving
+      # @return Result of yield
+      # @see Adapters::Abstract#transaction
+      def transaction(model_class)
+        model_class.transaction do
+          yield
+        end
+      end
+
+      def belongs_to_many_filter(sideload, scope, value)
+        scope
+          .includes(sideload.through_relationship_name)
+          .where(sideload.through_table_name => {
+            sideload.true_foreign_key => value
+          })
+      end
+
+      def associate_all(parent, children, association_name, association_type)
+        if activerecord_associate?(parent, children[0], association_name)
+          association = parent.association(association_name)
+          association.loaded!
+
+          children.each do |child|
+            if association_type == :many_to_many &&
+                !parent.send(association_name).exists?(child.id) &&
+                [:create, :update].include?(Graphiti.context[:namespace])
+              parent.send(association_name) << child
+            else
+              target = association.instance_variable_get(:@target)
+              target |= [child]
+              association.instance_variable_set(:@target, target)
+            end
+          end
+        else
+          super
+        end
+      end
+
+      def associate(parent, child, association_name, association_type)
+        if activerecord_associate?(parent, child, association_name)
+          association = parent.association(association_name)
+          association.loaded!
+          association.instance_variable_set(:@target, child)
+        else
+          super
+        end
+      end
+
+      # When a has_and_belongs_to_many relationship, we don't have a foreign
+      # key that can be null'd. Instead, go through the ActiveRecord API.
+      # @see Adapters::Abstract#disassociate
+      def disassociate(parent, child, association_name, association_type)
+        if association_type == :many_to_many
+          parent.send(association_name).delete(child)
+        else
+          # Nothing to do here, happened when we merged foreign key
+        end
+      end
+
+      # (see Adapters::Abstract#create)
+      def create(model_class, create_params)
+        instance = model_class.new(create_params)
+        instance.save
+        instance
+      end
+
+      # (see Adapters::Abstract#update)
+      def update(model_class, update_params)
+        instance = model_class.find(update_params.delete(:id))
+        instance.update_attributes(update_params)
+        instance
+      end
+
+      # (see Adapters::Abstract#destroy)
+      def destroy(model_class, id)
+        instance = model_class.find(id)
+        instance.destroy
+        instance
+      end
+    end
+  end
+end

data/lib/graphiti/adapters/active_record/belongs_to_sideload.rb

@@ -1,17 +1,11 @@
-module Graphiti
-  module Adapters
-    module ActiveRecord
-      class BelongsToSideload < Sideload::BelongsTo
-        include Inferrence
+class Graphiti::Adapters::ActiveRecord::BelongsToSideload < Graphiti::Sideload::BelongsTo
+  include Graphiti::Adapters::ActiveRecord::Inferrence
 
-        def default_base_scope
-          resource_class.model.all
-        end
+  def default_base_scope
+    resource_class.model.all
+  end
 
-        def scope(parent_ids)
-          base_scope.where(primary_key => parent_ids)
-        end
-      end
-    end
+  def scope(parent_ids)
+    base_scope.where(primary_key => parent_ids)
   end
 end

data/lib/graphiti/adapters/active_record/has_many_sideload.rb

@@ -1,17 +1,11 @@
-module Graphiti
-  module Adapters
-    module ActiveRecord # todo change
-      class HasManySideload < Sideload::HasMany
-        include Inferrence
+class Graphiti::Adapters::ActiveRecord::HasManySideload < Graphiti::Sideload::HasMany
+  include Graphiti::Adapters::ActiveRecord::Inferrence
 
-        def default_base_scope
-          resource_class.model.all
-        end
+  def default_base_scope
+    resource_class.model.all
+  end
 
-        def scope(parent_ids)
-          base_scope.where(foreign_key => parent_ids)
-        end
-      end
-    end
+  def scope(parent_ids)
+    base_scope.where(foreign_key => parent_ids)
   end
 end

data/lib/graphiti/adapters/active_record/has_one_sideload.rb

@@ -1,17 +1,11 @@
-module Graphiti
-  module Adapters
-    module ActiveRecord
-      class HasOneSideload < Sideload::HasOne
-        include Inferrence
+class Graphiti::Adapters::ActiveRecord::HasOneSideload < Graphiti::Sideload::HasOne
+  include Graphiti::Adapters::ActiveRecord::Inferrence
 
-        def default_base_scope
-          resource_class.model.all
-        end
+  def default_base_scope
+    resource_class.model.all
+  end
 
-        def scope(parent_ids)
-          base_scope.where(foreign_key => parent_ids)
-        end
-      end
-    end
+  def scope(parent_ids)
+    base_scope.where(foreign_key => parent_ids)
   end
 end

data/lib/graphiti/adapters/active_record/inferrence.rb

@@ -1,19 +1,13 @@
-module Graphiti
-  module Adapters
-    module ActiveRecord
-      module Inferrence
-        # If going AR to AR, use AR introspection
-        # If going AR to PORO, fall back to normal inferrence
-        def infer_foreign_key
-          parent_model = parent_resource_class.model
-          reflection = parent_model.reflections[association_name.to_s]
-          if reflection
-            reflection.foreign_key.to_sym
-          else
-            super
-          end
-        end
-      end
+module Graphiti::Adapters::ActiveRecord::Inferrence
+  # If going AR to AR, use AR introspection
+  # If going AR to PORO, fall back to normal inferrence
+  def infer_foreign_key
+    parent_model = parent_resource_class.model
+    reflection = parent_model.reflections[association_name.to_s]
+    if reflection
+      reflection.foreign_key.to_sym
+    else
+      super
     end
   end
 end

data/lib/graphiti/adapters/active_record/many_to_many_sideload.rb

@@ -1,23 +1,17 @@
-module Graphiti
-  module Adapters
-    module ActiveRecord
-      class ManyToManySideload < Sideload::ManyToMany
-        def through_table_name
-          @through_table_name ||= parent_resource_class.model
-            .reflections[through.to_s].klass.table_name
-        end
+class Graphiti::Adapters::ActiveRecord::ManyToManySideload < Graphiti::Sideload::ManyToMany
+  def through_table_name
+    @through_table_name ||= parent_resource_class.model
+      .reflections[through.to_s].klass.table_name
+  end
 
-        def through_relationship_name
-          foreign_key.keys.first
-        end
+  def through_relationship_name
+    foreign_key.keys.first
+  end
 
-        def infer_foreign_key
-          parent_model = parent_resource_class.model
-          key = parent_model.reflections[name.to_s].options[:through]
-          value = parent_model.reflections[key.to_s].foreign_key.to_sym
-          { key => value }
-        end
-      end
-    end
+  def infer_foreign_key
+    parent_model = parent_resource_class.model
+    key = parent_model.reflections[name.to_s].options[:through]
+    value = parent_model.reflections[key.to_s].foreign_key.to_sym
+    { key => value }
   end
 end

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.alpha.18"
+  VERSION = "1.0.alpha.19"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.0.alpha.18
+  version: 1.0.alpha.19
 platform: ruby
 authors:
 - Lee Richmond
@@ -236,7 +236,6 @@ files:
 - lib/graphiti.rb
 - lib/graphiti/adapters/abstract.rb
 - lib/graphiti/adapters/active_record.rb
-- lib/graphiti/adapters/active_record/base.rb
 - lib/graphiti/adapters/active_record/belongs_to_sideload.rb
 - lib/graphiti/adapters/active_record/has_many_sideload.rb
 - lib/graphiti/adapters/active_record/has_one_sideload.rb

data/lib/graphiti/adapters/active_record/base.rb

@@ -1,271 +0,0 @@
-module Graphiti
-  module Adapters
-    module ActiveRecord
-      class Base < ::Graphiti::Adapters::Abstract
-        def filter_eq(scope, attribute, value)
-          scope.where(attribute => value)
-        end
-        alias :filter_integer_eq :filter_eq
-        alias :filter_float_eq :filter_eq
-        alias :filter_big_decimal_eq :filter_eq
-        alias :filter_date_eq :filter_eq
-        alias :filter_boolean_eq :filter_eq
-
-        def filter_not_eq(scope, attribute, value)
-          scope.where.not(attribute => value)
-        end
-        alias :filter_integer_not_eq :filter_not_eq
-        alias :filter_float_not_eq :filter_not_eq
-        alias :filter_big_decimal_not_eq :filter_not_eq
-        alias :filter_date_not_eq :filter_not_eq
-        alias :filter_boolean_not_eq :filter_not_eq
-
-        def filter_string_eq(scope, attribute, value, is_not: false)
-          column = scope.klass.arel_table[attribute]
-          clause = column.lower.eq_any(value.map(&:downcase))
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-
-        def filter_string_eql(scope, attribute, value, is_not: false)
-          clause = { attribute => value }
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-
-        def filter_string_not_eq(scope, attribute, value)
-          filter_string_eq(scope, attribute, value, is_not: true)
-        end
-
-        def filter_string_not_eql(scope, attribute, value)
-          filter_string_eql(scope, attribute, value, is_not: true)
-        end
-
-        def filter_string_prefix(scope, attribute, value, is_not: false)
-          column = scope.klass.arel_table[attribute]
-          map = value.map { |v| "#{v}%" }
-          clause = column.lower.matches_any(map)
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-
-        def filter_string_not_prefix(scope, attribute, value)
-          filter_string_prefix(scope, attribute, value, is_not: true)
-        end
-
-        def filter_string_suffix(scope, attribute, value, is_not: false)
-          column = scope.klass.arel_table[attribute]
-          map = value.map { |v| "%#{v}" }
-          clause = column.lower.matches_any(map)
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-
-        def filter_string_not_suffix(scope, attribute, value)
-          filter_string_suffix(scope, attribute, value, is_not: true)
-        end
-
-        def filter_string_match(scope, attribute, value, is_not: false)
-          column = scope.klass.arel_table[attribute]
-          map = value.map { |v| "%#{v.downcase}%" }
-          clause = column.lower.matches_any(map)
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-
-        def filter_string_not_match(scope, attribute, value)
-          filter_string_match(scope, attribute, value, is_not: true)
-        end
-
-        def filter_gt(scope, attribute, value)
-          column = scope.klass.arel_table[attribute]
-          scope.where(column.gt_any(value))
-        end
-        alias :filter_integer_gt :filter_gt
-        alias :filter_float_gt :filter_gt
-        alias :filter_big_decimal_gt :filter_gt
-        alias :filter_datetime_gt :filter_gt
-        alias :filter_date_gt :filter_gt
-
-        def filter_gte(scope, attribute, value)
-          column = scope.klass.arel_table[attribute]
-          scope.where(column.gteq_any(value))
-        end
-        alias :filter_integer_gte :filter_gte
-        alias :filter_float_gte :filter_gte
-        alias :filter_big_decimal_gte :filter_gte
-        alias :filter_datetime_gte :filter_gte
-        alias :filter_date_gte :filter_gte
-
-        def filter_lt(scope, attribute, value)
-          column = scope.klass.arel_table[attribute]
-          scope.where(column.lt_any(value))
-        end
-        alias :filter_integer_lt :filter_lt
-        alias :filter_float_lt :filter_lt
-        alias :filter_big_decimal_lt :filter_lt
-        alias :filter_datetime_lt :filter_lt
-        alias :filter_date_lt :filter_lt
-
-        def filter_lte(scope, attribute, value)
-          column = scope.klass.arel_table[attribute]
-          scope.where(column.lteq_any(value))
-        end
-        alias :filter_integer_lte :filter_lte
-        alias :filter_float_lte :filter_lte
-        alias :filter_big_decimal_lte :filter_lte
-        alias :filter_date_lte :filter_lte
-
-        # Ensure fractional seconds don't matter
-        def filter_datetime_eq(scope, attribute, value, is_not: false)
-          ranges = value.map { |v| (v..v+1.second-0.00000001) }
-          clause = { attribute => ranges }
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-
-        def filter_datetime_not_eq(scope, attribute, value)
-          filter_datetime_eq(scope, attribute, value, is_not: true)
-        end
-
-        def filter_datetime_lte(scope, attribute, value)
-          value = value.map { |v| v + 1.second-0.00000001 }
-          column = scope.klass.arel_table[attribute]
-          scope.where(column.lteq_any(value))
-        end
-
-        def base_scope(model)
-          model.all
-        end
-
-        # (see Adapters::Abstract#order)
-        def order(scope, attribute, direction)
-          scope.order(attribute => direction)
-        end
-
-        # (see Adapters::Abstract#paginate)
-        def paginate(scope, current_page, per_page)
-          scope.page(current_page).per(per_page)
-        end
-
-        # (see Adapters::Abstract#count)
-        def count(scope, attr)
-          if attr.to_sym == :total
-            scope.distinct.count
-          else
-            scope.distinct.count(attr)
-          end
-        end
-
-        # (see Adapters::Abstract#average)
-        def average(scope, attr)
-          scope.average(attr).to_f
-        end
-
-        # (see Adapters::Abstract#sum)
-        def sum(scope, attr)
-          scope.sum(attr)
-        end
-
-        # (see Adapters::Abstract#maximum)
-        def maximum(scope, attr)
-          scope.maximum(attr)
-        end
-
-        # (see Adapters::Abstract#minimum)
-        def minimum(scope, attr)
-          scope.minimum(attr)
-        end
-
-        # (see Adapters::Abstract#resolve)
-        def resolve(scope)
-          scope.to_a
-        end
-
-        # Run this write request within an ActiveRecord transaction
-        # @param [Class] model_class The ActiveRecord class we are saving
-        # @return Result of yield
-        # @see Adapters::Abstract#transaction
-        def transaction(model_class)
-          model_class.transaction do
-            yield
-          end
-        end
-
-        def self.sideloading_classes
-          {
-            has_many: HasManySideload,
-            has_one: HasOneSideload,
-            belongs_to: BelongsToSideload,
-            many_to_many: ManyToManySideload
-          }
-        end
-
-        def belongs_to_many_filter(sideload, scope, value)
-          scope
-            .includes(sideload.through_relationship_name)
-            .where(sideload.through_table_name => {
-              sideload.true_foreign_key => value
-            })
-        end
-
-        def associate_all(parent, children, association_name, association_type)
-          if activerecord_associate?(parent, children[0], association_name)
-            association = parent.association(association_name)
-            association.loaded!
-
-            children.each do |child|
-              if association_type == :many_to_many &&
-                  !parent.send(association_name).exists?(child.id) &&
-                  [:create, :update].include?(Graphiti.context[:namespace])
-                parent.send(association_name) << child
-              else
-                target = association.instance_variable_get(:@target)
-                target |= [child]
-                association.instance_variable_set(:@target, target)
-              end
-            end
-          else
-            super
-          end
-        end
-
-        def associate(parent, child, association_name, association_type)
-          if activerecord_associate?(parent, child, association_name)
-            association = parent.association(association_name)
-            association.loaded!
-            association.instance_variable_set(:@target, child)
-          else
-            super
-          end
-        end
-
-        # When a has_and_belongs_to_many relationship, we don't have a foreign
-        # key that can be null'd. Instead, go through the ActiveRecord API.
-        # @see Adapters::Abstract#disassociate
-        def disassociate(parent, child, association_name, association_type)
-          if association_type == :many_to_many
-            parent.send(association_name).delete(child)
-          else
-            # Nothing to do here, happened when we merged foreign key
-          end
-        end
-
-        # (see Adapters::Abstract#create)
-        def create(model_class, create_params)
-          instance = model_class.new(create_params)
-          instance.save
-          instance
-        end
-
-        # (see Adapters::Abstract#update)
-        def update(model_class, update_params)
-          instance = model_class.find(update_params.delete(:id))
-          instance.update_attributes(update_params)
-          instance
-        end
-
-        # (see Adapters::Abstract#destroy)
-        def destroy(model_class, id)
-          instance = model_class.find(id)
-          instance.destroy
-          instance
-        end
-      end
-    end
-  end
-end