@prisma-next/target-postgres 0.16.0-dev.27 → 0.16.0-dev.29

package/dist/control.mjs

@@ -17,7 +17,7 @@ import { notOk, ok, okVoid } from "@prisma-next/utils/result";
 import { InternalError } from "@prisma-next/utils/internal-error";
 import { SqlSchemaVerifierBase } from "@prisma-next/family-sql/ir";
 import { SqlQueryError } from "@prisma-next/sql-errors";
-import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, toFieldName, toModelName, toNamedTypeName } from "@prisma-next/family-sql/psl-infer";
+import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, toFieldName, toModelName } from "@prisma-next/family-sql/psl-infer";
 import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma-next/framework-components/psl-ast";
 //#region src/core/migrations/runner.ts
 const LOCK_DOMAIN = "prisma_next.contract.marker";
@@ -437,170 +437,82 @@ const POSTGRES_TO_PSL = {
 	bigint: "BigInt",
 	float8: "Float",
 	"double precision": "Float",
-	numeric: "Decimal",
-	decimal: "Decimal",
-	timestamptz: "DateTime",
-	"timestamp with time zone": "DateTime",
 	jsonb: "Jsonb",
 	bytea: "Bytes"
 };
 const PRESERVED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	uuid: {
-		pslType: "String",
-		attributeName: "db.Uuid"
-	},
-	inet: {
-		pslType: "String",
-		attributeName: "db.Inet"
-	},
-	int2: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	smallint: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	float4: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	real: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	"timestamp without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	date: {
-		pslType: "DateTime",
-		attributeName: "db.Date"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	"time without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	"time with time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	json: {
-		pslType: "Json",
-		attributeName: "db.Json"
-	}
+	"character varying": "VarChar",
+	character: "Char",
+	char: "Char",
+	varchar: "VarChar",
+	uuid: "Uuid",
+	inet: "Inet",
+	int2: "SmallInt",
+	smallint: "SmallInt",
+	float4: "Real",
+	real: "Real",
+	numeric: "Numeric",
+	decimal: "Numeric",
+	timestamp: "Timestamp",
+	"timestamp without time zone": "Timestamp",
+	timestamptz: "Timestamptz",
+	"timestamp with time zone": "Timestamptz",
+	date: "Date",
+	time: "Time",
+	"time without time zone": "Time",
+	timetz: "Timetz",
+	"time with time zone": "Timetz",
+	json: "Json"
 };
 const PARAMETERIZED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	numeric: {
-		pslType: "Decimal",
-		attributeName: "db.Numeric"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	timestamptz: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamptz"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	}
+	"character varying": "VarChar",
+	character: "Char",
+	char: "Char",
+	varchar: "VarChar",
+	numeric: "Numeric",
+	decimal: "Numeric",
+	timestamp: "Timestamp",
+	timestamptz: "Timestamptz",
+	time: "Time",
+	timetz: "Timetz"
 };
 const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
 function getOwnMappingValue(map, key) {
 	return Object.hasOwn(map, key) ? map[key] : void 0;
 }
