@prisma-next/target-postgres 0.4.1 → 0.5.0-dev.1

package/dist/op-factory-call-C3bWXKSP.d.mts

@@ -0,0 +1,304 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-DH-azLu-.mjs";
+import { n as ForeignKeySpec, t as ColumnSpec } from "./shared-Bxkt8pNO.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { ImportRequirement, TsExpression } from "@prisma-next/ts-render";
+import { MigrationOperationClass, OpFactoryCall } from "@prisma-next/framework-components/control";
+
+//#region src/core/migrations/op-factory-call.d.ts
+
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+declare abstract class PostgresOpFactoryCallNode extends TsExpression implements OpFactoryCall {
+  abstract readonly factoryName: string;
+  abstract readonly operationClass: MigrationOperationClass;
+  abstract readonly label: string;
+  abstract toOp(): Op;
+  importRequirements(): readonly ImportRequirement[];
+  protected freeze(): void;
+}
+interface CreateTablePrimaryKey {
+  readonly columns: readonly string[];
+}
+declare class CreateTableCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "createTable";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columns: readonly ColumnSpec[];
+  readonly primaryKey: CreateTablePrimaryKey | undefined;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columns: readonly ColumnSpec[], primaryKey?: CreateTablePrimaryKey);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropTableCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropTable";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddColumnCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "addColumn";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly column: ColumnSpec;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, column: ColumnSpec);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropColumnCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropColumn";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+interface AlterColumnTypeOptions {
+  readonly qualifiedTargetType: string;
+  readonly formatTypeExpected: string;
+  readonly rawTargetTypeForLabel: string;
+  readonly using?: string;
+}
+declare class AlterColumnTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "alterColumnType";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly options: AlterColumnTypeOptions;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columnName: string, options: AlterColumnTypeOptions);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class SetNotNullCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "setNotNull";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropNotNullCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropNotNull";
+  readonly operationClass: "widening";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class SetDefaultCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "setDefault";
+  readonly operationClass: 'additive' | 'widening';
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly defaultSql: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columnName: string, defaultSql: string, operationClass?: 'additive' | 'widening');
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropDefaultCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropDefault";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, columnName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddPrimaryKeyCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "addPrimaryKey";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly columns: readonly string[];
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, constraintName: string, columns: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddUniqueCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "addUnique";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly columns: readonly string[];
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, constraintName: string, columns: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddForeignKeyCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "addForeignKey";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly fk: ForeignKeySpec;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, fk: ForeignKeySpec);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropConstraintCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropConstraint";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly kind: 'foreignKey' | 'unique' | 'primaryKey';
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, constraintName: string, kind?: 'foreignKey' | 'unique' | 'primaryKey');
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class CreateIndexCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "createIndex";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly indexName: string;
+  readonly columns: readonly string[];
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, indexName: string, columns: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropIndexCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropIndex";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly indexName: string;
+  readonly label: string;
+  constructor(schemaName: string, tableName: string, indexName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class CreateEnumTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "createEnumType";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly values: readonly string[];
+  readonly label: string;
+  constructor(schemaName: string, typeName: string, values: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class AddEnumValuesCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "addEnumValues";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly nativeType: string;
+  readonly values: readonly string[];
+  readonly label: string;
+  constructor(schemaName: string, typeName: string, nativeType: string, values: readonly string[]);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class DropEnumTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dropEnumType";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly label: string;
+  constructor(schemaName: string, typeName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class RenameTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "renameType";
+  readonly operationClass: "destructive";
+  readonly schemaName: string;
+  readonly fromName: string;
+  readonly toName: string;
+  readonly label: string;
+  constructor(schemaName: string, fromName: string, toName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+/**
+ * Laundered pre-built operation.
+ *
+ * Wraps an already-materialized `SqlMigrationPlanOperation` — typically one
+ * produced by a SQL-family method, a codec control hook, or a component
+ * `databaseDependencies.init` declaration — so the planner can carry it
+ * alongside IR nodes without reverse-engineering it into a
+ * structured call class. Doubles as the user-facing escape hatch for raw
+ * migrations: authors can pass a full op shape to `rawSql({...})`.
+ *
+ * `toOp()` returns the stored op unchanged. `renderTypeScript()` emits
+ * `rawSql({...})` with the op serialized as a JSON literal — round-tripping
+ * requires every field on the op to be JSON-serializable (no closures).
+ */
+declare class RawSqlCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "rawSql";
+  readonly operationClass: MigrationOperationClass;
+  readonly label: string;
+  readonly op: Op;
+  constructor(op: Op);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class CreateExtensionCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "createExtension";
+  readonly operationClass: "additive";
+  readonly extensionName: string;
+  readonly label: string;
+  constructor(extensionName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+declare class CreateSchemaCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "createSchema";
+  readonly operationClass: "additive";
+  readonly schemaName: string;
+  readonly label: string;
+  constructor(schemaName: string);
+  toOp(): Op;
+  renderTypeScript(): string;
+}
+/**
+ * A planner-generated data-transform stub. `checkSlot` and `runSlot` name
+ * the unfilled authoring slots that the rendered `migration.ts` will expose
+ * to the user via `placeholder("…")` calls. `toOp()` always throws
+ * `PN-MIG-2001`: the planner cannot lower a stubbed transform to a runtime
+ * op — the user must fill the rendered `migration.ts` and re-emit.
+ */
+declare class DataTransformCall extends PostgresOpFactoryCallNode {
+  readonly factoryName: "dataTransform";
+  readonly operationClass: MigrationOperationClass;
+  readonly label: string;
+  readonly checkSlot: string;
+  readonly runSlot: string;
+  constructor(label: string, checkSlot: string, runSlot: string, operationClass?: MigrationOperationClass);
+  toOp(): Op;
+  renderTypeScript(): string;
+  importRequirements(): readonly ImportRequirement[];
+}
+type PostgresOpFactoryCall = CreateTableCall | DropTableCall | AddColumnCall | DropColumnCall | AlterColumnTypeCall | SetNotNullCall | DropNotNullCall | SetDefaultCall | DropDefaultCall | AddPrimaryKeyCall | AddForeignKeyCall | AddUniqueCall | CreateIndexCall | DropIndexCall | DropConstraintCall | CreateEnumTypeCall | AddEnumValuesCall | DropEnumTypeCall | RenameTypeCall | RawSqlCall | CreateExtensionCall | CreateSchemaCall | DataTransformCall;
+//#endregion
+export { SetDefaultCall as C, RenameTypeCall as S, DropIndexCall as _, AddUniqueCall as a, PostgresOpFactoryCall as b, CreateExtensionCall as c, CreateTableCall as d, DataTransformCall as f, DropEnumTypeCall as g, DropDefaultCall as h, AddPrimaryKeyCall as i, CreateIndexCall as l, DropConstraintCall as m, AddEnumValuesCall as n, AlterColumnTypeCall as o, DropColumnCall as p, AddForeignKeyCall as r, CreateEnumTypeCall as s, AddColumnCall as t, CreateSchemaCall as u, DropNotNullCall as v, SetNotNullCall as w, RawSqlCall as x, DropTableCall as y };
+//# sourceMappingURL=op-factory-call-C3bWXKSP.d.mts.map

package/dist/op-factory-call-C3bWXKSP.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"op-factory-call-C3bWXKSP.d.mts","names":[],"sources":["../src/core/migrations/op-factory-call.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/op-factory-call.d.mts

@@ -0,0 +1,3 @@
+import "./shared-Bxkt8pNO.mjs";
+import { C as SetDefaultCall, S as RenameTypeCall, _ as DropIndexCall, a as AddUniqueCall, c as CreateExtensionCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, w as SetNotNullCall, x as RawSqlCall, y as DropTableCall } from "./op-factory-call-C3bWXKSP.mjs";
+export { AddColumnCall, AddEnumValuesCall, AddForeignKeyCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, CreateEnumTypeCall, CreateExtensionCall, CreateIndexCall, CreateSchemaCall, CreateTableCall, DataTransformCall, DropColumnCall, DropConstraintCall, DropDefaultCall, DropEnumTypeCall, DropIndexCall, DropNotNullCall, DropTableCall, RawSqlCall, RenameTypeCall, SetDefaultCall, SetNotNullCall };

package/dist/op-factory-call.mjs

@@ -0,0 +1,3 @@
+import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, c as CreateExtensionCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-BKlruaiC.mjs";
+
+export { AddColumnCall, AddEnumValuesCall, AddForeignKeyCall, AddPrimaryKeyCall, AddUniqueCall, AlterColumnTypeCall, CreateEnumTypeCall, CreateExtensionCall, CreateIndexCall, CreateSchemaCall, CreateTableCall, DataTransformCall, DropColumnCall, DropConstraintCall, DropDefaultCall, DropEnumTypeCall, DropIndexCall, DropNotNullCall, DropTableCall, RawSqlCall, RenameTypeCall, SetDefaultCall, SetNotNullCall };

package/dist/pack.d.mts

@@ -1,4 +1,4 @@
-import { CodecTypes } from "@prisma-next/adapter-postgres/codec-types";
+import { t as CodecTypes } from "./codecs-D-F2KJqt.mjs";
 
 //#region src/core/descriptor-meta.d.ts
 declare const postgresTargetDescriptorMetaBase: {

package/dist/pack.mjs

@@ -1,3 +1,3 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DkvCmY98.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-BVoVtyp-.mjs";
 
 export { postgresTargetDescriptorMeta as default };

package/dist/planner-CLUvVhUN.mjs

@@ -0,0 +1,98 @@
+import { t as parsePostgresDefault } from "./default-normalizer-DNOpRoOF.mjs";
+import { t as normalizeSchemaNativeType } from "./native-type-normalizer-CInai_oY.mjs";
+import { n as postgresPlannerStrategies, t as planIssues } from "./issue-planner-CFjB0_oO.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-DSSPq8QS.mjs";
+import { extractCodecControlHooks, plannerFailure } from "@prisma-next/family-sql/control";
+import { verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
+
+//#region src/core/migrations/planner.ts
+const DEFAULT_PLANNER_CONFIG = { defaultSchema: "public" };
+function createPostgresMigrationPlanner(config = {}) {
+	return new PostgresMigrationPlanner({
+		...DEFAULT_PLANNER_CONFIG,
+		...config
+	});
+}
+/**
+* Postgres migration planner — a thin wrapper over `planIssues`.
+*
+* `plan()` verifies the live schema against the target contract (producing
+* `SchemaIssue[]`) and delegates to `planIssues` with the unified
+* `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,
+* type-change, nullable-tightening, codec-hook storage types,
+* component-declared dependency installs, and shared-temp-default /
+* empty-table-guarded NOT-NULL add-column. The same strategy list runs for
+* `migration plan`, `db update`, and `db init`; behavior diverges purely on
+* `policy.allowedOperationClasses` (the data-safe strategies short-circuit
+* when `'data'` is excluded). The issue planner applies operation-class
+* policy gates and emits a single `PostgresOpFactoryCall[]` that drives both
+* the runtime-ops view (via `renderOps`) and the `renderTypeScript()`
+* authoring surface.
+*/
+var PostgresMigrationPlanner = class {
+	constructor(config) {
+		this.config = config;
+	}
+	plan(options) {
+		return this.planSql(options, options.fromHash ?? "");
+	}
+	emptyMigration(context) {
+		return new TypeScriptRenderablePostgresMigration([], {
+			from: context.fromHash,
+			to: context.toHash
+		});
+	}
+	planSql(options, fromHash) {
+		const schemaName = options.schemaName ?? this.config.defaultSchema;
+		const policyResult = this.ensureAdditivePolicy(options.policy);
+		if (policyResult) return policyResult;
+		const schemaIssues = this.collectSchemaIssues(options);
+		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
+		const storageTypes = options.contract.storage.types ?? {};
+		const result = planIssues({
+			issues: schemaIssues,
+			toContract: options.contract,
+			fromContract: options.fromContract ?? null,
+			schemaName,
+			codecHooks,
+			storageTypes,
+			schema: options.schema,
+			policy: options.policy,
+			frameworkComponents: options.frameworkComponents,
+			strategies: postgresPlannerStrategies
+		});
+		if (!result.ok) return plannerFailure(result.failure);
+		return Object.freeze({
+			kind: "success",
+			plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {
+				from: fromHash,
+				to: options.contract.storage.storageHash
+			})
+		});
+	}
+	ensureAdditivePolicy(policy) {
+		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
+			kind: "unsupportedOperation",
+			summary: "Migration planner requires additive operations be allowed",
+			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
+		}]);
+		return null;
+	}
+	collectSchemaIssues(options) {
+		const allowed = options.policy.allowedOperationClasses;
+		const strict = allowed.includes("widening") || allowed.includes("destructive");
+		return verifySqlSchema({
+			contract: options.contract,
+			schema: options.schema,
+			strict,
+			typeMetadataRegistry: /* @__PURE__ */ new Map(),
+			frameworkComponents: options.frameworkComponents,
+			normalizeDefault: parsePostgresDefault,
+			normalizeNativeType: normalizeSchemaNativeType
+		}).schema.issues;
+	}
+};
+
+//#endregion
+export { createPostgresMigrationPlanner as t };
+//# sourceMappingURL=planner-CLUvVhUN.mjs.map

package/dist/planner-CLUvVhUN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-CLUvVhUN.mjs","names":["DEFAULT_PLANNER_CONFIG: PlannerConfig","config: PlannerConfig"],"sources":["../src/core/migrations/planner.ts"],"sourcesContent":["import type {\n  MigrationOperationPolicy,\n  SqlMigrationPlannerPlanOptions,\n  SqlPlannerFailureResult,\n} from '@prisma-next/family-sql/control';\nimport { extractCodecControlHooks, plannerFailure } from '@prisma-next/family-sql/control';\nimport { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  MigrationPlanner,\n  MigrationPlanWithAuthoringSurface,\n  MigrationScaffoldContext,\n  SchemaIssue,\n} from '@prisma-next/framework-components/control';\nimport { parsePostgresDefault } from '../default-normalizer';\nimport { normalizeSchemaNativeType } from '../native-type-normalizer';\nimport { planIssues } from './issue-planner';\nimport { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';\nimport { postgresPlannerStrategies } from './planner-strategies';\n\ntype PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {\n  readonly frameworkComponents: infer T;\n}\n  ? T\n  : ReadonlyArray<unknown>;\n\ntype PlannerOptionsWithComponents = SqlMigrationPlannerPlanOptions & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ntype VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0] & {\n  readonly frameworkComponents: PlannerFrameworkComponents;\n};\n\ninterface PlannerConfig {\n  readonly defaultSchema: string;\n}\n\nconst DEFAULT_PLANNER_CONFIG: PlannerConfig = {\n  defaultSchema: 'public',\n};\n\nexport function createPostgresMigrationPlanner(\n  config: Partial<PlannerConfig> = {},\n): PostgresMigrationPlanner {\n  return new PostgresMigrationPlanner({\n    ...DEFAULT_PLANNER_CONFIG,\n    ...config,\n  });\n}\n\n/**\n * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose\n * success variant carries a `TypeScriptRenderablePostgresMigration` — a\n * migration object that both the CLI (via `renderTypeScript()`) and the\n * SQL-typed callers (via `operations`, `describe()`, etc.) consume\n * uniformly.\n */\nexport type PostgresPlanResult =\n  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }\n  | SqlPlannerFailureResult;\n\n/**\n * Postgres migration planner — a thin wrapper over `planIssues`.\n *\n * `plan()` verifies the live schema against the target contract (producing\n * `SchemaIssue[]`) and delegates to `planIssues` with the unified\n * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,\n * type-change, nullable-tightening, codec-hook storage types,\n * component-declared dependency installs, and shared-temp-default /\n * empty-table-guarded NOT-NULL add-column. The same strategy list runs for\n * `migration plan`, `db update`, and `db init`; behavior diverges purely on\n * `policy.allowedOperationClasses` (the data-safe strategies short-circuit\n * when `'data'` is excluded). The issue planner applies operation-class\n * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both\n * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`\n * authoring surface.\n */\nexport class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {\n  constructor(private readonly config: PlannerConfig) {}\n\n  plan(options: {\n    readonly contract: unknown;\n    readonly schema: unknown;\n    readonly policy: MigrationOperationPolicy;\n    readonly fromHash?: string;\n    /**\n     * The \"from\" contract (state the planner assumes the database starts\n     * at). Only `migration plan` supplies this; `db update` / `db init`\n     * reconcile against the live schema with no old contract. When present\n     * alongside the `'data'` operation class, strategies that need from/to\n     * column shape comparisons (unsafe type change, nullability tightening)\n     * activate.\n     */\n    readonly fromContract?: unknown;\n    readonly schemaName?: string;\n    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;\n  }): PostgresPlanResult {\n    return this.planSql(options as SqlMigrationPlannerPlanOptions, options.fromHash ?? '');\n  }\n\n  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {\n    return new TypeScriptRenderablePostgresMigration([], {\n      from: context.fromHash,\n      to: context.toHash,\n    });\n  }\n\n  private planSql(options: SqlMigrationPlannerPlanOptions, fromHash: string): PostgresPlanResult {\n    const schemaName = options.schemaName ?? this.config.defaultSchema;\n    const policyResult = this.ensureAdditivePolicy(options.policy);\n    if (policyResult) {\n      return policyResult;\n    }\n\n    const schemaIssues = this.collectSchemaIssues(options);\n    const codecHooks = extractCodecControlHooks(options.frameworkComponents);\n    const storageTypes = options.contract.storage.types ?? {};\n\n    const result = planIssues({\n      issues: schemaIssues,\n      toContract: options.contract,\n      // `fromContract` is only supplied by `migration plan`. It is `null` for\n      // `db update` / `db init`, which means data-safety strategies needing\n      // from/to comparisons (unsafe type change, nullable tightening) are\n      // inapplicable there — reconciliation falls through to\n      // `mapIssueToCall`'s direct destructive handlers.\n      fromContract: options.fromContract ?? null,\n      schemaName,\n      codecHooks,\n      storageTypes,\n      schema: options.schema,\n      policy: options.policy,\n      frameworkComponents: options.frameworkComponents,\n      strategies: postgresPlannerStrategies,\n    });\n\n    if (!result.ok) {\n      return plannerFailure(result.failure);\n    }\n\n    return Object.freeze({\n      kind: 'success' as const,\n      plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {\n        from: fromHash,\n        to: options.contract.storage.storageHash,\n      }),\n    });\n  }\n\n  private ensureAdditivePolicy(policy: MigrationOperationPolicy) {\n    if (!policy.allowedOperationClasses.includes('additive')) {\n      return plannerFailure([\n        {\n          kind: 'unsupportedOperation',\n          summary: 'Migration planner requires additive operations be allowed',\n          why: 'The planner requires the \"additive\" operation class to be allowed in the policy.',\n        },\n      ]);\n    }\n    return null;\n  }\n\n  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {\n    // `db init` uses additive-only policy and intentionally ignores extra\n    // schema objects. Any reconciliation-capable policy (widening or\n    // destructive) must inspect extras to reconcile strict equality.\n    const allowed = options.policy.allowedOperationClasses;\n    const strict = allowed.includes('widening') || allowed.includes('destructive');\n    const verifyOptions: VerifySqlSchemaOptionsWithComponents = {\n      contract: options.contract,\n      schema: options.schema,\n      strict,\n      typeMetadataRegistry: new Map(),\n      frameworkComponents: options.frameworkComponents,\n      normalizeDefault: parsePostgresDefault,\n      normalizeNativeType: normalizeSchemaNativeType,\n    };\n    const verifyResult = verifySqlSchema(verifyOptions);\n    return verifyResult.schema.issues;\n  }\n}\n"],"mappings":";;;;;;;;AAsCA,MAAMA,yBAAwC,EAC5C,eAAe,UAChB;AAED,SAAgB,+BACd,SAAiC,EAAE,EACT;AAC1B,QAAO,IAAI,yBAAyB;EAClC,GAAG;EACH,GAAG;EACJ,CAAC;;;;;;;;;;;;;;;;;;AA8BJ,IAAa,2BAAb,MAAqF;CACnF,YAAY,AAAiBC,QAAuB;EAAvB;;CAE7B,KAAK,SAgBkB;AACrB,SAAO,KAAK,QAAQ,SAA2C,QAAQ,YAAY,GAAG;;CAGxF,eAAe,SAAsE;AACnF,SAAO,IAAI,sCAAsC,EAAE,EAAE;GACnD,MAAM,QAAQ;GACd,IAAI,QAAQ;GACb,CAAC;;CAGJ,AAAQ,QAAQ,SAAyC,UAAsC;EAC7F,MAAM,aAAa,QAAQ,cAAc,KAAK,OAAO;EACrD,MAAM,eAAe,KAAK,qBAAqB,QAAQ,OAAO;AAC9D,MAAI,aACF,QAAO;EAGT,MAAM,eAAe,KAAK,oBAAoB,QAAQ;EACtD,MAAM,aAAa,yBAAyB,QAAQ,oBAAoB;EACxE,MAAM,eAAe,QAAQ,SAAS,QAAQ,SAAS,EAAE;EAEzD,MAAM,SAAS,WAAW;GACxB,QAAQ;GACR,YAAY,QAAQ;GAMpB,cAAc,QAAQ,gBAAgB;GACtC;GACA;GACA;GACA,QAAQ,QAAQ;GAChB,QAAQ,QAAQ;GAChB,qBAAqB,QAAQ;GAC7B,YAAY;GACb,CAAC;AAEF,MAAI,CAAC,OAAO,GACV,QAAO,eAAe,OAAO,QAAQ;AAGvC,SAAO,OAAO,OAAO;GACnB,MAAM;GACN,MAAM,IAAI,sCAAsC,OAAO,MAAM,OAAO;IAClE,MAAM;IACN,IAAI,QAAQ,SAAS,QAAQ;IAC9B,CAAC;GACH,CAAC;;CAGJ,AAAQ,qBAAqB,QAAkC;AAC7D,MAAI,CAAC,OAAO,wBAAwB,SAAS,WAAW,CACtD,QAAO,eAAe,CACpB;GACE,MAAM;GACN,SAAS;GACT,KAAK;GACN,CACF,CAAC;AAEJ,SAAO;;CAGT,AAAQ,oBAAoB,SAA+D;EAIzF,MAAM,UAAU,QAAQ,OAAO;EAC/B,MAAM,SAAS,QAAQ,SAAS,WAAW,IAAI,QAAQ,SAAS,cAAc;AAW9E,SADqB,gBATuC;GAC1D,UAAU,QAAQ;GAClB,QAAQ,QAAQ;GAChB;GACA,sCAAsB,IAAI,KAAK;GAC/B,qBAAqB,QAAQ;GAC7B,kBAAkB;GAClB,qBAAqB;GACtB,CACkD,CAC/B,OAAO"}

package/dist/planner-ddl-builders-Dxvw1LHw.mjs

@@ -0,0 +1,132 @@
+import { i as quoteIdentifier, n as escapeLiteral } from "./sql-utils-r-Lw535w.mjs";
+import { c as qualifyTableName, f as resolveColumnTypeMetadata } from "./planner-sql-checks-7jkgm9TX.mjs";
+
+//#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"),
+* and trailing [] for array types.
+*/
+const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/;
+function assertSafeNativeType(nativeType) {
+	if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) throw new Error(`Unsafe native type name in contract: "${nativeType}". Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?\$/`);
+}
+/**
+* Sanity check against accidental SQL injection from malformed contract files.
+* Rejects semicolons, SQL comment tokens, and dollar-quoting.
+* Not a comprehensive security boundary — the contract is developer-authored.
+*/
+function assertSafeDefaultExpression(expression) {
+	if (expression.includes(";") || /--|\/\*|\$\$|\bSELECT\b/i.test(expression)) throw new Error(`Unsafe default expression in contract: "${expression}". Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.`);
+}
+/**
+* Renders the SQL type for a column in DDL context.
+*
+* @param allowPseudoTypes - When true (default), autoincrement integer columns
+*   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts
+*   like ALTER COLUMN TYPE where pseudo-types are invalid.
+*/
+function buildColumnTypeSql(column, codecHooks, storageTypes = {}, allowPseudoTypes = true) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	if (allowPseudoTypes) {
+		const columnDefault = column.default;
+		if (columnDefault?.kind === "function" && columnDefault.expression === "autoincrement()") {
+			if (resolved.nativeType === "int4" || resolved.nativeType === "integer") return "SERIAL";
+			if (resolved.nativeType === "int8" || resolved.nativeType === "bigint") return "BIGSERIAL";
+			if (resolved.nativeType === "int2" || resolved.nativeType === "smallint") return "SMALLSERIAL";
+		}
+	}
+	const expanded = expandParameterizedTypeSql(resolved, codecHooks);
+	if (expanded !== null) return expanded;
+	if (column.typeRef) return quoteIdentifier(resolved.nativeType);
+	assertSafeNativeType(resolved.nativeType);
+	return resolved.nativeType;
+}
+function expandParameterizedTypeSql(column, codecHooks) {
+	if (!column.typeParams) return null;
+	if (!column.codecId) throw new Error(`Column declares typeParams for nativeType "${column.nativeType}" but has no codecId. Ensure the column is associated with a codec.`);
+	const hooks = codecHooks.get(column.codecId);
+	if (!hooks?.expandNativeType) {
+		if (hooks?.planTypeOperations) return null;
+		throw new Error(`Column declares typeParams for nativeType "${column.nativeType}" but no expandNativeType hook is registered for codecId "${column.codecId}". Ensure the extension providing this codec is included in extensionPacks.`);
+	}
+	const expanded = hooks.expandNativeType({
+		nativeType: column.nativeType,
+		codecId: column.codecId,
+		typeParams: column.typeParams
+	});
+	return expanded !== column.nativeType ? expanded : null;
+}
+/** Autoincrement columns use SERIAL types, so this returns empty for them. */
+function buildColumnDefaultSql(columnDefault, column) {
+	if (!columnDefault) return "";
+	switch (columnDefault.kind) {
+		case "literal": return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return "";
+			assertSafeDefaultExpression(columnDefault.expression);
+			return `DEFAULT (${columnDefault.expression})`;
+		case "sequence": return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;
+	}
+}
+function renderDefaultLiteral(value, column) {
+	const isJsonColumn = column?.nativeType === "json" || column?.nativeType === "jsonb";
+	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);
+	if (value === null) return "NULL";
+	const json = JSON.stringify(value);
+	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(" ");
+}
+const REFERENTIAL_ACTION_SQL = {
+	noAction: "NO ACTION",
+	restrict: "RESTRICT",
+	cascade: "CASCADE",
+	setNull: "SET NULL",
+	setDefault: "SET DEFAULT"
+};
+function buildForeignKeySql(schemaName, tableName, fkName, foreignKey) {
+	let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(fkName)}
+FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(", ")})
+REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns.map(quoteIdentifier).join(", ")})`;
+	if (foreignKey.onDelete !== void 0) {
+		const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];
+		if (!action) throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);
+		sql += `\nON DELETE ${action}`;
+	}
+	if (foreignKey.onUpdate !== void 0) {
+		const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];
+		if (!action) throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);
+		sql += `\nON UPDATE ${action}`;
+	}
+	return sql;
+}
+
+//#endregion
+export { buildForeignKeySql as a, buildCreateTableSql as i, buildColumnDefaultSql as n, renderDefaultLiteral as o, buildColumnTypeSql as r, buildAddColumnSql as t };
+//# sourceMappingURL=planner-ddl-builders-Dxvw1LHw.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner-ddl-builders-Dxvw1LHw.mjs","names":["constraintDefinitions: string[]","REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string>"],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"sourcesContent":["import type { CodecControlHooks } from '@prisma-next/family-sql/control';\nimport type {\n  ForeignKey,\n  ReferentialAction,\n  StorageColumn,\n  StorageTable,\n  StorageTypeInstance,\n} from '@prisma-next/sql-contract/types';\nimport { escapeLiteral, quoteIdentifier } from '../sql-utils';\nimport type { PostgresColumnDefault } from '../types';\nimport { qualifyTableName } from './planner-sql-checks';\nimport { resolveColumnTypeMetadata } from './planner-type-resolution';\n\nexport function buildCreateTableSql(\n  qualifiedTableName: string,\n  table: StorageTable,\n  codecHooks: Map<string, CodecControlHooks>,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n): string {\n  const columnDefinitions = Object.entries(table.columns).map(\n    ([columnName, column]: [string, StorageColumn]) => {\n      const parts = [\n        quoteIdentifier(columnName),\n        buildColumnTypeSql(column, codecHooks, storageTypes),\n        buildColumnDefaultSql(column.default, column),\n        column.nullable ? '' : 'NOT NULL',\n      ].filter(Boolean);\n      return parts.join(' ');\n    },\n  );\n\n  const constraintDefinitions: string[] = [];\n  if (table.primaryKey) {\n    constraintDefinitions.push(\n      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,\n    );\n  }\n\n  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];\n  return `CREATE TABLE ${qualifiedTableName} (\\n  ${allDefinitions.join(',\\n  ')}\\n)`;\n}\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: Map<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  const expanded = expandParameterizedTypeSql(resolved, codecHooks);\n  if (expanded !== null) {\n    return expanded;\n  }\n\n  if (column.typeRef) {\n    return quoteIdentifier(resolved.nativeType);\n  }\n\n  assertSafeNativeType(resolved.nativeType);\n  return resolved.nativeType;\n}\n\nfunction expandParameterizedTypeSql(\n  column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,\n  codecHooks: Map<string, CodecControlHooks>,\n): string | null {\n  if (!column.typeParams) {\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    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?: StorageColumn,\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(value: unknown, column?: StorageColumn): string {\n  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';\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\nexport function buildAddColumnSql(\n  qualifiedTableName: string,\n  columnName: string,\n  column: StorageColumn,\n  codecHooks: Map<string, CodecControlHooks>,\n  temporaryDefault?: string | null,\n  storageTypes: Record<string, StorageTypeInstance> = {},\n): string {\n  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);\n  const defaultSql =\n    buildColumnDefaultSql(column.default, column) ||\n    (temporaryDefault ? `DEFAULT ${temporaryDefault}` : '');\n  const parts = [\n    `ALTER TABLE ${qualifiedTableName}`,\n    `ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,\n    defaultSql,\n    column.nullable ? '' : 'NOT NULL',\n  ].filter(Boolean);\n  return parts.join(' ');\n}\n\nconst REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {\n  noAction: 'NO ACTION',\n  restrict: 'RESTRICT',\n  cascade: 'CASCADE',\n  setNull: 'SET NULL',\n  setDefault: 'SET DEFAULT',\n};\n\nexport function buildForeignKeySql(\n  schemaName: string,\n  tableName: string,\n  fkName: string,\n  foreignKey: ForeignKey,\n): string {\n  let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}\nADD CONSTRAINT ${quoteIdentifier(fkName)}\nFOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(', ')})\nREFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns\n    .map(quoteIdentifier)\n    .join(', ')})`;\n\n  if (foreignKey.onDelete !== undefined) {\n    const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];\n    if (!action) {\n      throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);\n    }\n    sql += `\\nON DELETE ${action}`;\n  }\n  if (foreignKey.onUpdate !== undefined) {\n    const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];\n    if (!action) {\n      throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);\n    }\n    sql += `\\nON UPDATE ${action}`;\n  }\n\n  return sql;\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,22 @@
+import { t as PostgresColumnDefault } from "./types-ClK03Ojd.mjs";
+import { CodecControlHooks } from "@prisma-next/family-sql/control";
+import { ForeignKey, 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: Map<string, CodecControlHooks>, storageTypes?: Record<string, StorageTypeInstance>): string;
+/**
+ * Renders the SQL type for a column in DDL context.
+ *
+ * @param allowPseudoTypes - When true (default), autoincrement integer columns
+ *   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts
+ *   like ALTER COLUMN TYPE where pseudo-types are invalid.
+ */
+declare function buildColumnTypeSql(column: StorageColumn, codecHooks: Map<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: Map<string, CodecControlHooks>, temporaryDefault?: string | null, storageTypes?: Record<string, StorageTypeInstance>): string;
+declare function buildForeignKeySql(schemaName: string, tableName: string, fkName: string, foreignKey: ForeignKey): string;
+//#endregion
+export { buildAddColumnSql, buildColumnDefaultSql, buildColumnTypeSql, buildCreateTableSql, buildForeignKeySql, renderDefaultLiteral };
+//# sourceMappingURL=planner-ddl-builders.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner-ddl-builders.d.mts","names":[],"sources":["../src/core/migrations/planner-ddl-builders.ts"],"sourcesContent":[],"mappings":";;;;;iBAagB,mBAAA,oCAEP,0BACK,YAAY,mCACV,eAAe;;AAJ/B;;;;;;AAIsB,iBA8DN,kBAAA,CA9DM,MAAA,EA+DZ,aA/DY,EAAA,UAAA,EAgER,GAhEQ,CAAA,MAAA,EAgEI,iBAhEJ,CAAA,EAAA,YAAA,CAAA,EAiEN,MAjEM,CAAA,MAAA,EAiES,mBAjET,CAAA,EAAA,gBAAA,CAAA,EAAA,OAAA,CAAA,EAAA,MAAA;AA8DtB;AACU,iBAwEM,qBAAA,CAxEN,aAAA,EAyEO,qBAzEP,GAAA,SAAA,EAAA,MAAA,CAAA,EA0EC,aA1ED,CAAA,EAAA,MAAA;AACgB,iBA8FV,oBAAA,CA9FU,KAAA,EAAA,OAAA,EAAA,MAAA,CAAA,EA8FoC,aA9FpC,CAAA,EAAA,MAAA;AAAZ,iBAoHE,iBAAA,CApHF,kBAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,MAAA,EAuHJ,aAvHI,EAAA,UAAA,EAwHA,GAxHA,CAAA,MAAA,EAwHY,iBAxHZ,CAAA,EAAA,gBAAA,CAAA,EAAA,MAAA,GAAA,IAAA,EAAA,YAAA,CAAA,EA0HE,MA1HF,CAAA,MAAA,EA0HiB,mBA1HjB,CAAA,CAAA,EAAA,MAAA;AACiB,iBAgJf,kBAAA,CAhJe,UAAA,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,EAAA,UAAA,EAoJjB,UApJiB,CAAA,EAAA,MAAA"}

package/dist/planner-ddl-builders.mjs

@@ -0,0 +1,3 @@
+import { a as buildForeignKeySql, i as buildCreateTableSql, n as buildColumnDefaultSql, o as renderDefaultLiteral, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-Dxvw1LHw.mjs";
+
+export { buildAddColumnSql, buildColumnDefaultSql, buildColumnTypeSql, buildCreateTableSql, buildForeignKeySql, renderDefaultLiteral };