@prisma-next/adapter-postgres 0.16.0-dev.3 → 0.16.0-dev.30

package/src/core/adapter.ts

@@ -11,6 +11,7 @@ import type {
 import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
 import type { RawCodecInferer } from '@prisma-next/sql-relational-core/expression';
 import type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';
+import { adapterError } from './adapter-errors';
 import { createPostgresBuiltinCodecLookup } from './codec-lookup';
 import { PostgresControlAdapter } from './control-adapter';
 import { renderLoweredSql } from './sql-renderer';
@@ -75,8 +76,10 @@ class PostgresAdapterImpl
     context: LowererContext<PostgresContract>,
   ): PostgresLoweredStatement {
     if (isDdlNode(ast)) {
-      throw new Error(
+      throw adapterError(
+        'RUNTIME.DDL_UNSUPPORTED',
         'lower() does not lower DDL on the runtime adapter — DDL lowering is a control-plane concern handled by the control adapter.',
+        { meta: { surface: 'runtime-adapter' } },
       );
     }
     return renderLoweredSql(ast, context.contract, this.codecLookup);
@@ -98,8 +101,10 @@ export const postgresRawCodecInferer: RawCodecInferer = {
       case 'object':
         if (value instanceof Uint8Array) return 'pg/bytea';
     }
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.RAW_SQL_UNSUPPORTED_INTERPOLATION',
       'unsupported JS value type for raw-SQL interpolation: wrap this value in `param(...)` with an explicit codec',
+      { meta: { valueType: typeof value } },
     );
   },
 };

package/src/core/control-adapter.ts

@@ -31,6 +31,7 @@ import type {
   SqlExecuteRequest,
 } from '@prisma-next/sql-relational-core/ast';
 import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
