@prisma/orm-family-sql 8.0.0-rc.21-dev.13 → 8.0.0-rc.21-dev.14

package/dist/contract-prisma7__provider.mjs

@@ -5,8 +5,9 @@ import { h as storedSqlText } from "./sql-expression-CKgKznXS.mjs";
 import { p as validateSqlStorageConsistency, u as validateModelStorageReferences } from "./validators-qcQteqs2.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-HVaxhALD.mjs";
 import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-D__agoFB-Boa1MHcA.mjs";
+import { o as composedExtensionPackRefs } from "./contract-builder-Y2rB4xMf.mjs";
 import { c as instantiateFieldTypeConstructor, i as defaultFunctionCall, v as readDataTypeDefault } from "./psl-field-resolution-BW2_FOb9-DxqR43fo.mjs";
-import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-ChvVEijY-FeJngsog.mjs";
+import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-6czZvMo_-C2_2jQGn.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { entryForTag, getAuthoringTypeChoice, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructorFromValues, resolveAuthoringTypeChoice } from "@prisma/orm-framework/components/authoring";
@@ -501,6 +502,135 @@ function dbgeneratedDefault(callArgs, unknown, span) {
 		onCreate: void 0
 	};
 }
+const PRISMA7_EXTENSION_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function entryValue(source, key) {
+	return source.block.entries.find((entry) => entry.key()?.name() === key);
+}
+function stringOf(expression) {
+	return expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+}
+function previewFeatures(generators) {
+	const features = /* @__PURE__ */ new Set();
+	for (const generator of generators) {
+		const value = entryValue(generator, "previewFeatures")?.value();
+		const list = value === void 0 ? void 0 : ArrayLiteralAst.cast(value.syntax);
+		for (const element of list?.elements() ?? []) {
+			const feature = stringOf(element);
+			if (feature !== void 0) features.add(feature);
+		}
+	}
+	return features;
+}
+function text(node) {
+	return printSyntax(node.syntax).trim();
+}
+/**
+* The datasource `extensions` list: each listed extension no composed pack's contract declares, in the namespace of its `schema:` argument or the default one. An extension a composed pack's contract declares is left to that pack; one the binding names a pack for that is not composed, and arguments the contract cannot describe, are reported.
+*/
+function readDatasourceExtensions(input) {
+	const { datasource, binding, diagnostics } = input;
+	const { sourceId, sources } = datasource;
+	const entry = entryValue(datasource, "extensions");
+	const value = entry?.value();
+	if (entry === void 0 || value === void 0) return [];
+	if (!previewFeatures(input.generators).has(binding.previewFeature)) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_EXTENSIONS_PREVIEW_FEATURE_MISSING", `The datasource lists extensions, which Prisma 7 reads only with the "${binding.previewFeature}" preview feature, so Prisma 7 refuses this schema too. Add "${binding.previewFeature}" to previewFeatures in the generator block.`, sourceId, nodePslSpan(entry.syntax, sources)));
+		return [];
+	}
+	const invalid = (what, span) => {
+		diagnostics.push({
+			code: "PSL_INVALID_EXTENSION_BLOCK_MEMBER",
+			message: `datasource "${datasource.block.name}": ${what}, and Prisma 7 refuses it too. List each extension by name, such as extensions = [pg_trgm].`,
+			sourceId,
+			span
+		});
+	};
+	const list = ArrayLiteralAst.cast(value.syntax);
+	if (list === void 0) {
+		invalid(`extensions is ${text(value)}, which is not a list`, nodePslSpan(value.syntax, sources));
+		return [];
+	}
+	const extensions = /* @__PURE__ */ new Map();
+	for (const element of list.elements()) {
+		const span = nodePslSpan(element.syntax, sources);
+		const call = FunctionCallAst.cast(element.syntax);
+		if (dottedPathsIn(element).length > 0) continue;
+		const name = call === void 0 ? IdentifierAst.cast(element.syntax)?.name() : call.path()[0];
+		if (name === void 0) {
+			invalid(`extensions lists ${text(element)}, which is not an extension name`, span);
+			continue;
+		}
+		const schema = readArguments(name, call, input);
+		const namespaceId = schema ?? input.defaultNamespaceId;
+		const declaring = input.declaringPack(name);
+		if (declaring !== void 0) {
+			if (declaring.namespaceId !== namespaceId) {
+				const packNamespace = declaring.namespaceId;
+				const edit = schema === void 0 ? `write ${name}(schema: "${packNamespace}")` : packNamespace === input.defaultNamespaceId ? `remove schema: "${schema}"` : `write schema: "${packNamespace}"`;
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_EXTENSION_SCHEMA_MISMATCH", `Extension "${name}": the "${declaring.packId}" extension pack declares it in schema "${packNamespace}", so Prisma 8 expects it there, but this entry puts it in schema "${namespaceId}". Moving it is a database change the pack does not make: move it with ALTER EXTENSION "${name}" SET SCHEMA "${packNamespace}", then ${edit}.`, sourceId, span));
+			}
+			continue;
+		}
+		const pack = Object.hasOwn(binding.packs, name) ? binding.packs[name] : void 0;
+		if (pack !== void 0 && !input.composedExtensions.has(pack.id)) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_EXTENSION_PACK_MISSING", `Extension "${name}" is declared by the "${pack.id}" extension pack, which is not available. Add the pack to extensions in prisma.config.ts: import ${pack.importName} from '${pack.importPath}', then extensions: [${pack.importName}].`, sourceId, span));
+			continue;
+		}
+		if (!extensions.has(name)) extensions.set(name, {
+			name,
+			namespaceId,
+			span,
+			sourceId
+		});
+	}
+	return [...extensions.values()];
+}
+/** Reports each argument the contract cannot describe; returns the `schema:` argument's value. */
+function readArguments(name, call, input) {
+	if (call === void 0) return void 0;
+	const { sourceId, sources } = input.datasource;
+	const args = [...call.args()];
+	const refuse = (arg, message) => {
+		input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_EXTENSION_ARGUMENT_UNSUPPORTED", `Extension "${name}": ${message}`, sourceId, nodePslSpan(arg.syntax, sources)));
+	};
+	let schema;
+	for (const arg of args) {
+		const argName = arg.name()?.name();
+		const argValue = stringOf(arg.value());
+		if (argName === void 0) {
+			refuse(arg, `the argument ${text(arg)} has no name, and Prisma 7 refuses it too. Remove it.`);
+			continue;
+		}
+		if (argValue === void 0 && [
+			"schema",
+			"version",
+			"map"
+		].includes(argName)) {
+			refuse(arg, `${argName} must be a string, and Prisma 7 refuses ${text(arg)} too.`);
+			continue;
+		}
+		switch (argName) {
+			case "schema":
+				schema = argValue;
+				break;
+			case "version":
+				refuse(arg, `the version argument is not supported, because the contract does not record an extension's version. Remove ${text(arg)}; Prisma 7's next migration is then empty.`);
+				break;
+			case "map": {
+				if (argValue === void 0 || !PRISMA7_EXTENSION_NAME.test(argValue)) {
+					refuse(arg, `the map argument is not supported, and Prisma 7 can write the name "${argValue}" only with map, so Prisma 8 cannot read this schema until it reads map.`);
+					break;
+				}
+				const others = args.filter((other) => other !== arg).map(text);
+				const replacement = others.length === 0 ? argValue : `${argValue}(${others.join(", ")})`;
+				refuse(arg, `the map argument is not supported. Replace ${text(call)} with ${replacement}, the extension's name in the database; Prisma 7's next migration is then empty.`);
+				break;
+			}
+			default: refuse(arg, `argument "${argName}" is not known, and Prisma 7 refuses it too. Remove it.`);
+		}
+	}
+	return schema;
+}
 function prisma7ScalarMapping(typeMap, scalar) {
 	return Object.hasOwn(typeMap.scalars, scalar) ? typeMap.scalars[scalar] : void 0;
 }
