jsonapi_compliable 0.11.34 → 1.0.alpha.2

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

@@ -0,0 +1,30 @@
+module JsonapiCompliable
+  module Adapters
+    module ActiveRecord
+      class ManyToManySideload < Sideload::ManyToMany
+        def default_base_scope
+          resource_class.model.all
+        end
+
+        def through_table_name
+          @through_table_name ||= parent_resource_class.model
+            .reflections[through.to_s].klass.table_name
+        end
+
+        def scope(parent_ids)
+          base_scope
+            .includes(through)
+            .where(through_table_name => { true_foreign_key => parent_ids })
+            .distinct
+        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
+  end
+end

data/lib/jsonapi_compliable/adapters/null.rb

@@ -4,11 +4,186 @@ module JsonapiCompliable
     # Useful when your customization does not support all possible
     # configuration (e.g. the service you hit does not support sorting)
     class Null < Abstract
-      # (see Adapters::Abstract#filter)
-      def filter(scope, attribute, value)
+      def filter_string_eq(scope, attribute, value)
         scope
       end
 
+      def filter_string_eql(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_eql(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_prefix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_prefix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_suffix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_suffix_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_like_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_string_not_like_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_integer_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_float_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_decimal_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_datetime_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_not_eq(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_gt(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_gte(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_lt(scope, attribute, value)
+        scope
+      end
+
+      def filter_date_lte(scope, attribute, value)
+        scope
+      end
+
+      def filter_boolean_eq(scope, attribute, value)
+        scope
+      end
+
+      def base_scope(model)
+        raise 'Null adapter has no base scope!'
+      end
+
       # (see Adapters::Abstract#order)
       def order(scope, attribute, direction)
         scope
@@ -56,10 +231,6 @@ module JsonapiCompliable
       def resolve(scope)
         scope
       end
-
-      # (see Adapters::Abstract#associate)
-      def associate(parent, child, association_name, association_type)
-      end
     end
   end
 end

data/lib/jsonapi_compliable/base.rb

@@ -1,357 +1,70 @@
 module JsonapiCompliable
-  # Provides main interface to jsonapi_compliable
-  #
-  # This gets mixed in to a "context" class, such as a Rails controller.
   module Base
     extend ActiveSupport::Concern
 
-    included do
-      class << self
-        attr_accessor :_jsonapi_compliable, :_sideload_whitelist
-      end
-
-      def self.inherited(klass)
-        super
-        klass._jsonapi_compliable = Class.new(_jsonapi_compliable)
-        klass._sideload_whitelist = _sideload_whitelist.dup if _sideload_whitelist
-      end
-    end
-
-    # @!classmethods
-    module ClassMethods
-      # Define your JSONAPI configuration
-      #
-      # @example Inline Resource
-      #   # 'Quick and Dirty' solution that does not require a separate
-      #   # Resource object
-      #   class PostsController < ApplicationController
-      #     jsonapi do
-      #       type :posts
-      #       use_adapter JsonapiCompliable::Adapters::ActiveRecord
-      #
-      #       allow_filter :title
-      #     end
-      #   end
-      #
-      # @example Resource Class (preferred)
-      #   # Make code reusable by encapsulating it in a Resource class
-      #   class PostsController < ApplicationController
-      #     jsonapi resource: PostResource
-      #   end
-      #
-      # @see Resource
-      # @param resource [Resource] the Resource class associated to this endpoint
-      # @return [void]
-      def jsonapi(foo = 'bar', resource: nil, &blk)
-        if resource
-          self._jsonapi_compliable = resource
-        else
-          if !self._jsonapi_compliable
-            self._jsonapi_compliable = Class.new(JsonapiCompliable::Resource)
-          end
-        end
-
-        self._jsonapi_compliable.class_eval(&blk) if blk
-      end
-
-      # Set the sideload whitelist. You may want to omit sideloads for
-      # security or performance reasons.
-      #
-      # Uses JSONAPI::IncludeDirective from {{http://jsonapi-rb.org jsonapi-rb}}
-      #
-      # @example Whitelisting Relationships
-      #   # Given the following whitelist
-      #   class PostsController < ApplicationResource
-      #     jsonapi resource: MyResource
-      #
-      #     sideload_whitelist({
-      #       index: [:blog],
-      #       show: [:blog, { comments: :author }]
-      #     })
-      #
-      #     # ... code ...
-      #   end
-      #
-      #   # A request to sideload 'tags'
-      #   #
-      #   # GET /posts/1?include=tags
-      #   #
-      #   # ...will silently fail.
-      #   #
-      #   # A request for comments and tags:
-      #   #
-      #   # GET /posts/1?include=tags,comments
-      #   #
-      #   # ...will only sideload comments
-      #
-      # @param [Hash, Array, Symbol] whitelist
-      # @see Query#include_hash
-      def sideload_whitelist(hash)
-        self._sideload_whitelist = JSONAPI::IncludeDirective.new(hash).to_hash
-      end
-    end
-
-    # @api private
-    def sideload_whitelist
-      self.class._sideload_whitelist || {}
-    end
-
-    # Returns an instance of the associated Resource
-    #
-    # In other words, if you configured your controller as:
-    #
-    #   jsonapi resource: MyResource
-    #
-    # This returns MyResource.new
-    #
-    # @return [Resource] the configured Resource for this controller
     def jsonapi_resource
-      @jsonapi_resource ||= begin
-        resource = self.class._jsonapi_compliable
-        if resource.is_a?(Hash)
-          resource[action_name.to_sym].new
-        else
-          resource.new
-        end
-      end
+      @jsonapi_resource
     end
 
-    # Instantiates the relevant Query object
-    #
-    # @see Query
-    # @return [Query] the Query object for this resource/params
     def query
       @query ||= Query.new(jsonapi_resource, params)
     end
 
-    # @see Query#to_hash
-    # @return [Hash] the normalized query hash for only the *current* resource
     def query_hash
-      @query_hash ||= query.to_hash[jsonapi_resource.type]
+      @query_hash ||= query.to_hash
     end
 
-    # Tracks the current context so we can refer to it within any
-    # random object. Helpful for easy-access to things like the current
-    # user.
-    #
-    # @api private
-    # @yieldreturn Code to run within the current context
     def wrap_context
-      jsonapi_resource.with_context(jsonapi_context, action_name.to_sym) do
+      JsonapiCompliable.with_context(jsonapi_context, action_name.to_sym) do
         yield
       end
     end
 
-    # Override if you'd like the "context" to be something other than
-    # an instance of this class.
-    # In Rails, context is the controller instance.
-    #
-    # @example Overriding
-    #   # within your controller
-    #   def jsonapi_context
-    #     current_user
-    #   end
-    #
-    #   # within a resource
-    #   default_filter :by_user do |scope, context|
-    #     scope.where(user_id: context.id)
-    #   end
-    #
-    # @return the context object you'd like
     def jsonapi_context
       self
     end
 
-    # Use when direct, low-level access to the scope is required.
-    #
-    # @example Show Action
-    #   # Scope#resolve returns an array, but we only want to render
-    #   # one object, not an array
-    #   scope = jsonapi_scope(Employee.where(id: params[:id]))
-    #   render_jsonapi(scope.resolve.first, scope: false)
-    #
-    # @example Scope Chaining
-    #   # Chain onto scope after running through typical DSL
-    #   # Here, we'll add active: true to our hash if the user
-    #   # is filtering on something
-    #   scope = jsonapi_scope({})
-    #   scope.object.merge!(active: true) if scope.object[:filter]
-    #
-    # @see Resource#build_scope
-    # @return [Scope] the configured scope
     def jsonapi_scope(scope, opts = {})
       jsonapi_resource.build_scope(scope, query, opts)
     end
 
-    # @see Deserializer#initialize
-    # @return [Deserializer]
-    def deserialized_params
-      @deserialized_params ||= JsonapiCompliable::Deserializer.new(params, request.env)
-    end
-
-    # Create the resource model and process all nested relationships via the
-    # serialized parameters. Any error, including validation errors, will roll
-    # back the transaction.
-    #
-    # @example Basic Rails
-    #   # Example Resource must have 'model'
-    #   #
-    #   # class PostResource < ApplicationResource
-    #   #   model Post
-    #   # end
-    #   def create
-    #     post, success = jsonapi_create.to_a
-    #
-    #     if success
-    #       render_jsonapi(post, scope: false)
-    #     else
-    #       render_errors_for(post)
-    #     end
-    #   end
-    #
-    # @see Resource.model
-    # @see #resource
-    # @see #deserialized_params
-    # @return [Util::ValidationResponse]
-    def jsonapi_create
-      _persist do
-        jsonapi_resource.persist_with_relationships \
-          deserialized_params.meta,
-          deserialized_params.attributes,
-          deserialized_params.relationships
+    def normalized_params
+      normalized = params
+      if normalized.respond_to?(:to_unsafe_h)
+        normalized = normalized.to_unsafe_h.deep_symbolize_keys
       end
+      normalized
     end
 
-    # Update the resource model and process all nested relationships via the
-    # serialized parameters. Any error, including validation errors, will roll
-    # back the transaction.
-    #
-    # @example Basic Rails
-    #   # Example Resource must have 'model'
-    #   #
-    #   # class PostResource < ApplicationResource
-    #   #   model Post
-    #   # end
-    #   def update
-    #     post, success = jsonapi_update.to_a
-    #
-    #     if success
-    #       render_jsonapi(post, scope: false)
-    #     else
-    #       render_errors_for(post)
-    #     end
-    #   end
-    #
-    # @see #jsonapi_create
-    # @return [Util::ValidationResponse]
-    def jsonapi_update
-      _persist do
-        jsonapi_resource.persist_with_relationships \
-          deserialized_params.meta,
-          deserialized_params.attributes,
-          deserialized_params.relationships
-      end
-    end
-
-    # Delete the model
-    # Any error, including validation errors, will roll back the transaction.
-    #
-    # Note: +before_commit+ hooks still run unless excluded
-    #
-    # @return [Util::ValidationResponse]
-    def jsonapi_destroy
-      jsonapi_resource.transaction do
-        model = jsonapi_resource.destroy(params[:id])
-        validator = ::JsonapiCompliable::Util::ValidationResponse.new \
-          model, deserialized_params
-        validator.validate!
-        jsonapi_resource.before_commit(model, :destroy)
-        validator
-      end
-    end
-
-    # Similar to +render :json+ or +render :jsonapi+
-    #
-    # By default, this will "build" the scope via +#jsonapi_scope+. To avoid
-    # this, pass +scope: false+
-    #
-    # This builds relevant options and sends them to
-    # +JSONAPI::Serializable::SuccessRenderer#render+from
-    # {http://jsonapi-rb.org jsonapi-rb}
-    #
-    # @example Build Scope by Default
-    #   # Employee.all returns an ActiveRecord::Relation. No SQL is fired at this point.
-    #   # We further 'chain' onto this scope, applying pagination, sorting,
-    #   # filters, etc that the user has requested.
-    #   def index
-    #     employees = Employee.all
-    #     render_jsonapi(employees)
-    #   end
-    #
-    # @example Avoid Building Scope by Default
-    #   # Maybe we already manually scoped, and don't want to fire the logic twice
-    #   # This code is equivalent to the above example
-    #   def index
-    #     scope = jsonapi_scope(Employee.all)
-    #     # ... do other things with the scope ...
-    #     render_jsonapi(scope.resolve, scope: false)
-    #   end
-    #
-    # @param scope [Scope, Object] the scope to build or render.
-    # @param [Hash] opts the render options passed to {http://jsonapi-rb.org jsonapi-rb}
-    # @option opts [Boolean] :scope Default: true. Should we call #jsonapi_scope on this object?
-    # @see #jsonapi_scope
-    def render_jsonapi(scope, opts = {})
-      scope = jsonapi_scope(scope) unless opts[:scope] == false || scope.is_a?(JsonapiCompliable::Scope)
-      opts  = default_jsonapi_render_options.merge(opts)
-      opts  = Util::RenderOptions.generate(scope, query_hash, opts)
-      opts[:expose][:context] = self
-
-      if opts[:include].empty? && force_includes?
-        opts[:include] = deserialized_params.include_directive
-      end
-
-      perform_render_jsonapi(opts)
-    end
-
-    # Define a hash that will be automatically merged into your
-    # render_jsonapi call
-    #
-    # @example
-    #   # this
-    #   render_jsonapi(foo)
-    #   # is equivalent to this
-    #   render jsonapi: foo, default_jsonapi_render_options
-    #
-    # @see #render_jsonapi
-    # @return [Hash] the options hash you define
-    def default_jsonapi_render_options
-      {}.tap do |options|
-      end
-    end
-
-    private
-
-    def _persist
-      jsonapi_resource.transaction do
-        ::JsonapiCompliable::Util::Hooks.record do
-          model = yield
-          validator = ::JsonapiCompliable::Util::ValidationResponse.new \
-            model, deserialized_params
-          validator.validate!
-          validator
+    def deserialized_params
+      @deserialized_params ||= begin
+        payload = normalized_params
+        if payload[:data] && payload[:data][:type]
+          JsonapiCompliable::Deserializer.new(payload)
         end
       end
     end
 
-    def force_includes?
-      not (deserialized_params.data.nil? || deserialized_params.data.empty?)
-    end
-
-    def perform_render_jsonapi(opts)
-      # TODO(beauby): Reuse renderer.
-      JSONAPI::Serializable::Renderer.new
-        .render(opts.delete(:jsonapi), opts).to_json
+    def jsonapi_render_options
+      options = {}
+      options.merge!(default_jsonapi_render_options)
+      options[:meta]   ||= {}
+      options[:expose] ||= {}
+      options[:expose][:context] = jsonapi_context
+      options
+    end
+
+    def proxy(base = nil, opts = {})
+      base ||= jsonapi_resource.base_scope
+      scope_opts = opts.slice :sideload_parent_length,
+        :default_paginate, :after_resolve
+      scope = jsonapi_scope(base, scope_opts)
+      ResourceProxy.new jsonapi_resource,
+        scope,
+        query,
+        payload: deserialized_params,
+        single: opts[:single],
+        raise_on_missing: opts[:raise_on_missing]
     end
   end
 end