Move to new adapters/sideloading pattern

Author: Lee Richmond

lib/jsonapi_compliable.rb

@@ -4,11 +4,11 @@
 require "jsonapi_compliable/errors"
 require "jsonapi_compliable/resource"
 require "jsonapi_compliable/query"
+require "jsonapi_compliable/sideload"
 require "jsonapi_compliable/scope"
 require "jsonapi_compliable/scoping/base"
 require "jsonapi_compliable/scoping/sort"
 require "jsonapi_compliable/scoping/paginate"
-require "jsonapi_compliable/scoping/sideload"
 require "jsonapi_compliable/scoping/extra_fields"
 require "jsonapi_compliable/scoping/filterable"
 require "jsonapi_compliable/scoping/default_filter"

lib/jsonapi_compliable/adapters/abstract.rb

@@ -16,6 +16,10 @@ def paginate(scope, number, size)
       def sideload(scope, includes)
         raise 'you must override #sideload in an adapter subclass'
       end
+
+      def sideloading_module
+        Module.new
+      end
     end
   end
 end

lib/jsonapi_compliable/adapters/active_record.rb

@@ -1,3 +1,5 @@
+require 'jsonapi_compliable/adapters/active_record_sideloading'
+
 module JsonapiCompliable
   module Adapters
     class ActiveRecord < Abstract
@@ -36,6 +38,10 @@ def maximum(scope, attr)
       def minimum(scope, attr)
         scope.minimum(attr)
       end
+
+      def sideloading_module
+        JsonapiCompliable::Adapters::ActiveRecordSideloading
+      end
     end
   end
 end

lib/jsonapi_compliable/adapters/active_record_sideloading.rb

@@ -0,0 +1,70 @@
+module JsonapiCompliable
+  module Adapters
+    module ActiveRecordSideloading
+      def has_many(association_name, scope:, resource:, foreign_key:, primary_key: :id, &blk)
+        _scope = scope
+
+        allow_sideload association_name, resource: resource do
+          scope do |parents|
+            parent_ids = parents.map { |p| p.send(primary_key) }
+            _scope.call.where(foreign_key => parent_ids)
+          end
+
+          assign do |parents, children|
+            parents.each do |parent|
+              parent.association(association_name).loaded!
+              relevant_children = children.select { |c| c.send(foreign_key) == parent.send(primary_key) }
+              relevant_children.each do |c|
+                parent.association(association_name).add_to_target(c, :skip_callbacks)
+              end
+            end
+          end
+
+          instance_eval(&blk) if blk
+        end
+      end
+
+      def belongs_to(association_name, scope:, resource:, foreign_key:, primary_key: :id, &blk)
+        _scope = scope
+
+        allow_sideload association_name, resource: resource do
+          scope do |parents|
+            parent_ids = parents.map { |p| p.send(foreign_key) }
+            _scope.call.where(primary_key => parent_ids)
+          end
+
+          assign do |parents, children|
+            parents.each do |parent|
+              relevant_child = children.find { |c| parent.send(foreign_key) == c.send(primary_key) }
+              parent.send(:"#{association_name}=", relevant_child)
+            end
+          end
+        end
+
+        instance_eval(&blk) if blk
+      end
+
+      def has_one(association_name, scope:, resource:, foreign_key:, primary_key: :id, &blk)
+        _scope = scope
+
+        allow_sideload association_name, resource: resource do
+          scope do |parents|
+            parent_ids = parents.map { |p| p.send(primary_key) }
+            _scope.call.where(foreign_key => parent_ids)
+          end
+
+          assign do |parents, children|
+            parents.each do |parent|
+              parent.association(association_name).loaded!
+              relevant_child = children.find { |c| c.send(foreign_key) == parent.send(primary_key) }
+              next unless relevant_child
+              parent.send(:"#{association_name}=", relevant_child)
+            end
+          end
+
+          instance_eval(&blk) if blk
+        end
+      end
+    end
+  end
+end

lib/jsonapi_compliable/adapters/null.rb

@@ -0,0 +1,21 @@
+module JsonapiCompliable
+  module Adapters
+    class Null < Abstract
+      def filter(scope, attribute, value)
+        scope
+      end
+
+      def order(scope, attribute, direction)
+        scope
+      end
+
+      def paginate(scope, number, size)
+        scope
+      end
+
+      def sideload(scope, includes)
+        scope
+      end
+    end
+  end
+end

