@prisma-next/family-sql 0.5.0-dev.26 → 0.5.0-dev.28

package/src/core/control-instance.ts

@@ -9,7 +9,11 @@ import type {
   ControlFamilyInstance,
   ControlStack,
   CoreSchemaView,
+  MigrationPlanOperation,
   OperationContext,
+  OperationPreview,
+  OperationPreviewCapable,
+  PslContractInferCapable,
   SchemaViewCapable,
   SignDatabaseResult,
   VerifyDatabaseResult,
@@ -22,6 +26,7 @@ import {
   VERIFY_CODE_TARGET_MISMATCH,
 } from '@prisma-next/framework-components/control';
 import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
+import type { PslDocumentAst } from '@prisma-next/framework-components/psl-ast';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import { validateContract as sqlValidateContract } from '@prisma-next/sql-contract/validate';
 import {
@@ -37,6 +42,8 @@ import type {
   SqlControlAdapterDescriptor,
   SqlControlExtensionDescriptor,
 } from './migrations/types';
+import { sqlOperationsToPreview } from './operation-preview';
+import { sqlSchemaIrToPslAst } from './psl-contract-infer/sql-schema-ir-to-psl-ast';
 import { verifySqlSchema } from './schema-verify/verify-sql-schema';
 import { collectSupportedCodecTypeIds } from './verify';
 
@@ -182,6 +189,8 @@ export interface SchemaVerifyOptions {
 export interface SqlControlFamilyInstance
   extends ControlFamilyInstance<'sql', SqlSchemaIR>,
     SchemaViewCapable<SqlSchemaIR>,
+    PslContractInferCapable<SqlSchemaIR>,
+    OperationPreviewCapable,
     SqlFamilyInstanceState {
   validateContract(contractJson: unknown): Contract;
 
@@ -206,6 +215,10 @@ export interface SqlControlFamilyInstance
     readonly driver: ControlDriverInstance<'sql', string>;
     readonly contract?: unknown;
   }): Promise<SqlSchemaIR>;
+
+  inferPslContract(schemaIR: SqlSchemaIR): PslDocumentAst;
+
+  toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;
 }
 
 export type SqlFamilyInstance = SqlControlFamilyInstance;
@@ -573,6 +586,14 @@ export function createSqlFamilyInstance<TTargetId extends string>(
       return getControlAdapter().introspect(options.driver, options.contract);
     },
 
+    inferPslContract(schemaIR: SqlSchemaIR): PslDocumentAst {
+      return sqlSchemaIrToPslAst(schemaIR);
+    },
+
+    toOperationPreview(operations: readonly MigrationPlanOperation[]): OperationPreview {
+      return sqlOperationsToPreview(operations);
+    },
+
     toSchemaView(schema: SqlSchemaIR): CoreSchemaView {
       const tableNodes: readonly SchemaTreeNode[] = Object.entries(schema.tables).map(
         ([tableName, table]: [string, SqlTableIR]) => {

package/src/core/operation-preview.ts

@@ -0,0 +1,62 @@
+import type {
+  MigrationPlanOperation,
+  OperationPreview,
+} from '@prisma-next/framework-components/control';
+
+/**
+ * Shape of an SQL execute step on `SqlMigrationPlanOperation`. Used for runtime
+ * type narrowing without importing the concrete SQL type.
+ */
+interface SqlExecuteStep {
+  readonly sql: string;
+}
+
+function isDdlStatement(sqlStatement: string): boolean {
+  const trimmed = sqlStatement.trim().toLowerCase();
+  return (
+    trimmed.startsWith('create ') || trimmed.startsWith('alter ') || trimmed.startsWith('drop ')
+  );
+}
+
+function hasExecuteSteps(
+  operation: MigrationPlanOperation,
+): operation is MigrationPlanOperation & { readonly execute: readonly SqlExecuteStep[] } {
+  const candidate = operation as unknown as Record<string, unknown>;
+  if (!('execute' in candidate) || !Array.isArray(candidate['execute'])) {
+    return false;
+  }
+  return candidate['execute'].every(
+    (step: unknown) => typeof step === 'object' && step !== null && 'sql' in step,
+  );
+}
+
+/**
+ * Extracts a best-effort SQL DDL preview for CLI plan output.
+ * Presentation-only: never used to decide migration correctness.
+ */
+export function extractSqlDdl(operations: readonly MigrationPlanOperation[]): string[] {
+  const statements: string[] = [];
+  for (const operation of operations) {
+    if (!hasExecuteSteps(operation)) {
+      continue;
+    }
+    for (const step of operation.execute) {
+      if (typeof step.sql === 'string' && isDdlStatement(step.sql)) {
+        statements.push(step.sql.trim());
+      }
+    }
+  }
+  return statements;
+}
+
+/**
+ * Wraps `extractSqlDdl` into the family-agnostic `OperationPreview` shape.
+ * Each statement carries `language: 'sql'`.
+ */
+export function sqlOperationsToPreview(
+  operations: readonly MigrationPlanOperation[],
+): OperationPreview {
+  return {
+    statements: extractSqlDdl(operations).map((text) => ({ text, language: 'sql' })),
+  };
+}

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

@@ -0,0 +1,56 @@
+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;
+}
+
+export type DefaultMappingResult = { readonly attribute: string } | { readonly comment: string };
+
+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, ' ')}` };
+    }
+  }
+}
+
+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/core/psl-contract-infer/name-transforms.ts

@@ -0,0 +1,178 @@
+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;
+};
+
+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);
+}
+
+function snakeToPascalCase(input: string): string {
+  const parts = extractIdentifierParts(input);
+  if (parts.length === 0) {
+    return capitalize(sanitizeIdentifierCharacters(input));
+  }
+  return parts.map(capitalize).join('');
+}
+
+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('');
+}
+
+function needsEscaping(name: string): boolean {
+  return PSL_RESERVED_WORDS.has(name.toLowerCase()) || /^\d/.test(name);
+}
+
+function escapeName(name: string): string {
+  return `_${name}`;
+}
+
+function escapeIfNeeded(name: string): string {
+  return needsEscaping(name) ? escapeName(name) : name;
+}
+
+export function toModelName(tableName: string): NameResult {
+  let name: string;
+
+  if (hasSeparators(tableName)) {
+    name = snakeToPascalCase(tableName);
+  } else {
+    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 };
+}
+
+export function toFieldName(columnName: string): NameResult {
+  let name: string;
+
+  if (hasSeparators(columnName)) {
+    name = snakeToCamelCase(columnName);
+  } else {
+    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 };
+}
+
+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 };
+}
+
+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`;
+}
+
+export function deriveRelationFieldName(
+  fkColumns: readonly string[],
+  referencedTableName: string,
+): string {
+  if (fkColumns.length === 1) {
+    const [col = referencedTableName] = fkColumns;
+    const stripped = col.replace(/_id$/i, '').replace(/Id$/, '');
+
+    if (stripped.length > 0 && stripped !== col) {
+      return escapeIfNeeded(snakeToCamelCase(stripped));
+    }
+    return escapeIfNeeded(snakeToCamelCase(referencedTableName));
+  }
+
+  return escapeIfNeeded(snakeToCamelCase(referencedTableName));
+}
+
+export function deriveBackRelationFieldName(childModelName: string, isOneToOne: boolean): string {
+  const base = childModelName.charAt(0).toLowerCase() + childModelName.slice(1);
+  return isOneToOne ? base : pluralize(base);
+}
+
+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/core/psl-contract-infer/postgres-default-mapping.ts

