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

package/dist/index.d.mts

@@ -1,10 +1,12 @@
 import { AuthoringContributions } from "@prisma-next/framework-components/authoring";
+import { SqlNamespaceTablesInput } from "@prisma-next/sql-contract/types";
 import { Result } from "@prisma-next/utils/result";
 import { ParsePslDocumentResult } from "@prisma-next/psl-parser";
 import { ControlMutationDefaults, ControlMutationDefaults as ControlMutationDefaults$1, DefaultFunctionLoweringContext, DefaultFunctionLoweringHandler, DefaultFunctionRegistry, DefaultFunctionRegistryEntry, MutationDefaultGeneratorDescriptor } from "@prisma-next/framework-components/control";
 import { ContractSourceDiagnostics } from "@prisma-next/config/config-types";
 import { Contract } from "@prisma-next/contract/types";
 import { ExtensionPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
+import { Namespace } from "@prisma-next/framework-components/ir";
 
 //#region src/psl-column-resolution.d.ts
 type ColumnDescriptor = {
@@ -23,6 +25,16 @@ interface InterpretPslDocumentToSqlContractInput {
   readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];
   readonly controlMutationDefaults?: ControlMutationDefaults$1;
   readonly authoringContributions?: AuthoringContributions;
+  /**
+   * Target-supplied `Namespace` factory threaded into
+   * `buildSqlContractFromDefinition` for the contract's
+   * `SqlStorage.namespaces` population. Required when the document
+   * contains any explicit `namespace { … }` block on Postgres; the
+   * single-namespace path (top-level declarations only) stays valid
+   * without the factory and falls back to the family
+   * `SqlUnboundNamespace` singleton.
+   */
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
 }
 declare function interpretPslDocumentToSqlContract(input: InterpretPslDocumentToSqlContractInput): Result<Contract, ContractSourceDiagnostics>;
 //#endregion

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;KAyCY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;UCyCP,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;AAAA;AAAA,iBAypCpB,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;KAyCY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;UC4CP,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;EDnDzB;;;;;;;AC4CX;;ED5CW,SC6DA,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBA+xCjD,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-D_zkd14G.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-fVwMptxi.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-D_zkd14G.mjs → interpreter-fVwMptxi.mjs}

@@ -1797,6 +1797,93 @@ function mapParserDiagnostics(document) {
 		span: diagnostic.span
 	}));
 }
