@dotdo/postgres 0.1.0

package/src/migrations/schema-generator.ts

@@ -0,0 +1,513 @@
+/**
+ * Schema Generator
+ *
+ * Utilities for generating type-safe schema definitions from
+ * migration history or database introspection.
+ *
+ * @module migrations/schema-generator
+ */
+
+import type { QueryExecutor } from './types'
+
+/**
+ * Column definition from database introspection
+ */
+export interface ColumnDefinition {
+  name: string
+  dataType: string
+  isNullable: boolean
+  hasDefault: boolean
+  defaultValue?: string
+  isPrimaryKey: boolean
+  isUnique: boolean
+  maxLength?: number
+  references?: {
+    table: string
+    column: string
+  }
+}
+
+/**
+ * Index definition from database introspection
+ */
+export interface IndexDefinition {
+  name: string
+  columns: string[]
+  isUnique: boolean
+  isPrimary: boolean
+  indexType?: string
+}
+
+/**
+ * Table definition from database introspection
+ */
+export interface TableDefinition {
+  name: string
+  schema: string
+  columns: ColumnDefinition[]
+  primaryKey?: string[]
+  indexes: IndexDefinition[]
+  foreignKeys: Array<{
+    column: string
+    referencesTable: string
+    referencesColumn: string
+    onDelete?: string
+    onUpdate?: string
+  }>
+}
+
+/**
+ * Database schema from introspection
+ */
+export interface DatabaseSchema {
+  tables: TableDefinition[]
+  enums: Array<{
+    name: string
+    values: string[]
+  }>
+  introspectedAt: Date
+}
+
+/**
+ * Type mapping from PostgreSQL to TypeScript
+ */
+const PG_TO_TS_TYPE_MAP: Record<string, string> = {
+  // Numeric types
+  smallint: 'number',
+  integer: 'number',
+  bigint: 'bigint',
+  decimal: 'string', // Decimal precision preserved as string
+  numeric: 'string',
+  real: 'number',
+  'double precision': 'number',
+  serial: 'number',
+  bigserial: 'bigint',
+  smallserial: 'number',
+
+  // Character types
+  'character varying': 'string',
+  varchar: 'string',
+  character: 'string',
+  char: 'string',
+  text: 'string',
+
+  // Binary types
+  bytea: 'Uint8Array',
+
+  // Boolean
+  boolean: 'boolean',
+
+  // Date/time types
+  date: 'Date',
+  timestamp: 'Date',
+  'timestamp with time zone': 'Date',
+  'timestamp without time zone': 'Date',
+  time: 'string',
+  'time with time zone': 'string',
+  'time without time zone': 'string',
+  interval: 'string',
+
+  // JSON types
+  json: 'unknown',
+  jsonb: 'unknown',
+
+  // UUID
+  uuid: 'string',
+
+  // Network types
+  inet: 'string',
+  cidr: 'string',
+  macaddr: 'string',
+
+  // Array types (simplified)
+  'integer[]': 'number[]',
+  'text[]': 'string[]',
+  'varchar[]': 'string[]',
+  'jsonb[]': 'unknown[]',
+}
+
+/**
+ * Convert PostgreSQL type to TypeScript type
+ */
+export function pgTypeToTs(pgType: string): string {
+  const normalizedType = pgType.toLowerCase().replace(/\s+/g, ' ')
+
+  // Check for exact match
+  if (PG_TO_TS_TYPE_MAP[normalizedType]) {
+    return PG_TO_TS_TYPE_MAP[normalizedType]
+  }
+
+  // Check for array type
+  if (normalizedType.endsWith('[]')) {
+    const baseType = normalizedType.slice(0, -2)
+    const tsBaseType = PG_TO_TS_TYPE_MAP[baseType] || 'unknown'
+    return `${tsBaseType}[]`
+  }
+
+  // Check for character varying with length
+  if (normalizedType.startsWith('character varying') || normalizedType.startsWith('varchar')) {
+    return 'string'
+  }
+
+  // Check for numeric with precision
+  if (normalizedType.startsWith('numeric') || normalizedType.startsWith('decimal')) {
+    return 'string'
+  }
+
+  // Default to unknown
+  return 'unknown'
+}
+
+/**
+ * Introspect database schema
+ *
+ * Queries the database to get the current schema definition.
+ *
+ * @example
+ * ```typescript
+ * const schema = await introspectSchema(pglite, { schema: 'public' })
+ * console.log(schema.tables)
+ * ```
+ */
+export async function introspectSchema(
+  executor: QueryExecutor,
+  options: { schema?: string } = {}
+): Promise<DatabaseSchema> {
+  const schema = options.schema ?? 'public'
+
+  // Query tables
+  const tablesResult = await executor.query<{
+    table_name: string
+    table_schema: string
+  }>(
+    `SELECT table_name, table_schema
+     FROM information_schema.tables
+     WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+     ORDER BY table_name`,
+    [schema]
+  )
+
+  // Query enums
+  const enumsResult = await executor.query<{
+    enum_name: string
+    enum_value: string
+  }>(
+    `SELECT t.typname as enum_name, e.enumlabel as enum_value
+     FROM pg_type t
+     JOIN pg_enum e ON t.oid = e.enumtypid
+     JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+     WHERE n.nspname = $1
+     ORDER BY t.typname, e.enumsortorder`,
+    [schema]
+  )
+
+  // Group enum values
+  const enumsMap = new Map<string, string[]>()
+  for (const row of enumsResult.rows) {
+    if (!enumsMap.has(row.enum_name)) {
+      enumsMap.set(row.enum_name, [])
+    }
+    enumsMap.get(row.enum_name)!.push(row.enum_value)
+  }
+
+  const enums = Array.from(enumsMap.entries()).map(([name, values]) => ({
+    name,
+    values,
+  }))
+
+  // Introspect each table
+  const tables: TableDefinition[] = []
+
+  for (const table of tablesResult.rows) {
+    const tableDefinition = await introspectTable(executor, table.table_name, schema)
+    tables.push(tableDefinition)
+  }
+
+  return {
+    tables,
+    enums,
+    introspectedAt: new Date(),
+  }
+}
+
+/**
+ * Introspect a single table
+ */
+async function introspectTable(
+  executor: QueryExecutor,
+  tableName: string,
+  schema: string
+): Promise<TableDefinition> {
+  // Query columns
+  const columnsResult = await executor.query<{
+    column_name: string
+    data_type: string
+    is_nullable: string
+    column_default: string | null
+    character_maximum_length: number | null
+  }>(
+    `SELECT column_name, data_type, is_nullable, column_default, character_maximum_length
+     FROM information_schema.columns
+     WHERE table_schema = $1 AND table_name = $2
+     ORDER BY ordinal_position`,
+    [schema, tableName]
+  )
+
+  // Query primary key
+  const pkResult = await executor.query<{ column_name: string }>(
+    `SELECT a.attname as column_name
+     FROM pg_index i
+     JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+     WHERE i.indrelid = ($1 || '.' || $2)::regclass
+       AND i.indisprimary`,
+    [schema, tableName]
+  )
+
+  const primaryKeyColumns = pkResult.rows.map((r) => r.column_name)
+
+  // Query foreign keys
+  const fkResult = await executor.query<{
+    column_name: string
+    foreign_table_name: string
+    foreign_column_name: string
+    on_delete: string
+    on_update: string
+  }>(
+    `SELECT
+       kcu.column_name,
+       ccu.table_name AS foreign_table_name,
+       ccu.column_name AS foreign_column_name,
+       rc.delete_rule AS on_delete,
+       rc.update_rule AS on_update
+     FROM information_schema.key_column_usage kcu
+     JOIN information_schema.referential_constraints rc
+       ON kcu.constraint_name = rc.constraint_name
+     JOIN information_schema.constraint_column_usage ccu
+       ON rc.unique_constraint_name = ccu.constraint_name
+     WHERE kcu.table_schema = $1 AND kcu.table_name = $2`,
+    [schema, tableName]
+  )
+
+  const foreignKeyMap = new Map<string, typeof fkResult.rows[0]>()
+  for (const fk of fkResult.rows) {
+    foreignKeyMap.set(fk.column_name, fk)
+  }
+
+  // Query unique constraints
+  const uniqueResult = await executor.query<{ column_name: string }>(
+    `SELECT a.attname as column_name
+     FROM pg_index i
+     JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+     WHERE i.indrelid = ($1 || '.' || $2)::regclass
+       AND i.indisunique AND NOT i.indisprimary`,
+    [schema, tableName]
+  )
+
+  const uniqueColumns = new Set(uniqueResult.rows.map((r) => r.column_name))
+
+  // Query indexes
+  const indexesResult = await executor.query<{
+    index_name: string
+    column_name: string
+    is_unique: boolean
+    is_primary: boolean
+    index_type: string
+  }>(
+    `SELECT
+       i.relname as index_name,
+       a.attname as column_name,
+       ix.indisunique as is_unique,
+       ix.indisprimary as is_primary,
+       am.amname as index_type
+     FROM pg_index ix
+     JOIN pg_class i ON i.oid = ix.indexrelid
+     JOIN pg_class t ON t.oid = ix.indrelid
+     JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+     JOIN pg_am am ON am.oid = i.relam
+     JOIN pg_namespace n ON n.oid = t.relnamespace
+     WHERE n.nspname = $1 AND t.relname = $2`,
+    [schema, tableName]
+  )
+
+  // Group indexes by name
+  const indexesMap = new Map<string, IndexDefinition>()
+  for (const row of indexesResult.rows) {
+    if (!indexesMap.has(row.index_name)) {
+      indexesMap.set(row.index_name, {
+        name: row.index_name,
+        columns: [],
+        isUnique: row.is_unique,
+        isPrimary: row.is_primary,
+        indexType: row.index_type,
+      })
+    }
+    indexesMap.get(row.index_name)!.columns.push(row.column_name)
+  }
+
+  // Build column definitions
+  const columns: ColumnDefinition[] = columnsResult.rows.map((col): ColumnDefinition => {
+    const fk = foreignKeyMap.get(col.column_name)
+
+    const colDef: ColumnDefinition = {
+      name: col.column_name,
+      dataType: col.data_type,
+      isNullable: col.is_nullable === 'YES',
+      hasDefault: col.column_default !== null,
+      isPrimaryKey: primaryKeyColumns.includes(col.column_name),
+      isUnique: uniqueColumns.has(col.column_name),
+    }
+
+    if (col.column_default !== null) {
+      colDef.defaultValue = col.column_default
+    }
+
+    if (col.character_maximum_length !== null) {
+      colDef.maxLength = col.character_maximum_length
+    }
+
+    if (fk) {
+      colDef.references = {
+        table: fk.foreign_table_name,
+        column: fk.foreign_column_name,
+      }
+    }
+
+    return colDef
+  })
+
+  const tableDef: TableDefinition = {
+    name: tableName,
+    schema,
+    columns,
+    indexes: Array.from(indexesMap.values()),
+    foreignKeys: fkResult.rows.map((fk) => ({
+      column: fk.column_name,
+      referencesTable: fk.foreign_table_name,
+      referencesColumn: fk.foreign_column_name,
+      onDelete: fk.on_delete,
+      onUpdate: fk.on_update,
+    })),
+  }
+
+  if (primaryKeyColumns.length > 0) {
+    tableDef.primaryKey = primaryKeyColumns
+  }
+
+  return tableDef
+}
+
+/**
+ * Generate TypeScript interface from table definition
+ *
+ * @example
+ * ```typescript
+ * const code = generateTableInterface(tableDefinition)
+ * // interface Users {
+ * //   id: number;
+ * //   email: string;
+ * //   created_at: Date | null;
+ * // }
+ * ```
+ */
+export function generateTableInterface(table: TableDefinition): string {
+  const interfaceName = toPascalCase(table.name)
+  const lines: string[] = []
+
+  lines.push(`export interface ${interfaceName} {`)
+
+  for (const col of table.columns) {
+    const tsType = pgTypeToTs(col.dataType)
+    const nullable = col.isNullable ? ' | null' : ''
+    const comment = col.isPrimaryKey
+      ? ' // Primary Key'
+      : col.references
+        ? ` // FK -> ${col.references.table}.${col.references.column}`
+        : ''
+
+    lines.push(`  ${col.name}: ${tsType}${nullable};${comment}`)
+  }
+
+  lines.push('}')
+
+  return lines.join('\n')
+}
+
+/**
+ * Generate TypeScript interfaces for an entire schema
+ *
+ * @example
+ * ```typescript
+ * const code = await generateSchemaTypes(pglite)
+ * writeFileSync('schema.ts', code)
+ * ```
+ */
+export async function generateSchemaTypes(
+  executor: QueryExecutor,
+  options: {
+    schema?: string
+    includeEnums?: boolean
+    includeInsertTypes?: boolean
+  } = {}
+): Promise<string> {
+  const { schema = 'public', includeEnums = true, includeInsertTypes = true } = options
+
+  const dbSchema = await introspectSchema(executor, { schema })
+  const lines: string[] = []
+
+  lines.push('/**')
+  lines.push(' * Auto-generated TypeScript types from database schema')
+  lines.push(` * Generated at: ${dbSchema.introspectedAt.toISOString()}`)
+  lines.push(' */')
+  lines.push('')
+
+  // Generate enums
+  if (includeEnums && dbSchema.enums.length > 0) {
+    lines.push('// Enums')
+    for (const enumDef of dbSchema.enums) {
+      const enumName = toPascalCase(enumDef.name)
+      lines.push(`export type ${enumName} = ${enumDef.values.map((v) => `'${v}'`).join(' | ')};`)
+    }
+    lines.push('')
+  }
+
+  // Generate table interfaces
+  lines.push('// Tables')
+  for (const table of dbSchema.tables) {
+    // Skip system tables
+    if (table.name.startsWith('_')) {
+      continue
+    }
+
+    lines.push(generateTableInterface(table))
+    lines.push('')
+
+    // Generate insert type (with optional fields for defaults)
+    if (includeInsertTypes) {
+      const insertName = `New${toPascalCase(table.name)}`
+      lines.push(`export interface ${insertName} {`)
+
+      for (const col of table.columns) {
+        const tsType = pgTypeToTs(col.dataType)
+        const nullable = col.isNullable ? ' | null' : ''
+        const optional = col.hasDefault || col.isNullable ? '?' : ''
+
+        lines.push(`  ${col.name}${optional}: ${tsType}${nullable};`)
+      }
+
+      lines.push('}')
+      lines.push('')
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Convert snake_case to PascalCase
+ */
+function toPascalCase(str: string): string {
+  return str
+    .split('_')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('')
+}