@warp-drive/legacy 5.8.0-alpha.30 → 5.8.0-alpha.32

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/build-url-mixin.d.ts

@@ -0,0 +1,33 @@
+import Mixin from "@ember/object/mixin";
+import type { Snapshot, SnapshotRecordArray } from "../../compat/-private.js";
+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;
+}
+export interface MixtBuildURLMixin extends BuildURLMixin {
+	host: string | null;
+	namespace: string | null;
+}
+export declare const BuildURLMixin: Mixin;

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/fastboot-interface.d.ts

@@ -0,0 +1,8 @@
+export interface Request {
+	protocol: string;
+	host: string;
+}
+export interface FastBoot {
+	isFastBoot: boolean;
+	request: Request;
+}

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/utils/continue-on-reject.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/utils/determine-body-promise.d.ts

@@ -0,0 +1,4 @@
+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 {};

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/utils/fetch.d.ts

@@ -0,0 +1,8 @@
+type FetchFunction = (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+type MockRequest = {
+	protocol?: string;
+	get(key: string): string | undefined;
+};
+export declare function getFetchFunction(): FetchFunction;
+export declare function setupFastboot(fastBootRequest: MockRequest): void;
+export {};

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/utils/parse-response-headers.d.ts

@@ -0,0 +1 @@
+export declare function parseResponseHeaders(headersString: string): Record<string, string>;

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/utils/serialize-into-hash.d.ts

@@ -0,0 +1,6 @@
+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;
+}): object;

package/dist/unpkg/dev-deprecated/declarations/adapter/-private/utils/serialize-query-params.d.ts

@@ -0,0 +1,5 @@
+interface PlainObject {
+	[key: string]: string | PlainObject | PlainObject[] | string[];
+}
+export declare function serializeQueryParams(queryParamsObject: PlainObject | string): string;
+export {};

package/dist/unpkg/dev-deprecated/declarations/adapter/-private.d.ts

@@ -0,0 +1,5 @@
+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/dist/unpkg/dev-deprecated/declarations/adapter/error.d.ts

@@ -0,0 +1,215 @@
+import type { ApiError } from "@warp-drive/core/types/spec/error";
+export interface AdapterRequestError<T extends string = string> extends Error {
+	isAdapterError: true;
+	code: T;
+	errors: ApiError[];
+}
+export interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {
+	new (errors?: unknown[], message?: string): Instance;
+	extend(options: {
+		message: string;
+	}): AdapterRequestErrorConstructor;
+}
+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 '@warp-drive/legacy/adapter/rest';
+import { InvalidError } from '@warp-drive/legacy/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
+*/
+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 '@warp-drive/legacy/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 '@warp-drive/legacy/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
+}
+}
+```
+
+@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 '@warp-drive/legacy/adapter/error';
+
+export default class PostRoute extends Route {
+@service store;
+model(params) {
+return this.store.findRecord('post', params.post_id);
+}
+@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;
+}
+}
+}
+```
+
+@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>;
+/**
+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
+*/
+export type ServerError = AdapterRequestError<"ServerError">;
+export declare const ServerError: AdapterRequestErrorConstructor<ServerError>;

package/dist/unpkg/dev-deprecated/declarations/adapter/json-api.d.ts

