@prisma-next/adapter-postgres 0.16.0-dev.2 → 0.16.0-dev.21

package/src/core/control-mutation-defaults.ts

@@ -1,5 +1,6 @@
 import type { ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
 import { timestampNowControlDescriptor } from '@prisma-next/family-sql/control';
+import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';
 import type {
   ControlMutationDefaultEntry,
   DefaultFunctionLoweringContext,
@@ -7,10 +8,7 @@ import type {
   MutationDefaultGeneratorDescriptor,
   TypedDefaultFunctionCall,
 } from '@prisma-next/framework-components/control';
-import {
-  builtinGeneratorRegistryMetadata,
-  resolveBuiltinGeneratedColumnDescriptor,
-} from '@prisma-next/ids';
+import { builtinGeneratorRegistryMetadata } from '@prisma-next/ids';
 import type { FuncCallSig } from '@prisma-next/psl-parser';
 import { int, num, oneOf, optional, str } from '@prisma-next/psl-parser';
 
@@ -153,17 +151,144 @@ const postgresDefaultFunctionRegistryEntries = [
   ],
 ] satisfies ReadonlyArray<readonly [string, ControlMutationDefaultEntry]>;
 
-const postgresScalarTypeDescriptors = new Map<string, string>([
-  ['String', 'pg/text@1'],
-  ['Boolean', 'pg/bool@1'],
-  ['Int', 'pg/int4@1'],
-  ['BigInt', 'pg/int8@1'],
-  ['Float', 'pg/float8@1'],
-  ['Decimal', 'pg/numeric@1'],
-  ['DateTime', 'pg/timestamptz@1'],
-  ['Json', 'pg/jsonb@1'],
-  ['Bytes', 'pg/bytea@1'],
-]);
+/**
+ * The base PSL scalars as zero-arg type constructors in the unified authoring
+ * channel, with explicit `nativeType` values pinned to the codec manifests
+ * (`codecLookup.targetTypesFor(codecId)[0]`).
+ *
+ * The type position is the only storage decider: a mutation-default generator
+ * (`@default(uuid())`) never re-picks a column's storage.
+ */
+export const postgresScalarAuthoringTypes = {
+  String: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/text@1', nativeType: 'text' },
+  },
+  Boolean: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/bool@1', nativeType: 'bool' },
+  },
+  Int: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/int4@1', nativeType: 'int4' },
+  },
+  BigInt: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/int8@1', nativeType: 'int8' },
+  },
+  Float: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/float8@1', nativeType: 'float8' },
+  },
+  Decimal: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/numeric@1', nativeType: 'numeric' },
+  },
+  DateTime: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/timestamptz@1', nativeType: 'timestamptz' },
+  },
+  Json: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/json@1', nativeType: 'json' },
+  },
+  Jsonb: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/jsonb@1', nativeType: 'jsonb' },
+  },
+  Bytes: {
+    kind: 'typeConstructor',
+    output: { codecId: 'pg/bytea@1', nativeType: 'bytea' },
+  },
+} as const satisfies AuthoringTypeNamespace;
+
+/**
+ * The former `@db.*` native types as first-class top-level type constructors
+ * (TML-2986). Codec ids, native types, and typeParams key shapes mirror the
+ * legacy `@db.*` attribute path (`NATIVE_TYPE_SPECS` in sql-contract-psl)
+ * exactly; every argument is optional, so each name is also authorable bare
+ * (`VarChar` ≡ `VarChar()`), and omitted arguments omit their typeParams keys.
+ */
+export const postgresNativeAuthoringTypes = {
+  VarChar: {
+    kind: 'typeConstructor',
+    args: [{ kind: 'number', name: 'length', integer: true, minimum: 1, optional: true }],
+    output: {
+      codecId: 'sql/varchar@1',
+      nativeType: 'character varying',
+      typeParams: { length: { kind: 'arg', index: 0 } },
+    },
+  },
+  Char: {
+    kind: 'typeConstructor',
+    args: [{ kind: 'number', name: 'length', integer: true, minimum: 1, optional: true }],
+    output: {
+      codecId: 'sql/char@1',
+      nativeType: 'character',
+      typeParams: { length: { kind: 'arg', index: 0 } },
+    },
+  },
+  Numeric: {
+    kind: 'typeConstructor',
+    args: [
+      { kind: 'number', name: 'precision', integer: true, minimum: 1, optional: true },
+      { kind: 'number', name: 'scale', integer: true, minimum: 0, optional: true },
+    ],
+    output: {
+      codecId: 'pg/numeric@1',
+      nativeType: 'numeric',
+      typeParams: {
+        precision: { kind: 'arg', index: 0 },
+        scale: { kind: 'arg', index: 1 },
+      },
+    },
+  },
+  Timestamp: {
+    kind: 'typeConstructor',
+    args: [{ kind: 'number', name: 'precision', integer: true, minimum: 0, optional: true }],
+    output: {
+      codecId: 'pg/timestamp@1',
+      nativeType: 'timestamp',
+      typeParams: { precision: { kind: 'arg', index: 0 } },
+    },
+  },
+  Timestamptz: {
+    kind: 'typeConstructor',
+    args: [{ kind: 'number', name: 'precision', integer: true, minimum: 0, optional: true }],
+    output: {
+      codecId: 'pg/timestamptz@1',
+      nativeType: 'timestamptz',
+      typeParams: { precision: { kind: 'arg', index: 0 } },
+    },
+  },
+  Time: {
+    kind: 'typeConstructor',
+    args: [{ kind: 'number', name: 'precision', integer: true, minimum: 0, optional: true }],
+    output: {
+      codecId: 'pg/time@1',
+      nativeType: 'time',
+      typeParams: { precision: { kind: 'arg', index: 0 } },
+    },
+  },
+  Timetz: {
+    kind: 'typeConstructor',
+    args: [{ kind: 'number', name: 'precision', integer: true, minimum: 0, optional: true }],
+    output: {
+      codecId: 'pg/timetz@1',
+      nativeType: 'timetz',
+      typeParams: { precision: { kind: 'arg', index: 0 } },
+    },
+  },
+  Uuid: { kind: 'typeConstructor', output: { codecId: 'pg/uuid@1', nativeType: 'uuid' } },
+  SmallInt: { kind: 'typeConstructor', output: { codecId: 'pg/int2@1', nativeType: 'int2' } },
+  Real: { kind: 'typeConstructor', output: { codecId: 'pg/float4@1', nativeType: 'float4' } },
+  Date: { kind: 'typeConstructor', output: { codecId: 'pg/date@1', nativeType: 'date' } },
+} as const satisfies AuthoringTypeNamespace;
+
+export const postgresAuthoringTypes = {
+  ...postgresScalarAuthoringTypes,
+  ...postgresNativeAuthoringTypes,
+} as const satisfies AuthoringTypeNamespace;
 
 export function createPostgresDefaultFunctionRegistry(): ReadonlyMap<
   string,
