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

package/dist/unpkg/dev-deprecated/-private-vOhxVExH.js

@@ -0,0 +1,896 @@
+import { assertPrivateStore, coerceId } from "@warp-drive/core/store/-private";
+import { Context } from "@warp-drive/core/reactive/-private";
+import { createDeferred } from "@warp-drive/core/request";
+import { waitFor } from "@warp-drive/core/signals/-leaked";
+import { getOrSetGlobal } from "@warp-drive/core/types/-private";
+
+//#region src/compat/legacy-network-handler/snapshot-record-array.ts
+/**
+SnapshotRecordArray is not directly instantiable.
+Instances are provided to consuming application's
+adapters for certain `findAll` requests.
+
+@hideconstructor
+@public
+*/
+var SnapshotRecordArray = class {
+	/**
+	* An array of snapshots
+	*
+	* @internal
+	*/
+	/** @internal */
+	/**
+	* The ResourceType of the underlying records for the {@link Snapshot | Snapshots} in the array
+	*/
+	/** @internal */
+	/**
+	*  A hash of adapter options passed into the store method for this request.
+	Example
+	```js [app/adapters/post.js]
+	import MyCustomAdapter from './custom-adapter';
+	export default class PostAdapter extends MyCustomAdapter {
+	findAll(store, type, sinceToken, snapshotRecordArray) {
+	if (snapshotRecordArray.adapterOptions.subscribe) {
+	// ...
+	}
+	// ...
+	}
+	}
+	```
+	*/
+	/**
+	* The relationships to include for this request.
+	Example
+	```js [app/adapters/application.js]
+	import Adapter from '@ember-data/adapter';
+	export default class ApplicationAdapter extends Adapter {
+	findAll(store, type, snapshotRecordArray) {
+	let url = `/${type.modelName}?include=${encodeURIComponent(snapshotRecordArray.include)}`;
+	return fetch(url).then((response) => response.json())
+	}
+	}
+	```
+	*/
+	/**
+	SnapshotRecordArray is not directly instantiable.
+	Instances are provided to consuming application's
+	adapters and serializers for certain requests.
+	@private
+	@constructor
+	@param {Store} store
+	@param {String} type
+	@param options
+	*/
+	constructor(store, type, options = {}) {
+		this.__store = store;
+		this._snapshots = null;
+		this.modelName = type;
+		this.adapterOptions = options.adapterOptions;
+		this.include = options.include;
+	}
+	/**
+	An array of records
+	@internal
+	*/
+	get _recordArray() {
+		return this.__store.peekAll(this.modelName);
+	}
+	/**
+	Number of records in the array
+	Example
+	```js [app/adapters/post.js]
+	import JSONAPIAdapter from '@ember-data/adapter/json-api';
+	export default class PostAdapter extends JSONAPIAdapter {
+	shouldReloadAll(store, snapshotRecordArray) {
+	return !snapshotRecordArray.length;
+	}
+	});
+	```
+	*/
+	get length() {
+		return this._recordArray.length;
+	}
+	/**
+	Get snapshots of the underlying record array
+	Example
+	```js [app/adapters/post.js]
+	import JSONAPIAdapter from '@ember-data/adapter/json-api';
+	export default class PostAdapter extends JSONAPIAdapter {
+	shouldReloadAll(store, snapshotArray) {
+	let snapshots = snapshotArray.snapshots();
+	return snapshots.any(function(ticketSnapshot) {
+	let timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt'), 'minutes');
+	if (timeDiff > 20) {
+	return true;
+	} else {
+	return false;
+	}
+	});
+	}
+	}
+	```
+	@public
+	@return Array of snapshots
+	*/
+	snapshots() {
+		if (this._snapshots !== null) return this._snapshots;
+		/* @__PURE__ */ upgradeStore(this.__store);
+		const { _fetchManager } = this.__store;
+		const LiveArrayContext = this._recordArray[Context];
+		this._snapshots = LiveArrayContext.source.map((identifier) => _fetchManager.createSnapshot(identifier));
+		return this._snapshots;
+	}
+};
+
+//#endregion
+//#region src/compat/legacy-network-handler/identifier-has-id.ts
+function assertIdentifierHasId(identifier) {
+	((test) => {
+		if (!test) throw new Error(`Attempted to schedule a fetch for a record without an id.`);
+	})(identifier && identifier.id !== null);
+}
+
+//#endregion
+//#region src/compat/legacy-network-handler/legacy-data-utils.ts
+function iterateData(data, fn) {
+	if (Array.isArray(data)) return data.map(fn);
+	else return fn(data, 0);
+}
+function payloadIsNotBlank(adapterPayload) {
+	if (Array.isArray(adapterPayload)) return true;
+	else return Object.keys(adapterPayload || {}).length !== 0;
+}
+
+//#endregion
+//#region src/compat/legacy-network-handler/serializer-response.ts
+/**
+This is a helper method that validates a JSON API top-level document
+
+The format of a document is described here:
+http://jsonapi.org/format/#document-top-level
+
+@internal
+*/
+function validateDocumentStructure(doc) {
+	{
+		const errors = [];
+		if (!doc || typeof doc !== "object") errors.push("Top level of a JSON API document must be an object");
+		else {
+			if (!("data" in doc) && !("errors" in doc) && !("meta" in doc)) errors.push("One or more of the following keys must be present: \"data\", \"errors\", \"meta\".");
+			else if ("data" in doc && "errors" in doc) errors.push("Top level keys \"errors\" and \"data\" cannot both be present in a JSON API document");
+			if ("data" in doc) {
+				if (!(doc.data === null || Array.isArray(doc.data) || typeof doc.data === "object")) errors.push("data must be null, an object, or an array");
+			}
+			if ("meta" in doc) {
+				if (typeof doc.meta !== "object") errors.push("meta must be an object");
+			}
+			if ("errors" in doc) {
+				if (!Array.isArray(doc.errors)) errors.push("errors must be an array");
+			}
+			if ("links" in doc) {
+				if (typeof doc.links !== "object") errors.push("links must be an object");
+			}
+			if ("jsonapi" in doc) {
+				if (typeof doc.jsonapi !== "object") errors.push("jsonapi must be an object");
+			}
+			if ("included" in doc) {
+				if (typeof doc.included !== "object") errors.push("included must be an array");
+			}
+		}
+		((test) => {
+			if (!test) throw new Error(`Response must be normalized to a valid JSON API document:\n\t* ${errors.join("\n	* ")}`);
+		})(errors.length === 0);
+	}
+}
+function normalizeResponseHelper(serializer, store, modelClass, payload, id, requestType) {
+	const normalizedResponse = serializer ? serializer.normalizeResponse(store, modelClass, payload, id, requestType) : payload;
+	validateDocumentStructure(normalizedResponse);
+	return normalizedResponse;
+}
+
+//#endregion
+//#region src/compat/legacy-network-handler/snapshot.ts
+/**
+Snapshot is not directly instantiable.
+Instances are provided to a consuming application's
+adapters and serializers for certain requests.
+
+Snapshots are only available when using `@ember-data/legacy-compat`
+for legacy compatibility with adapters and serializers.
+
+For serialization of records in modern paradigms, request data from
+the cache or off the record directly.
+
+@hideconstructor
+@public
+*/
+var Snapshot = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/**
+	The unique ResourceKey associated with this Snapshot.
+	@public
+	*/
+	/**
+	The ResourceType of the underlying record for this Snapshot, as a string.
+	@public
+	*/
+	/**
+	The id of the snapshot's underlying record
+	Example
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.id; // => '1'
+	```
+	@public
+	*/
+	/**
+	If `include` was passed to the options for the request, the value
+	would be available here.
+	@public
+	*/
+	/**
+	The adapterOptions passed to the request which generated this Snapshot, if any
+	@public
+	*/
+	constructor(options, identifier, store) {
+		this._store = store;
+		this.__attributes = null;
+		this._belongsToRelationships = Object.create(null);
+		this._belongsToIds = Object.create(null);
+		this._hasManyRelationships = Object.create(null);
+		this._hasManyIds = Object.create(null);
+		assertPrivateStore(store);
+		const hasRecord = !!store._instanceCache.peek(identifier);
+		this.modelName = identifier.type;
+		this.identifier = identifier;
+		if (hasRecord) this._attributes;
+		this.id = identifier.id;
+		this.adapterOptions = options.adapterOptions;
+		this.include = options.include;
+		this.modelName = identifier.type;
+		if (hasRecord) {
+			const cache = this._store.cache;
+			this._changedAttributes = cache.changedAttrs(identifier);
+		}
+	}
+	/**
+	The underlying record for this snapshot. Can be used to access methods and
+	properties defined on the record.
+	```js
+	const someValue = snapshot.record.someProp;
+	```
+	@property record
+	@public
+	*/
+	get record() {
+		const record = this._store.peekRecord(this.identifier);
+		((test) => {
+			if (!test) throw new Error(`Record ${this.identifier.type} ${this.identifier.id} (${this.identifier.lid}) is not yet loaded and thus cannot be accessed from the Snapshot during serialization`);
+		})(record !== null);
+		return record;
+	}
+	/** @internal */
+	get _attributes() {
+		if (this.__attributes !== null) return this.__attributes;
+		const attributes = this.__attributes = Object.create(null);
+		const { identifier } = this;
+		const cache = this._store.cache;
+		this.eachAttribute((key, meta) => {
+			attributes[key] = cache.getAttr(identifier, key);
+		});
+		return attributes;
+	}
+	get isNew() {
+		return this._store.cache?.isNew(this.identifier) || false;
+	}
+	/**
+	Returns the value of an attribute.
+	Example
+	```javascript
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.attr('author'); // => 'Tomster'
+	postSnapshot.attr('title'); // => 'Ember.js rocks'
+	```
+	Note: Values are loaded eagerly and cached when the snapshot is created.
+	@return The attribute value or undefined
+	@public
+	*/
+	attr(keyName) {
+		if (keyName in this._attributes) return this._attributes[keyName];
+		((test) => {
+			if (!test) throw new Error(`Model '${this.identifier.lid}' has no attribute named '${keyName}' defined.`);
+		})(false);
+	}
+	/**
+	Returns all attributes and their corresponding values.
+	::: warning ⚠️ WARNING
+	Attributes are SHALLOW copied from the cache.
+	Because they are NOT deep copied from the cache, mutating
+	any object or array fields will cause unintended side-effects
+	and bugs.
+	:::
+	Example
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
+	```
+	@return All attributes of the current snapshot
+	@public
+	*/
+	attributes() {
+		return { ...this._attributes };
+	}
+	/**
+	Returns all changed attributes and their old and new values.
+	Example
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postModel.set('title', 'Ember.js rocks!');
+	postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
+	```
+	@return All changed attributes of the current snapshot
+	@public
+	*/
+	changedAttributes() {
+		const changedAttributes = Object.create(null);
+		if (!this._changedAttributes) return changedAttributes;
+		const changedAttributeKeys = Object.keys(this._changedAttributes);
+		for (let i = 0, length = changedAttributeKeys.length; i < length; i++) {
+			const key = changedAttributeKeys[i];
+			changedAttributes[key] = this._changedAttributes[key].slice();
+		}
+		return changedAttributes;
+	}
+	/**
+	Returns the current value of a belongsTo relationship.
+	`belongsTo` takes an optional hash of options as a second parameter,
+	currently supported options are:
+	- `id`: set to `true` if you only want the ID of the related record to be
+	returned.
+	Example
+	```js
+	// store.push('post', { id: 1, title: 'Hello World' });
+	// store.createRecord('comment', { body: 'Lorem ipsum', post: post });
+	commentSnapshot.belongsTo('post'); // => Snapshot
+	commentSnapshot.belongsTo('post', { id: true }); // => '1'
+	// store.push('comment', { id: 1, body: 'Lorem ipsum' });
+	commentSnapshot.belongsTo('post'); // => undefined
+	```
+	Calling `belongsTo` will return a new Snapshot as long as there's any known
+	data for the relationship available, such as an ID. If the relationship is
+	known but unset, `belongsTo` will return `null`. If the contents of the
+	relationship is unknown `belongsTo` will return `undefined`.
+	Note: Relationships are loaded lazily and cached upon first access.
+	@public
+	@return A snapshot or ID of a known relationship or null if the
+	relationship is known but unset. undefined will be returned if the
+	contents of the relationship are unknown.
+	*/
+	belongsTo(keyName, options) {
+		const returnModeIsId = !!(options && options.id);
+		let result;
+		const store = this._store;
+		if (returnModeIsId === true && keyName in this._belongsToIds) return this._belongsToIds[keyName];
+		if (returnModeIsId === false && keyName in this._belongsToRelationships) return this._belongsToRelationships[keyName];
+		const relationshipMeta = store.schema.fields({ type: this.modelName }).get(keyName);
+		((test) => {
+			if (!test) throw new Error(`Model '${this.identifier.lid}' has no belongsTo relationship named '${keyName}' defined.`);
+		})(relationshipMeta && relationshipMeta.kind === "belongsTo");
+		((test) => {
+			if (!test) throw new Error(`snapshot.belongsTo only supported when using a cache that supports the graph`);
+		})(this._store._graph);
+		const { identifier } = this;
+		{
+			const relationship = this._store.schema.fields(identifier)?.get(keyName);
+			((test) => {
+				if (!test) throw new Error(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ""}, lid: ${identifier.lid} but no such relationship was found.`);
+			})(relationship);
+			((test) => {
+				if (!test) throw new Error(`You looked up the ${keyName} belongsTo relationship for { type: ${identifier.type}, id: ${identifier.id || ""}, lid: ${identifier.lid} but that relationship is a hasMany.`);
+			})(relationship.kind === "belongsTo");
+		}
+		const value = this._store.cache.getRelationship(identifier, keyName);
+		const data = value && value.data;
+		/* @__PURE__ */ upgradeStore(store);
+		const inverseIdentifier = data ? store.cacheKeyManager.getOrCreateRecordIdentifier(data) : null;
+		if (value && value.data !== void 0) {
+			const cache = store.cache;
+			if (inverseIdentifier && !cache.isDeleted(inverseIdentifier)) {
+				if (returnModeIsId) result = inverseIdentifier.id;
+				else result = store._fetchManager.createSnapshot(inverseIdentifier);
+			} else result = null;
+		}
+		if (returnModeIsId) this._belongsToIds[keyName] = result;
+		else this._belongsToRelationships[keyName] = result;
+		return result;
+	}
+	/**
+	Returns the current value of a hasMany relationship.
+	`hasMany` takes an optional hash of options as a second parameter,
+	currently supported options are:
+	- `ids`: set to `true` if you only want the IDs of the related records to be
+	returned.
+	Example
+	```javascript
+	// store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });
+	postSnapshot.hasMany('comments'); // => [Snapshot, Snapshot]
+	postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']
+	// store.push('post', { id: 1, title: 'Hello World' });
+	postSnapshot.hasMany('comments'); // => undefined
+	```
+	Note: Relationships are loaded lazily and cached upon first access.
+	@public
+	@return An array of snapshots or IDs of a known
+	relationship or an empty array if the relationship is known but unset.
+	undefined will be returned if the contents of the relationship is unknown.
+	*/
+	hasMany(keyName, options) {
+		const returnModeIsIds = !!(options && options.ids);
+		let results;
+		const cachedIds = this._hasManyIds[keyName];
+		const cachedSnapshots = this._hasManyRelationships[keyName];
+		if (returnModeIsIds === true && keyName in this._hasManyIds) return cachedIds;
+		if (returnModeIsIds === false && keyName in this._hasManyRelationships) return cachedSnapshots;
+		const store = this._store;
+		/* @__PURE__ */ upgradeStore(store);
+		const relationshipMeta = store.schema.fields({ type: this.modelName }).get(keyName);
+		((test) => {
+			if (!test) throw new Error(`Model '${this.identifier.lid}' has no hasMany relationship named '${keyName}' defined.`);
+		})(relationshipMeta && relationshipMeta.kind === "hasMany");
+		((test) => {
+			if (!test) throw new Error(`snapshot.hasMany only supported when using a cache that supports the graph`);
+		})(this._store._graph);
+		const { identifier } = this;
+		{
+			const relationship = this._store.schema.fields(identifier)?.get(keyName);
+			((test) => {
+				if (!test) throw new Error(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ""}, lid: ${identifier.lid} but no such relationship was found.`);
+			})(relationship);
+			((test) => {
+				if (!test) throw new Error(`You looked up the ${keyName} hasMany relationship for { type: ${identifier.type}, id: ${identifier.id || ""}, lid: ${identifier.lid} but that relationship is a belongsTo.`);
+			})(relationship.kind === "hasMany");
+		}
+		const value = this._store.cache.getRelationship(identifier, keyName);
+		if (value.data) {
+			results = [];
+			value.data.forEach((member) => {
+				const inverseIdentifier = store.cacheKeyManager.getOrCreateRecordIdentifier(member);
+				if (!store.cache.isDeleted(inverseIdentifier)) {
+					if (returnModeIsIds) results.push(inverseIdentifier.id);
+					else results.push(store._fetchManager.createSnapshot(inverseIdentifier));
+				}
+			});
+		}
+		if (returnModeIsIds) this._hasManyIds[keyName] = results;
+		else this._hasManyRelationships[keyName] = results;
+		return results;
+	}
+	/**
+	Iterates through all the attributes of the model, calling the passed
+	function on each attribute.
+	Example
+	```javascript
+	snapshot.eachAttribute(function(name, meta) {
+	// ...
+	});
+	```
+	@param callback the callback to execute
+	@param binding the optional value to which the callback's `this` should be bound
+	@public
+	*/
+	eachAttribute(callback, binding) {
+		if (typeof this._store.modelFor === "function") this._store.modelFor(this.identifier.type).eachAttribute(callback, binding);
+		else this._store.schema.fields(this.identifier).forEach((field, key) => {
+			if (field.kind === "attribute") callback.call(binding, key, field);
+		});
+	}
+	/**
+	Iterates through all the relationships of the model, calling the passed
+	function on each relationship.
+	Example
+	```javascript
+	snapshot.eachRelationship(function(name, relationship) {
+	// ...
+	});
+	```
+	@param callback the callback to execute
+	@param binding the optional value to which the callback's `this` should be bound
+	@public
+	*/
+	eachRelationship(callback, binding) {
+		if (typeof this._store.modelFor === "function") this._store.modelFor(this.identifier.type).eachRelationship(callback, binding);
+		else this._store.schema.fields(this.identifier).forEach((field, key) => {
+			if (field.kind === "belongsTo" || field.kind === "hasMany") callback.call(binding, key, field);
+		});
+	}
+	/**
+	Serializes the snapshot using the serializer for the model.
+	Example
+	```js [app/adapters/application.js]
+	import Adapter from '@ember-data/adapter';
+	export default Adapter.extend({
+	createRecord(store, type, snapshot) {
+	let data = snapshot.serialize({ includeId: true });
+	let url = `/${type.modelName}`;
+	return fetch(url, {
+	method: 'POST',
+	body: data,
+	}).then((response) => response.json())
+	}
+	});
+	```
+	@return an object whose values are primitive JSON values only
+	@public
+	*/
+	serialize(options) {
+		/* @__PURE__ */ upgradeStore(this._store);
+		const serializer = this._store.serializerFor(this.modelName);
+		((test) => {
+			if (!test) throw new Error(`Cannot serialize record, no serializer found`);
+		})(serializer);
+		return serializer.serialize(this, options);
+	}
+};
+
+//#endregion
+//#region src/compat/legacy-network-handler/fetch-manager.ts
+const SaveOp = getOrSetGlobal("SaveOp", Symbol("SaveOp"));
+/**
+* @private
+*/
+var FetchManager = class {
+	/**
+	* @internal
+	*/
+	/** @internal */
+	/**
+	* @internal
+	*/
+	/** @internal */
+	constructor(store) {
+		assertPrivateStore(store);
+		this._store = store;
+		this._pendingFetch = /* @__PURE__ */ new Map();
+		this.requestCache = store.getRequestStateService();
+		this.isDestroyed = false;
+	}
+	createSnapshot(identifier, options = {}) {
+		return new Snapshot(options, identifier, this._store);
+	}
+	/**
+	This method is called by `record.save`, and gets passed a
+	resolver for the promise that `record.save` returns.
+	It schedules saving to happen at the end of the run loop.
+	@private
+	*/
+	scheduleSave(identifier, options) {
+		const resolver = createDeferred();
+		const queryRequest = { data: [{
+			op: "saveRecord",
+			recordIdentifier: identifier,
+			options
+		}] };
+		const pendingSaveItem = {
+			snapshot: this.createSnapshot(identifier, options),
+			resolver,
+			identifier,
+			options,
+			queryRequest
+		};
+		const monitored = this.requestCache._enqueue(resolver.promise, pendingSaveItem.queryRequest);
+		_flushPendingSave(this._store, pendingSaveItem);
+		return monitored;
+	}
+	scheduleFetch(identifier, options, request) {
+		const queryRequest = { data: [{
+			op: "findRecord",
+			recordIdentifier: identifier,
+			options
+		}] };
+		const pendingFetch = this.getPendingFetch(identifier, options);
+		if (pendingFetch) return pendingFetch;
+		const modelName = identifier.type;
+		const resolver = createDeferred();
+		const pendingFetchItem = {
+			identifier,
+			resolver,
+			options,
+			queryRequest
+		};
+		const resolverPromise = resolver.promise;
+		const store = this._store;
+		const isInitialLoad = !store._instanceCache.recordIsLoaded(identifier);
+		let promise = this.requestCache._enqueue(resolverPromise, pendingFetchItem.queryRequest).then((payload) => {
+			if (payload.data && !Array.isArray(payload.data)) payload.data.lid = identifier.lid;
+			const potentiallyNewIm = store._push(payload, options.reload);
+			if (potentiallyNewIm && !Array.isArray(potentiallyNewIm)) return potentiallyNewIm;
+			return identifier;
+		}, (error) => {
+			((test) => {
+				if (!test) throw new Error(`Async Leak Detected: Expected the store to not be destroyed`);
+			})(!store.isDestroyed);
+			const cache = store.cache;
+			if (!cache || cache.isEmpty(identifier) || isInitialLoad) {
+				let isReleasable = true;
+				if (store._graph) {
+					const graph = store._graph;
+					if (!cache) {
+						isReleasable = graph.isReleasable(identifier);
+						if (!isReleasable) graph.unload(identifier, true);
+					}
+				}
+				if (cache || isReleasable) {
+					store._enableAsyncFlush = true;
+					store._instanceCache.unloadRecord(identifier);
+					store._enableAsyncFlush = null;
+				}
+			}
+			throw error;
+		});
+		if (this._pendingFetch.size === 0) new Promise((resolve) => setTimeout(resolve, 0)).then(() => {
+			this.flushAllPendingFetches();
+		});
+		const fetchesByType = this._pendingFetch;
+		let fetchesById = fetchesByType.get(modelName);
+		if (!fetchesById) {
+			fetchesById = /* @__PURE__ */ new Map();
+			fetchesByType.set(modelName, fetchesById);
+		}
+		let requestsForIdentifier = fetchesById.get(identifier);
+		if (!requestsForIdentifier) {
+			requestsForIdentifier = [];
+			fetchesById.set(identifier, requestsForIdentifier);
+		}
+		requestsForIdentifier.push(pendingFetchItem);
+		if (!request.disableTestWaiter) promise = waitFor(promise);
+		pendingFetchItem.promise = promise;
+		return promise;
+	}
+	getPendingFetch(identifier, options) {
+		const pendingFetches = this._pendingFetch.get(identifier.type)?.get(identifier);
+		if (pendingFetches) {
+			const matchingPendingFetch = pendingFetches.find((fetch) => isSameRequest(options, fetch.options));
+			if (matchingPendingFetch) return matchingPendingFetch.promise;
+		}
+	}
+	flushAllPendingFetches() {
+		if (this.isDestroyed) return;
+		const store = this._store;
+		this._pendingFetch.forEach((fetchItem, type) => _flushPendingFetchForType(store, fetchItem, type));
+		this._pendingFetch.clear();
+	}
+	fetchDataIfNeededForIdentifier(identifier, options = {}, request) {
+		const isEmpty = _isEmpty(this._store._instanceCache, identifier);
+		const isLoading = _isLoading(this._store._instanceCache, identifier);
+		let promise;
+		if (isEmpty) {
+			assertIdentifierHasId(identifier);
+			promise = this.scheduleFetch(identifier, Object.assign({}, options, { reload: true }), request);
+		} else if (isLoading) {
+			promise = this.getPendingFetch(identifier, options);
+			((test) => {
+				if (!test) throw new Error(`Expected to find a pending request for a record in the loading state, but found none`);
+			})(promise);
+		} else promise = Promise.resolve(identifier);
+		return promise;
+	}
+	destroy() {
+		this.isDestroyed = true;
+	}
+};
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+function _isEmpty(instanceCache, identifier) {
+	const cache = instanceCache.cache;
+	if (!cache) return true;
+	const isNew = cache.isNew(identifier);
+	const isDeleted = cache.isDeleted(identifier);
+	const isEmpty = cache.isEmpty(identifier);
+	return (!isNew || isDeleted) && isEmpty;
+}
+function _isLoading(cache, identifier) {
+	const req = cache.store.getRequestStateService();
+	return !cache.recordIsLoaded(identifier) && req.getPendingRequestsForRecord(identifier).some((r) => r.type === "query");
+}
+function includesSatisfies(current, existing) {
+	if (!current?.length) return true;
+	if (!existing?.length) return false;
+	const arrCurrent = (Array.isArray(current) ? current : current.split(",")).sort();
+	const arrExisting = (Array.isArray(existing) ? existing : existing.split(",")).sort();
+	if (arrCurrent.join(",") === arrExisting.join(",")) return true;
+	for (let i = 0; i < arrCurrent.length; i++) if (!arrExisting.includes(arrCurrent[i])) return false;
+	return true;
+}
+function optionsSatisfies(current, existing) {
+	return !current || current === existing || Object.keys(current).length === 0;
+}
+function isSameRequest(options = {}, existingOptions = {}) {
+	return optionsSatisfies(options.adapterOptions, existingOptions.adapterOptions) && includesSatisfies(options.include, existingOptions.include);
+}
+function _findMany(store, adapter, modelName, snapshots) {
+	const modelClass = store.modelFor(modelName);
+	const promise = Promise.resolve().then(() => {
+		const ids = snapshots.map((s) => s.id);
+		((test) => {
+			if (!test) throw new Error(`Cannot fetch a record without an id`);
+		})(ids.every((v) => v !== null));
+		((test) => {
+			if (!test) throw new Error(`Expected this adapter to implement findMany for coalescing`);
+		})(adapter.findMany);
+		const ret = adapter.findMany(store, modelClass, ids, snapshots);
+		((test) => {
+			if (!test) throw new Error("adapter.findMany returned undefined, this was very likely a mistake");
+		})(ret !== void 0);
+		return ret;
+	});
+	/* @__PURE__ */ upgradeStore(store);
+	return promise.then((adapterPayload) => {
+		((test) => {
+			if (!test) throw new Error(`You made a 'findMany' request for '${modelName}' records with ids '[${snapshots.map((s) => s.id).join(",")}]', but the adapter's response did not have any data`);
+		})(!!payloadIsNotBlank(adapterPayload));
+		const serializer = store.serializerFor(modelName);
+		return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, "findMany");
+	});
+}
+function rejectFetchedItems(fetchMap, snapshots, error) {
+	for (let i = 0, l = snapshots.length; i < l; i++) {
+		const snapshot = snapshots[i];
+		const pair = fetchMap.get(snapshot);
+		if (pair) pair.resolver.reject(error || /* @__PURE__ */ new Error(`Expected: '<${snapshot.modelName}:${snapshot.id}>' to be present in the adapter provided payload, but it was not found.`));
+	}
+}
+function handleFoundRecords(store, fetchMap, snapshots, coalescedPayload) {
+	const snapshotsById = /* @__PURE__ */ new Map();
+	for (let i = 0; i < snapshots.length; i++) {
+		const id = snapshots[i].id;
+		let snapshotGroup = snapshotsById.get(id);
+		if (!snapshotGroup) {
+			snapshotGroup = [];
+			snapshotsById.set(id, snapshotGroup);
+		}
+		snapshotGroup.push(snapshots[i]);
+	}
+	const included = Array.isArray(coalescedPayload.included) ? coalescedPayload.included : [];
+	const resources = coalescedPayload.data;
+	for (let i = 0, l = resources.length; i < l; i++) {
+		const resource = resources[i];
+		const snapshotGroup = snapshotsById.get(resource.id);
+		snapshotsById.delete(resource.id);
+		if (!snapshotGroup) included.push(resource);
+		else snapshotGroup.forEach((snapshot) => {
+			fetchMap.get(snapshot).resolver.resolve({ data: resource });
+		});
+	}
+	if (included.length > 0) store._push({
+		data: null,
+		included
+	}, true);
+	if (snapshotsById.size === 0) return;
+	const rejected = [];
+	snapshotsById.forEach((snapshotArray) => {
+		rejected.push(...snapshotArray);
+	});
+	console.warn("Ember Data expected to find records with the following ids in the adapter response from findMany but they were missing: [ \"" + [...snapshotsById.values()].map((r) => r[0].id).join("\", \"") + "\" ]", { id: "ds.store.missing-records-from-adapter" });
+	rejectFetchedItems(fetchMap, rejected);
+}
+function _fetchRecord(store, adapter, fetchItem) {
+	/* @__PURE__ */ upgradeStore(store);
+	const identifier = fetchItem.identifier;
+	const modelName = identifier.type;
+	((test) => {
+		if (!test) throw new Error(`You tried to find a record but you have no adapter (for ${modelName})`);
+	})(adapter);
+	((test) => {
+		if (!test) throw new Error(`You tried to find a record but your adapter (for ${modelName}) does not implement 'findRecord'`);
+	})(typeof adapter.findRecord === "function");
+	const snapshot = store._fetchManager.createSnapshot(identifier, fetchItem.options);
+	const klass = store.modelFor(identifier.type);
+	const id = identifier.id;
+	let promise = Promise.resolve().then(() => {
+		return adapter.findRecord(store, klass, identifier.id, snapshot);
+	});
+	promise = promise.then((adapterPayload) => {
+		((test) => {
+			if (!test) throw new Error(`Async Leak Detected: Expected the store to not be destroyed`);
+		})(!(store.isDestroyed || store.isDestroying));
+		((test) => {
+			if (!test) throw new Error(`You made a 'findRecord' request for a '${modelName}' with id '${id}', but the adapter's response did not have any data`);
+		})(!!payloadIsNotBlank(adapterPayload));
+		const serializer = store.serializerFor(modelName);
+		const payload = normalizeResponseHelper(serializer, store, klass, adapterPayload, id, "findRecord");
+		((test) => {
+			if (!test) throw new Error(`Ember Data expected the primary data returned from a 'findRecord' response to be an object but instead it found an array.`);
+		})(!Array.isArray(payload.data));
+		((test) => {
+			if (!test) throw new Error(`The 'findRecord' request for ${modelName}:${id} resolved indicating success but contained no primary data. To indicate a 404 not found you should either reject the promise returned by the adapter's findRecord method or throw a NotFoundError.`);
+		})("data" in payload && payload.data !== null && typeof payload.data === "object");
+		console.warn(`You requested a record of type '${modelName}' with id '${id}' but the adapter returned a payload with primary data having an id of '${payload.data.id}'. Use 'store.findRecord()' when the requested id is the same as the one returned by the adapter. In other cases use 'store.queryRecord()' instead.`, coerceId(payload.data.id) === coerceId(id), { id: "ds.store.findRecord.id-mismatch" });
+		return payload;
+	});
+	fetchItem.resolver.resolve(promise);
+}
+function _processCoalescedGroup(store, fetchMap, group, adapter, modelName) {
+	if (group.length > 1) _findMany(store, adapter, modelName, group).then((payloads) => {
+		handleFoundRecords(store, fetchMap, group, payloads);
+	}).catch((error) => {
+		rejectFetchedItems(fetchMap, group, error);
+	});
+	else if (group.length === 1) _fetchRecord(store, adapter, fetchMap.get(group[0]));
+	else ((test) => {
+		if (!test) throw new Error("You cannot return an empty array from adapter's method groupRecordsForFindMany");
+	})(false);
+}
+function _flushPendingFetchForType(store, pendingFetchMap, modelName) {
+	/* @__PURE__ */ upgradeStore(store);
+	const adapter = store.adapterFor(modelName);
+	if (!!adapter.findMany && adapter.coalesceFindRequests) {
+		const pendingFetchItems = [];
+		pendingFetchMap.forEach((requestsForIdentifier, identifier) => {
+			if (requestsForIdentifier.length > 1) return;
+			pendingFetchMap.delete(identifier);
+			pendingFetchItems.push(requestsForIdentifier[0]);
+		});
+		const totalItems = pendingFetchItems.length;
+		if (totalItems > 1) {
+			const snapshots = new Array(totalItems);
+			const fetchMap = /* @__PURE__ */ new Map();
+			for (let i = 0; i < totalItems; i++) {
+				const fetchItem = pendingFetchItems[i];
+				snapshots[i] = store._fetchManager.createSnapshot(fetchItem.identifier, fetchItem.options);
+				fetchMap.set(snapshots[i], fetchItem);
+			}
+			let groups;
+			if (adapter.groupRecordsForFindMany) groups = adapter.groupRecordsForFindMany(store, snapshots);
+			else groups = [snapshots];
+			for (let i = 0, l = groups.length; i < l; i++) _processCoalescedGroup(store, fetchMap, groups[i], adapter, modelName);
+		} else if (totalItems === 1) _fetchRecord(store, adapter, pendingFetchItems[0]);
+	}
+	pendingFetchMap.forEach((pendingFetchItems) => {
+		pendingFetchItems.forEach((pendingFetchItem) => {
+			_fetchRecord(store, adapter, pendingFetchItem);
+		});
+	});
+}
+function _flushPendingSave(store, pending) {
+	const { snapshot, resolver, identifier, options } = pending;
+	/* @__PURE__ */ upgradeStore(store);
+	const adapter = store.adapterFor(identifier.type);
+	const operation = options[SaveOp];
+	const modelName = snapshot.modelName;
+	const modelClass = store.modelFor(modelName);
+	((test) => {
+		if (!test) throw new Error(`You tried to update a record but you have no adapter (for ${modelName})`);
+	})(adapter);
+	((test) => {
+		if (!test) throw new Error(`You tried to update a record but your adapter (for ${modelName}) does not implement '${operation}'`);
+	})(typeof adapter[operation] === "function");
+	let promise = Promise.resolve().then(() => adapter[operation](store, modelClass, snapshot));
+	const serializer = store.serializerFor(modelName);
+	((test) => {
+		if (!test) throw new Error(`Your adapter's '${operation}' method must return a value, but it returned 'undefined'`);
+	})(promise !== void 0);
+	promise = promise.then((adapterPayload) => {
+		if (adapterPayload) return normalizeResponseHelper(serializer, store, modelClass, adapterPayload, snapshot.id, operation);
+	});
+	resolver.resolve(promise);
+}
+
+//#endregion
+//#region src/compat/-private.ts
+function upgradeStore(store) {}
+
+//#endregion
+export { normalizeResponseHelper as a, assertIdentifierHasId as c, Snapshot as i, SnapshotRecordArray as l, FetchManager as n, iterateData as o, SaveOp as r, payloadIsNotBlank as s, upgradeStore as t };
+//# sourceMappingURL=-private-vOhxVExH.js.map