jsonapi-resources 0.0.1

data/lib/jsonapi/resource_controller.rb

@@ -0,0 +1,169 @@
+require 'jsonapi/resource_for'
+require 'jsonapi/resource_serializer'
+require 'action_controller'
+require 'jsonapi/exceptions'
+require 'jsonapi/error'
+require 'jsonapi/error_codes'
+require 'jsonapi/request'
+require 'jsonapi/operations_processor'
+require 'jsonapi/active_record_operations_processor'
+require 'csv'
+
+module JSONAPI
+  class ResourceController < ActionController::Base
+    include ResourceFor
+
+    before_filter {
+      begin
+        @request = JSONAPI::Request.new(context, params)
+        render_errors(@request.errors) unless @request.errors.empty?
+      rescue => e
+        handle_exceptions(e)
+      end
+    }
+
+    def index
+      render json: JSONAPI::ResourceSerializer.new.serialize(
+          resource_klass.find(resource_klass.verify_filters(@request.filters, context), context),
+          @request.includes,
+          @request.fields,
+          context)
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    def show
+      keys = parse_key_array(params[resource_klass._key])
+
+      resources = []
+      keys.each do |key|
+        resources.push(resource_klass.find_by_key(key, context))
+      end
+
+      render json: JSONAPI::ResourceSerializer.new.serialize(
+          resources,
+          @request.includes,
+          @request.fields,
+          context)
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    def show_association
+      association_type = params[:association]
+
+      parent_key = params[resource_klass._as_parent_key]
+
+      parent_resource = resource_klass.find_by_key(parent_key, context)
+
+      association = resource_klass._association(association_type)
+      render json: { association_type => parent_resource.send(association.key)}
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    def create
+      process_request_operations
+    end
+
+    def create_association
+      process_request_operations
+    end
+
+    def update
+      process_request_operations
+    end
+
+    def destroy
+      process_request_operations
+    end
+
+    def destroy_association
+      process_request_operations
+    end
+
+    # Override this to use another operations processor
+    def create_operations_processor
+      JSONAPI::ActiveRecordOperationsProcessor.new
+    end
+
+    private
+    if RUBY_VERSION >= '2.0'
+      def resource_klass
+        @resource_klass ||= Object.const_get resource_klass_name
+      end
+    else
+      def resource_klass
+        @resource_klass ||= resource_klass_name.safe_constantize
+      end
+    end
+
+    def resource_klass_name
+      @resource_klass_name ||= "#{self.class.name.demodulize.sub(/Controller$/, '').singularize}Resource"
+    end
+
+    def parse_key_array(raw)
+      keys = []
+      raw.split(/,/).collect do |key|
+        keys.push resource_klass.verify_key(key, context)
+      end
+      return keys
+    end
+
+    # override to set context
+    def context
+      {}
+    end
+
+    def render_errors(errors, status = :bad_request)
+      render(json: {errors: errors}, status: errors.count == 1 ? errors[0].status : status)
+    end
+
+    def process_request_operations
+      op = create_operations_processor
+
+      results = op.process(@request)
+
+      errors = []
+      resources = []
+
+      results.each do |result|
+        if result.has_errors?
+          errors.concat(result.errors)
+        else
+          resources.push(result.resource) unless result.resource.nil?
+        end
+      end
+
+      if errors.count > 0
+        render :status => errors.count == 1 ? errors[0].status : :bad_request, json: {errors: errors}
+      else
+        # if patch
+          render :status => results[0].code, json: JSONAPI::ResourceSerializer.new.serialize(resources,
+                                                                                               @request.includes,
+                                                                                               @request.fields,
+                                                                                               context)
+        # else
+        #   result_hash = {}
+        #   resources.each do |resource|
+        #     result_hash.merge!(JSONAPI::ResourceSerializer.new.serialize(resource, @request.includes, @request.fields, context))
+        #   end
+        #   render :status => results.count == 1 ? results[0].code : :ok, json: result_hash
+        # end
+      end
+    rescue => e
+      handle_exceptions(e)
+    end
+
+    # override this to process other exceptions
+    # Note: Be sure to either call super(e) or handle JSONAPI::Exceptions::Error and raise unhandled exceptions
+    def handle_exceptions(e)
+      case e
+        when JSONAPI::Exceptions::Error
+          render_errors(e.errors)
+        else # raise all other exceptions
+          raise e
+      end
+    end
+  end
+end

data/lib/jsonapi/resource_for.rb

@@ -0,0 +1,25 @@
+module JSONAPI
+  module ResourceFor
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      if RUBY_VERSION >= '2.0'
+        def resource_for(type)
+          begin
+            resource_name = JSONAPI::Resource._resource_name_from_type(type)
+            Object.const_get resource_name if resource_name
+          rescue NameError
+            nil
+          end
+        end
+      else
+        def resource_for(type)
+          resource_name = JSONAPI::Resource._resource_name_from_type(type)
+          resource_name.safe_constantize if resource_name
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/resource_serializer.rb

