jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/jsonapi_compliable/filter_operators.rb

@@ -0,0 +1,25 @@
+module JsonapiCompliable
+  class FilterOperators
+    class Catchall
+      attr_reader :procs
+
+      def initialize
+        @procs = {}
+      end
+
+      def method_missing(name, *args, &blk)
+        @procs[name] = blk
+      end
+
+      def to_hash
+        @procs
+      end
+    end
+
+    def self.build(&blk)
+      c = Catchall.new
+      c.instance_eval(&blk) if blk
+      c.to_hash
+    end
+  end
+end

data/lib/jsonapi_compliable/hash_renderer.rb

@@ -0,0 +1,57 @@
+module JsonapiCompliable
+  module SerializableHash
+    def to_hash(fields: nil, include: {})
+      {}.tap do |hash|
+        _fields = fields[jsonapi_type] if fields
+        attrs = requested_attributes(_fields).each_with_object({}) do |(k, v), h|
+          h[k] = instance_eval(&v)
+        end
+        rels = @_relationships.select { |k,v| !!include[k] }
+        rels.each_with_object({}) do |(k, v), h|
+          serializers = v.send(:resources)
+          attrs[k] = if serializers.is_a?(Array)
+              serializers.map do |rr| # use private method to avoid array casting
+                rr.to_hash(fields: fields, include: include[k])
+              end
+            elsif serializers.nil?
+              nil
+            else
+              serializers.to_hash(fields: fields, include: include[k])
+            end
+        end
+
+        hash[:id] = jsonapi_id
+        hash.merge!(attrs) if attrs.any?
+      end
+    end
+  end
+  JSONAPI::Serializable::Resource.send(:include, SerializableHash)
+
+  class HashRenderer
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def render(options)
+      serializers = options[:data]
+      opts = options.slice(:fields, :include)
+      to_hash(serializers, opts).tap do |hash|
+        hash.merge!(options.slice(:meta)) if !options[:meta].empty?
+      end
+    end
+
+    private
+
+    def to_hash(serializers, opts)
+      {}.tap do |hash|
+        if serializers.is_a?(Array)
+          hash[@resource.type] = serializers.map do |s|
+            s.to_hash(opts)
+          end
+        else
+          hash[@resource.type] = serializers.to_hash(opts)
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_compliable/query.rb

@@ -1,263 +1,251 @@
 module JsonapiCompliable
-   # @attr_reader [Hash] params hash of query parameters with symbolized keys
-   # @attr_reader [Resource] resource the corresponding Resource object
   class Query
-    # TODO: This class could use some refactoring love!
-    attr_reader :params, :resource
-
-    # This is the structure of +Query#to_hash+ used elsewhere in the library
-    # @see #to_hash
-    # @api private
-    # @return [Hash] the default hash
-    def self.default_hash
-      {
-        filter: {},
-        sort: [],
-        page: {},
-        include: {},
-        stats: {},
-        fields: {},
-        extra_fields: {}
-      }
-    end
+    attr_reader :resource, :include_hash, :association_name
 
-    def initialize(resource, params)
+    def initialize(resource, params, association_name = nil, nested_include = nil, parents = [])
       @resource = resource
+      @association_name = association_name
       @params = params
       @params = @params.permit! if @params.respond_to?(:permit!)
+      @params = @params.to_h if @params.respond_to?(:to_h)
+      @params = @params.deep_symbolize_keys
+      @include_param = nested_include || @params[:include]
+      @parents = parents
     end
 
-    # The relevant include directive
-    # @see http://jsonapi-rb.org
-    # @return [JSONAPI::IncludeDirective]
-    def include_directive
-      @include_directive ||= JSONAPI::IncludeDirective.new(params[:include])
-    end
-
-    # The include, directive, as a hash. For instance
-    #
-    # { posts: { comments: {} } }
-    #
-    # This will only include relationships that are
-    #
-    # * Available on the Resource
-    # * Whitelisted (when specified)
-    #
-    # So that users can't simply request your entire object graph.
-    #
-    # @see Util::IncludeParams
-    # @return [Hash] the scrubbed include directive as a hash
-    def include_hash
-      @include_hash ||= begin
-        requested = include_directive.to_hash
-
-        whitelist = nil
-        if resource.context
-          whitelist = resource.context.sideload_whitelist
-          whitelist = whitelist[resource.context_namespace] if whitelist
-        end
-
-        whitelist ? Util::IncludeParams.scrub(requested, whitelist) : requested
-      end
+    def association?
+      !!@association_name
     end
 
