Add support for unsafe (raw) queries

porsager · porsager · commit e2a7b225222c · 2019-11-25T10:27:32.000+01:00
diff --git a/lib/index.js b/lib/index.js
@@ -37,7 +37,7 @@ export default function Postgres(url, options) {
       , typeArrayMap = {}
 
   function postgres(xs, ...args) {
-    return query(getConnection(), xs, args)
+    return query(false, getConnection(), xs, args)
   }
 
   Object.assign(postgres, {
@@ -74,7 +74,7 @@ export default function Postgres(url, options) {
     savepoint = ''
   }, connection) {
     begin && (connection.savepoints = 0)
-    addTypes(scoped)
+    addTypes(scoped, connection)
     scoped.savepoint = (name, fn) => new Promise((resolve, reject) => {
       transaction({
         savepoint: 'savepoint s' + connection.savepoints++ + '_' + (fn ? name : ''),
@@ -84,7 +84,7 @@ export default function Postgres(url, options) {
       }, connection)
     })
 
-    query(connection, raw(begin || savepoint))
+    query(true, connection, begin || savepoint)
       .then(() => {
         const result = fn(scoped)
         return (Array.isArray(result)
@@ -98,11 +98,11 @@ export default function Postgres(url, options) {
           : resolve(x)
       )
       .catch((err) => {
-        query(connection, raw(
+        query(true, connection,
           begin
             ? 'rollback'
             : 'rollback to ' + savepoint
-        ))
+        )
         .then(() => reject(err))
       })
       .then(() => {
@@ -111,7 +111,7 @@ export default function Postgres(url, options) {
       })
 
     function scoped(xs, ...args) {
-      return query(connection, xs, args).catch(err => {
+      return query(false, connection, xs, args).catch(err => {
         reject(err)
         throw err
       })
@@ -128,15 +128,15 @@ export default function Postgres(url, options) {
     while ((x = queries.shift()) && (c = getConnection(x.fn))) {
       x.fn
         ? transaction(x, c)
-        : c.send(x.query, parse(x.xs, x.args))
+        : send(c, x.query, x.xs, x.args)
     }
   }
 
-  function query(connection, xs, args) {
-    if (!Array.isArray(xs) || !Array.isArray(xs.raw))
+  function query(raw, connection, xs, args) {
+    if (!raw && (!Array.isArray(xs) || !Array.isArray(xs.raw)))
       throw errors.generic({ message: 'Query not called as a tagged template literal', code: 'NOT_TAGGED_CALL' })
 
-    const query = {}
+    const query = { raw }
 
     const promise = new Promise((resolve, reject) => {
       query.resolve = resolve
@@ -156,7 +156,7 @@ export default function Postgres(url, options) {
 
   function send(connection, query, xs, args) {
     connection
-      ? connection.send(query, parse(xs, args))
+      ? connection.send(query, query.raw ? parseRaw(xs, args) : parse(xs, args))
       : queries.push({ query, xs, args })
   }
 
@@ -179,11 +179,11 @@ export default function Postgres(url, options) {
 
   function instance({ fn }, connection) {
     let queries = 0
-    addTypes(scoped)
+    addTypes(scoped, connection)
     const container = fn(scoped)
     function scoped(xs, ...args) {
       queries++
-      const promise = query(connection, xs, args)
+      const promise = query(false, connection, xs, args)
       promise.then(finished, finished)
       return promise
     }
@@ -230,11 +230,11 @@ export default function Postgres(url, options) {
   function fetchArrayTypes(connection) {
     return arrayTypesPromise || (arrayTypesPromise =
       new Promise((resolve, reject) => {
-        send(connection, { resolve, reject }, raw(`
+        send(connection, { resolve, reject, raw: true }, `
           select oid, typelem
           from pg_catalog.pg_type
           where typcategory = 'A'
-        `))
+        `)
       }).then(types => {
         types.forEach(({ oid, typelem }) => addArrayType(oid, typelem))
         ready = true
@@ -251,9 +251,10 @@ export default function Postgres(url, options) {
     options.serializers[oid] = (xs) => arraySerializer(xs, serializer)
   }
 
-  function addTypes(instance) {
+  function addTypes(instance, connection) {
     Object.assign(instance, {
       notify: (channel, payload) => instance`select pg_notify(${ channel }, ${ String(payload) })`,
+      unsafe: (xs, args) => query(true, connection || getConnection(), xs, args),
       array,
       rows,
       row,
@@ -276,7 +277,7 @@ export default function Postgres(url, options) {
       ? listeners[x].push(fn)
       : (listeners[x] = [fn])
 
-    return query(getListener(), raw('listen "' + x + '"')).then(() => x)
+    return query(true, getListener(), 'listen "' + x + '"').then(() => x)
   }
 
   function getListener() {
@@ -311,6 +312,21 @@ export default function Postgres(url, options) {
     .then(() => clearTimeout(destroy))
   }
 
+  function parseRaw(str, args = []) {
+    const types = []
+        , xargs = args.map(x => {
+          const type = getType(x)
+          types.push(type.type)
+          return type
+        })
+
+    return {
+      sig: types + str,
+      str,
+      args: xargs
+    }
+  }
+
   function parse(xs, args = []) {
     const xargs = []
         , types = []
@@ -345,16 +361,21 @@ export default function Postgres(url, options) {
   }
 
   function parseValue(x, xargs, types) {
+    const type = getType(x)
+    types.push(type.type)
+    return '$' + xargs.push(type)
+  }
+
+  function getType(x) {
     const value = x.value ? x.value : x
         , type = x.type || (Array.isArray(value) ? typeArrayMap[inferType(value)] : inferType(value))
 
-    types.push(type)
-    return '$' + xargs.push({
+    return {
       type,
       value: type
         ? (options.serializers[type] || types.string.serialize)(value)
         : value
-    })
+    }
   }
 }
 
