@prisma-next/adapter-postgres 0.3.0-dev.33 → 0.3.0-dev.36

package/dist/descriptor-meta-D7pxo-wo.mjs

@@ -0,0 +1,996 @@
+import { C as SQL_CHAR_CODEC_ID, E as SQL_VARCHAR_CODEC_ID, S as PG_VARCHAR_CODEC_ID, T as SQL_INT_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, f as PG_INT_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, r as PG_CHAR_CODEC_ID, s as PG_FLOAT_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, w as SQL_FLOAT_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-Bsm9c7ns.mjs";
+import { arraysEqual } from "@prisma-next/family-sql/schema-verify";
+
+//#region src/core/sql-utils.ts
+/**
+* Shared SQL utility functions for the Postgres adapter.
+*
+* These functions handle safe SQL identifier and literal escaping
+* with security validations to prevent injection and encoding issues.
+*/
+/**
+* Error thrown when an invalid SQL identifier or literal is detected.
+* Boundary layers map this to structured envelopes.
+*/
+var SqlEscapeError = class extends Error {
+	constructor(message, value, kind) {
+		super(message);
+		this.value = value;
+		this.kind = kind;
+		this.name = "SqlEscapeError";
+	}
+};
+/**
+* Maximum length for PostgreSQL identifiers (NAMEDATALEN - 1).
+*/
+const MAX_IDENTIFIER_LENGTH$1 = 63;
+/**
+* Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
+*
+* Security validations:
+* - Rejects null bytes which could cause truncation or unexpected behavior
+* - Rejects empty identifiers
+* - Warns on identifiers exceeding PostgreSQL's 63-character limit
+*
+* @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+*/
+function quoteIdentifier(identifier) {
+	if (identifier.length === 0) throw new SqlEscapeError("Identifier cannot be empty", identifier, "identifier");
+	if (identifier.includes("\0")) throw new SqlEscapeError("Identifier cannot contain null bytes", identifier.replace(/\0/g, "\\0"), "identifier");
+	if (identifier.length > MAX_IDENTIFIER_LENGTH$1) console.warn(`Identifier "${identifier.slice(0, 20)}..." exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH$1}-character limit and will be truncated`);
+	return `"${identifier.replace(/"/g, "\"\"")}"`;
+}
+/**
+* Escapes a string literal for safe use in SQL statements.
+*
+* Security validations:
+* - Rejects null bytes which could cause truncation or unexpected behavior
+*
+* Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
+* Backslashes are treated as literal characters, not escape sequences.
+*
+* @throws {SqlEscapeError} If the value contains null bytes
+*/
+function escapeLiteral(value) {
+	if (value.includes("\0")) throw new SqlEscapeError("Literal value cannot contain null bytes", value.replace(/\0/g, "\\0"), "literal");
+	return value.replace(/'/g, "''");
+}
+/**
+* Builds a qualified name (schema.object) with proper quoting.
+*/
+function qualifyName(schemaName, objectName) {
+	return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;
+}
+/**
+* Validates that an enum value doesn't exceed PostgreSQL's label length limit.
+*
+* PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).
+* Unlike identifiers, enum labels that exceed this limit cause an error rather than
+* silent truncation.
+*
+* @param value - The enum value to validate
+* @param enumTypeName - Name of the enum type (for error messages)
+* @throws {SqlEscapeError} If the value exceeds the maximum length
+*/
+function validateEnumValueLength(value, enumTypeName) {
+	if (value.length > MAX_IDENTIFIER_LENGTH$1) throw new SqlEscapeError(`Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH$1}-character label limit`, value, "literal");
+}
+
+//#endregion
+//#region src/core/enum-control-hooks.ts
+const ENUM_INTROSPECT_QUERY = `
+  SELECT
+    n.nspname AS schema_name,
+    t.typname AS type_name,
+    array_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+  FROM pg_type t
+  JOIN pg_namespace n ON t.typnamespace = n.oid
+  JOIN pg_enum e ON t.oid = e.enumtypid
+  WHERE n.nspname = $1
+  GROUP BY n.nspname, t.typname
+  ORDER BY n.nspname, t.typname
+`;
+/**
+* Type guard for string arrays. Used for runtime validation of introspected data.
+*/
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+/**
+* Parses a PostgreSQL array value into a JavaScript string array.
+*
+* PostgreSQL's `pg` library may return `array_agg` results either as:
+* - A JavaScript array (when type parsers are configured)
+* - A string in PostgreSQL array literal format: `{value1,value2,...}`
+*
+* Handles PostgreSQL's quoting rules for array elements:
+* - Elements containing commas, double quotes, backslashes, or whitespace are double-quoted
+* - Inside quoted elements, `\"` represents `"` and `\\` represents `\`
+*
+* @param value - The value to parse (array or PostgreSQL array string)
+* @returns A string array, or null if the value cannot be parsed
+*/
+function parsePostgresArray(value) {
+	if (isStringArray(value)) return value;
+	if (typeof value === "string" && value.startsWith("{") && value.endsWith("}")) {
+		const inner = value.slice(1, -1);
+		if (inner === "") return [];
+		return parseArrayElements(inner);
+	}
+	return null;
+}
+function parseArrayElements(input) {
+	const result = [];
+	let i = 0;
+	while (i < input.length) {
+		if (input[i] === ",") {
+			i++;
+			continue;
+		}
+		if (input[i] === "\"") {
+			i++;
+			let element = "";
+			while (i < input.length && input[i] !== "\"") {
+				if (input[i] === "\\" && i + 1 < input.length) {
+					i++;
+					element += input[i];
+				} else element += input[i];
+				i++;
+			}
+			i++;
+			result.push(element);
+		} else {
+			const nextComma = input.indexOf(",", i);
+			if (nextComma === -1) {
+				result.push(input.slice(i).trim());
+				i = input.length;
+			} else {
+				result.push(input.slice(i, nextComma).trim());
+				i = nextComma;
+			}
+		}
+	}
+	return result;
+}
+/**
+* Extracts enum values from a StorageTypeInstance.
+* Returns null if values are missing or invalid.
+*/
+function getEnumValues(typeInstance) {
+	const values = typeInstance.typeParams?.["values"];
+	return isStringArray(values) ? values : null;
+}
+/**
+* Reads existing enum values from the schema IR for a given native type.
+* Uses optional chaining to simplify navigation through the annotations structure.
+*/
+function readExistingEnumValues(schema, nativeType) {
+	const existing = ((schema.annotations?.["pg"])?.["storageTypes"])?.[nativeType];
+	if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) return null;
+	return getEnumValues(existing);
+}
+/**
+* Determines what changes are needed to transform existing enum values to desired values.
+*
+* Returns one of:
+* - `unchanged`: No changes needed, values match exactly
+* - `add_values`: New values can be safely appended (PostgreSQL supports this)
+* - `rebuild`: Full enum rebuild required (value removal, reordering, or both)
+*
+* Note: PostgreSQL enums can only have values added (not removed or reordered) without
+* a full type rebuild involving temp type creation and column migration.
+*
+* @param existing - Current enum values in the database
+* @param desired - Target enum values from the contract
+* @returns The type of change required
+*/
+function determineEnumDiff(existing, desired) {
+	if (arraysEqual(existing, desired)) return { kind: "unchanged" };
+	const existingSet = new Set(existing);
+	const desiredSet = new Set(desired);
+	const missingValues = desired.filter((value) => !existingSet.has(value));
+	const removedValues = existing.filter((value) => !desiredSet.has(value));
+	const orderMismatch = missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);
+	if (removedValues.length > 0 || orderMismatch) return {
+		kind: "rebuild",
+		removedValues
+	};
+	return {
+		kind: "add_values",
+		values: missingValues
+	};
+}
+function enumTypeExistsCheck(schemaName, typeName, exists = true) {
+	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
+  SELECT 1
+  FROM pg_type t
+  JOIN pg_namespace n ON t.typnamespace = n.oid
+  WHERE n.nspname = '${escapeLiteral(schemaName)}'
+    AND t.typname = '${escapeLiteral(typeName)}'
+)`;
+}
+function buildCreateEnumOperation(typeName, nativeType, schemaName, values) {
+	for (const value of values) validateEnumValueLength(value, typeName);
+	const literalValues = values.map((value) => `'${escapeLiteral(value)}'`).join(", ");
+	const qualifiedType = qualifyName(schemaName, nativeType);
+	return {
+		id: `type.${typeName}`,
+		label: `Create type ${typeName}`,
+		summary: `Creates enum type ${typeName}`,
+		operationClass: "additive",
+		target: { id: "postgres" },
+		precheck: [{
+			description: `ensure type "${nativeType}" does not exist`,
+			sql: enumTypeExistsCheck(schemaName, nativeType, false)
+		}],
+		execute: [{
+			description: `create type "${nativeType}"`,
+			sql: `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`
+		}],
+		postcheck: [{
+			description: `verify type "${nativeType}" exists`,
+			sql: enumTypeExistsCheck(schemaName, nativeType)
+		}]
+	};
+}
+/**
+* Computes the optimal position for inserting a new enum value to maintain
+* the desired order relative to existing values.
+*
+* PostgreSQL's `ALTER TYPE ADD VALUE` supports BEFORE/AFTER positioning.
+* This function finds the best reference value by:
+* 1. Looking for the nearest preceding value that already exists
+* 2. Falling back to the nearest following value if no preceding exists
+* 3. Defaulting to end-of-list if no reference is found
+*
+* @param options.desired - The target ordered list of all enum values
+* @param options.desiredIndex - Index of the value being inserted in the desired list
+* @param options.current - Current list of enum values (being built up incrementally)
+* @returns SQL clause (e.g., " AFTER 'x'") and insert position for tracking
+*/
+function computeInsertPosition(options) {
+	const { desired, desiredIndex, current } = options;
+	const currentSet = new Set(current);
+	const previous = desired.slice(0, desiredIndex).reverse().find((candidate) => currentSet.has(candidate));
+	const next = desired.slice(desiredIndex + 1).find((candidate) => currentSet.has(candidate));
+	return {
+		clause: previous ? ` AFTER '${escapeLiteral(previous)}'` : next ? ` BEFORE '${escapeLiteral(next)}'` : "",
+		insertAt: previous ? current.indexOf(previous) + 1 : next ? current.indexOf(next) : current.length
+	};
+}
+/**
+* Builds operations to add new enum values to an existing PostgreSQL enum type.
+*
+* Each new value is added with `ALTER TYPE ... ADD VALUE IF NOT EXISTS` for idempotency.
+* Values are inserted in the correct order using BEFORE/AFTER positioning to match
+* the desired final order.
+*
+* This is a safe, non-destructive operation - existing data is not affected.
+*
+* @param options.typeName - Contract-level type name (e.g., 'Role')
+* @param options.nativeType - PostgreSQL type name (e.g., 'role')
+* @param options.schemaName - PostgreSQL schema (e.g., 'public')
+* @param options.desired - Target ordered list of all enum values
+* @param options.existing - Current enum values in the database
+* @returns Array of migration operations to add each missing value
+*/
+function buildAddValueOperations(options) {
+	const { typeName, nativeType, schemaName } = options;
+	const current = [...options.existing];
+	const currentSet = new Set(current);
+	const operations = [];
+	for (let index = 0; index < options.desired.length; index += 1) {
+		const value = options.desired[index];
+		if (value === void 0) continue;
+		if (currentSet.has(value)) continue;
+		validateEnumValueLength(value, typeName);
+		const { clause, insertAt } = computeInsertPosition({
+			desired: options.desired,
+			desiredIndex: index,
+			current
+		});
+		operations.push({
+			id: `type.${typeName}.value.${value}`,
+			label: `Add value ${value} to ${typeName}`,
+			summary: `Adds enum value ${value} to ${typeName}`,
+			operationClass: "widening",
+			target: { id: "postgres" },
+			precheck: [],
+			execute: [{
+				description: `add value "${value}" if not exists`,
+				sql: `ALTER TYPE ${qualifyName(schemaName, nativeType)} ADD VALUE IF NOT EXISTS '${escapeLiteral(value)}'${clause}`
+			}],
+			postcheck: []
+		});
+		current.splice(insertAt, 0, value);
+		currentSet.add(value);
+	}
+	return operations;
+}
+/**
+* Collects columns using the enum type from the contract (desired state).
+* Used for type-safe reference tracking.
+*/
+function collectEnumColumnsFromContract(contract, typeName, nativeType) {
+	const columns = [];
+	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName || column.nativeType === nativeType && column.codecId === PG_ENUM_CODEC_ID) columns.push({
+		table: tableName,
+		column: columnName
+	});
+	return columns;
+}
+/**
+* Collects columns using the enum type from the schema IR (live database state).
+* This ensures we find ALL dependent columns, including those added outside the contract
+* (e.g., manual DDL), which is critical for safe enum rebuild operations.
+*/
+function collectEnumColumnsFromSchema(schema, nativeType) {
+	const columns = [];
+	for (const [tableName, table] of Object.entries(schema.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.nativeType === nativeType) columns.push({
+		table: tableName,
+		column: columnName
+	});
+	return columns;
+}
+/**
+* Collects all columns using the enum type from both contract AND live database.
+* Merges and deduplicates to ensure we migrate ALL dependent columns during rebuild.
+*
+* This is critical for data integrity: if a column exists in the database using
+* this enum but is not in the contract (e.g., added via manual DDL), we must
+* still migrate it to avoid DROP TYPE failures.
+*/
+function collectAllEnumColumns(contract, schema, typeName, nativeType) {
+	const contractColumns = collectEnumColumnsFromContract(contract, typeName, nativeType);
+	const schemaColumns = collectEnumColumnsFromSchema(schema, nativeType);
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const col of [...contractColumns, ...schemaColumns]) {
+		const key = `${col.table}.${col.column}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(col);
+		}
+	}
+	return result.sort((a, b) => {
+		const tableCompare = a.table.localeCompare(b.table);
+		return tableCompare !== 0 ? tableCompare : a.column.localeCompare(b.column);
+	});
+}
+/**
+* Builds a SQL check to verify a column's type matches an expected type.
+*/
+function columnTypeCheck(options) {
+	return `SELECT EXISTS (
+  SELECT 1
+  FROM information_schema.columns
+  WHERE table_schema = '${escapeLiteral(options.schemaName)}'
+    AND table_name = '${escapeLiteral(options.tableName)}'
+    AND column_name = '${escapeLiteral(options.columnName)}'
+    AND udt_name = '${escapeLiteral(options.expectedType)}'
+)`;
+}
+/** PostgreSQL maximum identifier length (NAMEDATALEN - 1) */
+const MAX_IDENTIFIER_LENGTH = 63;
+/** Suffix added to enum type names during rebuild operations */
+const REBUILD_SUFFIX = "__pn_rebuild";
+/**
+* Builds an SQL check to verify no rows contain any of the removed enum values.
+* This prevents data loss during enum rebuild operations.
+*
+* @param schemaName - PostgreSQL schema name
+* @param tableName - Table containing the enum column
+* @param columnName - Column using the enum type
+* @param removedValues - Array of enum values being removed
+* @returns SQL query that returns true if no rows contain removed values
+*/
+function noRemovedValuesExistCheck(schemaName, tableName, columnName, removedValues) {
+	if (removedValues.length === 0) return "SELECT true";
+	const valuesList = removedValues.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+	return `SELECT NOT EXISTS (
+  SELECT 1 FROM ${qualifyName(schemaName, tableName)}
+  WHERE ${quoteIdentifier(columnName)}::text IN (${valuesList})
+  LIMIT 1
+)`;
+}
+/**
+* Builds a migration operation to recreate a PostgreSQL enum type with updated values.
+*
+* This is required when:
+* - Enum values are removed (PostgreSQL doesn't support direct removal)
+* - Enum values are reordered (PostgreSQL doesn't support reordering)
+*
+* The operation:
+* 1. Creates a new enum type with the desired values (temp name)
+* 2. Migrates all columns to use the new type via text cast
+* 3. Drops the original type
+* 4. Renames the temp type to the original name
+*
+* IMPORTANT: If values are being removed and data exists using those values,
+* the operation will fail at the precheck stage with a clear error message.
+* This prevents silent data loss.
+*
+* @param options.typeName - Contract-level type name
+* @param options.nativeType - PostgreSQL type name
+* @param options.schemaName - PostgreSQL schema
+* @param options.values - Desired final enum values
+* @param options.removedValues - Values being removed (for data loss checks)
+* @param options.contract - Full contract for column discovery
+* @param options.schema - Current schema IR for column discovery
+* @returns Migration operation for full enum rebuild
+*/
+function buildRecreateEnumOperation(options) {
+	const tempTypeName = `${options.nativeType}${REBUILD_SUFFIX}`;
+	if (tempTypeName.length > MAX_IDENTIFIER_LENGTH) {
+		const maxBaseLength = MAX_IDENTIFIER_LENGTH - 12;
+		throw new Error(`Enum type name "${options.nativeType}" is too long for rebuild operation. Maximum length is ${maxBaseLength} characters (type name + "${REBUILD_SUFFIX}" suffix must fit within PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character identifier limit).`);
+	}
+	const qualifiedOriginal = qualifyName(options.schemaName, options.nativeType);
+	const qualifiedTemp = qualifyName(options.schemaName, tempTypeName);
+	const literalValues = options.values.map((value) => `'${escapeLiteral(value)}'`).join(", ");
+	const columnRefs = collectAllEnumColumns(options.contract, options.schema, options.typeName, options.nativeType);
+	const alterColumns = columnRefs.map((ref) => ({
+		description: `alter ${ref.table}.${ref.column} to ${tempTypeName}`,
+		sql: `ALTER TABLE ${qualifyName(options.schemaName, ref.table)}
+ALTER COLUMN ${quoteIdentifier(ref.column)}
+TYPE ${qualifiedTemp}
+USING ${quoteIdentifier(ref.column)}::text::${qualifiedTemp}`
+	}));
+	const postchecks = [
+		{
+			description: `verify type "${options.nativeType}" exists`,
+			sql: enumTypeExistsCheck(options.schemaName, options.nativeType)
+		},
+		{
+			description: `verify temp type "${tempTypeName}" was removed`,
+			sql: enumTypeExistsCheck(options.schemaName, tempTypeName, false)
+		},
+		...columnRefs.map((ref) => ({
+			description: `verify ${ref.table}.${ref.column} uses type "${options.nativeType}"`,
+			sql: columnTypeCheck({
+				schemaName: options.schemaName,
+				tableName: ref.table,
+				columnName: ref.column,
+				expectedType: options.nativeType
+			})
+		}))
+	];
+	return {
+		id: `type.${options.typeName}.rebuild`,
+		label: `Rebuild type ${options.typeName}`,
+		summary: `Recreates enum type ${options.typeName} with updated values`,
+		operationClass: "destructive",
+		target: { id: "postgres" },
+		precheck: [{
+			description: `ensure type "${options.nativeType}" exists`,
+			sql: enumTypeExistsCheck(options.schemaName, options.nativeType)
+		}, ...options.removedValues.length > 0 ? columnRefs.map((ref) => ({
+			description: `ensure no rows in ${ref.table}.${ref.column} contain removed values (${options.removedValues.join(", ")})`,
+			sql: noRemovedValuesExistCheck(options.schemaName, ref.table, ref.column, options.removedValues)
+		})) : []],
+		execute: [
+			{
+				description: `drop orphaned temp type "${tempTypeName}" if exists`,
+				sql: `DROP TYPE IF EXISTS ${qualifiedTemp}`
+			},
+			{
+				description: `create temp type "${tempTypeName}"`,
+				sql: `CREATE TYPE ${qualifiedTemp} AS ENUM (${literalValues})`
+			},
+			...alterColumns,
+			{
+				description: `drop type "${options.nativeType}"`,
+				sql: `DROP TYPE ${qualifiedOriginal}`
+			},
+			{
+				description: `rename type "${tempTypeName}" to "${options.nativeType}"`,
+				sql: `ALTER TYPE ${qualifiedTemp} RENAME TO ${quoteIdentifier(options.nativeType)}`
+			}
+		],
+		postcheck: postchecks
+	};
+}
+/**
+* Postgres enum hooks for planning, verifying, and introspecting `storage.types`.
+*/
+const pgEnumControlHooks = {
+	planTypeOperations: ({ typeName, typeInstance, contract, schema, schemaName }) => {
+		const desired = getEnumValues(typeInstance);
+		if (!desired || desired.length === 0) return { operations: [] };
+		const schemaNamespace = schemaName ?? "public";
+		const existing = readExistingEnumValues(schema, typeInstance.nativeType);
+		if (!existing) return { operations: [buildCreateEnumOperation(typeName, typeInstance.nativeType, schemaNamespace, desired)] };
+		const diff = determineEnumDiff(existing, desired);
+		if (diff.kind === "unchanged") return { operations: [] };
+		if (diff.kind === "rebuild") return { operations: [buildRecreateEnumOperation({
+			typeName,
+			nativeType: typeInstance.nativeType,
+			schemaName: schemaNamespace,
+			values: desired,
+			removedValues: diff.removedValues,
+			contract,
+			schema
+		})] };
+		return { operations: buildAddValueOperations({
+			typeName,
+			nativeType: typeInstance.nativeType,
+			schemaName: schemaNamespace,
+			desired,
+			existing
+		}) };
+	},
+	verifyType: ({ typeName, typeInstance, schema }) => {
+		const desired = getEnumValues(typeInstance);
+		if (!desired) return [];
+		const existing = readExistingEnumValues(schema, typeInstance.nativeType);
+		if (!existing) return [{
+			kind: "type_missing",
+			table: "",
+			typeName,
+			message: `Type "${typeName}" is missing from database`
+		}];
+		if (!arraysEqual(existing, desired)) return [{
+			kind: "type_values_mismatch",
+			table: "",
+			typeName,
+			expected: desired.join(", "),
+			actual: existing.join(", "),
+			message: `Type "${typeName}" values do not match contract`
+		}];
+		return [];
+	},
+	introspectTypes: async ({ driver, schemaName }) => {
+		const namespace = schemaName ?? "public";
+		const result = await driver.query(ENUM_INTROSPECT_QUERY, [namespace]);
+		const types = {};
+		for (const row of result.rows) {
+			const values = parsePostgresArray(row.values);
+			if (!values) throw new Error(`Failed to parse enum values for type "${row.type_name}": unexpected format: ${JSON.stringify(row.values)}`);
+			types[row.type_name] = {
+				codecId: PG_ENUM_CODEC_ID,
+				nativeType: row.type_name,
+				typeParams: { values }
+			};
+		}
+		return types;
+	}
+};
+
+//#endregion
+//#region src/core/json-schema-type-expression.ts
+const MAX_DEPTH = 32;
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function escapeStringLiteral(str) {
+	return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function quotePropertyKey(key) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeStringLiteral(key)}'`;
+}
+function renderLiteral(value) {
+	if (typeof value === "string") return `'${escapeStringLiteral(value)}'`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value === null) return "null";
+	return "unknown";
+}
+function renderUnion(items, depth) {
+	return items.map((item) => render(item, depth)).join(" | ");
+}
+function renderObjectType(schema, depth) {
+	const properties = isRecord(schema["properties"]) ? schema["properties"] : {};
+	const required = Array.isArray(schema["required"]) ? new Set(schema["required"].filter((key) => typeof key === "string")) : /* @__PURE__ */ new Set();
+	const keys = Object.keys(properties).sort((left, right) => left.localeCompare(right));
+	if (keys.length === 0) {
+		const additionalProperties = schema["additionalProperties"];
+		if (additionalProperties === true || additionalProperties === void 0) return "Record<string, unknown>";
+		return `Record<string, ${render(additionalProperties, depth)}>`;
+	}
+	return `{ ${keys.map((key) => {
+		const valueSchema = properties[key];
+		const optionalMarker = required.has(key) ? "" : "?";
+		return `${quotePropertyKey(key)}${optionalMarker}: ${render(valueSchema, depth)}`;
+	}).join("; ")} }`;
+}
+function renderArrayType(schema, depth) {
+	if (Array.isArray(schema["items"])) return `readonly [${schema["items"].map((item) => render(item, depth)).join(", ")}]`;
+	if (schema["items"] !== void 0) {
+		const itemType = render(schema["items"], depth);
+		return itemType.includes(" | ") || itemType.includes(" & ") ? `(${itemType})[]` : `${itemType}[]`;
+	}
+	return "unknown[]";
+}
+function render(schema, depth) {
+	if (depth > MAX_DEPTH || !isRecord(schema)) return "JsonValue";
+	const nextDepth = depth + 1;
+	if ("const" in schema) return renderLiteral(schema["const"]);
+	if (Array.isArray(schema["enum"])) return schema["enum"].map((value) => renderLiteral(value)).join(" | ");
+	if (Array.isArray(schema["oneOf"])) return renderUnion(schema["oneOf"], nextDepth);
+	if (Array.isArray(schema["anyOf"])) return renderUnion(schema["anyOf"], nextDepth);
+	if (Array.isArray(schema["allOf"])) return schema["allOf"].map((item) => render(item, nextDepth)).join(" & ");
+	if (Array.isArray(schema["type"])) return schema["type"].map((item) => render({
+		...schema,
+		type: item
+	}, nextDepth)).join(" | ");
+	switch (schema["type"]) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "array": return renderArrayType(schema, nextDepth);
+		case "object": return renderObjectType(schema, nextDepth);
+		default: break;
+	}
+	return "JsonValue";
+}
+function renderTypeScriptTypeFromJsonSchema(schema) {
+	return render(schema, 0);
+}
+
+//#endregion
+//#region src/core/parameterized-types.ts
+/**
+* Shared utility for expanding parameterized Postgres types to their full SQL representation.
+*
+* This module provides a single source of truth for type expansion logic, used by:
+* - Schema verification (verify-sql-schema.ts) via the expandNativeType codec control hook
+* - Migration planner (planner.ts) via direct import
+*
+* @module
+*/
+/** Set of codec IDs that use the 'length' parameter */
+const LENGTH_CODEC_IDS = new Set([
+	SQL_CHAR_CODEC_ID,
+	SQL_VARCHAR_CODEC_ID,
+	PG_CHAR_CODEC_ID,
+	PG_VARCHAR_CODEC_ID,
+	PG_BIT_CODEC_ID,
+	PG_VARBIT_CODEC_ID
+]);
+/** Set of codec IDs that use the 'precision' parameter for temporal types */
+const TEMPORAL_PRECISION_CODEC_IDS = new Set([
+	PG_TIMESTAMP_CODEC_ID,
+	PG_TIMESTAMPTZ_CODEC_ID,
+	PG_TIME_CODEC_ID,
+	PG_TIMETZ_CODEC_ID,
+	PG_INTERVAL_CODEC_ID
+]);
+/**
+* Validates that a value is a valid type parameter number.
+* Type parameters must be finite, non-negative integers.
+*/
+function isValidTypeParamNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+/**
+* Expands a parameterized native type to its full SQL representation.
+*
+* For example:
+* - { nativeType: 'character varying', typeParams: { length: 255 } } -> 'character varying(255)'
+* - { nativeType: 'numeric', typeParams: { precision: 10, scale: 2 } } -> 'numeric(10,2)'
+* - { nativeType: 'timestamp without time zone', typeParams: { precision: 3 } } -> 'timestamp without time zone(3)'
+*
+* Returns the original nativeType if:
+* - No typeParams are provided
+* - No codecId is provided
+* - The codecId is not a known parameterized type
+* - The typeParams values are invalid
+*/
+function expandParameterizedNativeType(input) {
+	const { nativeType, codecId, typeParams } = input;
+	if (!typeParams || !codecId) return nativeType;
+	if (LENGTH_CODEC_IDS.has(codecId)) {
+		const length = typeParams["length"];
+		if (isValidTypeParamNumber(length)) return `${nativeType}(${length})`;
+		return nativeType;
+	}
+	if (codecId === PG_NUMERIC_CODEC_ID) {
+		const precision = typeParams["precision"];
+		const scale = typeParams["scale"];
+		if (isValidTypeParamNumber(precision)) {
+			if (isValidTypeParamNumber(scale)) return `${nativeType}(${precision},${scale})`;
+			return `${nativeType}(${precision})`;
+		}
+		return nativeType;
+	}
+	if (TEMPORAL_PRECISION_CODEC_IDS.has(codecId)) {
+		const precision = typeParams["precision"];
+		if (isValidTypeParamNumber(precision)) return `${nativeType}(${precision})`;
+		return nativeType;
+	}
+	return nativeType;
+}
+
+//#endregion
+//#region src/core/descriptor-meta.ts
+/** Creates a type import spec for codec types */
+const codecTypeImport = (named) => ({
+	package: "@prisma-next/adapter-postgres/codec-types",
+	named,
+	alias: named
+});
+/** Creates a precision-based TypeScript type renderer for temporal types */
+const precisionRenderer = (typeName) => ({
+	kind: "function",
+	render: (params) => {
+		const precision = params["precision"];
+		return typeof precision === "number" ? `${typeName}<${precision}>` : typeName;
+	}
+});
+/** Creates control hooks with just expandNativeType for parameterized types */
+const parameterizedTypeHooks = { expandNativeType: expandParameterizedNativeType };
+/**
+* Validates that a type expression string is safe to embed in generated .d.ts files.
+* Rejects expressions containing patterns that could inject executable code.
+*/
+function isSafeTypeExpression(expr) {
+	return !/import\s*\(|require\s*\(|declare\s|export\s|eval\s*\(/.test(expr);
+}
+function renderJsonTypeExpression(params) {
+	const typeName = params["type"];
+	if (typeof typeName === "string" && typeName.trim().length > 0) {
+		const trimmed = typeName.trim();
+		if (!isSafeTypeExpression(trimmed)) return "JsonValue";
+		return trimmed;
+	}
+	const schema = params["schemaJson"];
+	if (schema && typeof schema === "object") {
+		const rendered = renderTypeScriptTypeFromJsonSchema(schema);
+		if (!isSafeTypeExpression(rendered)) return "JsonValue";
+		return rendered;
+	}
+	return "JsonValue";
+}
+const postgresAdapterDescriptorMeta = {
+	kind: "adapter",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {
+		postgres: {
+			orderBy: true,
+			limit: true,
+			lateral: true,
+			jsonAgg: true,
+			returning: true
+		},
+		sql: { enums: true }
+	},
+	types: {
+		codecTypes: {
+			import: {
+				package: "@prisma-next/adapter-postgres/codec-types",
+				named: "CodecTypes",
+				alias: "PgTypes"
+			},
+			parameterized: {
+				[SQL_CHAR_CODEC_ID]: "Char<{{length}}>",
+				[SQL_VARCHAR_CODEC_ID]: "Varchar<{{length}}>",
+				[PG_CHAR_CODEC_ID]: "Char<{{length}}>",
+				[PG_VARCHAR_CODEC_ID]: "Varchar<{{length}}>",
+				[PG_NUMERIC_CODEC_ID]: {
+					kind: "function",
+					render: (params) => {
+						const precision = params["precision"];
+						if (typeof precision !== "number") throw new Error("pg/numeric@1 renderer expects precision");
+						const scale = params["scale"];
+						return typeof scale === "number" ? `Numeric<${precision}, ${scale}>` : `Numeric<${precision}>`;
+					}
+				},
+				[PG_BIT_CODEC_ID]: "Bit<{{length}}>",
+				[PG_VARBIT_CODEC_ID]: "VarBit<{{length}}>",
+				[PG_TIMESTAMP_CODEC_ID]: precisionRenderer("Timestamp"),
+				[PG_TIMESTAMPTZ_CODEC_ID]: precisionRenderer("Timestamptz"),
+				[PG_TIME_CODEC_ID]: precisionRenderer("Time"),
+				[PG_TIMETZ_CODEC_ID]: precisionRenderer("Timetz"),
+				[PG_INTERVAL_CODEC_ID]: precisionRenderer("Interval"),
+				[PG_ENUM_CODEC_ID]: {
+					kind: "function",
+					render: (params) => {
+						const values = params["values"];
+						if (!Array.isArray(values)) throw new Error("pg/enum@1 renderer expects values array");
+						return values.map((value) => `'${String(value).replace(/'/g, "\\'")}'`).join(" | ");
+					}
+				},
+				[PG_JSON_CODEC_ID]: {
+					kind: "function",
+					render: renderJsonTypeExpression
+				},
+				[PG_JSONB_CODEC_ID]: {
+					kind: "function",
+					render: renderJsonTypeExpression
+				}
+			},
+			typeImports: [
+				{
+					package: "@prisma-next/adapter-postgres/codec-types",
+					named: "JsonValue",
+					alias: "JsonValue"
+				},
+				codecTypeImport("Char"),
+				codecTypeImport("Varchar"),
+				codecTypeImport("Numeric"),
+				codecTypeImport("Bit"),
+				codecTypeImport("VarBit"),
+				codecTypeImport("Timestamp"),
+				codecTypeImport("Timestamptz"),
+				codecTypeImport("Time"),
+				codecTypeImport("Timetz"),
+				codecTypeImport("Interval")
+			],
+			controlPlaneHooks: {
+				[SQL_CHAR_CODEC_ID]: parameterizedTypeHooks,
+				[SQL_VARCHAR_CODEC_ID]: parameterizedTypeHooks,
+				[PG_CHAR_CODEC_ID]: parameterizedTypeHooks,
+				[PG_VARCHAR_CODEC_ID]: parameterizedTypeHooks,
+				[PG_NUMERIC_CODEC_ID]: parameterizedTypeHooks,
+				[PG_BIT_CODEC_ID]: parameterizedTypeHooks,
+				[PG_VARBIT_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIMESTAMP_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIMESTAMPTZ_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIME_CODEC_ID]: parameterizedTypeHooks,
+				[PG_TIMETZ_CODEC_ID]: parameterizedTypeHooks,
+				[PG_INTERVAL_CODEC_ID]: parameterizedTypeHooks,
+				[PG_ENUM_CODEC_ID]: pgEnumControlHooks
+			}
+		},
+		storage: [
+			{
+				typeId: PG_TEXT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "text"
+			},
+			{
+				typeId: SQL_CHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character"
+			},
+			{
+				typeId: SQL_VARCHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character varying"
+			},
+			{
+				typeId: SQL_INT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: SQL_FLOAT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_CHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character"
+			},
+			{
+				typeId: PG_VARCHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character varying"
+			},
+			{
+				typeId: PG_INT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: PG_FLOAT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_INT4_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: PG_INT2_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int2"
+			},
+			{
+				typeId: PG_INT8_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int8"
+			},
+			{
+				typeId: PG_FLOAT4_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float4"
+			},
+			{
+				typeId: PG_FLOAT8_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_NUMERIC_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "numeric"
+			},
+			{
+				typeId: PG_TIMESTAMP_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamp"
+			},
+			{
+				typeId: PG_TIMESTAMPTZ_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamptz"
+			},
+			{
+				typeId: PG_TIME_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "time"
+			},
+			{
+				typeId: PG_TIMETZ_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timetz"
+			},
+			{
+				typeId: PG_BOOL_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bool"
+			},
+			{
+				typeId: PG_BIT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bit"
+			},
+			{
+				typeId: PG_VARBIT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bit varying"
+			},
+			{
+				typeId: PG_INTERVAL_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "interval"
+			},
+			{
+				typeId: PG_JSON_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "json"
+			},
+			{
+				typeId: PG_JSONB_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "jsonb"
+			}
+		]
+	}
+};
+
+//#endregion
+export { escapeLiteral as a, SqlEscapeError as i, expandParameterizedNativeType as n, qualifyName as o, pgEnumControlHooks as r, quoteIdentifier as s, postgresAdapterDescriptorMeta as t };
+//# sourceMappingURL=descriptor-meta-D7pxo-wo.mjs.map