bson 4.5.2 → 4.6.1

package/src/parser/serializer.ts

@@ -7,6 +7,7 @@ import type { DBRefLike } from '../db_ref';
 import type { Decimal128 } from '../decimal128';
 import type { Double } from '../double';
 import { ensureBuffer } from '../ensure_buffer';
+import { BSONError, BSONTypeError } from '../error';
 import { isBSONType } from '../extended_json';
 import { writeIEEE754 } from '../float_parser';
 import type { Int32 } from '../int_32';
@@ -311,7 +312,7 @@ function serializeObjectId(
     // browser polyfill
     buffer.set(value.id.subarray(0, 12), index);
   } else {
-    throw new TypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
+    throw new BSONTypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
   }
 
   // Adjust index
@@ -363,7 +364,7 @@ function serializeObject(
   path: Document[] = []
 ) {
   for (let i = 0; i < path.length; i++) {
-    if (path[i] === value) throw new Error('cyclic dependency detected');
+    if (path[i] === value) throw new BSONError('cyclic dependency detected');
   }
 
   // Push value to stack
@@ -766,8 +767,7 @@ export function serializeInto(
       let value = object[i];
 
       // Is there an override value
-      if (value && value.toBSON) {
-        if (typeof value.toBSON !== 'function') throw new TypeError('toBSON is not a function');
+      if (typeof value?.toBSON === 'function') {
         value = value.toBSON();
       }
 
@@ -776,7 +776,7 @@ export function serializeInto(
       } else if (typeof value === 'number') {
         index = serializeNumber(buffer, key, value, index, true);
       } else if (typeof value === 'bigint') {
-        throw new TypeError('Unsupported type BigInt, please use Decimal128');
+        throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
       } else if (typeof value === 'boolean') {
         index = serializeBoolean(buffer, key, value, index, true);
       } else if (value instanceof Date || isDate(value)) {
@@ -841,7 +841,7 @@ export function serializeInto(
       } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index, true);
       } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+        throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
       }
     }
   } else if (object instanceof Map || isMap(object)) {
@@ -884,7 +884,7 @@ export function serializeInto(
       } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
       } else if (type === 'bigint' || isBigInt64Array(value) || isBigUInt64Array(value)) {
-        throw new TypeError('Unsupported type BigInt, please use Decimal128');
+        throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
       } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
       } else if (value instanceof Date || isDate(value)) {
@@ -942,24 +942,23 @@ export function serializeInto(
       } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+        throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
       }
     }
   } else {
-    // Did we provide a custom serialization method
-    if (object.toBSON) {
-      if (typeof object.toBSON !== 'function') throw new TypeError('toBSON is not a function');
+    if (typeof object?.toBSON === 'function') {
+      // Provided a custom serialization method
       object = object.toBSON();
-      if (object != null && typeof object !== 'object')
-        throw new TypeError('toBSON function did not return an object');
+      if (object != null && typeof object !== 'object') {
+        throw new BSONTypeError('toBSON function did not return an object');
+      }
     }
 
     // Iterate over all the keys
     for (const key in object) {
       let value = object[key];
       // Is there an override value
-      if (value && value.toBSON) {
-        if (typeof value.toBSON !== 'function') throw new TypeError('toBSON is not a function');
+      if (typeof value?.toBSON === 'function') {
         value = value.toBSON();
       }
 
@@ -988,7 +987,7 @@ export function serializeInto(
       } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
       } else if (type === 'bigint') {
-        throw new TypeError('Unsupported type BigInt, please use Decimal128');
+        throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
       } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
       } else if (value instanceof Date || isDate(value)) {
@@ -1048,7 +1047,7 @@ export function serializeInto(
       } else if (value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       } else if (typeof value['_bsontype'] !== 'undefined') {
-        throw new TypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
+        throw new BSONTypeError('Unrecognized or invalid _bsontype: ' + value['_bsontype']);
       }
     }
   }

package/src/regexp.ts

@@ -1,3 +1,4 @@
+import { BSONError, BSONTypeError } from './error';
 import type { EJSONOptions } from './extended_json';
 
 function alphabetize(str: string): string {
@@ -37,6 +38,17 @@ export class BSONRegExp {
     this.pattern = pattern;
     this.options = alphabetize(options ?? '');
 
+    if (this.pattern.indexOf('\x00') !== -1) {
+      throw new BSONError(
+        `BSON Regex patterns cannot contain null bytes, found: ${JSON.stringify(this.pattern)}`
+      );
+    }
+    if (this.options.indexOf('\x00') !== -1) {
+      throw new BSONError(
+        `BSON Regex options cannot contain null bytes, found: ${JSON.stringify(this.options)}`
+      );
+    }
+
     // Validate options
     for (let i = 0; i < this.options.length; i++) {
       if (
@@ -49,7 +61,7 @@ export class BSONRegExp {
           this.options[i] === 'u'
         )
       ) {
-        throw new Error(`The regular expression option [${this.options[i]}] is not supported`);
+        throw new BSONError(`The regular expression option [${this.options[i]}] is not supported`);
       }
     }
   }
@@ -85,7 +97,7 @@ export class BSONRegExp {
         BSONRegExp.parseOptions(doc.$regularExpression.options)
       );
     }
-    throw new TypeError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
+    throw new BSONTypeError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
   }
 }
 

package/src/uuid.ts

@@ -3,6 +3,7 @@ import { ensureBuffer } from './ensure_buffer';
 import { Binary } from './binary';
 import { bufferToUuidHexString, uuidHexStringToBuffer, uuidValidateString } from './uuid_utils';
 import { isUint8Array, randomBytes } from './parser/utils';
+import { BSONTypeError } from './error';
 
 /** @public */
 export type UUIDExtended = {
@@ -45,7 +46,7 @@ export class UUID {
     } else if (typeof input === 'string') {
       this.id = uuidHexStringToBuffer(input);
     } else {
-      throw new TypeError(
+      throw new BSONTypeError(
         '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).'
       );
     }

package/src/uuid_utils.ts

@@ -1,4 +1,5 @@
 import { Buffer } from 'buffer';
+import { BSONTypeError } from './error';
 
 // Validation regex for v4 uuid (validates with or without dashes)
 const VALIDATION_REGEX =
@@ -9,7 +10,7 @@ export const uuidValidateString = (str: string): boolean =>
 
 export const uuidHexStringToBuffer = (hexString: string): Buffer => {
   if (!uuidValidateString(hexString)) {
-    throw new TypeError(
+    throw new BSONTypeError(
       'UUID string representations must be a 32 or 36 character hex string (dashes excluded/included). Format: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" or "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".'
     );
   }