@danceroutine/tango-orm 1.11.1 → 1.11.3

package/dist/registerModelObjects-C-MliIiM.d.ts

@@ -0,0 +1,229 @@
+import { t as DBClient } from "./DBClient-DuYcXolQ.js";
+import { i as Dialect, t as Adapter } from "./Adapter-DKxAaL4l.js";
+import { E as ManyToManyRelatedManager, F as QNode, H as TableMeta, I as FilterInput, N as QuerySet } from "./QuerySetState-CjyvAUBs.js";
+import { ModelWriteHooks } from "@danceroutine/tango-schema";
+import { LoadedConfig } from "@danceroutine/tango-config";
+import { z } from "zod";
+import { Model, PersistedModelOutput } from "@danceroutine/tango-schema/domain";
+import { DecoratedFieldKind, InternalDecoratedFieldKind, RelationDecoratedSchema } from "@danceroutine/tango-schema/model";
+
+//#region src/manager/relations/MaterializedModelRecord.d.ts
+type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
+type AnyModel = Model<z.ZodObject<z.ZodRawShape>, string>;
+type SchemaShape<TSchema> = TSchema extends z.ZodObject<infer TShape> ? TShape : never;
+type RelationKindOf<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, infer TKind extends DecoratedFieldKind, AnyModel, string | undefined, string | undefined> ? TKind : never;
+type RelationTarget<TField> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, infer TTarget, string | undefined, string | undefined> ? TTarget : never;
+type RelationPublishedName<TField, TFallback extends string> = TField extends RelationDecoratedSchema<z.ZodTypeAny, DecoratedFieldKind, AnyModel, infer TName extends string | undefined, string | undefined> ? TName extends string ? TName : TFallback : TFallback;
+type ModelRow<TTarget> = TTarget extends Model<infer TSchema extends z.ZodObject<z.ZodRawShape>, string> ? PersistedModelOutput<TSchema> : never;
+type ManyToManyKeysOfShape<TShape extends z.ZodRawShape> = Extract<{ [K in keyof TShape]: IsAny<TShape[K]> extends true ? never : [RelationKindOf<TShape[K]>] extends [never] ? never : [RelationKindOf<TShape[K]>] extends [typeof InternalDecoratedFieldKind.MANY_TO_MANY] ? K : never }[keyof TShape], string>;
+type ManyToManyManagers<TShape extends z.ZodRawShape> = { readonly [K in ManyToManyKeysOfShape<TShape> as K extends keyof TShape ? RelationPublishedName<TShape[K], K> : never]: K extends keyof TShape ? RelationTarget<TShape[K]> extends AnyModel ? ManyToManyRelatedManager<ModelRow<RelationTarget<TShape[K]>>> : never : never };
+/**
+ * Persisted model record shape returned by ORM read and write paths.
+ *
+ * Combines the column-level {@link PersistedModelOutput} with a per-relation
+ * {@link ManyToManyRelatedManager} for every many-to-many field declared on the
+ * source schema. The manager properties are attached as non-enumerable accessors
+ * at runtime, so `JSON.stringify` and structural equality checks only see the
+ * column data.
+ */
+type MaterializedModelRecord<TSchema extends z.ZodObject<z.ZodRawShape>> = PersistedModelOutput<TSchema> & ManyToManyManagers<SchemaShape<TSchema>>;
+//#endregion
+//#region src/manager/ManagerLike.d.ts
+/**
+ * Public manager contract consumed by Tango resources and applications.
+ */
+interface ManagerLike<TModelRow extends Record<string, unknown>, TSourceModel = unknown> {
+  readonly meta: TableMeta;
+  query(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  all(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  getOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+  }>;
+  updateOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+    update?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+    updated: boolean;
+  }>;
+  findById(id: TModelRow[keyof TModelRow]): Promise<TModelRow | null>;
+  getOrThrow(id: TModelRow[keyof TModelRow]): Promise<TModelRow>;
+  create(input: Partial<TModelRow>): Promise<TModelRow>;
+  update(id: TModelRow[keyof TModelRow], patch: Partial<TModelRow>): Promise<TModelRow>;
+  delete(id: TModelRow[keyof TModelRow]): Promise<void>;
+  bulkCreate(inputs: Partial<TModelRow>[]): Promise<TModelRow[]>;
+}
+//#endregion
+//#region src/runtime/internal/DBClientProvider.d.ts
+interface TransactionClientLease {
+  readonly client: DBClient;
+  release(): Promise<void>;
+}
+//#endregion
+//#region src/runtime/TangoRuntime.d.ts
+/**
+ * Framework-owned database runtime that resolves Tango config and lazily
+ * creates the shared connection provider used by manager-backed models.
+ */
+declare class TangoRuntime {
+  static readonly BRAND: "tango.orm.runtime";
+  readonly __tangoBrand: typeof TangoRuntime.BRAND;
+  private readonly loadedConfig;
+  private providerPromise;
+  private runtimeClientPromise;
+  private cachedAdapter;
+  constructor(loadLoadedConfig: () => LoadedConfig);
+  /**
+   * Narrow an unknown value to `TangoRuntime`.
+   */
+  static isTangoRuntime(value: unknown): value is TangoRuntime;
+  /**
+   * Return the loaded Tango config snapshot for the active environment.
+   */
+  getConfig(): LoadedConfig;
+  /**
+   * Return the configured SQL dialect for the current runtime.
+   */
+  getDialect(): Dialect;
+  /**
+   * Return the adapter backing the configured dialect. Manager-side
+   * compilers use this to obtain placeholder formatters and dialect
+   * capabilities without branching on the raw dialect string.
+   */
+  getAdapter(): Adapter;
+  /**
+   * Return the runtime-bound DB client facade used by manager-backed code.
+   */
+  getClient(): Promise<DBClient>;
+  /**
+   * Execute SQL through the autocommit path owned by this runtime.
+   */
+  query<T = unknown>(sql: string, params?: readonly unknown[]): Promise<{
+    rows: T[];
+  }>;
+  /**
+   * Lease a transaction-scoped client for `transaction.atomic(...)`.
+   */
+  leaseTransactionClient(): Promise<TransactionClientLease>;
+  /**
+   * Close and clear the cached runtime resources so tests can start fresh.
+   */
+  reset(): Promise<void>;
+  private buildAdapterForDialect;
+  private getProvider;
+}
+//#endregion
+//#region src/manager/ModelManager.d.ts
+type ModelMetadataLike = Omit<Model['metadata'], 'key' | 'namespace' | 'fields'> & {
+  key?: string;
+  namespace?: string;
+  fields: Array<{
+    name: string;
+    type: string;
+    primaryKey?: boolean;
+  }>;
+};
+type ModelLike<TModelRow extends Record<string, unknown>> = {
+  metadata: ModelMetadataLike;
+  schema: {
+    parse(input: unknown): TModelRow;
+  };
+  hooks?: ModelWriteHooks<TModelRow>;
+};
+/**
+ * Model-backed data access API exposed as `Model.objects`.
+ */
+declare class ModelManager<TModelRow extends Record<string, unknown>, TSourceModel = unknown> implements ManagerLike<TModelRow, TSourceModel> {
+  static readonly BRAND: "tango.orm.model_manager";
+  readonly __tangoBrand: typeof ModelManager.BRAND;
+  private readonly queryExecutor;
+  private readonly mutationCompiler;
+  private readonly model;
+  private readonly client;
+  private readonly adapter;
+  private readonly runtime;
+  constructor(model: ModelLike<TModelRow>, runtime: TangoRuntime);
+  get meta(): TableMeta;
+  /**
+   * Narrow an unknown value to `ModelManager`.
+   */
+  static isModelManager<TModelRow extends Record<string, unknown>>(value: unknown): value is ModelManager<TModelRow>;
+  private static createTableMeta;
+  private static mergeCreatePayloadFromWhere;
+  private static countDefinedValues;
+  private static collectPlainFieldsFromQNode;
+  private static omitLookupKeysFromAtom;
+  private static mergeCompatiblePartials;
+  query(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  all(): QuerySet<TModelRow, TModelRow, TSourceModel>;
+  findById(id: TModelRow[keyof TModelRow]): Promise<TModelRow | null>;
+  getOrThrow(id: TModelRow[keyof TModelRow]): Promise<TModelRow>;
+  getOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+  }>;
+  updateOrCreate(args: {
+    where: FilterInput<TModelRow> | QNode<TModelRow>;
+    defaults?: Partial<TModelRow>;
+    update?: Partial<TModelRow>;
+  }): Promise<{
+    record: TModelRow;
+    created: boolean;
+    updated: boolean;
+  }>;
+  create(input: Partial<TModelRow>): Promise<TModelRow>;
+  update(id: TModelRow[keyof TModelRow], patch: Partial<TModelRow>): Promise<TModelRow>;
+  delete(id: TModelRow[keyof TModelRow]): Promise<void>;
+  /**
+   * 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<TTarget extends Record<string, unknown>>(relationName: string, ownerPrimaryKey: unknown): ManyToManyRelatedManager<TTarget>;
+  /**
+   * Insert multiple rows in a single multi-row INSERT statement.
+   *
+   * All rows must share the same field set after hook processing. Rows with
+   * extra or missing fields relative to the first row will cause an error.
+   * If you need to insert rows with different field sets, use individual
+   * {@link create} calls instead.
+   */
+  bulkCreate(inputs: Partial<TModelRow>[]): Promise<TModelRow[]>;
+  /**
+   * 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.
+   */
+  private attachOwnRelatedManagers;
+  private attachManyToManyRelatedManagers;
+  private resolveManagerForModelKey;
+  private resolveTargetExecutor;
+  private resolveTargetManager;
+  private requireManyToManyEdge;
+  private runBeforeCreate;
+  private runBeforeUpdate;
+  private getHookTransaction;
+  private assertUniformRowShape;
+}
+//#endregion
+//#region src/manager/registerModelObjects.d.ts
+/**
+ * Install the schema model augmentor that exposes `Model.objects`.
+ * This registration is idempotent so multiple Tango entrypoints can safely call it.
+ */
+declare function registerModelObjects(): void;
+//#endregion
+export { MaterializedModelRecord as a, ManagerLike as i, ModelManager as n, TangoRuntime as r, registerModelObjects as t };
+//# sourceMappingURL=registerModelObjects-C-MliIiM.d.ts.map

