@prisma-next/sql-contract-ts 0.9.0 → 0.10.0

package/dist/contract-builder.mjs

@@ -1,9 +1,9 @@
 import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
 import { coreHash, isColumnDefault } from "@prisma-next/contract/types";
-import { UNSPECIFIED_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { validateIndexTypes } from "@prisma-next/sql-contract/index-type-validation";
 import { createIndexTypeRegistry } from "@prisma-next/sql-contract/index-types";
-import { SqlStorage, SqlUnspecifiedNamespace, applyFkDefaults, isPostgresEnumStorageEntry, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { SqlStorage, StorageTable, applyFkDefaults, isPostgresEnumStorageEntry, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { validateStorageSemantics } from "@prisma-next/sql-contract/validators";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { createEntityHelpersFromNamespace } from "@prisma-next/contract-authoring";
@@ -95,11 +95,50 @@ function buildDomainField(field, column) {
 		...field.many ? { many: true } : {}
 	};
 }
+function collectStorageNamespaceCoordinateIds(definition) {
+	const ids = /* @__PURE__ */ new Set();
+	ids.add(UNBOUND_NAMESPACE_ID);
+	for (const id of definition.namespaces ?? []) if (id.length > 0) ids.add(id);
+	for (const model of definition.models) if (model.namespaceId !== void 0 && model.namespaceId.length > 0) ids.add(model.namespaceId);
+	return ids;
+}
+const POSTGRES_ENUM_NAMESPACE_ID = "public";
+function partitionStorageTypesForTarget(targetId, types, namespaceTypes) {
+	const documentTypes = {};
+	const namespaceEnumTypesById = {};
+	for (const [name, entry] of Object.entries(types)) {
+		if (isPostgresEnumStorageEntry(entry)) {
+			if (targetId !== "postgres") throw new Error(`buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`);
+			let slot = namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID];
+			if (slot === void 0) {
+				slot = {};
+				namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID] = slot;
+			}
+			slot[name] = entry;
+			continue;
+		}
+		documentTypes[name] = entry;
+	}
+	if (namespaceTypes !== void 0) for (const [nsId, enumsInNs] of Object.entries(namespaceTypes)) for (const [name, entry] of Object.entries(enumsInNs)) {
+		if (targetId !== "postgres") throw new Error(`buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`);
+		let slot = namespaceEnumTypesById[nsId];
+		if (slot === void 0) {
+			slot = {};
+			namespaceEnumTypesById[nsId] = slot;
+		}
+		slot[name] = entry;
+	}
+	return {
+		documentTypes,
+		namespaceEnumTypesById
+	};
+}
 function buildSqlContractFromDefinition(definition, codecLookup) {
 	const target = definition.target.targetId;
 	const targetFamily = "sql";
 	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
-	const storageTables = {};
+	const tablesByNamespace = {};
+	const tableNameToNamespaceId = /* @__PURE__ */ new Map();
 	const executionDefaults = [];
 	const models = {};
 	const roots = {};
@@ -138,13 +177,20 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 				...ifDefined("onUpdate", executionDefaultPhases.onUpdate)
 			});
 		}
+		const namespaceId = semanticModel.namespaceId !== void 0 && semanticModel.namespaceId.length > 0 ? semanticModel.namespaceId : UNBOUND_NAMESPACE_ID;
 		const foreignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
 			const targetModel = assertKnownTargetModel(modelsByName, semanticModel.modelName, fk.references.model, "Foreign key");
 			assertTargetTableMatches(semanticModel.modelName, targetModel, fk.references.table, "Foreign key");