-    # All the keys of the #include_hash
-    #
-    # For example, let's say we had
-    #
-    #   { posts: { comments: {} }
-    #
-    # +#association_names+ would return
-    #
-    #   [:posts, :comments]
-    #
-    # @return [Array<Symbol>] all association names, recursive
-    def association_names
-      @association_names ||= Util::Hash.keys(include_hash)
+    def top_level?
+      not association?
     end
 
-    # A flat hash of sanitized query parameters.
-    # All relationship names are top-level:
-    #
-    #   {
-    #     posts: { filter, sort, ... }
-    #     comments: { filter, sort, ... }
-    #   }
-    #
-    # @example sorting
-    #   # GET /posts?sort=-title
-    #   { posts: { sort: { title: :desc } } }
-    #
-    # @example pagination
-    #   # GET /posts?page[number]=2&page[size]=10
-    #   { posts: { page: { number: 2, size: 10 } }
-    #
-    # @example filtering
-    #   # GET /posts?filter[title]=Foo
-    #   { posts: { filter: { title: 'Foo' } }
-    #
-    # @example include
-    #   # GET /posts?include=comments.author
-    #   { posts: { include: { comments: { author: {} } } } }
-    #
-    # @example stats
-    #   # GET /posts?stats[likes]=count,average
-    #   { posts: { stats: [:count, :average] } }
-    #
-    # @example fields
-    #   # GET /posts?fields=foo,bar
-    #   { posts: { fields: [:foo, :bar] } }
-    #
-    # @example extra fields
-    #   # GET /posts?fields=foo,bar
-    #   { posts: { extra_fields: [:foo, :bar] } }
-    #
-    # @example nested parameters
-    #   # GET /posts?include=comments&sort=comments.created_at&page[comments][size]=3
-    #   {
-    #     posts: { ... },
-    #     comments: { page: { size: 3 }, sort: { created_at: :asc } }
-    #
-    # @see #default_hash
-    # @see Base#query_hash
-    # @return [Hash] the normalized query hash
     def to_hash
-      hash = { resource.type => self.class.default_hash }
-
-      association_names.each do |name|
-        hash[name] = self.class.default_hash
-      end
-
-      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
+      {}.tap do |hash|
+        hash[:filter] = filters unless filters.empty?
+        hash[:sort] = sorts unless sorts.empty?
+        hash[:page] = pagination unless pagination.empty?
+        unless association?
+          hash[:fields] = fields unless fields.empty?
+          hash[:extra_fields] = extra_fields unless extra_fields.empty?
+        end
+        hash[:stats] = stats unless stats.empty?
+        hash[:include] = sideload_hash unless sideload_hash.empty?
       end
-
-      parse_filter(hash)
-      parse_sort(hash)
-      parse_pagination(hash)
-
-      parse_include(hash, include_hash, resource.type)
-      parse_stats(hash)
-
-      hash
     end
 
-    # Check if the user has requested 0 actual results
-    # They may have done this to get, say, the total count
-    # without the overhead of fetching actual records.
-    #
-    # @example Total Count, 0 Results
-    #   # GET /posts?page[size]=0&stats[total]=count
-    #   # Response:
-    #   {
-    #     data: [],
-    #     meta: {
-    #       stats: { total: { count: 100 } }
-    #     }
-    #   }
-    #
-    # @return [Boolean] were 0 results requested?
     def zero_results?
       !@params[:page].nil? &&
         !@params[:page][:size].nil? &&
         @params[:page][:size].to_i == 0
     end
 
