graphiti-rb 1.0.alpha.1

data/lib/graphiti/base.rb

@@ -0,0 +1,70 @@
+module Graphiti
+  module Base
+    extend ActiveSupport::Concern
+
+    def jsonapi_resource
+      @jsonapi_resource
+    end
+
+    def query
+      @query ||= Query.new(jsonapi_resource, params)
+    end
+
+    def query_hash
+      @query_hash ||= query.to_hash
+    end
+
+    def wrap_context
+      Graphiti.with_context(jsonapi_context, action_name.to_sym) do
+        yield
+      end
+    end
+
+    def jsonapi_context
+      self
+    end
+
+    def jsonapi_scope(scope, opts = {})
+      jsonapi_resource.build_scope(scope, query, opts)
+    end
+
+    def normalized_params
+      normalized = params
+      if normalized.respond_to?(:to_unsafe_h)
+        normalized = normalized.to_unsafe_h.deep_symbolize_keys
+      end
+      normalized
+    end
+
+    def deserialized_params
+      @deserialized_params ||= begin
+        payload = normalized_params
+        if payload[:data] && payload[:data][:type]
+          Graphiti::Deserializer.new(payload)
+        end
+      end
+    end
+
+    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

data/lib/graphiti/configuration.rb

@@ -0,0 +1,21 @@
+# https://robots.thoughtbot.com/mygem-configure-block
+module Graphiti
+  class Configuration
+    # @return [Boolean] Should we raise when the client requests a relationship not defined on the server?
+    #   Defaults to true.
+    attr_accessor :raise_on_missing_sideload
+    # @return [Boolean] Concurrently fetch sideloads?
+    #   Defaults to false OR if classes are cached (Rails-only)
+    attr_accessor :concurrency
+
+    attr_accessor :respond_to
+
+    # Set defaults
+    # @api private
+    def initialize
+      @raise_on_missing_sideload = true
+      @concurrency = false
+      @respond_to = [:json, :jsonapi, :xml]
+    end
+  end
+end

data/lib/graphiti/context.rb

@@ -0,0 +1,16 @@
+module Graphiti
+  module Context
+    extend ActiveSupport::Concern
+
+    module Overrides
+      def sideload_whitelist=(val)
+        super(JSONAPI::IncludeDirective.new(val).to_hash)
+      end
+    end
+
+    included do
+      class_attribute :sideload_whitelist
+      class << self;prepend Overrides;end
+    end
+  end
+end

data/lib/graphiti/deserializer.rb

