@prisma-next/sql-contract 0.13.0 → 0.14.0-dev.10

package/dist/validators.mjs

@@ -1,32 +1,21 @@
-import { C as SqlUnboundNamespace, f as buildSqlNamespaceMap, i as SqlStorage } from "./types-DqhaAjCH.mjs";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { blindCast } from "@prisma-next/utils/casts";
+import { C as StorageTableSchema, S as ReferentialActionSchema, _ as ColumnDefaultSchema, b as ForeignKeySourceSchema, g as ColumnDefaultLiteralSchema, h as ColumnDefaultFunctionSchema, m as CheckConstraintSchema, t as composeSqlEntityKinds, v as ForeignKeyReferenceSchema, w as StorageValueSetSchema, x as IndexSchema, y as ForeignKeySchema } from "./entity-kinds-Cl36zL5j.mjs";
+import { i as SqlStorage, l as buildSqlNamespaceMap, u as SqlUnboundNamespace } from "./types-B-eiQXff.mjs";
+import { type } from "arktype";
+import { UNBOUND_NAMESPACE_ID, isPlainRecord } from "@prisma-next/framework-components/ir";
 import { CrossReferenceSchema } from "@prisma-next/contract/types";
+import { blindCast } from "@prisma-next/utils/casts";
 import { ContractValidationError } from "@prisma-next/contract/contract-validation-error";
 import { validateContractDomain } from "@prisma-next/contract/validate-domain";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { type } from "arktype";
 //#region src/validators.ts
-const literalKindSchema = type("'literal'");
-const functionKindSchema = type("'function'");
 const generatorKindSchema = type("'generator'");
 const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
