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

package/dist/unpkg/prod/errors-CoKAYQJi.js

@@ -0,0 +1,1977 @@
+import { t as upgradeStore } from "./-private-SfXkkHKd.js";
+import { n as decorateMethodV2, r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime-BPCpkOf1-CVHWB0MF.js";
+import { assertPrivateStore, createLegacyManyArray, fastPush, isPrivateStore, recordIdentifierFor, storeFor } from "@warp-drive/core/store/-private";
+import { Context } from "@warp-drive/core/reactive/-private";
+import { getOrSetGlobal } from "@warp-drive/core/types/-private";
+import { computed, get } from "@ember/object";
+import { defineNonEnumerableSignal, defineSignal, memoized, notifyInternalSignal } from "@warp-drive/core/signals/-leaked";
+import { EnableHydration } from "@warp-drive/core/types/request";
+import PromiseProxyMixin from "@ember/object/promise-proxy-mixin";
+import ObjectProxy from "@ember/object/proxy";
+import { A } from "@ember/array";
+import ArrayProxy from "@ember/array/proxy";
+import { mapBy, not } from "@ember/object/computed";
+
+//#region src/model/-private/promise-proxy-base.js
+const PromiseObject = ObjectProxy.extend(PromiseProxyMixin);
+
+//#endregion
+//#region src/model/-private/promise-belongs-to.ts
+const LegacyPromiseProxy = Symbol.for("LegacyPromiseProxy");
+const Extended = PromiseObject;
+/**
+A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
+to the underlying belongsTo model.
+Right now we proxy:
+* `reload()`
+@class PromiseBelongsTo
+@private
+*/
+var PromiseBelongsTo = class extends Extended {
+	get id() {
+		const { key, legacySupport } = this._belongsToState;
+		return legacySupport.referenceFor("belongsTo", key).id();
+	}
+	static {
+		decorateMethodV2(this.prototype, "id", [memoized]);
+	}
+	get meta() {}
+	static {
+		decorateMethodV2(this.prototype, "meta", [computed()]);
+	}
+	async reload(options) {
+		const { key, legacySupport } = this._belongsToState;
+		await legacySupport.reloadBelongsTo(key, options);
+		return this;
+	}
+};
+PromiseBelongsTo.prototype[LegacyPromiseProxy] = true;
+
+//#endregion
+//#region src/model/-private/promise-many-array.ts
+/**
+This class is returned as the result of accessing an async hasMany relationship
+on an instance of a Model extending from `@warp-drive/legacy/model`.
+
+A PromiseManyArray is an iterable proxy that allows templates to consume related
+ManyArrays and update once their contents are no longer pending.
+
+In your JS code you should resolve the promise first.
+
+```js
+const comments = await post.comments;
+```
+
+@public
+*/
+var PromiseManyArray = class {
+	/**
+	* The promise for the relationship's content, or `null` once
+	* {@link PromiseManyArray.destroy | destroy} has been called.
+	*/
+	/**
+	* Whether {@link PromiseManyArray.destroy | destroy} has been called.
+	*/
+	/**
+	* The resolved `ManyArray` for the relationship, if the promise has
+	* resolved, else `null`.
+	*/
+	constructor(promise, content) {
+		this._update(promise, content);
+		this.isDestroyed = false;
+		this[LegacyPromiseProxy] = true;
+	}
+	/**
+	* Retrieve the length of the content
+	* @public
+	*/
+	get length() {
+		return this.content ? this.content.length : 0;
+	}
+	/**
+	* @private
+	*/
+	static {
+		decorateMethodV2(this.prototype, "length", [memoized]);
+	}
+	get "[]"() {
+		return this.content?.length && this.content;
+	}
+	/**
+	* Iterate the proxied content. Called by the glimmer iterator in #each
+	* We do not guarantee that forEach will always be available. This
+	* may eventually be made to use Symbol.Iterator once glimmer supports it.
+	*
+	* @param cb
+	* @return
+	* @private
+	*/
+	static {
+		decorateMethodV2(this.prototype, "[]", [memoized]);
+	}
+	forEach(cb) {
+		if (this.content && this.length) this.content.forEach(cb);
+	}
+	/**
+	* Reload the relationship
+	* @public
+	*/
+	reload(options) {
+		this.content.reload(options);
+		return this;
+	}
+	/**
+	* Whether the loading promise is still pending
+	*
+	* @public
+	*/
+	/**
+	* Whether the loading promise rejected
+	*
+	* @public
+	*/
+	/**
+	* Whether the loading promise succeeded
+	*
+	* @public
+	*/
+	/**
+	* Whether the loading promise completed (resolved or rejected)
+	*
+	* @public
+	*/
+	/**
+	* chain this promise
+	*
+	* @public
+	*/
+	then(success, rejected) {
+		return this.promise.then(success, rejected);
+	}
+	/**
+	* catch errors thrown by this promise
+	* @public
+	*/
+	catch(cb) {
+		return this.promise.catch(cb);
+	}
+	/**
+	* run cleanup after this promise completes
+	*
+	* @public
+	*/
+	finally(cb) {
+		return this.promise.finally(cb);
+	}
+	/**
+	* Tears down this proxy, releasing its {@link PromiseManyArray.content | content} and
+	* {@link PromiseManyArray.promise | promise} and marking it as {@link PromiseManyArray.isDestroyed | destroyed}.
+	*
+	* @public
+	*/
+	destroy() {
+		this.isDestroyed = true;
+		this.content = null;
+		this.promise = null;
+	}
+	/**
+	* Retrieve the links for this relationship
+	* @public
+	*/
+	get links() {
+		return this.content ? this.content.links : void 0;
+	}
+	/**
+	* Retrieve the meta for this relationship
+	* @public
+	*/
+	static {
+		decorateMethodV2(this.prototype, "links", [memoized]);
+	}
+	get meta() {
+		return this.content ? this.content.meta : void 0;
+	}
+	/** @internal */
+	static {
+		decorateMethodV2(this.prototype, "meta", [memoized]);
+	}
+	_update(promise, content) {
+		if (content !== void 0) this.content = content;
+		this.promise = tapPromise(this, promise);
+	}
+	static create({ promise, content }) {
+		return new this(promise, content);
+	}
+};
+defineSignal(PromiseManyArray.prototype, "content", null);
+defineSignal(PromiseManyArray.prototype, "isPending", false);
+defineSignal(PromiseManyArray.prototype, "isRejected", false);
+defineSignal(PromiseManyArray.prototype, "isFulfilled", false);
+defineSignal(PromiseManyArray.prototype, "isSettled", false);
+function tapPromise(proxy, promise) {
+	proxy.isPending = true;
+	proxy.isSettled = false;
+	proxy.isFulfilled = false;
+	proxy.isRejected = false;
+	return Promise.resolve(promise).then((content) => {
+		proxy.isPending = false;
+		proxy.isFulfilled = true;
+		proxy.isSettled = true;
+		proxy.content = content;
+		return content;
+	}, (error) => {
+		proxy.isPending = false;
+		proxy.isFulfilled = false;
+		proxy.isRejected = true;
+		proxy.isSettled = true;
+		throw error;
+	});
+}
+
+//#endregion
+//#region src/model/-private/references/has-many.ts
+function isResourceIdentiferWithRelatedLinks$1(value) {
+	return Boolean(value && value.links && value.links.related);
+}
+/**
+A `HasManyReference` is a low-level API that allows access
+and manipulation of a hasMany relationship.
+
+It is especially useful when you're dealing with `async` relationships
+from `@warp-drive/legacy/model` as it allows synchronous access to
+the relationship data if loaded, as well as APIs for loading, reloading
+the data or accessing available information without triggering a load.
+
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
+that need to be loaded/reloaded with more precise timing than marking the
+relationship as `async` and relying on autofetch would have allowed.
+
+However,keep in mind that marking a relationship as `async: false` will introduce
+bugs into your application if the data is not always guaranteed to be available
+by the time the relationship is accessed. Ergo, it is recommended when using this
+approach to utilize `links` for unloaded relationship state instead of identifiers.
+
+Reference APIs are entangled with the relationship's underlying state,
+thus any getters or cached properties that utilize these will properly
+invalidate if the relationship state changes.
+
+References are "stable", meaning that multiple calls to retrieve the reference
+for a given relationship will always return the same HasManyReference.
+
+@class HasManyReference
+@public
+*/
+var HasManyReference = class {
+	/**
+	* The field name on the parent record for this has-many relationship.
+	*
+	* @property key
+	* @type {String}
+	* @public
+	*/
+	/**
+	* The type of resource this relationship will contain.
+	*
+	* @property type
+	* @type {String}
+	* @public
+	*/
+	___token;
+	___identifier;
+	___relatedTokenMap;
+	constructor(store, graph, parentIdentifier, hasManyRelationship, key) {
+		this.graph = graph;
+		this.key = key;
+		this.hasManyRelationship = hasManyRelationship;
+		this.type = hasManyRelationship.definition.type;
+		this.store = store;
+		this.___identifier = parentIdentifier;
+		this.___token = store.notifications.subscribe(parentIdentifier, (_, bucket, notifiedKey) => {
+			if (bucket === "relationships" && notifiedKey === key) this._ref++;
+		});
+		this.___relatedTokenMap = /* @__PURE__ */ new Map();
+	}
+	/**
+	* This method should never be called by user code.
+	*
+	* @internal
+	*/
+	destroy() {
+		this.store.notifications.unsubscribe(this.___token);
+		this.___relatedTokenMap.forEach((token) => {
+			this.store.notifications.unsubscribe(token);
+		});
+		this.___relatedTokenMap.clear();
+	}
+	/**
+	* An array of identifiers for the records that this reference refers to.
+	*
+	* @property identifiers
+	* @type {ResourceKey[]}
+	* @public
+	*/
+	get identifiers() {
+		ensureRefCanSubscribe(this);
+		this._ref;
+		const resource = this._resource();
+		const map = this.___relatedTokenMap;
+		this.___relatedTokenMap = /* @__PURE__ */ new Map();
+		if (resource && resource.data) return resource.data.map((resourceIdentifier) => {
+			const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resourceIdentifier);
+			let token = map.get(identifier);
+			if (token) map.delete(identifier);
+			else token = this.store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
+				if (bucket === "identity" || bucket === "attributes" && notifiedKey === "id") this._ref++;
+			});
+			this.___relatedTokenMap.set(identifier, token);
+			return identifier;
+		});
+		map.forEach((token) => {
+			this.store.notifications.unsubscribe(token);
+		});
+		map.clear();
+		return [];
+	}
+	static {
+		decorateMethodV2(this.prototype, "identifiers", [memoized]);
+	}
+	_resource() {
+		return this.store.cache.getRelationship(this.___identifier, this.key);
+	}
+	/**
+	This returns a string that represents how the reference will be
+	looked up when it is loaded. If the relationship has a link it will
+	use the "link" otherwise it defaults to "id".
+	Example
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	let commentsRef = post.hasMany('comments');
+	// get the identifier of the reference
+	if (commentsRef.remoteType() === "ids") {
+	let ids = commentsRef.ids();
+	} else if (commentsRef.remoteType() === "link") {
+	let link = commentsRef.link();
+	}
+	```
+	@public
+	@return The name of the remote type. This should either be `link` or `ids`
+	*/
+	remoteType() {
+		const value = this._resource();
+		if (value && value.links && value.links.related) return "link";
+		return "ids";
+	}
+	/**
+	`ids()` returns an array of the record IDs in this relationship.
+	Example
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	let commentsRef = post.hasMany('comments');
+	commentsRef.ids(); // ['1']
+	```
+	@public
+	@return The ids in this has-many relationship
+	*/
+	ids() {
+		return this.identifiers.map((identifier) => identifier.id);
+	}
+	/**
+	The link WarpDrive will use to fetch or reload this belongs-to
+	relationship. By default it uses only the "related" resource linkage.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	user: belongsTo('user', { async: true, inverse: null })
+	});
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	links: {
+	related: '/articles/1/author'
+	}
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	// get the identifier of the reference
+	if (userRef.remoteType() === "link") {
+	let link = userRef.link();
+	}
+	```
+	@public
+	@return The link WarpDrive will use to fetch or reload this belongs-to relationship.
+	*/
+	link() {
+		const resource = this._resource();
+		if (isResourceIdentiferWithRelatedLinks$1(resource)) {
+			if (resource.links) {
+				const related = resource.links.related;
+				return !related || typeof related === "string" ? related : related.href;
+			}
+		}
+		return null;
+	}
+	/**
+	* any links that have been received for this relationship
+	*
+	* @public
+	* @return
+	*/
+	links() {
+		const resource = this._resource();
+		return resource && resource.links ? resource.links : null;
+	}
+	/**
+	The meta data for the has-many relationship.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	users: hasMany('user', { async: true, inverse: null })
+	});
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	users: {
+	links: {
+	related: {
+	href: '/articles/1/authors'
+	},
+	},
+	meta: {
+	lastUpdated: 1458014400000
+	}
+	}
+	}
+	}
+	});
+	let usersRef = blog.hasMany('user');
+	usersRef.meta() // { lastUpdated: 1458014400000 }
+	```
+	@public
+	@return The meta information for the belongs-to relationship.
+	*/
+	meta() {
+		let meta = null;
+		const resource = this._resource();
+		if (resource && resource.meta && typeof resource.meta === "object") meta = resource.meta;
+		return meta;
+	}
+	/**
+	`push` can be used to update the data in the relationship and WarpDrive
+	will treat the new data as the canonical value of this relationship on
+	the backend. An empty array will signify the canonical value should be
+	empty.
+	Example model
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	Setup some initial state, note we haven't loaded the comments yet:
+	```js
+	const post = store.push({
+	data: {
+	type: 'post',
+	id: '1',
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: '1' }]
+	}
+	}
+	}
+	});
+	const commentsRef = post.hasMany('comments');
+	commentsRef.ids(); // ['1']
+	```
+	Update the state using `push`, note we can do this even without
+	having loaded these comments yet by providing resource identifiers.
+	Both full resources and resource identifiers are supported.
+	```js
+	await commentsRef.push({
+	data: [
+	{ type: 'comment', id: '2' },
+	{ type: 'comment', id: '3' },
+	]
+	});
+	commentsRef.ids(); // ['2', '3']
+	```
+	For convenience, you can also pass in an array of resources or resource identifiers
+	without wrapping them in the `data` property:
+	```js
+	await commentsRef.push([
+	{ type: 'comment', id: '4' },
+	{ type: 'comment', id: '5' },
+	]);
+	commentsRef.ids(); // ['4', '5']
+	```
+	When using the `data` property, you may also include other resource data via included,
+	as well as provide new links and meta to the relationship.
+	```js
+	await commentsRef.push({
+	links: {
+	related: '/posts/1/comments'
+	},
+	meta: {
+	total: 2
+	},
+	data: [
+	{ type: 'comment', id: '4' },
+	{ type: 'comment', id: '5' },
+	],
+	included: [
+	{ type: 'other-thing', id: '1', attributes: { foo: 'bar' },
+	]
+	});
+	```
+	By default, the store will attempt to fetch any unloaded records before resolving
+	the returned promise with the ManyArray.
+	Alternatively, pass `true` as the second argument to avoid fetching unloaded records
+	and instead the promise will resolve with void without attempting to fetch. This is
+	particularly useful if you want to update the state of the relationship without
+	forcing the load of all of the associated records.
+	@public
+	@param doc a JSONAPI document object describing the new value of this relationship.
+	@param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
+	*/
+	async push(doc, skipFetch) {
+		const { store } = this;
+		const dataDoc = Array.isArray(doc) ? { data: doc } : doc;
+		const isResourceData = Array.isArray(dataDoc.data) && dataDoc.data.length > 0 && isMaybeResource(dataDoc.data[0]);
+		const identifiers = !Array.isArray(dataDoc.data) ? [] : isResourceData ? store._push(dataDoc, true) : dataDoc.data.map((i) => store.cacheKeyManager.getOrCreateRecordIdentifier(i));
+		const { identifier } = this.hasManyRelationship;
+		const newData = {};
+		if (Array.isArray(dataDoc.data)) newData.data = identifiers;
+		if ("links" in dataDoc) newData.links = dataDoc.links;
+		if ("meta" in dataDoc) newData.meta = dataDoc.meta;
+		assertPrivateStore(store);
+		store._join(() => {
+			this.graph.push({
+				op: "updateRelationship",
+				record: identifier,
+				field: this.key,
+				value: newData
+			});
+		});
+		if (!skipFetch) return this.load();
+	}
+	_isLoaded() {
+		if (!this.hasManyRelationship.state.hasReceivedData) return false;
+		const relationship = this.graph.getData(this.hasManyRelationship.identifier, this.key);
+		return relationship.data ? relationship.data.every((identifier) => {
+			assertPrivateStore(this.store);
+			return this.store._instanceCache.recordIsLoaded(identifier, true) === true;
+		}) : false;
+	}
+	/**
+	`value()` synchronously returns the current value of the has-many
+	relationship. Unlike `record.relationshipName`, calling
+	`value()` on a reference does not trigger a fetch if the async
+	relationship is not yet loaded. If the relationship is not loaded
+	it will always return `null`.
+	Example
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	let commentsRef = post.hasMany('comments');
+	post.comments.then(function(comments) {
+	commentsRef.value() === comments
+	})
+	```
+	@public
+	*/
+	value() {
+		const support = LEGACY_SUPPORT.get(this.___identifier);
+		if (!ensureRefCanSubscribe(this)) {
+			this._ref;
+			return null;
+		}
+		return support.getManyArray(this.key);
+	}
+	/**
+	Loads the relationship if it is not already loaded.  If the
+	relationship is already loaded this method does not trigger a new
+	load. This causes a request to the specified
+	relationship link or reloads all items currently in the relationship.
+	Example
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	let commentsRef = post.hasMany('comments');
+	commentsRef.load().then(function(comments) {
+	//...
+	});
+	```
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference.
+	Example
+	```javascript
+	commentsRef.load({ adapterOptions: { isPrivate: true } })
+	.then(function(comments) {
+	//...
+	});
+	```
+	```js [app/adapters/comment.js]
+	export default ApplicationAdapter.extend({
+	findMany(store, type, id, snapshots) {
+	// In the adapter you will have access to adapterOptions.
+	let adapterOptions = snapshots[0].adapterOptions;
+	}
+	});
+	```
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the ManyArray in
+	this has-many relationship.
+	*/
+	async load(options) {
+		const support = LEGACY_SUPPORT.get(this.___identifier);
+		return !this.hasManyRelationship.definition.isAsync && !areAllInverseRecordsLoaded(this.store, this._resource()) ? support.reloadHasMany(this.key, options) : support.getHasMany(this.key, options);
+	}
+	/**
+	Reloads this has-many relationship. This causes a request to the specified
+	relationship link or reloads all items currently in the relationship.
+	Example
+	```js [app/models/post.js]
+	import { Model, hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	let commentsRef = post.hasMany('comments');
+	commentsRef.reload().then(function(comments) {
+	//...
+	});
+	```
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference. A full example
+	can be found in the `load` method.
+	Example
+	```javascript
+	commentsRef.reload({ adapterOptions: { isPrivate: true } })
+	```
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the ManyArray in this has-many relationship.
+	*/
+	reload(options) {
+		return LEGACY_SUPPORT.get(this.___identifier).reloadHasMany(this.key, options);
+	}
+};
+defineNonEnumerableSignal(HasManyReference.prototype, "_ref", 0);
+function isMaybeResource(object) {
+	return Object.keys(object).filter((k) => k !== "id" && k !== "type" && k !== "lid").length > 0;
+}
+function ensureRefCanSubscribe(rel) {
+	if (!rel._isLoaded()) {
+		const edge = rel.graph.get(rel.___identifier, rel.key);
+		edge.accessed = true;
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/model/-private/references/belongs-to.ts
+function isResourceIdentiferWithRelatedLinks(value) {
+	return Boolean(value && value.links && value.links.related);
+}
+/**
+A `BelongsToReference` is a low-level API that allows access
+and manipulation of a belongsTo relationship.
+
+It is especially useful when you're dealing with `async` relationships
+from `@warp-drive/legacy/model` as it allows synchronous access to
+the relationship data if loaded, as well as APIs for loading, reloading
+the data or accessing available information without triggering a load.
+
+It may also be useful when using `sync` relationships with `@warp-drive/legacy/model`
+that need to be loaded/reloaded with more precise timing than marking the
+relationship as `async` and relying on autofetch would have allowed.
+
+However,keep in mind that marking a relationship as `async: false` will introduce
+bugs into your application if the data is not always guaranteed to be available
+by the time the relationship is accessed. Ergo, it is recommended when using this
+approach to utilize `links` for unloaded relationship state instead of identifiers.
+
+Reference APIs are entangled with the relationship's underlying state,
+thus any getters or cached properties that utilize these will properly
+invalidate if the relationship state changes.
+
+References are "stable", meaning that multiple calls to retrieve the reference
+for a given relationship will always return the same HasManyReference.
+
+@public
+*/
+var BelongsToReference = class {
+	/**
+	* The field name on the parent record for this has-many relationship.
+	*
+	*/
+	/**
+	* The type of resource this relationship will contain.
+	*
+	*/
+	constructor(store, graph, parentIdentifier, belongsToRelationship, key) {
+		this.graph = graph;
+		this.key = key;
+		this.belongsToRelationship = belongsToRelationship;
+		this.type = belongsToRelationship.definition.type;
+		this.store = store;
+		this.___identifier = parentIdentifier;
+		this.___relatedToken = null;
+		this.___token = store.notifications.subscribe(parentIdentifier, (_, bucket, notifiedKey) => {
+			if (bucket === "relationships" && notifiedKey === key) this._ref++;
+		});
+	}
+	destroy() {
+		this.store.notifications.unsubscribe(this.___token);
+		this.___token = null;
+		if (this.___relatedToken) {
+			this.store.notifications.unsubscribe(this.___relatedToken);
+			this.___relatedToken = null;
+		}
+	}
+	/**
+	* The identifier of the record that this reference refers to.
+	* `null` if no related record is known.
+	*
+	*/
+	get identifier() {
+		if (this.___relatedToken) {
+			this.store.notifications.unsubscribe(this.___relatedToken);
+			this.___relatedToken = null;
+		}
+		const resource = this._resource();
+		if (resource && resource.data) {
+			const identifier = this.store.cacheKeyManager.getOrCreateRecordIdentifier(resource.data);
+			this.___relatedToken = this.store.notifications.subscribe(identifier, (_, bucket, notifiedKey) => {
+				if (bucket === "identity" || bucket === "attributes" && notifiedKey === "id") this._ref++;
+			});
+			return identifier;
+		}
+		return null;
+	}
+	/**
+	The `id` of the record that this reference refers to. Together, the
+	`type()` and `id()` methods form a composite key for the identity
+	map. This can be used to access the id of an async relationship
+	without triggering a fetch that would normally happen if you
+	attempted to use `record.relationship.id`.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	// get the identifier of the reference
+	if (userRef.remoteType() === "id") {
+	let id = userRef.id();
+	}
+	```
+	@public
+	@return The id of the record in this belongsTo relationship.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "identifier", [memoized]);
+	}
+	id() {
+		return this.identifier?.id || null;
+	}
+	/**
+	The link WarpDrive will use to fetch or reload this belongs-to
+	relationship. By default it uses only the "related" resource linkage.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	user: belongsTo('user', { async: true, inverse: null })
+	});
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	links: {
+	related: '/articles/1/author'
+	}
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	// get the identifier of the reference
+	if (userRef.remoteType() === "link") {
+	let link = userRef.link();
+	}
+	```
+	@public
+	@return The link WarpDrive will use to fetch or reload this belongs-to relationship.
+	*/
+	link() {
+		const resource = this._resource();
+		if (isResourceIdentiferWithRelatedLinks(resource)) {
+			if (resource.links) {
+				const related = resource.links.related;
+				return !related || typeof related === "string" ? related : related.href;
+			}
+		}
+		return null;
+	}
+	/**
+	* any links that have been received for this relationship
+	*
+	* @public
+	* @return
+	*/
+	links() {
+		const resource = this._resource();
+		return resource && resource.links ? resource.links : null;
+	}
+	/**
+	The meta data for the belongs-to relationship.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default Model.extend({
+	user: belongsTo('user', { async: true, inverse: null })
+	});
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	links: {
+	related: {
+	href: '/articles/1/author'
+	},
+	},
+	meta: {
+	lastUpdated: 1458014400000
+	}
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	userRef.meta() // { lastUpdated: 1458014400000 }
+	```
+	@public
+	@return The meta information for the belongs-to relationship.
+	*/
+	meta() {
+		let meta = null;
+		const resource = this._resource();
+		if (resource && resource.meta && typeof resource.meta === "object") meta = resource.meta;
+		return meta;
+	}
+	_resource() {
+		this._ref;
+		return this.store.cache.getRelationship(this.___identifier, this.key);
+	}
+	/**
+	This returns a string that represents how the reference will be
+	looked up when it is loaded. If the relationship has a link it will
+	use the "link" otherwise it defaults to "id".
+	Example
+	```js [app/models/post.js]
+	import Model, { hasMany } from '@warp-drive/legacy/model';
+	export default class PostModel extends Model {
+	@hasMany('comment', { async: true, inverse: null }) comments;
+	}
+	```
+	```javascript
+	let post = store.push({
+	data: {
+	type: 'post',
+	id: 1,
+	relationships: {
+	comments: {
+	data: [{ type: 'comment', id: 1 }]
+	}
+	}
+	}
+	});
+	let commentsRef = post.hasMany('comments');
+	// get the identifier of the reference
+	if (commentsRef.remoteType() === "ids") {
+	let ids = commentsRef.ids();
+	} else if (commentsRef.remoteType() === "link") {
+	let link = commentsRef.link();
+	}
+	```
+	@public
+	@return The name of the remote type. This should either be `link` or `id`
+	*/
+	remoteType() {
+		if (isResourceIdentiferWithRelatedLinks(this._resource())) return "link";
+		return "id";
+	}
+	/**
+	`push` can be used to update the data in the relationship and WarpDrive
+	will treat the new data as the canonical value of this relationship on
+	the backend. A value of `null` (e.g. `{ data: null }`) can be passed to
+	clear the relationship.
+	Example model
+	```js [app/models/blog.js]
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	```
+	Setup some initial state, note we haven't loaded the user yet:
+	```js
+	const blog = store.push({
+	data: {
+	type: 'blog',
+	id: '1',
+	relationships: {
+	user: {
+	data: { type: 'user', id: '1' }
+	}
+	}
+	}
+	});
+	const userRef = blog.belongsTo('user');
+	userRef.id(); // '1'
+	```
+	Update the state using `push`, note we can do this even without
+	having loaded the user yet by providing a resource-identifier.
+	Both full a resource and a resource-identifier are supported.
+	```js
+	await userRef.push({
+	data: {
+	type: 'user',
+	id: '2',
+	}
+	});
+	userRef.id(); // '2'
+	```
+	You may also pass in links and meta fore the relationship, and sideload
+	additional resources that might be required.
+	```js
+	await userRef.push({
+	data: {
+	type: 'user',
+	id: '2',
+	},
+	links: {
+	related: '/articles/1/author'
+	},
+	meta: {
+	lastUpdated: Date.now()
+	},
+	included: [
+	{
+	type: 'user-preview',
+	id: '2',
+	attributes: {
+	username: '@runspired'
+	}
+	}
+	]
+	});
+	```
+	By default, the store will attempt to fetch the record if it is not loaded or its
+	resource data is not included in the call to `push` before resolving the returned
+	promise with the new state..
+	Alternatively, pass `true` as the second argument to avoid fetching unloaded records
+	and instead the promise will resolve with void without attempting to fetch. This is
+	particularly useful if you want to update the state of the relationship without
+	forcing the load of all of the associated record.
+	@public
+	@param doc a JSONAPI document object describing the new value of this relationship.
+	@param skipFetch [optional] if `true`, do not attempt to fetch unloaded records
+	@return a promise that resolves with the record in this belongs-to relationship after the push has completed.
+	*/
+	async push(doc, skipFetch) {
+		const { store } = this;
+		const added = doc.data && isMaybeResource(doc.data) ? store._push(doc, true) : doc.data ? store.cacheKeyManager.getOrCreateRecordIdentifier(doc.data) : null;
+		const { identifier } = this.belongsToRelationship;
+		const newData = {};
+		if (doc.data || doc.data === null) newData.data = added;
+		if ("links" in doc) newData.links = doc.links;
+		if ("meta" in doc) newData.meta = doc.meta;
+		assertPrivateStore(store);
+		store._join(() => {
+			this.graph.push({
+				op: "updateRelationship",
+				record: identifier,
+				field: this.key,
+				value: newData
+			});
+		});
+		if (!skipFetch) return this.load();
+	}
+	/**
+	`value()` synchronously returns the current value of the belongs-to
+	relationship. Unlike `record.relationshipName`, calling
+	`value()` on a reference does not trigger a fetch if the async
+	relationship is not yet loaded. If the relationship is not loaded
+	it will always return `null`.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	userRef.value(); // null
+	// provide data for reference
+	userRef.push({
+	data: {
+	type: 'user',
+	id: 1,
+	attributes: {
+	username: "@user"
+	}
+	}
+	}).then(function(user) {
+	userRef.value(); // user
+	});
+	```
+	@public
+	@return the record in this relationship
+	*/
+	value() {
+		const resource = this._resource();
+		return resource && resource.data ? this.store.peekRecord(resource.data) : null;
+	}
+	/**
+	Loads a record in a belongs-to relationship if it is not already
+	loaded. If the relationship is already loaded this method does not
+	trigger a new load.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	userRef.value(); // null
+	userRef.load().then(function(user) {
+	userRef.value() === user
+	});
+	```
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference.
+	Example
+	```javascript
+	userRef.load({ adapterOptions: { isPrivate: true } }).then(function(user) {
+	userRef.value() === user;
+	});
+	```
+	```js [app/adapters/user.js]
+	import Adapter from '@warp-drive/legacy/adapter';
+	export default class UserAdapter extends Adapter {
+	findRecord(store, type, id, snapshot) {
+	// In the adapter you will have access to adapterOptions.
+	let adapterOptions = snapshot.adapterOptions;
+	}
+	});
+	```
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the record in this belongs-to relationship.
+	*/
+	async load(options) {
+		const support = LEGACY_SUPPORT.get(this.___identifier);
+		return !this.belongsToRelationship.definition.isAsync && !areAllInverseRecordsLoaded(this.store, this._resource()) ? support.reloadBelongsTo(this.key, options).then(() => this.value()) : support.getBelongsTo(this.key, options);
+	}
+	/**
+	Triggers a reload of the value in this relationship. If the
+	remoteType is `"link"` WarpDrive will use the relationship link to
+	reload the relationship. Otherwise it will reload the record by its
+	id.
+	Example
+	```javascript
+	// models/blog.js
+	import { Model, belongsTo } from '@warp-drive/legacy/model';
+	export default class BlogModel extends Model {
+	@belongsTo('user', { async: true, inverse: null }) user;
+	}
+	let blog = store.push({
+	data: {
+	type: 'blog',
+	id: 1,
+	relationships: {
+	user: {
+	data: { type: 'user', id: 1 }
+	}
+	}
+	}
+	});
+	let userRef = blog.belongsTo('user');
+	userRef.reload().then(function(user) {
+	userRef.value() === user
+	});
+	```
+	You may also pass in an options object whose properties will be
+	fed forward. This enables you to pass `adapterOptions` into the
+	request given to the adapter via the reference. A full example
+	can be found in the `load` method.
+	Example
+	```javascript
+	userRef.reload({ adapterOptions: { isPrivate: true } })
+	```
+	@public
+	@param options the options to pass in.
+	@return a promise that resolves with the record in this belongs-to relationship after the reload has completed.
+	*/
+	reload(options) {
+		return LEGACY_SUPPORT.get(this.___identifier).reloadBelongsTo(this.key, options).then(() => this.value());
+	}
+};
+defineNonEnumerableSignal(BelongsToReference.prototype, "_ref", 0);
+
+//#endregion
+//#region src/model/-private/legacy-relationships-support.ts
+const LEGACY_SUPPORT = getOrSetGlobal("LEGACY_SUPPORT", /* @__PURE__ */ new Map());
+function lookupLegacySupport(record) {
+	const identifier = recordIdentifierFor(record);
+	let support = LEGACY_SUPPORT.get(identifier);
+	if (!support) {
+		support = new LegacySupport(record, identifier);
+		LEGACY_SUPPORT.set(identifier, support);
+	}
+	return support;
+}
+/**
+* @hideconstructor
+*/
+var LegacySupport = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	constructor(record, identifier) {
+		this.record = record;
+		this.store = isPrivateStore(storeFor(record, false));
+		this.identifier = identifier;
+		this.cache = this.store.cache;
+		if (this.store._graph) this.graph = this.store._graph;
+		this._manyArrayCache = Object.create(null);
+		this._relationshipPromisesCache = Object.create(null);
+		this._relationshipProxyCache = Object.create(null);
+		this._pending = Object.create(null);
+		this.references = Object.create(null);
+	}
+	/** @private */
+	_syncArray(array) {
+		if (this.isDestroyed || this.isDestroying) return;
+		const currentState = array[Context].source;
+		const identifier = this.identifier;
+		const [identifiers, jsonApi] = this._getCurrentState(identifier, array.key);
+		if (jsonApi.meta) array.meta = jsonApi.meta;
+		if (jsonApi.links) array.links = jsonApi.links;
+		currentState.length = 0;
+		fastPush(currentState, identifiers);
+	}
+	mutate(mutation) {
+		this.cache.mutate(mutation);
+	}
+	_findBelongsTo(key, resource, relationship, options) {
+		const name = getRealFieldName(this, key);
+		return this._findBelongsToByJsonApiResource(resource, this.identifier, relationship, options).then((identifier) => handleCompletedRelationshipRequest(this, name, relationship, identifier), (e) => handleCompletedRelationshipRequest(this, name, relationship, null, e));
+	}
+	reloadBelongsTo(key, options) {
+		const loadingPromise = this._relationshipPromisesCache[key];
+		if (loadingPromise) return loadingPromise;
+		const name = getRealFieldName(this, key);
+		const resource = this.store.cache.getRelationship(this.identifier, name);
+		const relationship = this.graph.get(this.identifier, name);
+		relationship.state.hasFailedLoadAttempt = false;
+		relationship.state.shouldForceReload = true;
+		const promise = this._findBelongsTo(name, resource, relationship, options);
+		if (this._relationshipProxyCache[name]) return this._updatePromiseProxyFor("belongsTo", name, { promise });
+		return promise;
+	}
+	getBelongsTo(key, options) {
+		const { identifier } = this;
+		const name = getRealFieldName(this, key);
+		const resource = this.store.cache.getRelationship(this.identifier, name);
+		const relatedIdentifier = resource && resource.data ? resource.data : null;
+		const store = this.store;
+		const relationship = this.graph.get(this.identifier, name);
+		const isAsync = relationship.definition.isAsync;
+		const _belongsToState = {
+			key,
+			store,
+			legacySupport: this,
+			modelName: relationship.definition.type
+		};
+		if (isAsync) {
+			if (relationship.state.hasFailedLoadAttempt) return this._relationshipProxyCache[name];
+			const promise = this._findBelongsTo(name, resource, relationship, options);
+			const isLoaded = relatedIdentifier && store._instanceCache.recordIsLoaded(relatedIdentifier);
+			return this._updatePromiseProxyFor("belongsTo", name, {
+				promise,
+				content: isLoaded ? store._instanceCache.getRecord(relatedIdentifier) : null,
+				_belongsToState
+			});
+		} else if (relatedIdentifier === null) return null;
+		else return store._instanceCache.getRecord(relatedIdentifier);
+	}
+	setDirtyBelongsTo(key, value) {
+		const name = getRealFieldName(this, key);
+		return this.cache.mutate({
+			op: "replaceRelatedRecord",
+			record: this.identifier,
+			field: name,
+			value: extractIdentifierFromRecord(value)
+		}, true);
+	}
+	_getCurrentState(identifier, field) {
+		const jsonApi = this.cache.getRelationship(identifier, field);
+		const cache = this.store._instanceCache;
+		const identifiers = [];
+		if (jsonApi.data) for (let i = 0; i < jsonApi.data.length; i++) {
+			const relatedIdentifier = jsonApi.data[i];
+			if (cache.recordIsLoaded(relatedIdentifier, true)) identifiers.push(relatedIdentifier);
+		}
+		return [identifiers, jsonApi];
+	}
+	getManyArray(key, definition) {
+		const name = getRealFieldName(this, key);
+		if (this.graph) {
+			let manyArray = this._manyArrayCache[name];
+			if (!definition) definition = this.graph.get(this.identifier, name).definition;
+			if (!manyArray) {
+				const [identifiers, doc] = this._getCurrentState(this.identifier, name);
+				const field = getField(this, name);
+				manyArray = createLegacyManyArray({
+					store: this.store,
+					manager: this,
+					source: identifiers,
+					type: definition.type,
+					isLoaded: !definition.isAsync,
+					editable: true,
+					isAsync: definition.isAsync,
+					isPolymorphic: definition.isPolymorphic,
+					field,
+					identifier: this.identifier,
+					links: doc.links || null,
+					meta: doc.meta || null
+				});
+				this._manyArrayCache[name] = manyArray;
+			}
+			return manyArray;
+		}
+	}
+	fetchAsyncHasMany(key, relationship, manyArray, options) {
+		const name = getRealFieldName(this, key);
+		if (this.graph) {
+			let loadingPromise = this._relationshipPromisesCache[name];
+			if (loadingPromise) return loadingPromise;
+			const jsonApi = this.cache.getRelationship(this.identifier, name);
+			const promise = this._findHasManyByJsonApiResource(jsonApi, this.identifier, relationship, options);
+			if (!promise) {
+				manyArray.isLoaded = true;
+				return Promise.resolve(manyArray);
+			}
+			loadingPromise = promise.then(() => handleCompletedRelationshipRequest(this, name, relationship, manyArray), (e) => handleCompletedRelationshipRequest(this, name, relationship, manyArray, e));
+			this._relationshipPromisesCache[name] = loadingPromise;
+			return loadingPromise;
+		}
+	}
+	reloadHasMany(key, options) {
+		const name = getRealFieldName(this, key);
+		if (this.graph) {
+			const loadingPromise = this._relationshipPromisesCache[name];
+			if (loadingPromise) return loadingPromise;
+			const relationship = this.graph.get(this.identifier, name);
+			const { definition, state } = relationship;
+			state.hasFailedLoadAttempt = false;
+			state.shouldForceReload = true;
+			const manyArray = this.getManyArray(name, definition);
+			const promise = this.fetchAsyncHasMany(name, relationship, manyArray, options);
+			if (this._relationshipProxyCache[name]) return this._updatePromiseProxyFor("hasMany", name, { promise });
+			return promise;
+		}
+	}
+	getHasMany(key, options) {
+		const name = getRealFieldName(this, key);
+		if (this.graph) {
+			const relationship = this.graph.get(this.identifier, name);
+			const { definition, state } = relationship;
+			const manyArray = this.getManyArray(name, definition);
+			if (definition.isAsync) {
+				if (state.hasFailedLoadAttempt) return this._relationshipProxyCache[name];
+				const promise = this.fetchAsyncHasMany(name, relationship, manyArray, options);
+				return this._updatePromiseProxyFor("hasMany", name, {
+					promise,
+					content: manyArray
+				});
+			} else return manyArray;
+		}
+	}
+	_updatePromiseProxyFor(kind, key, args) {
+		let promiseProxy = this._relationshipProxyCache[key];
+		if (kind === "hasMany") {
+			const { promise, content } = args;
+			if (promiseProxy) promiseProxy._update(promise, content);
+			else promiseProxy = this._relationshipProxyCache[key] = new PromiseManyArray(promise, content);
+			return promiseProxy;
+		}
+		if (promiseProxy) {
+			const { promise, content } = args;
+			if (content !== void 0) promiseProxy.set("content", content);
+			promiseProxy.set("promise", promise);
+		} else {
+			promiseProxy = PromiseBelongsTo.create(args);
+			this._relationshipProxyCache[key] = promiseProxy;
+		}
+		return promiseProxy;
+	}
+	referenceFor(kind, key) {
+		const name = getRealFieldName(this, key);
+		let reference = this.references[name];
+		if (!reference) {
+			if (!this.graph) {}
+			const { graph, identifier } = this;
+			const relationship = graph.get(identifier, name);
+			const relationshipKind = relationship.definition.kind;
+			if (relationshipKind === "belongsTo") reference = new BelongsToReference(this.store, graph, identifier, relationship, key);
+			else if (relationshipKind === "hasMany") reference = new HasManyReference(this.store, graph, identifier, relationship, key);
+			this.references[name] = reference;
+		}
+		return reference;
+	}
+	_findHasManyByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
+		if (this.graph) {
+			if (!resource) return;
+			const { definition, state } = relationship;
+			/* @__PURE__ */ upgradeStore(this.store);
+			const adapter = this.store.adapterFor?.(definition.type);
+			const { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = state;
+			const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
+			const identifiers = resource.data;
+			const shouldFindViaLink = resource.links && resource.links.related && (typeof adapter?.findHasMany === "function" || typeof identifiers === "undefined") && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+			const field = this.store.schema.fields({ type: definition.inverseType }).get(definition.key);
+			const request = {
+				useLink: shouldFindViaLink,
+				field,
+				links: resource.links,
+				meta: resource.meta,
+				options,
+				record: parentIdentifier
+			};
+			if (shouldFindViaLink) {
+				const req = field.options.linksMode ? {
+					url: getRelatedLink(resource),
+					op: "findHasMany",
+					method: "GET",
+					records: identifiers || [],
+					data: request,
+					[EnableHydration]: false
+				} : {
+					op: "findHasMany",
+					records: identifiers || [],
+					data: request,
+					cacheOptions: { [Symbol.for("wd:skip-cache")]: true }
+				};
+				return this.store.request(req);
+			}
+			const preferLocalCache = hasReceivedData && !isEmpty;
+			const hasLocalPartialData = hasDematerializedInverse || isEmpty && Array.isArray(identifiers) && identifiers.length > 0;
+			const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
+			if (attemptLocalCache && allInverseRecordsAreLoaded) return;
+			if (attemptLocalCache || hasReceivedData && !isEmpty || hasLocalPartialData) {
+				options.reload = options.reload || !attemptLocalCache || void 0;
+				return this.store.request({
+					op: "findHasMany",
+					records: identifiers,
+					data: request,
+					cacheOptions: { [Symbol.for("wd:skip-cache")]: true }
+				});
+			}
+			return;
+		}
+	}
+	_findBelongsToByJsonApiResource(resource, parentIdentifier, relationship, options = {}) {
+		if (!resource) return Promise.resolve(null);
+		const key = relationship.definition.key;
+		const name = getRealFieldName(this, key);
+		if (this._pending[name]) return this._pending[name];
+		const identifier = resource.data ? resource.data : null;
+		const { isStale, hasDematerializedInverse, hasReceivedData, isEmpty, shouldForceReload } = relationship.state;
+		const allInverseRecordsAreLoaded = areAllInverseRecordsLoaded(this.store, resource);
+		const shouldFindViaLink = resource.links?.related && (shouldForceReload || hasDematerializedInverse || isStale || !allInverseRecordsAreLoaded && !isEmpty);
+		const field = this.store.schema.fields(this.identifier).get(relationship.definition.key);
+		const request = {
+			useLink: shouldFindViaLink,
+			field,
+			links: resource.links,
+			meta: resource.meta,
+			options,
+			record: parentIdentifier
+		};
+		if (shouldFindViaLink) {
+			const req = field.options.linksMode ? {
+				url: getRelatedLink(resource),
+				op: "findBelongsTo",
+				method: "GET",
+				records: identifier ? [identifier] : [],
+				data: request,
+				[EnableHydration]: false
+			} : {
+				op: "findBelongsTo",
+				records: identifier ? [identifier] : [],
+				data: request,
+				cacheOptions: { [Symbol.for("wd:skip-cache")]: true }
+			};
+			const future = this.store.request(req);
+			this._pending[name] = future.then((doc) => field.options.linksMode ? doc.content.data : doc.content).finally(() => {
+				this._pending[name] = void 0;
+			});
+			return this._pending[name];
+		}
+		const preferLocalCache = hasReceivedData && allInverseRecordsAreLoaded && !isEmpty;
+		const hasLocalPartialData = hasDematerializedInverse || isEmpty && resource.data;
+		const localDataIsEmpty = !identifier;
+		const attemptLocalCache = !shouldForceReload && !isStale && (preferLocalCache || hasLocalPartialData);
+		if (attemptLocalCache && localDataIsEmpty) return Promise.resolve(null);
+		const resourceIsLocal = identifier?.id === null;
+		if (attemptLocalCache && allInverseRecordsAreLoaded || resourceIsLocal) return Promise.resolve(identifier);
+		if (identifier) {
+			options.reload = options.reload || !attemptLocalCache || void 0;
+			this._pending[name] = this.store.request({
+				op: "findBelongsTo",
+				records: [identifier],
+				data: request,
+				cacheOptions: { [Symbol.for("wd:skip-cache")]: true }
+			}).then((doc) => doc.content).finally(() => {
+				this._pending[name] = void 0;
+			});
+			return this._pending[name];
+		}
+		return Promise.resolve(null);
+	}
+	destroy() {
+		this.isDestroying = true;
+		let cache = this._manyArrayCache;
+		this._manyArrayCache = Object.create(null);
+		Object.keys(cache).forEach((key) => {
+			cache[key].destroy();
+		});
+		cache = this._relationshipProxyCache;
+		this._relationshipProxyCache = Object.create(null);
+		Object.keys(cache).forEach((key) => {
+			const proxy = cache[key];
+			if (proxy.destroy) proxy.destroy();
+		});
+		cache = this.references;
+		this.references = Object.create(null);
+		Object.keys(cache).forEach((key) => {
+			cache[key].destroy();
+		});
+		this.isDestroyed = true;
+	}
+};
+function getRelatedLink(resource) {
+	const related = resource.links?.related;
+	return typeof related === "object" ? related.href : related;
+}
+function handleCompletedRelationshipRequest(recordExt, key, relationship, value, error) {
+	delete recordExt._relationshipPromisesCache[key];
+	relationship.state.shouldForceReload = false;
+	const isHasMany = relationship.definition.kind === "hasMany";
+	if (isHasMany) notifyInternalSignal(value[Context].signal);
+	if (error) {
+		relationship.state.hasFailedLoadAttempt = true;
+		const proxy = recordExt._relationshipProxyCache[key];
+		if (proxy && !isHasMany) {
+			if (proxy.content && proxy.content.isDestroying) proxy.set("content", null);
+			recordExt.store.notifications._flush();
+		}
+		throw error;
+	}
+	if (isHasMany) value.isLoaded = true;
+	else recordExt.store.notifications._flush();
+	relationship.state.hasFailedLoadAttempt = false;
+	relationship.state.isStale = false;
+	return isHasMany || !value ? value : recordExt.store.peekRecord(value);
+}
+function extractIdentifierFromRecord(record) {
+	if (!record) return null;
+	return recordIdentifierFor(record);
+}
+function areAllInverseRecordsLoaded(store, resource) {
+	assertPrivateStore(store);
+	const instanceCache = store._instanceCache;
+	const identifiers = resource.data;
+	if (Array.isArray(identifiers)) return identifiers.every((identifier) => instanceCache.recordIsLoaded(identifier));
+	if (!identifiers) return true;
+	return instanceCache.recordIsLoaded(identifiers);
+}
+function getField(context, key) {
+	const { identifier, store } = context;
+	return store.schema.fields(identifier).get(key) ?? store.schema.cacheFields?.(identifier).get(key);
+}
+function getRealFieldName(context, key) {
+	const field = getField(context, key);
+	return field ? field.sourceKey ?? field.name : key;
+}
+
+//#endregion
+//#region src/model/-private/errors.ts
+const ArrayProxyWithCustomOverrides = ArrayProxy;
+/**
+Holds validation errors for a given record, organized by attribute names.
+
+This class is not directly instantiable.
+
+Every `Model` has an `errors` property that is an instance of
+`Errors`. This can be used to display validation error
+messages returned from the server when a `record.save()` rejects.
+
+For Example, if you had a `User` model that looked like this:
+
+```js [app/models/user.js]
+import { Model, attr } from '@warp-drive/legacy/model';
+
+export default class UserModel extends Model {
+@attr('string') username;
+@attr('string') email;
+}
+```
+And you attempted to save a record that did not validate on the backend:
+
+```javascript
+let user = store.createRecord('user', {
+username: 'tomster',
+email: 'invalidEmail'
+});
+user.save();
+```
+
+Your backend would be expected to return an error response that described
+the problem, so that error messages can be generated on the app.
+
+API responses will be translated into instances of `Errors` differently,
+depending on the specific combination of adapter and serializer used. You
+may want to check the documentation or the source code of the libraries
+that you are using, to know how they expect errors to be communicated.
+
+Errors can be displayed to the user by accessing their property name
+to get an array of all the error objects for that property. Each
+error object is a JavaScript object with two keys:
+
+- `message` A string containing the error message from the backend
+- `attribute` The name of the property associated with this error message
+
+```handlebars
+<label>Username: <Input @value={{@model.username}} /> </label>
+{{#each @model.errors.username as |error|}}
+<div class="error">
+{{error.message}}
+</div>
+{{/each}}
+
+<label>Email: <Input @value={{@model.email}} /> </label>
+{{#each @model.errors.email as |error|}}
+<div class="error">
+{{error.message}}
+</div>
+{{/each}}
+```
+
+You can also access the special `messages` property on the error
+object to get an array of all the error strings.
+
+```handlebars
+{{#each @model.errors.messages as |message|}}
+<div class="error">
+{{message}}
+</div>
+{{/each}}
+```
+
+@class Errors
+@public
+*/
+var Errors = class extends ArrayProxyWithCustomOverrides {
+	/**
+	@property errorsByAttributeName
+	@type {MapWithDefault}
+	@private
+	*/
+	get errorsByAttributeName() {
+		return /* @__PURE__ */ new Map();
+	}
+	/**
+	Returns errors for a given attribute
+	```javascript
+	let user = store.createRecord('user', {
+	username: 'tomster',
+	email: 'invalidEmail'
+	});
+	user.save().catch(function(){
+	user.errors.errorsFor('email'); // returns:
+	// [{attribute: "email", message: "Doesn't look like a valid email."}]
+	});
+	```
+	@public
+	@param {String} attribute
+	@return {Array}
+	*/
+	static {
+		decorateMethodV2(this.prototype, "errorsByAttributeName", [computed()]);
+	}
+	errorsFor(attribute) {
+		const map = this.errorsByAttributeName;
+		let errors = map.get(attribute);
+		if (errors === void 0) {
+			errors = A();
+			map.set(attribute, errors);
+		}
+		get(errors, "[]");
+		return errors;
+	}
+	/**
+	An array containing all of the error messages for this
+	record. This is useful for displaying all errors to the user.
+	```handlebars
+	{{#each @model.errors.messages as |message|}}
+	<div class="error">
+	{{message}}
+	</div>
+	{{/each}}
+	```
+	@property messages
+	@public
+	@type {Array}
+	*/
+	static {
+		decorateFieldV2(this.prototype, "messages", [mapBy("content", "message")]);
+	}
+	#messages = (initializeDeferredDecorator(this, "messages"), void 0);
+	/**
+	@property content
+	@type {Array}
+	@private
+	*/
+	get content() {
+		return A();
+	}
+	/**
+	@private
+	*/
+	static {
+		decorateMethodV2(this.prototype, "content", [computed()]);
+	}
+	unknownProperty(attribute) {
+		const errors = this.errorsFor(attribute);
+		if (errors.length === 0) return;
+		return errors;
+	}
+	/**
+	Total number of errors.
+	@property length
+	@type {Number}
+	@public
+	@readonly
+	*/
+	/**
+	`true` if we have no errors.
+	@property isEmpty
+	@type {Boolean}
+	@public
+	@readonly
+	*/
+	static {
+		decorateFieldV2(this.prototype, "isEmpty", [not("length")]);
+	}
+	#isEmpty = (initializeDeferredDecorator(this, "isEmpty"), void 0);
+	/**
+	Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
+	the record and transition the record into an `invalid` state.
+	Example
+	```javascript
+	let errors = user.errors;
+	// add multiple errors
+	errors.add('password', [
+	'Must be at least 12 characters',
+	'Must contain at least one symbol',
+	'Cannot contain your name'
+	]);
+	errors.errorsFor('password');
+	// =>
+	// [
+	//   { attribute: 'password', message: 'Must be at least 12 characters' },
+	//   { attribute: 'password', message: 'Must contain at least one symbol' },
+	//   { attribute: 'password', message: 'Cannot contain your name' },
+	// ]
+	// add a single error
+	errors.add('username', 'This field is required');
+	errors.errorsFor('username');
+	// =>
+	// [
+	//   { attribute: 'username', message: 'This field is required' },
+	// ]
+	```
+	@public
+	@param {String} attribute - the property name of an attribute or relationship
+	@param {string[]|string} messages - an error message or array of error messages for the attribute
+	*/
+	add(attribute, messages) {
+		const errors = this._findOrCreateMessages(attribute, messages);
+		this.addObjects(errors);
+		this.errorsFor(attribute).addObjects(errors);
+		this.__record.currentState.notify("isValid");
+		this.notifyPropertyChange(attribute);
+	}
+	/**
+	@private
+	*/
+	_findOrCreateMessages(attribute, messages) {
+		const errors = this.errorsFor(attribute);
+		const messagesArray = Array.isArray(messages) ? messages : [messages];
+		const _messages = new Array(messagesArray.length);
+		for (let i = 0; i < messagesArray.length; i++) {
+			const message = messagesArray[i];
+			const err = errors.findBy("message", message);
+			if (err) _messages[i] = err;
+			else _messages[i] = {
+				attribute,
+				message
+			};
+		}
+		return _messages;
+	}
+	/**
+	Manually removes all errors for a given member from the record.
+	This will transition the record into a `valid` state, and
+	triggers the `becameValid` event and lifecycle method.
+	Example:
+	```javascript
+	let errors = user.errors;
+	errors.add('phone', ['error-1', 'error-2']);
+	errors.errorsFor('phone');
+	// =>
+	// [
+	//   { attribute: 'phone', message: 'error-1' },
+	//   { attribute: 'phone', message: 'error-2' },
+	// ]
+	errors.remove('phone');
+	errors.errorsFor('phone');
+	// => undefined
+	```
+	@public
+	@param {String} member - the property name of an attribute or relationship
+	*/
+	remove(attribute) {
+		if (this.isEmpty) return;
+		const content = this.rejectBy("attribute", attribute);
+		this.content.setObjects(content);
+		const errors = this.errorsFor(attribute);
+		for (let i = 0; i < errors.length; i++) if (errors[i].attribute === attribute) errors.replace(i, 1);
+		this.errorsByAttributeName.delete(attribute);
+		this.__record.currentState.notify("isValid");
+		this.notifyPropertyChange(attribute);
+		this.notifyPropertyChange("length");
+	}
+	/**
+	Manually clears all errors for the record.
+	This will transition the record into a `valid` state, and
+	will trigger the `becameValid` event and lifecycle method.
+	Example:
+	```javascript
+	let errors = user.errors;
+	errors.add('username', ['error-a']);
+	errors.add('phone', ['error-1', 'error-2']);
+	errors.errorsFor('username');
+	// =>
+	// [
+	//   { attribute: 'username', message: 'error-a' },
+	// ]
+	errors.errorsFor('phone');
+	// =>
+	// [
+	//   { attribute: 'phone', message: 'error-1' },
+	//   { attribute: 'phone', message: 'error-2' },
+	// ]
+	errors.clear();
+	errors.errorsFor('username');
+	// => undefined
+	errors.errorsFor('phone');
+	// => undefined
+	errors.messages
+	// => []
+	```
+	@public
+	*/
+	clear() {
+		if (this.isEmpty) return;
+		const errorsByAttributeName = this.errorsByAttributeName;
+		const attributes = [];
+		errorsByAttributeName.forEach(function(_, attribute) {
+			attributes.push(attribute);
+		});
+		errorsByAttributeName.clear();
+		attributes.forEach((attribute) => {
+			this.notifyPropertyChange(attribute);
+		});
+		this.__record.currentState.notify("isValid");
+		super.clear();
+	}
+	/**
+	Checks if there are error messages for the given attribute.
+	```js [app/controllers/user/edit.js]
+	export default class UserEditController extends Controller {
+	@action
+	save(user) {
+	if (user.errors.has('email')) {
+	return alert('Please update your email before attempting to save.');
+	}
+	user.save();
+	}
+	}
+	```
+	@public
+	@param {String} attribute
+	@return {Boolean} true if there some errors on given attribute
+	*/
+	has(attribute) {
+		return this.errorsFor(attribute).length > 0;
+	}
+};
+
+//#endregion
+export { PromiseBelongsTo as a, PromiseManyArray as i, LEGACY_SUPPORT as n, lookupLegacySupport as r, Errors as t };
+//# sourceMappingURL=errors-CoKAYQJi.js.map