feat(builder)!: add logger option

remove onError, auto log error

Author: subframe7536

packages/sqlite-builder/src/builder.ts

@@ -2,7 +2,7 @@ import type { Compilable, CompiledQuery, KyselyPlugin, LogEvent, QueryResult, Ra
 import { Kysely, sql } from 'kysely'
 import { SqliteSerializePlugin } from 'kysely-plugin-serialize'
 import { parseTableMap, runCreateTable } from './util'
-import type { ITable, SqliteBuilderOption } from './types'
+import type { ITable, Logger, SqliteBuilderOption } from './types'
 
 const enum DBStatus {
   'needDrop',
@@ -13,15 +13,17 @@ export class SqliteBuilder<DB extends Record<string, any>> {
   public kysely: Kysely<DB>
   private status: DBStatus
   private tableMap: Map<string, ITable<DB[Extract<keyof DB, string>]>>
+  private logger?: Logger
   public constructor(option: SqliteBuilderOption<DB>) {
-    const { dialect, tables, dropTableBeforeInit: truncateBeforeInit, onError, onQuery, plugins: additionalPlugin } = option
+    const { dialect, tables, dropTableBeforeInit: truncateBeforeInit, onQuery, plugins: additionalPlugin, logger } = option
+    this.logger = logger
     const plugins: KyselyPlugin[] = additionalPlugin ?? []
     plugins.push(new SqliteSerializePlugin())
     this.kysely = new Kysely<DB>({
       dialect,
       log: (event: LogEvent) => {
         event.level === 'error'
-          ? onError?.(event.error)
+          ? this.logger?.error('uncaught db error', event.error as Error)
           : onQuery?.(event.query, event.queryDurationMillis)
       },
       plugins,
@@ -39,44 +41,51 @@ export class SqliteBuilder<DB extends Record<string, any>> {
     return this
   }
 
-  private async checkInit() {
+  private async isEmptyTable(): Promise<boolean> {
     this.status !== DBStatus.ready && await this.init()
-    if (this.status !== DBStatus.ready) {
-      throw new Error('fail to init table')
+    if (this.status === DBStatus.ready) {
+      return false
     }
+    this.logger?.error('fail to init table')
+    return true
   }
 
   public async transaction<T>(
     cb: (trx: Transaction<DB>) => Promise<T>,
-    errorLog = false,
+    errorMsg = 'transaction error',
   ): Promise<T | undefined> {
-    await this.checkInit()
+    if (await this.isEmptyTable()) {
+      return undefined
+    }
     return await this.kysely.transaction().execute(cb)
       .catch((err) => {
-        errorLog && console.error(err)
+        this.logger?.error(errorMsg, err)
         return undefined
       })
   }
 
   public async exec<T>(
     cb: (db: Kysely<DB>) => Promise<T>,
-    errorLog = false,
+    errorMsg = 'execute error',
   ): Promise<T | undefined> {
-    await this.checkInit()
+    if (await this.isEmptyTable()) {
+      return undefined
+    }
     return cb(this.kysely)
       .catch((err) => {
-        errorLog && console.error(err)
+        this.logger?.error(errorMsg, err)
         return undefined
       })
   }
 
   public async toSQL<T extends Compilable>(cb: (db: Kysely<DB>) => T): Promise<CompiledQuery<unknown>> {
-    await this.checkInit()
     return cb(this.kysely).compile()
   }
 
-  public async raw<T = any>(rawSql: (s: Sql) => RawBuilder<T>): Promise<QueryResult<T>> {
-    await this.checkInit()
+  public async raw<T = any>(rawSql: (s: Sql) => RawBuilder<T>): Promise<QueryResult<T> | undefined> {
+    if (await this.isEmptyTable()) {
+      return undefined
+    }
     return rawSql(sql).execute(this.kysely)
   }
 }

packages/sqlite-builder/src/types.ts

@@ -47,6 +47,12 @@ export interface SqliteBuilderOption<T> {
   dialect: Dialect
   dropTableBeforeInit?: boolean
   onQuery?: (queryInfo: CompiledQuery, time: number) => any
-  onError?: (reason: unknown) => any
   plugins?: Array<KyselyPlugin>
+  logger?: Logger
 }
+export type Logger = {
+  info: (msg: string) => void
+  debug: (msg: string) => void
+  warn: (msg: string) => void
+  error: (msg: string, e?: Error) => void
+}

test/builder.test.ts

@@ -1,7 +1,7 @@
 import type { Generated } from 'kysely'
 import { SqliteDialect } from 'kysely'
 import Database from 'better-sqlite3'
-import { describe, expect, test } from 'vitest'
+import { beforeAll, describe, expect, test } from 'vitest'
 import { SqliteBuilder } from '../packages/sqlite-builder/src'
 
 interface DB {
@@ -36,15 +36,16 @@ describe('test builder', async () => {
       },
     },
     dropTableBeforeInit: true,
-    onError: reason => console.error(reason),
+    logger: console,
     onQuery: (queryInfo, time) => console.log(`${time}ms`, queryInfo.sql, queryInfo.parameters),
   })
-  // manually generate table
-  await db.init(true)
-  // auto generate table
+  beforeAll(async () => {
+    // manually generate table
+    await db.init(true)
+  })
   test('insert', async () => {
-    await db.transaction(trx => trx.insertInto('test').values({ gender: false }).execute())
     // auto generate table
+    await db.transaction(trx => trx.insertInto('test').values({ gender: false }).execute())
     const result = await db.exec(d => d.selectFrom('test').selectAll().execute())
     expect(result).toBeInstanceOf(Array)
     expect(result![0].person).toStrictEqual({ name: 'test' })