-    private
+    def sideload_hash
+      @sideload_hash = begin
+        {}.tap do |hash|
+          sideloads.each_pair do |key, value|
+            hash[key] = sideloads[key].to_hash
+          end
+        end
+      end
+    end
 
-    def association?(name)
-      resource.association_names.include?(name)
+    def sideloads
+      @sideloads ||= begin
+        {}.tap do |hash|
+          include_hash.each_pair do |key, sub_hash|
+            sideload = @resource.class.sideload(key)
+            if sideload
+              _parents = parents + [self]
+              hash[key] = Query.new(sideload.resource, @params, key, sub_hash, _parents)
+            else
+              handle_missing_sideload(key)
+            end
+          end
+        end
+      end
     end
 
-    def parse_include(memo, incl_hash, namespace)
-      memo[namespace] ||= self.class.default_hash
-      memo[namespace].merge!(include: incl_hash)
+    def parents
+      @parents ||= []
+    end
 
-      incl_hash.each_pair do |key, sub_hash|
-        key = Util::Sideload.namespace(namespace, key)
-        memo.merge!(parse_include(memo, sub_hash, key))
+    def fields
+      @fields ||= begin
+        hash = parse_fieldset(@params[:fields] || {})
+        hash.each_pair do |type, fields|
+          hash[type] += extra_fields[type] if extra_fields[type]
+        end
+        hash
       end
+    end
 
-      memo
+    def extra_fields
+      @extra_fields ||= parse_fieldset(@params[:extra_fields] || {})
     end
 
-    def parse_stats(hash)
-      if params[:stats]
-        params[:stats].each_pair do |namespace, calculations|
-          if namespace == resource.type || association?(namespace)
-            calculations.each_pair do |name, calcs|
-              hash[namespace][:stats][name] = calcs.split(',').map(&:to_sym)
+    def filters
+      @filters ||= begin
+        {}.tap do |hash|
+          (@params[:filter] || {}).each_pair do |name, value|
+            name = name.to_sym
+
+            if legacy_nested?(name)
+              filter_name = value.keys.first.to_sym
+              filter_value = value.values.first
+              if @resource.get_attr!(filter_name, :filterable, request: true)
+                hash[filter_name] = filter_value
+              end
+            elsif nested?(name)
+              name = name.to_s.split('.').last.to_sym
+              validate!(name, :filterable)
+              hash[name] = value
+            elsif top_level? && validate!(name, :filterable)
+              hash[name] = value
             end
-          else
-            hash[resource.type][:stats][namespace] = calculations.split(',').map(&:to_sym)
           end
         end
       end
     end
 
-    def parse_fields(hash, type)
-      field_params = Util::FieldParams.parse(params[type])
-      hash[type] = field_params
+    def sorts
+      @sorts ||= begin
+        return @params[:sort] if @params[:sort].is_a?(Array)
+        return [] if @params[:sort].nil?
+
+        [].tap do |arr|
+          sort_hashes do |key, value, type|
+            if legacy_nested?(type)
+              @resource.get_attr!(key, :sortable, request: true)
+              arr << { key => value }
+            elsif !type && top_level? && validate!(key, :sortable)
+              arr << { key => value }
+            end
+          end
+        end
+      end
     end
 
-    def parse_filter(hash)
-      if filter = params[:filter]
-        filter.each_pair do |key, value|
-          key = key.to_sym
-
-          if association?(key)
-            symbolized_hash = value.to_h.each_with_object({}) do |(k, v), hash|
-              hash[k.to_sym] = v
+    def pagination
+      @pagination ||= begin
+        {}.tap do |hash|
+          (@params[:page] || {}).each_pair do |name, value|
+            if legacy_nested?(name)
+              value.each_pair do |k,v|
+                hash[k.to_sym] = v.to_i
+              end
+            elsif top_level? && [:number, :size].include?(name.to_sym)
+              hash[name.to_sym] = value.to_i
             end
-            hash[key][:filter].merge!(symbolized_hash)
-          else
-            hash[resource.type][:filter][key] = value
           end
         end
       end
     end
 
