jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/resource.rb

@@ -72,12 +72,6 @@ module JSONAPI
       end
     end
 
-    def create_has_one_link(association_type, association_key_value)
-      change :create_has_one_link do
-        _create_has_one_link(association_type, association_key_value)
-      end
-    end
-
     def replace_has_one_link(association_type, association_key_value)
       change :replace_has_one_link do
         _replace_has_one_link(association_type, association_key_value)
@@ -148,19 +142,6 @@ module JSONAPI
       @save_needed = true
     end
 
-    def _create_has_one_link(association_type, association_key_value)
-      association = self.class._associations[association_type]
-
-      # ToDo: Add option to skip relations that already exist instead of returning an error?
-      relation = @model.send("#{association.foreign_key}")
-      if relation.nil?
-        send("#{association.foreign_key}=", association_key_value)
-      else
-        raise JSONAPI::Exceptions::HasOneRelationExists.new
-      end
-      @save_needed = true
-    end
-
     def _replace_has_one_link(association_type, association_key_value)
       association = self.class._associations[association_type]
 
@@ -215,6 +196,8 @@ module JSONAPI
         type = base.name.demodulize.sub(/Resource$/, '').underscore
         base._type = type.pluralize.to_sym
 
+        base.attribute :id, format: :id
+
         check_reserved_resource_name(base._type, base.name)
 
         # If eager loading is on this is how all the resource types are setup
@@ -223,7 +206,7 @@ module JSONAPI
         @@resource_types[base._type] ||= base.name.demodulize
       end
 
-      attr_accessor :_attributes, :_associations, :_allowed_filters , :_type
+      attr_accessor :_attributes, :_associations, :_allowed_filters , :_type, :_paginator
 
       def create(context)
         self.new(self.create_model, context)
@@ -251,6 +234,7 @@ module JSONAPI
       def attribute(attr, options = {})
         check_reserved_attribute_name(attr)
 
+        @_attributes ||= {}
         @_attributes[attr] = options
         define_method attr do
           @model.send(attr)
@@ -298,7 +282,7 @@ module JSONAPI
 
       # Override in your resource to filter the updateable keys
       def updateable_fields(context = nil)
-        _updateable_associations | _attributes.keys
+        _updateable_associations | _attributes.keys - [_primary_key]
       end
 
       # Override in your resource to filter the createable keys
@@ -315,22 +299,27 @@ module JSONAPI
         _associations.keys | _attributes.keys
       end
 
-      def apply_filter(records, filter, value)
-        records.where(filter => value)
+      def apply_pagination(records, paginator)
+        if paginator
+          records = paginator.apply(records)
+        end
+        records
       end
 
-      # Override this method if you have more complex requirements than this basic find method provides
-      def find(filters, options = {})
-        context = options[:context]
-        sort_params = options.fetch(:sort_params) { [] }
-        includes = []
+      def apply_sort(records, order_options)
+        records.order(order_options)
+      end
 
-        records = records(options)
+      def apply_filter(records, filter, value)
+        records.where(filter => value)
+      end
 
+      def apply_filters(records, filters)
+        required_includes = []
         filters.each do |filter, value|
           if _associations.include?(filter)
             if _associations[filter].is_a?(JSONAPI::Association::HasMany)
-              includes.push(filter)
+              required_includes.push(filter)
               records = apply_filter(records, "#{filter}.#{_associations[filter].primary_key}", value)
             else
               records = apply_filter(records, "#{_associations[filter].foreign_key}", value)
@@ -339,10 +328,22 @@ module JSONAPI
             records = apply_filter(records, filter, value)
           end
         end
+        records.includes(required_includes)
+      end
+
+      # Override this method if you have more complex requirements than this basic find method provides
+      def find(filters, options = {})
+        context = options[:context]
+        sort_criteria = options.fetch(:sort_criteria) { [] }
 
         resources = []
