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

package/src/core/migrations/render-typescript.ts

@@ -9,13 +9,19 @@
  * shape is, so future consolidation to a framework-level helper is mechanical.
  */
 
-import type { OpFactoryCall } from '@prisma-next/framework-components/control';
+import {
+  contractSnapshotJsonSpecifier,
+  contractSnapshotTypesSpecifier,
+  type OpFactoryCall,
+} from '@prisma-next/framework-components/control';
 import { detectScaffoldRuntime, shebangLineFor } from '@prisma-next/migration-tools/migration-ts';
 import { type ImportRequirement, renderImports } from '@prisma-next/ts-render';
 
 export interface RenderMigrationMeta {
   readonly from: string | null;
   readonly to: string;
+  /** POSIX-relative path from the migration package dir to `migrations/snapshots`, e.g. '../../snapshots'. */
+  readonly snapshotsImportPath: string;
 }
 
 /**
@@ -86,31 +92,37 @@ function buildImports(calls: ReadonlyArray<OpFactoryCall>, meta: RenderMigration
 
 /**
  * The committed contract-JSON imports the scaffold reads its from/to identity
- * from. `end-contract.json` is always present; `start-contract.json` is added
- * only for a non-baseline migration (`meta.from !== null`). The matching
- * `Contract` type imports (aliased `Start`/`End`) feed the
+ * from, resolved to the deduplicated snapshot store under
+ * `meta.snapshotsImportPath`. The end snapshot is always present; the start
+ * snapshot is added only for a non-baseline migration (`meta.from !== null`).
+ * The matching `Contract` type imports (aliased `Start`/`End`) feed the
  * `Migration<Start, End>` generics. Baseline emits `Migration<never, End>` with
  * no start imports — `never` is the honest "no prior contract" Start.
  */
 function contractImports(meta: RenderMigrationMeta): readonly ImportRequirement[] {
   const reqs: ImportRequirement[] = [
     {
-      moduleSpecifier: './end-contract.json',
+      moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.to),
       symbol: 'endContract',
       kind: 'default',
       attributes: { type: 'json' },
     },
-    { moduleSpecifier: './end-contract', symbol: 'Contract', alias: 'End', typeOnly: true },
+    {
+      moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.to),
+      symbol: 'Contract',
+      alias: 'End',
+      typeOnly: true,
+    },
   ];
   if (meta.from !== null) {
     reqs.push({
-      moduleSpecifier: './start-contract.json',
+      moduleSpecifier: contractSnapshotJsonSpecifier(meta.snapshotsImportPath, meta.from),
       symbol: 'startContract',
       kind: 'default',
       attributes: { type: 'json' },
     });
     reqs.push({
-      moduleSpecifier: './start-contract',
+      moduleSpecifier: contractSnapshotTypesSpecifier(meta.snapshotsImportPath, meta.from),
       symbol: 'Contract',
       alias: 'Start',
       typeOnly: true,

package/src/core/migrations/runner.ts

@@ -20,8 +20,10 @@ import { SqlQueryError } from '@prisma-next/sql-errors';
 import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { InternalError } from '@prisma-next/utils/internal-error';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
+import { postgresError } from '../errors';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 interface ApplyPlanSuccessValue {
@@ -76,8 +78,10 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
       UNBOUND_NAMESPACE_ID;
     const driver = options.driver;
     if (options.space !== undefined && options.space !== options.plan.spaceId) {
-      throw new Error(
+      throw postgresError(
+        'MIGRATION.CONTRACT_SPACE_VIOLATION',
         `SqlMigrationRunner: options.space (${options.space}) does not match plan.spaceId (${options.plan.spaceId})`,
+        { meta: { space: options.space, planSpaceId: options.plan.spaceId } },
       );
     }
     const space = options.plan.spaceId;
@@ -283,7 +287,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     const bootstrapQueries = this.family.bootstrapControlTableQueries();
     const [schemaQuery, ...tableQueries] = bootstrapQueries;
     if (schemaQuery === undefined) {
-      throw new Error('Postgres control-table bootstrap must include CREATE SCHEMA');
+      throw new InternalError('Postgres control-table bootstrap must include CREATE SCHEMA');
     }
     await this.executeStatement(driver, await this.family.lowerAst(schemaQuery, lowererContext));
     const legacyDetection = await this.detectLegacyMarkerShape(driver);
@@ -640,7 +644,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     const edges = options.migrationEdges;
     const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
     if (totalEdgeOps !== planOpsLength) {
-      throw new Error(
+      throw new InternalError(
         `Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
       );
     }

package/src/core/psl-infer/infer-psl-contract.ts

@@ -3,7 +3,6 @@ import type { SqlDescribedContractSpace } from '@prisma-next/family-sql/control'
 import type {
   DefaultMappingOptions,
   EnumInfo,
-  PslNativeTypeAttribute,
   PslPrinterOptions,
   PslTypeMap,
   RelationField,
@@ -18,7 +17,6 @@ import {
   toEnumName,
   toFieldName,
   toModelName,
-  toNamedTypeName,
 } from '@prisma-next/family-sql/psl-infer';
 import { coordinateKey, elementCoordinates } from '@prisma-next/framework-components/ir';
 import type {
@@ -31,10 +29,8 @@ import type {
   PslFieldAttribute,
   PslModel,
   PslModelAttribute,
-  PslNamedTypeDeclaration,
   PslSpan,
   PslTypeConstructorCall,
-  PslTypesBlock,
 } from '@prisma-next/framework-components/psl-ast';
 import {
   makePslNamespace,
@@ -46,6 +42,7 @@ import type { SqlColumnIR, SqlForeignKeyIR } from '@prisma-next/sql-schema-ir/ty
 import { SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { postgresError } from '../errors';
 import type { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { createPostgresDefaultMapping } from './postgres-default-mapping';
 import { createPostgresTypeMap } from './postgres-type-map';
@@ -74,17 +71,6 @@ type ResolvedColumnFieldName = {
 
 type TableColumnFieldNameMap = ReadonlyMap<string, ResolvedColumnFieldName>;
 
-type NamedTypeRegistryEntry = {
-  readonly name: string;
-  readonly baseType: string;
-  readonly nativeTypeAttribute: PslNativeTypeAttribute;
-};
-
-type NamedTypeRegistry = {
-  readonly entriesByKey: Map<string, NamedTypeRegistryEntry>;
-  readonly usedNames: Set<string>;
-};
-
 type TopLevelNameResult = {
   readonly name: string;
   readonly map?: string | undefined;
@@ -224,11 +210,13 @@ function resolveForeignKeys(
         if (owner !== undefined) {
           const target = resolveCrossSpaceTarget(owner, fk.referencedSchema, fk.referencedTable);
           if (target === undefined) {
-            throw new Error(
+            throw postgresError(
+              'CONTRACT.PACK_CONTRIBUTION_INVALID',
               `contract infer: described contract space "${owner.spaceId}" owns storage ` +
                 `coordinate "${fk.referencedSchema}.${fk.referencedTable}" but declares no ` +
                 'domain model mapped to it. A pack that describes a table must also declare the ' +
                 'domain model it maps to; this pack is malformed.',
+              { meta: { spaceId: owner.spaceId, tableName: fk.referencedTable } },
             );
           }
 
@@ -384,22 +372,26 @@ export function inferPostgresPslContract(
         continue;
       }
       if (tables[tableName] !== undefined) {
-        throw new Error(
+        throw postgresError(
+          'CONTRACT.INFER_UNSUPPORTED',
           `contract infer: duplicate table name "${tableName}" across schemas is not yet supported ` +
             '(single-namespace PSL inference emits one flat bucket; multi-namespace `namespace { … }` ' +
             'output is a later slice).',
+          { meta: { tableName } },
         );
       }
       if (ownedEnumTypes !== undefined) {
         for (const column of Object.values(table.columns)) {
           const owningSpaceId = ownedEnumTypes.get(column.nativeType);
           if (owningSpaceId !== undefined) {
-            throw new Error(
+            throw postgresError(
+              'CONTRACT.INFER_UNSUPPORTED',
               `contract infer: column "${tableName}"."${column.name}" is typed by native enum ` +
                 `type "${column.nativeType}", which extension pack space "${owningSpaceId}" ` +
                 'already describes. A cross-space enum-typed column has no authorable PSL form ' +
                 "yet; describe the table in that pack's contract or retype the column before " +
                 're-running contract infer.',
+              { meta: { tableName, columnName: column.name } },
             );
           }
         }
@@ -418,12 +410,14 @@ export function inferPostgresPslContract(
   if (enumDefinitions.size > 0) {
     const contentNamespaces = new Set([...enumNamespaceNames, ...tableNamespaceNames]);
     if (contentNamespaces.size > 1) {
-      throw new Error(
+      throw postgresError(
+        'CONTRACT.INFER_UNSUPPORTED',
         'contract infer: native enum adoption with content across multiple schemas is not yet ' +
           'supported (single-namespace PSL inference emits one `namespace { … }` block; ' +
           `multi-namespace output is a later slice). Schemas: ${[...contentNamespaces]
             .sort()
             .join(', ')}.`,
+        { meta: { schemas: [...contentNamespaces].sort() } },
       );
     }
     wrapNamespaceName = [...contentNamespaces][0];
@@ -511,8 +505,6 @@ export function buildPslDocumentAst(
     }
   }
 
-  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNameMap);
-
   // Cross-space entries are seeded first so a real local table of the same
   // bare name (an existing single-namespace-flat-bucket limitation, not new
   // here) always wins the merge, matching `resolveForeignKeys`'s own
@@ -522,7 +514,6 @@ export function buildPslDocumentAst(
     ...buildFieldNamesByTable(schemaIR.tables),
   ]);
   const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
 
   const models: PslModel[] = [];
   for (const table of Object.values(schemaIR.tables)) {
@@ -532,7 +523,6 @@ export function buildPslDocumentAst(
         typeMap,
         enumNameMap,
         fieldNamesByTable,
-        namedTypes,
         defaultMapping,
         rawDefaultParser,
         [
@@ -546,18 +536,6 @@ export function buildPslDocumentAst(
 
   const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
 
-  const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) =>
-    a.name.localeCompare(b.name),
-  );
-  const types: PslTypesBlock | undefined =
-    namedTypeEntries.length > 0
-      ? {
-          kind: 'types',
-          declarations: namedTypeEntries.map(buildNamedTypeDeclaration),
-          span: SYNTHETIC_SPAN,
-        }
-      : undefined;
-
   // Inferred PSL nodes will eventually be routed into per-namespace buckets
   // matching the source storage; for now everything lands in a single bucket.
   // Without a `namespaceName` that bucket is the synthesised `__unspecified__`
@@ -576,7 +554,6 @@ export function buildPslDocumentAst(
         span: SYNTHETIC_SPAN,
       }),
     ],
-    ...(types ? { types } : {}),
     span: SYNTHETIC_SPAN,
   };
 
@@ -670,7 +647,6 @@ function buildModel(
   typeMap: PslTypeMap,
   enumNameMap: ReadonlyMap<string, string>,
   fieldNamesByTable: ReadonlyMap<string, TableColumnFieldNameMap>,
-  namedTypes: NamedTypeRegistry,
   defaultMapping: DefaultMappingOptions | undefined,
   rawDefaultParser: PslPrinterOptions['parseRawDefault'],
   relationFields: readonly RelationField[],
@@ -703,7 +679,6 @@ function buildModel(
         typeMap,
         enumNameMap,
         fieldNameMap,
-        namedTypes,
         defaultMapping,
         rawDefaultParser,
         pkColumns,
@@ -738,8 +713,15 @@ function buildModel(
   }
 
   for (const index of table.indexes) {
+    // Expression indexes (no column tuple) and partial indexes (a where
+    // predicate) are not emitted yet — no authoring surface can carry their
+    // bodies, so adopting them name-only would fail its own verify (the
+    // exact-mode body compare). Their inference lands when the authoring
+    // surfaces for those bodies exist.
+    if (index.columns === undefined || index.where !== undefined) continue;
     if (!index.unique) {
-      const indexFieldNames = index.columns.map((columnName) =>
+      const columns = index.columns;
+      const indexFieldNames = columns.map((columnName) =>
         resolveColumnFieldName(fieldNamesByTable, table.name, columnName),
       );
       modelAttributes.push(
@@ -805,7 +787,7 @@ function buildDanglingForeignKeyWarning(
   return (
     `Foreign key ${descriptions.join(', ')} exists in the database, but its target schema is ` +
     'outside the introspected scope, so no relation field was generated. If the target schema ' +
-    'is described by an extension pack, add it to extensionPacks and re-run infer.'
+    'is described by an extension pack, add it to extensions and re-run infer.'
   );
 }
 
@@ -815,7 +797,6 @@ function buildScalarField(
   typeMap: PslTypeMap,
   enumNameMap: ReadonlyMap<string, string>,
   fieldNameMap: TableColumnFieldNameMap | undefined,
-  namedTypes: NamedTypeRegistry,
   defaultMapping: DefaultMappingOptions | undefined,
   rawDefaultParser: PslPrinterOptions['parseRawDefault'],
   pkColumns: ReadonlySet<string>,
@@ -849,8 +830,15 @@ function buildScalarField(
   // the Phase-1 authoring form a `native_enum` ref field takes — not a bare
   // name substitution. The printer renders `typeConstructor` when present and
   // composes `?`/`[]` exactly like any other field type.
-  let typeName = resolution.pslType;
-  let typeConstructor: PslTypeConstructorCall | undefined;
+  let typeName = resolution.pslType.name;
+  let typeConstructor: PslTypeConstructorCall | undefined = resolution.pslType.args
+    ? {
+        kind: 'typeConstructor',
+        path: [resolution.pslType.name],
+        args: resolution.pslType.args.map(positionalArg),
+        span: SYNTHETIC_SPAN,
+      }
+    : undefined;
   const enumPslName = enumNameMap.get(column.nativeType);
   if (enumPslName) {
     typeName = enumPslName;
@@ -861,9 +849,6 @@ function buildScalarField(
       span: SYNTHETIC_SPAN,
     };
   }
-  if (resolution.nativeTypeAttribute && !enumPslName) {
-    typeName = resolveNamedTypeName(namedTypes, resolution);
-  }
 
   const attributes: PslFieldAttribute[] = [];
   const isId = isSinglePk && pkColumns.has(column.name);
@@ -1063,21 +1048,6 @@ function namedArg(name: string, value: string): PslAttributeArgument {
   return { kind: 'named', name, value, span: SYNTHETIC_SPAN };
 }
 
-function buildNamedTypeDeclaration(entry: NamedTypeRegistryEntry): PslNamedTypeDeclaration {
-  const attribute = buildAttribute(
-    'namedType',
-    entry.nativeTypeAttribute.name,
-    (entry.nativeTypeAttribute.args ?? []).map(positionalArg),
-  );
-  return {
-    kind: 'namedType',
-    name: entry.name,
-    baseType: entry.baseType,
-    attributes: [attribute],
-    span: SYNTHETIC_SPAN,
-  };
-}
-
 function escapePslString(value: string): string {
   return value
     .replace(/\\/g, '\\\\')
@@ -1222,135 +1192,16 @@ function buildTopLevelNameMap(
           .map((source) => `"${source}"`)
           .join(', ')}`,
     );
-    throw new Error(`PSL ${kind} name collisions detected:\n${details.join('\n')}`);
+    throw postgresError(
+      'CONTRACT.NAME_DUPLICATE',
+      `PSL ${kind} name collisions detected:\n${details.join('\n')}`,
+      { meta: { kind, names: duplicates.map(([normalizedName]) => normalizedName) } },
+    );
   }
 
   return results;
 }
 
-function createReservedNamedTypeNames(
-  modelNames: ReadonlyMap<string, TopLevelNameResult>,
-  enumNameMap: ReadonlyMap<string, string>,
-): Set<string> {
-  const reservedNames = new Set<string>(PSL_SCALAR_TYPE_NAMES);
-
-  for (const result of modelNames.values()) {
-    reservedNames.add(result.name);
-  }
-  for (const enumPslName of enumNameMap.values()) {
-    reservedNames.add(enumPslName);
-  }
-
-  return reservedNames;
-}
-
-function seedNamedTypeRegistry(
-  schemaIR: SqlSchemaIR,
-  typeMap: PslTypeMap,
-  enumNameMap: ReadonlyMap<string, string>,
-  reservedNames: ReadonlySet<string>,
-): NamedTypeRegistry {
-  type Seed = {
-    readonly baseType: string;
-    readonly desiredName: string;
-    readonly nativeTypeAttribute: PslNativeTypeAttribute;
-  };
-
-  const seeds = new Map<string, Seed>();
-
-  for (const tableName of Object.keys(schemaIR.tables).sort()) {
-    const table = schemaIR.tables[tableName];
-    if (!table) {
-      continue;
-    }
-
-    for (const columnName of Object.keys(table.columns).sort()) {
-      const column = table.columns[columnName];
-      if (!column) {
-        continue;
-      }
-
-      const resolution = typeMap.resolve(column.nativeType, table.annotations);
-      if (
-        'unsupported' in resolution ||
-        enumNameMap.has(column.nativeType) ||
-        !resolution.nativeTypeAttribute
-      ) {
-        continue;
-      }
-
-      const signatureKey = createNamedTypeSignatureKey(resolution);
-      if (!seeds.has(signatureKey)) {
-        seeds.set(signatureKey, {
-          baseType: resolution.pslType,
-          desiredName: toNamedTypeName(column.name),
-          nativeTypeAttribute: resolution.nativeTypeAttribute,
-        });
-      }
-    }
-  }
-
-  const registry: NamedTypeRegistry = {
-    entriesByKey: new Map<string, NamedTypeRegistryEntry>(),
-    usedNames: new Set<string>(reservedNames),
-  };
-
-  const sortedSeeds = [...seeds.entries()].sort((left, right) => {
-    const desiredNameComparison = left[1].desiredName.localeCompare(right[1].desiredName);
-    if (desiredNameComparison !== 0) {
-      return desiredNameComparison;
-    }
-    return left[0].localeCompare(right[0]);
-  });
-
-  for (const [signatureKey, seed] of sortedSeeds) {
-    const name = createUniqueFieldName(seed.desiredName, registry.usedNames);
-    registry.entriesByKey.set(signatureKey, {
-      name,
-      baseType: seed.baseType,
-      nativeTypeAttribute: seed.nativeTypeAttribute,
-    });
-    registry.usedNames.add(name);
-  }
-
-  return registry;
-}
-
-function resolveNamedTypeName(
-  registry: NamedTypeRegistry,
-  resolution: {
-    readonly pslType: string;
-    readonly nativeType: string;
-    readonly typeParams?: Record<string, unknown>;
-    readonly nativeTypeAttribute?: PslNativeTypeAttribute;
-  },
-): string {
-  const key = createNamedTypeSignatureKey(resolution);
-  const existing = registry.entriesByKey.get(key);
-  if (existing) {
-    return existing.name;
-  }
-
-  throw new Error(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
-}
-
-function createNamedTypeSignatureKey(resolution: {
-  readonly pslType: string;
-  readonly nativeType: string;
-  readonly typeParams?: Record<string, unknown>;
-  readonly nativeTypeAttribute?: PslNativeTypeAttribute;
-}): string {
-  return JSON.stringify({
-    baseType: resolution.pslType,
-    nativeTypeAttribute: resolution.nativeTypeAttribute
-      ? {
-          name: resolution.nativeTypeAttribute.name,
-          args: resolution.nativeTypeAttribute.args ?? null,
-        }
-      : null,
-  });
-}
-
 function topologicalSort(
   models: PslModel[],
   tables: Record<string, SqlTableIR>,

package/src/core/psl-infer/postgres-type-map.ts

@@ -1,8 +1,4 @@
-import type {
-  PslNativeTypeAttribute,
-  PslTypeMap,
-  PslTypeResolution,
-} from '@prisma-next/family-sql/psl-infer';
+import type { PslTypeMap, PslTypeResolution } from '@prisma-next/family-sql/psl-infer';
 
 const POSTGRES_TO_PSL: Record<string, string> = {
   text: 'String',
@@ -14,51 +10,46 @@ const POSTGRES_TO_PSL: Record<string, string> = {
   bigint: 'BigInt',
   float8: 'Float',
   'double precision': 'Float',
-  numeric: 'Decimal',
-  decimal: 'Decimal',
-  timestamptz: 'DateTime',
-  'timestamp with time zone': 'DateTime',
-  jsonb: 'Json',
+  jsonb: 'Jsonb',
   bytea: 'Bytes',
 };
 
-const PRESERVED_NATIVE_TYPES: Record<
-  string,
-  { readonly pslType: string; readonly attributeName: string }
-> = {
-  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },
-  character: { pslType: 'String', attributeName: 'db.Char' },
-  char: { pslType: 'String', attributeName: 'db.Char' },
-  varchar: { pslType: 'String', attributeName: 'db.VarChar' },
-  uuid: { pslType: 'String', attributeName: 'db.Uuid' },
-  inet: { pslType: 'String', attributeName: 'db.Inet' },
-  int2: { pslType: 'Int', attributeName: 'db.SmallInt' },
-  smallint: { pslType: 'Int', attributeName: 'db.SmallInt' },
-  float4: { pslType: 'Float', attributeName: 'db.Real' },
-  real: { pslType: 'Float', attributeName: 'db.Real' },
-  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },
-  'timestamp without time zone': { pslType: 'DateTime', attributeName: 'db.Timestamp' },
-  date: { pslType: 'DateTime', attributeName: 'db.Date' },
-  time: { pslType: 'DateTime', attributeName: 'db.Time' },
-  'time without time zone': { pslType: 'DateTime', attributeName: 'db.Time' },
-  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },
-  'time with time zone': { pslType: 'DateTime', attributeName: 'db.Timetz' },
-  json: { pslType: 'Json', attributeName: 'db.Json' },
+const PRESERVED_NATIVE_TYPES: Record<string, string> = {
+  'character varying': 'VarChar',
+  character: 'Char',
+  char: 'Char',
+  varchar: 'VarChar',
+  uuid: 'Uuid',
+  inet: 'Inet',
+  int2: 'SmallInt',
+  smallint: 'SmallInt',
+  float4: 'Real',
+  real: 'Real',
+  numeric: 'Numeric',
+  decimal: 'Numeric',
+  timestamp: 'Timestamp',
+  'timestamp without time zone': 'Timestamp',
+  timestamptz: 'Timestamptz',
+  'timestamp with time zone': 'Timestamptz',
+  date: 'Date',
+  time: 'Time',
+  'time without time zone': 'Time',
+  timetz: 'Timetz',
+  'time with time zone': 'Timetz',
+  json: 'Json',
 };
 
-const PARAMETERIZED_NATIVE_TYPES: Record<
-  string,
-  { readonly pslType: string; readonly attributeName: string }
-> = {
-  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },
-  character: { pslType: 'String', attributeName: 'db.Char' },
-  char: { pslType: 'String', attributeName: 'db.Char' },
-  varchar: { pslType: 'String', attributeName: 'db.VarChar' },
-  numeric: { pslType: 'Decimal', attributeName: 'db.Numeric' },
-  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },
-  timestamptz: { pslType: 'DateTime', attributeName: 'db.Timestamptz' },
-  time: { pslType: 'DateTime', attributeName: 'db.Time' },
-  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },
+const PARAMETERIZED_NATIVE_TYPES: Record<string, string> = {
+  'character varying': 'VarChar',
+  character: 'Char',
+  char: 'Char',
+  varchar: 'VarChar',
+  numeric: 'Numeric',
+  decimal: 'Numeric',
+  timestamp: 'Timestamp',
+  timestamptz: 'Timestamptz',
+  time: 'Time',
+  timetz: 'Timetz',
 };
 
 const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
@@ -67,14 +58,6 @@ function getOwnMappingValue(map: Record<string, string>, key: string): string |
   return Object.hasOwn(map, key) ? map[key] : undefined;
 }
 
-function getOwnRecordValue<T>(map: Record<string, T>, key: string): T | undefined {
-  return Object.hasOwn(map, key) ? map[key] : undefined;
-}
-
-function createNativeTypeAttribute(name: string, args?: readonly string[]): PslNativeTypeAttribute {
-  return args && args.length > 0 ? { name, args } : { name };
-}
-
 function splitTypeParameterList(params: string): readonly string[] {
   return params
     .split(',')
@@ -86,39 +69,34 @@ export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslT
   return {
     resolve(nativeType: string): PslTypeResolution {
       if (enumTypeNames?.has(nativeType)) {
-        return { pslType: nativeType, nativeType };
+        return { pslType: { name: nativeType }, nativeType };
       }
 
       const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
       if (paramMatch) {
         const [, baseType = nativeType, params = ''] = paramMatch;
-        const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
-        if (template) {
+        const typeName = getOwnMappingValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+        if (typeName) {
           return {
-            pslType: template.pslType,
+            pslType: { name: typeName, args: splitTypeParameterList(params) },
             nativeType,
             typeParams: { baseType, params },
-            nativeTypeAttribute: createNativeTypeAttribute(
-              template.attributeName,
-              splitTypeParameterList(params),
-            ),
           };
         }
       }
 
-      const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+      const preservedType = getOwnMappingValue(PRESERVED_NATIVE_TYPES, nativeType);
       if (preservedType) {
         return {
-          pslType: preservedType.pslType,
+          pslType: { name: preservedType },
           nativeType,
-          nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName),
         };
       }
 
       const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
       if (pslType) {
         return {
-          pslType,
+          pslType: { name: pslType },
           nativeType,
         };
       }