+/**
+* Name of the framework-parser synthesised bucket for top-level
+* declarations. Re-declared here so the per-target dispatch does not
+* have to import from `@prisma-next/framework-components/psl-ast`
+* (which would cross a layer that the interpreter does not otherwise
+* import from). The value is part of the framework parser's contract;
+* if it changes there, the matching test in this package's
+* `interpreter.diagnostics.test.ts` flips first.
+*/
+const UNSPECIFIED_PSL_NAMESPACE_NAME = "__unspecified__";
+/**
+* Per-target namespace-block validation: walk the AST's namespace buckets and
+* emit diagnostics for syntactic constructs the target does not accept.
+*
+* - **SQLite** has no schema concept and rejects every explicit
+*   `namespace { … }` block. The implicit `__unspecified__` bucket
+*   (produced by the parser for top-level declarations outside any
+*   block) is the only namespace SQLite accepts.
+* - **Postgres** accepts every explicit block — `namespace unbound { … }`
+*   is the late-binding opt-in (lowers to the IR `__unbound__` slot in
+*   a follow-on commit), `namespace public { … }` reopen-merges with
+*   the implicit bucket, and any other name lowers to a named schema.
+*
+* Storage-side lowering of these buckets to IR namespace slots is not
+* yet wired; this helper closes only the diagnostic surface.
+*/
+/**
+* Per-target namespace lowering: map a PSL AST namespace bucket name to the
+* resolved IR namespace id (the key downstream consumers use against
+* `SqlStorage.namespaces`).
+*
+* - **Postgres**: an explicit `namespace unbound { … }` block lowers
+*   to the framework sentinel `__unbound__` — the slot whose binding
+*   the connection's `search_path` resolves at runtime. Every other
+*   explicit bucket name (e.g. `auth`, `public`) passes through as a
+*   named schema id. The implicit `__unspecified__` bucket — top-level
+*   declarations outside any `namespace { … }` block — leaves the
+*   coordinate unset; downstream consumers treat unset as the
+*   late-bound default, and TS / PSL authoring stay byte-identical
+*   on single-namespace contracts. (A future round will add a
+*   target-default-namespace surface so `__unspecified__` lowers to
+*   `public` consistently on both authoring paths.)
+* - **SQLite**: SQLite has no schema concept; every namespace
+*   collapses to the late-bound default. The namespace-block
+*   validation step (above) has already rejected any explicit
+*   `namespace { … }` block on SQLite, so the only bucket the
+*   lowering ever sees there is `__unspecified__`.
+*
+* Returns `undefined` for targets / bucket names with no explicit
+* namespaceId to assign — callers leave the model's `namespaceId`
+* slot empty (which means the late-bound default at the `StorageTable`
+* layer; emitted JSON omits the field).
+*/
+function resolveNamespaceIdForSqlTarget(input) {
+	if (input.targetId !== "postgres") return;
+	if (input.bucketName === UNSPECIFIED_PSL_NAMESPACE_NAME) return;
+	if (input.bucketName === "unbound") return "__unbound__";
+	return input.bucketName;
+}
+function validateNamespaceBlocksForSqlTarget(input) {
+	if (input.targetId === "sqlite") {
+		for (const namespace of input.namespaces) {
+			if (namespace.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+				message: `SQLite does not support \`namespace ${namespace.name} { … }\` blocks (SQLite has no schema concept; declare models at the document top level instead).`,
+				sourceId: input.sourceId,
+				span: namespace.span
+			});
+		}
+		return;
+	}
+	if (input.targetId === "postgres") {
+		const namedBlocks = input.namespaces.filter((ns) => ns.name !== UNSPECIFIED_PSL_NAMESPACE_NAME);
+		const hasUnbound = namedBlocks.some((ns) => ns.name === "unbound");
+		const hasSibling = namedBlocks.some((ns) => ns.name !== "unbound");
+		if (hasUnbound && hasSibling) {
+			const unboundBlock = namedBlocks.find((ns) => ns.name === "unbound");
+			input.diagnostics.push({
+				code: "PSL_RESERVED_NAMESPACE_NAME",
+				message: "Namespace \"unbound\" is reserved for the late-binding sentinel mapping and cannot appear alongside other named namespace blocks. Use `namespace unbound { … }` alone (no sibling named namespaces) for late-binding multi-tenant contracts.",
+				sourceId: input.sourceId,
+				...ifDefined("span", unboundBlock?.span)
+			});
+		}
+	}
+}
 function processEnumDeclarations(input) {
 	const storageTypes = {};
 	const enumTypeDescriptors = /* @__PURE__ */ new Map();
@@ -2293,15 +2380,28 @@ function buildModelNodeFromPsl(input) {
 	const resultFkRelationMetadata = [];
 	for (const relationAttribute of relationAttributes) {
 		if (relationAttribute.field.list) continue;
-		if (!input.modelNames.has(relationAttribute.field.typeName)) {
+		const { typeName: fieldTypeName, typeNamespaceId: fieldTypeNamespaceId } = relationAttribute.field;
+		const qualifiedTypeName = fieldTypeNamespaceId ? `${fieldTypeNamespaceId}.${fieldTypeName}` : fieldTypeName;
+		if (!input.modelNames.has(fieldTypeName)) {
 			diagnostics.push({
 				code: "PSL_INVALID_RELATION_TARGET",
-				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
 				sourceId,
 				span: relationAttribute.field.span
 			});
 			continue;
 		}
+		if (fieldTypeNamespaceId !== void 0) {
+			if (input.modelNamespaceIds.get(fieldTypeName) !== (fieldTypeNamespaceId === "unbound" ? "__unbound__" : fieldTypeNamespaceId)) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_TARGET",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
+					sourceId,
+					span: relationAttribute.field.span
+				});
+				continue;
+			}
+		}
 		const parsedRelation = parseRelationAttribute({
 			attribute: relationAttribute.relation,
 			modelName: model.name,
@@ -2319,11 +2419,11 @@ function buildModelNodeFromPsl(input) {
 			});
 			continue;
 		}
-		const targetMapping = input.modelMappings.get(relationAttribute.field.typeName);
+		const targetMapping = input.modelMappings.get(fieldTypeName);
 		if (!targetMapping) {
 			diagnostics.push({
 				code: "PSL_INVALID_RELATION_TARGET",
-				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
 				sourceId,
 				span: relationAttribute.field.span
 			});
@@ -2376,12 +2476,14 @@ function buildModelNodeFromPsl(input) {
 			span: relationAttribute.field.span,
 			diagnostics
 		}) : void 0;
+		const targetNamespaceId = input.modelNamespaceIds.get(targetMapping.model.name);
 		foreignKeyNodes.push({
 			columns: localColumns,
 			references: {
 				model: targetMapping.model.name,
 				table: targetMapping.tableName,
-				columns: referencedColumns
+				columns: referencedColumns,
+				...ifDefined("namespaceId", targetNamespaceId)
 			},
 			...ifDefined("name", parsedRelation.constraintName),
 			...ifDefined("onDelete", onDelete),
@@ -2697,9 +2799,37 @@ function interpretPslDocumentToSqlContract(input) {
 		}]
 	});
 	const diagnostics = mapParserDiagnostics(input.document);