-        order_options = construct_order_options(sort_params)
-        records.order(order_options).includes(includes).each do |model|
+
+        records = records(options)
+        records = apply_filters(records, filters)
+        records = apply_sort(records, construct_order_options(sort_criteria))
+        records = apply_pagination(records, options[:paginator])
+
+        records.each do |model|
           resources.push self.new(model, context)
         end
 
@@ -480,6 +481,14 @@ module JSONAPI
         return class_name
       end
 
+      def _paginator
+        @_paginator ||= JSONAPI.configuration.default_paginator
+      end
+
+      def paginator(paginator)
+        @_paginator = paginator
+      end
+
       # :nocov:
       if RUBY_VERSION >= '2.0'
         def _model_class
@@ -500,8 +509,13 @@ module JSONAPI
         @module_path ||= self.name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').downcase : ''
       end
 
-      private
+      def construct_order_options(sort_params)
+        sort_params.each_with_object({}) { |sort, order_hash|
+          order_hash[sort[:field]] = sort[:direction]
+        }
+      end
 
+      private
       def check_reserved_resource_name(type, name)
         if [:ids, :types, :hrefs, :links].include?(type)
           warn "[NAME COLLISION] `#{name}` is a reserved resource name."
@@ -551,14 +565,21 @@ module JSONAPI
               end
             end unless method_defined?(attr)
           elsif @_associations[attr].is_a?(JSONAPI::Association::HasMany)
-            define_method attr do
+            define_method attr do |options = {}|
               type_name = self.class._associations[attr].type.to_s
               resource_class = self.class.resource_for(self.class.module_path + type_name)
+              filters = options.fetch(:filters, {})
+              sort_criteria =  options.fetch(:sort_criteria, {})
+              paginator = options.fetch(:paginator, nil)
+
               resources = []
               if resource_class
-                associated_models = @model.send attr
-                associated_models.each do |associated_model|
-                  resources.push resource_class.new(associated_model, @context)
+                records = @model.send attr
+                records = self.class.apply_filters(records, filters)
+                records = self.class.apply_sort(records, self.class.construct_order_options(sort_criteria))
+                records = self.class.apply_pagination(records, paginator)
+                records.each do |record|
+                  resources.push resource_class.new(record, @context)
                 end
               end
               return resources
@@ -566,16 +587,6 @@ module JSONAPI
           end
         end
       end
-
-      def construct_order_options(sort_params)
-        sort_params.each_with_object({}) { |sort_key, order_hash|
-          if sort_key.starts_with?('-')
-            order_hash[sort_key.slice(1..-1)] = :desc
-          else
-            order_hash[sort_key] = :asc
-          end
-        }
-      end
     end
   end
 end

data/lib/jsonapi/resource_controller.rb

@@ -18,32 +18,40 @@ module JSONAPI
     after_filter :setup_response
 
     def index
-      render json: JSONAPI::ResourceSerializer.new(resource_klass).serialize_to_hash(
-          resource_klass.find(resource_klass.verify_filters(@request.filters, context),
-            context: context, sort_params: @request.sort_params),
-          include: @request.include,
-          fields: @request.fields,
-          attribute_formatters: attribute_formatters,
-          key_formatter: key_formatter)
+      serializer = JSONAPI::ResourceSerializer.new(resource_klass,
+                                                   include: @request.include,
+                                                   fields: @request.fields,
+                                                   base_url: base_url,
+                                                   key_formatter: key_formatter,
+                                                   route_formatter: route_formatter)
+
+      resource_records = resource_klass.find(resource_klass.verify_filters(@request.filters, context),
+                                             context: context,
+                                             sort_criteria: @request.sort_criteria,
+                                             paginator: @request.paginator)
+
+      render json: serializer.serialize_to_hash(resource_records)
     rescue => e
       handle_exceptions(e)
     end
 
     def show
+      serializer = JSONAPI::ResourceSerializer.new(resource_klass,
+                                                   include: @request.include,
+                                                   fields: @request.fields,
+                                                   base_url: base_url,
+                                                   key_formatter: key_formatter,
+                                                   route_formatter: route_formatter)
+
       keys = parse_key_array(params[resource_klass._primary_key])
 