@@ -0,0 +1,209 @@
+module JSONAPI
+  class ResourceSerializer
+
+    # Serializes a single resource, or an array of resources
+    # include:
+    #     Purpose: determines which objects will be side loaded with the source objects in a linked section
+    #     Example: ['comments','author','comments.tags','author.posts']
+    # fields:
+    #     Purpose: determines which fields are serialized for a resource type. This encompasses both attributes and
+    #              association ids in the links section for a resource. Fields are global for a resource type.
+    #     Example: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
+    def serialize(source, include = [], fields = {}, context = nil)
+      @fields = fields
+      @context = context
+      @linked_objects = {}
+
+      requested_associations = parse_includes(include)
+
+      if source.respond_to?(:to_ary)
+        return {} if source.size == 0
+        @primary_class_name = source[0].class._serialize_as
+      else
+        @primary_class_name = source.class._serialize_as
+      end
+
+      process_primary(source, requested_associations)
+
+      primary_class_name = @primary_class_name.to_sym
+      primary_hash = {primary_class_name => []}
+
+      linked_hash = {}
+      @linked_objects.each do |class_name, objects|
+        class_name = class_name.to_sym
+
+        linked = []
+        objects.each_value do |object|
+          if object[:primary]
+            primary_hash[primary_class_name].push(object[:object_hash])
+          else
+            linked.push(object[:object_hash])
+          end
+        end
+        linked_hash[class_name] = linked unless linked.empty?
+      end
+
+      if linked_hash.size > 0
+        primary_hash.merge!({linked: linked_hash})
+      end
+
+      return primary_hash
+    end
+
+    private
+    # Convert an array of associated objects to include along with the primary document in the form of
+    # ['comments','author','comments.tags','author.posts'] into a structure that tells what we need to include
+    # from each association.
+    def parse_includes(includes)
+      requested_associations = {}
+      includes.each do |include|
+        include = include.to_s if include.is_a? Symbol
+
+        pos = include.index('.')
+        if pos
+          association_name = include[0, pos].to_sym
+          requested_associations[association_name] ||= {}
+          requested_associations[association_name].store(:include_children, true)
+          requested_associations[association_name].store(:include_related, parse_includes([include[pos+1, include.length]]))
+        else
+          association_name = include.to_sym
+          requested_associations[association_name] ||= {}
+          requested_associations[association_name].store(:include, true)
+        end
+      end if includes.is_a?(Array)
+      return requested_associations
+    end
+
+    # Process the primary source object(s). This will then serialize associated object recursively based on the
+    # requested includes. Fields are controlled fields option for each resource type, such
+    # as fields: { people: [:id, :email, :comments], posts: [:id, :title, :author], comments: [:id, :body, :post]}
+    # The fields options controls both fields and included links references.
+    def process_primary(source, requested_associations)
+      if source.respond_to?(:to_ary)
+        source.each do |object|
+          id = object.send(object.class._key)
+          if already_serialized?(@primary_class_name, id)
+            set_primary(@primary_class_name, id)
+          end
+
+          add_linked_object(@primary_class_name, id, object_hash(object,  requested_associations), true)
+        end
+      else
+        id = source.send(source.class._key)
+        # ToDo: See if this is actually needed
+        # if already_serialized?(@primary_class_name, id)
+        #   set_primary(@primary_class_name, id)
+        # end
+
+        add_linked_object(@primary_class_name, id, object_hash(source,  requested_associations), true)
+      end
+    end
+
+    # Returns a serialized hash for the source object, with
+    def object_hash(source, requested_associations)
+      obj_hash = attribute_hash(source)
+      links = links_hash(source, requested_associations)
+      obj_hash.merge!({links: links}) unless links.empty?
+      return obj_hash
+    end
+
+    def requested_fields(model)
+      @fields[model] if @fields
+    end
+
+    def attribute_hash(source)
+      requested = requested_fields(source.class._serialize_as)
+      fields = source.class._attributes.to_a
+      unless requested.nil?
+        fields = requested & fields
+      end
+
+      source.fetchable(fields, @context).each_with_object({}) do |name, hash|
+        hash[name] = source.send(name)
+      end
+    end
+
+    # Returns a hash of links for the requested associations for a resource, filtered by the resource
+    # class's fetchable method
+    def links_hash(source, requested_associations)
+      associations = source.class._associations
+      requested = requested_fields(source.class._serialize_as)
+      fields = associations.keys
+      unless requested.nil?
+        fields = requested & fields
+      end
+
+      field_set = Set.new(fields)
+
+      included_associations = source.fetchable(associations.keys, @context)
+      associations.each_with_object({}) do |(name, association), hash|
+        if included_associations.include? name
+          key = association.key
+
+          if field_set.include?(name)
+            hash[name] = source.send(key)
+          end
+
+          ia = requested_associations.is_a?(Hash) ? requested_associations[name] : nil
+
+          include_linked_object = ia && ia[:include]
+          include_linked_children = ia && ia[:include_children]
+
+          type = association.serialize_type_name
+
+          # If the object has been serialized once it will be in the related objects list,
+          # but it's possible all children won't have been captured. So we must still go
+          # through the associations.
+          if include_linked_object || include_linked_children
+            if association.is_a?(JSONAPI::Association::HasOne)
+              object = source.send("_#{name}_object")
+
+              id = object.send(association.primary_key)
+              associations_only = already_serialized?(type, id)
+              if include_linked_object && !associations_only
+                add_linked_object(type, id, object_hash(object, ia[:include_related]))
+              elsif include_linked_children || associations_only
+                links_hash(object, ia[:include_related])
+              end
+            elsif association.is_a?(JSONAPI::Association::HasMany)
+              objects = source.send("_#{name}_objects")
+              objects.each do |object|
+                id = object.send(association.primary_key)
+                associations_only = already_serialized?(type, id)
+                if include_linked_object && !associations_only
+                  add_linked_object(type, id, object_hash(object, ia[:include_related]))
+                elsif include_linked_children || associations_only
+                  links_hash(object, ia[:include_related])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def already_serialized?(type, id)
+      return @linked_objects.key?(type) && @linked_objects[type].key?(id)
+    end
+
+    # Sets that an object should be included in the primary document of the response.
+    def set_primary(type, id)
+      @linked_objects[type][id][:primary] = true
+    end
+
+    # Collects the hashes for all objects processed by the serializer
+    def add_linked_object(type, id, object_hash, primary = false)
+      unless @linked_objects.key?(type)
+        @linked_objects[type] = {}
+      end
+
+      if already_serialized?(type, id)
+        if primary
+          set_primary(type, id)
+        end
+      else
+        @linked_objects[type].store(id, {primary: primary, object_hash: object_hash})
+      end
+    end
+  end
+end