package/dist/{registerModelObjects-22ZJKoit.js → registerModelObjects-DZfZ20fa.js}

@@ -1,13 +1,42 @@
-import { InternalQNodeType, InternalRelationKind, InternalSqlValidationPlanKind, ModelQuerySet, OrmSqlSafetyAdapter, QBuilder, QueryResult, QuerySet, TableMetaFactory, isQNodeLike } from "./query-DUZnBFhf.js";
-import { RuntimeBoundClient, TransactionEngine, getTangoRuntime } from "./defaultRuntime-DzqBQ9Hb.js";
+import { a as isQNodeLike, c as InternalRelationKind, f as OrmSqlSafetyAdapter, i as QBuilder, l as QueryResult, m as InternalQNodeType, n as ModelQuerySet, p as InternalSqlValidationPlanKind, r as QuerySet, s as TableMetaFactory } from "./query-CP1UMIX6.js";
+import { a as RuntimeBoundClient, o as TransactionEngine, t as getTangoRuntime } from "./defaultRuntime-CdTX8cXm.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));
 }
+/**
+* {@link QuerySet} returned by `post.tags.all()` on a many-to-many related
+* manager.
+*
+* Behaves like a normal `QuerySet` over the target model from an application
+* developer's perspective: you can chain `filter`, `exclude`, `orderBy`,
+* `limit`, `offset`, and terminate with `fetch`, `fetchOne`, or `count`.
+* Each chainable call returns another `ManyToManyRelatedQuerySet` so the
+* chain keeps the membership scoping of the owning record.
+*
+* Two behaviors differ from a plain `QuerySet` and matter to application
+* developers:
+*
+* - When the relation was loaded by `prefetchRelated(...)` and no chainable
+*   state has been added (no `filter`, `orderBy`, etc.), `fetch()` and
+*   `count()` resolve from the prefetch cache without issuing SQL.
+* - Mutating the membership via `post.tags.add(tag)` or
+*   `post.tags.remove(tag)` invalidates that cache so follow-up reads go
+*   back to the database.
+*
+* @example
+* ```ts
+* const post = await PostModel.objects.getOrThrow(postId);
+* await post.tags.add(tag);
+* const tags = await post.tags.all().filter({ color: 'red' }).orderBy('name').fetch();
+* ```
+*
+* @template TTarget - The persisted target record shape (e.g. `Tag`).
+*/
 var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet {
+	bridge;
 	constructor(executor, bridge, state = {}) {
 		super(executor, state);
 		this.bridge = bridge;
@@ -15,10 +44,7 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 	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);
-			}
+			if (cache !== null) return new QueryResult(shape ? applyShape(cache, shape) : [...cache]);
 		}
 		const ids = await this.bridge.fetchTargetIds();
 		if (ids.length === 0) return new QueryResult([]);
