@tachybase/module-multi-app 0.23.8

package/dist/node_modules/mariadb/lib/io/compression-input-stream.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const ZLib = require('zlib');
+const Utils = require('../misc/utils');
+
+/**
+ * MySQL packet parser
+ * see : https://mariadb.com/kb/en/library/0-packet/
+ */
+class CompressionInputStream {
+  constructor(reader, receiveQueue, opts, info) {
+    this.reader = reader;
+    this.receiveQueue = receiveQueue;
+    this.info = info;
+    this.opts = opts;
+    this.header = Buffer.allocUnsafe(7);
+    this.headerLen = 0;
+    this.compressPacketLen = null;
+    this.packetLen = null;
+    this.remainingLen = null;
+
+    this.parts = null;
+    this.partsTotalLen = 0;
+  }
+
+  receivePacket(chunk) {
+    let cmd = this.currentCmd();
+    if (this.opts.debugCompress) {
+      console.log(
+        '<== conn:%d %s (compress)\n%s',
+        this.info.threadId ? this.info.threadId : -1,
+        cmd
+          ? cmd.onPacketReceive
+            ? cmd.constructor.name + '.' + cmd.onPacketReceive.name
+            : cmd.constructor.name
+          : 'no command',
+        Utils.log(this.opts, chunk, 0, chunk.length, this.header)
+      );
+    }
+    if (cmd) cmd.compressSequenceNo = this.header[3];
+    const unCompressLen = this.header[4] | (this.header[5] << 8) | (this.header[6] << 16);
+    if (unCompressLen === 0) {
+      this.reader.onData(chunk);
+    } else {
+      //use synchronous inflating, to ensure FIFO packet order
+      const unCompressChunk = ZLib.inflateSync(chunk);
+      this.reader.onData(unCompressChunk);
+    }
+  }
+
+  currentCmd() {
+    let cmd;
+    while ((cmd = this.receiveQueue.peek())) {
+      if (cmd.onPacketReceive) return cmd;
+      this.receiveQueue.shift();
+    }
+    return null;
+  }
+
+  resetHeader() {
+    this.remainingLen = null;
+    this.headerLen = 0;
+  }
+
+  onData(chunk) {
+    let pos = 0;
+    let length;
+    const chunkLen = chunk.length;
+
+    do {
+      if (this.remainingLen) {
+        length = this.remainingLen;
+      } else if (this.headerLen === 0 && chunkLen - pos >= 7) {
+        this.header[0] = chunk[pos];
+        this.header[1] = chunk[pos + 1];
+        this.header[2] = chunk[pos + 2];
+        this.header[3] = chunk[pos + 3];
+        this.header[4] = chunk[pos + 4];
+        this.header[5] = chunk[pos + 5];
+        this.header[6] = chunk[pos + 6];
+        this.headerLen = 7;
+        pos += 7;
+        this.compressPacketLen = this.header[0] + (this.header[1] << 8) + (this.header[2] << 16);
+        this.packetLen = this.header[4] | (this.header[5] << 8) | (this.header[6] << 16);
+        if (this.packetLen === 0) this.packetLen = this.compressPacketLen;
+        length = this.compressPacketLen;
+      } else {
+        length = null;
+        while (chunkLen - pos > 0) {
+          this.header[this.headerLen++] = chunk[pos++];
+          if (this.headerLen === 7) {
+            this.compressPacketLen =
+              this.header[0] + (this.header[1] << 8) + (this.header[2] << 16);
+            this.packetLen = this.header[4] | (this.header[5] << 8) | (this.header[6] << 16);
+            if (this.packetLen === 0) this.packetLen = this.compressPacketLen;
+            length = this.compressPacketLen;
+            break;
+          }
+        }
+      }
+
+      if (length) {
+        if (chunkLen - pos >= length) {
+          const buf = chunk.slice(pos, pos + length);
+          pos += length;
+          if (this.parts) {
+            this.parts.push(buf);
+            this.partsTotalLen += length;
+
+            if (this.compressPacketLen < 0xffffff) {
+              let buf = Buffer.concat(this.parts, this.partsTotalLen);
+              this.parts = null;
+              this.receivePacket(buf);
+            }
+          } else {
+            if (this.compressPacketLen < 0xffffff) {
+              this.receivePacket(buf);
+            } else {
+              this.parts = [buf];
+              this.partsTotalLen = length;
+            }
+          }
+          this.resetHeader();
+        } else {
+          const buf = chunk.slice(pos, chunkLen);
+          if (!this.parts) {
+            this.parts = [buf];
+            this.partsTotalLen = chunkLen - pos;
+          } else {
+            this.parts.push(buf);
+            this.partsTotalLen += chunkLen - pos;
+          }
+          this.remainingLen = length - (chunkLen - pos);
+          return;
+        }
+      }
+    } while (pos < chunkLen);
+  }
+}
+
+module.exports = CompressionInputStream;

