jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/jsonapi_compliable/resource/sideloading.rb

@@ -0,0 +1,102 @@
+module JsonapiCompliable
+  class Resource
+    module Sideloading
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def allow_sideload(name, opts = {}, &blk)
+          klass = Class.new(opts.delete(:class) || Sideload)
+          klass.class_eval(&blk) if blk
+          opts[:parent_resource] = self
+          relationship_option(opts, :readable)
+          relationship_option(opts, :writable)
+          sideload = klass.new(name, opts)
+          if parent = opts[:parent]
+            parent.children[name] = sideload
+          else
+            config[:sideloads][name] = sideload
+            apply_sideloads_to_serializer
+          end
+          sideload
+        end
+
+        def apply_sideloads_to_serializer
+          config[:sideloads].each_pair do |name, sideload|
+            if serializer.relationship_blocks[name].nil? && sideload.readable?
+              serializer.relationship(name)
+            end
+          end
+        end
+
+        def has_many(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:has_many]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def belongs_to(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:belongs_to]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def has_one(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:has_one]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def many_to_many(name, opts = {}, &blk)
+          opts[:class] = adapter.sideloading_classes[:many_to_many]
+          allow_sideload(name, opts, &blk)
+        end
+
+        def polymorphic_belongs_to(name, opts = {}, &blk)
+          opts[:resource] ||= Class.new(::JsonapiCompliable::Resource) do
+            self.polymorphic = []
+            self.abstract_class = true
+          end
+          # adapters *probably* don't need to override this, but it's allowed
+          opts[:class] ||= adapter.sideloading_classes[:polymorphic_belongs_to]
+          opts[:class] ||= ::JsonapiCompliable::Sideload::PolymorphicBelongsTo
+          allow_sideload(name, opts, &blk)
+        end
+
+        def sideload(name)
+          sideloads[name]
+        end
+
+        def all_sideloads(memo = {})
+          sideloads.each_pair do |name, sideload|
+            unless memo[name]
+              memo[name] = sideload
+              memo.merge!(sideload.resource.class.all_sideloads(memo))
+            end
+          end
+          memo
+        end
+
+        def association_names(memo = [])
+          all_sideloads.each_pair do |name, sl|
+            unless memo.include?(sl.name)
+              memo << sl.name
+              memo |= sl.resource.class.association_names(memo)
+            end
+          end
+
+          memo
+        end
+
+        def association_types(memo = [])
+          all_sideloads.each_pair do |name, sl|
+            unless memo.include?(sl.resource.type)
+              memo << sl.resource.type
+              memo |= sl.resource.class.association_types(memo)
+            end
+          end
+
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/resource_proxy.rb

@@ -0,0 +1,127 @@
+module JsonapiCompliable
+  class ResourceProxy
+    include Enumerable
+
+    attr_reader :resource, :query, :scope
+
+    def initialize(resource, scope, query, payload: nil, single: false, raise_on_missing: false)
+      @resource = resource
+      @scope = scope
+      @query = query
+      @payload = payload
+      @single = single
+      @raise_on_missing = raise_on_missing
+    end
+
+    def single?
+      !!@single
+    end
+
+    def raise_on_missing?
+      !!@raise_on_missing
+    end
+
+    def errors
+      data.errors
+    end
+
+    def [](val)
+      data[val]
+    end
+
+    def jsonapi_render_options(opts = {})
+      opts[:meta]   ||= {}
+      opts[:expose] ||= {}
+      opts[:expose][:context] = JsonapiCompliable.context[:object]
+      opts
+    end
+
+    def to_jsonapi(options = {})
+      options = jsonapi_render_options(options)
+      Renderer.new(self, options).to_jsonapi
+    end
+
+    def to_json(options = {})
+      Renderer.new(self, options).to_json
+    end
+
+    def to_xml(options = {})
+      Renderer.new(self, options).to_xml
+    end
+
+    def data
+      @data ||= begin
+        records = @scope.resolve
+        if records.empty? && raise_on_missing?
+          raise JsonapiCompliable::Errors::RecordNotFound
+        end
+        records = records[0] if single?
+        records
+      end
+    end
+    alias :to_a :data
+
+    def each(&blk)
+      to_a.each(&blk)
+    end
+
+    def stats
+      @stats ||= @scope.resolve_stats
+    end
+
+    def save(action: :create)
+      validator = persist do
+        @resource.persist_with_relationships \
+          @payload.meta(action: action),
+          @payload.attributes,
+          @payload.relationships
+      end
+      @data, success = validator.to_a
+      success
+    end
+
+    def destroy
+      validator = @resource.transaction do
+        model = @resource.destroy(@query.filters[:id])
+        model.instance_variable_set(:@__serializer_klass, @resource.serializer)
+        validator = ::JsonapiCompliable::Util::ValidationResponse.new \
+          model, @payload
+        validator.validate!
+        @resource.before_commit(model, :destroy)
+        validator
+      end
+      @data, success = validator.to_a
+      success
+    end
+
+    def update_attributes
+      save(action: :update)
+    end
+
+    def include_hash
+      @payload ? @payload.include_hash : @query.include_hash
+    end
+
+    def fields
+      query.fields
+    end
+
+    def extra_fields
+      query.extra_fields
+    end
+
+    private
+
+    def persist
+      @resource.transaction do
+        ::JsonapiCompliable::Util::Hooks.record do
+          model = yield
+          validator = ::JsonapiCompliable::Util::ValidationResponse.new \
+            model, @payload
+          validator.validate!
+          validator
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/responders.rb

