graphiti 1.0.alpha.1

data/lib/graphiti/util/attribute_check.rb

@@ -0,0 +1,88 @@
+# Private, tested in resource specs
+module Graphiti
+  module Util
+    class AttributeCheck
+      attr_reader :resource, :name, :flag, :request, :raise_error
+
+      def self.run(resource, name, flag, request, raise_error)
+        new(resource, name, flag, request, raise_error).run
+      end
+
+      def initialize(resource, name, flag, request, raise_error)
+        @resource = resource
+        @name = name.to_sym
+        @flag = flag
+        @request = request
+        @raise_error = raise_error
+      end
+
+      def run
+        if attribute?
+          if supported?
+            if guarded?
+              if guard_passes?
+                attribute
+              else
+                maybe_raise(request: true, guard: attribute[flag])
+              end
+            else
+              attribute
+            end
+          else
+            maybe_raise(exists: true)
+          end
+        else
+          maybe_raise(exists: false)
+        end
+      end
+
+      def maybe_raise(opts = {})
+        default = { request: request, exists: true }
+        opts = default.merge(opts)
+        if raise_error?(opts[:exists])
+          raise error_class.new(resource, name, flag, opts)
+        else
+          false
+        end
+      end
+
+      def guard_passes?
+        !!resource.send(attribute[flag])
+      end
+
+      def guarded?
+        request? &&
+          attribute[flag].is_a?(Symbol) &&
+          attribute[flag] != :required
+      end
+
+      def error_class
+        Errors::AttributeError
+      end
+
+      def supported?
+        attribute[flag] != false
+      end
+
+      def attribute
+        resource.all_attributes[name]
+      end
+
+      def attribute?
+        !!attribute
+      end
+
+      def raise_error?(exists)
+        if raise_error == :only_unsupported
+          exists ? true : false
+        else
+          !!raise_error
+        end
+      end
+
+      def request?
+        !!request
+      end
+    end
+  end
+end

data/lib/graphiti/util/field_params.rb

