bson 5.0.0 → 5.1.0

package/package.json

@@ -13,7 +13,7 @@
     "etc/prepare.js"
   ],
   "types": "bson.d.ts",
-  "version": "5.0.0",
+  "version": "5.1.0",
   "author": {
     "name": "The MongoDB NodeJS Team",
     "email": "dbx-node@mongodb.com"
@@ -41,6 +41,7 @@
     "chalk": "^5.1.2",
     "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-no-bigint-usage": "file:./etc/eslint/no-bigint-usage",
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-tsdoc": "^0.2.17",
     "magic-string": "^0.27.0",
@@ -76,20 +77,31 @@
   "main": "./lib/bson.cjs",
   "module": "./lib/bson.mjs",
   "exports": {
-    "import": "./lib/bson.mjs",
-    "require": "./lib/bson.cjs",
+    "import": {
+      "types": "./bson.d.ts",
+      "default": "./lib/bson.mjs"
+    },
+    "require": {
+      "types": "./bson.d.ts",
+      "default": "./lib/bson.cjs"
+    },
     "react-native": "./lib/bson.cjs",
     "browser": "./lib/bson.mjs"
   },
+  "compass:exports": {
+    "import": "./lib/bson.cjs",
+    "require": "./lib/bson.cjs"
+  },
   "engines": {
     "node": ">=14.20.1"
   },
   "scripts": {
     "pretest": "npm run build",
-    "test": "npm run check:node && npm run check:web",
+    "test": "npm run check:node && npm run check:web && npm run check:web-no-bigint",
     "check:node": "WEB=false mocha test/node",
     "check:tsd": "npm run build:dts && tsd",
     "check:web": "WEB=true mocha test/node",
+    "check:web-no-bigint": "WEB=true NO_BIGINT=true mocha test/node",
     "build:ts": "node ./node_modules/typescript/bin/tsc",
     "build:dts": "npm run build:ts && api-extractor run --typescript-compiler-folder node_modules/typescript --local && rimraf 'lib/**/*.d.ts*' lib/parser lib/utils",
     "build:bundle": "rollup -c rollup.config.mjs",

package/src/bson.ts

@@ -50,7 +50,7 @@ export {
   Decimal128
 };
 export { BSONValue } from './bson_value';
-export { BSONError, BSONVersionError } from './error';
+export { BSONError, BSONVersionError, BSONRuntimeError } from './error';
 export { BSONType } from './constants';
 export { EJSON } from './extended_json';
 

package/src/error.ts

@@ -2,7 +2,11 @@ import { BSON_MAJOR_VERSION } from './constants';
 
 /**
  * @public
- * `BSONError` objects are thrown when runtime errors occur.
+ * @category Error
+ *
+ * `BSONError` objects are thrown when BSON ecounters an error.
+ *
+ * This is the parent class for all the other errors thrown by this library.
  */
 export class BSONError extends Error {
   /**
@@ -46,7 +50,10 @@ export class BSONError extends Error {
   }
 }
 
-/** @public */
+/**
+ * @public
+ * @category Error
+ */
 export class BSONVersionError extends BSONError {
   get name(): 'BSONVersionError' {
     return 'BSONVersionError';
@@ -58,3 +65,21 @@ export class BSONVersionError extends BSONError {
     );
   }
 }
+
+/**
+ * @public
+ * @category Error
+ *
+ * An error generated when BSON functions encounter an unexpected input
+ * or reaches an unexpected/invalid internal state
+ *
+ */
+export class BSONRuntimeError extends BSONError {
+  get name(): 'BSONRuntimeError' {
+    return 'BSONRuntimeError';
+  }
+
+  constructor(message: string) {
+    super(message);
+  }
+}

package/src/extended_json.ts

@@ -11,13 +11,13 @@ import {
 import { DBRef, isDBRefLike } from './db_ref';
 import { Decimal128 } from './decimal128';
 import { Double } from './double';
-import { BSONError, BSONVersionError } from './error';
+import { BSONError, BSONRuntimeError, BSONVersionError } from './error';
 import { Int32 } from './int_32';
 import { Long } from './long';
 import { MaxKey } from './max_key';
 import { MinKey } from './min_key';
 import { ObjectId } from './objectid';
-import { isDate, isRegExp } from './parser/utils';
+import { isDate, isRegExp, isMap } from './parser/utils';
 import { BSONRegExp } from './regexp';
 import { BSONSymbol } from './symbol';
 import { Timestamp } from './timestamp';
@@ -93,6 +93,7 @@ function deserializeValue(value: any, options: EJSONOptions = {}) {
       }
       if (in64BitRange) {
         if (options.useBigInt64) {
+          // eslint-disable-next-line no-restricted-globals -- This is allowed here as useBigInt64=true
           return BigInt(value);
         }
         return Long.fromNumber(value);
@@ -124,10 +125,14 @@ function deserializeValue(value: any, options: EJSONOptions = {}) {
     if (options.legacy) {
       if (typeof d === 'number') date.setTime(d);
       else if (typeof d === 'string') date.setTime(Date.parse(d));
+      else if (typeof d === 'bigint') date.setTime(Number(d));
+      else throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);
     } else {
       if (typeof d === 'string') date.setTime(Date.parse(d));
       else if (Long.isLong(d)) date.setTime(d.toNumber());
       else if (typeof d === 'number' && options.relaxed) date.setTime(d);
+      else if (typeof d === 'bigint') date.setTime(Number(d));
+      else throw new BSONRuntimeError(`Unrecognized type for EJSON date: ${typeof d}`);
     }
     return date;
   }
@@ -185,6 +190,18 @@ function getISOString(date: Date) {
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function serializeValue(value: any, options: EJSONSerializeOptions): any {
+  if (value instanceof Map || isMap(value)) {
+    const obj: Record<string, unknown> = Object.create(null);
+    for (const [k, v] of value) {
+      if (typeof k !== 'string') {
+        throw new BSONError('Can only serialize maps with string keys');
+      }
+      obj[k] = v;
+    }
+
+    return serializeValue(obj, options);
+  }
+
   if ((typeof value === 'object' || typeof value === 'function') && value !== null) {
     const index = options.seenObjects.findIndex(entry => entry.obj === value);
     if (index !== -1) {
@@ -249,10 +266,12 @@ function serializeValue(value: any, options: EJSONSerializeOptions): any {
   }
 
   if (typeof value === 'bigint') {
+    /* eslint-disable no-restricted-globals -- This is allowed as we are accepting a bigint as input */
     if (!options.relaxed) {
       return { $numberLong: BigInt.asIntN(64, value).toString() };
     }
     return Number(BigInt.asIntN(64, value));
+    /* eslint-enable */
   }
 
   if (value instanceof RegExp || isRegExp(value)) {

package/src/long.ts

@@ -896,6 +896,7 @@ export class Long extends BSONValue {
 
   /** Converts the Long to a BigInt (arbitrary precision). */
   toBigInt(): bigint {
+    // eslint-disable-next-line no-restricted-globals -- This is allowed here as it is explicitly requesting a bigint
     return BigInt(this.toString());
   }
 
@@ -1042,8 +1043,10 @@ export class Long extends BSONValue {
     }
 
     if (useBigInt64) {
+      /* eslint-disable no-restricted-globals -- Can use BigInt here as useBigInt64=true */
       const bigIntResult = BigInt(doc.$numberLong);
       return BigInt.asIntN(64, bigIntResult);
+      /* eslint-enable */
     }
 
     const longResult = Long.fromString(doc.$numberLong);

package/src/utils/node_byte_utils.ts

@@ -22,7 +22,7 @@ type NodeJsBufferConstructor = Omit<Uint8ArrayConstructor, 'from'> & {
 // This can be nullish, but we gate the nodejs functions on being exported whether or not this exists
 // Node.js global
 declare const Buffer: NodeJsBufferConstructor;
-declare const require: (mod: 'node:crypto') => { randomBytes: (byteLength: number) => Uint8Array };
+declare const require: (mod: 'crypto') => { randomBytes: (byteLength: number) => Uint8Array };
 
 /** @internal */
 export function nodejsMathRandomBytes(byteLength: number) {
@@ -48,7 +48,7 @@ export function nodejsMathRandomBytes(byteLength: number) {
  */
 const nodejsRandomBytes: (byteLength: number) => Uint8Array = (() => {
   try {
-    return require('node:crypto').randomBytes;
+    return require('crypto').randomBytes;
   } catch {
     return nodejsMathRandomBytes;
   }