bson 4.5.4 → 4.6.2

package/bower.json

@@ -22,5 +22,5 @@
     "test",
     "tools"
   ],
-  "version": "4.5.4"
+  "version": "4.6.2"
 }

package/bson.d.ts

@@ -156,6 +156,7 @@ export default BSON;
 /* Excluded from this release type: BSON_INT64_MIN */
 /** @public */
 export declare class BSONError extends Error {
+    constructor(message: string);
     readonly name: string;
 }
 /**
@@ -208,6 +209,7 @@ export declare interface BSONSymbolExtended {
 }
 /** @public */
 export declare class BSONTypeError extends TypeError {
+    constructor(message: string);
     readonly name: string;
 }
 /**
@@ -339,6 +341,24 @@ export declare interface DeserializeOptions {
     /** Offset into buffer to begin reading document from */
     index?: number;
     raw?: boolean;
+    /** Allows for opt-out utf-8 validation for all keys or
+     * specified keys. Must be all true or all false.
+     *
+     * @example
+     * ```js
+     * // disables validation on all keys
+     *  validation: { utf8: false }
+     *
+     * // enables validation only on specified keys a, b, and c
+     *  validation: { utf8: { a: true, b: true, c: true } }
+     *
+     *  // disables validation only on specified keys a, b
+     *  validation: { utf8: { a: false, b: false } }
+     * ```
+     */
+    validation?: {
+        utf8: boolean | Record<string, true> | Record<string, false>;
+    };
 }
 /**
  * Deserialize stream data as BSON documents.
@@ -855,7 +875,7 @@ export declare interface MinKeyExtended {
  * @public
  */
 declare class ObjectId {
-    _bsontype: 'ObjectId';
+    _bsontype: 'ObjectID';
     /* Excluded from this release type: index */
     static cacheHexString: boolean;
     /* Excluded from this release type: [kId] */
@@ -865,7 +885,7 @@ declare class ObjectId {
      *
      * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
      */
-    constructor(inputId?: string | Buffer | number | ObjectIdLike | ObjectId);
+    constructor(inputId?: string | number | ObjectId | ObjectIdLike | Buffer | Uint8Array);
     /*
     * The ObjectId bytes
     * @readonly
@@ -919,7 +939,7 @@ declare class ObjectId {
      *
      * @param id - ObjectId instance to validate.
      */
-    static isValid(id: number | string | ObjectId | Uint8Array | ObjectIdLike): boolean;
+    static isValid(id: string | number | ObjectId | ObjectIdLike | Buffer | Uint8Array): boolean;
     /* Excluded from this release type: toExtendedJSON */
     /* Excluded from this release type: fromExtendedJSON */
     inspect(): string;

package/dist/bson.browser.esm.js

@@ -2071,11 +2071,29 @@ function __extends(d, b) {
   d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 }
 
+var _assign = function __assign() {
+  _assign = Object.assign || function __assign(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return _assign.apply(this, arguments);
+};
+
 /** @public */
 var BSONError = /** @class */ (function (_super) {
     __extends(BSONError, _super);
-    function BSONError() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    function BSONError(message) {
+        var _this = _super.call(this, message) || this;
+        Object.setPrototypeOf(_this, BSONError.prototype);
+        return _this;
     }
     Object.defineProperty(BSONError.prototype, "name", {
         get: function () {
@@ -2089,8 +2107,10 @@ var BSONError = /** @class */ (function (_super) {
 /** @public */
 var BSONTypeError = /** @class */ (function (_super) {
     __extends(BSONTypeError, _super);
-    function BSONTypeError() {
-        return _super !== null && _super.apply(this, arguments) || this;
+    function BSONTypeError(message) {
+        var _this = _super.call(this, message) || this;
+        Object.setPrototypeOf(_this, BSONTypeError.prototype);
+        return _this;
     }
     Object.defineProperty(BSONTypeError.prototype, "name", {
         get: function () {
@@ -2213,7 +2233,7 @@ function deprecate(fn, message) {
  * @param potentialBuffer - The potential buffer
  * @returns Buffer the input if potentialBuffer is a buffer, or a buffer that
  * wraps a passed in Uint8Array
- * @throws TypeError If anything other than a Buffer or Uint8Array is passed in
+ * @throws BSONTypeError If anything other than a Buffer or Uint8Array is passed in
  */
 function ensureBuffer(potentialBuffer) {
     if (ArrayBuffer.isView(potentialBuffer)) {
@@ -3780,9 +3800,15 @@ var Decimal128 = /** @class */ (function () {
         if (typeof bytes === 'string') {
             this.bytes = Decimal128.fromString(bytes).bytes;
         }
-        else {
+        else if (isUint8Array(bytes)) {
+            if (bytes.byteLength !== 16) {
+                throw new BSONTypeError('Decimal128 must take a Buffer of 16 bytes');
+            }
             this.bytes = bytes;
         }
+        else {
+            throw new BSONTypeError('Decimal128 must take a Buffer or string');
+        }
     }
     /**
      * Create a Decimal128 instance from a string representation
@@ -4567,7 +4593,7 @@ var ObjectId = /** @class */ (function () {
                 this[kId] = buffer_1.from(workingId, 'hex');
             }
             else {
-                throw new BSONTypeError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters');
+                throw new BSONTypeError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer');
             }
         }
         else {
@@ -4684,7 +4710,7 @@ var ObjectId = /** @class */ (function () {
             return false;
         }
         if (otherId instanceof ObjectId) {
-            return this.toString() === otherId.toString();
+            return this[kId][11] === otherId[kId][11] && this[kId].equals(otherId[kId]);
         }
         if (typeof otherId === 'string' &&
             ObjectId.isValid(otherId) &&
@@ -4701,7 +4727,9 @@ var ObjectId = /** @class */ (function () {
         if (typeof otherId === 'object' &&
             'toHexString' in otherId &&
             typeof otherId.toHexString === 'function') {
-            return otherId.toHexString() === this.toHexString();
+            var otherIdString = otherId.toHexString();
+            var thisIdString = this.toHexString().toLowerCase();
+            return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;
         }
         return false;
     };
@@ -4748,26 +4776,13 @@ var ObjectId = /** @class */ (function () {
     ObjectId.isValid = function (id) {
         if (id == null)
             return false;
-        if (typeof id === 'number') {
-            return true;
-        }
-        if (typeof id === 'string') {
-            return id.length === 12 || (id.length === 24 && checkForHexRegExp.test(id));
-        }
-        if (id instanceof ObjectId) {
-            return true;
-        }
-        if (isUint8Array(id) && id.length === 12) {
+        try {
+            new ObjectId(id);
             return true;
         }
-        // Duck-Typing detection of ObjectId like objects
-        if (typeof id === 'object' && 'toHexString' in id && typeof id.toHexString === 'function') {
-            if (typeof id.id === 'string') {
-                return id.id.length === 12;
-            }
-            return id.toHexString().length === 24 && checkForHexRegExp.test(id.id.toString('hex'));
+        catch (_a) {
+            return false;
         }
-        return false;
     };
     /** @internal */
     ObjectId.prototype.toExtendedJSON = function () {
@@ -5563,7 +5578,7 @@ function calculateObjectSize$1(object, serializeFunctions, ignoreUndefined) {
     }
     else {
         // If we have toBSON defined, override the current object
-        if (object.toBSON) {
+        if (typeof (object === null || object === void 0 ? void 0 : object.toBSON) === 'function') {
             object = object.toBSON();
         }
         // Calculate size
@@ -5581,7 +5596,7 @@ value, serializeFunctions, isArray, ignoreUndefined) {
     if (isArray === void 0) { isArray = false; }
     if (ignoreUndefined === void 0) { ignoreUndefined = false; }
     // If we have toBSON defined, override the current object
-    if (value && value.toBSON) {
+    if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
         value = value.toBSON();
     }
     switch (typeof value) {
@@ -5827,6 +5842,43 @@ function deserializeObject(buffer, index, options, isArray) {
     var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
     var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
     var promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
+    // Ensures default validation option if none given
+    var validation = options.validation == null ? { utf8: true } : options.validation;
+    // Shows if global utf-8 validation is enabled or disabled
+    var globalUTFValidation = true;
+    // Reflects utf-8 validation setting regardless of global or specific key validation
+    var validationSetting;
+    // Set of keys either to enable or disable validation on
+    var utf8KeysSet = new Set();
+    // Check for boolean uniformity and empty validation option
+    var utf8ValidatedKeys = validation.utf8;
+    if (typeof utf8ValidatedKeys === 'boolean') {
+        validationSetting = utf8ValidatedKeys;
+    }
+    else {
+        globalUTFValidation = false;
+        var utf8ValidationValues = Object.keys(utf8ValidatedKeys).map(function (key) {
+            return utf8ValidatedKeys[key];
+        });
+        if (utf8ValidationValues.length === 0) {
+            throw new BSONError('UTF-8 validation setting cannot be empty');
+        }
+        if (typeof utf8ValidationValues[0] !== 'boolean') {
+            throw new BSONError('Invalid UTF-8 validation option, must specify boolean values');
+        }
+        validationSetting = utf8ValidationValues[0];
+        // Ensures boolean uniformity in utf-8 validation (all true or all false)
+        if (!utf8ValidationValues.every(function (item) { return item === validationSetting; })) {
+            throw new BSONError('Invalid UTF-8 validation option - keys must be all true or all false');
+        }
+    }
+    // Add keys to set that will either be validated or not based on validationSetting
+    if (!globalUTFValidation) {
+        for (var _i = 0, _a = Object.keys(utf8ValidatedKeys); _i < _a.length; _i++) {
+            var key = _a[_i];
+            utf8KeysSet.add(key);
+        }
+    }
     // Set the start index
     var startIndex = index;
     // Validate that we have at least 4 bytes of buffer
@@ -5859,7 +5911,16 @@ function deserializeObject(buffer, index, options, isArray) {
         // If are at the end of the buffer there is a problem with the document
         if (i >= buffer.byteLength)
             throw new BSONError('Bad BSON Document: illegal CString');
+        // Represents the key
         var name = isArray ? arrayIndex++ : buffer.toString('utf8', index, i);
+        // shouldValidateKey is true if the key should be validated, false otherwise
+        var shouldValidateKey = true;
+        if (globalUTFValidation || utf8KeysSet.has(name)) {
+            shouldValidateKey = validationSetting;
+        }
+        else {
+            shouldValidateKey = !validationSetting;
+        }
         if (isPossibleDBRef !== false && name[0] === '$') {
             isPossibleDBRef = allowedDBRefKeys.test(name);
         }
@@ -5875,7 +5936,7 @@ function deserializeObject(buffer, index, options, isArray) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            value = getValidatedString(buffer, index, index + stringSize - 1);
+            value = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
             index = index + stringSize;
         }
         else if (elementType === BSON_DATA_OID) {
@@ -5931,7 +5992,11 @@ function deserializeObject(buffer, index, options, isArray) {
                 value = buffer.slice(index, index + objectSize);
             }
             else {
-                value = deserializeObject(buffer, _index, options, false);
+                var objectOptions = options;
+                if (!globalUTFValidation) {
+                    objectOptions = _assign(_assign({}, options), { validation: { utf8: shouldValidateKey } });
+                }
+                value = deserializeObject(buffer, _index, objectOptions, false);
             }
             index = index + objectSize;
         }
@@ -5952,6 +6017,9 @@ function deserializeObject(buffer, index, options, isArray) {
                 }
                 arrayOptions['raw'] = true;
             }
+            if (!globalUTFValidation) {
+                arrayOptions = _assign(_assign({}, arrayOptions), { validation: { utf8: shouldValidateKey } });
+            }
             value = deserializeObject(buffer, _index, arrayOptions, true);
             index = index + objectSize;
             if (buffer[index - 1] !== 0)
@@ -6152,7 +6220,7 @@ function deserializeObject(buffer, index, options, isArray) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            var symbol = getValidatedString(buffer, index, index + stringSize - 1);
+            var symbol = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
             value = promoteValues ? symbol : new BSONSymbol(symbol);
             index = index + stringSize;
         }
@@ -6183,7 +6251,7 @@ function deserializeObject(buffer, index, options, isArray) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            var functionString = getValidatedString(buffer, index, index + stringSize - 1);
+            var functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
             // If we are evaluating the functions
             if (evalFunctions) {
                 // If we have cache enabled let's look for the md5 of the function in the cache
@@ -6222,7 +6290,7 @@ function deserializeObject(buffer, index, options, isArray) {
                 throw new BSONError('bad string length in bson');
             }
             // Javascript function
-            var functionString = getValidatedString(buffer, index, index + stringSize - 1);
+            var functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
             // Update parse index position
             index = index + stringSize;
             // Parse the element
@@ -6272,8 +6340,10 @@ function deserializeObject(buffer, index, options, isArray) {
                 buffer[index + stringSize - 1] !== 0)
                 throw new BSONError('bad string length in bson');
             // Namespace
-            if (!validateUtf8(buffer, index, index + stringSize - 1)) {
-                throw new BSONError('Invalid UTF-8 string in BSON document');
+            if (validation != null && validation.utf8) {
+                if (!validateUtf8(buffer, index, index + stringSize - 1)) {
+                    throw new BSONError('Invalid UTF-8 string in BSON document');
+                }
             }
             var namespace = buffer.toString('utf8', index, index + stringSize - 1);
             // Update parse index position
@@ -6335,14 +6405,17 @@ function isolateEval(functionString, functionCache, object) {
     // Set the object
     return functionCache[functionString].bind(object);
 }
-function getValidatedString(buffer, start, end) {
+function getValidatedString(buffer, start, end, shouldValidateUtf8) {
     var value = buffer.toString('utf8', start, end);
-    for (var i = 0; i < value.length; i++) {
-        if (value.charCodeAt(i) === 0xfffd) {
-            if (!validateUtf8(buffer, start, end)) {
-                throw new BSONError('Invalid UTF-8 string in BSON document');
+    // if utf8 validation is on, do the check
+    if (shouldValidateUtf8) {
+        for (var i = 0; i < value.length; i++) {
+            if (value.charCodeAt(i) === 0xfffd) {
+                if (!validateUtf8(buffer, start, end)) {
+                    throw new BSONError('Invalid UTF-8 string in BSON document');
+                }
+                break;
             }
-            break;
         }
     }
     return value;
@@ -6971,9 +7044,7 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             var key = '' + i;
             var value = object[i];
             // Is there an override value
-            if (value && value.toBSON) {
-                if (typeof value.toBSON !== 'function')
-                    throw new BSONTypeError('toBSON is not a function');
+            if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
                 value = value.toBSON();
             }
             if (typeof value === 'string') {
@@ -7149,21 +7220,18 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
         }
     }
     else {
-        // Did we provide a custom serialization method
-        if (object.toBSON) {
-            if (typeof object.toBSON !== 'function')
-                throw new BSONTypeError('toBSON is not a function');
+        if (typeof (object === null || object === void 0 ? void 0 : object.toBSON) === 'function') {
+            // Provided a custom serialization method
             object = object.toBSON();
-            if (object != null && typeof object !== 'object')
+            if (object != null && typeof object !== 'object') {
                 throw new BSONTypeError('toBSON function did not return an object');
+            }
         }
         // Iterate over all the keys
         for (var key in object) {
             var value = object[key];
             // Is there an override value
-            if (value && value.toBSON) {
-                if (typeof value.toBSON !== 'function')
-                    throw new BSONTypeError('toBSON is not a function');
+            if (typeof (value === null || value === void 0 ? void 0 : value.toBSON) === 'function') {
                 value = value.toBSON();
             }
             // Check the type of the value