@prisma/orm-target-postgres 8.0.0-rc.14-dev.28 → 8.0.0-rc.14-dev.30

package/dist/{control-CyiVFspE.mjs → control-C0mAPRzk.mjs}

@@ -1,23 +1,24 @@
 import { C as PG_TIMESTAMPTZ_DATE_CODEC_ID, D as PG_TIMESTAMP_TEMPORAL_CODEC_ID, E as PG_TIMESTAMP_STRING_CODEC_ID, S as PG_TEXT_CODEC_ID, T as PG_TIMESTAMPTZ_TEMPORAL_CODEC_ID, s as PG_ENUM_CODEC_ID, w as PG_TIMESTAMPTZ_STRING_CODEC_ID } from "./codec-ids-Cb0yO-IS--e0P2rfI.mjs";
-import { i as isPostgresCodecDescriptor } from "./codec-descriptor-B61d-k4C-BdWVU6Fu.mjs";
 import { s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
 import { t as PostgresNativeEnum } from "./postgres-native-enum-CdP3b_-R-Cgz9KEKx.mjs";
-import { P as setFallbackTemporal, n as NUMERIC_SCALE_RANGE, t as NUMERIC_PRECISION_RANGE } from "./codecs-CnbVrlil--FxLKWM5.mjs";
-import { i as PostgresRlsPolicy, n as PostgresRlsEnablement, o as PostgresRole } from "./postgres-schema-C8slJGZo-CFGUyJPt.mjs";
+import { M as setFallbackTemporal } from "./codecs-BzCRfsit-BbLlbudt.mjs";
+import { i as PostgresRlsPolicy, n as PostgresRlsEnablement, o as PostgresRole } from "./postgres-schema-DXd0mebY-CExd_GcQ.mjs";
 import { n as computeContentHash } from "./canonicalize-CrN3u_xM-D4MrOqcB.mjs";
-import { m as postgresNowGeneratorIdFor, r as POLICY_BLOCK_KEYWORDS } from "./authoring-C5Ch8RNG-Qgq9GiOY.mjs";
-import { t as postgresRenderCheckExpressions } from "./check-expressions-DJNIFTHB-C86_fR5c.mjs";
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-Bvq6_NJ8-Cn_M79Lf.mjs";
+import { m as postgresNowGeneratorIdFor, r as POLICY_BLOCK_KEYWORDS } from "./authoring-BarDKx1G-BKhOsXKo.mjs";
+import { t as postgresRenderCheckExpressions } from "./check-expressions-BRuSxJ5d-CC5OFfR1.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CUmf1G9P-GAdC3zfT.mjs";
 import { a as postgresDiffSubjectGranularity, i as postgresDiffSubjectEntityKind } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
 import { t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
-import { i as diffPostgresSchema } from "./diff-database-schema-_bbfF4oI-D_VmL4Ma.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-view-Da0ymIZE-CBV3OE-k.mjs";
-import { a as postgresContractToSchema } from "./postgres-migration-Dq60Mixq-DYNJokZW.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-D7lEhXHR-8Wz1p_6j.mjs";
-import { a as buildIndexAttribute, c as buildNativeEnumBlock, d as createPostgresTypeMap, f as inferPostgresPslContract, g as positionalArg, h as parseDefaultAttributeString, i as buildCheckAttribute, n as SYNTHETIC_SPAN, o as buildMapAttribute, p as namedArg, r as buildAttribute, s as buildModelConstraintAttribute } from "./infer-psl-contract-Burb6YAz-DbKU4cXm.mjs";
-import { escapePslString } from "@prisma/orm-family-sql/relational-core/ast";
+import { r as diffPostgresSchema } from "./diff-database-schema-BYHT4ZZp-DHQM3yoO.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-view-D60F8OWK-Bi5oJkOx.mjs";
+import { a as postgresContractToSchema } from "./postgres-migration-PLXsv15e-BruyXuKH.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-BWKFZaOu--28k5rC4.mjs";
+import { a as buildIndexAttribute, c as buildNativeEnumBlock, d as createPostgresTypeMap, f as inferPostgresPslContract, g as positionalArg, h as parseDefaultAttributeString, i as buildCheckAttribute, n as SYNTHETIC_SPAN, o as buildMapAttribute, p as namedArg, r as buildAttribute, s as buildModelConstraintAttribute } from "./infer-psl-contract-DBWXA-jx-CmKQgKZJ.mjs";
+import { requiredParamKeys, validateCodecTypeParams } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { dataTypeParams, isSqlDataType, unquotedSqlBaseName } from "@prisma/orm-family-sql/contract/data-type";
+import { escapePslString } from "@prisma/orm-family-sql/contract/data-type-support";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
 import { StorageColumn, resolvedTypeParams } from "@prisma/orm-family-sql/contract/types";
 import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
@@ -1139,7 +1140,8 @@ function typeArgumentText(value, coordinate) {
 }
 function typeCall(path, args) {
 	const name = path.join(".");
-	if (args.length === 0) return { typeName: name };
+	const isNamespaced = path.length > 1;
+	if (args.length === 0 && !isNamespaced) return { typeName: name };
 	return {
 		typeName: name,
 		typeConstructor: {
@@ -1189,21 +1191,26 @@ function buildColumnType(input) {
 	if (call !== void 0) return typeCall(call.path, call.args.map((value) => typeArgumentText(value, coordinate)));
 	refuseColumnWithoutPslType(column, coordinate);
 }
-/** The native type the stack's codec names for a value-object member, which has no column of its own. */
+/**
+* The type name a value-object member's codec stores, from the data type the codec represents and
+* the member's type parameters. A member has no column of its own.
+*/
 function nativeTypeOfMember(type, coordinate, context) {
 	const { codecId } = type;
 	const descriptor = context.codecLookup.descriptorFor(codecId);
-	if (!isPostgresCodecDescriptor(descriptor)) refuseMemberCodecWithoutNativeType(codecId, coordinate);
+	if (descriptor === void 0) refuseMemberCodecWithoutNativeType(codecId, coordinate);
+	const dataType = context.dataTypeLookup.get(descriptor.dataType);
+	if (dataType === void 0 || !isSqlDataType(dataType)) refuseMemberCodecWithoutNativeType(codecId, coordinate);
 	const typeParams = resolvedTypeParams(type, void 0);
-	if (typeParams !== void 0) return descriptor.nativeTypeFor({
+	if (typeParams === void 0) {
+		if (requiredParamKeys(dataType).length > 0) refuseMemberCodecNeedingTypeParameters(codecId, coordinate);
+		return unquotedSqlBaseName(dataType, {});
+	}
+	validateCodecTypeParams(descriptor, {
 		codecId,
 		typeParams: blindCast(typeParams)
 	});
-	try {
-		return descriptor.nativeTypeFor({ codecId });
-	} catch {
-		refuseMemberCodecNeedingTypeParameters(codecId, coordinate);
-	}
+	return unquotedSqlBaseName(dataType, dataTypeParams(dataType, typeParams));
 }
 /** The PSL type position of a value-object member: a value object or an enum by name, or a scalar as a column would print. */
 function buildMemberType(input) {
@@ -1865,7 +1872,7 @@ function buildColumnDefault(input) {
 	const { context } = input;
 	const result = mapDefault(columnDefault, {
 		dataTypeEntries: context.authoringContributions.dataTypes,
-		dataTypes: context.dataTypeLookup,
+		dataTypeLookup: context.dataTypeLookup,
 		columnDataType: context.codecLookup.descriptorFor(input.isEnum ? PG_TEXT_CODEC_ID : input.column.codecId)?.dataType,
 		list: input.column.many !== false
 	});
@@ -2276,110 +2283,84 @@ function buildPostgresPslContract(contract, context) {
 }
 /**
 * The base PSL scalars as zero-arg type constructors in the unified authoring
-* channel, with explicit `nativeType` values pinned to the codec manifests
-* (`codecLookup.targetTypesFor(codecId)[0]`).
+* channel. Each names a codec; the column's database type is its data type's.
 *
 * The type position is the only storage decider: a mutation-default generator
 * (`@default(uuid())`) never re-picks a column's storage.
-*
-* These and `postgresNativeAuthoringTypes` are defined here, next to the codecs they name, but the adapter contributes them: the TypeScript contract builder builds its `type.*` helpers from the target, so a target contribution would add `type.String()` and the like there.
 */
 const postgresScalarAuthoringTypes = {
 	String: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "Variable-length text stored as PostgreSQL text.",
-		output: {
-			codecId: "pg/text@1",
-			nativeType: "text"
-		}
+		output: { codecId: "pg/text@1" }
 	},
 	Boolean: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A true or false value stored as PostgreSQL boolean.",
-		output: {
-			codecId: "pg/bool@1",
-			nativeType: "bool"
-		}
+		output: { codecId: "pg/bool@1" }
 	},
 	Int: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A signed 32-bit integer represented as a JavaScript number.",
-		output: {
-			codecId: "pg/int4@1",
-			nativeType: "int4"
-		}
+		output: { codecId: "pg/int4@1" }
 	},
 	BigInt: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A signed 64-bit integer represented as a JavaScript bigint.",
-		output: {
-			codecId: "pg/int8@1",
-			nativeType: "int8"
-		}
+		output: { codecId: "pg/int8@1" }
 	},
 	Float: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A double-precision floating-point number.",
-		output: {
-			codecId: "pg/float8@1",
-			nativeType: "float8"
-		}
+		output: { codecId: "pg/float8@1" }
 	},
 	Decimal: {
 		kind: "typeConstructor",
 		documentation: "An exact decimal value stored as PostgreSQL numeric.",
-		output: {
-			codecId: "pg/numeric@1",
-			nativeType: "numeric"
-		}
+		output: { codecId: "pg/numeric@1" }
 	},
 	DateTime: {
 		kind: "typeConstructor",
 		documentation: "An instant stored as PostgreSQL timestamptz and represented as Temporal.Instant.",
-		output: {
-			codecId: "pg/timestamptz-temporal@1",
-			nativeType: "timestamptz"
-		}
+		output: { codecId: "pg/timestamptz-temporal@1" }
 	},
 	Json: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A JSON value stored as PostgreSQL json.",
-		output: {
-			codecId: "pg/json@1",
-			nativeType: "json"
-		}
+		output: { codecId: "pg/json@1" }
 	},
 	Jsonb: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A JSON value stored in PostgreSQL binary jsonb format.",
-		output: {
-			codecId: "pg/jsonb@1",
-			nativeType: "jsonb"
-		}
+		output: { codecId: "pg/jsonb@1" }
 	},
 	Bytes: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "Binary data stored as PostgreSQL bytea.",
-		output: {
-			codecId: "pg/bytea@1",
-			nativeType: "bytea"
-		}
+		output: { codecId: "pg/bytea@1" }
 	}
 };
 const postgresNativeAuthoringTypes = {
 	VarChar: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "Variable-length text with an optional maximum character length.",
 		args: [{
 			kind: "number",
 			name: "length",
 			integer: true,
-			minimum: 1,
 			optional: true
 		}],
 		output: {
 			codecId: "sql/varchar@1",
-			nativeType: "character varying",
 			typeParams: { length: {
 				kind: "arg",
 				index: 0
@@ -2388,17 +2369,16 @@ const postgresNativeAuthoringTypes = {
 	},
 	Char: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "Fixed-length, blank-padded text with an optional character length.",
 		args: [{
 			kind: "number",
 			name: "length",
 			integer: true,
-			minimum: 1,
 			optional: true
 		}],
 		output: {
 			codecId: "sql/char@1",
-			nativeType: "character",
 			typeParams: { length: {
 				kind: "arg",
 				index: 0
@@ -2407,25 +2387,21 @@ const postgresNativeAuthoringTypes = {
 	},
 	Numeric: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "An exact decimal value with optional precision and scale.",
 		args: [{
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: NUMERIC_PRECISION_RANGE.min,
-			maximum: NUMERIC_PRECISION_RANGE.max,
 			optional: true
 		}, {
 			kind: "number",
 			name: "scale",
 			integer: true,
-			minimum: NUMERIC_SCALE_RANGE.min,
-			maximum: NUMERIC_SCALE_RANGE.max,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/numeric@1",
-			nativeType: "numeric",
 			typeParams: {
 				precision: {
 					kind: "arg",
@@ -2445,12 +2421,10 @@ const postgresNativeAuthoringTypes = {
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/timestamp-temporal@1",
-			nativeType: "timestamp",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2464,12 +2438,10 @@ const postgresNativeAuthoringTypes = {
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/timestamptz-temporal@1",
-			nativeType: "timestamptz",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2483,12 +2455,10 @@ const postgresNativeAuthoringTypes = {
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/time-temporal@1",
-			nativeType: "time",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2497,17 +2467,16 @@ const postgresNativeAuthoringTypes = {
 	},
 	Timetz: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A time of day with a UTC offset stored as PostgreSQL timetz.",
 		args: [{
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/timetz@1",
-			nativeType: "timetz",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2516,65 +2485,51 @@ const postgresNativeAuthoringTypes = {
 	},
 	Uuid: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A universally unique identifier stored as PostgreSQL uuid.",
-		output: {
-			codecId: "pg/uuid@1",
-			nativeType: "uuid"
-		}
+		output: { codecId: "pg/uuid@1" }
 	},
 	Inet: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "An IPv4 or IPv6 address with an optional subnet mask.",
-		output: {
-			codecId: "pg/inet@1",
-			nativeType: "inet"
-		}
+		output: { codecId: "pg/inet@1" }
 	},
 	SmallInt: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A signed 16-bit integer represented as a JavaScript number.",
-		output: {
-			codecId: "pg/int2@1",
-			nativeType: "int2"
-		}
+		output: { codecId: "pg/int2@1" }
 	},
 	Real: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A single-precision floating-point number.",
-		output: {
-			codecId: "pg/float4@1",
-			nativeType: "float4"
-		}
+		output: { codecId: "pg/float4@1" }
 	},
 	Date: {
 		kind: "typeConstructor",
 		documentation: "A calendar date represented as Temporal.PlainDate.",
-		output: {
-			codecId: "pg/date-temporal@1",
-			nativeType: "date"
-		}
+		output: { codecId: "pg/date-temporal@1" }
 	},
 	DateString: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A PostgreSQL date represented as database text rather than Temporal.PlainDate.",
-		output: {
-			codecId: "pg/date-string@1",
-			nativeType: "date"
-		}
+		output: { codecId: "pg/date-string@1" }
 	},
 	TimestampString: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A timestamp without a time zone represented as PostgreSQL text.",
 		args: [{
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/timestamp-string@1",
-			nativeType: "timestamp",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2588,12 +2543,10 @@ const postgresNativeAuthoringTypes = {
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: PG_TIMESTAMPTZ_DATE_CODEC_ID,
-			nativeType: "timestamptz",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2602,17 +2555,16 @@ const postgresNativeAuthoringTypes = {
 	},
 	TimestamptzString: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A timestamp with time zone represented as PostgreSQL text.",
 		args: [{
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/timestamptz-string@1",
-			nativeType: "timestamptz",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2621,17 +2573,16 @@ const postgresNativeAuthoringTypes = {
 	},
 	TimeString: {
 		kind: "typeConstructor",
+		inferred: true,
 		documentation: "A time of day without a time zone represented as PostgreSQL text.",
 		args: [{
 			kind: "number",
 			name: "precision",
 			integer: true,
-			minimum: 0,
 			optional: true
 		}],
 		output: {
 			codecId: "pg/time-string@1",
-			nativeType: "time",
 			typeParams: { precision: {
 				kind: "arg",
 				index: 0
@@ -2639,6 +2590,13 @@ const postgresNativeAuthoringTypes = {
 		}
 	}
 };
+/**
+* The constructors only PSL offers, defined here next to the codecs they name. The adapter contributes them: the TypeScript contract builder builds its `type.*` helpers from the target, so a target contribution would add `type.String()` and the like there. The constructors that should also be `type.*` helpers are the target's own, in `postgresAuthoringTypes`.
+*/
+const postgresPslTypeConstructors = {
+	...postgresScalarAuthoringTypes,
+	...postgresNativeAuthoringTypes
+};
 function createPostgresTargetDescriptor() {
 	setFallbackTemporal(Temporal);
 	return {
@@ -2692,6 +2650,6 @@ function createPostgresTargetDescriptor() {
 }
 const postgresTargetDescriptor = createPostgresTargetDescriptor();
 //#endregion
-export { postgresScalarAuthoringTypes as n, postgresTargetDescriptor as r, postgresNativeAuthoringTypes as t };
+export { postgresTargetDescriptor as i, postgresPslTypeConstructors as n, postgresScalarAuthoringTypes as r, postgresNativeAuthoringTypes as t };
 
-//# sourceMappingURL=control-CyiVFspE.mjs.map
+//# sourceMappingURL=control-C0mAPRzk.mjs.map