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

package/dist/adapter.js

@@ -1,1250 +1,3 @@
-import EmberObject from '@ember/object';
-import * as s from '@ember/service';
-import { macroCondition, getGlobalConfig } from '@embroider/macros';
-import { a as decorateFieldV2, i as initializeDeferredDecorator } from "./runtime-BPCpkOf1-BKOwiRJp.js";
-import Mixin from '@ember/object/mixin';
-import { camelize, pluralize } from '@warp-drive/utilities/string';
+import { n as BuildURLMixin, t as Adapter } from "./adapter-XgLAkYVs.js";
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-
-/*
- 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.
-/**
- * The methods provided by the `BuildURLMixin` mixin (see the exported
- * `BuildURLMixin` {@link Mixin} below).
- *
- * See also {@link MixtBuildURLMixin}, the interface used to type `this`
- * within these methods.
- */
-
-// 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
-
-/**
-    Builds a URL for a given type and optional ID.
-
-    By default, it pluralizes the type's name (for example, 'post'
-    becomes 'posts' and 'person' becomes 'people'). To override the
-    pluralization see [pathForType](./pathForType?anchor=pathForType).
-
-    If an ID is specified, it adds the ID to the path generated
-    for the type, separated by a `/`.
-
-    When called by `RESTAdapter.findMany()` the `id` and `snapshot` parameters
-    will be arrays of ids and snapshots.
-
-    @public
-    @param {String} modelName
-    @param {(String|Array|Object)} id single id or array of ids or query
-    @param {(Snapshot|SnapshotRecordArray)} snapshot single snapshot or array of snapshots
-    @param {String} requestType
-    @param {Object} query object of query parameters to send for query requests.
-    @return {String} url
-  */
-
-function buildURL(modelName, id, snapshot, requestType, query) {
-  /*
-      Switch statements in typescript don't currently narrow even when the function is implemented
-      with overloads.
-       We still extract this to stand alone so that we can provide nice overloads for calling signatures,
-      but we will still require all of this casting (or a ridiculous number of assertsthat narrow it down
-      for us).
-  */
-  switch (requestType) {
-    case 'findRecord':
-      return this.urlForFindRecord(id, modelName, snapshot);
-    case 'findAll':
-      return this.urlForFindAll(modelName, snapshot);
-    case 'query':
-      return this.urlForQuery(query || {}, modelName);
-    case 'queryRecord':
-      return this.urlForQueryRecord(query || {}, modelName);
-    case 'findMany':
-      return this.urlForFindMany(id, modelName, snapshot);
-    case 'findHasMany':
-      return this.urlForFindHasMany(id, modelName, snapshot);
-    case 'findBelongsTo':
-      return this.urlForFindBelongsTo(id, modelName, snapshot);
-    case 'createRecord':
-      return this.urlForCreateRecord(modelName, snapshot);
-    case 'updateRecord':
-      return this.urlForUpdateRecord(id, modelName, snapshot);
-    case 'deleteRecord':
-      return this.urlForDeleteRecord(id, modelName, snapshot);
-    default:
-      // this is the 'never' case but someone may call `buildURL` manually so
-      // we try to do something for them.
-      return this._buildURL(modelName, id);
-  }
-}
-
-/**
-    @private
-    @param {String} modelName
-    @param {String} id
-    @return {String} url
-  */
-function _buildURL(modelName, id) {
-  let path;
-  const url = [];
-  const {
-    host
-  } = this;
-  const prefix = this.urlPrefix();
-  if (modelName) {
-    path = this.pathForType(modelName);
-    if (path) {
-      url.push(path);
-    }
-  }
-  if (id) {
-    url.push(encodeURIComponent(id));
-  }
-  if (prefix) {
-    url.unshift(prefix);
-  }
-  let urlString = url.join('/');
-  if (!host && urlString && urlString.charAt(0) !== '/') {
-    urlString = '/' + urlString;
-  }
-  return urlString;
-}
-
-/**
-   Builds a URL for a `store.findRecord(type, id)` call.
-
-   Example:
-
-   ```js [app/adapters/user.js]
-   import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
-
-   export default class ApplicationAdapter extends JSONAPIAdapter {
-     urlForFindRecord(id, modelName, snapshot) {
-       let baseUrl = this.buildURL(modelName, id, snapshot);
-       return `${baseUrl}/users/${snapshot.adapterOptions.user_id}/playlists/${id}`;
-     }
-   }
-   ```
-
-   @public
-   @param {String} id
-   @param {String} modelName
-   @param {Snapshot} snapshot
-   @return {String} url
-
-   */
-function urlForFindRecord(id, modelName, snapshot) {
-  return this._buildURL(modelName, id);
-}
-
-/**
-   Builds a URL for a `store.findAll(type)` call.
-
-   Example:
-
-   ```js [app/adapters/comment.js]
-   import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
-
-   export default class ApplicationAdapter extends JSONAPIAdapter {
-     urlForFindAll(modelName, snapshot) {
-       let baseUrl = this.buildURL(modelName);
-       return `${baseUrl}/data/comments.json`;
-     }
-   }
-   ```
-
-    @public
-   @param {String} modelName
-   @param {SnapshotRecordArray} snapshot
-   @return {String} url
-   */
-function urlForFindAll(modelName, snapshots) {
-  return this._buildURL(modelName);
-}
-
-/**
-   Builds a URL for a `store.query(type, query)` call.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-
-   export default class ApplicationAdapter extends RESTAdapter {
-     host = 'https://api.github.com';
-     urlForQuery (query, modelName) {
-       switch(modelName) {
-         case 'repo':
-           return `https://api.github.com/orgs/${query.orgId}/repos`;
-         default:
-           return super.urlForQuery(...arguments);
-       }
-     }
-   }
-   ```
-
-    @public
-   @param {Object} query
-   @param {String} modelName
-   @return {String} url
-   */
-function urlForQuery(query, modelName) {
-  return this._buildURL(modelName);
-}
-
-/**
-   Builds a URL for a `store.queryRecord(type, query)` call.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-
-   export default class ApplicationAdapter extends RESTAdapter {
-     urlForQueryRecord({ slug }, modelName) {
-       let baseUrl = this.buildURL();
-       return `${baseUrl}/${encodeURIComponent(slug)}`;
-     }
-   }
-   ```
-
-    @public
-   @param {Object} query
-   @param {String} modelName
-   @return {String} url
-   */
-function urlForQueryRecord(query, modelName) {
-  return this._buildURL(modelName);
-}
-
-/**
-   Builds a URL for coalescing multiple `store.findRecord(type, id)`
-   records into 1 request when the adapter's `coalesceFindRequests`
-   property is `true`.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-
-   export default class ApplicationAdapter extends RESTAdapter {
-     urlForFindMany(ids, modelName) {
-       let baseUrl = this.buildURL();
-       return `${baseUrl}/coalesce`;
-     }
-   }
-   ```
-
-    @public
-   @param {Array} ids
-   @param {String} modelName
-   @param {Array} snapshots
-   @return {String} url
-   */
-function urlForFindMany(ids, modelName, snapshots) {
-  return this._buildURL(modelName);
-}
-
-/**
-   Builds a URL for fetching an async `hasMany` relationship when a URL
-   is not provided by the server.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
-
-   export default class ApplicationAdapter extends JSONAPIAdapter {
-     urlForFindHasMany(id, modelName, snapshot) {
-       let baseUrl = this.buildURL(modelName, id);
-       return `${baseUrl}/relationships`;
-     }
-   }
-   ```
-
-    @public
-   @param {String} id
-   @param {String} modelName
-   @param {Snapshot} snapshot
-   @return {String} url
-   */
-function urlForFindHasMany(id, modelName, snapshot) {
-  return this._buildURL(modelName, id);
-}
-
-/**
-   Builds a URL for fetching an async `belongsTo` relationship when a url
-   is not provided by the server.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { JSONAPIAdapter } from '@warp-drive/legacy/adapter/json-api';
-
-   export default class ApplicationAdapter extends JSONAPIAdapter {
-     urlForFindBelongsTo(id, modelName, snapshot) {
-       let baseUrl = this.buildURL(modelName, id);
-       return `${baseUrl}/relationships`;
-     }
-   }
-   ```
-
-    @public
-   @param {String} id
-   @param {String} modelName
-   @param {Snapshot} snapshot
-   @return {String} url
-   */
-function urlForFindBelongsTo(id, modelName, snapshot) {
-  return this._buildURL(modelName, id);
-}
-
-/**
-   Builds a URL for a `record.save()` call when the record was created
-   locally using `store.createRecord()`.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-
-   export default class ApplicationAdapter extends RESTAdapter {
-     urlForCreateRecord(modelName, snapshot) {
-       return super.urlForCreateRecord(...arguments) + '/new';
-     }
-   }
-   ```
-
-    @public
-   @param {String} modelName
-   @param {Snapshot} snapshot
-   @return {String} url
-   */
-function urlForCreateRecord(modelName, snapshot) {
-  return this._buildURL(modelName);
-}
-
-/**
-   Builds a URL for a `record.save()` call when the record has been updated locally.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-
-   export default class ApplicationAdapter extends RESTAdapter {
-     urlForUpdateRecord(id, modelName, snapshot) {
-       return `/${id}/feed?access_token=${snapshot.adapterOptions.token}`;
-     }
-   }
-   ```
-
-    @public
-   @param {String} id
-   @param {String} modelName
-   @param {Snapshot} snapshot
-   @return {String} url
-   */
-function urlForUpdateRecord(id, modelName, snapshot) {
-  return this._buildURL(modelName, id);
-}
-
-/**
-   Builds a URL for a `record.save()` call when the record has been deleted locally.
-
-   Example:
-
-   ```js [app/adapters/application.js]
-   import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-
-   export default class ApplicationAdapter extends RESTAdapter {
-     urlForDeleteRecord(id, modelName, snapshot) {
-       return super.urlForDeleteRecord(...arguments) + '/destroy';
-     }
-   }
-   ```
-
-    @public
-   @param {String} id
-   @param {String} modelName
-   @param {Snapshot} snapshot
-   @return {String} url
-   */
-function urlForDeleteRecord(id, modelName, snapshot) {
-  return this._buildURL(modelName, id);
-}
-
-/**
-    @private
-    @param {String} path
-    @param {String} parentURL
-    @return {String} urlPrefix
-  */
-function urlPrefix(path, parentURL) {
-  const {
-    namespace
-  } = this;
-  let {
-    host
-  } = this;
-  if (!host || host === '/') {
-    host = '';
-  }
-  if (path) {
-    // Protocol relative url
-    if (/^\/\//.test(path) || /http(s)?:\/\//.test(path)) {
-      // Do nothing, the full host is already included.
-      return path;
-
-      // Absolute path
-    } else if (path.charAt(0) === '/') {
-      return `${host}${path}`;
-      // Relative path
-    } else {
-      return `${parentURL}/${path}`;
-    }
-  }
-
-  // No path provided
-  const url = [];
-  if (host) {
-    url.push(host);
-  }
-  if (namespace) {
-    url.push(namespace);
-  }
-  return url.join('/');
-}
-
-/**
-    Determines the pathname for a given type.
-
-    By default, it pluralizes the type's name (for example,
-    'post' becomes 'posts' and 'person' becomes 'people').
-
-    ### Pathname customization
-
-    For example, if you have an object `LineItem` with an
-    endpoint of `/line_items/`.
-
-    ```js [app/adapters/application.js]
-    import { RESTAdapter } from '@warp-drive/legacy/adapter/rest';
-    import { undesrcore, pluralize } from '<app-name>/utils/string-utils';
-
-    export default class ApplicationAdapter extends RESTAdapter {
-      pathForType(modelName) {
-        return pluralize(underscore(modelName));
-      }
-    }
-    ```
-
-    @public
-    @param {String} modelName
-    @return {String} path
-  **/
-function pathForType(modelName) {
-  const camelized = camelize(modelName);
-  return pluralize(camelized);
-}
-
-// we build it this way vs casting to BuildURLMixin so that any
-// changes to the interface surface as errors here.
-const mixinProps = {
-  buildURL,
-  _buildURL,
-  urlForFindRecord,
-  urlForFindAll,
-  urlForQueryRecord,
-  urlForQuery,
-  urlForFindMany,
-  urlForFindHasMany,
-  urlForFindBelongsTo,
-  urlForCreateRecord,
-  urlForDeleteRecord,
-  urlForUpdateRecord,
-  urlPrefix,
-  pathForType
-};
-
-/**
- * The `Mixin` implementation of {@link BuildURLMixin}, ready to be applied
- * to an `EmberObject` subclass such as an `Adapter`.
- *
- * @public
- */
-const BuildURLMixin = Mixin.create(mixinProps);
-
-/**
- * ## 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}
- * ::::
- *
- * In order to properly fetch and update data, @warp-drive/legacy
- * needs to understand how to connect to your API.
- *
- * `Adapters` accept various kinds of requests from the store
- * and manage fulfillment of the request from your API.
- *
- * ### Request Flow
- *
- * When the store decides it needs to issue a request it uses the following flow to manage the request and process the data.
- *
- * - find the appropriate adapter
- * - issue the request to the adapter
- * - await the adapter's response
- *   - if an error occurs reject with the error
- *   - if no error
- *      - if there is response data
- *      - pass the response data to the appropriate serializer
- *      - update the cache using the JSON:API formatted data from the serializer's response
- *    - return the primary record(s) associated with the request
- *
- * ### Request Errors
- *
- * When a request errors and your adapter does not have the ability to recover from the error,
- * you may either reject the promise returned by your adapter method with the error or simply
- * throw the error.
- *
- * If the request was for a `createRecord` `updateRecord` or `deleteRecord` special rules
- * apply to how this error will affect the state of the store and additional properties on
- * the `Error` class may be used. See the documentation for these methods in
- * {@link MinimumAdapterInterface} for more information.
- *
- * ### Implementing an Adapter
- *
- * There are seven required adapter methods, one for each of
- * the primary request types that @warp-drive/legacy issues.
- *
- * They are:
- *
- *  - findRecord
- *  - findAll
- *  - queryRecord
- *  - query
- *  - createRecord
- *  - updateRecord
- *  - deleteRecord
- *
- * Each of these request types has a matching store method that triggers it
- * and matching `requestType` that is passed to the serializer's
- * `normalizeResponse` method.
- *
- * If your app only reads data but never writes data, it is not necessary
- * to implement the methods for create, update, and delete. This extends to
- * all of the store's find methods with the exception of `findRecord` (`findAll`,
- * `query`, `queryRecord`): if you do not use the store method in your app then
- * your Adapter does not need the method.
- *
- * ```ts
- * async function fetchData(url, options = {}) {
- *   let response = await fetch(url, options);
- *   return response.toJSON();
- * }
- *
- * export default class ApplicationAdapter {
- *   findRecord(_, { modelName }, id) {
- *     return fetchData(`./${modelName}s/${id}`);
- *   }
- *
- *   static create() {
- *     return new this();
- *   }
- * }
- * ```
- *
- * ### Adapter Resolution
- *
- * `store.adapterFor(name)` will lookup adapters defined in `app/adapters/` and
- * return an instance.
- *
- * `adapterFor` first attempts to find an adapter with an exact match on `name`,
-  then falls back to checking for the presence of an adapter named `application`.
-
-  If no adapter is found, an error will be thrown.
-
-  ```ts
-  store.adapterFor('author');
-
-  // lookup paths (in order) =>
-  //   app/adapters/author.js
-  //   app/adapters/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`.
-
-  `adapterFor` is used by the store to find an adapter with a name matching that of the primary
-  resource `type` for the request, which then falls back to the `application` adapter.
-
-  It is recommended that applications define only a single `application` adapter and serializer
-  where possible, only implementing an adapter specific to the `type` when absolutely necessary.
-
-  If you need to support multiple API versions for the same type, the per-type strategy for
-  defining adapters might not be adequate.
-
-  If you have multiple APIs or multiple API versions and the single application adapter and per-type
-  strategy does not suite your needs, one strategy is to write an `application` adapter and serializer
-  that make use of `options` to specify the desired format when making a request, then forwards to the
-  request to the desired adapter or serializer as needed.
-
-  ```js [app/adapters/application.js]
-  export default class Adapter extends EmberObject {
-    findRecord(store, schema, id, snapshot) {
-      let { apiVersion } = snapshot.adapterOptions;
-      return this.adapterFor(`-api-${apiVersion}`).findRecord(store, schema, id, snapshot);
-    }
-  }
-  ```
-
-  ### Overriding `Store.adapterFor`
-
-  ```js
-  import Store from '@ember-data/store';
-  import Adapter from '@ember-data/adapter/json-api';
-
-  class extends Store {
-    #adapter = new Adapter();
-
-    adapterFor() {
-      return this.#adapter;
-    }
-  }
-  ```
-
-
-Note: If you are using Ember and would like to make use of `service` injections in your adapter, you will want to additionally `setOwner` for the Adapter.
-
-  ```js
-  import Store from '@ember-data/store';
-  import Adapter from '@ember-data/adapter/json-api';
-  import { getOwner, setOwner } from '@ember/owner';
-
-  class extends Store {
-    #adapter = null;
-
-    adapterFor() {
-      let adapter = this.#adapter;
-      if (!adapter) {
-        const owner = getOwner(this);
-        adapter = new Adapter();
-        setOwner(adapter, owner);
-        this.#adapter = adapter;
-      }
-
-      return adapter;
-    }
-  }
-  ```
-
-By default when using with Ember you only need to implement this hook if you want your adapter usage to be statically analyzeable. *Ember***Data** will attempt to resolve adapters using Ember's resolver. To provide a single Adapter for your application like the above you would provide it as the default export of the file `app/adapters/application.{js/ts}`
-
-  ### Using an Adapter
-
-  Any adapter in `app/adapters/` can be looked up by `name` using `store.adapterFor(name)`.
-
-  ### Default Adapters
-
-  Applications whose API's structure endpoint URLs *very close to* or *exactly* the **REST**
-  or **JSON:API** convention, the `@ember-data/adapter` package contains implementations
-  these applications can extend.
-
-  Many applications will find writing their own adapter to be allow greater flexibility,
-  customization, and maintenance than attempting to override methods in these adapters.
-
-  @module
-*/
-
-const service = s.service ?? s.inject;
-/**
-  An adapter is an object that receives requests from a store and
-  translates them into the appropriate action to take against your
-  persistence layer. The persistence layer is usually an HTTP API but
-  may be anything, such as the browser's local storage. Typically the
-  adapter is not invoked directly instead its functionality is accessed
-  through the `store`.
-
-  > ⚠️ CAUTION you likely want the docs for {@link MinimumAdapterInterface}
-  > as extending this abstract class is unnecessary.
-
-  ### Creating an Adapter
-
-  Create a new subclass of `Adapter` in the `app/adapters` folder:
-
-  ```js [app/adapters/application.js]
-  import { Adapter } from '@warp-drive/legacy/adapter';
-
-  export default class extends Adapter {
-    // ...your code here
-  }
-  ```
-
-  Model-specific adapters can be created by putting your adapter
-  class in an `app/adapters/` + `model-name` + `.js` file of the application.
-
-  ```js [app/adapters/post.js]
-  import { Adapter } from '@warp-drive/legacy/adapter';
-
-  export default class extends Adapter {
-    // ...Post-specific adapter code goes here
-  }
-  ```
-
-  `Adapter` is an abstract base class that you should override in your
-  application to customize it for your backend. The minimum set of methods
-  that you should implement is:
-
-    * `findRecord()`
-    * `createRecord()`
-    * `updateRecord()`
-    * `deleteRecord()`
-    * `findAll()`
-    * `query()`
-
-  To improve the network performance of your application, you can optimize
-  your adapter by overriding these lower-level methods:
-
-    * `findMany()`
-
-
-  For an example of the implementation, see `RESTAdapter`, the
-  included REST adapter.
-
-  @public
-*/
-class Adapter extends EmberObject {
-  static {
-    decorateFieldV2(this.prototype, "store", [service]);
-  }
-  #store = (initializeDeferredDecorator(this, "store"), void 0);
-  /**
-   * The Store service instance that owns this Adapter.
-   */
-  /**
-   * @private
-   */
-
-  /**
-    The `findRecord()` method is invoked when the store is asked for a record that
-    has not previously been loaded. In response to `findRecord()` being called, you
-    should query your persistence layer for a record with the given ID. The `findRecord`
-    method should return a promise that will resolve to a JavaScript object that will be
-    normalized by the serializer.
-     Here is an example of the `findRecord` implementation:
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      findRecord(store, type, id, snapshot) {
-        return new RSVP.Promise(function(resolve, reject) {
-          $.getJSON(`/${type.modelName}/${id}`).then(function(data) {
-            resolve(data);
-          }, function(jqXHR) {
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @public
-  */
-  // @ts-expect-error
-  findRecord(store, type, id, snapshot) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a findRecord override');
-    }
-  }
-
-  /**
-    The `findAll()` method is used to retrieve all records for a given type.
-     Example
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      findAll(store, type) {
-        return new RSVP.Promise(function(resolve, reject) {
-          $.getJSON(`/${type.modelName}`).then(function(data) {
-            resolve(data);
-          }, function(jqXHR) {
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @param neverSet a value is never provided to this argument
-    @public
-  */
-  findAll(store, type, neverSet, snapshotRecordArray) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a findAll override');
-    }
-  }
-
-  /**
-    This method is called when you call `query` on the store.
-     Example
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      query(store, type, query) {
-        return new RSVP.Promise(function(resolve, reject) {
-          $.getJSON(`/${type.modelName}`, query).then(function(data) {
-            resolve(data);
-          }, function(jqXHR) {
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @public
-  */
-  // @ts-expect-error
-  query(store, type, query) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a query override');
-    }
-  }
-
-  /**
-    The `queryRecord()` method is invoked when the store is asked for a single
-    record through a query object.
-     In response to `queryRecord()` being called, you should always fetch fresh
-    data. Once found, you can asynchronously call the store's `push()` method
-    to push the record into the store.
-     Here is an example `queryRecord` implementation:
-     Example
-     ```js [app/adapters/application.js]
-    import  { Adapter, BuildURLMixin } from '@warp-drive/legacy/adapter';
-     export default class ApplicationAdapter extends Adapter.extend(BuildURLMixin) {
-      queryRecord(store, type, query) {
-        return fetch(`/${type.modelName}`, { body: JSON.stringify(query) })
-          .then((response) => response.json());
-      }
-    }
-    ```
-     @public
-  */
-  queryRecord(store, type, query, adapterOptions) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a queryRecord override');
-    }
-  }
-
-  /**
-    If the globally unique IDs for your records should be generated on the client,
-    implement the `generateIdForRecord()` method. This method will be invoked
-    each time you create a new record, and the value returned from it will be
-    assigned to the record's `primaryKey`.
-     Most traditional REST-like HTTP APIs will not use this method. Instead, the ID
-    of the record will be set by the server, and your adapter will update the store
-    with the new ID when it calls `didCreateRecord()`. Only implement this method if
-    you intend to generate record IDs on the client-side.
-     The `generateIdForRecord()` method will be invoked with the requesting store as
-    the first parameter and the newly created record as the second parameter:
-     ```javascript
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import { v4 } from 'uuid';
-     export default class ApplicationAdapter extends Adapter {
-      generateIdForRecord(store, type, inputProperties) {
-        return v4();
-      }
-    }
-    ```
-     @param {Store} store
-    @param {Model} type   the Model class of the record
-    @param {Object} inputProperties a hash of properties to set on the
-      newly created record.
-    @return {(String|Number)} id
-    @public
-  */
-
-  /**
-    Proxies to the serializer's `serialize` method.
-     Example
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-     export default class ApplicationAdapter extends Adapter {
-      createRecord(store, type, snapshot) {
-        let data = this.serialize(snapshot, { includeId: true });
-        let url = `/${type.modelName}`;
-         // ...
-      }
-    }
-    ```
-     @public
-  */
-  serialize(snapshot, options) {
-    const serialized = snapshot.serialize(options);
-    macroCondition(getGlobalConfig().WarpDrive.env.DEBUG) ? (test => {
-      if (!test) {
-        throw new Error(`Your adapter's serialize method must return an object, but it returned ${typeof serialized}`);
-      }
-    })(serialized && typeof serialized === 'object') : {};
-    return serialized;
-  }
-
-  /**
-    Implement this method in a subclass to handle the creation of
-    new records.
-     Serializes the record and sends it to the server.
-     Example
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      createRecord(store, type, snapshot) {
-        let data = this.serialize(snapshot, { includeId: true });
-         return new RSVP.Promise(function (resolve, reject) {
-          $.ajax({
-            type: 'POST',
-            url: `/${type.modelName}`,
-            dataType: 'json',
-            data: data
-          }).then(function (data) {
-            resolve(data);
-          }, function (jqXHR) {
-            jqXHR.then = null; // tame jQuery's ill mannered promises
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @public
-  */
-  // @ts-expect-error
-  createRecord(store, type, snapshot) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a createRecord override');
-    }
-  }
-
-  /**
-    Implement this method in a subclass to handle the updating of
-    a record.
-     Serializes the record update and sends it to the server.
-     The updateRecord method is expected to return a promise that will
-    resolve with the serialized record. This allows the backend to
-    inform the WarpDrive store the current state of this record after
-    the update. If it is not possible to return a serialized record
-    the updateRecord promise can also resolve with `undefined` and the
-    WarpDrive store will assume all of the updates were successfully
-    applied on the backend.
-     Example
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      updateRecord(store, type, snapshot) {
-        let data = this.serialize(snapshot, { includeId: true });
-        let id = snapshot.id;
-         return new RSVP.Promise(function(resolve, reject) {
-          $.ajax({
-            type: 'PUT',
-            url: `/${type.modelName}/${id}`,
-            dataType: 'json',
-            data: data
-          }).then(function(data) {
-            resolve(data);
-          }, function(jqXHR) {
-            jqXHR.then = null; // tame jQuery's ill mannered promises
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @param {Store} store
-    @param {Model} type   the Model class of the record
-    @param {Snapshot} snapshot
-    @return {Promise} promise
-    @public
-  */
-  // @ts-expect-error
-  updateRecord(store, type, snapshot) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a updateRecord override');
-    }
-  }
-
-  /**
-    Implement this method in a subclass to handle the deletion of
-    a record.
-     Sends a delete request for the record to the server.
-     Example
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      deleteRecord(store, type, snapshot) {
-        let data = this.serialize(snapshot, { includeId: true });
-        let id = snapshot.id;
-         return new RSVP.Promise(function(resolve, reject) {
-          $.ajax({
-            type: 'DELETE',
-            url: `/${type.modelName}/${id}`,
-            dataType: 'json',
-            data: data
-          }).then(function(data) {
-            resolve(data)
-          }, function(jqXHR) {
-            jqXHR.then = null; // tame jQuery's ill mannered promises
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @param {Store} store
-    @param {Model} type   the Model class of the record
-    @param {Snapshot} snapshot
-    @return {Promise} promise
-    @public
-  */
-  // @ts-expect-error
-  deleteRecord(store, type, snapshot) {
-    if (macroCondition(getGlobalConfig().WarpDrive.env.DEBUG)) {
-      throw new Error('You subclassed the Adapter class but missing a deleteRecord override');
-    }
-  }
-
-  /**
-    By default the store will try to coalesce all `findRecord` calls within the same runloop
-    into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call.
-    You can opt out of this behaviour by either not implementing the findMany hook or by setting
-    coalesceFindRequests to false.
-     @property coalesceFindRequests
-    @public
-    @type {Boolean}
-  */
-  get coalesceFindRequests() {
-    const coalesceFindRequests = this._coalesceFindRequests;
-    if (typeof coalesceFindRequests === 'boolean') {
-      return coalesceFindRequests;
-    }
-    return this._coalesceFindRequests = true;
-  }
-  set coalesceFindRequests(value) {
-    this._coalesceFindRequests = value;
-  }
-
-  /**
-    The store will call `findMany` instead of multiple `findRecord`
-    requests to find multiple records at once if coalesceFindRequests
-    is true.
-     ```js [app/adapters/application.js]
-    import { Adapter } from '@warp-drive/legacy/adapter';
-    import RSVP from 'RSVP';
-    import $ from 'jquery';
-     export default class ApplicationAdapter extends Adapter {
-      findMany(store, type, ids, snapshots) {
-        return new RSVP.Promise(function(resolve, reject) {
-          $.ajax({
-            type: 'GET',
-            url: `/${type.modelName}/`,
-            dataType: 'json',
-            data: { filter: { id: ids.join(',') } }
-          }).then(function(data) {
-            resolve(data);
-          }, function(jqXHR) {
-            jqXHR.then = null; // tame jQuery's ill mannered promises
-            reject(jqXHR);
-          });
-        });
-      }
-    }
-    ```
-     @param {Store} store
-    @param {Model} type   the Model class of the records
-    @param {Array}    ids
-    @param {Array} snapshots
-    @return {Promise} promise
-    @public
-  */
-
-  /**
-    Organize records into groups, each of which is to be passed to separate
-    calls to `findMany`.
-     For example, if your API has nested URLs that depend on the parent, you will
-    want to group records by their parent.
-     The default implementation returns the records as a single group.
-     @public
-    @param {Store} store
-    @param {Array} snapshots
-    @return {Array}  an array of arrays of records, each of which is to be
-                      loaded separately by `findMany`.
-  */
-  groupRecordsForFindMany(store, snapshots) {
-    return [snapshots];
-  }
-
-  /**
-    This method is used by the store to determine if the store should
-    reload a record from the adapter when a record is requested by
-    `store.findRecord`.
-     If this method returns `true`, the store will re-fetch a record from
-    the adapter. If this method returns `false`, the store will resolve
-    immediately using the cached record.
-     For example, if you are building an events ticketing system, in which users
-    can only reserve tickets for 20 minutes at a time, and want to ensure that
-    in each route you have data that is no more than 20 minutes old you could
-    write:
-     ```javascript
-    shouldReloadRecord(store, ticketSnapshot) {
-      let lastAccessedAt = ticketSnapshot.attr('lastAccessedAt');
-      let timeDiff = moment().diff(lastAccessedAt, 'minutes');
-       if (timeDiff > 20) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-    ```
-     This method would ensure that whenever you do `store.findRecord('ticket',
-    id)` you will always get a ticket that is no more than 20 minutes old. In
-    case the cached version is more than 20 minutes old, `findRecord` will not
-    resolve until you fetched the latest version.
-     By default this hook returns `false`, as most UIs should not block user
-    interactions while waiting on data update.
-     Note that, with default settings, `shouldBackgroundReloadRecord` will always
-    re-fetch the records in the background even if `shouldReloadRecord` returns
-    `false`. You can override `shouldBackgroundReloadRecord` if this does not
-    suit your use case.
-     @since 1.13.0
-    @param {Store} store
-    @param {Snapshot} snapshot
-    @return {Boolean}
-    @public
-  */
-  shouldReloadRecord(store, snapshot) {
-    return false;
-  }
-
-  /**
-    This method is used by the store to determine if the store should
-    reload all records from the adapter when records are requested by
-    `store.findAll`.
-     If this method returns `true`, the store will re-fetch all records from
-    the adapter. If this method returns `false`, the store will resolve
-    immediately using the cached records.
-     For example, if you are building an events ticketing system, in which users
-    can only reserve tickets for 20 minutes at a time, and want to ensure that
-    in each route you have data that is no more than 20 minutes old you could
-    write:
-     ```javascript
-    shouldReloadAll(store, snapshotArray) {
-      let snapshots = snapshotArray.snapshots();
-       return snapshots.any((ticketSnapshot) => {
-        let lastAccessedAt = ticketSnapshot.attr('lastAccessedAt');
-        let timeDiff = moment().diff(lastAccessedAt, 'minutes');
-         if (timeDiff > 20) {
-          return true;
-        } else {
-          return false;
-        }
-      });
-    }
-    ```
-     This method would ensure that whenever you do `store.findAll('ticket')` you
-    will always get a list of tickets that are no more than 20 minutes old. In
-    case a cached version is more than 20 minutes old, `findAll` will not
-    resolve until you fetched the latest versions.
-     By default, this method returns `true` if the passed `snapshotRecordArray`
-    is empty (meaning that there are no records locally available yet),
-    otherwise, it returns `false`.
-     Note that, with default settings, `shouldBackgroundReloadAll` will always
-    re-fetch all the records in the background even if `shouldReloadAll` returns
-    `false`. You can override `shouldBackgroundReloadAll` if this does not suit
-    your use case.
-     @since 1.13.0
-    @param {Store} store
-    @param {SnapshotRecordArray} snapshotRecordArray
-    @return {Boolean}
-    @public
-  */
-  shouldReloadAll(store, snapshotRecordArray) {
-    return !snapshotRecordArray.length;
-  }
-
-  /**
-    This method is used by the store to determine if the store should
-    reload a record after the `store.findRecord` method resolves a
-    cached record.
-     This method is *only* checked by the store when the store is
-    returning a cached record.
-     If this method returns `true` the store will re-fetch a record from
-    the adapter.
-     For example, if you do not want to fetch complex data over a mobile
-    connection, or if the network is down, you can implement
-    `shouldBackgroundReloadRecord` as follows:
-     ```javascript
-    shouldBackgroundReloadRecord(store, snapshot) {
-      let { downlink, effectiveType } = navigator.connection;
-       return downlink > 0 && effectiveType === '4g';
-    }
-    ```
-     By default, this hook returns `true` so the data for the record is updated
-    in the background.
-     @since 1.13.0
-    @param {Store} store
-    @param {Snapshot} snapshot
-    @return {Boolean}
-    @public
-  */
-  shouldBackgroundReloadRecord(store, snapshot) {
-    return true;
-  }
-
-  /**
-    This method is used by the store to determine if the store should
-    reload a record array after the `store.findAll` method resolves
-    with a cached record array.
-     This method is *only* checked by the store when the store is
-    returning a cached record array.
-     If this method returns `true` the store will re-fetch all records
-    from the adapter.
-     For example, if you do not want to fetch complex data over a mobile
-    connection, or if the network is down, you can implement
-    `shouldBackgroundReloadAll` as follows:
-     ```javascript
-    shouldBackgroundReloadAll(store, snapshotArray) {
-      let { downlink, effectiveType } = navigator.connection;
-       return downlink > 0 && effectiveType === '4g';
-    }
-    ```
-     By default this method returns `true`, indicating that a background reload
-    should always be triggered.
-     @since 1.13.0
-    @param {Store} store
-    @param {SnapshotRecordArray} snapshotRecordArray
-    @return {Boolean}
-    @public
-  */
-  shouldBackgroundReloadAll(store, snapshotRecordArray) {
-    return true;
-  }
-}
 export { Adapter, BuildURLMixin };