data/lib/jsonapi/resources/version.rb

@@ -0,0 +1,5 @@
+module JSONAPI
+  module Resources
+    VERSION = "0.0.1"
+  end
+end

data/lib/jsonapi/routing_ext.rb

@@ -0,0 +1,104 @@
+module ActionDispatch
+  module Routing
+    class Mapper
+      Resources.class_eval do
+        def jsonapi_resource(*resources, &block)
+          resource_type = resources.first
+          options = resources.extract_options!.dup
+
+          res = JSONAPI::Resource.resource_for(resource_type)
+          resource resource_type, options.merge(res.routing_resource_options) do
+            @scope[:jsonapi_resource] = resource_type
+
+            if block_given?
+              yield
+            else
+              res._associations.each do |association_name, association|
+                if association.is_a?(JSONAPI::Association::HasMany)
+                  jsonapi_links(association_name)
+                else
+                  jsonapi_link(association_name)
+                end
+              end
+            end
+          end
+        end
+
+        def jsonapi_resources(*resources, &block)
+          resource_type = resources.first
+          options = resources.extract_options!.dup
+
+          res = JSONAPI::Resource.resource_for(resource_type)
+          resources resource_type, options.merge(res.routing_resource_options) do
+            @scope[:jsonapi_resource] = resource_type
+
+            if block_given?
+              yield
+            else
+              res._associations.each do |association_name, association|
+                if association.is_a?(JSONAPI::Association::HasMany)
+                  jsonapi_links(association_name)
+                else
+                  jsonapi_link(association_name)
+                end
+              end
+            end
+          end
+        end
+
+        def links_methods(options)
+          default_methods = [:show, :create, :destroy]
+          if only = options[:only]
+            Array(only).map(&:to_sym)
+          elsif except = options[:except]
+            default_methods - except
+          else
+            default_methods
+          end
+        end
+
+        def jsonapi_link(*links)
+          link_type = links.first
+          options = links.extract_options!.dup
+
+          res = JSONAPI::Resource.resource_for(@scope[:jsonapi_resource])
+
+          methods = links_methods(options)
+
+          if methods.include?(:show)
+            match "links/#{link_type}", controller: res._type.to_s, action: 'show_association', association: link_type.to_s, via: [:get]
+          end
+
+          if methods.include?(:create)
+            match "links/#{link_type}", controller: res._type.to_s, action: 'create_association', association: link_type.to_s, via: [:post]
+          end
+
+          if methods.include?(:destroy)
+            match "links/#{link_type}", controller: res._type.to_s, action: 'destroy_association', association: link_type.to_s, via: [:delete]
+          end
+        end
+
+        def jsonapi_links(*links)
+          link_type = links.first
+          options = links.extract_options!.dup
+
+          res = JSONAPI::Resource.resource_for(@scope[:jsonapi_resource])
+
+          methods = links_methods(options)
+
+          if methods.include?(:show)
+            match "links/#{link_type}", controller: res._type.to_s, action: 'show_association', association: link_type.to_s, via: [:get]
+          end
+
+          if methods.include?(:create)
+            match "links/#{link_type}", controller: res._type.to_s, action: 'create_association', association: link_type.to_s, via: [:post]
+          end
+
+          if methods.include?(:destroy)
+            match "links/#{link_type}/:keys", controller: res._type.to_s, action: 'destroy_association', association: link_type.to_s, via: [:delete]
+          end
+        end
+      end
+    end
+  end
+end