@@ -178,27 +303,8 @@ export function createPostgresMutationDefaultGeneratorDescriptors(): readonly Mu
       ({ id, applicableCodecIds }): MutationDefaultGeneratorDescriptor => ({
         id,
         applicableCodecIds,
-        resolveGeneratedColumnDescriptor: ({ generated }) => {
-          if (generated.kind !== 'generator' || generated.id !== id) {
-            return undefined;
-          }
-          const descriptor = resolveBuiltinGeneratedColumnDescriptor({
-            id,
-            ...(generated.params ? { params: generated.params } : {}),
-          });
-          return {
-            codecId: descriptor.type.codecId,
-            nativeType: descriptor.type.nativeType,
-            ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),
-            ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),
-          };
-        },
       }),
     ),
     timestampNowControlDescriptor(),
   ];
 }
-
-export function createPostgresScalarTypeDescriptors(): ReadonlyMap<string, string> {
-  return new Map(postgresScalarTypeDescriptors);
-}

package/src/core/sql-renderer.ts

@@ -5,18 +5,23 @@ import {
   type AggregateExpr,
   type AnyExpression,
   type AnyFromSource,
+  type AnyJsonValueProjection,
   type AnyParamRef,
   type AnyQueryAst,
   type BinaryExpr,
+  type CaseExpr,
+  type CastExpr,
   type ColumnRef,
   collectOrderedParamRefs,
   type DeleteAst,
+  type FunctionCallExpr,
   type InsertAst,
   type InsertValue,
   type JoinAst,
   type JoinOnExpr,
   type JsonArrayAggExpr,
   type JsonObjectExpr,
+  type JsonValueProjectionVisitor,
   type ListExpression,
   LiteralExpr,
   type LoweredParam,
@@ -32,7 +37,12 @@ import {
   type UpdateAst,
   type WindowFuncExpr,
 } from '@prisma-next/sql-relational-core/ast';
-import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
+import { isPgEnumParams } from '@prisma-next/target-postgres/codecs';
+import {
+  escapeLiteral,
+  quoteIdentifier,
+  quoteQualifiedName,
+} from '@prisma-next/target-postgres/sql-utils';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresContract } from './types';
 