-      resources = if keys.length > 1
-                    resource_klass.find_by_keys(keys, context: context)
-                  else
-                    resource_klass.find_by_key(keys[0], context: context)
-                  end
-
-      render json: JSONAPI::ResourceSerializer.new(resource_klass).serialize_to_hash(
-          resources,
-          include: @request.include,
-          fields: @request.fields,
-          attribute_formatters: attribute_formatters,
-          key_formatter: key_formatter)
+      resource_records = if keys.length > 1
+                           resource_klass.find_by_keys(keys, context: context)
+                         else
+                           resource_klass.find_by_key(keys[0], context: context)
+                         end
+
+      render json: serializer.serialize_to_hash(resource_records)
     rescue => e
       handle_exceptions(e)
     end
@@ -56,7 +64,14 @@ module JSONAPI
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
       association = resource_klass._association(association_type)
-      render json: { key_formatter.format(association_type) => parent_resource.send(association.foreign_key)}
+
+      serializer = JSONAPI::ResourceSerializer.new(resource_klass,
+                                                   fields: @request.fields,
+                                                   base_url: base_url,
+                                                   key_formatter: key_formatter,
+                                                   route_formatter: route_formatter)
+
+      render json: serializer.serialize_to_links_hash(parent_resource, association)
     rescue => e
       # :nocov:
       handle_exceptions(e)
@@ -87,6 +102,41 @@ module JSONAPI
       process_request_operations
     end
 
+    def get_related_resource
+      association_type = params[:association]
+      source_resource = @request.source_klass.find_by_key(@request.source_id, context: context)
+
+      serializer = JSONAPI::ResourceSerializer.new(@request.source_klass,
+                                                   include: @request.include,
+                                                   fields: @request.fields,
+                                                   base_url: base_url,
+                                                   key_formatter: key_formatter,
+                                                   route_formatter: route_formatter)
+
+      render json: serializer.serialize_to_hash(source_resource.send(association_type))
+    end
+
+    def get_related_resources
+      association_type = params[:association]
+      source_resource = @request.source_klass.find_by_key(@request.source_id, context: context)
+
+      related_resources = source_resource.send(association_type,
+                                               {
+                                                 filters:  @request.source_klass.verify_filters(@request.filters, context),
+                                                 sort_criteria: @request.sort_criteria,
+                                                 paginator: @request.paginator
+                                               })
+
+      serializer = JSONAPI::ResourceSerializer.new(@request.source_klass,
+                                                   include: @request.include,
+                                                   fields: @request.fields,
+                                                   base_url: base_url,
+                                                   key_formatter: key_formatter,
+                                                   route_formatter: route_formatter)
+
+      render json: serializer.serialize_to_hash(related_resources)
+    end
+
     # Override this to use another operations processor
     def create_operations_processor
       JSONAPI::ActiveRecordOperationsProcessor.new
@@ -105,6 +155,10 @@ module JSONAPI
     end
     # :nocov:
 
+    def base_url
+      @base_url ||= request.protocol + request.host_with_port
+    end
+
     def resource_klass_name
       @resource_klass_name ||= "#{self.class.name.sub(/Controller$/, '').singularize}Resource"
     end
@@ -149,6 +203,7 @@ module JSONAPI
 
     # Control by setting in an initializer:
     #     JSONAPI.configuration.json_key_format = :camelized_key
+    #     JSONAPI.configuration.route = :camelized_route
     #
     # Override if you want to set a per controller key format.
     # Must return a class derived from KeyFormatter.
@@ -156,9 +211,8 @@ module JSONAPI
       JSONAPI.configuration.key_formatter
     end
 
-    # override to setup custom attribute_formatters
-    def attribute_formatters
-      {}
+    def route_formatter
+      JSONAPI.configuration.route_formatter
     end
 
     def render_errors(errors)
@@ -185,13 +239,15 @@ module JSONAPI
         render status: errors[0].status, json: {errors: errors}
       else
         if results.length > 0 && resources.length > 0
