bson 4.5.4 → 4.6.0

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)) {
@@ -5833,6 +5853,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 +5922,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 +5947,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 +6003,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 +6028,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 +6231,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 +6262,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 +6301,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 +6351,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 +6416,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;