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

package/dist/unpkg/dev/compat-CeyxXB7K.js

@@ -0,0 +1,825 @@
+import { a as normalizeResponseHelper, c as assertIdentifierHasId, l as SnapshotRecordArray, n as FetchManager, o as iterateData, r as SaveOp, s as payloadIsNotBlank, t as upgradeStore } from "./-private-vOhxVExH.js";
+import { recordIdentifierFor } from "@warp-drive/core";
+import { getOwner } from "@ember/application";
+import { _deprecatingNormalize, assertPrivateStore } from "@warp-drive/core/store/-private";
+import { waitFor } from "@warp-drive/core/signals/-leaked";
+
+//#region src/compat/legacy-network-handler/legacy-data-fetch.ts
+function _findHasMany(adapter, store, identifier, link, relationship, options) {
+	/* @__PURE__ */ upgradeStore(store);
+	return Promise.resolve().then(() => {
+		const snapshot = store._fetchManager.createSnapshot(identifier, options);
+		const relatedLink = !link || typeof link === "string" ? link : link.href;
+		((test) => {
+			if (!test) throw new Error(`Attempted to load a hasMany relationship from a specified 'link' in the original payload, but the specified link is empty. You must provide a valid 'link' in the original payload to use 'findHasMany'`);
+		})(relatedLink);
+		((test) => {
+			if (!test) throw new Error(`Expected the adapter to implement 'findHasMany' but it does not`);
+		})(typeof adapter.findHasMany === "function");
+		return adapter.findHasMany(store, snapshot, relatedLink, relationship);
+	}).then((adapterPayload) => {
+		((test) => {
+			if (!test) throw new Error(`You made a 'findHasMany' request for a ${identifier.type}'s '${relationship.name}' relationship, using link '${JSON.stringify(link)}' , but the adapter's response did not have any data`);
+		})(payloadIsNotBlank(adapterPayload));
+		const modelClass = store.modelFor(relationship.type);
+		const serializer = store.serializerFor(relationship.type);
+		let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, "findHasMany");
+		((test) => {
+			if (!test) throw new Error(`fetched the hasMany relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${JSON.stringify(link)}', but no data member is present in the response. If no data exists, the response should set { data: [] }`);
+		})("data" in payload && Array.isArray(payload.data));
+		payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
+		return store._push(payload, true);
+	}, null);
+}
+function _findBelongsTo(store, identifier, link, relationship, options) {
+	/* @__PURE__ */ upgradeStore(store);
+	return Promise.resolve().then(() => {
+		const adapter = store.adapterFor(identifier.type);
+		((test) => {
+			if (!test) throw new Error(`You tried to load a belongsTo relationship but you have no adapter (for ${identifier.type})`);
+		})(adapter);
+		((test) => {
+			if (!test) throw new Error(`You tried to load a belongsTo relationship from a specified 'link' in the original payload but your adapter does not implement 'findBelongsTo'`);
+		})(typeof adapter.findBelongsTo === "function");
+		const snapshot = store._fetchManager.createSnapshot(identifier, options);
+		const relatedLink = !link || typeof link === "string" ? link : link.href;
+		((test) => {
+			if (!test) throw new Error(`Attempted to load a belongsTo relationship from a specified 'link' in the original payload, but the specified link is empty. You must provide a valid 'link' in the original payload to use 'findBelongsTo'`);
+		})(relatedLink);
+		return adapter.findBelongsTo(store, snapshot, relatedLink, relationship);
+	}).then((adapterPayload) => {
+		const modelClass = store.modelFor(relationship.type);
+		const serializer = store.serializerFor(relationship.type);
+		let payload = normalizeResponseHelper(serializer, store, modelClass, adapterPayload, null, "findBelongsTo");
+		((test) => {
+			if (!test) throw new Error(`fetched the belongsTo relationship '${relationship.name}' for ${identifier.type}:${identifier.id} with link '${JSON.stringify(link)}', but no data member is present in the response. If no data exists, the response should set { data: null }`);
+		})("data" in payload && (payload.data === null || typeof payload.data === "object" && !Array.isArray(payload.data)));
+		if (!payload.data && !payload.links && !payload.meta) return null;
+		payload = syncRelationshipDataFromLink(store, payload, identifier, relationship);
+		return store._push(payload, true);
+	}, null);
+}
+function syncRelationshipDataFromLink(store, payload, parentIdentifier, relationship) {
+	const relationshipData = payload.data ? iterateData(payload.data, (data, index) => {
+		const { id, type } = data;
+		ensureRelationshipIsSetToParent(data, parentIdentifier, store, relationship, index);
+		return {
+			id,
+			type
+		};
+	}) : null;
+	const relatedDataHash = {};
+	if ("meta" in payload) relatedDataHash.meta = payload.meta;
+	if ("links" in payload) relatedDataHash.links = payload.links;
+	if ("data" in payload) relatedDataHash.data = relationshipData;
+	const parentPayload = {
+		id: parentIdentifier.id,
+		type: parentIdentifier.type,
+		relationships: { [relationship.name]: relatedDataHash }
+	};
+	if (!Array.isArray(payload.included)) payload.included = [];
+	payload.included.push(parentPayload);
+	return payload;
+}
+function ensureRelationshipIsSetToParent(payload, parentIdentifier, store, parentRelationship, index) {
+	const { id, type } = payload;
+	if (!payload.relationships) payload.relationships = {};
+	const { relationships } = payload;
+	const inverse = getInverse(store, parentIdentifier, parentRelationship, type);
+	if (inverse) {
+		const { inverseKey, kind } = inverse;
+		const relationshipData = relationships[inverseKey]?.data;
+		if (typeof relationshipData !== "undefined" && !relationshipDataPointsToParent(relationshipData, parentIdentifier)) {
+			const inspect = function inspect(thing) {
+				return `'${JSON.stringify(thing)}'`;
+			};
+			const quotedType = inspect(type);
+			const quotedInverse = inspect(inverseKey);
+			const expected = inspect({
+				id: parentIdentifier.id,
+				type: parentIdentifier.type
+			});
+			const expectedModel = `${parentIdentifier.type}:${parentIdentifier.id}`;
+			const got = inspect(relationshipData);
+			const prefix = typeof index === "number" ? `data[${index}]` : `data`;
+			const path = `${prefix}.relationships.${inverseKey}.data`;
+			const data = Array.isArray(relationshipData) ? relationshipData[0] : relationshipData;
+			const other = data ? `<${data.type}:${data.id}>` : null;
+			const relationshipFetched = `${expectedModel}.${parentRelationship.kind}("${parentRelationship.name}")`;
+			const includedRecord = `<${type}:${id}>`;
+			const message = [
+				`Encountered mismatched relationship: WarpDrive expected ${path} in the payload from ${relationshipFetched} to include ${expected} but got ${got} instead.\n`,
+				`The ${includedRecord} record loaded at ${prefix} in the payload specified ${other} as its ${quotedInverse}, but should have specified ${expectedModel} (the record the relationship is being loaded from) as its ${quotedInverse} instead.`,
+				`This could mean that the response for ${relationshipFetched} may have accidentally returned ${quotedType} records that aren't related to ${expectedModel} and could be related to a different ${parentIdentifier.type} record instead.`,
+				`WarpDrive has corrected the ${includedRecord} record's ${quotedInverse} relationship to ${expectedModel} so that ${relationshipFetched} will include ${includedRecord}.`,
+				`Please update the response from the server or change your serializer to either ensure that the response for only includes ${quotedType} records that specify ${expectedModel} as their ${quotedInverse}, or omit the ${quotedInverse} relationship from the response.`
+			].join("\n");
+			((test) => {
+				if (!test) throw new Error(message);
+			})(false);
+		}
+		if (kind !== "hasMany" || typeof relationshipData !== "undefined") {
+			relationships[inverseKey] = relationships[inverseKey] || {};
+			relationships[inverseKey].data = fixRelationshipData(relationshipData ?? null, kind, parentIdentifier);
+		}
+	}
+}
+function inverseForRelationship(store, identifier, key) {
+	const definition = store.schema.fields(identifier).get(key);
+	if (!definition) return null;
+	((test) => {
+		if (!test) throw new Error(`Expected the field definition to be a relationship`);
+	})(definition.kind === "hasMany" || definition.kind === "belongsTo");
+	((test) => {
+		if (!test) throw new Error(`Expected the relationship defintion to specify the inverse type or null.`);
+	})(definition.options?.inverse === null || typeof definition.options?.inverse === "string" && definition.options.inverse.length > 0);
+	return definition.options.inverse;
+}
+function getInverse(store, parentIdentifier, parentRelationship, type) {
+	const { name: lhs_relationshipName } = parentRelationship;
+	const { type: parentType } = parentIdentifier;
+	const inverseKey = inverseForRelationship(store, { type: parentType }, lhs_relationshipName);
+	if (inverseKey) {
+		const definition = store.schema.fields({ type }).get(inverseKey);
+		((test) => {
+			if (!test) throw new Error(`Expected the field definition to be a relationship`);
+		})(definition && (definition.kind === "hasMany" || definition.kind === "belongsTo"));
+		return {
+			inverseKey,
+			kind: definition.kind
+		};
+	}
+}
+function relationshipDataPointsToParent(relationshipData, identifier) {
+	if (relationshipData === null) return false;
+	if (Array.isArray(relationshipData)) {
+		if (relationshipData.length === 0) return false;
+		for (let i = 0; i < relationshipData.length; i++) {
+			const entry = relationshipData[i];
+			if (validateRelationshipEntry(entry, identifier)) return true;
+		}
+	} else return validateRelationshipEntry(relationshipData, identifier);
+	return false;
+}
+function fixRelationshipData(relationshipData, relationshipKind, { id, type }) {
+	const parentRelationshipData = {
+		id,
+		type
+	};
+	let payload = null;
+	if (relationshipKind === "hasMany") {
+		const relData = relationshipData || [];
+		if (relationshipData) {
+			((test) => {
+				if (!test) throw new Error("expected the relationship data to be an array");
+			})(Array.isArray(relationshipData));
+			if (!relationshipData.find((v) => {
+				return v.type === parentRelationshipData.type && v.id === parentRelationshipData.id;
+			})) relData.push(parentRelationshipData);
+		} else relData.push(parentRelationshipData);
+		payload = relData;
+	} else {
+		const relData = relationshipData || {};
+		Object.assign(relData, parentRelationshipData);
+		payload = relData;
+	}
+	return payload;
+}
+function validateRelationshipEntry({ id }, { id: parentModelID }) {
+	return !!id && id.toString() === parentModelID;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@embroi_8c5bde00dfb478e637d05be822ff1428/node_modules/@embroider/macros/src/addon/runtime.js
+function config(packageRoot) {
+	return runtimeConfig.packages[packageRoot];
+}
+function getGlobalConfig() {
+	return runtimeConfig.global;
+}
+const runtimeConfig = globalThis.__embroider_macros__runtime_config__ ||= {};
+runtimeConfig.packages ||= {};
+runtimeConfig.global ||= {};
+const localConfig = initializeRuntimeMacrosConfig();
+Object.assign(runtimeConfig.packages, localConfig.packages);
+Object.assign(runtimeConfig.global, localConfig.global);
+function initializeRuntimeMacrosConfig() {
+	return {
+		"packages": {},
+		"global": {
+			"@embroider/macros": { "isTesting": false },
+			"WarpDrive": {
+				"debug": {
+					"DEBUG_RELATIONSHIP_NOTIFICATIONS": false,
+					"LOG_CACHE": false,
+					"LOG_CACHE_POLICY": false,
+					"LOG_GRAPH": false,
+					"LOG_IDENTIFIERS": false,
+					"LOG_INSTANCE_CACHE": false,
+					"LOG_METRIC_COUNTS": false,
+					"LOG_MUTATIONS": false,
+					"LOG_NOTIFICATIONS": false,
+					"LOG_OPERATIONS": false,
+					"LOG_PAYLOADS": false,
+					"LOG_REACT_SIGNAL_INTEGRATION": false,
+					"LOG_REQUESTS": false,
+					"LOG_REQUEST_STATUS": false,
+					"__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": false
+				},
+				"polyfillUUID": false,
+				"includeDataAdapter": true,
+				"compatWith": "99.0",
+				"deprecations": {
+					"DEPRECATE_CATCH_ALL": false,
+					"DEPRECATE_COMPUTED_CHAINS": false,
+					"DEPRECATE_EMBER_INFLECTOR": false,
+					"DEPRECATE_LEGACY_IMPORTS": false,
+					"DEPRECATE_MANY_ARRAY_DUPLICATES": false,
+					"DEPRECATE_NON_STRICT_ID": false,
+					"DEPRECATE_NON_STRICT_TYPES": false,
+					"DEPRECATE_NON_UNIQUE_PAYLOADS": false,
+					"DEPRECATE_RELATIONSHIP_REMOTE_UPDATE_CLEARING_LOCAL_STATE": false,
+					"DEPRECATE_STORE_EXTENDS_EMBER_OBJECT": false,
+					"DEPRECATE_TRACKING_PACKAGE": false,
+					"DISABLE_7X_DEPRECATIONS": false,
+					"ENABLE_LEGACY_REQUEST_METHODS": false,
+					"ENABLE_LEGACY_SCHEMA_SERVICE": false
+				},
+				"features": {
+					"ENFORCE_STRICT_RESOURCE_FINALIZATION": false,
+					"JSON_API_CACHE_VALIDATION_ERRORS": false,
+					"SAMPLE_FEATURE_FLAG": null
+				},
+				"activeLogging": {
+					"DEBUG_RELATIONSHIP_NOTIFICATIONS": true,
+					"LOG_CACHE": true,
+					"LOG_CACHE_POLICY": true,
+					"LOG_GRAPH": true,
+					"LOG_IDENTIFIERS": true,
+					"LOG_INSTANCE_CACHE": true,
+					"LOG_METRIC_COUNTS": true,
+					"LOG_MUTATIONS": true,
+					"LOG_NOTIFICATIONS": true,
+					"LOG_OPERATIONS": true,
+					"LOG_PAYLOADS": true,
+					"LOG_REACT_SIGNAL_INTEGRATION": true,
+					"LOG_REQUESTS": true,
+					"LOG_REQUEST_STATUS": true,
+					"__INTERNAL_LOG_NATIVE_MAP_SET_COUNTS": true
+				},
+				"env": {
+					"TESTING": true,
+					"PRODUCTION": false,
+					"DEBUG": true,
+					"IS_RECORDING": false,
+					"IS_CI": true,
+					"SHOULD_RECORD": false
+				}
+			}
+		}
+	};
+}
+function updaterMethods() {
+	return {
+		config,
+		getGlobalConfig,
+		setConfig(packageRoot, value) {
+			runtimeConfig.packages[packageRoot] = value;
+		},
+		setGlobalConfig(key, value) {
+			runtimeConfig.global[key] = value;
+		}
+	};
+}
+let updaters = typeof window !== "undefined" ? window._embroider_macros_runtime_config : void 0;
+if (updaters) {
+	let methods = updaterMethods();
+	for (let updater of updaters) updater(methods);
+}
+
+//#endregion
+//#region src/compat/legacy-network-handler/legacy-network-handler.ts
+const PotentialLegacyOperations = /* @__PURE__ */ new Set([
+	"findRecord",
+	"findAll",
+	"query",
+	"queryRecord",
+	"findBelongsTo",
+	"findHasMany",
+	"updateRecord",
+	"createRecord",
+	"deleteRecord"
+]);
+/**
+* A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/
+* `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/
+* `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
+* and {@link MinimumSerializerInterface | serializer}, passing any other
+* request through to the next handler unchanged.
+*/
+const LegacyNetworkHandler = { request(context, next) {
+	if (context.request.url || !context.request.op || !PotentialLegacyOperations.has(context.request.op)) return next(context.request);
+	const { store } = context.request;
+	/* @__PURE__ */ upgradeStore(store);
+	if (!store._fetchManager) store._fetchManager = new FetchManager(store);
+	switch (context.request.op) {
+		case "findRecord": return findRecord(context);
+		case "findAll": return findAll(context);
+		case "query": return query(context);
+		case "queryRecord": return queryRecord(context);
+		case "findBelongsTo": return findBelongsTo(context);
+		case "findHasMany": return findHasMany(context);
+		case "updateRecord": return saveRecord(context);
+		case "createRecord": return saveRecord(context);
+		case "deleteRecord": return saveRecord(context);
+		default: return next(context.request);
+	}
+} };
+function findBelongsTo(context) {
+	const { store, data, records: identifiers } = context.request;
+	const { options, record, links, useLink, field } = data;
+	const identifier = identifiers?.[0];
+	/* @__PURE__ */ upgradeStore(store);
+	const pendingRequest = identifier && store._fetchManager.getPendingFetch(identifier, options);
+	if (pendingRequest) return pendingRequest;
+	if (useLink) {
+		((test) => {
+			if (!test) throw new Error(`Expected a related link when calling store.findBelongsTo, found ${String(links)}`);
+		})(links && links.related);
+		return _findBelongsTo(store, record, links.related, field, options);
+	}
+	((test) => {
+		if (!test) throw new Error(`Expected an identifier`);
+	})(Array.isArray(identifiers) && identifiers.length === 1);
+	const manager = store._fetchManager;
+	assertIdentifierHasId(identifier);
+	return options.reload ? manager.scheduleFetch(identifier, options, context.request) : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+}
+function findHasMany(context) {
+	const { store, data, records: identifiers } = context.request;
+	const { options, record, links, useLink, field } = data;
+	/* @__PURE__ */ upgradeStore(store);
+	if (useLink) {
+		const adapter = store.adapterFor(record.type);
+		((test) => {
+			if (!test) throw new Error(`You tried to load a hasMany relationship but you have no adapter (for ${record.type})`);
+		})(adapter);
+		((test) => {
+			if (!test) throw new Error(`You tried to load a hasMany relationship from a specified 'link' in the original payload but your adapter does not implement 'findHasMany'`);
+		})(typeof adapter.findHasMany === "function");
+		((test) => {
+			if (!test) throw new Error(`Expected a related link when calling store.findHasMany, found ${String(links)}`);
+		})(links && links.related);
+		return _findHasMany(adapter, store, record, links.related, field, options);
+	}
+	((test) => {
+		if (!test) throw new Error(`Expected an array of identifiers to fetch`);
+	})(Array.isArray(identifiers));
+	const fetches = new Array(identifiers.length);
+	const manager = store._fetchManager;
+	for (let i = 0; i < identifiers.length; i++) {
+		const identifier = identifiers[i];
+		assertIdentifierHasId(identifier);
+		fetches[i] = options.reload ? manager.scheduleFetch(identifier, options, context.request) : manager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+	}
+	return Promise.all(fetches);
+}
+function saveRecord(context) {
+	const { store, data, op: operation } = context.request;
+	const { options, record: identifier } = data;
+	/* @__PURE__ */ upgradeStore(store);
+	assertPrivateStore(store);
+	store.cache.willCommit(identifier, context);
+	const saveOptions = Object.assign({ [SaveOp]: operation }, options);
+	return store._fetchManager.scheduleSave(identifier, saveOptions).then((payload) => {
+		let result;
+		store._join(() => {
+			result = store.cache.didCommit(identifier, {
+				request: context.request,
+				content: payload
+			});
+		});
+		if (store.lifetimes?.didRequest && operation === "createRecord") store.lifetimes.didRequest(context.request, { status: 201 }, null, store);
+		return store.peekRecord(result.data);
+	}).catch((e) => {
+		let err = e;
+		if (!e) err = /* @__PURE__ */ new Error(`Unknown Error Occurred During Request`);
+		else if (typeof e === "string") err = new Error(e);
+		adapterDidInvalidate(store, identifier, err);
+		throw err;
+	});
+}
+function adapterDidInvalidate(store, identifier, error) {
+	/* @__PURE__ */ upgradeStore(store);
+	if (error && error.isAdapterError === true && error.code === "InvalidError") {
+		const serializer = store.serializerFor(identifier.type);
+		if (serializer && typeof serializer.extractErrors === "function") error.errors = errorsHashToArray(serializer.extractErrors(store, store.modelFor(identifier.type), error, identifier.id));
+	}
+	const cache = store.cache;
+	if (error.errors) {
+		((test) => {
+			if (!test) throw new Error(`Expected the cache in use by resource ${String(identifier)} to have a getErrors(identifier) method for retrieving errors.`);
+		})(typeof cache.getErrors === "function");
+		let jsonApiErrors = error.errors;
+		if (jsonApiErrors.length === 0) jsonApiErrors = [{
+			title: "Invalid Error",
+			detail: "",
+			source: { pointer: "/data" }
+		}];
+		cache.commitWasRejected(identifier, jsonApiErrors);
+	} else cache.commitWasRejected(identifier);
+}
+function makeArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+const PRIMARY_ATTRIBUTE_KEY = "base";
+function errorsHashToArray(errors) {
+	const out = [];
+	if (errors) Object.keys(errors).forEach((key) => {
+		const messages = makeArray(errors[key]);
+		for (let i = 0; i < messages.length; i++) {
+			let title = "Invalid Attribute";
+			let pointer = `/data/attributes/${key}`;
+			if (key === PRIMARY_ATTRIBUTE_KEY) {
+				title = "Invalid Document";
+				pointer = `/data`;
+			}
+			out.push({
+				title,
+				detail: messages[i],
+				source: { pointer }
+			});
+		}
+	});
+	return out;
+}
+function findRecord(context) {
+	const { store, data } = context.request;
+	const { record: identifier, options } = data;
+	/* @__PURE__ */ upgradeStore(store);
+	assertPrivateStore(store);
+	let promise;
+	if (!store._instanceCache.recordIsLoaded(identifier)) promise = store._fetchManager.fetchDataIfNeededForIdentifier(identifier, options, context.request);
+	else if (options.reload) {
+		assertIdentifierHasId(identifier);
+		promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
+	} else {
+		let snapshot = null;
+		const adapter = store.adapterFor(identifier.type);
+		if (typeof options.reload === "undefined" && adapter.shouldReloadRecord && adapter.shouldReloadRecord(store, snapshot = store._fetchManager.createSnapshot(identifier, options))) {
+			assertIdentifierHasId(identifier);
+			promise = store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, { reload: true }), context.request);
+		} else {
+			if (options.backgroundReload !== false && (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(store, snapshot = snapshot || store._fetchManager.createSnapshot(identifier, options)))) {
+				assertIdentifierHasId(identifier);
+				store._fetchManager.scheduleFetch(identifier, Object.assign({}, options, { backgroundReload: true }), context.request);
+			}
+			promise = Promise.resolve(identifier);
+		}
+	}
+	return promise.then((i) => store.peekRecord(i));
+}
+function findAll(context) {
+	const { store, data } = context.request;
+	const { type, options } = data;
+	/* @__PURE__ */ upgradeStore(store);
+	assertPrivateStore(store);
+	const adapter = store.adapterFor(type);
+	((test) => {
+		if (!test) throw new Error(`You tried to load all records but you have no adapter (for ${type})`);
+	})(adapter);
+	((test) => {
+		if (!test) throw new Error(`You tried to load all records but your adapter does not implement 'findAll'`);
+	})(typeof adapter.findAll === "function");
+	const maybeRecordArray = store.recordArrayManager._live.get(type);
+	const snapshotArray = new SnapshotRecordArray(store, type, options);
+	const shouldReload = options.reload || options.reload !== false && (adapter.shouldReloadAll && adapter.shouldReloadAll(store, snapshotArray) || !adapter.shouldReloadAll && snapshotArray.length === 0);
+	let fetch;
+	if (shouldReload) {
+		maybeRecordArray && (maybeRecordArray.isUpdating = true);
+		fetch = _findAll(adapter, store, type, snapshotArray, context.request, true);
+	} else {
+		fetch = Promise.resolve(store.peekAll(type));
+		if (options.backgroundReload || options.backgroundReload !== false && (!adapter.shouldBackgroundReloadAll || adapter.shouldBackgroundReloadAll(store, snapshotArray))) {
+			maybeRecordArray && (maybeRecordArray.isUpdating = true);
+			_findAll(adapter, store, type, snapshotArray, context.request, false);
+		}
+	}
+	return fetch;
+}
+function _findAll(adapter, store, type, snapshotArray, request, isAsyncFlush) {
+	const schema = store.modelFor(type);
+	let promise = Promise.resolve().then(() => adapter.findAll(store, schema, null, snapshotArray));
+	promise = promise.then((adapterPayload) => {
+		((test) => {
+			if (!test) throw new Error(`You made a 'findAll' request for '${type}' records, but the adapter's response did not have any data`);
+		})(payloadIsNotBlank(adapterPayload));
+		/* @__PURE__ */ upgradeStore(store);
+		const serializer = store.serializerFor(type);
+		const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, "findAll");
+		store._push(payload, isAsyncFlush);
+		snapshotArray._recordArray.isUpdating = false;
+		if (getGlobalConfig().WarpDrive.debug.LOG_REQUESTS || globalThis.getWarpDriveRuntimeConfig().debug.LOG_REQUESTS) console.log(`request: findAll<${type}> background reload complete`);
+		return snapshotArray._recordArray;
+	});
+	if (!request.disableTestWaiter) promise = waitFor(promise);
+	return promise;
+}
+function query(context) {
+	const { store, data } = context.request;
+	/* @__PURE__ */ upgradeStore(store);
+	assertPrivateStore(store);
+	let { options } = data;
+	const { type, query } = data;
+	const adapter = store.adapterFor(type);
+	((test) => {
+		if (!test) throw new Error(`You tried to make a query but you have no adapter (for ${type})`);
+	})(adapter);
+	((test) => {
+		if (!test) throw new Error(`You tried to make a query but your adapter does not implement 'query'`);
+	})(typeof adapter.query === "function");
+	const recordArray = options._recordArray || store.recordArrayManager.getCollection({
+		type,
+		query
+	});
+	options = Object.assign({}, options);
+	delete options._recordArray;
+	const schema = store.modelFor(type);
+	return Promise.resolve().then(() => adapter.query(store, schema, query, recordArray, options)).then((adapterPayload) => {
+		const serializer = store.serializerFor(type);
+		const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, "query");
+		const identifiers = store._push(payload, true);
+		((test) => {
+			if (!test) throw new Error("The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.");
+		})(Array.isArray(identifiers));
+		store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
+		return recordArray;
+	});
+}
+function assertSingleResourceDocument(payload) {
+	((test) => {
+		if (!test) throw new Error(`Expected the primary data returned by the serializer for a 'queryRecord' response to be a single object or null but instead it was an array.`);
+	})(!Array.isArray(payload.data));
+}
+function queryRecord(context) {
+	const { store, data } = context.request;
+	const { type, query, options } = data;
+	/* @__PURE__ */ upgradeStore(store);
+	const adapter = store.adapterFor(type);
+	((test) => {
+		if (!test) throw new Error(`You tried to make a query but you have no adapter (for ${type})`);
+	})(adapter);
+	((test) => {
+		if (!test) throw new Error(`You tried to make a query but your adapter does not implement 'queryRecord'`);
+	})(typeof adapter.queryRecord === "function");
+	const schema = store.modelFor(type);
+	return Promise.resolve().then(() => adapter.queryRecord(store, schema, query, options)).then((adapterPayload) => {
+		const serializer = store.serializerFor(type);
+		const payload = normalizeResponseHelper(serializer, store, schema, adapterPayload, null, "queryRecord");
+		assertSingleResourceDocument(payload);
+		const identifier = store._push(payload, true);
+		return identifier ? store.peekRecord(identifier) : null;
+	});
+}
+
+//#endregion
+//#region src/compat.ts
+/**
+* Extends the signature of {@link Store} with additional
+* methods available when using the legacy network layer.
+*
+* @public
+* @noInheritDoc
+* @legacy
+*/
+/**
+* @deprecated - use {@link LegacyStoreCompat} instead
+*/
+/**
+Returns an instance of the adapter for a given type. For
+example, `adapterFor('person')` will return an instance of
+the adapter located at `app/adapters/person.js`
+
+If no `person` adapter is found, this method will look
+for an `application` adapter (the default adapter for
+your entire application).
+
+@public
+@param modelName
+*/
+function adapterFor(modelName, _allowMissing) {
+	((test) => {
+		if (!test) throw new Error(`Attempted to call store.adapterFor(), but the store instance has already been destroyed.`);
+	})(!(this.isDestroying || this.isDestroyed));
+	((test) => {
+		if (!test) throw new Error(`You need to pass a model name to the store's adapterFor method`);
+	})(modelName);
+	((test) => {
+		if (!test) throw new Error(`Passing classes to store.adapterFor has been removed. Please pass a dasherized string instead of ${modelName}`);
+	})(typeof modelName === "string");
+	/* @__PURE__ */ upgradeStore(this);
+	this._adapterCache = this._adapterCache || Object.create(null);
+	const normalizedModelName = _deprecatingNormalize(modelName);
+	const { _adapterCache } = this;
+	let adapter = _adapterCache[normalizedModelName];
+	if (adapter) return adapter;
+	const owner = getOwner(this);
+	adapter = owner.lookup(`adapter:${normalizedModelName}`);
+	if (adapter !== void 0) {
+		_adapterCache[normalizedModelName] = adapter;
+		return adapter;
+	}
+	adapter = _adapterCache.application || owner.lookup("adapter:application");
+	if (adapter !== void 0) {
+		_adapterCache[normalizedModelName] = adapter;
+		_adapterCache.application = adapter;
+		return adapter;
+	}
+	((test) => {
+		if (!test) throw new Error(`No adapter was found for '${modelName}' and no 'application' adapter was found as a fallback.`);
+	})(_allowMissing);
+}
+/**
+Returns an instance of the serializer for a given type. For
+example, `serializerFor('person')` will return an instance of
+`App.PersonSerializer`.
+
+If no `App.PersonSerializer` is found, this method will look
+for an `App.ApplicationSerializer` (the default serializer for
+your entire application).
+
+If a serializer cannot be found on the adapter, it will fall back
+to an instance of `JSONSerializer`.
+
+@public
+@param modelName the record to serialize
+*/
+function serializerFor(modelName) {
+	((test) => {
+		if (!test) throw new Error(`Attempted to call store.serializerFor(), but the store instance has already been destroyed.`);
+	})(!(this.isDestroying || this.isDestroyed));
+	((test) => {
+		if (!test) throw new Error(`You need to pass a model name to the store's serializerFor method`);
+	})(modelName);
+	((test) => {
+		if (!test) throw new Error(`Passing classes to store.serializerFor has been removed. Please pass a dasherized string instead of ${modelName}`);
+	})(typeof modelName === "string");
+	/* @__PURE__ */ upgradeStore(this);
+	this._serializerCache = this._serializerCache || Object.create(null);
+	const normalizedModelName = _deprecatingNormalize(modelName);
+	const { _serializerCache } = this;
+	let serializer = _serializerCache[normalizedModelName];
+	if (serializer) return serializer;
+	const owner = getOwner(this);
+	serializer = owner.lookup(`serializer:${normalizedModelName}`);
+	if (serializer !== void 0) {
+		_serializerCache[normalizedModelName] = serializer;
+		return serializer;
+	}
+	serializer = _serializerCache.application || owner.lookup("serializer:application");
+	if (serializer !== void 0) {
+		_serializerCache[normalizedModelName] = serializer;
+		_serializerCache.application = serializer;
+		return serializer;
+	}
+	return null;
+}
+/**
+`normalize` converts a json payload into the normalized form expected by
+{@link Store.push | push} using the serializer specified by `modelName`
+
+:::warning
+Generally it would be better to invoke the serializer yourself directly,
+or write a more specialized normalization utility.
+:::
+
+Example
+
+```js
+socket.on('message', function(message) {
+let modelName = message.model;
+let data = message.data;
+store.push(store.normalize(modelName, data));
+});
+```
+
+@legacy
+@public
+@param modelName The name of the model type for this payload
+@return The normalized payload
+*/
+function normalize(modelName, payload) {
+	/* @__PURE__ */ upgradeStore(this);
+	((test) => {
+		if (!test) throw new Error(`Attempted to call store.normalize(), but the store instance has already been destroyed.`);
+	})(!(this.isDestroying || this.isDestroyed));
+	((test) => {
+		if (!test) throw new Error(`You need to pass a model name to the store's normalize method`);
+	})(modelName);
+	((test) => {
+		if (!test) throw new Error(`Passing classes to store methods has been removed. Please pass a dasherized string instead of ${typeof modelName}`);
+	})(typeof modelName === "string");
+	const normalizedModelName = _deprecatingNormalize(modelName);
+	const serializer = this.serializerFor(normalizedModelName);
+	const schema = this.modelFor(normalizedModelName);
+	((test) => {
+		if (!test) throw new Error(`You must define a normalize method in your serializer in order to call store.normalize`);
+	})(typeof serializer?.normalize === "function");
+	return serializer.normalize(schema, payload);
+}
+/**
+Push some raw data into the store.
+
+This method can be used both to push in brand new
+records, as well as to update existing records. You
+can push in more than one type of object at once.
+All objects should be in the format expected by the
+serializer.
+
+```js [app/serializers/application.js]
+import RESTSerializer from '@warp-drive/legacy/serializer/rest';
+
+export default class ApplicationSerializer extends RESTSerializer;
+```
+
+```js
+let pushData = {
+posts: [
+{ id: 1, postTitle: "Great post", commentIds: [2] }
+],
+comments: [
+{ id: 2, commentBody: "Insightful comment" }
+]
+}
+
+store.pushPayload(pushData);
+```
+
+By default, the data will be deserialized using a default
+serializer (the application serializer if it exists).
+
+Alternatively, `pushPayload` will accept a model type which
+will determine which serializer will process the payload.
+
+```js [app/serializers/application.js]
+import RESTSerializer from '@warp-drive/legacy/serializer/rest';
+
+export default class ApplicationSerializer extends RESTSerializer;
+```
+
+```js [app/serializers/post.js]
+import JSONSerializer from '@warp-drive/legacy/serializer/json';
+
+export default JSONSerializer;
+```
+
+```js
+store.pushPayload(pushData); // Will use the application serializer
+store.pushPayload('post', pushData); // Will use the post serializer
+```
+
+@public
+@param modelName Optionally, a model type used to determine which serializer will be used
+@param inputPayload
+*/
+function pushPayload(modelName, inputPayload) {
+	/* @__PURE__ */ upgradeStore(this);
+	((test) => {
+		if (!test) throw new Error(`Attempted to call store.pushPayload(), but the store instance has already been destroyed.`);
+	})(!(this.isDestroying || this.isDestroyed));
+	const payload = inputPayload || modelName;
+	const normalizedModelName = inputPayload ? _deprecatingNormalize(modelName) : "application";
+	const serializer = this.serializerFor(normalizedModelName);
+	((test) => {
+		if (!test) throw new Error(`You cannot use 'store.pushPayload(<type>, <payload>)' unless the serializer for '${normalizedModelName}' defines 'pushPayload'`);
+	})(serializer && typeof serializer.pushPayload === "function");
+	serializer.pushPayload(this, payload);
+}
+/**
+* Serializes a record using the store's legacy network layer, as with
+* {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
+*/
+function serializeRecord(record, options) {
+	/* @__PURE__ */ upgradeStore(this);
+	if (!this._fetchManager) this._fetchManager = new FetchManager(this);
+	return this._fetchManager.createSnapshot(recordIdentifierFor(record)).serialize(options);
+}
+/**
+* Destroys any adapters/serializers the legacy network layer has created
+* for this store, invoked when the store itself is destroyed.
+*/
+function cleanup() {
+	/* @__PURE__ */ upgradeStore(this);
+	for (const adapterName in this._adapterCache) {
+		const adapter = this._adapterCache[adapterName];
+		if (typeof adapter.destroy === "function") adapter.destroy();
+	}
+	for (const serializerName in this._serializerCache) {
+		const serializer = this._serializerCache[serializerName];
+		if (typeof serializer.destroy === "function") serializer.destroy();
+	}
+}
+
+//#endregion
+export { serializeRecord as a, pushPayload as i, cleanup as n, serializerFor as o, normalize as r, LegacyNetworkHandler as s, adapterFor as t };
+//# sourceMappingURL=compat-CeyxXB7K.js.map