@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.2

package/dist/unpkg/prod/json-BD1kRTfB.js

@@ -0,0 +1,1080 @@
+import { Serializer } from "./serializer.js";
+import { getOwner } from "@ember/application";
+import { dasherize, singularize } from "@warp-drive/utilities/string";
+
+//#region src/serializer/-private/utils.ts
+function coerceId(id) {
+	if (id === null || id === void 0 || id === "") return null;
+	else if (typeof id === "string") return id;
+	else if (typeof id === "symbol") return id.toString();
+	else return String(id);
+}
+/**
+Given the name of a relationship on a resource `type`, determines the
+inverse relationship field (if any) using only the schema service.
+
+Unlike `Model.inverseFor`, this does not require `type` to be backed by
+a `Model` class, so it works for both `Model`-based and schema-only
+(e.g. `withDefaults` migration-support) resources.
+
+@private
+*/
+function inverseForRelationship(store, type, name) {
+	const relationship = store.schema.fields({ type }).get(name);
+	const { options } = relationship;
+	if (options.inverse === null) return null;
+	if (!store.schema.hasResource(relationship)) return null;
+	return store.schema.fields(relationship).get(options.inverse) ?? null;
+}
+/**
+Given a relationship field on a resource `type`, determines the
+cardinality of the relationship using only the schema service.
+
+Unlike `Model.determineRelationshipType`, this does not require `type`
+to be backed by a `Model` class, so it works for both `Model`-based and
+schema-only (e.g. `withDefaults` migration-support) resources.
+
+@private
+*/
+function determineRelationshipType(store, type, knownSide) {
+	const knownKind = knownSide.kind;
+	const inverse = inverseForRelationship(store, type, knownSide.name);
+	if (!inverse) return knownKind === "belongsTo" ? "oneToNone" : "manyToNone";
+	if (inverse.kind === "belongsTo") return knownKind === "belongsTo" ? "oneToOne" : "manyToOne";
+	else return knownKind === "belongsTo" ? "oneToMany" : "manyToMany";
+}
+
+//#endregion
+//#region src/serializer/json.ts
+const SOURCE_POINTER_REGEXP = /^\/?data\/(attributes|relationships)\/(.*)/;
+const SOURCE_POINTER_PRIMARY_REGEXP = /^\/?data/;
+const PRIMARY_ATTRIBUTE_KEY = "base";
+/**
+* :::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
+If starting a new app or thinking of implementing a new adapter, consider writing a
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
+
+In WarpDrive a Serializer is used to serialize and deserialize
+records when they are transferred in and out of an external source.
+This process involves normalizing property names, transforming
+attribute values and serializing relationships.
+
+By default, WarpDrive uses and recommends the `JSONAPISerializer`.
+
+`JSONSerializer` is useful for simpler or legacy backends that may
+not support the http://jsonapi.org/ spec.
+
+For example, given the following `User` model and JSON payload:
+
+```js [app/models/user.js]
+import Model, { attr, belongsTo, hasMany } from '@warp-drive/legacy/model';
+
+export default class UserModel extends Model {
+@hasMany('user') friends;
+@belongsTo('location') house;
+
+@attr('string') name;
+}
+```
+
+```js
+{
+id: 1,
+name: 'Sebastian',
+friends: [3, 4],
+links: {
+house: '/houses/lefkada'
+}
+}
+```
+
+`JSONSerializer` will normalize the JSON payload to the {json:api} format that the
+JSONAPICache uses to cache data in the Store.
+
+You can customize how JSONSerializer processes its payload by passing options in
+the `attrs` hash or by subclassing the `JSONSerializer` and overriding hooks:
+
+- To customize how a single record is normalized, use the `normalize` hook.
+- To customize how `JSONSerializer` normalizes the whole server response, use the
+`normalizeResponse` hook.
+- To customize how `JSONSerializer` normalizes a specific response from the server,
+use one of the many specific `normalizeResponse` hooks.
+- To customize how `JSONSerializer` normalizes your id, attributes or relationships,
+use the `extractId`, `extractAttributes` and `extractRelationships` hooks.
+
+The `JSONSerializer` normalization process follows these steps:
+
+1. `normalizeResponse`
+- entry method to the serializer.
+2. `normalizeCreateRecordResponse`
+- a `normalizeResponse` for a specific operation is called.
+3. `normalizeSingleResponse`|`normalizeArrayResponse`
+- for methods like `createRecord` we expect a single record back, while for methods like `findAll` we expect multiple records back.
+4. `normalize`
+- `normalizeArrayResponse` iterates and calls `normalize` for each of its records while `normalizeSingle`
+calls it once. This is the method you most likely want to subclass.
+5. `extractId` | `extractAttributes` | `extractRelationships`
+- `normalize` delegates to these methods to
+turn the record payload into the JSON API format.
+
+@class JSONSerializer
+@public
+*/
+const JSONSerializer = Serializer.extend({
+	/**
+	The `primaryKey` is used when serializing and deserializing
+	data. WarpDrive always uses the `id` property to store the id of
+	the record. The external source may not always follow this
+	convention. In these cases it is useful to override the
+	`primaryKey` property to match the `primaryKey` of your external
+	store.
+	Example
+	```js [app/serializers/application.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class ApplicationSerializer extends JSONSerializer {
+	primaryKey = '_id'
+	}
+	```
+	@public
+	@default 'id'
+	*/
+	primaryKey: "id",
+	/**
+	The `attrs` object can be used to declare a simple mapping between
+	property names on `Model` records and payload keys in the
+	serialized JSON object representing the record. An object with the
+	property `key` can also be used to designate the attribute's key on
+	the response payload.
+	Example
+	```js [app/models/person.js]
+	import Model, { attr } from '@warp-drive/legacy/model';
+	export default class PersonModel extends Model {
+	@attr('string') firstName;
+	@attr('string') lastName;
+	@attr('string') occupation;
+	@attr('boolean') admin;
+	}
+	```
+	```js [app/serializers/person.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PersonSerializer extends JSONSerializer {
+	attrs = {
+	admin: 'is_admin',
+	occupation: { key: 'career' }
+	}
+	}
+	```
+	You can also remove attributes and relationships by setting the `serialize`
+	key to `false` in your mapping object.
+	Example
+	```js [app/serializers/person.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	attrs = {
+	admin: { serialize: false },
+	occupation: { key: 'career' }
+	}
+	}
+	```
+	When serialized:
+	```js
+	{
+	"firstName": "Harry",
+	"lastName": "Houdini",
+	"career": "magician"
+	}
+	```
+	Note that the `admin` is now not included in the payload.
+	Setting `serialize` to `true` enforces serialization for hasMany
+	relationships even if it's neither a many-to-many nor many-to-none
+	relationship.
+	@public
+	*/
+	mergedProperties: ["attrs"],
+	/**
+	Given a subclass of `Model` and a JSON object this method will
+	iterate through each attribute of the `Model` and invoke the
+	`Transform#deserialize` method on the matching property of the
+	JSON object.  This method is typically called after the
+	serializer's `normalize` method.
+	@private
+	*/
+	applyTransforms(typeClass, data) {
+		const attributes = typeClass.attributes;
+		typeClass.eachTransformedAttribute((key, type) => {
+			if (data[key] === void 0) return;
+			const transform = this.transformFor(type);
+			const transformMeta = attributes.get(key);
+			data[key] = transform.deserialize(data[key], transformMeta.options);
+		});
+		return data;
+	},
+	/**
+	The `normalizeResponse` method is used to normalize a payload from the
+	server to a JSON-API Document.
+	http://jsonapi.org/format/#document-structure
+	This method delegates to a more specific normalize method based on
+	the `requestType`.
+	To override this method with a custom one, make sure to call
+	`return super.normalizeResponse(store, primaryModelClass, payload, id, requestType)` with your
+	pre-processed data.
+	Here's an example of using `normalizeResponse` manually:
+	```javascript
+	socket.on('message', function(message) {
+	let data = message.data;
+	let modelClass = store.modelFor(data.modelName);
+	let serializer = store.serializerFor(data.modelName);
+	let normalized = serializer.normalizeSingleResponse(store, modelClass, data, data.id);
+	store.push(normalized);
+	});
+	```
+	@since 1.13.0
+	@public
+	*/
+	normalizeResponse(store, primaryModelClass, payload, id, requestType) {
+		switch (requestType) {
+			case "findRecord": return this.normalizeFindRecordResponse(...arguments);
+			case "queryRecord": return this.normalizeQueryRecordResponse(...arguments);
+			case "findAll": return this.normalizeFindAllResponse(...arguments);
+			case "findBelongsTo": return this.normalizeFindBelongsToResponse(...arguments);
+			case "findHasMany": return this.normalizeFindHasManyResponse(...arguments);
+			case "findMany": return this.normalizeFindManyResponse(...arguments);
+			case "query": return this.normalizeQueryResponse(...arguments);
+			case "createRecord": return this.normalizeCreateRecordResponse(...arguments);
+			case "deleteRecord": return this.normalizeDeleteRecordResponse(...arguments);
+			case "updateRecord": return this.normalizeUpdateRecordResponse(...arguments);
+		}
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `findRecord`
+	@since 1.13.0
+	@public
+	*/
+	normalizeFindRecordResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSingleResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `queryRecord`
+	@since 1.13.0
+	@public
+	*/
+	normalizeQueryRecordResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSingleResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `findAll`
+	@since 1.13.0
+	@public
+	*/
+	normalizeFindAllResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeArrayResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `findBelongsTo`
+	@since 1.13.0
+	@public
+	*/
+	normalizeFindBelongsToResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSingleResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `findHasMany`
+	@since 1.13.0
+	@public
+	*/
+	normalizeFindHasManyResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeArrayResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `findMany`
+	@since 1.13.0
+	@public
+	*/
+	normalizeFindManyResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeArrayResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `query`
+	@since 1.13.0
+	@public
+	*/
+	normalizeQueryResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeArrayResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `createRecord`
+	@since 1.13.0
+	@public
+	*/
+	normalizeCreateRecordResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSaveResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `deleteRecord`
+	@since 1.13.0
+	@public
+	*/
+	normalizeDeleteRecordResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSaveResponse(...arguments);
+	},
+	/**
+	Called by the default normalizeResponse implementation when the
+	type of request is `updateRecord`
+	@since 1.13.0
+	@public
+	*/
+	normalizeUpdateRecordResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSaveResponse(...arguments);
+	},
+	/**
+	normalizeUpdateRecordResponse, normalizeCreateRecordResponse and
+	normalizeDeleteRecordResponse delegate to this method by default.
+	@since 1.13.0
+	@public
+	*/
+	normalizeSaveResponse(store, primaryModelClass, payload, id, requestType) {
+		return this.normalizeSingleResponse(...arguments);
+	},
+	/**
+	normalizeQueryResponse and normalizeFindRecordResponse delegate to this
+	method by default.
+	@since 1.13.0
+	@public
+	*/
+	normalizeSingleResponse(store, primaryModelClass, payload, id, requestType) {
+		return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, true);
+	},
+	/**
+	normalizeQueryResponse, normalizeFindManyResponse, and normalizeFindHasManyResponse delegate
+	to this method by default.
+	@since 1.13.0
+	@public
+	*/
+	normalizeArrayResponse(store, primaryModelClass, payload, id, requestType) {
+		return this._normalizeResponse(store, primaryModelClass, payload, id, requestType, false);
+	},
+	/**
+	@private
+	*/
+	_normalizeResponse(store, primaryModelClass, payload, id, requestType, isSingle) {
+		const documentHash = {
+			data: null,
+			included: []
+		};
+		const meta = this.extractMeta(store, primaryModelClass, payload);
+		if (meta) documentHash.meta = meta;
+		if (isSingle) {
+			const { data, included } = this.normalize(primaryModelClass, payload);
+			documentHash.data = data;
+			if (included) documentHash.included = included;
+		} else {
+			const ret = new Array(payload.length);
+			for (let i = 0, l = payload.length; i < l; i++) {
+				const item = payload[i];
+				const { data, included } = this.normalize(primaryModelClass, item);
+				if (included) documentHash.included = documentHash.included.concat(included);
+				ret[i] = data;
+			}
+			documentHash.data = ret;
+		}
+		return documentHash;
+	},
+	/**
+	Normalizes a part of the JSON payload returned by
+	the server. You should override this method, munge the hash
+	and call super if you have generic normalization to do.
+	It takes the type of the record that is being normalized
+	(as a Model class), the property where the hash was
+	originally found, and the hash to normalize.
+	You can use this method, for example, to normalize underscored keys to camelized
+	or other general-purpose normalizations.
+	Example
+	```js [app/serializers/application.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	import { underscore } from '<app-name>/utils/string-utils';
+	import { get } from '@ember/object';
+	export default class ApplicationSerializer extends JSONSerializer {
+	normalize(typeClass, hash) {
+	let fields = typeClass.fields;
+	fields.forEach(function(type, field) {
+	let payloadField = underscore(field);
+	if (field === payloadField) { return; }
+	hash[field] = hash[payloadField];
+	delete hash[payloadField];
+	});
+	return super.normalize(...arguments);
+	}
+	}
+	```
+	@public
+	*/
+	normalize(modelClass, resourceHash) {
+		let data = null;
+		if (resourceHash) {
+			this.normalizeUsingDeclaredMapping(modelClass, resourceHash);
+			if (typeof resourceHash.links === "object") this.normalizeUsingDeclaredMapping(modelClass, resourceHash.links);
+			data = {
+				id: this.extractId(modelClass, resourceHash),
+				type: modelClass.modelName,
+				attributes: this.extractAttributes(modelClass, resourceHash),
+				relationships: this.extractRelationships(modelClass, resourceHash)
+			};
+			if (resourceHash.lid) data.lid = resourceHash.lid;
+			this.applyTransforms(modelClass, data.attributes);
+		}
+		return { data };
+	},
+	/**
+	Returns the resource's ID.
+	@public
+	*/
+	extractId(modelClass, resourceHash) {
+		const id = resourceHash[this.primaryKey];
+		return coerceId(id);
+	},
+	/**
+	Returns the resource's attributes formatted as a JSON-API "attributes object".
+	http://jsonapi.org/format/#document-resource-object-attributes
+	@public
+	*/
+	extractAttributes(modelClass, resourceHash) {
+		let attributeKey;
+		const attributes = {};
+		modelClass.eachAttribute((key) => {
+			attributeKey = this.keyForAttribute(key, "deserialize");
+			if (resourceHash[attributeKey] !== void 0) attributes[key] = resourceHash[attributeKey];
+		});
+		return attributes;
+	},
+	/**
+	Returns a relationship formatted as a JSON-API "relationship object".
+	http://jsonapi.org/format/#document-resource-object-relationships
+	@public
+	*/
+	extractRelationship(relationshipModelName, relationshipHash) {
+		if (!relationshipHash) return null;
+		if (relationshipHash && typeof relationshipHash === "object" && !Array.isArray(relationshipHash)) {
+			if (relationshipHash.id) relationshipHash.id = coerceId(relationshipHash.id);
+			const modelClass = this.store.modelFor(relationshipModelName);
+			if (relationshipHash.type && !modelClass.fields.has("type")) relationshipHash.type = this.modelNameFromPayloadKey(relationshipHash.type);
+			return relationshipHash;
+		}
+		return {
+			id: coerceId(relationshipHash),
+			type: dasherize(singularize(relationshipModelName))
+		};
+	},
+	/**
+	Returns a polymorphic relationship formatted as a JSON-API "relationship object".
+	http://jsonapi.org/format/#document-resource-object-relationships
+	`relationshipOptions` is a hash which contains more information about the
+	polymorphic relationship which should be extracted:
+	- `resourceHash` complete hash of the resource the relationship should be
+	extracted from
+	- `relationshipKey` key under which the value for the relationship is
+	extracted from the resourceHash
+	- `relationshipMeta` meta information about the relationship
+	@public
+	*/
+	extractPolymorphicRelationship(relationshipModelName, relationshipHash, relationshipOptions) {
+		return this.extractRelationship(relationshipModelName, relationshipHash);
+	},
+	/**
+	Returns the resource's relationships formatted as a JSON-API "relationships object".
+	http://jsonapi.org/format/#document-resource-object-relationships
+	@public
+	*/
+	extractRelationships(modelClass, resourceHash) {
+		const relationships = {};
+		modelClass.eachRelationship((key, relationshipMeta) => {
+			let relationship = null;
+			const relationshipKey = this.keyForRelationship(key, relationshipMeta.kind, "deserialize");
+			if (resourceHash[relationshipKey] !== void 0) {
+				let data = null;
+				const relationshipHash = resourceHash[relationshipKey];
+				if (relationshipMeta.kind === "belongsTo") {
+					if (relationshipMeta.options.polymorphic) data = this.extractPolymorphicRelationship(relationshipMeta.type, relationshipHash, {
+						key,
+						resourceHash,
+						relationshipMeta
+					});
+					else data = this.extractRelationship(relationshipMeta.type, relationshipHash);
+				} else if (relationshipMeta.kind === "hasMany") {
+					if (relationshipHash) {
+						data = new Array(relationshipHash.length);
+						if (relationshipMeta.options.polymorphic) for (let i = 0, l = relationshipHash.length; i < l; i++) {
+							const item = relationshipHash[i];
+							data[i] = this.extractPolymorphicRelationship(relationshipMeta.type, item, {
+								key,
+								resourceHash,
+								relationshipMeta
+							});
+						}
+						else for (let i = 0, l = relationshipHash.length; i < l; i++) {
+							const item = relationshipHash[i];
+							data[i] = this.extractRelationship(relationshipMeta.type, item);
+						}
+					}
+				}
+				relationship = { data };
+			}
+			const linkKey = this.keyForLink(key, relationshipMeta.kind);
+			if (resourceHash.links && resourceHash.links[linkKey] !== void 0) {
+				const related = resourceHash.links[linkKey];
+				relationship = relationship || {};
+				relationship.links = { related };
+			}
+			if (relationship) relationships[key] = relationship;
+		});
+		return relationships;
+	},
+	/**
+	Dasherizes the model name in the payload
+	@public
+	@return the model's modelName
+	*/
+	modelNameFromPayloadKey(key) {
+		return dasherize(singularize(key));
+	},
+	/**
+	@private
+	*/
+	normalizeRelationships(typeClass, hash) {
+		let payloadKey;
+		if (this.keyForRelationship) typeClass.eachRelationship((key, relationship) => {
+			payloadKey = this.keyForRelationship(key, relationship.kind, "deserialize");
+			if (key === payloadKey) return;
+			if (hash[payloadKey] === void 0) return;
+			hash[key] = hash[payloadKey];
+			delete hash[payloadKey];
+		});
+	},
+	/**
+	@private
+	*/
+	normalizeUsingDeclaredMapping(modelClass, hash) {
+		const attrs = this.attrs;
+		let normalizedKey;
+		let payloadKey;
+		if (attrs) for (const key in attrs) {
+			normalizedKey = payloadKey = this._getMappedKey(key, modelClass);
+			if (hash[payloadKey] === void 0) continue;
+			if (modelClass.attributes.has(key)) normalizedKey = this.keyForAttribute(key, "deserialize");
+			if (modelClass.relationshipsByName.has(key)) normalizedKey = this.keyForRelationship(key, modelClass, "deserialize");
+			if (payloadKey !== normalizedKey) {
+				hash[normalizedKey] = hash[payloadKey];
+				delete hash[payloadKey];
+			}
+		}
+	},
+	/**
+	Looks up the property key that was set by the custom `attr` mapping
+	passed to the serializer.
+	@private
+	*/
+	_getMappedKey(key, modelClass) {
+		const attrs = this.attrs;
+		let mappedKey;
+		if (attrs && attrs[key]) {
+			mappedKey = attrs[key];
+			if (mappedKey.key) mappedKey = mappedKey.key;
+			if (typeof mappedKey === "string") key = mappedKey;
+		}
+		return key;
+	},
+	/**
+	Check attrs.key.serialize property to inform if the `key`
+	can be serialized
+	@private
+	@return true if the key can be serialized
+	*/
+	_canSerialize(key) {
+		const attrs = this.attrs;
+		return !attrs || !attrs[key] || attrs[key].serialize !== false;
+	},
+	/**
+	When attrs.key.serialize is set to true then
+	it takes priority over the other checks and the related
+	attribute/relationship will be serialized
+	@private
+	@return true if the key must be serialized
+	*/
+	_mustSerialize(key) {
+		const attrs = this.attrs;
+		return attrs && attrs[key] && attrs[key].serialize === true;
+	},
+	/**
+	Check if the given hasMany relationship should be serialized
+	By default only many-to-many and many-to-none relationships are serialized.
+	This could be configured per relationship by Serializer's `attrs` object.
+	@public
+	@return true if the hasMany relationship should be serialized
+	*/
+	shouldSerializeHasMany(snapshot, key, relationship) {
+		const relationshipType = determineRelationshipType(this.store, snapshot.modelName, relationship);
+		if (this._mustSerialize(key)) return true;
+		return this._canSerialize(key) && (relationshipType === "manyToNone" || relationshipType === "manyToMany");
+	},
+	/**
+	Called when a record is saved in order to convert the
+	record into JSON.
+	By default, it creates a JSON object with a key for
+	each attribute and belongsTo relationship.
+	For example, consider this model:
+	```js [app/models/comment.js]
+	import Model, { attr, belongsTo } from '@warp-drive/legacy/model';
+	export default class CommentModel extends Model {
+	@attr title;
+	@attr body;
+	@belongsTo('user') author;
+	}
+	```
+	The default serialization would create a JSON object like:
+	```javascript
+	{
+	"title": "Rails is unagi",
+	"body": "Rails? Omakase? O_O",
+	"author": 12
+	}
+	```
+	By default, attributes are passed through as-is, unless
+	you specified an attribute type (`attr('date')`). If
+	you specify a transform, the JavaScript value will be
+	serialized when inserted into the JSON hash.
+	By default, belongs-to relationships are converted into
+	IDs when inserted into the JSON hash.
+	## IDs
+	`serialize` takes an options hash with a single option:
+	`includeId`. If this option is `true`, `serialize` will,
+	by default include the ID in the JSON object it builds.
+	Whether `includeId` is `true` or `false` depends on the
+	adapter and the operation being performed, since it is the
+	adapter that invokes `serialize` and decides which options
+	to pass. For instance, `RESTAdapter` passes `includeId: true`
+	when serializing a record for `createRecord`, but not for
+	`updateRecord`, while `JSONAPIAdapter` passes `includeId: true`
+	for both `createRecord` and `updateRecord`. Refer to the
+	documentation for the adapter and serializer pairing you are
+	using for specifics.
+	## Customization
+	Your server may expect a different JSON format than the
+	built-in serialization format.
+	In that case, you can implement `serialize` yourself and
+	return a JSON hash of your choosing.
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	serialize(snapshot, options) {
+	let json = {
+	POST_TTL: snapshot.attr('title'),
+	POST_BDY: snapshot.attr('body'),
+	POST_CMS: snapshot.hasMany('comments', { ids: true })
+	};
+	if (options.includeId) {
+	json.POST_ID_ = snapshot.id;
+	}
+	return json;
+	}
+	}
+	```
+	## Customizing an App-Wide Serializer
+	If you want to define a serializer for your entire
+	application, you'll probably want to use `eachAttribute`
+	and `eachRelationship` on the record.
+	```js [app/serializers/application.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	import { singularize } from '<app-name>/utils/string-utils';
+	export default class ApplicationSerializer extends JSONSerializer {
+	serialize(snapshot, options) {
+	let json = {};
+	snapshot.eachAttribute((name) => {
+	json[serverAttributeName(name)] = snapshot.attr(name);
+	});
+	snapshot.eachRelationship((name, relationship) => {
+	if (relationship.kind === 'hasMany') {
+	json[serverHasManyName(name)] = snapshot.hasMany(name, { ids: true });
+	}
+	});
+	if (options.includeId) {
+	json.ID_ = snapshot.id;
+	}
+	return json;
+	}
+	}
+	function serverAttributeName(attribute) {
+	return attribute.underscore().toUpperCase();
+	}
+	function serverHasManyName(name) {
+	return serverAttributeName(singularize(name)) + "_IDS";
+	}
+	```
+	This serializer will generate JSON that looks like this:
+	```javascript
+	{
+	"TITLE": "Rails is omakase",
+	"BODY": "Yep. Omakase.",
+	"COMMENT_IDS": [ "1", "2", "3" ]
+	}
+	```
+	## Tweaking the Default JSON
+	If you just want to do some small tweaks on the default JSON,
+	you can call `super.serialize` first and make the tweaks on
+	the returned JSON.
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	serialize(snapshot, options) {
+	let json = super.serialize(...arguments);
+	json.subject = json.title;
+	delete json.title;
+	return json;
+	}
+	}
+	```
+	@public
+	*/
+	serialize(snapshot, options) {
+		const json = {};
+		if (options && options.includeId) {
+			const id = snapshot.id;
+			if (id) json[this.primaryKey] = id;
+		}
+		snapshot.eachAttribute((key, attribute) => {
+			this.serializeAttribute(snapshot, json, key, attribute);
+		});
+		snapshot.eachRelationship((key, relationship) => {
+			if (relationship.kind === "belongsTo") this.serializeBelongsTo(snapshot, json, relationship);
+			else if (relationship.kind === "hasMany") this.serializeHasMany(snapshot, json, relationship);
+		});
+		return json;
+	},
+	/**
+	You can use this method to customize how a serialized record is added to the complete
+	JSON hash to be sent to the server. By default the JSON Serializer does not namespace
+	the payload and just sends the raw serialized JSON object.
+	If your server expects namespaced keys, you should consider using the RESTSerializer.
+	Otherwise you can override this method to customize how the record is added to the hash.
+	The hash property should be modified by reference.
+	For example, your server may expect underscored root objects.
+	```js [app/serializers/application.js]
+	import RESTSerializer from '@warp-drive/legacy/serializer/rest';
+	import { underscoren} from '<app-name>/utils/string-utils';
+	export default class ApplicationSerializer extends RESTSerializer {
+	serializeIntoHash(data, type, snapshot, options) {
+	let root = underscore(type.modelName);
+	data[root] = this.serialize(snapshot, options);
+	}
+	}
+	```
+	@public
+	*/
+	serializeIntoHash(hash, typeClass, snapshot, options) {
+		Object.assign(hash, this.serialize(snapshot, options));
+	},
+	/**
+	`serializeAttribute` can be used to customize how `attr`
+	properties are serialized
+	For example if you wanted to ensure all your attributes were always
+	serialized as properties on an `attributes` object you could
+	write:
+	```js [app/serializers/application.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class ApplicationSerializer extends JSONSerializer {
+	serializeAttribute(snapshot, json, key, attributes) {
+	json.attributes = json.attributes || {};
+	super.serializeAttribute(snapshot, json.attributes, key, attributes);
+	}
+	}
+	```
+	@public
+	*/
+	serializeAttribute(snapshot, json, key, attribute) {
+		if (this._canSerialize(key)) {
+			const type = attribute.type;
+			let value = snapshot.attr(key);
+			if (type) value = this.transformFor(type).serialize(value, attribute.options);
+			const schema = this.store.modelFor(snapshot.modelName);
+			let payloadKey = this._getMappedKey(key, schema);
+			if (payloadKey === key && this.keyForAttribute) payloadKey = this.keyForAttribute(key, "serialize");
+			json[payloadKey] = value;
+		}
+	},
+	/**
+	`serializeBelongsTo` can be used to customize how `belongsTo`
+	properties are serialized.
+	Example
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	serializeBelongsTo(snapshot, json, relationship) {
+	let key = relationship.name;
+	let belongsTo = snapshot.belongsTo(key);
+	key = this.keyForRelationship ? this.keyForRelationship(key, "belongsTo", "serialize") : key;
+	json[key] = !belongsTo ? null : belongsTo.record.toJSON();
+	}
+	}
+	```
+	@public
+	*/
+	serializeBelongsTo(snapshot, json, relationship) {
+		const name = relationship.name;
+		if (this._canSerialize(name)) {
+			const belongsToId = snapshot.belongsTo(name, { id: true });
+			const schema = this.store.modelFor(snapshot.modelName);
+			let payloadKey = this._getMappedKey(name, schema);
+			if (payloadKey === name && this.keyForRelationship) payloadKey = this.keyForRelationship(name, "belongsTo", "serialize");
+			if (!belongsToId) json[payloadKey] = null;
+			else json[payloadKey] = belongsToId;
+			if (relationship.options.polymorphic) this.serializePolymorphicType(snapshot, json, relationship);
+		}
+	},
+	/**
+	`serializeHasMany` can be used to customize how `hasMany`
+	properties are serialized.
+	Example
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	serializeHasMany(snapshot, json, relationship) {
+	let key = relationship.name;
+	if (key === 'comments') {
+	return;
+	} else {
+	super.serializeHasMany(...arguments);
+	}
+	}
+	}
+	```
+	@public
+	*/
+	serializeHasMany(snapshot, json, relationship) {
+		const name = relationship.name;
+		if (this.shouldSerializeHasMany(snapshot, name, relationship)) {
+			const hasMany = snapshot.hasMany(name, { ids: true });
+			if (hasMany !== void 0) {
+				const schema = this.store.modelFor(snapshot.modelName);
+				let payloadKey = this._getMappedKey(name, schema);
+				if (payloadKey === name && this.keyForRelationship) payloadKey = this.keyForRelationship(name, "hasMany", "serialize");
+				json[payloadKey] = hasMany;
+			}
+		}
+	},
+	/**
+	You can use this method to customize how polymorphic objects are
+	serialized. Objects are considered to be polymorphic if
+	`{ polymorphic: true }` is pass as the second argument to the
+	`belongsTo` function.
+	Example
+	```js [app/serializers/comment.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class CommentSerializer extends JSONSerializer {
+	serializePolymorphicType(snapshot, json, relationship) {
+	let key = relationship.name;
+	let belongsTo = snapshot.belongsTo(key);
+	key = this.keyForAttribute ? this.keyForAttribute(key, 'serialize') : key;
+	if (!belongsTo) {
+	json[key + '_type'] = null;
+	} else {
+	json[key + '_type'] = belongsTo.modelName;
+	}
+	}
+	}
+	```
+	@public
+	*/
+	serializePolymorphicType(snapshot, json, relationship) {},
+	/**
+	`extractMeta` is used to deserialize any meta information in the
+	adapter payload. By default Ember Data expects meta information to
+	be located on the `meta` property of the payload object.
+	Example
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	extractMeta(store, typeClass, payload) {
+	if (payload && payload.hasOwnProperty('_pagination')) {
+	let meta = payload._pagination;
+	delete payload._pagination;
+	return meta;
+	}
+	}
+	}
+	```
+	@public
+	*/
+	extractMeta(store, modelClass, payload) {
+		if (payload && payload["meta"] !== void 0) {
+			const meta = payload.meta;
+			delete payload.meta;
+			return meta;
+		}
+	},
+	/**
+	`extractErrors` is used to extract model errors when a call
+	to `Model#save` fails with an `InvalidError`. By default
+	Ember Data expects error information to be located on the `errors`
+	property of the payload object.
+	This serializer expects this `errors` object to be an Array similar
+	to the following, compliant with the https://jsonapi.org/format/#errors specification:
+	```js
+	{
+	"errors": [
+	{
+	"detail": "This username is already taken!",
+	"source": {
+	"pointer": "data/attributes/username"
+	}
+	}, {
+	"detail": "Doesn't look like a valid email.",
+	"source": {
+	"pointer": "data/attributes/email"
+	}
+	}
+	]
+	}
+	```
+	The key `detail` provides a textual description of the problem.
+	Alternatively, the key `title` can be used for the same purpose.
+	The nested keys `source.pointer` detail which specific element
+	of the request data was invalid.
+	Note that JSON-API also allows for object-level errors to be placed
+	in an object with pointer `data`, signifying that the problem
+	cannot be traced to a specific attribute:
+	```javascript
+	{
+	"errors": [
+	{
+	"detail": "Some generic non property error message",
+	"source": {
+	"pointer": "data"
+	}
+	}
+	]
+	}
+	```
+	When turn into a `Errors` object, you can read these errors
+	through the property `base`:
+	```handlebars
+	{{#each @model.errors.base as |error|}}
+	<div class="error">
+	{{error.message}}
+	</div>
+	{{/each}}
+	```
+	Example of alternative implementation, overriding the default
+	behavior to deal with a different format of errors:
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	export default class PostSerializer extends JSONSerializer {
+	extractErrors(store, typeClass, payload, id) {
+	if (payload && typeof payload === 'object' && payload._problems) {
+	payload = payload._problems;
+	this.normalizeErrors(typeClass, payload);
+	}
+	return payload;
+	}
+	}
+	```
+	@public
+	@return json The deserialized errors
+	*/
+	extractErrors(store, typeClass, payload, id) {
+		if (payload && typeof payload === "object" && payload.errors) {
+			const extracted = {};
+			payload.errors.forEach((error) => {
+				if (error.source && error.source.pointer) {
+					let key = error.source.pointer.match(SOURCE_POINTER_REGEXP);
+					if (key) key = key[2];
+					else if (error.source.pointer.search(SOURCE_POINTER_PRIMARY_REGEXP) !== -1) key = PRIMARY_ATTRIBUTE_KEY;
+					if (key) {
+						extracted[key] = extracted[key] || [];
+						extracted[key].push(error.detail || error.title);
+					}
+				}
+			});
+			this.normalizeUsingDeclaredMapping(typeClass, extracted);
+			typeClass.eachAttribute((name) => {
+				const key = this.keyForAttribute(name, "deserialize");
+				if (key !== name && extracted[key] !== void 0) {
+					extracted[name] = extracted[key];
+					delete extracted[key];
+				}
+			});
+			typeClass.eachRelationship((name) => {
+				const key = this.keyForRelationship(name, "deserialize");
+				if (key !== name && extracted[key] !== void 0) {
+					extracted[name] = extracted[key];
+					delete extracted[key];
+				}
+			});
+			return extracted;
+		}
+		return payload;
+	},
+	/**
+	`keyForAttribute` can be used to define rules for how to convert an
+	attribute name in your model to a key in your JSON.
+	Example
+	```js [app/serializers/application.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	import { underscore } from '<app-name>/utils/string-utils';
+	export default class ApplicationSerializer extends JSONSerializer {
+	keyForAttribute(attr, method) {
+	return underscore(attr).toUpperCase();
+	}
+	}
+	```
+	@public
+	*/
+	keyForAttribute(key, method) {
+		return key;
+	},
+	/**
+	`keyForRelationship` can be used to define a custom key when
+	serializing and deserializing relationship properties. By default
+	`JSONSerializer` does not provide an implementation of this method.
+	Example
+	```js [app/serializers/post.js]
+	import { JSONSerializer } from '@warp-drive/legacy/serializer/json';
+	import { underscore } from '<app-name>/utils/string-utils';
+	export default class PostSerializer extends JSONSerializer {
+	keyForRelationship(key, relationship, method) {
+	return `rel_${underscore(key)}`;
+	}
+	}
+	```
+	@public
+	*/
+	keyForRelationship(key, typeClass, method) {
+		return key;
+	},
+	/**
+	`keyForLink` can be used to define a custom key when deserializing link
+	properties.
+	@public
+	*/
+	keyForLink(key, kind) {
+		return key;
+	},
+	/**
+	@private
+	*/
+	transformFor(attributeType, skipAssertion) {
+		return getOwner(this).lookup(`transform:${attributeType}`);
+	}
+});
+
+//#endregion
+export { coerceId as n, inverseForRelationship as r, JSONSerializer as t };
+//# sourceMappingURL=json-BD1kRTfB.js.map