Build deno and cjs

Author: porsager

cjs/src/connection.js

@@ -268,7 +268,11 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       socket,
       ...(ssl === 'require' || ssl === 'allow' || ssl === 'prefer'
         ? { rejectUnauthorized: false }
-        : ssl
+        : ssl === 'verify-full'
+        ? {}
+        : typeof ssl === 'object'
+        ? ssl
+        : {}
       )
     })
     socket.on('secureConnect', connected)
@@ -565,7 +569,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       return errored(Errors.generic('UNSAFE_TRANSACTION', 'Only use sql.begin or max: 1'))
 
     if (query.options.simple)
-      return
+      return BindComplete()
 
     if (query.cursorFn) {
       result.count && query.cursorFn(result)

cjs/src/index.js

@@ -376,44 +376,62 @@ function parseOptions(a, b) {
   const env = process.env // eslint-disable-line
       , o = (typeof a === 'string' ? b : a) || {}
       , { url, multihost } = parseUrl(a)
-      , query = url.searchParams
+      , query = [...url.searchParams].reduce((a, [b, c]) => (a[b] = c, a), {})
       , host = o.hostname || o.host || multihost || url.hostname || env.PGHOST || 'localhost'
       , port = o.port || url.port || env.PGPORT || 5432
       , user = o.user || o.username || url.username || env.PGUSERNAME || env.PGUSER || osUsername()
 
-  return Object.assign({
+  o.no_prepare && (o.prepare = false)
+  query.sslmode && (query.ssl = query.sslmode, delete query.sslmode)
+  'timeout' in o && (console.log('The timeout option is deprecated, use idle_timeout instead'), o.idle_timeout = o.timeout) // eslint-disable-line
+
+  const defaults = {
+    max             : 10,
+    ssl             : false,
+    idle_timeout    : null,
+    connect_timeout : 30,
+    max_lifetime    : max_lifetime,
+    max_pipeline    : 100,
+    backoff         : backoff,
+    keep_alive      : 60,
+    prepare         : true,
+    debug           : false,
+    fetch_types     : true,
+    publications    : 'alltables'
+  }
+
+  return {
     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,
     database        : o.database || o.db || (url.pathname || '').slice(1) || env.PGDATABASE || user,
     user            : user,
     pass            : o.pass || o.password || url.password || env.PGPASSWORD || '',
-    max             : o.max || query.get('max') || 10,
+    ...Object.entries(defaults).reduce((acc, [k, d]) =>
+      (acc[k] = k in o ? o[k] : k in query
+        ? (query[k] === 'disable' || query[k] === 'false' ? false : query[k])
+        : env['PG' + k.toUpperCase()] || d,
+      acc
+      ),
+      {}
+    ),
+    connection      : {
+      application_name: 'postgres.js',
+      ...o.connection,
+      ...Object.entries(query).reduce((acc, [k, v]) => (k in defaults || (acc[k] = v), acc), {})
+    },
     types           : o.types || {},
-    ssl             : o.ssl || parseSSL(query.get('sslmode') || query.get('ssl')) || false,
-    idle_timeout    : o.idle_timeout || query.get('idle_timeout') || env.PGIDLE_TIMEOUT || warn(o.timeout),
-    connect_timeout : o.connect_timeout || query.get('connect_timeout') || env.PGCONNECT_TIMEOUT || 30,
-    max_lifetime    : o.max_lifetime || url.max_lifetime || max_lifetime,
-    max_pipeline    : o.max_pipeline || url.max_pipeline || 100,
-    backoff         : o.backoff || url.backoff || backoff,
-    keep_alive      : o.keep_alive || url.keep_alive || 60,
-    prepare         : 'prepare' in o ? o.prepare : 'no_prepare' in o ? !o.no_prepare : true,
+    target_session_attrs: tsa(o, url, env),
     onnotice        : o.onnotice,
     onnotify        : o.onnotify,
     onclose         : o.onclose,
     onparameter     : o.onparameter,
-    transform       : parseTransform(o.transform || { undefined: undefined }),
-    connection      : Object.assign({ application_name: 'postgres.js' }, o.connection),
-    target_session_attrs: tsa(o, url, env),
-    debug           : o.debug,
     socket          : o.socket,
-    fetch_types     : 'fetch_types' in o ? o.fetch_types : true,
+    transform       : parseTransform(o.transform || { undefined: undefined }),
     parameters      : {},
     shared          : { retries: 0, typeArrayMap: {} },
-    publications    : o.publications || query.get('publications') || 'alltables'
-  },
-    mergeUserTypes(o.types)
-  )
+    ...mergeUserTypes(o.types)
+  }
 }
 
 function tsa(o, url, env) {
@@ -450,30 +468,20 @@ function parseTransform(x) {
   }
 }
 
-function parseSSL(x) {
-  return x !== 'disable' && x !== 'false' && x
-}
-
 function parseUrl(url) {
   if (typeof url !== 'string')
     return { url: { searchParams: new Map() } }
 
   let host = url
-  host = host.slice(host.indexOf('://') + 3)
-  host = host.split(/[?/]/)[0]
-  host = host.slice(host.indexOf('@') + 1)
+  host = host.slice(host.indexOf('://') + 3).split(/[?/]/)[0]
+  host = decodeURIComponent(host.slice(host.indexOf('@') + 1))
 
   return {
     url: new URL(url.replace(host, host.split(',')[0])),
     multihost: host.indexOf(',') > -1 && host
   }
 }
 
-function warn(x) {
-  typeof x !== 'undefined' && console.log('The timeout option is deprecated, use idle_timeout instead') // eslint-disable-line
-  return x
-}
-
 function osUsername() {
   try {
     return os.userInfo().username // eslint-disable-line

cjs/src/subscribe.js

@@ -212,7 +212,7 @@ function parse(x, state, parsers, handle) {
       old && (i = tuples(x, old, key ? relation.keys : relation.columns, i += 3))
 
       const row = {}
-      i = tuples(x, row, relation.columns, i + 3)
+      tuples(x, row, relation.columns, i + 3)
 
       handle(row, {
         command: 'update',

cjs/src/types.js

@@ -99,6 +99,7 @@ const defaultHandlers = typeHandlers(types)
 module.exports.stringify = stringify;function stringify(q, string, value, parameters, types, options) { // eslint-disable-line
   for (let i = 1; i < q.strings.length; i++) {
     string += (
+      value && value[0] instanceof Query ? value.reduce((acc, x) => acc + ' ' + fragment(x, parameters, types), '') :
       value instanceof Query ? fragment(value, parameters, types) :
       value instanceof Identifier ? value.value :
       value instanceof Builder ? value.build(string, parameters, types, options) :

cjs/tests/index.js

@@ -612,6 +612,10 @@ t('unsafe simple', async() => {
   return [1, (await sql.unsafe('select 1 as x'))[0].x]
 })
 
+t('unsafe simple includes columns', async() => {
+  return ['x', (await sql.unsafe('select 1 as x').values()).columns[0].name]
+})
+
 t('listen and notify', async() => {
   const sql = postgres(options)
   const channel = 'hello'
@@ -1812,7 +1816,7 @@ t('subscribe reconnects and calls onsubscribe', { timeout: 4 }, async() => {
   await subscribeSql.close()
   await delay(500)
   await sql`delete from test`
-  await delay(10)
+  await delay(100)
   await unsubscribe()
   return [
     '2insert,Murray,,delete,1,',
@@ -2096,3 +2100,14 @@ t('Supports nested fragments with parameters', async() => {
     await sql`drop table test`
   ]
 })
+
+t('Supports arrays of fragments', async() => {
+  const [{ x }] = await sql`
+    ${ [sql`select`, sql`1`, sql`as`, sql`x`] }
+  `
+
+  return [
+    1,
+    x
+  ]
+})

cjs/tests/test.js

@@ -13,7 +13,7 @@ const tests = {}
 const nt = module.exports.nt = () => ignored++
 const ot = module.exports.ot = (...rest) => (only = true, test(true, ...rest))
 const t = module.exports.t = (...rest) => test(false, ...rest)
-t.timeout = 0.5
+t.timeout = 1
 
 async function test(o, name, options, fn) {
   typeof options !== 'object' && (fn = options, options = {})

deno/README.md

@@ -68,6 +68,7 @@ async function insertUser({ name, age }) {
 * [Listen & notify](#listen--notify)
 * [Realtime subscribe](#realtime-subscribe)
 * [Numbers, bigint, numeric](#numbers-bigint-numeric)
+* [Result Array](#result-array)
 * [Connection details](#connection-details)
 * [Custom Types](#custom-types)
 * [Teardown / Cleanup](#teardown--cleanup)
@@ -336,7 +337,7 @@ await sql`
 `.cursor(async([row]) => {
   // row = { x: 1 }
   await http.request('https://example.com/wat', { row })
-}
+})
 ```
 
 ##### for await...of
@@ -361,7 +362,7 @@ await sql`
   await Promise.all(rows.map(row =>
     http.request('https://example.com/wat', { row })
   ))
-}
+})
 ```
 
 If an error is thrown inside the callback function no more rows will be requested and the outer promise will reject with the thrown error.
@@ -421,6 +422,53 @@ Using a file for a query is also supported with optional parameters to use if th
 const result = await sql.file('query.sql', ['Murray', 68])
 ```
 
+### Copy to/from as Streams
+
+Postgres.js supports [`COPY ...`](https://www.postgresql.org/docs/14/sql-copy.html) queries, which are exposed as [Node.js streams](https://nodejs.org/api/stream.html).
+
+#### ```await sql`copy ... from stdin`.writable() -> Writable```
+
+```js
+import { pipeline } from 'node:stream/promises'
+
+// Stream of users with the default tab delimitated cells and new-line delimitated rows
+const userStream = Readable.from([
+  'Murray\t68\n',
+  'Walter\t80\n'
+])
+
+const query = await sql`copy users (name, age) from stdin`.writable()
+await pipeline(userStream, query);
+```
+
+#### ```await sql`copy ... to stdout`.readable() -> Readable```
+
+##### Using Stream Pipeline
+```js
+import { pipeline } from 'node:stream/promises'
+import { createWriteStream } from 'node:fs'
+
+const readableStream = await sql`copy users (name, age) to stdout`.readable()
+await pipeline(readableStream, createWriteStream('output.tsv'))
+// output.tsv content: `Murray\t68\nWalter\t80\n`
+```
+
+##### Using `for await...of`
+```js
+const readableStream = await sql`
+  copy (
+    select name, age 
+    from users 
+    where age = 68
+  ) to stdout
+`.readable()
+for await (const chunk of readableStream) {
+  // chunk.toString() === `Murray\t68\n`
+}
+```
+
+> **NOTE** This is a low-level API which does not provide any type safety. To make this work, you must match your [`copy query` parameters](https://www.postgresql.org/docs/14/sql-copy.html) correctly to your [Node.js stream read or write](https://nodejs.org/api/stream.html) code. Ensure [Node.js stream backpressure](https://nodejs.org/en/docs/guides/backpressuring-in-streams/) is handled correctly to avoid memory exhaustion.
+
 ### Canceling Queries in Progress
 
 Postgres.js supports, [canceling queries in progress](https://www.postgresql.org/docs/7.1/protocol-protocol.html#AEN39000). It works by opening a new connection with a protocol level startup message to cancel the current query running on a specific connection. That means there is no guarantee that the query will be canceled, and due to the possible race conditions it might even result in canceling another query. This is fine for long running queries, but in the case of high load and fast queries it might be better to simply ignore results instead of canceling.
@@ -657,6 +705,46 @@ const sql = postgres({
 
 There is currently no guaranteed way to handle `numeric` / `decimal` types in native Javascript. **These [and similar] types will be returned as a `string`**. The best way in this case is to use  [custom types](#custom-types).
 
+## Result Array
+
+The `Result` Array returned from queries is a custom array allowing for easy destructuring or passing on directly to JSON.stringify or general Array usage. It includes the following properties.
+
+### .count
+
+The `count` property is the number of affected rows returned by the database. This is usefull for insert, update and delete operations to know the number of rows since .length will be 0 in these cases if not using `RETURNING ...`.
+
+### .command
+
+The `command` run by the query - eg. one of `SELECT`, `UPDATE`, `INSERT`, `DELETE`
+
+### .columns
+
+The `columns` returned by the query useful to determine types, or map to the result values when using `.values()`
+
+```js
+{
+  name  : String,    // Column name,
+  type  : oid,       // PostgreSQL oid column type
+  parser: Function   // The function used by Postgres.js for parsing
+}
+```
+
+### .statement
+
+The `statement` contains information about the statement implicitly created by Postgres.js.
+
+```js
+{
+  name    : String,  // The auto generated statement name
+  string  : String,  // The actual query string executed
+  types   : [oid],   // An array of oid expected as input parameters
+  columns : [Column] // Array of columns - same as Result.columns
+}
+```
+
+### .state
+
+This is the state `{ pid, secret }` of the connection that executed the query.
 
 ## Connection details
 
@@ -675,7 +763,7 @@ const sql = postgres('postgres://username:password@host:port/database', {
   max_lifetime         : null,          // Max lifetime in seconds (more info below)
   idle_timeout         : 0,             // Idle connection timeout in seconds
   connect_timeout      : 30,            // Connect timeout in seconds
-  no_prepare           : false,         // No automatic creation of prepared statements
+  prepare              : true,          // Automatic creation of prepared statements
   types                : [],            // Array of custom types, see more below
   onnotice             : fn,            // Defaults to console.log
   onparameter          : fn,            // (key, value) when server param change

deno/src/connection.js

@@ -272,7 +272,11 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       socket,
       ...(ssl === 'require' || ssl === 'allow' || ssl === 'prefer'
         ? { rejectUnauthorized: false }
-        : ssl
+        : ssl === 'verify-full'
+        ? {}
+        : typeof ssl === 'object'
+        ? ssl
+        : {}
       )
     })
     socket.on('secureConnect', connected)
@@ -569,7 +573,7 @@ function Connection(options, queues = {}, { onopen = noop, onend = noop, onclose
       return errored(Errors.generic('UNSAFE_TRANSACTION', 'Only use sql.begin or max: 1'))
 
     if (query.options.simple)
-      return
+      return BindComplete()
 
     if (query.cursorFn) {
       result.count && query.cursorFn(result)