graphiti-rb 1.0.alpha.1

data/lib/graphiti/extensions/boolean_attribute.rb

@@ -0,0 +1,33 @@
+module Graphiti
+  module Extensions
+    # Turns ruby ? methods into is_ attributes
+    #
+    # @example Basic Usage
+    #   boolean_attribute :active?
+    #
+    #   # equivalent do
+    #   def is_active
+    #     @object.active?
+    #   end
+    module BooleanAttribute
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        # Register a boolean attribute
+        # @param name the corresponding ? method
+        # @param [Hash] options Normal .attribute options
+        def boolean_attribute(name, options = {}, &blk)
+          blk ||= proc { @object.public_send(name) }
+          field_name = :"is_#{name.to_s.gsub('?', '')}"
+          attribute field_name, options, &blk
+        end
+      end
+    end
+  end
+end
+
+JSONAPI::Serializable::Resource.class_eval do
+  include Graphiti::Extensions::BooleanAttribute
+end

data/lib/graphiti/extensions/extra_attribute.rb

@@ -0,0 +1,70 @@
+require 'jsonapi/serializable/resource/conditional_fields'
+
+module Graphiti
+  module Extensions
+    # Only render a given attribute when the user specifically requests it.
+    # Useful for computationally-expensive attributes that are not required
+    # on every request.
+    #
+    # This class handles the serialization, but you may also want to run
+    # code during scoping (for instance, to eager load associations referenced
+    # by this extra attribute. See (Resource.extra_field).
+    #
+    # @example Basic Usage
+    #   # Will only be rendered on user request, ie
+    #   # /people?extra_fields[people]=net_worth
+    #   extra_attribute :net_worth
+    #
+    # @example Eager Loading
+    #   class PersonResource < ApplicationResource
+    #     # If the user requests the 'net_worth' attribute, make sure
+    #     # 'assets' are eager loaded
+    #     extra_field :net_worth do |scope|
+    #       scope.includes(:assets)
+    #     end
+    #   end
+    #
+    #   class SerializablePerson < JSONAPI::Serializable::Resource
+    #     # ... code ...
+    #     extra_attribute :net_worth do
+    #       @object.assets.sum(&:value)
+    #     end
+    #   end
+    #
+    # @see Resource.extra_field
+    module ExtraAttribute
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        # @param [Symbol] name the name of the attribute
+        # @param [Hash] options the options passed on to vanilla to .attribute
+        def extra_attribute(name, options = {}, &blk)
+          allow_field = proc {
+            if options[:if]
+              next false unless instance_eval(&options[:if])
+            end
+
+            @extra_fields &&
+              @extra_fields[@_type] &&
+              @extra_fields[@_type].include?(name)
+          }
+
+          attribute name, if: allow_field, &blk
+        end
+      end
+    end
+  end
+end
+
+JSONAPI::Serializable::Resource.class_eval do
+  def self.inherited(klass)
+    super
+    klass.class_eval do
+      extend JSONAPI::Serializable::Resource::ConditionalFields
+    end
+  end
+
+  include Graphiti::Extensions::ExtraAttribute
+end

data/lib/graphiti/extensions/temp_id.rb

@@ -0,0 +1,26 @@
+module Graphiti
+  # If the object we are serializing has the instance variable
+  # +@_jsonapi_temp_id+, render +temp-id+ in the {http://jsonapi.org/format/#document-resource-identifier-objects resource identifier}
+  #
+  # Why? Well, when the request is a nested POST, creating the main entity as
+  # well as relationships, we need some way of telling the client, "hey, the
+  # object you have in memory, that you just sent to the server, has been
+  # persisted and now has id X".
+  #
+  # +@_jsonapi_temp_id+ is set within this library. You should never have to
+  # reference it directly.
+  module SerializableTempId
+    # Common interface for jsonapi-rb extensions
+    def as_jsonapi(*)
+      super.tap do |hash|
+        if temp_id = @object.instance_variable_get(:'@_jsonapi_temp_id')
+          hash[:'temp-id'] = temp_id
+        end
+      end
+    end
+  end
+end
+
+JSONAPI::Serializable::Resource.class_eval do
+  prepend Graphiti::SerializableTempId
+end

data/lib/graphiti/filter_operators.rb

@@ -0,0 +1,25 @@
+module Graphiti
+  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/graphiti/hash_renderer.rb

@@ -0,0 +1,57 @@
+module Graphiti
+  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/graphiti/jsonapi_serializable_ext.rb

@@ -0,0 +1,50 @@
+module Graphiti
+  module JsonapiSerializableExt
+    # This library looks up a serializer based on the record's class name
+    # This wouldn't work for us, since a model may be associated with
+    # multiple resources.
+    # Instead, this variable is assigned when the query is resolved
+    # To ensure we always render with the *resource* serializer
+    module RendererOverrides
+      def _build(object, exposures, klass)
+        klass = object.instance_variable_get(:@__serializer_klass)
+        klass.new(exposures.merge(object: object))
+      end
+    end
+
+    # See above comment
+    module RelationshipOverrides
+      def data
+        @_resources_block = proc do
+          resources = yield
+          if resources.nil?
+            nil
+          elsif resources.respond_to?(:to_ary)
+            Array(resources).map do |obj|
+              klass = obj.instance_variable_get(:@__serializer_klass)
+              klass.new(@_exposures.merge(object: obj))
+            end
+          else
+            klass = resources.instance_variable_get(:@__serializer_klass)
+            klass.new(@_exposures.merge(object: resources))
+          end
+        end
+      end
+    end
+
+    # Temporary fix until fixed upstream
+    # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
+    module ResourceOverrides
+      def requested_relationships(fields)
+        @_relationships
+      end
+    end
+
+    JSONAPI::Serializable::Resource
+      .send(:prepend, ResourceOverrides)
+    JSONAPI::Serializable::Relationship
+      .send(:prepend, RelationshipOverrides)
+    JSONAPI::Serializable::Renderer
+      .send(:prepend, RendererOverrides)
+  end
+end

data/lib/graphiti/query.rb

@@ -0,0 +1,251 @@
+module Graphiti
+  class Query
+    attr_reader :resource, :include_hash, :association_name
+
+    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
+
+    def association?
+      !!@association_name
+    end
+
+    def top_level?
+      not association?
+    end
+
+    def to_hash
+      {}.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
+    end
+
+    def zero_results?
+      !@params[:page].nil? &&
+        !@params[:page][:size].nil? &&
+        @params[:page][:size].to_i == 0
+    end
+
+    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 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 parents
+      @parents ||= []
+    end
+
+    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
+
+    def extra_fields
+      @extra_fields ||= parse_fieldset(@params[:extra_fields] || {})
+    end
+
+    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
+          end
+        end
+      end
+    end
+
+    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 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
+          end
+        end
+      end
+    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
+
+    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
+
+    private
+
+    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 include_directive
+      @include_directive ||= JSONAPI::IncludeDirective.new(@include_param)
+    end
+
+    def handle_missing_sideload(name)
+      if Graphiti.config.raise_on_missing_sideload
+        raise Graphiti::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