@@ -0,0 +1,19 @@
+# If you're using Rails + responders gem to get respond_with
+module JsonapiCompliable
+  module Responders
+    extend ActiveSupport::Concern
+
+    included do
+      include ActionController::MimeResponds
+      respond_to :json, :jsonapi, :xml, :api_json
+    end
+
+    # Override to avoid location url generation (for now)
+    def respond_with(*args, &blk)
+      opts = args.extract_options!
+      opts[:location] = nil
+      args << opts
+      super(*args, &blk)
+    end
+  end
+end

data/lib/jsonapi_compliable/runner.rb

@@ -0,0 +1,25 @@
+module JsonapiCompliable
+  class Runner
+    attr_reader :params
+    include JsonapiCompliable::Base
+
+    def initialize(resource_class, params)
+      @resource_class = resource_class
+      @params = params
+    end
+
+    def jsonapi_resource
+      @jsonapi_resource ||= @resource_class.new
+    end
+
+    # Typically, this is 'self' of a controller
+    # We're overriding here so we can do stuff like
+    #
+    # JsonapiCompliable.with_context my_context, {} do
+    #   Runner.new ...
+    # end
+    def jsonapi_context
+      JsonapiCompliable.context[:object]
+    end
+  end
+end

data/lib/jsonapi_compliable/scope.rb

@@ -1,112 +1,69 @@
 module JsonapiCompliable
-  # A Scope wraps an underlying object. It modifies that object
-  # using the corresponding Resource and Query, and how to resolve
-  # that underlying object scope.
-  #
-  # @example Basic Controller usage
-  #   def index
-  #     base  = Post.all
-  #     scope = jsonapi_scope(base)
-  #     scope.object == base # => true
-  #     scope.object = scope.object.where(active: true)
-  #
-  #     # actually fires sql
-  #     scope.resolve #=> [#<Post ...>, #<Post ...>, etc]
-  #   end
   class Scope
-    attr_reader :object, :unpaginated_object
+    attr_accessor :object, :unpaginated_object
 
-    # @param object - The underlying, chainable base scope object
-    # @param resource - The Resource that will process the object
-    # @param query - The Query object for the current request
-    # @param [Hash] opts Options to configure the Scope
-    # @option opts [String] :namespace The nested relationship name
-    # @option opts [Boolean] :filter Opt-out of filter scoping
-    # @option opts [Boolean] :extra_fields Opt-out of extra_fields scoping
-    # @option opts [Boolean] :sort Opt-out of sort scoping
-    # @option opts [Boolean] :pagination Opt-out of pagination scoping
-    # @option opts [Boolean] :default_paginate Opt-out of default pagination when not specified in request
     def initialize(object, resource, query, opts = {})
       @object    = object
       @resource  = resource
       @query     = query
+      @opts      = opts
 
-      # 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)
+      @object = @resource.around_scoping(@object, query_hash) do |scope|
+        apply_scoping(scope, opts)
+      end
     end
 
-    # Resolve the requested stats. Returns hash like:
-    #
-    #   { rating: { average: 5.5, maximum: 9 } }
-    #
-    # @return [Hash] the resolved stat info
-    # @api private
     def resolve_stats
-      Stats::Payload.new(@resource, query_hash, @unpaginated_object).generate
+      if query_hash[:stats]
+        Stats::Payload.new(@resource, @query, @unpaginated_object).generate
+      else
+        {}
+      end
     end
 
