@prisma-next/adapter-postgres 0.13.0 → 0.14.0-dev.2

package/src/core/descriptor-meta.ts

@@ -27,6 +27,7 @@ import {
   PG_TIMESTAMP_CODEC_ID,
   PG_TIMESTAMPTZ_CODEC_ID,
   PG_TIMETZ_CODEC_ID,
+  PG_UUID_CODEC_ID,
   PG_VARBIT_CODEC_ID,
   PG_VARCHAR_CODEC_ID,
   SQL_CHAR_CODEC_ID,
@@ -215,6 +216,7 @@ export const postgresAdapterDescriptorMeta = {
         [PG_JSON_CODEC_ID]: identityHooks,
         [PG_JSONB_CODEC_ID]: identityHooks,
         [PG_BYTEA_CODEC_ID]: identityHooks,
+        [PG_UUID_CODEC_ID]: identityHooks,
       },
     },
     storage: [
@@ -281,6 +283,7 @@ export const postgresAdapterDescriptorMeta = {
       { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },
       { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },
       { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },
+      { typeId: PG_UUID_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'uuid' },
     ],
     queryOperationTypes: {
       import: {

package/src/core/marker-ledger.ts

@@ -4,13 +4,7 @@ import {
   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,
@@ -20,8 +14,7 @@ import {
   textArray,
   timestamptz,
 } from '@prisma-next/target-postgres/contract-free';
-
-const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+import { encodeControlQueryParams } from './control-codecs';
 
 export const marker = pgTable(
   { name: 'marker', schema: 'prisma_contract' },
@@ -105,16 +98,7 @@ export async function execute(
   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 encoded = await encodeControlQueryParams(lowered, query);
   const result = await driver.query(lowered.sql, encoded);
   return result.rows;
 }

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 {
@@ -31,7 +32,6 @@ import {
   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';
@@ -175,12 +175,13 @@ function renderLimitOffset(
 }
 
 function renderSelect(ast: SelectAst, contract: PostgresContract, pim: ParamIndexMap): string {
-  const selectClause = `SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(
+  const sourcesByRef = collectTableSources(ast);
+  const selectClause = `SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, sourcesByRef, contract, pim)}${renderProjection(
     ast.projection,
     contract,
     pim,
   )}`;
-  const fromClause = `FROM ${renderSource(ast.from, contract, pim)}`;
+  const fromClause = ast.from !== undefined ? `FROM ${renderSource(ast.from, contract, pim)}` : '';
 
   const joinsClause = ast.joins?.length
     ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(' ')
@@ -194,7 +195,7 @@ function renderSelect(ast: SelectAst, contract: PostgresContract, pim: ParamInde
   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(', ')}`
@@ -218,6 +219,129 @@ 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 });
+  };
+  if (ast.from !== undefined) 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 sourceNs = contract.storage.namespaces[source.namespaceId];
+  const column =
+    sourceNs !== undefined ? sourceNs.entries.table?.[source.name]?.columns[ref.column] : undefined;
+  const valueSet = column?.valueSet;
+  if (valueSet === undefined) {
+    return undefined;
+  }
+  const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
+  return valueSetNs !== undefined
+    ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values
+    : undefined;
+}
+
+/**
+ * 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 identNs = contract.storage.namespaces[source.namespaceId];
+    const column =
+      identNs !== undefined ? identNs.entries.table?.[source.name]?.columns[name] : undefined;
+    if (column === undefined) {
+      continue;
+    }
+    matchedColumns += 1;
+    if (matchedColumns > 1) {
+      return undefined;
+    }
+    const valueSet = column.valueSet;
+    if (valueSet === undefined) {
+      return undefined;
+    }
+    const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
+    resolved =
+      valueSetNs !== undefined
+        ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values
+        : undefined;
+  }
+  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,
@@ -258,11 +382,14 @@ function renderReturning(
 function renderDistinctPrefix(
   distinct: true | undefined,
   distinctOn: ReadonlyArray<AnyExpression> | undefined,
+  sourcesByRef: ReadonlyMap<string, TableSourceCoordinate>,
   contract: PostgresContract,
   pim: ParamIndexMap,
 ): string {
   if (distinctOn && distinctOn.length > 0) {
-    const rendered = distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(', ');
+    const rendered = distinctOn
+      .map((expr) => renderOrderByExpr(expr, sourcesByRef, contract, pim))
+      .join(', ');
     return `DISTINCT ON (${rendered}) `;
   }
   if (distinct) {
@@ -271,11 +398,17 @@ function renderDistinctPrefix(
   return '';
 }
 
+function hasExplicitSchema(
+  table: Pick<TableSource, 'name' | 'namespaceId'>,
+): table is Pick<TableSource, 'name' | 'namespaceId'> & { readonly schema: string } {
+  return 'schema' in table && typeof table.schema === 'string';
+}
+
 function qualifyTableFromNamespaceCoordinate(
   table: Pick<TableSource, 'name' | 'namespaceId'>,
   contract: PostgresContract,
 ): string {
-  if (table instanceof PostgresTableSource && table.schema !== undefined) {
+  if (hasExplicitSchema(table)) {
     return `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`;
   }
   if (table.namespaceId === undefined) {
@@ -315,6 +448,11 @@ function renderSource(
       return renderTableSource(node, contract);
     case 'derived-table-source':
       return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
+    case 'function-source': {
+      const args = node.args.map((arg) => renderExpr(arg, contract, pim)).join(', ');
+      const call = `${node.fn}(${args})`;
+      return node.alias !== undefined ? `${call} AS ${quoteIdentifier(node.alias)}` : call;
+    }
     // v8 ignore next 4
     default:
       throw new Error(
@@ -712,11 +850,11 @@ function getInsertColumnOrder(
   let table: { columns: Readonly<Record<string, unknown>> } | undefined;
   if (tableRef.namespaceId !== undefined) {
     const ns = contract.storage.namespaces[tableRef.namespaceId];
-    table = ns?.entries.table[tableName];
+    table = ns !== undefined ? ns.entries.table?.[tableName] : undefined;
   }
   if (table === undefined) {
     for (const ns of Object.values(contract.storage.namespaces)) {
-      const found = ns.entries.table[tableName];
+      const found = ns.entries.table?.[tableName];
       if (found !== undefined) {
         table = found;
         break;

package/src/core/types.ts

@@ -1,5 +1,5 @@
 import type { Contract } from '@prisma-next/contract/types';
-import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { CodecRegistry } from '@prisma-next/framework-components/codec';
 import type { SqlStorage, StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
@@ -29,7 +29,7 @@ export interface PostgresAdapterOptions {
    * `SqlControlAdapterDescriptor.create(stack)`) supply the assembled stack
    * lookup so extension codecs are visible to the renderer.
    */
-  readonly codecLookup?: CodecLookup;
+  readonly codecLookup?: CodecRegistry;
 }
 
 export type PostgresContract = Contract<SqlStorage> & { readonly target: 'postgres' };

package/src/exports/column-types.ts

@@ -9,7 +9,6 @@ import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
-  PG_ENUM_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
   PG_INT2_CODEC_ID,
@@ -28,7 +27,6 @@ import {
   SQL_CHAR_CODEC_ID,
   SQL_VARCHAR_CODEC_ID,
 } from '@prisma-next/target-postgres/codec-ids';
-import { PostgresEnumType } from '@prisma-next/target-postgres/types';
 
 export const textColumn = {
   codecId: PG_TEXT_CODEC_ID,
@@ -185,21 +183,3 @@ export const jsonbColumn = {
   codecId: PG_JSONB_CODEC_ID,
   nativeType: 'jsonb',
 } as const satisfies ColumnTypeDescriptor;
-
-export function enumType<const Values extends readonly string[]>(
-  name: string,
-  values: Values,
-): PostgresEnumType {
-  return new PostgresEnumType({ name, nativeType: name, values });
-}
-
-export function enumColumn<TypeName extends string>(
-  typeName: TypeName,
-  nativeType: string,
-): ColumnTypeDescriptor & { readonly typeRef: TypeName } {
-  return {
-    codecId: PG_ENUM_CODEC_ID,
-    nativeType,
-    typeRef: typeName,
-  };
-}

package/src/exports/control.ts

@@ -30,5 +30,6 @@ export default postgresAdapterDescriptor;
 
 export { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 export { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
+export { createPostgresBuiltinCodecLookup } from '../core/codec-lookup';
 export { PostgresControlAdapter } from '../core/control-adapter';
 export { escapeLiteral, qualifyName, quoteIdentifier, SqlEscapeError };

package/dist/adapter-CAlWA4ug.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter-CAlWA4ug.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  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 type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';\nimport { createPostgresBuiltinCodecLookup } from './codec-lookup';\nimport { PostgresControlAdapter } from './control-adapter';\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    const controlAdapter = new PostgresControlAdapter(this.codecLookup);\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      readMarker: (queryable: SqlQueryable) =>\n        controlAdapter.readMarkerDiscriminated(\n          {\n            familyId: 'sql',\n            targetId: 'postgres',\n            query: async <Row = Record<string, unknown>>(\n              sql: string,\n              params?: readonly unknown[],\n            ) => {\n              const result = await queryable.query<Row>(sql, params);\n              return { rows: [...result.rows] };\n            },\n            close: async () => {},\n          },\n          APP_SPACE_ID,\n        ),\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\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;AAmBA,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,MAAM,iBAAiB,IAAI,uBAAuB,KAAK,WAAW;EAClE,KAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,aAAa,cACX,eAAe,wBACb;IACE,UAAU;IACV,UAAU;IACV,OAAO,OACL,KACA,WACG;KAEH,OAAO,EAAE,MAAM,CAAC,IAAG,MADE,UAAU,MAAW,KAAK,MAAM,EAAA,CAC3B,IAAI,EAAE;IAClC;IACA,OAAO,YAAY,CAAC;GACtB,GACA,YACF;EACJ,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,SAAgB,sBAAsB,SAAkC;CACtE,OAAO,OAAO,OAAO,IAAI,oBAAoB,OAAO,CAAC;AACvD"}