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

package/declarations/adapter/-private/build-url-mixin.d.ts

@@ -1,34 +1,46 @@
-import Mixin from '@ember/object/mixin';
-import type { Snapshot, SnapshotRecordArray } from '../../compat/-private.ts';
+import Mixin from "@ember/object/mixin";
+import type { Snapshot, SnapshotRecordArray } from "../../compat/-private.js";
+/*
+The structure of this file is such because typing Mixins is hard. Here we've structured it in
+such a way as to maximize the type information that a consumer can utilize. There are simpler
+ways to type a mixin but we would not be able to provide the nice overload signature for buildURL
+*/
+// the interface must fully declare the function signatures that the individual functions
+// will also declare. If instead we try to keep them in sync by doing something like
+// `interface BuildURLMixin { buildURL: typeof buildURL }`
+// then an extending class overwriting one of the methods will break because typescript
+// thinks it is a switch from an instance prop (that is a method) to an instance method.
 export interface BuildURLMixin {
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: 'findRecord'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: SnapshotRecordArray, requestType: 'findAll'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: null, requestType: 'query', query: Record<string, unknown>): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: null, requestType: 'queryRecord', query: Record<string, unknown>): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string[], snapshot: Snapshot[], requestType: 'findMany'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: 'findHasMany'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: 'findBelongsTo'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string | null, snapshot: Snapshot, requestType: 'createRecord'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: 'updateRecord'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: 'deleteRecord'): string;
-    buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot): string;
-    _buildURL(this: MixtBuildURLMixin, modelName: string | null | undefined, id?: string | null): string;
-    urlForFindRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
-    urlForFindAll(this: MixtBuildURLMixin, modelName: string, snapshots: SnapshotRecordArray): string;
-    urlForQueryRecord(this: MixtBuildURLMixin, query: Record<string, unknown>, modelName: string): string;
-    urlForQuery(this: MixtBuildURLMixin, query: Record<string, unknown>, modelName: string): string;
-    urlForFindMany(this: MixtBuildURLMixin, ids: string[], modelName: string, snapshots: Snapshot[]): string;
-    urlForFindHasMany(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
-    urlForFindBelongsTo(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
-    urlForCreateRecord(this: MixtBuildURLMixin, modelName: string, snapshot: Snapshot): string;
-    urlForUpdateRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
-    urlForDeleteRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
-    urlPrefix(this: MixtBuildURLMixin, path?: string | null, parentURL?: string): string;
-    pathForType(this: MixtBuildURLMixin, modelName: string): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findRecord"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: SnapshotRecordArray, requestType: "findAll"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: null, requestType: "query", query: Record<string, unknown>): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: null, requestType: "queryRecord", query: Record<string, unknown>): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string[], snapshot: Snapshot[], requestType: "findMany"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findHasMany"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findBelongsTo"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string | null, snapshot: Snapshot, requestType: "createRecord"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "updateRecord"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "deleteRecord"): string;
+	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot): string;
+	_buildURL(this: MixtBuildURLMixin, modelName: string | null | undefined, id?: string | null): string;
+	urlForFindRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+	urlForFindAll(this: MixtBuildURLMixin, modelName: string, snapshots: SnapshotRecordArray): string;
+	urlForQueryRecord(this: MixtBuildURLMixin, query: Record<string, unknown>, modelName: string): string;
+	urlForQuery(this: MixtBuildURLMixin, query: Record<string, unknown>, modelName: string): string;
+	urlForFindMany(this: MixtBuildURLMixin, ids: string[], modelName: string, snapshots: Snapshot[]): string;
+	urlForFindHasMany(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+	urlForFindBelongsTo(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+	urlForCreateRecord(this: MixtBuildURLMixin, modelName: string, snapshot: Snapshot): string;
+	urlForUpdateRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+	urlForDeleteRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+	urlPrefix(this: MixtBuildURLMixin, path?: string | null, parentURL?: string): string;
+	pathForType(this: MixtBuildURLMixin, modelName: string): string;
 }
+// prevents the final constructed object from needing to add
+// host and namespace which are provided by the final consuming
+// class to the prototype which can result in overwrite errors
 export interface MixtBuildURLMixin extends BuildURLMixin {
-    host: string | null;
-    namespace: string | null;
+	host: string | null;
+	namespace: string | null;
 }
 export declare const BuildURLMixin: Mixin;
-//# sourceMappingURL=build-url-mixin.d.ts.map

package/declarations/adapter/-private/fastboot-interface.d.ts

@@ -1,9 +1,8 @@
 export interface Request {
-    protocol: string;
-    host: string;
+	protocol: string;
+	host: string;
 }
 export interface FastBoot {
-    isFastBoot: boolean;
-    request: Request;
+	isFastBoot: boolean;
+	request: Request;
 }
-//# sourceMappingURL=fastboot-interface.d.ts.map

package/declarations/adapter/-private/utils/continue-on-reject.d.ts

@@ -1,8 +1,7 @@
 /**
- * A utility function that returns a promise that resolves
- * even when the source promise rejects.
- *
- * @internal
- */
+* A utility function that returns a promise that resolves
+* even when the source promise rejects.
+*
+* @internal
+*/
 export declare function continueOnReject<T>(promise: Promise<T>): Promise<T>;
-//# sourceMappingURL=continue-on-reject.d.ts.map

package/declarations/adapter/-private/utils/determine-body-promise.d.ts

@@ -1,5 +1,4 @@
-import type { RequestData } from '../../rest.ts';
+import type { RequestData } from "../../rest.js";
 type Payload = Error | Record<string, unknown> | unknown[] | string | undefined;
 export declare function determineBodyPromise(response: Response, requestData: RequestData): Promise<Payload>;
 export {};
-//# sourceMappingURL=determine-body-promise.d.ts.map

package/declarations/adapter/-private/utils/fetch.d.ts

@@ -1,9 +1,8 @@
 type FetchFunction = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
 type MockRequest = {
-    protocol?: string;
-    get(key: string): string | undefined;
+	protocol?: string;
+	get(key: string): string | undefined;
 };
 export declare function getFetchFunction(): FetchFunction;
 export declare function setupFastboot(fastBootRequest: MockRequest): void;
 export {};
-//# sourceMappingURL=fetch.d.ts.map

package/declarations/adapter/-private/utils/parse-response-headers.d.ts

@@ -1,2 +1 @@
 export declare function parseResponseHeaders(headersString: string): Record<string, string>;
-//# sourceMappingURL=parse-response-headers.d.ts.map

package/declarations/adapter/-private/utils/serialize-into-hash.d.ts

@@ -1,7 +1,6 @@
-import type { Store } from '@warp-drive/core';
-import type { ModelSchema } from '@warp-drive/core/types';
-import { type Snapshot } from '../../../compat/-private.ts';
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import { type Snapshot } from "../../../compat/-private.js";
 export declare function serializeIntoHash(store: Store, modelClass: ModelSchema, snapshot: Snapshot, options?: {
-    includeId?: boolean;
-}): {};
-//# sourceMappingURL=serialize-into-hash.d.ts.map
+	includeId?: boolean;
+}): object;

