@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.17

package/declarations/serializer.d.ts

@@ -1,258 +1,257 @@
 /**
-  ## Overview
+## Overview
 
-  <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
-  <p>
-    ⚠️ <strong>This is LEGACY documentation</strong> 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
-    <a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
-  </p>
-  </blockquote>
+<blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
+<p>
+⚠️ <strong>This is LEGACY documentation</strong> 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
+<a href="/ember-data/release/classes/%3CInterface%3E%20Handler">Handler</a> instead to be used with the <a href="https://github.com/emberjs/data/tree/main/packages/request#readme">RequestManager</a>
+</p>
+</blockquote>
 
-  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 `@ember-data/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 `@ember-data/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
 */
-import EmberObject from '@ember/object';
-import type { Store } from '@warp-drive/core';
-import type { ModelSchema } from '@warp-drive/core/types';
-import type { EmptyResourceDocument, SingleResourceDocument } from '@warp-drive/core/types/spec/json-api-raw';
+import EmberObject from "@ember/object";
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import type { EmptyResourceDocument, SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
 /**
-  > ⚠️ 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
-  [JSONSerializer](JSONSerializer), the included JSON serializer.
+For an example implementation, see
+[JSONSerializer](JSONSerializer), the included JSON serializer.
 
-  @class Serializer
-  @public
+@class Serializer
+@public
 */
 export declare class Serializer extends EmberObject {
-    store: Store;
-    /**
-      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);
-        }
-      });
-      ```
-  
-      @property store
-      @type {Store}
-      @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 {Model} typeClass
-      @param {Object} hash
-      @return {Object}
-    */
-    normalize(_typeClass: ModelSchema, hash: Record<string, unknown>): SingleResourceDocument | EmptyResourceDocument;
+	store: Store;
+	/**
+	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);
+	}
+	});
+	```
+	
+	@property store
+	@type {Store}
+	@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 {Model} typeClass
+	@param {Object} hash
+	@return {Object}
+	*/
+	normalize(_typeClass: ModelSchema, hash: Record<string, unknown>): SingleResourceDocument | EmptyResourceDocument;
 }
-//# sourceMappingURL=serializer.d.ts.map

package/dist/{-private-DFfBszo5.js → -private-CKrP0ogQ.js}

@@ -129,7 +129,7 @@ class SnapshotRecordArray {
     }
     ```
      @public
-    @return {Array} Array of snapshots
+    @return Array of snapshots
   */
   snapshots() {
     if (this._snapshots !== null) {

package/dist/adapter/-private.js

@@ -1 +1 @@
-export { d as determineBodyPromise, g as fetch, p as parseResponseHeaders, b as serializeIntoHash, s as serializeQueryParams, a as setupFastboot } from "../serialize-into-hash-BxfqWC8u.js";
+export { d as determineBodyPromise, g as fetch, p as parseResponseHeaders, b as serializeIntoHash, s as serializeQueryParams, a as setupFastboot } from "../serialize-into-hash-Bp58npke.js";

package/dist/adapter/error.js

@@ -1,15 +1,23 @@
 import { getOrSetGlobal } from '@warp-drive/core/types/-private';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
+
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
 function _AdapterError(errors, message = 'Adapter operation failed') {
   this.isAdapterError = true;
   const error = Error.call(this, message);
   if (error) {
     this.stack = error.stack;
+    // @ts-expect-error untyped
     this.description = error.description;
+    // @ts-expect-error untyped
     this.fileName = error.fileName;
+    // @ts-expect-error untyped
     this.lineNumber = error.lineNumber;
     this.message = error.message;
     this.name = error.name;
+    // @ts-expect-error untyped
     this.number = error.number;
   }
   this.errors = errors || [{
@@ -37,6 +45,7 @@ function extend(ParentErrorClass, defaultMessage) {
     })(Array.isArray(errors || [])) : {};
     ParentErrorClass.call(this, errors, message || defaultMessage);
   };
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
   ErrorClass.prototype = Object.create(ParentErrorClass.prototype);
   ErrorClass.extend = extendFn(ErrorClass);
   return ErrorClass;
@@ -102,6 +111,7 @@ function extend(ParentErrorClass, defaultMessage) {
   @public
 */
 // TODO @deprecate extractError documentation
+
 const InvalidError = getOrSetGlobal('InvalidError', extend(AdapterError, 'The adapter rejected the commit because it was invalid'));
 InvalidError.prototype.code = 'InvalidError';
 
@@ -133,6 +143,7 @@ InvalidError.prototype.code = 'InvalidError';
   @class TimeoutError
   @public
 */
+
 const TimeoutError = getOrSetGlobal('TimeoutError', extend(AdapterError, 'The adapter operation timed out'));
 TimeoutError.prototype.code = 'TimeoutError';
 
@@ -145,6 +156,7 @@ TimeoutError.prototype.code = 'TimeoutError';
   @class AbortError
   @public
 */
+
 const AbortError = getOrSetGlobal('AbortError', extend(AdapterError, 'The adapter operation was aborted'));
 AbortError.prototype.code = 'AbortError';
 
@@ -177,6 +189,7 @@ AbortError.prototype.code = 'AbortError';
   @class UnauthorizedError
   @public
 */
+
 const UnauthorizedError = getOrSetGlobal('UnauthorizedError', extend(AdapterError, 'The adapter operation is unauthorized'));
 UnauthorizedError.prototype.code = 'UnauthorizedError';
 
@@ -190,6 +203,7 @@ UnauthorizedError.prototype.code = 'UnauthorizedError';
   @class ForbiddenError
   @public
 */
+
 const ForbiddenError = getOrSetGlobal('ForbiddenError', extend(AdapterError, 'The adapter operation is forbidden'));
 ForbiddenError.prototype.code = 'ForbiddenError';
 
@@ -225,6 +239,7 @@ ForbiddenError.prototype.code = 'ForbiddenError';
   @class NotFoundError
   @public
 */
+
 const NotFoundError = getOrSetGlobal('NotFoundError', extend(AdapterError, 'The adapter could not find the resource'));
 NotFoundError.prototype.code = 'NotFoundError';
 
@@ -238,6 +253,7 @@ NotFoundError.prototype.code = 'NotFoundError';
   @class ConflictError
   @public
 */
+
 const ConflictError = getOrSetGlobal('ConflictError', extend(AdapterError, 'The adapter operation failed due to a conflict'));
 ConflictError.prototype.code = 'ConflictError';
 
@@ -249,6 +265,7 @@ ConflictError.prototype.code = 'ConflictError';
   @class ServerError
   @public
 */
+
 const ServerError = getOrSetGlobal('ServerError', extend(AdapterError, 'The adapter operation failed due to a server error'));
 ServerError.prototype.code = 'ServerError';
 export { AbortError, AdapterError, ConflictError, ForbiddenError, InvalidError, NotFoundError, ServerError, TimeoutError, UnauthorizedError };

package/dist/adapter/json-api.js

@@ -1,7 +1,7 @@
 import { dasherize, pluralize } from '@warp-drive/utilities/string';
 import '@ember/debug';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { b as serializeIntoHash } from "../serialize-into-hash-BxfqWC8u.js";
+import { b as serializeIntoHash } from "../serialize-into-hash-Bp58npke.js";
 import { RESTAdapter } from './rest.js';
 class JSONAPIAdapter extends RESTAdapter {
   _defaultContentType = 'application/vnd.api+json';

package/dist/adapter/rest.js

@@ -2,7 +2,7 @@ import { getOwner } from '@ember/application';
 import { warn } from '@ember/debug';
 import { computed } from '@ember/object';
 import { Adapter, BuildURLMixin } from '../adapter.js';
-import { b as serializeIntoHash, d as determineBodyPromise, g as getFetchFunction, s as serializeQueryParams, p as parseResponseHeaders } from "../serialize-into-hash-BxfqWC8u.js";
+import { b as serializeIntoHash, d as determineBodyPromise, g as getFetchFunction, s as serializeQueryParams, p as parseResponseHeaders } from "../serialize-into-hash-Bp58npke.js";
 import { InvalidError, ServerError, ConflictError, NotFoundError, ForbiddenError, UnauthorizedError, AdapterError, TimeoutError, AbortError } from './error.js';
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 import { d as decorateMethodV2 } from "../runtime-BPCpkOf1-BKOwiRJp.js";
@@ -11,6 +11,8 @@ import { d as decorateMethodV2 } from "../runtime-BPCpkOf1-BKOwiRJp.js";
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
+const AdapterWithBuildURLMixin = Adapter.extend(BuildURLMixin);
+
 /**
  * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
   <p>
@@ -238,7 +240,7 @@ import { d as decorateMethodV2 } from "../runtime-BPCpkOf1-BKOwiRJp.js";
   @constructor
   @uses BuildURLMixin
 */
-class RESTAdapter extends Adapter.extend(BuildURLMixin) {
+class RESTAdapter extends AdapterWithBuildURLMixin {
   /**
     This property allows ajax to still be used instead when `false`.
      @property useFetch
@@ -600,11 +602,6 @@ class RESTAdapter extends Adapter.extend(BuildURLMixin) {
      * Links beginning with a single `/` will have the current adapter's `host` value prepended to it.
      * Links with no beginning `/` will have a parentURL prepended to it, via the current adapter's `buildURL`.
      @public
-    @param {Store} store
-    @param {Snapshot} snapshot
-    @param {String} url
-    @param {Object} relationship meta object describing the relationship
-    @return {Promise} promise
   */
   findBelongsTo(store, snapshot, url, relationship) {
     const id = snapshot.id;
@@ -779,6 +776,7 @@ class RESTAdapter extends Adapter.extend(BuildURLMixin) {
     if (this.isSuccess(status, headers, payload)) {
       return payload;
     } else if (this.isInvalid(status, headers, payload)) {
+      // @ts-expect-error needs cast to JsonApiError
       return new InvalidError(typeof payload === 'object' && 'errors' in payload ? payload.errors : undefined);
     }
     const errors = this.normalizeErrorResponse(status, headers, payload);