@prisma-next/target-postgres 0.14.0-dev.5 → 0.14.0-dev.51

package/dist/ddl.mjs

@@ -1,2 +1,2 @@
-import { a as PostgresDdlNode, i as PostgresCreateTable, n as PostgresAlterTable, r as PostgresCreateSchema, t as AddColumnAction } from "./nodes-Bbhs2rwj.mjs";
-export { AddColumnAction, PostgresAlterTable, PostgresCreateSchema, PostgresCreateTable, PostgresDdlNode };
+import { a as PostgresCreateSchema, c as PostgresDropPolicy, i as PostgresCreatePolicy, n as DropDefaultAction, o as PostgresCreateTable, r as PostgresAlterTable, s as PostgresDdlNode, t as AddColumnAction } from "./nodes-Dh__NS58.mjs";
+export { AddColumnAction, DropDefaultAction, PostgresAlterTable, PostgresCreatePolicy, PostgresCreateSchema, PostgresCreateTable, PostgresDdlNode, PostgresDropPolicy };

package/dist/default-normalizer.d.mts

@@ -9,7 +9,7 @@ import { ColumnDefault } from "@prisma-next/contract/types";
  * 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)
+ * @param nativeType - Native column type, used for type-aware parsing (array, bigint, JSON)
  * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
  */
 declare function parsePostgresDefault(rawDefault: string, nativeType?: string): ColumnDefault | undefined;

package/dist/default-normalizer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"default-normalizer.d.mts","names":[],"sources":["../src/core/default-normalizer.ts"],"mappings":";;;;;AAgEA;;;;;;;;AAGgB;iBAHA,oBAAA,CACd,UAAA,UACA,UAAA,YACC,aAAa"}
+{"version":3,"file":"default-normalizer.d.mts","names":[],"sources":["../src/core/default-normalizer.ts"],"mappings":";;;;;AA6KA;;;;;;;;AAGgB;iBAHA,oBAAA,CACd,UAAA,UACA,UAAA,YACC,aAAa"}

package/dist/default-normalizer.mjs