@@ -89,7 +99,7 @@ function renderTypedParam(
       `Postgres lowering: ParamRef carries codecId "${codecId}" but the ` +
         'assembled codec lookup has no entry for it. This usually indicates ' +
         'a missing extension pack in the runtime stack — register the pack ' +
-        'that contributes this codec (e.g. `extensionPacks: [pgvectorRuntime]`), ' +
+        'that contributes this codec (e.g. `extensions: [pgvectorRuntime]`), ' +
         'or use the codec directly from `@prisma-next/target-postgres/codecs` ' +
         "if it's a builtin.",
     );
@@ -107,6 +117,15 @@ function renderTypedParam(
   const nativeType = isRecord(dialectBlock) ? dialectBlock['nativeType'] : undefined;
   if (typeof nativeType === 'string') {
     const arraySuffix = many ? '[]' : '';
+    // A `typeParams.typeName` marks a named database type (e.g. a native
+    // enum): cast to its quoted, schema-qualified identifier so Postgres does
+    // not case-fold it (`$1::HoldType` would resolve as `holdtype`). Mirrors
+    // the DDL-side policy in `buildColumnTypeSql`. Builtin spellings
+    // (`double precision`, `jsonb`, …) stay verbatim — quoting them would
+    // turn them into (nonexistent) user-type lookups.
+    if (isPgEnumParams(typeParams)) {
+      return `$${index}::${quoteQualifiedName(nativeType)}${arraySuffix}`;
+    }
     if (!POSTGRES_INFERRABLE_NATIVE_TYPES.has(nativeType)) {
       return `$${index}::${nativeType}${arraySuffix}`;
     }
@@ -121,6 +140,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
 
+function unreachableKind(value: never): string {
+  const candidate: unknown = value;
+  if (
+    typeof candidate === 'object' &&
+    candidate !== null &&
+    'kind' in candidate &&
+    typeof candidate.kind === 'string'
+  ) {
+    return candidate.kind;
+  }
+  return 'unknown';
+}
+
 /**
  * Per-render carrier threaded through every helper. Bundles the param-index map (for `$N` numbering) and the assembled-stack `codecLookup` (for cast policy at the `renderTypedParam` chokepoint). Carrying both on a single value keeps helper signatures stable.
  */
@@ -169,9 +201,7 @@ export function renderLoweredSql(
       break;
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported AST node kind: ${(node satisfies never as { kind: string }).kind}`,
-      );
+      throw new Error(`Unsupported AST node kind: ${unreachableKind(node)}`);
   }
 
   return Object.freeze({ sql, params: Object.freeze(params) });
@@ -465,13 +495,17 @@ function renderSource(
     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;
+      const ordinality = node.ordinality ? ' WITH ORDINALITY' : '';
+      const alias = node.alias === undefined ? '' : ` AS ${quoteIdentifier(node.alias)}`;
+      const columnAliases =
+        node.columnAliases === undefined
+          ? ''
+          : `(${node.columnAliases.map((column) => quoteIdentifier(column)).join(', ')})`;
+      return `${call}${ordinality}${alias}${columnAliases}`;
     }
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported source node kind: ${(node satisfies never as { kind: string }).kind}`,
-      );
+      throw new Error(`Unsupported source node kind: ${unreachableKind(node)}`);
   }
 }
 
