Build deno and cjs

Author: porsager

cjs/src/connection.js

@@ -359,7 +359,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function reconnect() {
-    setTimeout(connect, closedDate ? closedDate + delay - Date.now() : 0)
+    setTimeout(connect, closedDate ? closedDate + delay - Number(process.hrtime.bigint() / 1000000n) : 0)
   }
 
   function connected() {
@@ -446,7 +446,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       return reconnect()
 
     !hadError && (query || sent.length) && error(Errors.connection('CONNECTION_CLOSED', options, socket))
-    closedDate = Date.now()
+    closedDate = Number(process.hrtime.bigint() / 1000000n)
     hadError && options.shared.retries++
     delay = (typeof backoff === 'function' ? backoff(options.shared.retries) : backoff) * 1000
     onclose(connection)

cjs/src/query.js

@@ -118,6 +118,7 @@ const Query = module.exports.Query = class Query extends Promise {
 
   forEach(fn) {
     this.forEachFn = fn
+    this.handle()
     return this
   }
 

cjs/src/types.js

@@ -110,9 +110,28 @@ function values(first, rest, parameters, types, transform) {
   return valuesBuilder(multi ? first : [first], parameters, types, transform, columns)
 }
 
+function select(first, rest, parameters, types, transform) {
+  typeof first === 'string' && (first = [first].concat(rest))
+  if (Array.isArray(first))
+    return first.map(x => escapeIdentifier(transform.column.to ? transform.column.to(x) : x)).join(',')
+
+  let value
+  const columns = rest.length ? rest.flat() : Object.keys(first)
+  return columns.map(x => {
+    value = first[x]
+    return (
+      value instanceof Query ? value.strings[0] :
+      value instanceof Identifier ? value.value :
+      handleValue(value, parameters, types)
+    ) + ' as ' + escapeIdentifier(transform.column.to ? transform.column.to(x) : x)
+  }).join(',')
+}
+
 const builders = Object.entries({
   values,
   in: values,
+  select,
+  returning: select,
 
   update(first, rest, parameters, types, transform) {
     return (rest.length ? rest.flat() : Object.keys(first)).map(x =>
@@ -121,23 +140,6 @@ const builders = Object.entries({
     )
   },
 
-  select(first, rest, parameters, types, transform) {
-    typeof first === 'string' && (first = [first].concat(rest))
-    if (Array.isArray(first))
-      return first.map(x => escapeIdentifier(transform.column.to ? transform.column.to(x) : x)).join(',')
-
-    let value
-    const columns = rest.length ? rest.flat() : Object.keys(first)
-    return columns.map(x => {
-      value = first[x]
-      return (
-        value instanceof Query ? value.strings[0] :
-        value instanceof Identifier ? value.value :
-        handleValue(value, parameters, types)
-      ) + ' as ' + escapeIdentifier(transform.column.to ? transform.column.to(x) : x)
-    }).join(',')
-  },
-
   insert(first, rest, parameters, types, transform) {
     const columns = rest.length ? rest.flat() : Object.keys(Array.isArray(first) ? first[0] : first)
     return '(' + columns.map(x =>

cjs/tests/index.js

@@ -961,6 +961,15 @@ t('dynamic select array', async() => {
   return ['yay', (await sql`select ${ sql(['a', 'b']) } from test`)[0].b, await sql`drop table test`]
 })
 
+t('dynamic returning array', async() => {
+  await sql`create table test (a int, b text)`
+  return [
+    'yay',
+    (await sql`insert into test (a, b) values (42, 'yay') returning ${ sql(['a', 'b']) }`)[0].b,
+    await sql`drop table test`
+  ]
+})
+
 t('dynamic select args', async() => {
   await sql`create table test (a int, b text)`
   await sql`insert into test (a, b) values (42, 'yay')`

deno/README.md

@@ -64,6 +64,7 @@ async function insertUser({ name, age }) {
 * [Building queries](#building-queries)
 * [Advanced query methods](#advanced-query-methods)
 * [Transactions](#transactions)
+* [Data Transformation](#data-transformation)
 * [Listen & notify](#listen--notify)
 * [Realtime subscribe](#realtime-subscribe)
 * [Numbers, bigint, numeric](#numbers-bigint-numeric)
@@ -513,6 +514,38 @@ sql.begin('read write', async sql => {
 
 Do note that you can often achieve the same result using [`WITH` queries (Common Table Expressions)](https://www.postgresql.org/docs/current/queries-with.html) instead of using transactions.
 
+## Data Transformation
+
+`postgres.js` comes with a number of built-in data transformation functions that can be used to transform the data returned from a query or when inserting data. They are available under `transformation` option in the `postgres()` function connection options.
+
+Like - `postgres('connectionURL', { transformation: {...} })`
+
+### Parameters
+* `to`: The function to transform the outgoing query column name to, i.e ``SELECT ${ sql('aName') }` to `SELECT a_name` when using `postgres.toCamel`.
+* `from`: The function to transform the incoming query result column name to, see example below.
+
+> Both parameters are optional, if not provided, the default transformation function will be used.
+
+Built in transformation functions are:
+* For camelCase - `postgres.toCamel` and `postgres.fromCamel`
+* For PascalCase - `postgres.toPascal` and `postgres.fromPascal`
+* For Kebab-Case - `postgres.toKebab` and `postgres.fromKebab`
+
+These functions can be passed in as options when calling `postgres()`. For example -
+```js
+// this will tranform the column names to camel case back and forth
+(async function () {
+  const sql = postgres('connectionURL', { transform: { column: { to: postgres.fromCamel, from: postgres.toCamel } }});
+  await sql`CREATE TABLE IF NOT EXISTS camel_case (a_test INTEGER, b_test TEXT)`;
+  await sql`INSERT INTO camel_case ${ sql([{ aTest: 1, bTest: 1 }]) }`
+  const data = await sql`SELECT ${ sql('aTest', 'bTest') } FROM camel_case`;
+  console.log(data) // [ { aTest: 1, bTest: '1' } ]
+  process.exit(1)
+})();
+```
+
+> Note that if a column name is originally registered as snake_case in the database then to tranform it from camelCase to snake_case when querying or inserting, the column camelCase name must be put in `sql('columnName')` as it's done in the above example.
+
 ## Listen & notify
 
 When you call `.listen`, a dedicated connection will be created to ensure that you receive notifications instantly. This connection will be used for any further calls to `.listen`. The connection will automatically reconnect according to a backoff reconnection pattern to not overload the database server.
@@ -682,6 +715,23 @@ Connections are created lazily once a query is created. This means that simply d
 
 > No connection will be made until a query is made.
 
+For example:
+
+```js
+const sql = postgres() // no connections are opened
+
+await sql`...` // one connection is now opened
+await sql`...` // previous opened connection is reused
+
+// two connections are opened now
+await Promise.all([
+  sql`...`,
+  sql`...`
+])
+```
+
+> When there are high amount of concurrent queries, `postgres` will open as many connections as needed up until `max` number of connections is reached. By default `max` is 10. This can be changed by setting `max` in the `postgres()` call. Example - `postgres('connectionURL', { max: 20 })`.
+
 This means that we get a much simpler story for error handling and reconnections. Queries will be sent over the wire immediately on the next available connection in the pool. Connections are automatically taken out of the pool if you start a transaction using `sql.begin()`, and automatically returned to the pool once your transaction is done.
 
 Any query which was already sent over the wire will be rejected if the connection is lost. It'll automatically defer to the error handling you have for that query, and since connections are lazy it'll automatically try to reconnect the next time a query is made. The benefit of this is no weird generic "onerror" handler that tries to get things back to normal, and also simpler application code since you don't have to handle errors out of context.

deno/src/connection.js

@@ -1,5 +1,6 @@
 import { HmacSha256 } from 'https://deno.land/std@0.132.0/hash/sha256.ts'
 import { Buffer } from 'https://deno.land/std@0.132.0/node/buffer.ts'
+import process from 'https://deno.land/std@0.132.0/node/process.ts'
 import { setImmediate, clearImmediate } from '../polyfills.js'
 import { net } from '../polyfills.js'
 import { tls } from '../polyfills.js'
@@ -362,7 +363,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
   }
 
   function reconnect() {
-    setTimeout(connect, closedDate ? closedDate + delay - Date.now() : 0)
+    setTimeout(connect, closedDate ? closedDate + delay - Number(process.hrtime.bigint() / 1000000n) : 0)
   }
 
   function connected() {
@@ -449,7 +450,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       return reconnect()
 
     !hadError && (query || sent.length) && error(Errors.connection('CONNECTION_CLOSED', options, socket))
-    closedDate = Date.now()
+    closedDate = Number(process.hrtime.bigint() / 1000000n)
     hadError && options.shared.retries++
     delay = (typeof backoff === 'function' ? backoff(options.shared.retries) : backoff) * 1000
     onclose(connection)

deno/src/query.js

@@ -118,6 +118,7 @@ export class Query extends Promise {
 
   forEach(fn) {
     this.forEachFn = fn
+    this.handle()
     return this
   }
 

deno/src/types.js

@@ -111,9 +111,28 @@ function values(first, rest, parameters, types, transform) {
   return valuesBuilder(multi ? first : [first], parameters, types, transform, columns)
 }
 
+function select(first, rest, parameters, types, transform) {
+  typeof first === 'string' && (first = [first].concat(rest))
+  if (Array.isArray(first))
+    return first.map(x => escapeIdentifier(transform.column.to ? transform.column.to(x) : x)).join(',')
+
+  let value
+  const columns = rest.length ? rest.flat() : Object.keys(first)
+  return columns.map(x => {
+    value = first[x]
+    return (
+      value instanceof Query ? value.strings[0] :
+      value instanceof Identifier ? value.value :
+      handleValue(value, parameters, types)
+    ) + ' as ' + escapeIdentifier(transform.column.to ? transform.column.to(x) : x)
+  }).join(',')
+}
+
 const builders = Object.entries({
   values,
   in: values,
+  select,
+  returning: select,
 
   update(first, rest, parameters, types, transform) {
     return (rest.length ? rest.flat() : Object.keys(first)).map(x =>
@@ -122,23 +141,6 @@ const builders = Object.entries({
     )
   },
 
-  select(first, rest, parameters, types, transform) {
-    typeof first === 'string' && (first = [first].concat(rest))
-    if (Array.isArray(first))
-      return first.map(x => escapeIdentifier(transform.column.to ? transform.column.to(x) : x)).join(',')
-
-    let value
-    const columns = rest.length ? rest.flat() : Object.keys(first)
-    return columns.map(x => {
-      value = first[x]
-      return (
-        value instanceof Query ? value.strings[0] :
-        value instanceof Identifier ? value.value :
-        handleValue(value, parameters, types)
-      ) + ' as ' + escapeIdentifier(transform.column.to ? transform.column.to(x) : x)
-    }).join(',')
-  },
-
   insert(first, rest, parameters, types, transform) {
     const columns = rest.length ? rest.flat() : Object.keys(Array.isArray(first) ? first[0] : first)
     return '(' + columns.map(x =>

deno/tests/index.js

@@ -963,6 +963,15 @@ t('dynamic select array', async() => {
   return ['yay', (await sql`select ${ sql(['a', 'b']) } from test`)[0].b, await sql`drop table test`]
 })
 
+t('dynamic returning array', async() => {
+  await sql`create table test (a int, b text)`
+  return [
+    'yay',
+    (await sql`insert into test (a, b) values (42, 'yay') returning ${ sql(['a', 'b']) }`)[0].b,
+    await sql`drop table test`
+  ]
+})
+
 t('dynamic select args', async() => {
   await sql`create table test (a int, b text)`
   await sql`insert into test (a, b) values (42, 'yay')`