Error handling. Unit test for it. Reduce code dupe. Version bump to 1.1.0.

Author: samhuk

package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-pg-client",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "description": "Simplified Javascript PostgreSQL client.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/dbService.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from 'crypto'
+import { QueryResult } from 'pg'
 import { truncate } from './common/string'
 import { DbService, DbServiceOptions } from './types'
 
@@ -10,44 +11,27 @@ const onError = (options: DbServiceOptions, queryId: string, error: any, sql: st
   options.events?.onError?.(queryId, `Executing SQL Failed (${queryId}): ${error.message}`, sql, parameters)
 }
 
+const queryBase = async <T = any>(
+  options: DbServiceOptions,
+  sql: string,
+  parameters: any,
+  resultCreator: (result: QueryResult) => T,
+) => {
+  const queryId = randomUUID()
+  onQuery(options, queryId, sql, parameters)
+  try {
+    const result = await options.client.query(sql, parameters)
+    return resultCreator(result)
+  }
+  catch (e) {
+    onError(options, queryId, e, sql, parameters)
+    throw e
+  }
+}
+
 export const createDbService = (options: DbServiceOptions): DbService => ({
-  query: (sql, parameters) => {
-    const queryId = randomUUID()
-    onQuery(options, queryId, sql, parameters)
-    return options.client.query(sql, parameters)
-      .catch(error => {
-        onError(options, queryId, error, sql, parameters)
-        return null
-      })
-  },
-  queryExists: (sql, parameters) => {
-    const queryId = randomUUID()
-    onQuery(options, queryId, sql, parameters)
-    return options.client.query(sql, parameters)
-      .then(result => result.rowCount > 0)
-      .catch(error => {
-        onError(options, queryId, error, sql, parameters)
-        return null
-      })
-  },
-  queryGetFirstRow: (sql, parameters) => {
-    const queryId = randomUUID()
-    onQuery(options, queryId, sql, parameters)
-    return options.client.query(sql, parameters)
-      .then(result => result.rows[0])
-      .catch(error => {
-        onError(options, queryId, error, sql, parameters)
-        return null
-      })
-  },
-  queryGetRows: (sql, parameters) => {
-    const queryId = randomUUID()
-    onQuery(options, queryId, sql, parameters)
-    return options.client.query(sql, parameters)
-      .then(result => result.rows)
-      .catch(error => {
-        onError(options, queryId, error, sql, parameters)
-        return null
-      })
-  },
+  query: async (sql, parameters) => queryBase(options, sql, parameters, r => r),
+  queryExists: async (sql, parameters) => queryBase(options, sql, parameters, r => r.rows.length > 0),
+  queryGetFirstRow: async (sql, parameters) => queryBase(options, sql, parameters, r => r.rows[0]),
+  queryGetRows: async (sql, parameters) => queryBase(options, sql, parameters, r => r.rows),
 })

src/index.spec.ts

@@ -1,6 +1,6 @@
 /* eslint-disable no-console */
 import { createConsoleLogEventHandlers, createSimplePgClient } from '.'
-import { SimplePgClientOptions } from './types'
+import { SimplePgClient, SimplePgClientOptions } from './types'
 
 const DEFAULT_OPTIONS: SimplePgClientOptions = {
   host: 'localhost',
@@ -34,15 +34,48 @@ CONNECTION LIMIT = -1;`,
 describe('createSimplePgClient', () => {
   const fn = createSimplePgClient
 
+  let simplePgClient: SimplePgClient
+
+  afterEach(async () => {
+    await simplePgClient.client.end()
+  })
+
   test('basic test of initial values', async () => {
     const options: SimplePgClientOptions = {
       ...DEFAULT_OPTIONS,
       events: createConsoleLogEventHandlers(),
     }
-    const simplePgClient = await fn(options)
+    simplePgClient = await fn(options)
+  })
 
-    expect(simplePgClient).toBeDefined()
+  test('error handling', async () => {
+    let onErrorParams: any[]
+    let e: any
+    let result: any
 
-    await simplePgClient.client.end()
+    const options: SimplePgClientOptions = {
+      ...DEFAULT_OPTIONS,
+      events: {
+        ...createConsoleLogEventHandlers(),
+        onQueryError: (...params) => {
+          onErrorParams = params
+        },
+      },
+    }
+    simplePgClient = await fn(options)
+
+    try {
+      result = await simplePgClient.query('not a valid query')
+    }
+    catch (_e) {
+      e = _e
+    }
+
+    expect(e).toBeDefined()
+    expect(result).toBeUndefined()
+    const queryId = onErrorParams[0]
+    expect(onErrorParams[1]).toBe(`Executing SQL Failed (${queryId}): syntax error at or near "not"`)
+    expect(onErrorParams[2]).toBe('not a valid query')
+    expect(onErrorParams[3]).toBe(undefined)
   })
 })