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

package/src/core/control-adapter.ts

@@ -14,6 +14,7 @@ import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
+import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
 import type {
   PostgresEnumStorageEntry,
   SqlControlDriverInstance,
@@ -21,10 +22,16 @@ import type {
 } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
+  CodecRef,
+  DdlColumn,
   DdlNode,
+  DdlTableConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
   LoweredStatement,
   LowererContext,
   MarkerReadResult,
+  SqlExecuteRequest,
 } from '@prisma-next/sql-relational-core/ast';
 import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
 import type {
@@ -42,19 +49,23 @@ import {
   buildControlTableBootstrapQueries,
   buildSignMarkerBootstrapQueries,
 } from '@prisma-next/target-postgres/contract-free';
-import type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';
+import type {
+  PostgresCreateSchema,
+  PostgresCreateTable,
+  PostgresDdlNode,
+} from '@prisma-next/target-postgres/ddl';
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 import {
   createResolveExistingEnumValues,
-  enumStorageCompoundKey,
   readExistingEnumValues,
   readPostgresSchemaIrAnnotations,
 } from '@prisma-next/target-postgres/enum-planning';
 import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
+import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { createPostgresBuiltinCodecLookup } from './codec-lookup';
-import { renderLoweredDdl } from './ddl-renderer';
+import { encodeControlQueryParams } from './control-codecs';
 import {
   introspectPostgresEnumTypes,
   type PostgresEnumStorageTypeAnnotation,
@@ -157,11 +168,39 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<unknown>): LoweredStatement {
     if (isDdlNode(ast)) {
-      return renderLoweredDdl(ast);
+      throw new Error(
+        'lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().',
+      );
     }
     return renderLoweredSql(ast, context.contract as PostgresContract, this.codecLookup);
   }
 
+  /**
+   * Lower an AST all the way to a driver-ready statement. For DDL nodes,
+   * literal column defaults are formatted as inline SQL with proper quoting and
+   * `::nativeType` cast suffixes. For query ASTs, params are kept as `$N`
+   * placeholders; wire values go in `params`. Does NOT call `this.lower()` —
+   * independent implementation.
+   */
+  async lowerToExecuteRequest(
+    ast: AnyQueryAst | PostgresDdlNode,
+    context?: LowererContext<unknown>,
+  ): Promise<SqlExecuteRequest> {
+    if (isDdlNode(ast)) {
+      return pgRenderDdlExecuteRequest(
+        blindCast<PostgresDdlNode, 'isDdlNode guard'>(ast),
+        this.codecLookup,
+      );
+    }
+    const lowered = renderLoweredSql(
+      ast,
+      blindCast<PostgresContract, 'Caller must supply matching contract'>(context?.contract),
+      this.codecLookup,
+    );
+    const params = await encodeControlQueryParams(lowered, ast);
+    return { sql: lowered.sql, params };
+  }
+
   /**
    * Reads the contract marker from `prisma_contract.marker`. Probes
    * `information_schema.tables` first so a fresh database (where the
@@ -625,16 +664,18 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       }
     }
 
-    const mergedStorageTypes: Record<string, PostgresEnumStorageTypeAnnotation> = {};
-    for (let i = 0; i < perSchema.length; i++) {
-      const ir = perSchema[i];
-      const pg = blindCast<
-        { storageTypes?: Record<string, PostgresEnumStorageTypeAnnotation> } | undefined,
+    const mergedEnumTypes: Record<string, Record<string, PostgresEnumStorageTypeAnnotation>> = {};
+    for (const ir of perSchema) {
+      const enumTypes = blindCast<
+        | { enumTypes?: Record<string, Record<string, PostgresEnumStorageTypeAnnotation>> }
+        | undefined,
         'pg annotation envelope index slot'
-      >(ir?.annotations?.['pg'])?.storageTypes;
-      if (!pg) continue;
-      for (const [key, value] of Object.entries(pg)) {
-        mergedStorageTypes[key] = value;
+      >(ir?.annotations?.['pg'])?.enumTypes;
+      if (!enumTypes) continue;
+      for (const [schemaName, byType] of Object.entries(enumTypes)) {
+        const merged = mergedEnumTypes[schemaName] ?? {};
+        Object.assign(merged, byType);
+        mergedEnumTypes[schemaName] = merged;
       }
     }
 
@@ -650,8 +691,8 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         pg: {
           ...firstPg,
           ...ifDefined(
-            'storageTypes',
-            Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : undefined,
+            'enumTypes',
+            Object.keys(mergedEnumTypes).length > 0 ? mergedEnumTypes : undefined,
           ),
         },
       }),
@@ -1093,20 +1134,17 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       };
     }
 
-    const rawStorageTypes = await introspectPostgresEnumTypes({ driver, schemaName: schema });
-    const storageTypes: Record<string, PostgresEnumStorageTypeAnnotation> = {};
-    for (const [typeName, annotation] of Object.entries(rawStorageTypes)) {
-      storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
-    }
+    const rawEnumTypes = await introspectPostgresEnumTypes({ driver, schemaName: schema });
+    const enumTypes: Record<
+      string,
+      Record<string, PostgresEnumStorageTypeAnnotation>
+    > = Object.keys(rawEnumTypes).length > 0 ? { [schema]: rawEnumTypes } : {};
 
     const annotations = {
       pg: {
         schema,
         version: await this.getPostgresVersion(driver),
-        ...ifDefined(
-          'storageTypes',
-          Object.keys(storageTypes).length > 0 ? storageTypes : undefined,
-        ),
+        ...ifDefined('enumTypes', Object.keys(enumTypes).length > 0 ? enumTypes : undefined),
       },
     };
 
@@ -1368,3 +1406,167 @@ function extractQuotedLiterals(listBody: string): readonly string[] | undefined
   const values = [...listBody.matchAll(pattern)].map((m) => (m[1] ?? '').replace(/''/g, "'"));
   return values.length > 0 ? values : undefined;
 }
+
+// ---------------------------------------------------------------------------
+// pgRenderDdlExecuteRequest — independent DDL walker for lowerToExecuteRequest
+// ---------------------------------------------------------------------------
+
+function pgIsTextLikeNativeType(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(')
+  );
+}
+
+function pgInlineLiteral(wire: unknown, nativeType: string): string {
+  if (wire === null) return 'NULL';
+  if (typeof wire === 'boolean') return wire ? 'true' : 'false';
+  if (typeof wire === 'number') {
+    if (!Number.isFinite(wire)) {
+      throw new Error(
+        `pgRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal for native type "${nativeType}"`,
+      );
+    }
+    return String(wire);
+  }
+  if (typeof wire === 'bigint') return String(wire);
+  if (wire instanceof Date) {
+    if (Number.isNaN(wire.getTime())) {
+      throw new Error(
+        `pgRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal for native type "${nativeType}"`,
+      );
+    }
+    const quoted = `'${escapeLiteral(wire.toISOString())}'`;
+    return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+  }
+  if (typeof wire === 'string') {
+    const quoted = `'${escapeLiteral(wire)}'`;
+    return pgIsTextLikeNativeType(nativeType) ? quoted : `${quoted}::${nativeType}`;
+  }
+  if (wire instanceof Uint8Array) {
+    const hex = Array.from(wire)
+      .map((b) => b.toString(16).padStart(2, '0'))
+      .join('');
+    return `'\\x${hex}'::${nativeType}`;
+  }
+  if (typeof wire === 'object') {
+    const quoted = `'${escapeLiteral(JSON.stringify(wire))}'`;
+    return `${quoted}::${nativeType}`;
+  }
+  throw new Error(
+    `pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${nativeType}"`,
+  );
+}
+
+async function pgRenderDdlColumnDefault(
+  def: LiteralColumnDefault | FunctionColumnDefault,
+  nativeType: string,
+  codecLookup: CodecLookup,
+  codecRef: CodecRef | undefined,
+): Promise<string> {
+  if (def.kind === 'function') {
+    if (def.expression === 'autoincrement()') return '';
+    return `DEFAULT (${def.expression})`;
+  }
+  if (codecRef !== undefined) {
+    const codec = codecLookup.get(codecRef.codecId);
+    if (codec !== undefined) {
+      const wire = await codec.encode(def.value, {});
+      return `DEFAULT ${pgInlineLiteral(wire, nativeType)}`;
+    }
+  }
+  // Fallback: codec-less literal defaults follow RawSqlLiteral wire-scalar semantics.
+  return `DEFAULT ${pgInlineLiteral(def.value, nativeType)}`;
+}
+
+async function pgRenderDdlColumn(column: DdlColumn, codecLookup: CodecLookup): Promise<string> {
+  const parts = [quoteIdentifier(column.name), column.type];
+  if (column.notNull) parts.push('NOT NULL');
+  if (column.primaryKey) parts.push('PRIMARY KEY');
+  if (column.default) {
+    const clause = await pgRenderDdlColumnDefault(
+      column.default,
+      column.type,
+      codecLookup,
+      column.codecRef,
+    );
+    if (clause.length > 0) parts.push(clause);
+  }
+  return parts.join(' ');
+}
+
+function pgRenderDdlConstraint(constraint: DdlTableConstraint): string {
+  if (constraint.kind === 'primary-key') {
+    const cols = constraint.columns.map(quoteIdentifier).join(', ');
+    if (constraint.name !== undefined) {
+      return `CONSTRAINT ${quoteIdentifier(constraint.name)} PRIMARY KEY (${cols})`;
+    }
+    return `PRIMARY KEY (${cols})`;
+  }
+  if (constraint.kind === 'foreign-key') {
+    const cols = constraint.columns.map(quoteIdentifier).join(', ');
+    const refTable = constraint.refTable.split('.').map(quoteIdentifier).join('.');
+    const refCols = constraint.refColumns.map(quoteIdentifier).join(', ');
+    let sql = `FOREIGN KEY (${cols}) REFERENCES ${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;
+  }
+  const cols = constraint.columns.map(quoteIdentifier).join(', ');
+  if (constraint.name !== undefined) {
+    return `CONSTRAINT ${quoteIdentifier(constraint.name)} UNIQUE (${cols})`;
+  }
+  return `UNIQUE (${cols})`;
+}
+
+async function pgRenderCreateTable(
+  node: PostgresCreateTable,
+  codecLookup: CodecLookup,
+): Promise<SqlExecuteRequest> {
+  const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+  const tableRef = node.schema
+    ? `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`
+    : quoteIdentifier(node.table);
+  const columnDefs = await Promise.all(
+    node.columns.map((col) => pgRenderDdlColumn(col, codecLookup)),
+  );
+  const constraintDefs =
+    node.constraints !== undefined ? node.constraints.map(pgRenderDdlConstraint) : [];
+  const allDefs = [...columnDefs, ...constraintDefs].join(',\n  ');
+  return {
+    sql: `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${allDefs}\n)`,
+    params: [],
+  };
+}
+
+function pgRenderCreateSchema(node: PostgresCreateSchema): SqlExecuteRequest {
+  const ifNotExists = node.ifNotExists ? 'IF NOT EXISTS ' : '';
+  return {
+    sql: `CREATE SCHEMA ${ifNotExists}${quoteIdentifier(node.schema)}`,
+    params: [],
+  };
+}
+
+async function pgRenderDdlExecuteRequest(
+  ast: PostgresDdlNode,
+  codecLookup: CodecLookup,
+): Promise<SqlExecuteRequest> {
+  if (ast.kind === 'create-table') {
+    return pgRenderCreateTable(blindCast<PostgresCreateTable, 'kind guard'>(ast), codecLookup);
+  }
+  return pgRenderCreateSchema(blindCast<PostgresCreateSchema, 'kind guard'>(ast));
+}

package/src/core/control-codecs.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyQueryAst,
+  ContractCodecRegistry,
+  LoweredStatement,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  createAstCodecRegistry,
+  deriveParamMetadata,
+  encodeParamsWithMetadata,
+} from '@prisma-next/sql-runtime';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
+
+export const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+
+export async function encodeControlQueryParams(
+  lowered: LoweredStatement,
+  ast: AnyQueryAst,
+  codecs: ContractCodecRegistry = CONTROL_CODECS,
+): Promise<readonly unknown[]> {
+  const values = lowered.params.map((slot) => {
+    if (slot.kind === 'literal') return slot.value;
+    throw new Error(`control query lowered to a bind slot '${slot.name}', which is unsupported`);
+  });
+  return encodeParamsWithMetadata(values, deriveParamMetadata(ast), {}, codecs);
+}

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 {
@@ -191,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(', ')}`
@@ -218,6 +220,125 @@ 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.entityName]
+    ?.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.entityName]
+        ?.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,

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"}