bson 4.5.4 → 4.6.2

package/dist/bson.browser.umd.js

@@ -2077,11 +2077,29 @@
 	  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 () {
@@ -2095,8 +2113,10 @@
 	/** @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 () {
@@ -2219,7 +2239,7 @@
 	 * @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)) {
@@ -3786,9 +3806,15 @@
 	        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
@@ -4573,7 +4599,7 @@
 	                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 {
@@ -4690,7 +4716,7 @@
 	            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) &&
@@ -4707,7 +4733,9 @@
 	        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;
 	    };
@@ -4754,26 +4782,13 @@
 	    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 () {
@@ -5569,7 +5584,7 @@
 	    }
 	    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
@@ -5587,7 +5602,7 @@
 	    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) {
@@ -5833,6 +5848,43 @@
 	    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
@@ -5865,7 +5917,16 @@
 	        // 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);
 	        }
@@ -5881,7 +5942,7 @@
 	                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) {
@@ -5937,7 +5998,11 @@
 	                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;
 	        }
@@ -5958,6 +6023,9 @@
 	                }
 	                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)
@@ -6158,7 +6226,7 @@
 	                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;
 	        }
@@ -6189,7 +6257,7 @@
 	                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
@@ -6228,7 +6296,7 @@
 	                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
@@ -6278,8 +6346,10 @@
 	                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
@@ -6341,14 +6411,17 @@
 	    // 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;
@@ -6977,9 +7050,7 @@
 	            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') {
@@ -7155,21 +7226,18 @@
 	        }
 	    }
 	    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