@prisma-next/adapter-postgres 0.12.0 → 0.13.0-dev.10

package/src/core/ddl-renderer.ts

@@ -0,0 +1,155 @@
+import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import type {
+  DdlColumn,
+  DdlColumnDefaultVisitor,
+  DdlTableConstraint,
+  ForeignKeyConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+} from '@prisma-next/sql-relational-core/ast';
+import type {
+  PostgresCreateSchema,
+  PostgresCreateTable,
+  PostgresDdlNode,
+  PostgresDdlVisitor,
+} from '@prisma-next/target-postgres/ddl';
+import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
+import type { PostgresLoweredStatement } from './types';
+
+function quoteQualifiedIdentifier(name: string): string {
+  return name.split('.').map(quoteIdentifier).join('.');
+}
+
+function renderPrimaryKeyConstraint(constraint: PrimaryKeyConstraint): string {
+  const cols = constraint.columns.map(quoteIdentifier).join(', ');
+  if (constraint.name !== undefined) {
+    return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
+  }
+  return `PRIMARY KEY (${cols})`;
+}
+
+function renderForeignKeyConstraint(constraint: ForeignKeyConstraint): string {
+  const cols = constraint.columns.map(quoteIdentifier).join(', ');
+  const refCols = constraint.refColumns.map(quoteIdentifier).join(', ');
+  let sql = `FOREIGN KEY (${cols}) REFERENCES ${quoteQualifiedIdentifier(constraint.refTable)} (${refCols})`;
+  if (constraint.onDelete !== undefined) {
+    sql += ` ON DELETE ${REFERENTIAL_ACTION_SQL[constraint.onDelete]}`;
+  }
+  if (constraint.onUpdate !== undefined) {
+    sql += ` ON UPDATE ${REFERENTIAL_ACTION_SQL[constraint.onUpdate]}`;
+  }
+  if (constraint.name !== undefined) {
+    sql = `CONSTRAINT ${quoteIdentifier(constraint.name)} ${sql}`;
+  }
+  return sql;
+}
+
+function renderUniqueConstraint(constraint: UniqueConstraint): string {
+  const cols = constraint.columns.map(quoteIdentifier).join(', ');
+  if (constraint.name !== undefined) {
+    return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
+  }
+  return `UNIQUE (${cols})`;
+}
+
+function renderTableConstraint(constraint: DdlTableConstraint): string {
+  switch (constraint.kind) {
+    case 'primary-key':
+      return renderPrimaryKeyConstraint(constraint);
+    case 'foreign-key':
+      return renderForeignKeyConstraint(constraint);
+    case 'unique':
+      return renderUniqueConstraint(constraint);
+  }
+}
+
+class PostgresDdlVisitorImpl implements PostgresDdlVisitor<string> {
+  createTable(node: PostgresCreateTable): string {
+    const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+    const tableRef = node.schema
+      ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`
+      : quoteIdentifier(node.table);
+    const columnDefs = node.columns.map((column) => renderColumn(column));
+    const constraintDefs =
+      node.constraints !== undefined ? node.constraints.map(renderTableConstraint) : [];
+    const allDefs = [...columnDefs, ...constraintDefs].join(',\n  ');
+    return `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${allDefs}\n)`;
+  }
+
+  createSchema(node: PostgresCreateSchema): string {
+    const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+    return `CREATE SCHEMA ${ifNotExists}${quoteIdentifier(node.schema)}`;
+  }
+}
+
+// Postgres infers a quoted-literal default's type as `text` at parse time
+// and applies an implicit text → target coercion at default-evaluation
+// time. That coercion exists for some target types (text, jsonb, json)
+// and not others (uuid, inet, timestamptz, citext, enums, user-defined
+// types, geometry/geography from PostGIS, array types). Quoted-literal
+// defaults on any non-text column therefore need an explicit
+// `::<nativeType>` cast in the emitted DDL — both to state the default's
+// intent (the literal IS that type, not text that happens to coerce) and
+// to keep emitted migrations correct for types where no implicit cast
+// exists. Numeric, boolean, and null literals are typed by Postgres
+// directly (no `text` indirection) so they need no cast.
+function isTextLikeNativeType(nativeType: string): boolean {
+  return (
+    nativeType === 'text' ||
+    nativeType === 'varchar' ||
+    nativeType.startsWith('varchar(') ||
+    nativeType === 'character varying' ||
+    nativeType.startsWith('character varying(') ||
+    nativeType === 'char' ||
+    nativeType.startsWith('char(') ||
+    nativeType === 'character' ||
+    nativeType.startsWith('character(')
+  );
+}
+
+const defaultVisitor: DdlColumnDefaultVisitor<string> = {
+  literal(node: LiteralColumnDefault, ctx): string {
+    const { value } = node;
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      return `DEFAULT ${String(value)}`;
+    }
+    if (value === null) {
+      return 'DEFAULT NULL';
+    }
+    const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+    const literal = `'${escapeLiteral(serialized)}'`;
+    return isTextLikeNativeType(ctx.nativeType)
+      ? `DEFAULT ${literal}`
+      : `DEFAULT ${literal}::${ctx.nativeType}`;
+  },
+  function(node: FunctionColumnDefault, _ctx): string {
+    if (node.expression === 'autoincrement()') {
+      return '';
+    }
+    return `DEFAULT (${node.expression})`;
+  },
+};
+
+function renderColumn(column: DdlColumn): string {
+  const parts = [quoteIdentifier(column.name), column.type];
+  if (column.notNull) {
+    parts.push('NOT NULL');
+  }
+  if (column.primaryKey) {
+    parts.push('PRIMARY KEY');
+  }
+  const defaultClause = column.default
+    ? column.default.accept(defaultVisitor, { nativeType: column.type })
+    : '';
+  if (defaultClause.length > 0) {
+    parts.push(defaultClause);
+  }
+  return parts.join(' ');
+}
+
+export function renderLoweredDdl(ast: PostgresDdlNode): PostgresLoweredStatement {
+  const sql = ast.accept(new PostgresDdlVisitorImpl());
+  return Object.freeze({ sql, params: Object.freeze([]) });
+}

package/src/core/enum-control-hooks.ts

@@ -1,4 +1,4 @@
-import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import type { SqlControlDriverInstance } from '@prisma-next/sql-contract/types';
 import { PG_ENUM_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
 
 /**
@@ -117,7 +117,7 @@ function parseArrayElements(input: string): string[] {
  * (which writes them under `schema.annotations.pg.storageTypes`).
  */
 export async function introspectPostgresEnumTypes(options: {
-  readonly driver: ControlDriverInstance<'sql', 'postgres'>;
+  readonly driver: SqlControlDriverInstance<'postgres'>;
   readonly schemaName?: string;
 }): Promise<Record<string, PostgresEnumStorageTypeAnnotation>> {
   const namespace = options.schemaName ?? 'public';

package/src/core/marker-ledger.ts

@@ -0,0 +1,124 @@
+import type { SqlControlDriverInstance } from '@prisma-next/sql-contract/types';
+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 = SqlControlDriverInstance<'postgres'>;

package/src/core/sql-renderer.ts

@@ -1,3 +1,4 @@
+import type { JsonValue } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import { runtimeError } from '@prisma-next/framework-components/runtime';
 import {
@@ -27,9 +28,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';
@@ -189,10 +192,11 @@ function renderSelect(ast: SelectAst, contract: PostgresContract, pim: ParamInde
     ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(', ')}`
     : '';
   const havingClause = ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : '';
+  const sourcesByRef = collectTableSources(ast);
   const orderClause = ast.orderBy?.length
     ? `ORDER BY ${ast.orderBy
         .map((order) => {
-          const expr = renderExpr(order.expr, contract, pim);
+          const expr = renderOrderByExpr(order.expr, sourcesByRef, contract, pim);
           return `${expr} ${order.dir.toUpperCase()}`;
         })
         .join(', ')}`
@@ -216,6 +220,124 @@ function renderSelect(ast: SelectAst, contract: PostgresContract, pim: ParamInde
   return clauses.trim();
 }
 
+/**
+ * Storage coordinate a query-level table reference (alias or bare name) resolves to. The ORDER BY enum hook uses this to look a column-ref's storage column up and read its value-set.
+ */
+interface TableSourceCoordinate {
+  readonly name: string;
+  readonly namespaceId: string | undefined;
+}
+
+/**
+ * Map a SELECT's table references (the FROM source and any JOIN sources) to their storage coordinate, keyed by the name a `ColumnRef.table` would carry (the alias when present, otherwise the table name). Derived-table sources are skipped — their columns are projected through a sub-select, not a base storage column, so the enum hook does not apply.
+ */
+function collectTableSources(ast: SelectAst): ReadonlyMap<string, TableSourceCoordinate> {
+  const sources = new Map<string, TableSourceCoordinate>();
+  const add = (source: AnyFromSource): void => {
+    if (source.kind !== 'table-source') {
+      return;
+    }
+    const ref = source.alias ?? source.name;
+    sources.set(ref, { name: source.name, namespaceId: source.namespaceId });
+  };
+  add(ast.from);
+  for (const join of ast.joins ?? []) {
+    add(join.source);
+  }
+  return sources;
+}
+
+/**
+ * Ordered, codec-encoded values of the value-set a storage column restricts to, or `undefined` when the referenced column carries no value-set (the common, non-enum case). Resolves the column's storage coordinate from the SELECT's table sources, then the column's `valueSet` ref to the value-set's `values`.
+ */
+function allStrings(values: readonly JsonValue[]): values is readonly string[] {
+  return values.every((value) => typeof value === 'string');
+}
+
+function resolveEnumOrderValues(
+  ref: ColumnRef,
+  sourcesByRef: ReadonlyMap<string, TableSourceCoordinate>,
+  contract: PostgresContract,
+): readonly JsonValue[] | undefined {
+  const source = sourcesByRef.get(ref.table);
+  if (source === undefined || source.namespaceId === undefined) {
+    return undefined;
+  }
+  const column =
+    contract.storage.namespaces[source.namespaceId]?.entries.table[source.name]?.columns[
+      ref.column
+    ];
+  const valueSet = column?.valueSet;
+  if (valueSet === undefined) {
+    return undefined;
+  }
+  return contract.storage.namespaces[valueSet.namespaceId]?.entries.valueSet?.[valueSet.name]
+    ?.values;
+}
+
+/**
+ * Ordered values for an unqualified ORDER BY column (an `identifier-ref`, the shape the sql-builder emits for `.orderBy('col')`). Scans every FROM/JOIN source for a column of that name. Resolves only when exactly one source has a column of that name and it carries a value-set; if more than one source has such a column the bare identifier is ambiguous (regardless of which are enum-backed), so it falls through to the plain column rendering.
+ */
+function resolveEnumOrderValuesForIdentifier(
+  name: string,
+  sourcesByRef: ReadonlyMap<string, TableSourceCoordinate>,
+  contract: PostgresContract,
+): readonly JsonValue[] | undefined {
+  let matchedColumns = 0;
+  let resolved: readonly JsonValue[] | undefined;
+  for (const source of sourcesByRef.values()) {
+    if (source.namespaceId === undefined) {
+      continue;
+    }
+    const column =
+      contract.storage.namespaces[source.namespaceId]?.entries.table[source.name]?.columns[name];
+    if (column === undefined) {
+      continue;
+    }
+    matchedColumns += 1;
+    if (matchedColumns > 1) {
+      return undefined;
+    }
+    const valueSet = column.valueSet;
+    if (valueSet === undefined) {
+      return undefined;
+    }
+    resolved =
+      contract.storage.namespaces[valueSet.namespaceId]?.entries.valueSet?.[valueSet.name]?.values;
+  }
+  return resolved;
+}
+
+/**
+ * Render an ORDER BY expression. A column reference onto an enum-restricted column sorts by declaration order via `array_position(ARRAY[…]::text[], <col>)` over the value-set's ordered values (NULLs return `NULL` from `array_position`, sorting per the clause's default NULL handling). Both qualified `column-ref`s and the unqualified `identifier-ref`s the sql-builder emits for `.orderBy('col')` are intercepted. Every other expression renders unchanged.
+ */
+function renderOrderByExpr(
+  expr: AnyExpression,
+  sourcesByRef: ReadonlyMap<string, TableSourceCoordinate>,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
+  // Only TEXT enums lower to a value-set whose ORDER BY rewrite ships in this
+  // slice. Numeric-enum ORDER BY is future work; until then a non-string
+  // value-set falls through to plain column rendering rather than emitting a
+  // wrong numeric-as-text ARRAY.
+  if (expr.kind === 'column-ref') {
+    const orderValues = resolveEnumOrderValues(expr, sourcesByRef, contract);
+    if (orderValues !== undefined && allStrings(orderValues)) {
+      const array = orderValues.map((value) => `'${escapeLiteral(value)}'`).join(', ');
+      return `array_position(ARRAY[${array}]::text[], ${renderColumn(expr)})`;
+    }
+  }
+  if (expr.kind === 'identifier-ref') {
+    const orderValues = resolveEnumOrderValuesForIdentifier(expr.name, sourcesByRef, contract);
+    if (orderValues !== undefined && allStrings(orderValues)) {
+      const array = orderValues.map((value) => `'${escapeLiteral(value)}'`).join(', ');
+      return `array_position(ARRAY[${array}]::text[], ${quoteIdentifier(expr.name)})`;
+    }
+  }
+  return renderExpr(expr, contract, pim);
+}
+
 function renderProjection(
   projection: ReadonlyArray<ProjectionItem>,
   contract: PostgresContract,
@@ -269,6 +391,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 +431,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 +809,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>();
 
@@ -678,14 +829,18 @@ function getInsertColumnOrder(
     return orderedColumns;
   }
 
-  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 (found !== undefined) {
-      table = found;
-      break;
+  let table: { columns: Readonly<Record<string, unknown>> } | undefined;
+  if (tableRef.namespaceId !== undefined) {
+    const ns = contract.storage.namespaces[tableRef.namespaceId];
+    table = ns?.entries.table[tableName];
+  }
+  if (table === undefined) {
+    for (const ns of Object.values(contract.storage.namespaces)) {
+      const found = ns.entries.table[tableName];
+      if (found !== undefined) {
+        table = found;
+        break;
+      }
     }
   }
   if (!table) {
@@ -694,7 +849,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 +864,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 +875,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 +887,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 +899,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 +949,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 +968,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"}