lib/jsonapi_compliable/base.rb

@@ -50,7 +50,7 @@ def render_jsonapi(scope, opts = {})
       options = default_jsonapi_render_options
       options[:include] = forced_includes || Util::IncludeParams.scrub(query_hash[:include], resource.allowed_sideloads)
       options[:jsonapi] = resolved
-      options[:fields] = query.fieldsets
+      options[:fields] = query_hash[:fields]
       options[:meta] ||= {}
       options.merge!(opts)
 
@@ -107,7 +107,7 @@ def jsonapi(resource: nil, &blk)
           self._jsonapi_compliable = resource
         else
           if !self._jsonapi_compliable
-            self._jsonapi_compliable = JsonapiCompliable::Resource
+            self._jsonapi_compliable = Class.new(JsonapiCompliable::Resource)
           end
         end
 

lib/jsonapi_compliable/extensions/extra_attribute.rb

@@ -14,7 +14,7 @@ def extra_attribute(name, options = {}, &blk)
               next false unless instance_eval(&options[:if])
             end
 
-            @extra_fields.include?(name)
+            @extra_fields[@_type] && @extra_fields[@_type].include?(name)
           }
 
           attribute name, if: allow_field, &blk

lib/jsonapi_compliable/query.rb

@@ -10,9 +10,9 @@ def self.default_hash
         sort: [],
         page: {},
         include: {},
-        extra_fields: [],
-        fields: [],
-        stats: {}
+        stats: {},
+        fields: {},
+        extra_fields: {}
       }
     end
 
@@ -27,8 +27,13 @@ def to_hash
         hash[name] = self.class.default_hash.except(:include)
       end
 
-      parse_fields(hash, :fields)
-      parse_fields(hash, :extra_fields)
+      fields = parse_fields({}, :fields)
+      extra_fields = parse_fields({}, :extra_fields)
+      hash.each_pair do |type, query_hash|
+        hash[type][:fields] = fields
+        hash[type][:extra_fields] = extra_fields
+      end
+
       parse_filter(hash)
       parse_sort(hash)
       parse_pagination(hash)
@@ -38,17 +43,6 @@ def to_hash
       hash
     end
 
-    # TODO: test
-    def fieldsets
-      {}.tap do |fs|
-        to_hash.each_pair do |namespace, query_hash|
-          if query_hash[:fields] and !query_hash[:fields].empty?
-            fs[namespace] = query_hash[:fields]
-          end
-        end
-      end
-    end
-
     def zero_results?
       !@params[:page].nil? &&
         !@params[:page][:size].nil? &&
@@ -61,7 +55,6 @@ def association?(name)
       resource.association_names.include?(name)
     end
 
-    # TODO: maybe walk the graph and apply to all
     def parse_include(hash)
       hash[resource.type][:include] = JSONAPI::IncludeDirective.new(params[:include] || {}).to_hash
     end
@@ -82,9 +75,7 @@ def parse_stats(hash)
 
     def parse_fields(hash, type)
       field_params = Util::FieldParams.parse(params[type])
-      field_params.each_pair do |namespace, fields|
-        hash[namespace][type] = fields
-      end
+      hash[type] = field_params
     end
 
     def parse_filter(hash)

lib/jsonapi_compliable/resource.rb

@@ -7,9 +7,10 @@ class Resource
       :default_page_number,
       :sorting,
       :stats,
-      :sideloads,
+      :sideload_whitelist,
       :pagination,
       :extra_fields,
+      :sideloading,
       :adapter,
       :type,
       :context
@@ -18,17 +19,27 @@ class << self
       attr_accessor :config
     end
 
+    delegate :sideload, to: :sideloading
+
+    # Incorporate custom adapter methods
+    def self.method_missing(meth, *args, &blk)
+      if sideloading.respond_to?(meth)
+        sideloading.send(meth, *args, &blk)
+      else
+        super
+      end
+    end
+
     def self.inherited(klass)
       klass.config = self.config.deep_dup
     end
 
