bson 5.1.0 → 5.3.0

package/lib/bson.cjs

@@ -1,5 +1,21 @@
 'use strict';
 
+function isAnyArrayBuffer(value) {
+    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
+}
+function isUint8Array(value) {
+    return Object.prototype.toString.call(value) === '[object Uint8Array]';
+}
+function isRegExp(d) {
+    return Object.prototype.toString.call(d) === '[object RegExp]';
+}
+function isMap(d) {
+    return Object.prototype.toString.call(d) === '[object Map]';
+}
+function isDate(d) {
+    return Object.prototype.toString.call(d) === '[object Date]';
+}
+
 const BSON_MAJOR_VERSION = 5;
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
@@ -282,44 +298,6 @@ class BSONDataView extends DataView {
     }
 }
 
-const VALIDATION_REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|[0-9a-f]{12}4[0-9a-f]{3}[89ab][0-9a-f]{15})$/i;
-const uuidValidateString = (str) => typeof str === 'string' && VALIDATION_REGEX.test(str);
-const uuidHexStringToBuffer = (hexString) => {
-    if (!uuidValidateString(hexString)) {
-        throw new BSONError('UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".');
-    }
-    const sanitizedHexString = hexString.replace(/-/g, '');
-    return ByteUtils.fromHex(sanitizedHexString);
-};
-function bufferToUuidHexString(buffer, includeDashes = true) {
-    if (includeDashes) {
-        return [
-            ByteUtils.toHex(buffer.subarray(0, 4)),
-            ByteUtils.toHex(buffer.subarray(4, 6)),
-            ByteUtils.toHex(buffer.subarray(6, 8)),
-            ByteUtils.toHex(buffer.subarray(8, 10)),
-            ByteUtils.toHex(buffer.subarray(10, 16))
-        ].join('-');
-    }
-    return ByteUtils.toHex(buffer);
-}
-
-function isAnyArrayBuffer(value) {
-    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
-}
-function isUint8Array(value) {
-    return Object.prototype.toString.call(value) === '[object Uint8Array]';
-}
-function isRegExp(d) {
-    return Object.prototype.toString.call(d) === '[object RegExp]';
-}
-function isMap(d) {
-    return Object.prototype.toString.call(d) === '[object Map]';
-}
-function isDate(d) {
-    return Object.prototype.toString.call(d) === '[object Date]';
-}
-
 class BSONValue {
     get [Symbol.for('@@mdb.bson.version')]() {
         return BSON_MAJOR_VERSION;
@@ -457,6 +435,12 @@ class Binary extends BSONValue {
         }
         throw new BSONError(`Binary sub_type "${this.sub_type}" is not supported for converting to UUID. Only "${Binary.SUBTYPE_UUID}" is currently supported.`);
     }
+    static createFromHexString(hex, subType) {
+        return new Binary(ByteUtils.fromHex(hex), subType);
+    }
+    static createFromBase64(base64, subType) {
+        return new Binary(ByteUtils.fromBase64(base64), subType);
+    }
     static fromExtendedJSON(doc, options) {
         options = options || {};
         let data;
@@ -475,7 +459,7 @@ class Binary extends BSONValue {
         }
         else if ('$uuid' in doc) {
             type = 4;
-            data = uuidHexStringToBuffer(doc.$uuid);
+            data = UUID.bytesFromString(doc.$uuid);
         }
         if (!data) {
             throw new BSONError(`Unexpected Binary Extended JSON format ${JSON.stringify(doc)}`);
@@ -486,7 +470,8 @@ class Binary extends BSONValue {
         return this.inspect();
     }
     inspect() {
-        return `new Binary(Buffer.from("${ByteUtils.toHex(this.buffer)}", "hex"), ${this.sub_type})`;
+        const base64 = ByteUtils.toBase64(this.buffer.subarray(0, this.position));
+        return `Binary.createFromBase64("${base64}", ${this.sub_type})`;
     }
 }
 Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
@@ -501,47 +486,45 @@ Binary.SUBTYPE_ENCRYPTED = 6;
 Binary.SUBTYPE_COLUMN = 7;
 Binary.SUBTYPE_USER_DEFINED = 128;
 const UUID_BYTE_LENGTH = 16;
+const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
+const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
 class UUID extends Binary {
     constructor(input) {
         let bytes;
-        let hexStr;
         if (input == null) {
             bytes = UUID.generate();
         }
         else if (input instanceof UUID) {
             bytes = ByteUtils.toLocalBufferType(new Uint8Array(input.buffer));
-            hexStr = input.__id;
         }
         else if (ArrayBuffer.isView(input) && input.byteLength === UUID_BYTE_LENGTH) {
             bytes = ByteUtils.toLocalBufferType(input);
         }
         else if (typeof input === 'string') {
-            bytes = uuidHexStringToBuffer(input);
+            bytes = UUID.bytesFromString(input);
         }
         else {
             throw new BSONError('Argument passed in UUID constructor must be a UUID, a 16 byte Buffer or a 32/36 character hex string (dashes excluded/included, format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).');
         }
         super(bytes, BSON_BINARY_SUBTYPE_UUID_NEW);
-        this.__id = hexStr;
     }
     get id() {
         return this.buffer;
     }
     set id(value) {
         this.buffer = value;
-        if (UUID.cacheHexString) {
-            this.__id = bufferToUuidHexString(value);
-        }
     }
     toHexString(includeDashes = true) {
-        if (UUID.cacheHexString && this.__id) {
-            return this.__id;
-        }
-        const uuidHexString = bufferToUuidHexString(this.id, includeDashes);
-        if (UUID.cacheHexString) {
-            this.__id = uuidHexString;
+        if (includeDashes) {
+            return [
+                ByteUtils.toHex(this.buffer.subarray(0, 4)),
+                ByteUtils.toHex(this.buffer.subarray(4, 6)),
+                ByteUtils.toHex(this.buffer.subarray(6, 8)),
+                ByteUtils.toHex(this.buffer.subarray(8, 10)),
+                ByteUtils.toHex(this.buffer.subarray(10, 16))
+            ].join('-');
         }
-        return uuidHexString;
+        return ByteUtils.toHex(this.buffer);
     }
     toString(encoding) {
         if (encoding === 'hex')
@@ -580,24 +563,32 @@ class UUID extends Binary {
         if (!input) {
             return false;
         }
-        if (input instanceof UUID) {
-            return true;
-        }
         if (typeof input === 'string') {
-            return uuidValidateString(input);
+            return UUID.isValidUUIDString(input);
         }
         if (isUint8Array(input)) {
-            if (input.byteLength !== UUID_BYTE_LENGTH) {
-                return false;
-            }
-            return (input[6] & 0xf0) === 0x40 && (input[8] & 0x80) === 0x80;
+            return input.byteLength === UUID_BYTE_LENGTH;
         }
-        return false;
+        return (input._bsontype === 'Binary' &&
+            input.sub_type === this.SUBTYPE_UUID &&
+            input.buffer.byteLength === 16);
     }
     static createFromHexString(hexString) {
-        const buffer = uuidHexStringToBuffer(hexString);
+        const buffer = UUID.bytesFromString(hexString);
         return new UUID(buffer);
     }
+    static createFromBase64(base64) {
+        return new UUID(ByteUtils.fromBase64(base64));
+    }
+    static bytesFromString(representation) {
+        if (!UUID.isValidUUIDString(representation)) {
+            throw new BSONError('UUID string representation must be 32 hex digits or canonical hyphenated representation');
+        }
+        return ByteUtils.fromHex(representation.replace(/-/g, ''));
+    }
+    static isValidUUIDString(representation) {
+        return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);
+    }
     [Symbol.for('nodejs.util.inspect.custom')]() {
         return this.inspect();
     }
@@ -605,6 +596,7 @@ class UUID extends Binary {
         return `new UUID("${this.toHexString()}")`;
     }
 }
+UUID.cacheHexString = false;
 
 class Code extends BSONValue {
     get _bsontype() {
@@ -2116,11 +2108,17 @@ class ObjectId extends BSONValue {
         return new ObjectId(buffer);
     }
     static createFromHexString(hexString) {
-        if (typeof hexString === 'undefined' || (hexString != null && hexString.length !== 24)) {
-            throw new BSONError('Argument passed in must be a single String of 12 bytes or a string of 24 hex characters');
+        if (hexString?.length !== 24) {
+            throw new BSONError('hex string must be 24 characters');
         }
         return new ObjectId(ByteUtils.fromHex(hexString));
     }
+    static createFromBase64(base64) {
+        if (base64?.length !== 16) {
+            throw new BSONError('base64 string must be 16 characters');
+        }
+        return new ObjectId(ByteUtils.fromBase64(base64));
+    }
     static isValid(id) {
         if (id == null)
             return false;
@@ -2775,7 +2773,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
+                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
                         value = value.toUUID();
                     }
                 }
@@ -2801,11 +2799,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 if (promoteBuffers && promoteValues) {
                     value = _buffer;
                 }
-                else if (subType === BSON_BINARY_SUBTYPE_UUID_NEW) {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType).toUUID();
-                }
                 else {
                     value = new Binary(buffer.slice(index, index + binarySize), subType);
+                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
+                        value = value.toUUID();
+                    }
                 }
             }
             index = index + binarySize;
@@ -4037,32 +4035,32 @@ function deserializeStream(data, startIndex, numberOfDocuments, documents, docSt
 
 var bson = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Code: Code,
+    BSONError: BSONError,
+    BSONRegExp: BSONRegExp,
+    BSONRuntimeError: BSONRuntimeError,
     BSONSymbol: BSONSymbol,
-    DBRef: DBRef,
+    BSONType: BSONType,
+    BSONValue: BSONValue,
+    BSONVersionError: BSONVersionError,
     Binary: Binary,
-    ObjectId: ObjectId,
-    UUID: UUID,
-    Long: Long,
-    Timestamp: Timestamp,
+    Code: Code,
+    DBRef: DBRef,
+    Decimal128: Decimal128,
     Double: Double,
+    EJSON: EJSON,
     Int32: Int32,
-    MinKey: MinKey,
+    Long: Long,
     MaxKey: MaxKey,
-    BSONRegExp: BSONRegExp,
-    Decimal128: Decimal128,
-    setInternalBufferSize: setInternalBufferSize,
-    serialize: serialize,
-    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
-    deserialize: deserialize,
+    MinKey: MinKey,
+    ObjectId: ObjectId,
+    Timestamp: Timestamp,
+    UUID: UUID,
     calculateObjectSize: calculateObjectSize,
+    deserialize: deserialize,
     deserializeStream: deserializeStream,
-    BSONValue: BSONValue,
-    BSONError: BSONError,
-    BSONVersionError: BSONVersionError,
-    BSONRuntimeError: BSONRuntimeError,
-    BSONType: BSONType,
-    EJSON: EJSON
+    serialize: serialize,
+    serializeWithBufferAndIndex: serializeWithBufferAndIndex,
+    setInternalBufferSize: setInternalBufferSize
 });
 
 exports.BSON = bson;