orcaq 1.0.21 → 1.0.26

package/.output/server/node_modules/pg-copy-streams/copy-from.js

@@ -0,0 +1,173 @@
+'use strict'
+
+module.exports = function (txt, options) {
+  return new CopyStreamQuery(txt, options)
+}
+
+const { Writable } = require('stream')
+const code = require('./message-formats')
+
+class CopyStreamQuery extends Writable {
+  constructor(text, options) {
+    super(options)
+    this.text = text
+    this.rowCount = 0
+    this._gotCopyInResponse = false
+    this.chunks = []
+    this.cb_CopyInResponse = null
+    this.cb_ReadyForQuery = null
+    this.cb_destroy = null
+    this.cork()
+  }
+
+  submit(connection) {
+    this.connection = connection
+    connection.query(this.text)
+  }
+
+  callback() {
+    // this callback is empty but defining it allows
+    // `pg` to discover it and overwrite it
+    // with its timeout mechanism when query_timeout config is set
+  }
+
+  _write(chunk, enc, cb) {
+    this.chunks.push({ chunk: chunk, encoding: enc })
+    if (this._gotCopyInResponse) {
+      return this.flush(cb)
+    }
+    this.cb_CopyInResponse = cb
+  }
+
+  _writev(chunks, cb) {
+    // this.chunks.push(...chunks)
+    // => issue #136, RangeError: Maximum call stack size exceeded
+    // Using hybrid approach as advised on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply
+    if (this.chunks.length == 0) {
+      this.chunks = chunks
+    } else {
+      // https://stackoverflow.com/questions/22747068/is-there-a-max-number-of-arguments-javascript-functions-can-accept
+      // 100K seems to be a reasonable size for v8
+      const QUANTUM = 125000
+      for (let i = 0; i < chunks.length; i += QUANTUM) {
+        this.chunks.push(...chunks.slice(i, Math.min(i + QUANTUM, chunks.length)))
+      }
+    }
+    if (this._gotCopyInResponse) {
+      return this.flush(cb)
+    }
+    this.cb_CopyInResponse = cb
+  }
+
+  _destroy(err, cb) {
+    // writable.destroy([error]) was called.
+    // send a CopyFail message that will rollback the COPY operation.
+    // the cb will be called only after the ErrorResponse message is received
+    // from the backend
+    if (this.cb_ReadyForQuery) return cb(err)
+    this.cb_destroy = cb
+    const msg = err ? err.message : 'NODE-PG-COPY-STREAMS destroy() was called'
+    const self = this
+    const done = function () {
+      self.connection.sendCopyFail(msg)
+    }
+
+    this.chunks = []
+    if (this._gotCopyInResponse) {
+      return this.flush(done)
+    }
+    this.cb_CopyInResponse = done
+  }
+
+  _final(cb) {
+    this.cb_ReadyForQuery = cb
+    const self = this
+    const done = function () {
+      const Int32Len = 4
+      const finBuffer = Buffer.from([code.CopyDone, 0, 0, 0, Int32Len])
+      self.connection.stream.write(finBuffer)
+    }
+
+    if (this._gotCopyInResponse) {
+      return this.flush(done)
+    }
+    this.cb_CopyInResponse = done
+  }
+
+  flush(callback) {
+    let chunk
+    let ok = true
+    while (ok && (chunk = this.chunks.shift())) {
+      ok = this.flushChunk(chunk.chunk)
+    }
+    if (callback) {
+      if (ok) {
+        callback()
+      } else {
+        if (this.chunks.length) {
+          this.connection.stream.once('drain', this.flush.bind(this, callback))
+        } else {
+          this.connection.stream.once('drain', callback)
+        }
+      }
+    }
+  }
+
+  flushChunk(chunk) {
+    const Int32Len = 4
+    const lenBuffer = Buffer.from([code.CopyData, 0, 0, 0, 0])
+    lenBuffer.writeUInt32BE(chunk.length + Int32Len, 1)
+    this.connection.stream.write(lenBuffer)
+    return this.connection.stream.write(chunk)
+  }
+
+  handleError(e) {
+    // clear `pg` timeout mechanism
+    this.callback()
+
+    if (this.cb_destroy) {
+      const cb = this.cb_destroy
+      this.cb_destroy = null
+      cb(e)
+    } else {
+      this.emit('error', e)
+    }
+    this.connection = null
+  }
+
+  handleCopyInResponse(connection) {
+    this._gotCopyInResponse = true
+    if (!this.destroyed) {
+      this.uncork()
+    }
+    const cb = this.cb_CopyInResponse || function () {}
+    this.cb_CopyInResponse = null
+    this.flush(cb)
+  }
+
+  handleCommandComplete(msg) {
+    // Parse affected row count as in
+    // https://github.com/brianc/node-postgres/blob/35e5567f86774f808c2a8518dd312b8aa3586693/lib/result.js#L37
+    const match = /COPY (\d+)/.exec((msg || {}).text)
+    if (match) {
+      this.rowCount = parseInt(match[1], 10)
+    }
+  }
+
+  handleReadyForQuery() {
+    // triggered after ReadyForQuery
+    // we delay the _final callback so that the 'finish' event is
+    // sent only when the ingested data is visible inside postgres and
+    // after the postgres connection is ready for a new query
+
+    // Note: `pg` currently does not call this callback when the backend
+    // sends an ErrorResponse message during the query (for example during
+    // a CopyFail)
+
+    // clear `pg` timeout mechanism
+    this.callback()
+
+    this.cb_ReadyForQuery()
+    this.connection = null
+  }
+}