-	const models = input.document.ast.models ?? [];
-	const enums = input.document.ast.enums ?? [];
-	const compositeTypes = input.document.ast.compositeTypes ?? [];
+	validateNamespaceBlocksForSqlTarget({
+		namespaces: input.document.ast.namespaces,
+		targetId: input.target.targetId,
+		sourceId,
+		diagnostics
+	});
+	const models = [];
+	const modelNamespaceIds = /* @__PURE__ */ new Map();
+	for (const namespace of input.document.ast.namespaces) {
+		const resolvedNamespaceId = resolveNamespaceIdForSqlTarget({
+			bucketName: namespace.name,
+			targetId: input.target.targetId
+		});
+		for (const model of namespace.models) {
+			models.push(model);
+			if (resolvedNamespaceId !== void 0) modelNamespaceIds.set(model.name, resolvedNamespaceId);
+		}
+	}
+	const topLevelEnums = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => ns.enums);
+	const namedNamespaceEnumsByNsId = /* @__PURE__ */ new Map();
+	for (const ns of input.document.ast.namespaces) {
+		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME || ns.enums.length === 0) continue;
+		const resolvedId = resolveNamespaceIdForSqlTarget({
+			bucketName: ns.name,
+			targetId: input.target.targetId
+		});
+		if (resolvedId === void 0) continue;
+		const existing = namedNamespaceEnumsByNsId.get(resolvedId) ?? [];
+		namedNamespaceEnumsByNsId.set(resolvedId, [...existing, ...ns.enums]);
+	}
+	const compositeTypes = input.document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
 	const modelNames = new Set(models.map((model) => model.name));
 	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
