@prisma-next/adapter-postgres 0.12.0-dev.3 → 0.12.0-dev.30

package/README.md

@@ -20,7 +20,7 @@ Provide PostgreSQL-specific adapter implementation, codecs, and capabilities. En
 
 - **Adapter Implementation**: Implement `Adapter` SPI for PostgreSQL
   - Lower SQL ASTs to PostgreSQL dialect SQL
-  - Render `includeMany` as `LEFT JOIN LATERAL` with `json_agg` for nested array includes
+  - Render JSON aggregation (`json_agg`, `json_build_object`) and scalar subqueries
   - Advertise PostgreSQL capabilities (`lateral`, `jsonAgg`)
   - Normalize PostgreSQL EXPLAIN output
   - Map PostgreSQL errors to `RuntimeError` envelope
@@ -89,8 +89,8 @@ flowchart TD
 **Adapter (`adapter.ts`)**
 - Main adapter implementation
 - Lowers SQL ASTs to PostgreSQL SQL
-- Renders joins (INNER, LEFT, RIGHT, FULL) with ON conditions
-- Renders `includeMany` as `LEFT JOIN LATERAL` with `json_agg` for nested array includes
+- Renders joins (INNER, LEFT, RIGHT, FULL, LATERAL) with ON conditions
+- Renders JSON aggregation (`json_agg`, `json_build_object`) and scalar subqueries
 - Renders DML operations (INSERT, UPDATE, DELETE) with RETURNING clauses
 - Advertises PostgreSQL capabilities (`lateral`, `jsonAgg`, `returning`)
 - Maps PostgreSQL errors to `RuntimeError`
@@ -191,8 +191,8 @@ The adapter declares the following PostgreSQL capabilities:
 
 - **`orderBy: true`** - Supports ORDER BY clauses
 - **`limit: true`** - Supports LIMIT clauses
-- **`lateral: true`** - Supports LATERAL joins for `includeMany` nested array includes
-- **`jsonAgg: true`** - Supports JSON aggregation functions (`json_agg`) for `includeMany`
+- **`lateral: true`** - Supports LATERAL joins
+- **`jsonAgg: true`** - Supports JSON aggregation functions (`json_agg`)
 - **`returning: true`** - Supports RETURNING clauses for DML operations (INSERT, UPDATE, DELETE)
 - **`sql.enums: true`** - Supports contract-defined enum storage types
 
@@ -205,29 +205,22 @@ The capabilities on the descriptor must match the capabilities in code. If they
 
 See `docs/reference/capabilities.md` and `docs/architecture docs/subsystems/5. Adapters & Targets.md` for details.
 
-## includeMany Support
+## JSON Aggregation
 
-The adapter supports `includeMany` for nested array includes using PostgreSQL's `LATERAL` joins and `json_agg`:
+The renderer lowers JSON-aggregation AST nodes to PostgreSQL's `json_agg`:
 
-**Lowering Strategy:**
-- Renders `includeMany` as `LEFT JOIN LATERAL` with a subquery that uses `json_agg(json_build_object(...))` to aggregate child rows into a JSON array
-- The ON condition from the include is moved into the WHERE clause of the lateral subquery
-- When both `ORDER BY` and `LIMIT` are present, wraps the query in an inner SELECT that projects individual columns with aliases, then uses `json_agg(row_to_json(sub.*))` on the result
-- Uses different aliases for the table (`{alias}_lateral`) and column (`{alias}`) to avoid ambiguity
-
-**Capabilities Required:**
-- `lateral: true` - Enables LATERAL join support
-- `jsonAgg: true` - Enables `json_agg` function support
+- `json_agg(json_build_object(...))` aggregates a row set into a JSON array of objects
+- A scalar subquery (`SubqueryExpr`) in the SELECT list correlates against the outer row through its WHERE clause
+- When the subquery carries an inner `ORDER BY` and `LIMIT`, its rows are wrapped in an inner SELECT, then aggregated with `json_agg(row_to_json(sub.*))`
 
 **Example SQL Output:**
 ```sql
-SELECT "user"."id" AS "id", "posts_lateral"."posts" AS "posts"
-FROM "user"
-LEFT JOIN LATERAL (
+SELECT "user"."id" AS "id", (
   SELECT json_agg(json_build_object('id', "post"."id", 'title', "post"."title")) AS "posts"
   FROM "post"
   WHERE "user"."id" = "post"."userId"
-) AS "posts_lateral" ON true
+) AS "posts"
+FROM "user"
 ```
 
 ## DML Operations with RETURNING

