feat(lib): always use pg-pool, support pool.end()

* Always use `Pool` from node-postgres.

Originally the library allows using the `Client` class from
node-postgres (by setting `pooled: false`) which is allegedly for when
we only need one DB connection that we manage manually, however it turns
out that using it directly is not the "happy path", and it's simpler to
just use a `Pool` with max size 1 (`pool.end()` ends connections
gracefully, among other things--`client.end()` ends ongoing queries
abruptly).

* Support `pool.end()` from the client.

Since we're dynamically creating pools in the server, we want the
library to be able to end unneeded pools. Note that in the typical use
case of one DB connection this isn't necessary--pools are closed when
the server stops.

Author: soedirgo

src/lib/PostgresMeta.ts

@@ -1,4 +1,4 @@
-import { ClientConfig } from 'pg'
+import { PoolConfig } from 'pg'
 import PostgresMetaColumns from './PostgresMetaColumns'
 import PostgresMetaConfig from './PostgresMetaConfig'
 import PostgresMetaExtensions from './PostgresMetaExtensions'
@@ -15,6 +15,7 @@ import { PostgresMetaResult } from './types'
 
 export default class PostgresMeta {
   query: (sql: string) => Promise<PostgresMetaResult<any>>
+  end: () => Promise<void>
   columns: PostgresMetaColumns
   config: PostgresMetaConfig
   extensions: PostgresMetaExtensions
@@ -27,8 +28,10 @@ export default class PostgresMeta {
   types: PostgresMetaTypes
   version: PostgresMetaVersion
 
-  constructor(config: ClientConfig) {
-    this.query = init(config)
+  constructor(config: PoolConfig) {
+    const { query, end } = init(config)
+    this.query = query
+    this.end = end
     this.columns = new PostgresMetaColumns(this.query)
     this.config = new PostgresMetaConfig(this.query)
     this.extensions = new PostgresMetaExtensions(this.query)

src/lib/db.ts

@@ -1,19 +1,44 @@
-import { types, Client, ClientConfig, Pool } from 'pg'
+import { types, Pool, PoolConfig } from 'pg'
 import { PostgresMetaResult } from './types'
 
 types.setTypeParser(20, parseInt)
 
-export const init = (
-  config: ClientConfig,
-  { pooled = true } = {}
-): ((sql: string) => Promise<PostgresMetaResult<any>>) => {
-  const client = pooled ? new Pool(config) : new Client(config)
-  return async (sql: string) => {
-    try {
-      const { rows } = await client.query(sql)
-      return { data: rows, error: null }
-    } catch (e) {
-      return { data: null, error: { message: e.message } }
-    }
+export const init: (
+  config: PoolConfig
+) => {
+  query: (sql: string) => Promise<PostgresMetaResult<any>>
+  end: () => Promise<void>
+} = (config) => {
+  // XXX: Race condition could happen here: one async task may be doing
+  // `pool.end()` which invalidates the pool and subsequently all existing
+  // handles to `query`. Normally you might only deal with one DB so you don't
+  // need to call `pool.end()`, but since the server needs this, we make a
+  // compromise: if we run `query` after `pool.end()` is called (i.e. pool is
+  // `null`), we temporarily create a pool and close is right after.
+  let pool: Pool | null = new Pool(config)
+  return {
+    async query(sql) {
+      try {
+        if (!pool) {
+          const pool = new Pool(config)
+          const { rows } = await pool.query(sql)
+          await pool.end()
+          return { data: rows, error: null }
+        }
+
+        const { rows } = await pool.query(sql)
+        return { data: rows, error: null }
+      } catch (e) {
+        return { data: null, error: { message: e.message } }
+      }
+    },
+
+    async end() {
+      const _pool = pool
+      pool = null
+      // Gracefully wait for active connections to be idle, then close all
+      // connections in the pool.
+      if (_pool) await _pool.end()
+    },
   }
 }