@prisma-next/adapter-postgres 0.12.0-dev.4 → 0.12.0-dev.40

package/src/core/marker-ledger.ts

@@ -0,0 +1,124 @@
+import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import {
+  type AnyQueryAst,
+  type LoweredStatement,
+  RawExpr,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  createAstCodecRegistry,
+  deriveParamMetadata,
+  encodeParamsWithMetadata,
+} from '@prisma-next/sql-runtime';
+import { PG_TIMESTAMPTZ_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
+import {
+  int4,
+  int8,
+  jsonb,
+  pgTable,
+  text,
+  textArray,
+  timestamptz,
+} from '@prisma-next/target-postgres/contract-free';
+
+const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+
+export const marker = pgTable(
+  { name: 'marker', schema: 'prisma_contract' },
+  {
+    space: text(),
+    core_hash: text(),
+    profile_hash: text(),
+    contract_json: jsonb({ nullable: true }),
+    canonical_version: int4({ nullable: true }),
+    updated_at: timestamptz(),
+    app_tag: text({ nullable: true }),
+    meta: jsonb({ nullable: true }),
+    invariants: textArray(),
+  },
+);
+
+/**
+ * Writeable subset of the `prisma_contract.ledger` table. Omits the
+ * DB-generated `id` (bigserial) and `created_at` (default `now()`) so the
+ * insert path doesn't have to pass them.
+ */
+export const ledger = pgTable(
+  { name: 'ledger', schema: 'prisma_contract' },
+  {
+    space: text(),
+    migration_name: text(),
+    migration_hash: text(),
+    origin_core_hash: text({ nullable: true }),
+    destination_core_hash: text(),
+    operations: jsonb(),
+  },
+);
+
+/**
+ * Read-side handle covering every column of `prisma_contract.ledger`,
+ * including the DB-generated `id` (for ORDER BY) and `created_at`.
+ */
+export const ledgerReadShape = pgTable(
+  { name: 'ledger', schema: 'prisma_contract' },
+  {
+    id: int8(),
+    space: text(),
+    migration_name: text(),
+    migration_hash: text(),
+    origin_core_hash: text({ nullable: true }),
+    destination_core_hash: text(),
+    operations: jsonb(),
+    created_at: timestamptz(),
+  },
+);
+
+export const infoSchemaTables = pgTable(
+  { name: 'tables', schema: 'information_schema' },
+  { table_schema: text(), table_name: text() },
+);
+
+export const NOW = new RawExpr({
+  parts: ['now()'],
+  returns: { codecId: PG_TIMESTAMPTZ_CODEC_ID, nullable: false },
+});
+
+type Lower = (query: AnyQueryAst) => LoweredStatement;
+
+type MarkerDriver = {
+  query<Row = Record<string, unknown>>(
+    sql: string,
+    params?: readonly unknown[],
+  ): Promise<{ readonly rows: ReadonlyArray<Row> }>;
+};
+
+export function mergeInvariants(
+  current: readonly string[],
+  incoming: readonly string[],
+): readonly string[] {
+  return [...new Set([...current, ...incoming])].sort();
+}
+
+export async function execute(
+  lower: Lower,
+  driver: MarkerDriver,
+  query: AnyQueryAst,
+): Promise<readonly Record<string, unknown>[]> {
+  const lowered = lower(query);
+  const values = lowered.params.map((slot) => {
+    if (slot.kind === 'literal') return slot.value;
+    throw new Error('Postgres control DML lowered to a bind parameter, which is unsupported');
+  });
+  const encoded = await encodeParamsWithMetadata(
+    values,
+    deriveParamMetadata(query),
+    {},
+    CONTROL_CODECS,
+  );
+  const result = await driver.query(lowered.sql, encoded);
+  return result.rows;
+}
+
+export type PostgresMarkerDriver = MarkerDriver;
+export type PostgresMarkerLower = Lower;
+export type PostgresMarkerWriteDriver = ControlDriverInstance<'sql', 'postgres'>;

package/src/core/sql-renderer.ts

@@ -27,9 +27,11 @@ import {
   type RawSqlExpr,
   type SelectAst,
   type SubqueryExpr,
+  type TableSource,
   type UpdateAst,
   type WindowFuncExpr,
 } from '@prisma-next/sql-relational-core/ast';
+import { PostgresTableSource } from '@prisma-next/target-postgres/contract-free';
 import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresContract } from './types';
@@ -269,6 +271,39 @@ function renderDistinctPrefix(
   return '';
 }
 