package/dist/{adapter-H8BiuXdq.mjs → adapter-Dr2W2Syq.mjs}

@@ -1,5 +1,6 @@
-import { n as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DlZhVI9B.mjs";
+import { n as renderLoweredDdl, r as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DqVeL4hP.mjs";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
+import { isDdlNode } from "@prisma-next/sql-relational-core/ast";
 import { parseContractMarkerRow } from "@prisma-next/sql-runtime";
 //#region src/core/adapter.ts
 const defaultCapabilities = Object.freeze({
@@ -33,6 +34,7 @@ var PostgresAdapterImpl = class {
 		});
 	}
 	lower(ast, context) {
+		if (isDdlNode(ast)) return renderLoweredDdl(ast);
 		return renderLoweredSql(ast, context.contract, this.codecLookup);
 	}
 };
@@ -62,4 +64,4 @@ function createPostgresAdapter(options) {
 //#endregion
 export { postgresRawCodecInferer as n, createPostgresAdapter as t };
 
-//# sourceMappingURL=adapter-H8BiuXdq.mjs.map
+//# sourceMappingURL=adapter-Dr2W2Syq.mjs.map

package/dist/adapter-Dr2W2Syq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-Dr2W2Syq.mjs","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":["import type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport { APP_SPACE_ID } from '@prisma-next/framework-components/control';\nimport type {\n  Adapter,\n  AdapterProfile,\n  AnyQueryAst,\n  LowererContext,\n  MarkerReadResult,\n  RawSqlLiteral,\n  SqlQueryable,\n} from '@prisma-next/sql-relational-core/ast';\nimport { isDdlNode } from '@prisma-next/sql-relational-core/ast';\nimport type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport { parseContractMarkerRow } from '@prisma-next/sql-runtime';\nimport type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { renderLoweredDdl } from './ddl-renderer';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n    distinctOn: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n    lateral: true,\n  },\n});\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecLookup: CodecLookup;\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.codecLookup = options?.codecLookup ?? createPostgresBuiltinCodecLookup();\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) => readPostgresMarker(queryable),\n    });\n  }\n\n  lower(\n    ast: AnyQueryAst | PostgresDdlNode,\n    context: LowererContext<PostgresContract>,\n  ): PostgresLoweredStatement {\n    if (isDdlNode(ast)) {\n      return renderLoweredDdl(ast);\n    }\n    return renderLoweredSql(ast, context.contract, this.codecLookup);\n  }\n}\n\n/** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */\nexport const postgresRawCodecInferer: RawCodecInferer = {\n  inferCodec(value: RawSqlLiteral): string {\n    switch (typeof value) {\n      case 'number':\n        return Number.isSafeInteger(value) && value % 1 === 0 ? 'pg/int4' : 'pg/float8';\n      case 'bigint':\n        return 'pg/int8';\n      case 'string':\n        return 'pg/text';\n      case 'boolean':\n        return 'pg/bool';\n      case 'object':\n        if (value instanceof Uint8Array) return 'pg/bytea';\n    }\n    throw new Error(\n      'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',\n    );\n  },\n};\n\nasync function readPostgresMarker(queryable: SqlQueryable): Promise<MarkerReadResult> {\n  const exists = await queryable.query(\n    'select 1 from information_schema.tables where table_schema = $1 and table_name = $2',\n    ['prisma_contract', 'marker'],\n  );\n  if (exists.rows.length === 0) {\n    return { kind: 'no-table' };\n  }\n\n  const result = await queryable.query(\n    'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where space = $1',\n    [APP_SPACE_ID],\n  );\n  const row = result.rows[0];\n  if (!row) {\n    return { kind: 'absent' };\n  }\n  // Postgres' driver hydrates `text[]` columns as native JS arrays, so the row is already in the shape the shared parser expects.\n  return { kind: 'present', record: parseContractMarkerRow(row) };\n}\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;;AAoBA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACX,YAAY;CACd;CACA,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EACjB,SAAS;CACX;AACF,CAAC;AAED,IAAM,sBAAN,MAEA;CAEE,WAAoB;CACpB,WAAoB;CAEpB;CACA;CAEA,YAAY,SAAkC;EAC5C,KAAK,cAAc,SAAS,eAAe,iCAAiC;EAC5E,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,aAAa,cAA4B,mBAAmB,SAAS;EACvE,CAAC;CACH;CAEA,MACE,KACA,SAC0B;EAC1B,IAAI,UAAU,GAAG,GACf,OAAO,iBAAiB,GAAG;EAE7B,OAAO,iBAAiB,KAAK,QAAQ,UAAU,KAAK,WAAW;CACjE;AACF;;AAGA,MAAa,0BAA2C,EACtD,WAAW,OAA8B;CACvC,QAAQ,OAAO,OAAf;EACE,KAAK,UACH,OAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,MAAM,IAAI,YAAY;EACtE,KAAK,UACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,UACH,IAAI,iBAAiB,YAAY,OAAO;CAC5C;CACA,MAAM,IAAI,MACR,6GACF;AACF,EACF;AAEA,eAAe,mBAAmB,WAAoD;CAKpF,KAAI,MAJiB,UAAU,MAC7B,uFACA,CAAC,mBAAmB,QAAQ,CAC9B,GACW,KAAK,WAAW,GACzB,OAAO,EAAE,MAAM,WAAW;CAO5B,MAAM,OAAM,MAJS,UAAU,MAC7B,wJACA,CAAC,YAAY,CACf,GACmB,KAAK;CACxB,IAAI,CAAC,KACH,OAAO,EAAE,MAAM,SAAS;CAG1B,OAAO;EAAE,MAAM;EAAW,QAAQ,uBAAuB,GAAG;CAAE;AAChE;AAEA,SAAgB,sBAAsB,SAAkC;CACtE,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}

package/dist/adapter.d.mts

@@ -1,6 +1,7 @@
 import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-B1eiuBHQ.mjs";
 import { Adapter, AdapterProfile, AnyQueryAst, LowererContext } from "@prisma-next/sql-relational-core/ast";
 import { RawCodecInferer } from "@prisma-next/sql-relational-core/expression";
+import { PostgresDdlNode } from "@prisma-next/target-postgres/ddl";
 
 //#region src/core/adapter.d.ts
 declare class PostgresAdapterImpl implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement> {
@@ -9,7 +10,7 @@ declare class PostgresAdapterImpl implements Adapter<AnyQueryAst, PostgresContra
   readonly profile: AdapterProfile<'postgres'>;
   private readonly codecLookup;
   constructor(options?: PostgresAdapterOptions);
-  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement;
+  lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<PostgresContract>): PostgresLoweredStatement;
 }
 /** Codec-id lookup for bare-literal interpolations used by `fns.raw` on a postgres client. Contributed as the descriptor's static `rawCodecInferer` slot. */
 declare const postgresRawCodecInferer: RawCodecInferer;

