bson 5.0.0-alpha.0 → 5.0.0-alpha.2

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 } 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,7 +706,10 @@ export function serializeInto(
           ignoreUndefined,
           path
         );
-      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
+      } else if (
+        typeof value === 'object' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
         throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
@@ -726,7 +735,7 @@ export function serializeInto(
         );
       } else if (value._bsontype === 'Binary') {
         index = serializeBinary(buffer, key, value, index);
-      } else if (value._bsontype === 'Symbol') {
+      } else if (value._bsontype === 'BSONSymbol') {
         index = serializeSymbol(buffer, key, value, index);
       } else if (value._bsontype === 'DBRef') {
         index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
@@ -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,7 +816,10 @@ export function serializeInto(
           ignoreUndefined,
           path
         );
-      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
+      } else if (
+        typeof value === 'object' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
         throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
@@ -829,7 +845,7 @@ export function serializeInto(
         index = serializeFunction(buffer, key, value, index);
       } else if (value._bsontype === 'Binary') {
         index = serializeBinary(buffer, key, value, index);
-      } else if (value._bsontype === 'Symbol') {
+      } else if (value._bsontype === 'BSONSymbol') {
         index = serializeSymbol(buffer, key, value, index);
       } else if (value._bsontype === 'DBRef') {
         index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
@@ -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,7 +926,10 @@ export function serializeInto(
           ignoreUndefined,
           path
         );
-      } else if (typeof value === 'object' && value[Symbol.for('@@mdb.bson.version')] == null) {
+      } else if (
+        typeof value === 'object' &&
+        value[Symbol.for('@@mdb.bson.version')] !== constants.BSON_MAJOR_VERSION
+      ) {
         throw new BSONError('Unsupported BSON version, bson types must be from bson 5.0 or later');
       } else if (value._bsontype === 'ObjectId') {
         index = serializeObjectId(buffer, key, value, index);
@@ -936,7 +955,7 @@ export function serializeInto(
         index = serializeFunction(buffer, key, value, index);
       } else if (value._bsontype === 'Binary') {
         index = serializeBinary(buffer, key, value, index);
-      } else if (value._bsontype === 'Symbol') {
+      } else if (value._bsontype === 'BSONSymbol') {
         index = serializeSymbol(buffer, key, value, index);
       } else if (value._bsontype === 'DBRef') {
         index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
@@ -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,4 +1,5 @@
-import { BSONError, BSONTypeError } from './error';
+import { BSON_MAJOR_VERSION } from './constants';
+import { BSONError } from './error';
 import type { EJSONOptions } from './extended_json';
 
 function alphabetize(str: string): string {
@@ -29,8 +30,8 @@ export class BSONRegExp {
     return 'BSONRegExp';
   }
   /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): 5 {
-    return 5;
+  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
+    return BSON_MAJOR_VERSION;
   }
 
   pattern!: string;
@@ -102,7 +103,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 */

package/src/symbol.ts

@@ -1,3 +1,5 @@
+import { BSON_MAJOR_VERSION } from './constants';
+
 /** @public */
 export interface BSONSymbolExtended {
   $symbol: string;
@@ -13,8 +15,8 @@ export class BSONSymbol {
     return 'BSONSymbol';
   }
   /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): 5 {
-    return 5;
+  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
+    return BSON_MAJOR_VERSION;
   }
 
   value!: string;

package/src/timestamp.ts

@@ -1,3 +1,4 @@
+import { BSON_MAJOR_VERSION } from './constants';
 import { BSONError } from './error';
 import type { Int32 } from './int_32';
 import { Long } from './long';
@@ -33,8 +34,8 @@ export class Timestamp extends LongWithoutOverridesClass {
     return 'Timestamp';
   }
   /** @internal */
-  get [Symbol.for('@@mdb.bson.version')](): 5 {
-    return 5;
+  get [Symbol.for('@@mdb.bson.version')](): BSON_MAJOR_VERSION {
+    return BSON_MAJOR_VERSION;
   }
 
   static readonly MAX_VALUE = Long.MAX_UNSIGNED_VALUE;

package/src/uuid_utils.ts

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