@@ -0,0 +1,208 @@
+# Responsible for parsing incoming write payloads
+#
+# Given a PUT payload like:
+#
+#   {
+#     data: {
+#       id: '1',
+#       type: 'posts',
+#       attributes: { title: 'My Title' },
+#       relationships: {
+#         author: {
+#           data: {
+#             id: '1',
+#             type: 'authors'
+#           }
+#         }
+#       }
+#     },
+#     included: [
+#       {
+#         id: '1'
+#         type: 'authors',
+#         attributes: { name: 'Joe Author' }
+#       }
+#     ]
+#   }
+#
+# You can now easily deal with this payload:
+#
+#   deserializer.attributes
+#   # => { id: '1', title: 'My Title' }
+#   deserializer.meta
+#   # => { type: 'posts', method: :update }
+#   deserializer.relationships
+#   # {
+#   #   author: {
+#   #     meta: { ... },
+#   #     attributes: { ... },
+#   #     relationships: { ... }
+#   #   }
+#   # }
+#
+# When creating objects, we accept a +temp-id+ so that the client can track
+# the object it just created. Expect this in +meta+:
+#
+#   { type: 'authors', method: :create, temp_id: 'abc123' }
+class Graphiti::Deserializer
+  def initialize(payload)
+    @payload = payload
+    @payload = @payload[:_jsonapi] if @payload.has_key?(:_jsonapi)
+  end
+
+  def params
+    @payload
+  end
+
+  # @return [Hash] the raw :data value of the payload
+  def data
+    @payload[:data]
+  end
+
+  # @return [String] the raw :id value of the payload
+  def id
+    data[:id]
+  end
+
+  # @return [Hash] the raw :attributes hash + +id+
+  def attributes
+    @attributes ||= raw_attributes.tap do |hash|
+      hash[:id] = id if id
+    end
+  end
+
+  # Override the attributes
+  # # @see #attributes
+  def attributes=(attrs)
+    @attributes = attrs
+  end
+
+  # 'meta' information about this resource. Includes:
+  #
+  # +type+: the jsonapi type
+  # +method+: create/update/destroy/disassociate. Based on the request env or the +method+ within the +relationships+ hash
+  # +temp_id+: the +temp-id+, if specified
+  #
+  # @return [Hash]
+  def meta(action: :update)
+    {
+      type: data[:type],
+      temp_id: data[:'temp-id'],
+      method: action
+    }
+  end
+
+  # @return [Hash] the relationships hash
+  def relationships
+    @relationships ||= process_relationships(raw_relationships)
+  end
+
+  def include_hash(memo = {}, relationship_node = nil)
+    relationship_node ||= relationships
+
+    relationship_node.each_pair do |name, relationship_payload|
+      merge_include_hash(memo, name, relationship_payload)
+    end
+
+    memo
+  end
+
+  private
+
+  def merge_include_hash(memo, name, relationship_payload)
+    arrayified = [relationship_payload].flatten
+    return if arrayified.all? { |rp| removed?(rp) }
+
+    memo[name] ||= {}
+    deep_merge!(memo[name], nested_include_hashes(memo[name], arrayified))
+    memo
+  end
+
+  def included
+    @payload[:included] || []
+  end
+
+  def removed?(relationship_payload)
+    method = relationship_payload[:meta][:method]
+    [:disassociate, :destroy].include?(method)
+  end
+
+  def nested_include_hashes(memo, relationship_payloads)
+    {}.tap do |subs|
+      relationship_payloads.each do |rp|
+        nested = include_hash(memo, rp[:relationships])
+        deep_merge!(subs, nested)
+      end
+    end
+  end
+
+  def deep_merge!(a, b)
+    Graphiti::Util::Hash.deep_merge!(a, b)
+  end
+
+  def process_relationships(relationship_hash)
+    {}.tap do |hash|
+      relationship_hash.each_pair do |name, relationship_payload|
+        name = name.to_sym
+
+        if relationship_payload[:data]
+          hash[name] = process_relationship(relationship_payload[:data])
+        end
+      end
+    end
+  end
+
+  def process_relationship(relationship_data)
+    if relationship_data.is_a?(Array)
+      relationship_data.map do |rd|
+        process_relationship_datum(rd)
+      end
+    else
+      process_relationship_datum(relationship_data)
+    end
+  end
+
+  def process_relationship_datum(datum)
+    temp_id = datum[:'temp-id']
+    included_object = included.find do |i|
+      next unless i[:type] == datum[:type]
+
+      (i[:id] && i[:id] == datum[:id]) ||
+        (i[:'temp-id'] && i[:'temp-id'] == temp_id)
+    end
+    included_object ||= {}
+    included_object[:relationships] ||= {}
+
+    attributes = included_object[:attributes] || {}
+    attributes[:id] = datum[:id] if datum[:id]
+    relationships = process_relationships(included_object[:relationships] || {})
+    method = datum[:method]
+    method = method.to_sym if method
+
+    {
+      meta: {
+        jsonapi_type: datum[:type],
+        temp_id: temp_id,
+        method: method
+      },
+      attributes: attributes,
+      relationships: relationships
+    }
+  end
+
+  def raw_attributes
+    if data
+      data[:attributes] || {}
+    else
+      {}
+    end
+  end
+
+  def raw_relationships
+    if data
+      data[:relationships] || {}
+    else
+      {}
+    end
+  end
+end

