@warp-drive/legacy 5.8.0-alpha.4 → 5.8.0-alpha.40

package/dist/unpkg/prod-deprecated/adapter/-private.js

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

package/dist/unpkg/prod-deprecated/adapter/error.js

@@ -0,0 +1,330 @@
+import { getOrSetGlobal } from '@warp-drive/core/types/-private';
+
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+/**
+  ## 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}
+  :::
+
+  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 '@warp-drive/legacy/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 '@warp-drive/legacy/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
+*/
+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 || [{
+    title: 'Adapter Error',
+    detail: message
+  }];
+}
+_AdapterError.prototype = Object.create(Error.prototype);
+_AdapterError.prototype.code = 'AdapterError';
+_AdapterError.extend = extendFn(_AdapterError);
+const AdapterError = getOrSetGlobal('AdapterError', _AdapterError);
+function extendFn(ErrorClass) {
+  return function ({
+    message: defaultMessage
+  } = {}) {
+    return extend(ErrorClass, defaultMessage);
+  };
+}
+function extend(ParentErrorClass, defaultMessage) {
+  const ErrorClass = function (errors, message) {
+    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;
+}
+
+/**
+  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
+*/
+// TODO @deprecate extractError documentation
+
+const InvalidError = getOrSetGlobal('InvalidError', extend(AdapterError, 'The adapter rejected the commit because it was invalid'));
+InvalidError.prototype.code = '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
+*/
+
+const TimeoutError = getOrSetGlobal('TimeoutError', extend(AdapterError, 'The adapter operation timed out'));
+TimeoutError.prototype.code = '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
+*/
+
+const AbortError = getOrSetGlobal('AbortError', extend(AdapterError, 'The adapter operation was aborted'));
+AbortError.prototype.code = '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
+*/
+
+const UnauthorizedError = getOrSetGlobal('UnauthorizedError', extend(AdapterError, 'The adapter operation is unauthorized'));
+UnauthorizedError.prototype.code = '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
+*/
+
+const ForbiddenError = getOrSetGlobal('ForbiddenError', extend(AdapterError, 'The adapter operation is forbidden'));
+ForbiddenError.prototype.code = '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
+*/
+
+const NotFoundError = getOrSetGlobal('NotFoundError', extend(AdapterError, 'The adapter could not find the resource'));
+NotFoundError.prototype.code = '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
+*/
+
+const ConflictError = getOrSetGlobal('ConflictError', extend(AdapterError, 'The adapter operation failed due to a conflict'));
+ConflictError.prototype.code = '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
+*/
+
+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/unpkg/prod-deprecated/adapter/json-api.js

@@ -0,0 +1,266 @@
+import { dasherize, pluralize } from '@warp-drive/utilities/string';
+import { b as serializeIntoHash } from "../serialize-into-hash-DYU2egXl.js";
+import { RESTAdapter } from './rest.js';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+/**
+  ## 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
+*/
+class JSONAPIAdapter extends RESTAdapter {
+  _defaultContentType = 'application/vnd.api+json';
+
+  /**
+    @private
+    @param {String} url
+    @param {String} type The request type GET, POST, PUT, DELETE etc.
+    @param {Object} options
+    @return {Object}
+  */
+  ajaxOptions(url, type, options = {}) {
+    const hash = super.ajaxOptions(url, type, options);
+    const headers = hash.headers = hash.headers || {};
+    headers['Accept'] = headers['Accept'] || 'application/vnd.api+json';
+    return hash;
+  }
+
+  /**
+    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() {
+    const coalesceFindRequests = this._coalesceFindRequests;
+    if (typeof coalesceFindRequests === 'boolean') {
+      return coalesceFindRequests;
+    }
+    return this._coalesceFindRequests = false;
+  }
+  set coalesceFindRequests(value) {
+    this._coalesceFindRequests = value;
+  }
+  findMany(store, type, ids, snapshots) {
+    const url = this.buildURL(type.modelName, ids, snapshots, 'findMany');
+    return this.ajax(url, 'GET', {
+      data: {
+        filter: {
+          id: ids.join(',')
+        }
+      }
+    });
+  }
+  pathForType(modelName) {
+    const dasherized = dasherize(modelName);
+    return pluralize(dasherized);
+  }
+  updateRecord(store, schema, snapshot) {
+    const data = serializeIntoHash(store, schema, snapshot);
+    const type = snapshot.modelName;
+    const id = snapshot.id;
+    const url = this.buildURL(type, id, snapshot, 'updateRecord');
+    return this.ajax(url, 'PATCH', {
+      data: data
+    });
+  }
+
+  /**
+    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) {
+    const query = {};
+    if (snapshot) {
+      const {
+        include
+      } = snapshot;
+      const normalizedInclude = Array.isArray(include) ? include.join(',') : include;
+      if (normalizedInclude) {
+        query.include = normalizedInclude;
+      }
+    }
+    return query;
+  }
+}
+export { JSONAPIAdapter };