-function getOwnRecordValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function createNativeTypeAttribute(name, args) {
-	return args && args.length > 0 ? {
-		name,
-		args
-	} : { name };
-}
 function splitTypeParameterList(params) {
 	return params.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 }
 function createPostgresTypeMap(enumTypeNames) {
 	return { resolve(nativeType) {
 		if (enumTypeNames?.has(nativeType)) return {
-			pslType: nativeType,
+			pslType: { name: nativeType },
 			nativeType
 		};
 		const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
 		if (paramMatch) {
 			const [, baseType = nativeType, params = ""] = paramMatch;
-			const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
-			if (template) return {
-				pslType: template.pslType,
+			const typeName = getOwnMappingValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+			if (typeName) return {
+				pslType: {
+					name: typeName,
+					args: splitTypeParameterList(params)
+				},
 				nativeType,
 				typeParams: {
 					baseType,
 					params
-				},
-				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
+				}
 			};
 		}
-		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+		const preservedType = getOwnMappingValue(PRESERVED_NATIVE_TYPES, nativeType);
 		if (preservedType) return {
-			pslType: preservedType.pslType,
-			nativeType,
-			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
+			pslType: { name: preservedType },
+			nativeType
 		};
 		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
 		if (pslType) return {
-			pslType,
+			pslType: { name: pslType },
 			nativeType
 		};
 		return {
@@ -852,19 +764,11 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName)
 	const { enumNameMap: bareEnumNameMap, enumBlocks } = buildNativeEnumBlocks(options.enumInfo?.definitions ?? /* @__PURE__ */ new Map(), modelNames);
 	const enumNameMap = new Map(bareEnumNameMap);
 	if (namespaceName !== void 0) for (const [typeName, pslName] of bareEnumNameMap) enumNameMap.set(`${namespaceName}.${typeName}`, pslName);
-	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNameMap);
 	const fieldNamesByTable = new Map([...crossSpaceFieldNamesByTable, ...buildFieldNamesByTable(schemaIR.tables)]);
 	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
 	const models = [];
-	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.get(table.name) ?? []], danglingForeignKeysByTable.get(table.name) ?? []));
+	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.get(table.name) ?? []], danglingForeignKeysByTable.get(table.name) ?? []));
 	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
-	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
-	const types = namedTypeEntries.length > 0 ? {
-		kind: "types",
-		declarations: namedTypeEntries.map(buildNamedTypeDeclaration),
-		span: SYNTHETIC_SPAN
-	} : void 0;
 	return {
 		kind: "document",
 		sourceId: "<sql-schema-ir>",
@@ -874,7 +778,6 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName)
 			entries: makePslNamespaceEntries(sortedModels, [], enumBlocks),
 			span: SYNTHETIC_SPAN
 		})],
-		...types ? { types } : {},
 		span: SYNTHETIC_SPAN
 	};
 }
@@ -934,7 +837,7 @@ function buildNativeEnumBlock(name, typeName, values) {
 		span: SYNTHETIC_SPAN
 	};
 }
-function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys) {
+function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys) {
 	const { name: modelName, map: mapName } = toModelName(table.name);
 	const fieldNameMap = fieldNamesByTable.get(table.name);
 	const pkColumns = new Set(table.primaryKey?.columns ?? []);
@@ -947,7 +850,7 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes,
 		if (!uniqueColumns.has(columnName) || existingConstraintName === void 0 && unique.name) uniqueColumns.set(columnName, unique.name);
 	}
 	const fields = [];
-	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
+	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
 	const usedFieldNames = new Set(fields.map((field) => field.name));
 	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
 	const modelAttributes = [];