-    def parse_sort(hash)
-      if sort = params[:sort]
-        sorts = sort.split(',')
-        sorts.each do |s|
-          if s.include?('.')
-            type, attr = s.split('.')
-            if type.starts_with?('-')
-              type = type.sub('-', '')
-              attr = "-#{attr}"
-            end
+    def include_hash
+      @include_hash ||= begin
+        requested = include_directive.to_hash
+
+        whitelist = nil
+        if @resource.context && @resource.context.respond_to?(:sideload_whitelist)
+          whitelist = @resource.context.sideload_whitelist
+          whitelist = whitelist[@resource.context_namespace] if whitelist
+        end
+
+        whitelist ? Util::IncludeParams.scrub(requested, whitelist) : requested
+      end
+    end
 
-            hash[type.to_sym][:sort] << sort_attr(attr)
-          else
-            hash[resource.type][:sort] << sort_attr(s)
+    def stats
+      @stats ||= begin
+        {}.tap do |hash|
+          (@params[:stats] || {}).each_pair do |k, v|
+            if legacy_nested?(k)
+              raise NotImplementedError.new('Association statistics are not currently supported')
+            elsif top_level?
+              v = v.split(',') if v.is_a?(String)
+              hash[k.to_sym] = Array(v).flatten.map(&:to_sym)
+            end
           end
         end
       end
     end
 
-    def parse_pagination(hash)
-      if pagination = params[:page]
-        pagination.each_pair do |key, value|
-          key = key.to_sym
+    private
 
-          if [:number, :size].include?(key)
-            hash[resource.type][:page][key] = value.to_i
-          else
-            hash[key][:page] = { number: value[:number].to_i, size: value[:size].to_i }
-          end
+    def validate!(name, flag)
+      return false if name.to_s.include?('.') # nested
+
+      not_associated_name = !@resource.class.association_names.include?(name)
+      not_associated_type = !@resource.class.association_types.include?(name)
+
+      if not_associated_name && not_associated_type
+        @resource.get_attr!(name, flag, request: true)
+        return true
+      end
+      false
+    end
+
+    def nested?(name)
+      return false unless association?
+      split = name.to_s.split('.')
+      query_names = split[0..split.length-2].map(&:to_sym)
+      my_names = parents.map(&:association_name).compact + [association_name].compact
+      query_names == my_names
+    end
+
+    def legacy_nested?(name)
+      association? &&
+        (name == @resource.type || name == @association_name)
+    end
+
+    def parse_fieldset(fieldset)
+      {}.tap do |hash|
+        fieldset.each_pair do |type, fields|
+          type       = type.to_sym
+          fields     = fields.split(',') unless fields.is_a?(Array)
+          hash[type] = fields.map(&:to_sym)
         end
       end
     end
 
-    def sort_attr(attr)
-      value = attr.starts_with?('-') ? :desc : :asc
+    def include_directive
+      @include_directive ||= JSONAPI::IncludeDirective.new(@include_param)
+    end
+
+    def handle_missing_sideload(name)
+      if JsonapiCompliable.config.raise_on_missing_sideload
+        raise JsonapiCompliable::Errors::InvalidInclude
+          .new(name, @resource.type)
+      end
+    end
+
+    def sort_hash(attr)
+      value = attr[0] == '-' ? :desc : :asc
       key   = attr.sub('-', '').to_sym
 
       { key => value }
     end
+
+    def sort_hashes
+      sorts = @params[:sort].split(',')
+      sorts.each do |s|
+        type, attr = s.split('.')
+
+        if attr.nil? # top-level
+          next if @association_name
+          hash = sort_hash(type)
+          yield hash.keys.first.to_sym, hash.values.first
+        else
+          if type[0] == '-'
+            type = type.sub('-', '')
+            attr = "-#{attr}"
+          end
+          hash = sort_hash(attr)
+          yield hash.keys.first.to_sym, hash.values.first, type.to_sym
+        end
+      end
+    end
   end
 end