-    def self.includes(whitelist: nil, &blk)
-      whitelist = JSONAPI::IncludeDirective.new(whitelist) if whitelist
+    def self.sideloading
+      config[:sideloading] ||= Sideload.new(:base, resource: self)
+    end
 
-      config[:sideloads] = {
-        whitelist: whitelist,
-        custom_scope: blk
-      }
+    def self.sideload_whitelist(whitelist)
+      config[:sideload_whitelist] = JSONAPI::IncludeDirective.new(whitelist).to_hash
     end
 
     def self.allow_filter(name, *args, &blk)
@@ -89,6 +100,7 @@ def self.config
       @config ||= begin
         {
           sideloads: {},
+          sideload_whitelist: {},
           filters: {},
           default_filters: {},
           extra_fields: {},
@@ -136,22 +148,22 @@ def build_scope(base, query, opts = {})
 
     def association_names
       @association_names ||= begin
-        if whitelist = sideloads[:whitelist]
-          Util::Hash.keys(whitelist.to_hash.values.reduce(&:merge))
+        if sideloading
+          Util::Hash.keys(sideloading.to_hash[:base])
         else
           []
         end
       end
     end
 
     def allowed_sideloads
-      return {} if sideloads.empty?
+      return {} unless sideloading
 
-      if namespace = context[:namespace]
-        sideloads[:whitelist][namespace].to_hash
-      else
-        sideloads[:whitelist].to_hash.values.reduce(&:merge)
+      sideloads = sideloading.to_hash[:base]
+      if !sideload_whitelist.empty? && context[:namespace]
+        sideloads = Util::IncludeParams.scrub(sideloads, sideload_whitelist[context[:namespace]])
       end
+      sideloads
     end
 
     def stat(attribute, calculation)

lib/jsonapi_compliable/scope.rb

@@ -1,9 +1,15 @@
 module JsonapiCompliable
   class Scope
     def initialize(object, resource, query, opts = {})
-      @object   = object
-      @resource = resource
-      @query    = query
+      @object    = object
+      @resource  = resource
+      @query     = query
+
+      # Namespace for the 'outer' or 'main' resource is its type
+      # For its relationships, its the relationship name
+      # IOW when hitting /states, it's resource type 'states
+      # when hitting /authors?include=state its 'state'
+      @namespace = opts.delete(:namespace) || resource.type
 
       apply_scoping(opts)
     end
@@ -16,21 +22,36 @@ def resolve
       if @query.zero_results?
         []
       else
-        @object
+        resolved = @object
+        # TODO - configurable resolve function
+        resolved = @object.to_a if @object.is_a?(ActiveRecord::Relation)
+        sideload(resolved, query_hash[:include]) if query_hash[:include]
+        resolved
       end
     end
 
     def query_hash
-      @query_hash ||= @query.to_hash[@resource.type]
+      @query_hash ||= @query.to_hash[@namespace]
     end
 
     private
 
+    def sideload(results, includes)
+      includes.each_pair do |name, nested|
+        if @resource.allowed_sideloads.has_key?(name)
+          sideload         = @resource.sideload(name)
+          sideload_scope   = sideload.scope_proc.call(results)
+          sideload_scope   = Scope.new(sideload_scope, sideload.resource, @query, namespace: sideload.name)
+          sideload_results = sideload_scope.resolve
+          sideload.assign_proc.call(results, sideload_results)
+        end
+      end
+    end
+
     def apply_scoping(opts)
       @object = JsonapiCompliable::Scoping::DefaultFilter.new(@resource, query_hash, @object).apply
       @object = JsonapiCompliable::Scoping::Filter.new(@resource, query_hash, @object).apply unless opts[:filter] == false
       @object = JsonapiCompliable::Scoping::ExtraFields.new(@resource, query_hash, @object).apply unless opts[:extra_fields] == false
-      @object = JsonapiCompliable::Scoping::Sideload.new(@resource, query_hash, @object).apply unless opts[:includes] == false
       @object = JsonapiCompliable::Scoping::Sort.new(@resource, query_hash, @object).apply unless opts[:sort] == false
       @unpaginated_object = @object
       @object = JsonapiCompliable::Scoping::Paginate.new(@resource, query_hash, @object).apply unless opts[:paginate] == false