@prisma-next/target-postgres 0.14.0-dev.49 → 0.14.0-dev.50

package/src/core/schema-ir/postgres-role-schema-node.ts

@@ -1,6 +1,6 @@
 import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
-import { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { assertNode, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { PostgresSchemaNodeKind } from './schema-node-kinds';
 
@@ -25,6 +25,7 @@ export interface PostgresRoleSchemaNodeInput {
  */
 export class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {
   override readonly nodeKind = PostgresSchemaNodeKind.role;
+
   readonly name: string;
   readonly namespaceId: string;
 
@@ -57,10 +58,6 @@ export class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableN
   }
 
   static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode {
-    if (!PostgresRoleSchemaNode.is(node)) {
-      throw new Error(
-        `Expected a PostgresRoleSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,
-      );
-    }
+    assertNode(node, 'PostgresRoleSchemaNode', PostgresRoleSchemaNode.is);
   }
 }

package/src/core/schema-ir/postgres-table-schema-node.ts

@@ -1,6 +1,7 @@
 import type { DiffableNode } from '@prisma-next/framework-components/control';
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import {
+  assertNode,
   PrimaryKey,
   type SqlAnnotations,
   SqlCheckConstraintIR,
@@ -27,12 +28,18 @@ export interface PostgresTableSchemaNodeInput extends SqlTableIRInput {
  * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents
  * subclass field initialisation.
  *
- * `id` is the table name. `children()` returns the policy nodes on this table.
- * `isEqualTo` is identity — two table nodes are equal iff their ids (names)
- * match. Columns are not compared here; they become child nodes later.
+ * `id` is the table name. `isEqualTo` is identity — two table nodes are equal
+ * iff their ids (names) match; the table's own structural drift is entirely
+ * expressed by its children. `children()` returns every column, the primary
+ * key (when present), every foreign key, unique, index, and check constraint,
+ * plus the policy nodes — one flat list, so a drifted column and a drifted
+ * policy are both reported by the same walk. Order is deterministic (object
+ * key order for columns, array order for the rest) so two structurally equal
+ * tables always produce the same child list.
  */
 export class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {
   override readonly nodeKind = PostgresSchemaNodeKind.table;
+
   readonly name: string;
   readonly columns: Readonly<Record<string, SqlColumnIR>>;
   readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
@@ -90,7 +97,15 @@ export class PostgresTableSchemaNode extends SqlSchemaIRNode implements Diffable
   }
 
   children(): readonly DiffableNode[] {
-    return this.policies;
+    return [
+      ...Object.values(this.columns),
+      ...(this.primaryKey ? [this.primaryKey] : []),
+      ...this.foreignKeys,
+      ...this.uniques,
+      ...this.indexes,
+      ...(this.checks ?? []),
+      ...this.policies,
+    ];
   }
 
   static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode {
@@ -98,10 +113,6 @@ export class PostgresTableSchemaNode extends SqlSchemaIRNode implements Diffable
   }
 
   static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode {
-    if (!PostgresTableSchemaNode.is(node)) {
-      throw new Error(
-        `Expected a PostgresTableSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,
-      );
-    }
+    assertNode(node, 'PostgresTableSchemaNode', PostgresTableSchemaNode.is);
   }
 }

package/src/core/schema-ir/schema-node-kinds.ts

@@ -1,5 +1,12 @@
-import type { DiffableNode } from '@prisma-next/framework-components/control';
-import type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import type {
+  DiffableNode,
+  DiffSubjectGranularity,
+} from '@prisma-next/framework-components/control';
+import {
+  relationalNodeEntityKind,
+  relationalNodeGranularity,
+  type SqlSchemaIRNode,
+} from '@prisma-next/sql-schema-ir/types';
 
 /**
  * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements
@@ -26,3 +33,74 @@ export const PostgresSchemaNodeKind = {
 
 export type PostgresSchemaNodeKind =
   (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];
+
+/**
+ * The one real map from a Postgres-specific `nodeKind` to the
+ * framework-neutral {@link DiffSubjectGranularity} its diff issues carry —
+ * resolution is by `nodeKind` equality against this map, never a
+ * `nodeKind`-suffix string match and never anything stamped on the node.
+ */
+const POSTGRES_NODE_GRANULARITY: Readonly<Record<PostgresSchemaNodeKind, DiffSubjectGranularity>> =
+  {
+    [PostgresSchemaNodeKind.database]: 'structural',
+    [PostgresSchemaNodeKind.namespace]: 'namespace',
+    [PostgresSchemaNodeKind.table]: 'entity',
+    [PostgresSchemaNodeKind.policy]: 'structural',
+    [PostgresSchemaNodeKind.role]: 'structural',
+  };
+
+function isPostgresSchemaNodeKind(nodeKind: string): nodeKind is PostgresSchemaNodeKind {
+  return Object.hasOwn(POSTGRES_NODE_GRANULARITY, nodeKind);
+}
+
+/** Looks up the subject granularity for a Postgres-specific `nodeKind`. */
+export function postgresNodeGranularity(nodeKind: PostgresSchemaNodeKind): DiffSubjectGranularity {
+  return POSTGRES_NODE_GRANULARITY[nodeKind];
+}
+
+/**
+ * The subject granularity for any node kind that appears in a Postgres diff
+ * tree — the tree mixes Postgres-specific kinds (database/namespace/table/
+ * policy/role) with the relational leaf kinds (columns, constraints, indexes,
+ * …), so this dispatches to whichever family/target map owns the kind. Called
+ * on demand by consumers (the family verdict, the framework aggregate's
+ * unclaimed-elements sweep, via the {@link
+ * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+ * capability) — never stamped onto the issue or the node.
+ */
+export function postgresDiffSubjectGranularity(nodeKind: string): DiffSubjectGranularity {
+  return isPostgresSchemaNodeKind(nodeKind)
+    ? postgresNodeGranularity(nodeKind)
+    : relationalNodeGranularity(nodeKind);
+}
+
+/**
+ * The one real map from a Postgres-specific `nodeKind` to its storage
+ * `entityKind` — the same vocabulary the contract storage's `entries`
+ * dictionary keys use. Only the whole-table kind has an entity of its own;
+ * database/namespace/policy/role nodes map to nothing here (a namespace is
+ * addressed by id, not by an `entries` kind; policies and roles are
+ * structural, never a sibling space's unclaimed entity).
+ */
+const POSTGRES_NODE_ENTITY_KIND: Partial<Readonly<Record<PostgresSchemaNodeKind, string>>> = {
+  [PostgresSchemaNodeKind.table]: 'table',
+};
+
+/** Looks up the storage entityKind for a Postgres-specific `nodeKind`. */
+export function postgresNodeEntityKind(nodeKind: PostgresSchemaNodeKind): string | undefined {
+  return POSTGRES_NODE_ENTITY_KIND[nodeKind];
+}
+
+/**
+ * The storage `entityKind` for any node kind that appears in a Postgres diff
+ * tree — sibling of {@link postgresDiffSubjectGranularity}, dispatching the
+ * same way to whichever family/target map owns the kind. Called on demand by
+ * the framework aggregate's unclaimed-elements sweep via the {@link
+ * import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+ * capability — never stamped onto the issue or the node.
+ */
+export function postgresDiffSubjectEntityKind(nodeKind: string): string | undefined {
+  return isPostgresSchemaNodeKind(nodeKind)
+    ? postgresNodeEntityKind(nodeKind)
+    : relationalNodeEntityKind(nodeKind);
+}

package/src/exports/control.ts

@@ -1,8 +1,7 @@
 import type { ColumnDefault } from '@prisma-next/contract/types';
 import type { SqlControlTargetDescriptor } from '@prisma-next/family-sql/control';
-import { extractCodecControlHooks } from '@prisma-next/family-sql/control';
+import { buildNativeTypeExpander } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
-import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
   ControlTargetInstance,
   MigrationRunner,
@@ -12,10 +11,7 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { postgresTargetDescriptorMeta } from '../core/descriptor-meta';
 import { contractToPostgresDatabaseSchemaNode } from '../core/migrations/contract-to-postgres-database-schema-node';
-import {
-  diffPostgresDatabaseSchema,
-  verifyPostgresDatabaseSchema,
-} from '../core/migrations/diff-database-schema';
+import { diffPostgresSchema } from '../core/migrations/diff-database-schema';
 import { createPostgresMigrationPlanner } from '../core/migrations/planner';
 import { renderDefaultLiteral } from '../core/migrations/planner-ddl-builders';
 import type { PostgresPlanTargetDetails } from '../core/migrations/planner-target-details';
@@ -25,26 +21,10 @@ import type { PostgresContract } from '../core/postgres-schema';
 import { PostgresSchemaVerifier } from '../core/postgres-schema-verifier';
 import { inferPostgresPslContract } from '../core/psl-infer/infer-psl-contract';
 import { PostgresDatabaseSchemaNode } from '../core/schema-ir/postgres-database-schema-node';
-
-function buildNativeTypeExpander(
-  frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<'sql', 'postgres'>>,
-) {
-  if (!frameworkComponents) {
-    return undefined;
-  }
-  const codecHooks = extractCodecControlHooks(frameworkComponents);
-  return (input: {
-    readonly nativeType: string;
-    readonly codecId?: string;
-    readonly typeParams?: Record<string, unknown>;
-  }) => {
-    if (!input.typeParams) return input.nativeType;
-    if (!input.codecId) return input.nativeType;
-    const hooks = codecHooks.get(input.codecId);
-    if (!hooks?.expandNativeType) return input.nativeType;
-    return hooks.expandNativeType(input);
-  };
-}
+import {
+  postgresDiffSubjectEntityKind,
+  postgresDiffSubjectGranularity,
+} from '../core/schema-ir/schema-node-kinds';
 
 export function postgresRenderDefault(def: ColumnDefault, column: StorageColumn): string {
   if (def.kind === 'function') {
@@ -62,24 +42,11 @@ const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresP
       PostgresDatabaseSchemaNode.assert(schema);
       return inferPostgresPslContract(schema, describedContracts);
     },
-    diffDatabaseSchema(input) {
-      return diffPostgresDatabaseSchema({
-        contract: input.contract,
-        actualSchema: input.schema,
-        strict: input.strict,
-        typeMetadataRegistry: input.typeMetadataRegistry,
-        frameworkComponents: input.frameworkComponents,
-      });
-    },
-    verifyDatabaseSchema(input) {
-      return verifyPostgresDatabaseSchema({
-        contract: input.contract,
-        actualSchema: input.schema,
-        strict: input.strict,
-        typeMetadataRegistry: input.typeMetadataRegistry,
-        frameworkComponents: input.frameworkComponents,
-      });
+    diffSchema(input) {
+      return diffPostgresSchema(input);
     },
+    classifySubjectGranularity: postgresDiffSubjectGranularity,
+    classifyEntityKind: postgresDiffSubjectEntityKind,
     migrations: {
       createPlanner(adapter: SqlControlAdapter<'postgres'>) {
         return createPostgresMigrationPlanner(adapter);

package/src/exports/diff-database-schema.ts

@@ -0,0 +1,7 @@
+/**
+ * Own entry point (rather than folded into `exports/planner.ts`) because
+ * cross-package tests need `buildPostgresPlanDiff` as a public import to
+ * drive the one-differ path directly — they cannot reach it via a relative
+ * `src` import.
+ */
+export { buildPostgresPlanDiff } from '../core/migrations/diff-database-schema';

package/src/exports/issue-planner.ts

@@ -1 +1 @@
-export { planIssues } from '../core/migrations/issue-planner';
+export { coalesceSubtreeIssues, planIssues } from '../core/migrations/issue-planner';

package/src/exports/op-factory-call.ts

@@ -2,6 +2,7 @@ export {
   AddCheckConstraintCall,
   AddColumnCall,
   AddForeignKeyCall,
+  AddNotNullColumnWithTempDefaultCall,
   AddPrimaryKeyCall,
   AddUniqueCall,
   AlterColumnTypeCall,

package/src/exports/planner-identity-values.ts

@@ -1 +1,4 @@
-export { buildBuiltinIdentityValue } from '../core/migrations/planner-identity-values';
+export {
+  buildBuiltinIdentityValue,
+  resolveIdentityValue,
+} from '../core/migrations/planner-identity-values';

package/src/exports/planner.ts

@@ -1,3 +1,2 @@
 export { contractToPostgresDatabaseSchemaNode } from '../core/migrations/contract-to-postgres-database-schema-node';
-export { diffPostgresDatabaseSchema } from '../core/migrations/diff-database-schema';
 export { createPostgresMigrationPlanner } from '../core/migrations/planner';

package/dist/default-normalizer-Dug8Fez9.mjs

@@ -1,248 +0,0 @@
-//#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 as t };
-
-//# sourceMappingURL=default-normalizer-Dug8Fez9.mjs.map

package/dist/default-normalizer-Dug8Fez9.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-normalizer-Dug8Fez9.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":";;;;;AAMA,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;AAC7B,MAAM,0BAA0B;AAChC,MAAM,wBAAwB;AAC9B,MAAM,mBAAmB;AACzB,MAAM,sBAAsB;AAC5B,MAAM,eAAe;AACrB,MAAM,oBAAoB;AAC1B,MAAM,eAAe;AACrB,MAAM,eAAe;AACrB,MAAM,gBAAgB;AACtB,MAAM,kBAAkB;AACxB,MAAM,yBAAyB;;;;;;AAO/B,MAAM,wBAAwB;;;;;;;;;;;;;AAc9B,SAAS,6BAA6B,MAAkC;CACtE,IAAI,qBAAqB,KAAK,IAAI,GAAG,OAAO;CAC5C,IAAI,wBAAwB,KAAK,IAAI,GAAG,OAAO;CAE/C,IAAI,CAAC,sBAAsB,KAAK,IAAI,GAAG,OAAO,KAAA;CAE9C,IAAI,QAAQ,KAAK,QAAQ,uBAAuB,EAAE,CAAC,CAAC,KAAK;CAEzD,IAAI,MAAM,WAAW,GAAG,KAAK,MAAM,SAAS,GAAG,GAC7C,QAAQ,MAAM,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK;CAGlC,IAAI,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC7C,IAAI,wBAAwB,KAAK,KAAK,GAAG,OAAO;CAEhD,QAAQ,MAAM,QAAQ,kBAAkB,EAAE,CAAC,CAAC,KAAK;CACjD,IAAI,oBAAoB,KAAK,KAAK,GAAG,OAAO;AAG9C;;;;;;;;;AAYA,SAAS,mBAAmB,OAAyD;CACnF,MAAM,SAA8B,CAAC;CACrC,IAAI,UAAU;CACd,IAAI,WAAW;CACf,IAAI,SAAS;CAEb,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,IAAI,UAAU;GACZ,IAAI,SAAS,MAAM;IACjB,MAAM,OAAO,MAAM,IAAI;IACvB,IAAI,SAAS,KAAA,GAAW,OAAO,KAAA;IAC/B,WAAW;IACX;IACA;GACF;GACA,IAAI,SAAS,MAAK;IAChB,IAAI,MAAM,IAAI,OAAO,MAAK;KACxB,WAAW;KACX;KACA;IACF;IACA,WAAW;IACX;GACF;GACA,WAAW;GACX;EACF;EACA,IAAI,SAAS,MAAK;GAChB,WAAW;GACX,SAAS;GACT;EACF;EACA,IAAI,SAAS,KAAK;GAChB,OAAO,KAAK;IAAE,OAAO;IAAS;GAAO,CAAC;GACtC,UAAU;GACV,SAAS;GACT;EACF;EACA,WAAW;CACb;CAEA,IAAI,UAAU,OAAO,KAAA;CACrB,OAAO,KAAK;EAAE,OAAO;EAAS;CAAO,CAAC;CACtC,OAAO;AACT;;;;;;;;;;;AAYA,SAAS,sBAAsB,MAAgD;CAC7E,MAAM,QAAQ,KAAK,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK;CACrC,IAAI,UAAU,IAAI,OAAO,CAAC;CAC1B,MAAM,SAAS,mBAAmB,KAAK;CACvC,IAAI,WAAW,KAAA,GAAW,OAAO,KAAA;CACjC,MAAM,SAAsB,CAAC;CAC7B,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,MAAM,QAAQ;GAGhB,OAAO,KAAK,MAAM,KAAK;GACvB;EACF;EACA,MAAM,KAAK,MAAM,MAAM,KAAK;EAC5B,IAAI,GAAG,YAAY,MAAM,QAAQ;GAC/B,OAAO,KAAK,IAAI;GAChB;EACF;EACA,IAAI,OAAO,QAAQ;GACjB,OAAO,KAAK,IAAI;GAChB;EACF;EACA,IAAI,OAAO,SAAS;GAClB,OAAO,KAAK,KAAK;GACjB;EACF;EACA,IAAI,gBAAgB,KAAK,EAAE,GAAG;GAC5B,OAAO,KAAK,OAAO,EAAE,CAAC;GACtB;EACF;EACA;CACF;CACA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,qBACd,YACA,YAC2B;CAC3B,MAAM,UAAU,WAAW,KAAK;CAChC,MAAM,iBAAiB,YAAY,YAAY;CAC/C,MAAM,WAAW,mBAAmB,YAAY,mBAAmB;CACnE,MAAM,cAAc,gBAAgB,SAAS,IAAI,KAAK;CAEtD,IAAI,gBAAgB,KAAK,OAAO,GAC9B,OAAO;EAAE,MAAM;EAAY,YAAY;CAAkB;CAG3D,IAAI,aAAa;EACf,MAAM,aAAa,QAAQ,MAAM,qBAAqB;EACtD,IAAI,aAAa,OAAO,KAAA,GAAW;GACjC,MAAM,SAAS,sBAAsB,WAAW,EAAE;GAClD,IAAI,WAAW,KAAA,GACb,OAAO;IAAE,MAAM;IAAW,OAAO;GAAO;EAE5C;CACF;CAEA,MAAM,qBAAqB,6BAA6B,OAAO;CAC/D,IAAI,oBACF,OAAO;EAAE,MAAM;EAAY,YAAY;CAAmB;CAG5D,IAAI,aAAa,KAAK,OAAO,GAC3B,OAAO;EAAE,MAAM;EAAY,YAAY;CAAoB;CAG7D,IAAI,kBAAkB,KAAK,OAAO,GAChC,OAAO;EAAE,MAAM;EAAY,YAAY;CAAoB;CAG7D,IAAI,aAAa,KAAK,OAAO,GAC3B,OAAO;EAAE,MAAM;EAAW,OAAO;CAAK;CAGxC,IAAI,aAAa,KAAK,OAAO,GAC3B,OAAO;EAAE,MAAM;EAAW,OAAO;CAAK;CAExC,IAAI,cAAc,KAAK,OAAO,GAC5B,OAAO;EAAE,MAAM;EAAW,OAAO;CAAM;CAGzC,IAAI,gBAAgB,KAAK,OAAO,GAAG;EACjC,MAAM,MAAM,OAAO,OAAO;EAC1B,IAAI,CAAC,OAAO,SAAS,GAAG,GAAG,OAAO,KAAA;EAClC,IAAI,YAAY,CAAC,OAAO,cAAc,GAAG,GACvC,OAAO;GAAE,MAAM;GAAW,OAAO;EAAQ;EAE3C,OAAO;GAAE,MAAM;GAAW,OAAO;EAAI;CACvC;CAEA,MAAM,cAAc,QAAQ,MAAM,sBAAsB;CACxD,IAAI,cAAc,OAAO,KAAA,GAAW;EAClC,MAAM,YAAY,YAAY,EAAE,CAAC,QAAQ,OAAO,GAAG;EACnD,IAAI,mBAAmB,UAAU,mBAAmB,SAClD,IAAI;GACF,OAAO;IAAE,MAAM;IAAW,OAAO,KAAK,MAAM,SAAS;GAAE;EACzD,QAAQ,CAER;EAEF,IAAI,YAAY,gBAAgB,KAAK,SAAS,GAAG;GAC/C,MAAM,MAAM,OAAO,SAAS;GAC5B,IAAI,OAAO,cAAc,GAAG,GAC1B,OAAO;IAAE,MAAM;IAAW,OAAO;GAAI;GAEvC,OAAO;IAAE,MAAM;IAAW,OAAO;GAAU;EAC7C;EACA,OAAO;GAAE,MAAM;GAAW,OAAO;EAAU;CAC7C;CAEA,OAAO;EAAE,MAAM;EAAY,YAAY;CAAQ;AACjD"}