data/lib/graphiti/errors.rb

@@ -0,0 +1,309 @@
+module Graphiti
+  module Errors
+    class Base < StandardError;end
+
+    class AdapterNotImplemented < Base
+      def initialize(adapter, attribute, method)
+        @adapter = adapter
+        @attribute = attribute
+        @method = method
+      end
+
+      def message
+        <<-MSG
+The adapter #{@adapter.class} does not implement method '#{@method}', which was requested for attribute '#{@attribute}'. Add this method to your adapter to support this filter operator.
+        MSG
+      end
+    end
+
+    class AttributeError < Base
+      attr_reader :resource,
+        :name,
+        :flag,
+        :exists,
+        :request,
+        :guard
+
+      def initialize(resource, name, flag, **opts)
+        @resource = resource
+        @name = name
+        @flag = flag
+        @exists = opts[:exists] || false
+        @request = opts[:request] || false
+        @guard = opts[:guard]
+      end
+
+      def action
+        if @request
+          {
+            sortable: 'sort on',
+            filterable: 'filter on',
+            readable: 'read',
+            writable: 'write'
+          }[@flag]
+        else
+          {
+            sortable: 'add sort',
+            filterable: 'add filter',
+            readable: 'read',
+            writable: 'write'
+          }[@flag]
+        end
+      end
+
+      def resource_name
+        name = if @resource.is_a?(Graphiti::Resource)
+          @resource.class.name
+        else
+          @resource.name
+        end
+        name || 'AnonymousResourceClass'
+      end
+
+      def message
+        msg = "#{resource_name}: Tried to #{action} attribute #{@name.inspect}"
+        if @exists
+          if @guard
+            msg << ", but the guard #{@guard.inspect} did not pass."
+          else
+            msg << ", but the attribute was marked #{@flag.inspect} => false."
+          end
+        else
+          msg << ", but could not find an attribute with that name."
+        end
+        msg
+      end
+    end
+
+    class PolymorphicChildNotFound < Base
+      def initialize(resource_class, model)
+        @resource_class = resource_class
+        @model = model
+      end
+
+      def message
+        <<-MSG
+#{@resource_class}: Tried to find subclass with model #{@model.class}, but nothing found!
+
+Make sure all your child classes are assigned and associated to the right models:
+
+self.polymorphic = ['Subclass1Resource', 'Subclass2Resource']
+        MSG
+      end
+    end
+
+    class ValidationError < Base
+      attr_reader :validation_response
+
+      def initialize(validation_response)
+        @validation_response = validation_response
+      end
+    end
+
+    class ImplicitFilterTypeMissing < Base
+      def initialize(resource_class, name)
+        @resource_class = resource_class
+        @name = name
+      end
+
+      def message
+        <<-MSG
+Tried to add filter-only attribute #{@name.inspect}, but type was missing!
+
+If you are adding a filter that does not have a corresponding attribute, you must pass a type:
+
+filter :name, :string do <--- like this
+  # ... code ...
+end
+        MSG
+      end
+    end
+
+    class ImplicitSortTypeMissing < Base
+      def initialize(resource_class, name)
+        @resource_class = resource_class
+        @name = name
+      end
+
+      def message
+        <<-MSG
+Tried to add sort-only attribute #{@name.inspect}, but type was missing!
+
+If you are adding a sort that does not have a corresponding attribute, you must pass a type:
+
+sort :name, :string do <--- like this
+  # ... code ...
+end
+        MSG
+      end
+    end
+
+    class TypecastFailed < Base
+      def initialize(resource, name, value, error)
+        @resource = resource
+        @name = name
+        @value = value
+        @error = error
+      end
+
+      def message
+        <<-MSG
+#{@resource.class}: Failed typecasting #{@name.inspect}! Given #{@value.inspect} but the following error was raised:
+
+#{@error.message}
+
+#{@error.backtrace.join("\n")}
+        MSG
+      end
+    end
+
+    class ModelNotFound < Base
+      def initialize(resource_class)
+        @resource_class = resource_class
+      end
+
+      def message
+        <<-MSG
+Could not find model for Resource '#{@resource_class}'
+
+Manually set model (self.model = MyModel) if it does not match name of the Resource.
+        MSG
+      end
+    end
+
+    class TypeNotFound < Base
+      def initialize(resource, attribute, type)
+        @resource = resource
+        @attribute = attribute
+        @type = type
+      end
+
+      def message
+        <<-MSG
+Could not find type #{@type.inspect}! This was specified on attribute #{@attribute.inspect} within resource #{@resource.name}
+
+Valid types are: #{Graphiti::Types.map.keys.inspect}
+        MSG
+      end
+    end
+
+    class PolymorphicChildNotFound < Base
+      def initialize(sideload, name)
+        @sideload = sideload
+        @name = name
+      end
+
+      def message
+        <<-MSG
+#{@sideload.parent_resource}: Found record with #{@sideload.grouper.field_name.inspect} == #{@name.inspect}, which is not registered!
+
+Register the behavior of different types like so:
+
+polymorphic_belongs_to #{@sideload.name.inspect} do
+  group_by(#{@sideload.grouper.field_name.inspect}) do
+    on(#{@name.to_sym.inspect}) <---- this is what's missing
+    on(:foo).belongs_to :foo, resource: FooResource (long-hand example)
+  end
+end
+        MSG
+      end
+    end
+
+    class ResourceNotFound < Base
+      def initialize(resource, sideload_name)
+        @resource = resource
+        @sideload_name = sideload_name
+      end
+
+      def message
+        <<-MSG
+Could not find resource class for sideload '#{@sideload_name}' on Resource '#{@resource.class.name}'!
+
+If this follows a non-standard naming convention, use the :resource option to pass it directly:
+
+has_many :comments, resource: SpecialCommentResource
+        MSG
+      end
+    end
+
+    class UnsupportedPagination < Base
+      def message
+        <<-MSG
+It looks like you are requesting pagination of a sideload, but there are > 1 parents.
+
+This is not supported. In other words, you can do
+
+/employees/1?include=positions&page[positions][size]=2
+
+But not
+
+/employees?include=positions&page[positions][size]=2
+
+This is a limitation of most datastores; the same issue exists in ActiveRecord.
+
+Consider using a named relationship instead, e.g. 'has_one :top_comment'
+        MSG
+      end
+    end
+
+    class UnsupportedPageSize < Base
+      def initialize(size, max)
+        @size, @max = size, max
+      end
+
+      def message
+        "Requested page size #{@size} is greater than max supported size #{@max}"
+      end
+    end
+
+    class InvalidInclude < Base
+      def initialize(relationship, parent_resource)
+        @relationship = relationship
+        @parent_resource = parent_resource
+      end
+
+      def message
+        "The requested included relationship \"#{@relationship}\" is not supported on resource \"#{@parent_resource}\""
+      end
+    end
+
+    class StatNotFound < Base
+      def initialize(attribute, calculation)
+        @attribute = attribute
+        @calculation = calculation
+      end
+
+      def message
+        "No stat configured for calculation #{pretty(@calculation)} on attribute #{pretty(@attribute)}"
+      end
+
+      private
+
+      def pretty(input)
+        if input.is_a?(Symbol)
+          ":#{input}"
+        else
+          "'#{input}'"
+        end
+      end
+    end
+
+    class RecordNotFound < Base
+    end
+
+    class RequiredFilter < Base
+      def initialize(resource, attributes)
+        @resource = resource
+        @attributes = Array(attributes)
+      end
+
+      def message
+        if @attributes.length > 1
+          "The required filters \"#{@attributes.join(', ')}\" on resource #{@resource.class} were not provided"
+        else
+          "The required filter \"#{@attributes[0]}\" on resource #{@resource.class} was not provided"
+        end
+      end
+    end
+  end
+end