package/dist/adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;cAkCM,mBAAA,YACO,OAAA,CAAQ,WAAA,EAAa,gBAAA,EAAkB,wBAAA;EAAA,SAGzC,QAAA;EAAA,SACA,QAAA;EAAA,SAEA,OAAA,EAAS,cAAA;EAAA,iBACD,WAAA;cAEL,OAAA,GAAU,sBAAA;EAUtB,KAAA,CAAM,GAAA,EAAK,WAAA,EAAa,OAAA,EAAS,cAAA,CAAe,gBAAA,IAAoB,wBAAA;AAAA;;cAMzD,uBAAA,EAAyB,eAkBrC;AAAA,iBAuBe,qBAAA,CAAsB,OAAA,GAAU,sBAAA,GAAsB,QAAA,CAAA,mBAAA"}
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"mappings":";;;;;;cAqCM,mBAAA,YACO,OAAA,CAAQ,WAAA,EAAa,gBAAA,EAAkB,wBAAA;EAAA,SAGzC,QAAA;EAAA,SACA,QAAA;EAAA,SAEA,OAAA,EAAS,cAAA;EAAA,iBACD,WAAA;cAEL,OAAA,GAAU,sBAAA;EAUtB,KAAA,CACE,GAAA,EAAK,WAAA,GAAc,eAAA,EACnB,OAAA,EAAS,cAAA,CAAe,gBAAA,IACvB,wBAAA;AAAA;;cASQ,uBAAA,EAAyB,eAkBrC;AAAA,iBAuBe,qBAAA,CAAsB,OAAA,GAAU,sBAAA,GAAsB,QAAA,CAAA,mBAAA"}

package/dist/adapter.mjs

@@ -1,2 +1,2 @@
-import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-H8BiuXdq.mjs";
+import { n as postgresRawCodecInferer, t as createPostgresAdapter } from "./adapter-Dr2W2Syq.mjs";
 export { createPostgresAdapter, postgresRawCodecInferer };