@@ -2707,20 +2837,37 @@ function interpretPslDocumentToSqlContract(input) {
 	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
 	const generatorDescriptorById = /* @__PURE__ */ new Map();
 	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
+	const enumEntityDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
+	const enumEntityContext = {
+		family: input.target.familyId,
+		target: input.target.targetId
+	};
 	const enumResult = processEnumDeclarations({
-		enums,
+		enums: topLevelEnums,
 		sourceId,
-		enumEntityDescriptor: getAuthoringEntity(input.authoringContributions, ["enum"]),
-		entityContext: {
-			family: input.target.familyId,
-			target: input.target.targetId
-		},
+		enumEntityDescriptor,
+		entityContext: enumEntityContext,
 		diagnostics
 	});
+	const allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
+	const namespaceEnumStorageTypes = {};
+	for (const [nsId, nsEnums] of namedNamespaceEnumsByNsId) {
+		const nsEnumResult = processEnumDeclarations({
+			enums: nsEnums,
+			sourceId,
+			enumEntityDescriptor,
+			entityContext: enumEntityContext,
+			diagnostics
+		});
+		for (const [name, descriptor] of nsEnumResult.enumTypeDescriptors) allEnumTypeDescriptors.set(name, descriptor);
+		const nsEntries = {};
+		for (const [name, entry] of Object.entries(nsEnumResult.storageTypes)) if (isPostgresEnumStorageEntry(entry)) nsEntries[name] = entry;
+		if (Object.keys(nsEntries).length > 0) namespaceEnumStorageTypes[nsId] = nsEntries;
+	}
 	const namedTypeResult = resolveNamedTypeDeclarations({
 		declarations: input.document.ast.types?.declarations ?? [],
 		sourceId,
-		enumTypeDescriptors: enumResult.enumTypeDescriptors,
+		enumTypeDescriptors: allEnumTypeDescriptors,
 		scalarTypeDescriptors: input.scalarTypeDescriptors,
 		composedExtensions,
 		familyId: input.target.familyId,
@@ -2746,7 +2893,7 @@ function interpretPslDocumentToSqlContract(input) {
 			modelMappings,
 			modelNames,
 			compositeTypeNames,
-			enumTypeDescriptors: enumResult.enumTypeDescriptors,
+			enumTypeDescriptors: allEnumTypeDescriptors,
 			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
 			composedExtensions,
 			familyId: input.target.familyId,
@@ -2756,9 +2903,14 @@ function interpretPslDocumentToSqlContract(input) {
 			generatorDescriptorById,
 			scalarTypeDescriptors: input.scalarTypeDescriptors,
 			sourceId,
-			diagnostics
+			diagnostics,
+			modelNamespaceIds
 		});
-		modelNodes.push(result.modelNode);
+		const resolvedNamespaceId = modelNamespaceIds.get(model.name);
+		modelNodes.push(resolvedNamespaceId !== void 0 ? {
+			...result.modelNode,
+			namespaceId: resolvedNamespaceId
+		} : result.modelNode);
 		fkRelationMetadata.push(...result.fkRelationMetadata);
 		backrelationCandidates.push(...result.backrelationCandidates);
 		modelResolvedFields.set(model.name, result.resolvedFields);
@@ -2774,7 +2926,7 @@ function interpretPslDocumentToSqlContract(input) {
 	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, sourceId, diagnostics);
 	const valueObjects = buildValueObjects({
 		compositeTypes,
-		enumTypeDescriptors: enumResult.enumTypeDescriptors,
+		enumTypeDescriptors: allEnumTypeDescriptors,
 		namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
 		scalarTypeDescriptors: input.scalarTypeDescriptors,
 		composedExtensions,
@@ -2792,6 +2944,8 @@ function interpretPslDocumentToSqlContract(input) {
 		target: input.target,
 		...ifDefined("extensionPacks", buildComposedExtensionPackRefs(input.target, [...composedExtensions].sort(compareStrings), input.composedExtensionPackRefs)),
 		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
+		...Object.keys(namespaceEnumStorageTypes).length > 0 ? { namespaceTypes: namespaceEnumStorageTypes } : {},
+		...ifDefined("createNamespace", input.createNamespace),
 		models: modelNodes.map((model) => ({
 			...model,
 			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
@@ -2816,4 +2970,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-D_zkd14G.mjs.map
+//# sourceMappingURL=interpreter-fVwMptxi.mjs.map