@danceroutine/tango-schema 1.1.3 → 1.2.0

package/dist/model-CJbsYdkM.js

@@ -0,0 +1,1124 @@
+import { getLogger } from "@danceroutine/tango-core";
+import { z } from "zod";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
+//#endregion
+//#region src/model/fields/FieldMetadataStore.ts
+const fieldMetadataStore = new WeakMap();
+function getFieldMetadata(schema) {
+	return fieldMetadataStore.get(schema);
+}
+function setFieldMetadata(schema, meta) {
+	const existing = fieldMetadataStore.get(schema);
+	fieldMetadataStore.set(schema, {
+		...existing,
+		...meta
+	});
+}
+
+//#endregion
+//#region src/model/decorators/domain/DecoratedFieldKind.ts
+const INTERNAL_DECORATED_FIELD_KIND = {
+	FOREIGN_KEY: "foreignKey",
+	ONE_TO_ONE: "oneToOne",
+	MANY_TO_MANY: "manyToMany"
+};
+
+//#endregion
+//#region src/model/decorators/Decorators.ts
+function isZodType(value) {
+	return !!value && typeof value === "object" && "safeParse" in value && typeof value.safeParse === "function";
+}
+function decorate(schema, meta) {
+	setFieldMetadata(schema, meta);
+	return schema;
+}
+const warnedDecoratorKinds = new Set();
+function warnDeprecatedSchemaOverload(kind, replacement) {
+	if (warnedDecoratorKinds.has(kind)) return;
+	warnedDecoratorKinds.add(kind);
+	getLogger("tango.schema.decorators").warn(`Deprecated positional schema overload used for t.${kind}(...). Prefer ${replacement} instead.`);
+}
+function maybeDecorator(schemaOrUndefined, meta) {
+	if (schemaOrUndefined) return decorate(schemaOrUndefined, meta);
+	return (schema) => decorate(schema, meta);
+}
+function primaryKey(schema) {
+	return maybeDecorator(schema, {
+		primaryKey: true,
+		notNull: true
+	});
+}
+function unique(schema) {
+	return maybeDecorator(schema, { unique: true });
+}
+function nullValue(schema) {
+	return maybeDecorator(schema, { notNull: false });
+}
+function notNull(schema) {
+	return maybeDecorator(schema, { notNull: true });
+}
+function defaultValue(schema, value) {
+	return decorate(schema, { default: value });
+}
+function dbDefault(schema, value) {
+	return decorate(schema, { dbDefault: value });
+}
+function dbColumn(schema, name) {
+	return decorate(schema, { dbColumn: name });
+}
+function dbIndex(schema) {
+	return decorate(schema, { dbIndex: true });
+}
+function choices(schema, values) {
+	return decorate(schema, { choices: values });
+}
+function validators(schema, ...values) {
+	return decorate(schema, { validators: values });
+}
+function helpText(schema, text) {
+	return decorate(schema, { helpText: text });
+}
+function errorMessages(schema, map) {
+	return decorate(schema, { errorMessages: map });
+}
+var FieldDecoratorBuilderImpl = class {
+	constructor(schema) {
+		this.schema = schema;
+	}
+	defaultValue(value) {
+		decorate(this.schema, { default: value });
+		return this;
+	}
+	dbDefault(value) {
+		decorate(this.schema, { dbDefault: value });
+		return this;
+	}
+	dbColumn(name) {
+		decorate(this.schema, { dbColumn: name });
+		return this;
+	}
+	dbIndex() {
+		decorate(this.schema, { dbIndex: true });
+		return this;
+	}
+	choices(values) {
+		decorate(this.schema, { choices: values });
+		return this;
+	}
+	validators(...values) {
+		decorate(this.schema, { validators: values });
+		return this;
+	}
+	helpText(text) {
+		decorate(this.schema, { helpText: text });
+		return this;
+	}
+	errorMessages(map) {
+		decorate(this.schema, { errorMessages: map });
+		return this;
+	}
+	build() {
+		return this.schema;
+	}
+};
+function field(schema) {
+	return new FieldDecoratorBuilderImpl(schema);
+}
+function applyRelationMetadata(schema, meta, config) {
+	return decorate(schema, {
+		...meta,
+		forwardName: config?.name,
+		reverseName: config?.relatedName
+	});
+}
+function toReferentialOptions(config) {
+	if (!config) return undefined;
+	if (config.column === undefined && config.onDelete === undefined && config.onUpdate === undefined) return undefined;
+	return {
+		column: config.column,
+		onDelete: config.onDelete,
+		onUpdate: config.onUpdate
+	};
+}
+function foreignKey(target, schemaOrOptions, maybeOptions) {
+	if (isZodType(schemaOrOptions)) {
+		warnDeprecatedSchemaOverload(INTERNAL_DECORATED_FIELD_KIND.FOREIGN_KEY, "t.foreignKey(target, { field: schema, ...options })");
+		return applyRelationMetadata(schemaOrOptions, {
+			relationKind: INTERNAL_DECORATED_FIELD_KIND.FOREIGN_KEY,
+			references: {
+				target,
+				options: maybeOptions
+			}
+		});
+	}
+	const config = schemaOrOptions;
+	const schema = config?.field ?? z.number().int();
+	return applyRelationMetadata(schema, {
+		relationKind: INTERNAL_DECORATED_FIELD_KIND.FOREIGN_KEY,
+		references: {
+			target,
+			options: toReferentialOptions(config)
+		},
+		notNull: config?.field ? undefined : true
+	}, config);
+}
+function oneToOne(target, schemaOrOptions, maybeOptions) {
+	if (isZodType(schemaOrOptions)) {
+		warnDeprecatedSchemaOverload(INTERNAL_DECORATED_FIELD_KIND.ONE_TO_ONE, "t.oneToOne(target, { field: schema, ...options })");
+		return applyRelationMetadata(schemaOrOptions, {
+			relationKind: INTERNAL_DECORATED_FIELD_KIND.ONE_TO_ONE,
+			unique: true,
+			references: {
+				target,
+				options: maybeOptions
+			}
+		});
+	}
+	const config = schemaOrOptions;
+	const schema = config?.field ?? z.number().int();
+	return applyRelationMetadata(schema, {
+		relationKind: INTERNAL_DECORATED_FIELD_KIND.ONE_TO_ONE,
+		unique: true,
+		references: {
+			target,
+			options: toReferentialOptions(config)
+		},
+		notNull: config?.field ? undefined : true
+	}, config);
+}
+function manyToMany(target, schemaOrConfig) {
+	if (isZodType(schemaOrConfig)) {
+		warnDeprecatedSchemaOverload(INTERNAL_DECORATED_FIELD_KIND.MANY_TO_MANY, "t.manyToMany(target, { field: schema, name })");
+		return applyRelationMetadata(schemaOrConfig, {
+			relationKind: INTERNAL_DECORATED_FIELD_KIND.MANY_TO_MANY,
+			references: { target }
+		});
+	}
+	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());
+	return applyRelationMetadata(schema, {
+		relationKind: INTERNAL_DECORATED_FIELD_KIND.MANY_TO_MANY,
+		references: { target }
+	}, config);
+}
+const Decorators = {
+	field,
+	primaryKey,
+	unique,
+	null: nullValue,
+	notNull,
+	default: defaultValue,
+	dbDefault,
+	dbColumn,
+	dbIndex,
+	choices,
+	validators,
+	helpText,
+	errorMessages,
+	foreignKey,
+	oneToOne,
+	manyToMany
+};
+
+//#endregion
+//#region src/model/decorators/index.ts
+var decorators_exports = {};
+__export(decorators_exports, {
+	Decorators: () => Decorators,
+	t: () => Decorators
+});
+
+//#endregion
+//#region src/model/meta/Meta.ts
+const Meta = {
+	ordering(...fields) {
+		return { ordering: fields };
+	},
+	managed(value) {
+		return { managed: value };
+	},
+	defaultRelatedName(value) {
+		return { defaultRelatedName: value };
+	},
+	indexes(...indexes) {
+		return { indexes };
+	},
+	constraints(...constraints) {
+		return { constraints };
+	},
+	uniqueTogether(...sets) {
+		return { constraints: sets.map((fields) => ({
+			kind: "uniqueTogether",
+			fields
+		})) };
+	},
+	indexTogether(...sets) {
+		return { indexes: sets.map((on, index) => ({
+			name: `idx_${on.join("_")}_${index}`,
+			on
+		})) };
+	},
+	merge(...fragments) {
+		return fragments.reduce((acc, fragment) => ({
+			ordering: fragment.ordering ?? acc.ordering,
+			managed: fragment.managed ?? acc.managed,
+			defaultRelatedName: fragment.defaultRelatedName ?? acc.defaultRelatedName,
+			indexes: [...acc.indexes ?? [], ...fragment.indexes ?? []],
+			constraints: [...acc.constraints ?? [], ...fragment.constraints ?? []]
+		}), {});
+	}
+};
+
+//#endregion
+//#region src/model/meta/index.ts
+var meta_exports = {};
+__export(meta_exports, {
+	Meta: () => Meta,
+	m: () => Meta
+});
+
+//#endregion
+//#region src/model/constraints/Constraints.ts
+const Constraints = {
+	unique(fields, options) {
+		return {
+			kind: "unique",
+			fields,
+			...options
+		};
+	},
+	check(condition, options) {
+		return {
+			kind: "check",
+			condition,
+			...options
+		};
+	},
+	exclusion(definition) {
+		return {
+			kind: "exclusion",
+			...definition
+		};
+	}
+};
+
+//#endregion
+//#region src/model/constraints/Indexes.ts
+const Indexes = { index(on, options) {
+	const suffix = on.join("_");
+	return {
+		name: options?.name ?? `idx_${suffix}`,
+		on,
+		unique: options?.unique,
+		where: options?.where
+	};
+} };
+
+//#endregion
+//#region src/model/constraints/index.ts
+var constraints_exports = {};
+__export(constraints_exports, {
+	Constraints: () => Constraints,
+	Indexes: () => Indexes,
+	c: () => Constraints,
+	i: () => Indexes
+});
+
+//#endregion
+//#region src/domain/internal/InternalFieldType.ts
+const InternalFieldType = {
+	SERIAL: "serial",
+	INT: "int",
+	BIGINT: "bigint",
+	TEXT: "text",
+	BOOL: "bool",
+	TIMESTAMPTZ: "timestamptz",
+	JSONB: "jsonb",
+	UUID: "uuid"
+};
+
+//#endregion
+//#region src/domain/internal/zod/isDate.ts
+function isDate(value) {
+	return value !== null && value !== undefined && Object.prototype.toString.call(value) === "[object Date]";
+}
+
+//#endregion
+//#region src/domain/internal/zod/hasConstructorName.ts
+function hasConstructorName(value, name) {
+	return !!value && typeof value === "object" && value.constructor?.name === name;
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodArray.ts
+function isZodArray(value) {
+	return hasConstructorName(value, "ZodArray");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodBoolean.ts
+function isZodBoolean(value) {
+	return hasConstructorName(value, "ZodBoolean");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodDate.ts
+function isZodDate(value) {
+	return hasConstructorName(value, "ZodDate");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodDefault.ts
+function isZodDefault(value) {
+	return hasConstructorName(value, "ZodDefault");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodNullable.ts
+function isZodNullable(value) {
+	return hasConstructorName(value, "ZodNullable");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodNumber.ts
+function isZodNumber(value) {
+	return hasConstructorName(value, "ZodNumber");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodObject.ts
+function isZodObject(value) {
+	return hasConstructorName(value, "ZodObject");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodOptional.ts
+function isZodOptional(value) {
+	return hasConstructorName(value, "ZodOptional");
+}
+
+//#endregion
+//#region src/domain/internal/zod/isZodString.ts
+function isZodString(value) {
+	return hasConstructorName(value, "ZodString");
+}
+
+//#endregion
+//#region src/model/fields/inferFieldsFromSchema.ts
+/**
+* Infer one storage field from a Zod schema member plus any Tango decorator metadata.
+*
+* The registry and optional target resolver are used only when the field carries
+* reference metadata that must be translated into concrete table/primary-key names.
+*/
+function inferField(name, zodType, meta, registry, resolveReferenceTarget) {
+	let type;
+	let notNull$1 = true;
+	let defaultValue$1 = undefined;
+	let unwrapped = zodType;
+	if (isZodOptional(unwrapped)) {
+		notNull$1 = false;
+		unwrapped = unwrapped.unwrap();
+	}
+	if (isZodNullable(unwrapped)) {
+		notNull$1 = false;
+		unwrapped = unwrapped.unwrap();
+	}
+	if (isZodDefault(unwrapped)) {
+		const def = unwrapped._zod.def.defaultValue;
+		if (isDate(def)) defaultValue$1 = { now: true };
+else if (typeof def === "string" || typeof def === "number") defaultValue$1 = String(def);
+		unwrapped = unwrapped.removeDefault();
+	}
+	if (isZodString(unwrapped)) type = InternalFieldType.TEXT;
+else if (isZodNumber(unwrapped)) {
+		const checks = unwrapped._zod.def.checks ?? [];
+		const isInt = checks.some((c) => "format" in c._zod.def && c._zod.def.format === "safeint");
+		type = isInt ? InternalFieldType.INT : InternalFieldType.BIGINT;
+	} else if (isZodBoolean(unwrapped)) type = InternalFieldType.BOOL;
+else if (isZodDate(unwrapped)) type = InternalFieldType.TIMESTAMPTZ;
+else if (isZodObject(unwrapped) || isZodArray(unwrapped)) type = InternalFieldType.JSONB;
+else return null;
+	const field$1 = {
+		name,
+		type,
+		notNull: notNull$1,
+		default: defaultValue$1
+	};
+	if (!meta) return field$1;
+	if (meta.dbColumn) field$1.name = meta.dbColumn;
+	if (typeof meta.notNull === "boolean") field$1.notNull = meta.notNull;
+	if (meta.default !== undefined) field$1.default = meta.default;
+	if (meta.primaryKey) field$1.primaryKey = true;
+	if (meta.unique) field$1.unique = true;
+	if (meta.relationKind === INTERNAL_DECORATED_FIELD_KIND.MANY_TO_MANY) return null;
+	if (meta.references) {
+		const targetMetadata = resolveReferenceTarget ? resolveReferenceTarget(meta.references.target) : resolveReferenceTargetFromRegistry(meta.references.target, registry, meta.references.options?.column);
+		field$1.references = {
+			table: targetMetadata.table,
+			column: meta.references.options?.column ?? targetMetadata.pk,
+			onDelete: meta.references.options?.onDelete,
+			onUpdate: meta.references.options?.onUpdate
+		};
+	}
+	return field$1;
+}
+function resolveReferenceTargetFromRegistry(target, registry, explicitColumn) {
+	const targetModel = registry.resolveRef(target);
+	const primaryKey$1 = explicitColumn ?? targetModel.metadata.fields.find((candidate) => candidate.primaryKey)?.name ?? "id";
+	return {
+		table: targetModel.metadata.table,
+		pk: primaryKey$1
+	};
+}
+function inferFieldsFromSchema(schema, options) {
+	const registry = options?.registry ?? ModelRegistry.global();
+	const shape = schema.shape;
+	const fields = [];
+	for (const [name, zodType] of Object.entries(shape)) {
+		const field$1 = inferField(name, zodType, getFieldMetadata(zodType), registry, options?.resolveReferenceTarget);
+		if (field$1) fields.push(field$1);
+	}
+	return fields;
+}
+
+//#endregion
+//#region src/domain/internal/InternalRelationType.ts
+const InternalRelationType = {
+	HAS_MANY: "hasMany",
+	BELONGS_TO: "belongsTo",
+	HAS_ONE: "hasOne"
+};
+
+//#endregion
+//#region src/model/relations/RelationBuilder.ts
+var RelationBuilder = class {
+	/** Declare a one-to-many relation from this model to `target`. */
+	hasMany(target, foreignKey$1) {
+		return {
+			type: InternalRelationType.HAS_MANY,
+			target,
+			foreignKey: foreignKey$1
+		};
+	}
+	/** Declare an owning relation to a parent model. */
+	belongsTo(target, foreignKey$1, localKey) {
+		return {
+			type: InternalRelationType.BELONGS_TO,
+			target,
+			foreignKey: foreignKey$1,
+			localKey
+		};
+	}
+	/** Declare a one-to-one relation from this model to `target`. */
+	hasOne(target, foreignKey$1) {
+		return {
+			type: InternalRelationType.HAS_ONE,
+			target,
+			foreignKey: foreignKey$1
+		};
+	}
+};
+
+//#endregion
+//#region src/model/relations/RelationDescriptorNormalizer.ts
+var RelationDescriptorNormalizer = class RelationDescriptorNormalizer {
+	constructor(sourceModelKey, schema) {
+		this.sourceModelKey = sourceModelKey;
+		this.schema = schema;
+	}
+	static normalize(sourceModelKey, schema) {
+		return new RelationDescriptorNormalizer(sourceModelKey, schema).normalize();
+	}
+	/**
+	* Run the field-authored relation normalization pipeline for one model
+	* schema and emit descriptors that later relation stages can resolve.
+	*/
+	normalize() {
+		const descriptors = [];
+		for (const candidate of this.collectRelationCandidates()) {
+			const descriptor = this.normalizeCandidate(candidate);
+			if (descriptor) descriptors.push(descriptor);
+		}
+		return descriptors;
+	}
+	collectRelationCandidates() {
+		return Object.entries(this.schema.shape).map(([sourceSchemaFieldKey, zodType]) => ({
+			sourceSchemaFieldKey,
+			zodType
+		}));
+	}
+	normalizeCandidate(candidate) {
+		const meta = getFieldMetadata(candidate.zodType);
+		if (!meta?.references || !meta.relationKind) return undefined;
+		return {
+			edgeId: this.buildEdgeId(candidate.sourceSchemaFieldKey, meta.relationKind),
+			sourceModelKey: this.sourceModelKey,
+			sourceSchemaFieldKey: candidate.sourceSchemaFieldKey,
+			targetRef: meta.references.target,
+			origin: meta.relationKind,
+			localFieldName: candidate.sourceSchemaFieldKey,
+			dbColumnName: meta.dbColumn ?? candidate.sourceSchemaFieldKey,
+			referencedTargetColumn: meta.references.options?.column,
+			onDelete: meta.references.options?.onDelete,
+			onUpdate: meta.references.options?.onUpdate,
+			unique: meta.unique || meta.relationKind === INTERNAL_DECORATED_FIELD_KIND.ONE_TO_ONE,
+			explicitForwardName: meta.forwardName,
+			explicitReverseName: meta.reverseName,
+			namingHint: this.deriveNamingHint(candidate.sourceSchemaFieldKey),
+			provenance: "field-decorator"
+		};
+	}
+	buildEdgeId(sourceSchemaFieldKey, origin) {
+		return `${this.sourceModelKey}:${sourceSchemaFieldKey}:${origin}`;
+	}
+	deriveNamingHint(fieldKey) {
+		if (fieldKey.endsWith("Id") && fieldKey.length > 2) return fieldKey.slice(0, -2);
+		if (fieldKey.endsWith("_id") && fieldKey.length > 3) return fieldKey.slice(0, -3);
+		return fieldKey;
+	}
+};
+
+//#endregion
+//#region src/model/relations/SchemaNaming.ts
+function toSnakeCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+function pluralize(value) {
+	if (/(s|x|z|ch|sh)$/.test(value)) return `${value}es`;
+	if (/[^aeiou]y$/.test(value)) return `${value.slice(0, -1)}ies`;
+	return `${value}s`;
+}
+function deriveTableName(name) {
+	return pluralize(toSnakeCase(name));
+}
+
+//#endregion
+//#region src/model/internal/InternalSchemaModel.ts
+var InternalSchemaModel = class InternalSchemaModel {
+	static BRAND = "tango.schema.internal_schema_model";
+	__tangoBrand = InternalSchemaModel.BRAND;
+	metadata;
+	schema;
+	hooks;
+	registry;
+	normalizedRelations;
+	explicitFields;
+	explicitRelations;
+	constructor(registry, metadata, schema, hooks, normalizedRelations, explicitFields, explicitRelations) {
+		this.registry = registry;
+		this.metadata = metadata;
+		this.schema = schema;
+		this.hooks = hooks;
+		this.normalizedRelations = Object.freeze([...normalizedRelations]);
+		this.explicitFields = explicitFields ? Object.freeze([...explicitFields]) : undefined;
+		this.explicitRelations = explicitRelations;
+	}
+	static create(definition, registry) {
+		InternalSchemaModel.validateDefinition(definition);
+		const builder = new RelationBuilder();
+		const relations = definition.relations ? Object.freeze(definition.relations(builder)) : undefined;
+		const key = `${definition.namespace}/${definition.name}`;
+		const table = definition.table?.trim() || deriveTableName(definition.name);
+		const normalizedRelations = RelationDescriptorNormalizer.normalize(key, definition.schema);
+		const metadata = {
+			namespace: definition.namespace,
+			name: definition.name,
+			key,
+			table,
+			fields: [],
+			indexes: definition.indexes,
+			relations,
+			ordering: definition.ordering,
+			managed: definition.managed,
+			defaultRelatedName: definition.defaultRelatedName,
+			constraints: definition.constraints
+		};
+		Object.defineProperty(metadata, "fields", {
+			enumerable: true,
+			configurable: false,
+			get: () => registry.getFinalizedFields(key)
+		});
+		Object.freeze(metadata);
+		return new InternalSchemaModel(registry, metadata, definition.schema, definition.hooks, normalizedRelations, definition.fields, relations);
+	}
+	static isInternalSchemaModel(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === InternalSchemaModel.BRAND;
+	}
+	static getRegistryOwner(model) {
+		return InternalSchemaModel.require(model).registry;
+	}
+	static getNormalizedRelations(model) {
+		return InternalSchemaModel.require(model).normalizedRelations;
+	}
+	static getExplicitFields(model) {
+		return InternalSchemaModel.require(model).explicitFields;
+	}
+	static getExplicitRelations(model) {
+		return InternalSchemaModel.require(model).explicitRelations;
+	}
+	static validateDefinition(definition) {
+		if (!definition.namespace.trim()) throw new Error("Model.namespace is required and cannot be empty.");
+		if (!definition.name.trim()) throw new Error("Model.name is required and cannot be empty.");
+		if (definition.table !== undefined && !definition.table.trim()) throw new Error("Model.table cannot be empty when provided.");
+	}
+	static require(model) {
+		if (!InternalSchemaModel.isInternalSchemaModel(model)) throw new Error(`Model '${model.metadata.key}' is missing internal registry ownership metadata.`);
+		return model;
+	}
+};
+
+//#endregion
+//#region src/model/relations/RelationSpec.ts
+const INTERNAL_RELATION_PUBLIC_KIND = {
+	BELONGS_TO: "belongsTo",
+	HAS_ONE: "hasOne",
+	HAS_MANY: "hasMany",
+	MANY_TO_MANY: "manyToMany"
+};
+const INTERNAL_RELATION_STORAGE_STRATEGY = {
+	REFERENCE: "reference",
+	REVERSE_REFERENCE: "reverse_reference",
+	MANY_TO_MANY: "many_to_many"
+};
+const INTERNAL_RELATION_CARDINALITY = {
+	SINGLE: "single",
+	MANY: "many"
+};
+const INTERNAL_RELATION_PROVENANCE = {
+	FIELD_DECORATOR: "field-decorator",
+	RELATIONS_API: "relations-api",
+	SYNTHESIZED_REVERSE: "synthesized-reverse"
+};
+
+//#endregion
+//#region src/model/relations/ResolvedRelationGraphBuilder.ts
+const REFERENCE_CAPABILITIES = Object.freeze({
+	migratable: true,
+	queryable: true,
+	hydratable: true
+});
+const MANY_TO_MANY_CAPABILITIES = Object.freeze({
+	migratable: false,
+	queryable: false,
+	hydratable: false
+});
+const RELATION_NAME_SEPARATOR = ":";
+var ResolvedRelationGraphBuilder = class ResolvedRelationGraphBuilder {
+	byModel = new Map();
+	byEdgeId = new Map();
+	matchedOverrides = new Set();
+	constructor(options) {
+		this.options = options;
+	}
+	static build(options) {
+		return new ResolvedRelationGraphBuilder(options).build();
+	}
+	/**
+	* Resolve every model's normalized relation descriptors into a single
+	* registry-scoped graph and fail when authoring ambiguity remains.
+	*/
+	build() {
+		for (const model of this.options.models) this.addModelRelations(model);
+		for (const model of this.options.models) this.assertAllOverridesMatched(model);
+		return {
+			version: this.options.version,
+			byModel: this.byModel,
+			byEdgeId: this.byEdgeId
+		};
+	}
+	addModelRelations(model) {
+		const explicitRelations = InternalSchemaModel.getExplicitRelations(model) ?? {};
+		for (const descriptor of InternalSchemaModel.getNormalizedRelations(model)) {
+			const targetModel = this.options.resolveRef(descriptor.targetRef);
+			if (descriptor.origin === "manyToMany") {
+				const relationName = descriptor.explicitForwardName ?? descriptor.namingHint;
+				this.addResolvedRelation({
+					edgeId: descriptor.edgeId,
+					sourceModelKey: model.metadata.key,
+					targetModelKey: targetModel.metadata.key,
+					name: relationName,
+					kind: INTERNAL_RELATION_PUBLIC_KIND.MANY_TO_MANY,
+					storageStrategy: INTERNAL_RELATION_STORAGE_STRATEGY.MANY_TO_MANY,
+					cardinality: INTERNAL_RELATION_CARDINALITY.MANY,
+					capabilities: MANY_TO_MANY_CAPABILITIES,
+					provenance: INTERNAL_RELATION_PROVENANCE.FIELD_DECORATOR,
+					alias: `${toSnakeCase(model.metadata.name)}_${relationName}`
+				});
+				continue;
+			}
+			this.addReferenceRelations(model, descriptor, targetModel, explicitRelations);
+		}
+	}
+	addReferenceRelations(sourceModel, descriptor, targetModel, explicitRelations) {
+		const forwardOverride = this.findForwardOverride(sourceModel, targetModel, descriptor, explicitRelations);
+		if (forwardOverride) this.markOverrideMatched(sourceModel.metadata.key, forwardOverride[0]);
+		const forwardName = forwardOverride?.[0] ?? descriptor.explicitForwardName ?? descriptor.namingHint;
+		const targetPrimaryKey = this.getPrimaryKey(targetModel.metadata.key);
+		this.addResolvedRelation({
+			edgeId: descriptor.edgeId,
+			sourceModelKey: sourceModel.metadata.key,
+			targetModelKey: targetModel.metadata.key,
+			name: forwardName,
+			inverseEdgeId: `${descriptor.edgeId}:inverse`,
+			kind: INTERNAL_RELATION_PUBLIC_KIND.BELONGS_TO,
+			storageStrategy: INTERNAL_RELATION_STORAGE_STRATEGY.REFERENCE,
+			cardinality: INTERNAL_RELATION_CARDINALITY.SINGLE,
+			localFieldName: descriptor.dbColumnName,
+			targetFieldName: descriptor.referencedTargetColumn ?? targetPrimaryKey,
+			capabilities: REFERENCE_CAPABILITIES,
+			provenance: INTERNAL_RELATION_PROVENANCE.FIELD_DECORATOR,
+			alias: `${toSnakeCase(targetModel.metadata.name)}_${forwardName}`
+		});
+		const reverseOverride = this.findReverseOverride(sourceModel, targetModel, descriptor);
+		if (reverseOverride) this.markOverrideMatched(targetModel.metadata.key, reverseOverride[0]);
+		const reverseKind = descriptor.unique ? INTERNAL_RELATION_PUBLIC_KIND.HAS_ONE : INTERNAL_RELATION_PUBLIC_KIND.HAS_MANY;
+		const reverseCardinality = descriptor.unique ? INTERNAL_RELATION_CARDINALITY.SINGLE : INTERNAL_RELATION_CARDINALITY.MANY;
+		const reverseName = reverseOverride?.[0] ?? descriptor.explicitReverseName ?? this.deriveReverseName(sourceModel, reverseCardinality);
+		this.addResolvedRelation({
+			edgeId: `${descriptor.edgeId}:inverse`,
+			sourceModelKey: targetModel.metadata.key,
+			targetModelKey: sourceModel.metadata.key,
+			name: reverseName,
+			inverseEdgeId: descriptor.edgeId,
+			kind: reverseKind,
+			storageStrategy: INTERNAL_RELATION_STORAGE_STRATEGY.REVERSE_REFERENCE,
+			cardinality: reverseCardinality,
+			localFieldName: descriptor.dbColumnName,
+			targetFieldName: descriptor.referencedTargetColumn ?? targetPrimaryKey,
+			capabilities: REFERENCE_CAPABILITIES,
+			provenance: reverseOverride ? INTERNAL_RELATION_PROVENANCE.RELATIONS_API : INTERNAL_RELATION_PROVENANCE.SYNTHESIZED_REVERSE,
+			alias: `${toSnakeCase(sourceModel.metadata.name)}_${reverseName}`
+		});
+	}
+	findForwardOverride(sourceModel, targetModel, descriptor, explicitRelations) {
+		return Object.entries(explicitRelations).find(([, relation]) => {
+			const relationTargetKey = this.resolveRelationTargetKey(sourceModel, relation.target);
+			return relation.type === INTERNAL_RELATION_PUBLIC_KIND.BELONGS_TO && relationTargetKey === targetModel.metadata.key && relation.foreignKey === descriptor.sourceSchemaFieldKey;
+		});
+	}
+	findReverseOverride(sourceModel, targetModel, descriptor) {
+		const reverseModelRelations = InternalSchemaModel.getExplicitRelations(targetModel) ?? {};
+		const reverseKind = descriptor.unique ? INTERNAL_RELATION_PUBLIC_KIND.HAS_ONE : INTERNAL_RELATION_PUBLIC_KIND.HAS_MANY;
+		return Object.entries(reverseModelRelations).find(([, relation]) => {
+			const relationTargetKey = this.resolveRelationTargetKey(targetModel, relation.target);
+			return relationTargetKey === sourceModel.metadata.key && relation.type === reverseKind && relation.foreignKey === descriptor.sourceSchemaFieldKey;
+		});
+	}
+	assertAllOverridesMatched(model) {
+		const explicitRelations = InternalSchemaModel.getExplicitRelations(model);
+		if (!explicitRelations) return;
+		for (const relationName of Object.keys(explicitRelations)) {
+			const marker = this.buildOverrideMarker(model.metadata.key, relationName);
+			if (!this.matchedOverrides.has(marker)) throw new Error(`Relation override '${relationName}' on model '${model.metadata.key}' does not match a field-authored relation.`);
+		}
+	}
+	addResolvedRelation(descriptor) {
+		const modelRelations = this.byModel.get(descriptor.sourceModelKey) ?? new Map();
+		const existing = modelRelations.get(descriptor.name);
+		if (existing) throw new Error(`Ambiguous relation name '${descriptor.name}' on model '${descriptor.sourceModelKey}'. Add an explicit relations override.`);
+		modelRelations.set(descriptor.name, descriptor);
+		this.byModel.set(descriptor.sourceModelKey, modelRelations);
+		this.byEdgeId.set(descriptor.edgeId, descriptor);
+	}
+	getPrimaryKey(modelKey) {
+		return this.options.storage.byModel.get(modelKey).pk;
+	}
+	markOverrideMatched(modelKey, relationName) {
+		this.matchedOverrides.add(this.buildOverrideMarker(modelKey, relationName));
+	}
+	buildOverrideMarker(modelKey, relationName) {
+		return `${modelKey}${RELATION_NAME_SEPARATOR}${relationName}`;
+	}
+	resolveRelationTargetKey(sourceModel, target) {
+		if (target.includes("/")) return target;
+		return `${sourceModel.metadata.namespace}/${target}`;
+	}
+	deriveReverseName(sourceModel, cardinality) {
+		if (sourceModel.metadata.defaultRelatedName) return sourceModel.metadata.defaultRelatedName;
+		const snake = toSnakeCase(sourceModel.metadata.name);
+		return cardinality === INTERNAL_RELATION_CARDINALITY.MANY ? pluralize(snake) : snake;
+	}
+};
+
+//#endregion
+//#region src/model/registry/ModelRegistry.ts
+const DEFAULT_IDENTIFIER_NAME = "id";
+const activeRegistryStorage = new AsyncLocalStorage();
+var ModelRegistry = class ModelRegistry {
+	static globalRegistry;
+	models = new Map();
+	version = 0;
+	storageCache;
+	relationGraphCache;
+	/**
+	* Return the shared process-wide registry used by `Model(...)`.
+	*/
+	static global() {
+		if (!ModelRegistry.globalRegistry) ModelRegistry.globalRegistry = new ModelRegistry();
+		return ModelRegistry.globalRegistry;
+	}
+	/**
+	* Return the registry currently bound to model construction work.
+	*/
+	static active() {
+		return activeRegistryStorage.getStore() ?? ModelRegistry.global();
+	}
+	/**
+	* Run work with a specific registry bound as the active construction target.
+	*/
+	static async runWithRegistry(registry, work) {
+		return await activeRegistryStorage.run(registry, work);
+	}
+	/**
+	* Register a model on the shared global registry.
+	*/
+	static register(model) {
+		ModelRegistry.global().register(model);
+	}
+	/**
+	* Register several models on the shared global registry.
+	*/
+	static registerMany(models) {
+		ModelRegistry.global().registerMany(models);
+	}
+	/**
+	* Resolve a model from the shared registry by namespace and name.
+	*/
+	static get(namespace, name) {
+		return ModelRegistry.global().get(namespace, name);
+	}
+	/**
+	* Resolve a model from the shared registry by its `namespace/name` key.
+	*/
+	static getByKey(key) {
+		return ModelRegistry.global().getByKey(key);
+	}
+	/**
+	* Resolve any supported model reference form against the shared registry.
+	*/
+	static resolveRef(ref) {
+		return ModelRegistry.global().resolveRef(ref);
+	}
+	/**
+	* Clear the shared registry, which is mainly useful in tests.
+	*/
+	static clear() {
+		ModelRegistry.global().clear();
+	}
+	/**
+	* Return the owning registry for a model.
+	*/
+	static getOwner(model) {
+		return InternalSchemaModel.getRegistryOwner(model);
+	}
+	/**
+	* Register a model on this registry instance.
+	*/
+	register(model) {
+		const owner = InternalSchemaModel.getRegistryOwner(model);
+		if (owner !== this) throw new Error(`Model '${model.metadata.key}' belongs to a different registry and cannot be registered here.`);
+		const existing = this.models.get(model.metadata.key);
+		if (existing && existing !== model) throw new Error(`Model '${model.metadata.key}' is already registered in this registry.`);
+		this.models.set(model.metadata.key, model);
+		this.bumpVersion();
+	}
+	/**
+	* Register several models on this registry instance.
+	*/
+	registerMany(models) {
+		for (const model of models) this.register(model);
+	}
+	/**
+	* Resolve a model from this registry instance by namespace and name.
+	*/
+	get(namespace, name) {
+		return this.getByKey(`${namespace}/${name}`);
+	}
+	/**
+	* Resolve a model from this registry instance by its `namespace/name` key.
+	*/
+	getByKey(key) {
+		return this.models.get(key);
+	}
+	/**
+	* Resolve a string, callback, or direct model reference into a model object.
+	*/
+	resolveRef(ref) {
+		if (typeof ref === "string") {
+			const model$1 = this.getByKey(ref);
+			if (!model$1) throw new Error(`Unable to resolve model reference '${ref}'. Ensure it is registered in ModelRegistry.`);
+			return model$1;
+		}
+		const model = typeof ref === "function" ? ref() : ref;
+		if (InternalSchemaModel.getRegistryOwner(model) !== this) throw new Error(`Model reference '${model.metadata.key}' belongs to a different registry and cannot be resolved here.`);
+		return model;
+	}
+	/**
+	* Finalize storage-only artifacts for all models in this registry.
+	*/
+	finalizeStorageArtifacts() {
+		if (this.storageCache?.version === this.version) return this.storageCache;
+		const primaryKeyByModel = new Map();
+		for (const model of this.models.values()) primaryKeyByModel.set(model.metadata.key, this.inferPrimaryKeyName(model));
+		const byModel = new Map();
+		for (const model of this.models.values()) {
+			const explicitFields = InternalSchemaModel.getExplicitFields(model);
+			const inferredFields = inferFieldsFromSchema(model.schema, {
+				registry: this,
+				resolveReferenceTarget: (target) => {
+					const targetModel = this.resolveRef(target);
+					return {
+						table: targetModel.metadata.table,
+						pk: primaryKeyByModel.get(targetModel.metadata.key)
+					};
+				}
+			});
+			const fields = this.freezeFields(this.mergeStorageFields(inferredFields, explicitFields));
+			const primaryKey$1 = fields.find((field$1) => field$1.primaryKey)?.name ?? DEFAULT_IDENTIFIER_NAME;
+			byModel.set(model.metadata.key, {
+				key: model.metadata.key,
+				table: model.metadata.table,
+				fields,
+				pk: primaryKey$1
+			});
+		}
+		const finalized = {
+			version: this.version,
+			byModel
+		};
+		this.storageCache = finalized;
+		return finalized;
+	}
+	/**
+	* Return finalized storage fields for a specific model.
+	*/
+	getFinalizedFields(model) {
+		const key = typeof model === "string" ? model : model.metadata.key;
+		const fields = this.finalizeStorageArtifacts().byModel.get(key)?.fields;
+		if (!fields) throw new Error(`No finalized storage fields are available for model '${key}'.`);
+		return fields;
+	}
+	/**
+	* Resolve the registry's relation graph from finalized storage artifacts.
+	*/
+	getResolvedRelationGraph() {
+		if (this.relationGraphCache?.version === this.version) return this.relationGraphCache;
+		const finalized = ResolvedRelationGraphBuilder.build({
+			version: this.version,
+			models: this.values(),
+			storage: this.finalizeStorageArtifacts(),
+			resolveRef: (ref) => this.resolveRef(ref)
+		});
+		this.relationGraphCache = finalized;
+		return finalized;
+	}
+	/**
+	* Remove all registered models from this registry instance.
+	*/
+	clear() {
+		this.models.clear();
+		this.bumpVersion();
+	}
+	/**
+	* Return all registered models in insertion order.
+	*/
+	values() {
+		return Array.from(this.models.values());
+	}
+	bumpVersion() {
+		this.version += 1;
+		this.storageCache = undefined;
+		this.relationGraphCache = undefined;
+	}
+	freezeFields(fields) {
+		return Object.freeze(fields.map((field$1) => Object.freeze({ ...field$1 })));
+	}
+	inferPrimaryKeyName(model) {
+		for (const [fieldKey, zodType] of Object.entries(model.schema.shape)) {
+			const meta = getFieldMetadata(zodType);
+			if (meta?.primaryKey) return meta.dbColumn ?? fieldKey;
+		}
+		const explicitFields = InternalSchemaModel.getExplicitFields(model);
+		if (explicitFields) return explicitFields.find((field$1) => field$1.primaryKey)?.name ?? DEFAULT_IDENTIFIER_NAME;
+		return DEFAULT_IDENTIFIER_NAME;
+	}
+	mergeStorageFields(inferredFields, explicitFields) {
+		if (!explicitFields?.length) return inferredFields;
+		const mergedFields = new Map(inferredFields.map((field$1) => [field$1.name, field$1]));
+		for (const explicitField of explicitFields) mergedFields.set(explicitField.name, explicitField);
+		return Array.from(mergedFields.values());
+	}
+};
+
+//#endregion
+//#region src/model/registry/index.ts
+var registry_exports = {};
+__export(registry_exports, { ModelRegistry: () => ModelRegistry });
+
+//#endregion
+//#region src/model/relations/index.ts
+var relations_exports = {};
+__export(relations_exports, { RelationBuilder: () => RelationBuilder });
+
+//#endregion
+//#region src/model/ModelAugmentorRegistry.ts
+const modelAugmentors = new Set();
+function registerModelAugmentor(augmentor) {
+	modelAugmentors.add(augmentor);
+	for (const model of ModelRegistry.global().values()) augmentor(model);
+	return () => {
+		modelAugmentors.delete(augmentor);
+	};
+}
+function applyModelAugmentors(model) {
+	for (const augmentor of modelAugmentors) augmentor(model);
+	return model;
+}
+
+//#endregion
+//#region src/model/Model.ts
+function Model(definition) {
+	const registry = definition.registry ?? ModelRegistry.active();
+	const model = applyModelAugmentors(InternalSchemaModel.create(definition, registry));
+	registry.register(model);
+	return model;
+}
+
+//#endregion
+//#region src/model/index.ts
+var model_exports = {};
+__export(model_exports, {
+	Constraints: () => Constraints,
+	Decorators: () => Decorators,
+	Indexes: () => Indexes,
+	Meta: () => Meta,
+	Model: () => Model,
+	ModelRegistry: () => ModelRegistry,
+	RelationBuilder: () => RelationBuilder,
+	c: () => Constraints,
+	constraints: () => constraints_exports,
+	decorators: () => decorators_exports,
+	i: () => Indexes,
+	m: () => Meta,
+	meta: () => meta_exports,
+	registerModelAugmentor: () => registerModelAugmentor,
+	registry: () => registry_exports,
+	relations: () => relations_exports,
+	t: () => Decorators
+});
+
+//#endregion
+export { Constraints, Decorators, Indexes, Meta, Model, ModelRegistry, RelationBuilder, constraints_exports, decorators_exports, meta_exports, model_exports, registerModelAugmentor, registry_exports, relations_exports };
+//# sourceMappingURL=model-CJbsYdkM.js.map