package/.output/server/node_modules/pg-copy-streams/copy-to.js

@@ -0,0 +1,177 @@
+'use strict'
+
+module.exports = function (txt, options) {
+  return new CopyStreamQuery(txt, options)
+}
+
+const { Readable } = require('stream')
+const assert = require('assert')
+const BufferList = require('./obuf')
+const code = require('./message-formats')
+
+// decoder states
+const PG_CODE = 0
+const PG_LENGTH = 1
+const PG_MESSAGE = 2
+
+class CopyStreamQuery extends Readable {
+  constructor(text, options) {
+    super(options)
+    this.text = text
+    this.rowCount = 0
+    this._state = PG_CODE
+    this._buffer = new BufferList()
+    this._unreadMessageContentLength = 0
+    this._copyDataChunks = new BufferList()
+    this._pgDataHandler = null
+    this._drained = false
+    this._forwarding = false
+    this._onReadableEvent = this._onReadable.bind(this)
+  }
+
+  submit(connection) {
+    this.connection = connection
+    this._attach()
+    connection.query(this.text)
+  }
+
+  _attach() {
+    const connectionStream = this.connection.stream
+    const pgDataListeners = connectionStream.listeners('data')
+    assert(pgDataListeners.length == 1)
+    this._pgDataHandler = pgDataListeners.pop()
+    connectionStream.removeListener('data', this._pgDataHandler)
+    connectionStream.pause()
+    this._forward()
+    connectionStream.on('readable', this._onReadableEvent)
+  }
+
+  _detach() {
+    const connectionStream = this.connection.stream
+    const unreadBuffer = this._buffer.take(this._buffer.size)
+    //connectionStream.unpipe(this)
+    connectionStream.removeListener('readable', this._onReadableEvent)
+    connectionStream.addListener('data', this._pgDataHandler)
+    this._pgDataHandler(unreadBuffer)
+
+    // unpipe can pause the stream but also underlying onData event can potentially pause the stream because of hitting
+    // the highWaterMark and pausing the stream, so we resume the stream in the next tick after the underlying onData
+    // event has finished
+    process.nextTick(function () {
+      connectionStream.resume()
+    })
+  }
+
+  _cleanup() {
+    this._buffer = null
+    this._copyDataChunks = null
+    this._pgDataHandler = null
+    this._onReadableEvent = null
+  }
+
+  _onReadable() {
+    this._forward()
+  }
+
+  _read() {
+    this._drained = true
+    this._forward()
+  }
+
+  _forward() {
+    if (this._forwarding || !this._drained || !this.connection) return
+    this._forwarding = true
+    const connectionStream = this.connection.stream
+    let chunk
+    while (this._drained && (chunk = connectionStream.read()) !== null) {
+      this._drained = this._parse(chunk)
+    }
+    this._forwarding = false
+  }
+
+  _parse(chunk) {
+    let done = false
+    let drained = true
+    this._buffer.push(chunk)
+
+    while (!done && this._buffer.size > 0) {
+      if (PG_CODE === this._state) {
+        if (!this._buffer.has(1)) break
+        this._code = this._buffer.peekUInt8()
+        if (this._code === code.ErrorResponse) {
+          // ErrorResponse Interception
+          // We must let pg parse future messages and handle their consequences on
+          // the ActiveQuery
+          this._detach()
+          return
+        }
+        this._buffer.readUInt8()
+        this._state = PG_LENGTH
+      }
+
+      if (PG_LENGTH === this._state) {
+        if (!this._buffer.has(4)) break
+        this._unreadMessageContentLength = this._buffer.readUInt32BE() - 4
+        this._state = PG_MESSAGE
+      }
+
+      if (PG_MESSAGE === this._state) {
+        if (this._unreadMessageContentLength > 0 && this._buffer.size > 0) {
+          const n = Math.min(this._buffer.size, this._unreadMessageContentLength)
+          const messageContentChunk = this._buffer.take(n)
+          this._unreadMessageContentLength -= n
+          if (this._code === code.CopyData) {
+            this._copyDataChunks.push(messageContentChunk)
+          }
+        }
+
+        if (this._unreadMessageContentLength === 0) {
+          // a full message has been captured
+          switch (this._code) {
+            case code.CopyOutResponse:
+            case code.CopyData:
+            // standard interspersed messages.
+            // see https://www.postgresql.org/docs/9.6/protocol-flow.html#PROTOCOL-COPY
+            case code.ParameterStatus:
+            case code.NoticeResponse:
+            case code.NotificationResponse:
+              break
+            case code.CopyDone:
+            default:
+              done = true
+              break
+          }
+          this._state = PG_CODE
+        }
+      }
+    }
+
+    // flush data if any data has been captured
+    const len = this._copyDataChunks.size
+    if (len > 0) {
+      drained = this.push(this._copyDataChunks.take(len))
+    }
+
+    if (done) {
+      this._detach()
+      this.push(null)
+      this._cleanup()
+    }
+
+    return drained
+  }
+
+  handleError(err) {
+    this.emit('error', err)
+    this._cleanup()
+  }
+
+  handleCommandComplete(msg) {
+    const match = /COPY (\d+)/.exec((msg || {}).text)
+    if (match) {
+      this.rowCount = parseInt(match[1], 10)
+    }
+  }
+
+  handleReadyForQuery() {}
+}

