@prisma-next/psl-printer 0.5.0-dev.9 → 0.6.0-dev.1

package/dist/postgres.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres.mjs","names":["POSTGRES_FUNCTION_ATTRIBUTES: Readonly<Record<string, string>>","POSTGRES_TO_PSL: Record<string, string>","PRESERVED_NATIVE_TYPES: Record<\n  string,\n  { readonly pslType: string; readonly attributeName: string }\n>","PARAMETERIZED_NATIVE_TYPES: Record<\n  string,\n  { readonly pslType: string; readonly attributeName: string }\n>"],"sources":["../src/postgres-default-mapping.ts","../src/postgres-type-map.ts","../src/raw-default-parser.ts"],"sourcesContent":["import type { DefaultMappingOptions } from './default-mapping';\n\nconst POSTGRES_FUNCTION_ATTRIBUTES: Readonly<Record<string, string>> = {\n  'gen_random_uuid()': '@default(dbgenerated(\"gen_random_uuid()\"))',\n};\n\nfunction formatDbGeneratedAttribute(expression: string): string {\n  return `@default(dbgenerated(${JSON.stringify(expression)}))`;\n}\n\nexport function createPostgresDefaultMapping(): DefaultMappingOptions {\n  return {\n    functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,\n    fallbackFunctionAttribute: formatDbGeneratedAttribute,\n  };\n}\n","import type { EnumInfo, PslNativeTypeAttribute, PslTypeMap, PslTypeResolution } from './types';\n\n/**\n * Reverse mapping from Postgres native types to PSL scalar types.\n * This is the inverse of SCALAR_COLUMN_MAP in the PSL interpreter.\n *\n * Only types NOT covered by PRESERVED_NATIVE_TYPES belong here — preserved types\n * are checked first in createPostgresTypeMap and would shadow any duplicate entries.\n */\nconst POSTGRES_TO_PSL: Record<string, string> = {\n  text: 'String',\n  bool: 'Boolean',\n  boolean: 'Boolean',\n  int4: 'Int',\n  integer: 'Int',\n  int8: 'BigInt',\n  bigint: 'BigInt',\n  float8: 'Float',\n  'double precision': 'Float',\n  numeric: 'Decimal',\n  decimal: 'Decimal',\n  timestamptz: 'DateTime',\n  'timestamp with time zone': 'DateTime',\n  jsonb: 'Json',\n  bytea: 'Bytes',\n};\n\n/**\n * Native types that require explicit `@db.*` preservation because the provider's\n * default scalar descriptors would otherwise collapse them to a different storage type.\n */\nconst PRESERVED_NATIVE_TYPES: Record<\n  string,\n  { readonly pslType: string; readonly attributeName: string }\n> = {\n  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },\n  character: { pslType: 'String', attributeName: 'db.Char' },\n  char: { pslType: 'String', attributeName: 'db.Char' },\n  varchar: { pslType: 'String', attributeName: 'db.VarChar' },\n  uuid: { pslType: 'String', attributeName: 'db.Uuid' },\n  int2: { pslType: 'Int', attributeName: 'db.SmallInt' },\n  smallint: { pslType: 'Int', attributeName: 'db.SmallInt' },\n  float4: { pslType: 'Float', attributeName: 'db.Real' },\n  real: { pslType: 'Float', attributeName: 'db.Real' },\n  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },\n  'timestamp without time zone': { pslType: 'DateTime', attributeName: 'db.Timestamp' },\n  date: { pslType: 'DateTime', attributeName: 'db.Date' },\n  time: { pslType: 'DateTime', attributeName: 'db.Time' },\n  'time without time zone': { pslType: 'DateTime', attributeName: 'db.Time' },\n  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },\n  'time with time zone': { pslType: 'DateTime', attributeName: 'db.Timetz' },\n  json: { pslType: 'Json', attributeName: 'db.Json' },\n};\n\n/**\n * Parameterized Postgres types that also need explicit `@db.*` preservation.\n */\nconst PARAMETERIZED_NATIVE_TYPES: Record<\n  string,\n  { readonly pslType: string; readonly attributeName: string }\n> = {\n  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },\n  character: { pslType: 'String', attributeName: 'db.Char' },\n  char: { pslType: 'String', attributeName: 'db.Char' },\n  varchar: { pslType: 'String', attributeName: 'db.VarChar' },\n  numeric: { pslType: 'Decimal', attributeName: 'db.Numeric' },\n  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },\n  timestamptz: { pslType: 'DateTime', attributeName: 'db.Timestamptz' },\n  time: { pslType: 'DateTime', attributeName: 'db.Time' },\n  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },\n};\n\n/**\n * Regex to extract base type and optional parameters from a native type string.\n * Examples: \"character varying(255)\" → [\"character varying\", \"255\"]\n *           \"numeric(10,2)\" → [\"numeric\", \"10,2\"]\n */\nconst PARAMETERIZED_TYPE_PATTERN = /^(.+?)\\((.+)\\)$/;\n\n/**\n * Set of enum storage type codec IDs used for detection.\n */\nconst ENUM_CODEC_ID = 'pg/enum@1';\n\nfunction getOwnMappingValue(map: Record<string, string>, key: string): string | undefined {\n  return Object.hasOwn(map, key) ? map[key] : undefined;\n}\n\nfunction getOwnRecordValue<T>(map: Record<string, T>, key: string): T | undefined {\n  return Object.hasOwn(map, key) ? map[key] : undefined;\n}\n\nfunction createNativeTypeAttribute(name: string, args?: readonly string[]): PslNativeTypeAttribute {\n  return args && args.length > 0 ? { name, args } : { name };\n}\n\nfunction splitTypeParameterList(params: string): readonly string[] {\n  return params\n    .split(',')\n    .map((part) => part.trim())\n    .filter((part) => part.length > 0);\n}\n\n/**\n * Creates a Postgres-specific type map for the PSL printer.\n *\n * @param enumTypeNames - Set of native type names that are enums (from annotations.pg.storageTypes)\n */\nexport function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslTypeMap {\n  return {\n    resolve(nativeType: string): PslTypeResolution {\n      // Check for enum types first\n      if (enumTypeNames?.has(nativeType)) {\n        return { pslType: nativeType, nativeType };\n      }\n\n      // Check for parameterized types first so we keep precision/scale/length.\n      const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);\n      if (paramMatch) {\n        const [, baseType = nativeType, params = ''] = paramMatch;\n        const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);\n        if (template) {\n          return {\n            pslType: template.pslType,\n            nativeType,\n            typeParams: { baseType, params },\n            nativeTypeAttribute: createNativeTypeAttribute(\n              template.attributeName,\n              splitTypeParameterList(params),\n            ),\n          };\n        }\n      }\n\n      // Non-parameterized native types that still need explicit preservation.\n      const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);\n      if (preservedType) {\n        return {\n          pslType: preservedType.pslType,\n          nativeType,\n          nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName),\n        };\n      }\n\n      // Direct scalar mapping\n      const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);\n      if (pslType) {\n        return {\n          pslType,\n          nativeType,\n        };\n      }\n\n      // Unsupported type\n      return { unsupported: true, nativeType };\n    },\n  };\n}\n\nexport type { EnumInfo };\n\n/**\n * Extracts enum type names and definitions from SqlSchemaIR annotations\n * in a single traversal.\n */\nexport function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {\n  const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;\n  const storageTypes = pgAnnotations?.['storageTypes'] as\n    | Record<string, { codecId: string; nativeType: string; typeParams?: Record<string, unknown> }>\n    | undefined;\n\n  const typeNames = new Set<string>();\n  const definitions = new Map<string, readonly string[]>();\n\n  if (storageTypes) {\n    for (const [key, typeInstance] of Object.entries(storageTypes)) {\n      if (typeInstance.codecId === ENUM_CODEC_ID) {\n        typeNames.add(key);\n        const values = typeInstance.typeParams?.['values'];\n        if (Array.isArray(values)) {\n          definitions.set(key, values as string[]);\n        }\n      }\n    }\n  }\n\n  return { typeNames, definitions };\n}\n\n/**\n * Extracts enum type names from the SqlSchemaIR annotations.\n */\nexport function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string> {\n  return extractEnumInfo(annotations).typeNames;\n}\n\n/**\n * Extracts enum definitions (name → values) from SqlSchemaIR annotations.\n */\nexport function extractEnumDefinitions(\n  annotations?: Record<string, unknown>,\n): ReadonlyMap<string, readonly string[]> {\n  return extractEnumInfo(annotations).definitions;\n}\n","import type { ColumnDefault } from '@prisma-next/contract/types';\n\n/**\n * Parses a raw database default expression into a normalized ColumnDefault.\n * When nativeType is provided, parsing can preserve Postgres semantics for\n * timestamp and JSON defaults that would otherwise be ambiguous.\n */\n\nconst NEXTVAL_PATTERN = /^nextval\\s*\\(/i;\nconst NOW_FUNCTION_PATTERN = /^(now\\s*\\(\\s*\\)|CURRENT_TIMESTAMP)$/i;\nconst CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\\s*\\(\\s*\\)$/i;\nconst TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\\s+(?:with|without)\\s+time\\s+zone)?$/i;\nconst TEXT_CAST_SUFFIX = /::text$/i;\nconst NOW_LITERAL_PATTERN = /^'now'$/i;\nconst UUID_PATTERN = /^gen_random_uuid\\s*\\(\\s*\\)$/i;\nconst UUID_OSSP_PATTERN = /^uuid_generate_v4\\s*\\(\\s*\\)$/i;\nconst NULL_PATTERN = /^NULL(?:::.+)?$/i;\nconst TRUE_PATTERN = /^true$/i;\nconst FALSE_PATTERN = /^false$/i;\nconst NUMERIC_PATTERN = /^-?\\d+(\\.\\d+)?$/;\nconst JSON_CAST_SUFFIX = /::jsonb?$/i;\nconst STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:\"[^\"]+\"|[\\w\\s]+)(?:\\(\\d+\\))?)?$/;\n\nfunction canonicalizeTimestampDefault(expr: string): string | undefined {\n  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';\n\n  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;\n\n  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();\n  if (inner.startsWith('(') && inner.endsWith(')')) {\n    inner = inner.slice(1, -1).trim();\n  }\n\n  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';\n\n  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();\n  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';\n\n  return undefined;\n}\n\nexport function parseRawDefault(\n  rawDefault: string,\n  nativeType?: string,\n): ColumnDefault | undefined {\n  const trimmed = rawDefault.trim();\n  const normalizedType = nativeType?.toLowerCase();\n\n  if (NEXTVAL_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'autoincrement()' };\n  }\n\n  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);\n  if (canonicalTimestamp) {\n    return { kind: 'function', expression: canonicalTimestamp };\n  }\n\n  if (UUID_PATTERN.test(trimmed) || UUID_OSSP_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  if (NULL_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: null };\n  }\n\n  if (TRUE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: true };\n  }\n\n  if (FALSE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: false };\n  }\n\n  if (NUMERIC_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: Number(trimmed) };\n  }\n\n  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);\n  if (stringMatch?.[1] !== undefined) {\n    const unescaped = stringMatch[1].replace(/''/g, \"'\");\n    if (normalizedType === 'json' || normalizedType === 'jsonb') {\n      if (JSON_CAST_SUFFIX.test(trimmed)) {\n        return { kind: 'function', expression: trimmed };\n      }\n      try {\n        return { kind: 'literal', value: JSON.parse(unescaped) };\n      } catch {\n        // Fall through to the string form for malformed/non-JSON values.\n      }\n    }\n    return { kind: 'literal', value: unescaped };\n  }\n\n  // Unrecognized — return as function with raw expression\n  return { kind: 'function', expression: trimmed };\n}\n"],"mappings":"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"}

package/dist/types-BmnVaMF1.d.mts

@@ -1,54 +0,0 @@
-import { ColumnDefault, ColumnDefault as ColumnDefault$1 } from "@prisma-next/contract/types";
-
-//#region src/default-mapping.d.ts
-interface DefaultMappingOptions {
-  readonly functionAttributes?: Readonly<Record<string, string>>;
-  readonly fallbackFunctionAttribute?: ((expression: string) => string | undefined) | undefined;
-}
-//#endregion
-//#region src/types.d.ts
-/**
- * Result of resolving a native database type to a PSL type.
- */
-type PslNativeTypeAttribute = {
-  readonly name: string;
-  readonly args?: readonly string[];
-};
-type PslTypeResolution = {
-  readonly pslType: string;
-  readonly nativeType: string;
-  readonly typeParams?: Record<string, unknown>;
-  readonly nativeTypeAttribute?: PslNativeTypeAttribute;
-} | {
-  readonly unsupported: true;
-  readonly nativeType: string;
-};
-/**
- * Interface for mapping native database types to PSL scalar types.
- * Implementations are target-specific (e.g., Postgres, MySQL).
- */
-interface PslTypeMap {
-  resolve(nativeType: string, annotations?: Record<string, unknown>): PslTypeResolution;
-}
-/**
- * Pre-extracted enum information from target-specific annotations.
- */
-interface EnumInfo {
-  readonly typeNames: ReadonlySet<string>;
-  readonly definitions: ReadonlyMap<string, readonly string[]>;
-}
-/**
- * Options for the PSL printer.
- */
-interface PslPrinterOptions {
-  readonly typeMap: PslTypeMap;
-  readonly header?: string;
-  readonly defaultMapping?: DefaultMappingOptions;
-  /** Pre-extracted enum info. Required for schemas with enum types. */
-  readonly enumInfo?: EnumInfo;
-  /** Target-specific parser for raw default expressions (e.g., Postgres SQL dialect). */
-  readonly parseRawDefault?: (rawDefault: string, nativeType?: string) => ColumnDefault$1 | undefined;
-}
-//#endregion
-export { DefaultMappingOptions as a, PslTypeResolution as i, PslPrinterOptions as n, PslTypeMap as r, EnumInfo as t };
-//# sourceMappingURL=types-BmnVaMF1.d.mts.map

package/dist/types-BmnVaMF1.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-BmnVaMF1.d.mts","names":[],"sources":["../src/default-mapping.ts","../src/types.ts"],"sourcesContent":[],"mappings":";;;UAOiB,qBAAA;gCACe,SAAS;EADxB,SAAA,yBAAqB,CAAA,EACG,CAAA,CAAA,UAAT,EAAA,MAAQ,EAAA,GAAA,MAAA,GAAA,SAAA,CAAA,GAAA,SAAA;;;;;AADxC;;KCDY,sBAAA;;EAAA,SAAA,IAAA,CAAA,EAAA,SAAsB,MAAA,EAAA;AAKlC,CAAA;AAgBiB,KAhBL,iBAAA,GAiBgC;EAM3B,SAAA,OAAQ,EAAA,MACH;EAOL,SAAA,UAAA,EAAiB,MAAA;EACd,SAAA,UAAA,CAAA,EA5BQ,MA4BR,CAAA,MAAA,EAAA,OAAA,CAAA;EAEQ,SAAA,mBAAA,CAAA,EA7BS,sBA6BT;CAEN,GAAA;EAEoD,SAAA,WAAA,EAAA,IAAA;EAAa,SAAA,UAAA,EAAA,MAAA;;;;;;UAtBtE,UAAA;4CAC2B,0BAA0B;;;;;UAMrD,QAAA;sBACK;wBACE;;;;;UAMP,iBAAA;oBACG;;4BAEQ;;sBAEN;;0EAEoD"}

package/src/default-mapping.ts

@@ -1,66 +0,0 @@
-import type { ColumnDefault } from '@prisma-next/contract/types';
-
-const DEFAULT_FUNCTION_ATTRIBUTES: Readonly<Record<string, string>> = {
-  'autoincrement()': '@default(autoincrement())',
-  'now()': '@default(now())',
-};
-
-export interface DefaultMappingOptions {
-  readonly functionAttributes?: Readonly<Record<string, string>>;
-  readonly fallbackFunctionAttribute?: ((expression: string) => string | undefined) | undefined;
-}
-
-/**
- * Result of mapping a ColumnDefault to a PSL @default expression.
- */
-export type DefaultMappingResult = { readonly attribute: string } | { readonly comment: string };
-
-/**
- * Maps a normalized ColumnDefault to a PSL @default(...) attribute string,
- * or a comment for unrecognized expressions.
- */
-export function mapDefault(
-  columnDefault: ColumnDefault,
-  options?: DefaultMappingOptions,
-): DefaultMappingResult {
-  switch (columnDefault.kind) {
-    case 'literal':
-      return { attribute: `@default(${formatLiteralValue(columnDefault.value)})` };
-    case 'function': {
-      const attribute =
-        options?.functionAttributes?.[columnDefault.expression] ??
-        DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ??
-        options?.fallbackFunctionAttribute?.(columnDefault.expression);
-      return attribute
-        ? { attribute }
-        : { comment: `// Raw default: ${columnDefault.expression.replace(/[\r\n]+/g, ' ')}` };
-    }
-  }
-}
-
-/**
- * Formats a literal value for use in @default(...).
- */
-function formatLiteralValue(value: unknown): string {
-  if (value === null) {
-    return 'null';
-  }
-
-  switch (typeof value) {
-    case 'boolean':
-    case 'number':
-      return String(value);
-    case 'string':
-      return quoteString(value);
-    default:
-      return quoteString(JSON.stringify(value));
-  }
-}
-
-function quoteString(str: string): string {
-  return `"${escapeString(str)}"`;
-}
-
-function escapeString(str: string): string {
-  return JSON.stringify(str).slice(1, -1);
-}

package/src/exports/postgres.ts

@@ -1,8 +0,0 @@
-export { createPostgresDefaultMapping } from '../postgres-default-mapping';
-export {
-  createPostgresTypeMap,
-  extractEnumDefinitions,
-  extractEnumInfo,
-  extractEnumTypeNames,
-} from '../postgres-type-map';
-export { parseRawDefault } from '../raw-default-parser';

package/src/name-transforms.ts

@@ -1,234 +0,0 @@
-/**
- * PSL reserved words that cannot be used as identifiers without escaping.
- */
-const PSL_RESERVED_WORDS = new Set(['model', 'enum', 'types', 'type', 'generator', 'datasource']);
-
-const IDENTIFIER_PART_PATTERN = /[A-Za-z0-9]+/g;
-
-type NameResult = {
-  readonly name: string;
-  readonly map?: string;
-};
-
-/**
- * Checks whether normalization needs to split or sanitize the identifier.
- */
-function hasSeparators(input: string): boolean {
-  return /[^A-Za-z0-9]/.test(input);
-}
-
-function extractIdentifierParts(input: string): string[] {
-  return input.match(IDENTIFIER_PART_PATTERN) ?? [];
-}
-
-function createSyntheticIdentifier(input: string): string {
-  let hash = 2166136261;
-
-  for (const char of input) {
-    hash ^= char.codePointAt(0) ?? 0;
-    hash = Math.imul(hash, 16777619);
-  }
-
-  return `x${(hash >>> 0).toString(16)}`;
-}
-
-function sanitizeIdentifierCharacters(input: string): string {
-  const sanitized = input.replace(/[^\w]/g, '');
-  return sanitized.length > 0 ? sanitized : createSyntheticIdentifier(input);
-}
-
-function capitalize(word: string): string {
-  return word.charAt(0).toUpperCase() + word.slice(1);
-}
-
-/**
- * Converts a normalized identifier to PascalCase.
- */
-function snakeToPascalCase(input: string): string {
-  const parts = extractIdentifierParts(input);
-  if (parts.length === 0) {
-    return capitalize(sanitizeIdentifierCharacters(input));
-  }
-  return parts.map(capitalize).join('');
-}
-
-/**
- * Converts a normalized identifier to camelCase.
- */
-function snakeToCamelCase(input: string): string {
-  const parts = extractIdentifierParts(input);
-  if (parts.length === 0) {
-    return sanitizeIdentifierCharacters(input);
-  }
-  const [firstPart = input, ...rest] = parts;
-  return firstPart.charAt(0).toLowerCase() + firstPart.slice(1) + rest.map(capitalize).join('');
-}
-
-/**
- * Checks if a name needs escaping (reserved word or starts with digit).
- */
-function needsEscaping(name: string): boolean {
-  return PSL_RESERVED_WORDS.has(name.toLowerCase()) || /^\d/.test(name);
-}
-
-/**
- * Escapes a name by prefixing with underscore.
- */
-function escapeName(name: string): string {
-  return `_${name}`;
-}
-
-function escapeIfNeeded(name: string): string {
-  return needsEscaping(name) ? escapeName(name) : name;
-}
-
-/**
- * Converts a database table name to a PSL model name.
- * snake_case → PascalCase, with @@map("db_name") when the name was transformed.
- * Names that are already PascalCase (no separators, start with uppercase) are kept as-is.
- */
-export function toModelName(tableName: string): NameResult {
-  let name: string;
-
-  if (hasSeparators(tableName)) {
-    name = snakeToPascalCase(tableName);
-  } else {
-    // Ensure first character is uppercase
-    name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
-  }
-
-  if (needsEscaping(name)) {
-    const escaped = escapeName(name);
-    return { name: escaped, map: tableName };
-  }
-
-  if (name !== tableName) {
-    return { name, map: tableName };
-  }
-
-  return { name };
-}
-
-/**
- * Converts a database column name to a PSL field name.
- * snake_case → camelCase, with @map("db_col") when the name was transformed.
- * Names that are already camelCase (no separators, start with lowercase) are kept as-is.
- */
-export function toFieldName(columnName: string): NameResult {
-  let name: string;
-
-  if (hasSeparators(columnName)) {
-    name = snakeToCamelCase(columnName);
-  } else {
-    // Ensure first character is lowercase
-    name = columnName.charAt(0).toLowerCase() + columnName.slice(1);
-  }
-
-  if (needsEscaping(name)) {
-    const escaped = escapeName(name);
-    return { name: escaped, map: columnName };
-  }
-
-  if (name !== columnName) {
-    return { name, map: columnName };
-  }
-
-  return { name };
-}
-
-/**
- * Converts a Postgres enum type name to a PSL enum name.
- * snake_case → PascalCase, with @@map when transformed.
- */
-export function toEnumName(pgTypeName: string): NameResult {
-  let name: string;
-
-  if (hasSeparators(pgTypeName)) {
-    name = snakeToPascalCase(pgTypeName);
-  } else {
-    name = pgTypeName.charAt(0).toUpperCase() + pgTypeName.slice(1);
-  }
-
-  if (needsEscaping(name)) {
-    const escaped = escapeName(name);
-    return { name: escaped, map: pgTypeName };
-  }
-
-  if (name !== pgTypeName) {
-    return { name, map: pgTypeName };
-  }
-
-  return { name };
-}
-
-/**
- * Simple English pluralization for back-relation field names.
- * Handles: s→ses, y→ies, default→s
- */
-export function pluralize(word: string): string {
-  if (
-    word.endsWith('s') ||
-    word.endsWith('x') ||
-    word.endsWith('z') ||
-    word.endsWith('ch') ||
-    word.endsWith('sh')
-  ) {
-    return `${word}es`;
-  }
-  if (word.endsWith('y') && !/[aeiou]y$/i.test(word)) {
-    return `${word.slice(0, -1)}ies`;
-  }
-  return `${word}s`;
-}
-
-/**
- * Derives a relation field name from FK column names.
- *
- * For single-column FKs: strip _id/Id suffix, camelCase the result.
- * For composite FKs: use the referenced table name (lowercased, camelCased).
- */
-export function deriveRelationFieldName(
-  fkColumns: readonly string[],
-  referencedTableName: string,
-): string {
-  if (fkColumns.length === 1) {
-    const [col = referencedTableName] = fkColumns;
-    // Strip common FK suffixes
-    const stripped = col.replace(/_id$/i, '').replace(/Id$/, '');
-
-    if (stripped.length > 0 && stripped !== col) {
-      return escapeIfNeeded(snakeToCamelCase(stripped));
-    }
-    // If stripping didn't change anything, use the referenced table name
-    return escapeIfNeeded(snakeToCamelCase(referencedTableName));
-  }
-
-  // Composite FK: use referenced table name
-  return escapeIfNeeded(snakeToCamelCase(referencedTableName));
-}
-
-/**
- * Derives a back-relation field name.
- * For 1:N: pluralize the child model name (lowercased first char).
- * For 1:1: lowercase first char of child model name.
- */
-export function deriveBackRelationFieldName(childModelName: string, isOneToOne: boolean): string {
-  const base = childModelName.charAt(0).toLowerCase() + childModelName.slice(1);
-  return isOneToOne ? base : pluralize(base);
-}
-
-/**
- * Converts a column name to a named type name for the types block.
- * E.g., column "email" with type "character varying(255)" → "Email"
- */
-export function toNamedTypeName(columnName: string): string {
-  let name: string;
-
-  if (hasSeparators(columnName)) {
-    name = snakeToPascalCase(columnName);
-  } else {
-    name = columnName.charAt(0).toUpperCase() + columnName.slice(1);
-  }
-
-  return escapeIfNeeded(name);
-}

package/src/postgres-default-mapping.ts

@@ -1,16 +0,0 @@
-import type { DefaultMappingOptions } from './default-mapping';
-
-const POSTGRES_FUNCTION_ATTRIBUTES: Readonly<Record<string, string>> = {
-  'gen_random_uuid()': '@default(dbgenerated("gen_random_uuid()"))',
-};
-
-function formatDbGeneratedAttribute(expression: string): string {
-  return `@default(dbgenerated(${JSON.stringify(expression)}))`;
-}
-
-export function createPostgresDefaultMapping(): DefaultMappingOptions {
-  return {
-    functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
-    fallbackFunctionAttribute: formatDbGeneratedAttribute,
-  };
-}

package/src/postgres-type-map.ts

@@ -1,204 +0,0 @@
-import type { EnumInfo, PslNativeTypeAttribute, PslTypeMap, PslTypeResolution } from './types';
-
-/**
- * Reverse mapping from Postgres native types to PSL scalar types.
- * This is the inverse of SCALAR_COLUMN_MAP in the PSL interpreter.
- *
- * Only types NOT covered by PRESERVED_NATIVE_TYPES belong here — preserved types
- * are checked first in createPostgresTypeMap and would shadow any duplicate entries.
- */
-const POSTGRES_TO_PSL: Record<string, string> = {
-  text: 'String',
-  bool: 'Boolean',
-  boolean: 'Boolean',
-  int4: 'Int',
-  integer: 'Int',
-  int8: 'BigInt',
-  bigint: 'BigInt',
-  float8: 'Float',
-  'double precision': 'Float',
-  numeric: 'Decimal',
-  decimal: 'Decimal',
-  timestamptz: 'DateTime',
-  'timestamp with time zone': 'DateTime',
-  jsonb: 'Json',
-  bytea: 'Bytes',
-};
-
-/**
- * Native types that require explicit `@db.*` preservation because the provider's
- * default scalar descriptors would otherwise collapse them to a different storage type.
- */
-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' },
-  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' },
-};
-
-/**
- * Parameterized Postgres types that also need explicit `@db.*` preservation.
- */
-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' },
-};
-
-/**
- * Regex to extract base type and optional parameters from a native type string.
- * Examples: "character varying(255)" → ["character varying", "255"]
- *           "numeric(10,2)" → ["numeric", "10,2"]
- */
-const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
-
-/**
- * Set of enum storage type codec IDs used for detection.
- */
-const ENUM_CODEC_ID = 'pg/enum@1';
-
-function getOwnMappingValue(map: Record<string, string>, key: string): string | undefined {
-  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(',')
-    .map((part) => part.trim())
-    .filter((part) => part.length > 0);
-}
-
-/**
- * Creates a Postgres-specific type map for the PSL printer.
- *
- * @param enumTypeNames - Set of native type names that are enums (from annotations.pg.storageTypes)
- */
-export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslTypeMap {
-  return {
-    resolve(nativeType: string): PslTypeResolution {
-      // Check for enum types first
-      if (enumTypeNames?.has(nativeType)) {
-        return { pslType: nativeType, nativeType };
-      }
-
-      // Check for parameterized types first so we keep precision/scale/length.
-      const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
-      if (paramMatch) {
-        const [, baseType = nativeType, params = ''] = paramMatch;
-        const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
-        if (template) {
-          return {
-            pslType: template.pslType,
-            nativeType,
-            typeParams: { baseType, params },
-            nativeTypeAttribute: createNativeTypeAttribute(
-              template.attributeName,
-              splitTypeParameterList(params),
-            ),
-          };
-        }
-      }
-
-      // Non-parameterized native types that still need explicit preservation.
-      const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
-      if (preservedType) {
-        return {
-          pslType: preservedType.pslType,
-          nativeType,
-          nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName),
-        };
-      }
-
-      // Direct scalar mapping
-      const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
-      if (pslType) {
-        return {
-          pslType,
-          nativeType,
-        };
-      }
-
-      // Unsupported type
-      return { unsupported: true, nativeType };
-    },
-  };
-}
-
-export type { EnumInfo };
-
-/**
- * Extracts enum type names and definitions from SqlSchemaIR annotations
- * in a single traversal.
- */
-export function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {
-  const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;
-  const storageTypes = pgAnnotations?.['storageTypes'] as
-    | Record<string, { codecId: string; nativeType: string; typeParams?: Record<string, unknown> }>
-    | undefined;
-
-  const typeNames = new Set<string>();
-  const definitions = new Map<string, readonly string[]>();
-
-  if (storageTypes) {
-    for (const [key, typeInstance] of Object.entries(storageTypes)) {
-      if (typeInstance.codecId === ENUM_CODEC_ID) {
-        typeNames.add(key);
-        const values = typeInstance.typeParams?.['values'];
-        if (Array.isArray(values)) {
-          definitions.set(key, values as string[]);
-        }
-      }
-    }
-  }
-
-  return { typeNames, definitions };
-}
-
-/**
- * Extracts enum type names from the SqlSchemaIR annotations.
- */
-export function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string> {
-  return extractEnumInfo(annotations).typeNames;
-}
-
-/**
- * Extracts enum definitions (name → values) from SqlSchemaIR annotations.
- */
-export function extractEnumDefinitions(
-  annotations?: Record<string, unknown>,
-): ReadonlyMap<string, readonly string[]> {
-  return extractEnumInfo(annotations).definitions;
-}