joist-core 2.3.0 → 2.4.0

package/build/relations/OneToOneReference.cjs

@@ -0,0 +1,209 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_AbstractRelationImpl = require("./AbstractRelationImpl.cjs");
+const require_relations_RelationSymbols = require("./RelationSymbols.cjs");
+const require_relations_ReferenceSymbols = require("./ReferenceSymbols.cjs");
+const require_fields = require("../fields.cjs");
+const require_keys = require("../keys.cjs");
+require("./Reference.cjs");
+const require_relations_isCascadeDelete = require("./isCascadeDelete.cjs");
+const require_relations_ManyToOneReference = require("./ManyToOneReference.cjs");
+const require_batchloaders_oneToOneBatchLoader = require("../batchloaders/oneToOneBatchLoader.cjs");
+const require_relations_ReactiveReference = require("./ReactiveReference.cjs");
+const require_newEntity = require("../newEntity.cjs");
+const require_EntityMetadata = require("../EntityMetadata.cjs");
+const require_index = require("../index.cjs");
+const require_EntityManager = require("../EntityManager.cjs");
+require("../Entity.cjs");
+const require_BaseEntity = require("../BaseEntity.cjs");
+//#region src/relations/OneToOneReference.ts
+const OneToOne = Symbol();
+/** An alias for creating `OneToOneReference`s. */
+function hasOneToOne() {
+	return require_newEntity.lazyField((entity, fieldName) => {
+		const o2o = require_EntityMetadata.getMetadata(entity).allFields[fieldName];
+		return new OneToOneReferenceImpl(entity, o2o);
+	});
+}
+/** Type guard utility for determining if an entity field is a Reference. */
+function isOneToOneReference(maybeReference) {
+	return maybeReference instanceof OneToOneReferenceImpl;
+}
+/** Type guard utility for determining if an entity field is a loaded Reference. */
+function isLoadedOneToOneReference(maybeReference) {
+	return isOneToOneReference(maybeReference) && maybeReference.isLoaded;
+}
+/**
+* Represents the "many" side of a one-to-one relationship.
+*
+* I.e. in a one-to-many from Book -> Reviews, there is a review.book_id that can have many books.
+*
+* This class is for when that `review.book_id` column is itself unique, i.e. like `image.book_id`, and
+* so instead of `Book.images: OneToManyCollection` we have a `Book.image: OneToOneReference`.
+*
+* This class implements `Reference` because it is essentially like "one entity pointing/refereing to another",
+* however because we require a `.load` call to lazily know the value of other side (unlike ManyToOneReference
+* which has it's `book_id` column immediately available in the entity `data` hash), there is some wonkiness
+* around methods like `Reference.id` that are usually callable without `load`/`populate`, that for this
+* class can actually only be called post `load`/`populate`.
+*
+* Currently we enforce this with a runtime check, which is not great, but the trade-off of implementing
+* `Reference` seemed worth the downside of a un-type-safe `.id` property.
+*/
+var OneToOneReferenceImpl = class extends require_relations_AbstractRelationImpl.AbstractRelationImpl {
+	#field;
+	loaded;
+	_isLoaded = false;
+	#hasBeenSet = false;
+	constructor(entity, field) {
+		super(entity);
+		this.#field = field;
+		if (require_BaseEntity.getInstanceData(entity).isOrWasNew) this._isLoaded = true;
+	}
+	get fieldName() {
+		return this.#field.fieldName;
+	}
+	get otherFieldName() {
+		return this.#field.otherFieldName;
+	}
+	get id() {
+		return this.idMaybe || require_relations_ManyToOneReference.failNoId(this.entity, this.fieldName, this.loaded);
+	}
+	get idIfSet() {
+		if (this._isLoaded) return this.idMaybe || require_relations_ManyToOneReference.failIfNewEntity(this.entity, this.fieldName, this.loaded);
+		throw new Error(`${this.entity}.${this.fieldName} was not loaded`);
+	}
+	get idUntagged() {
+		return this.idUntaggedMaybe || require_relations_ManyToOneReference.failNoId(this.entity, this.fieldName, this.loaded);
+	}
+	get idUntaggedIfSet() {
+		return this.idUntaggedMaybe || require_relations_ManyToOneReference.failIfNewEntity(this.entity, this.fieldName, this.loaded);
+	}
+	get idMaybe() {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (this._isLoaded) return this.loaded?.idMaybe;
+		throw new Error(`${this.entity}.${this.fieldName} was not loaded`);
+	}
+	get idTaggedMaybe() {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (this._isLoaded) return this.loaded?.idTaggedMaybe;
+		throw new Error(`${this.entity}.${this.fieldName} was not loaded`);
+	}
+	get idUntaggedMaybe() {
+		return require_keys.deTagId(this.otherMeta, this.idMaybe);
+	}
+	get isSet() {
+		if (this._isLoaded) return this.loaded !== void 0;
+		throw new Error(`${this.entity}.${this.fieldName} was not loaded`);
+	}
+	async load(opts = {}) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (!this._isLoaded || opts.forceReload) {
+			if (!this.entity.isNewEntity) {
+				const joinLoaded = this.getPreloaded();
+				if (joinLoaded) this.loaded = joinLoaded[0];
+				else {
+					try {
+						await require_batchloaders_oneToOneBatchLoader.oneToOneBatchLoader(this.entity.em, this).load(this.entity.idTagged);
+					} catch (err) {
+						throw require_EntityManager.appendStack(err, /* @__PURE__ */ new Error());
+					}
+					this.preload();
+				}
+			}
+			this._isLoaded = true;
+		}
+		return this.filterDeleted(this.loaded, opts);
+	}
+	set(other, opts = {}) {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		this.#hasBeenSet = true;
+		if (other === this.loaded) {
+			this._isLoaded = true;
+			return;
+		}
+		if (this._isLoaded) {
+			if (this.loaded && !opts.percolating) this.getOtherRelation(this.loaded).set(void 0);
+		}
+		const { fieldLogger } = require_EntityManager.getEmInternalApi(this.entity.em);
+		fieldLogger.logSet(this.entity, this.fieldName, other);
+		this.loaded = other;
+		this._isLoaded = true;
+		if (other && !opts.percolating) this.getOtherRelation(other).set(this.entity);
+	}
+	get isLoaded() {
+		return this._isLoaded;
+	}
+	get isPreloaded() {
+		return !!this.getPreloaded();
+	}
+	preload() {
+		this.loaded = this.getPreloaded()?.[0];
+		this._isLoaded = true;
+	}
+	import(other, findEntity) {
+		this.loaded = other.loaded ? findEntity(other.loaded) : void 0;
+		this._isLoaded = true;
+	}
+	get getWithDeleted() {
+		return this.filterDeleted(this.doGet(), { withDeleted: true });
+	}
+	get get() {
+		return this.filterDeleted(this.doGet(), { withDeleted: false });
+	}
+	get otherMeta() {
+		return this.#field.otherMetadata();
+	}
+	doGet() {
+		require_index.ensureNotDeleted(this.entity, "pending");
+		if (!this._isLoaded) throw new Error("get was called when not loaded");
+		return this.loaded;
+	}
+	setFromOpts(other) {
+		this.set(other);
+	}
+	maybeCascadeDelete() {
+		if (this.isCascadeDelete && this.loaded) this.entity.em.delete(this.loaded);
+	}
+	async cleanupOnEntityDeleted() {
+		if (this.isCascadeDelete) return;
+		const current = await this.load({ withDeleted: true });
+		if (current !== void 0) {
+			const otherSide = this.getOtherRelation(current);
+			if (!require_relations_ReactiveReference.isReactiveReference(otherSide)) otherSide.set(void 0);
+			require_fields.setField(current, this.otherFieldName, void 0);
+		}
+		this.loaded = void 0;
+		this._isLoaded = true;
+	}
+	get hasBeenSet() {
+		return this.#hasBeenSet;
+	}
+	toString() {
+		return `OneToOneReference(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;
+	}
+	filterDeleted(entity, opts) {
+		return opts?.withDeleted === true || entity === void 0 || !entity.isDeletedEntity ? entity : void 0;
+	}
+	/** Returns the other relation that points back at us, i.e. we're `Author.image` and this is `Image.author_id`. */
+	getOtherRelation(other) {
+		return other[this.otherFieldName];
+	}
+	getPreloaded() {
+		if (this.entity.isNewEntity) return void 0;
+		return require_EntityManager.getEmInternalApi(this.entity.em).getPreloadedRelation(this.entity.idTagged, this.fieldName);
+	}
+	get isCascadeDelete() {
+		return require_relations_isCascadeDelete.isCascadeDelete(this, this.fieldName);
+	}
+	[require_relations_RelationSymbols.RelationT] = null;
+	[require_relations_RelationSymbols.RelationU] = null;
+	[require_relations_ReferenceSymbols.ReferenceN] = null;
+	[OneToOne] = null;
+};
+//#endregion
+exports.OneToOneReferenceImpl = OneToOneReferenceImpl;
+exports.hasOneToOne = hasOneToOne;
+exports.isLoadedOneToOneReference = isLoadedOneToOneReference;
+exports.isOneToOneReference = isOneToOneReference;
+
+//# sourceMappingURL=OneToOneReference.cjs.map

package/build/relations/OneToOneReference.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OneToOneReference.cjs","names":["lazyField","getMetadata","AbstractRelationImpl","#field","getInstanceData","failNoId","failIfNewEntity","deTagId","oneToOneBatchLoader","appendStack","#hasBeenSet","getEmInternalApi","isReactiveReference","isCascadeDelete","RelationT","RelationU","ReferenceN"],"sources":["../../src/relations/OneToOneReference.ts"],"sourcesContent":["import { oneToOneBatchLoader } from \"src/batchloaders/oneToOneBatchLoader.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { setField } from \"src/fields.ts\";\nimport {\n  type IdOf,\n  type LoadedReference,\n  type OneToOneField,\n  type TaggedId,\n  appendStack,\n  deTagId,\n  ensureNotDeleted,\n  getEmInternalApi,\n  getInstanceData,\n  getMetadata,\n} from \"src/index.ts\";\nimport { lazyField } from \"src/newEntity.ts\";\nimport { AbstractRelationImpl } from \"src/relations/AbstractRelationImpl.ts\";\nimport { isCascadeDelete } from \"src/relations/isCascadeDelete.ts\";\nimport { type ManyToOneReference, failIfNewEntity, failNoId } from \"src/relations/ManyToOneReference.ts\";\nimport { isReactiveReference } from \"src/relations/ReactiveReference.ts\";\nimport { type Reference } from \"src/relations/Reference.ts\";\nimport { ReferenceN } from \"src/relations/ReferenceSymbols.ts\";\nimport { RelationT, RelationU } from \"src/relations/RelationSymbols.ts\";\n\nconst OneToOne = Symbol();\n\n/** An alias for creating `OneToOneReference`s. */\nexport function hasOneToOne<T extends Entity, U extends Entity>(): OneToOneReference<T, U> {\n  return lazyField((entity: T, fieldName) => {\n    const o2o = getMetadata(entity).allFields[fieldName] as OneToOneField;\n    return new OneToOneReferenceImpl<T, U>(entity, o2o);\n  });\n}\n\n/** The lazy-loaded/lookup side of a one-to-one, i.e. the side w/o the unique foreign key column. */\nexport interface OneToOneReference<T extends Entity, U extends Entity> extends Reference<T, U, undefined> {\n  // Need to differentiate OneToOneReference from Reference\n  [OneToOne]: T;\n}\n\n/** Adds a known-safe `get` accessor. */\nexport interface LoadedOneToOneReference<T extends Entity, U extends Entity> extends LoadedReference<T, U, undefined> {\n  get: U | undefined;\n\n  getWithDeleted: U | undefined;\n\n  // Once OneToOneReference is loaded, it can get a lot of the ManyToOneReference methods that\n  // are available even in an unloaded state; below is mostly a copy/paste of those.\n\n  /** Returns the id of the current assigned entity or a runtime error if it's either a) unset or b) set to a new entity that doesn't have an `id` yet. */\n  id: IdOf<U>;\n\n  idIfSet: IdOf<U> | undefined;\n\n  idUntagged: string;\n\n  idUntaggedMaybe: string | undefined;\n\n  /** Returns `true` if this relation is currently set (i.e. regardless of whether it's loaded, or if it is set but the assigned entity doesn't have an id saved. */\n  readonly isSet: boolean;\n}\n\n/** Type guard utility for determining if an entity field is a Reference. */\nexport function isOneToOneReference(maybeReference: any): maybeReference is OneToOneReference<any, any> {\n  return maybeReference instanceof OneToOneReferenceImpl;\n}\n\n/** Type guard utility for determining if an entity field is a loaded Reference. */\nexport function isLoadedOneToOneReference(\n  maybeReference: any,\n): maybeReference is Reference<any, any, any> & LoadedOneToOneReference<any, any> {\n  return isOneToOneReference(maybeReference) && maybeReference.isLoaded;\n}\n\n/**\n * Represents the \"many\" side of a one-to-one relationship.\n *\n * I.e. in a one-to-many from Book -> Reviews, there is a review.book_id that can have many books.\n *\n * This class is for when that `review.book_id` column is itself unique, i.e. like `image.book_id`, and\n * so instead of `Book.images: OneToManyCollection` we have a `Book.image: OneToOneReference`.\n *\n * This class implements `Reference` because it is essentially like \"one entity pointing/refereing to another\",\n * however because we require a `.load` call to lazily know the value of other side (unlike ManyToOneReference\n * which has it's `book_id` column immediately available in the entity `data` hash), there is some wonkiness\n * around methods like `Reference.id` that are usually callable without `load`/`populate`, that for this\n * class can actually only be called post `load`/`populate`.\n *\n * Currently we enforce this with a runtime check, which is not great, but the trade-off of implementing\n * `Reference` seemed worth the downside of a un-type-safe `.id` property.\n */\nexport class OneToOneReferenceImpl<T extends Entity, U extends Entity>\n  extends AbstractRelationImpl<T, U>\n  implements OneToOneReference<T, U>\n{\n  #field: OneToOneField;\n  private loaded: U | undefined;\n  private _isLoaded: boolean = false;\n  #hasBeenSet = false;\n\n  constructor(entity: T, field: OneToOneField) {\n    super(entity);\n    this.#field = field;\n    if (getInstanceData(entity).isOrWasNew) {\n      this._isLoaded = true;\n    }\n  }\n\n  // These are public to our internal implementation but not exposed in the Collection API\n  get fieldName(): keyof T & string {\n    return this.#field.fieldName as keyof T & string;\n  }\n\n  get otherFieldName(): keyof U & string {\n    return this.#field.otherFieldName as keyof U & string;\n  }\n\n  get id(): IdOf<U> {\n    return this.idMaybe || failNoId(this.entity, this.fieldName, this.loaded);\n  }\n\n  get idIfSet(): IdOf<U> | undefined {\n    if (this._isLoaded) {\n      return this.idMaybe || failIfNewEntity(this.entity, this.fieldName, this.loaded);\n    }\n    throw new Error(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  get idUntagged(): string {\n    return this.idUntaggedMaybe || failNoId(this.entity, this.fieldName, this.loaded);\n  }\n\n  get idUntaggedIfSet(): string | undefined {\n    return this.idUntaggedMaybe || failIfNewEntity(this.entity, this.fieldName, this.loaded);\n  }\n\n  private get idMaybe(): IdOf<U> | undefined {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this._isLoaded) {\n      return this.loaded?.idMaybe as IdOf<U> | undefined;\n    }\n    throw new Error(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  get idTaggedMaybe(): TaggedId | undefined {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (this._isLoaded) {\n      return this.loaded?.idTaggedMaybe;\n    }\n    throw new Error(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  private get idUntaggedMaybe(): string | undefined {\n    return deTagId(this.otherMeta, this.idMaybe);\n  }\n\n  get isSet(): boolean {\n    if (this._isLoaded) {\n      return this.loaded !== undefined;\n    }\n    throw new Error(`${this.entity}.${this.fieldName} was not loaded`);\n  }\n\n  // opts is an internal parameter\n  async load(opts: { withDeleted?: boolean; forceReload?: boolean } = {}): Promise<U | undefined> {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this._isLoaded || opts.forceReload) {\n      if (!this.entity.isNewEntity) {\n        const joinLoaded = this.getPreloaded();\n        if (joinLoaded) {\n          this.loaded = joinLoaded[0];\n        } else {\n          try {\n            await oneToOneBatchLoader(this.entity.em, this).load(this.entity.idTagged);\n          } catch (err) {\n            throw appendStack(err as Error, new Error());\n          }\n          this.preload();\n        }\n      }\n      this._isLoaded = true;\n    }\n    return this.filterDeleted(this.loaded, opts);\n  }\n\n  set(other: U, opts: { percolating?: boolean } = {}): void {\n    ensureNotDeleted(this.entity, \"pending\");\n    this.#hasBeenSet = true;\n    if (other === this.loaded) {\n      this._isLoaded = true;\n      return;\n    }\n    if (this._isLoaded) {\n      if (this.loaded && !opts.percolating) {\n        this.getOtherRelation(this.loaded).set(undefined);\n      }\n    }\n    const { fieldLogger } = getEmInternalApi(this.entity.em);\n    fieldLogger.logSet(this.entity, this.fieldName, other);\n    this.loaded = other;\n    this._isLoaded = true;\n    // This will no-op and mark other dirty if necessary\n    if (other && !opts.percolating) {\n      this.getOtherRelation(other).set(this.entity);\n    }\n  }\n\n  get isLoaded(): boolean {\n    return this._isLoaded;\n  }\n\n  get isPreloaded(): boolean {\n    return !!this.getPreloaded();\n  }\n\n  preload(): void {\n    this.loaded = this.getPreloaded()?.[0];\n    this._isLoaded = true;\n  }\n\n  import(other: OneToOneReferenceImpl<T, U>, findEntity: (e: U) => U): void {\n    this.loaded = other.loaded ? findEntity(other.loaded) : undefined;\n    this._isLoaded = true;\n  }\n\n  get getWithDeleted(): U | undefined {\n    return this.filterDeleted(this.doGet(), { withDeleted: true });\n  }\n\n  get get(): U | undefined {\n    return this.filterDeleted(this.doGet(), { withDeleted: false });\n  }\n\n  get otherMeta(): EntityMetadata {\n    return this.#field.otherMetadata();\n  }\n\n  private doGet(): U | undefined {\n    ensureNotDeleted(this.entity, \"pending\");\n    if (!this._isLoaded) {\n      // This should only be callable in the type system if we've already resolved this to an instance\n      throw new Error(\"get was called when not loaded\");\n    }\n    return this.loaded;\n  }\n\n  // internal impl\n\n  setFromOpts(other: U): void {\n    this.set(other);\n  }\n\n  maybeCascadeDelete(): void {\n    if (this.isCascadeDelete && this.loaded) {\n      this.entity.em.delete(this.loaded);\n    }\n  }\n\n  async cleanupOnEntityDeleted(): Promise<void> {\n    // if we are going to delete this relation as well, then we don't need to clean it up\n    if (this.isCascadeDelete) return;\n    const current = await this.load({ withDeleted: true });\n    if (current !== undefined) {\n      const otherSide = this.getOtherRelation(current);\n      // Don't call `ReactiveReference.set` because it'll blow up\n      if (!isReactiveReference(otherSide)) {\n        otherSide.set(undefined as any);\n      }\n      setField(current, this.otherFieldName, undefined);\n    }\n    this.loaded = undefined as any;\n    this._isLoaded = true;\n  }\n\n  get hasBeenSet() {\n    return this.#hasBeenSet;\n  }\n\n  public toString(): string {\n    return `OneToOneReference(entity: ${this.entity}, fieldName: ${this.fieldName}, otherType: ${this.otherMeta.type}, otherFieldName: ${this.otherFieldName})`;\n  }\n\n  private filterDeleted(entity: U | undefined, opts?: { withDeleted?: boolean }): U | undefined {\n    return opts?.withDeleted === true || entity === undefined || !entity.isDeletedEntity ? entity : undefined;\n  }\n\n  /** Returns the other relation that points back at us, i.e. we're `Author.image` and this is `Image.author_id`. */\n  private getOtherRelation(other: U): ManyToOneReference<U, T, any> {\n    return (other as U)[this.otherFieldName] as any;\n  }\n\n  private getPreloaded(): U[] | undefined {\n    if (this.entity.isNewEntity) return undefined;\n    return getEmInternalApi(this.entity.em).getPreloadedRelation(this.entity.idTagged, this.fieldName);\n  }\n\n  private get isCascadeDelete(): boolean {\n    return isCascadeDelete(this, this.fieldName);\n  }\n\n  [RelationT] = null!;\n  [RelationU] = null!;\n  [ReferenceN] = null!;\n  [OneToOne] = null!;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,MAAM,WAAW,OAAO;;AAGxB,SAAgB,cAA2E;CACzF,OAAOA,kBAAAA,WAAW,QAAW,cAAc;EACzC,MAAM,MAAMC,uBAAAA,YAAY,MAAM,CAAC,CAAC,UAAU;EAC1C,OAAO,IAAI,sBAA4B,QAAQ,GAAG;CACpD,CAAC;AACH;;AA+BA,SAAgB,oBAAoB,gBAAoE;CACtG,OAAO,0BAA0B;AACnC;;AAGA,SAAgB,0BACd,gBACgF;CAChF,OAAO,oBAAoB,cAAc,KAAK,eAAe;AAC/D;;;;;;;;;;;;;;;;;;AAmBA,IAAa,wBAAb,cACUC,uCAAAA,qBAEV;CACE;CACA;CACA,YAA6B;CAC7B,cAAc;CAEd,YAAY,QAAW,OAAsB;EAC3C,MAAM,MAAM;EACZ,KAAKC,SAAS;EACd,IAAIC,mBAAAA,gBAAgB,MAAM,CAAC,CAAC,YAC1B,KAAK,YAAY;CAErB;CAGA,IAAI,YAA8B;EAChC,OAAO,KAAKD,OAAO;CACrB;CAEA,IAAI,iBAAmC;EACrC,OAAO,KAAKA,OAAO;CACrB;CAEA,IAAI,KAAc;EAChB,OAAO,KAAK,WAAWE,qCAAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,KAAK,MAAM;CAC1E;CAEA,IAAI,UAA+B;EACjC,IAAI,KAAK,WACP,OAAO,KAAK,WAAWC,qCAAAA,gBAAgB,KAAK,QAAQ,KAAK,WAAW,KAAK,MAAM;EAEjF,MAAM,IAAI,MAAM,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACnE;CAEA,IAAI,aAAqB;EACvB,OAAO,KAAK,mBAAmBD,qCAAAA,SAAS,KAAK,QAAQ,KAAK,WAAW,KAAK,MAAM;CAClF;CAEA,IAAI,kBAAsC;EACxC,OAAO,KAAK,mBAAmBC,qCAAAA,gBAAgB,KAAK,QAAQ,KAAK,WAAW,KAAK,MAAM;CACzF;CAEA,IAAY,UAA+B;EACzC,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,KAAK,WACP,OAAO,KAAK,QAAQ;EAEtB,MAAM,IAAI,MAAM,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACnE;CAEA,IAAI,gBAAsC;EACxC,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,KAAK,WACP,OAAO,KAAK,QAAQ;EAEtB,MAAM,IAAI,MAAM,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACnE;CAEA,IAAY,kBAAsC;EAChD,OAAOC,aAAAA,QAAQ,KAAK,WAAW,KAAK,OAAO;CAC7C;CAEA,IAAI,QAAiB;EACnB,IAAI,KAAK,WACP,OAAO,KAAK,WAAW,KAAA;EAEzB,MAAM,IAAI,MAAM,GAAG,KAAK,OAAO,GAAG,KAAK,UAAU,gBAAgB;CACnE;CAGA,MAAM,KAAK,OAAyD,CAAC,GAA2B;EAC9F,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAK,aAAa,KAAK,aAAa;GACvC,IAAI,CAAC,KAAK,OAAO,aAAa;IAC5B,MAAM,aAAa,KAAK,aAAa;IACrC,IAAI,YACF,KAAK,SAAS,WAAW;SACpB;KACL,IAAI;MACF,MAAMC,yCAAAA,oBAAoB,KAAK,OAAO,IAAI,IAAI,CAAC,CAAC,KAAK,KAAK,OAAO,QAAQ;KAC3E,SAAS,KAAK;MACZ,MAAMC,sBAAAA,YAAY,qBAAc,IAAI,MAAM,CAAC;KAC7C;KACA,KAAK,QAAQ;IACf;GACF;GACA,KAAK,YAAY;EACnB;EACA,OAAO,KAAK,cAAc,KAAK,QAAQ,IAAI;CAC7C;CAEA,IAAI,OAAU,OAAkC,CAAC,GAAS;EACxD,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,KAAKC,cAAc;EACnB,IAAI,UAAU,KAAK,QAAQ;GACzB,KAAK,YAAY;GACjB;EACF;EACA,IAAI,KAAK,WACH;OAAA,KAAK,UAAU,CAAC,KAAK,aACvB,KAAK,iBAAiB,KAAK,MAAM,CAAC,CAAC,IAAI,KAAA,CAAS;EAAA;EAGpD,MAAM,EAAE,gBAAgBC,sBAAAA,iBAAiB,KAAK,OAAO,EAAE;EACvD,YAAY,OAAO,KAAK,QAAQ,KAAK,WAAW,KAAK;EACrD,KAAK,SAAS;EACd,KAAK,YAAY;EAEjB,IAAI,SAAS,CAAC,KAAK,aACjB,KAAK,iBAAiB,KAAK,CAAC,CAAC,IAAI,KAAK,MAAM;CAEhD;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAK;CACd;CAEA,IAAI,cAAuB;EACzB,OAAO,CAAC,CAAC,KAAK,aAAa;CAC7B;CAEA,UAAgB;EACd,KAAK,SAAS,KAAK,aAAa,CAAC,GAAG;EACpC,KAAK,YAAY;CACnB;CAEA,OAAO,OAAoC,YAA+B;EACxE,KAAK,SAAS,MAAM,SAAS,WAAW,MAAM,MAAM,IAAI,KAAA;EACxD,KAAK,YAAY;CACnB;CAEA,IAAI,iBAAgC;EAClC,OAAO,KAAK,cAAc,KAAK,MAAM,GAAG,EAAE,aAAa,KAAK,CAAC;CAC/D;CAEA,IAAI,MAAqB;EACvB,OAAO,KAAK,cAAc,KAAK,MAAM,GAAG,EAAE,aAAa,MAAM,CAAC;CAChE;CAEA,IAAI,YAA4B;EAC9B,OAAO,KAAKR,OAAO,cAAc;CACnC;CAEA,QAA+B;EAC7B,cAAA,iBAAiB,KAAK,QAAQ,SAAS;EACvC,IAAI,CAAC,KAAK,WAER,MAAM,IAAI,MAAM,gCAAgC;EAElD,OAAO,KAAK;CACd;CAIA,YAAY,OAAgB;EAC1B,KAAK,IAAI,KAAK;CAChB;CAEA,qBAA2B;EACzB,IAAI,KAAK,mBAAmB,KAAK,QAC/B,KAAK,OAAO,GAAG,OAAO,KAAK,MAAM;CAErC;CAEA,MAAM,yBAAwC;EAE5C,IAAI,KAAK,iBAAiB;EAC1B,MAAM,UAAU,MAAM,KAAK,KAAK,EAAE,aAAa,KAAK,CAAC;EACrD,IAAI,YAAY,KAAA,GAAW;GACzB,MAAM,YAAY,KAAK,iBAAiB,OAAO;GAE/C,IAAI,CAACS,oCAAAA,oBAAoB,SAAS,GAChC,UAAU,IAAI,KAAA,CAAgB;GAEhC,eAAA,SAAS,SAAS,KAAK,gBAAgB,KAAA,CAAS;EAClD;EACA,KAAK,SAAS,KAAA;EACd,KAAK,YAAY;CACnB;CAEA,IAAI,aAAa;EACf,OAAO,KAAKF;CACd;CAEA,WAA0B;EACxB,OAAO,6BAA6B,KAAK,OAAO,eAAe,KAAK,UAAU,eAAe,KAAK,UAAU,KAAK,oBAAoB,KAAK,eAAe;CAC3J;CAEA,cAAsB,QAAuB,MAAiD;EAC5F,OAAO,MAAM,gBAAgB,QAAQ,WAAW,KAAA,KAAa,CAAC,OAAO,kBAAkB,SAAS,KAAA;CAClG;;CAGA,iBAAyB,OAAyC;EAChE,OAAQ,MAAY,KAAK;CAC3B;CAEA,eAAwC;EACtC,IAAI,KAAK,OAAO,aAAa,OAAO,KAAA;EACpC,OAAOC,sBAAAA,iBAAiB,KAAK,OAAO,EAAE,CAAC,CAAC,qBAAqB,KAAK,OAAO,UAAU,KAAK,SAAS;CACnG;CAEA,IAAY,kBAA2B;EACrC,OAAOE,kCAAAA,gBAAgB,MAAM,KAAK,SAAS;CAC7C;CAEA,CAACC,kCAAAA,aAAa;CACd,CAACC,kCAAAA,aAAa;CACd,CAACC,mCAAAA,cAAc;CACf,CAAC,YAAY;AACf"}

package/build/relations/OneToOneReference.d.cts

@@ -0,0 +1,97 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.cjs";
+import { RelationT, RelationU } from "./RelationSymbols.cjs";
+import { ReferenceN } from "./ReferenceSymbols.cjs";
+import { LoadedReference, Reference } from "./Reference.cjs";
+import { EntityMetadata, OneToOneField } from "../EntityMetadata.cjs";
+import "../index.cjs";
+import { IdOf, TaggedId } from "../EntityManager.cjs";
+import { Entity } from "../Entity.cjs";
+//#region src/relations/OneToOneReference.d.ts
+declare const OneToOne: unique symbol;
+/** An alias for creating `OneToOneReference`s. */
+declare function hasOneToOne<T extends Entity, U extends Entity>(): OneToOneReference<T, U>;
+/** The lazy-loaded/lookup side of a one-to-one, i.e. the side w/o the unique foreign key column. */
+interface OneToOneReference<T extends Entity, U extends Entity> extends Reference<T, U, undefined> {
+  [OneToOne]: T;
+}
+/** Adds a known-safe `get` accessor. */
+interface LoadedOneToOneReference<T extends Entity, U extends Entity> extends LoadedReference<T, U, undefined> {
+  get: U | undefined;
+  getWithDeleted: U | undefined;
+  /** Returns the id of the current assigned entity or a runtime error if it's either a) unset or b) set to a new entity that doesn't have an `id` yet. */
+  id: IdOf<U>;
+  idIfSet: IdOf<U> | undefined;
+  idUntagged: string;
+  idUntaggedMaybe: string | undefined;
+  /** Returns `true` if this relation is currently set (i.e. regardless of whether it's loaded, or if it is set but the assigned entity doesn't have an id saved. */
+  readonly isSet: boolean;
+}
+/** Type guard utility for determining if an entity field is a Reference. */
+declare function isOneToOneReference(maybeReference: any): maybeReference is OneToOneReference<any, any>;
+/** Type guard utility for determining if an entity field is a loaded Reference. */
+declare function isLoadedOneToOneReference(maybeReference: any): maybeReference is Reference<any, any, any> & LoadedOneToOneReference<any, any>;
+/**
+ * Represents the "many" side of a one-to-one relationship.
+ *
+ * I.e. in a one-to-many from Book -> Reviews, there is a review.book_id that can have many books.
+ *
+ * This class is for when that `review.book_id` column is itself unique, i.e. like `image.book_id`, and
+ * so instead of `Book.images: OneToManyCollection` we have a `Book.image: OneToOneReference`.
+ *
+ * This class implements `Reference` because it is essentially like "one entity pointing/refereing to another",
+ * however because we require a `.load` call to lazily know the value of other side (unlike ManyToOneReference
+ * which has it's `book_id` column immediately available in the entity `data` hash), there is some wonkiness
+ * around methods like `Reference.id` that are usually callable without `load`/`populate`, that for this
+ * class can actually only be called post `load`/`populate`.
+ *
+ * Currently we enforce this with a runtime check, which is not great, but the trade-off of implementing
+ * `Reference` seemed worth the downside of a un-type-safe `.id` property.
+ */
+declare class OneToOneReferenceImpl<T extends Entity, U extends Entity> extends AbstractRelationImpl<T, U> implements OneToOneReference<T, U> {
+  #private;
+  private loaded;
+  private _isLoaded;
+  constructor(entity: T, field: OneToOneField);
+  get fieldName(): keyof T & string;
+  get otherFieldName(): keyof U & string;
+  get id(): IdOf<U>;
+  get idIfSet(): IdOf<U> | undefined;
+  get idUntagged(): string;
+  get idUntaggedIfSet(): string | undefined;
+  private get idMaybe();
+  get idTaggedMaybe(): TaggedId | undefined;
+  private get idUntaggedMaybe();
+  get isSet(): boolean;
+  load(opts?: {
+    withDeleted?: boolean;
+    forceReload?: boolean;
+  }): Promise<U | undefined>;
+  set(other: U, opts?: {
+    percolating?: boolean;
+  }): void;
+  get isLoaded(): boolean;
+  get isPreloaded(): boolean;
+  preload(): void;
+  import(other: OneToOneReferenceImpl<T, U>, findEntity: (e: U) => U): void;
+  get getWithDeleted(): U | undefined;
+  get get(): U | undefined;
+  get otherMeta(): EntityMetadata;
+  private doGet;
+  setFromOpts(other: U): void;
+  maybeCascadeDelete(): void;
+  cleanupOnEntityDeleted(): Promise<void>;
+  get hasBeenSet(): boolean;
+  toString(): string;
+  private filterDeleted;
+  /** Returns the other relation that points back at us, i.e. we're `Author.image` and this is `Image.author_id`. */
+  private getOtherRelation;
+  private getPreloaded;
+  private get isCascadeDelete();
+  [RelationT]: never;
+  [RelationU]: never;
+  [ReferenceN]: never;
+  [OneToOne]: never;
+}
+//#endregion
+export { LoadedOneToOneReference, OneToOneReference, OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference };
+//# sourceMappingURL=OneToOneReference.d.cts.map

package/build/relations/OneToOneReference.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OneToOneReference.d.cts","names":[],"sources":["../../src/relations/OneToOneReference.ts"],"mappings":";;;;;;;;;cAyBM;;iBAGU,YAAY,UAAU,QAAQ,UAAU,WAAW,kBAAkB,GAAG;;UAQvE,kBAAkB,UAAU,QAAQ,UAAU,gBAAgB,UAAU,GAAG;GAEzF,WAAW;;;UAIG,wBAAwB,UAAU,QAAQ,UAAU,gBAAgB,gBAAgB,GAAG;EACtG,KAAK;EAEL,gBAAgB;;EAMhB,IAAI,KAAK;EAET,SAAS,KAAK;EAEd;EAEA;;WAGS;;;iBAIK,oBAAoB,sBAAsB,kBAAkB;;iBAK5D,0BACd,sBACC,kBAAkB,2BAA2B;;;;;;;;;;;;;;;;;;cAqBnC,sBAAsB,UAAU,QAAQ,UAAU,gBACrD,qBAAqB,GAAG,cACrB,kBAAkB,GAAG;;UAGxB;UACA;EAGR,YAAY,QAAQ,GAAG,OAAO;MAS1B,mBAAmB;MAInB,wBAAwB;MAIxB,MAAM,KAAK;MAIX,WAAW,KAAK;MAOhB;MAIA;cAIQ;MAQR,iBAAiB;cAQT;MAIR;EAQE,KAAK;IAAQ;IAAuB;MAA+B,QAAQ;EAqBjF,IAAI,OAAO,GAAG;IAAQ;;MAsBlB;MAIA;EAIJ;EAKA,OAAO,OAAO,sBAAsB,GAAG,IAAI,aAAa,GAAG,MAAM;MAK7D,kBAAkB;MAIlB,OAAO;MAIP,aAAa;UAIT;EAWR,YAAY,OAAO;EAInB;EAMM,0BAA0B;MAgB5B;EAIG;UAIC;;UAKA;UAIA;cAKI;GAIX;GACA;GACA;GACA"}

package/build/relations/OneToOneReference.d.mts

@@ -0,0 +1,97 @@
+import { AbstractRelationImpl } from "./AbstractRelationImpl.mjs";
+import { RelationT, RelationU } from "./RelationSymbols.mjs";
+import { ReferenceN } from "./ReferenceSymbols.mjs";
+import { LoadedReference, Reference } from "./Reference.mjs";
+import { EntityMetadata, OneToOneField } from "../EntityMetadata.mjs";
+import "../index.mjs";
+import { IdOf, TaggedId } from "../EntityManager.mjs";
+import { Entity } from "../Entity.mjs";
+//#region src/relations/OneToOneReference.d.ts
+declare const OneToOne: unique symbol;
+/** An alias for creating `OneToOneReference`s. */
+declare function hasOneToOne<T extends Entity, U extends Entity>(): OneToOneReference<T, U>;
+/** The lazy-loaded/lookup side of a one-to-one, i.e. the side w/o the unique foreign key column. */
+interface OneToOneReference<T extends Entity, U extends Entity> extends Reference<T, U, undefined> {
+  [OneToOne]: T;
+}
+/** Adds a known-safe `get` accessor. */
+interface LoadedOneToOneReference<T extends Entity, U extends Entity> extends LoadedReference<T, U, undefined> {
+  get: U | undefined;
+  getWithDeleted: U | undefined;
+  /** Returns the id of the current assigned entity or a runtime error if it's either a) unset or b) set to a new entity that doesn't have an `id` yet. */
+  id: IdOf<U>;
+  idIfSet: IdOf<U> | undefined;
+  idUntagged: string;
+  idUntaggedMaybe: string | undefined;
+  /** Returns `true` if this relation is currently set (i.e. regardless of whether it's loaded, or if it is set but the assigned entity doesn't have an id saved. */
+  readonly isSet: boolean;
+}
+/** Type guard utility for determining if an entity field is a Reference. */
+declare function isOneToOneReference(maybeReference: any): maybeReference is OneToOneReference<any, any>;
+/** Type guard utility for determining if an entity field is a loaded Reference. */
+declare function isLoadedOneToOneReference(maybeReference: any): maybeReference is Reference<any, any, any> & LoadedOneToOneReference<any, any>;
+/**
+ * Represents the "many" side of a one-to-one relationship.
+ *
+ * I.e. in a one-to-many from Book -> Reviews, there is a review.book_id that can have many books.
+ *
+ * This class is for when that `review.book_id` column is itself unique, i.e. like `image.book_id`, and
+ * so instead of `Book.images: OneToManyCollection` we have a `Book.image: OneToOneReference`.
+ *
+ * This class implements `Reference` because it is essentially like "one entity pointing/refereing to another",
+ * however because we require a `.load` call to lazily know the value of other side (unlike ManyToOneReference
+ * which has it's `book_id` column immediately available in the entity `data` hash), there is some wonkiness
+ * around methods like `Reference.id` that are usually callable without `load`/`populate`, that for this
+ * class can actually only be called post `load`/`populate`.
+ *
+ * Currently we enforce this with a runtime check, which is not great, but the trade-off of implementing
+ * `Reference` seemed worth the downside of a un-type-safe `.id` property.
+ */
+declare class OneToOneReferenceImpl<T extends Entity, U extends Entity> extends AbstractRelationImpl<T, U> implements OneToOneReference<T, U> {
+  #private;
+  private loaded;
+  private _isLoaded;
+  constructor(entity: T, field: OneToOneField);
+  get fieldName(): keyof T & string;
+  get otherFieldName(): keyof U & string;
+  get id(): IdOf<U>;
+  get idIfSet(): IdOf<U> | undefined;
+  get idUntagged(): string;
+  get idUntaggedIfSet(): string | undefined;
+  private get idMaybe();
+  get idTaggedMaybe(): TaggedId | undefined;
+  private get idUntaggedMaybe();
+  get isSet(): boolean;
+  load(opts?: {
+    withDeleted?: boolean;
+    forceReload?: boolean;
+  }): Promise<U | undefined>;
+  set(other: U, opts?: {
+    percolating?: boolean;
+  }): void;
+  get isLoaded(): boolean;
+  get isPreloaded(): boolean;
+  preload(): void;
+  import(other: OneToOneReferenceImpl<T, U>, findEntity: (e: U) => U): void;
+  get getWithDeleted(): U | undefined;
+  get get(): U | undefined;
+  get otherMeta(): EntityMetadata;
+  private doGet;
+  setFromOpts(other: U): void;
+  maybeCascadeDelete(): void;
+  cleanupOnEntityDeleted(): Promise<void>;
+  get hasBeenSet(): boolean;
+  toString(): string;
+  private filterDeleted;
+  /** Returns the other relation that points back at us, i.e. we're `Author.image` and this is `Image.author_id`. */
+  private getOtherRelation;
+  private getPreloaded;
+  private get isCascadeDelete();
+  [RelationT]: never;
+  [RelationU]: never;
+  [ReferenceN]: never;
+  [OneToOne]: never;
+}
+//#endregion
+export { LoadedOneToOneReference, OneToOneReference, OneToOneReferenceImpl, hasOneToOne, isLoadedOneToOneReference, isOneToOneReference };
+//# sourceMappingURL=OneToOneReference.d.mts.map

package/build/relations/OneToOneReference.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OneToOneReference.d.mts","names":[],"sources":["../../src/relations/OneToOneReference.ts"],"mappings":";;;;;;;;;cAyBM;;iBAGU,YAAY,UAAU,QAAQ,UAAU,WAAW,kBAAkB,GAAG;;UAQvE,kBAAkB,UAAU,QAAQ,UAAU,gBAAgB,UAAU,GAAG;GAEzF,WAAW;;;UAIG,wBAAwB,UAAU,QAAQ,UAAU,gBAAgB,gBAAgB,GAAG;EACtG,KAAK;EAEL,gBAAgB;;EAMhB,IAAI,KAAK;EAET,SAAS,KAAK;EAEd;EAEA;;WAGS;;;iBAIK,oBAAoB,sBAAsB,kBAAkB;;iBAK5D,0BACd,sBACC,kBAAkB,2BAA2B;;;;;;;;;;;;;;;;;;cAqBnC,sBAAsB,UAAU,QAAQ,UAAU,gBACrD,qBAAqB,GAAG,cACrB,kBAAkB,GAAG;;UAGxB;UACA;EAGR,YAAY,QAAQ,GAAG,OAAO;MAS1B,mBAAmB;MAInB,wBAAwB;MAIxB,MAAM,KAAK;MAIX,WAAW,KAAK;MAOhB;MAIA;cAIQ;MAQR,iBAAiB;cAQT;MAIR;EAQE,KAAK;IAAQ;IAAuB;MAA+B,QAAQ;EAqBjF,IAAI,OAAO,GAAG;IAAQ;;MAsBlB;MAIA;EAIJ;EAKA,OAAO,OAAO,sBAAsB,GAAG,IAAI,aAAa,GAAG,MAAM;MAK7D,kBAAkB;MAIlB,OAAO;MAIP,aAAa;UAIT;EAWR,YAAY,OAAO;EAInB;EAMM,0BAA0B;MAgB5B;EAIG;UAIC;;UAKA;UAIA;cAKI;GAIX;GACA;GACA;GACA"}