test: cover real knex and pino integrations

Author: khmm12

AGENTS.md

@@ -17,6 +17,7 @@
 - Keep this a dual package: ESM and CommonJS must both work.
 - Keep TypeScript declarations valid for both ESM and CJS consumers.
 - Keep `sideEffects: false` unless a real package-level side effect is introduced.
+- Mark safe top-level helper initializers with pure pragmas, for example `/* @__PURE__ */`, so `sideEffects: false` stays effective for bundlers.
 - Keep source unit tests independent from `dist`.
 
 ## API Shape

package.json

@@ -91,6 +91,7 @@
     "@biomejs/biome": "^2.4.13",
     "@types/node": "^24",
     "knex": "^3.1.0",
+    "pino": "^10.3.1",
     "sqlite3": "^6.0.1",
     "typescript": "^5.9.0",
     "unbuild": "^3.6.1"

pnpm-lock.yaml

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { createFakeKnex } from '../test/helpers/fake-knex.ts'
+import knexTinyLogger from './index.ts'
+
+test('knexTinyLogger wires logger start hooks', () => {
+  const knex = createFakeKnex()
+  const startEvents: unknown[] = []
+
+  knexTinyLogger(knex, {
+    logger: {
+      onStart(event) {
+        startEvents.push(event)
+      },
+    },
+  })
+
+  knex.emit('query', { __knexQueryUid: 'query-1', sql: 'select ?', bindings: [1] })
+
+  assert.equal(startEvents.length, 1)
+})
+
+test('knexTinyLogger reports logger errors', () => {
+  const knex = createFakeKnex()
+  const loggerError = new Error('logger failed')
+  const loggerErrors: unknown[] = []
+
+  knexTinyLogger(knex, {
+    logger: {
+      onEnd() {
+        throw loggerError
+      },
+    },
+    onLoggerError(event) {
+      loggerErrors.push(event.error)
+    },
+  })
+
+  knex.emit('query', { __knexQueryUid: 'query-1', sql: 'select ?', bindings: [1] })
+  knex.emit('query-response', [], { __knexQueryUid: 'query-1' })
+
+  assert.deepEqual(loggerErrors, [loggerError])
+})
+
+test('knexTinyLogger falls back to console.error when logger error handlers throw', () => {
+  const knex = createFakeKnex()
+  const loggerError = new Error('logger failed')
+  const handlerError = new Error('handler failed')
+  const consoleErrors: unknown[][] = []
+  const originalError = console.error
+
+  console.error = (...args: unknown[]) => {
+    consoleErrors.push(args)
+  }
+
+  try {
+    knexTinyLogger(knex, {
+      logger: {
+        onError() {
+          throw loggerError
+        },
+      },
+      onLoggerError() {
+        throw handlerError
+      },
+    })
+
+    knex.emit('query', { __knexQueryUid: 'query-1', sql: 'select broken' })
+    knex.emit('query-error', new Error('query failed'), { __knexQueryUid: 'query-1' })
+  } finally {
+    console.error = originalError
+  }
+
+  assert.deepEqual(consoleErrors, [[handlerError]])
+})

src/index.test.ts

@@ -1,5 +1,7 @@
 import assert from 'node:assert/strict'
+import { Writable } from 'node:stream'
 import test from 'node:test'
+import pino from 'pino'
 import { createQueryEndEvent, createQueryErrorEvent } from '../test/helpers/events.ts'
 import { pinoLogger } from './pino-logger.ts'
 
@@ -88,3 +90,25 @@ test('pinoLogger can omit bindings', () => {
     ],
   ])
 })
+
+test('pinoLogger writes structured entries with real pino', () => {
+  const chunks: string[] = []
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      chunks.push(String(chunk))
+      callback()
+    },
+  })
+  const logger = pinoLogger(pino({ base: undefined, timestamp: false }, stream))
+
+  logger.onEnd?.(createQueryEndEvent())
+
+  assert.equal(chunks.length, 1)
+  assert.deepEqual(JSON.parse(chunks[0]), {
+    level: 30,
+    sql: 'select ?',
+    bindings: [1],
+    durationMs: 12.34567,
+    msg: 'SQL query',
+  })
+})

src/pino-logger.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
-import { hrtimeTimingAdapter, performanceTimingAdapter } from './timing.ts'
+import { hrtimeTimingAdapter, performanceTimingAdapter, selectTimingAdapter, supportsPerformance } from './timing.ts'
 
 test('performance timing adapter measures duration with performance.now', () => {
   const originalPerformance = globalThis.performance
@@ -33,3 +33,14 @@ test('hrtime timing adapter measures duration with process.hrtime', () => {
 
   assert.ok(hrtimeTimingAdapter.duration(startTime) >= 0)
 })
+
+test('supportsPerformance detects performance.now support', () => {
+  assert.equal(supportsPerformance({ now: () => 0 }), true)
+  assert.equal(supportsPerformance(null), false)
+  assert.equal(supportsPerformance({}), false)
+})
+
+test('selectTimingAdapter prefers performance.now when available', () => {
+  assert.equal(selectTimingAdapter({ now: () => 0 }), performanceTimingAdapter)
+  assert.equal(selectTimingAdapter(null), hrtimeTimingAdapter)
+})