@tachybase/module-multi-app 1.5.1 → 1.6.1

package/dist/node_modules/mariadb/lib/io/packet.js

@@ -1,47 +1,32 @@
+//  SPDX-License-Identifier: LGPL-2.1-or-later
+//  Copyright (c) 2015-2024 MariaDB Corporation Ab
+
 'use strict';
 
 const Errors = require('../misc/errors');
-const Iconv = require('iconv-lite');
-const Long = require('long');
-const moment = require('moment-timezone');
 
 /**
  * Object to easily parse buffer.
+ * Packet are MUTABLE (buffer are changed, to avoid massive packet object creation).
+ * Use clone() in case immutability is required
  *
  */
 class Packet {
-  constructor(buf, pos, end) {
+  update(buf, pos, end) {
     this.buf = buf;
     this.pos = pos;
     this.end = end;
+    return this;
   }
 
   skip(n) {
     this.pos += n;
   }
 
-  readGeometry(dataTypeName) {
+  readGeometry(defaultVal) {
     const geoBuf = this.readBufferLengthEncoded();
     if (geoBuf === null || geoBuf.length === 0) {
-      if (dataTypeName) {
-        switch (dataTypeName) {
-          case 'point':
-            return { type: 'Point' };
-          case 'linestring':
-            return { type: 'LineString' };
-          case 'polygon':
-            return { type: 'Polygon' };
-          case 'multipoint':
-            return { type: 'MultiPoint' };
-          case 'multilinestring':
-            return { type: 'MultiLineString' };
-          case 'multipolygon':
-            return { type: 'MultiPolygon' };
-          default:
-            return { type: dataTypeName };
-        }
-      }
-      return null;
+      return defaultVal;
     }
     let geoPos = 4;
     return readGeometryObject(false);
@@ -144,88 +129,110 @@ class Packet {
     return this.end - this.pos > 0;
   }
 
+  readInt8() {
+    const val = this.buf[this.pos++];
+    return val | ((val & (2 ** 7)) * 0x1fffffe);
+  }
+
   readUInt8() {
     return this.buf[this.pos++];
   }
 
+  readInt16() {
+    this.pos += 2;
+    const first = this.buf[this.pos - 2];
+    const last = this.buf[this.pos - 1];
+    const val = first + last * 2 ** 8;
+    return val | ((val & (2 ** 15)) * 0x1fffe);
+  }
+
   readUInt16() {
-    return this.buf[this.pos++] + (this.buf[this.pos++] << 8);
+    this.pos += 2;
+    return this.buf[this.pos - 2] + this.buf[this.pos - 1] * 2 ** 8;
+  }
+
+  readInt24() {
+    const first = this.buf[this.pos];
+    const last = this.buf[this.pos + 2];
+    const val = first + this.buf[this.pos + 1] * 2 ** 8 + last * 2 ** 16;
+    this.pos += 3;
+    return val | ((val & (2 ** 23)) * 0x1fe);
   }
 
   readUInt24() {
-    return this.buf[this.pos++] + (this.buf[this.pos++] << 8) + (this.buf[this.pos++] << 16);
+    this.pos += 3;
+    return this.buf[this.pos - 3] + this.buf[this.pos - 2] * 2 ** 8 + this.buf[this.pos - 1] * 2 ** 16;
   }
 
   readUInt32() {
+    this.pos += 4;
     return (
-      this.buf[this.pos++] +
-      (this.buf[this.pos++] << 8) +
-      (this.buf[this.pos++] << 16) +
-      this.buf[this.pos++] * 0x1000000
+      this.buf[this.pos - 4] +
+      this.buf[this.pos - 3] * 2 ** 8 +
+      this.buf[this.pos - 2] * 2 ** 16 +
+      this.buf[this.pos - 1] * 2 ** 24
     );
   }
 
   readInt32() {
+    this.pos += 4;
     return (
-      this.buf[this.pos++] +
-      (this.buf[this.pos++] << 8) +
-      (this.buf[this.pos++] << 16) +
-      (this.buf[this.pos++] << 24)
+      this.buf[this.pos - 4] +
+      this.buf[this.pos - 3] * 2 ** 8 +
+      this.buf[this.pos - 2] * 2 ** 16 +
+      (this.buf[this.pos - 1] << 24)
     );
   }
 
-  readInt32LE() {
-    return (
-      (this.buf[this.pos++] << 24) +
-      (this.buf[this.pos++] << 16) +
-      (this.buf[this.pos++] << 8) +
-      this.buf[this.pos++]
-    );
+  readBigInt64() {
+    const val = this.buf.readBigInt64LE(this.pos);
+    this.pos += 8;
+    return val;
   }
 
-  readInt64() {
-    // could use readBigInt64LE when support would be 10.20+
-    const val =
-      this.buf[this.pos + 4] +
-      this.buf[this.pos + 5] * 2 ** 8 +
-      this.buf[this.pos + 6] * 2 ** 16 +
-      (this.buf[this.pos + 7] << 24);
-    const vv =
-      (BigInt(val) << BigInt(32)) +
-      BigInt(
-        this.buf[this.pos] +
-          this.buf[this.pos + 1] * 2 ** 8 +
-          this.buf[this.pos + 2] * 2 ** 16 +
-          this.buf[this.pos + 3] * 2 ** 24
-      );
+  readBigUInt64() {
+    const val = this.buf.readBigUInt64LE(this.pos);
     this.pos += 8;
-    return vv;
+    return val;
+  }
+
+  /**
+   * Metadata are length encoded, but cannot have length > 256, so simplified readUnsignedLength
+   * @returns {number}
+   */
+  readMetadataLength() {
+    const type = this.buf[this.pos++];
+    if (type < 0xfb) return type;
+    return this.readUInt16();
   }
 
   readUnsignedLength() {
-    const type = this.buf[this.pos++] & 0xff;
+    const type = this.buf[this.pos++];
+    if (type < 0xfb) return type;
     switch (type) {
       case 0xfb:
         return null;
       case 0xfc:
-        return this.readUInt16();
+        //readUInt16();
+        this.pos += 2;
+        return this.buf[this.pos - 2] + this.buf[this.pos - 1] * 2 ** 8;
       case 0xfd:
-        return this.readUInt24();
+        //readUInt24();
+        this.pos += 3;
+        return this.buf[this.pos - 3] + this.buf[this.pos - 2] * 2 ** 8 + this.buf[this.pos - 1] * 2 ** 16;
       case 0xfe:
         // limitation to BigInt signed value
-        return Number(this.readInt64());
-      default:
-        return type;
+        return Number(this.readBigInt64());
     }
   }
 
   readBuffer(len) {
     this.pos += len;
-    return this.buf.slice(this.pos - len, this.pos);
+    return this.buf.subarray(this.pos - len, this.pos);
   }
 
   readBufferRemaining() {
-    let b = this.buf.slice(this.pos, this.end);
+    let b = this.buf.subarray(this.pos, this.end);
     this.pos = this.end;
     return b;
   }
@@ -234,7 +241,7 @@ class Packet {
     const len = this.readUnsignedLength();
     if (len === null) return null;
     this.pos += len;
-    return this.buf.slice(this.pos - len, this.pos);
+    return this.buf.subarray(this.pos - len, this.pos);
   }
 
   readStringNullEnded() {
@@ -243,38 +250,27 @@ class Packet {
     while (this.remaining() > 0 && this.buf[this.pos++] !== 0) {
       cnt++;
     }
-    return this.buf.toString('utf8', initialPosition, initialPosition + cnt);
+    return this.buf.toString(undefined, initialPosition, initialPosition + cnt);
   }
 
-  readSignedLength() {
-    const type = this.buf[this.pos++];
-    switch (type) {
-      case 0xfb:
-        return null;
-      case 0xfc:
-        return this.readUInt16();
-      case 0xfd:
-        return this.readUInt24();
-      case 0xfe:
-        return Number(this.readInt64());
-      default:
-        return type;
-    }
-  }
-
-  readSignedLengthBigInt() {
+  /**
+   * Return unsigned Bigint.
+   *
+   * Could be used for reading other kinds of value than InsertId, if reading possible null value
+   * @returns {bigint}
+   */
+  readInsertId() {
     const type = this.buf[this.pos++];
+    if (type < 0xfb) return BigInt(type);
     switch (type) {
-      case 0xfb:
-        return null;
       case 0xfc:
-        return BigInt(this.readUInt16());
+        this.pos += 2;
+        return BigInt(this.buf[this.pos - 2] + this.buf[this.pos - 1] * 2 ** 8);
       case 0xfd:
-        return BigInt(this.readUInt24());
+        this.pos += 3;
+        return BigInt(this.buf[this.pos - 3] + this.buf[this.pos - 2] * 2 ** 8 + this.buf[this.pos - 1] * 2 ** 16);
       case 0xfe:
-        return this.readInt64();
-      default:
-        return BigInt(type);
+        return this.readBigInt64();
     }
   }
 
@@ -285,72 +281,51 @@ class Packet {
     return this.buf.toString('ascii', this.pos - len, this.pos);
   }
 
-  readStringLength() {
-    throw new Error(
-      'code is normally superseded by Node encoder or Iconv depending on charset used'
-    );
+  readStringLengthEncoded() {
+    throw new Error('code is normally superseded by Node encoder or Iconv depending on charset used');
   }
 
-  readStringLengthEncoded(encoding) {
-    const len = this.readUnsignedLength();
-    if (len === null) return null;
+  readBigIntLengthEncoded() {
+    const len = this.buf[this.pos++];
 
-    this.pos += len;
-    if (Buffer.isEncoding(encoding)) {
-      return this.buf.toString(encoding, this.pos - len, this.pos);
+    // fast-path: if length encoded is < to 16, value is in safe integer range, using atoi
+    if (len < 16) {
+      return BigInt(this._atoi(len));
     }
-    return Iconv.decode(this.buf.slice(this.pos - len, this.pos), encoding);
-  }
 
-  readLongLengthEncoded(supportBigInt, supportBigNumbers, bigNumberStrings, unsigned) {
-    const len = this.readUnsignedLength();
-    if (len === null) return null;
+    if (len === 0xfb) return null;
 
-    if (supportBigInt) {
-      const str = this.buf.toString('ascii', this.pos, this.pos + len);
-      this.pos += len;
-      return BigInt(str);
-    }
+    return this.readBigIntFromLen(len);
+  }
 
-    let result = 0;
+  readBigIntFromLen(len) {
+    // atoll
+    let result = 0n;
     let negate = false;
     let begin = this.pos;
 
-    //minus sign
     if (len > 0 && this.buf[begin] === 45) {
+      //minus sign
       negate = true;
       begin++;
     }
     for (; begin < this.pos + len; begin++) {
-      result = result * 10 + (this.buf[begin] - 48);
+      result = result * 10n + BigInt(this.buf[begin] - 48);
     }
-
-    let val = negate ? -1 * result : result;
     this.pos += len;
-
-    if (!Number.isSafeInteger(val)) {
-      const str = this.buf.toString('ascii', this.pos - len, this.pos);
-      if (bigNumberStrings) return str;
-      if (supportBigNumbers) {
-        return Long.fromString(str, unsigned, 10);
-      }
-    }
-    return val;
+    return negate ? -1n * result : result;
   }
 
-  readDecimalLengthEncoded(bigNumberStrings) {
-    const len = this.readUnsignedLength();
-    if (len === null) return null;
-
+  readDecimalLengthEncoded() {
+    const len = this.buf[this.pos++];
+    if (len === 0xfb) return null;
     this.pos += len;
-    let str = this.buf.toString('ascii', this.pos - len, this.pos);
-    return bigNumberStrings ? str : +str;
+    return this.buf.toString('ascii', this.pos - len, this.pos);
   }
 
   readDate() {
-    const len = this.readUnsignedLength();
-    if (len === null) return null;
-
+    const len = this.buf[this.pos++];
+    if (len === 0xfb) return null;
     let res = [];
     let value = 0;
     let initPos = this.pos;
@@ -373,25 +348,168 @@ class Packet {
     return new Date(res[0], res[1] - 1, res[2]);
   }
 
-  readDateTime(opts) {
-    const len = this.readUnsignedLength();
-    if (len === null) return null;
+  readBinaryDate(opts) {
+    const len = this.buf[this.pos++];
+    let year = 0;
+    let month = 0;
+    let day = 0;
+    if (len > 0) {
+      year = this.readInt16();
+      if (len > 2) {
+        month = this.readUInt8() - 1;
+        if (len > 3) {
+          day = this.readUInt8();
+        }
+      }
+    }
+    if (year === 0 && month === 0 && day === 0) return opts.dateStrings ? '0000-00-00' : null;
+    if (opts.dateStrings) {
+      return `${appendZero(year, 4)}-${appendZero(month + 1, 2)}-${appendZero(day, 2)}`;
+    }
+    //handle zero-date as null
+    return new Date(year, month, day);
+  }
+
+  readDateTime() {
+    const len = this.buf[this.pos++];
+    if (len === 0xfb) return null;
     this.pos += len;
     const str = this.buf.toString('ascii', this.pos - len, this.pos);
     if (str.startsWith('0000-00-00 00:00:00')) return null;
+    return new Date(str);
+  }
 
-    if (opts.tz) {
-      return new Date(
-        moment.tz(str, opts.tz).clone().tz(opts._localTz).format('YYYY-MM-DD HH:mm:ss.SSSSSS')
-      );
+  readBinaryDateTime() {
+    const len = this.buf[this.pos++];
+    let year = 0;
+    let month = 0;
+    let day = 0;
+    let hour = 0;
+    let min = 0;
+    let sec = 0;
+    let microSec = 0;
+
+    if (len > 0) {
+      year = this.readInt16();
+      if (len > 2) {
+        month = this.readUInt8();
+        if (len > 3) {
+          day = this.readUInt8();
+          if (len > 4) {
+            hour = this.readUInt8();
+            min = this.readUInt8();
+            sec = this.readUInt8();
+            if (len > 7) {
+              microSec = this.readUInt32();
+            }
+          }
+        }
+      }
     }
-    return new Date(str);
+
+    //handle zero-date as null
+    if (year === 0 && month === 0 && day === 0 && hour === 0 && min === 0 && sec === 0 && microSec === 0) return null;
+    return new Date(year, month - 1, day, hour, min, sec, microSec / 1000);
+  }
+
+  readBinaryDateTimeAsString(scale) {
+    const len = this.buf[this.pos++];
+    let year = 0;
+    let month = 0;
+    let day = 0;
+    let hour = 0;
+    let min = 0;
+    let sec = 0;
+    let microSec = 0;
+
+    if (len > 0) {
+      year = this.readInt16();
+      if (len > 2) {
+        month = this.readUInt8();
+        if (len > 3) {
+          day = this.readUInt8();
+          if (len > 4) {
+            hour = this.readUInt8();
+            min = this.readUInt8();
+            sec = this.readUInt8();
+            if (len > 7) {
+              microSec = this.readUInt32();
+            }
+          }
+        }
+      }
+    }
+
+    //handle zero-date as null
+    if (year === 0 && month === 0 && day === 0 && hour === 0 && min === 0 && sec === 0 && microSec === 0)
+      return '0000-00-00 00:00:00' + (scale > 0 ? '.000000'.substring(0, scale + 1) : '');
+
+    return (
+      appendZero(year, 4) +
+      '-' +
+      appendZero(month, 2) +
+      '-' +
+      appendZero(day, 2) +
+      ' ' +
+      appendZero(hour, 2) +
+      ':' +
+      appendZero(min, 2) +
+      ':' +
+      appendZero(sec, 2) +
+      (microSec > 0
+        ? scale > 0
+          ? '.' + appendZero(microSec, 6).substring(0, scale)
+          : '.' + appendZero(microSec, 6)
+        : scale > 0
+          ? '.' + appendZero(microSec, 6).substring(0, scale)
+          : '')
+    );
+  }
+
+  readBinaryTime() {
+    const len = this.buf[this.pos++];
+    let negate = false;
+    let hour = 0;
+    let min = 0;
+    let sec = 0;
+    let microSec = 0;
+
+    if (len > 0) {
+      negate = this.buf[this.pos++] === 1;
+      hour = this.readUInt32() * 24 + this.readUInt8();
+      min = this.readUInt8();
+      sec = this.readUInt8();
+      if (len > 8) {
+        microSec = this.readUInt32();
+      }
+    }
+    let val = appendZero(hour, 2) + ':' + appendZero(min, 2) + ':' + appendZero(sec, 2);
+    if (microSec > 0) {
+      val += '.' + appendZero(microSec, 6);
+    }
+    if (negate) return '-' + val;
+    return val;
+  }
+
+  readFloat() {
+    const val = this.buf.readFloatLE(this.pos);
+    this.pos += 4;
+    return val;
+  }
+
+  readDouble() {
+    const val = this.buf.readDoubleLE(this.pos);
+    this.pos += 8;
+    return val;
   }
 
   readIntLengthEncoded() {
-    const len = this.readUnsignedLength();
-    if (len === null) return null;
+    const len = this.buf[this.pos++];
+    if (len === 0xfb) return null;
+    return this._atoi(len);
+  }
 
+  _atoi(len) {
     let result = 0;
     let negate = false;
     let begin = this.pos;
@@ -416,33 +534,19 @@ class Packet {
   }
 
   skipLengthCodedNumber() {
-    const type = this.buf[this.pos++] & 0xff;
+    const type = this.buf[this.pos++];
     switch (type) {
       case 251:
         return;
       case 252:
-        this.pos +=
-          2 + (0xffff & ((this.buf[this.pos] & 0xff) + ((this.buf[this.pos + 1] & 0xff) << 8)));
+        this.pos += 2 + (0xffff & (this.buf[this.pos] + (this.buf[this.pos + 1] << 8)));
         return;
       case 253:
         this.pos +=
-          3 +
-          (0xffffff &
-            ((this.buf[this.pos] & 0xff) +
-              ((this.buf[this.pos + 1] & 0xff) << 8) +
-              ((this.buf[this.pos + 2] & 0xff) << 16)));
+          3 + (0xffffff & (this.buf[this.pos] + (this.buf[this.pos + 1] << 8) + (this.buf[this.pos + 2] << 16)));
         return;
       case 254:
-        this.pos +=
-          8 +
-          ((this.buf[this.pos] & 0xff) +
-            ((this.buf[this.pos + 1] & 0xff) << 8) +
-            ((this.buf[this.pos + 2] & 0xff) << 16) +
-            ((this.buf[this.pos + 3] & 0xff) << 24) +
-            ((this.buf[this.pos + 4] & 0xff) << 32) +
-            ((this.buf[this.pos + 5] & 0xff) << 40) +
-            ((this.buf[this.pos + 6] & 0xff) << 48) +
-            ((this.buf[this.pos + 7] & 0xff) << 56));
+        this.pos += 8 + Number(this.buf.readBigUInt64LE(this.pos));
         return;
       default:
         this.pos += type;
@@ -450,30 +554,11 @@ class Packet {
     }
   }
 
-  positionFromEnd(num) {
-    this.pos = this.end - num;
-  }
-
-  /**
-   * For testing purpose only
-   */
-  _toBuf() {
-    return this.buf.slice(this.pos, this.end);
-  }
-
-  forceOffset(off) {
-    this.pos = off;
-  }
-
   length() {
     return this.end - this.pos;
   }
 
-  subPacketLengthEncoded() {
-    const len = this.readUnsignedLength();
-    this.skip(len);
-    return new Packet(this.buf, this.pos - len, this.pos);
-  }
+  subPacketLengthEncoded(len) {}
 
   /**
    * Parse ERR_Packet : https://mariadb.com/kb/en/library/err_packet/
@@ -485,31 +570,31 @@ class Packet {
    */
   readError(info, sql, stack) {
     this.skip(1);
-    let errorCode = this.readUInt16();
-    let sqlState = '';
-
+    let errno = this.readUInt16();
+    let sqlState;
+    let msg;
+    // check '#'
     if (this.peek() === 0x23) {
+      // skip '#'
       this.skip(6);
-      sqlState = this.buf.toString('utf8', this.pos - 5, this.pos);
+      sqlState = this.buf.toString(undefined, this.pos - 5, this.pos);
+      msg = this.readStringNullEnded();
+    } else {
+      // pre 4.1 format
+      sqlState = 'HY000';
+      msg = this.buf.toString(undefined, this.pos, this.end);
     }
-
-    let msg = this.buf.toString('utf8', this.pos, this.end);
     let fatal = sqlState.startsWith('08') || sqlState === '70100';
-    if (fatal) {
-      const packetMsgs = info.getLastPackets();
-      if (packetMsgs !== '')
-        return Errors.createError(
-          msg + '\nlast received packets:\n' + packetMsgs,
-          sql,
-          fatal,
-          info,
-          sqlState,
-          errorCode,
-          stack
-        );
-    }
-    return Errors.createError(msg, sql, fatal, info, sqlState, errorCode, stack);
+    return Errors.createError(msg, errno, info, sqlState, sql, fatal, stack);
   }
 }
 
+const appendZero = (val, len) => {
+  let st = val.toString();
+  while (st.length < len) {
+    st = '0' + st;
+  }
+  return st;
+};
+
 module.exports = Packet;