+          serializer = JSONAPI::ResourceSerializer.new(resource_klass,
+                                                       include: @request.include,
+                                                       fields: @request.fields,
+                                                       base_url: base_url,
+                                                       key_formatter: key_formatter,
+                                                       route_formatter: route_formatter)
+
           render status: results[0].code,
-                 json: JSONAPI::ResourceSerializer.new(resource_klass).serialize_to_hash(
-                   resources.length > 1 ? resources : resources[0],
-                   include: @request.include,
-                   fields: @request.fields,
-                   attribute_formatters: attribute_formatters,
-                   key_formatter: key_formatter)
+                 json: serializer.serialize_to_hash(resources.length > 1 ? resources : resources[0])
         else
           render status: results[0].code, json: nil
         end

data/lib/jsonapi/resource_serializer.rb

@@ -1,12 +1,7 @@
 module JSONAPI
   class ResourceSerializer
 
-    def initialize(primary_resource_klass)
-      @primary_resource_klass = primary_resource_klass
-      @primary_class_name = @primary_resource_klass._type
-    end
-
-    # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
+    # Options can include
     # include:
     #     Purpose: determines which objects will be side loaded with the source objects in a linked section
     #     Example: ['comments','author','comments.tags','author.posts']
@@ -14,26 +9,33 @@ module JSONAPI
     #     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_to_hash(source, options = {})
-      is_resource_collection = source.respond_to?(:to_ary)
+    # key_formatter: KeyFormatter class to override the default configuration
+    # base_url: a string to prepend to generated resource links
 
-      @fields =  options.fetch(:fields, {})
-      include = options.fetch(:include, [])
+    def initialize(primary_resource_klass, options = {})
+      @primary_resource_klass = primary_resource_klass
+      @primary_class_name = @primary_resource_klass._type
 
+      @fields =  options.fetch(:fields, {})
+      @include = options.fetch(:include, [])
       @key_formatter = options.fetch(:key_formatter, JSONAPI.configuration.key_formatter)
+      @route_formatter = options.fetch(:route_formatter, JSONAPI.configuration.route_formatter)
+      @base_url = options.fetch(:base_url, '')
+    end
+
+    # Converts a single resource, or an array of resources to a hash, conforming to the JSONAPI structure
+    def serialize_to_hash(source)
+      is_resource_collection = source.respond_to?(:to_ary)
 
       @linked_objects = {}
 
-      requested_associations = parse_includes(include)
+      requested_associations = parse_includes(@include)
 
       process_primary(source, requested_associations)
 
-      linked_hash = {}
+      linked_objects = []
       primary_objects = []
-      @linked_objects.each do |class_name, objects|
-        class_name = class_name.to_sym
-
-        linked_objects = []
+      @linked_objects.each_value do |objects|
         objects.each_value do |object|
           if object[:primary]
             primary_objects.push(object[:object_hash])
@@ -41,20 +43,20 @@ module JSONAPI
             linked_objects.push(object[:object_hash])
           end
         end
-        linked_hash[format_key(class_name)] = linked_objects unless linked_objects.empty?
       end
 
-      if is_resource_collection
-        primary_hash = {format_key(@primary_class_name) => primary_objects}
-      else
-        primary_hash = {format_key(@primary_class_name) => primary_objects[0]}
-      end
+      primary_hash = {data: is_resource_collection ? primary_objects : primary_objects[0]}
 
-      if linked_hash.size > 0
-        primary_hash.merge({linked: linked_hash})
+      if linked_objects.size > 0
+        primary_hash[:linked] = linked_objects
       else
         primary_hash
       end
+      primary_hash
+    end
+
+    def serialize_to_links_hash(source, requested_association)
+      {data: link_object(source, requested_association, true)}
     end
 
     private
@@ -111,6 +113,10 @@ module JSONAPI
     def object_hash(source, requested_associations)
       obj_hash = attribute_hash(source)
       links = links_hash(source, requested_associations)
+
+      # ToDo: Do we format these required keys
+      obj_hash[format_key('type')] = format_value(source.class._type.to_s, :default, source)
+      obj_hash[format_key('id')] ||= format_value(source.id, :id, source)
       obj_hash.merge!({links: links}) unless links.empty?
       return obj_hash
     end
