@danceroutine/tango-orm 1.6.0 → 1.8.0

package/dist/registerModelObjects-DxlBfuUN.js

@@ -0,0 +1,797 @@
+import { InternalQNodeType, InternalRelationKind, InternalSqlValidationPlanKind, ModelQuerySet, OrmSqlSafetyAdapter, QBuilder, QueryResult, QuerySet, TableMetaFactory, isQNodeLike } from "./query-DUZnBFhf.js";
+import { RuntimeBoundClient, TransactionEngine, getTangoRuntime } from "./defaultRuntime-DzqBQ9Hb.js";
+import { NotFoundError } from "@danceroutine/tango-core";
+import { ModelRegistry, registerModelAugmentor } from "@danceroutine/tango-schema";
+
+//#region src/manager/relations/ManyToManyRelatedQuerySet.ts
+function applyShape(rows, shape) {
+	return typeof shape === "function" ? rows.map(shape) : rows.map((row) => shape.parse(row));
+}
+var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet {
+	constructor(executor, bridge, state = {}) {
+		super(executor, state);
+		this.bridge = bridge;
+	}
+	async fetch(shape) {
+		if (this.isStateTrivial()) {
+			const cache = this.bridge.getCache();
+			if (cache !== null) {
+				const results = shape ? applyShape(cache, shape) : [...cache];
+				return new QueryResult(results);
+			}
+		}
+		const ids = await this.bridge.fetchTargetIds();
+		if (ids.length === 0) return new QueryResult([]);
+		const scopedQs = new ModelQuerySet(this.executor, this.scopedState(ids));
+		return shape ? scopedQs.fetch(shape) : scopedQs.fetch();
+	}
+	async fetchOne(shape) {
+		const result = shape ? await this.fetch(shape) : await this.fetch();
+		return result.items[0] ?? null;
+	}
+	async count() {
+		if (this.isStateTrivial()) {
+			const cache = this.bridge.getCache();
+			if (cache !== null) return cache.length;
+		}
+		const ids = await this.bridge.fetchTargetIds();
+		if (ids.length === 0) return 0;
+		if (this.isStateTrivial()) return ids.length;
+		const scopedQs = new ModelQuerySet(this.executor, this.scopedState(ids));
+		return scopedQs.count();
+	}
+	spawn(state) {
+		return new ManyToManyRelatedQuerySet(this.executor, this.bridge, state);
+	}
+	isStateTrivial() {
+		return Object.keys(this.state).length === 0;
+	}
+	scopedState(ids) {
+		const inFilter = { [`${this.bridge.targetPrimaryKeyField}__in`]: [...ids] };
+		const inAtom = {
+			kind: InternalQNodeType.ATOM,
+			where: inFilter
+		};
+		const merged = this.state.q ? QBuilder.and(inAtom, this.state.q) : inAtom;
+		return {
+			...this.state,
+			q: merged
+		};
+	}
+};
+
+//#endregion
+//#region src/manager/internal/MutationCompiler.ts
+const InternalDuplicateInsertPolicy = {
+	ERROR: "error",
+	IGNORE: "ignore"
+};
+var MutationCompiler = class {
+	adapter;
+	placeholders;
+	constructor(adapter) {
+		this.adapter = adapter;
+		this.placeholders = adapter.placeholders;
+	}
+	compileInsert(plan, values) {
+		return {
+			sql: `INSERT INTO ${plan.meta.table} (${plan.writeKeys.join(", ")}) VALUES (${this.placeholders.list(plan.writeKeys.length)}) RETURNING *`,
+			params: values
+		};
+	}
+	compileUpdate(plan, values, id) {
+		const sets = plan.writeKeys.map((key, index) => `${key} = ${this.placeholders.at(index + 1)}`).join(", ");
+		const whereParam = this.placeholders.at(plan.writeKeys.length + 1);
+		return {
+			sql: `UPDATE ${plan.meta.table} SET ${sets} WHERE ${plan.meta.pk} = ${whereParam} RETURNING *`,
+			params: [...values, id]
+		};
+	}
+	compileDelete(plan, id) {
+		return {
+			sql: `DELETE FROM ${plan.meta.table} WHERE ${plan.meta.pk} = ${this.placeholders.at(1)}`,
+			params: [id]
+		};
+	}
+	compileDeleteByJoinKeys(plan, leftFilterKey, rightFilterKey, leftValue, rightValue) {
+		const leftDescriptor = plan.filterKeys[leftFilterKey];
+		const rightDescriptor = plan.filterKeys[rightFilterKey];
+		if (!leftDescriptor || !rightDescriptor) throw new Error(`MutationCompiler.compileDeleteByJoinKeys: filter keys '${leftFilterKey}' and '${rightFilterKey}' must be present on the validated plan.`);
+		return {
+			sql: `DELETE FROM ${plan.meta.table} WHERE ${leftDescriptor.field} = ${this.placeholders.at(1)} AND ${rightDescriptor.field} = ${this.placeholders.at(2)}`,
+			params: [leftValue, rightValue]
+		};
+	}
+	compileBulkInsert(plan, valueRows) {
+		const columnCount = plan.writeKeys.length;
+		const placeholders = valueRows.map((_row, rowIndex) => `(${this.placeholders.listFromOffset(columnCount, rowIndex * columnCount)})`).join(", ");
+		return {
+			sql: `INSERT INTO ${plan.meta.table} (${plan.writeKeys.join(", ")}) VALUES ${placeholders} RETURNING *`,
+			params: valueRows.flat()
+		};
+	}
+	compileInsertJoinLinks(plan, sourceKey, targetKey, ownerValue, targetValues, duplicatePolicy) {
+		const valueRows = targetValues.map((targetValue) => [ownerValue, targetValue]);
+		const placeholders = valueRows.map((_row, rowIndex) => `(${this.placeholders.listFromOffset(2, rowIndex * 2)})`).join(", ");
+		const params = valueRows.flat();
+		if (duplicatePolicy === InternalDuplicateInsertPolicy.IGNORE) switch (this.adapter.dialect) {
+			case "postgres": return {
+				sql: `INSERT INTO ${plan.meta.table} (${plan.writeKeys.join(", ")}) VALUES ${placeholders} ON CONFLICT (${sourceKey}, ${targetKey}) DO NOTHING`,
+				params
+			};
+			case "sqlite": return {
+				sql: `INSERT OR IGNORE INTO ${plan.meta.table} (${plan.writeKeys.join(", ")}) VALUES ${placeholders}`,
+				params
+			};
+		}
+		return {
+			sql: `INSERT INTO ${plan.meta.table} (${plan.writeKeys.join(", ")}) VALUES ${placeholders}`,
+			params
+		};
+	}
+	compileDeleteJoinLinks(plan, leftFilterKey, rightFilterKey, leftValue, rightValues) {
+		const leftDescriptor = plan.filterKeys[leftFilterKey];
+		const rightDescriptor = plan.filterKeys[rightFilterKey];
+		if (!leftDescriptor || !rightDescriptor) throw new Error(`MutationCompiler.compileDeleteJoinLinks: filter keys '${leftFilterKey}' and '${rightFilterKey}' must be present on the validated plan.`);
+		if (rightValues.length === 0) throw new Error("MutationCompiler.compileDeleteJoinLinks requires at least one target value.");
+		if (rightValues.length === 1) return {
+			sql: `DELETE FROM ${plan.meta.table} WHERE ${leftDescriptor.field} = ${this.placeholders.at(1)} AND ${rightDescriptor.field} = ${this.placeholders.at(2)}`,
+			params: [leftValue, rightValues[0]]
+		};
+		return {
+			sql: `DELETE FROM ${plan.meta.table} WHERE ${leftDescriptor.field} = ${this.placeholders.at(1)} AND ${rightDescriptor.field} IN (${this.placeholders.listFromOffset(rightValues.length, 1)})`,
+			params: [leftValue, ...rightValues]
+		};
+	}
+};
+
+//#endregion
+//#region src/manager/relations/internal/ThroughTableManager.ts
+var ThroughTableManager = class ThroughTableManager {
+	constructor(client, mutationCompiler, descriptor, adapter, sqlSafetyAdapter$1 = new OrmSqlSafetyAdapter()) {
+		this.client = client;
+		this.mutationCompiler = mutationCompiler;
+		this.descriptor = descriptor;
+		this.adapter = adapter;
+		this.sqlSafetyAdapter = sqlSafetyAdapter$1;
+	}
+	/**
+	* Derive a {@link ThroughTableLinkDescriptor} from the through-model
+	* metadata exposed by a many-to-many relation edge.
+	*/
+	static buildLinkDescriptor(relation, throughModelFields) {
+		if (!relation.throughTable || !relation.throughSourceKey || !relation.throughTargetKey) throw new Error("Cannot derive a through-table descriptor from a relation that is not a persisted many-to-many edge.");
+		const primaryKeyField = throughModelFields.find((field) => field.primaryKey);
+		if (!primaryKeyField) throw new Error("Through-model metadata is missing a primary-key field.");
+		return {
+			table: relation.throughTable,
+			primaryKey: primaryKeyField.name,
+			columns: Object.fromEntries(throughModelFields.map((field) => [field.name, field.type])),
+			sourceColumn: relation.throughSourceKey,
+			targetColumn: relation.throughTargetKey
+		};
+	}
+	/**
+	* Convenience factory that derives the join-table descriptor from the
+	* relation edge and instantiates a {@link ThroughTableManager} in one
+	* step.
+	*/
+	static fromRelation(inputs) {
+		return new ThroughTableManager(inputs.client, inputs.mutationCompiler, ThroughTableManager.buildLinkDescriptor(inputs.relation, inputs.throughModelFields), inputs.adapter, inputs.sqlSafetyAdapter);
+	}
+	/**
+	* Read every target primary-key value linked to the supplied owner via
+	* the join table. Used by ManyToManyRelatedManager.all to scope
+	* follow-up target queries to the current owner.
+	*/
+	async selectTargetIdsForOwner(ownerPrimaryKey) {
+		const validated = this.sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.SELECT,
+			meta: {
+				table: this.descriptor.table,
+				pk: this.descriptor.primaryKey,
+				columns: this.descriptor.columns
+			},
+			filterKeys: [this.descriptor.sourceColumn, this.descriptor.targetColumn]
+		});
+		const sourceColumn = validated.filterKeys[this.descriptor.sourceColumn].field;
+		const targetColumn = validated.filterKeys[this.descriptor.targetColumn].field;
+		const placeholder = this.adapter.placeholders.at(1);
+		const sql = `SELECT ${targetColumn} AS target_id FROM ${validated.meta.table} WHERE ${sourceColumn} = ${placeholder}`;
+		const result = await this.client.query(sql, [ownerPrimaryKey]);
+		return result.rows.map((row) => row.target_id).filter((value) => typeof value === "string" || typeof value === "number");
+	}
+	async insertLink(ownerPrimaryKey, targetPrimaryKey, options = {}) {
+		await this.insertLinks(ownerPrimaryKey, [targetPrimaryKey], options);
+	}
+	async insertLinks(ownerPrimaryKey, targetPrimaryKeys, options = {}) {
+		if (targetPrimaryKeys.length === 0) return;
+		const validatedPlan = this.sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.INSERT,
+			meta: {
+				table: this.descriptor.table,
+				pk: this.descriptor.primaryKey,
+				columns: this.descriptor.columns
+			},
+			writeKeys: [this.descriptor.sourceColumn, this.descriptor.targetColumn]
+		});
+		const duplicatePolicy = options.onDuplicate ?? InternalDuplicateInsertPolicy.ERROR;
+		if (duplicatePolicy === InternalDuplicateInsertPolicy.IGNORE && !this.adapter.features.ignoreDuplicateInsert) throw new Error(`Adapter '${this.adapter.name}' does not support duplicate-safe link insertion for many-to-many writes.`);
+		const compiled = this.mutationCompiler.compileInsertJoinLinks(validatedPlan, this.descriptor.sourceColumn, this.descriptor.targetColumn, ownerPrimaryKey, targetPrimaryKeys, duplicatePolicy);
+		await this.client.query(compiled.sql, compiled.params);
+	}
+	async deleteLink(ownerPrimaryKey, targetPrimaryKey) {
+		await this.deleteLinks(ownerPrimaryKey, [targetPrimaryKey]);
+	}
+	async deleteLinks(ownerPrimaryKey, targetPrimaryKeys) {
+		if (targetPrimaryKeys.length === 0) return;
+		const validated = this.sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.SELECT,
+			meta: {
+				table: this.descriptor.table,
+				pk: this.descriptor.primaryKey,
+				columns: this.descriptor.columns
+			},
+			filterKeys: [this.descriptor.sourceColumn, this.descriptor.targetColumn]
+		});
+		const compiled = this.mutationCompiler.compileDeleteJoinLinks(validated, this.descriptor.sourceColumn, this.descriptor.targetColumn, ownerPrimaryKey, targetPrimaryKeys);
+		await this.client.query(compiled.sql, compiled.params);
+	}
+};
+
+//#endregion
+//#region src/manager/relations/ManyToManyRelatedManager.ts
+var ManyToManyRelatedManager = class ManyToManyRelatedManager {
+	static BRAND = "tango.orm.m2m_related_manager";
+	__tangoBrand = ManyToManyRelatedManager.BRAND;
+	prefetchCache = null;
+	/**
+	* Constructor is internal. Application and ORM code must build instances
+	* through {@link ManyToManyRelatedManager.create}, which owns the wiring
+	* between relation metadata and the backing through-table mutator. The
+	* testing package exposes a fixture for unit tests that need a custom
+	* mutator.
+	*/
+	constructor(inputs) {
+		this.inputs = inputs;
+	}
+	/**
+	* Narrow an unknown value to {@link ManyToManyRelatedManager}.
+	*/
+	static isManyToManyRelatedManager(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === ManyToManyRelatedManager.BRAND;
+	}
+	/**
+	* Build a {@link ManyToManyRelatedManager} bound to a single owner record.
+	* The factory derives the join-table descriptor from the relation edge and
+	* through-model fields, wires a {@link ThroughTableManager} against the
+	* supplied runtime-bound client, and returns a manager whose `add`,
+	* `remove`, and `all` methods enroll in any active
+	* `transaction.atomic(...)` boundary.
+	*/
+	static create(inputs) {
+		const throughTableManager = ThroughTableManager.fromRelation({
+			relation: inputs.relation,
+			throughModelFields: inputs.throughModelFields,
+			client: inputs.client,
+			mutationCompiler: inputs.mutationCompiler,
+			adapter: inputs.adapter,
+			sqlSafetyAdapter: inputs.sqlSafetyAdapter
+		});
+		return new ManyToManyRelatedManager({
+			ownerPrimaryKey: inputs.ownerPrimaryKey,
+			relationName: inputs.relationName,
+			ownerModelLabel: inputs.ownerModelLabel,
+			targetPrimaryKeyField: inputs.relation.targetPrimaryKey,
+			throughTableManager,
+			targetExecutorProvider: inputs.targetExecutorProvider,
+			runAtomic: inputs.runAtomic
+		});
+	}
+	/**
+	* Insert join-table rows linking the owning record to the supplied
+	* targets. Duplicate links are ignored so repeated `add(...)` calls are
+	* idempotent. When multiple targets are supplied, Tango performs the
+	* membership write inside one `transaction.atomic(...)` boundary.
+	*/
+	async add(...targets) {
+		const targetPrimaryKeys = this.resolveTargetPrimaryKeys(targets);
+		if (targetPrimaryKeys.length === 0) return;
+		if (targetPrimaryKeys.length === 1) await this.inputs.throughTableManager.insertLink(this.inputs.ownerPrimaryKey, targetPrimaryKeys[0], { onDuplicate: InternalDuplicateInsertPolicy.IGNORE });
+else await this.inputs.runAtomic(() => this.inputs.throughTableManager.insertLinks(this.inputs.ownerPrimaryKey, targetPrimaryKeys, { onDuplicate: InternalDuplicateInsertPolicy.IGNORE }));
+		this.invalidateCache();
+	}
+	/**
+	* Delete join-table rows linking the owning record to the supplied
+	* targets. When multiple targets are supplied, Tango performs the
+	* membership write inside one `transaction.atomic(...)` boundary.
+	*/
+	async remove(...targets) {
+		const targetPrimaryKeys = this.resolveTargetPrimaryKeys(targets);
+		if (targetPrimaryKeys.length === 0) return;
+		if (targetPrimaryKeys.length === 1) await this.inputs.throughTableManager.deleteLink(this.inputs.ownerPrimaryKey, targetPrimaryKeys[0]);
+else await this.inputs.runAtomic(() => this.inputs.throughTableManager.deleteLinks(this.inputs.ownerPrimaryKey, targetPrimaryKeys));
+		this.invalidateCache();
+	}
+	/**
+	* Return a {@link QuerySet} for the related target rows of this many-to-many
+	* relation. When the relation was already loaded by `prefetchRelated(...)`,
+	* the first `fetch()` resolves with the cached materialization without
+	* re-querying. Mutating the membership through `add`/`remove` invalidates
+	* that cache.
+	*/
+	all() {
+		const executor = this.inputs.targetExecutorProvider();
+		if (!executor) throw new Error(`Cannot resolve a target query executor for relation '${this.inputs.relationName}' on '${this.inputs.ownerModelLabel}'.`);
+		return new ManyToManyRelatedQuerySet(executor, {
+			getCache: () => this.prefetchCache,
+			fetchTargetIds: () => this.inputs.throughTableManager.selectTargetIdsForOwner(this.inputs.ownerPrimaryKey),
+			targetPrimaryKeyField: this.inputs.targetPrimaryKeyField
+		});
+	}
+	/**
+	* Replace the prefetch cache with the supplied target rows. Called by the
+	* many-to-many prefetch path so a follow-up `all()` resolves without an
+	* extra database round-trip.
+	*/
+	primePrefetchCache(targets) {
+		this.prefetchCache = [...targets];
+	}
+	/**
+	* Drop any cached prefetch results. Mutating helpers call this so reads
+	* after an `add`/`remove` go back to the database.
+	*/
+	invalidateCache() {
+		this.prefetchCache = null;
+	}
+	/**
+	* Snapshot of the current prefetch cache, exposed for diagnostics and
+	* focused unit testing. Returns a fresh array copy so callers cannot
+	* mutate the manager's internal state.
+	*/
+	snapshotCache() {
+		return this.prefetchCache ? [...this.prefetchCache] : null;
+	}
+	resolveTargetPrimaryKeys(targets) {
+		const resolved = [];
+		const seen = new Set();
+		for (const target of targets) {
+			const primaryKey = this.resolveTargetPrimaryKey(target);
+			const canonical = this.canonicalizePrimaryKey(primaryKey);
+			if (seen.has(canonical)) continue;
+			seen.add(canonical);
+			resolved.push(primaryKey);
+		}
+		return resolved;
+	}
+	resolveTargetPrimaryKey(target) {
+		if (typeof target === "string" || typeof target === "number") return target;
+		if (typeof target === "object" && target !== null) {
+			const targetPrimaryKey = target[this.inputs.targetPrimaryKeyField];
+			if (targetPrimaryKey === undefined || targetPrimaryKey === null) throw new Error(`Cannot resolve target primary key '${this.inputs.targetPrimaryKeyField}' for relation '${this.inputs.relationName}' on '${this.inputs.ownerModelLabel}'.`);
+			return targetPrimaryKey;
+		}
+		throw new Error(`Unsupported target reference for relation '${this.inputs.relationName}' on '${this.inputs.ownerModelLabel}'. Expected a record, a primary-key carrier, or a primary-key value.`);
+	}
+	canonicalizePrimaryKey(primaryKey) {
+		switch (typeof primaryKey) {
+			case "string": return `string:${primaryKey}`;
+			case "number": return `number:${primaryKey}`;
+			case "bigint": return `bigint:${String(primaryKey)}`;
+			case "boolean": return `boolean:${primaryKey}`;
+			default: return `json:${JSON.stringify(primaryKey)}`;
+		}
+	}
+};
+
+//#endregion
+//#region src/manager/ModelManager.ts
+const sqlSafetyAdapter = new OrmSqlSafetyAdapter();
+var ModelManager = class ModelManager {
+	static BRAND = "tango.orm.model_manager";
+	__tangoBrand = ModelManager.BRAND;
+	queryExecutor;
+	mutationCompiler;
+	model;
+	client;
+	adapter;
+	runtime;
+	constructor(model, runtime) {
+		this.model = model;
+		this.runtime = runtime;
+		this.client = new RuntimeBoundClient(runtime);
+		this.adapter = runtime.getAdapter();
+		this.mutationCompiler = new MutationCompiler(this.adapter);
+		this.queryExecutor = {
+			get meta() {
+				return ModelManager.createTableMeta(model);
+			},
+			client: this.client,
+			adapter: this.adapter,
+			run: async (compiled) => {
+				const result = await this.client.query(compiled.sql, compiled.params);
+				return result.rows;
+			},
+			attachPersistedRecordAccessors: (record, modelKey) => {
+				this.attachManyToManyRelatedManagers(record, modelKey ?? this.model.metadata.key);
+			}
+		};
+	}
+	get meta() {
+		return ModelManager.createTableMeta(this.model);
+	}
+	/**
+	* Narrow an unknown value to `ModelManager`.
+	*/
+	static isModelManager(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === ModelManager.BRAND;
+	}
+	static createTableMeta(model) {
+		const rawMeta = TableMetaFactory.create(model);
+		const validatedMeta = sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.INSERT,
+			meta: rawMeta,
+			writeKeys: Object.keys(rawMeta.columns)
+		}).meta;
+		if (rawMeta.relations) validatedMeta.relations = rawMeta.relations;
+		return validatedMeta;
+	}
+	static mergeCreatePayloadFromWhere(modelName, pkColumn, where, defaults) {
+		const hasDefaultsArg = defaults !== undefined;
+		const providedDefaults = defaults !== undefined ? { ...defaults } : undefined;
+		if (isQNodeLike(where)) {
+			if (!hasDefaultsArg || !providedDefaults || Object.keys(providedDefaults).length === 0) throw new Error(`Cannot create ${modelName} from Q filters without defaults.`);
+			const fromQ = ModelManager.collectPlainFieldsFromQNode(modelName, where);
+			const merged$1 = {
+				...fromQ,
+				...providedDefaults
+			};
+			const keys$1 = Object.keys(merged$1).filter((key) => merged$1[key] !== undefined);
+			const nonPkKeys$1 = keys$1.filter((key) => key !== pkColumn);
+			if (nonPkKeys$1.length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
+			return merged$1;
+		}
+		const atom = where;
+		const entries = Object.entries(atom);
+		const plainEntries = entries.filter(([key]) => !String(key).includes("__"));
+		const lookupOnly = entries.length > 0 && plainEntries.length === 0;
+		const fromAtom = plainEntries.length > 0 ? Object.fromEntries(plainEntries) : undefined;
+		const mergeBase = {
+			...fromAtom,
+			...providedDefaults
+		};
+		if (lookupOnly && ModelManager.countDefinedValues(mergeBase, pkColumn) === 0) throw new Error(`Cannot create ${modelName} from lookup-only filters without defaults.`);
+		const cleanedAtom = plainEntries.length > 0 ? Object.fromEntries(plainEntries) : {};
+		const merged = {
+			...cleanedAtom,
+			...mergeBase
+		};
+		const keys = Object.keys(merged).filter((key) => merged[key] !== undefined);
+		const nonPkKeys = keys.filter((key) => key !== pkColumn);
+		if (nonPkKeys.length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
+		return merged;
+	}
+	static countDefinedValues(payload, pkColumn) {
+		return Object.entries(payload).filter(([key, value]) => key !== pkColumn && value !== undefined).length;
+	}
+	static collectPlainFieldsFromQNode(modelName, node) {
+		switch (node.kind) {
+			case InternalQNodeType.ATOM: return ModelManager.omitLookupKeysFromAtom(node.where);
+			case InternalQNodeType.AND: {
+				const partials = (node.nodes ?? []).map((child) => ModelManager.collectPlainFieldsFromQNode(modelName, child));
+				return ModelManager.mergeCompatiblePartials(partials);
+			}
+			case InternalQNodeType.OR: {
+				const partials = (node.nodes ?? []).map((child) => ModelManager.collectPlainFieldsFromQNode(modelName, child));
+				const nonEmpty = partials.filter((partial) => Object.keys(partial).length > 0);
+				if (nonEmpty.length > 1) throw new Error(`Cannot derive a create payload from ${modelName} OR filters with multiple predicates. Supply defaults that fully describe the insert.`);
+				return nonEmpty.length === 1 ? nonEmpty[0] : {};
+			}
+			case InternalQNodeType.NOT: return {};
+		}
+	}
+	static omitLookupKeysFromAtom(atom) {
+		const entries = Object.entries(atom).filter(([key]) => !String(key).includes("__"));
+		return Object.fromEntries(entries);
+	}
+	static mergeCompatiblePartials(partials) {
+		const merged = {};
+		for (const partial of partials) for (const [key, value] of Object.entries(partial)) {
+			const existing = merged[key];
+			if (existing !== undefined && existing !== value) throw new Error(`Conflicting values for '${key}' while deriving create payload from Q filters.`);
+			merged[key] = value;
+		}
+		return merged;
+	}
+	query() {
+		return new ModelQuerySet(this.queryExecutor, {});
+	}
+	all() {
+		return this.query();
+	}
+	async findById(id) {
+		const filter = { [this.meta.pk]: id };
+		return this.query().filter(filter).fetchOne();
+	}
+	async getOrThrow(id) {
+		const result = await this.findById(id);
+		if (!result) throw new NotFoundError(`${this.model.metadata.name} with ${this.meta.pk}=${String(id)} not found`);
+		return result;
+	}
+	async getOrCreate(args) {
+		try {
+			const record$1 = await this.query().get(args.where);
+			return {
+				record: record$1,
+				created: false
+			};
+		} catch (error) {
+			if (!NotFoundError.isNotFoundError(error)) throw error;
+		}
+		const merged = ModelManager.mergeCreatePayloadFromWhere(this.model.metadata.name, this.meta.pk, args.where, args.defaults);
+		const record = await this.create(merged);
+		return {
+			record,
+			created: true
+		};
+	}
+	async updateOrCreate(args) {
+		let existing = null;
+		try {
+			existing = await this.query().get(args.where);
+		} catch (error) {
+			if (!NotFoundError.isNotFoundError(error)) throw error;
+		}
+		if (!existing) {
+			const merged = ModelManager.mergeCreatePayloadFromWhere(this.model.metadata.name, this.meta.pk, args.where, args.defaults);
+			const record$1 = await this.create(merged);
+			return {
+				record: record$1,
+				created: true,
+				updated: false
+			};
+		}
+		const patch = args.update ?? args.defaults ?? {};
+		if (Object.keys(patch).length === 0) return {
+			record: existing,
+			created: false,
+			updated: false
+		};
+		const id = existing[this.meta.pk];
+		const record = await this.update(id, patch);
+		return {
+			record,
+			created: false,
+			updated: true
+		};
+	}
+	async create(input) {
+		const prepared = await this.runBeforeCreate(input);
+		const preparedKeys = Object.keys(prepared);
+		if (preparedKeys.length === 0) throw new Error(`Cannot create ${this.model.metadata.name} without any values.`);
+		const validatedPlan = sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.INSERT,
+			meta: this.meta,
+			writeKeys: preparedKeys
+		});
+		const compiled = this.mutationCompiler.compileInsert(validatedPlan, preparedKeys.map((key) => prepared[key]));
+		const result = await this.queryExecutor.client.query(compiled.sql, compiled.params);
+		const created = result.rows[0];
+		this.attachOwnRelatedManagers(created);
+		await this.model.hooks?.afterCreate?.({
+			record: created,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		});
+		return created;
+	}
+	async update(id, patch) {
+		const current = await this.getOrThrow(id);
+		const prepared = await this.runBeforeUpdate(id, patch, current);
+		const preparedKeys = Object.keys(prepared);
+		if (preparedKeys.length === 0) throw new Error(`Cannot update ${this.model.metadata.name} without any values.`);
+		const validatedPlan = sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.UPDATE,
+			meta: this.meta,
+			writeKeys: preparedKeys
+		});
+		const compiled = this.mutationCompiler.compileUpdate(validatedPlan, preparedKeys.map((key) => prepared[key]), id);
+		const result = await this.queryExecutor.client.query(compiled.sql, compiled.params);
+		const updated = result.rows[0];
+		this.attachOwnRelatedManagers(updated);
+		await this.model.hooks?.afterUpdate?.({
+			id,
+			patch: prepared,
+			previous: current,
+			record: updated,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		});
+		return updated;
+	}
+	async delete(id) {
+		const current = await this.getOrThrow(id);
+		this.attachOwnRelatedManagers(current);
+		await this.model.hooks?.beforeDelete?.({
+			id,
+			current,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		});
+		const validatedPlan = sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.DELETE,
+			meta: this.meta
+		});
+		const compiled = this.mutationCompiler.compileDelete(validatedPlan, id);
+		await this.queryExecutor.client.query(compiled.sql, compiled.params);
+		await this.model.hooks?.afterDelete?.({
+			id,
+			previous: current,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		});
+	}
+	/**
+	* Build a {@link ManyToManyRelatedManager} bound to a single owner record
+	* for the supplied many-to-many relation. The returned manager performs
+	* its INSERT/DELETE writes through the shared runtime-bound client, so
+	* mutations enroll in any active `transaction.atomic(...)` boundary.
+	*/
+	createManyToManyRelatedManager(relationName, ownerPrimaryKey) {
+		const relation = this.requireManyToManyEdge(relationName);
+		const registry = ModelRegistry.getOwner(this.model);
+		const throughModel = registry.getByKey(relation.throughModelKey);
+		return ManyToManyRelatedManager.create({
+			ownerPrimaryKey,
+			relationName,
+			ownerModelLabel: this.model.metadata.name,
+			relation,
+			throughModelFields: throughModel.metadata.fields,
+			client: this.client,
+			mutationCompiler: this.mutationCompiler,
+			adapter: this.adapter,
+			sqlSafetyAdapter,
+			targetExecutorProvider: () => this.resolveTargetExecutor(relation.targetModelKey),
+			runAtomic: (work) => TransactionEngine.forRuntime(this.runtime).atomic(() => work())
+		});
+	}
+	async bulkCreate(inputs) {
+		if (inputs.length === 0) return [];
+		const perRowPrepared = await Promise.all(inputs.map((input) => this.runBeforeCreate(input)));
+		const batchPrepared = await this.model.hooks?.beforeBulkCreate?.({
+			rows: perRowPrepared,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		}) ?? perRowPrepared;
+		const preparedKeys = Object.keys(batchPrepared[0] ?? {});
+		if (preparedKeys.length === 0) throw new Error(`Cannot create ${this.model.metadata.name} without any values.`);
+		const validatedPlan = sqlSafetyAdapter.validate({
+			kind: InternalSqlValidationPlanKind.INSERT,
+			meta: this.meta,
+			writeKeys: preparedKeys
+		});
+		const valueRows = batchPrepared.map((input) => preparedKeys.map((key) => input[key]));
+		const compiled = this.mutationCompiler.compileBulkInsert(validatedPlan, valueRows);
+		const result = await this.queryExecutor.client.query(compiled.sql, compiled.params);
+		for (const record of result.rows) this.attachOwnRelatedManagers(record);
+		await Promise.all(result.rows.map((record) => this.model.hooks?.afterCreate?.({
+			record,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		})));
+		await this.model.hooks?.afterBulkCreate?.({
+			records: result.rows,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		});
+		return result.rows;
+	}
+	/**
+	* Attach a {@link ManyToManyRelatedManager} as a non-enumerable property
+	* for every persisted many-to-many relation declared on the supplied
+	* record's model. Existing properties are left untouched so that prior
+	* hydration writes (such as prefetched arrays) survive the attach pass
+	* during the incremental rollout of related-manager hydration.
+	*/
+	attachOwnRelatedManagers(record) {
+		this.attachManyToManyRelatedManagers(record, this.model.metadata.key);
+	}
+	attachManyToManyRelatedManagers(record, modelKey) {
+		if (!modelKey) return;
+		const targetManager = this.resolveManagerForModelKey(modelKey);
+		if (!targetManager) return;
+		const meta = targetManager.meta;
+		const relations = meta.relations;
+		if (!relations) return;
+		const ownerPrimaryKey = record[meta.pk];
+		if (ownerPrimaryKey === undefined || ownerPrimaryKey === null) return;
+		for (const [relationName, relation] of Object.entries(relations)) {
+			if (relation.kind !== InternalRelationKind.MANY_TO_MANY) continue;
+			if (Object.prototype.hasOwnProperty.call(record, relationName)) continue;
+			const relatedManager = targetManager.createManyToManyRelatedManager(relationName, ownerPrimaryKey);
+			Object.defineProperty(record, relationName, {
+				value: relatedManager,
+				writable: true,
+				configurable: true,
+				enumerable: false
+			});
+		}
+	}
+	resolveManagerForModelKey(modelKey) {
+		if (modelKey === this.model.metadata.key) return this;
+		const registry = ModelRegistry.getOwner(this.model);
+		const otherModel = registry.getByKey(modelKey);
+		if (!otherModel) return null;
+		const candidate = otherModel.objects;
+		return ModelManager.isModelManager(candidate) ? candidate : null;
+	}
+	resolveTargetExecutor(targetModelKey) {
+		const targetManager = this.resolveManagerForModelKey(targetModelKey);
+		if (!targetManager) return null;
+		return targetManager.queryExecutor;
+	}
+	requireManyToManyEdge(relationName) {
+		const rel = this.meta.relations?.[relationName];
+		if (!rel || rel.kind !== InternalRelationKind.MANY_TO_MANY || !rel.throughTable || !rel.throughSourceKey || !rel.throughTargetKey || !rel.throughModelKey) throw new Error(`Relation '${relationName}' on '${this.model.metadata.name}' is not a persisted many-to-many edge.`);
+		return rel;
+	}
+	async runBeforeCreate(data) {
+		return await this.model.hooks?.beforeCreate?.({
+			data,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		}) ?? data;
+	}
+	async runBeforeUpdate(id, patch, current) {
+		return await this.model.hooks?.beforeUpdate?.({
+			id,
+			patch,
+			current,
+			model: this.model,
+			manager: this,
+			transaction: this.getHookTransaction()
+		}) ?? patch;
+	}
+	getHookTransaction() {
+		return TransactionEngine.forRuntime(this.runtime).getActiveTransaction();
+	}
+};
+
+//#endregion
+//#region src/manager/registerModelObjects.ts
+const managerCache = new WeakMap();
+let hasRegisteredModelObjects = false;
+function defineObjectsProperty(model) {
+	Object.defineProperty(model, "objects", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const runtime = getTangoRuntime();
+			const cached = managerCache.get(model);
+			if (cached && cached.runtime === runtime) return cached.manager;
+			const manager = new ModelManager(model, runtime);
+			managerCache.set(model, {
+				runtime,
+				manager
+			});
+			return manager;
+		}
+	});
+}
+function registerModelObjects() {
+	if (hasRegisteredModelObjects) return;
+	registerModelAugmentor(defineObjectsProperty);
+	hasRegisteredModelObjects = true;
+}
+
+//#endregion
+export { ManyToManyRelatedManager, ManyToManyRelatedQuerySet, ModelManager, registerModelObjects };
+//# sourceMappingURL=registerModelObjects-DxlBfuUN.js.map