@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

package/dist/unpkg/dev/serializer.js

@@ -1,245 +1,245 @@
-import EmberObject from '@ember/object';
-import * as s from '@ember/service';
-import { a as decorateFieldV2, i as initializeDeferredDecorator } from "./runtime-BPCpkOf1-BKOwiRJp.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-BPCpkOf1-BgO3Lyjx.js";
+import EmberObject from "@ember/object";
+import * as s from "@ember/service";
 
+//#region src/serializer.ts
 /**
-  ## Overview
+## Overview
 
-  :::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 serializer, consider writing a
-    {@link Handler} instead to be used with the {@link RequestManager}
-  :::
+:::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 serializer, consider writing a
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
 
-  In order to properly manage and present your data, WarpDrive
-  needs to understand the structure of data it receives.
+In order to properly manage and present your data, WarpDrive
+needs to understand the structure of data it receives.
 
-  `Serializers` convert data between the server's API format and
-  the format WarpDrive understands.
+`Serializers` convert data between the server's API format and
+the format WarpDrive understands.
 
-  Data received from an API response is **normalized** into
-  [{json:api}](https://jsonapi.org/) (the format used internally
-  by WarpDrive), while data sent to an API is **serialized**
-  into the format the API expects.
+Data received from an API response is **normalized** into
+[{json:api}](https://jsonapi.org/) (the format used internally
+by WarpDrive), while data sent to an API is **serialized**
+into the format the API expects.
 
-  ### Implementing a Serializer
+### Implementing a Serializer
 
-  There are only two required serializer methods, one for
-  normalizing data from the server API format into {json:api}, and
-  another for serializing records via `Snapshots` into the expected
-  server API format.
+There are only two required serializer methods, one for
+normalizing data from the server API format into {json:api}, and
+another for serializing records via `Snapshots` into the expected
+server API format.
 
-  To implement a serializer, export a class that conforms to the structure
-  described by {@link MinimumSerializerInterface}
-  from the `app/serializers/` directory. An example is below.
+To implement a serializer, export a class that conforms to the structure
+described by {@link MinimumSerializerInterface}
+from the `app/serializers/` directory. An example is below.
 
-  ```ts
-  import EmberObject from '@ember/object';
+```ts
+import EmberObject from '@ember/object';
 
-  export default class ApplicationSerializer extends EmberObject {
-    normalizeResponse(store, schema, rawPayload) {
-      return rawPayload;
-    }
+export default class ApplicationSerializer extends EmberObject {
+normalizeResponse(store, schema, rawPayload) {
+return rawPayload;
+}
 
-    serialize(snapshot, options) {
-      const serializedResource = {
-        id: snapshot.id,
-        type: snapshot.modelName,
-        attributes: snapshot.attributes()
-      };
+serialize(snapshot, options) {
+const serializedResource = {
+id: snapshot.id,
+type: snapshot.modelName,
+attributes: snapshot.attributes()
+};
 
-      return serializedResource;
-    }
-  }
- ```
+return serializedResource;
+}
+}
+```
 
 
-  ### Serializer Resolution
+### Serializer Resolution
 
-  `store.serializerFor(name)` will lookup serializers defined in
-  `app/serializers/` and return an instance. If no serializer is found, an
-  error will be thrown.
+`store.serializerFor(name)` will lookup serializers defined in
+`app/serializers/` and return an instance. If no serializer is found, an
+error will be thrown.
 
-  `serializerFor` first attempts to find a serializer with an exact match on `name`,
-  then falls back to checking for the presence of a serializer named `application`.
+`serializerFor` first attempts to find a serializer with an exact match on `name`,
+then falls back to checking for the presence of a serializer named `application`.
 
-  ```ts
-  store.serializerFor('author');
+```ts
+store.serializerFor('author');
 
-  // lookup paths (in order) =>
-  //   app/serializers/author.js
-  //   app/serializers/application.js
-  ```
+// lookup paths (in order) =>
+//   app/serializers/author.js
+//   app/serializers/application.js
+```
 
-  Most requests in `@warp-drive/legacy` are made with respect to a particular `type` (or `modelName`)
-  (e.g., "get me the full collection of **books**" or "get me the **employee** whose id is 37"). We
-  refer to this as the **primary** resource `type`.
+Most requests in `@warp-drive/legacy` are made with respect to a particular `type` (or `modelName`)
+(e.g., "get me the full collection of **books**" or "get me the **employee** whose id is 37"). We
+refer to this as the **primary** resource `type`.
 
-  Typically `serializerFor` will be used to find a serializer with a name matching that of the primary
-  resource `type` for the request, falling back to the `application` serializer for those types that
-  do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy
-  for defining serializers. However, because APIs rarely format payloads per-type but rather
-  per-API-version, this may not be a desired strategy.
+Typically `serializerFor` will be used to find a serializer with a name matching that of the primary
+resource `type` for the request, falling back to the `application` serializer for those types that
+do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy
+for defining serializers. However, because APIs rarely format payloads per-type but rather
+per-API-version, this may not be a desired strategy.
 
-  It is recommended that applications define only a single `application` adapter and serializer
-  where possible.
+It is recommended that applications define only a single `application` adapter and serializer
+where possible.
 
-  If you have multiple API formats and the per-type strategy is not viable, one strategy is to
-  write an `application` adapter and serializer that make use of `options` to specify the desired
-  format when making a request.
+If you have multiple API formats and the per-type strategy is not viable, one strategy is to
+write an `application` adapter and serializer that make use of `options` to specify the desired
+format when making a request.
 
-  ### Using a Serializer
+### Using a Serializer
 
-  Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.
+Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.
 
-  ### Default Serializers
+### Default Serializers
 
-  For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**
-  format the `@warp-drive/legacy/serializer` package contains implementations these applications can
-  extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.
+For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**
+format the `@warp-drive/legacy/serializer` package contains implementations these applications can
+extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.
 
-  Many applications will find writing their own serializer to be more performant and less
-  complex than extending these classes even when their API format is very close to that expected
-  by these serializers.
+Many applications will find writing their own serializer to be more performant and less
+complex than extending these classes even when their API format is very close to that expected
+by these serializers.
 
-  It is recommended that apps write their own serializer to best suit the needs of their API and
-  application.
+It is recommended that apps write their own serializer to best suit the needs of their API and
+application.
 
-  @module
+@module
 */
 const service = s.service ?? s.inject;