@@ -0,0 +1,16 @@
+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/core/psl-contract-infer/postgres-type-map.ts

@@ -0,0 +1,165 @@
+import type {
+  EnumInfo,
+  PslNativeTypeAttribute,
+  PslTypeMap,
+  PslTypeResolution,
+} from './printer-config';
+
+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',
+};
+
+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' },
+};
+
+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_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
+
+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);
+}
+
+export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslTypeMap {
+  return {
+    resolve(nativeType: string): PslTypeResolution {
+      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 };
+    },
+  };
+}
+
+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 };
+}
+
+export function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string> {
+  return extractEnumInfo(annotations).typeNames;
+}
+
+export function extractEnumDefinitions(
+  annotations?: Record<string, unknown>,
+): ReadonlyMap<string, readonly string[]> {
+  return extractEnumInfo(annotations).definitions;
+}

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

@@ -0,0 +1,55 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+import type { DefaultMappingOptions } from './default-mapping';
+
+/**
+ * Internal printer-shaped configuration, used by the SQL family's
+ * `sqlSchemaIrToPslAst` helper (M2). The framework-level psl-printer no longer
+ * exposes these — they're consumed only inside the SQL family.
+ */
+
+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;
+    };
+
+export interface PslTypeMap {
+  resolve(nativeType: string, annotations?: Record<string, unknown>): PslTypeResolution;
+}
+
+export interface EnumInfo {
+  readonly typeNames: ReadonlySet<string>;
+  readonly definitions: ReadonlyMap<string, readonly string[]>;
+}
+
+export interface PslPrinterOptions {
+  readonly typeMap: PslTypeMap;
+  readonly defaultMapping?: DefaultMappingOptions;
+  readonly enumInfo?: EnumInfo;
+  readonly parseRawDefault?: (rawDefault: string, nativeType?: string) => ColumnDefault | undefined;
+}
+
+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/src/core/psl-contract-infer/raw-default-parser.ts

@@ -0,0 +1,91 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+
+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: string): string | undefined {
+  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';
+  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';
+
+  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;
+
+  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()';
+
+  return undefined;
+}
+
+export function parseRawDefault(
+  rawDefault: string,
+  nativeType?: string,
+): ColumnDefault | undefined {
+  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] !== undefined) {
+    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 {
+        // Fall through to the string form for malformed/non-JSON values.
+      }
+    }
+    return { kind: 'literal', value: unescaped };
+  }
+
+  return { kind: 'function', expression: trimmed };
+}