@prisma-next/target-postgres 0.4.0-dev.6 → 0.4.0-dev.8

package/dist/descriptor-meta-DkvCmY98.mjs

@@ -0,0 +1,120 @@
+//#region src/core/authoring.ts
+const postgresAuthoringTypes = { enum: {
+	kind: "typeConstructor",
+	args: [{ kind: "string" }, { kind: "stringArray" }],
+	output: {
+		codecId: "pg/enum@1",
+		nativeType: {
+			kind: "arg",
+			index: 0
+		},
+		typeParams: { values: {
+			kind: "arg",
+			index: 1
+		} }
+	}
+} };
+/**
+* Field presets contributed by the Postgres target pack.
+*
+* These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
+* (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
+* via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
+* surface (e.g. `Int`) lowers to byte-identical contracts.
+*/
+const postgresAuthoringFieldPresets = {
+	text: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/text@1",
+			nativeType: "text"
+		}
+	},
+	int: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int4@1",
+			nativeType: "int4"
+		}
+	},
+	bigint: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int8@1",
+			nativeType: "int8"
+		}
+	},
+	float: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/float8@1",
+			nativeType: "float8"
+		}
+	},
+	decimal: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/numeric@1",
+			nativeType: "numeric"
+		}
+	},
+	boolean: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bool@1",
+			nativeType: "bool"
+		}
+	},
+	json: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/jsonb@1",
+			nativeType: "jsonb"
+		}
+	},
+	bytes: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bytea@1",
+			nativeType: "bytea"
+		}
+	},
+	dateTime: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/timestamptz@1",
+			nativeType: "timestamptz"
+		}
+	},
+	createdAt: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/timestamptz@1",
+			nativeType: "timestamptz",
+			default: {
+				kind: "function",
+				expression: "now()"
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/core/descriptor-meta.ts
+const postgresTargetDescriptorMetaBase = {
+	kind: "target",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {},
+	authoring: {
+		type: postgresAuthoringTypes,
+		field: postgresAuthoringFieldPresets
+	}
+};
+const postgresTargetDescriptorMeta = postgresTargetDescriptorMetaBase;
+
+//#endregion
+export { postgresTargetDescriptorMeta as t };
+//# sourceMappingURL=descriptor-meta-DkvCmY98.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-DkvCmY98.mjs","names":["postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n}"],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type {\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\n\nexport const postgresAuthoringTypes = {\n  enum: {\n    kind: 'typeConstructor',\n    args: [{ kind: 'string' }, { kind: 'stringArray' }],\n    output: {\n      codecId: 'pg/enum@1',\n      nativeType: { kind: 'arg', index: 0 },\n      typeParams: {\n        values: { kind: 'arg', index: 1 },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n */\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  createdAt: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n      default: {\n        kind: 'function',\n        expression: 'now()',\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n","import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';\nimport { postgresAuthoringFieldPresets, postgresAuthoringTypes } from './authoring';\n\nconst postgresTargetDescriptorMetaBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";AAKA,MAAa,yBAAyB,EACpC,MAAM;CACJ,MAAM;CACN,MAAM,CAAC,EAAE,MAAM,UAAU,EAAE,EAAE,MAAM,eAAe,CAAC;CACnD,QAAQ;EACN,SAAS;EACT,YAAY;GAAE,MAAM;GAAO,OAAO;GAAG;EACrC,YAAY,EACV,QAAQ;GAAE,MAAM;GAAO,OAAO;GAAG,EAClC;EACF;CACF,EACF;;;;;;;;;AAUD,MAAa,gCAAgC;CAC3C,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,KAAK;EACH,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,QAAQ;EACN,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,UAAU;EACR,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACb;EACF;CACD,WAAW;EACT,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;GACZ,SAAS;IACP,MAAM;IACN,YAAY;IACb;GACF;EACF;CACF;;;;ACnGD,MAAM,mCAAmC;CACvC,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,EAAE;CAChB,WAAW;EACT,MAAM;EACN,OAAO;EACR;CACF;AAED,MAAaA,+BAET"}

package/dist/pack.d.mts

@@ -1,8 +1,7 @@
 import { CodecTypes } from "@prisma-next/adapter-postgres/codec-types";
-import { TargetPackRef } from "@prisma-next/framework-components/components";
 
 //#region src/core/descriptor-meta.d.ts
-declare const postgresTargetDescriptorMeta: {
+declare const postgresTargetDescriptorMetaBase: {
   readonly kind: "target";
   readonly familyId: "sql";
   readonly targetId: "postgres";
@@ -33,13 +32,87 @@ declare const postgresTargetDescriptorMeta: {
         };
       };
     };
+    readonly field: {
+      readonly text: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/text@1";
+          readonly nativeType: "text";
+        };
+      };
+      readonly int: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/int4@1";
+          readonly nativeType: "int4";
+        };
+      };
+      readonly bigint: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/int8@1";
+          readonly nativeType: "int8";
+        };
+      };
+      readonly float: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/float8@1";
+          readonly nativeType: "float8";
+        };
+      };
+      readonly decimal: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/numeric@1";
+          readonly nativeType: "numeric";
+        };
+      };
+      readonly boolean: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/bool@1";
+          readonly nativeType: "bool";
+        };
+      };
+      readonly json: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/jsonb@1";
+          readonly nativeType: "jsonb";
+        };
+      };
+      readonly bytes: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/bytea@1";
+          readonly nativeType: "bytea";
+        };
+      };
+      readonly dateTime: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/timestamptz@1";
+          readonly nativeType: "timestamptz";
+        };
+      };
+      readonly createdAt: {
+        readonly kind: "fieldPreset";
+        readonly output: {
+          readonly codecId: "pg/timestamptz@1";
+          readonly nativeType: "timestamptz";
+          readonly default: {
+            readonly kind: "function";
+            readonly expression: "now()";
+          };
+        };
+      };
+    };
   };
 };