package/declarations/adapter/-private/utils/serialize-query-params.d.ts

@@ -1,6 +1,9 @@
 interface PlainObject {
-    [key: string]: string | PlainObject | PlainObject[] | string[];
+	[key: string]: string | PlainObject | PlainObject[] | string[];
 }
+/*
+* Helper function that turns the data/body of a request into a query param string.
+* This is directly copied from jQuery.param.
+*/
 export declare function serializeQueryParams(queryParamsObject: PlainObject | string): string;
 export {};
-//# sourceMappingURL=serialize-query-params.d.ts.map

package/declarations/adapter/-private.d.ts

@@ -1,6 +1,5 @@
-export { parseResponseHeaders } from './-private/utils/parse-response-headers.ts';
-export { determineBodyPromise } from './-private/utils/determine-body-promise.ts';
-export { serializeQueryParams } from './-private/utils/serialize-query-params.ts';
-export { getFetchFunction as fetch, setupFastboot } from './-private/utils/fetch.ts';
-export { serializeIntoHash } from './-private/utils/serialize-into-hash.ts';
-//# sourceMappingURL=-private.d.ts.map
+export { parseResponseHeaders } from "./-private/utils/parse-response-headers.js";
+export { determineBodyPromise } from "./-private/utils/determine-body-promise.js";
+export { serializeQueryParams } from "./-private/utils/serialize-query-params.js";
+export { getFetchFunction as fetch, setupFastboot } from "./-private/utils/fetch.js";
+export { serializeIntoHash } from "./-private/utils/serialize-into-hash.js";