package/dist/control.d.mts

@@ -1,10 +1,12 @@
 import { ControlDriverInstance } from "@prisma-next/framework-components/control";
-import { AnyQueryAst, LoweredStatement, LowererContext } from "@prisma-next/sql-relational-core/ast";
+import { AnyQueryAst, DdlNode, LoweredStatement, LowererContext } from "@prisma-next/sql-relational-core/ast";
 import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { postgresColumnsCompatible } from "@prisma-next/target-postgres/column-type-compatibility";
 import { parsePostgresDefault, parsePostgresDefault as parsePostgresDefault$1 } from "@prisma-next/target-postgres/default-normalizer";
 import { normalizeSchemaNativeType, normalizeSchemaNativeType as normalizeSchemaNativeType$1 } from "@prisma-next/target-postgres/native-type-normalizer";
 import { SqlControlAdapterDescriptor } from "@prisma-next/family-sql/control";
-import { Contract, ContractMarkerRecord } from "@prisma-next/contract/types";
+import { PostgresDdlNode } from "@prisma-next/target-postgres/ddl";
+import { Contract, ContractMarkerRecord, LedgerEntryRecord } from "@prisma-next/contract/types";
 import { CodecLookup } from "@prisma-next/framework-components/codec";
 import { PostgresEnumStorageEntry, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlControlAdapter } from "@prisma-next/family-sql/control-adapter";
@@ -38,6 +40,12 @@ declare class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * before comparison with contract native types.
    */
   readonly normalizeNativeType: typeof normalizeSchemaNativeType$1;
+  /**
+   * Target-supplied compatible-shape relation used under the `external`
+   * control policy. Threading the same relation the migration planner/runner
+   * use keeps runtime verify and migration verify in agreement.
+   */
+  readonly columnsCompatible: typeof postgresColumnsCompatible;
   /**
    * Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
    * introspection shape (`schema.annotations.pg.storageTypes`). Lets
@@ -46,6 +54,8 @@ declare class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   readonly resolveExistingEnumValues: (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
   readonly resolveExistingEnumValuesForContract: (contract: Contract<SqlStorage>) => (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
+  bootstrapControlTableQueries(): readonly DdlNode[];
+  bootstrapSignMarkerQueries(): readonly DdlNode[];
   /**
    * Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
    *
@@ -54,7 +64,7 @@ declare class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
    * without instantiating the runtime adapter.
    */
-  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement;
+  lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<unknown>): LoweredStatement;
   /**
    * Reads the contract marker from `prisma_contract.marker`. Probes
    * `information_schema.tables` first so a fresh database (where the
@@ -71,6 +81,13 @@ declare class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * map rather than raising "relation does not exist".
    */
   readAllMarkers(driver: ControlDriverInstance<'sql', 'postgres'>): Promise<ReadonlyMap<string, ContractMarkerRecord>>;