-//#endregion
-//#region src/exports/pack.d.ts
-declare const _default: typeof postgresTargetDescriptorMeta & TargetPackRef<"sql", "postgres"> & {
+declare const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {
   readonly __codecTypes?: CodecTypes;
 };
 //#endregion
-export { _default as default };
+export { postgresTargetDescriptorMeta as default };
 //# sourceMappingURL=pack.d.mts.map

package/dist/pack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts","../src/exports/pack.ts"],"sourcesContent":[],"mappings":";;;;cAEa;;;;EAAA,SAAA,EAAA,EAAA,UAAA;;;;ICA0D,SAOpE,IAAA,EAAA;MAHmC,SAAA,IAAA,EAAA;QACpC,SAAA,IAAA,EAAA,iBAAA;QAC0B,SAAA,IAAA,EAAA,SAAA,CAAA;UAAU,SAAA,IAAA,EAAA,QAAA;;;;;;;;;;;;;;;;;;;;;;;cANiC,iBAIjC,+BACpC;EDLW,SAAA,YAAA,CAAA,ECMe,UDIlB"}
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":[],"mappings":";;;cAGM;;EAAA,SAAA,QAAA,EAAA,KAAA;EAaO,SAAA,QAAA,EAAA,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAA,qCAAqC;0BACxB"}

package/dist/pack.mjs

@@ -1,9 +1,3 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CAf16lsJ.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DkvCmY98.mjs";
 
-//#region src/exports/pack.ts
-const postgresPack = postgresTargetDescriptorMeta;
-var pack_default = postgresPack;
-
-//#endregion
-export { pack_default as default };
-//# sourceMappingURL=pack.mjs.map
+export { postgresTargetDescriptorMeta as default };

package/dist/runtime.mjs

@@ -1,4 +1,4 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CAf16lsJ.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DkvCmY98.mjs";
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 
 //#region src/exports/runtime.ts

package/package.json

@@ -1,33 +1,35 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.4.0-dev.6",
+  "version": "0.4.0-dev.8",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.4.0-dev.6",
-    "@prisma-next/framework-components": "0.4.0-dev.6",
-    "@prisma-next/family-sql": "0.4.0-dev.6",
-    "@prisma-next/sql-builder": "0.4.0-dev.6",
-    "@prisma-next/sql-contract": "0.4.0-dev.6",
-    "@prisma-next/sql-operations": "0.4.0-dev.6",
-    "@prisma-next/sql-errors": "0.4.0-dev.6",
-    "@prisma-next/sql-relational-core": "0.4.0-dev.6",
-    "@prisma-next/sql-schema-ir": "0.4.0-dev.6",
-    "@prisma-next/utils": "0.4.0-dev.6",
-    "@prisma-next/sql-runtime": "0.4.0-dev.6"
+    "pathe": "^2.0.3",
+    "@prisma-next/contract": "0.4.0-dev.8",
+    "@prisma-next/errors": "0.4.0-dev.8",
+    "@prisma-next/family-sql": "0.4.0-dev.8",
+    "@prisma-next/framework-components": "0.4.0-dev.8",
+    "@prisma-next/sql-builder": "0.4.0-dev.8",
+    "@prisma-next/sql-errors": "0.4.0-dev.8",
+    "@prisma-next/sql-relational-core": "0.4.0-dev.8",
+    "@prisma-next/sql-runtime": "0.4.0-dev.8",
+    "@prisma-next/sql-operations": "0.4.0-dev.8",
+    "@prisma-next/sql-contract": "0.4.0-dev.8",
+    "@prisma-next/sql-schema-ir": "0.4.0-dev.8",
+    "@prisma-next/utils": "0.4.0-dev.8"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/adapter-postgres": "0.4.0-dev.6",
-    "@prisma-next/driver-postgres": "0.4.0-dev.6",
-    "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/extension-pgvector": "0.4.0-dev.6",
+    "@prisma-next/adapter-postgres": "0.4.0-dev.8",
+    "@prisma-next/driver-postgres": "0.4.0-dev.8",
+    "@prisma-next/extension-pgvector": "0.4.0-dev.8",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0"
+    "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
     "dist",

package/src/core/authoring.ts

@@ -1,4 +1,7 @@
-import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';
+import type {
+  AuthoringFieldNamespace,
+  AuthoringTypeNamespace,
+} from '@prisma-next/framework-components/authoring';
 
 export const postgresAuthoringTypes = {
   enum: {
@@ -13,3 +16,88 @@ export const postgresAuthoringTypes = {
     },
   },
 } as const satisfies AuthoringTypeNamespace;
+
+/**
+ * Field presets contributed by the Postgres target pack.
+ *
+ * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
+ * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
+ * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
+ * surface (e.g. `Int`) lowers to byte-identical contracts.
+ */
+export const postgresAuthoringFieldPresets = {
+  text: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/text@1',
+      nativeType: 'text',
+    },
+  },
+  int: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/int4@1',
+      nativeType: 'int4',
+    },
+  },
+  bigint: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/int8@1',
+      nativeType: 'int8',
+    },
+  },
+  float: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/float8@1',
+      nativeType: 'float8',
+    },
+  },
+  decimal: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/numeric@1',
+      nativeType: 'numeric',
+    },
+  },
+  boolean: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/bool@1',
+      nativeType: 'bool',
+    },
+  },
+  json: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/jsonb@1',
+      nativeType: 'jsonb',
+    },
+  },
+  bytes: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/bytea@1',
+      nativeType: 'bytea',
+    },
+  },
+  dateTime: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/timestamptz@1',
+      nativeType: 'timestamptz',
+    },
+  },
+  createdAt: {
+    kind: 'fieldPreset',
+    output: {
+      codecId: 'pg/timestamptz@1',
+      nativeType: 'timestamptz',
+      default: {
+        kind: 'function',
+        expression: 'now()',
+      },
+    },
+  },
+} as const satisfies AuthoringFieldNamespace;

