build

Author: porsager

cf/src/connection.js

@@ -295,7 +295,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     if (incomings) {
       incomings.push(x)
       remaining -= x.length
-      if (remaining >= 0)
+      if (remaining > 0)
         return
     }
 
@@ -383,10 +383,13 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function errored(err) {
     stream && (stream.destroy(err), stream = null)
     query && queryError(query, err)
-    initial && (queryError(initial, err), initial = null)
+    initial && (initial.reserve ? initial.reject(err) : queryError(initial, err), initial = null)
   }
 
   function queryError(query, err) {
+    if (!err || typeof err !== 'object')
+      err = new Error(err)
+
     'query' in err || 'parameters' in err || Object.defineProperties(err, {
       stack: { value: err.stack + query.origin.replace(/.*\n/, '\n'), enumerable: options.debug },
       query: { value: query.string, enumerable: options.debug },

cf/src/index.js

@@ -205,9 +205,10 @@ function Postgres(a, b) {
     const queue = Queue()
     const c = open.length
       ? open.shift()
-      : await new Promise(r => {
-        queries.push({ reserve: r })
-        closed.length && connect(closed.shift())
+      : await new Promise((resolve, reject) => {
+        const query = { reserve: resolve, reject }
+        queries.push(query)
+        closed.length && connect(closed.shift(), query)
       })
 
     move(c, reserved)
@@ -481,7 +482,7 @@ function parseOptions(a, b) {
       {}
     ),
     connection      : {
-      application_name: 'postgres.js',
+      application_name: env.PGAPPNAME || 'postgres.js',
       ...o.connection,
       ...Object.entries(query).reduce((acc, [k, v]) => (k in defaults || (acc[k] = v), acc), {})
     },

cjs/src/connection.js

@@ -293,7 +293,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     if (incomings) {
       incomings.push(x)
       remaining -= x.length
-      if (remaining >= 0)
+      if (remaining > 0)
         return
     }
 
@@ -381,10 +381,13 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function errored(err) {
     stream && (stream.destroy(err), stream = null)
     query && queryError(query, err)
-    initial && (queryError(initial, err), initial = null)
+    initial && (initial.reserve ? initial.reject(err) : queryError(initial, err), initial = null)
   }
 
   function queryError(query, err) {
+    if (!err || typeof err !== 'object')
+      err = new Error(err)
+
     'query' in err || 'parameters' in err || Object.defineProperties(err, {
       stack: { value: err.stack + query.origin.replace(/.*\n/, '\n'), enumerable: options.debug },
       query: { value: query.string, enumerable: options.debug },

cjs/src/index.js

@@ -204,9 +204,10 @@ function Postgres(a, b) {
     const queue = Queue()
     const c = open.length
       ? open.shift()
-      : await new Promise(r => {
-        queries.push({ reserve: r })
-        closed.length && connect(closed.shift())
+      : await new Promise((resolve, reject) => {
+        const query = { reserve: resolve, reject }
+        queries.push(query)
+        closed.length && connect(closed.shift(), query)
       })
 
     move(c, reserved)
@@ -480,7 +481,7 @@ function parseOptions(a, b) {
       {}
     ),
     connection      : {
-      application_name: 'postgres.js',
+      application_name: env.PGAPPNAME || 'postgres.js',
       ...o.connection,
       ...Object.entries(query).reduce((acc, [k, v]) => (k in defaults || (acc[k] = v), acc), {})
     },

cjs/tests/index.js

@@ -429,6 +429,30 @@ t('Reconnect using SSL', { timeout: 2 }, async() => {
   return [1, (await sql`select 1 as x`)[0].x]
 })
 
+t('Proper handling of non object Errors', async() => {
+  const sql = postgres({ socket: () => { throw 'wat' } }) // eslint-disable
+
+  return [
+    'wat', await sql`select 1 as x`.catch(e => e.message)
+  ]
+})
+
+t('Proper handling of null Errors', async() => {
+  const sql = postgres({ socket: () => { throw null } }) // eslint-disable
+
+  return [
+    'null', await sql`select 1 as x`.catch(e => e.message)
+  ]
+})
+
+t('Ensure reserve throws proper error', async() => {
+  const sql = postgres({ socket: () => { throw 'wat' }, idle_timeout }) // eslint-disable
+
+  return [
+    'wat', await sql.reserve().catch(e => e)
+  ]
+})
+
 t('Login without password', async() => {
   return [true, (await postgres({ ...options, ...login })`select true as x`)[0].x]
 })

deno/README.md

@@ -338,6 +338,27 @@ select * from users
 select * from users where user_id = $1
 ```
 
+### Dynamic ordering
+
+```js
+const id = 1
+const order = {
+  username: 'asc'
+  created_at: 'desc'
+}
+await sql`
+  select 
+    * 
+  from ticket 
+  where account = ${ id }  
+  order by ${
+    Object.entries(order).flatMap(([column, order], i) =>
+      [i ? sql`,` : sql``, sql`${ sql(column) } ${ order === 'desc' ? sql`desc` : sql`asc` }`]
+    )
+  }
+`
+```
+
 ### SQL functions
 Using keywords or calling functions dynamically is also possible by using ``` sql`` ``` fragments.
 ```js
@@ -564,6 +585,8 @@ If you know what you're doing, you can use `unsafe` to pass any string you'd lik
 sql.unsafe('select ' + danger + ' from users where id = ' + dragons)
 ```
 
+By default, `sql.unsafe` assumes the `query` string is sufficiently dynamic that prepared statements do not make sense, and so defaults them to off. If you'd like to re-enable prepared statements, you can pass `{ prepare: true }`.
+
 You can also nest `sql.unsafe` within a safe `sql` expression.  This is useful if only part of your fraction has unsafe elements.
 
 ```js
@@ -1121,20 +1144,25 @@ It is also possible to connect to the database without a connection string or an
 const sql = postgres()
 ```
 
-| Option            | Environment Variables    |
-| ----------------- | ------------------------ |
-| `host`            | `PGHOST`                 |
-| `port`            | `PGPORT`                 |
-| `database`        | `PGDATABASE`             |
-| `username`        | `PGUSERNAME` or `PGUSER` |
-| `password`        | `PGPASSWORD`             |
-| `idle_timeout`    | `PGIDLE_TIMEOUT`         |
-| `connect_timeout` | `PGCONNECT_TIMEOUT`      |
+| Option             | Environment Variables    |
+| ------------------ | ------------------------ |
+| `host`             | `PGHOST`                 |
+| `port`             | `PGPORT`                 |
+| `database`         | `PGDATABASE`             |
+| `username`         | `PGUSERNAME` or `PGUSER` |
+| `password`         | `PGPASSWORD`             |
+| `application_name` | `PGAPPNAME`              |
+| `idle_timeout`     | `PGIDLE_TIMEOUT`         |
+| `connect_timeout`  | `PGCONNECT_TIMEOUT`      |
 
 ### Prepared statements
 
 Prepared statements will automatically be created for any queries where it can be inferred that the query is static. This can be disabled by using the `prepare: false` option. For instance — this is useful when [using PGBouncer in `transaction mode`](https://github.com/porsager/postgres/issues/93#issuecomment-656290493).
 
+**update**: [since 1.21.0](https://www.pgbouncer.org/2023/10/pgbouncer-1-21-0)
+PGBouncer supports protocol-level named prepared statements when [configured
+properly](https://www.pgbouncer.org/config.html#max_prepared_statements)
+
 ## Custom Types
 
 You can add ergonomic support for custom types, or simply use `sql.typed(value, type)` inline, where type is the PostgreSQL `oid` for the type and the correctly serialized string. _(`oid` values for types can be found in the `pg_catalog.pg_type` table.)_
@@ -1294,8 +1322,8 @@ This error is thrown if the user has called [`sql.end()`](#teardown--cleanup) an
 
 This error is thrown for any queries that were pending when the timeout to [`sql.end({ timeout: X })`](#teardown--cleanup) was reached.
 
-##### CONNECTION_CONNECT_TIMEOUT
-> write CONNECTION_CONNECT_TIMEOUT host:port
+##### CONNECT_TIMEOUT
+> write CONNECT_TIMEOUT host:port
 
 This error is thrown if the startup phase of the connection (tcp, protocol negotiation, and auth) took more than the default 30 seconds or what was specified using `connect_timeout` or `PGCONNECT_TIMEOUT`.
 

deno/src/connection.js

@@ -296,7 +296,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
     if (incomings) {
       incomings.push(x)
       remaining -= x.length
-      if (remaining >= 0)
+      if (remaining > 0)
         return
     }
 
@@ -384,10 +384,13 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   function errored(err) {
     stream && (stream.destroy(err), stream = null)
     query && queryError(query, err)
-    initial && (queryError(initial, err), initial = null)
+    initial && (initial.reserve ? initial.reject(err) : queryError(initial, err), initial = null)
   }
 
   function queryError(query, err) {
+    if (!err || typeof err !== 'object')
+      err = new Error(err)
+
     'query' in err || 'parameters' in err || Object.defineProperties(err, {
       stack: { value: err.stack + query.origin.replace(/.*\n/, '\n'), enumerable: options.debug },
       query: { value: query.string, enumerable: options.debug },

deno/src/index.js

@@ -205,9 +205,10 @@ function Postgres(a, b) {
     const queue = Queue()
     const c = open.length
       ? open.shift()
-      : await new Promise(r => {
-        queries.push({ reserve: r })
-        closed.length && connect(closed.shift())
+      : await new Promise((resolve, reject) => {
+        const query = { reserve: resolve, reject }
+        queries.push(query)
+        closed.length && connect(closed.shift(), query)
       })
 
     move(c, reserved)
@@ -481,7 +482,7 @@ function parseOptions(a, b) {
       {}
     ),
     connection      : {
-      application_name: 'postgres.js',
+      application_name: env.PGAPPNAME || 'postgres.js',
       ...o.connection,
       ...Object.entries(query).reduce((acc, [k, v]) => (k in defaults || (acc[k] = v), acc), {})
     },

deno/tests/index.js

@@ -431,6 +431,30 @@ t('Reconnect using SSL', { timeout: 2 }, async() => {
   return [1, (await sql`select 1 as x`)[0].x]
 })
 
+t('Proper handling of non object Errors', async() => {
+  const sql = postgres({ socket: () => { throw 'wat' } }) // eslint-disable
+
+  return [
+    'wat', await sql`select 1 as x`.catch(e => e.message)
+  ]
+})
+
+t('Proper handling of null Errors', async() => {
+  const sql = postgres({ socket: () => { throw null } }) // eslint-disable
+
+  return [
+    'null', await sql`select 1 as x`.catch(e => e.message)
+  ]
+})
+
+t('Ensure reserve throws proper error', async() => {
+  const sql = postgres({ socket: () => { throw 'wat' }, idle_timeout }) // eslint-disable
+
+  return [
+    'wat', await sql.reserve().catch(e => e)
+  ]
+})
+
 t('Login without password', async() => {
   return [true, (await postgres({ ...options, ...login })`select true as x`)[0].x]
 })

deno/types/index.d.ts

@@ -458,7 +458,8 @@ declare namespace postgres {
     | 'NOT_TAGGED_CALL'
     | 'UNDEFINED_VALUE'
     | 'MAX_PARAMETERS_EXCEEDED'
-    | 'SASL_SIGNATURE_MISMATCH';
+    | 'SASL_SIGNATURE_MISMATCH'
+    | 'UNSAFE_TRANSACTION';
     message: string;
   }