package/declarations/adapter/error.d.ts

@@ -1,188 +1,216 @@
-export const AdapterError: typeof _AdapterError;
-export class InvalidError {
-    private constructor();
-    code: string;
+import type { JsonApiError } from "@warp-drive/core/store/-types/q/record-data-json-api";
+export interface AdapterRequestError<T extends string = string> extends Error {
+	isAdapterError: true;
+	code: T;
+	errors: JsonApiError[];
 }
-export class TimeoutError {
-    private constructor();
-    code: string;
+export interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {
+	new (errors?: unknown[], message?: string): Instance;
+	extend(options: {
+		message: string;
+	}): AdapterRequestErrorConstructor;
 }
-export class AbortError {
-    private constructor();
-    code: string;
+export type AdapterError = AdapterRequestError<"AdapterError">;
+export declare const AdapterError: AdapterRequestErrorConstructor<AdapterError>;
+/**
+A `InvalidError` is used by an adapter to signal the external API
+was unable to process a request because the content was not
+semantically correct or meaningful per the API. Usually, this means a
+record failed some form of server-side validation. When a promise
+from an adapter is rejected with a `InvalidError` the record will
+transition to the `invalid` state and the errors will be set to the
+`errors` property on the record.
+
+For Ember Data to correctly map errors to their corresponding
+properties on the model, Ember Data expects each error to be
+a valid JSON-API error object with a `source/pointer` that matches
+the property name. For example, if you had a Post model that
+looked like this.
+
+```js [app/models/post.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class PostModel extends Model {
+@attr('string') title;
+@attr('string') content;
+}
+```
+
+To show an error from the server related to the `title` and
+`content` properties your adapter could return a promise that
+rejects with a `InvalidError` object that looks like this:
+
+```js [app/adapters/post.js]
+import RSVP from 'RSVP';
+import RESTAdapter from '@ember-data/adapter/rest';
+import { InvalidError } from '@ember-data/adapter/error';
+
+export default class ApplicationAdapter extends RESTAdapter {
+updateRecord() {
+// Fictional adapter that always rejects
+return RSVP.reject(new InvalidError([
+{
+detail: 'Must be unique',
+source: { pointer: '/data/attributes/title' }
+},
+{
+detail: 'Must not be blank',
+source: { pointer: '/data/attributes/content'}
+}
+]));
+}
+}
+```
+
+Your backend may use different property names for your records the
+store will attempt to extract and normalize the errors using the
+serializer's `extractErrors` method before the errors get added to
+the model. As a result, it is safe for the `InvalidError` to
+wrap the error payload unaltered.
+
+@class InvalidError
+@public
+*/
+// TODO @deprecate extractError documentation
+export type InvalidError = AdapterRequestError<"InvalidError">;
+export declare const InvalidError: AdapterRequestErrorConstructor<InvalidError>;
+/**
+A `TimeoutError` is used by an adapter to signal that a request
+to the external API has timed out. I.e. no response was received from
+the external API within an allowed time period.
+
+An example use case would be to warn the user to check their internet
+connection if an adapter operation has timed out:
+
+```js [app/routes/application.js]
+import { TimeoutError } from '@ember-data/adapter/error';
+
+export default class ApplicationRoute extends Route {
+@action
+error(error, transition) {
+if (error instanceof TimeoutError) {
+// alert the user
+alert('Are you still connected to the Internet?');
+return;
+}
+
+// ...other error handling logic
+}
+}
+```
+
+@class TimeoutError
+@public
+*/
+export type TimeoutError = AdapterRequestError<"TimeoutError">;
+export declare const TimeoutError: AdapterRequestErrorConstructor<TimeoutError>;
+/**
+A `AbortError` is used by an adapter to signal that a request to
+the external API was aborted. For example, this can occur if the user
+navigates away from the current page after a request to the external API
+has been initiated but before a response has been received.
+
+@class AbortError
+@public
+*/
+export type AbortError = AdapterRequestError<"AbortError">;
+export declare const AbortError: AdapterRequestErrorConstructor<AbortError>;
+/**
+A `UnauthorizedError` equates to a HTTP `401 Unauthorized` response
+status. It is used by an adapter to signal that a request to the external
+API was rejected because authorization is required and has failed or has not
+yet been provided.
+
+An example use case would be to redirect the user to a login route if a
+request is unauthorized:
+
+```js [app/routes/application.js]
+import { UnauthorizedError } from '@ember-data/adapter/error';
+
+export default class ApplicationRoute extends Route {
+@action
+error(error, transition) {
+if (error instanceof UnauthorizedError) {
+// go to the login route
+this.transitionTo('login');
+return;
+}
+
+// ...other error handling logic
 }
-export class UnauthorizedError {
-    private constructor();
-    code: string;
 }
-export class ForbiddenError {
-    private constructor();
-    code: string;
+```
+
+@class UnauthorizedError
+@public
+*/
+export type UnauthorizedError = AdapterRequestError<"UnauthorizedError">;
+export declare const UnauthorizedError: AdapterRequestErrorConstructor<UnauthorizedError>;
+/**
+A `ForbiddenError` equates to a HTTP `403 Forbidden` response status.
+It is used by an adapter to signal that a request to the external API was
+valid but the server is refusing to respond to it. If authorization was
+provided and is valid, then the authenticated user does not have the
+necessary permissions for the request.
+
+@class ForbiddenError
+@public
+*/
+export type ForbiddenError = AdapterRequestError<"ForbiddenError">;
+export declare const ForbiddenError: AdapterRequestErrorConstructor<ForbiddenError>;
+/**
+A `NotFoundError` equates to a HTTP `404 Not Found` response status.
+It is used by an adapter to signal that a request to the external API
+was rejected because the resource could not be found on the API.
+
+An example use case would be to detect if the user has entered a route
+for a specific model that does not exist. For example:
+
+```js [app/routes/post.js]
+import { NotFoundError } from '@ember-data/adapter/error';
+
+export default class PostRoute extends Route {
+@service store;
+model(params) {
+return this.store.findRecord('post', params.post_id);
 }
-export class NotFoundError {
-    private constructor();
-    code: string;
+@action
+error(error, transition) {
+if (error instanceof NotFoundError) {
+// redirect to a list of all posts instead
+this.transitionTo('posts');
+} else {
+// otherwise let the error bubble
+return true;
 }
-export class ConflictError {
-    private constructor();
-    code: string;
 }
-export class ServerError {
-    private constructor();
-    code: string;
 }
+```
+
+@class NotFoundError
+@public
+*/
+export type NotFoundError = AdapterRequestError<"NotFoundError">;
+export declare const NotFoundError: AdapterRequestErrorConstructor<NotFoundError>;
+/**
+A `ConflictError` equates to a HTTP `409 Conflict` response status.
+It is used by an adapter to indicate that the request could not be processed
+because of a conflict in the request. An example scenario would be when
+creating a record with a client-generated ID but that ID is already known
+to the external API.
+
+@class ConflictError
+@public
+*/
+export type ConflictError = AdapterRequestError<"ConflictError">;
+export declare const ConflictError: AdapterRequestErrorConstructor<ConflictError>;
 /**
-  ## 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 adapter, 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>
-
-  An `AdapterError` is used by an adapter to signal that an error occurred
-  during a request to an external API. It indicates a generic error, and
-  subclasses are used to indicate specific error states.
-
-  To create a custom error to signal a specific error state in communicating
-  with an external API, extend the `AdapterError`. For example, if the
-  external API exclusively used HTTP `503 Service Unavailable` to indicate
-  it was closed for maintenance:
-
-  ```js [app/adapters/maintenance-error.js]
-  import AdapterError from '@ember-data/adapter/error';
-
-  export default AdapterError.extend({ message: "Down for maintenance." });
-  ```
-
-  This error would then be returned by an adapter's `handleResponse` method:
-
-  ```js [app/adapters/application.js]
-  import JSONAPIAdapter from '@ember-data/adapter/json-api';
-  import MaintenanceError from './maintenance-error';
-
-  export default class ApplicationAdapter extends JSONAPIAdapter {
-    handleResponse(status) {
-      if (503 === status) {
-        return new MaintenanceError();
-      }
-
-      return super.handleResponse(...arguments);
-    }
-  }
-  ```
-
-  And can then be detected in an application and used to send the user to an
-  `under-maintenance` route:
-
-  ```js [app/routes/application.js]
-  import MaintenanceError from '../adapters/maintenance-error';
-
-  export default class ApplicationRoute extends Route {
-    actions: {
-      error(error, transition) {
-        if (error instanceof MaintenanceError) {
-          this.transitionTo('under-maintenance');
-          return;
-        }
-
-        // ...other error handling logic
-      }
-    }
-  }
-  ```
-
-  @class AdapterError
-  @public
+A `ServerError` equates to a HTTP `500 Internal Server Error` response
+status. It is used by the adapter to indicate that a request has failed
+because of an error in the external API.
+
+@class ServerError
+@public
 */
-declare function _AdapterError(errors: any, message?: string): void;
-declare class _AdapterError {
-    /**
-      ## 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 adapter, 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>
-    
-      An `AdapterError` is used by an adapter to signal that an error occurred
-      during a request to an external API. It indicates a generic error, and
-      subclasses are used to indicate specific error states.
-    
-      To create a custom error to signal a specific error state in communicating
-      with an external API, extend the `AdapterError`. For example, if the
-      external API exclusively used HTTP `503 Service Unavailable` to indicate
-      it was closed for maintenance:
-    
-      ```js [app/adapters/maintenance-error.js]
-      import AdapterError from '@ember-data/adapter/error';
-    
-      export default AdapterError.extend({ message: "Down for maintenance." });
-      ```
-    
-      This error would then be returned by an adapter's `handleResponse` method:
-    
-      ```js [app/adapters/application.js]
-      import JSONAPIAdapter from '@ember-data/adapter/json-api';
-      import MaintenanceError from './maintenance-error';
-    
-      export default class ApplicationAdapter extends JSONAPIAdapter {
-        handleResponse(status) {
-          if (503 === status) {
-            return new MaintenanceError();
-          }
-    
-          return super.handleResponse(...arguments);
-        }
-      }
-      ```
-    
-      And can then be detected in an application and used to send the user to an
-      `under-maintenance` route:
-    
-      ```js [app/routes/application.js]
-      import MaintenanceError from '../adapters/maintenance-error';
-    
-      export default class ApplicationRoute extends Route {
-        actions: {
-          error(error, transition) {
-            if (error instanceof MaintenanceError) {
-              this.transitionTo('under-maintenance');
-              return;
-            }
-    
-            // ...other error handling logic
-          }
-        }
-      }
-      ```
-    
-      @class AdapterError
-      @public
-    */
-    constructor(errors: any, message?: string);
-    isAdapterError: boolean;
-    stack: string | undefined;
-    description: any;
-    fileName: any;
-    lineNumber: any;
-    message: string | undefined;
-    name: string | undefined;
-    number: any;
-    errors: any;
-    code: string;
-}
-declare namespace _AdapterError {
-    function extend({ message: defaultMessage }?: {}): {
-        (errors: any, message: any): void;
-        prototype: any;
-        extend: ({ message: defaultMessage }?: {}) => /*elided*/ any;
-    };
-}
-export {};
-//# sourceMappingURL=error.d.ts.map
+export type ServerError = AdapterRequestError<"ServerError">;
+export declare const ServerError: AdapterRequestErrorConstructor<ServerError>;