-    # Resolve the scope. This is where SQL is actually fired, an HTTP
-    # request is actually made, etc.
-    #
-    # Does nothing if the user requested zero results, ie /posts?page[size]=0
-    #
-    # First resolves the top-level resource, then processes each relevant sideload
-    #
-    # @see Resource#resolve
-    # @return [Array] an array of resolved model instances
     def resolve
       if @query.zero_results?
         []
       else
         resolved = @resource.resolve(@object)
+        assign_serializer(resolved)
         yield resolved if block_given?
-        sideload(resolved, query_hash[:include]) if query_hash[:include]
+        if @opts[:after_resolve]
+          @opts[:after_resolve].call(resolved)
+        end
+        sideload(resolved) unless @query.sideloads.empty?
         resolved
       end
     end
 
-    # The slice of Query#to_hash for the current namespace
-    # @see Query#to_hash
-    # @api private
     def query_hash
-      @query_hash ||= @query.to_hash[@namespace]
+      @query_hash ||= @query.to_hash
     end
 
     private
 
-    def sideload(results, includes)
+    # Used to ensure the resource's serializer is used
+    # Not one derived through the usual jsonapi-rb logic
+    def assign_serializer(records)
+      records.each do |r|
+        serializer = @resource.serializer_for(r)
+        r.instance_variable_set(:@__serializer_klass, serializer)
+      end
+    end
+
+    def sideload(results)
       return if results == []
 
       concurrent = ::JsonapiCompliable.config.experimental_concurrency
       promises = []
 
-      includes.each_pair do |name, nested|
-        sideload = @resource.sideload(name)
-
-        if sideload.nil?
-          if JsonapiCompliable.config.raise_on_missing_sideload
-            raise JsonapiCompliable::Errors::InvalidInclude
-              .new(name, @resource.type)
-          end
+      @query.sideloads.each_pair do |name, q|
+        sideload = @resource.class.sideload(name)
+        resolve_sideload = -> { sideload.resolve(results, q) }
+        if concurrent
+          promises << Concurrent::Promise.execute(&resolve_sideload)
         else
-          namespace = Util::Sideload.namespace(@namespace, sideload.name)
-          resolve_sideload = -> {
-            begin
-              sideload.resolve(results, @query, namespace)
-            ensure
-              ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord)
-            end
-          }
-          if concurrent
-            promises << Concurrent::Promise.execute(&resolve_sideload)
-          else
-            resolve_sideload.call
-          end
+          resolve_sideload.call
         end
       end
 
@@ -124,16 +81,17 @@ module JsonapiCompliable
       end
     end
 
-     def apply_scoping(opts)
+    def apply_scoping(scope, opts)
+      @object = scope
       add_scoping(nil, JsonapiCompliable::Scoping::DefaultFilter, opts)
       add_scoping(:filter, JsonapiCompliable::Scoping::Filter, opts)
-      add_scoping(:extra_fields, JsonapiCompliable::Scoping::ExtraFields, opts)
       add_scoping(:sort, JsonapiCompliable::Scoping::Sort, opts)
-      add_scoping(:paginate, JsonapiCompliable::Scoping::Paginate, opts, default: opts[:default_paginate])
+      add_scoping(:paginate, JsonapiCompliable::Scoping::Paginate, opts)
+      @object
     end
 
     def add_scoping(key, scoping_class, opts, default = {})
-      @object = scoping_class.new(@resource, query_hash, @object, default).apply unless opts[key] == false
+      @object = scoping_class.new(@resource, query_hash, @object, opts).apply
       @unpaginated_object = @object unless key == :paginate
     end
   end

data/lib/jsonapi_compliable/scoping/extra_attributes.rb

@@ -0,0 +1,29 @@
+module JsonapiCompliable
+  class Scoping::ExtraAttributes < Scoping::Base
+    # Loop through all requested extra fields. If custom scoping
+    # logic is define for that field, run it. Otherwise, do nothing.
+    #
+    # @return the scope object we are chaining/modofying
+    def apply
+      each_extra_attribute do |callable|
+        @scope = callable.call(@scope, resource.context)
+      end
+
+      @scope
+    end
+
+    private
+
+    def each_extra_field
+      resource.extra_fields.each_pair do |name, callable|
+        if extra_fields.include?(name)
+          yield callable
+        end
+      end
+    end
+
+    def extra_fields
+      query_hash[:extra_fields][resource.type] || []
+    end
+  end
+end