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

package/dist/unpkg/prod-deprecated/compat-CJ87MzDn.js

@@ -0,0 +1,547 @@
+import { a as normalizeResponseHelper, n as FetchManager, o as assertIdentifierHasId, r as SaveOp, s as SnapshotRecordArray, t as upgradeStore } from "./-private-SfXkkHKd.js";
+import { recordIdentifierFor } from "@warp-drive/core";
+import { getOwner } from "@ember/application";
+import { _deprecatingNormalize, assertPrivateStore } from "@warp-drive/core/store/-private";
+
+//#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);
+}
+
+//#endregion
+//#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;
+		return adapter.findHasMany(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, "findHasMany");
+		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);
+		const snapshot = store._fetchManager.createSnapshot(identifier, options);
+		const relatedLink = !link || typeof link === "string" ? link : link.href;
+		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");
+		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 (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;
+	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) return {
+		inverseKey,
+		kind: store.schema.fields({ type }).get(inverseKey).kind
+	};
+}
+function fixRelationshipData(relationshipData, relationshipKind, { id, type }) {
+	const parentRelationshipData = {
+		id,
+		type
+	};
+	let payload = null;
+	if (relationshipKind === "hasMany") {
+		const relData = relationshipData || [];
+		if (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;
+}
+
+//#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) return _findBelongsTo(store, record, links.related, field, options);
+	const manager = store._fetchManager;
+	/* @__PURE__ */ 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);
+		return _findHasMany(adapter, store, record, links.related, field, options);
+	}
+	const fetches = new Array(identifiers.length);
+	const manager = store._fetchManager;
+	for (let i = 0; i < identifiers.length; i++) {
+		const identifier = identifiers[i];
+		/* @__PURE__ */ 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) {
+		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) {
+		/* @__PURE__ */ 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))) {
+			/* @__PURE__ */ assertIdentifierHasId(identifier);
+			options.reload = true;
+			promise = store._fetchManager.scheduleFetch(identifier, options, context.request);
+		} else {
+			if (options.backgroundReload !== false && (options.backgroundReload || !adapter.shouldBackgroundReloadRecord || adapter.shouldBackgroundReloadRecord(store, snapshot = snapshot || store._fetchManager.createSnapshot(identifier, options)))) {
+				/* @__PURE__ */ assertIdentifierHasId(identifier);
+				options.backgroundReload = true;
+				store._fetchManager.scheduleFetch(identifier, options, 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);
+	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) => {
+		/* @__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;
+		return snapshotArray._recordArray;
+	});
+	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);
+	const recordArray = options._recordArray || store.recordArrayManager.getCollection({
+		type,
+		query
+	});
+	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);
+		store.recordArrayManager.populateManagedArray(recordArray, identifiers, payload);
+		return recordArray;
+	});
+}
+function queryRecord(context) {
+	const { store, data } = context.request;
+	const { type, query, options } = data;
+	/* @__PURE__ */ upgradeStore(store);
+	const adapter = store.adapterFor(type);
+	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");
+		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) {
+	/* @__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;
+	}
+}
+/**
+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) {
+	/* @__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);
+	const normalizedModelName = _deprecatingNormalize(modelName);
+	const serializer = this.serializerFor(normalizedModelName);
+	const schema = this.modelFor(normalizedModelName);
+	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);
+	const payload = inputPayload || modelName;
+	const normalizedModelName = inputPayload ? _deprecatingNormalize(modelName) : "application";
+	this.serializerFor(normalizedModelName).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-CJ87MzDn.js.map