@@ -0,0 +1,16 @@
+module Graphiti
+  module Util
+    # @api private
+    class FieldParams
+      def self.parse(params)
+        return {} if params.nil?
+
+        {}.tap do |parsed|
+          params.each_pair do |key, value|
+            parsed[key.to_sym] = value.split(',').map(&:to_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/util/hash.rb

@@ -0,0 +1,51 @@
+module Graphiti
+  module Util
+    # @api private
+    class Hash
+      # Grab all keys at any level of the hash.
+      #
+      #   { foo: { bar: { baz: {} } } }
+      #
+      # Becomes
+      #
+      # [:foo, :bar, :bar]
+      #
+      # @param hash the hash we want to process
+      # @param [Array<Symbol, String>] collection the memoized collection of keys
+      # @return [Array<Symbol, String>] the keys
+      # @api private
+      def self.keys(hash, collection = [])
+        hash.each_pair do |key, value|
+          collection << key
+          keys(value, collection)
+        end
+
+        collection
+      end
+
+      # Like ActiveSupport's #deep_merge
+      # @return [Hash] the merged hash
+      # @api private
+      def self.deep_merge!(hash, other)
+        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+        hash.merge!(other, &merger)
+      end
+
+      # Like ActiveSupport's #deep_dup
+      # @api private
+      def self.deep_dup(hash)
+        if hash.respond_to?(:deep_dup)
+          hash.deep_dup
+        else
+          {}.tap do |duped|
+            hash.each_pair do |key, value|
+              value = deep_dup(value) if value.is_a?(Hash)
+              value = value.dup if value && value.respond_to?(:dup) && ![Symbol, Fixnum].include?(value.class)
+              duped[key] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/util/hooks.rb

@@ -0,0 +1,33 @@
+module Graphiti
+  module Util
+    class Hooks
+      def self.record
+        self.hooks = []
+        begin
+          yield.tap { run }
+        ensure
+          self.hooks = []
+        end
+      end
+
+      def self._hooks
+        Thread.current[:_compliable_hooks] ||= []
+      end
+      private_class_method :_hooks
+
+      def self.hooks=(val)
+        Thread.current[:_compliable_hooks] = val
+      end
+
+      # Because hooks will be added from the outer edges of
+      # the graph, working inwards
+      def self.add(prc)
+        _hooks.unshift(prc)
+      end
+
+      def self.run
+        _hooks.each { |h| h.call }
+      end
+    end
+  end
+end

data/lib/graphiti/util/include_params.rb

@@ -0,0 +1,39 @@
+module Graphiti
+  module Util
+    # Utility class for dealing with Include Directives
+    class IncludeParams
+      class << self
+        # Let's say the user requested these sideloads:
+        #
+        #   GET /posts?include=comments.author
+        #
+        # But our resource had this code:
+        #
+        #   sideload_whitelist({ index: [:comments] })
+        #
+        # We should drop the 'author' sideload from the request.
+        #
+        # Hashes become 'include directive hashes' within the library. ie
+        #
+        #   [:tags, { comments: :author }]
+        #
+        # Becomes
+        #
+        #   { tags: {}, comments: { author: {} } }
+        #
+        # @param [Hash] requested_includes the nested hash the user requested
+        # @param [Hash] allowed_includes the nested hash configured via DSL
+        # @return [Hash] the scrubbed hash
+        def scrub(requested_includes, allowed_includes)
+          {}.tap do |valid|
+            requested_includes.each_pair do |key, sub_hash|
+              if allowed_includes[key]
+                valid[key] = scrub(sub_hash, allowed_includes[key])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/util/persistence.rb

@@ -0,0 +1,219 @@
+# Save the given Resource#model, and all of its nested relationships.
+# @api private
+class Graphiti::Util::Persistence
+  # @param [Resource] resource the resource instance
+  # @param [Hash] meta see (Deserializer#meta)
+  # @param [Hash] attributes see (Deserializer#attributes)
+  # @param [Hash] relationships see (Deserializer#relationships)
+  def initialize(resource, meta, attributes, relationships, caller_model)
+    @resource      = resource
+    @meta          = meta
+    @attributes    = attributes
+    @relationships = relationships
+    @caller_model  = caller_model
+
+    @attributes.each_pair do |key, value|
+      @attributes[key] = @resource.typecast(key, value, :writable)
+    end
+  end
+
+  # Perform the actual save logic.
+  #
+  # belongs_to must be processed before/separately from has_many -
+  # we need to know the primary key value of the parent before
+  # persisting the child.
+  #
+  # Flow:
+  # * process parents
+  # * update attributes to reflect parent primary keys
+  # * persist current object
+  # * associate temp id with current object
+  # * associate parent objects with current object
+  # * process children
+  # * associate children
+  # * record hooks for later playback
+  # * run post-process sideload hooks
+  # * return current object
+  #
+  # @return a model instance
+  def run
+    parents = process_belongs_to(@relationships)
+    update_foreign_key_for_parents(parents)
+
+    persisted = persist_object(@meta[:method], @attributes)
+    persisted.instance_variable_set(:@__serializer_klass, @resource.serializer)
+    assign_temp_id(persisted, @meta[:temp_id])
+
+    associate_parents(persisted, parents)
+
+    children = process_has_many(@relationships, persisted) do |x|
+      update_foreign_key(persisted, x[:attributes], x)
+    end
+
+    associate_children(persisted, children) unless @meta[:method] == :destroy
+
+    post_process(persisted, parents)
+    post_process(persisted, children)
+    before_commit = -> { @resource.before_commit(persisted, @meta[:method]) }
+    add_hook(before_commit)
+    persisted
+  end
+
+  private
+
+  def add_hook(prc)
+    ::Graphiti::Util::Hooks.add(prc)
+  end
+
+  # The child's attributes should be modified to nil-out the
+  # foreign_key when the parent is being destroyed or disassociated
+  #
+  # This is not the case for HABTM, whose "foreign key" is a join table
+  def update_foreign_key(parent_object, attrs, x)
+    return if x[:sideload].type == :many_to_many
+
+    if [:destroy, :disassociate].include?(x[:meta][:method])
+      attrs[x[:foreign_key]] = nil
+      update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
+    else
+      attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
+      update_foreign_type(attrs, x) if x[:is_polymorphic]
+    end
+  end
+
+  def update_foreign_type(attrs, x, null: false)
+    grouping_field = x[:sideload].parent.grouper.field_name
+    attrs[grouping_field] = null ? nil : x[:sideload].group_name
+  end
+
+  def update_foreign_key_for_parents(parents)
+    parents.each do |x|
+      update_foreign_key(x[:object], @attributes, x)
+    end
+  end
+
+  def associate_parents(object, parents)
+    # No need to associate to destroyed objects
+    parents = parents.select { |x| x[:meta][:method] != :destroy }
+
+    parents.each do |x|
+      if x[:object] && object
+        if x[:meta][:method] == :disassociate
+          if x[:sideload].type == :belongs_to
+            x[:sideload].disassociate(object, x[:object])
+          else
+            x[:sideload].disassociate(x[:object], object)
+          end
+        else
+          if x[:sideload].type == :belongs_to
+            x[:sideload].associate(object, x[:object])
+          else
+            if [:has_many, :many_to_many].include?(x[:sideload].type)
+              x[:sideload].associate_all(object, Array(x[:object]))
+            else
+              x[:sideload].associate(x[:object], object)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def associate_children(object, children)
+    children.each do |x|
+      if x[:object] && object
+        if x[:meta][:method] == :disassociate
+          x[:sideload].disassociate(object, x[:object])
+        elsif x[:meta][:method] == :destroy
+          if x[:sideload].type == :many_to_many
+            x[:sideload].disassociate(object, x[:object])
+          end # otherwise, no need to disassociate destroyed objects
+        else
+          if [:has_many, :many_to_many].include?(x[:sideload].type)
+            x[:sideload].associate_all(object, Array(x[:object]))
+          else
+            x[:sideload].associate(object, x[:object])
+          end
+        end
+      end
+    end
+  end
+
+  def persist_object(method, attributes)
+    case method
+      when :destroy
+        call_resource_method(:destroy, attributes[:id], @caller_model)
+      when :update, nil, :disassociate
+        call_resource_method(:update, attributes, @caller_model)
+      else
+        call_resource_method(:create, attributes, @caller_model)
+    end
+  end
+
+  def process_has_many(relationships, caller_model)
+    [].tap do |processed|
+      iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
+        yield x
+
+        x[:object] = x[:sideload].resource
+          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model)
+        processed << x
+      end
+    end
+  end
+
+  def process_belongs_to(relationships)
+    [].tap do |processed|
+      iterate(only: [:polymorphic_belongs_to, :belongs_to]) do |x|
+        x[:object] = x[:sideload].resource
+          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+        processed << x
+      end
+    end
+  end
+
+  def post_process(caller_model, processed)
+    groups = processed.group_by { |x| x[:meta][:method] }
+    groups.each_pair do |method, group|
+      group.group_by { |g| g[:sideload] }.each_pair do |sideload, members|
+        objects = members.map { |x| x[:object] }
+        hook = -> { sideload.fire_hooks!(caller_model, objects, method) }
+        add_hook(hook)
+      end
+    end
+  end
+
+  def assign_temp_id(object, temp_id)
+    object.instance_variable_set(:@_jsonapi_temp_id, temp_id)
+  end
+
+  def iterate(only: [], except: [])
+    opts = {
+      resource: @resource,
+      relationships: @relationships,
+    }.merge(only: only, except: except)
+
+    Graphiti::Util::RelationshipPayload.iterate(opts) do |x|
+      yield x
+    end
+  end
+
+  # In the Resource, we want to allow:
+  #
+  # def create(attrs)
+  #
+  # and
+  #
+  # def create(attrs, parent = nil)
+  #
+  # 'parent' is an optional parameter that should not be part of the
+  # method signature in most use cases.
+  def call_resource_method(method_name, attributes, caller_model)
+    method = @resource.method(method_name)
+    if [2,-2].include?(method.arity)
+      method.call(attributes, caller_model)
+    else
+      method.call(attributes)
+    end
+  end
+end