@@ -152,30 +158,33 @@ module JSONAPI
       field_set = Set.new(fields)
 
       included_associations = source.fetchable_fields & associations.keys
-      associations.each_with_object({}) do |(name, association), hash|
-        if included_associations.include? name
 
-          if field_set.include?(name)
-            hash[format_key(name)] = foreign_key_value(source, association)
-          end
+      links = {}
+      links[:self] = self_href(source)
 
+      associations.each_with_object(links) do |(name, association), hash|
+        if included_associations.include? name
           ia = requested_associations.is_a?(Hash) ? requested_associations[name] : nil
 
-          include_linked_object = ia && ia[:include]
+          include_linkage = ia && ia[:include]
           include_linked_children = ia && ia[:include_children]
 
+          if field_set.include?(name)
+            hash[format_key(name)] = link_object(source, association, include_linkage)
+          end
+
           type = association.type
 
           # 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 include_linkage || include_linked_children
             if association.is_a?(JSONAPI::Association::HasOne)
               resource = source.send(name)
               if resource
                 id = resource.id
                 associations_only = already_serialized?(type, id)
-                if include_linked_object && !associations_only
+                if include_linkage && !associations_only
                   add_linked_object(type, id, object_hash(resource, ia[:include_related]))
                 elsif include_linked_children || associations_only
                   links_hash(resource, ia[:include_related])
@@ -186,7 +195,7 @@ module JSONAPI
               resources.each do |resource|
                 id = resource.id
                 associations_only = already_serialized?(type, id)
-                if include_linked_object && !associations_only
+                if include_linkage && !associations_only
                   add_linked_object(type, id, object_hash(resource, ia[:include_related]))
                 elsif include_linked_children || associations_only
                   links_hash(resource, ia[:include_related])
@@ -198,11 +207,57 @@ module JSONAPI
       end
     end
 
+    def formatted_module_path(source)
+      source.class.name =~ /::[^:]+\Z/ ? (@route_formatter.format($`).freeze.gsub('::', '/') + '/').downcase : ''
+    end
+
+    def self_href(source)
+      "#{@base_url}/#{formatted_module_path(source)}#{@route_formatter.format(source.class._type.to_s)}/#{source.id}"
+    end
+
     def already_serialized?(type, id)
       type = format_key(type)
       return @linked_objects.key?(type) && @linked_objects[type].key?(id)
     end
 
+    def format_route(route)
+      @route_formatter.format(route.to_s)
+    end
+
+    def link_object_has_one(source, association)
+      route = association.name
+
+      link_object_hash = {}
+      link_object_hash[:self] = "#{self_href(source)}/links/#{format_route(route)}"
+      link_object_hash[:resource] = "#{self_href(source)}/#{format_route(route)}"
+      # ToDo: Get correct formatting figured out
+      link_object_hash[:type] = format_route(association.type)
+      link_object_hash[:id] = foreign_key_value(source, association)
+      link_object_hash
+    end
+
+    def link_object_has_many(source, association, include_linkage)
+      route = association.name
+
+      link_object_hash = {}
+      link_object_hash[:self] = "#{self_href(source)}/links/#{format_route(route)}"
+      link_object_hash[:resource] = "#{self_href(source)}/#{format_route(route)}"
+      if include_linkage
+        # ToDo: Get correct formatting figured out
+        link_object_hash[:type] = format_route(association.type)
+        link_object_hash[:ids] = foreign_key_value(source, association)
+      end
+      link_object_hash
+    end
+
+    def link_object(source, association, include_linkage = false)
+      if association.is_a?(JSONAPI::Association::HasOne)
+        link_object_has_one(source, association)
+      elsif association.is_a?(JSONAPI::Association::HasMany)
+        link_object_has_many(source, association, include_linkage)
+      end
+    end
+
     # Extracts the foreign key value for an association.
     def foreign_key_value(source, association)
       foreign_key = association.foreign_key