@prisma-next/target-postgres 0.14.0 → 0.15.0-dev.10

package/dist/pack.d.mts

@@ -1,10 +1,56 @@
-import { r as CodecTypes } from "./codec-types-DHCkwPKE.mjs";
+import { Z as postgresQualifyColumnType } from "./codecs-D7W9O0Xx.mjs";
+import { r as CodecTypes } from "./codec-types-CTfT4U4O.mjs";
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy--CSddvMR.mjs";
+import { a as postgresCreateNamespace, c as PostgresRlsEnablement, l as PostgresRlsEnablementInput, o as PostgresRole, u as PostgresNativeEnum } from "./postgres-schema-DKq6s1P3.mjs";
+import { PslExtensionBlock } from "@prisma-next/framework-components/authoring";
+import { EntityHandleLoweringInput, LoweredPackEntity, ResolvedPslModelRefs } from "@prisma-next/sql-contract/entity-handle-lowering-hook";
 
+//#region src/core/authoring.d.ts
+interface RlsPolicyExtensionBlock extends PslExtensionBlock {
+  readonly namespaceId: string;
+  /**
+   * Model refs the family interpreter resolved from the block's descriptor-
+   * declared `refKind: 'model'` parameters before invoking this factory
+   * (keyed by parameter name). An unresolved required ref is the
+   * interpreter's diagnostic; the factory is never called with one missing.
+   */
+  readonly resolvedModelRefs?: ResolvedPslModelRefs;
+}
+/** A parsed `role` block annotated with its lexical namespace id by the interpreter. */
+interface RoleExtensionBlock extends PslExtensionBlock {
+  readonly namespaceId: string;
+}
+/**
+ * The SQL-family entity-handle batch lowering hook for the Postgres pack
+ * (`SqlEntityHandleLoweringContribution`). Receives every `entities` handle
+ * whose kind this pack registered — batch, so the cross-entity diagnostics
+ * (duplicate prefix, policy without rlsEnabled, duplicate role) can see
+ * sibling handles — and lowers them with the same keying and hash assembly
+ * as the PSL path: `policy` keyed by prefix (wire name via
+ * {@link buildRlsPolicyEntity}), `rls` keyed by table name, `role` keyed by
+ * name and filed under the default namespace (roles are declared
+ * contract-wide; PSL has no role block to set a precedent).
+ */
+declare function postgresLowerEntityHandles(input: EntityHandleLoweringInput): readonly LoweredPackEntity[];
+//#endregion
 //#region src/core/descriptor-meta.d.ts
 declare const postgresTargetDescriptorMetaBase: {
   readonly defaultNamespaceId: "public";
   readonly authoring: {
-    readonly type: {};
+    readonly type: {
+      readonly pg: {
+        readonly enum: {
+          readonly kind: "typeConstructor";
+          readonly entityRefArg: {
+            readonly index: 0;
+            readonly entityKind: "native_enum";
+          };
+          readonly output: {
+            readonly codecId: "pg/enum@1";
+          };
+        };
+      };
+    };
     readonly field: {
       readonly text: {
         readonly kind: "fieldPreset";
@@ -137,7 +183,279 @@ declare const postgresTargetDescriptorMetaBase: {
         };
       };
     };
-    readonly entityTypes: {};
+    readonly entityTypes: {
+      readonly role: {
+        readonly kind: "entity";
+        readonly discriminator: "role";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "role";
+          name: string;
+          namespaceId: string;
+          control?: "external";
+        }, {}>;
+        readonly output: {
+          readonly factory: (block: RoleExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresRole | undefined;
+        };
+      };
+      readonly rls: {
+        readonly kind: "entity";
+        readonly discriminator: "rls";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "rls";
+          tableName: string;
+          namespaceId: string;
+        }, {}>;
+        readonly output: {
+          readonly factory: (input: PostgresRlsEnablementInput) => PostgresRlsEnablement;
+        };
+      };
+      readonly policy: {
+        readonly kind: "entity";
+        readonly discriminator: "policy";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "policy";
+          name: string;
+          prefix: string;
+          tableName: string;
+          namespaceId: string;
+          operation: "delete" | "select" | "insert" | "update" | "all";
+          roles: readonly string[];
+          permissive: boolean;
+          using?: string;
+          withCheck?: string;
+        }, {}>;
+        readonly output: {
+          readonly factory: (block: RlsPolicyExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresRlsPolicy | undefined;
+        };
+      };
+      readonly native_enum: {
+        readonly kind: "entity";
+        readonly discriminator: "native_enum";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "postgres-enum";
+          typeName: string;
+          members: readonly string[];
+          control?: "external" | "managed" | "tolerated" | "observed";
+        }, {}>;
+        readonly output: {
+          factory: (block: import("@prisma-next/psl-parser").PslExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresNativeEnum | undefined;
+          deriveValueSet: (entity: PostgresNativeEnum) => {
+            kind: "valueSet";
+            values: string[];
+          };
+        };
+      };
+    };
+    readonly pslBlockDescriptors: {
+      readonly policy_select: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_select";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_delete: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_delete";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_insert: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_insert";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_update: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_update";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_all: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_all";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly native_enum: {
+        readonly kind: "pslBlock";
+        readonly keyword: "native_enum";
+        readonly discriminator: "native_enum";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {};
+        readonly variadicParameters: true;
+      };
+      readonly role: {
+        readonly kind: "pslBlock";
+        readonly keyword: "role";
+        readonly discriminator: "role";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {};
+      };
+    };
+    readonly modelAttributes: {
+      readonly rls: {
+        readonly kind: "modelAttribute";
+        readonly attribute: "rls";
+        readonly spec: import("@prisma-next/psl-parser").AttributeSpec<{}>;
+        readonly lower: (_parsed: Record<never, never>, ctx: import("@prisma-next/framework-components/authoring").AuthoringModelAttributeContext) => {
+          key: string;
+          entity: PostgresRlsEnablement;
+        };
+      };
+    };
+    readonly createNamespace: typeof postgresCreateNamespace;
+    readonly qualifyColumnType: typeof postgresQualifyColumnType;
+    readonly lowerEntityHandles: typeof postgresLowerEntityHandles;
   };
   readonly kind: "target";
   readonly familyId: "sql";