-
 /**
-  > ⚠️ CAUTION you likely want the docs for {@link MinimumSerializerInterface}
-  > as extending this abstract class is unnecessary.
+> ⚠️ CAUTION you likely want the docs for {@link MinimumSerializerInterface}
+> as extending this abstract class is unnecessary.
 
-  `Serializer` is an abstract base class that you may override in your
-  application to customize it for your backend. The minimum set of methods
-  that you should implement is:
+`Serializer` is an abstract base class that you may override in your
+application to customize it for your backend. The minimum set of methods
+that you should implement is:
 
-    * `normalizeResponse()`
-    * `serialize()`
+* `normalizeResponse()`
+* `serialize()`
 
-  And you can optionally override the following methods:
+And you can optionally override the following methods:
 
-    * `normalize()`
+* `normalize()`
 
-  For an example implementation, see the included {@link JSONSerializer}.
+For an example implementation, see the included {@link JSONSerializer}.
 
-  @class Serializer
-  @public
+@class Serializer
+@public
 */
-
-class Serializer extends EmberObject {
-  static {
-    decorateFieldV2(this.prototype, "store", [service]);
-  }
-  #store = (initializeDeferredDecorator(this, "store"), void 0);
-  /**
-    The `store` property is the application's `store` that contains
-    all records. It can be used to look up serializers for other model
-    types that may be nested inside the payload response.
-     Example:
-     ```js
-    Serializer.extend({
-      extractRelationship(relationshipModelName, relationshipHash) {
-        let modelClass = this.store.modelFor(relationshipModelName);
-        let relationshipSerializer = this.store.serializerFor(relationshipModelName);
-        return relationshipSerializer.normalize(modelClass, relationshipHash);
-      }
-    });
-    ```
-     @public
-  */
-  /**
-    The `normalizeResponse` method is used to normalize a payload from the
-    server to a JSON-API Document.
-     http://jsonapi.org/format/#document-structure
-     Example:
-     ```js
-    Serializer.extend({
-      normalizeResponse(store, primaryModelClass, payload, id, requestType) {
-        if (requestType === 'findRecord') {
-          return this.normalize(primaryModelClass, payload);
-        } else {
-          return payload.reduce(function(documentHash, item) {
-            let { data, included } = this.normalize(primaryModelClass, item);
-            documentHash.included.push(...included);
-            documentHash.data.push(data);
-            return documentHash;
-          }, { data: [], included: [] })
-        }
-      }
-    });
-    ```
-     @since 1.13.0
-    @public
-    @param {Store} store
-    @param {Model} primaryModelClass
-    @param {Object} payload
-    @param {String|Number} id
-    @param {String} requestType
-    @return {Object} JSON-API Document
-  */
-
-  /**
-    The `serialize` method is used when a record is saved in order to convert
-    the record into the form that your external data source expects.
-     `serialize` takes an optional `options` hash with a single option:
-     - `includeId`: If this is `true`, `serialize` should include the ID
-      in the serialized object it builds.
-     Example:
-     ```js
-    Serializer.extend({
-      serialize(snapshot, options) {
-        let json = {
-          id: snapshot.id
-        };
-         snapshot.eachAttribute((key, attribute) => {
-          json[key] = snapshot.attr(key);
-        });
-         snapshot.eachRelationship((key, relationship) => {
-          if (relationship.kind === 'belongsTo') {
-            json[key] = snapshot.belongsTo(key, { id: true });
-          } else if (relationship.kind === 'hasMany') {
-            json[key] = snapshot.hasMany(key, { ids: true });
-          }
-        });
-         return json;
-      },
-    });
-    ```
-     @public
-    @param {Snapshot} snapshot
-    @param {Object} [options]
-    @return {Object}
-  */
-
-  /**
-    The `normalize` method is used to convert a payload received from your
-    external data source into the normalized form `store.push()` expects. You
-    should override this method, munge the hash and return the normalized
-    payload.
-     Example:
-     ```js
-    Serializer.extend({
-      normalize(modelClass, resourceHash) {
-        let data = {
-          id:            resourceHash.id,
-          type:          modelClass.modelName,
-          attributes:    resourceHash
-        };
-        return { data: data };
-      }
-    })
-    ```
-     @public
-    @param _typeClass - the model class the hash is being normalized for
-    @param hash - the raw payload hash to normalize
-    @return the normalized resource document
-  */
-  normalize(_typeClass, hash) {
-    return hash;
-  }
-}
-export { Serializer };
+var Serializer = class extends EmberObject {
+	static {
+		decorateFieldV2(this.prototype, "store", [service]);
+	}
+	#store = (initializeDeferredDecorator(this, "store"), void 0);
+	/**
+	The `store` property is the application's `store` that contains
+	all records. It can be used to look up serializers for other model
+	types that may be nested inside the payload response.
+	Example:
+	```js
+	Serializer.extend({
+	extractRelationship(relationshipModelName, relationshipHash) {
+	let modelClass = this.store.modelFor(relationshipModelName);
+	let relationshipSerializer = this.store.serializerFor(relationshipModelName);
+	return relationshipSerializer.normalize(modelClass, relationshipHash);
+	}
+	});
+	```
+	@public
+	*/
+	/**
+	The `normalizeResponse` method is used to normalize a payload from the
+	server to a JSON-API Document.
+	http://jsonapi.org/format/#document-structure
+	Example:
+	```js
+	Serializer.extend({
+	normalizeResponse(store, primaryModelClass, payload, id, requestType) {
+	if (requestType === 'findRecord') {
+	return this.normalize(primaryModelClass, payload);
+	} else {
+	return payload.reduce(function(documentHash, item) {
+	let { data, included } = this.normalize(primaryModelClass, item);
+	documentHash.included.push(...included);
+	documentHash.data.push(data);
+	return documentHash;
+	}, { data: [], included: [] })
+	}
+	}
+	});
+	```
+	@since 1.13.0
+	@public
+	@param {Store} store
+	@param {Model} primaryModelClass
+	@param {Object} payload
+	@param {String|Number} id
+	@param {String} requestType
+	@return {Object} JSON-API Document
+	*/
+	/**
+	The `serialize` method is used when a record is saved in order to convert
+	the record into the form that your external data source expects.
+	`serialize` takes an optional `options` hash with a single option:
+	- `includeId`: If this is `true`, `serialize` should include the ID
+	in the serialized object it builds.
+	Example:
+	```js
+	Serializer.extend({
+	serialize(snapshot, options) {
+	let json = {
+	id: snapshot.id
+	};
+	snapshot.eachAttribute((key, attribute) => {
+	json[key] = snapshot.attr(key);
+	});
+	snapshot.eachRelationship((key, relationship) => {
+	if (relationship.kind === 'belongsTo') {
+	json[key] = snapshot.belongsTo(key, { id: true });
+	} else if (relationship.kind === 'hasMany') {
+	json[key] = snapshot.hasMany(key, { ids: true });
+	}
+	});
+	return json;
+	},
+	});
+	```
+	@public
+	@param {Snapshot} snapshot
+	@param {Object} [options]
+	@return {Object}
+	*/
+	/**
+	The `normalize` method is used to convert a payload received from your
+	external data source into the normalized form `store.push()` expects. You
+	should override this method, munge the hash and return the normalized
+	payload.
+	Example:
+	```js
+	Serializer.extend({
+	normalize(modelClass, resourceHash) {
+	let data = {
+	id:            resourceHash.id,
+	type:          modelClass.modelName,
+	attributes:    resourceHash
+	};
+	return { data: data };
+	}
+	})
+	```
+	@public
+	@param _typeClass - the model class the hash is being normalized for
+	@param hash - the raw payload hash to normalize
+	@return the normalized resource document
+	*/
+	normalize(_typeClass, hash) {
+		return hash;
+	}
+};
+
+//#endregion
+export { Serializer };
+//# sourceMappingURL=serializer.js.map