package/dist/node_modules/mariadb/lib/io/compression-output-stream.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const Utils = require('../misc/utils');
+const ZLib = require('zlib');
+
+//increase by level to avoid buffer copy.
+const SMALL_BUFFER_SIZE = 2048;
+const MEDIUM_BUFFER_SIZE = 131072; //128k
+const LARGE_BUFFER_SIZE = 1048576; //1M
+const MAX_BUFFER_SIZE = 16777222; //16M + 7
+
+/**
+/**
+ * MySQL compression filter.
+ * see https://mariadb.com/kb/en/library/0-packet/#compressed-packet
+ */
+class CompressionOutputStream {
+  /**
+   * Constructor
+   *
+   * @param socket    current socket
+   * @param opts      current connection options
+   * @param info      current connection information
+   * @constructor
+   */
+  constructor(socket, opts, info) {
+    this.info = info;
+    this.opts = opts;
+    this.pos = 7;
+    this.header = Buffer.allocUnsafe(7);
+    this.buf = Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+    this.writer = (buffer) => {
+      socket.write(buffer);
+    };
+  }
+
+  growBuffer(len) {
+    let newCapacity;
+    if (len + this.pos < MEDIUM_BUFFER_SIZE) {
+      newCapacity = MEDIUM_BUFFER_SIZE;
+    } else if (len + this.pos < LARGE_BUFFER_SIZE) {
+      newCapacity = LARGE_BUFFER_SIZE;
+    } else newCapacity = MAX_BUFFER_SIZE;
+
+    let newBuf = Buffer.allocUnsafe(newCapacity);
+    this.buf.copy(newBuf, 0, 0, this.pos);
+    this.buf = newBuf;
+  }
+
+  writeBuf(arr, cmd) {
+    let off = 0,
+      len = arr.length;
+    if (len > this.buf.length - this.pos) {
+      if (this.buf.length !== MAX_BUFFER_SIZE) {
+        this.growBuffer(len);
+      }
+
+      //max buffer size
+      if (len > this.buf.length - this.pos) {
+        //not enough space in buffer, will stream :
+        // fill buffer and flush until all data are snd
+        let remainingLen = len;
+
+        while (true) {
+          //filling buffer
+          let lenToFillBuffer = Math.min(MAX_BUFFER_SIZE - this.pos, remainingLen);
+          arr.copy(this.buf, this.pos, off, off + lenToFillBuffer);
+          remainingLen -= lenToFillBuffer;
+          off += lenToFillBuffer;
+          this.pos += lenToFillBuffer;
+
+          if (remainingLen === 0) return;
+          this.flush(false, cmd, remainingLen);
+        }
+      }
+    }
+    arr.copy(this.buf, this.pos, off, off + len);
+    this.pos += len;
+  }
+
+  /**
+   * Flush the internal buffer.
+   */
+  flush(cmdEnd, cmd, remainingLen) {
+    if (this.pos < 1536) {
+      //*******************************************************************************
+      // small packet, no compression
+      //*******************************************************************************
+
+      this.buf[0] = this.pos - 7;
+      this.buf[1] = (this.pos - 7) >>> 8;
+      this.buf[2] = (this.pos - 7) >>> 16;
+      this.buf[3] = ++cmd.compressSequenceNo;
+      this.buf[4] = 0;
+      this.buf[5] = 0;
+      this.buf[6] = 0;
+
+      if (this.opts.debugCompress) {
+        console.log(
+          '==> conn:%d %s (compress)\n%s',
+          this.info.threadId ? this.info.threadId : -1,
+          cmd ? cmd.constructor.name + '(0,' + this.pos + ')' : 'unknown',
+          Utils.log(this.opts, this.buf, 0, this.pos)
+        );
+      }
+
+      this.writer(this.buf.slice(0, this.pos));
+    } else {
+      //*******************************************************************************
+      // compressing packet
+      //*******************************************************************************
+      //use synchronous inflating, to ensure FIFO packet order
+      const compressChunk = ZLib.deflateSync(this.buf.slice(7, this.pos));
+      const compressChunkLen = compressChunk.length;
+
+      this.header[0] = compressChunkLen;
+      this.header[1] = compressChunkLen >>> 8;
+      this.header[2] = compressChunkLen >>> 16;
+      this.header[3] = ++cmd.compressSequenceNo;
+      this.header[4] = this.pos - 7;
+      this.header[5] = (this.pos - 7) >>> 8;
+      this.header[6] = (this.pos - 7) >>> 16;
+
+      if (this.opts.debugCompress) {
+        console.log(
+          '==> conn:%d %s (compress)\n%s',
+          this.info.threadId ? this.info.threadId : -1,
+          cmd ? cmd.constructor.name + '(0,' + this.pos + '=>' + compressChunkLen + ')' : 'unknown',
+          Utils.log(this.opts, compressChunk, 0, compressChunkLen, this.header)
+        );
+      }
+
+      this.writer(this.header);
+      this.writer(compressChunk);
+      if (cmdEnd && this.pos === MAX_BUFFER_SIZE) this.writeEmptyPacket(cmd);
+      this.header = Buffer.allocUnsafe(7);
+    }
+    this.buf = remainingLen
+      ? CompressionOutputStream.allocateBuffer(remainingLen)
+      : Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+    this.pos = 7;
+  }
+
+  static allocateBuffer(len) {
+    if (len + 4 < SMALL_BUFFER_SIZE) {
+      return Buffer.allocUnsafe(SMALL_BUFFER_SIZE);
+    } else if (len + 4 < MEDIUM_BUFFER_SIZE) {
+      return Buffer.allocUnsafe(MEDIUM_BUFFER_SIZE);
+    } else if (len + 4 < LARGE_BUFFER_SIZE) {
+      return Buffer.allocUnsafe(LARGE_BUFFER_SIZE);
+    }
+    return Buffer.allocUnsafe(MAX_BUFFER_SIZE);
+  }
+
+  writeEmptyPacket(cmd) {
+    const emptyBuf = Buffer.from([0x00, 0x00, 0x00, cmd.compressSequenceNo, 0x00, 0x00, 0x00]);
+
+    if (this.opts.debugCompress) {
+      console.log(
+        '==> conn:%d %s (compress)\n%s',
+        this.info.threadId ? this.info.threadId : -1,
+        cmd ? cmd.constructor.name + '(0,' + this.pos + ')' : 'unknown',
+        Utils.log(this.opts, emptyBuf, 0, 7)
+      );
+    }
+
+    this.writer(emptyBuf);
+  }
+}
+
+module.exports = CompressionOutputStream;

