@warp-drive/legacy 5.9.0-beta.0 → 5.9.0-beta.2

package/{declarations/adapter.d.ts → dist/unpkg/prod-deprecated/adapter-DQ9UA7FC.js}

@@ -1,3 +1,404 @@
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-DMTJ0Kb3.js";
+import EmberObject from "@ember/object";
+import { camelize, pluralize } from "@warp-drive/utilities/string";
+import * as s from "@ember/service";
+import Mixin from "@ember/object/mixin";
+
+//#region src/adapter/-private/build-url-mixin.ts
+/**
+* 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.
+*/
+/**
+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 (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: 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) {
+		if (/^\/\//.test(path) || /http(s)?:\/\//.test(path)) return path;
+		else if (path.charAt(0) === "/") return `${host}${path}`;
+		else return `${parentURL}/${path}`;
+	}
+	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);
+}
+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);
+
+//#endregion
+//#region src/adapter.ts
 /**
 * ## Overview
 *
@@ -182,11 +583,7 @@ customization, and maintenance than attempting to override methods in these adap
 
 @module
 */
-import EmberObject from "@ember/object";
-import type { Store } from "@warp-drive/core";
-import type { ModelSchema } from "@warp-drive/core/types";
-import type { AdapterPayload, MinimumAdapterInterface, SerializerOptions } from "./compat.js";
-import type { Snapshot, SnapshotRecordArray } from "./compat/-private.js";
+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
@@ -243,23 +640,28 @@ included REST adapter.
 
 @public
 */
-export declare class Adapter extends EmberObject implements MinimumAdapterInterface {
-	store: Store;
-	_coalesceFindRequests: boolean;
+var Adapter = class 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) {
@@ -272,20 +674,16 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@public
 	*/
-	findRecord(store: Store, type: ModelSchema, id: string, snapshot: Snapshot): Promise<AdapterPayload>;
+	findRecord(store, type, id, snapshot) {}
 	/**
 	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) {
@@ -298,21 +696,17 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@param neverSet a value is never provided to this argument
 	@public
 	*/
-	findAll(store: Store, type: ModelSchema, neverSet: null, snapshotRecordArray: SnapshotRecordArray): Promise<AdapterPayload>;
+	findAll(store, type, neverSet, snapshotRecordArray) {}
 	/**
 	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) {
@@ -325,25 +719,19 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@public
 	*/
-	query(store: Store, type: ModelSchema, query: Record<string, unknown>): Promise<AdapterPayload>;
+	query(store, type, query) {}
 	/**
 	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) })
@@ -351,35 +739,29 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@public
 	*/
-	queryRecord(store: Store, type: ModelSchema, query: Record<string, unknown>, adapterOptions: object): Promise<AdapterPayload>;
+	queryRecord(store, type, query, adapterOptions) {}
 	/**
 	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
@@ -389,42 +771,34 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	*/
 	/**
 	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: Snapshot, options: SerializerOptions): Record<string, unknown>;
+	serialize(snapshot, options) {
+		return snapshot.serialize(options);
+	}
 	/**
 	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',
@@ -441,16 +815,13 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@public
 	*/
-	createRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+	createRecord(store, type, snapshot) {}
 	/**
 	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
@@ -458,19 +829,15 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	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',
@@ -487,32 +854,26 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@param {Store} store
 	@param {Model} type   the Model class of the record
 	@param {Snapshot} snapshot
 	@return {Promise} promise
 	@public
 	*/
-	updateRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+	updateRecord(store, type, snapshot) {}
 	/**
 	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',
@@ -529,36 +890,38 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@param {Store} store
 	@param {Model} type   the Model class of the record
 	@param {Snapshot} snapshot
 	@return {Promise} promise
 	@public
 	*/
-	deleteRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+	deleteRecord(store, type, snapshot) {}
 	/**
 	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(): boolean;
-	set coalesceFindRequests(value: 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) {
@@ -577,7 +940,6 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	@param {Store} store
 	@param {Model} type   the Model class of the records
 	@param {Array}    ids
@@ -588,38 +950,33 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	/**
 	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: Store, snapshots: Snapshot[]): Snapshot[][];
+	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 {
@@ -627,49 +984,42 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	}
 	}
 	```
-	
 	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: Store, snapshot: Snapshot): boolean;
+	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 {
@@ -678,93 +1028,84 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	});
 	}
 	```
-	
 	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: Store, snapshotRecordArray: SnapshotRecordArray): boolean;
+	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: Store, snapshot: Snapshot): boolean;
+	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: Store, snapshotRecordArray: SnapshotRecordArray): boolean;
-}
-export { BuildURLMixin } from "./adapter/-private/build-url-mixin.js";
+	shouldBackgroundReloadAll(store, snapshotRecordArray) {
+		return true;
+	}
+};
+
+//#endregion
+export { BuildURLMixin as n, Adapter as t };
+//# sourceMappingURL=adapter-DQ9UA7FC.js.map