package/dist/unpkg/dev/serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","names":["EmberObject","s","g","i","service","inject","Serializer","prototype","store","void 0","normalize","_typeClass","hash"],"sources":["../../../src/serializer.ts"],"sourcesContent":["/**\n  ## Overview\n\n  :::danger\n    ⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.\n    If starting a new app or thinking of implementing a new serializer, consider writing a\n    {@link Handler} instead to be used with the {@link RequestManager}\n  :::\n\n  In order to properly manage and present your data, WarpDrive\n  needs to understand the structure of data it receives.\n\n  `Serializers` convert data between the server's API format and\n  the format WarpDrive understands.\n\n  Data received from an API response is **normalized** into\n  [{json:api}](https://jsonapi.org/) (the format used internally\n  by WarpDrive), while data sent to an API is **serialized**\n  into the format the API expects.\n\n  ### Implementing a Serializer\n\n  There are only two required serializer methods, one for\n  normalizing data from the server API format into {json:api}, and\n  another for serializing records via `Snapshots` into the expected\n  server API format.\n\n  To implement a serializer, export a class that conforms to the structure\n  described by {@link MinimumSerializerInterface}\n  from the `app/serializers/` directory. An example is below.\n\n  ```ts\n  import EmberObject from '@ember/object';\n\n  export default class ApplicationSerializer extends EmberObject {\n    normalizeResponse(store, schema, rawPayload) {\n      return rawPayload;\n    }\n\n    serialize(snapshot, options) {\n      const serializedResource = {\n        id: snapshot.id,\n        type: snapshot.modelName,\n        attributes: snapshot.attributes()\n      };\n\n      return serializedResource;\n    }\n  }\n ```\n\n\n  ### Serializer Resolution\n\n  `store.serializerFor(name)` will lookup serializers defined in\n  `app/serializers/` and return an instance. If no serializer is found, an\n  error will be thrown.\n\n  `serializerFor` first attempts to find a serializer with an exact match on `name`,\n  then falls back to checking for the presence of a serializer named `application`.\n\n  ```ts\n  store.serializerFor('author');\n\n  // lookup paths (in order) =>\n  //   app/serializers/author.js\n  //   app/serializers/application.js\n  ```\n\n  Most requests in `@warp-drive/legacy` are made with respect to a particular `type` (or `modelName`)\n  (e.g., \"get me the full collection of **books**\" or \"get me the **employee** whose id is 37\"). We\n  refer to this as the **primary** resource `type`.\n\n  Typically `serializerFor` will be used to find a serializer with a name matching that of the primary\n  resource `type` for the request, falling back to the `application` serializer for those types that\n  do not have a defined serializer. This is often described as a `per-model` or `per-type` strategy\n  for defining serializers. However, because APIs rarely format payloads per-type but rather\n  per-API-version, this may not be a desired strategy.\n\n  It is recommended that applications define only a single `application` adapter and serializer\n  where possible.\n\n  If you have multiple API formats and the per-type strategy is not viable, one strategy is to\n  write an `application` adapter and serializer that make use of `options` to specify the desired\n  format when making a request.\n\n  ### Using a Serializer\n\n  Any serializer in `app/serializers/` can be looked up by `name` using `store.serializerFor(name)`.\n\n  ### Default Serializers\n\n  For applications whose APIs are *very close to* or *exactly* the **REST** format or **JSON:API**\n  format the `@warp-drive/legacy/serializer` package contains implementations these applications can\n  extend. It also contains a simple `JSONSerializer` for serializing to/from very basic JSON objects.\n\n  Many applications will find writing their own serializer to be more performant and less\n  complex than extending these classes even when their API format is very close to that expected\n  by these serializers.\n\n  It is recommended that apps write their own serializer to best suit the needs of their API and\n  application.\n\n  @module\n*/\nimport EmberObject from '@ember/object';\nimport * as s from '@ember/service';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { RequestManager, Store } from '@warp-drive/core';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { Handler } from '@warp-drive/core/request';\nimport type { ModelSchema } from '@warp-drive/core/types';\nimport type { EmptyResourceDocument, SingleResourceDocument } from '@warp-drive/core/types/spec/json-api-raw';\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { MinimumSerializerInterface } from './compat';\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nimport type { JSONSerializer } from './serializer/json';\n\nconst service = s.service ?? s.inject;\n\n/**\n  > ⚠️ CAUTION you likely want the docs for {@link MinimumSerializerInterface}\n  > as extending this abstract class is unnecessary.\n\n  `Serializer` is an abstract base class that you may override in your\n  application to customize it for your backend. The minimum set of methods\n  that you should implement is:\n\n    * `normalizeResponse()`\n    * `serialize()`\n\n  And you can optionally override the following methods:\n\n    * `normalize()`\n\n  For an example implementation, see the included {@link JSONSerializer}.\n\n  @class Serializer\n  @public\n*/\n\nexport class Serializer extends EmberObject {\n  /**\n    The `store` property is the application's `store` that contains\n    all records. It can be used to look up serializers for other model\n    types that may be nested inside the payload response.\n\n    Example:\n\n    ```js\n    Serializer.extend({\n      extractRelationship(relationshipModelName, relationshipHash) {\n        let modelClass = this.store.modelFor(relationshipModelName);\n        let relationshipSerializer = this.store.serializerFor(relationshipModelName);\n        return relationshipSerializer.normalize(modelClass, relationshipHash);\n      }\n    });\n    ```\n\n    @public\n  */\n  @service declare store: Store;\n\n  /**\n    The `normalizeResponse` method is used to normalize a payload from the\n    server to a JSON-API Document.\n\n    http://jsonapi.org/format/#document-structure\n\n    Example:\n\n    ```js\n    Serializer.extend({\n      normalizeResponse(store, primaryModelClass, payload, id, requestType) {\n        if (requestType === 'findRecord') {\n          return this.normalize(primaryModelClass, payload);\n        } else {\n          return payload.reduce(function(documentHash, item) {\n            let { data, included } = this.normalize(primaryModelClass, item);\n            documentHash.included.push(...included);\n            documentHash.data.push(data);\n            return documentHash;\n          }, { data: [], included: [] })\n        }\n      }\n    });\n    ```\n\n    @since 1.13.0\n    @public\n    @param {Store} store\n    @param {Model} primaryModelClass\n    @param {Object} payload\n    @param {String|Number} id\n    @param {String} requestType\n    @return {Object} JSON-API Document\n  */\n\n  /**\n    The `serialize` method is used when a record is saved in order to convert\n    the record into the form that your external data source expects.\n\n    `serialize` takes an optional `options` hash with a single option:\n\n    - `includeId`: If this is `true`, `serialize` should include the ID\n      in the serialized object it builds.\n\n    Example:\n\n    ```js\n    Serializer.extend({\n      serialize(snapshot, options) {\n        let json = {\n          id: snapshot.id\n        };\n\n        snapshot.eachAttribute((key, attribute) => {\n          json[key] = snapshot.attr(key);\n        });\n\n        snapshot.eachRelationship((key, relationship) => {\n          if (relationship.kind === 'belongsTo') {\n            json[key] = snapshot.belongsTo(key, { id: true });\n          } else if (relationship.kind === 'hasMany') {\n            json[key] = snapshot.hasMany(key, { ids: true });\n          }\n        });\n\n        return json;\n      },\n    });\n    ```\n\n    @public\n    @param {Snapshot} snapshot\n    @param {Object} [options]\n    @return {Object}\n  */\n\n  /**\n    The `normalize` method is used to convert a payload received from your\n    external data source into the normalized form `store.push()` expects. You\n    should override this method, munge the hash and return the normalized\n    payload.\n\n    Example:\n\n    ```js\n    Serializer.extend({\n      normalize(modelClass, resourceHash) {\n        let data = {\n          id:            resourceHash.id,\n          type:          modelClass.modelName,\n          attributes:    resourceHash\n        };\n        return { data: data };\n      }\n    })\n    ```\n\n    @public\n    @param _typeClass - the model class the hash is being normalized for\n    @param hash - the raw payload hash to normalize\n    @return the normalized resource document\n  */\n  normalize(_typeClass: ModelSchema, hash: Record<string, unknown>): SingleResourceDocument | EmptyResourceDocument {\n    return hash as unknown as SingleResourceDocument;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwHA,MAAMI,UAAUH,EAAEG,WAAWH,EAAEI;;;;;;;;;;;;;;;;;;;;;AAuB/B,IAAaC,aAAb,cAAgCN,YAAY;CAAA;EAAAE,gBAAA,KAAAK,WAAA,SAAA,CAoBzCH,OAAO,CAAA;CAAA;CAAA,UAAAD,4BAAA,MAAA,OAAA,GAAAM,KAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwGRC,UAAUC,YAAyBC,MAA+E;EAChH,OAAOA;CACT;AACF"}