package/.output/server/node_modules/pg-copy-streams/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const CopyToQueryStream = require('./copy-to')
+const CopyFromQueryStream = require('./copy-from')
+const CopyBothQueryStream = require('./copy-both')
+
+exports.to = function copyTo(txt, options) {
+  return new CopyToQueryStream(txt, options)
+}
+
+exports.from = function copyFrom(txt, options) {
+  return new CopyFromQueryStream(txt, options)
+}
+
+exports.both = function copyBoth(txt, options) {
+  return new CopyBothQueryStream(txt, options)
+}

package/.output/server/node_modules/pg-copy-streams/message-formats.js

@@ -0,0 +1,27 @@
+/**
+ * The COPY feature uses the following protocol codes.
+ * The codes for the most recent protocol version are documented on
+ * https://www.postgresql.org/docs/current/static/protocol-message-formats.html
+ *
+ * The protocol flow itself is described on
+ * https://www.postgresql.org/docs/current/static/protocol-flow.html
+ */
+module.exports = {
+  ErrorResponse: 0x45, // E
+  CopyInResponse: 0x47, // G
+  CopyOutResponse: 0x48, // H
+  CopyBothResponse: 0x57, // W
+  CopyDone: 0x63, // c
+  CopyData: 0x64, // d
+  CopyFail: 0x66, // f
+  CommandComplete: 0x43, // C
+  ReadyForQuery: 0x5a, // Z
+
+  // It is possible for NoticeResponse and ParameterStatus messages to be interspersed between CopyData messages;
+  // frontends must handle these cases, and should be prepared for other asynchronous message types as well
+  // (see Section 50.2.6).
+  // Otherwise, any message type other than CopyData or CopyDone may be treated as terminating copy-out mode.
+  NotificationResponse: 0x41, // A
+  NoticeResponse: 0x4e, // N
+  ParameterStatus: 0x53, // S
+}