@@ -518,6 +552,9 @@ function isAtomicExpressionKind(kind: AnyExpression['kind']): boolean {
     case 'literal':
     case 'aggregate':
     case 'window-func':
+    case 'function-call':
+    case 'cast':
+    case 'case':
     case 'json-object':
     case 'json-array-agg':
     case 'list':
@@ -644,6 +681,44 @@ function renderWindowFuncExpr(
   return `${fn}(${args}) OVER (${over})`;
 }
 
+function renderFunctionCallExpr(
+  expr: FunctionCallExpr,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
+  const args = expr.args.map((arg) => renderExpr(arg, contract, pim)).join(', ');
+  return `${expr.fn}(${args})`;
+}
+
+function renderCastExpr(expr: CastExpr, contract: PostgresContract, pim: ParamIndexMap): string {
+  return `CAST(${renderExpr(expr.expr, contract, pim)} AS ${expr.targetType})`;
+}
+
+function renderCaseExpr(expr: CaseExpr, contract: PostgresContract, pim: ParamIndexMap): string {
+  const branches = expr.branches
+    .map(
+      (branch) =>
+        `WHEN ${renderExpr(branch.condition, contract, pim)} THEN ${renderExpr(branch.value, contract, pim)}`,
+    )
+    .join(' ');
+  const elseClause =
+    expr.elseExpr === undefined ? '' : ` ELSE ${renderExpr(expr.elseExpr, contract, pim)}`;
+  return `CASE ${branches}${elseClause} END`;
+}
+
+function renderJsonValueProjection(
+  projection: AnyJsonValueProjection,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
+  const visitor: JsonValueProjectionVisitor<string> = {
+    codec: ({ value }) => renderExpr(value, contract, pim),
+    native: ({ value }) => renderExpr(value, contract, pim),
+    document: ({ value }) => renderExpr(value, contract, pim),
+  };
+  return projection.accept(visitor);
+}
+
 function renderJsonObjectExpr(
   expr: JsonObjectExpr,
   contract: PostgresContract,
@@ -652,10 +727,7 @@ function renderJsonObjectExpr(
   const args = expr.entries
     .flatMap((entry): [string, string] => {
       const key = `'${escapeLiteral(entry.key)}'`;
-      if (entry.value.kind === 'literal') {
-        return [key, renderLiteral(entry.value)];
-      }
-      return [key, renderExpr(entry.value, contract, pim)];
+      return [key, renderJsonValueProjection(entry.value, contract, pim)];
     })
     .join(', ');
   return `json_build_object(${args})`;
@@ -680,7 +752,7 @@ function renderJsonArrayAggExpr(
     expr.orderBy && expr.orderBy.length > 0
       ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}`
       : '';
-  const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;
+  const aggregated = `json_agg(${renderJsonValueProjection(expr.expr, contract, pim)}${aggregateOrderBy})`;
   if (expr.onEmpty === 'emptyArray') {
     return `coalesce(${aggregated}, json_build_array())`;
   }
@@ -702,6 +774,12 @@ function renderExpr(expr: AnyExpression, contract: PostgresContract, pim: ParamI
       return renderAggregateExpr(node, contract, pim);
     case 'window-func':
       return renderWindowFuncExpr(node, contract, pim);
+    case 'function-call':
+      return renderFunctionCallExpr(node, contract, pim);
+    case 'cast':
+      return renderCastExpr(node, contract, pim);
+    case 'case':
+      return renderCaseExpr(node, contract, pim);
     case 'json-object':
       return renderJsonObjectExpr(node, contract, pim);
     case 'json-array-agg':
@@ -738,9 +816,7 @@ function renderExpr(expr: AnyExpression, contract: PostgresContract, pim: ParamI
       return renderRawExpr(node, contract, pim);
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported expression node kind: ${(node satisfies never as { kind: string }).kind}`,
-      );
+      throw new Error(`Unsupported expression node kind: ${unreachableKind(node)}`);
   }
 }
 
@@ -912,9 +988,7 @@ function renderInsertValue(
       return renderExpr(value, contract, pim);
     // v8 ignore next 4
     default:
-      throw new Error(
-        `Unsupported value node in INSERT: ${(value satisfies never as { kind: string }).kind}`,
-      );
+      throw new Error(`Unsupported value node in INSERT: ${unreachableKind(value)}`);
   }
 }
 
@@ -979,9 +1053,7 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
           }
           // v8 ignore next 4
           default:
-            throw new Error(
-              `Unsupported onConflict action: ${(action satisfies never as { kind: string }).kind}`,
-            );
+            throw new Error(`Unsupported onConflict action: ${unreachableKind(action)}`);
         }
       })()
     : '';

package/src/exports/control.ts

@@ -10,13 +10,13 @@ import { PostgresControlAdapter } from '../core/control-adapter';
 import {
   createPostgresDefaultFunctionRegistry,
   createPostgresMutationDefaultGeneratorDescriptors,
-  createPostgresScalarTypeDescriptors,
+  postgresAuthoringTypes,
 } from '../core/control-mutation-defaults';
 import { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';
 
 const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'> = {
   ...postgresAdapterDescriptorMeta,
-  scalarTypeDescriptors: createPostgresScalarTypeDescriptors(),
+  authoring: { type: postgresAuthoringTypes, valueObjectStorageType: 'Jsonb' },
   controlMutationDefaults: {
     defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
     generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors(),

package/src/exports/runtime.ts

@@ -39,7 +39,7 @@ const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres',
     create(stack): SqlRuntimeAdapter {
       // The runtime `ExecutionStack` does not (yet) carry a pre-assembled `codecLookup` field the way the control `ControlStack` does, so we derive an equivalent lookup here from the stack's component metadata (target + adapter + extension packs) using the same assembly helper that `createControlStack` uses. This keeps the renderer fed with the same codec set on both planes — including extension-contributed codecs like
       // `pg/vector@1` from `@prisma-next/extension-pgvector`.
-      const components = [stack.target, stack.adapter, ...stack.extensionPacks];
+      const components = [stack.target, stack.adapter, ...stack.extensions];
       const codecLookup = extractCodecLookup(components);
       return createPostgresAdapter({ codecLookup });
     },