package/dist/pack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"mappings":";;;cAQM,gCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAQI,UAAA;AAAA;AAAA,cAEG,4BAAA,SAAqC,gCAAA;EAAA,SACvC,YAAA,GAAe,UAAU;AAAA"}
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"mappings":";;;;;;;;UA8DiB,uBAAA,SAAgC,iBAAiB;EAAA,SACvD,WAAA;EA+pBkB;AAAA;;;;ACltB+B;EDktB/B,SAxpBlB,iBAAA,GAAoB,oBAAA;AAAA;;UAId,kBAAA,SAA2B,iBAAiB;EAAA,SAClD,WAAW;AAAA;;;;;;;;;;;;iBAipBN,0BAAA,CACd,KAAA,EAAO,yBAAA,YACG,iBAAiB;;;cChtBvB,gCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAaI,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,4BAAA,SAAqC,gCAAA;EAAA,SACvC,YAAA,GAAe,UAAU;AAAA"}

package/dist/pack.mjs

@@ -1,2 +1,2 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CpGygXpI.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CFQKLXl_.mjs";
 export { postgresTargetDescriptorMeta as default };

package/dist/{planner-ddl-builders-B2wOwLqI.mjs → planner-ddl-builders-BKlmGDJl.mjs}

@@ -1,20 +1,7 @@
-import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-DcfMz4MQ.mjs";
+import { a as quoteQualifiedName, i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-SU4FDvIV.mjs";
 import { t as resolveColumnTypeMetadata } from "./planner-type-resolution-Bt2f_q-F.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 //#region src/core/migrations/planner-ddl-builders.ts
-function buildCreateTableSql(qualifiedTableName, table, codecHooks, storageTypes = {}) {
-	const columnDefinitions = Object.entries(table.columns).map(([columnName, column]) => {
-		return [
-			quoteIdentifier(columnName),
-			buildColumnTypeSql(column, codecHooks, storageTypes),
-			buildColumnDefaultSql(column.default, column),
-			column.nullable ? "" : "NOT NULL"
-		].filter(Boolean).join(" ");
-	});
-	const constraintDefinitions = [];
-	if (table.primaryKey) constraintDefinitions.push(`PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`);
-	return `CREATE TABLE ${qualifiedTableName} (\n  ${[...columnDefinitions, ...constraintDefinitions].join(",\n  ")}\n)`;
-}
 /**
 * Pattern for safe PostgreSQL type names.
 * Allows letters, digits, underscores, spaces (for "double precision", "character varying"),
@@ -49,11 +36,18 @@ function buildColumnTypeSql(column, codecHooks, storageTypes = {}, allowPseudoTy
 			if (resolved.nativeType === "int2" || resolved.nativeType === "smallint") return "SMALLSERIAL";
 		}
 	}
+	if (typeof resolved.typeParams?.["typeName"] === "string") {
+		const quoted = quoteQualifiedName(resolved.nativeType);
+		return column.many ? `${quoted}[]` : quoted;
+	}
 	const expanded = expandParameterizedTypeSql(resolved, codecHooks);
-	if (expanded !== null) return expanded;
-	if (column.typeRef) return quoteIdentifier(resolved.nativeType);
+	if (expanded !== null) return column.many ? `${expanded}[]` : expanded;
+	if (column.typeRef) {
+		const base = quoteQualifiedName(resolved.nativeType);
+		return column.many ? `${base}[]` : base;
+	}
 	assertSafeNativeType(resolved.nativeType);
-	return resolved.nativeType;
+	return column.many ? `${resolved.nativeType}[]` : resolved.nativeType;
 }
 function expandParameterizedTypeSql(column, codecHooks) {
 	if (!column.typeParams || Object.keys(column.typeParams).length === 0) return null;
@@ -84,6 +78,7 @@ function buildColumnDefaultSql(columnDefault, column) {
 }
 function renderDefaultLiteral(value, column) {
 	const isJsonColumn = column?.nativeType === "json" || column?.nativeType === "jsonb";
+	if (column?.many && Array.isArray(value)) return renderArrayLiteralDefault(value);
 	if (value instanceof Date) return `'${escapeLiteral(value.toISOString())}'`;
 	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
 	if (typeof value === "number" || typeof value === "boolean") return String(value);
@@ -92,17 +87,11 @@ function renderDefaultLiteral(value, column) {
 	if (isJsonColumn) return `'${escapeLiteral(json)}'::${column.nativeType}`;
 	return `'${escapeLiteral(json)}'`;
 }
-function buildAddColumnSql(qualifiedTableName, columnName, column, codecHooks, temporaryDefault, storageTypes = {}) {
-	const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
-	const defaultSql = buildColumnDefaultSql(column.default, column) || (temporaryDefault ? `DEFAULT ${temporaryDefault}` : "");
-	return [
-		`ALTER TABLE ${qualifiedTableName}`,
-		`ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,
-		defaultSql,
-		column.nullable ? "" : "NOT NULL"
-	].filter(Boolean).join(" ");
+function renderArrayLiteralDefault(elements) {
+	if (elements.length === 0) return "'{}'";
+	return `ARRAY[${elements.map((el) => renderDefaultLiteral(el)).join(", ")}]`;
 }
 //#endregion
-export { renderDefaultLiteral as a, buildCreateTableSql as i, buildColumnDefaultSql as n, buildColumnTypeSql as r, buildAddColumnSql as t };
+export { buildColumnTypeSql as n, renderDefaultLiteral as r, buildColumnDefaultSql as t };
 
-//# sourceMappingURL=planner-ddl-builders-B2wOwLqI.mjs.map
+//# sourceMappingURL=planner-ddl-builders-BKlmGDJl.mjs.map

package/dist/planner-ddl-builders-BKlmGDJl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-ddl-builders-BKlmGDJl.mjs","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { escapeLiteral, quoteIdentifier, quoteQualifiedName } from '../sql-utils';\nimport type { PostgresColumnDefault } from '../types';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\n/**\n * Pattern for safe PostgreSQL type names.\n * Allows letters, digits, underscores, spaces (for \"double precision\", \"character varying\"),\n * and trailing [] for array types.\n */\nconst SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/;\n\nfunction assertSafeNativeType(nativeType: string): void {\n  if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {\n    throw new Error(\n      `Unsafe native type name in contract: \"${nativeType}\". ` +\n        'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\\\[\\\\])?$/',\n    );\n  }\n}\n\n/**\n * Sanity check against accidental SQL injection from malformed contract files.\n * Rejects semicolons, SQL comment tokens, and dollar-quoting.\n * Not a comprehensive security boundary — the contract is developer-authored.\n */\nfunction assertSafeDefaultExpression(expression: string): void {\n  if (expression.includes(';') || /--|\\/\\*|\\$\\$|\\bSELECT\\b/i.test(expression)) {\n    throw new Error(\n      `Unsafe default expression in contract: \"${expression}\". ` +\n        'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',\n    );\n  }\n}\n\n/**\n * Renders the SQL type for a column in DDL context.\n *\n * @param allowPseudoTypes - When true (default), autoincrement integer columns\n *   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts\n *   like ALTER COLUMN TYPE where pseudo-types are invalid.\n */\nexport function buildColumnTypeSql(\n  column: StorageColumn,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n  allowPseudoTypes = true,\n): string {\n  const resolved = resolveColumnTypeMetadata(column, storageTypes);\n\n  if (allowPseudoTypes) {\n    const columnDefault = column.default;\n    if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {\n      if (resolved.nativeType === 'int4' || resolved.nativeType === 'integer') {\n        return 'SERIAL';\n      }\n      if (resolved.nativeType === 'int8' || resolved.nativeType === 'bigint') {\n        return 'BIGSERIAL';\n      }\n      if (resolved.nativeType === 'int2' || resolved.nativeType === 'smallint') {\n        return 'SMALLSERIAL';\n      }\n    }\n  }\n\n  // A column whose codec supplied a `typeParams.typeName` references a named\n  // database type (e.g. a native enum), not a parameterized builtin: render it\n  // as its quoted, schema-qualified type-name identifier. DDL-render only — the\n  // verify comparison value (`resolvedNativeType`) stays the bare name the\n  // family expander produces, matching introspection.\n  if (typeof resolved.typeParams?.['typeName'] === 'string') {\n    const quoted = quoteQualifiedName(resolved.nativeType);\n    return column.many ? `${quoted}[]` : quoted;\n  }\n\n  const expanded = expandParameterizedTypeSql(resolved, codecHooks);\n  if (expanded !== null) {\n    return column.many ? `${expanded}[]` : expanded;\n  }\n\n  if (column.typeRef) {\n    const base = quoteQualifiedName(resolved.nativeType);\n    return column.many ? `${base}[]` : base;\n  }\n\n  assertSafeNativeType(resolved.nativeType);\n  return column.many ? `${resolved.nativeType}[]` : resolved.nativeType;\n}\n\nfunction expandParameterizedTypeSql(\n  column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n): string | null {\n  if (!column.typeParams || Object.keys(column.typeParams).length === 0) {\n    return null;\n  }\n\n  if (!column.codecId) {\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" but has no codecId. ` +\n        'Ensure the column is associated with a codec.',\n    );\n  }\n\n  const hooks = codecHooks.get(column.codecId);\n  if (!hooks?.expandNativeType) {\n    if (hooks?.planTypeOperations) {\n      return null;\n    }\n    throw new Error(\n      `Column declares typeParams for nativeType \"${column.nativeType}\" ` +\n        `but no expandNativeType hook is registered for codecId \"${column.codecId}\". ` +\n        'Ensure the extension providing this codec is included in extensionPacks.',\n    );\n  }\n\n  const expanded = hooks.expandNativeType({\n    nativeType: column.nativeType,\n    codecId: column.codecId,\n    ...ifDefined('typeParams', column.typeParams),\n  });\n\n  return expanded !== column.nativeType ? expanded : null;\n}\n\n/** Autoincrement columns use SERIAL types, so this returns empty for them. */\nexport function buildColumnDefaultSql(\n  columnDefault: PostgresColumnDefault | undefined,\n  column?: Pick<StorageColumn, 'many' | 'nativeType'>,\n): string {\n  if (!columnDefault) {\n    return '';\n  }\n\n  switch (columnDefault.kind) {\n    case 'literal':\n      return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;\n    case 'function': {\n      if (columnDefault.expression === 'autoincrement()') {\n        return '';\n      }\n      assertSafeDefaultExpression(columnDefault.expression);\n      return `DEFAULT (${columnDefault.expression})`;\n    }\n    case 'sequence':\n      return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;\n  }\n}\n\nexport function renderDefaultLiteral(\n  value: unknown,\n  column?: Pick<StorageColumn, 'many' | 'nativeType'>,\n): string {\n  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';\n\n  if (column?.many && Array.isArray(value)) {\n    return renderArrayLiteralDefault(value);\n  }\n\n  if (value instanceof Date) {\n    return `'${escapeLiteral(value.toISOString())}'`;\n  }\n  if (typeof value === 'string') {\n    return `'${escapeLiteral(value)}'`;\n  }\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return String(value);\n  }\n  if (value === null) {\n    return 'NULL';\n  }\n  const json = JSON.stringify(value);\n  if (isJsonColumn) {\n    return `'${escapeLiteral(json)}'::${column.nativeType}`;\n  }\n  return `'${escapeLiteral(json)}'`;\n}\n\nfunction renderArrayLiteralDefault(elements: unknown[]): string {\n  if (elements.length === 0) {\n    return \"'{}'\";\n  }\n  const rendered = elements.map((el) => renderDefaultLiteral(el)).join(', ');\n  return `ARRAY[${rendered}]`;\n}\n"],"mappings":"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"}

package/dist/planner-ddl-builders.d.mts

@@ -1,9 +1,8 @@
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
+import { StorageColumn, StorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { CodecControlHooks } from "@prisma-next/family-sql/control";
-import { StorageColumn, StorageTable, StorageTypeInstance } from "@prisma-next/sql-contract/types";
 
 //#region src/core/migrations/planner-ddl-builders.d.ts
-declare function buildCreateTableSql(qualifiedTableName: string, table: StorageTable, codecHooks: ReadonlyMap<string, CodecControlHooks>, storageTypes?: Record<string, StorageTypeInstance>): string;
 /**
  * Renders the SQL type for a column in DDL context.
  *
@@ -13,9 +12,8 @@ declare function buildCreateTableSql(qualifiedTableName: string, table: StorageT
  */
 declare function buildColumnTypeSql(column: StorageColumn, codecHooks: ReadonlyMap<string, CodecControlHooks>, storageTypes?: Record<string, StorageTypeInstance>, allowPseudoTypes?: boolean): string;
 /** Autoincrement columns use SERIAL types, so this returns empty for them. */
-declare function buildColumnDefaultSql(columnDefault: PostgresColumnDefault | undefined, column?: StorageColumn): string;
-declare function renderDefaultLiteral(value: unknown, column?: StorageColumn): string;
-declare function buildAddColumnSql(qualifiedTableName: string, columnName: string, column: StorageColumn, codecHooks: ReadonlyMap<string, CodecControlHooks>, temporaryDefault?: string | null, storageTypes?: Record<string, StorageTypeInstance>): string;
+declare function buildColumnDefaultSql(columnDefault: PostgresColumnDefault | undefined, column?: Pick<StorageColumn, 'many' | 'nativeType'>): string;
+declare function renderDefaultLiteral(value: unknown, column?: Pick<StorageColumn, 'many' | 'nativeType'>): string;
 //#endregion
-export { buildAddColumnSql, buildColumnDefaultSql, buildColumnTypeSql, buildCreateTableSql, renderDefaultLiteral };
+export { buildColumnDefaultSql, buildColumnTypeSql, renderDefaultLiteral };
 //# sourceMappingURL=planner-ddl-builders.d.mts.map

package/dist/planner-ddl-builders.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-ddl-builders.d.mts","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"mappings":";;;;;iBAWgB,mBAAA,CACd,kBAAA,UACA,KAAA,EAAO,YAAA,EACP,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA;;AAJ/B;;;;;;iBAkEgB,kBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA,GAC7B,gBAAA;;iBAqEc,qBAAA,CACd,aAAA,EAAe,qBAAA,cACf,MAAA,GAAS,aAAa;AAAA,iBAqBR,oBAAA,CAAqB,KAAA,WAAgB,MAAA,GAAS,aAAa;AAAA,iBAsB3D,iBAAA,CACd,kBAAA,UACA,UAAA,UACA,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,gBAAA,kBACA,YAAA,GAAc,MAAA,SAAe,mBAAA"}
+{"version":3,"file":"planner-ddl-builders.d.mts","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"mappings":";;;;;;;AA4CA;;;;;iBAAgB,kBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA,GAC7B,gBAAA;;iBAgFc,qBAAA,CACd,aAAA,EAAe,qBAAA,cACf,MAAA,GAAS,IAAA,CAAK,aAAA;AAAA,iBAqBA,oBAAA,CACd,KAAA,WACA,MAAA,GAAS,IAAI,CAAC,aAAA"}

package/dist/planner-ddl-builders.mjs

@@ -1,2 +1,2 @@
-import { a as renderDefaultLiteral, i as buildCreateTableSql, n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-B2wOwLqI.mjs";
-export { buildAddColumnSql, buildColumnDefaultSql, buildColumnTypeSql, buildCreateTableSql, renderDefaultLiteral };
+import { n as buildColumnTypeSql, r as renderDefaultLiteral, t as buildColumnDefaultSql } from "./planner-ddl-builders-BKlmGDJl.mjs";
+export { buildColumnDefaultSql, buildColumnTypeSql, renderDefaultLiteral };

package/dist/planner-identity-values-CJPha2Sz.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"planner-identity-values-CJPha2Sz.mjs","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\n\n/**\n * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.\n * Checks codec hooks first (extensions can provide type-specific identity values),\n * then falls back to the built-in map.\n */\nexport function resolveIdentityValue(\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n): string | null {\n  const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;\n  const codecId = referencedType?.codecId ?? column.codecId;\n  const nativeType = referencedType?.nativeType ?? column.nativeType;\n  const typeParams = referencedType?.typeParams ?? column.typeParams;\n\n  if (codecId) {\n    const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({\n      nativeType,\n      codecId,\n      ...ifDefined('typeParams', typeParams),\n    });\n    if (hookDefault !== undefined) {\n      return hookDefault;\n    }\n  }\n\n  return buildBuiltinIdentityValue(nativeType, typeParams);\n}\n\n/**\n * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given\n * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.\n *\n * This is the planner's fallback when no codec hook provides a type-specific identity value.\n *\n * Returns null for unrecognized types (for example enums and extension-owned types without a\n * hook), which causes the planner to fall back to the empty-table precheck.\n *\n * @internal Exported for testing only.\n */\nexport function buildBuiltinIdentityValue(\n  nativeType: string,\n  typeParams?: Record<string, unknown>,\n): string | null {\n  const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);\n\n  if (normalizedNativeType.endsWith('[]')) {\n    return \"'{}'\";\n  }\n\n  switch (normalizedNativeType) {\n    case 'text':\n    case 'character':\n    case 'bpchar':\n    case 'character varying':\n    case 'varchar':\n      return \"''\";\n\n    case 'int2':\n    case 'int4':\n    case 'int8':\n    case 'integer':\n    case 'bigint':\n    case 'smallint':\n    case 'float4':\n    case 'float8':\n    case 'real':\n    case 'double precision':\n    case 'numeric':\n    case 'decimal':\n      return '0';\n\n    case 'bool':\n    case 'boolean':\n      return 'false';\n\n    case 'uuid':\n      return \"'00000000-0000-0000-0000-000000000000'\";\n\n    case 'json':\n      return \"'{}'::json\";\n    case 'jsonb':\n      return \"'{}'::jsonb\";\n\n    case 'date':\n    case 'timestamp':\n    case 'timestamptz':\n    case 'timestamp with time zone':\n    case 'timestamp without time zone':\n      return \"'epoch'\";\n\n    case 'time':\n    case 'time without time zone':\n      return \"'00:00:00'\";\n    case 'timetz':\n    case 'time with time zone':\n      return \"'00:00:00+00'\";\n\n    case 'interval':\n      return \"'0'\";\n\n    case 'bytea':\n      return \"''::bytea\";\n    case 'tsvector':\n      return \"''::tsvector\";\n\n    case 'bit':\n      return buildBitIdentityValue(typeParams);\n    case 'bit varying':\n    case 'varbit':\n      return \"B''\";\n\n    default:\n      return null;\n  }\n}\n\nfunction normalizeIdentityValueNativeType(nativeType: string): string {\n  return nativeType.trim().toLowerCase().replace(/\\s+/g, ' ');\n}\n\nfunction buildBitIdentityValue(typeParams?: Record<string, unknown>): string | null {\n  const length = typeParams?.['length'];\n  if (length === undefined) {\n    return \"B'0'\";\n  }\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n  return `B'${'0'.repeat(length)}'`;\n}\n"],"mappings":";;;;;;;AASA,SAAgB,qBACd,QACA,YACA,eAAoD,CAAC,GACtC;CACf,MAAM,iBAAiB,OAAO,UAAU,aAAa,OAAO,WAAW,KAAA;CACvE,MAAM,UAAU,gBAAgB,WAAW,OAAO;CAClD,MAAM,aAAa,gBAAgB,cAAc,OAAO;CACxD,MAAM,aAAa,gBAAgB,cAAc,OAAO;CAExD,IAAI,SAAS;EACX,MAAM,cAAc,WAAW,IAAI,OAAO,CAAC,EAAE,uBAAuB;GAClE;GACA;GACA,GAAG,UAAU,cAAc,UAAU;EACvC,CAAC;EACD,IAAI,gBAAgB,KAAA,GAClB,OAAO;CAEX;CAEA,OAAO,0BAA0B,YAAY,UAAU;AACzD;;;;;;;;;;;;AAaA,SAAgB,0BACd,YACA,YACe;CACf,MAAM,uBAAuB,iCAAiC,UAAU;CAExE,IAAI,qBAAqB,SAAS,IAAI,GACpC,OAAO;CAGT,QAAQ,sBAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EACT,KAAK,SACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,+BACH,OAAO;EAET,KAAK;EACL,KAAK,0BACH,OAAO;EACT,KAAK;EACL,KAAK,uBACH,OAAO;EAET,KAAK,YACH,OAAO;EAET,KAAK,SACH,OAAO;EACT,KAAK,YACH,OAAO;EAET,KAAK,OACH,OAAO,sBAAsB,UAAU;EACzC,KAAK;EACL,KAAK,UACH,OAAO;EAET,SACE,OAAO;CACX;AACF;AAEA,SAAS,iCAAiC,YAA4B;CACpE,OAAO,WAAW,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,QAAQ,QAAQ,GAAG;AAC5D;AAEA,SAAS,sBAAsB,YAAqD;CAClF,MAAM,SAAS,aAAa;CAC5B,IAAI,WAAW,KAAA,GACb,OAAO;CAET,IAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,MAAM,KAAK,UAAU,GACvE,OAAO;CAET,OAAO,KAAK,IAAI,OAAO,MAAM,EAAE;AACjC"}
+{"version":3,"file":"planner-identity-values-CJPha2Sz.mjs","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\n\n/**\n * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.\n * Checks codec hooks first (extensions can provide type-specific identity values),\n * then falls back to the built-in map.\n */\nexport function resolveIdentityValue(\n  column: StorageColumn,\n  codecHooks: ReadonlyMap<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n): string | null {\n  const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;\n  const codecId = referencedType?.codecId ?? column.codecId;\n  const nativeType = referencedType?.nativeType ?? column.nativeType;\n  const typeParams = referencedType?.typeParams ?? column.typeParams;\n\n  if (codecId) {\n    const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({\n      nativeType,\n      codecId,\n      ...ifDefined('typeParams', typeParams),\n    });\n    if (hookDefault !== undefined) {\n      return hookDefault;\n    }\n  }\n\n  return buildBuiltinIdentityValue(nativeType, typeParams);\n}\n\n/**\n * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given\n * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.\n *\n * This is the planner's fallback when no codec hook provides a type-specific identity value.\n *\n * Returns null for unrecognized types (for example enums and extension-owned types without a\n * hook), which causes the planner to fall back to the empty-table precheck.\n *\n * @internal Exported for testing only.\n */\nexport function buildBuiltinIdentityValue(\n  nativeType: string,\n  typeParams?: Record<string, unknown>,\n): string | null {\n  const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);\n\n  if (normalizedNativeType.endsWith('[]')) {\n    return \"'{}'\";\n  }\n\n  switch (normalizedNativeType) {\n    case 'text':\n    case 'character':\n    case 'bpchar':\n    case 'character varying':\n    case 'varchar':\n      return \"''\";\n\n    case 'int2':\n    case 'int4':\n    case 'int8':\n    case 'integer':\n    case 'bigint':\n    case 'smallint':\n    case 'float4':\n    case 'float8':\n    case 'real':\n    case 'double precision':\n    case 'numeric':\n    case 'decimal':\n      return '0';\n\n    case 'bool':\n    case 'boolean':\n      return 'false';\n\n    case 'uuid':\n      return \"'00000000-0000-0000-0000-000000000000'\";\n\n    case 'json':\n      return \"'{}'::json\";\n    case 'jsonb':\n      return \"'{}'::jsonb\";\n\n    case 'date':\n    case 'timestamp':\n    case 'timestamptz':\n    case 'timestamp with time zone':\n    case 'timestamp without time zone':\n      return \"'epoch'\";\n\n    case 'time':\n    case 'time without time zone':\n      return \"'00:00:00'\";\n    case 'timetz':\n    case 'time with time zone':\n      return \"'00:00:00+00'\";\n\n    case 'interval':\n      return \"'0'\";\n\n    case 'bytea':\n      return \"''::bytea\";\n    case 'tsvector':\n      return \"''::tsvector\";\n\n    case 'bit':\n      return buildBitIdentityValue(typeParams);\n    case 'bit varying':\n    case 'varbit':\n      return \"B''\";\n\n    default:\n      return null;\n  }\n}\n\nfunction normalizeIdentityValueNativeType(nativeType: string): string {\n  return nativeType.trim().toLowerCase().replace(/\\s+/g, ' ');\n}\n\nfunction buildBitIdentityValue(typeParams?: Record<string, unknown>): string | null {\n  const length = typeParams?.['length'];\n  if (length === undefined) {\n    return \"B'0'\";\n  }\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n  return `B'${'0'.repeat(length)}'`;\n}\n"],"mappings":";;;;;;;AASA,SAAgB,qBACd,QACA,YACA,eAAoD,CAAC,GACtC;CACf,MAAM,iBAAiB,OAAO,UAAU,aAAa,OAAO,WAAW,KAAA;CACvE,MAAM,UAAU,gBAAgB,WAAW,OAAO;CAClD,MAAM,aAAa,gBAAgB,cAAc,OAAO;CACxD,MAAM,aAAa,gBAAgB,cAAc,OAAO;CAExD,IAAI,SAAS;EACX,MAAM,cAAc,WAAW,IAAI,OAAO,CAAC,EAAE,uBAAuB;GAClE;GACA;GACA,GAAG,UAAU,cAAc,UAAU;EACvC,CAAC;EACD,IAAI,gBAAgB,KAAA,GAClB,OAAO;CAEX;CAEA,OAAO,0BAA0B,YAAY,UAAU;AACzD;;;;;;;;;;;;AAaA,SAAgB,0BACd,YACA,YACe;CACf,MAAM,uBAAuB,iCAAiC,UAAU;CAExE,IAAI,qBAAqB,SAAS,IAAI,GACpC,OAAO;CAGT,QAAQ,sBAAR;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK;EACL,KAAK,WACH,OAAO;EAET,KAAK,QACH,OAAO;EAET,KAAK,QACH,OAAO;EACT,KAAK,SACH,OAAO;EAET,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,+BACH,OAAO;EAET,KAAK;EACL,KAAK,0BACH,OAAO;EACT,KAAK;EACL,KAAK,uBACH,OAAO;EAET,KAAK,YACH,OAAO;EAET,KAAK,SACH,OAAO;EACT,KAAK,YACH,OAAO;EAET,KAAK,OACH,OAAO,sBAAsB,UAAU;EACzC,KAAK;EACL,KAAK,UACH,OAAO;EAET,SACE,OAAO;CACX;AACF;AAEA,SAAS,iCAAiC,YAA4B;CACpE,OAAO,WAAW,KAAK,CAAC,CAAC,YAAY,CAAC,CAAC,QAAQ,QAAQ,GAAG;AAC5D;AAEA,SAAS,sBAAsB,YAAqD;CAClF,MAAM,SAAS,aAAa;CAC5B,IAAI,WAAW,KAAA,GACb,OAAO;CAET,IAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,MAAM,KAAK,UAAU,GACvE,OAAO;CAET,OAAO,KAAK,IAAI,OAAO,MAAM,EAAE;AACjC"}

package/dist/planner-identity-values.d.mts

@@ -1,7 +1,13 @@
-import { CodecControlHooks } from "@prisma-next/family-sql/control";
 import { StorageColumn, StorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { CodecControlHooks } from "@prisma-next/family-sql/control";
 
 //#region src/core/migrations/planner-identity-values.d.ts
+/**
+ * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.
+ * Checks codec hooks first (extensions can provide type-specific identity values),
+ * then falls back to the built-in map.
+ */
+declare function resolveIdentityValue(column: StorageColumn, codecHooks: ReadonlyMap<string, CodecControlHooks>, storageTypes?: Record<string, StorageTypeInstance>): string | null;
 /**
  * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given
  * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.
@@ -15,5 +21,5 @@ import { StorageColumn, StorageTypeInstance } from "@prisma-next/sql-contract/ty
  */
 declare function buildBuiltinIdentityValue(nativeType: string, typeParams?: Record<string, unknown>): string | null;
 //#endregion
-export { buildBuiltinIdentityValue };
+export { buildBuiltinIdentityValue, resolveIdentityValue };
 //# sourceMappingURL=planner-identity-values.d.mts.map

package/dist/planner-identity-values.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-identity-values.d.mts","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"mappings":";;;;;;;;AA8CsC;;;;;;;iBAFtB,yBAAA,CACd,UAAA,UACA,UAAA,GAAa,MAAM"}
+{"version":3,"file":"planner-identity-values.d.mts","names":[],"sources":["../src/core/migrations/planner-identity-values.ts"],"mappings":";;;;;;AASA;;;iBAAgB,oBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA;;;;;;;;;;;;iBAgCf,yBAAA,CACd,UAAA,UACA,UAAA,GAAa,MAAM"}

package/dist/planner-identity-values.mjs

@@ -1,2 +1,2 @@
-import { t as buildBuiltinIdentityValue } from "./planner-identity-values-CJPha2Sz.mjs";
-export { buildBuiltinIdentityValue };
+import { n as resolveIdentityValue, t as buildBuiltinIdentityValue } from "./planner-identity-values-CJPha2Sz.mjs";
+export { buildBuiltinIdentityValue, resolveIdentityValue };