@prisma-next/adapter-postgres 0.3.0-pr.99.6 → 0.3.0

package/dist/control.mjs

@@ -0,0 +1,776 @@
+import { i as quoteIdentifier, n as escapeLiteral, r as qualifyName, t as SqlEscapeError } from "./sql-utils-CSfAGEwF.mjs";
+import { n as pgEnumControlHooks, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-DemWrTfB.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { builtinGeneratorRegistryMetadata, resolveBuiltinGeneratedColumnDescriptor } from "@prisma-next/ids";
+
+//#region src/core/default-normalizer.ts
+/**
+* Pre-compiled regex patterns for performance.
+* These are compiled once at module load time rather than on each function call.
+*/
+const NEXTVAL_PATTERN = /^nextval\s*\(/i;
+const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
+const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
+const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
+const TEXT_CAST_SUFFIX = /::text$/i;
+const NOW_LITERAL_PATTERN = /^'now'$/i;
+const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
+const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
+const NULL_PATTERN = /^NULL(?:::.+)?$/i;
+const TRUE_PATTERN = /^true$/i;
+const FALSE_PATTERN = /^false$/i;
+const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
+const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
+/**
+* Returns the canonical expression for a timestamp default function, or undefined
+* if the expression is not a recognized timestamp default.
+*
+* Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:
+* - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'
+* - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'
+*
+* These are semantically different in Postgres: now() returns the transaction
+* start time (constant within a transaction), while clock_timestamp() returns
+* the actual wall-clock time (can differ across rows in a single INSERT).
+*/
+function canonicalizeTimestampDefault(expr) {
+	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
+	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
+	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
+	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
+	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
+	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
+	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
+	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
+	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
+}
+/**
+* Parses a raw Postgres column default expression into a normalized ColumnDefault.
+* This enables semantic comparison between contract defaults and introspected schema defaults.
+*
+* Used by the migration diff layer to normalize raw database defaults during comparison,
+* keeping the introspection layer focused on faithful data capture.
+*
+* @param rawDefault - Raw default expression from information_schema.columns.column_default
+* @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
+* @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
+*/
+function parsePostgresDefault(rawDefault, nativeType) {
+	const trimmed = rawDefault.trim();
+	const normalizedType = nativeType?.toLowerCase();
+	const isBigInt = normalizedType === "bigint" || normalizedType === "int8";
+	if (NEXTVAL_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "autoincrement()"
+	};
+	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
+	if (canonicalTimestamp) return {
+		kind: "function",
+		expression: canonicalTimestamp
+	};
+	if (UUID_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "gen_random_uuid()"
+	};
+	if (UUID_OSSP_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "gen_random_uuid()"
+	};
+	if (NULL_PATTERN.test(trimmed)) return {
+		kind: "literal",
+		value: null
+	};
+	if (TRUE_PATTERN.test(trimmed)) return {
+		kind: "literal",
+		value: true
+	};
+	if (FALSE_PATTERN.test(trimmed)) return {
+		kind: "literal",
+		value: false
+	};
+	if (NUMERIC_PATTERN.test(trimmed)) {
+		const num = Number(trimmed);
+		if (!Number.isFinite(num)) return void 0;
+		if (isBigInt && !Number.isSafeInteger(num)) return {
+			kind: "literal",
+			value: trimmed
+		};
+		return {
+			kind: "literal",
+			value: num
+		};
+	}
+	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
+	if (stringMatch?.[1] !== void 0) {
+		const unescaped = stringMatch[1].replace(/''/g, "'");
+		if (normalizedType === "json" || normalizedType === "jsonb") try {
+			return {
+				kind: "literal",
+				value: JSON.parse(unescaped)
+			};
+		} catch {}
+		if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {
+			const num = Number(unescaped);
+			if (Number.isSafeInteger(num)) return {
+				kind: "literal",
+				value: num
+			};
+			return {
+				kind: "literal",
+				value: unescaped
+			};
+		}
+		return {
+			kind: "literal",
+			value: unescaped
+		};
+	}
+	return {
+		kind: "function",
+		expression: trimmed
+	};
+}
+
+//#endregion
+//#region src/core/control-adapter.ts
+/**
+* Postgres control plane adapter for control-plane operations like introspection.
+* Provides target-specific implementations for control-plane domain actions.
+*/
+var PostgresControlAdapter = class {
+	familyId = "sql";
+	targetId = "postgres";
+	/**
+	* Target-specific normalizer for raw Postgres default expressions.
+	* Used by schema verification to normalize raw defaults before comparison.
+	*/
+	normalizeDefault = parsePostgresDefault;
+	/**
+	* Target-specific normalizer for Postgres schema native type names.
+	* Used by schema verification to normalize introspected type names
+	* before comparison with contract native types.
+	*/
+	normalizeNativeType = normalizeSchemaNativeType;
+	/**
+	* Introspects a Postgres database schema and returns a raw SqlSchemaIR.
+	*
+	* This is a pure schema discovery operation that queries the Postgres catalog
+	* and returns the schema structure without type mapping or contract enrichment.
+	* Type mapping and enrichment are handled separately by enrichment helpers.
+	*
+	* Uses batched queries to minimize database round trips (7 queries instead of 5T+3).
+	*
+	* @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
+	* @param contract - Optional contract for contract-guided introspection (filtering, optimization)
+	* @param schema - Schema name to introspect (defaults to 'public')
+	* @returns Promise resolving to SqlSchemaIR representing the live database schema
+	*/
+	async introspect(driver, _contract, schema = "public") {
+		const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, extensionsResult] = await Promise.all([
+			driver.query(`SELECT table_name
+         FROM information_schema.tables
+         WHERE table_schema = $1
+           AND table_type = 'BASE TABLE'
+         ORDER BY table_name`, [schema]),
+			driver.query(`SELECT
+           c.table_name,
+           column_name,
+           data_type,
+           udt_name,
+           is_nullable,
+           character_maximum_length,
+           numeric_precision,
+           numeric_scale,
+           column_default,
+           format_type(a.atttypid, a.atttypmod) AS formatted_type
+         FROM information_schema.columns c
+         JOIN pg_catalog.pg_class cl
+           ON cl.relname = c.table_name
+         JOIN pg_catalog.pg_namespace ns
+           ON ns.nspname = c.table_schema
+           AND ns.oid = cl.relnamespace
+         JOIN pg_catalog.pg_attribute a
+           ON a.attrelid = cl.oid
+           AND a.attname = c.column_name
+           AND a.attnum > 0
+           AND NOT a.attisdropped
+         WHERE c.table_schema = $1
+         ORDER BY c.table_name, c.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           tc.table_name,
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = $1
+           AND tc.constraint_type = 'PRIMARY KEY'
+         ORDER BY tc.table_name, kcu.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           tc.table_name,
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position,
+           ref_ns.nspname AS referenced_table_schema,
+           ref_cl.relname AS referenced_table_name,
+           ref_att.attname AS referenced_column_name,
+           rc.delete_rule,
+           rc.update_rule
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         JOIN pg_catalog.pg_constraint pgc
+           ON pgc.conname = tc.constraint_name
+           AND pgc.connamespace = (
+             SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = tc.table_schema
+           )
+         JOIN pg_catalog.pg_class ref_cl
+           ON ref_cl.oid = pgc.confrelid
+         JOIN pg_catalog.pg_namespace ref_ns
+           ON ref_ns.oid = ref_cl.relnamespace
+         JOIN pg_catalog.pg_attribute ref_att
+           ON ref_att.attrelid = pgc.confrelid
+           AND ref_att.attnum = pgc.confkey[kcu.ordinal_position]
+         JOIN information_schema.referential_constraints rc
+           ON rc.constraint_name = tc.constraint_name
+           AND rc.constraint_schema = tc.table_schema
+         WHERE tc.table_schema = $1
+           AND tc.constraint_type = 'FOREIGN KEY'
+         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           tc.table_name,
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = $1
+           AND tc.constraint_type = 'UNIQUE'
+         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`, [schema]),
+			driver.query(`SELECT
+           i.tablename,
+           i.indexname,
+           ix.indisunique,
+           a.attname,
+           a.attnum
+         FROM pg_indexes i
+         JOIN pg_class ic ON ic.relname = i.indexname
+         JOIN pg_namespace ins ON ins.oid = ic.relnamespace AND ins.nspname = $1
+         JOIN pg_index ix ON ix.indexrelid = ic.oid
+         JOIN pg_class t ON t.oid = ix.indrelid
+         JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1
+         LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey) AND a.attnum > 0
+         WHERE i.schemaname = $1
+           AND NOT EXISTS (
+             SELECT 1
+             FROM information_schema.table_constraints tc
+             WHERE tc.table_schema = $1
+               AND tc.table_name = i.tablename
+               AND tc.constraint_name = i.indexname
+           )
+         ORDER BY i.tablename, i.indexname, a.attnum`, [schema]),
+			driver.query(`SELECT extname
+         FROM pg_extension
+         ORDER BY extname`, [])
+		]);
+		const columnsByTable = groupBy(columnsResult.rows, "table_name");
+		const pksByTable = groupBy(pkResult.rows, "table_name");
+		const fksByTable = groupBy(fkResult.rows, "table_name");
+		const uniquesByTable = groupBy(uniqueResult.rows, "table_name");
+		const indexesByTable = groupBy(indexResult.rows, "tablename");
+		const pkConstraintsByTable = /* @__PURE__ */ new Map();
+		for (const row of pkResult.rows) {
+			let constraints = pkConstraintsByTable.get(row.table_name);
+			if (!constraints) {
+				constraints = /* @__PURE__ */ new Set();
+				pkConstraintsByTable.set(row.table_name, constraints);
+			}
+			constraints.add(row.constraint_name);
+		}
+		const tables = {};
+		for (const tableRow of tablesResult.rows) {
+			const tableName = tableRow.table_name;
+			const columns = {};
+			for (const colRow of columnsByTable.get(tableName) ?? []) {
+				let nativeType = colRow.udt_name;
+				const formattedType = colRow.formatted_type ? normalizeFormattedType(colRow.formatted_type, colRow.data_type, colRow.udt_name) : null;
+				if (formattedType) nativeType = formattedType;
+				else if (colRow.data_type === "character varying" || colRow.data_type === "character") if (colRow.character_maximum_length) nativeType = `${colRow.data_type}(${colRow.character_maximum_length})`;
+				else nativeType = colRow.data_type;
+				else if (colRow.data_type === "numeric" || colRow.data_type === "decimal") if (colRow.numeric_precision && colRow.numeric_scale !== null) nativeType = `${colRow.data_type}(${colRow.numeric_precision},${colRow.numeric_scale})`;
+				else if (colRow.numeric_precision) nativeType = `${colRow.data_type}(${colRow.numeric_precision})`;
+				else nativeType = colRow.data_type;
+				else nativeType = colRow.udt_name || colRow.data_type;
+				columns[colRow.column_name] = {
+					name: colRow.column_name,
+					nativeType,
+					nullable: colRow.is_nullable === "YES",
+					...ifDefined("default", colRow.column_default ?? void 0)
+				};
+			}
+			const pkRows = [...pksByTable.get(tableName) ?? []];
+			const primaryKeyColumns = pkRows.sort((a, b) => a.ordinal_position - b.ordinal_position).map((row) => row.column_name);
+			const primaryKey = primaryKeyColumns.length > 0 ? {
+				columns: primaryKeyColumns,
+				...pkRows[0]?.constraint_name ? { name: pkRows[0].constraint_name } : {}
+			} : void 0;
+			const foreignKeysMap = /* @__PURE__ */ new Map();
+			for (const fkRow of fksByTable.get(tableName) ?? []) {
+				const existing = foreignKeysMap.get(fkRow.constraint_name);
+				if (existing) {
+					existing.columns.push(fkRow.column_name);
+					existing.referencedColumns.push(fkRow.referenced_column_name);
+				} else foreignKeysMap.set(fkRow.constraint_name, {
+					columns: [fkRow.column_name],
+					referencedTable: fkRow.referenced_table_name,
+					referencedColumns: [fkRow.referenced_column_name],
+					name: fkRow.constraint_name,
+					deleteRule: fkRow.delete_rule,
+					updateRule: fkRow.update_rule
+				});
+			}
+			const foreignKeys = Array.from(foreignKeysMap.values()).map((fk) => ({
+				columns: Object.freeze([...fk.columns]),
+				referencedTable: fk.referencedTable,
+				referencedColumns: Object.freeze([...fk.referencedColumns]),
+				name: fk.name,
+				...ifDefined("onDelete", mapReferentialAction(fk.deleteRule)),
+				...ifDefined("onUpdate", mapReferentialAction(fk.updateRule))
+			}));
+			const pkConstraints = pkConstraintsByTable.get(tableName) ?? /* @__PURE__ */ new Set();
+			const uniquesMap = /* @__PURE__ */ new Map();
+			for (const uniqueRow of uniquesByTable.get(tableName) ?? []) {
+				if (pkConstraints.has(uniqueRow.constraint_name)) continue;
+				const existing = uniquesMap.get(uniqueRow.constraint_name);
+				if (existing) existing.columns.push(uniqueRow.column_name);
+				else uniquesMap.set(uniqueRow.constraint_name, {
+					columns: [uniqueRow.column_name],
+					name: uniqueRow.constraint_name
+				});
+			}
+			const uniques = Array.from(uniquesMap.values()).map((uq) => ({
+				columns: Object.freeze([...uq.columns]),
+				name: uq.name
+			}));
+			const indexesMap = /* @__PURE__ */ new Map();
+			for (const idxRow of indexesByTable.get(tableName) ?? []) {
+				if (!idxRow.attname) continue;
+				const existing = indexesMap.get(idxRow.indexname);
+				if (existing) existing.columns.push(idxRow.attname);
+				else indexesMap.set(idxRow.indexname, {
+					columns: [idxRow.attname],
+					name: idxRow.indexname,
+					unique: idxRow.indisunique
+				});
+			}
+			const indexes = Array.from(indexesMap.values()).map((idx) => ({
+				columns: Object.freeze([...idx.columns]),
+				name: idx.name,
+				unique: idx.unique
+			}));
+			tables[tableName] = {
+				name: tableName,
+				columns,
+				...ifDefined("primaryKey", primaryKey),
+				foreignKeys,
+				uniques,
+				indexes
+			};
+		}
+		const dependencies = extensionsResult.rows.map((row) => ({ id: `postgres.extension.${row.extname}` }));
+		const storageTypes = await pgEnumControlHooks.introspectTypes?.({
+			driver,
+			schemaName: schema
+		}) ?? {};
+		return {
+			tables,
+			dependencies,
+			annotations: { pg: {
+				schema,
+				version: await this.getPostgresVersion(driver),
+				...ifDefined("storageTypes", Object.keys(storageTypes).length > 0 ? storageTypes : void 0)
+			} }
+		};
+	}
+	/**
+	* Gets the Postgres version from the database.
+	*/
+	async getPostgresVersion(driver) {
+		return ((await driver.query("SELECT version() AS version", [])).rows[0]?.version ?? "").match(/PostgreSQL (\d+\.\d+)/)?.[1] ?? "unknown";
+	}
+};
+/**
+* Pre-computed lookup map for simple prefix-based type normalization.
+* Maps short Postgres type names to their canonical SQL names.
+* Using a Map for O(1) lookup instead of multiple startsWith checks.
+*/
+const TYPE_PREFIX_MAP = new Map([
+	["varchar", "character varying"],
+	["bpchar", "character"],
+	["varbit", "bit varying"]
+]);
+/**
+* Normalizes a Postgres schema native type to its canonical form for comparison.
+*
+* Uses a pre-computed lookup map for simple prefix replacements (O(1))
+* and handles complex temporal type normalization separately.
+*/
+function normalizeSchemaNativeType(nativeType) {
+	const trimmed = nativeType.trim();
+	for (const [prefix, replacement] of TYPE_PREFIX_MAP) if (trimmed.startsWith(prefix)) return replacement + trimmed.slice(prefix.length);
+	if (trimmed.includes(" with time zone")) {
+		if (trimmed.startsWith("timestamp")) return `timestamptz${trimmed.slice(9).replace(" with time zone", "")}`;
+		if (trimmed.startsWith("time")) return `timetz${trimmed.slice(4).replace(" with time zone", "")}`;
+	}
+	if (trimmed.includes(" without time zone")) return trimmed.replace(" without time zone", "");
+	return trimmed;
+}
+function normalizeFormattedType(formattedType, dataType, udtName) {
+	if (formattedType === "integer") return "int4";
+	if (formattedType === "smallint") return "int2";
+	if (formattedType === "bigint") return "int8";
+	if (formattedType === "real") return "float4";
+	if (formattedType === "double precision") return "float8";
+	if (formattedType === "boolean") return "bool";
+	if (formattedType.startsWith("varchar")) return formattedType.replace("varchar", "character varying");
+	if (formattedType.startsWith("bpchar")) return formattedType.replace("bpchar", "character");
+	if (formattedType.startsWith("varbit")) return formattedType.replace("varbit", "bit varying");
+	if (dataType === "timestamp with time zone" || udtName === "timestamptz") return formattedType.replace("timestamp", "timestamptz").replace(" with time zone", "").trim();
+	if (dataType === "timestamp without time zone" || udtName === "timestamp") return formattedType.replace(" without time zone", "").trim();
+	if (dataType === "time with time zone" || udtName === "timetz") return formattedType.replace("time", "timetz").replace(" with time zone", "").trim();
+	if (dataType === "time without time zone" || udtName === "time") return formattedType.replace(" without time zone", "").trim();
+	if (formattedType.startsWith("\"") && formattedType.endsWith("\"")) return formattedType.slice(1, -1);
+	return formattedType;
+}
+const PG_REFERENTIAL_ACTION_MAP = {
+	"NO ACTION": "noAction",
+	RESTRICT: "restrict",
+	CASCADE: "cascade",
+	"SET NULL": "setNull",
+	"SET DEFAULT": "setDefault"
+};
+/**
+* Maps a Postgres referential action rule to the canonical SqlReferentialAction.
+* Returns undefined for 'NO ACTION' (the database default) to keep the IR sparse.
+* Throws for unrecognized rules to prevent silent data loss.
+*/
+function mapReferentialAction(rule) {
+	const mapped = PG_REFERENTIAL_ACTION_MAP[rule];
+	if (mapped === void 0) throw new Error(`Unknown PostgreSQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`);
+	if (mapped === "noAction") return void 0;
+	return mapped;
+}
+/**
+* Groups an array of objects by a specified key.
+* Returns a Map for O(1) lookup by group key.
+*/
+function groupBy(items, key) {
+	const map = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const groupKey = item[key];
+		let group = map.get(groupKey);
+		if (!group) {
+			group = [];
+			map.set(groupKey, group);
+		}
+		group.push(item);
+	}
+	return map;
+}
+
+//#endregion
+//#region src/core/control-mutation-defaults.ts
+function invalidArgumentDiagnostic(input) {
+	return {
+		ok: false,
+		diagnostic: {
+			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+			message: input.message,
+			sourceId: input.context.sourceId,
+			span: input.span
+		}
+	};
+}
+function executionGenerator(id, params) {
+	return {
+		ok: true,
+		value: {
+			kind: "execution",
+			generated: {
+				kind: "generator",
+				id,
+				...params ? { params } : {}
+			}
+		}
+	};
+}
+function expectNoArgs(input) {
+	if (input.call.args.length === 0) return;
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: `Default function "${input.call.name}" does not accept arguments. Use ${input.usage}.`
+	});
+}
+function parseIntegerArgument(raw) {
+	const trimmed = raw.trim();
+	if (!/^-?\d+$/.test(trimmed)) return;
+	const value = Number(trimmed);
+	if (!Number.isInteger(value)) return;
+	return value;
+}
+function parseStringLiteral(raw) {
+	const match = raw.trim().match(/^(['"])(.*)\1$/s);
+	if (!match) return;
+	return match[2] ?? "";
+}
+function lowerAutoincrement(input) {
+	const maybeNoArgs = expectNoArgs({
+		call: input.call,
+		context: input.context,
+		usage: "`autoincrement()`"
+	});
+	if (maybeNoArgs) return maybeNoArgs;
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression: "autoincrement()"
+			}
+		}
+	};
+}
+function lowerNow(input) {
+	const maybeNoArgs = expectNoArgs({
+		call: input.call,
+		context: input.context,
+		usage: "`now()`"
+	});
+	if (maybeNoArgs) return maybeNoArgs;
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression: "now()"
+			}
+		}
+	};
+}
+function lowerUuid(input) {
+	if (input.call.args.length === 0) return executionGenerator("uuidv4");
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"uuid\" accepts at most one version argument: `uuid()`, `uuid(4)`, or `uuid(7)`."
+	});
+	const version = parseIntegerArgument(input.call.args[0]?.raw ?? "");
+	if (version === 4) return executionGenerator("uuidv4");
+	if (version === 7) return executionGenerator("uuidv7");
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"uuid\" supports only `uuid()`, `uuid(4)`, or `uuid(7)` in SQL PSL provider v1."
+	});
+}
+function lowerCuid(input) {
+	if (input.call.args.length === 0) return {
+		ok: false,
+		diagnostic: {
+			code: "PSL_UNKNOWN_DEFAULT_FUNCTION",
+			message: "Default function \"cuid()\" is not supported in SQL PSL provider v1. Use `cuid(2)` instead.",
+			sourceId: input.context.sourceId,
+			span: input.call.span
+		}
+	};
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"cuid\" accepts exactly one version argument: `cuid(2)`."
+	});
+	if (parseIntegerArgument(input.call.args[0]?.raw ?? "") === 2) return executionGenerator("cuid2");
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"cuid\" supports only `cuid(2)` in SQL PSL provider v1."
+	});
+}
+function lowerUlid(input) {
+	const maybeNoArgs = expectNoArgs({
+		call: input.call,
+		context: input.context,
+		usage: "`ulid()`"
+	});
+	if (maybeNoArgs) return maybeNoArgs;
+	return executionGenerator("ulid");
+}
+function lowerNanoid(input) {
+	if (input.call.args.length === 0) return executionGenerator("nanoid");
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"nanoid\" accepts at most one size argument: `nanoid()` or `nanoid(<2-255>)`."
+	});
+	const size = parseIntegerArgument(input.call.args[0]?.raw ?? "");
+	if (size !== void 0 && size >= 2 && size <= 255) return executionGenerator("nanoid", { size });
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"nanoid\" size argument must be an integer between 2 and 255."
+	});
+}
+function lowerDbgenerated(input) {
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"dbgenerated\" requires exactly one string argument: `dbgenerated(\"...\")`."
+	});
+	const rawExpression = parseStringLiteral(input.call.args[0]?.raw ?? "");
+	if (rawExpression === void 0) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"dbgenerated\" argument must be a string literal."
+	});
+	if (rawExpression.trim().length === 0) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"dbgenerated\" argument cannot be empty."
+	});
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression: rawExpression
+			}
+		}
+	};
+}
+const postgresDefaultFunctionRegistryEntries = [
+	["autoincrement", {
+		lower: lowerAutoincrement,
+		usageSignatures: ["autoincrement()"]
+	}],
+	["now", {
+		lower: lowerNow,
+		usageSignatures: ["now()"]
+	}],
+	["uuid", {
+		lower: lowerUuid,
+		usageSignatures: [
+			"uuid()",
+			"uuid(4)",
+			"uuid(7)"
+		]
+	}],
+	["cuid", {
+		lower: lowerCuid,
+		usageSignatures: ["cuid(2)"]
+	}],
+	["ulid", {
+		lower: lowerUlid,
+		usageSignatures: ["ulid()"]
+	}],
+	["nanoid", {
+		lower: lowerNanoid,
+		usageSignatures: ["nanoid()", "nanoid(<2-255>)"]
+	}],
+	["dbgenerated", {
+		lower: lowerDbgenerated,
+		usageSignatures: ["dbgenerated(\"...\")"]
+	}]
+];
+const postgresPslScalarTypeDescriptors = new Map([
+	["String", {
+		codecId: "pg/text@1",
+		nativeType: "text"
+	}],
+	["Boolean", {
+		codecId: "pg/bool@1",
+		nativeType: "bool"
+	}],
+	["Int", {
+		codecId: "pg/int4@1",
+		nativeType: "int4"
+	}],
+	["BigInt", {
+		codecId: "pg/int8@1",
+		nativeType: "int8"
+	}],
+	["Float", {
+		codecId: "pg/float8@1",
+		nativeType: "float8"
+	}],
+	["Decimal", {
+		codecId: "pg/numeric@1",
+		nativeType: "numeric"
+	}],
+	["DateTime", {
+		codecId: "pg/timestamptz@1",
+		nativeType: "timestamptz"
+	}],
+	["Json", {
+		codecId: "pg/jsonb@1",
+		nativeType: "jsonb"
+	}],
+	["Bytes", {
+		codecId: "pg/bytea@1",
+		nativeType: "bytea"
+	}]
+]);
+function createPostgresDefaultFunctionRegistry() {
+	return new Map(postgresDefaultFunctionRegistryEntries);
+}
+function createPostgresMutationDefaultGeneratorDescriptors() {
+	return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
+		id,
+		applicableCodecIds,
+		resolveGeneratedColumnDescriptor: ({ generated }) => {
+			if (generated.kind !== "generator" || generated.id !== id) return;
+			const descriptor = resolveBuiltinGeneratedColumnDescriptor({
+				id,
+				...generated.params ? { params: generated.params } : {}
+			});
+			return {
+				codecId: descriptor.type.codecId,
+				nativeType: descriptor.type.nativeType,
+				...descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {},
+				...descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}
+			};
+		}
+	}));
+}
+function createPostgresPslScalarTypeDescriptors() {
+	return new Map(postgresPslScalarTypeDescriptors);
+}
+
+//#endregion
+//#region src/exports/control.ts
+const postgresAdapterDescriptor = {
+	...postgresAdapterDescriptorMeta,
+	pslTypeDescriptors: () => ({ scalarTypeDescriptors: createPostgresPslScalarTypeDescriptors() }),
+	controlMutationDefaults: () => ({
+		defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
+		generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors()
+	}),
+	create() {
+		return new PostgresControlAdapter();
+	}
+};
+var control_default = postgresAdapterDescriptor;
+
+//#endregion
+export { SqlEscapeError, control_default as default, escapeLiteral, normalizeSchemaNativeType, parsePostgresDefault, qualifyName, quoteIdentifier };
+//# sourceMappingURL=control.mjs.map