+function qualifyTableFromNamespaceCoordinate(
+  table: Pick<TableSource, 'name' | 'namespaceId'>,
+  contract: PostgresContract,
+): string {
+  if (table instanceof PostgresTableSource && table.schema !== undefined) {
+    return `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`;
+  }
+  if (table.namespaceId === undefined) {
+    return quoteIdentifier(table.name);
+  }
+  const namespace = contract.storage.namespaces[table.namespaceId];
+  if (namespace === undefined) {
+    throw new Error(
+      `Table "${table.name}" references namespace "${table.namespaceId}" which is not present as a Postgres schema on the contract`,
+    );
+  }
+  const qualifyTable = namespace.qualifyTable;
+  if (qualifyTable === undefined) {
+    throw new Error(
+      `Table "${table.name}" references namespace "${table.namespaceId}" which is not materialised as a Postgres schema on the contract`,
+    );
+  }
+  return qualifyTable.call(namespace, table.name);
+}
+
+function renderTableSource(source: TableSource, contract: PostgresContract): string {
+  const qualified = qualifyTableFromNamespaceCoordinate(source, contract);
+  if (!source.alias) {
+    return qualified;
+  }
+  return `${qualified} AS ${quoteIdentifier(source.alias)}`;
+}
+
 function renderSource(
   source: AnyFromSource,
   contract: PostgresContract,
@@ -276,13 +311,8 @@ function renderSource(
 ): string {
   const node = source;
   switch (node.kind) {
-    case 'table-source': {
-      const table = quoteIdentifier(node.name);
-      if (!node.alias) {
-        return table;
-      }
-      return `${table} AS ${quoteIdentifier(node.alias)}`;
-    }
+    case 'table-source':
+      return renderTableSource(node, contract);
     case 'derived-table-source':
       return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
     // v8 ignore next 4
@@ -659,8 +689,9 @@ function renderJoinOn(on: JoinOnExpr, contract: PostgresContract, pim: ParamInde
 function getInsertColumnOrder(
   rows: ReadonlyArray<Record<string, InsertValue>>,
   contract: PostgresContract,
-  tableName: string,
+  tableRef: Pick<TableSource, 'name' | 'namespaceId'>,
 ): string[] {
+  const tableName = tableRef.name;
   const orderedColumns: string[] = [];
   const seenColumns = new Set<string>();
 
@@ -679,13 +710,22 @@ function getInsertColumnOrder(
   }
 
   let table: { columns: Record<string, unknown> } | undefined;
-  for (const ns of Object.values(contract.storage.namespaces)) {
-    // Namespace.tables is Record<string, IRNode> at the interface level;
-    // SQL family namespaces hold StorageTable instances which have .columns.
-    const found = ns.tables[tableName] as { columns: Record<string, unknown> } | undefined;
+  if (tableRef.namespaceId !== undefined) {
+    const ns = contract.storage.namespaces[tableRef.namespaceId];
+    const found = ns?.tables[tableName] as { columns: Record<string, unknown> } | undefined;
     if (found !== undefined) {
       table = found;
-      break;
+    }
+  }
+  if (table === undefined) {
+    for (const ns of Object.values(contract.storage.namespaces)) {
+      // Namespace.tables is Record<string, IRNode> at the interface level;
+      // SQL family namespaces hold StorageTable instances which have .columns.
+      const found = ns.tables[tableName] as { columns: Record<string, unknown> } | undefined;
+      if (found !== undefined) {
+        table = found;
+        break;
+      }
     }
   }
   if (!table) {
@@ -694,7 +734,11 @@ function getInsertColumnOrder(
   return Object.keys(table.columns);
 }
 
-function renderInsertValue(value: InsertValue | undefined, pim: ParamIndexMap): string {
+function renderInsertValue(
+  value: InsertValue | undefined,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
   if (!value || value.kind === 'default-value') {
     return 'DEFAULT';
   }
@@ -705,6 +749,8 @@ function renderInsertValue(value: InsertValue | undefined, pim: ParamIndexMap):
       return renderParamRef(value, pim);
     case 'column-ref':
       return renderColumn(value);
+    case 'raw-expr':
+      return renderExpr(value, contract, pim);
     // v8 ignore next 4
     default:
       throw new Error(
@@ -714,7 +760,7 @@ function renderInsertValue(value: InsertValue | undefined, pim: ParamIndexMap):
 }
 
 function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamIndexMap): string {
-  const table = quoteIdentifier(ast.table.name);
+  const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
   const rows = ast.rows;
   if (rows.length === 0) {
     throw new Error('INSERT requires at least one row');
@@ -726,7 +772,7 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
         return `INSERT INTO ${table} DEFAULT VALUES`;
       }
 
-      const defaultColumns = getInsertColumnOrder(rows, contract, ast.table.name);
+      const defaultColumns = getInsertColumnOrder(rows, contract, ast.table);
       if (defaultColumns.length === 0) {
         return `INSERT INTO ${table} VALUES ${rows.map(() => '()').join(', ')}`;
       }
@@ -738,11 +784,13 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
         .join(', ')}`;
     }
 
-    const columnOrder = getInsertColumnOrder(rows, contract, ast.table.name);
+    const columnOrder = getInsertColumnOrder(rows, contract, ast.table);
     const columns = columnOrder.map((column) => quoteIdentifier(column));
     const values = rows
       .map((row) => {
-        const renderedRow = columnOrder.map((column) => renderInsertValue(row[column], pim));
+        const renderedRow = columnOrder.map((column) =>
+          renderInsertValue(row[column], contract, pim),
+        );
         return `(${renderedRow.join(', ')})`;
       })
       .join(', ');
@@ -786,7 +834,7 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
 }
 
 function renderUpdate(ast: UpdateAst, contract: PostgresContract, pim: ParamIndexMap): string {
-  const table = quoteIdentifier(ast.table.name);
+  const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
   const setEntries = Object.entries(ast.set);
   if (setEntries.length === 0) {
     throw new Error('UPDATE requires at least one SET assignment');
@@ -805,7 +853,7 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract, pim: ParamInde
 }
 
 function renderDelete(ast: DeleteAst, contract: PostgresContract, pim: ParamIndexMap): string {
-  const table = quoteIdentifier(ast.table.name);
+  const table = qualifyTableFromNamespaceCoordinate(ast.table, contract);
   const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : '';
   const returningClause = ast.returning?.length
     ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}`

package/dist/adapter-H8BiuXdq.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-H8BiuXdq.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 type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';\nimport { parseContractMarkerRow } from '@prisma-next/sql-runtime';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\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(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement {\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":";;;;AAiBA,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,MAAM,KAAkB,SAAqE;EAC3F,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"}