@dockstat/sqlite-wrapper 1.2.7 → 1.3.0

package/index.ts

@@ -1,52 +1,49 @@
-import { Database, type SQLQueryBindings } from 'bun:sqlite'
-import { createLogger } from '@dockstat/logger'
-import { QueryBuilder } from './query-builder/index'
-import type {
-  ColumnConstraints,
-  ColumnDefinition,
-  DefaultExpression,
-  ForeignKeyAction,
-  JsonColumnConfig,
-  SQLiteType,
-  TableConstraints,
-  TableOptions,
-  TableSchema,
-} from './types'
+import { Database, type SQLQueryBindings } from "bun:sqlite"
+import { QueryBuilder } from "./query-builder/index"
+import type { ColumnDefinition, Parser, TableConstraints, TableOptions, TableSchema } from "./types"
+import { addLoggerParents as addParents, createLogger, logger as sqliteLogger } from "./utils"
 
-const logger = createLogger('sqlite-wrapper')
+// Re-export logger utilities for external use
+export const logger = sqliteLogger
+export const addLoggerParents = addParents
+
+// Internal loggers for different components
+const dbLog = createLogger("db")
+const backupLog = createLogger("backup")
+const tableLog = createLogger("table")
 
 /**
  * Re-export all types and utilities
  */
 export { QueryBuilder }
 export type {
-  InsertResult,
-  UpdateResult,
+  ArrayKey,
+  ColumnConstraints,
+  ColumnDefinition,
+  ColumnNames,
+  DefaultExpression,
   DeleteResult,
+  ForeignKeyAction,
   InsertOptions,
-  ColumnNames,
-  WhereCondition,
+  InsertResult,
   RegexCondition,
-  JsonColumnConfig,
-  TableSchema,
-  ColumnDefinition,
   SQLiteType,
-  ColumnConstraints,
-  TableOptions,
-  DefaultExpression,
-  ForeignKeyAction,
   TableConstraints,
-} from './types'
+  TableOptions,
+  TableSchema,
+  UpdateResult,
+  WhereCondition,
+} from "./types"
 
 // Re-export helper utilities
 export {
   column,
-  sql,
-  SQLiteTypes,
+  defaultExpr,
   SQLiteFunctions,
   SQLiteKeywords,
-  defaultExpr,
-} from './types'
+  SQLiteTypes,
+  sql,
+} from "./types"
 
 /**
  * TypedSQLite — comprehensive wrapper around bun:sqlite `Database`.
@@ -60,8 +57,41 @@ export {
  * - JSON column support
  * - And much more...
  */