+import { parseWireName } from '@prisma-next/sql-schema-ir/naming';
 import type {
   PrimaryKeyInput,
   SqlCheckConstraintIRInput,
@@ -49,21 +50,24 @@ import type {
   AddColumnAction,
   AlterTableActionVisitor,
   DropDefaultAction,
+  PostgresAlterIndexRename,
   PostgresAlterPolicyRename,
   PostgresAlterTable,
+  PostgresCreateIndex,
   PostgresCreatePolicy,
   PostgresCreateSchema,
   PostgresCreateTable,
   PostgresCreateType,
   PostgresDdlNode,
   PostgresDisableRowLevelSecurity,
+  PostgresDropIndex,
   PostgresDropPolicy,
   PostgresDropType,
   RlsPolicyOperation,
 } from '@prisma-next/target-postgres/ddl';
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
+import { postgresError } from '@prisma-next/target-postgres/errors';
 import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
-import { parseRlsPolicyWireName } from '@prisma-next/target-postgres/rls-canonicalize';
 import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
 import {
   PostgresDatabaseSchemaNode,
@@ -76,6 +80,7 @@ import {
 } from '@prisma-next/target-postgres/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { adapterError } from './adapter-errors';
 import { encodeControlQueryParams } from './control-codecs';
 import {
   execute,
@@ -148,8 +153,10 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<unknown>): LoweredStatement {
     if (isDdlNode(ast)) {
-      throw new Error(
+      throw adapterError(
+        'RUNTIME.DDL_UNSUPPORTED',
         'lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().',
+        { meta: { surface: 'control-adapter' } },
       );
     }
     return renderLoweredSql(
@@ -867,7 +874,9 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       tablename: string;
       indexname: string;
       indisunique: boolean;
+      where_predicate: string | null;
       attname: string | null;
+      element_def: string | null;
       index_position: number;
       amname: string | null;
       reloptions: string[] | null;
@@ -881,11 +890,24 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       // the table order — verification compares against the contract
       // with order-sensitive equality and reports a spurious
       // `index_mismatch`.
+      //
+      // `element_def` is the per-position element text as Postgres reprints
+      // it (`pg_get_indexdef` with pretty-printing); an expression element
+      // has attnum 0 so its `attname` is null and the element text is the
+      // only faithful capture. A mixed index (columns + expressions) carries
+      // the WHOLE element list as one opaque string, so the reprint must
+      // fire for every position of an expression-carrying index — the CASE
+      // bounds the per-element catalog reconstruction to those indexes,
+      // which keeps pure-column schemas free of the reprint cost.
+      // `where_predicate` is the reprinted partial-index predicate, null
+      // for total indexes.
       `SELECT
            i.tablename,
            i.indexname,
            ix.indisunique,
+           pg_get_expr(ix.indpred, ix.indrelid) AS where_predicate,
            a.attname,
+           CASE WHEN 0 = ANY(ix.indkey::int[]) THEN pg_get_indexdef(ix.indexrelid, k.ord::int, true) END AS element_def,
            k.ord AS index_position,
            am.amname,
            ic.reloptions
@@ -1123,38 +1145,24 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         dependsOn: postgresColumnDependsOn(schema, tableName, uq.columns),
       }));
 
-      // Process indexes
+      // Process indexes — keyed by catalog-unique index name, so two same-
+      // tuple siblings (a unique index beside a redundant plain index) and
+      // expression indexes all enter the tree at full fidelity.
       const indexesMap = new Map<
         string,
         {
-          columns: string[];
           name: string;
+          elements: { attname: string | null; elementDef: string | null }[];
           unique: boolean;
+          where: string | null;
           type: string | undefined;
           options: Record<string, string> | undefined;
         }
       >();
-      // An index with an expression key (e.g. `lower(email)`) reports that
-      // key's row with `attname = null` (Postgres attribute numbers are
-      // <= 0 for expressions, which the LEFT JOIN above can't resolve to a
-      // real column). Every row for that index name is skipped below
-      // rather than only the expression row, so the index never enters
-      // `indexesMap` with a collapsed, misleading column list — a
-      // two-column expression index silently reduced to its one real
-      // column can coincide with an unrelated real single-column index,
-      // and the schema differ's diff-tree node id is derived from the
-      // column tuple (`sql-index/index:<columns>`), so two indexes
-      // colliding on that tuple abort the diff with "duplicate id among
-      // siblings" instead of a normal drift report.
-      const indexNamesWithExpressionKey = new Set<string>();
       for (const idxRow of indexesByTable.get(tableName) ?? []) {
-        if (!idxRow.attname) {
-          indexNamesWithExpressionKey.add(idxRow.indexname);
-          continue;
-        }
         const existing = indexesMap.get(idxRow.indexname);
         if (existing) {
-          existing.columns.push(idxRow.attname);
+          existing.elements.push({ attname: idxRow.attname, elementDef: idxRow.element_def });
         } else {
           // Drop btree (the Postgres default) so a contract index without an
           // explicit type matches a default-method introspected index without
@@ -1162,49 +1170,46 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
           const indexType = idxRow.amname && idxRow.amname !== 'btree' ? idxRow.amname : undefined;
           const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
           indexesMap.set(idxRow.indexname, {
-            columns: [idxRow.attname],
             name: idxRow.indexname,
+            elements: [{ attname: idxRow.attname, elementDef: idxRow.element_def }],
             unique: idxRow.indisunique,
+            where: idxRow.where_predicate,
             type: indexType,
             options: indexOptions,
           });
         }
       }
-      // Two real indexes can legitimately share the exact same column tuple
-      // on one table (e.g. a unique index and a redundant plain index) —
-      // valid in Postgres, but the schema differ's diff-tree node id for an
-      // index is the column tuple alone (`SqlIndexIR#id`, deliberately —
-      // see its doc comment), so two same-tuple siblings from one
-      // introspection abort the diff with "duplicate id among siblings"
-      // rather than a normal drift report. Keep only one per column tuple:
-      // the unique one when there is a unique/non-unique pair (a unique
-      // index is a strict superset of what a plain index on the same
-      // columns would add), otherwise the first by name for determinism.
-      const survivingIndexes = Array.from(indexesMap.values()).filter(
-        (idx) => !indexNamesWithExpressionKey.has(idx.name),
-      );
-      const bestByColumnTuple = new Map<string, (typeof survivingIndexes)[number]>();
-      for (const idx of survivingIndexes) {
-        const tupleKey = idx.columns.join(',');
-        const existing = bestByColumnTuple.get(tupleKey);
-        if (
-          !existing ||
-          (idx.unique && !existing.unique) ||
-          (idx.unique === existing.unique && idx.name < existing.name)
-        ) {
-          bestByColumnTuple.set(tupleKey, idx);
-        }
-      }
-      const indexes: readonly SqlIndexIRInput[] = Array.from(bestByColumnTuple.values()).map(
-        (idx) => ({
-          columns: Object.freeze([...idx.columns]),
+      const indexes: readonly SqlIndexIRInput[] = Array.from(indexesMap.values()).map((idx) => {
+        // An expression element has attnum 0, which the attribute LEFT JOIN
+        // cannot resolve — its attname is null. Any such element makes the
+        // whole index an expression node: the entire element list (real
+        // columns included) is carried as one opaque reprinted string.
+        const isExpression = idx.elements.some((el) => el.attname === null);
+        const columnNames = idx.elements.flatMap((el) => (el.attname !== null ? [el.attname] : []));
+        const base = {
           name: idx.name,
+          // Rename-pass grouping only, like policy introspection: undefined
+          // when the live name does not follow the wire-name shape.
+          prefix: parseWireName(idx.name)?.prefix,
+          where: idx.where ?? undefined,
           unique: idx.unique,
-          ...(idx.type !== undefined && { type: idx.type }),
-          ...(idx.options !== undefined && { options: idx.options }),
-          dependsOn: postgresColumnDependsOn(schema, tableName, idx.columns),
-        }),
-      );
+          partial: idx.where !== null,
+          type: idx.type,
+          options: idx.options,
+          annotations: undefined,
+          // Expression indexes stamp chains to every column of the table —
+          // the opaque expression is never parsed, so the deterministic
+          // over-approximation keeps drops ordered.
+          dependsOn: postgresColumnDependsOn(
+            schema,
+            tableName,
+            isExpression ? Object.keys(columns) : columnNames,
+          ),
+        };
+        return isExpression
+          ? { ...base, expression: idx.elements.map((el) => el.elementDef ?? '').join(', ') }
+          : { ...base, columns: Object.freeze([...columnNames]) };
+      });
 
       // Process check constraints — parse each predicate into column + value set.
       // Only the two shapes emitted by this slice are recognised; free-form
@@ -1274,7 +1279,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         ...new Set(parsePgNameArray(row.roles).map((r) => r.toLowerCase())),
       ].sort();
       const permissive = row.permissive.toUpperCase() === 'PERMISSIVE';
-      const prefix = parseRlsPolicyWireName(row.policyname)?.prefix ?? row.policyname;
+      const prefix = parseWireName(row.policyname)?.prefix ?? row.policyname;
       const policy = new PostgresPolicySchemaNode({
         name: row.policyname,
         prefix,
@@ -1542,8 +1547,10 @@ const PG_REFERENTIAL_ACTION_MAP: Record<PgReferentialActionRule, SqlReferentialA
 function mapReferentialAction(rule: string): SqlReferentialAction | undefined {
   const mapped = PG_REFERENTIAL_ACTION_MAP[rule as PgReferentialActionRule];
   if (mapped === undefined) {
-    throw new Error(
+    throw adapterError(
+      'CONTRACT.INTROSPECTION_UNSUPPORTED',
       `Unknown PostgreSQL referential action rule: "${rule}". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`,
+      { meta: { rule } },
     );
   }
   if (mapped === 'noAction') return undefined;
@@ -1614,8 +1621,10 @@ export function parsePgReloptions(
   for (const entry of reloptions) {
     const eq = entry.indexOf('=');
     if (eq === -1) {
-      throw new Error(
+      throw adapterError(
+        'CONTRACT.INTROSPECTION_UNSUPPORTED',
         `Postgres introspection: malformed reloption entry "${entry}" on index "${indexName}" (expected "key=value")`,
+        { meta: { entry, indexName } },
       );
     }
     const key = entry.slice(0, eq);
@@ -1771,8 +1780,10 @@ function pgInlineLiteral(wire: unknown, nativeType: string): string {
   if (typeof wire === 'boolean') return wire ? 'true' : 'false';
   if (typeof wire === 'number') {
     if (!Number.isFinite(wire)) {
-      throw new Error(
+      throw adapterError(
+        'CONTRACT.DEFAULT_INVALID',
         `pgRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal for native type "${nativeType}"`,
+        { meta: { nativeType } },
       );
     }
     return String(wire);
@@ -1780,8 +1791,10 @@ function pgInlineLiteral(wire: unknown, nativeType: string): string {
   if (typeof wire === 'bigint') return String(wire);
   if (wire instanceof Date) {
     if (Number.isNaN(wire.getTime())) {
-      throw new Error(
+      throw adapterError(
+        'CONTRACT.DEFAULT_INVALID',
         `pgRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal for native type "${nativeType}"`,
+        { meta: { nativeType } },
       );
     }
     const quoted = `'${escapeLiteral(wire.toISOString())}'`;
@@ -1804,8 +1817,10 @@ function pgInlineLiteral(wire: unknown, nativeType: string): string {
     const quoted = `'${escapeLiteral(JSON.stringify(wire))}'`;
     return `${quoted}::${nativeType}`;
   }
-  throw new Error(
+  throw adapterError(
+    'CONTRACT.PACK_CONTRIBUTION_INVALID',
     `pgRenderDdlExecuteRequest: unexpected wire type "${typeof wire}" for native type "${nativeType}"`,
+    { meta: { wireType: typeof wire, nativeType } },
   );
 }
 
@@ -1991,6 +2006,65 @@ function pgRenderAlterPolicyRename(node: PostgresAlterPolicyRename): SqlExecuteR
   };
 }
 
+/**
+ * Renders one index reloption value: strings single-quote-escaped, finite
+ * numbers verbatim, booleans in the `on`/`off` catalog spelling (the
+ * canonical form the wire hash and the option equality commit to).
+ */
+function pgRenderIndexOptionValue(key: string, value: unknown): string {
+  if (typeof value === 'string') return `'${escapeLiteral(value)}'`;
+  if (typeof value === 'number' && Number.isFinite(value)) return String(value);
+  if (typeof value === 'boolean') return value ? 'on' : 'off';
+  throw postgresError(
+    'CONTRACT.INDEX_INVALID',
+    `Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`,
+    { meta: { key, valueType: typeof value } },
+  );
+}
+
+/** Qualifies an object name; an absent schema renders it unqualified (unbound namespace). */
+function pgQualify(schema: string | undefined, name: string): string {
+  return schema === undefined
+    ? quoteIdentifier(name)
+    : `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+}
+
+function pgRenderCreateIndex(node: PostgresCreateIndex): SqlExecuteRequest {
+  const elementList =
+    'columns' in node.elements
+      ? node.elements.columns.map(quoteIdentifier).join(', ')
+      : node.elements.expression;
+  const unique = node.unique ? 'UNIQUE ' : '';
+  const using = node.type !== undefined ? ` USING ${quoteIdentifier(node.type)}` : '';
+  const withClause =
+    node.options !== undefined && Object.keys(node.options).length > 0
+      ? ` WITH (${Object.entries(node.options)
+          .map(
+            ([key, value]) => `${quoteIdentifier(key)} = ${pgRenderIndexOptionValue(key, value)}`,
+          )
+          .join(', ')})`
+      : '';
+  const whereClause = node.where !== undefined ? ` WHERE (${node.where})` : '';
+  return {
+    sql: `CREATE ${unique}INDEX ${quoteIdentifier(node.name)} ON ${pgQualify(node.schema, node.table)}${using} (${elementList})${withClause}${whereClause}`,
+    params: [],
+  };
+}
+
+function pgRenderDropIndex(node: PostgresDropIndex): SqlExecuteRequest {
+  return {
+    sql: `DROP INDEX ${pgQualify(node.schema, node.name)}`,
+    params: [],
+  };
+}
+
+function pgRenderAlterIndexRename(node: PostgresAlterIndexRename): SqlExecuteRequest {
+  return {
+    sql: `ALTER INDEX ${pgQualify(node.schema, node.from)} RENAME TO ${quoteIdentifier(node.to)}`,
+    params: [],
+  };
+}
+
 function pgRenderDisableRowLevelSecurity(node: PostgresDisableRowLevelSecurity): SqlExecuteRequest {
   const tableRef = `${quoteIdentifier(node.schema)}.${quoteIdentifier(node.table)}`;
   return {
@@ -2013,6 +2087,10 @@ async function pgRenderDdlExecuteRequest(
     dropPolicy: (node: PostgresDropPolicy) => Promise.resolve(pgRenderDropPolicy(node)),
     alterPolicyRename: (node: PostgresAlterPolicyRename) =>
       Promise.resolve(pgRenderAlterPolicyRename(node)),
+    createIndex: (node: PostgresCreateIndex) => Promise.resolve(pgRenderCreateIndex(node)),
+    dropIndex: (node: PostgresDropIndex) => Promise.resolve(pgRenderDropIndex(node)),
+    alterIndexRename: (node: PostgresAlterIndexRename) =>
+      Promise.resolve(pgRenderAlterIndexRename(node)),
     disableRowLevelSecurity: (node: PostgresDisableRowLevelSecurity) =>
       Promise.resolve(pgRenderDisableRowLevelSecurity(node)),
   };

package/src/core/control-codecs.ts

@@ -9,6 +9,7 @@ import {
   encodeParamsWithMetadata,
 } from '@prisma-next/sql-runtime';
 import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
+import { InternalError } from '@prisma-next/utils/internal-error';
 
 export const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
 
@@ -19,7 +20,9 @@ export async function encodeControlQueryParams(
 ): 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`);
+    throw new InternalError(
+      `control query lowered to a bind slot '${slot.name}', which is unsupported`,
+    );
   });
   return encodeParamsWithMetadata(values, deriveParamMetadata(ast), {}, codecs);
 }

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,138 @@ 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;
+
+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' } },
+  Inet: { kind: 'typeConstructor', output: { codecId: 'pg/inet@1', nativeType: 'inet' } },
+  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 +297,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/descriptor-meta.ts

@@ -40,6 +40,7 @@ import {
 } from '@prisma-next/target-postgres/codec-ids';
 import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
 import type { QueryOperationTypes } from '../types/operation-types';
+import { adapterError } from './adapter-errors';
 
 // ============================================================================ Helper functions for reducing boilerplate ============================================================================
 
@@ -69,8 +70,10 @@ function expandLength({ nativeType, typeParams }: ExpandNativeTypeInput): string
   }
   const length = typeParams['length'];
   if (!isPositiveInteger(length)) {
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `Invalid "length" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(length)}`,
+      { meta: { nativeType, param: 'length', received: length } },
     );
   }
   return `${nativeType}(${length})`;
@@ -82,8 +85,10 @@ function expandPrecision({ nativeType, typeParams }: ExpandNativeTypeInput): str
   }
   const precision = typeParams['precision'];
   if (!isPositiveInteger(precision)) {
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`,
+      { meta: { nativeType, param: 'precision', received: precision } },
     );
   }
   return `${nativeType}(${precision})`;
@@ -98,23 +103,29 @@ function expandNumeric({ nativeType, typeParams }: ExpandNativeTypeInput): strin
   }
 
   if (!hasPrecision && hasScale) {
-    throw new Error(
+    throw adapterError(
+      'RUNTIME.TYPE_PARAMS_INVALID',
       `Invalid type parameters for "${nativeType}": "scale" requires "precision" to be specified`,
+      { meta: { nativeType, param: 'scale' } },
     );
   }
 
   if (hasPrecision) {
     const precision = typeParams['precision'];
     if (!isPositiveInteger(precision)) {
-      throw new Error(
+      throw adapterError(
+        'RUNTIME.TYPE_PARAMS_INVALID',
         `Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`,
+        { meta: { nativeType, param: 'precision', received: precision } },
       );
     }
     if (hasScale) {
       const scale = typeParams['scale'];
       if (!isNonNegativeInteger(scale)) {
-        throw new Error(
+        throw adapterError(
+          'RUNTIME.TYPE_PARAMS_INVALID',
           `Invalid "scale" type parameter for "${nativeType}": expected a non-negative integer, got ${JSON.stringify(scale)}`,
+          { meta: { nativeType, param: 'scale', received: scale } },
         );
       }
       return `${nativeType}(${precision},${scale})`;