+  /**
+   * Reads per-migration ledger rows from `prisma_contract.ledger` in apply
+   * order. Probes `information_schema.tables` first so a fresh database
+   * without the ledger table returns `[]` instead of raising "relation does
+   * not exist".
+   */
+  readLedger(driver: ControlDriverInstance<'sql', 'postgres'>, space?: string): Promise<readonly LedgerEntryRecord[]>;
   /**
    * Introspects a Postgres database schema and returns a raw SqlSchemaIR.
    *

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-adapter.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;;;;;;;;cAkDa,sBAAA,YAAkC,iBAAA;EAAA,SACpC,QAAA;EAAA,SACA,QAAA;EAAA,iBAEQ,WAAA;EAiBQ;;;;;;;cARb,WAAA,GAAc,WAAA;EA8Cf;;;;EAAA,SAtCF,gBAAA,SAAgB,sBAAA;EAqDtB;;;;;EAAA,SA9CM,mBAAA,SAAmB,2BAAA;EA4LjB;;;;;;EAAA,SApLF,yBAAA,GACP,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA,EACV,WAAA;EAAA,SASO,oCAAA,GAAwC,QAAA,EAAU,QAAA,CAAS,UAAA,OAAW,MAAA,EAAA,WAAA,EAAA,QAAA,EAAA,wBAAA,EAAA,WAAA;EA5C9D;;;;;;;;EAuDjB,KAAA,CAAM,GAAA,EAAK,WAAA,EAAa,OAAA,EAAS,cAAA,YAA0B,gBAAA;EAtBjD;;;;;;;;EAkCJ,UAAA,CACJ,MAAA,EAAQ,qBAAA,qBACR,KAAA,WACC,OAAA,CAAQ,oBAAA;EA1BoE;;;;;;EAiFzE,cAAA,CACJ,MAAA,EAAQ,qBAAA,sBACP,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EAxEzB;;;;;;;;;;;;;;;;;;;;;;;;EAyJA,UAAA,CACJ,MAAA,EAAQ,qBAAA,qBACR,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EAmHG;;;AA8ZkB;;;;ACpxBc;EDsXhC,QArFA,mBAAA;;;ACxR4C;;;;;UD6S5C,oBAAA;;;;;;UAgEA,gBAAA;;;;UA8ZA,kBAAA;AAAA;;;cC3wBV,yBAAA,EAA2B,2BAA2B"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-adapter.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAiEa,sBAAA,YAAkC,iBAAA;EAAA,SACpC,QAAA;EAAA,SACA,QAAA;EAAA,iBAEQ,WAAA;EAiBQ;;;;;;;cARb,WAAA,GAAc,WAAA;EA0CqD;;;;EAAA,SAlCtE,gBAAA,SAAgB,sBAAA;EAqD0B;;;;;EAAA,SA9C1C,mBAAA,SAAmB,2BAAA;EAyHG;;;;;EAAA,SAlHtB,iBAAA,SAAiB,yBAAA;EAsQhB;;;;;;EAAA,SA9PD,yBAAA,GACP,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA,EACV,WAAA;EAAA,SASO,oCAAA,GAAwC,QAAA,EAAU,QAAA,CAAS,UAAA,OAAW,MAAA,EAAA,WAAA,EAAA,QAAA,EAAA,wBAAA,EAAA,WAAA;EAG/E,4BAAA,CAAA,YAAyC,OAAA;EAIzC,0BAAA,CAAA,YAAuC,OAAA;;;;;;;;;EAYvC,KAAA,CAAM,GAAA,EAAK,WAAA,GAAc,eAAA,EAAiB,OAAA,EAAS,cAAA,YAA0B,gBAAA;EA/BpE;;;;;;;;EA8CH,UAAA,CACJ,MAAA,EAAQ,qBAAA,qBACR,KAAA,WACC,OAAA,CAAQ,oBAAA;EArCsC;;;;;;EA4F3C,cAAA,CACJ,MAAA,EAAQ,qBAAA,sBACP,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EA3FU;;;;;;EA0JnC,UAAA,CACJ,MAAA,EAAQ,qBAAA,qBACR,KAAA,YACC,OAAA,UAAiB,iBAAA;EA7I+B;;;;;;;;;;;;;;;;;;;;;;;;EA8N7C,UAAA,CACJ,MAAA,EAAQ,qBAAA,qBACR,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EADT;;;;;;;;EAAA,QA+BY,mBAAA;;;;ACpYgC;;;;UDyZhC,oBAAA;;;;;;UAgEA,gBAAA;;;;UA8ZA,kBAAA;AAAA;;;cC92BV,yBAAA,EAA2B,2BAA2B"}

package/dist/control.mjs

@@ -1,18 +1,27 @@
-import { n as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DlZhVI9B.mjs";
+import { n as renderLoweredDdl, r as createPostgresBuiltinCodecLookup, t as renderLoweredSql } from "./sql-renderer-DqVeL4hP.mjs";
 import { t as postgresAdapterDescriptorMeta } from "./descriptor-meta-C1wNCHkd.mjs";
 import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
+import { isDdlNode } from "@prisma-next/sql-relational-core/ast";
 import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { PG_ENUM_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 import { parseMarkerRowSafely, withMarkerReadErrorHandling } from "@prisma-next/errors/execution";
 import { parseContractMarkerRow } from "@prisma-next/family-sql/verify";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { postgresColumnsCompatible } from "@prisma-next/target-postgres/column-type-compatibility";
+import { buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries } from "@prisma-next/target-postgres/contract-free";
 import { parsePostgresDefault, parsePostgresDefault as parsePostgresDefault$1 } from "@prisma-next/target-postgres/default-normalizer";
 import { createResolveExistingEnumValues, enumStorageCompoundKey, readExistingEnumValues, readPostgresSchemaIrAnnotations } from "@prisma-next/target-postgres/enum-planning";
 import { normalizeSchemaNativeType, normalizeSchemaNativeType as normalizeSchemaNativeType$1 } from "@prisma-next/target-postgres/native-type-normalizer";
 import { blindCast } from "@prisma-next/utils/casts";
 import { timestampNowControlDescriptor } from "@prisma-next/family-sql/control";
 import { builtinGeneratorRegistryMetadata, resolveBuiltinGeneratedColumnDescriptor } from "@prisma-next/ids";
+//#region ../../../1-framework/3-tooling/migration/dist/exports/ledger-origin.mjs
+function ledgerOriginFromStored(originCoreHash) {
+	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "sha256:empty") return null;
+	return originCoreHash;
+}
+//#endregion
 //#region src/core/enum-control-hooks.ts
 const ENUM_INTROSPECT_QUERY = `
   SELECT
@@ -106,6 +115,7 @@ async function introspectPostgresEnumTypes(options) {
 //#endregion
 //#region src/core/control-adapter.ts
 const POSTGRES_MARKER_TABLE = "prisma_contract.marker";
+const POSTGRES_LEDGER_TABLE = "prisma_contract.ledger";
 /**
 * Postgres control plane adapter for control-plane operations like introspection.
 * Provides target-specific implementations for control-plane domain actions.
@@ -136,6 +146,12 @@ var PostgresControlAdapter = class {
 	*/
 	normalizeNativeType = normalizeSchemaNativeType$1;
 	/**
+	* Target-supplied compatible-shape relation used under the `external`
+	* control policy. Threading the same relation the migration planner/runner
+	* use keeps runtime verify and migration verify in agreement.
+	*/
+	columnsCompatible = postgresColumnsCompatible;
+	/**
 	* Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
 	* introspection shape (`schema.annotations.pg.storageTypes`). Lets
 	* the family-level schema verifier walk enum types without reaching
@@ -145,6 +161,12 @@ var PostgresControlAdapter = class {
 		return readExistingEnumValues(schema, namespaceId === UNBOUND_NAMESPACE_ID ? readPostgresSchemaIrAnnotations(schema).schema ?? "public" : namespaceId, enumType.nativeType);
 	};
 	resolveExistingEnumValuesForContract = (contract) => createResolveExistingEnumValues(contract.storage);
+	bootstrapControlTableQueries() {
+		return buildControlTableBootstrapQueries();
+	}
+	bootstrapSignMarkerQueries() {
+		return buildSignMarkerBootstrapQueries();
+	}
 	/**
 	* Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
 	*
@@ -154,6 +176,7 @@ var PostgresControlAdapter = class {
 	* without instantiating the runtime adapter.
 	*/
 	lower(ast, context) {
+		if (isDdlNode(ast)) return renderLoweredDdl(ast);
 		return renderLoweredSql(ast, context.contract, this.codecLookup);
 	}
 	/**
@@ -219,6 +242,43 @@ var PostgresControlAdapter = class {
 		return rows;
 	}
 	/**
+	* Reads per-migration ledger rows from `prisma_contract.ledger` in apply
+	* order. Probes `information_schema.tables` first so a fresh database
+	* without the ledger table returns `[]` instead of raising "relation does
+	* not exist".
+	*/
+	async readLedger(driver, space) {
+		const ledgerContext = {
+			space: space ?? "*",
+			markerLocation: POSTGRES_LEDGER_TABLE
+		};
+		if ((await withMarkerReadErrorHandling(() => driver.query(`select 1
+       from information_schema.tables
+       where table_schema = $1 and table_name = $2`, ["prisma_contract", "ledger"]), ledgerContext)).rows.length === 0) return [];
+		let sql = `select
+         space,
+         migration_name,
+         migration_hash,
+         origin_core_hash,
+         destination_core_hash,
+         operations,
+         created_at
+       from prisma_contract.ledger`;
+		if (space !== void 0) sql += `
+       where space = $1`;
+		sql += `
+       order by id`;
+		return (await withMarkerReadErrorHandling(() => driver.query(sql, space === void 0 ? void 0 : [space]), ledgerContext)).rows.map((row) => ({
+			space: row.space,
+			migrationName: row.migration_name,
+			migrationHash: row.migration_hash,
+			from: ledgerOriginFromStored(row.origin_core_hash),
+			to: row.destination_core_hash,
+			appliedAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at),
+			operationCount: Array.isArray(row.operations) ? row.operations.length : 0
+		}));
+	}
+	/**
 	* Introspects a Postgres database schema and returns a raw SqlSchemaIR.
 	*
 	* This is a pure schema discovery operation that queries the Postgres catalog