package/src/core/descriptor-meta.ts

@@ -1,6 +1,7 @@
-import { postgresAuthoringTypes } from './authoring';
+import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';
+import { postgresAuthoringFieldPresets, postgresAuthoringTypes } from './authoring';
 
-export const postgresTargetDescriptorMeta = {
+const postgresTargetDescriptorMetaBase = {
   kind: 'target',
   familyId: 'sql',
   targetId: 'postgres',
@@ -9,5 +10,10 @@ export const postgresTargetDescriptorMeta = {
   capabilities: {},
   authoring: {
     type: postgresAuthoringTypes,
+    field: postgresAuthoringFieldPresets,
   },
 } as const;
+
+export const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {
+  readonly __codecTypes?: CodecTypes;
+} = postgresTargetDescriptorMetaBase;

package/src/core/migrations/planner.ts

@@ -3,24 +3,30 @@ import {
   parsePostgresDefault,
   quoteIdentifier,
 } from '@prisma-next/adapter-postgres/control';
+import { errorPlanDoesNotSupportAuthoringSurface } from '@prisma-next/errors/migration';
 import type {
   CodecControlHooks,
   ComponentDatabaseDependency,
   MigrationOperationPolicy,
-  SqlMigrationPlanner,
   SqlMigrationPlannerPlanOptions,
   SqlMigrationPlanOperation,
   SqlPlannerConflict,
+  SqlPlannerFailureResult,
 } from '@prisma-next/family-sql/control';
 import {
   collectInitDependencies,
   createMigrationPlan,
   extractCodecControlHooks,
   plannerFailure,
-  plannerSuccess,
 } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
-import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
+import type {
+  MigrationPlanner,
+  MigrationPlanWithAuthoringSurface,
+  MigrationScaffoldContext,
+  SchemaIssue,
+} from '@prisma-next/framework-components/control';
 import type {
   StorageColumn,
   StorageTable,
@@ -58,6 +64,7 @@ import {
   type PlanningMode,
   type PostgresPlanTargetDetails,
 } from './planner-target-details';
+import { renderDescriptorTypeScript } from './scaffolding';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
   readonly frameworkComponents: infer T;
@@ -89,17 +96,79 @@ const DEFAULT_PLANNER_CONFIG: PlannerConfig = {
 
 export function createPostgresMigrationPlanner(
   config: Partial<PlannerConfig> = {},
-): SqlMigrationPlanner<PostgresPlanTargetDetails> {
+): PostgresMigrationPlanner {
   return new PostgresMigrationPlanner({
     ...DEFAULT_PLANNER_CONFIG,
     ...config,
   });
 }
 
-class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTargetDetails> {
+/**
+ * Postgres planner success plan: the SQL-typed plan (so target-detail
+ * typing is preserved for direct SQL callers, including this package's unit
+ * tests) plus the framework-required `renderTypeScript()` stub.
+ */
+export type PostgresPlanWithRender = ReturnType<
+  typeof createMigrationPlan<PostgresPlanTargetDetails>
+> & {
+  renderTypeScript(): string;
+};
+
+/**
+ * Result of `PostgresMigrationPlanner.plan()`. A discriminated union that
+ * satisfies both the framework's `MigrationPlannerResult` (success plan
+ * carries `renderTypeScript()`) and the SQL family's typed result shape
+ * (success plan is a `SqlMigrationPlan<PostgresPlanTargetDetails>`).
+ */
+export type PostgresPlanResult =
+  | { readonly kind: 'success'; readonly plan: PostgresPlanWithRender }
+  | SqlPlannerFailureResult;
+
+/**
+ * Postgres migration planner.
+ *
+ * Implements the framework's `MigrationPlanner<'sql', 'postgres'>` directly
+ * — meaning it owns `emptyMigration()` and attaches the `renderTypeScript()`
+ * stub to success plans (Postgres uses descriptor-flow authoring, so
+ * `renderTypeScript()` throws on planner-produced plans). No external wrapper
+ * is required at the descriptor level.
+ *
+ * `plan()` accepts the framework's option shape (with `contract`/`schema`
+ * typed as `unknown`); SQL-typed callers may pass the more specific
+ * `SqlMigrationPlannerPlanOptions`, since those structurally satisfy the
+ * looser framework contract. Internally we treat options as the SQL-typed
+ * superset so the existing planner logic stays identical.
+ *
+ * `fromHash` is accepted but ignored: Postgres is descriptor-flow and never
+ * needs it (only class-flow planners like Mongo populate `describe()` from
+ * `fromHash`).
+ */
+export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
   constructor(private readonly config: PlannerConfig) {}
 
-  plan(options: SqlMigrationPlannerPlanOptions) {
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly fromHash?: string;
+    readonly schemaName?: string;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  }): PostgresPlanResult {
+    return this.planSql(options as SqlMigrationPlannerPlanOptions);
+  }
+
+  emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {
+    return {
+      targetId: 'postgres',
+      destination: { storageHash: context.toHash },
+      operations: [],
+      renderTypeScript(): string {
+        return renderDescriptorTypeScript([], context);
+      },
+    };
+  }
+
+  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {
     const schemaName = options.schemaName ?? this.config.defaultSchema;
     const policyResult = this.ensureAdditivePolicy(options.policy);
     if (policyResult) {
@@ -176,7 +245,15 @@ class PostgresMigrationPlanner implements SqlMigrationPlanner<PostgresPlanTarget
       operations,
     });
 
-    return plannerSuccess(plan);
+    return Object.freeze({
+      kind: 'success' as const,
+      plan: Object.freeze({
+        ...plan,
+        renderTypeScript(): string {
+          throw errorPlanDoesNotSupportAuthoringSurface({ targetId: 'postgres' });
+        },
+      }),
+    });
   }
 
   private ensureAdditivePolicy(policy: MigrationOperationPolicy) {