@@ -994,7 +897,7 @@ function buildDanglingForeignKeyWarning(danglingForeignKeys, fieldNamesByTable,
 		return `"${fieldNames.join(", ")}" -> "${target}"`;
 	}).join(", ")} exists in the database, but its target schema is outside the introspected scope, so no relation field was generated. If the target schema is described by an extension pack, add it to extensions and re-run infer.`;
 }
-function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
+function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
 	const resolvedField = fieldNameMap?.get(column.name);
 	const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
 	const fieldMap = resolvedField?.fieldMap;
@@ -1012,8 +915,13 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 			span: SYNTHETIC_SPAN
 		};
 	}
-	let typeName = resolution.pslType;
-	let typeConstructor;
+	let typeName = resolution.pslType.name;
+	let typeConstructor = resolution.pslType.args ? {
+		kind: "typeConstructor",
+		path: [resolution.pslType.name],
+		args: resolution.pslType.args.map(positionalArg),
+		span: SYNTHETIC_SPAN
+	} : void 0;
 	const enumPslName = enumNameMap.get(column.nativeType);
 	if (enumPslName) {
 		typeName = enumPslName;
@@ -1024,7 +932,6 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, nam
 			span: SYNTHETIC_SPAN
 		};
 	}
-	if (resolution.nativeTypeAttribute && !enumPslName) typeName = resolveNamedTypeName(namedTypes, resolution);
 	const attributes = [];
 	const isId = isSinglePk && pkColumns.has(column.name);
 	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
@@ -1129,16 +1036,6 @@ function namedArg(name, value) {
 		span: SYNTHETIC_SPAN
 	};
 }
-function buildNamedTypeDeclaration(entry) {
-	const attribute = buildAttribute("namedType", entry.nativeTypeAttribute.name, (entry.nativeTypeAttribute.args ?? []).map(positionalArg));
-	return {
-		kind: "namedType",
-		name: entry.name,
-		baseType: entry.baseType,
-		attributes: [attribute],
-		span: SYNTHETIC_SPAN
-	};
-}
 function escapePslString(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
 }
@@ -1222,65 +1119,6 @@ function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
 	} });
 	return results;
 }
-function createReservedNamedTypeNames(modelNames, enumNameMap) {
-	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
-	for (const result of modelNames.values()) reservedNames.add(result.name);
-	for (const enumPslName of enumNameMap.values()) reservedNames.add(enumPslName);
-	return reservedNames;
-}
-function seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNames) {
-	const seeds = /* @__PURE__ */ new Map();
-	for (const tableName of Object.keys(schemaIR.tables).sort()) {
-		const table = schemaIR.tables[tableName];
-		if (!table) continue;
-		for (const columnName of Object.keys(table.columns).sort()) {
-			const column = table.columns[columnName];
-			if (!column) continue;
-			const resolution = typeMap.resolve(column.nativeType, table.annotations);
-			if ("unsupported" in resolution || enumNameMap.has(column.nativeType) || !resolution.nativeTypeAttribute) continue;
-			const signatureKey = createNamedTypeSignatureKey(resolution);
-			if (!seeds.has(signatureKey)) seeds.set(signatureKey, {
-				baseType: resolution.pslType,
-				desiredName: toNamedTypeName(column.name),
-				nativeTypeAttribute: resolution.nativeTypeAttribute
-			});
-		}
-	}
-	const registry = {
-		entriesByKey: /* @__PURE__ */ new Map(),
-		usedNames: new Set(reservedNames)
-	};
-	const sortedSeeds = [...seeds.entries()].sort((left, right) => {
-		const desiredNameComparison = left[1].desiredName.localeCompare(right[1].desiredName);
-		if (desiredNameComparison !== 0) return desiredNameComparison;
-		return left[0].localeCompare(right[0]);
-	});
-	for (const [signatureKey, seed] of sortedSeeds) {
-		const name = createUniqueFieldName(seed.desiredName, registry.usedNames);
-		registry.entriesByKey.set(signatureKey, {
-			name,
-			baseType: seed.baseType,
-			nativeTypeAttribute: seed.nativeTypeAttribute
-		});
-		registry.usedNames.add(name);
-	}
-	return registry;
-}
-function resolveNamedTypeName(registry, resolution) {
-	const key = createNamedTypeSignatureKey(resolution);
-	const existing = registry.entriesByKey.get(key);
-	if (existing) return existing.name;
-	throw new InternalError(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
-}
-function createNamedTypeSignatureKey(resolution) {
-	return JSON.stringify({
-		baseType: resolution.pslType,
-		nativeTypeAttribute: resolution.nativeTypeAttribute ? {
-			name: resolution.nativeTypeAttribute.name,
-			args: resolution.nativeTypeAttribute.args ?? null
-		} : null
-	});
-}
 function topologicalSort(models, tables, modelNameMap) {
 	const modelByName = /* @__PURE__ */ new Map();
 	for (const model of models) modelByName.set(model.name, model);