package/dist/node_modules/mariadb/lib/io/packet-input-stream.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const PacketNodeEncoded = require('./packet-node-encoded');
+const PacketIconvEncoded = require('./packet-node-iconv');
+
+const Utils = require('../misc/utils');
+
+/**
+ * MySQL packet parser
+ * see : https://mariadb.com/kb/en/library/0-packet/
+ */
+class PacketInputStream {
+  constructor(unexpectedPacket, receiveQueue, out, opts, info) {
+    this.unexpectedPacket = unexpectedPacket;
+    this.opts = opts;
+    this.receiveQueue = receiveQueue;
+    this.info = info;
+    this.out = out;
+
+    //in case packet is not complete
+    this.header = Buffer.allocUnsafe(4);
+    this.headerLen = 0;
+    this.packetLen = null;
+    this.remainingLen = null;
+
+    this.parts = null;
+    this.partsTotalLen = 0;
+    this.changeEncoding(this.opts.collation);
+    this.changeDebug(this.opts.logPackets, this.opts.debug);
+    this.opts.on('collation', this.changeEncoding.bind(this));
+    this.opts.on('debug', this.changeDebug.bind(this));
+  }
+
+  changeEncoding(collation) {
+    this.encoding = collation.charset;
+    this.packetConstructor = Buffer.isEncoding(this.encoding)
+      ? PacketNodeEncoded
+      : PacketIconvEncoded;
+  }
+
+  changeDebug(logPackets, debug) {
+    this.logPackets = logPackets;
+    this.debug = debug;
+    this.receivePacket =
+      this.logPackets || this.debug ? this.receivePacketDebug : this.receivePacketBasic;
+  }
+
+  receivePacketDebug(packet) {
+    let cmd = this.currentCmd();
+
+    if (packet) {
+      const packetStr = Utils.log(this.opts, packet.buf, packet.pos, packet.end, this.header);
+      if (this.opts.logPackets) {
+        this.info.addPacket(
+          '<== conn:' +
+            (this.info.threadId ? this.info.threadId : -1) +
+            ' ' +
+            (cmd
+              ? cmd.onPacketReceive
+                ? cmd.constructor.name + '.' + cmd.onPacketReceive.name
+                : cmd.constructor.name
+              : 'no command') +
+            ' (' +
+            packet.pos +
+            ',' +
+            packet.end +
+            '))\n' +
+            packetStr
+        );
+      }
+      if (this.opts.debug) {
+        console.log(
+          '<== conn:%d %s (%d,%d)\n%s',
+          this.info.threadId ? this.info.threadId : -1,
+          cmd
+            ? cmd.onPacketReceive
+              ? cmd.constructor.name + '.' + cmd.onPacketReceive.name
+              : cmd.constructor.name
+            : 'no command',
+          packet.pos,
+          packet.end,
+          packetStr
+        );
+      }
+    }
+
+    if (!cmd) {
+      this.unexpectedPacket(packet);
+      return;
+    }
+
+    cmd.sequenceNo = this.header[3];
+    cmd.onPacketReceive(packet, this.out, this.opts, this.info);
+    if (!cmd.onPacketReceive) this.receiveQueue.shift();
+  }
+
+  receivePacketBasic(packet) {
+    let cmd = this.currentCmd();
+    if (!cmd) {
+      this.unexpectedPacket(packet);
+      return;
+    }
+    cmd.sequenceNo = this.header[3];
+    cmd.onPacketReceive(packet, this.out, this.opts, this.info);
+    if (!cmd.onPacketReceive) this.receiveQueue.shift();
+  }
+
+  resetHeader() {
+    this.remainingLen = null;
+    this.headerLen = 0;
+  }
+
+  currentCmd() {
+    let cmd;
+    while ((cmd = this.receiveQueue.peek())) {
+      if (cmd.onPacketReceive) return cmd;
+      this.receiveQueue.shift();
+    }
+    return null;
+  }
+
+  onData(chunk) {
+    let pos = 0;
+    let length;
+    const chunkLen = chunk.length;
+
+    do {
+      //read header
+      if (this.remainingLen) {
+        length = this.remainingLen;
+      } else if (this.headerLen === 0 && chunkLen - pos >= 4) {
+        this.header[0] = chunk[pos];
+        this.header[1] = chunk[pos + 1];
+        this.header[2] = chunk[pos + 2];
+        this.header[3] = chunk[pos + 3];
+        pos += 4;
+        this.headerLen = 4;
+        this.packetLen = this.header[0] + (this.header[1] << 8) + (this.header[2] << 16);
+        length = this.packetLen;
+      } else {
+        length = null;
+        while (chunkLen - pos > 0) {
+          this.header[this.headerLen++] = chunk[pos++];
+          if (this.headerLen === 4) {
+            this.packetLen = this.header[0] + (this.header[1] << 8) + (this.header[2] << 16);
+            length = this.packetLen;
+            break;
+          }
+        }
+      }
+
+      if (length) {
+        if (chunkLen - pos >= length) {
+          const buf = chunk.slice(pos, pos + length);
+          pos += length;
+          if (this.parts) {
+            this.parts.push(buf);
+            this.partsTotalLen += length;
+
+            if (this.packetLen < 0xffffff) {
+              let buf = Buffer.concat(this.parts, this.partsTotalLen);
+              this.parts = null;
+              const packet = new this.packetConstructor(buf, 0, this.partsTotalLen, this.encoding);
+              this.receivePacket(packet);
+            }
+          } else {
+            if (this.packetLen < 0xffffff) {
+              const packet = new this.packetConstructor(buf, 0, length, this.encoding);
+              this.receivePacket(packet);
+            } else {
+              this.parts = [buf];
+              this.partsTotalLen = length;
+            }
+          }
+          this.resetHeader();
+        } else {
+          const buf = chunk.slice(pos, chunkLen);
+          if (!this.parts) {
+            this.parts = [buf];
+            this.partsTotalLen = chunkLen - pos;
+          } else {
+            this.parts.push(buf);
+            this.partsTotalLen += chunkLen - pos;
+          }
+          this.remainingLen = length - (chunkLen - pos);
+          return;
+        }
+      }
+    } while (pos < chunkLen);
+  }
+}
+
+module.exports = PacketInputStream;