@@ -26,8 +52,7 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 		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;
+		return (shape ? await this.fetch(shape) : await this.fetch()).items[0] ?? null;
 	}
 	async count() {
 		if (this.isStateTrivial()) {
@@ -37,8 +62,7 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 		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();
+		return new ModelQuerySet(this.executor, this.scopedState(ids)).count();
 	}
 	spawn(state) {
 		return new ManyToManyRelatedQuerySet(this.executor, this.bridge, state);
@@ -59,13 +83,15 @@ var ManyToManyRelatedQuerySet = class ManyToManyRelatedQuerySet extends QuerySet
 		};
 	}
 };
-
 //#endregion
 //#region src/manager/internal/MutationCompiler.ts
 const InternalDuplicateInsertPolicy = {
 	ERROR: "error",
 	IGNORE: "ignore"
 };
+/**
+* Internal compiler for manager-owned INSERT/UPDATE/DELETE statements.
+*/
 var MutationCompiler = class {
 	adapter;
 	placeholders;
@@ -144,16 +170,26 @@ var MutationCompiler = class {
 		};
 	}
 };
-
 //#endregion
 //#region src/manager/relations/internal/ThroughTableManager.ts
+/**
+* Internal helper that issues the INSERT, DELETE, and SELECT statements for
+* a single many-to-many join table. Centralizes SQL safety validation and
+* compilation so {@link ManyToManyRelatedManager} implementations only deal
+* in primary-key values.
+*/
 var ThroughTableManager = class ThroughTableManager {
-	constructor(client, mutationCompiler, descriptor, adapter, sqlSafetyAdapter$1 = new OrmSqlSafetyAdapter()) {
+	client;
+	mutationCompiler;
+	descriptor;
+	adapter;
+	sqlSafetyAdapter;
+	constructor(client, mutationCompiler, descriptor, adapter, sqlSafetyAdapter = new OrmSqlSafetyAdapter()) {
 		this.client = client;
 		this.mutationCompiler = mutationCompiler;
 		this.descriptor = descriptor;
 		this.adapter = adapter;
-		this.sqlSafetyAdapter = sqlSafetyAdapter$1;
+		this.sqlSafetyAdapter = sqlSafetyAdapter;
 	}
 	/**
 	* Derive a {@link ThroughTableLinkDescriptor} from the through-model
@@ -198,8 +234,7 @@ var ThroughTableManager = class ThroughTableManager {
 		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");
+		return (await this.client.query(sql, [ownerPrimaryKey])).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);
@@ -258,10 +293,32 @@ var ThroughTableManager = class ThroughTableManager {
 		await this.client.query(sql, [ownerPrimaryKey]);
 	}
 };
-
 //#endregion
 //#region src/manager/relations/ManyToManyRelatedManager.ts
+/**
+* Django-style related manager exposed on materialized model records for each
+* many-to-many relation.
+*
+* Use the manager to add or remove join-table membership and to query the
+* related target rows. The owning record's primary key and the relation name
+* are bound when the manager is attached, so application code does not need
+* to pass them on every call.
+*
+* Prefetched memberships seed an internal cache that the queryset returned
+* from `all()` short-circuits to without re-querying. Mutations through
+* `add`, `remove`, `set`, `clear`, and `create` invalidate the cache so
+* subsequent reads observe the updated membership. `set(...)` applies
+* Django-shaped replacement semantics:
+* it diffs the current relation membership against the supplied targets,
+* removes any missing links, and inserts any new links inside one atomic
+* write boundary. `clear()` removes every join row for the owner, and
+* `create(...)` persists a new target row plus its join-row link inside one
+* atomic boundary.
+*
+* @template TTarget - The persisted target record shape returned by `all()`.
+*/
 var ManyToManyRelatedManager = class ManyToManyRelatedManager {
+	inputs;
 	static BRAND = "tango.orm.m2m_related_manager";
 	__tangoBrand = ManyToManyRelatedManager.BRAND;
 	prefetchCache = null;
@@ -319,7 +376,7 @@ var ManyToManyRelatedManager = class ManyToManyRelatedManager {
 		const targetPrimaryKeys = this.resolveTargetPrimaryKeys(targets);
 		if (targetPrimaryKeys.length === 0) return;
 		if (targetPrimaryKeys.length === 1) await this.insertTargetPrimaryKeys(targetPrimaryKeys);
-else await this.inputs.runAtomic(() => this.insertTargetPrimaryKeys(targetPrimaryKeys));
+		else await this.inputs.runAtomic(() => this.insertTargetPrimaryKeys(targetPrimaryKeys));
 		this.invalidateCache();
 	}
 	/**
@@ -331,7 +388,7 @@ else await this.inputs.runAtomic(() => this.insertTargetPrimaryKeys(targetPrimar
 		const targetPrimaryKeys = this.resolveTargetPrimaryKeys(targets);
 		if (targetPrimaryKeys.length === 0) return;
 		if (targetPrimaryKeys.length === 1) await this.deleteTargetPrimaryKeys(targetPrimaryKeys);
-else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimaryKeys));
+		else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimaryKeys));
 		this.invalidateCache();
 	}
 	/**
@@ -438,7 +495,7 @@ else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimar
 	}
 	resolveTargetPrimaryKeys(targets) {
 		const resolved = [];
-		const seen = new Set();
+		const seen = /* @__PURE__ */ new Set();
 		for (const target of targets) {
 			const primaryKey = this.resolveTargetPrimaryKey(target);
 			const canonical = this.canonicalizePrimaryKey(primaryKey);
@@ -452,7 +509,7 @@ else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimar
 		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}'.`);
+			if (targetPrimaryKey === void 0 || 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.`);
@@ -467,10 +524,12 @@ else await this.inputs.runAtomic(() => this.deleteTargetPrimaryKeys(targetPrimar
 		}
 	}
 };
-
 //#endregion
 //#region src/manager/ModelManager.ts
 const sqlSafetyAdapter = new OrmSqlSafetyAdapter();
+/**
+* Model-backed data access API exposed as `Model.objects`.
+*/
 var ModelManager = class ModelManager {
 	static BRAND = "tango.orm.model_manager";
 	__tangoBrand = ModelManager.BRAND;
@@ -493,8 +552,7 @@ var ModelManager = class ModelManager {
 			client: this.client,
 			adapter: this.adapter,
 			run: async (compiled) => {
-				const result = await this.client.query(compiled.sql, compiled.params);
-				return result.rows;
+				return (await this.client.query(compiled.sql, compiled.params)).rows;
 			},
 			attachPersistedRecordAccessors: (record, modelKey) => {
 				this.attachManyToManyRelatedManagers(record, modelKey ?? this.model.metadata.key);
@@ -521,42 +579,34 @@ var ModelManager = class ModelManager {
 		return validatedMeta;
 	}
 	static mergeCreatePayloadFromWhere(modelName, pkColumn, where, defaults) {
-		const hasDefaultsArg = defaults !== undefined;
-		const providedDefaults = defaults !== undefined ? { ...defaults } : undefined;
+		const hasDefaultsArg = defaults !== void 0;
+		const providedDefaults = defaults !== void 0 ? { ...defaults } : void 0;
 		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,
+			const merged = {
+				...ModelManager.collectPlainFieldsFromQNode(modelName, where),
 				...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;
+			if (Object.keys(merged).filter((key) => merged[key] !== void 0).filter((key) => key !== pkColumn).length === 0) throw new Error(`Cannot create ${modelName} without any values.`);
+			return merged;
 		}
-		const atom = where;
-		const entries = Object.entries(atom);
+		const entries = Object.entries(where);
 		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,
+			...plainEntries.length > 0 ? Object.fromEntries(plainEntries) : void 0,
 			...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,
+			...plainEntries.length > 0 ? Object.fromEntries(plainEntries) : {},
 			...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.`);
+		if (Object.keys(merged).filter((key) => merged[key] !== void 0).filter((key) => key !== pkColumn).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;
+		return Object.entries(payload).filter(([key, value]) => key !== pkColumn && value !== void 0).length;
 	}
 	static collectPlainFieldsFromQNode(modelName, node) {
 		switch (node.kind) {
@@ -566,8 +616,7 @@ var ModelManager = class ModelManager {
 				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);
+				const nonEmpty = (node.nodes ?? []).map((child) => ModelManager.collectPlainFieldsFromQNode(modelName, child)).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] : {};
 			}
@@ -582,7 +631,7 @@ var ModelManager = class ModelManager {
 		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.`);
+			if (existing !== void 0 && existing !== value) throw new Error(`Conflicting values for '${key}' while deriving create payload from Q filters.`);
 			merged[key] = value;
 		}
 		return merged;
@@ -604,18 +653,16 @@ var ModelManager = class ModelManager {
 	}
 	async getOrCreate(args) {
 		try {
-			const record$1 = await this.query().get(args.where);
 			return {
-				record: record$1,
+				record: await this.query().get(args.where),
 				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,
+			record: await this.create(merged),
 			created: true
 		};
 	}
@@ -628,9 +675,8 @@ var ModelManager = class ModelManager {
 		}
 		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,
+				record: await this.create(merged),
 				created: true,
 				updated: false
 			};
@@ -642,9 +688,8 @@ var ModelManager = class ModelManager {
 			updated: false
 		};
 		const id = existing[this.meta.pk];
-		const record = await this.update(id, patch);
 		return {
-			record,
+			record: await this.update(id, patch),
 			created: false,
 			updated: true
 		};
@@ -659,8 +704,7 @@ var ModelManager = class ModelManager {
 			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];
+		const created = (await this.queryExecutor.client.query(compiled.sql, compiled.params)).rows[0];
 		this.attachOwnRelatedManagers(created);
 		await this.model.hooks?.afterCreate?.({
 			record: created,
@@ -681,8 +725,7 @@ var ModelManager = class ModelManager {
 			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];
+		const updated = (await this.queryExecutor.client.query(compiled.sql, compiled.params)).rows[0];
 		this.attachOwnRelatedManagers(updated);
 		await this.model.hooks?.afterUpdate?.({
 			id,
@@ -727,8 +770,7 @@ var ModelManager = class ModelManager {
 	*/
 	createManyToManyRelatedManager(relationName, ownerPrimaryKey) {
 		const relation = this.requireManyToManyEdge(relationName);
-		const registry = ModelRegistry.getOwner(this.model);
-		const throughModel = registry.getByKey(relation.throughModelKey);
+		const throughModel = ModelRegistry.getOwner(this.model).getByKey(relation.throughModelKey);
 		return ManyToManyRelatedManager.create({
 			ownerPrimaryKey,
 			relationName,
@@ -809,7 +851,7 @@ var ModelManager = class ModelManager {
 		const relations = meta.relations;
 		if (!relations) return;
 		const ownerPrimaryKey = record[meta.pk];
-		if (ownerPrimaryKey === undefined || ownerPrimaryKey === null) return;
+		if (ownerPrimaryKey === void 0 || 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;
@@ -818,14 +860,19 @@ var ModelManager = class ModelManager {
 				value: relatedManager,
 				writable: true,
 				configurable: true,
+				/**
+				* Non-enumerable so `Object.keys(record)`, `JSON.stringify(record)`,
+				* `{ ...record }`, and similar enumeration paths continue to
+				* see only the persisted columns. Application code reaches the
+				* manager through `record.tags`, never through enumeration.
+				*/
 				enumerable: false
 			});
 		}
 	}
 	resolveManagerForModelKey(modelKey) {
 		if (modelKey === this.model.metadata.key) return this;
-		const registry = ModelRegistry.getOwner(this.model);
-		const otherModel = registry.getByKey(modelKey);
+		const otherModel = ModelRegistry.getOwner(this.model).getByKey(modelKey);
 		if (!otherModel) return null;
 		const candidate = otherModel.objects;
 		return ModelManager.isModelManager(candidate) ? candidate : null;
@@ -889,10 +936,9 @@ var ModelManager = class ModelManager {
 		throw new Error(`bulkCreate failed after hook processing: rows at indices [${indices.join(", ")}] have mismatched fields.\n${details}\nExpected fields (from row at index 0): [${sortedReferenceKeys.join(", ")}].`);
 	}
 };
-
 //#endregion
 //#region src/manager/registerModelObjects.ts
-const managerCache = new WeakMap();
+const managerCache = /* @__PURE__ */ new WeakMap();
 let hasRegisteredModelObjects = false;
 function defineObjectsProperty(model) {
 	Object.defineProperty(model, "objects", {
@@ -911,12 +957,16 @@ function defineObjectsProperty(model) {
 		}
 	});
 }
+/**
+* Install the schema model augmentor that exposes `Model.objects`.
+* This registration is idempotent so multiple Tango entrypoints can safely call it.
+*/
 function registerModelObjects() {
 	if (hasRegisteredModelObjects) return;
 	registerModelAugmentor(defineObjectsProperty);
 	hasRegisteredModelObjects = true;
 }
-
 //#endregion
-export { ManyToManyRelatedManager, ManyToManyRelatedQuerySet, ModelManager, registerModelObjects };
-//# sourceMappingURL=registerModelObjects-22ZJKoit.js.map
+export { ManyToManyRelatedQuerySet as i, ModelManager as n, ManyToManyRelatedManager as r, registerModelObjects as t };
+
+//# sourceMappingURL=registerModelObjects-DZfZ20fa.js.map