@prisma/orm-target-postgres 8.0.0-rc.11-dev.16 → 8.0.0-rc.11-dev.18

package/dist/{control-BC3oXXIK.mjs → infer-psl-contract-BaZaJAD9-DTVu5Zab.mjs}

@@ -1,420 +1,16 @@
 import { s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
-import { n as postgresResolveDefault } from "./default-normalizer-Ba5ZebHM-isV86rjy.mjs";
+import { t as parsePostgresDefault } from "./default-normalizer-Bjtm2F4f-uV5vvkVt.mjs";
 import { t as postgresRenderCheckExpressions } from "./check-expressions-DFTeR0rd-CSxSpyMV.mjs";
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-C4i4pLQn-CmdN74uG.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 { r as renderDefaultLiteral } from "./planner-ddl-builders-Cf6-fTvi-CKp-yZkB.mjs";
-import { n as contractToPostgresDatabaseSchemaNode, r as diffPostgresSchema } from "./diff-database-schema-BaSP2z4y-Ch42uw-j.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-view-C22aDeL9-BWJIOpCz.mjs";
-import { t as createPostgresMigrationPlanner } from "./planner-C70Loeo_-qHTNBO3Q.mjs";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { UNBOUND_NAMESPACE_ID, coordinateKey, elementCoordinates } from "@prisma/orm-framework/components/ir";
+import { coordinateKey, elementCoordinates } from "@prisma/orm-framework/components/ir";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { composeCheckWirePrefix, computeCheckContentHash, computeIndexContentHash, formatWireName, parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
 import { assertDefined } from "@prisma/orm-framework/utils/assertions";
-import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
-import { buildNativeTypeExpander, runnerFailure, runnerSuccess } from "@prisma/orm-family-sql/family/control";
 import { SqlSchemaIR, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { notOk, ok, okVoid } from "@prisma/orm-framework/utils/result";
-import { SqlSchemaVerifierBase } from "@prisma/orm-family-sql/family/ir";
-import { SqlQueryError } from "@prisma/orm-family-sql/errors";
-import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, toEnumMemberName, toEnumName, toFieldName, toModelName } from "@prisma/orm-family-sql/family/psl-infer";
+import { buildChildRelationField, deriveRelationFieldName, inferRelations, mapDefault, toEnumMemberName, toEnumName, toFieldName, toModelName } from "@prisma/orm-family-sql/family/psl-infer";
 import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma/orm-framework/components/psl-ast";
 import { isColumnDefault } from "@prisma/orm-framework/contract/types";
-//#region ../../../3-targets/3-targets/postgres/dist/control.mjs
-const LOCK_DOMAIN = "prisma_8.contract.marker";
-/**
-* Deep clones and freezes a record object to prevent mutation.
-* Recursively clones nested objects and arrays to ensure complete isolation.
-*/
-function cloneAndFreezeRecord(value) {
-	const cloned = {};
-	for (const [key, val] of Object.entries(value)) if (val === null || val === void 0) cloned[key] = val;
-	else if (Array.isArray(val)) cloned[key] = Object.freeze([...val]);
-	else if (typeof val === "object") cloned[key] = cloneAndFreezeRecord(val);
-	else cloned[key] = val;
-	return Object.freeze(cloned);
-}
-function createPostgresMigrationRunner(family) {
-	return new PostgresMigrationRunner(family);
-}
-var PostgresMigrationRunner = class {
-	family;
-	constructor(family) {
-		this.family = family;
-	}
-	/**
-	* Body of the migration runner without transaction management. The
-	* caller ({@link PostgresMigrationRunner.execute}) owns the
-	* `BEGIN`/`COMMIT`/`ROLLBACK` lifecycle.
-	*/
-	async executeOnConnection(options) {
-		const schema = options.schemaName ?? Object.keys(options.destinationContract.storage.namespaces).find((id) => id !== UNBOUND_NAMESPACE_ID) ?? UNBOUND_NAMESPACE_ID;
-		const driver = options.driver;
-		if (options.space !== void 0 && options.space !== options.plan.spaceId) throw postgresError("MIGRATION.CONTRACT_SPACE_VIOLATION", `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`, { meta: {
-			space: options.space,
-			planSpaceId: options.plan.spaceId
-		} });
-		const space = options.plan.spaceId;
-		const lockKey = `${LOCK_DOMAIN}:${schema}:${space}`;
-		const planOps = blindCast(await Promise.all(options.plan.operations));
-		const destinationCheck = this.ensurePlanMatchesDestinationContract(options.plan.destination, options.destinationContract);
-		if (!destinationCheck.ok) return destinationCheck;
-		const policyCheck = this.enforcePolicyCompatibility(options.policy, planOps);
-		if (!policyCheck.ok) return policyCheck;
-		await this.acquireLock(driver, lockKey);
-		const ensureResult = await this.ensureControlTables(driver, options.destinationContract);
-		if (!ensureResult.ok) return ensureResult;
-		const existingMarker = await this.family.readMarker({
-			driver,
-			space
-		});
-		const markerCheck = this.ensureMarkerCompatibility(existingMarker, options.plan);
-		if (!markerCheck.ok) return markerCheck;
-		const markerAtDestination = this.markerMatchesDestination(existingMarker, options.plan);
-		const isSelfEdge = options.plan.origin?.storageHash === options.plan.destination.storageHash;
-		const skipOperations = markerAtDestination && options.plan.origin != null && !isSelfEdge;
-		let applyValue;
-		if (skipOperations) applyValue = {
-			operationsExecuted: 0,
-			executedOperations: []
-		};
-		else {
-			const applyResult = await this.applyPlan(driver, options, planOps);
-			if (!applyResult.ok) return applyResult;
-			applyValue = applyResult.value;
-		}
-		if (space === APP_SPACE_ID) {
-			const schemaNode = await this.family.introspect({
-				driver,
-				contract: options.destinationContract
-			});
-			const schemaVerifyResult = this.family.verifySchema({
-				contract: options.destinationContract,
-				schema: schemaNode,
-				strict: options.strictVerification ?? true,
-				frameworkComponents: options.frameworkComponents
-			});
-			if (!schemaVerifyResult.ok) return runnerFailure("MIGRATION.SCHEMA_VERIFY_FAILED", schemaVerifyResult.summary, {
-				why: "The resulting database schema does not satisfy the destination contract.",
-				meta: { issues: schemaVerifyResult.schema.issues }
-			});
-		}
-		const incomingInvariants = options.plan.providedInvariants ?? [];
-		const existingInvariants = new Set(existingMarker?.invariants ?? []);
-		const incomingIsSubsetOfExisting = incomingInvariants.every((id) => existingInvariants.has(id));
-		if (!(isSelfEdge && applyValue.operationsExecuted === 0 && incomingIsSubsetOfExisting)) {
-			const markerResult = await this.upsertMarker(driver, options, existingMarker, space);
-			if (!markerResult.ok) return markerResult;
-			await this.recordLedgerEntries(driver, options, applyValue.executedOperations, planOps.length);
-		}
-		return runnerSuccess({
-			operationsPlanned: planOps.length,
-			operationsExecuted: applyValue.operationsExecuted
-		});
-	}
-	async execute(options) {
-		const driver = options.driver;
-		const perSpaceOptions = options.perSpaceOptions;
-		if (perSpaceOptions.length === 0) return ok({ perSpaceResults: [] });
-		await this.beginTransaction(driver);
-		let committed = false;
-		try {
-			const perSpaceResults = [];
-			for (const spaceOptions of perSpaceOptions) {
-				const space = spaceOptions.space ?? spaceOptions.plan.spaceId;
-				const result = await this.executeOnConnection({
-					...spaceOptions,
-					driver,
-					space
-				});
-				if (!result.ok) return notOk({
-					...result.failure,
-					failingSpace: space
-				});
-				perSpaceResults.push({
-					space,
-					value: result.value
-				});
-			}
-			await this.commitTransaction(driver);
-			committed = true;
-			return ok({ perSpaceResults });
-		} finally {
-			if (!committed) await this.rollbackTransaction(driver);
-		}
-	}
-	async applyPlan(driver, options, ops) {
-		const checks = options.executionChecks;
-		const runPrechecks = checks?.prechecks !== false;
-		const runPostchecks = checks?.postchecks !== false;
-		const runIdempotency = checks?.idempotencyChecks !== false;
-		let operationsExecuted = 0;
-		const executedOperations = [];
-		for (const operation of ops) {
-			options.callbacks?.onOperationStart?.(operation);
-			try {
-				if (runPostchecks && runIdempotency) {
-					if (await this.expectationsAreSatisfied(driver, operation.postcheck)) {
-						executedOperations.push(this.createPostcheckPreSatisfiedSkipRecord(operation));
-						continue;
-					}
-				}
-				if (runPrechecks) {
-					const precheckResult = await this.runExpectationSteps(driver, operation.precheck, operation, "precheck");
-					if (!precheckResult.ok) return precheckResult;
-				}
-				const executeResult = await this.runExecuteSteps(driver, operation.execute, operation);
-				if (!executeResult.ok) return executeResult;
-				if (runPostchecks) {
-					const postcheckResult = await this.runExpectationSteps(driver, operation.postcheck, operation, "postcheck");
-					if (!postcheckResult.ok) return postcheckResult;
-				}
-				executedOperations.push(operation);
-				operationsExecuted += 1;
-			} finally {
-				options.callbacks?.onOperationComplete?.(operation);
-			}
-		}
-		return ok({
-			operationsExecuted,
-			executedOperations
-		});
-	}
-	async ensureControlTables(driver, contract) {
-		const lowererContext = { contract };
-		const [schemaQuery, ...tableQueries] = this.family.bootstrapControlTableQueries();
-		if (schemaQuery === void 0) throw new InternalError("Postgres control-table bootstrap must include CREATE SCHEMA");
-		await this.executeStatement(driver, await this.family.lowerAst(schemaQuery, lowererContext));
-		const legacyDetection = await this.detectLegacyMarkerShape(driver);
-		if (!legacyDetection.ok) return legacyDetection;
-		for (const query of tableQueries) await this.executeStatement(driver, await this.family.lowerAst(query, lowererContext));
-		return okVoid();
-	}
-	async detectLegacyMarkerShape(driver) {
-		const result = await driver.query(`select column_name
-         from information_schema.columns
-        where table_schema = 'prisma_contract'
-          and table_name = 'marker'`);
-		if (result.rows.length === 0) return okVoid();
-		const columns = new Set(result.rows.map((row) => row.column_name));
-		if (columns.has("space")) return okVoid();
-		return runnerFailure("MIGRATION.LEGACY_MARKER_SHAPE", "Legacy marker-table shape detected on prisma_contract.marker (no `space` column). Prisma 8 is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.", { meta: {
-			table: "prisma_contract.marker",
-			columns: [...columns].sort()
-		} });
-	}
-	async runExpectationSteps(driver, steps, operation, phase) {
-		for (const step of steps) {
-			const result = await driver.query(step.sql, step.params ?? []);
-			if (!this.stepResultIsTrue(result.rows)) return runnerFailure(phase === "precheck" ? "MIGRATION.PRECHECK_FAILED" : "MIGRATION.POSTCHECK_FAILED", `Operation ${operation.id} failed during ${phase}: ${step.description}`, { meta: {
-				operationId: operation.id,
-				phase,
-				stepDescription: step.description
-			} });
-		}
-		return okVoid();
-	}
-	async runExecuteSteps(driver, steps, operation) {
-		for (const step of steps) try {
-			await driver.query(step.sql, step.params ?? []);
-		} catch (error) {
-			if (SqlQueryError.is(error)) return runnerFailure("MIGRATION.EXECUTION_FAILED", `Operation ${operation.id} failed during execution: ${step.description}`, {
-				why: error.message,
-				meta: {
-					operationId: operation.id,
-					stepDescription: step.description,
-					sql: step.sql,
-					sqlState: error.sqlState,
-					constraint: error.constraint,
-					table: error.table,
-					column: error.column,
-					detail: error.detail
-				}
-			});
-			throw error;
-		}
-		return okVoid();
-	}
-	stepResultIsTrue(rows) {
-		if (!rows || rows.length === 0) return false;
-		const firstRow = rows[0];
-		const firstValue = firstRow ? Object.values(firstRow)[0] : void 0;
-		if (typeof firstValue === "boolean") return firstValue;
-		if (typeof firstValue === "number") return firstValue !== 0;
-		if (typeof firstValue === "string") {
-			const lower = firstValue.toLowerCase();
-			if (lower === "t" || lower === "true" || lower === "1") return true;
-			if (lower === "f" || lower === "false" || lower === "0") return false;
-			return firstValue.length > 0;
-		}
-		return Boolean(firstValue);
-	}
-	async expectationsAreSatisfied(driver, steps) {
-		if (steps.length === 0) return false;
-		for (const step of steps) {
-			const result = await driver.query(step.sql, step.params ?? []);
-			if (!this.stepResultIsTrue(result.rows)) return false;
-		}
-		return true;
-	}
-	createPostcheckPreSatisfiedSkipRecord(operation) {
-		const clonedMeta = operation.meta ? cloneAndFreezeRecord(operation.meta) : void 0;
-		const runnerMeta = Object.freeze({
-			skipped: true,
-			reason: "postcheck_pre_satisfied"
-		});
-		const mergedMeta = Object.freeze({
-			...clonedMeta ?? {},
-			runner: runnerMeta
-		});
-		const frozenPostcheck = Object.freeze([...operation.postcheck]);
-		return Object.freeze({
-			id: operation.id,
-			label: operation.label,
-			...ifDefined("summary", operation.summary),
-			operationClass: operation.operationClass,
-			target: operation.target,
-			precheck: Object.freeze([]),
-			execute: Object.freeze([]),
-			postcheck: frozenPostcheck,
-			...ifDefined("meta", operation.meta || mergedMeta ? mergedMeta : void 0)
-		});
-	}
-	markerMatchesDestination(marker, plan) {
-		if (!marker) return false;
-		if (marker.storageHash !== plan.destination.storageHash) return false;
-		if (plan.destination.profileHash && marker.profileHash !== plan.destination.profileHash) return false;
-		return true;
-	}
-	enforcePolicyCompatibility(policy, operations) {
-		const allowedClasses = new Set(policy.allowedOperationClasses);
-		for (const operation of operations) if (!allowedClasses.has(operation.operationClass)) return runnerFailure("MIGRATION.POLICY_VIOLATION", `Operation ${operation.id} has class "${operation.operationClass}" which is not allowed by policy.`, {
-			why: `Policy only allows: ${policy.allowedOperationClasses.join(", ")}.`,
-			meta: {
-				operationId: operation.id,
-				operationClass: operation.operationClass,
-				allowedClasses: policy.allowedOperationClasses
-			}
-		});
-		return okVoid();
-	}
-	ensureMarkerCompatibility(marker, plan) {
-		const origin = plan.origin ?? null;
-		if (!origin) return okVoid();
-		if (!marker) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
-		if (marker.storageHash !== origin.storageHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
-			markerStorageHash: marker.storageHash,
-			expectedOriginStorageHash: origin.storageHash
-		} });
-		if (origin.profileHash && marker.profileHash !== origin.profileHash) return runnerFailure("MIGRATION.MARKER_ORIGIN_MISMATCH", `Existing contract marker profile hash (${marker.profileHash}) does not match plan origin profile hash (${origin.profileHash}).`, { meta: {
-			markerProfileHash: marker.profileHash,
-			expectedOriginProfileHash: origin.profileHash
-		} });
-		return okVoid();
-	}
-	ensurePlanMatchesDestinationContract(destination, contract) {
-		if (destination.storageHash !== contract.storage.storageHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination storage hash (${destination.storageHash}) does not match provided contract storage hash (${contract.storage.storageHash}).`, { meta: {
-			planStorageHash: destination.storageHash,
-			contractStorageHash: contract.storage.storageHash
-		} });
-		if (destination.profileHash && contract.profileHash && destination.profileHash !== contract.profileHash) return runnerFailure("MIGRATION.DESTINATION_CONTRACT_MISMATCH", `Plan destination profile hash (${destination.profileHash}) does not match provided contract profile hash (${contract.profileHash}).`, { meta: {
-			planProfileHash: destination.profileHash,
-			contractProfileHash: contract.profileHash
-		} });
-		return okVoid();
-	}
-	async upsertMarker(driver, options, existingMarker, space) {
-		const destination = {
-			storageHash: options.plan.destination.storageHash,
-			profileHash: options.plan.destination.profileHash ?? options.destinationContract.profileHash ?? options.plan.destination.storageHash,
-			invariants: options.plan.providedInvariants ?? []
-		};
-		if (!existingMarker) {
-			await this.family.initMarker({
-				driver,
-				space,
-				destination
-			});
-			return okVoid();
-		}
-		if (!await this.family.updateMarker({
-			driver,
-			space,
-			expectedFrom: existingMarker.storageHash,
-			destination
-		})) return runnerFailure("MIGRATION.MARKER_CAS_FAILURE", "Marker was modified by another process during migration execution.", { meta: {
-			space,
-			expectedStorageHash: existingMarker.storageHash,
-			destinationStorageHash: options.plan.destination.storageHash
-		} });
-		return okVoid();
-	}
-	async recordLedgerEntries(driver, options, executedOperations, planOpsLength) {
-		const space = options.plan.spaceId;
-		const edges = options.migrationEdges;
-		const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
-		if (totalEdgeOps !== planOpsLength) throw new InternalError(`Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`);
-		let offset = 0;
-		for (const edge of edges) {
-			const edgeOps = executedOperations.slice(offset, offset + edge.operationCount);
-			offset += edge.operationCount;
-			await this.family.writeLedgerEntry({
-				driver,
-				space,
-				entry: {
-					edgeId: `${edge.from}->${edge.to}`,
-					from: edge.from,
-					to: edge.to,
-					migrationName: edge.dirName,
-					migrationHash: edge.migrationHash,
-					operations: edgeOps,
-					...ifDefined("destinationContractJson", edge.destinationContractJson)
-				}
-			});
-		}
-	}
-	async acquireLock(driver, key) {
-		await driver.query("select pg_advisory_xact_lock(hashtext($1))", [key]);
-	}
-	async beginTransaction(driver) {
-		await driver.query("BEGIN");
-	}
-	async commitTransaction(driver) {
-		await driver.query("COMMIT");
-	}
-	async rollbackTransaction(driver) {
-		await driver.query("ROLLBACK");
-	}
-	async executeStatement(driver, statement) {
-		await driver.query(statement.sql, statement.params);
-	}
-};
-/**
-* Postgres target `SchemaVerifier` concretion. Plugs into the
-* SQL-shared verification surface; production verification today still
-* routes through the family verify verdict (`verifySqlSchemaByDiff` over
-* `diffPostgresSchema`), which carries options (codec hooks,
-* normalizers, framework components) that the framework-level
-* `SchemaVerifyOptions` shape does not yet surface.
-*
-* The hooks return the empty list pending the call-site migration that
-* routes the existing verifier behaviour through the SPI — at that
-* point `verifyCommonSqlSchema` will likely lift onto the family base
-* (mirroring `verifyCommonMongoSchema`) and `verifyTargetExtensions`
-* will house Postgres-only kinds (functions, RLS policies in a future
-* project).
-*/
-var PostgresSchemaVerifier = class extends SqlSchemaVerifierBase {
-	verifyCommonSqlSchema(_options) {
-		return [];
-	}
-	verifyTargetExtensions(_options) {
-		return [];
-	}
-};
+//#region ../../../3-targets/3-targets/postgres/dist/infer-psl-contract-BaZaJAD9.mjs
 function buildFieldNamesByTable(tables) {
 	const fieldNamesByTable = /* @__PURE__ */ new Map();
 	for (const table of Object.values(tables)) {
@@ -560,18 +156,79 @@ function namedArg(name, value) {
 function escapePslString(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
 }
+const INTEGER_TEXT = /^-?\d+$/;
+const SPECIAL_VALUE_TEXT = /^(?:NaN|-?Infinity)$/;
+const DECIMAL_TEXT = /^(?:-?\d+(?:\.\d+)?|NaN|-?Infinity)$/;
+/** PSL has no exponent syntax, so the decimal point moves to where the exponent puts it. */
+function plainNumeral(value) {
+	const [coefficient = "", exponent] = String(value).split("e");
+	if (exponent === void 0) return coefficient;
+	const sign = coefficient.startsWith("-") ? "-" : "";
+	const [whole = "", fraction = ""] = coefficient.slice(sign.length).split(".");
+	const digits = `${whole}${fraction}`;
+	const point = whole.length + Number(exponent);
+	if (point <= 0) return `${sign}0.${"0".repeat(-point)}${digits}`;
+	if (point >= digits.length) return `${sign}${digits}${"0".repeat(point - digits.length)}`;
+	return `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;
+}
+const formatPslValue = (value) => {
+	if (typeof value === "string") return `"${escapePslString(value)}"`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+};
+const formatNumber = (value) => typeof value === "number" && Number.isFinite(value) ? plainNumeral(value) : void 0;
+/** PSL has no number for `NaN` or `Infinity`; the float codecs pass their quoted text through. */
+const formatFloat = (value) => typeof value === "string" && SPECIAL_VALUE_TEXT.test(value) ? `"${value}"` : formatNumber(value);
+/**
+* `pg/int8@1` reads a PSL number from the text written, so every digit of an `int8` survives. A
+* PSL string is not a `bigint`. A JavaScript number past the safe integer range is already rounded.
+*/
+const formatInteger = (value) => {
+	if (typeof value === "string") return INTEGER_TEXT.test(value) ? value : void 0;
+	return typeof value === "number" && Number.isSafeInteger(value) ? String(value) : void 0;
+};
 /**
-* Formats a resolved literal-default array as PSL literal-list syntax
-* (`[1, 2, 3]`, `["a", "b"]`, `[]`). PSL's list-literal grammar only accepts
-* string/number/boolean elements, so any other element (e.g. `null`, a
-* nested array/object) makes the value unrepresentable and this returns
-* `undefined`.
+* `pg/numeric@1` stores decimal text, `NaN` or `Infinity`, and reads a PSL string as that text. A
+* PSL number would also keep every digit, but has no spelling for `NaN` or `Infinity`.
 */
-function formatPslListLiteralValue(elements) {
+const formatDecimalText = (value) => {
+	const text = typeof value === "number" && Number.isFinite(value) ? plainNumeral(value) : value;
+	return typeof text === "string" && DECIMAL_TEXT.test(text) ? `"${text}"` : void 0;
+};
+/**
+* The codecs of `Date`, `Time`, `Timestamp` and `Timestamptz` encode Temporal values, which no PSL
+* literal is. A JSON codec reads a PSL string as a JSON string, not as JSON text, so a JSON default
+* keeps its raw expression.
+*/
+const noLiteral = () => void 0;
+const DEFAULT_VALUE_FORMATS = /* @__PURE__ */ new Map([
+	["Int", formatNumber],
+	["SmallInt", formatNumber],
+	["Float", formatFloat],
+	["Real", formatFloat],
+	["BigInt", formatInteger],
+	["Numeric", formatDecimalText],
+	["Date", noLiteral],
+	["Time", noLiteral],
+	["Timestamp", noLiteral],
+	["Timestamptz", noLiteral],
+	["Json", noLiteral],
+	["Jsonb", noLiteral]
+]);
+/** The default value format for a field of a PSL type the Postgres type map resolves. */
+function pslDefaultValueFormat(typeName) {
+	return DEFAULT_VALUE_FORMATS.get(typeName) ?? formatPslValue;
+}
+/**
+* Formats a resolved list default as PSL literal-list syntax (`[1, 2]`, `["a"]`, `[]`), or returns
+* `undefined` when any element has no literal, such as `null` or a value `format` refuses.
+*/
+function formatPslListLiteralValue(elements, format) {
 	const parts = [];
-	for (const element of elements) if (typeof element === "string") parts.push(`"${escapePslString(element)}"`);
-	else if (typeof element === "number" || typeof element === "boolean") parts.push(String(element));
-	else return;
+	for (const element of elements) {
+		const part = format(element);
+		if (part === void 0) return void 0;
+		parts.push(part);
+	}
 	return `[${parts.join(", ")}]`;
 }
 /**
@@ -954,17 +611,8 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, def
 	const attributes = [];
 	const isId = isSinglePk && pkColumns.has(column.name);
 	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
-	if (column.default === void 0 && column.resolvedDefault?.kind === "function" && column.resolvedDefault.expression === "autoincrement()") attributes.push(parseDefaultAttributeString("@default(autoincrement())"));
-	else if (column.many === true && column.resolvedDefault?.kind === "literal") {
-		const formatted = Array.isArray(column.resolvedDefault.value) ? formatPslListLiteralValue(column.resolvedDefault.value) : void 0;
-		if (formatted !== void 0) attributes.push(parseDefaultAttributeString(`@default(${formatted})`));
-	} else if (column.default !== void 0) {
-		const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
-		if (parsed) {
-			const result = mapDefault(parsed, defaultMapping);
-			if ("attribute" in result) attributes.push(parseDefaultAttributeString(result.attribute));
-		}
-	}
+	const defaultAttribute = inferDefaultAttribute(column, enumPslName === void 0 ? pslDefaultValueFormat(resolution.pslType.name) : formatPslValue, defaultMapping, rawDefaultParser);
+	if (defaultAttribute !== void 0) attributes.push(parseDefaultAttributeString(defaultAttribute));
 	if (uniqueColumns.has(column.name) && !isId) {
 		const uniqueConstraintName = uniqueColumns.get(column.name);
 		attributes.push(buildSimpleConstraintFieldAttribute("unique", uniqueConstraintName));
@@ -990,6 +638,34 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, def
 		span: SYNTHETIC_SPAN
 	};
 }
+/**
+* A literal default prints as the PSL literal its codec accepts. A literal that has no such PSL
+* literal prints as `dbgenerated(...)` with the expression Postgres reported: `contract emit`
+* accepts that on a scalar column and rejects it at the field on a list column.
+*/
+function inferDefaultAttribute(column, valueFormat, defaultMapping, rawDefaultParser) {
+	if (column.default === void 0 && column.resolvedDefault?.kind === "function" && column.resolvedDefault.expression === "autoincrement()") return "@default(autoincrement())";
+	if (column.many === true && column.resolvedDefault?.kind === "literal") {
+		const { value } = column.resolvedDefault;
+		return Array.isArray(value) ? literalOrRawAttribute(formatPslListLiteralValue(value, valueFormat), column, defaultMapping) : void 0;
+	}
+	const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
+	if (parsed === void 0) return;
+	if (parsed.kind === "literal") return literalOrRawAttribute(valueFormat(parsed.value), column, defaultMapping);
+	return mappedAttribute(parsed, defaultMapping);
+}
+function literalOrRawAttribute(literal, column, defaultMapping) {
+	if (literal !== void 0) return `@default(${literal})`;
+	return typeof column.default === "string" ? mappedAttribute({
+		kind: "function",
+		expression: column.default
+	}, defaultMapping) : void 0;
+}
+/** A default the mapping can only describe in a comment is dropped: a field AST node has no comment. */
+function mappedAttribute(columnDefault, defaultMapping) {
+	const result = mapDefault(columnDefault, defaultMapping);
+	return "attribute" in result ? result.attribute : void 0;
+}
 function buildRelationField(rel, hostTableName, fieldNamesByTable, usedFieldNames) {
 	const fieldName = createUniqueFieldName(rel.fieldName, usedFieldNames);
 	usedFieldNames.add(fieldName);
@@ -1235,8 +911,9 @@ function createPostgresTypeMap(enumTypeNames) {
 *
 * Target-owned inference: it walks the `PostgresDatabaseSchemaNode` tree and
 * owns the Postgres dialect knowledge — the native type map and default map.
-* Relation inference, name transforms, generic default mapping, and raw-default
-* parsing are shape-neutral utilities imported from the SQL family.
+* It reads raw defaults with `parsePostgresDefault`, the parser introspection
+* and verify use. Relation inference, name transforms, and generic default
+* mapping are shape-neutral utilities imported from the SQL family.
 *
 * The tree's tables (across its namespaces — `contract infer` introspects a
 * single live namespace) are gathered into the model set and emitted in one
@@ -1323,7 +1000,7 @@ function inferPostgresPslContract(tree, describedContracts) {
 	return buildPslDocumentAst(schemaIR, {
 		typeMap: createPostgresTypeMap(enumInfo.typeNames),
 		defaultMapping: createPostgresDefaultMapping(),
-		parseRawDefault,
+		parseRawDefault: parsePostgresDefault,
 		...enumDefinitions.size > 0 ? { enumInfo } : {}
 	}, {
 		extraRelationsByTable,
@@ -1406,62 +1083,7 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName,
 		span: SYNTHETIC_SPAN
 	};
 }
-function postgresRenderDefault(def, column) {
-	if (def.kind === "function") return def.expression;
-	return renderDefaultLiteral(def.value, column);
-}
-const postgresTargetDescriptor = {
-	...postgresTargetDescriptorMeta,
-	contractSerializer: new PostgresContractSerializer(),
-	schemaVerifier: new PostgresSchemaVerifier(),
-	inferPslContract(schema, describedContracts) {
-		PostgresDatabaseSchemaNode.assert(schema);
-		return inferPostgresPslContract(schema, describedContracts);
-	},
-	diffSchema(input) {
-		return diffPostgresSchema(input);
-	},
-	classifySubjectGranularity: postgresDiffSubjectGranularity,
-	classifyEntityKind: postgresDiffSubjectEntityKind,
-	migrations: {
-		createPlanner(adapter) {
-			return createPostgresMigrationPlanner(adapter);
-		},
-		createRunner(family) {
-			return createPostgresMigrationRunner(family);
-		},
-		contractToSchema(contract, frameworkComponents) {
-			const expander = buildNativeTypeExpander(frameworkComponents);
-			return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
-				annotationNamespace: "pg",
-				...ifDefined("expandNativeType", expander),
-				renderDefault: postgresRenderDefault,
-				resolveDefault: postgresResolveDefault
-			});
-		}
-	},
-	create() {
-		return {
-			familyId: "sql",
-			targetId: "postgres"
-		};
-	},
-	/**
-	* Direct method for SQL-specific usage.
-	* @deprecated Use migrations.createPlanner() for CLI compatibility.
-	*/
-	createPlanner(adapter) {
-		return createPostgresMigrationPlanner(adapter);
-	},
-	/**
-	* Direct method for SQL-specific usage.
-	* @deprecated Use migrations.createRunner() for CLI compatibility.
-	*/
-	createRunner(family) {
-		return createPostgresMigrationRunner(family);
-	}
-};
 //#endregion
-export { postgresTargetDescriptor as n, postgresRenderDefault as t };
+export { inferPostgresPslContract as i, createPostgresDefaultMapping as n, createPostgresTypeMap as r, buildPslDocumentAst as t };
 
-//# sourceMappingURL=control-BC3oXXIK.mjs.map
+//# sourceMappingURL=infer-psl-contract-BaZaJAD9-DTVu5Zab.mjs.map