@@ -1,2 +1,248 @@
-import { t as parsePostgresDefault } from "./default-normalizer-DyyCHQWs.mjs";
+//#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+\))?)?$/;
+/**
+* Matches a Postgres array literal default of the form `'{...}'::elemtype[]`.
+* The literal body is captured in group 1; the cast (including `[]`) is optional.
+* Examples: `'{}'::text[]`, `'{1,2}'::integer[]`, `'{}'`
+*/
+const ARRAY_LITERAL_PATTERN = /^'(\{.*\})'(?:::.+\[\])?$/;
+/**
+* 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()";
+}
+/**
+* Splits a Postgres array literal body (without the enclosing braces) into its
+* element tokens, honouring quoting. A comma only separates elements when it is
+* outside double quotes; inside a quoted element a doubled quote (`""`) or a
+* backslash-escaped quote (`\"`) is a literal quote, and a backslash escapes the
+* next character. Returns undefined if the body is malformed (e.g. an unbalanced
+* quote).
+*/
+function splitArrayElements(inner) {
+	const tokens = [];
+	let current = "";
+	let inQuotes = false;
+	let quoted = false;
+	for (let i = 0; i < inner.length; i++) {
+		const char = inner[i];
+		if (inQuotes) {
+			if (char === "\\") {
+				const next = inner[i + 1];
+				if (next === void 0) return void 0;
+				current += next;
+				i++;
+				continue;
+			}
+			if (char === "\"") {
+				if (inner[i + 1] === "\"") {
+					current += "\"";
+					i++;
+					continue;
+				}
+				inQuotes = false;
+				continue;
+			}
+			current += char;
+			continue;
+		}
+		if (char === "\"") {
+			inQuotes = true;
+			quoted = true;
+			continue;
+		}
+		if (char === ",") {
+			tokens.push({
+				value: current,
+				quoted
+			});
+			current = "";
+			quoted = false;
+			continue;
+		}
+		current += char;
+	}
+	if (inQuotes) return void 0;
+	tokens.push({
+		value: current,
+		quoted
+	});
+	return tokens;
+}
+/**
+* Parses a Postgres array literal body (`{...}`) into a JS array of primitives.
+* Returns undefined if the body cannot be reliably parsed.
+*
+* Handles:
+* - `{}` → `[]`
+* - `{elem1,elem2,...}` → `[elem1, elem2, ...]` with numeric and string element coercion
+* - quoted elements that contain commas, doubled/escaped quotes, and the literal
+*   strings `NULL`/`true`/`false` (a quoted token is always a string)
+*/
+function parseArrayLiteralBody(body) {
+	const inner = body.slice(1, -1).trim();
+	if (inner === "") return [];
+	const tokens = splitArrayElements(inner);
+	if (tokens === void 0) return void 0;
+	const result = [];
+	for (const token of tokens) {
+		if (token.quoted) {
+			result.push(token.value);
+			continue;
+		}
+		const el = token.value.trim();
+		if (el.toUpperCase() === "NULL") {
+			result.push(null);
+			continue;
+		}
+		if (el === "true") {
+			result.push(true);
+			continue;
+		}
+		if (el === "false") {
+			result.push(false);
+			continue;
+		}
+		if (NUMERIC_PATTERN.test(el)) {
+			result.push(Number(el));
+			continue;
+		}
+		return;
+	}
+	return result;
+}
+/**
+* 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 (array, bigint, JSON)
+* @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";
+	const isArrayType = normalizedType?.endsWith("[]") ?? false;
+	if (NEXTVAL_PATTERN.test(trimmed)) return {
+		kind: "function",
+		expression: "autoincrement()"
+	};
+	if (isArrayType) {
+		const arrayMatch = trimmed.match(ARRAY_LITERAL_PATTERN);
+		if (arrayMatch?.[1] !== void 0) {
+			const parsed = parseArrayLiteralBody(arrayMatch[1]);
+			if (parsed !== void 0) return {
+				kind: "literal",
+				value: parsed
+			};
+		}
+	}
+	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
 export { parsePostgresDefault };
+
+//# sourceMappingURL=default-normalizer.mjs.map

package/dist/default-normalizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-normalizer.mjs","names":[],"sources":["../src/core/default-normalizer.ts"],"sourcesContent":["import type { ColumnDefault, JsonValue } from '@prisma-next/contract/types';\n\n/**\n * Pre-compiled regex patterns for performance.\n * These are compiled once at module load time rather than on each function call.\n */\nconst NEXTVAL_PATTERN = /^nextval\\s*\\(/i;\nconst NOW_FUNCTION_PATTERN = /^(now\\s*\\(\\s*\\)|CURRENT_TIMESTAMP)$/i;\nconst CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\\s*\\(\\s*\\)$/i;\nconst TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\\s+(?:with|without)\\s+time\\s+zone)?$/i;\nconst TEXT_CAST_SUFFIX = /::text$/i;\nconst NOW_LITERAL_PATTERN = /^'now'$/i;\nconst UUID_PATTERN = /^gen_random_uuid\\s*\\(\\s*\\)$/i;\nconst UUID_OSSP_PATTERN = /^uuid_generate_v4\\s*\\(\\s*\\)$/i;\nconst NULL_PATTERN = /^NULL(?:::.+)?$/i;\nconst TRUE_PATTERN = /^true$/i;\nconst FALSE_PATTERN = /^false$/i;\nconst NUMERIC_PATTERN = /^-?\\d+(\\.\\d+)?$/;\nconst STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:\"[^\"]+\"|[\\w\\s]+)(?:\\(\\d+\\))?)?$/;\n\n/**\n * Matches a Postgres array literal default of the form `'{...}'::elemtype[]`.\n * The literal body is captured in group 1; the cast (including `[]`) is optional.\n * Examples: `'{}'::text[]`, `'{1,2}'::integer[]`, `'{}'`\n */\nconst ARRAY_LITERAL_PATTERN = /^'(\\{.*\\})'(?:::.+\\[\\])?$/;\n\n/**\n * Returns the canonical expression for a timestamp default function, or undefined\n * if the expression is not a recognized timestamp default.\n *\n * Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:\n * - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'\n * - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'\n *\n * These are semantically different in Postgres: now() returns the transaction\n * start time (constant within a transaction), while clock_timestamp() returns\n * the actual wall-clock time (can differ across rows in a single INSERT).\n */\nfunction canonicalizeTimestampDefault(expr: string): string | undefined {\n  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';\n\n  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;\n\n  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();\n\n  if (inner.startsWith('(') && inner.endsWith(')')) {\n    inner = inner.slice(1, -1).trim();\n  }\n\n  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';\n\n  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();\n  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';\n\n  return undefined;\n}\n\ntype ArrayElementToken = { readonly value: string; readonly quoted: boolean };\n\n/**\n * Splits a Postgres array literal body (without the enclosing braces) into its\n * element tokens, honouring quoting. A comma only separates elements when it is\n * outside double quotes; inside a quoted element a doubled quote (`\"\"`) or a\n * backslash-escaped quote (`\\\"`) is a literal quote, and a backslash escapes the\n * next character. Returns undefined if the body is malformed (e.g. an unbalanced\n * quote).\n */\nfunction splitArrayElements(inner: string): readonly ArrayElementToken[] | undefined {\n  const tokens: ArrayElementToken[] = [];\n  let current = '';\n  let inQuotes = false;\n  let quoted = false;\n\n  for (let i = 0; i < inner.length; i++) {\n    const char = inner[i];\n    if (inQuotes) {\n      if (char === '\\\\') {\n        const next = inner[i + 1];\n        if (next === undefined) return undefined;\n        current += next;\n        i++;\n        continue;\n      }\n      if (char === '\"') {\n        if (inner[i + 1] === '\"') {\n          current += '\"';\n          i++;\n          continue;\n        }\n        inQuotes = false;\n        continue;\n      }\n      current += char;\n      continue;\n    }\n    if (char === '\"') {\n      inQuotes = true;\n      quoted = true;\n      continue;\n    }\n    if (char === ',') {\n      tokens.push({ value: current, quoted });\n      current = '';\n      quoted = false;\n      continue;\n    }\n    current += char;\n  }\n\n  if (inQuotes) return undefined;\n  tokens.push({ value: current, quoted });\n  return tokens;\n}\n\n/**\n * Parses a Postgres array literal body (`{...}`) into a JS array of primitives.\n * Returns undefined if the body cannot be reliably parsed.\n *\n * Handles:\n * - `{}` → `[]`\n * - `{elem1,elem2,...}` → `[elem1, elem2, ...]` with numeric and string element coercion\n * - quoted elements that contain commas, doubled/escaped quotes, and the literal\n *   strings `NULL`/`true`/`false` (a quoted token is always a string)\n */\nfunction parseArrayLiteralBody(body: string): readonly JsonValue[] | undefined {\n  const inner = body.slice(1, -1).trim();\n  if (inner === '') return [];\n  const tokens = splitArrayElements(inner);\n  if (tokens === undefined) return undefined;\n  const result: JsonValue[] = [];\n  for (const token of tokens) {\n    if (token.quoted) {\n      // A quoted token is always a string — `\"NULL\"`, `\"true\"`, `\"1\"` are the\n      // literal text, never the keyword/number.\n      result.push(token.value);\n      continue;\n    }\n    const el = token.value.trim();\n    if (el.toUpperCase() === 'NULL') {\n      result.push(null);\n      continue;\n    }\n    if (el === 'true') {\n      result.push(true);\n      continue;\n    }\n    if (el === 'false') {\n      result.push(false);\n      continue;\n    }\n    if (NUMERIC_PATTERN.test(el)) {\n      result.push(Number(el));\n      continue;\n    }\n    return undefined;\n  }\n  return result;\n}\n\n/**\n * Parses a raw Postgres column default expression into a normalized ColumnDefault.\n * This enables semantic comparison between contract defaults and introspected schema defaults.\n *\n * Used by the migration diff layer to normalize raw database defaults during comparison,\n * keeping the introspection layer focused on faithful data capture.\n *\n * @param rawDefault - Raw default expression from information_schema.columns.column_default\n * @param nativeType - Native column type, used for type-aware parsing (array, bigint, JSON)\n * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed\n */\nexport function parsePostgresDefault(\n  rawDefault: string,\n  nativeType?: string,\n): ColumnDefault | undefined {\n  const trimmed = rawDefault.trim();\n  const normalizedType = nativeType?.toLowerCase();\n  const isBigInt = normalizedType === 'bigint' || normalizedType === 'int8';\n  const isArrayType = normalizedType?.endsWith('[]') ?? false;\n\n  if (NEXTVAL_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'autoincrement()' };\n  }\n\n  if (isArrayType) {\n    const arrayMatch = trimmed.match(ARRAY_LITERAL_PATTERN);\n    if (arrayMatch?.[1] !== undefined) {\n      const parsed = parseArrayLiteralBody(arrayMatch[1]);\n      if (parsed !== undefined) {\n        return { kind: 'literal', value: parsed };\n      }\n    }\n  }\n\n  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);\n  if (canonicalTimestamp) {\n    return { kind: 'function', expression: canonicalTimestamp };\n  }\n\n  if (UUID_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  if (UUID_OSSP_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  if (NULL_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: null };\n  }\n\n  if (TRUE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: true };\n  }\n  if (FALSE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: false };\n  }\n\n  if (NUMERIC_PATTERN.test(trimmed)) {\n    const num = Number(trimmed);\n    if (!Number.isFinite(num)) return undefined;\n    if (isBigInt && !Number.isSafeInteger(num)) {\n      return { kind: 'literal', value: trimmed };\n    }\n    return { kind: 'literal', value: num };\n  }\n\n  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);\n  if (stringMatch?.[1] !== undefined) {\n    const unescaped = stringMatch[1].replace(/''/g, \"'\");\n    if (normalizedType === 'json' || normalizedType === 'jsonb') {\n      try {\n        return { kind: 'literal', value: JSON.parse(unescaped) };\n      } catch {\n        // Keep legacy behavior for malformed/non-JSON string content.\n      }\n    }\n    if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {\n      const num = Number(unescaped);\n      if (Number.isSafeInteger(num)) {\n        return { kind: 'literal', value: num };\n      }\n      return { kind: 'literal', value: unescaped };\n    }\n    return { kind: 'literal', value: unescaped };\n  }\n\n  return { kind: 'function', expression: trimmed };\n}\n"],"mappings":"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"}

