bson 5.0.0-alpha.1 → 5.0.0-alpha.3

package/src/long.ts

@@ -1,4 +1,5 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
+import { BSONError } from './error';
 import type { EJSONOptions } from './extended_json';
 import type { Timestamp } from './timestamp';
 
@@ -75,6 +76,10 @@ const INT_CACHE: { [key: number]: Long } = {};
 /** A cache of the Long representations of small unsigned integer values. */
 const UINT_CACHE: { [key: number]: Long } = {};
 
+const MAX_INT64_STRING_LENGTH = 20;
+
+const DECIMAL_REG_EX = /^(\+?0|(\+|-)?[1-9][0-9]*)$/;
+
 /** @public */
 export interface LongExtended {
   $numberLong: string;
@@ -99,14 +104,10 @@ export interface LongExtended {
  * case would often result in infinite recursion.
  * Common constant values ZERO, ONE, NEG_ONE, etc. are found as static properties on this class.
  */
-export class Long {
+export class Long extends BSONValue {
   get _bsontype(): 'Long' {
     return 'Long';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** An indicator used to reliably determine if an object is a Long or not. */
   get __isLong__(): boolean {
@@ -142,6 +143,7 @@ export class Long {
    * @param unsigned - Whether unsigned or not, defaults to signed
    */
   constructor(low: number | bigint | string = 0, high?: number | boolean, unsigned?: boolean) {
+    super();
     if (typeof low === 'bigint') {
       Object.assign(this, Long.fromBigInt(low, !!high));
     } else if (typeof low === 'string') {
@@ -250,7 +252,7 @@ export class Long {
    * @returns The corresponding Long value
    */
   static fromString(str: string, unsigned?: boolean, radix?: number): Long {
-    if (str.length === 0) throw Error('empty string');
+    if (str.length === 0) throw new BSONError('empty string');
     if (str === 'NaN' || str === 'Infinity' || str === '+Infinity' || str === '-Infinity')
       return Long.ZERO;
     if (typeof unsigned === 'number') {
@@ -260,10 +262,10 @@ export class Long {
       unsigned = !!unsigned;
     }
     radix = radix || 10;
-    if (radix < 2 || 36 < radix) throw RangeError('radix');
+    if (radix < 2 || 36 < radix) throw new BSONError('radix');
 
     let p;
-    if ((p = str.indexOf('-')) > 0) throw Error('interior hyphen');
+    if ((p = str.indexOf('-')) > 0) throw new BSONError('interior hyphen');
     else if (p === 0) {
       return Long.fromString(str.substring(1), unsigned, radix).neg();
     }
@@ -431,7 +433,7 @@ export class Long {
    */
   divide(divisor: string | number | Long | Timestamp): Long {
     if (!Long.isLong(divisor)) divisor = Long.fromValue(divisor);
-    if (divisor.isZero()) throw Error('division by zero');
+    if (divisor.isZero()) throw new BSONError('division by zero');
 
     // use wasm support if present
     if (wasm) {
@@ -959,7 +961,7 @@ export class Long {
    */
   toString(radix?: number): string {
     radix = radix || 10;
-    if (radix < 2 || 36 < radix) throw RangeError('radix');
+    if (radix < 2 || 36 < radix) throw new BSONError('radix');
     if (this.isZero()) return '0';
     if (this.isNegative()) {
       // Unsigned Longs are never negative
@@ -1025,9 +1027,30 @@ export class Long {
     if (options && options.relaxed) return this.toNumber();
     return { $numberLong: this.toString() };
   }
-  static fromExtendedJSON(doc: { $numberLong: string }, options?: EJSONOptions): number | Long {
-    const result = Long.fromString(doc.$numberLong);
-    return options && options.relaxed ? result.toNumber() : result;
+  static fromExtendedJSON(
+    doc: { $numberLong: string },
+    options?: EJSONOptions
+  ): number | Long | bigint {
+    const { useBigInt64 = false, relaxed = true } = { ...options };
+
+    if (doc.$numberLong.length > MAX_INT64_STRING_LENGTH) {
+      throw new BSONError('$numberLong string is too long');
+    }
+
+    if (!DECIMAL_REG_EX.test(doc.$numberLong)) {
+      throw new BSONError(`$numberLong string "${doc.$numberLong}" is in an invalid format`);
+    }
+
+    if (useBigInt64) {
+      const bigIntResult = BigInt(doc.$numberLong);
+      return BigInt.asIntN(64, bigIntResult);
+    }
+
+    const longResult = Long.fromString(doc.$numberLong);
+    if (relaxed) {
+      return longResult.toNumber();
+    }
+    return longResult;
   }
 
   /** @internal */

package/src/max_key.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 
 /** @public */
 export interface MaxKeyExtended {
@@ -10,14 +10,10 @@ export interface MaxKeyExtended {
  * @public
  * @category BSONType
  */
-export class MaxKey {
+export class MaxKey extends BSONValue {
   get _bsontype(): 'MaxKey' {
     return 'MaxKey';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** @internal */
   toExtendedJSON(): MaxKeyExtended {

package/src/min_key.ts

@@ -1,4 +1,4 @@
-import { BSON_MAJOR_VERSION } from './constants';
+import { BSONValue } from './bson_value';
 
 /** @public */
 export interface MinKeyExtended {
@@ -10,14 +10,10 @@ export interface MinKeyExtended {
  * @public
  * @category BSONType
  */
-export class MinKey {
+export class MinKey extends BSONValue {
   get _bsontype(): 'MinKey' {
     return 'MinKey';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** @internal */
   toExtendedJSON(): MinKeyExtended {

package/src/objectid.ts

@@ -1,5 +1,5 @@
-import { BSON_MAJOR_VERSION } from './constants';
-import { BSONTypeError } from './error';
+import { BSONValue } from './bson_value';
+import { BSONError } from './error';
 import { isUint8Array } from './parser/utils';
 import { BSONDataView, ByteUtils } from './utils/byte_utils';
 
@@ -28,14 +28,10 @@ const kId = Symbol('id');
  * @public
  * @category BSONType
  */
-export class ObjectId {
+export class ObjectId extends BSONValue {
   get _bsontype(): 'ObjectId' {
     return 'ObjectId';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   /** @internal */
   private static index = Math.floor(Math.random() * 0xffffff);
@@ -53,13 +49,12 @@ export class ObjectId {
    * @param inputId - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
    */
   constructor(inputId?: string | number | ObjectId | ObjectIdLike | Uint8Array) {
+    super();
     // workingId is set based on type of input and whether valid id exists for the input
     let workingId;
     if (typeof inputId === 'object' && inputId && 'id' in inputId) {
       if (typeof inputId.id !== 'string' && !ArrayBuffer.isView(inputId.id)) {
-        throw new BSONTypeError(
-          'Argument passed in must have an id that is of type string or Buffer'
-        );
+        throw new BSONError('Argument passed in must have an id that is of type string or Buffer');
       }
       if ('toHexString' in inputId && typeof inputId.toHexString === 'function') {
         workingId = ByteUtils.fromHex(inputId.toHexString());
@@ -85,17 +80,17 @@ export class ObjectId {
         if (bytes.byteLength === 12) {
           this[kId] = bytes;
         } else {
-          throw new BSONTypeError('Argument passed in must be a string of 12 bytes');
+          throw new BSONError('Argument passed in must be a string of 12 bytes');
         }
       } else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
         this[kId] = ByteUtils.fromHex(workingId);
       } else {
-        throw new BSONTypeError(
+        throw new BSONError(
           'Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer'
         );
       }
     } else {
-      throw new BSONTypeError('Argument passed in does not match the accepted types');
+      throw new BSONError('Argument passed in does not match the accepted types');
     }
     // If we are caching the hex string
     if (ObjectId.cacheHexString) {
@@ -271,7 +266,7 @@ export class ObjectId {
   static createFromHexString(hexString: string): ObjectId {
     // Throw an error if it's not a valid setup
     if (typeof hexString === 'undefined' || (hexString != null && hexString.length !== 24)) {
-      throw new BSONTypeError(
+      throw new BSONError(
         'Argument passed in must be a single String of 12 bytes or a string of 24 hex characters'
       );
     }

package/src/parser/calculate_size.ts

@@ -1,5 +1,6 @@
 import { Binary } from '../binary';
 import type { Document } from '../bson';
+import { BSONVersionError } from '../error';
 import * as constants from '../constants';
 import { ByteUtils } from '../utils/byte_utils';
 import { isAnyArrayBuffer, isDate, isRegExp } from './utils';
@@ -77,9 +78,15 @@ function calculateElement(
     case 'boolean':
       return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 1);
     case 'object':
-      if (value == null || value['_bsontype'] === 'MinKey' || value['_bsontype'] === 'MaxKey') {
+      if (
+        value != null &&
+        typeof value._bsontype === 'string' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
+        throw new BSONVersionError();
+      } else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + 1;
-      } else if (value['_bsontype'] === 'ObjectId') {
+      } else if (value._bsontype === 'ObjectId') {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (12 + 1);
       } else if (value instanceof Date || isDate(value)) {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
@@ -92,14 +99,14 @@ function calculateElement(
           (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (1 + 4 + 1) + value.byteLength
         );
       } else if (
-        value['_bsontype'] === 'Long' ||
-        value['_bsontype'] === 'Double' ||
-        value['_bsontype'] === 'Timestamp'
+        value._bsontype === 'Long' ||
+        value._bsontype === 'Double' ||
+        value._bsontype === 'Timestamp'
       ) {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
-      } else if (value['_bsontype'] === 'Decimal128') {
+      } else if (value._bsontype === 'Decimal128') {
         return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (16 + 1);
-      } else if (value['_bsontype'] === 'Code') {
+      } else if (value._bsontype === 'Code') {
         // Calculate size depending on the availability of a scope
         if (value.scope != null && Object.keys(value.scope).length > 0) {
           return (
@@ -120,7 +127,7 @@ function calculateElement(
             1
           );
         }
-      } else if (value['_bsontype'] === 'Binary') {
+      } else if (value._bsontype === 'Binary') {
         const binary: Binary = value;
         // Check what kind of subtype we have
         if (binary.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
@@ -133,7 +140,7 @@ function calculateElement(
             (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (binary.position + 1 + 4 + 1)
           );
         }
-      } else if (value['_bsontype'] === 'Symbol') {
+      } else if (value._bsontype === 'Symbol') {
         return (
           (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
           ByteUtils.utf8ByteLength(value.value) +
@@ -141,7 +148,7 @@ function calculateElement(
           1 +
           1
         );
-      } else if (value['_bsontype'] === 'DBRef') {
+      } else if (value._bsontype === 'DBRef') {
         // Set up correct object for serialization
         const ordered_values = Object.assign(
           {
@@ -172,7 +179,7 @@ function calculateElement(
           (value.multiline ? 1 : 0) +
           1
         );
-      } else if (value['_bsontype'] === 'BSONRegExp') {
+      } else if (value._bsontype === 'BSONRegExp') {
         return (
           (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) +
           1 +

package/src/parser/deserializer.ts

@@ -14,12 +14,14 @@ import { ObjectId } from '../objectid';
 import { BSONRegExp } from '../regexp';
 import { BSONSymbol } from '../symbol';
 import { Timestamp } from '../timestamp';
-import { ByteUtils } from '../utils/byte_utils';
+import { BSONDataView, ByteUtils } from '../utils/byte_utils';
 import { validateUtf8 } from '../validate_utf8';
 
 /** @public */
 export interface DeserializeOptions {
-  /** when deserializing a Long will fit it into a Number if it's smaller than 53 bits */
+  /** when deserializing a Long will return as a BigInt. */
+  useBigInt64?: boolean;
+  /** when deserializing a Long will fit it into a Number if it's smaller than 53 bits. */
   promoteLongs?: boolean;
   /** when deserializing a Binary will return it as a node.js Buffer instance. */
   promoteBuffers?: boolean;
@@ -29,7 +31,7 @@ export interface DeserializeOptions {
   fieldsAsRaw?: Document;
   /** return BSON regular expressions as BSONRegExp instances. */
   bsonRegExp?: boolean;
-  /** allows the buffer to be larger than the parsed BSON object */
+  /** allows the buffer to be larger than the parsed BSON object. */
   allowObjectSmallerThanBufferSize?: boolean;
   /** Offset into buffer to begin reading document from */
   index?: number;
@@ -96,7 +98,7 @@ export function internalDeserialize(
     );
   }
 
-  // Start deserializtion
+  // Start deserialization
   return deserializeObject(buffer, index, options, isArray);
 }
 
@@ -117,9 +119,18 @@ function deserializeObject(
   const bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;
 
   // Controls the promotion of values vs wrapper classes
-  const promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
-  const promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
-  const promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
+  const promoteBuffers = options.promoteBuffers ?? false;
+  const promoteLongs = options.promoteLongs ?? true;
+  const promoteValues = options.promoteValues ?? true;
+  const useBigInt64 = options.useBigInt64 ?? false;
+
+  if (useBigInt64 && !promoteValues) {
+    throw new BSONError('Must either request bigint or Long for int64 deserialization');
+  }
+
+  if (useBigInt64 && !promoteLongs) {
+    throw new BSONError('Must either request bigint or Long for int64 deserialization');
+  }
 
   // Ensures default validation option if none given
   const validation = options.validation == null ? { utf8: true } : options.validation;
@@ -323,6 +334,8 @@ function deserializeObject(
       value = null;
     } else if (elementType === constants.BSON_DATA_LONG) {
       // Unpack the low and high bits
+      const dataview = BSONDataView.fromUint8Array(buffer.subarray(index, index + 8));
+
       const lowBits =
         buffer[index++] |
         (buffer[index++] << 8) |
@@ -334,8 +347,10 @@ function deserializeObject(
         (buffer[index++] << 16) |
         (buffer[index++] << 24);
       const long = new Long(lowBits, highBits);
-      // Promote the long if possible
-      if (promoteLongs && promoteValues === true) {
+      if (useBigInt64) {
+        value = dataview.getBigInt64(0, true);
+      } else if (promoteLongs && promoteValues === true) {
+        // Promote the long if possible
         value =
           long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
             ? long.toNumber()

package/src/parser/serializer.ts

@@ -5,22 +5,14 @@ import * as constants from '../constants';
 import type { DBRefLike } from '../db_ref';
 import type { Decimal128 } from '../decimal128';
 import type { Double } from '../double';
-import { BSONError, BSONTypeError } from '../error';
+import { BSONError, BSONVersionError } from '../error';
 import type { Int32 } from '../int_32';
 import { Long } from '../long';
 import type { MinKey } from '../min_key';
 import type { ObjectId } from '../objectid';
 import type { BSONRegExp } from '../regexp';
 import { ByteUtils } from '../utils/byte_utils';
-import {
-  isAnyArrayBuffer,
-  isBigInt64Array,
-  isBigUInt64Array,
-  isDate,
-  isMap,
-  isRegExp,
-  isUint8Array
-} from './utils';
+import { isAnyArrayBuffer, isDate, isMap, isRegExp, isUint8Array } from './utils';
 
 /** @public */
 export interface SerializeOptions {
@@ -103,6 +95,20 @@ function serializeNumber(buffer: Uint8Array, key: string, value: number, index:
   return index;
 }
 
+function serializeBigInt(buffer: Uint8Array, key: string, value: bigint, index: number) {
+  buffer[index++] = constants.BSON_DATA_LONG;
+  // Number of written bytes
+  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
+  // Encode the name
+  index += numberOfWrittenBytes;
+  buffer[index++] = 0;
+  NUMBER_SPACE.setBigInt64(0, value, true);
+  // Write BigInt value
+  buffer.set(EIGHT_BYTE_VIEW_ON_NUMBER, index);
+  index += EIGHT_BYTE_VIEW_ON_NUMBER.byteLength;
+  return index;
+}
+
 function serializeNull(buffer: Uint8Array, key: string, _: unknown, index: number) {
   // Set long type
   buffer[index++] = constants.BSON_DATA_NULL;
@@ -165,7 +171,7 @@ function serializeRegExp(buffer: Uint8Array, key: string, value: RegExp, index:
   index = index + numberOfWrittenBytes;
   buffer[index++] = 0;
   if (value.source && value.source.match(regexp) != null) {
-    throw Error('value ' + value.source + ' must not contain null bytes');
+    throw new BSONError('value ' + value.source + ' must not contain null bytes');
   }
   // Adjust the index
   index = index + ByteUtils.encodeUTF8Into(buffer, value.source, index);
@@ -194,7 +200,7 @@ function serializeBSONRegExp(buffer: Uint8Array, key: string, value: BSONRegExp,
   if (value.pattern.match(regexp) != null) {
     // The BSON spec doesn't allow keys with null bytes because keys are
     // null-terminated.
-    throw Error('pattern ' + value.pattern + ' must not contain null bytes');
+    throw new BSONError('pattern ' + value.pattern + ' must not contain null bytes');
   }
 
   // Adjust the index
@@ -241,7 +247,7 @@ function serializeObjectId(buffer: Uint8Array, key: string, value: ObjectId, ind
   if (isUint8Array(value.id)) {
     buffer.set(value.id.subarray(0, 12), index);
   } else {
-    throw new BSONTypeError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
+    throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
   }
 
   // Adjust index
@@ -675,7 +681,7 @@ export function serializeInto(
       } else if (typeof value === 'number') {
         index = serializeNumber(buffer, key, value, index);
       } else if (typeof value === 'bigint') {
-        throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
+        index = serializeBigInt(buffer, key, value, index);
       } else if (typeof value === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
       } else if (value instanceof Date || isDate(value)) {
@@ -700,8 +706,11 @@ export function serializeInto(
           ignoreUndefined,
           path
         );
-      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+      } else if (
+        typeof value === 'object' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
+        throw new BSONVersionError();
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
       } else if (value._bsontype === 'Decimal128') {
@@ -737,7 +746,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 BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   } else if (object instanceof Map || isMap(object)) {
@@ -753,7 +762,11 @@ export function serializeInto(
 
       // Get the entry values
       const key = entry.value[0];
-      const value = entry.value[1];
+      let value = entry.value[1];
+
+      if (typeof value?.toBSON === 'function') {
+        value = value.toBSON();
+      }
 
       // Check the type of the value
       const type = typeof value;
@@ -763,14 +776,14 @@ export function serializeInto(
         if (key.match(regexp) != null) {
           // The BSON spec doesn't allow keys with null bytes because keys are
           // null-terminated.
-          throw Error('key ' + key + ' must not contain null bytes');
+          throw new BSONError('key ' + key + ' must not contain null bytes');
         }
 
         if (checkKeys) {
           if ('$' === key[0]) {
-            throw Error('key ' + key + " must not start with '$'");
+            throw new BSONError('key ' + key + " must not start with '$'");
           } else if (~key.indexOf('.')) {
-            throw Error('key ' + key + " must not contain '.'");
+            throw new BSONError('key ' + key + " must not contain '.'");
           }
         }
       }
@@ -779,8 +792,8 @@ export function serializeInto(
         index = serializeString(buffer, key, value, index);
       } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
-      } else if (type === 'bigint' || isBigInt64Array(value) || isBigUInt64Array(value)) {
-        throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
+      } else if (type === 'bigint') {
+        index = serializeBigInt(buffer, key, value, index);
       } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
       } else if (value instanceof Date || isDate(value)) {
@@ -803,8 +816,11 @@ export function serializeInto(
           ignoreUndefined,
           path
         );
-      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+      } else if (
+        typeof value === 'object' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
+        throw new BSONVersionError();
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
       } else if (type === 'object' && value._bsontype === 'Decimal128') {
@@ -840,7 +856,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 BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   } else {
@@ -848,7 +864,7 @@ export function serializeInto(
       // Provided a custom serialization method
       object = object.toBSON();
       if (object != null && typeof object !== 'object') {
-        throw new BSONTypeError('toBSON function did not return an object');
+        throw new BSONError('toBSON function did not return an object');
       }
     }
 
@@ -868,14 +884,14 @@ export function serializeInto(
         if (key.match(regexp) != null) {
           // The BSON spec doesn't allow keys with null bytes because keys are
           // null-terminated.
-          throw Error('key ' + key + ' must not contain null bytes');
+          throw new BSONError('key ' + key + ' must not contain null bytes');
         }
 
         if (checkKeys) {
           if ('$' === key[0]) {
-            throw Error('key ' + key + " must not start with '$'");
+            throw new BSONError('key ' + key + " must not start with '$'");
           } else if (~key.indexOf('.')) {
-            throw Error('key ' + key + " must not contain '.'");
+            throw new BSONError('key ' + key + " must not contain '.'");
           }
         }
       }
@@ -885,7 +901,7 @@ export function serializeInto(
       } else if (type === 'number') {
         index = serializeNumber(buffer, key, value, index);
       } else if (type === 'bigint') {
-        throw new BSONTypeError('Unsupported type BigInt, please use Decimal128');
+        index = serializeBigInt(buffer, key, value, index);
       } else if (type === 'boolean') {
         index = serializeBoolean(buffer, key, value, index);
       } else if (value instanceof Date || isDate(value)) {
@@ -910,8 +926,11 @@ export function serializeInto(
           ignoreUndefined,
           path
         );
-      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
-        throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
+      } else if (
+        typeof value === 'object' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
+        throw new BSONVersionError();
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
       } else if (type === 'object' && value._bsontype === 'Decimal128') {
@@ -947,7 +966,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 BSONTypeError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
     }
   }

package/src/regexp.ts

@@ -1,5 +1,5 @@
-import { BSON_MAJOR_VERSION } from './constants';
-import { BSONError, BSONTypeError } from './error';
+import { BSONValue } from './bson_value';
+import { BSONError } from './error';
 import type { EJSONOptions } from './extended_json';
 
 function alphabetize(str: string): string {
@@ -25,14 +25,10 @@ export interface BSONRegExpExtended {
  * @public
  * @category BSONType
  */
-export class BSONRegExp {
+export class BSONRegExp extends BSONValue {
   get _bsontype(): 'BSONRegExp' {
     return 'BSONRegExp';
   }
-  /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
-    return BSON_MAJOR_VERSION;
-  }
 
   pattern!: string;
   options!: string;
@@ -41,6 +37,7 @@ export class BSONRegExp {
    * @param options - The regular expression options
    */
   constructor(pattern: string, options?: string) {
+    super();
     this.pattern = pattern;
     this.options = alphabetize(options ?? '');
 
@@ -103,7 +100,7 @@ export class BSONRegExp {
         BSONRegExp.parseOptions(doc.$regularExpression.options)
       );
     }
-    throw new BSONTypeError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
+    throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
   }
 
   /** @internal */