@danceroutine/tango-schema 1.7.0 → 1.8.1

package/dist/{model-BxkSqwrt.js → model-upj6jxaK.js}

@@ -1,9 +1,9 @@
 import { getLogger, getLogger as getLogger$1 } from "@danceroutine/tango-core";
-import { z } from "zod";
+import { z, z as z$1 } from "zod";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, existsSync as existsSync$1, readFileSync } from "node:fs";
 import { dirname, extname, resolve, resolve as resolve$1 } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, createHash as createHash$1 } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
 //#region rolldown:runtime
@@ -178,7 +178,7 @@ function foreignKey(target, schemaOrOptions, maybeOptions) {
 		});
 	}
 	const config = schemaOrOptions;
-	const schema = config?.field ?? z.number().int();
+	const schema = config?.field ?? z$1.number().int();
 	return applyRelationMetadata(schema, {
 		relationKind: InternalDecoratedFieldKind.FOREIGN_KEY,
 		references: {
@@ -201,7 +201,7 @@ function oneToOne(target, schemaOrOptions, maybeOptions) {
 		});
 	}
 	const config = schemaOrOptions;
-	const schema = config?.field ?? z.number().int();
+	const schema = config?.field ?? z$1.number().int();
 	return applyRelationMetadata(schema, {
 		relationKind: InternalDecoratedFieldKind.ONE_TO_ONE,
 		unique: true,
@@ -222,10 +222,17 @@ function manyToMany(target, schemaOrConfig) {
 	}
 	if (schemaOrConfig?.relatedName !== undefined) throw new Error("t.manyToMany(...) does not support relatedName yet.");
 	const config = schemaOrConfig;
-	const schema = config?.field ?? z.array(z.number().int());
+	const hasPartialThroughConfig = (config?.through !== undefined || config?.throughSourceFieldName !== undefined || config?.throughTargetFieldName !== undefined) && !(config?.through && config.throughSourceFieldName && config.throughTargetFieldName);
+	if (hasPartialThroughConfig) throw new Error("t.manyToMany(...) through config requires through, throughSourceFieldName, and throughTargetFieldName.");
+	const schema = config?.field ?? z$1.array(z$1.number().int());
 	return applyRelationMetadata(schema, {
 		relationKind: InternalDecoratedFieldKind.MANY_TO_MANY,
-		references: { target }
+		references: {
+			target,
+			through: config?.through,
+			throughSourceFieldName: config?.throughSourceFieldName,
+			throughTargetFieldName: config?.throughTargetFieldName
+		}
 	}, config);
 }
 const Decorators = {
@@ -597,6 +604,9 @@ var RelationDescriptorNormalizer = class RelationDescriptorNormalizer {
 			explicitForwardName: meta.forwardName,
 			explicitReverseName: meta.reverseName,
 			namingHint: this.deriveNamingHint(candidate.sourceSchemaFieldKey),
+			throughModelRef: meta.references.through,
+			throughSourceFieldName: meta.references.throughSourceFieldName,
+			throughTargetFieldName: meta.references.throughTargetFieldName,
 			provenance: "field-decorator"
 		};
 	}
@@ -623,6 +633,10 @@ function pluralize(value) {
 function deriveTableName(name) {
 	return pluralize(toSnakeCase(name));
 }
+function decapitalizeModelName(name) {
+	if (name.length === 0) return name;
+	return `${name[0].toLowerCase()}${name.slice(1)}`;
+}
 
 //#endregion
 //#region src/model/internal/InternalSchemaModel.ts
@@ -736,6 +750,14 @@ var InternalSchemaModel = class InternalSchemaModel {
 	}
 };
 
+//#endregion
+//#region src/model/relations/NormalizedRelationStorageDescriptor.ts
+const InternalNormalizedRelationOrigin = {
+	FOREIGN_KEY: "foreignKey",
+	ONE_TO_ONE: "oneToOne",
+	MANY_TO_MANY: "manyToMany"
+};
+
 //#endregion
 //#region src/model/relations/RelationSpec.ts
 const InternalRelationPublicKind = {
@@ -759,6 +781,216 @@ const InternalRelationProvenance = {
 	SYNTHESIZED_REVERSE: "synthesized-reverse"
 };
 
+//#endregion
+//#region src/model/relations/ImplicitManyToManyIdentifier.ts
+var ImplicitManyToManyIdentifier = class ImplicitManyToManyIdentifier {
+	static NAMESPACE = "tango.implicit";
+	/**
+	* Stable model key for the synthesized through model connecting
+	* `sourceModelKey` to `targetModelKey` via the schema field
+	* `sourceSchemaFieldKey`.
+	*
+	* The returned key is deterministic across runs so storage and hydration
+	* artifacts stay stable as long as the inputs match.
+	*/
+	static getModelKey(sourceModelKey, sourceSchemaFieldKey, targetModelKey) {
+		const digest = ImplicitManyToManyIdentifier.digest(sourceModelKey, sourceSchemaFieldKey, targetModelKey, 32);
+		return `${ImplicitManyToManyIdentifier.NAMESPACE}/m2m_${digest}`;
+	}
+	/**
+	* Deterministic short digest used to derive the physical join-table name
+	* for a synthesized through model. Shorter than the model-key digest so
+	* table names stay within common SQL identifier limits.
+	*/
+	static getTableBaseDigest(sourceModelKey, sourceSchemaFieldKey, targetModelKey) {
+		return ImplicitManyToManyIdentifier.digest(sourceModelKey, sourceSchemaFieldKey, targetModelKey, 16);
+	}
+	/**
+	* True when `modelKey` was produced by {@link getModelKey} and therefore
+	* identifies a synthesized through model. Callers use this instead of
+	* comparing namespace prefixes so the namespace remains an implementation
+	* detail of this class.
+	*/
+	static isImplicitManyToManyModel(modelKey) {
+		return modelKey.startsWith(`${ImplicitManyToManyIdentifier.NAMESPACE}/`);
+	}
+	/**
+	* Namespace under which synthesized through models are registered.
+	* Exposed so {@link ImplicitManyToManyThroughFactory} can construct the
+	* model with the correct namespace. External callers that want to ask
+	* "is this an implicit model" should prefer {@link isImplicitManyToManyModel}.
+	*/
+	static getNamespace() {
+		return ImplicitManyToManyIdentifier.NAMESPACE;
+	}
+	/**
+	* Extract the `m2m_<digest>` component of a synthesized model key so the
+	* factory can register the through model with a deterministic name while
+	* keeping the namespace owned by this class.
+	*/
+	static getModelName(modelKey) {
+		const prefix = `${ImplicitManyToManyIdentifier.NAMESPACE}/`;
+		if (!modelKey.startsWith(prefix)) throw new Error(`ImplicitManyToManyIdentifier.getModelName expected a key produced by getModelKey, received '${modelKey}'.`);
+		return modelKey.slice(prefix.length);
+	}
+	static digest(sourceModelKey, sourceSchemaFieldKey, targetModelKey, byteLength) {
+		return createHash$1("sha256").update(`${sourceModelKey}\0${sourceSchemaFieldKey}\0${targetModelKey}`, "utf8").digest("hex").slice(0, byteLength);
+	}
+};
+
+//#endregion
+//#region src/domain/internal/InternalReferentialAction.ts
+const InternalReferentialAction = {
+	CASCADE: "CASCADE",
+	SET_NULL: "SET NULL",
+	RESTRICT: "RESTRICT",
+	NO_ACTION: "NO ACTION"
+};
+
+//#endregion
+//#region src/model/relations/ImplicitManyToManyThroughFactory.ts
+var ImplicitManyToManyThroughFactory = class ImplicitManyToManyThroughFactory {
+	static throughFieldNames(sourceModel, targetModel) {
+		if (sourceModel.metadata.key === targetModel.metadata.key) return {
+			throughSourceFieldName: `from${sourceModel.metadata.name}`,
+			throughTargetFieldName: `to${targetModel.metadata.name}`
+		};
+		return {
+			throughSourceFieldName: `${decapitalizeModelName(sourceModel.metadata.name)}Id`,
+			throughTargetFieldName: `${decapitalizeModelName(targetModel.metadata.name)}Id`
+		};
+	}
+	static buildModels(registry) {
+		const descriptors = ImplicitManyToManyThroughFactory.collectImplicitDescriptors(registry);
+		const models = [];
+		const occupiedTables = new Set([...registry.values()].map((m) => m.metadata.table.trim().toLowerCase()));
+		for (const descriptor of descriptors) {
+			const sourceModel = registry.getByKey(descriptor.sourceModelKey);
+			const targetModel = registry.resolveRef(descriptor.targetRef);
+			const identityKey = ImplicitManyToManyIdentifier.getModelKey(descriptor.sourceModelKey, descriptor.sourceSchemaFieldKey, targetModel.metadata.key);
+			const pkSource = ImplicitManyToManyThroughFactory.readSinglePrimaryKey(sourceModel);
+			const pkTarget = ImplicitManyToManyThroughFactory.readSinglePrimaryKey(targetModel);
+			const digest = ImplicitManyToManyIdentifier.getTableBaseDigest(descriptor.sourceModelKey, descriptor.sourceSchemaFieldKey, targetModel.metadata.key);
+			const tableName = ImplicitManyToManyThroughFactory.allocateTableName(occupiedTables, digest);
+			const selfReferential = sourceModel.metadata.key === targetModel.metadata.key;
+			let throughSchema;
+			let indexes;
+			if (selfReferential) {
+				const leftKey = `from${sourceModel.metadata.name}`;
+				const rightKey = `to${sourceModel.metadata.name}`;
+				throughSchema = z.object({
+					id: Decorators.primaryKey(z.number().int()),
+					[leftKey]: Decorators.foreignKey(sourceModel, {
+						field: pkSource.zod,
+						onDelete: InternalReferentialAction.CASCADE,
+						onUpdate: InternalReferentialAction.CASCADE
+					}),
+					[rightKey]: Decorators.foreignKey(sourceModel, {
+						field: pkTarget.zod,
+						onDelete: InternalReferentialAction.CASCADE,
+						onUpdate: InternalReferentialAction.CASCADE
+					})
+				});
+				indexes = [{
+					name: `${tableName}_uniq_pair`,
+					on: [leftKey, rightKey],
+					unique: true
+				}];
+			} else {
+				const sourceIdKey = `${decapitalizeModelName(sourceModel.metadata.name)}Id`;
+				const targetIdKey = `${decapitalizeModelName(targetModel.metadata.name)}Id`;
+				throughSchema = z.object({
+					id: Decorators.primaryKey(z.number().int()),
+					[sourceIdKey]: Decorators.foreignKey(sourceModel, {
+						field: pkSource.zod,
+						onDelete: InternalReferentialAction.CASCADE,
+						onUpdate: InternalReferentialAction.CASCADE
+					}),
+					[targetIdKey]: Decorators.foreignKey(targetModel, {
+						field: pkTarget.zod,
+						onDelete: InternalReferentialAction.CASCADE,
+						onUpdate: InternalReferentialAction.CASCADE
+					})
+				});
+				indexes = [{
+					name: `${tableName}_uniq_pair`,
+					on: [sourceIdKey, targetIdKey],
+					unique: true
+				}];
+			}
+			const modelNamePart = ImplicitManyToManyIdentifier.getModelName(identityKey);
+			const throughModel = InternalSchemaModel.create({
+				namespace: ImplicitManyToManyIdentifier.getNamespace(),
+				name: modelNamePart,
+				table: tableName,
+				schema: throughSchema,
+				registry,
+				indexes,
+				managed: true
+			}, registry);
+			models.push(throughModel);
+		}
+		return models;
+	}
+	static unwrapForForeignKeyField(zodType) {
+		let inner = zodType;
+		while (isZodOptional(inner)) inner = inner.unwrap();
+		while (isZodNullable(inner)) inner = inner.unwrap();
+		while (isZodDefault(inner)) inner = inner.removeDefault();
+		return inner;
+	}
+	static clonePrimaryKeySchemaForForeignKey(zodType) {
+		const unwrapped = ImplicitManyToManyThroughFactory.unwrapForForeignKeyField(zodType);
+		if (isZodNumber(unwrapped)) {
+			const checks = unwrapped._zod.def.checks ?? [];
+			const isInt = checks.some((check) => "format" in check._zod.def && check._zod.def.format === "safeint");
+			return isInt ? z.number().int() : z.number();
+		}
+		if (isZodString(unwrapped)) return z.string();
+		if (isZodBoolean(unwrapped)) return z.boolean();
+		if (isZodDate(unwrapped)) return z.date();
+		if (isZodObject(unwrapped)) return z.object({});
+		if (isZodArray(unwrapped)) return z.array(z.unknown());
+		throw new Error("Implicit many-to-many primary keys must resolve to a clonable scalar Zod schema.");
+	}
+	static readSinglePrimaryKey(model) {
+		const keys = [];
+		for (const [fieldKey$1, zodType$1] of Object.entries(model.schema.shape)) {
+			const meta$1 = getFieldMetadata(zodType$1);
+			if (meta$1?.primaryKey) keys.push(fieldKey$1);
+		}
+		if (keys.length !== 1) throw new Error(`Implicit many-to-many requires model '${model.metadata.key}' to declare exactly one primary key field.`);
+		const fieldKey = keys[0];
+		const zodType = model.schema.shape[fieldKey];
+		const meta = getFieldMetadata(zodType);
+		return {
+			fieldKey,
+			zod: ImplicitManyToManyThroughFactory.clonePrimaryKeySchemaForForeignKey(zodType),
+			dbColumn: meta?.dbColumn ?? fieldKey
+		};
+	}
+	static collectImplicitDescriptors(registry) {
+		const out = [];
+		for (const model of registry.values()) for (const descriptor of InternalSchemaModel.getNormalizedRelations(model)) {
+			if (descriptor.origin !== InternalNormalizedRelationOrigin.MANY_TO_MANY) continue;
+			if (descriptor.throughModelRef && descriptor.throughSourceFieldName && descriptor.throughTargetFieldName) continue;
+			out.push(descriptor);
+		}
+		return out;
+	}
+	static allocateTableName(occupied, digest) {
+		const base = `m2m_${digest}`;
+		let candidate = base;
+		let suffix = 0;
+		while (occupied.has(candidate.toLowerCase())) {
+			suffix += 1;
+			candidate = `${base}_${suffix}`;
+		}
+		occupied.add(candidate.toLowerCase());
+		return candidate;
+	}
+};
+
 //#endregion
 //#region src/model/relations/ResolvedRelationGraphBuilder.ts
 const REFERENCE_CAPABILITIES = Object.freeze({
@@ -768,8 +1000,8 @@ const REFERENCE_CAPABILITIES = Object.freeze({
 });
 const MANY_TO_MANY_CAPABILITIES = Object.freeze({
 	migratable: false,
-	queryable: false,
-	hydratable: false
+	queryable: true,
+	hydratable: true
 });
 const RELATION_NAME_SEPARATOR = ":";
 var ResolvedRelationGraphBuilder = class ResolvedRelationGraphBuilder {
@@ -800,6 +1032,12 @@ var ResolvedRelationGraphBuilder = class ResolvedRelationGraphBuilder {
 				cardinality: relation.cardinality,
 				localFieldName: relation.localFieldName,
 				targetFieldName: relation.targetFieldName,
+				throughModelKey: relation.throughModelKey,
+				throughTable: relation.throughTable,
+				throughSourceFieldName: relation.throughSourceFieldName,
+				throughTargetFieldName: relation.throughTargetFieldName,
+				throughSourceKey: relation.throughSourceKey,
+				throughTargetKey: relation.throughTargetKey,
 				alias: relation.alias,
 				capabilities: {
 					migratable: relation.capabilities.migratable,
@@ -826,8 +1064,27 @@ var ResolvedRelationGraphBuilder = class ResolvedRelationGraphBuilder {
 		const explicitRelations = InternalSchemaModel.getExplicitRelations(model) ?? {};
 		for (const descriptor of InternalSchemaModel.getNormalizedRelations(model)) {
 			const targetModel = this.options.resolveRef(descriptor.targetRef);
-			if (descriptor.origin === "manyToMany") {
+			if (descriptor.origin === InternalNormalizedRelationOrigin.MANY_TO_MANY) {
 				const relationName = descriptor.explicitForwardName ?? descriptor.namingHint;
+				let throughModel;
+				let throughSourceFieldName;
+				let throughTargetFieldName;
+				if (descriptor.throughModelRef && descriptor.throughSourceFieldName && descriptor.throughTargetFieldName) {
+					throughModel = this.options.resolveRef(descriptor.throughModelRef);
+					throughSourceFieldName = descriptor.throughSourceFieldName;
+					throughTargetFieldName = descriptor.throughTargetFieldName;
+				} else {
+					throughModel = this.options.resolveRef(ImplicitManyToManyIdentifier.getModelKey(model.metadata.key, descriptor.sourceSchemaFieldKey, targetModel.metadata.key));
+					const implicitNames = ImplicitManyToManyThroughFactory.throughFieldNames(model, targetModel);
+					throughSourceFieldName = implicitNames.throughSourceFieldName;
+					throughTargetFieldName = implicitNames.throughTargetFieldName;
+				}
+				const throughNormalized = InternalSchemaModel.getNormalizedRelations(throughModel);
+				const throughSource = throughNormalized.find((rel) => rel.sourceSchemaFieldKey === throughSourceFieldName);
+				const throughTarget = throughNormalized.find((rel) => rel.sourceSchemaFieldKey === throughTargetFieldName);
+				if (!throughSource || !throughTarget) throw new Error(`Many-to-many relation '${relationName}' on model '${model.metadata.key}' cannot find through fields on '${throughModel.metadata.key}'.`);
+				const throughStorage = this.options.storage.byModel.get(throughModel.metadata.key);
+				if (!throughStorage) throw new Error(`Many-to-many relation '${relationName}' on model '${model.metadata.key}' cannot resolve storage artifacts for through model '${throughModel.metadata.key}'.`);
 				this.addResolvedRelation({
 					edgeId: descriptor.edgeId,
 					sourceModelKey: model.metadata.key,
@@ -838,7 +1095,13 @@ var ResolvedRelationGraphBuilder = class ResolvedRelationGraphBuilder {
 					cardinality: InternalRelationCardinality.MANY,
 					capabilities: MANY_TO_MANY_CAPABILITIES,
 					provenance: InternalRelationProvenance.FIELD_DECORATOR,
-					alias: `${toSnakeCase(model.metadata.name)}_${relationName}`
+					alias: `${toSnakeCase(model.metadata.name)}_${relationName}`,
+					throughModelKey: throughModel.metadata.key,
+					throughTable: throughStorage.table,
+					throughSourceFieldName,
+					throughTargetFieldName,
+					throughSourceKey: throughSource.dbColumnName,
+					throughTargetKey: throughTarget.dbColumnName
 				});
 				continue;
 			}
@@ -865,6 +1128,7 @@ var ResolvedRelationGraphBuilder = class ResolvedRelationGraphBuilder {
 			provenance: InternalRelationProvenance.FIELD_DECORATOR,
 			alias: `${toSnakeCase(targetModel.metadata.name)}_${forwardName}`
 		});
+		if (ImplicitManyToManyIdentifier.isImplicitManyToManyModel(sourceModel.metadata.key)) return;
 		const reverseOverride = this.findReverseOverride(sourceModel, targetModel, descriptor);
 		if (reverseOverride) this.markOverrideMatched(targetModel.metadata.key, reverseOverride[0]);
 		const reverseKind = descriptor.unique ? InternalRelationPublicKind.HAS_ONE : InternalRelationPublicKind.HAS_MANY;
@@ -1087,6 +1351,10 @@ var ModelRegistry = class ModelRegistry {
 	*/
 	finalizeStorageArtifacts() {
 		if (this.storageCache?.version === this.version) return this.storageCache;
+		const strippedImplicit = this.stripImplicitManyToManyModels();
+		const implicitThroughModels = ImplicitManyToManyThroughFactory.buildModels(this);
+		for (const model of implicitThroughModels) this.models.set(model.metadata.key, model);
+		if (strippedImplicit || implicitThroughModels.length > 0) this.bumpVersion();
 		const primaryKeyByModel = new Map();
 		for (const model of this.models.values()) primaryKeyByModel.set(model.metadata.key, this.inferPrimaryKeyName(model));
 		const byModel = new Map();
@@ -1132,10 +1400,11 @@ var ModelRegistry = class ModelRegistry {
 	*/
 	getResolvedRelationGraph() {
 		if (this.relationGraphCache?.version === this.version) return this.relationGraphCache;
+		const storage = this.finalizeStorageArtifacts();
 		const finalized = ResolvedRelationGraphBuilder.build({
 			version: this.version,
 			models: this.values(),
-			storage: this.finalizeStorageArtifacts(),
+			storage,
 			resolveRef: (ref) => this.resolveRef(ref)
 		});
 		this.relationGraphCache = finalized;
@@ -1173,6 +1442,14 @@ var ModelRegistry = class ModelRegistry {
 		this.relationGraphCache = undefined;
 		this.lastRelationRegistryDriftCheckVersion = undefined;
 	}
+	stripImplicitManyToManyModels() {
+		let removed = false;
+		for (const key of this.models.keys()) if (ImplicitManyToManyIdentifier.isImplicitManyToManyModel(key)) {
+			this.models.delete(key);
+			removed = true;
+		}
+		return removed;
+	}
 	freezeFields(fields) {
 		return Object.freeze(fields.map((field$1) => Object.freeze({ ...field$1 })));
 	}
@@ -1310,6 +1587,7 @@ __export(model_exports, {
 	GENERATED_RELATION_REGISTRY_METADATA_FILENAME: () => GENERATED_RELATION_REGISTRY_METADATA_FILENAME,
 	GENERATED_RELATION_REGISTRY_METADATA_VERSION: () => GENERATED_RELATION_REGISTRY_METADATA_VERSION,
 	GENERATED_RELATION_REGISTRY_TYPES_FILENAME: () => GENERATED_RELATION_REGISTRY_TYPES_FILENAME,
+	ImplicitManyToManyIdentifier: () => ImplicitManyToManyIdentifier,
 	Indexes: () => Indexes,
 	InternalDecoratedFieldKind: () => InternalDecoratedFieldKind,
 	Meta: () => Meta,
@@ -1334,5 +1612,5 @@ __export(model_exports, {
 });
 
 //#endregion
-export { Constraints, Decorators, GENERATED_RELATION_REGISTRY_DIRNAME, GENERATED_RELATION_REGISTRY_METADATA_FILENAME, GENERATED_RELATION_REGISTRY_METADATA_VERSION, GENERATED_RELATION_REGISTRY_TYPES_FILENAME, Indexes, InternalDecoratedFieldKind, Meta, Model, ModelRegistry, RelationBuilder, ResolvedRelationGraphArtifactFactory, constraints_exports, createSchemaModuleAliases, createTypedModelRef, decorators_exports, isTypedModelRef, meta_exports, model_exports, registerModelAugmentor, registry_exports, relations_exports, resolveSchemaModuleEntrypoint };
-//# sourceMappingURL=model-BxkSqwrt.js.map
+export { Constraints, Decorators, GENERATED_RELATION_REGISTRY_DIRNAME, GENERATED_RELATION_REGISTRY_METADATA_FILENAME, GENERATED_RELATION_REGISTRY_METADATA_VERSION, GENERATED_RELATION_REGISTRY_TYPES_FILENAME, ImplicitManyToManyIdentifier, Indexes, InternalDecoratedFieldKind, Meta, Model, ModelRegistry, RelationBuilder, ResolvedRelationGraphArtifactFactory, constraints_exports, createSchemaModuleAliases, createTypedModelRef, decorators_exports, isTypedModelRef, meta_exports, model_exports, registerModelAugmentor, registry_exports, relations_exports, resolveSchemaModuleEntrypoint };
+//# sourceMappingURL=model-upj6jxaK.js.map