@prisma-next/target-postgres 0.12.0-dev.62 → 0.12.0-dev.64

package/dist/{postgres-migration--iqDr7rB.d.mts → postgres-migration-B6rKNT4N.d.mts}

@@ -1,5 +1,6 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-DyUHJ7MY.mjs";
 import { n as DataTransformOptions } from "./data-transform-lq3NGdIt.mjs";
+import { DdlColumn, DdlTableConstraint } from "@prisma-next/sql-relational-core/ast";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { Migration } from "@prisma-next/family-sql/migration";
@@ -44,7 +45,28 @@ declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDet
    * `get operations()`; the adapter argument is hidden from the call site.
    */
   protected dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+  /**
+   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createTable(options: {
+    readonly schema?: string;
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+  /**
+   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createSchema(options: {
+    readonly schema: string;
+    readonly ifNotExists?: boolean;
+  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 }
 //#endregion
 export { PostgresMigration as t };
-//# sourceMappingURL=postgres-migration--iqDr7rB.d.mts.map
+//# sourceMappingURL=postgres-migration-B6rKNT4N.d.mts.map

package/dist/postgres-migration-B6rKNT4N.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-B6rKNT4N.d.mts","names":[],"sources":["../src/core/migrations/postgres-migration.ts"],"mappings":";;;;;;;;;;;;;AAiCA;;;;;;;;;;;;;;;;;;uBAAsB,iBAAA,SAA0B,SAAA,CAC9C,yBAAA;EAAA,SAGS,QAAA;EAJiD;;;;;;EAAA,mBAYvC,cAAA,EAAgB,iBAAA;cAEvB,KAAA,GAAQ,YAAA;EAAR;;;;;EAAA,UAeF,aAAA,mBAAgC,QAAA,CAAS,UAAA,GACjD,QAAA,EAAU,SAAA,EACV,IAAA,UACA,OAAA,EAAS,oBAAA,GACR,yBAAA,CAA0B,yBAAA;EAH3B;;;;;EAAA,UAeQ,WAAA,CAAY,OAAA;IAAA,SACX,MAAA;IAAA,SACA,KAAA;IAAA,SACA,WAAA;IAAA,SACA,OAAA,WAAkB,SAAA;IAAA,SAClB,WAAA,YAAuB,kBAAA;EAAA,IAC9B,yBAAA,CAA0B,yBAAA;EADnB;;;;;EAAA,UAkBD,YAAA,CAAa,OAAA;IAAA,SACZ,MAAA;IAAA,SACA,WAAA;EAAA,IACP,yBAAA,CAA0B,yBAAA;AAAA"}

package/dist/{postgres-migration-DcymFlMG.mjs → postgres-migration-C_wPoWz_.mjs}

@@ -1,5 +1,7 @@
+import { d as CreateTableCall, u as CreateSchemaCall } from "./op-factory-call-q9Tpw6wc.mjs";
 import { t as errorPostgresMigrationStackMissing } from "./errors-CUk87ByX.mjs";
 import { t as dataTransform } from "./data-transform-D25tLeYU.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { Migration } from "@prisma-next/family-sql/migration";
 //#region src/core/migrations/postgres-migration.ts
 /**
@@ -44,8 +46,26 @@ var PostgresMigration = class extends Migration {
 		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
 		return dataTransform(contract, name, options, this.controlAdapter);
 	}
+	/**
+	* Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createTable(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new CreateTableCall(options.schema ?? UNBOUND_NAMESPACE_ID, options.table, options.columns, options.constraints).toOp(this.controlAdapter);
+	}
+	/**
+	* Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createSchema(options) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing();
+		return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
+	}
 };
 //#endregion
 export { PostgresMigration as t };
 
-//# sourceMappingURL=postgres-migration-DcymFlMG.mjs.map
+//# sourceMappingURL=postgres-migration-C_wPoWz_.mjs.map

package/dist/postgres-migration-C_wPoWz_.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-migration-C_wPoWz_.mjs","names":["SqlMigration"],"sources":["../src/core/migrations/postgres-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { Migration as SqlMigration } from '@prisma-next/family-sql/migration';\nimport type { ControlStack } from '@prisma-next/framework-components/control';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport { errorPostgresMigrationStackMissing } from '../errors';\nimport { CreateSchemaCall, CreateTableCall } from './op-factory-call';\nimport { type DataTransformOptions, dataTransform } from './operations/data-transform';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\n/**\n * Target-owned base class for Postgres migrations.\n *\n * Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the\n * abstract `targetId` to the Postgres target-id string literal, so both\n * user-authored migrations and renderer-generated scaffolds (the output of\n * `renderCallsToTypeScript`) can extend `PostgresMigration` directly without\n * redeclaring target-local identity.\n *\n * Mirrors `MongoMigration` in `@prisma-next/family-mongo`: the renderer\n * emits `extends Migration` against a facade re-export of this class\n * from `@prisma-next/postgres/migration`, keeping the authoring surface\n * target-scoped rather than family-scoped.\n *\n * The constructor materializes a single Postgres `SqlControlAdapter` from\n * `stack.adapter.create(stack)` and stores it; the protected `dataTransform`\n * instance method forwards to the free `dataTransform` factory with that\n * stored adapter, so user migrations can write `this.dataTransform(...)`\n * without threading the adapter through every call.\n */\nexport abstract class PostgresMigration extends SqlMigration<\n  PostgresPlanTargetDetails,\n  'postgres'\n> {\n  readonly targetId = 'postgres' as const;\n\n  /**\n   * Materialized Postgres control adapter, created once per migration\n   * instance from the injected stack. `undefined` only when the migration\n   * was instantiated without a stack (test fixtures); `dataTransform`\n   * throws in that case to surface the misuse.\n   */\n  protected readonly controlAdapter: SqlControlAdapter<'postgres'> | undefined;\n\n  constructor(stack?: ControlStack<'sql', 'postgres'>) {\n    super(stack);\n    // The descriptor `create()` is typed as the wider `ControlAdapterInstance`;\n    // the Postgres descriptor concretely returns a `SqlControlAdapter<'postgres'>`,\n    // so the cast holds for any Postgres-target stack assembled at runtime.\n    this.controlAdapter = stack?.adapter\n      ? (stack.adapter.create(stack) as SqlControlAdapter<'postgres'>)\n      : undefined;\n  }\n\n  /**\n   * Instance-method wrapper around the free `dataTransform` factory that\n   * supplies the stored control adapter. Authors call this from inside\n   * `get operations()`; the adapter argument is hidden from the call site.\n   */\n  protected dataTransform<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n    name: string,\n    options: DataTransformOptions,\n  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return dataTransform(contract, name, options, this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createTable(options: {\n    readonly schema?: string;\n    readonly table: string;\n    readonly ifNotExists?: boolean;\n    readonly columns: readonly DdlColumn[];\n    readonly constraints?: readonly DdlTableConstraint[];\n  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateTableCall(\n      options.schema ?? UNBOUND_NAMESPACE_ID,\n      options.table,\n      options.columns,\n      options.constraints,\n    ).toOp(this.controlAdapter);\n  }\n\n  /**\n   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from\n   * the supplied options and lowers it through the stored control adapter.\n   * Throws if no adapter is present (i.e. migration instantiated without a stack).\n   */\n  protected createSchema(options: {\n    readonly schema: string;\n    readonly ifNotExists?: boolean;\n  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {\n    if (!this.controlAdapter) {\n      throw errorPostgresMigrationStackMissing();\n    }\n    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,oBAAtB,cAAgDA,UAG9C;CACA,WAAoB;;;;;;;CAQpB;CAEA,YAAY,OAAyC;EACnD,MAAM,KAAK;EAIX,KAAK,iBAAiB,OAAO,UACxB,MAAM,QAAQ,OAAO,KAAK,IAC3B,KAAA;CACN;;;;;;CAOA,cACE,UACA,MACA,SACsD;EACtD,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,cAAc,UAAU,MAAM,SAAS,KAAK,cAAc;CACnE;;;;;;CAOA,YAAsB,SAMmC;EACvD,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,gBACT,QAAQ,UAAU,sBAClB,QAAQ,OACR,QAAQ,SACR,QAAQ,WACV,CAAC,CAAC,KAAK,KAAK,cAAc;CAC5B;;;;;;CAOA,aAAuB,SAGkC;EACvD,IAAI,CAAC,KAAK,gBACR,MAAM,mCAAmC;EAE3C,OAAO,IAAI,iBAAiB,QAAQ,MAAM,CAAC,CAAC,KAAK,KAAK,cAAc;CACtE;AACF"}

package/dist/{render-ops-Wb6SCGmj.mjs → render-ops-BpjstrKQ.mjs}

@@ -1,3 +1,4 @@
+import { blindCast } from "@prisma-next/utils/casts";
 //#region src/core/migrations/render-ops.ts
 /**
 * Asserts an op materialised by an `OpFactoryCall` targets postgres. The
@@ -10,9 +11,9 @@ function assertPostgresOp(op, callFactoryName) {
 	const targetId = op.target?.id;
 	if (targetId !== "postgres") throw new Error(`renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`);
 }
-function renderOps(calls) {
+function renderOps(calls, lowerer) {
 	return calls.map((c) => {
-		const op = c.toOp();
+		const op = blindCast(c).toOp(lowerer);
 		assertPostgresOp(op, c.factoryName);
 		return op;
 	});
@@ -20,4 +21,4 @@ function renderOps(calls) {
 //#endregion
 export { renderOps as t };
 
-//# sourceMappingURL=render-ops-Wb6SCGmj.mjs.map
+//# sourceMappingURL=render-ops-BpjstrKQ.mjs.map

package/dist/{render-ops-Wb6SCGmj.mjs.map → render-ops-BpjstrKQ.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"render-ops-Wb6SCGmj.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(\n  op: ReturnType<OpFactoryCall['toOp']>,\n  callFactoryName: string,\n): asserts op is Op {\n  const targetId = (op as Partial<Op>).target?.id;\n  if (targetId !== 'postgres') {\n    throw new Error(\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n    );\n  }\n}\n\nexport function renderOps(calls: readonly OpFactoryCall[]): Op[] {\n  return calls.map((c) => {\n    const op = c.toOp();\n    assertPostgresOp(op, c.factoryName);\n    return op;\n  });\n}\n"],"mappings":";;;;;;;;AAaA,SAAS,iBACP,IACA,iBACkB;CAClB,MAAM,WAAY,GAAmB,QAAQ;CAC7C,IAAI,aAAa,YACf,MAAM,IAAI,MACR,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,0HAChI;AAEJ;AAEA,SAAgB,UAAU,OAAuC;CAC/D,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,KAAK,EAAE,KAAK;EAClB,iBAAiB,IAAI,EAAE,WAAW;EAClC,OAAO;CACT,CAAC;AACH"}
+{"version":3,"file":"render-ops-BpjstrKQ.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { Lowerer } from '@prisma-next/family-sql/control-adapter';\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(\n  op: ReturnType<OpFactoryCall['toOp']>,\n  callFactoryName: string,\n): asserts op is Op {\n  const targetId = (op as Partial<Op>).target?.id;\n  if (targetId !== 'postgres') {\n    throw new Error(\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n    );\n  }\n}\n\nexport function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[] {\n  return calls.map((c) => {\n    const op = blindCast<\n      { toOp(lowerer?: Lowerer): ReturnType<OpFactoryCall['toOp']> },\n      'PG OpFactoryCall.toOp accepts an optional Lowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'\n    >(c).toOp(lowerer);\n    assertPostgresOp(op, c.factoryName);\n    return op;\n  });\n}\n"],"mappings":";;;;;;;;;AAeA,SAAS,iBACP,IACA,iBACkB;CAClB,MAAM,WAAY,GAAmB,QAAQ;CAC7C,IAAI,aAAa,YACf,MAAM,IAAI,MACR,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,0HAChI;AAEJ;AAEA,SAAgB,UAAU,OAAiC,SAAyB;CAClF,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,KAAK,UAGT,CAAC,CAAC,CAAC,KAAK,OAAO;EACjB,iBAAiB,IAAI,EAAE,WAAW;EAClC,OAAO;CACT,CAAC;AACH"}

package/dist/render-ops.d.mts

@@ -1,10 +1,11 @@
 import { t as PostgresPlanTargetDetails } from "./planner-target-details-DyUHJ7MY.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { OpFactoryCall } from "@prisma-next/framework-components/control";
+import { Lowerer } from "@prisma-next/family-sql/control-adapter";
 
 //#region src/core/migrations/render-ops.d.ts
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
-declare function renderOps(calls: readonly OpFactoryCall[]): Op[];
+declare function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[];
 //#endregion
 export { renderOps };
 //# sourceMappingURL=render-ops.d.mts.map

package/dist/render-ops.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"render-ops.d.mts","names":[],"sources":["../src/core/migrations/render-ops.ts"],"mappings":";;;;;KAIK,EAAA,GAAK,yBAAyB,CAAC,yBAAA;AAAA,iBAqBpB,SAAA,CAAU,KAAA,WAAgB,aAAA,KAAkB,EAAE"}
+{"version":3,"file":"render-ops.d.mts","names":[],"sources":["../src/core/migrations/render-ops.ts"],"mappings":";;;;;;KAMK,EAAA,GAAK,yBAAyB,CAAC,yBAAA;AAAA,iBAqBpB,SAAA,CAAU,KAAA,WAAgB,aAAA,IAAiB,OAAA,GAAU,OAAA,GAAU,EAAA"}

package/dist/render-ops.mjs

@@ -1,2 +1,2 @@
-import { t as renderOps } from "./render-ops-Wb6SCGmj.mjs";
+import { t as renderOps } from "./render-ops-BpjstrKQ.mjs";
 export { renderOps };

package/dist/{render-typescript-BShM6uyS.mjs → render-typescript-KMgosran.mjs}

@@ -28,7 +28,7 @@ const BASE_IMPORTS = [{
 }];
 function renderCallsToTypeScript(calls, meta) {
 	const imports = buildImports(calls);
-	const operationsBody = calls.map((c) => c.renderTypeScript()).join(",\n");
+	const operationsBody = calls.map((c) => renderCall(c)).join(",\n");
 	return [
 		shebangLineFor(detectScaffoldRuntime()),
 		imports,
@@ -46,6 +46,9 @@ function renderCallsToTypeScript(calls, meta) {
 		""
 	].join("\n");
 }
+function renderCall(call) {
+	return call.renderTypeScript();
+}
 function buildImports(calls) {
 	const requirements = [...BASE_IMPORTS];
 	for (const call of calls) for (const req of call.importRequirements()) requirements.push(req);
@@ -69,4 +72,4 @@ function indent(text, spaces) {
 //#endregion
 export { renderCallsToTypeScript as t };
 
-//# sourceMappingURL=render-typescript-BShM6uyS.mjs.map
+//# sourceMappingURL=render-typescript-KMgosran.mjs.map

package/dist/render-typescript-KMgosran.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-typescript-KMgosran.mjs","names":[],"sources":["../src/core/migrations/render-typescript.ts"],"sourcesContent":["/**\n * Polymorphic TypeScript emitter for the Postgres migration IR.\n *\n * Each `OpFactoryCall` renders itself via `renderTypeScript()` and\n * declares its own `importRequirements()`; this file just composes the module\n * source around those contributions. The design mirrors the Mongo target's\n * `render-typescript.ts` deliberately — byte-for-byte alignment isn't required\n * (different factory module specifiers, different base-class name) but the\n * shape is, so future consolidation to a framework-level helper is mechanical.\n */\n\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';\nimport { type ImportRequirement, renderImports } from '@prisma-next/ts-render';\n\nexport interface RenderMigrationMeta {\n  readonly from: string | null;\n  readonly to: string;\n}\n\n/**\n * Always-present base imports for the rendered scaffold. Both come from\n * `@prisma-next/postgres/migration` so an authored Postgres\n * `migration.ts` only needs a single dependency for its base class and\n * its CLI entrypoint:\n *\n * - `Migration` — the facade re-export fixes the `SqlMigration`\n *   generic to `PostgresPlanTargetDetails` and the abstract `targetId`\n *   to `'postgres'`, so user-authored migrations don't need to thread\n *   target-details or redeclare `targetId`.\n * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from\n *   `@prisma-next/cli/migration-cli`. Loads `prisma-next.config.ts`,\n *   assembles a `ControlStack`, and instantiates the migration class.\n *   The migration file owns this dependency directly: pulling CLI\n *   machinery in at script run time is acceptable because the script's\n *   whole purpose is to be invoked from the project that owns the\n *   config.\n */\nconst BASE_IMPORTS: readonly ImportRequirement[] = [\n  { moduleSpecifier: '@prisma-next/postgres/migration', symbol: 'Migration' },\n  { moduleSpecifier: '@prisma-next/postgres/migration', symbol: 'MigrationCLI' },\n];\n\nexport function renderCallsToTypeScript(\n  calls: ReadonlyArray<OpFactoryCall>,\n  meta: RenderMigrationMeta,\n): string {\n  const imports = buildImports(calls);\n  const operationsBody = calls.map((c) => renderCall(c)).join(',\\n');\n\n  return [\n    shebangLineFor(detectScaffoldRuntime()),\n    imports,\n    '',\n    'export default class M extends Migration {',\n    buildDescribeMethod(meta),\n    '  override get operations() {',\n    '    return [',\n    indent(operationsBody, 6),\n    '    ];',\n    '  }',\n    '}',\n    '',\n    'MigrationCLI.run(import.meta.url, M);',\n    '',\n  ].join('\\n');\n}\n\nfunction renderCall(call: OpFactoryCall): string {\n  return call.renderTypeScript();\n}\n\nfunction buildImports(calls: ReadonlyArray<OpFactoryCall>): string {\n  const requirements: ImportRequirement[] = [...BASE_IMPORTS];\n  for (const call of calls) {\n    for (const req of call.importRequirements()) {\n      requirements.push(req);\n    }\n  }\n  return renderImports(requirements);\n}\n\nfunction buildDescribeMethod(meta: RenderMigrationMeta): string {\n  const lines: string[] = [];\n  lines.push('  override describe() {');\n  lines.push('    return {');\n  lines.push(`      from: ${JSON.stringify(meta.from)},`);\n  lines.push(`      to: ${JSON.stringify(meta.to)},`);\n  lines.push('    };');\n  lines.push('  }');\n  lines.push('');\n  return lines.join('\\n');\n}\n\nfunction indent(text: string, spaces: number): string {\n  const pad = ' '.repeat(spaces);\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${pad}${line}` : line))\n    .join('\\n');\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsCA,MAAM,eAA6C,CACjD;CAAE,iBAAiB;CAAmC,QAAQ;AAAY,GAC1E;CAAE,iBAAiB;CAAmC,QAAQ;AAAe,CAC/E;AAEA,SAAgB,wBACd,OACA,MACQ;CACR,MAAM,UAAU,aAAa,KAAK;CAClC,MAAM,iBAAiB,MAAM,KAAK,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK;CAEjE,OAAO;EACL,eAAe,sBAAsB,CAAC;EACtC;EACA;EACA;EACA,oBAAoB,IAAI;EACxB;EACA;EACA,OAAO,gBAAgB,CAAC;EACxB;EACA;EACA;EACA;EACA;EACA;CACF,CAAC,CAAC,KAAK,IAAI;AACb;AAEA,SAAS,WAAW,MAA6B;CAC/C,OAAO,KAAK,iBAAiB;AAC/B;AAEA,SAAS,aAAa,OAA6C;CACjE,MAAM,eAAoC,CAAC,GAAG,YAAY;CAC1D,KAAK,MAAM,QAAQ,OACjB,KAAK,MAAM,OAAO,KAAK,mBAAmB,GACxC,aAAa,KAAK,GAAG;CAGzB,OAAO,cAAc,YAAY;AACnC;AAEA,SAAS,oBAAoB,MAAmC;CAC9D,MAAM,QAAkB,CAAC;CACzB,MAAM,KAAK,yBAAyB;CACpC,MAAM,KAAK,cAAc;CACzB,MAAM,KAAK,eAAe,KAAK,UAAU,KAAK,IAAI,EAAE,EAAE;CACtD,MAAM,KAAK,aAAa,KAAK,UAAU,KAAK,EAAE,EAAE,EAAE;CAClD,MAAM,KAAK,QAAQ;CACnB,MAAM,KAAK,KAAK;CAChB,MAAM,KAAK,EAAE;CACb,OAAO,MAAM,KAAK,IAAI;AACxB;AAEA,SAAS,OAAO,MAAc,QAAwB;CACpD,MAAM,MAAM,IAAI,OAAO,MAAM;CAC7B,OAAO,KACJ,MAAM,IAAI,CAAC,CACX,KAAK,SAAU,KAAK,KAAK,IAAI,GAAG,MAAM,SAAS,IAAK,CAAC,CACrD,KAAK,IAAI;AACd"}

package/dist/render-typescript.mjs

@@ -1,2 +1,2 @@
-import { t as renderCallsToTypeScript } from "./render-typescript-BShM6uyS.mjs";
+import { t as renderCallsToTypeScript } from "./render-typescript-KMgosran.mjs";
 export { renderCallsToTypeScript };

package/dist/{shared-C3gXQyxj.d.mts → shared-C6QxSU0W.d.mts}

@@ -5,9 +5,9 @@ import { ReferentialAction } from "@prisma-next/sql-contract/types";
 //#region src/core/migrations/operations/shared.d.ts
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 /**
- * Literal-args shape for a column definition consumed by `createTable` and
- * `addColumn`. Fully materialized: codec expansion and default rendering have
- * already happened in the wrapper.
+ * Literal-args shape for a column definition consumed by `addColumn` and
+ * similar operations. Fully materialized: codec expansion and default
+ * rendering have already happened in the wrapper.
  *
  * - `typeSql` is the column's DDL type string (e.g. `"integer"`, `"SERIAL"`,
  *   `"varchar(100)"`), already produced by `buildColumnTypeSql` in the
@@ -40,4 +40,4 @@ interface ForeignKeySpec {
 }
 //#endregion
 export { ForeignKeySpec as n, Op as r, ColumnSpec as t };
-//# sourceMappingURL=shared-C3gXQyxj.d.mts.map
+//# sourceMappingURL=shared-C6QxSU0W.d.mts.map

package/dist/{shared-C3gXQyxj.d.mts.map → shared-C6QxSU0W.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"shared-C3gXQyxj.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"mappings":";;;;;KAMY,EAAA,GAAK,yBAAyB,CAAC,yBAAA;;AAA3C;;;;AAAoE;AAcpE;;;;;;UAAiB,UAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;AAAA;;;;;;UAQM,cAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;IAAA,SACE,MAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA;EAAA,SAEF,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAiB;AAAA"}
+{"version":3,"file":"shared-C6QxSU0W.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"mappings":";;;;;KAMY,EAAA,GAAK,yBAAyB,CAAC,yBAAA;;AAA3C;;;;AAAoE;AAcpE;;;;;;UAAiB,UAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;AAAA;;;;;;UAQM,cAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;IAAA,SACE,MAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA;EAAA,SAEF,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAiB;AAAA"}

package/package.json

@@ -1,32 +1,32 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.12.0-dev.62",
+  "version": "0.12.0-dev.64",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.12.0-dev.62",
-    "@prisma-next/contract": "0.12.0-dev.62",
-    "@prisma-next/errors": "0.12.0-dev.62",
-    "@prisma-next/family-sql": "0.12.0-dev.62",
-    "@prisma-next/framework-components": "0.12.0-dev.62",
-    "@prisma-next/migration-tools": "0.12.0-dev.62",
-    "@prisma-next/ts-render": "0.12.0-dev.62",
-    "@prisma-next/sql-contract": "0.12.0-dev.62",
-    "@prisma-next/sql-errors": "0.12.0-dev.62",
-    "@prisma-next/sql-operations": "0.12.0-dev.62",
-    "@prisma-next/sql-relational-core": "0.12.0-dev.62",
-    "@prisma-next/sql-schema-ir": "0.12.0-dev.62",
-    "@prisma-next/utils": "0.12.0-dev.62",
+    "@prisma-next/cli": "0.12.0-dev.64",
+    "@prisma-next/contract": "0.12.0-dev.64",
+    "@prisma-next/errors": "0.12.0-dev.64",
+    "@prisma-next/family-sql": "0.12.0-dev.64",
+    "@prisma-next/framework-components": "0.12.0-dev.64",
+    "@prisma-next/migration-tools": "0.12.0-dev.64",
+    "@prisma-next/ts-render": "0.12.0-dev.64",
+    "@prisma-next/sql-contract": "0.12.0-dev.64",
+    "@prisma-next/sql-errors": "0.12.0-dev.64",
+    "@prisma-next/sql-operations": "0.12.0-dev.64",
+    "@prisma-next/sql-relational-core": "0.12.0-dev.64",
+    "@prisma-next/sql-schema-ir": "0.12.0-dev.64",
+    "@prisma-next/utils": "0.12.0-dev.64",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.12.0-dev.62",
-    "@prisma-next/tsconfig": "0.12.0-dev.62",
-    "@prisma-next/tsdown": "0.12.0-dev.62",
+    "@prisma-next/test-utils": "0.12.0-dev.64",
+    "@prisma-next/tsconfig": "0.12.0-dev.64",
+    "@prisma-next/tsdown": "0.12.0-dev.64",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.7"

package/src/contract-free/ddl.ts

@@ -1,9 +1,13 @@
-import type { DdlColumn } from '@prisma-next/sql-relational-core/ast';
+import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import { PostgresCreateSchema, PostgresCreateTable } from '../core/ddl/nodes';
 
 /**
  * Build a Postgres `CREATE TABLE` query node.
  *
+ * Pass `constraints` for table-level composite primary keys, foreign keys, and
+ * unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},
+ * and {@link UniqueConstraint} classes from `@prisma-next/sql-relational-core/ast`.
+ *
  * Precondition: identifiers (`table`, `schema`, column names/types) are
  * emitted to SQL verbatim — they are not quoted or escaped, so callers must
  * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal
@@ -16,6 +20,7 @@ export function createTable(options: {
   readonly schema?: string;
   readonly ifNotExists?: boolean;
   readonly columns: readonly DdlColumn[];
+  readonly constraints?: readonly DdlTableConstraint[];
 }): PostgresCreateTable {
   return new PostgresCreateTable(options);
 }

package/src/core/ddl/nodes.ts

@@ -1,4 +1,8 @@
-import { type DdlColumn, DdlNode } from '@prisma-next/sql-relational-core/ast';
+import {
+  type DdlColumn,
+  DdlNode,
+  type DdlTableConstraint,
+} from '@prisma-next/sql-relational-core/ast';
 
 export interface PostgresDdlVisitor<R> {
   createTable(node: PostgresCreateTable): R;
@@ -13,24 +17,33 @@ function freezeDdlColumns(columns: readonly DdlColumn[]): ReadonlyArray<DdlColum
   return Object.freeze([...columns]);
 }
 
+function freezeConstraints(
+  constraints: readonly DdlTableConstraint[] | undefined,
+): ReadonlyArray<DdlTableConstraint> | undefined {
+  return constraints ? Object.freeze([...constraints]) : undefined;
+}
+
 export class PostgresCreateTable extends PostgresDdlNode {
   readonly kind = 'create-table' as const;
   readonly table: string;
   readonly schema: string | undefined;
   readonly ifNotExists: boolean | undefined;
   readonly columns: ReadonlyArray<DdlColumn>;
+  readonly constraints: ReadonlyArray<DdlTableConstraint> | undefined;
 
   constructor(options: {
     readonly table: string;
     readonly schema?: string;
     readonly ifNotExists?: boolean;
     readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
   }) {
     super();
     this.table = options.table;
     this.schema = options.schema;
     this.ifNotExists = options.ifNotExists;
     this.columns = freezeDdlColumns(options.columns);
+    this.constraints = freezeConstraints(options.constraints);
     this.freeze();
   }
 

package/src/core/migrations/issue-planner.ts

@@ -25,6 +25,8 @@ import type {
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
+import * as contractFree from '@prisma-next/sql-relational-core/contract-free';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
@@ -47,6 +49,7 @@ import {
   DropNotNullCall,
   DropTableCall,
   type PostgresOpFactoryCall,
+  postgresDefaultToDdlColumnDefault,
   SetDefaultCall,
   SetNotNullCall,
 } from './op-factory-call';
@@ -191,16 +194,26 @@ function toColumnSpec(
 ): ColumnSpec {
   return {
     name,
-    typeSql: buildColumnTypeSql(
-      column,
-      codecHooks as Map<string, CodecControlHooks>,
-      storageTypes as Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-    ),
+    typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),
     defaultSql: buildColumnDefaultSql(column.default, column),
     nullable: column.nullable,
   };
 }
 
+function toDdlColumn(
+  name: string,
+  column: StorageColumn,
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+): DdlColumn {
+  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
+  const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
+  return contractFree.col(name, typeSql, {
+    ...(!column.nullable ? { notNull: true } : {}),
+    ...(ddlDefault ? { default: ddlDefault } : {}),
+  });
+}
+
 function mapIssueToCall(
   issue: SchemaIssue,
   ctx: StrategyContext,
@@ -245,14 +258,18 @@ function mapIssueToCall(
         );
       }
       const schemaForTable = tableSchema(issue);
-      const columns: ColumnSpec[] = Object.entries(contractTable.columns).map(([name, column]) =>
-        toColumnSpec(name, column, codecHooks, storageTypes),
+      const ddlColumns: DdlColumn[] = Object.entries(contractTable.columns).map(([name, column]) =>
+        toDdlColumn(name, column, codecHooks, storageTypes),
       );
-      const primaryKey = contractTable.primaryKey
-        ? { columns: contractTable.primaryKey.columns }
+      const ddlConstraints: DdlTableConstraint[] | undefined = contractTable.primaryKey
+        ? [
+            contractFree.primaryKey(contractTable.primaryKey.columns, {
+              ...(contractTable.primaryKey.name ? { name: contractTable.primaryKey.name } : {}),
+            }),
+          ]
         : undefined;
       const calls: PostgresOpFactoryCall[] = [
-        new CreateTableCall(schemaForTable, issue.table, columns, primaryKey),
+        new CreateTableCall(schemaForTable, issue.table, ddlColumns, ddlConstraints),
       ];
       for (const index of contractTable.indexes) {
         const indexName = index.name ?? `${issue.table}_${index.columns.join('_')}_idx`;