@steadybrew/postgresjs 3.4.9 → 4.0.0

package/src/index.js

@@ -3,6 +3,7 @@ import fs from 'fs'
 
 import {
   mergeUserTypes,
+  addDefaultArrayTypes,
   inferType,
   Parameter,
   Identifier,
@@ -62,7 +63,7 @@ function Postgres(a, b) {
       , full = Queue()
       , queues = { connecting, reserved, closed, ended, open, busy, full }
 
-  const connections = [...Array(options.max)].map(() => Connection(options, queues, { onopen, onend, onclose }))
+  const connections = [...Array(options.max)].map(() => Connection(options, queues, { onopen, onend, onclose, ondrain }))
 
   const sql = Sql(handler)
 
@@ -200,58 +201,104 @@ function Postgres(a, b) {
     return await sql`select pg_notify(${ channel }, ${ '' + payload })`
   }
 
-  async function reserve() {
-    const queue = Queue()
-    const c = open.length
-      ? open.shift()
-      : await new Promise((resolve, reject) => {
-        const query = { reserve: resolve, reject }
-        queries.push(query)
-        closed.length && connect(closed.shift(), query)
-      })
+  async function lease(auto) {
+    if (ending)
+      throw Errors.connection('CONNECTION_ENDED', options)
+
+    const l = { connection: null, closed: null, onclose: null, reserved: null, queue: Queue() }
+    open.length
+      ? own(open.shift(), l)
+      : auto && !closed.length && busy.length
+        ? own(busy.shift(), l)
+        : await new Promise((resolve, reject) => {
+          const query = { reserve: c => resolve(own(c, l)), reject }
+          closed.length
+            ? connect(closed.shift(), query)
+            : queries.push(query)
+        })
+    return l
+  }
 
+  function own(c, l) {
+    l.connection = c
+    c.lease = l
     move(c, reserved)
-    c.reserved = () => queue.length
-      ? c.execute(queue.shift())
+    c.reserved = l.reserved = () => l.queue.length
+      ? c.execute(l.queue.shift())
       : move(c, reserved)
     c.reserved.release = true
+    return c
+  }
 
-    const sql = Sql(handler)
-    sql.release = () => {
-      c.reserved = null
-      onopen(c)
-    }
-
-    return sql
+  function valid(l) {
+    return !l.closed && l.connection.lease === l && l.connection.reserved === l.reserved
+  }
 
-    function handler(q) {
-      c.queue === full
-        ? queue.push(q)
+  function send(l, q) {
+    const c = l.connection
+    valid(l)
+      ? c.queue === full
+        ? l.queue.push(q)
         : c.execute(q) || move(c, full)
-    }
+      : q.reject(gone(l))
+  }
+
+  function gone(l) {
+    return Errors.connection(l.closed && l.closed.code === 'CONNECTION_ENDED' ? 'CONNECTION_ENDED' : 'CONNECTION_CLOSED', options)
+  }
+
+  function finish(l) {
+    const c = l.connection
+    if (l.closed || c.lease !== l)
+      return false
+
+    const held = c.reserved === l.reserved
+    c.lease = null
+    l.closed = Errors.connection('CONNECTION_ENDED', options)
+    held && (c.reserved = null)
+    while (l.queue.length)
+      l.queue.shift().reject(gone(l))
+    return held
+  }
+
+  async function reserve() {
+    const l = await lease(false)
+    const sql = Sql(q => send(l, q))
+    sql.release = () => finish(l) && l.connection.release()
+    return sql
   }
 
   async function begin(options, fn) {
     !fn && (fn = options, options = '')
-    const queries = Queue()
+    const l = await lease(true)
     let savepoints = 0
-      , connection
       , prepare = null
+      , settled = false
 
     try {
-      await sql.unsafe('begin ' + options.replace(/[^a-z ]/ig, ''), [], { onexecute }).execute()
-      return await Promise.race([
-        scope(connection, fn),
-        new Promise((_, reject) => connection.onclose = reject)
-      ])
-    } catch (error) {
-      throw error
+      const closing = new Promise((_, reject) => l.onclose = reject)
+      return await Promise.race([transaction(), closing])
+    } finally {
+      finish(l) && (settled ? l.connection.release() : l.connection.terminate())
+    }
+
+    async function transaction() {
+      await Sql(q => send(l, q)).unsafe('begin ' + options.replace(/[^a-z ]/ig, ''), []).execute().catch(e => {
+        e instanceof PostgresError && (settled = true)
+        throw e
+      })
+      return scope(fn)
     }
 
-    async function scope(c, fn, name) {
+    async function scope(fn, name) {
       const sql = Sql(handler)
       sql.savepoint = savepoint
-      sql.prepare = x => prepare = x.replace(/[^a-z0-9$-_. ]/gi)
+      sql.prepare = x => {
+        if (typeof x !== 'string' || !x || x.includes('\0'))
+          throw Errors.generic('INVALID_TRANSACTION_NAME', 'sql.prepare requires a non-empty string without null bytes')
+
+        prepare = 'E\'' + x.replace(/\\/g, '\\\\').replace(/'/g, '\'\'') + '\''
+      }
       let uncaughtError
         , result
 
@@ -265,17 +312,22 @@ function Postgres(a, b) {
         if (uncaughtError)
           throw uncaughtError
       } catch (e) {
-        await (name
+        l.closed || await (name
           ? sql`rollback to ${ sql(name) }`
           : sql`rollback`
         )
+        name || (settled = true)
         throw e instanceof PostgresError && e.code === '25P02' && uncaughtError || e
       }
 
+      if (l.closed)
+        throw l.closed
+
       if (!name) {
         prepare
-          ? await sql`prepare transaction '${ sql.unsafe(prepare) }'`
+          ? await sql`prepare transaction ${ sql.unsafe(prepare) }`
           : await sql`commit`
+        settled = true
       }
 
       return result
@@ -285,24 +337,14 @@ function Postgres(a, b) {
           return savepoint(sql => sql.apply(sql, arguments))
 
         arguments.length === 1 && (fn = name, name = null)
-        return scope(c, fn, 's' + savepoints++ + (name ? '_' + name : ''))
+        return scope(fn, 's' + savepoints++ + (name ? '_' + name : ''))
       }
 
       function handler(q) {
         q.catch(e => uncaughtError || (uncaughtError = e))
-        c.queue === full
-          ? queries.push(q)
-          : c.execute(q) || move(c, full)
+        send(l, q)
       }
     }
-
-    function onexecute(c) {
-      connection = c
-      move(c, reserved)
-      c.reserved = () => queries.length
-        ? c.execute(queries.shift())
-        : move(c, reserved)
-    }
   }
 
   function move(c, queue) {
@@ -368,13 +410,17 @@ function Postgres(a, b) {
 
     await 1
     let timer
-    return ending = Promise.race([
-      new Promise(r => timeout !== null && (timer = setTimeout(destroy, timeout * 1000, r))),
+    return ending = Promise.resolve().then(() => Promise.race([
+      new Promise(r => timeout !== null && (timer = setTimeout(() => destroy(r), timeout * 1000))),
       Promise.all(connections.map(c => c.end()).concat(
         listen.sql ? listen.sql.end({ timeout: 0 }) : [],
         subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []
       ))
-    ]).then(() => clearTimeout(timer))
+    ])).then(() => {
+      clearTimeout(timer)
+      while (queries.length)
+        queries.shift().reject(Errors.connection('CONNECTION_CLOSED', options))
+    })
   }
 
   async function close() {
@@ -382,9 +428,9 @@ function Postgres(a, b) {
   }
 
   async function destroy(resolve) {
-    await Promise.all(connections.map(c => c.terminate()))
     while (queries.length)
       queries.shift().reject(Errors.connection('CONNECTION_DESTROYED', options))
+    await Promise.all(connections.map(c => c.terminate()))
     resolve()
   }
 
@@ -398,7 +444,10 @@ function Postgres(a, b) {
     move(c, ended)
   }
 
-  function onopen(c) {
+  function onopen(c, initial) {
+    if (initial && initial.reserve)
+      return initial.reserve(move(c, reserved))
+
     if (queries.length === 0)
       return move(c, open)
 
@@ -408,7 +457,7 @@ function Postgres(a, b) {
     while (ready && queries.length && max-- > 0) {
       const query = queries.shift()
       if (query.reserve)
-        return query.reserve(c)
+        return query.reserve(move(c, reserved))
 
       ready = c.execute(query)
     }
@@ -418,12 +467,40 @@ function Postgres(a, b) {
       : move(c, full)
   }
 
+  function ondrain(c) {
+    if (!ending)
+      return false
+
+    let drained = false
+    let ready = true
+    while (ready && queries.length) {
+      const query = queries.shift()
+      query.reserve
+        ? query.reject(Errors.connection('CONNECTION_ENDED', options))
+        : (drained = true, ready = c.execute(query))
+    }
+    return drained
+  }
+
+  function abandon(l, e) {
+    l.connection.lease = null
+    l.closed = e || Errors.connection('CONNECTION_CLOSED', options)
+    while (l.queue.length)
+      l.queue.shift().reject(gone(l))
+    l.onclose && l.onclose(e)
+  }
+
   function onclose(c, e) {
     move(c, closed)
     c.reserved = null
-    c.onclose && (c.onclose(e), c.onclose = null)
+    c.lease && abandon(c.lease, e)
     options.onclose && options.onclose(c.id)
-    queries.length && connect(c, queries.shift())
+    if (ending) {
+      while (queries.length)
+        queries.shift().reject(e)
+    } else if (queries.length && c.queue === closed) {
+      connect(c, queries.shift())
+    }
   }
 }
 
@@ -462,7 +539,7 @@ function parseOptions(a, b) {
     target_session_attrs: null
   }
 
-  return {
+  const options = {
     host            : Array.isArray(host) ? host : host.split(',').map(x => x.split(':')[0]),
     port            : Array.isArray(port) ? port : host.split(',').map(x => parseInt(x.split(':')[1] || port)),
     path            : o.path || host.indexOf('/') > -1 && host + '/.s.PGSQL.' + port,
@@ -498,6 +575,9 @@ function parseOptions(a, b) {
     shared          : { retries: 0, typeArrayMap: {} },
     ...mergeUserTypes(o.types)
   }
+
+  !options.fetch_types && addDefaultArrayTypes(options)
+  return options
 }
 
 function tsa(o, url, env) {

package/src/types.js

@@ -190,6 +190,25 @@ function firstIsString(x) {
   return typeof x === 'string' ? 1009 : 0
 }
 
+const builtInArrays = [[16, 1000], [17, 1001], [18, 1002], [19, 1003], [20, 1016], [21, 1005], [23, 1007], [25, 1009],
+                       [26, 1028], [114, 199], [700, 1021], [701, 1022], [1042, 1014], [1043, 1015], [1082, 1182],
+                       [1083, 1183], [1114, 1115], [1184, 1185], [1186, 1187], [1700, 1231], [2950, 2951], [3802, 3807]]
+
+export function addDefaultArrayTypes(options) {
+  builtInArrays.forEach(([oid, typarray]) => addArrayType(options, oid, typarray))
+}
+
+export function addArrayType(options, oid, typarray) {
+  options.shared.typeArrayMap[oid] = typarray
+  if (!options.parsers[typarray]) {
+    const parser = options.parsers[oid]
+    options.parsers[typarray] = xs => arrayParser(xs, parser, typarray)
+    options.parsers[typarray].array = true
+  }
+  if (!options.serializers[typarray])
+    options.serializers[typarray] = xs => arraySerializer(xs, options.serializers[oid], options, typarray)
+}
+
 export const mergeUserTypes = function(types) {
   const user = typeHandlers(types || {})
   return {
@@ -278,6 +297,10 @@ export const arrayParser = function arrayParser(x, parser, typarray) {
   return arrayParserLoop(arrayParserState, x, parser, typarray)
 }
 
+function parseArrayValue(value, parser) {
+  return value === 'NULL' ? null : parser ? parser(value) : value
+}
+
 function arrayParserLoop(s, x, parser, typarray) {
   const xs = []
   // Only _box (1020) has the ';' delimiter for arrays, all other types use the ',' delimiter
@@ -302,16 +325,16 @@ function arrayParserLoop(s, x, parser, typarray) {
       xs.push(arrayParserLoop(s, x, parser, typarray))
     } else if (s.char === '}') {
       s.quoted = false
-      s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i))
+      s.last < s.i && xs.push(parseArrayValue(x.slice(s.last, s.i), parser))
       s.last = s.i + 1
       break
     } else if (s.char === delimiter && s.p !== '}' && s.p !== '"') {
-      xs.push(parser ? parser(x.slice(s.last, s.i)) : x.slice(s.last, s.i))
+      xs.push(parseArrayValue(x.slice(s.last, s.i), parser))
       s.last = s.i + 1
     }
     s.p = s.char
   }
-  s.last < s.i && xs.push(parser ? parser(x.slice(s.last, s.i + 1)) : x.slice(s.last, s.i + 1))
+  s.last < s.i && xs.push(parseArrayValue(x.slice(s.last, s.i + 1), parser))
   return xs
 }