+/**
+ * Auto-backup configuration options
+ */
+export interface AutoBackupOptions {
+  /** Enable automatic backups */
+  enabled: boolean
+  /** Directory to store backup files */
+  directory: string
+  /** Backup interval in milliseconds (default: 1 hour) */
+  intervalMs?: number
+  /** Maximum number of backups to retain (default: 10) */
+  maxBackups?: number
+  /** Prefix for backup filenames (default: 'backup') */
+  filenamePrefix?: string
+  /** Whether to compress backups using gzip (default: false) */
+  compress?: boolean
+}
+
+/**
+ * Database configuration options
+ */
+export interface DBOptions {
+  /** PRAGMA settings to apply on database open */
+  pragmas?: Array<[string, SQLQueryBindings]>
+  /** Paths to SQLite extensions to load */
+  loadExtensions?: string[]
+  /** Auto-backup configuration */
+  autoBackup?: AutoBackupOptions
+}
+
 class DB {
-  private db: Database
+  protected db: Database
+  protected dbPath: string
+  private autoBackupTimer: ReturnType<typeof setInterval> | null = null
+  private autoBackupOptions: AutoBackupOptions | null = null
 
   /**
    * Open or create a SQLite database at `path`.
@@ -69,14 +99,9 @@ class DB {
    * @param path - Path to the SQLite file (e.g. "app.db"). Use ":memory:" for in-memory DB.
    * @param options - Optional database configuration
    */
-  constructor(
-    path: string,
-    options?: {
-      pragmas?: Array<[string, SQLQueryBindings]>
-      loadExtensions?: string[]
-    }
-  ) {
-    logger.info(`Opening database: ${path}`)
+  constructor(path: string, options?: DBOptions) {
+    dbLog.connection(path, "open")
+    this.dbPath = path
     this.db = new Database(path)
 
     // Apply PRAGMA settings if provided
@@ -92,6 +117,231 @@ class DB {
         this.loadExtension(extensionPath)
       }
     }
+
+    // Setup auto-backup if configured
+    if (options?.autoBackup?.enabled) {
+      this.setupAutoBackup(options.autoBackup)
+    }
+  }
+
+  /**
+   * Setup automatic backup with retention policy
+   */
+  private setupAutoBackup(options: AutoBackupOptions): void {
+    if (this.dbPath === ":memory:") {
+      backupLog.warn("Auto-backup is not available for in-memory databases")
+      return
+    }
+
+    this.autoBackupOptions = {
+      enabled: options.enabled,
+      directory: options.directory,
+      intervalMs: options.intervalMs ?? 60 * 60 * 1000, // Default: 1 hour
+      maxBackups: options.maxBackups ?? 10,
+      filenamePrefix: options.filenamePrefix ?? "backup",
+      compress: options.compress ?? false,
+    }
+
+    // Ensure backup directory exists
+    const fs = require("node:fs")
+    if (!fs.existsSync(this.autoBackupOptions.directory)) {
+      fs.mkdirSync(this.autoBackupOptions.directory, { recursive: true })
+      backupLog.info(`Created backup directory: ${this.autoBackupOptions.directory}`)
+    }
+
+    // Create initial backup
+    this.backup()
+
+    // Setup interval for periodic backups
+    this.autoBackupTimer = setInterval(() => {
+      this.backup()
+    }, this.autoBackupOptions.intervalMs)
+
+    backupLog.info(
+      `Auto-backup enabled: interval=${this.autoBackupOptions.intervalMs}ms, maxBackups=${this.autoBackupOptions.maxBackups}`
+    )
+  }
+
+  /**
+   * Create a backup of the database
+   *
+   * @param customPath - Optional custom path for the backup file. If not provided, uses auto-backup settings or generates a timestamped filename.
+   * @returns The path to the created backup file
+   */
+  backup(customPath?: string): string {
+    if (this.dbPath === ":memory:") {
+      throw new Error("Cannot backup an in-memory database")
+    }
+
+    const path = require("node:path")
+
+    let backupPath: string
+
+    if (customPath) {
+      backupPath = customPath
+    } else if (this.autoBackupOptions) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+      const filename = `${this.autoBackupOptions.filenamePrefix}_${timestamp}.db`
+      backupPath = path.join(this.autoBackupOptions.directory, filename)
+    } else {
+      // Generate a default backup path next to the database file
+      const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+      const dir = path.dirname(this.dbPath)
+      const basename = path.basename(this.dbPath, path.extname(this.dbPath))
+      backupPath = path.join(dir, `${basename}_backup_${timestamp}.db`)
+    }
+
+    // Use SQLite's backup API via VACUUM INTO for a consistent backup
+    try {
+      this.db.run(`VACUUM INTO '${backupPath.replace(/'/g, "''")}'`)
+      backupLog.backup("create", backupPath)
+
+      // Apply retention policy if auto-backup is enabled
+      if (this.autoBackupOptions) {
+        this.applyRetentionPolicy()
+      }
+
+      return backupPath
+    } catch (error) {
+      backupLog.error(`Failed to create backup: ${error}`)
+      throw error
+    }
+  }
+
+  /**
+   * Apply retention policy to remove old backups
+   */
+  private applyRetentionPolicy(): void {
+    if (!this.autoBackupOptions) return
+
+    const fs = require("node:fs")
+    const path = require("node:path")
+
+    const backupDir = this.autoBackupOptions.directory
+    const prefix = this.autoBackupOptions.filenamePrefix || "backup"
+    const maxBackups = this.autoBackupOptions.maxBackups || 10
+
+    try {
+      // Get all backup files matching the pattern
+      const files = fs
+        .readdirSync(backupDir)
+        .filter((file: string) => file.startsWith(prefix) && file.endsWith(".db"))
+        .map((file: string) => ({
+          name: file,
+          path: path.join(backupDir, file),
+          mtime: fs.statSync(path.join(backupDir, file)).mtime.getTime(),
+        }))
+        .sort((a: { mtime: number }, b: { mtime: number }) => b.mtime - a.mtime) // Sort by newest first
+
+      // Remove excess backups
+      if (files.length > maxBackups) {
+        const toDelete = files.slice(maxBackups)
+        for (const file of toDelete) {
+          fs.unlinkSync(file.path)
+          backupLog.debug(`Removed old backup: ${file.name}`)
+        }
+        backupLog.info(`Retention policy applied: removed ${toDelete.length} old backup(s)`)
+      }
+    } catch (error) {
+      backupLog.error(`Failed to apply retention policy: ${error}`)
+    }
+  }
+
+  /**
+   * List all available backups
+   *
+   * @returns Array of backup file information
+   */
+  listBackups(): Array<{ filename: string; path: string; size: number; created: Date }> {
+    if (!this.autoBackupOptions) {
+      backupLog.warn("Auto-backup is not configured. Use backup() with a custom path instead.")
+      return []
+    }
+
+    const fs = require("node:fs")
+    const path = require("node:path")
+
+    const backupDir = this.autoBackupOptions.directory
+    const prefix = this.autoBackupOptions.filenamePrefix || "backup"
+
+    try {
+      return fs
+        .readdirSync(backupDir)
+        .filter((file: string) => file.startsWith(prefix) && file.endsWith(".db"))
+        .map((file: string) => {
+          const filePath = path.join(backupDir, file)
+          const stats = fs.statSync(filePath)
+          return {
+            filename: file,
+            path: filePath,
+            size: stats.size,
+            created: stats.mtime,
+          }
+        })
+        .sort(
+          (a: { created: Date }, b: { created: Date }) => b.created.getTime() - a.created.getTime()
+        )
+    } catch (error) {
+      backupLog.error(`Failed to list backups: ${error}`)
+      return []
+    }
+  }
+
+  /**
+   * Restore database from a backup file
+   *
+   * @param backupPath - Path to the backup file to restore from
+   * @param targetPath - Optional target path. If not provided, restores to the original database path.
+   */
+  restore(backupPath: string, targetPath?: string): void {
+    const fs = require("node:fs")
+
+    if (!fs.existsSync(backupPath)) {
+      throw new Error(`Backup file not found: ${backupPath}`)
+    }
+
+    const restorePath = targetPath || this.dbPath
+
+    if (restorePath === ":memory:") {
+      throw new Error("Cannot restore to an in-memory database path")
+    }
+
+    // Close current connection if restoring to the same path
+    if (restorePath === this.dbPath) {
+      this.db.close()
+    }
+
+    try {
+      fs.copyFileSync(backupPath, restorePath)
+      backupLog.backup("restore", backupPath)
+
+      // Reopen database if we closed it
+      if (restorePath === this.dbPath) {
+        this.db = new Database(this.dbPath)
+        dbLog.info("Database connection reopened after restore")
+      }
+    } catch (error) {
+      backupLog.error(`Failed to restore backup: ${error}`)
+      throw error
+    }
+  }
+
+  /**
+   * Stop auto-backup if it's running
+   */
+  stopAutoBackup(): void {
+    if (this.autoBackupTimer) {
+      clearInterval(this.autoBackupTimer)
+      this.autoBackupTimer = null
+      backupLog.info("Auto-backup stopped")
+    }
+  }
+
+  /**
+   * Get the database file path
+   */
+  getPath(): string {
+    return this.dbPath
   }
 
   /**
@@ -100,17 +350,25 @@ class DB {
    */
   table<T extends Record<string, unknown>>(
     tableName: string,
-    jsonConfig?: JsonColumnConfig<T>
+    parser: Partial<Parser<T>>
   ): QueryBuilder<T> {
-    logger.debug(`Creating QueryBuilder for table: ${tableName} - JSONConfig: ${JSON.stringify(jsonConfig)}`)
-    return new QueryBuilder<T>(this.db, tableName, jsonConfig)
+    const pObj: Parser<T> = {
+      JSON: parser.JSON || [],
+      MODULE: parser.MODULE || {},
+      BOOLEAN: parser.BOOLEAN || [],
+    }
+
+    tableLog.debug(`Creating QueryBuilder for: ${tableName}`)
+    return new QueryBuilder<T>(this.db, tableName, pObj)
   }
 
   /**
    * Close the underlying SQLite database handle.
+   * Also stops auto-backup if it's running.
    */
   close(): void {
-    logger.info('Closing database connection')
+    dbLog.connection(this.dbPath, "close")
+    this.stopAutoBackup()
     this.db.close()
   }
 