package/dist/node_modules/mariadb/lib/io/packet-node-encoded.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const Packet = require('./packet');
+
+class PacketNodeEncoded extends Packet {
+  constructor(buf, pos, end, encoding) {
+    super(buf, pos, end);
+    this.encoding = encoding;
+  }
+
+  readStringLength() {
+    const len = this.readUnsignedLength();
+    if (len === null) return null;
+
+    this.pos += len;
+    return this.buf.toString(this.encoding, this.pos - len, this.pos);
+  }
+
+  readString(beg, len) {
+    return this.buf.toString(this.encoding, beg, beg + len);
+  }
+
+  subPacketLengthEncoded() {
+    const len = this.readUnsignedLength();
+    this.skip(len);
+    return new PacketNodeEncoded(this.buf, this.pos - len, this.pos, this.encoding);
+  }
+
+  readStringRemaining() {
+    const str = this.buf.toString(this.encoding, this.pos, this.end);
+    this.pos = this.end;
+    return str;
+  }
+}
+
+module.exports = PacketNodeEncoded;

package/dist/node_modules/mariadb/lib/io/packet-node-iconv.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const Packet = require('./packet');
+const Iconv = require('iconv-lite');
+
+class PacketIconvEncoded extends Packet {
+  constructor(buf, pos, end, encoding) {
+    super(buf, pos, end);
+    this.encoding = encoding;
+  }
+
+  readStringLength() {
+    const len = this.readUnsignedLength();
+    if (len === null) return null;
+
+    this.pos += len;
+    return Iconv.decode(this.buf.slice(this.pos - len, this.pos), this.encoding);
+  }
+
+  readString(beg, len) {
+    return Iconv.decode(this.buf.slice(beg, beg + len), this.encoding);
+  }
+
+  subPacketLengthEncoded() {
+    const len = this.readUnsignedLength();
+    this.skip(len);
+    return new PacketIconvEncoded(this.buf, this.pos - len, this.pos, this.encoding);
+  }
+
+  readStringRemaining() {
+    const str = Iconv.decode(this.buf.slice(this.pos, this.end), this.encoding);
+    this.pos = this.end;
+    return str;
+  }
+}
+
+module.exports = PacketIconvEncoded;