-const generatorIdSchema = type("string").narrow((value, ctx) => {
-	return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value) ? true : ctx.mustBe("a flat generator id");
-});
-const ColumnDefaultLiteralSchema = type.declare().type({
-	kind: literalKindSchema,
-	value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
-});
-const ColumnDefaultFunctionSchema = type.declare().type({
-	kind: functionKindSchema,
-	expression: "string"
-});
-const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
 const ExecutionMutationDefaultValueSchema = type({
 	"+": "reject",
 	kind: generatorKindSchema,
-	id: generatorIdSchema,
+	id: type("string").narrow((value, ctx) => {
+		return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(value) ? true : ctx.mustBe("a flat generator id");
+	}),
 	"params?": "Record<string, unknown>"
 });
 const ExecutionSchema = type({
@@ -38,6 +27,7 @@ const ExecutionSchema = type({
 			"+": "reject",
 			ref: {
 				"+": "reject",
+				namespace: "string",
 				table: "string",
 				column: "string"
 			},
@@ -46,63 +36,21 @@ const ExecutionSchema = type({
 		}).array().readonly()
 	}
 });
-const ValueSetRefSchema = type({
-	plane: "'domain' | 'storage'",
+const DomainEnumRefSchema = type({
+	plane: "'domain'",
 	namespaceId: "string",
-	entityKind: "'enum' | 'value-set'",
-	name: "string",
+	entityKind: "'enum'",
+	entityName: "string",
 	"spaceId?": "string"
 });
-const StorageColumnSchema = type({
-	"+": "reject",
-	nativeType: "string",
-	codecId: "string",
-	nullable: "boolean",
-	"typeParams?": "Record<string, unknown>",
-	"typeRef?": "string",
-	"default?": ColumnDefaultSchema,
-	"control?": ControlPolicySchema,
-	"valueSet?": ValueSetRefSchema
-}).narrow((col, ctx) => {
-	if (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe("a column with either typeParams or typeRef, not both");
-	return true;
-});
-/**
-* Codec-triple entry persisted under `storage.types[name]`. Carries an
-* enumerable literal `kind: 'codec-instance'` discriminator so the
-* polymorphic slot dispatch can distinguish codec triples from
-* class-instance kinds (e.g. `'postgres-enum'`) sharing the slot.
-*/
-const StorageTypeInstanceSchema = type.declare().type({
+/** Document-scoped `storage.types`: codec triples only. */
+const DocumentScopedStorageTypeSchema = type.declare().type({
 	kind: "'codec-instance'",
 	codecId: "string",
 	nativeType: "string",
 	"typeParams?": "Record<string, unknown>"
 });
 /**
-* Postgres native enum entry under `storage.namespaces[namespaceId].entries.type[name]`.
-* Document-scoped `storage.types` carries codec aliases only
-* (`DocumentScopedStorageTypeSchema`).
-*/
-const PostgresEnumTypeSchema = type({
-	kind: "'postgres-enum'",
-	"name?": "string",
-	"nativeType?": "string",
-	values: type.string.array().readonly(),
-	"control?": ControlPolicySchema
-});
-/** Document-scoped `storage.types`: codec triples only. */
-const DocumentScopedStorageTypeSchema = StorageTypeInstanceSchema;
-/**
-* Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
-* Carries a `kind: 'value-set'` discriminator (enumerable, survives JSON) and an
-* ordered `values` array of codec-encoded permitted values.
-*/
-const StorageValueSetSchema = type({
-	kind: "'value-set'",
-	values: type.string.array().readonly()
-});
-/**
 * Domain enum entry under `domain.namespaces[id].enum[name]`.
 * Carries the codec id and an ordered `members` array of `{name, value}` pairs.
 */
@@ -111,130 +59,55 @@ const ContractEnumSchema = type({
 	codecId: "string",
 	members: type({
 		name: "string",
-		value: "string"
+		value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
 	}).array().readonly()
 });
-const PrimaryKeySchema = type.declare().type({
-	columns: type.string.array().readonly(),
-	"name?": "string"
-});
-const UniqueConstraintSchema = type.declare().type({
-	columns: type.string.array().readonly(),
-	"name?": "string"
-});
-const IndexSchema = type({
-	columns: type.string.array().readonly(),
-	"name?": "string",
-	"type?": "string",
-	"options?": "Record<string, unknown>"
-});
-const ForeignKeyReferenceSchema = type({
-	"+": "reject",
-	namespaceId: "string",
-	tableName: "string",
-	columns: type.string.array().readonly(),
-	"spaceId?": "string"
-});
-const ForeignKeySourceSchema = type({
-	"+": "reject",
-	namespaceId: "string",
-	tableName: "string",
-	columns: type.string.array().readonly()
-});
-const ReferentialActionSchema = type.declare().type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
-const ForeignKeySchema = type.declare().type({
-	source: ForeignKeySourceSchema,
-	target: ForeignKeyReferenceSchema,
-	"name?": "string",
-	"onDelete?": ReferentialActionSchema,
-	"onUpdate?": ReferentialActionSchema,
-	constraint: "boolean",
-	index: "boolean"
-});
-const CheckConstraintSchema = type({
-	"+": "reject",
-	name: "string",
-	column: "string",
-	valueSet: ValueSetRefSchema
-});
-const StorageTableSchema = type({
-	"+": "reject",
-	columns: type({ "[string]": StorageColumnSchema }),
-	"primaryKey?": PrimaryKeySchema,
-	uniques: UniqueConstraintSchema.array().readonly(),
-	indexes: IndexSchema.array().readonly(),
-	foreignKeys: ForeignKeySchema.array().readonly(),
-	"control?": ControlPolicySchema,
-	"checks?": CheckConstraintSchema.array().readonly()
-});
 /**
-* Composes a hardcoded family `fallback` schema with optional
-* pack-contributed `fragments` keyed by the entry's `kind`
-* discriminator. The composition is **additive**, not substitutive:
-*
-* - No fragments registered → entries are validated by `fallback`
-*   alone (the unchanged baseline).
-* - An entry's `kind` matches `fallbackKind` AND a fragment for that
-*   kind is registered → the entry must pass **both** `fallback` and
-*   the fragment. This preserves family-owned invariants (e.g. the
-*   built-in `PostgresEnumType` shape) even when a pack contributes
-*   its own schema for the same kind.
-* - An entry's `kind` matches a registered fragment for some
-*   non-fallback kind → the fragment alone validates the entry.
-*   `fallback` is family-specific (validates a single hardcoded kind)
-*   and would reject any other kind, so it does not apply here.
-* - An entry's `kind` matches no fragment → fall through to
-*   `fallback`.
+* Derives a schema map from a descriptor map: maps each kind's key to its
+* `schema` field. Used by validation functions to validate entries.
 */
-function namespaceSlotEntrySchema(fallback, fallbackKind, fragments) {
-	if (fragments === void 0 || fragments.size === 0) return fallback;
-	return type("unknown").narrow((entry, ctx) => {
-		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return ctx.mustBe("an object");
-		const kind = entry.kind;
-		if (typeof kind === "string") {
-			const fragment = fragments.get(kind);
-			if (fragment !== void 0) {
-				if (kind === fallbackKind) {
-					const baseParsed = fallback(entry);
-					if (baseParsed instanceof type.errors) return ctx.reject({ expected: baseParsed.summary });
-				}
-				const parsed = fragment(entry);
-				if (parsed instanceof type.errors) return ctx.reject({ expected: parsed.summary });
-				return true;
-			}
-		}
-		const parsed = fallback(entry);
-		if (parsed instanceof type.errors) return ctx.reject({ expected: parsed.summary });
-		return true;
-	});
+function schemaViewOf(kinds) {
+	return new Map([...kinds].map(([k, d]) => [k, d.schema]));
 }
+const DEFAULT_SQL_KINDS = composeSqlEntityKinds();
 /**
 * Builds the per-namespace entry schema for `storage.namespaces[id]`.
-* Pack-contributed `validatorSchema` fragments — keyed by the
-* descriptor's `discriminator` — validate each entry by matching the
-* entry's `kind` field on the `'entries.type'` slot.
+*
+* Validation is descriptor-driven: the `kinds` map carries both the schema
+* (used here for structural validation) and the construct function (used at
+* hydration time). An unregistered key fails validation naming the kind and
+* the namespace id, so validation fails closed.
 */
-function createNamespaceEntrySchema(fragments) {
+function createNamespaceEntrySchema(kinds) {
+	const schemas = schemaViewOf(kinds);
+	const knownKinds = new Set(kinds.keys());
 	return type({
 		"+": "reject",
 		id: "string",
 		"kind?": "string",
-		entries: type({
-			"+": "reject",
-			"table?": type({ "[string]": StorageTableSchema }),
-			"type?": type({ "[string]": namespaceSlotEntrySchema(PostgresEnumTypeSchema, "postgres-enum", fragments) }),
-			"valueSet?": type({ "[string]": StorageValueSetSchema })
-		})
+		entries: "object"
+	}).narrow((ns, ctx) => {
+		if (!isPlainRecord(ns.entries)) return ctx.mustBe("an entries object");
+		for (const [key, innerMap] of Object.entries(ns.entries)) {
+			if (!knownKinds.has(key)) return ctx.reject({ expected: `entries key "${key}" in namespace "${ns.id}" is not a registered entity kind` });
+			if (!isPlainRecord(innerMap)) return ctx.reject({ expected: `entries["${key}"] in namespace "${ns.id}" must be an object` });
+			const entrySchema = blindCast(schemas.get(key));
+			for (const [, value] of Object.entries(innerMap)) {
+				const parsed = entrySchema(value);
+				if (parsed instanceof type.errors) return ctx.reject({ expected: parsed.summary });
+			}
+		}
+		return true;
 	});
 }
 /**
 * Builds the storage schema. Pack contributions reach the per-namespace
 * entry shape through {@link createNamespaceEntrySchema}; the
-* document-scoped `storage.types` slot (codec triples only) and the
+* document-scoped `storage.types` field (codec triples only) and the
 * storage hash stay family-shared.
 */
-function createSqlStorageSchema(fragments) {
-	const namespaceEntry = createNamespaceEntrySchema(fragments);
+function createSqlStorageSchema(kinds) {
+	const namespaceEntry = createNamespaceEntrySchema(kinds);
 	return type({
 		"+": "reject",
 		storageHash: "string",
@@ -242,17 +115,14 @@ function createSqlStorageSchema(fragments) {
 		"namespaces?": type({ "[string]": namespaceEntry })
 	});
 }
-const StorageSchema = createSqlStorageSchema();
+const StorageSchema = createSqlStorageSchema(DEFAULT_SQL_KINDS);
 function eachStorageTable(storage) {
-	return Object.entries(storage.namespaces).flatMap(([namespaceId, ns]) => Object.entries(ns.entries.table).map(([tableName, table]) => ({
+	return Object.entries(storage.namespaces).flatMap(([namespaceId, ns]) => Object.entries(ns.entries["table"] ?? {}).map(([tableName, table]) => ({
 		namespaceId,
 		tableName,
 		table
 	})));
 }
-function isPlainRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function findDuplicateValue(values) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const value of values) {
@@ -283,7 +153,7 @@ const ModelFieldSchema = type({
 	type: type("unknown").narrow((value, ctx) => isContractFieldType(value) ? true : ctx.mustBe("scalar, valueObject, or union field type")),
 	"many?": "true",
 	"dict?": "true",
-	"valueSet?": ValueSetRefSchema
+	"valueSet?": DomainEnumRefSchema
 });
 const ModelStorageSchema = type({
 	table: "string",
@@ -342,8 +212,8 @@ const ContractMetaSchema = type({ "[string]": "unknown" });
 * pack contributions through {@link createSqlStorageSchema}; the rest
 * of the contract envelope is family-shared.
 */
-function createSqlContractSchema(fragments) {
-	const storage = createSqlStorageSchema(fragments);
+function createSqlContractSchema(kinds) {
+	const storage = createSqlStorageSchema(kinds);
 	return type({
 		"+": "reject",
 		target: "string",
@@ -364,7 +234,7 @@ function createSqlContractSchema(fragments) {
 		"execution?": ExecutionSchema
 	});
 }
-const SqlContractSchema = createSqlContractSchema();
+const SqlContractSchema = createSqlContractSchema(DEFAULT_SQL_KINDS);
 /**
 * Validates the structural shape of SqlStorage using Arktype.
 *
@@ -525,7 +395,7 @@ function validateModelStorageReferences(contract) {
 			const storageNamespaceId = model.storage.namespaceId;
 			if (storageNamespaceId !== namespaceId) throw new ContractValidationError(`Model "${qualifiedName}" storage.namespaceId "${storageNamespaceId}" does not match domain namespace "${namespaceId}"`, "storage");
 			const storageTable = model.storage.table;
-			const rawTable = contract.storage.namespaces[storageNamespaceId]?.entries.table[storageTable];
+			const rawTable = contract.storage.namespaces[storageNamespaceId]?.entries.table?.[storageTable];
 			if (rawTable === void 0) throw new ContractValidationError(`Model "${qualifiedName}" references non-existent table "${storageNamespaceId}.${storageTable}"`, "storage");
 			const table = rawTable;
 			const columnNames = new Set(Object.keys(table.columns));
@@ -563,7 +433,7 @@ function validateSqlStorageConsistency(contract) {
 			if (fk.source.namespaceId !== namespaceId || fk.source.tableName !== tableName) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" contains foreignKey with mismatched source coordinates (${fk.source.namespaceId}.${fk.source.tableName})`, "storage");
 			for (const colName of fk.source.columns) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent column "${colName}"`, "storage");
 			if (fk.target.spaceId === void 0) {
-				const referencedRaw = contract.storage.namespaces[fk.target.namespaceId]?.entries.table[fk.target.tableName];
+				const referencedRaw = contract.storage.namespaces[fk.target.namespaceId]?.entries.table?.[fk.target.tableName];
 				if (referencedRaw === void 0) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent table "${fk.target.namespaceId}.${fk.target.tableName}"`, "storage");
 				const referencedColumnNames = new Set(Object.keys(referencedRaw.columns));
 				for (const colName of fk.target.columns) if (!referencedColumnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" foreignKey references non-existent column "${colName}" in table "${fk.target.tableName}"`, "storage");
@@ -593,9 +463,111 @@ function validateSqlContractFully(value, options) {
 	const semanticErrors = validateStorageSemantics(validated.storage);
 	if (semanticErrors.length > 0) throw new ContractValidationError(`Contract semantic validation failed: ${semanticErrors.join("; ")}`, "storage");
 	validateModelStorageReferences(validated);
+	validateRelationThroughConsistency(validated);
 	return validated;
 }
+/** Storage column lookup for through-consistency validation. */
+function lookupStorageColumn(contract, namespaceId, tableName, columnName) {
+	const rawTable = contract.storage.namespaces[namespaceId]?.entries.table?.[tableName];
+	if (rawTable === void 0) return;
+	return blindCast(rawTable).columns[columnName];
+}
+/**
+* Two storage columns share a type when their `nativeType` and `typeParams`
+* match. The contract is canonicalized, so `typeParams` key order is stable and
+* a JSON comparison is exact. `codecId` and `nullable` are intentionally not
+* compared: they do not change the database-level type that governs a join.
+*/
+function sameStorageType(a, b) {
+	return a.nativeType === b.nativeType && JSON.stringify(a.typeParams ?? null) === JSON.stringify(b.typeParams ?? null);
+}
+function describeColumnType(column) {
+	return column.typeParams === void 0 ? column.nativeType : `${column.nativeType} ${JSON.stringify(column.typeParams)}`;
+}
+/**
+* Validates one side of an N:M join: the junction columns and the model
+* columns they pair against positionally must be equal in number, exist in
+* their tables, and share the same storage type (`nativeType` + `typeParams`).
+* The junction's storage foreign keys already guarantee this for user-declared
+* FK constraints, but `through` is a logical descriptor never tied to them by
+* the rest of validation — and the TS builder accepts explicit join columns
+* without requiring a junction FK at all — so this checks the columns directly
+* against storage, one path regardless of how the junction was authored.
+*
+* Joined columns must be the *same* storage type, not merely compatible:
+* relying on implicit conversion (e.g. `text`↔`character`) is unsafe on writes
+* — `character(n)` space-padding makes such coercions non-associative — and no
+* ADR sanctions heterogeneous junction columns. Equality is the conservative
+* default; it can be relaxed deliberately if a real use case ever appears.
+*/
+function validateThroughJoinSide(input) {
+	const fail = (detail) => new ContractValidationError(`Many-to-many relation "${input.qualifiedName}" ${detail}`, "storage");
+	if (input.junctionColumns.length !== input.modelColumns.length) throw fail(`pairs ${input.junctionColumnsLabel} (${input.junctionColumns.length}) with ${input.modelColumnsLabel} (${input.modelColumns.length}) of differing length; they join positionally and must match.`);
+	for (const [index, junctionColumnName] of input.junctionColumns.entries()) {
+		const modelColumnRef = input.modelColumns[index];
+		if (modelColumnRef === void 0) continue;
+		const junctionColumn = lookupStorageColumn(input.contract, input.junctionNamespaceId, input.junctionTable, junctionColumnName);
+		if (junctionColumn === void 0) throw fail(`${input.junctionColumnsLabel} references column "${junctionColumnName}" absent from junction table "${input.junctionNamespaceId}.${input.junctionTable}".`);
+		const model = input.model;
+		if (model === void 0) continue;
+		let modelColumnName = modelColumnRef;
+		if (model.fieldToColumn !== void 0) {
+			const mapped = model.fieldToColumn[modelColumnRef];
+			if (mapped === void 0) throw fail(`${input.modelColumnsLabel} references field "${modelColumnRef}" absent from model on table "${model.namespaceId}.${model.table}".`);
+			modelColumnName = mapped.column;
+		}
+		const modelColumn = lookupStorageColumn(input.contract, model.namespaceId, model.table, modelColumnName);
+		if (modelColumn === void 0) throw fail(`${input.modelColumnsLabel} references column "${modelColumnName}" absent from table "${model.namespaceId}.${model.table}".`);
+		if (!sameStorageType(junctionColumn, modelColumn)) throw fail(`joins "${input.junctionTable}.${junctionColumnName}" (${describeColumnType(junctionColumn)}) with "${model.table}.${modelColumnName}" (${describeColumnType(modelColumn)}) of differing storage type; junction columns must match the type of the column they reference.`);
+	}
+}
+/**
+* Validates that every N:M relation's `through` descriptor is consistent with
+* the storage columns it joins: both join sides match in column count,
+* reference columns that exist in their tables, and pair columns of the same
+* storage type. Without this, a `through` that disagrees with storage surfaces
+* as a silently wrong JOIN at query time rather than a validation error here.
+*/
+function validateRelationThroughConsistency(contract) {
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespace.models)) for (const [relationName, relation] of Object.entries(model.relations)) {
+		if (relation.cardinality !== "N:M") continue;
+		const qualifiedName = `${namespaceId}.${modelName}.${relationName}`;
+		const { on, through } = relation;
+		const modelStorage = blindCast(model.storage);
+		validateThroughJoinSide({
+			contract,
+			qualifiedName,
+			modelColumns: on.localFields,
+			modelColumnsLabel: "on.localFields",
+			model: {
+				namespaceId,
+				table: modelStorage.table,
+				fieldToColumn: modelStorage.fields
+			},
+			junctionColumns: through.parentColumns,
+			junctionColumnsLabel: "through.parentColumns",
+			junctionNamespaceId: through.namespaceId,
+			junctionTable: through.table
+		});
+		const targetModel = relation.to.space === void 0 ? contract.domain.namespaces[relation.to.namespace]?.models[relation.to.model] : void 0;
+		const targetModelSide = targetModel === void 0 ? void 0 : {
+			namespaceId: relation.to.namespace,
+			table: blindCast(targetModel.storage).table
+		};
+		validateThroughJoinSide({
+			contract,
+			qualifiedName,
+			modelColumns: through.targetColumns,
+			modelColumnsLabel: "through.targetColumns",
+			...ifDefined("model", targetModelSide),
+			junctionColumns: through.childColumns,
+			junctionColumnsLabel: "through.childColumns",
+			junctionNamespaceId: through.namespaceId,
+			junctionTable: through.table
+		});
+	}
+}
 //#endregion
-export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, PostgresEnumTypeSchema, ReferentialActionSchema, StorageValueSetSchema, createNamespaceEntrySchema, createSqlContractSchema, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };
+export { CheckConstraintSchema, ColumnDefaultFunctionSchema, ColumnDefaultLiteralSchema, ColumnDefaultSchema, ContractEnumSchema, ForeignKeyReferenceSchema, ForeignKeySchema, ForeignKeySourceSchema, IndexSchema, ReferentialActionSchema, StorageTableSchema, StorageValueSetSchema, createNamespaceEntrySchema, createSqlContractSchema, createSqlStorageSchema, validateModel, validateModelStorageReferences, validateSqlContractFully, validateSqlStorageConsistency, validateStorage, validateStorageSemantics };
 
 //# sourceMappingURL=validators.mjs.map