@@ -207,28 +465,22 @@ class DB {
    *
    * @throws {Error} If column definitions are invalid or constraints conflict.
    */
-  createTable<_T extends Record<string, unknown>>(
+  createTable<_T extends Record<string, unknown> = Record<string, unknown>>(
     tableName: string,
-    columns: string | Record<string, string> | Partial<Record<Extract<keyof _T, string>, ColumnDefinition>> | TableSchema,
-    options?: TableOptions<_T>,
+    columns: Record<keyof _T, ColumnDefinition>,
+    options?: TableOptions<_T>
   ): QueryBuilder<_T> {
-    const temp = options?.temporary ? 'TEMPORARY ' : ''
-    const ifNot = options?.ifNotExists ? 'IF NOT EXISTS ' : ''
-    const withoutRowId = options?.withoutRowId ? ' WITHOUT ROWID' : ''
+    const temp = options?.temporary ? "TEMPORARY " : tableName === ":memory" ? "TEMPORARY " : ""
+    const ifNot = options?.ifNotExists ? "IF NOT EXISTS " : ""
+    const withoutRowId = options?.withoutRowId ? " WITHOUT ROWID" : ""
 
     const quoteIdent = (s: string) => `"${s.replace(/"/g, '""')}"`
 
     let columnDefs: string
     let tableConstraints: string[] = []
 
-    if (typeof columns === 'string') {
-      // Original string-based approach
-      columnDefs = columns.trim()
-      if (!columnDefs) {
-        throw new Error('Empty column definition string')
-      }
-    } else if (this.isTableSchema(columns)) {
-      // New comprehensive type-safe approach
+    if (this.isTableSchema(columns)) {
+      //  comprehensive type-safe approach
       const parts: string[] = []
       for (const [colName, colDef] of Object.entries(columns)) {
         if (!colName) continue
@@ -238,9 +490,10 @@ class DB {
       }
 
       if (parts.length === 0) {
-        throw new Error('No columns provided')
+        throw new Error("No columns provided")
       }
-      columnDefs = parts.join(', ')
+
+      columnDefs = parts.join(", ")
 
       // Add table-level constraints
       if (options?.constraints) {
@@ -249,10 +502,10 @@ class DB {
     } else {
       // Original object-based approach
       const parts: string[] = []
-      for (const [col, def] of Object.entries(columns)) {
+      for (const [col, def] of Object.entries(columns as Record<string, string>)) {
         if (!col) continue
 
-        const defTrim = (def ?? '').trim()
+        const defTrim = (def || "").trim()
         if (!defTrim) {
           throw new Error(`Missing SQL type/constraints for column "${col}"`)
         }
@@ -260,15 +513,19 @@ class DB {
       }
 
       if (parts.length === 0) {
-        throw new Error('No columns provided')
+        throw new Error("No columns provided")
       }
-      columnDefs = parts.join(', ')
+      columnDefs = parts.join(", ")
     }
 
-    // Combine column definitions and table constraints
-    const allDefinitions = [columnDefs, ...tableConstraints].join(', ')
+    const allDefinitions = [columnDefs, ...tableConstraints].join(", ")
 
-    const sql = `CREATE ${temp}TABLE ${ifNot}${quoteIdent(tableName)} (${allDefinitions})${withoutRowId};`
+    const columnNames = Object.keys(columns)
+    tableLog.tableCreate(tableName, columnNames)
+
+    const sql = `CREATE ${temp}TABLE ${ifNot}${quoteIdent(
+      tableName
+    )} (${allDefinitions})${withoutRowId};`
 
     this.db.run(sql)
 
@@ -277,7 +534,39 @@ class DB {
       this.setTableComment(tableName, options.comment)
     }
 
-    return this.table<_T>(tableName, options?.jsonConfig)
+    // Auto-detect JSON and BOOLEAN columns from schema
+    const autoDetectedJson: Array<keyof _T> = []
+    const autoDetectedBoolean: Array<keyof _T> = []
+
+    if (this.isTableSchema(columns)) {
+      for (const [colName, colDef] of Object.entries(columns)) {
+        if (colDef.type === "JSON") {
+          autoDetectedJson.push(colName as keyof _T)
+        }
+        if (colDef.type === "BOOLEAN") {
+          autoDetectedBoolean.push(colName as keyof _T)
+        }
+      }
+    }
+
+    // Merge auto-detected columns with user-provided parser options
+    const userJson = options?.parser?.JSON || []
+    const userBoolean = options?.parser?.BOOLEAN || []
+    const userModule = options?.parser?.MODULE || {}
+
+    // Combine and deduplicate
+    const mergedJson = [...new Set([...autoDetectedJson, ...userJson])] as Array<keyof _T>
+    const mergedBoolean = [...new Set([...autoDetectedBoolean, ...userBoolean])] as Array<keyof _T>
+
+    const pObj = {
+      JSON: mergedJson,
+      MODULE: userModule,
+      BOOLEAN: mergedBoolean,
+    }
+
+    tableLog.parserConfig(pObj.JSON.map(String), pObj.BOOLEAN.map(String), Object.keys(pObj.MODULE))
+
+    return this.table<_T>(tableName, pObj)
   }
 
   /**
@@ -294,15 +583,17 @@ class DB {
       partial?: string
     }
   ): void {
-    const unique = options?.unique ? 'UNIQUE ' : ''
-    const ifNot = options?.ifNotExists ? 'IF NOT EXISTS ' : ''
+    const unique = options?.unique ? "UNIQUE " : ""
+    const ifNot = options?.ifNotExists ? "IF NOT EXISTS " : ""
     const quoteIdent = (s: string) => `"${s.replace(/"/g, '""')}"`
 
     const columnList = Array.isArray(columns)
-      ? columns.map(quoteIdent).join(', ')
+      ? columns.map(quoteIdent).join(", ")
       : quoteIdent(columns)
 
-    let sql = `CREATE ${unique}INDEX ${ifNot}${quoteIdent(indexName)} ON ${quoteIdent(tableName)} (${columnList})`
+    let sql = `CREATE ${unique}INDEX ${ifNot}${quoteIdent(
+      indexName
+    )} ON ${quoteIdent(tableName)} (${columnList})`
 
     if (options?.where) {
       sql += ` WHERE ${options.where}`
@@ -315,7 +606,7 @@ class DB {
    * Drop a table
    */
   dropTable(tableName: string, options?: { ifExists?: boolean }): void {
-    const ifExists = options?.ifExists ? 'IF EXISTS ' : ''
+    const ifExists = options?.ifExists ? "IF EXISTS " : ""
     const quoteIdent = (s: string) => `"${s.replace(/"/g, '""')}"`
 
     const sql = `DROP TABLE ${ifExists}${quoteIdent(tableName)};`
@@ -326,7 +617,7 @@ class DB {
    * Drop an index
    */
   dropIndex(indexName: string, options?: { ifExists?: boolean }): void {
-    const ifExists = options?.ifExists ? 'IF EXISTS ' : ''
+    const ifExists = options?.ifExists ? "IF EXISTS " : ""
     const quoteIdent = (s: string) => `"${s.replace(/"/g, '""')}"`
 
     const sql = `DROP INDEX ${ifExists}${quoteIdent(indexName)};`
@@ -337,40 +628,40 @@ class DB {
    * Type guard to check if columns definition is a TableSchema
    */
   private isTableSchema(columns: unknown): columns is TableSchema {
-    if (typeof columns !== 'object' || columns === null) {
+    if (typeof columns !== "object" || columns === null) {
       return false
     }
 
     // Check if any value has a 'type' property with a valid SQLite type
     for (const [_key, value] of Object.entries(columns)) {
-      if (typeof value === 'object' && value !== null && 'type' in value) {
+      if (typeof value === "object" && value !== null && "type" in value) {
         const type = (value as { type: string }).type
         const validTypes = [
-          'INTEGER',
-          'TEXT',
-          'REAL',
-          'BLOB',
-          'NUMERIC',
-          'INT',
-          'TINYINT',
-          'SMALLINT',
-          'MEDIUMINT',
-          'BIGINT',
-          'VARCHAR',
-          'CHAR',
-          'CHARACTER',
-          'NCHAR',
-          'NVARCHAR',
-          'CLOB',
-          'DOUBLE',
-          'FLOAT',
-          'DECIMAL',
-          'DATE',
-          'DATETIME',
-          'TIMESTAMP',
-          'TIME',
-          'BOOLEAN',
-          'JSON',
+          "INTEGER",
+          "TEXT",
+          "REAL",
+          "BLOB",
+          "NUMERIC",
+          "INT",
+          "TINYINT",
+          "SMALLINT",
+          "MEDIUMINT",
+          "BIGINT",
+          "VARCHAR",
+          "CHAR",
+          "CHARACTER",
+          "NCHAR",
+          "NVARCHAR",
+          "CLOB",
+          "DOUBLE",
+          "FLOAT",
+          "DECIMAL",
+          "DATE",
+          "DATETIME",
+          "TIMESTAMP",
+          "TIME",
+          "BOOLEAN",
+          "JSON",
         ]
         if (validTypes.includes(type)) {
           return true
@@ -402,40 +693,37 @@ class DB {
 
     // Add PRIMARY KEY (must come before AUTOINCREMENT)
     if (colDef.primaryKey) {
-      parts.push('PRIMARY KEY')
+      parts.push("PRIMARY KEY")
     }
 
     // Add AUTOINCREMENT (only valid with INTEGER PRIMARY KEY)
     if (colDef.autoincrement) {
-      if (!colDef.type.includes('INT') || !colDef.primaryKey) {
+      if (!colDef.type.includes("INT") || !colDef.primaryKey) {
         throw new Error(
           `AUTOINCREMENT can only be used with INTEGER PRIMARY KEY columns (column: ${columnName})`
         )
       }
-      parts.push('AUTOINCREMENT')
+      parts.push("AUTOINCREMENT")
     }
 
     // Add NOT NULL (but skip if PRIMARY KEY is already specified, as it's implicit)
     if (colDef.notNull && !colDef.primaryKey) {
-      parts.push('NOT NULL')
+      parts.push("NOT NULL")
     }
 
     // Add UNIQUE
     if (colDef.unique) {
-      parts.push('UNIQUE')
+      parts.push("UNIQUE")
     }
 
     // Add DEFAULT
     if (colDef.default !== undefined) {
       if (colDef.default === null) {
-        parts.push('DEFAULT NULL')
-      } else if (
-        typeof colDef.default === 'object' &&
-        colDef.default._type === 'expression'
-      ) {
+        parts.push("DEFAULT NULL")
+      } else if (typeof colDef.default === "object" && colDef.default._type === "expression") {
         // Handle DefaultExpression
         parts.push(`DEFAULT (${colDef.default.expression})`)
-      } else if (typeof colDef.default === 'string') {
+      } else if (typeof colDef.default === "string") {
         // Handle string defaults - check if it's a function call or literal
         if (this.isSQLFunction(colDef.default)) {
           parts.push(`DEFAULT (${colDef.default})`)
@@ -443,7 +731,7 @@ class DB {
           // Literal string value
           parts.push(`DEFAULT '${colDef.default.replace(/'/g, "''")}'`)
         }
-      } else if (typeof colDef.default === 'boolean') {
+      } else if (typeof colDef.default === "boolean") {
         parts.push(`DEFAULT ${colDef.default ? 1 : 0}`)
       } else {
         parts.push(`DEFAULT ${colDef.default}`)
@@ -467,7 +755,10 @@ class DB {
     // Add REFERENCES (foreign key)
     if (colDef.references) {
       const ref = colDef.references
-      let refClause = `REFERENCES "${ref.table.replace(/"/g, '""')}"("${ref.column.replace(/"/g, '""')}")`
+      let refClause = `REFERENCES "${ref.table.replace(
+        /"/g,
+        '""'
+      )}"("${ref.column.replace(/"/g, '""')}")`
 
       if (ref.onDelete) {
         refClause += ` ON DELETE ${ref.onDelete}`
@@ -482,26 +773,23 @@ class DB {
 
     // Add GENERATED column
     if (colDef.generated) {
-      const storageType = colDef.generated.stored ? 'STORED' : 'VIRTUAL'
-      parts.push(
-        `GENERATED ALWAYS AS (${colDef.generated.expression}) ${storageType}`
-      )
+      const storageType = colDef.generated.stored ? "STORED" : "VIRTUAL"
+      parts.push(`GENERATED ALWAYS AS (${colDef.generated.expression}) ${storageType}`)
     }
-
-    return parts.join(' ')
+    return parts.join(" ")
   }
 
   /**
    * Build table-level constraints
    */
-  private buildTableConstraints(constraints: TableConstraints): string[] {
+  private buildTableConstraints<T>(constraints: TableConstraints<T>): string[] {
     const parts: string[] = []
 
     // PRIMARY KEY constraint
     if (constraints.primaryKey && constraints.primaryKey.length > 0) {
       const columns = constraints.primaryKey
-        .map((col) => `"${col.replace(/"/g, '""')}"`)
-        .join(', ')
+        .map((col) => `"${String(col).replace(/"/g, '""')}"`)
+        .join(", ")
       parts.push(`PRIMARY KEY (${columns})`)
     }
 
@@ -510,16 +798,14 @@ class DB {
       if (Array.isArray(constraints.unique[0])) {
         // Multiple composite unique constraints
         for (const uniqueGroup of constraints.unique as string[][]) {
-          const columns = uniqueGroup
-            .map((col) => `"${col.replace(/"/g, '""')}"`)
-            .join(', ')
+          const columns = uniqueGroup.map((col) => `"${col.replace(/"/g, '""')}"`).join(", ")
           parts.push(`UNIQUE (${columns})`)
         }
       } else {
         // Single unique constraint
         const columns = (constraints.unique as string[])
           .map((col) => `"${col.replace(/"/g, '""')}"`)
-          .join(', ')
+          .join(", ")
         parts.push(`UNIQUE (${columns})`)
       }
     }
@@ -534,14 +820,15 @@ class DB {
     // FOREIGN KEY constraints
     if (constraints.foreignKeys) {
       for (const fk of constraints.foreignKeys) {
-        const columns = fk.columns
-          .map((col) => `"${col.replace(/"/g, '""')}"`)
-          .join(', ')
+        const columns = fk.columns.map((col) => `"${String(col).replace(/"/g, '""')}"`).join(", ")
         const refColumns = fk.references.columns
           .map((col) => `"${col.replace(/"/g, '""')}"`)
-          .join(', ')
+          .join(", ")
 
-        let fkClause = `FOREIGN KEY (${columns}) REFERENCES "${fk.references.table.replace(/"/g, '""')}" (${refColumns})`
+        let fkClause = `FOREIGN KEY (${columns}) REFERENCES "${fk.references.table.replace(
+          /"/g,
+          '""'
+        )}" (${refColumns})`
 
         if (fk.references.onDelete) {
           fkClause += ` ON DELETE ${fk.references.onDelete}`
@@ -596,7 +883,7 @@ class DB {
       stmt.run(tableName, comment)
     } catch (error) {
       // Silently ignore if we can't create metadata table
-      console.warn(`Could not store table comment for ${tableName}:`, error)
+      logger.warn(`Could not store table comment for ${tableName}: ${error}`)
     }
   }
 
@@ -640,8 +927,8 @@ class DB {
   /**
    * Begin a transaction manually
    */
-  begin(mode?: 'DEFERRED' | 'IMMEDIATE' | 'EXCLUSIVE'): void {
-    const modeStr = mode ? ` ${mode}` : ''
+  begin(mode?: "DEFERRED" | "IMMEDIATE" | "EXCLUSIVE"): void {
+    const modeStr = mode ? ` ${mode}` : ""
     this.db.run(`BEGIN${modeStr}`)
   }
 
@@ -649,16 +936,16 @@ class DB {
    * Commit a transaction
    */
   commit(): void {
-    logger.debug('Committing transaction')
-    this.run('COMMIT')
+    dbLog.transaction("commit")
+    this.run("COMMIT")
   }
 
   /**
    * Rollback a transaction
    */
   rollback(): void {
-    logger.warn('Rolling back transaction')
-    this.run('ROLLBACK')
+    dbLog.transaction("rollback")
+    this.run("ROLLBACK")
   }
 
   /**
@@ -688,8 +975,10 @@ class DB {
   /**
    * Vacuum the database (reclaim space and optimize)
    */
-  vacuum(): void {
-    this.db.run('VACUUM')
+  vacuum() {
+    const result = this.db.run("VACUUM")
+    dbLog.debug("Vacuum completed")
+    return result
   }
 
   /**
@@ -700,7 +989,7 @@ class DB {
       const quotedName = `"${tableName.replace(/"/g, '""')}"`
       this.db.run(`ANALYZE ${quotedName}`)
     } else {
-      this.db.run('ANALYZE')
+      this.db.run("ANALYZE")
     }
   }
 
@@ -708,7 +997,7 @@ class DB {
    * Check database integrity
    */
   integrityCheck(): Array<{ integrity_check: string }> {
-    const stmt = this.db.prepare('PRAGMA integrity_check')
+    const stmt = this.db.prepare("PRAGMA integrity_check")
     return stmt.all() as Array<{ integrity_check: string }>
   }
 
@@ -736,9 +1025,7 @@ class DB {
     dflt_value: SQLQueryBindings
     pk: number
   }> {
-    const stmt = this.db.prepare(
-      `PRAGMA table_info("${tableName.replace(/"/g, '""')}")`
-    )
+    const stmt = this.db.prepare(`PRAGMA table_info("${tableName.replace(/"/g, '""')}")`)
     return stmt.all() as Array<{
       cid: number
       name: string
@@ -762,9 +1049,7 @@ class DB {
     on_delete: string
     match: string
   }> {
-    const stmt = this.db.prepare(
-      `PRAGMA foreign_key_list("${tableName.replace(/"/g, '""')}")`
-    )
+    const stmt = this.db.prepare(`PRAGMA foreign_key_list("${tableName.replace(/"/g, '""')}")`)
     return stmt.all() as Array<{
       id: number
       seq: number
@@ -786,9 +1071,7 @@ class DB {
     origin: string
     partial: number
   }> {
-    const stmt = this.db.prepare(
-      `PRAGMA index_list("${tableName.replace(/"/g, '""')}")`
-    )
+    const stmt = this.db.prepare(`PRAGMA index_list("${tableName.replace(/"/g, '""')}")`)
     return stmt.all() as Array<{
       name: string
       unique: number
@@ -809,10 +1092,7 @@ class DB {
       this.db.run(`PRAGMA ${name} = ${value}`)
       return undefined
     }
-    const result = this.db.prepare(`PRAGMA ${name}`).get() as Record<
-      string,
-      SQLQueryBindings
-    >
+    const result = this.db.prepare(`PRAGMA ${name}`).get() as Record<string, SQLQueryBindings>
     return Object.values(result)[0]
   }