+			const targetNamespaceId = fk.references.namespaceId ?? (targetModel.namespaceId !== void 0 && targetModel.namespaceId.length > 0 ? targetModel.namespaceId : UNBOUND_NAMESPACE_ID);
 			return {
-				columns: fk.columns,
-				references: {
-					table: fk.references.table,
+				source: {
+					namespaceId,
+					tableName,
+					columns: fk.columns
+				},
+				target: {
+					namespaceId: targetNamespaceId,
+					tableName: fk.references.table,
 					columns: fk.references.columns
 				},
 				...applyFkDefaults({
@@ -156,7 +202,10 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 				...ifDefined("onUpdate", fk.onUpdate)
 			};
 		});
-		storageTables[tableName] = {
+		const existingNs = tableNameToNamespaceId.get(tableName);
+		if (existingNs !== void 0 && existingNs !== namespaceId) throw new Error(`buildSqlContractFromDefinition: table "${tableName}" is mapped in namespace "${namespaceId}" but already exists in namespace "${existingNs}".`);
+		tableNameToNamespaceId.set(tableName, namespaceId);
+		const tableInput = {
 			columns,
 			uniques: (semanticModel.uniques ?? []).map((u) => ({
 				columns: u.columns,
@@ -174,6 +223,13 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 				...ifDefined("name", semanticModel.id.name)
 			} } : {}
 		};
+		let nsTables = tablesByNamespace[namespaceId];
+		if (nsTables === void 0) {
+			nsTables = {};
+			tablesByNamespace[namespaceId] = nsTables;
+		}
+		if (nsTables[tableName] !== void 0) throw new Error(`buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`);
+		nsTables[tableName] = new StorageTable(tableInput);
 		const storageFields = {};
 		for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
 		const columnToField = new Map(Object.entries(fieldToColumn).map(([field, col]) => [col, field]));
@@ -207,18 +263,29 @@ function buildSqlContractFromDefinition(definition, codecLookup) {
 		};
 	}
 	const rawStorageTypes = definition.storageTypes ?? {};
+	const { documentTypes, namespaceEnumTypesById } = partitionStorageTypesForTarget(target, Object.fromEntries(Object.entries(rawStorageTypes).map(([name, entry]) => {
+		if (isPostgresEnumStorageEntry(entry)) return [name, entry];
+		if (entry.kind === "codec-instance") return [name, entry];
+		return [name, toStorageTypeInstance({
+			codecId: entry.codecId,
+			nativeType: entry.nativeType,
+			typeParams: entry.typeParams ?? {}
+		})];
+	})), definition.namespaceTypes);
+	const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
+	for (const id of Object.keys(namespaceEnumTypesById)) namespaceCoordinateIds.add(id);
+	const { createNamespace } = definition;
 	const storageWithoutHash = {
-		tables: storageTables,
-		types: Object.fromEntries(Object.entries(rawStorageTypes).map(([name, entry]) => {
-			if (isPostgresEnumStorageEntry(entry)) return [name, entry];
-			if (entry.kind === "codec-instance") return [name, entry];
-			return [name, toStorageTypeInstance({
-				codecId: entry.codecId,
-				nativeType: entry.nativeType,
-				typeParams: entry.typeParams ?? {}
-			})];
-		})),
-		namespaces: { [UNSPECIFIED_NAMESPACE_ID]: SqlUnspecifiedNamespace.instance }
+		types: documentTypes,
+		namespaces: Object.fromEntries([...namespaceCoordinateIds].sort().map((id) => {
+			const enumTypes = namespaceEnumTypesById[id];
+			const nsInput = {
+				id,
+				tables: tablesByNamespace[id] ?? {},
+				...ifDefined("types", enumTypes)
+			};
+			return [id, createNamespace ? createNamespace(nsInput) : nsInput];
+		}))
 	};
 	const storageHash = definition.storageHash ? coreHash(definition.storageHash) : computeStorageHash({
 		target,
@@ -675,6 +742,7 @@ function model(modelNameOrInput, maybeInput) {
 	if (!input) throw new Error("model(\"ModelName\", ...) requires a model definition.");
 	return new ContractModelBuilder({
 		...typeof modelNameOrInput === "string" ? { modelName: modelNameOrInput } : {},
+		...input.namespace !== void 0 ? { namespace: input.namespace } : {},
 		fields: input.fields,
 		relations: input.relations ?? {}
 	});
@@ -1210,6 +1278,7 @@ function resolveModelNode(spec, allSpecs, storageTypes, storageTypeReverseLookup
 	return {
 		modelName: spec.modelName,
 		tableName: spec.tableName,
+		...spec.namespace !== void 0 ? { namespaceId: spec.namespace } : {},
 		fields,
 		...idConstraint ? { id: {
 			columns: mapFieldNamesToColumnNames(spec.modelName, idConstraint.fields, spec.fieldToColumn),
@@ -1254,6 +1323,7 @@ function collectRuntimeModelSpecs(definition) {
 		modelSpecs.set(modelName, {
 			modelName,
 			tableName,
+			namespace: modelDefinition.stageOne.namespace,
 			fieldBuilders,
 			fieldToColumn,
 			relations: modelDefinition.stageOne.relations,
@@ -1283,6 +1353,8 @@ function buildContractDefinition(definition) {
 		...definition.storageHash ? { storageHash: definition.storageHash } : {},
 		...definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {},
 		...Object.keys(collection.storageTypes).length > 0 ? { storageTypes: collection.storageTypes } : {},
+		...definition.namespaces ? { namespaces: definition.namespaces } : {},
+		...definition.createNamespace ? { createNamespace: definition.createNamespace } : {},
 		models
 	};
 }
@@ -1292,6 +1364,69 @@ function validateTargetPackRef(family, target) {
 	if (family.familyId !== "sql") throw new Error(`defineContract only accepts SQL family packs. Received family "${family.familyId}".`);
 	if (target.familyId !== family.familyId) throw new Error(`target pack "${target.id}" targets family "${target.familyId}" but contract family is "${family.familyId}".`);
 }
+/**
+* Per-target reserved namespace names enforced by `defineContract` for
+* SQL family contracts. Two categories:
+*
+* 1. **IR sentinels** (`__unbound__`, `__unspecified__`) — reserved on
+*    every SQL target. The double-underscore decoration marks them as
+*    framework-reserved coordinates; user code must not declare them
+*    explicitly.
+* 2. **Target-specific PSL keywords** — Postgres reserves the bare
+*    `unbound` identifier for the late-binding opt-in
+*    (`namespace unbound { … }`) so the TS surface must reject it from
+*    `defineContract({ namespaces })` lists. SQLite has no schema
+*    concept and rejects every non-empty namespaces list outright;
+*    callers should declare `namespaces: []` or omit the field.
+*/
+function validateNamespaceDeclarations(target, namespaces) {
+	if (!namespaces) return;
+	if (target.targetId === "sqlite" && namespaces.length > 0) throw new Error(`defineContract: SQLite contracts cannot declare namespaces (SQLite has no schema concept; emitted DDL is always unqualified). Received namespaces: [${namespaces.map((name) => `"${name}"`).join(", ")}].`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const namespace of namespaces) {
+		if (namespace.length === 0) throw new Error("defineContract: namespace names cannot be empty.");
+		if (namespace.trim().length === 0) throw new Error(`defineContract: namespace name "${namespace}" cannot be whitespace-only.`);
+		if (namespace === "__unbound__" || namespace === "__unspecified__") throw new Error(`defineContract: namespace name "${namespace}" is a reserved IR sentinel and cannot appear in the declared namespaces list.`);
+		if (target.targetId === "postgres" && namespace === "unbound") throw new Error(`defineContract: namespace name "unbound" is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead of declaring it as a regular schema).`);
+		if (seen.has(namespace)) throw new Error(`defineContract: namespaces list contains duplicate entry "${namespace}".`);
+		seen.add(namespace);
+	}
+}
+/**
+* Per-model `namespace` validation paired with
+* {@link validateNamespaceDeclarations}. Mirrors the reserved-name
+* rules so the per-model surface stays consistent with the contract-
+* level surface:
+*
+* - `__unbound__` / `__unspecified__` — reserved IR sentinels on
+*   every SQL target.
+* - `unbound` on Postgres — reserved for the PSL
+*   `namespace unbound { … }` opt-in.
+*
+* Additionally enforces that each per-model `namespace` either
+* references an entry in the contract's declared `namespaces` list or
+* names the Postgres late-binding keyword (`unbound`) — the latter is
+* not a "declared namespace" but is a legal opt-in only via PSL today,
+* so the TS surface also rejects it on the per-model side and points
+* authors at the PSL `namespace unbound { … }` block.
+*
+* The SQLite per-model `namespace` field is rejected outright (SQLite
+* has no schema concept).
+*/
+function validatePerModelNamespaces(target, namespaces, models) {
+	const declaredNamespaces = new Set(namespaces ?? []);
+	for (const [modelKey, modelBuilder] of Object.entries(models)) {
+		const perModelNamespace = modelBuilder.stageOne.namespace;
+		if (perModelNamespace === void 0) continue;
+		if (target.targetId === "sqlite") throw new Error(`defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but the target is SQLite (SQLite has no schema concept; remove the per-model \`namespace\` field).`);
+		if (perModelNamespace === "__unbound__" || perModelNamespace === "__unspecified__") throw new Error(`defineContract: model "${modelKey}" sets \`namespace: "${perModelNamespace}"\` but that name is a reserved IR sentinel and cannot appear in user code.`);
+		if (target.targetId === "postgres" && perModelNamespace === "unbound") throw new Error(`defineContract: model "${modelKey}" sets \`namespace: "unbound"\` but that name is reserved by Postgres for the late-binding opt-in (use \`namespace unbound { … }\` in PSL instead — there is no equivalent surface in the TS builder today).`);
+		if (!declaredNamespaces.has(perModelNamespace)) {
+			const hint = declaredNamespaces.size > 0 ? ` Declared namespaces: [${[...declaredNamespaces].map((name) => `"${name}"`).join(", ")}].` : " The contract does not declare any namespaces; add `namespaces: [\"…\"]` to `defineContract` first.";
+			throw new Error(`defineContract: model "${modelKey}" references namespace "${perModelNamespace}" but that name does not appear in the contract's declared \`namespaces\` list.${hint}`);
+		}
+	}
+}
 function validateExtensionPackRefs(target, extensionPacks) {
 	if (!extensionPacks) return;
 	for (const packRef of Object.values(extensionPacks)) {
@@ -1303,6 +1438,8 @@ function validateExtensionPackRefs(target, extensionPacks) {
 function buildContractFromDsl(definition) {
 	validateTargetPackRef(definition.family, definition.target);
 	validateExtensionPackRefs(definition.target, definition.extensionPacks);
+	validateNamespaceDeclarations(definition.target, definition.namespaces);
+	validatePerModelNamespaces(definition.target, definition.namespaces, definition.models ?? {});
 	return buildSqlContractFromDefinition(buildContractDefinition(definition), definition.codecLookup);
 }
 function defineContract(definition, factory) {