bson 4.5.4 → 4.6.0

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)) {
@@ -5827,6 +5847,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 +5916,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 +5941,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 +5997,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 +6022,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 +6225,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 +6256,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 +6295,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 +6345,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 +6410,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;