add error log level

Author: koskimas

src/driver/runtime-driver.ts

@@ -105,17 +105,33 @@ class RuntimeConnection implements DatabaseConnection {
 
     try {
       return await this.#connection.executeQuery<R>(compiledQuery)
+    } catch (error) {
+      this.#logError(error)
+      throw error
     } finally {
-      this.#log.query((log) => {
-        log(compiledQuery.sql)
-        log(`duration: ${this.#calculateDurationMillis(startTime)}ms`)
-      })
+      this.#logQuery(compiledQuery, startTime)
     }
   }
 
+  #logError(error: unknown): void {
+    this.#log.error(() => ({
+      level: 'error',
+      error,
+    }))
+  }
+
+  #logQuery(compiledQuery: CompiledQuery, startTime: bigint): void {
+    this.#log.query(() => ({
+      level: 'query',
+      sql: compiledQuery.sql,
+      queryDurationMillis: this.#calculateDurationMillis(startTime),
+    }))
+  }
+
   #calculateDurationMillis(startTime: bigint): number {
     const endTime = process.hrtime.bigint()
-    const durationTensMillis = Number((endTime - startTime) / 1_00_000n)
-    return durationTensMillis / 10
+    const durationNanos = Number(endTime - startTime)
+
+    return durationNanos / 1_000_000
   }
 }

src/kysely.ts

@@ -358,12 +358,13 @@ export interface KyselyConfig {
   /**
    * A list of log levels to log.
    *
-   * Currently there's only one level: `query` and it's logged using
-   * `console.log`. This will be expanded based on user request later.
+   * Currently there's only two levels: `query` and `error`.
+   * This will be expanded based on user feedback later.
    *
    * Log levels:
    *
-   *  - query: Log each query's SQL and duration.
+   *  - query: Log each query's SQL and duration using console.log
+   *  - error: Log all query errors using console.error
    */
   readonly log?: ReadonlyArray<LogLevel>
 }

src/util/log.ts

@@ -1,24 +1,56 @@
+import { freeze } from './object-utils.js'
 import { ArrayItemType } from './type-utils.js'
 
-export const LOG_LEVELS = ['query'] as const
+export const LOG_LEVELS = ['query', 'error'] as const
 export type LogLevel = ArrayItemType<typeof LOG_LEVELS>
 
 export class Log {
   #levels: Readonly<Record<LogLevel, boolean>>
 
   constructor(levels: ReadonlyArray<LogLevel>) {
-    this.#levels = {
+    this.#levels = freeze({
       query: levels.includes('query'),
-    }
+      error: levels.includes('error'),
+    })
   }
 
-  query(callback: (log: (message: string) => void) => void) {
+  query(getEvent: () => QueryLogEvent) {
     if (this.#levels.query) {
-      callback(this.#query)
+      this.#defaultQuery(getEvent())
+    }
+  }
+
+  error(getEvent: () => ErrorLogEvent) {
+    if (this.#levels.error) {
+      this.#defaultError(getEvent())
     }
   }
 
-  #query(message: string) {
-    console.log(`kysely:query: ${message}`)
+  #defaultQuery(event: QueryLogEvent) {
+    console.log(`kysely:query: ${event.sql}`)
+    console.log(
+      `kysely:query: duration: ${event.queryDurationMillis.toFixed(1)}ms`
+    )
+  }
+
+  #defaultError(event: ErrorLogEvent) {
+    if (event.error instanceof Error) {
+      console.error(`kysely:error: ${event.error.stack ?? event.error.message}`)
+    } else {
+      console.error(`kysely:error: ${event}`)
+    }
   }
 }
+
+export type LogEvent = QueryLogEvent | ErrorLogEvent
+
+export interface QueryLogEvent {
+  readonly level: 'query'
+  readonly sql: string
+  readonly queryDurationMillis: number
+}
+
+export interface ErrorLogEvent {
+  readonly level: 'error'
+  readonly error: unknown
+}