@dockstat/sqlite-wrapper 1.3.0 → 1.3.1

package/index.ts

@@ -1,16 +1,8 @@
 import { Database, type SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
 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"
-
-// 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")
+import { createLogger, type SqliteLogger } from "./utils"
 
 /**
  * Re-export all types and utilities
@@ -92,6 +84,10 @@ class DB {
   protected dbPath: string
   private autoBackupTimer: ReturnType<typeof setInterval> | null = null
   private autoBackupOptions: AutoBackupOptions | null = null
+  private baseLogger: Logger
+  private dbLog: SqliteLogger
+  private backupLog: SqliteLogger
+  private tableLog: SqliteLogger
 
   /**
    * Open or create a SQLite database at `path`.
@@ -99,8 +95,16 @@ 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?: DBOptions) {
-    dbLog.connection(path, "open")
+  constructor(path: string, baseLogger: Logger, options?: DBOptions) {
+    this.baseLogger = baseLogger
+
+    // Wire base logger so sqlite-wrapper logs inherit the same LogHook/parents as the consumer.
+    this.dbLog = createLogger("DB", this.baseLogger)
+    this.backupLog = createLogger("Backup", this.baseLogger)
+    this.tableLog = createLogger("Table", this.baseLogger)
+
+    this.dbLog.connection(path, "open")
+
     this.dbPath = path
     this.db = new Database(path)
 
@@ -129,8 +133,7 @@ class DB {
    */
   private setupAutoBackup(options: AutoBackupOptions): void {
     if (this.dbPath === ":memory:") {
-      backupLog.warn("Auto-backup is not available for in-memory databases")
-      return
+      this.backupLog.warn("Auto-backup is not available for in-memory databases")
     }
 
     this.autoBackupOptions = {
@@ -146,7 +149,7 @@ class DB {
     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}`)
+      this.backupLog.info(`Created backup directory: ${this.autoBackupOptions.directory}`)
     }
 
     // Create initial backup
@@ -157,7 +160,7 @@ class DB {
       this.backup()
     }, this.autoBackupOptions.intervalMs)
 
-    backupLog.info(
+    this.backupLog.info(
       `Auto-backup enabled: interval=${this.autoBackupOptions.intervalMs}ms, maxBackups=${this.autoBackupOptions.maxBackups}`
     )
   }
@@ -194,7 +197,7 @@ class 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)
+      this.backupLog.backup("create", backupPath)
 
       // Apply retention policy if auto-backup is enabled
       if (this.autoBackupOptions) {
@@ -203,7 +206,7 @@ class DB {
 
       return backupPath
     } catch (error) {
-      backupLog.error(`Failed to create backup: ${error}`)
+      this.backupLog.error(`Failed to create backup: ${error}`)
       throw error
     }
   }
@@ -238,12 +241,12 @@ class DB {
         const toDelete = files.slice(maxBackups)
         for (const file of toDelete) {
           fs.unlinkSync(file.path)
-          backupLog.debug(`Removed old backup: ${file.name}`)
+          this.backupLog.debug(`Removed old backup: ${file.name}`)
         }
-        backupLog.info(`Retention policy applied: removed ${toDelete.length} old backup(s)`)
+        this.backupLog.info(`Retention policy applied: removed ${toDelete.length} old backup(s)`)
       }
     } catch (error) {
-      backupLog.error(`Failed to apply retention policy: ${error}`)
+      this.backupLog.error(`Failed to apply retention policy: ${error}`)
     }
   }
 
@@ -254,7 +257,8 @@ class DB {
    */
   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.")
+      this.backupLog.warn("Auto-backup is not configured. Use backup() with a custom path instead.")
+
       return []
     }
 
@@ -282,7 +286,7 @@ class DB {
           (a: { created: Date }, b: { created: Date }) => b.created.getTime() - a.created.getTime()
         )
     } catch (error) {
-      backupLog.error(`Failed to list backups: ${error}`)
+      this.backupLog.error(`Failed to list backups: ${error}`)
       return []
     }
   }
@@ -313,15 +317,15 @@ class DB {
 
     try {
       fs.copyFileSync(backupPath, restorePath)
-      backupLog.backup("restore", backupPath)
+      this.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")
+        this.dbLog.info("Database connection reopened after restore")
       }
     } catch (error) {
-      backupLog.error(`Failed to restore backup: ${error}`)
+      this.backupLog.error(`Failed to restore backup: ${error}`)
       throw error
     }
   }
@@ -333,7 +337,7 @@ class DB {
     if (this.autoBackupTimer) {
       clearInterval(this.autoBackupTimer)
       this.autoBackupTimer = null
-      backupLog.info("Auto-backup stopped")
+      this.backupLog.info("Auto-backup stopped")
     }
   }
 
@@ -350,7 +354,7 @@ class DB {
    */
   table<T extends Record<string, unknown>>(
     tableName: string,
-    parser: Partial<Parser<T>>
+    parser: Partial<Parser<T>> = {}
   ): QueryBuilder<T> {
     const pObj: Parser<T> = {
       JSON: parser.JSON || [],
@@ -358,8 +362,8 @@ class DB {
       BOOLEAN: parser.BOOLEAN || [],
     }
 
-    tableLog.debug(`Creating QueryBuilder for: ${tableName}`)
-    return new QueryBuilder<T>(this.db, tableName, pObj)
+    this.tableLog.debug(`Creating QueryBuilder for: ${tableName}`)
+    return new QueryBuilder<T>(this.db, tableName, pObj, this.baseLogger)
   }
 
   /**
@@ -367,7 +371,7 @@ class DB {
    * Also stops auto-backup if it's running.
    */
   close(): void {
-    dbLog.connection(this.dbPath, "close")
+    this.dbLog.connection(this.dbPath, "close")
     this.stopAutoBackup()
     this.db.close()
   }
@@ -521,7 +525,7 @@ class DB {
     const allDefinitions = [columnDefs, ...tableConstraints].join(", ")
 
     const columnNames = Object.keys(columns)
-    tableLog.tableCreate(tableName, columnNames)
+    this.tableLog.tableCreate(tableName, columnNames)
 
     const sql = `CREATE ${temp}TABLE ${ifNot}${quoteIdent(
       tableName
@@ -564,7 +568,11 @@ class DB {
       BOOLEAN: mergedBoolean,
     }
 
-    tableLog.parserConfig(pObj.JSON.map(String), pObj.BOOLEAN.map(String), Object.keys(pObj.MODULE))
+    this.tableLog.parserConfig(
+      pObj.JSON.map(String),
+      pObj.BOOLEAN.map(String),
+      Object.keys(pObj.MODULE)
+    )
 
     return this.table<_T>(tableName, pObj)
   }
@@ -883,7 +891,7 @@ class DB {
       stmt.run(tableName, comment)
     } catch (error) {
       // Silently ignore if we can't create metadata table
-      logger.warn(`Could not store table comment for ${tableName}: ${error}`)
+      this.tableLog.warn(`Could not store table comment for ${tableName}: ${error}`)
     }
   }
 
@@ -906,7 +914,7 @@ class DB {
    * runute a raw SQL statement
    */
   run(sql: string): void {
-    logger.debug(`runuting SQL: ${sql}`)
+    this.tableLog.debug(`Running SQL: ${sql}`)
     this.db.run(sql)
   }
 
@@ -936,7 +944,7 @@ class DB {
    * Commit a transaction
    */
   commit(): void {
-    dbLog.transaction("commit")
+    this.dbLog.transaction("commit")
     this.run("COMMIT")
   }
 
@@ -944,7 +952,7 @@ class DB {
    * Rollback a transaction
    */
   rollback(): void {
-    dbLog.transaction("rollback")
+    this.dbLog.transaction("rollback")
     this.run("ROLLBACK")
   }
 
@@ -977,7 +985,7 @@ class DB {
    */
   vacuum() {
     const result = this.db.run("VACUUM")
-    dbLog.debug("Vacuum completed")
+    this.dbLog.debug("Vacuum completed")
     return result
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dockstat/sqlite-wrapper",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "A TypeScript wrapper around bun:sqlite with type-safe query building",
   "type": "module",
   "main": "./index.ts",
@@ -48,7 +48,7 @@
     "bun": ">=1.0.0"
   },
   "dependencies": {
-    "@dockstat/logger": "1.0.1"
+    "@dockstat/logger": "workspace:*"
   },
   "peerDependencies": {
     "typescript": "^5.9.3"

package/query-builder/base.ts

@@ -1,4 +1,5 @@
 import type { Database, SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
 import type { Parser, QueryBuilderState } from "../types"
 import {
   createLogger,
@@ -20,9 +21,9 @@ import {
  */
 export abstract class BaseQueryBuilder<T extends Record<string, unknown>> {
   protected state: QueryBuilderState<T>
-  protected log = createLogger("query")
+  protected log: ReturnType<typeof createLogger>
 
-  constructor(db: Database, tableName: string, parser?: Parser<T>) {
+  constructor(db: Database, tableName: string, parser?: Parser<T>, baseLogger?: Logger) {
     this.state = {
       db,
       tableName,
@@ -32,6 +33,9 @@ export abstract class BaseQueryBuilder<T extends Record<string, unknown>> {
       parser,
     }
 
+    // If a base logger is provided, this will inherit the consumer's LogHook/parents.
+    this.log = createLogger("Query", baseLogger)
+
     this.log.debug(`QueryBuilder initialized for table: ${tableName}`)
   }
 
@@ -163,14 +167,14 @@ export abstract class BaseQueryBuilder<T extends Record<string, unknown>> {
    * (deserialize JSON, convert booleans, etc.)
    */
   protected transformRowFromDb(row: unknown): T {
-    return transformFromDb<T>(row, { parser: this.state.parser })
+    return transformFromDb<T>(row, { parser: this.state.parser, logger: this.log })
   }
 
   /**
    * Transform multiple rows FROM the database
    */
   protected transformRowsFromDb(rows: unknown[]): T[] {
-    return transformRowsFromDb<T>(rows, { parser: this.state.parser })
+    return transformRowsFromDb<T>(rows, { parser: this.state.parser, logger: this.log })
   }
 
   /**
@@ -178,6 +182,6 @@ export abstract class BaseQueryBuilder<T extends Record<string, unknown>> {
    * (serialize JSON, stringify functions, etc.)
    */
   protected transformRowToDb(row: Partial<T>): RowData {
-    return transformToDb<T>(row, { parser: this.state.parser })
+    return transformToDb<T>(row, { parser: this.state.parser, logger: this.log })
   }
 }

package/query-builder/delete.ts

@@ -1,5 +1,6 @@
-import type { SQLQueryBindings } from "bun:sqlite"
-import type { DeleteResult } from "../types"
+import type { Database, SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
+import type { DeleteResult, Parser } from "../types"
 import { createLogger, quoteIdentifier } from "../utils"
 import { SelectQueryBuilder } from "./select"
 
@@ -17,7 +18,12 @@ import { SelectQueryBuilder } from "./select"
  * - Truncate (explicit full-table delete)
  */
 export class DeleteQueryBuilder<T extends Record<string, unknown>> extends SelectQueryBuilder<T> {
-  private deleteLog = createLogger("delete")
+  private deleteLog: ReturnType<typeof createLogger>
+
+  constructor(db: Database, tableName: string, parser: Parser<T>, baseLogger?: Logger) {
+    super(db, tableName, parser, baseLogger)
+    this.deleteLog = createLogger("Delete", baseLogger)
+  }
 
   // ===== Public Delete Methods =====
 

package/query-builder/index.ts

@@ -1,4 +1,5 @@
 import type { Database, SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
 import type {
   ColumnNames,
   DeleteResult,
@@ -32,12 +33,12 @@ export class QueryBuilder<T extends Record<string, unknown> = Record<string, unk
   private updateBuilder: UpdateQueryBuilder<T>
   private deleteBuilder: DeleteQueryBuilder<T>
 
-  constructor(db: Database, tableName: string, parser: Parser<T>) {
+  constructor(db: Database, tableName: string, parser: Parser<T>, baseLogger?: Logger) {
     // Create instances of each specialized builder
-    this.selectBuilder = new SelectQueryBuilder<T>(db, tableName, parser)
-    this.insertBuilder = new InsertQueryBuilder<T>(db, tableName, parser)
-    this.updateBuilder = new UpdateQueryBuilder<T>(db, tableName, parser)
-    this.deleteBuilder = new DeleteQueryBuilder<T>(db, tableName, parser)
+    this.selectBuilder = new SelectQueryBuilder<T>(db, tableName, parser, baseLogger)
+    this.insertBuilder = new InsertQueryBuilder<T>(db, tableName, parser, baseLogger)
+    this.updateBuilder = new UpdateQueryBuilder<T>(db, tableName, parser, baseLogger)
+    this.deleteBuilder = new DeleteQueryBuilder<T>(db, tableName, parser, baseLogger)
 
     // Ensure all builders share the same state for WHERE conditions
     this.syncBuilderStates()

package/query-builder/insert.ts

@@ -1,5 +1,6 @@
-import type { SQLQueryBindings } from "bun:sqlite"
-import type { InsertOptions, InsertResult } from "../types"
+import type { Database, SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
+import type { InsertOptions, InsertResult, Parser } from "../types"
 import {
   buildPlaceholders,
   createLogger,
@@ -20,7 +21,12 @@ import { WhereQueryBuilder } from "./where"
  * - Automatic JSON/Boolean serialization
  */
 export class InsertQueryBuilder<T extends Record<string, unknown>> extends WhereQueryBuilder<T> {
-  private insertLog = createLogger("insert")
+  private insertLog: ReturnType<typeof createLogger>
+
+  constructor(db: Database, tableName: string, parser: Parser<T>, baseLogger?: Logger) {
+    super(db, tableName, parser, baseLogger)
+    this.insertLog = createLogger("Insert", baseLogger)
+  }
 
   // ===== Private Helpers =====
 

package/query-builder/select.ts

@@ -1,5 +1,6 @@
-import type { SQLQueryBindings } from "bun:sqlite"
-import type { ColumnNames, OrderDirection } from "../types"
+import type { Database, SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
+import type { ColumnNames, OrderDirection, Parser } from "../types"
 import { createLogger, quoteIdentifier } from "../utils"
 import { WhereQueryBuilder } from "./where"
 
@@ -20,11 +21,12 @@ export class SelectQueryBuilder<T extends Record<string, unknown>> extends Where
   private limitValue?: number
   private offsetValue?: number
 
-  private selectLog = createLogger("select")
+  private selectLog: ReturnType<typeof createLogger>
 
-  /* constructor(db: Database, tableName: string, parser: Parser<T>) {
-    super(db, tableName, parser)
-  } */
+  constructor(db: Database, tableName: string, parser: Parser<T>, baseLogger?: Logger) {
+    super(db, tableName, parser, baseLogger)
+    this.selectLog = createLogger("Select", baseLogger)
+  }
 
   // ===== Query Building Methods =====
 

package/query-builder/update.ts

@@ -1,5 +1,6 @@
-import type { SQLQueryBindings } from "bun:sqlite"
-import type { UpdateResult } from "../types"
+import type { Database, SQLQueryBindings } from "bun:sqlite"
+import type { Logger } from "@dockstat/logger"
+import type { Parser, UpdateResult } from "../types"
 import { buildSetClause, createLogger, quoteIdentifier, type RowData } from "../utils"
 import { SelectQueryBuilder } from "./select"
 
@@ -15,7 +16,12 @@ import { SelectQueryBuilder } from "./select"
  * - Automatic JSON serialization
  */
 export class UpdateQueryBuilder<T extends Record<string, unknown>> extends SelectQueryBuilder<T> {
-  private updateLog = createLogger("update")
+  private updateLog: ReturnType<typeof createLogger>
+
+  constructor(db: Database, tableName: string, parser: Parser<T>, baseLogger?: Logger) {
+    super(db, tableName, parser, baseLogger)
+    this.updateLog = createLogger("Update", baseLogger)
+  }
 
   // ===== Public Update Methods =====
 

package/utils/index.ts

@@ -8,8 +8,10 @@
 export {
   addLoggerParents,
   createLogger,
+  createSqliteBaseLogger,
   logger,
   SqliteLogger,
+  setSqliteLogHook,
 } from "./logger"
 
 // SQL utilities

package/utils/logger.ts

@@ -1,4 +1,4 @@
-import Logger from "@dockstat/logger"
+import { Logger, type LogHook } from "@dockstat/logger"
 
 /**
  * Centralized logging for sqlite-wrapper
@@ -31,8 +31,15 @@ export class SqliteLogger {
   private logger: Logger
   private tableName?: string
 
-  constructor(name: string, parent?: Logger, tableName?: string) {
-    this.logger = parent ? parent.spawn(name) : new Logger(name)
+  constructor(name: string, parent?: Logger, tableName?: string, logHook?: LogHook) {
+    try {
+      this.logger =
+        typeof parent?.spawn === "function" ? parent.spawn(name) : new Logger(name, [], logHook)
+    } catch (error) {
+      this.logger = new Logger(name, [], logHook)
+      console.error(error)
+    }
+
     this.tableName = tableName
   }
 
@@ -173,7 +180,12 @@ export const logger = new SqliteLogger("Sqlite")
 /**
  * Create a new logger for a specific module
  */
-export function createLogger(name: string): SqliteLogger {
+export function createLogger(name: string, baseLogger?: Logger): SqliteLogger {
+  // If a base logger is provided (recommended for apps/packages that want shared LogHook/parents),
+  // derive a sqlite-scoped child logger from it.
+  if (baseLogger) return new SqliteLogger(name, baseLogger)
+
+  // Fallback to the package-level logger (works, but won't automatically inherit app hooks)
   return logger.child(name)
 }
 
@@ -181,4 +193,24 @@ export function addLoggerParents(parents: string[]): void {
   logger.addParents(parents)
 }
 
+/**
+ * Configure a shared LogHook for sqlite-wrapper's root logger.
+ *
+ * Useful when consumers (e.g. `apps/api`, `packages/db`) want sqlite-wrapper logs
+ * to be routed through the same sink/formatter as the rest of the app.
+ */
+export function setSqliteLogHook(logHook: LogHook): void {
+  logger.getBaseLogger().setLogHook(logHook)
+}
+
+/**
+ * Optional convenience for consumers: create a sqlite-scoped base Logger that shares a LogHook.
+ *
+ * This is handy if you want to pass a base logger into `createLogger()` / `DB` and have
+ * everything inherit the same hook.
+ */
+export function createSqliteBaseLogger(logHook?: LogHook): Logger {
+  return new Logger("Sqlite", [], logHook)
+}
+
 export default logger

package/utils/transformer.ts

@@ -1,6 +1,6 @@
 import type { SQLQueryBindings } from "bun:sqlite"
 import type { Parser } from "../types"
-import { createLogger } from "./logger"
+import { createLogger, type SqliteLogger } from "./logger"
 
 /**
  * Row Transformer for sqlite-wrapper
@@ -9,7 +9,7 @@ import { createLogger } from "./logger"
  * including JSON columns, Boolean columns, and Module columns.
  */
 
-const logger = createLogger("transformer")
+const defaultLogger = createLogger("Transformer")
 
 /**
  * Generic row data type
@@ -21,6 +21,7 @@ export type RowData = Record<string, SQLQueryBindings>
  */
 export interface TransformOptions<T> {
   parser?: Parser<T>
+  logger?: SqliteLogger
 }
 
 /**
@@ -43,6 +44,7 @@ export function transformFromDb<T extends Record<string, unknown>>(
     return row as T
   }
 
+  const logger = options?.logger || defaultLogger
   const transformed = { ...row } as RowData
   const transformedColumns: string[] = []
 
@@ -166,6 +168,7 @@ export function transformToDb<T extends Record<string, unknown>>(
     return row as RowData
   }
 
+  const logger = options?.logger || defaultLogger
   const transformed = { ...row } as RowData
   const transformedColumns: string[] = []