package/dist/descriptor-meta-CuGDsrG4.mjs

@@ -0,0 +1,19 @@
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86.mjs";
+import { i as postgresCreateNamespace } from "./postgres-schema-CajYAwny.mjs";
+import { i as postgresAuthoringTypes, n as postgresAuthoringFieldPresets, r as postgresAuthoringPslBlockDescriptors, t as postgresAuthoringEntityTypes } from "./authoring-DzHOdWTl.mjs";
+import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-UwYdV8fD.mjs";
+const postgresTargetDescriptorMeta = {
+	...postgresTargetDescriptorMetaRuntime,
+	defaultNamespaceId: DEFAULT_NAMESPACE_ID,
+	authoring: {
+		type: postgresAuthoringTypes,
+		field: postgresAuthoringFieldPresets,
+		entityTypes: postgresAuthoringEntityTypes,
+		pslBlockDescriptors: postgresAuthoringPslBlockDescriptors,
+		createNamespace: postgresCreateNamespace
+	}
+};
+//#endregion
+export { postgresTargetDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-CuGDsrG4.mjs.map

package/dist/descriptor-meta-CuGDsrG4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-CuGDsrG4.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringPslBlockDescriptors,\n  postgresAuthoringTypes,\n} from './authoring';\nimport { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';\nimport { DEFAULT_NAMESPACE_ID } from './namespace-ids';\nimport { postgresCreateNamespace } from './postgres-schema';\n\nconst postgresTargetDescriptorMetaBase = {\n  ...postgresTargetDescriptorMetaRuntime,\n  defaultNamespaceId: DEFAULT_NAMESPACE_ID,\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n    pslBlockDescriptors: postgresAuthoringPslBlockDescriptors,\n    createNamespace: postgresCreateNamespace,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";;;;AAuBA,MAAa,+BAET;CAbF,GAAG;CACH,oBAAoB;CACpB,WAAW;EACT,MAAM;EACN,OAAO;EACP,aAAa;EACb,qBAAqB;EACrB,iBAAiB;CACnB;AAKE"}

package/dist/descriptor-meta-runtime-UwYdV8fD.mjs

@@ -0,0 +1,12 @@
+const postgresTargetDescriptorMetaRuntime = {
+	kind: "target",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {}
+};
+//#endregion
+export { postgresTargetDescriptorMetaRuntime as t };
+
+//# sourceMappingURL=descriptor-meta-runtime-UwYdV8fD.mjs.map

package/dist/descriptor-meta-runtime-UwYdV8fD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-runtime-UwYdV8fD.mjs","names":[],"sources":["../src/core/descriptor-meta-runtime.ts"],"sourcesContent":["// Runtime-safe slice of the postgres target descriptor metadata.\n//\n// This file exists separately from ./descriptor-meta on purpose: the runtime\n// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the\n// `__codecTypes` phantom). The `authoring` slot lives on the pack/control\n// descriptor only, because authoring contributions are consumed at\n// contract-construction time by `assembleAuthoringContributions` (control\n// plane) and the PSL interpreter — never at runtime.\n//\n// Keeping the runtime closure free of the `./authoring` import is what lets\n// the bundler tree-shake `@prisma-next/family-sql/control` (and its\n// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not\n// add an `authoring` field here — if you need to, the pack/control meta in\n// `./descriptor-meta` is the right place. See TML-2766 for context.\nimport type { CodecTypes } from '../exports/codec-types';\n\nconst postgresTargetDescriptorMetaRuntimeBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n\nexport const postgresTargetDescriptorMetaRuntime: typeof postgresTargetDescriptorMetaRuntimeBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaRuntimeBase;\n"],"mappings":"AAyBA,MAAa,sCAET;CAVF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,CAAC;AAKb"}

package/dist/diff-database-schema-BmSmWcaY.mjs

@@ -0,0 +1,313 @@
+import { r as isPostgresSchema } from "./postgres-schema-CajYAwny.mjs";
+import { r as postgresDiffSubjectGranularity } from "./schema-node-kinds-ClScchhi.mjs";
+import { a as PostgresDatabaseSchemaNode, i as PostgresNamespaceSchemaNode, n as PostgresRoleSchemaNode, r as PostgresPolicySchemaNode, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-BgaSrxYN.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-Bv1ZvjX8.mjs";
+import { i as resolvePostgresNodeIssueControlPolicySubject } from "./control-policy-DUFgy9jO.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
+import { buildNativeTypeExpander, contractNamespaceToSchemaIR } from "@prisma-next/family-sql/control";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { SqlForeignKeyIR } from "@prisma-next/sql-schema-ir/types";
+import { classifyDiffSubjectGranularity, resolveSemanticSatisfaction } from "@prisma-next/family-sql/diff";
+import { diffSchemas } from "@prisma-next/framework-components/control";
+//#region src/core/migrations/contract-to-postgres-database-schema-node.ts
+function toPolicyNode(policy, namespaceId) {
+	return new PostgresPolicySchemaNode({
+		name: policy.name,
+		prefix: policy.prefix,
+		tableName: policy.tableName,
+		namespaceId,
+		operation: policy.operation,
+		roles: [...policy.roles],
+		...ifDefined("using", policy.using),
+		...ifDefined("withCheck", policy.withCheck),
+		permissive: policy.permissive
+	});
+}
+/**
+* Projects a Postgres contract into the expected schema-diff tree: a
+* `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`
+* per Postgres namespace, each holding its `PostgresTableSchemaNode`s with
+* their `PostgresPolicySchemaNode`s, plus the database roles on the root.
+*
+* Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,
+* single `{ tables }` map (and throws on cross-namespace name collisions, with
+* no RLS/role concept) for SQLite's single-schema world. This is the
+* Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.
+* It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)
+* for column/FK/index building and only adds the Postgres tree/policy/role shape.
+*
+* Tables are grouped by their owning namespace (resolved DDL schema name) so
+* the tree mirrors Postgres's object hierarchy. The DDL schema name is
+* resolved once per namespace.
+*
+* A policy that references a table absent from its namespace is a malformed
+* contract — the loop throws rather than fabricating a stub table.
+*/
+function contractToPostgresDatabaseSchemaNode(contract, options) {
+	if (contract === null) return new PostgresDatabaseSchemaNode({
+		namespaces: {},
+		roles: [],
+		existingSchemas: [],
+		pgVersion: ""
+	});
+	const namespaces = {};
+	const roles = [];
+	const ownedSchemas = [];
+	for (const ns of Object.values(contract.storage.namespaces)) {
+		if (!isPostgresSchema(ns)) continue;
+		const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);
+		ownedSchemas.push(ddlSchema);
+		const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;
+		const policiesByTable = /* @__PURE__ */ new Map();
+		for (const policy of Object.values(ns.policy)) {
+			const list = policiesByTable.get(policy.tableName) ?? [];
+			list.push(toPolicyNode(policy, ddlSchema));
+			policiesByTable.set(policy.tableName, list);
+		}
+		const tables = {};
+		for (const tableName of Object.keys(ns.table)) {
+			const sqlTable = sqlTables[tableName];
+			if (sqlTable === void 0) continue;
+			const foreignKeys = sqlTable.foreignKeys.map((fk) => new SqlForeignKeyIR({
+				columns: fk.columns,
+				referencedTable: fk.referencedTable,
+				referencedColumns: fk.referencedColumns,
+				...ifDefined("referencedSchema", fk.referencedSchema),
+				...ifDefined("name", fk.name),
+				...ifDefined("onDelete", fk.onDelete),
+				...ifDefined("onUpdate", fk.onUpdate),
+				...ifDefined("annotations", fk.annotations),
+				resolvedReferencedNamespace: resolveDdlSchemaForNamespaceStorage(contract.storage, fk.referencedSchema ?? UNBOUND_NAMESPACE_ID)
+			}));
+			tables[tableName] = new PostgresTableSchemaNode({
+				name: sqlTable.name,
+				columns: sqlTable.columns,
+				foreignKeys,
+				uniques: sqlTable.uniques,
+				indexes: sqlTable.indexes,
+				...ifDefined("primaryKey", sqlTable.primaryKey),
+				...ifDefined("annotations", sqlTable.annotations),
+				...ifDefined("checks", sqlTable.checks),
+				policies: policiesByTable.get(tableName) ?? []
+			});
+		}
+		for (const [tableName, tablePolicies] of policiesByTable) if (!(tableName in tables)) {
+			const policyName = tablePolicies[0]?.name ?? "(unknown)";
+			throw new Error(`contract-to-postgres-database-schema-node: policy "${policyName}" references table "${tableName}" not present in namespace "${ddlSchema}"`);
+		}
+		namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({
+			schemaName: ddlSchema,
+			tables,
+			nativeEnumTypeNames: []
+		});
+		for (const role of Object.values(ns.role)) roles.push(new PostgresRoleSchemaNode({
+			name: role.name,
+			namespaceId: role.namespaceId
+		}));
+	}
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles,
+		existingSchemas: ownedSchemas,
+		pgVersion: ""
+	});
+}
+//#endregion
+//#region src/core/migrations/diff-database-schema.ts
+function ownedSchemaNames(expected) {
+	const policyNamespaces = Object.values(expected.namespaces).flatMap((ns) => Object.values(ns.tables).flatMap((t) => t.policies.map((p) => p.namespaceId)));
+	return new Set([...policyNamespaces, ...expected.existingSchemas]);
+}
+/**
+* Applies the family's semantic-satisfaction normalization across a Postgres
+* tree pair: every actual table with an expected counterpart (paired by
+* namespace id, then table id) gets its unique/index child lists adjusted;
+* everything else passes through untouched.
+*/
+function normalizePostgresActualForDiff(expected, actual) {
+	const namespaces = {};
+	for (const [nsId, actualNs] of Object.entries(actual.namespaces)) {
+		const expectedNs = expected.namespaces[nsId];
+		if (expectedNs === void 0) {
+			namespaces[nsId] = actualNs;
+			continue;
+		}
+		const tables = {};
+		for (const [tableName, actualTable] of Object.entries(actualNs.tables)) {
+			const expectedTable = expectedNs.tables[tableName];
+			if (expectedTable === void 0) {
+				tables[tableName] = actualTable;
+				continue;
+			}
+			const adjusted = resolveSemanticSatisfaction({
+				expectedUniques: expectedTable.uniques,
+				expectedIndexes: expectedTable.indexes,
+				actualUniques: actualTable.uniques,
+				actualIndexes: actualTable.indexes
+			});
+			tables[tableName] = new PostgresTableSchemaNode({
+				name: actualTable.name,
+				columns: actualTable.columns,
+				foreignKeys: actualTable.foreignKeys,
+				uniques: adjusted.actualUniques,
+				indexes: adjusted.actualIndexes,
+				...ifDefined("primaryKey", actualTable.primaryKey),
+				...ifDefined("annotations", actualTable.annotations),
+				...ifDefined("checks", actualTable.checks),
+				policies: [...actualTable.policies]
+			});
+		}
+		namespaces[nsId] = new PostgresNamespaceSchemaNode({
+			schemaName: actualNs.schemaName,
+			tables,
+			nativeEnumTypeNames: actualNs.nativeEnumTypeNames
+		});
+	}
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...actual.roles],
+		existingSchemas: [...actual.existingSchemas],
+		pgVersion: actual.pgVersion
+	});
+}
+/**
+* Drops contract namespaces that declare no tables from the verdict-diff
+* expected tree and the relational owned-schema set. The legacy relational
+* walk skipped a table-less namespace (e.g. an enums-only schema) before
+* pairing, so neither its DDL schema's absence nor that schema's live
+* relational contents ever reached the verdict — the pruned tree
+* reproduces that. The prune loses no expected policies: policies attach
+* to tables, so a table-less namespace carries none (the projection
+* throws on a policy referencing an absent table). Live policies in a
+* pruned schema remain governed via the full owned set (see
+* {@link diffPostgresSchema}).
+*/
+function pruneTableLessNamespaces(expected) {
+	const namespaces = Object.fromEntries(Object.entries(expected.namespaces).filter(([, ns]) => Object.keys(ns.tables).length > 0));
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...expected.roles],
+		existingSchemas: expected.existingSchemas.filter((s) => namespaces[s] !== void 0),
+		pgVersion: expected.pgVersion
+	});
+}
+/**
+* Resolves a verdict-diff issue's subject table's declared control policy
+* directly from the contract, by delegating to the same node-typed resolver
+* ({@link resolvePostgresNodeIssueControlPolicySubject}) the planner uses to
+* gate DDL calls. `undefined` when the issue resolves to no contract table.
+*/
+function resolveControlPolicy(issue, contract) {
+	return resolvePostgresNodeIssueControlPolicySubject(blindCast(issue), contract)?.explicitNodeControlPolicy;
+}
+/**
+* The Postgres full-tree node diff for the family verify verdict: derive
+* the expected tree (resolved leaf values, expander threaded, FK schemas
+* resolved, table-less namespaces pruned), normalize the actual tree for
+* semantic satisfaction, run the generic
+* differ, and scope out `not-expected` findings under namespaces the
+* contract does not own. Ownership is role-aware, mirroring the legacy
+* decomposition: relational extras check the PRUNED owned set (the legacy
+* per-namespace walk never visited a table-less namespace, so its live
+* relational contents are invisible), while `structural` extras (RLS
+* policies) check the FULL owned set (the legacy policy diff governed
+* every contract schema regardless of tables — RLS governance does not
+* shrink because a namespace declares no tables). The codec `verifyType`
+* hooks run once per contract namespace with tables against that
+* namespace's paired actual node (the hooks read namespace-scoped state
+* such as `nativeEnumTypeNames`).
+*/
+function diffPostgresSchema(input) {
+	const postgresContract = blindCast(input.contract);
+	PostgresDatabaseSchemaNode.assert(input.schema);
+	const actual = input.schema;
+	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+		annotationNamespace: "pg",
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents))
+	});
+	const expected = pruneTableLessNamespaces(fullExpected);
+	const normalizedActual = normalizePostgresActualForDiff(expected, actual);
+	const relationalOwned = ownedSchemaNames(expected);
+	const structuralOwned = ownedSchemaNames(fullExpected);
+	return {
+		issues: diffSchemas(expected, normalizedActual).filter((issue) => {
+			if (issue.reason !== "not-expected") return true;
+			const namespaceSegment = issue.path[1];
+			if (namespaceSegment === void 0) return true;
+			return (classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity) === "structural" ? structuralOwned : relationalOwned).has(namespaceSegment);
+		}),
+		resolveControlPolicy: (issue) => resolveControlPolicy(issue, postgresContract),
+		namespacePairs: Object.values(expected.namespaces).map((ns) => ({ actual: actual.namespaces[ns.schemaName] }))
+	};
+}
+/**
+* Adds an empty namespace node to the actual tree for every expected namespace
+* absent from it. The relational plan diff pairs on namespace: a contract
+* namespace whose live schema does not exist yet must surface each of its
+* tables as `not-found` (→ `CREATE TABLE`), NOT as a single namespace
+* `not-found` that subtree-coalescing would collapse (leaving `CREATE SCHEMA`
+* with no tables). Padding makes the namespaces pair, so only table/column/
+* policy drift surfaces; `CREATE SCHEMA` comes separately from the synthesized
+* namespace-presence stitch (`verifyPostgresNamespacePresence`), never from the
+* tree diff — matching the retired per-namespace-paired relational walk, which
+* paired a missing schema against an empty namespace node.
+*/
+function padActualNamespaces(expected, actual) {
+	const namespaces = { ...actual.namespaces };
+	let padded = false;
+	for (const schemaName of Object.keys(expected.namespaces)) if (namespaces[schemaName] === void 0) {
+		namespaces[schemaName] = new PostgresNamespaceSchemaNode({
+			schemaName,
+			tables: {},
+			nativeEnumTypeNames: []
+		});
+		padded = true;
+	}
+	if (!padded) return actual;
+	return new PostgresDatabaseSchemaNode({
+		namespaces,
+		roles: [...actual.roles],
+		existingSchemas: [...actual.existingSchemas],
+		pgVersion: actual.pgVersion
+	});
+}
+/**
+* The Postgres planner's diff input: the SAME tree-building
+* `diffPostgresSchema` uses (expander threaded, FK schemas resolved,
+* table-less namespaces pruned, actual normalized for semantic satisfaction,
+* role-aware ownership filter) plus actual namespace padding (so a missing
+* schema's tables surface as `not-found` instead of a swallowed namespace
+* `not-found`). One differ drives both verify and plan; this is the
+* plan-side derivation. The single issue list covers tables / columns /
+* constraints / indexes / defaults AND policies — the caller splits it
+* (relational → `mapNodeIssueToCall`; policy → RLS ops) and stitches in
+* `CREATE SCHEMA` separately.
+*/
+function buildPostgresPlanDiff(input) {
+	const postgresContract = blindCast(input.contract);
+	PostgresDatabaseSchemaNode.assert(input.actualSchema);
+	const actual = input.actualSchema;
+	const fullExpected = contractToPostgresDatabaseSchemaNode(postgresContract, {
+		annotationNamespace: "pg",
+		...ifDefined("expandNativeType", buildNativeTypeExpander(input.frameworkComponents))
+	});
+	const expected = pruneTableLessNamespaces(fullExpected);
+	const normalizedActual = normalizePostgresActualForDiff(expected, padActualNamespaces(expected, actual));
+	const relationalOwned = ownedSchemaNames(expected);
+	const structuralOwned = ownedSchemaNames(fullExpected);
+	return {
+		expected,
+		actual: normalizedActual,
+		issues: blindCast(diffSchemas(expected, normalizedActual)).filter((issue) => {
+			if (issue.reason !== "not-expected") return true;
+			const namespaceSegment = issue.path[1];
+			if (namespaceSegment === void 0) return true;
+			return (classifyDiffSubjectGranularity(issue, postgresDiffSubjectGranularity) === "structural" ? structuralOwned : relationalOwned).has(namespaceSegment);
+		})
+	};
+}
+//#endregion
+export { diffPostgresSchema as n, contractToPostgresDatabaseSchemaNode as r, buildPostgresPlanDiff as t };
+
+//# sourceMappingURL=diff-database-schema-BmSmWcaY.mjs.map