active_model_serializers 0.10.9 → 0.10.10

data/docs/integrations/ember-and-json-api.md

@@ -1,147 +0,0 @@
-[Back to Guides](../README.md)
-
-# Integrating with Ember and JSON API
-
- - [Preparation](./ember-and-json-api.md#preparation)
- - [Server-Side Changes](./ember-and-json-api.md#server-side-changes)
- - [Adapter Changes](./ember-and-json-api.md#adapter-changes)
-   - [Serializer Changes](./ember-and-json-api.md#serializer-changes)
- - [Including Nested Resources](./ember-and-json-api.md#including-nested-resources)
-
-## Preparation
-
-Note: This guide assumes that `ember-cli` is used for your ember app.
-
-The JSON API specification calls for hyphens for multi-word separators. ActiveModelSerializers uses underscores.
-To solve this, in Ember, both the adapter and the serializer will need some modifications:
-
-### Server-Side Changes
-
-First, set the adapter type in an initializer file:
-
-```ruby
-# config/initializers/active_model_serializers.rb
-ActiveModelSerializers.config.adapter = :json_api
-```
-
-or:
-
-```ruby
-# config/initializers/active_model_serializers.rb
-ActiveModelSerializers.config.adapter = ActiveModelSerializers::Adapter::JsonApi
-```
-
-You will also want to set the `key_transform` to `:unaltered` since you will adjust the attributes in your Ember serializer to use underscores instead of dashes later. You could also use `:underscore`, but `:unaltered` is better for performance.
-
-```ruby
-# config/initializers/active_model_serializers.rb
-ActiveModelSerializers.config.key_transform = :unaltered
-```
-
-In order to properly handle JSON API responses, we need to register a JSON API renderer, like so:
-
-```ruby
-# config/initializers/active_model_serializers.rb
-ActiveSupport.on_load(:action_controller) do
-  require 'active_model_serializers/register_jsonapi_renderer'
-end
-```
-Rails also requires your controller to tell it that you accept and generate JSONAPI data.  To do that, you use `respond_to` in your controller handlers to tell rails you are consuming and returning jsonapi format data. Without this, Rails will refuse to parse the request body into params.  You can add `ActionController::MimeResponds` to your application controller to enable this:
-
-```ruby
-class ApplicationController < ActionController::API
-  include ActionController::MimeResponds
-end
-```
-Then, in your controller you can tell rails you're accepting and rendering the jsonapi format:
-```ruby
- # POST /post
-  def create
-    @post = Post.new(post_params)
-    respond_to do |format|
-      if @post.save
-        format.jsonapi { render jsonapi: @post, status: :created, location: @post }
-      else
-        format.jsonapi { render jsonapi: @post.errors, status: :unprocessable_entity }
-      end
-    end
-  end
-  
-    # Only allow a trusted parameter "white list" through.
-    def post_params
-      ActiveModelSerializers::Deserialization.jsonapi_parse!(params, only: [:title, :body] )
-    end
-end
-```
-
-#### Note: 
-In Rails 5, the "unsafe" method ( `jsonapi_parse!` vs the safe `jsonapi_parse`) throws an `InvalidDocument` exception when the payload does not meet basic criteria for JSON API deserialization.
-
-
-### Adapter Changes
-
-```javascript
-// app/adapters/application.js
-import Ember from 'ember';
-import DS from 'ember-data';
-import ENV from "../config/environment";
-const { underscore, pluralize } = Ember.String;
-
-export default  DS.JSONAPIAdapter.extend({
-  namespace: 'api',
-  // if your rails app is on a different port from your ember app
-  // this can be helpful for development.
-  // in production, the host for both rails and ember should be the same.
-  host: ENV.host,
-
-  // allows the multiword paths in urls to be underscored
-  pathForType: function(type) {
-    let underscored = underscore(type);
-    return pluralize(underscored);
-  },
-
-});
-```
-
-### Serializer Changes
-
-```javascript
-// app/serializers/application.js
-import Ember from 'ember';
-import DS from 'ember-data';
-var underscore = Ember.String.underscore;
-
-export default DS.JSONAPISerializer.extend({
-  keyForAttribute: function(attr) {
-    return underscore(attr);
-  },
-
-  keyForRelationship: function(rawKey) {
-    return underscore(rawKey);
-  }
-});
-
-```
-
-
-## Including Nested Resources
-
-Ember Data can request related records by using `include`.  Below are some examples of how to make Ember Data request the inclusion of related records. For more on `include` usage, see: [The JSON API include examples](./../general/adapters.md#JSON-API)
-
-```javascript
-store.findRecord('post', postId, { include: 'comments' } );
-```
-which will generate the path /posts/{postId}?include='comments'
-
-So then in your controller, you'll want to be sure to have something like:
-```ruby
-render jsonapi: @post, include: params[:include]
-```
-
-If you want to use `include` on a collection, you'd write something like this:
-
-```javascript
-store.query('post', { include: 'comments' });
-```
-
-which will generate the path `/posts?include='comments'`

data/docs/integrations/grape.md

@@ -1,19 +0,0 @@
-# Integration with Grape
-
-[Grape](https://github.com/ruby-grape/grape) is an opinionated micro-framework for creating REST-like APIs in ruby.
-
-ActiveModelSerializers currently supports Grape >= 0.13, < 1.0
-
-To add [Grape](https://github.com/ruby-grape/grape) support, enable the formatter and helper functions by including `Grape::ActiveModelSerializers` in your base endpoint. For example:
-
-```ruby
-module Example
-  class Dummy < Grape::API
-    require 'grape/active_model_serializers'
-    include Grape::ActiveModelSerializers
-    mount Example::V1::Base
-  end
-end
-```
-
-Aside from this, [configuration](../general/configuration_options.md) of ActiveModelSerializers is exactly the same.

data/docs/jsonapi/errors.md

@@ -1,56 +0,0 @@
-[Back to Guides](../README.md)
-
-# [JSON API Errors](http://jsonapi.org/format/#errors)
-
-Rendering error documents requires specifying the error serializer(s):
-
-- Serializer:
-  - For a single resource: `serializer: ActiveModel::Serializer::ErrorSerializer`.
-  - For a collection: `serializer: ActiveModel::Serializer::ErrorsSerializer`, `each_serializer: ActiveModel::Serializer::ErrorSerializer`.
-
-The resource **MUST** have a non-empty associated `#errors` object.
-The `errors` object must have a `#messages` method that returns a hash of error name to array of
-descriptions.
-
-## Use in controllers
-
-```ruby
-resource = Profile.new(name: 'Name 1',
-                       description: 'Description 1',
-                       comments: 'Comments 1')
-resource.errors.add(:name, 'cannot be nil')
-resource.errors.add(:name, 'must be longer')
-resource.errors.add(:id, 'must be a uuid')
-
-render json: resource, status: 422, adapter: :json_api, serializer: ActiveModel::Serializer::ErrorSerializer
-# #=>
-#  { :errors =>
-#    [
-#      { :source => { :pointer => '/data/attributes/name' }, :detail => 'cannot be nil' },
-#      { :source => { :pointer => '/data/attributes/name' }, :detail => 'must be longer' },
-#      { :source => { :pointer => '/data/attributes/id' }, :detail => 'must be a uuid' }
-#    ]
-#  }.to_json
-```
-
-## Direct error document generation
-
-```ruby
-options = nil
-resource = ModelWithErrors.new
-resource.errors.add(:name, 'must be awesome')
-
-serializable_resource = ActiveModelSerializers::SerializableResource.new(
-  resource, {
-    serializer: ActiveModel::Serializer::ErrorSerializer,
-    adapter: :json_api
-  })
-serializable_resource.as_json(options)
-# #=>
-# {
-#   :errors =>
-#     [
-#       { :source => { :pointer => '/data/attributes/name' }, :detail => 'must be awesome' }
-#     ]
-# }
-```

data/docs/jsonapi/schema.md

@@ -1,151 +0,0 @@
-[Back to Guides](../README.md)
-
-[![JSON API 1.0](https://img.shields.io/badge/JSON%20API-1.0-lightgrey.svg)](http://jsonapi.org/)
-
-## JSON API Requests
-
-- [Query Parameters Spec](http://jsonapi.org/format/#query-parameters)
-
-Headers:
-
-- Request: `Accept: application/vnd.api+json`
-- Response: `Content-Type: application/vnd.api+json`
-
-### [Fetching Data](http://jsonapi.org/format/#fetching)
-
-A server MUST support fetching resource data for every URL provided as:
-
-- a `self` link as part of the top-level links object
-- a `self` link as part of a resource-level links object
-- a `related` link as part of a relationship-level links object
-
-Example supported requests
-
-- Individual resource or collection
-  - GET /articles
-  - GET /articles/1
-  - GET /articles/1/author
-- Relationships
-  - GET /articles/1/relationships/comments
-  - GET /articles/1/relationships/author
-- Optional: [Inclusion of related resources](http://jsonapi.org/format/#fetching-includes) `JSONAPI::IncludeDirective`
-  - GET /articles/1?`include`=comments
-  - GET /articles/1?`include`=comments.author
-  - GET /articles/1?`include`=author,comments.author
-  - GET /articles/1/relationships/comments?`include`=comments.author
-- Optional: [Sparse Fieldsets](http://jsonapi.org/format/#fetching-sparse-fieldsets) `ActiveModel::Serializer::Fieldset`
-  - GET /articles?`include`=author&`fields`[articles]=title,body&`fields`[people]=name
-- Optional: [Sorting](http://jsonapi.org/format/#fetching-sorting)
-  - GET /people?`sort`=age
-  - GET /people?`sort`=age,author.name
-  - GET /articles?`sort`=-created,title
-- Optional: [Pagination](http://jsonapi.org/format/#fetching-pagination)
-  - GET /articles?`page`[number]=3&`page`[size]=1
-- Optional: [Filtering](http://jsonapi.org/format/#fetching-filtering)
-  - GET /comments?`filter`[post]=1
-  - GET /comments?`filter`[post]=1,2
-  - GET /comments?`filter`[post]=1,2
-
-### [CRUD Actions](http://jsonapi.org/format/#crud)
-
-### [Asynchronous Processing](http://jsonapi.org/recommendations/#asynchronous-processing)
-
-### [Bulk Operations Extension](http://jsonapi.org/extensions/bulk/)
-
-## JSON API Document Schema
-
-| JSON API object       | JSON API properties                                                                                | Required | ActiveModelSerializers representation |
-|-----------------------|----------------------------------------------------------------------------------------------------|----------|---------------------------------------|
-| schema                | oneOf (success, failure, info)                                                                     |          |
-| success               | data, included, meta, links, jsonapi                                                               |          | AM::SerializableResource
-| success.meta          | meta                                                                                               |          | AMS::Adapter::Base#meta
-| success.included      | UniqueArray(resource)                                                                              |          | AMS::Adapter::JsonApi#serializable_hash_for_collection
-| success.data          | data                                                                                               |          |
-| success.links         | allOf (links, pagination)                                                                          |          | AMS::Adapter::JsonApi#links_for
-| success.jsonapi       | jsonapi                                                                                            |          |
-| failure               | errors, meta, jsonapi                                                                              | errors   | AMS::Adapter::JsonApi#failure_document, #1004
-| failure.errors        | UniqueArray(error)                                                                                 |          | AM::S::ErrorSerializer, #1004
-| meta                  | Object                                                                                             |          | 
-| data                  | oneOf (resource, UniqueArray(resource))                                                            |          | AMS::Adapter::JsonApi#serializable_hash_for_collection,#serializable_hash_for_single_resource
-| resource              | String(type), String(id),<br>attributes, relationships,<br>links, meta                                   | type, id | AM::S::Adapter::JsonApi#primary_data_for
-| links                 | Uri(self), Link(related)                                                                           |          | #1028, #1246, #1282
-| link                  | oneOf (linkString, linkObject)                                                                     |          |
-| link.linkString       | Uri                                                                                                |          |
-| link.linkObject       | Uri(href), meta                                                                                    | href     |
-| attributes            | patternProperties(<br>`"^(?!relationships$|links$)\\w[-\\w_]*$"`),<br>any valid JSON                      |          | AM::Serializer#attributes, AMS::Adapter::JsonApi#resource_object_for
-| relationships         | patternProperties(<br>`"^\\w[-\\w_]*$"`);<br>links, relationships.data, meta                              |          | AMS::Adapter::JsonApi#relationships_for
-| relationships.data    | oneOf (relationshipToOne, relationshipToMany)                                                      |          | AMS::Adapter::JsonApi#resource_identifier_for
-| relationshipToOne     | anyOf(empty, linkage)                                                                              |          |
-| relationshipToMany    | UniqueArray(linkage)                                                                               |          |
-| empty                 | null                                                                                               |          |
-| linkage               | String(type), String(id), meta                                                                     | type, id | AMS::Adapter::JsonApi#primary_data_for
-| pagination            | pageObject(first), pageObject(last),<br>pageObject(prev), pageObject(next)                            |          | AMS::Adapter::JsonApi::PaginationLinks#serializable_hash
-| pagination.pageObject | oneOf(Uri, null)                                                                                   |          |
-| jsonapi               | String(version), meta                                                                              |          | AMS::Adapter::JsonApi::Jsonapi#as_json
-| error                 | String(id), links, String(status),<br>String(code), String(title),<br>String(detail), error.source, meta |          | AM::S::ErrorSerializer, AMS::Adapter::JsonApi::Error.resource_errors
-| error.source          | String(pointer), String(parameter)                                                                 |          | AMS::Adapter::JsonApi::Error.error_source
-| pointer               | [JSON Pointer RFC6901](https://tools.ietf.org/html/rfc6901)                                        |          | AMS::JsonPointer
-
-
-The [http://jsonapi.org/schema](schema/schema.json) makes a nice roadmap.
-
-### Success Document
-- [ ] success
-  - [ ] data: `"$ref": "#/definitions/data"`
-  - [ ] included: array of unique items of type `"$ref": "#/definitions/resource"`
-  - [ ] meta: `"$ref": "#/definitions/meta"`
-  - [ ] links:
-    - [ ] link: `"$ref": "#/definitions/links"`
-    - [ ] pagination: ` "$ref": "#/definitions/pagination"`
-  - [ ] jsonapi: ` "$ref": "#/definitions/jsonapi"`
-
-### Failure Document
-
-- [ ] failure
-  - [x] errors: array of unique items of type ` "$ref": "#/definitions/error"`
-  - [ ] meta:  `"$ref": "#/definitions/meta"`
-  - [ ] jsonapi: `"$ref": "#/definitions/jsonapi"`
-
-### Info Document
-
-- [ ] info
-  - [ ] meta: `"$ref": "#/definitions/meta"`
-  - [ ] links: `"$ref": "#/definitions/links"`
-  - [ ] jsonapi: ` "$ref": "#/definitions/jsonapi"`
-
-### Definitions
-
-- [ ] definitions:
-  - [ ] meta
-  - [ ] data: oneOf (resource, array of unique resources)
-  - [ ] resource
-    - [ ] attributes
-    - [ ] relationships
-      - [ ] relationshipToOne
-        - [ ] empty
-        - [ ] linkage
-          - [ ] meta
-      - [ ] relationshipToMany
-        - [ ] linkage
-          - [ ] meta
-    - [ ] links
-    - [ ] meta
-  - [ ] links
-    - [ ] link
-      - [ ] uri
-      - [ ] href, meta
-  - [ ] pagination
-  - [ ] jsonapi
-    - [ ] meta
-  - [ ] error
-    - [ ] id: a unique identifier for this particular occurrence of the problem.
-    - [ ] links: a links object containing the following members:
-      - [ ] about: a link that leads to further details about this particular occurrence of the problem.
-    - [ ] status: the HTTP status code applicable to this problem, expressed as a string value.
-    - [ ] code: an application-specific error code, expressed as a string value.
-    - [ ] title: a short, human-readable summary of the problem that SHOULD NOT change from occurrence to occurrence of the problem, except for purposes of localization.
-    - [x] detail: a human-readable explanation specific to this occurrence of the problem.
-    - [x] source: an object containing references to the source of the error, optionally including any of the following members:
-      -  [x] pointer: a JSON Pointer [RFC6901](https://tools.ietf.org/html/rfc6901) to the associated entity in the request document [e.g. "/data" for a primary data object, or "/data/attributes/title" for a specific attribute].
-      -  [x] parameter: a string indicating which query parameter caused the error.
-    - [ ] meta: a meta object containing non-standard meta-information about the error.

data/docs/jsonapi/schema/schema.json

@@ -1,366 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-04/schema#",
-  "title": "JSON API Schema",
-  "description": "This is a schema for responses in the JSON API format. For more, see http://jsonapi.org",
-  "oneOf": [
-    {
-      "$ref": "#/definitions/success"
-    },
-    {
-      "$ref": "#/definitions/failure"
-    },
-    {
-      "$ref": "#/definitions/info"
-    }
-  ],
-  
-  "definitions": {
-    "success": {
-      "type": "object",
-      "required": [
-        "data"
-      ],
-      "properties": {
-        "data": {
-          "$ref": "#/definitions/data"
-        },
-        "included": {
-          "description": "To reduce the number of HTTP requests, servers **MAY** allow responses that include related resources along with the requested primary resources. Such responses are called \"compound documents\".",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/resource"
-          },
-          "uniqueItems": true
-        },
-        "meta": {
-          "$ref": "#/definitions/meta"
-        },
-        "links": {
-          "description": "Link members related to the primary data.",
-          "allOf": [
-            {
-              "$ref": "#/definitions/links"
-            },
-            {
-              "$ref": "#/definitions/pagination"
-            }
-          ]
-        },
-        "jsonapi": {
-          "$ref": "#/definitions/jsonapi"
-        }
-      },
-      "additionalProperties": false
-    },
-    "failure": {
-      "type": "object",
-      "required": [
-        "errors"
-      ],
-      "properties": {
-        "errors": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/error"
-          },
-          "uniqueItems": true
-        },
-        "meta": {
-          "$ref": "#/definitions/meta"
-        },
-        "jsonapi": {
-          "$ref": "#/definitions/jsonapi"
-        }
-      },
-      "additionalProperties": false
-    },
-    "info": {
-      "type": "object",
-      "required": [
-        "meta"
-      ],
-      "properties": {
-        "meta": {
-          "$ref": "#/definitions/meta"
-        },
-        "links": {
-          "$ref": "#/definitions/links"
-        },
-        "jsonapi": {
-          "$ref": "#/definitions/jsonapi"
-        }
-      },
-      "additionalProperties": false
-    },
-    
-    "meta": {
-      "description": "Non-standard meta-information that can not be represented as an attribute or relationship.",
-      "type": "object",
-      "additionalProperties": true
-    },
-    "data": {
-      "description": "The document's \"primary data\" is a representation of the resource or collection of resources targeted by a request.",
-      "oneOf": [
-        {
-          "$ref": "#/definitions/resource"
-        },
-        {
-          "description": "An array of resource objects, an array of resource identifier objects, or an empty array ([]), for requests that target resource collections.",
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/resource"
-          },
-          "uniqueItems": true
-        }
-      ]
-    },
-    "resource": {
-      "description": "\"Resource objects\" appear in a JSON API document to represent resources.",
-      "type": "object",
-      "required": [
-        "type",
-        "id"
-      ],
-      "properties": {
-        "type": {
-          "type": "string"
-        },
-        "id": {
-          "type": "string"
-        },
-        "attributes": {
-          "$ref": "#/definitions/attributes"
-        },
-        "relationships": {
-          "$ref": "#/definitions/relationships"
-        },
-        "links": {
-          "$ref": "#/definitions/links"
-        },
-        "meta": {
-          "$ref": "#/definitions/meta"
-        }
-      },
-      "additionalProperties": false
-    },
-    
-    "links": {
-      "description": "A resource object **MAY** contain references to other resource objects (\"relationships\"). Relationships may be to-one or to-many. Relationships can be specified by including a member in a resource's links object.",
-      "type": "object",
-      "properties": {
-        "self": {
-          "description": "A `self` member, whose value is a URL for the relationship itself (a \"relationship URL\"). This URL allows the client to directly manipulate the relationship. For example, it would allow a client to remove an `author` from an `article` without deleting the people resource itself.",
-          "type": "string",
-          "format": "uri"
-        },
-        "related": {
-          "$ref": "#/definitions/link"
-        }
-      },
-      "additionalProperties": true
-    },
-    "link": {
-      "description": "A link **MUST** be represented as either: a string containing the link's URL or a link object.",
-      "oneOf": [
-        {
-          "description": "A string containing the link's URL.",
-          "type": "string",
-          "format": "uri"
-        },
-        {
-          "type": "object",
-          "required": [
-            "href"
-          ],
-          "properties": {
-            "href": {
-              "description": "A string containing the link's URL.",
-              "type": "string",
-              "format": "uri"
-            },
-            "meta": {
-              "$ref": "#/definitions/meta"
-            }
-          }
-        }
-      ]
-    },
-
-    "attributes": {
-      "description": "Members of the attributes object (\"attributes\") represent information about the resource object in which it's defined.",
-      "type": "object",
-      "patternProperties": {
-        "^(?!relationships$|links$)\\w[-\\w_]*$": {
-          "description": "Attributes may contain any valid JSON value."
-        }
-      },
-      "additionalProperties": false
-    },
-
-    "relationships": {
-      "description": "Members of the relationships object (\"relationships\") represent references from the resource object in which it's defined to other resource objects.",
-      "type": "object",
-      "patternProperties": {
-        "^\\w[-\\w_]*$": {
-          "properties": {
-            "links": {
-              "$ref": "#/definitions/links"
-            },
-            "data": {
-              "description": "Member, whose value represents \"resource linkage\".",
-              "oneOf": [
-                {
-                  "$ref": "#/definitions/relationshipToOne"
-                },
-                {
-                  "$ref": "#/definitions/relationshipToMany"
-                }
-              ]
-            },
-            "meta": {
-              "$ref": "#/definitions/meta"
-            }
-          },
-          "additionalProperties": false
-        }
-      },
-      "additionalProperties": false
-    },
-    "relationshipToOne": {
-      "description": "References to other resource objects in a to-one (\"relationship\"). Relationships can be specified by including a member in a resource's links object.",
-      "anyOf": [
-        {
-          "$ref": "#/definitions/empty"
-        },
-        {
-          "$ref": "#/definitions/linkage"
-        }
-      ]
-    },
-    "relationshipToMany": {
-      "description": "An array of objects each containing \"type\" and \"id\" members for to-many relationships.",
-      "type": "array",
-      "items": {
-        "$ref": "#/definitions/linkage"
-      },
-      "uniqueItems": true
-    },
-    "empty": {
-      "description": "Describes an empty to-one relationship.",
-      "type": "null"
-    },
-    "linkage": {
-      "description": "The \"type\" and \"id\" to non-empty members.",
-      "type": "object",
-      "required": [
-        "type",
-        "id"
-      ],
-      "properties": {
-        "type": {
-          "type": "string"
-        },
-        "id": {
-          "type": "string"
-        },
-        "meta": {
-          "$ref": "#/definitions/meta"
-        }
-      },
-      "additionalProperties": false
-    },
-    "pagination": {
-      "type": "object",
-      "properties": {
-        "first": {
-          "description": "The first page of data",
-          "oneOf": [
-            { "type": "string", "format": "uri" },
-            { "type": "null" }
-          ]
-        },
-        "last": {
-          "description": "The last page of data",
-          "oneOf": [
-            { "type": "string", "format": "uri" },
-            { "type": "null" }
-          ]
-        },
-        "prev": {
-          "description": "The previous page of data",
-          "oneOf": [
-            { "type": "string", "format": "uri" },
-            { "type": "null" }
-          ]
-        },
-        "next": {
-          "description": "The next page of data",
-          "oneOf": [
-            { "type": "string", "format": "uri" },
-            { "type": "null" }
-          ]
-        }
-      }
-    },
-    
-    "jsonapi": {
-      "description": "An object describing the server's implementation",
-      "type": "object",
-      "properties": {
-        "version": {
-          "type": "string"
-        },
-        "meta": {
-          "$ref": "#/definitions/meta"
-        }
-      },
-      "additionalProperties": false
-    },
-    
-    "error": {
-      "type": "object",
-      "properties": {
-        "id": {
-          "description": "A unique identifier for this particular occurrence of the problem.",
-          "type": "string"
-        },
-        "links": {
-          "$ref": "#/definitions/links"
-        },
-        "status": {
-          "description": "The HTTP status code applicable to this problem, expressed as a string value.",
-          "type": "string"
-        },
-        "code": {
-          "description": "An application-specific error code, expressed as a string value.",
-          "type": "string"
-        },
-        "title": {
-          "description": "A short, human-readable summary of the problem. It **SHOULD NOT** change from occurrence to occurrence of the problem, except for purposes of localization.",
-          "type": "string"
-        },
-        "detail": {
-          "description": "A human-readable explanation specific to this occurrence of the problem.",
-          "type": "string"
-        },
-        "source": {
-          "type": "object",
-          "properties": {
-            "pointer": {
-              "description": "A JSON Pointer [RFC6901] to the associated entity in the request document [e.g. \"/data\" for a primary data object, or \"/data/attributes/title\" for a specific attribute].",
-              "type": "string"
-            },
-            "parameter": {
-              "description": "A string indicating which query parameter caused the error.",
-              "type": "string"
-            }
-          }
-        },
-        "meta": {
-          "$ref": "#/definitions/meta"
-        }
-      },
-      "additionalProperties": false
-    }
-  }
-}