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

package/src/serialize-print-document.ts

@@ -0,0 +1,182 @@
+import type { PrintDocument } from './print-document';
+import type { PrinterEnumValue, PrinterField, PrinterNamedType } from './types';
+
+const PSL_IDENTIFIER_PATTERN = /^[A-Za-z_]\w*$/;
+const ENUM_MEMBER_RESERVED_WORDS = new Set([
+  'datasource',
+  'default',
+  'enum',
+  'generator',
+  'model',
+  'type',
+  'types',
+]);
+
+export function escapePslString(value: string): string {
+  return value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r');
+}
+
+export function serializePrintDocument(doc: PrintDocument): string {
+  const sections: string[] = [];
+
+  sections.push(doc.headerComment);
+
+  const namedTypeEntries = [...doc.namedTypes].sort((a, b) => a.name.localeCompare(b.name));
+  if (namedTypeEntries.length > 0) {
+    sections.push(serializeTypesBlock(namedTypeEntries));
+  }
+
+  const enumsSorted = [...doc.enums].sort((a, b) => a.name.localeCompare(b.name));
+  for (const e of enumsSorted) {
+    sections.push(serializeEnum(e));
+  }
+
+  for (const model of doc.models) {
+    sections.push(serializeModel(model));
+  }
+
+  return `${sections.join('\n\n')}\n`;
+}
+
+function serializeTypesBlock(namedTypes: readonly PrinterNamedType[]): string {
+  const lines = ['types {'];
+  for (const nt of namedTypes) {
+    const attrStr = nt.attributes.length > 0 ? ` ${nt.attributes.join(' ')}` : '';
+    lines.push(`  ${nt.name} = ${nt.baseType}${attrStr}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function serializeEnum(e: {
+  name: string;
+  mapName?: string | undefined;
+  values: readonly PrinterEnumValue[];
+}): string {
+  const lines = [`enum ${e.name} {`];
+  const usedNames = new Set<string>();
+  for (const value of e.values) {
+    const memberName = normalizeEnumMemberName(value.name, usedNames);
+    // Emit a per-member `@map("...")` whenever the printed identifier differs
+    // from the original storage label (e.g. PostgreSQL enum labels with
+    // hyphens that get normalised to camelCase, reserved words that get
+    // `_`-prefixed, or names that collide and get a numeric suffix), or when
+    // the AST carried an explicit `mapName` from a parsed source. Without
+    // this, parsing the emitted PSL would lose the original storage label and
+    // a subsequent `contract emit` would talk to the wrong DB enum value.
+    const explicitMap = value.mapName;
+    const storageLabel =
+      explicitMap !== undefined ? explicitMap : memberName !== value.name ? value.name : undefined;
+    if (storageLabel !== undefined) {
+      lines.push(`  ${memberName} @map("${escapePslString(storageLabel)}")`);
+    } else {
+      lines.push(`  ${memberName}`);
+    }
+    usedNames.add(memberName);
+  }
+  if (e.mapName) {
+    lines.push('');
+    lines.push(`  @@map("${escapePslString(e.mapName)}")`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function serializeModel(model: import('./types').PrinterModel): string {
+  const lines: string[] = [];
+
+  if (model.comment) {
+    lines.push(model.comment);
+  }
+  lines.push(`model ${model.name} {`);
+
+  const idFields = model.fields.filter((f) => f.isId);
+  const scalarFields = model.fields.filter((f) => !f.isId && !f.isRelation);
+  const relationFields = model.fields.filter((f) => f.isRelation);
+
+  const allOrderedFields = [...idFields, ...scalarFields, ...relationFields];
+
+  if (allOrderedFields.length > 0) {
+    const maxNameLen = Math.max(...allOrderedFields.map((f) => f.name.length));
+    const maxTypeLen = Math.max(...allOrderedFields.map((f) => formatFieldType(f).length));
+
+    for (const field of allOrderedFields) {
+      const typePart = formatFieldType(field);
+      const paddedName = field.name.padEnd(maxNameLen);
+      const paddedType = typePart.padEnd(maxTypeLen);
+
+      if (field.comment) {
+        lines.push(`  ${field.comment}`);
+      }
+
+      const attrStr = field.attributes.length > 0 ? ` ${field.attributes.join(' ')}` : '';
+      lines.push(`  ${paddedName} ${paddedType}${attrStr}`.trimEnd());
+    }
+  }
+
+  if (model.modelAttributes.length > 0) {
+    if (allOrderedFields.length > 0) {
+      lines.push('');
+    }
+    for (const attr of model.modelAttributes) {
+      lines.push(`  ${attr}`);
+    }
+  }
+
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function formatFieldType(field: PrinterField): string {
+  let type = field.typeName;
+  if (field.list) {
+    type += '[]';
+  } else if (field.optional) {
+    type += '?';
+  }
+  return type;
+}
+
+function createUniqueFieldName(desiredName: string, usedFieldNames: ReadonlySet<string>): string {
+  if (!usedFieldNames.has(desiredName)) {
+    return desiredName;
+  }
+
+  let counter = 2;
+  while (usedFieldNames.has(`${desiredName}${counter}`)) {
+    counter++;
+  }
+  return `${desiredName}${counter}`;
+}
+
+function isNormalizedEnumMemberReservedWord(value: string): boolean {
+  return ENUM_MEMBER_RESERVED_WORDS.has(value.toLowerCase());
+}
+
+function normalizeEnumMemberName(value: string, usedNames: ReadonlySet<string>): string {
+  const desiredName =
+    PSL_IDENTIFIER_PATTERN.test(value) && !isNormalizedEnumMemberReservedWord(value)
+      ? value
+      : createNormalizedEnumMemberBaseName(value);
+
+  return createUniqueFieldName(desiredName, usedNames);
+}
+
+function createNormalizedEnumMemberBaseName(value: string): string {
+  const tokens = value.match(/[A-Za-z0-9]+/g)?.map((token) => token.toLowerCase()) ?? [];
+  let normalized = tokens[0] ?? 'value';
+
+  for (const token of tokens.slice(1)) {
+    normalized += token.charAt(0).toUpperCase() + token.slice(1);
+  }
+
+  if (isNormalizedEnumMemberReservedWord(normalized) || /^\d/.test(normalized)) {
+    normalized = `_${normalized}`;
+  }
+
+  return normalized;
+}

package/src/types.ts

@@ -1,64 +1,9 @@
-import type { ColumnDefault } from '@prisma-next/contract/types';
-import type { DefaultMappingOptions } from './default-mapping';
-
 /**
- * Result of resolving a native database type to a PSL type.
+ * Internal printer intermediates used by `astDocumentToPrintDocument` →
+ * `serializePrintDocument`. These types are package-private and never
+ * exported through `src/exports/`.
  */
-export type PslNativeTypeAttribute = {
-  readonly name: string;
-  readonly args?: readonly string[];
-};
 
-export 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).
- */
-export interface PslTypeMap {
-  resolve(nativeType: string, annotations?: Record<string, unknown>): PslTypeResolution;
-}
-
-/**
- * Pre-extracted enum information from target-specific annotations.
- */
-export interface EnumInfo {
-  readonly typeNames: ReadonlySet<string>;
-  readonly definitions: ReadonlyMap<string, readonly string[]>;
-}
-
-/**
- * Options for the PSL printer.
- */
-export 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 | undefined;
-}
-
-/**
- * Normalized column default, accepted by the printer.
- * Re-exported for convenience.
- */
-export type { ColumnDefault };
-
-/**
- * A processed field ready for serialization.
- */
 export type PrinterField = {
   readonly name: string;
   readonly typeName: string;
@@ -72,9 +17,6 @@ export type PrinterField = {
   readonly comment?: string | undefined;
 };
 
-/**
- * A processed model ready for serialization.
- */
 export type PrinterModel = {
   readonly name: string;
   readonly mapName?: string | undefined;
@@ -84,36 +26,25 @@ export type PrinterModel = {
 };
 
 /**
- * A processed enum ready for serialization.
+ * A printer-internal enum value. `name` is the original storage label as it
+ * appeared in the AST or in the producer's input; `serializeEnum` normalises
+ * it for emission and emits a per-member `@map(...)` when normalisation
+ * changed the printed form (or when the AST already carried an explicit
+ * `mapName`), preserving the round-trip through the parser.
  */
+export type PrinterEnumValue = {
+  readonly name: string;
+  readonly mapName?: string | undefined;
+};
+
 export type PrinterEnum = {
   readonly name: string;
   readonly mapName?: string | undefined;
-  readonly values: readonly string[];
+  readonly values: readonly PrinterEnumValue[];
 };
 
-/**
- * A named type entry for the types block.
- */
 export type PrinterNamedType = {
   readonly name: string;
   readonly baseType: string;
   readonly attributes: readonly string[];
 };
-
-/**
- * Relation field metadata used during inference.
- */
-export type RelationField = {
-  readonly fieldName: string;
-  readonly typeName: string;
-  readonly referencedTableName?: string | undefined;
-  readonly optional: boolean;
-  readonly list: boolean;
-  readonly relationName?: string | undefined;
-  readonly fkName?: string | undefined;
-  readonly fields?: readonly string[] | undefined;
-  readonly references?: readonly string[] | undefined;
-  readonly onDelete?: string | undefined;
-  readonly onUpdate?: string | undefined;
-};

package/dist/postgres.d.mts

@@ -1,32 +0,0 @@
-import { a as DefaultMappingOptions, r as PslTypeMap, t as EnumInfo } from "./types-BmnVaMF1.mjs";
-import { ColumnDefault } from "@prisma-next/contract/types";
-
-//#region src/postgres-default-mapping.d.ts
-declare function createPostgresDefaultMapping(): DefaultMappingOptions;
-//#endregion
-//#region src/postgres-type-map.d.ts
-/**
- * Creates a Postgres-specific type map for the PSL printer.
- *
- * @param enumTypeNames - Set of native type names that are enums (from annotations.pg.storageTypes)
- */
-declare function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslTypeMap;
-/**
- * Extracts enum type names and definitions from SqlSchemaIR annotations
- * in a single traversal.
- */
-declare function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo;
-/**
- * Extracts enum type names from the SqlSchemaIR annotations.
- */
-declare function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string>;
-/**
- * Extracts enum definitions (name → values) from SqlSchemaIR annotations.
- */
-declare function extractEnumDefinitions(annotations?: Record<string, unknown>): ReadonlyMap<string, readonly string[]>;
-//#endregion
-//#region src/raw-default-parser.d.ts
-declare function parseRawDefault(rawDefault: string, nativeType?: string): ColumnDefault | undefined;
-//#endregion
-export { createPostgresDefaultMapping, createPostgresTypeMap, extractEnumDefinitions, extractEnumInfo, extractEnumTypeNames, parseRawDefault };
-//# sourceMappingURL=postgres.d.mts.map

package/dist/postgres.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres.d.mts","names":[],"sources":["../src/postgres-default-mapping.ts","../src/postgres-type-map.ts","../src/raw-default-parser.ts"],"sourcesContent":[],"mappings":";;;;iBAUgB,4BAAA,CAAA,GAAgC;;;;;;AAAhD;;iBCkGgB,qBAAA,iBAAsC,sBAAsB;AAA5E;AAyDA;AA2BA;AAOA;iBAlCgB,eAAA,eAA8B,0BAA0B;;;AC1HxE;iBDqJgB,oBAAA,eAAmC,0BAA0B;;;;iBAO7D,sBAAA,eACA,0BACb;;;iBC9Ja,eAAA,2CAGb"}

package/dist/postgres.mjs

@@ -1,346 +0,0 @@
-//#region src/postgres-default-mapping.ts
-const POSTGRES_FUNCTION_ATTRIBUTES = { "gen_random_uuid()": "@default(dbgenerated(\"gen_random_uuid()\"))" };
-function formatDbGeneratedAttribute(expression) {
-	return `@default(dbgenerated(${JSON.stringify(expression)}))`;
-}
-function createPostgresDefaultMapping() {
-	return {
-		functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
-		fallbackFunctionAttribute: formatDbGeneratedAttribute
-	};
-}
-
-//#endregion
-//#region src/postgres-type-map.ts
-/**
-* 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 = {
-	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 = {
-	"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 = {
-	"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, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function getOwnRecordValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function createNativeTypeAttribute(name, args) {
-	return args && args.length > 0 ? {
-		name,
-		args
-	} : { name };
-}
-function splitTypeParameterList(params) {
-	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)
-*/
-function createPostgresTypeMap(enumTypeNames) {
-	return { resolve(nativeType) {
-		if (enumTypeNames?.has(nativeType)) return {
-			pslType: 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) return {
-				pslType: template.pslType,
-				nativeType,
-				typeParams: {
-					baseType,
-					params
-				},
-				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
-			};
-		}
-		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
-		if (preservedType) return {
-			pslType: preservedType.pslType,
-			nativeType,
-			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
-		};
-		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
-		if (pslType) return {
-			pslType,
-			nativeType
-		};
-		return {
-			unsupported: true,
-			nativeType
-		};
-	} };
-}
-/**
-* Extracts enum type names and definitions from SqlSchemaIR annotations
-* in a single traversal.
-*/
-function extractEnumInfo(annotations) {
-	const storageTypes = (annotations?.["pg"])?.["storageTypes"];
-	const typeNames = /* @__PURE__ */ new Set();
-	const definitions = /* @__PURE__ */ new Map();
-	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);
-		}
-	}
-	return {
-		typeNames,
-		definitions
-	};
-}
-/**
-* Extracts enum type names from the SqlSchemaIR annotations.
-*/
-function extractEnumTypeNames(annotations) {
-	return extractEnumInfo(annotations).typeNames;
-}
-/**
-* Extracts enum definitions (name → values) from SqlSchemaIR annotations.
-*/
-function extractEnumDefinitions(annotations) {
-	return extractEnumInfo(annotations).definitions;
-}
-
-//#endregion
-//#region src/raw-default-parser.ts
-/**
-* Parses a raw database default expression into a normalized ColumnDefault.
-* When nativeType is provided, parsing can preserve Postgres semantics for
-* timestamp and JSON defaults that would otherwise be ambiguous.
-*/
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const JSON_CAST_SUFFIX = /::jsonb?$/i;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-function canonicalizeTimestampDefault(expr) {
-	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
-	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
-	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
-	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
-	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
-	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
-	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
-}
-function parseRawDefault(rawDefault, nativeType) {
-	const trimmed = rawDefault.trim();
-	const normalizedType = nativeType?.toLowerCase();
-	if (NEXTVAL_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-	if (canonicalTimestamp) return {
-		kind: "function",
-		expression: canonicalTimestamp
-	};
-	if (UUID_PATTERN.test(trimmed) || UUID_OSSP_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (NULL_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: null
-	};
-	if (TRUE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: true
-	};
-	if (FALSE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: false
-	};
-	if (NUMERIC_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: Number(trimmed)
-	};
-	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-	if (stringMatch?.[1] !== void 0) {
-		const unescaped = stringMatch[1].replace(/''/g, "'");
-		if (normalizedType === "json" || normalizedType === "jsonb") {
-			if (JSON_CAST_SUFFIX.test(trimmed)) return {
-				kind: "function",
-				expression: trimmed
-			};
-			try {
-				return {
-					kind: "literal",
-					value: JSON.parse(unescaped)
-				};
-			} catch {}
-		}
-		return {
-			kind: "literal",
-			value: unescaped
-		};
-	}
-	return {
-		kind: "function",
-		expression: trimmed
-	};
-}
-
-//#endregion
-export { createPostgresDefaultMapping, createPostgresTypeMap, extractEnumDefinitions, extractEnumInfo, extractEnumTypeNames, parseRawDefault };
-//# sourceMappingURL=postgres.mjs.map