@@ -1145,6 +1275,7 @@ function interpretPrisma7Documents(input) {
 	const diagnostics = [...input.seedDiagnostics];
 	const { defaultNamespaceId } = input;
 	const datasources = [];
+	const generators = [];
 	const enumBlocks = [];
 	const models = [];
 	const declaredNames = /* @__PURE__ */ new Map();
@@ -1201,6 +1332,12 @@ function interpretPrisma7Documents(input) {
 				reportDottedBlockValues(block, sourceId, sources, diagnostics);
 				break;
 			case "generator":
+				generators.push({
+					block,
+					sourceId,
+					sources,
+					sourceFile
+				});
 				reportDottedBlockValues(block, sourceId, sources, diagnostics);
 				break;
 			case "enum":
@@ -1248,6 +1385,16 @@ function interpretPrisma7Documents(input) {
 		if (declaration !== void 0) enums.set(declaration.name, declaration);
 	}
 	const namespaceEntities = lowerNativeEnums(enums, input, diagnostics);
+	const [datasource] = datasources;
+	if (datasource !== void 0) lowerDatasourceExtensions(readDatasourceExtensions({
+		datasource,
+		generators,
+		binding: binding.extensions,
+		composedExtensions: new Set(input.composedExtensions),
+		declaringPack: (extensionName) => packDeclaring(input.composedExtensionContracts, binding.extensions.entityKind, extensionName),
+		defaultNamespaceId,
+		diagnostics
+	}), namespaceEntities, input, diagnostics);
 	const modelNames = new Set(models.map((model) => model.symbol.name));
 	const ignoredModels = new Set(models.filter((model) => model.ignored).map((model) => model.symbol.name));
 	const composedExtensions = new Set(input.composedExtensions);
@@ -1397,6 +1544,7 @@ function interpretPrisma7Documents(input) {
 		target: binding.target,
 		warnings: void 0,
 		createNamespace,
+		...ifDefined("extensions", composedExtensionPackRefs(binding.target, input.composedExtensions)),
 		...namespaceEntities.size > 0 ? { namespaces: [...namespaceEntities.keys()] } : {},
 		models: modelNodes,
 		...tables.length > 0 ? { tables } : {}
@@ -1593,6 +1741,50 @@ function readEnumDeclaration(source, defaultNamespaceId, diagnostics) {
 		sourceId
 	};
 }
+function packDeclaring(packContracts, entityKind, name) {
+	for (const [packId, contract] of packContracts) for (const [namespaceId, namespace] of Object.entries(contract.storage.namespaces)) if (Object.hasOwn(namespace.entries[entityKind] ?? {}, name)) return {
+		packId,
+		namespaceId
+	};
+}
+function entityContext(input, sourceId, diagnostics) {
+	return {
+		family: input.binding.target.familyId,
+		target: input.binding.target.targetId,
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes,
+		sourceId,
+		diagnostics: { push: (diagnostic) => {
+			diagnostics.push(blindCast(diagnostic));
+		} }
+	};
+}
+/** Files each extension the application's contract declares under its namespace, as the target's extension entity. */
+function lowerDatasourceExtensions(extensions, namespaceEntities, input, diagnostics) {
+	if (extensions.length === 0) return;
+	const { entityKind } = input.binding.extensions;
+	const descriptor = buildEntityTypesByDiscriminator(input.authoringContributions).get(entityKind);
+	if (descriptor === void 0) throw new InternalError(`The Prisma 7 binding names the extension entity kind "${entityKind}", which target "${input.binding.target.targetId}" does not register.`);
+	for (const extension of extensions) {
+		const entity = instantiateAuthoringEntityType(entityKind, descriptor, [{
+			kind: entityKind,
+			keyword: entityKind,
+			name: extension.name,
+			values: {},
+			writtenValues: {},
+			parameterSpans: {},
+			attributes: {},
+			span: extension.span,
+			namespaceId: extension.namespaceId
+		}], entityContext(input, extension.sourceId, diagnostics));
+		const entities = namespaceEntities.get(extension.namespaceId) ?? {};
+		namespaceEntities.set(extension.namespaceId, entities);
+		entities[entityKind] = {
+			...entities[entityKind],
+			[extension.name]: entity
+		};
+	}
+}
 function lowerNativeEnums(enums, input, diagnostics) {
 	const result = /* @__PURE__ */ new Map();
 	if (enums.size === 0) return result;
@@ -1603,16 +1795,7 @@ function lowerNativeEnums(enums, input, diagnostics) {
 			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `Enum "${declaration.name}" cannot be lowered: target "${input.binding.target.targetId}" registers no "${entityKind}" entity kind.`, declaration.sourceId, declaration.span));
 			continue;
 		}
-		const context = {
-			family: input.binding.target.familyId,
-			target: input.binding.target.targetId,
-			codecLookup: input.codecLookup,
-			dataTypes: input.dataTypes,
-			sourceId: declaration.sourceId,
-			diagnostics: { push: (diagnostic) => {
-				diagnostics.push(blindCast(diagnostic));
-			} }
-		};
+		const context = entityContext(input, declaration.sourceId, diagnostics);
 		const values = Object.create(null);
 		const writtenValues = Object.create(null);
 		const parameterSpans = Object.create(null);
@@ -2048,6 +2231,7 @@ function prisma7Contract(schemaPath, options) {
 						codecLookup: context.codecLookup,
 						dataTypes: context.dataTypes,
 						composedExtensions: context.composedExtensions,
+						composedExtensionContracts: context.composedExtensionContracts,
 						defaultNamespaceId: context.defaultNamespaceId
 					});
 					if (!interpreted.ok) return interpreted;