@@ -0,0 +1,231 @@
+import type { Store } from "@warp-drive/core";
+import type { ModelSchema } from "@warp-drive/core/types";
+import type { HTTPMethod } from "@warp-drive/core/types/request";
+import type { AdapterPayload } from "../compat.js";
+import type { Snapshot, SnapshotRecordArray } from "../compat/-private.js";
+import type { FetchRequestInit, JQueryRequestInit, QueryState } from "./rest.js";
+import { RESTAdapter } from "./rest.js";
+/**
+## 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 adapter, consider writing a
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
+
+The `JSONAPIAdapter` is an adapter whichtransforms the store's
+requests into HTTP requests that follow the [JSON API format](http://jsonapi.org/format/).
+
+## JSON API Conventions
+
+The JSONAPIAdapter uses JSON API conventions for building the URL
+for a record and selecting the HTTP verb to use with a request. The
+actions you can take on a record map onto the following URLs in the
+JSON API adapter:
+
+<table>
+<tr>
+<th>
+Action
+</th>
+<th>
+HTTP Verb
+</th>
+<th>
+URL
+</th>
+</tr>
+<tr>
+<th>
+`store.findRecord('post', 123)`
+</th>
+<td>
+GET
+</td>
+<td>
+/posts/123
+</td>
+</tr>
+<tr>
+<th>
+`store.findAll('post')`
+</th>
+<td>
+GET
+</td>
+<td>
+/posts
+</td>
+</tr>
+<tr>
+<th>
+Update `postRecord.save()`
+</th>
+<td>
+PATCH
+</td>
+<td>
+/posts/123
+</td>
+</tr>
+<tr>
+<th>
+Create `store.createRecord('post').save()`
+</th>
+<td>
+POST
+</td>
+<td>
+/posts
+</td>
+</tr>
+<tr>
+<th>
+Delete `postRecord.destroyRecord()`
+</th>
+<td>
+DELETE
+</td>
+<td>
+/posts/123
+</td>
+</tr>
+</table>
+
+## Success and failure
+
+The JSONAPIAdapter will consider a success any response with a
+status code of the 2xx family ("Success"), as well as 304 ("Not
+Modified"). Any other status code will be considered a failure.
+
+On success, the request promise will be resolved with the full
+response payload.
+
+Failed responses with status code 422 ("Unprocessable Entity") will
+be considered "invalid". The response will be discarded, except for
+the `errors` key. The request promise will be rejected with a
+`InvalidError`. This error object will encapsulate the saved
+`errors` value.
+
+Any other status codes will be treated as an adapter error. The
+request promise will be rejected, similarly to the invalid case,
+but with an instance of `AdapterError` instead.
+
+### Endpoint path customization
+
+Endpoint paths can be prefixed with a `namespace` by setting the
+namespace property on the adapter:
+
+```js [app/adapters/application.js]
+import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
+
+export default class ApplicationAdapter extends JSONAPIAdapter {
+namespace = 'api/1';
+}
+```
+Requests for the `person` model would now target `/api/1/people/1`.
+
+### Host customization
+
+An adapter can target other hosts by setting the `host` property.
+
+```js [app/adapters/application.js]
+import JSONAPIAdapter from '@warp-drive/legacy/adapter/json-api';
+
+export default class ApplicationAdapter extends JSONAPIAdapter {
+host = 'https://api.example.com';
+}
+```
+
+Requests for the `person` model would now target
+`https://api.example.com/people/1`.
+
+@since 1.13.0
+@class JSONAPIAdapter
+@public
+@constructor
+*/
+declare class JSONAPIAdapter extends RESTAdapter {
+	_defaultContentType: string;
+	/**
+	@private
+	@param {String} url
+	@param {String} type The request type GET, POST, PUT, DELETE etc.
+	@param {Object} options
+	@return {Object}
+	*/
+	ajaxOptions(url: string, type: HTTPMethod, options?: JQueryAjaxSettings | RequestInit): JQueryRequestInit | FetchRequestInit;
+	/**
+	By default the JSONAPIAdapter will send each find request coming from a `store.find`
+	or from accessing a relationship separately to the server. If your server supports passing
+	ids as a query string, you can set coalesceFindRequests to true to coalesce all find requests
+	within a single runloop.
+	
+	For example, if you have an initial payload of:
+	
+	```javascript
+	{
+	data: {
+	id: 1,
+	type: 'post',
+	relationship: {
+	comments: {
+	data: [
+	{ id: 1, type: 'comment' },
+	{ id: 2, type: 'comment' }
+	]
+	}
+	}
+	}
+	}
+	```
+	
+	By default calling `post.comments` will trigger the following requests(assuming the
+	comments haven't been loaded before):
+	
+	```
+	GET /comments/1
+	GET /comments/2
+	```
+	
+	If you set coalesceFindRequests to `true` it will instead trigger the following request:
+	
+	```
+	GET /comments?filter[id]=1,2
+	```
+	
+	Setting coalesceFindRequests to `true` also works for `store.find` requests and `belongsTo`
+	relationships accessed within the same runloop. If you set `coalesceFindRequests: true`
+	
+	```javascript
+	store.findRecord('comment', 1);
+	store.findRecord('comment', 2);
+	```
+	
+	will also send a request to: `GET /comments?filter[id]=1,2`
+	
+	Note: Requests coalescing rely on URL building strategy. So if you override `buildURL` in your app
+	`groupRecordsForFindMany` more likely should be overridden as well in order for coalescing to work.
+	
+	@property coalesceFindRequests
+	@public
+	@type {Boolean}
+	*/
+	get coalesceFindRequests(): boolean;
+	set coalesceFindRequests(value: boolean);
+	findMany(store: Store, type: ModelSchema, ids: string[], snapshots: Snapshot[]): Promise<AdapterPayload>;
+	pathForType(modelName: string): string;
+	updateRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+	/**
+	Used by `findAll` and `findRecord` to build the query's `data` hash
+	supplied to the ajax method.
+	
+	@since 2.5.0
+	@public
+	@param  {Snapshot} snapshot
+	@return {Object}
+	*/
+	buildQuery(snapshot: Snapshot | SnapshotRecordArray): QueryState;
+}
+export { JSONAPIAdapter };