feat(NODE-4874): support EJSON parse for BigInt from $numberLong

src/constants.ts

@@ -7,6 +7,11 @@ export const BSON_INT64_MAX = Math.pow(2, 63) - 1;
 /** @internal */
 export const BSON_INT64_MIN = -Math.pow(2, 63);
 
+/** @internal */
+export const BSON_INT64_MAX_N = 2n ** 63n -1n; 
+/** @internal */
+export const BSON_INT64_MIN_N = 2n ** 63n -1n; 
+
 /**
  * Any integer up to 2^53 can be precisely represented by a double.
  * @internal

src/extended_json.ts

@@ -76,7 +76,7 @@ function deserializeValue(value: any, options: EJSONOptions = {}) {
     const in64BitRange = value <= BSON_INT64_MAX && value >= BSON_INT64_MIN;
 
     if (options.relaxed || options.legacy) {
-      return Number.isInteger(value) && options.useBigInt64 ? BigInt(value) : value;
+      return value;
     }
 
     if (Number.isInteger(value) && !Object.is(value, -0)) {
@@ -202,8 +202,8 @@ function serializeValue(value: any, options: EJSONSerializeOptions): any {
 
       throw new BSONError(
         'Converting circular structure to EJSON:\n' +
-          `    ${leadingPart}${alreadySeen}${circularPart}${current}\n` +
-          `    ${leadingSpace}\\${dashes}/`
+        `    ${leadingPart}${alreadySeen}${circularPart}${current}\n` +
+        `    ${leadingSpace}\\${dashes}/`
       );
     }
     options.seenObjects[options.seenObjects.length - 1].obj = value;

src/long.ts

@@ -1,6 +1,7 @@
 import { BSONError } from './error';
 import type { EJSONOptions } from './extended_json';
 import type { Timestamp } from './timestamp';
+import { BSON_INT64_MAX, BSON_INT64_MIN } from './constants';
 
 interface LongWASMHelpers {
   /** Gets the high bits of the last operation performed */
@@ -75,6 +76,18 @@ const INT_CACHE: { [key: number]: Long } = {};
 /** A cache of the Long representations of small unsigned integer values. */
 const UINT_CACHE: { [key: number]: Long } = {};
 
+/**
+  * Validate an int64 string.
+  *
+  * Fails on strings longer than 22 characters
+  * Fails on non-decimal strings */
+function validateInt64String(input: string): boolean {
+  if (input.length > 22) {
+    return false;
+  }
+  return /^(\+|\-)?[1-9][0-9]+$/.test(input);
+}
+
 /** @public */
 export interface LongExtended {
   $numberLong: string;
@@ -1025,11 +1038,22 @@ export class Long {
     doc: { $numberLong: string },
     options?: EJSONOptions
   ): number | Long | bigint {
-    const longResult = Long.fromString(doc.$numberLong);
     const defaults = { useBigInt64: false, relaxed: true };
     const ejsonOptions = { ...defaults, ...options };
+
+    if (!validateInt64String(doc.$numberLong)) {
+      throw new BSONError('Invalid int64 string');
+    }
+    const longResult = Long.fromString(doc.$numberLong);
+
     if (ejsonOptions.useBigInt64) {
-      return BigInt(doc.$numberLong);
+      const INT64_MAX = BigInt('0x7fffffffffffffff');
+      const INT64_MIN = BigInt('0xffffffffffffffff');
+      const result = BigInt(doc.$numberLong);
+      if (result > INT64_MAX || result < INT64_MIN) {
+        throw new BSONError('EJSON numberLong must be in int64 range');
+      }
+      return result;
     }
     if (ejsonOptions.relaxed) {
       return longResult.toNumber();

test/node/bigint.test.ts

@@ -4,8 +4,8 @@ import { expect } from 'chai';
 import { BSON_DATA_LONG } from '../../src/constants';
 import { BSONDataView } from '../../src/utils/byte_utils';
 
-describe('BSON BigInt support', function () {
-  describe('BSON.deserialize()', function () {
+describe('BSON BigInt support', function() {
+  describe('BSON.deserialize()', function() {
     type DeserialzationOptions = {
       useBigInt64: boolean | undefined;
       promoteValues: boolean | undefined;
@@ -60,15 +60,12 @@ describe('BSON BigInt support', function () {
 
     function generateTestDescription(entry: TestTableEntry): string {
       const options = entry.options;
-      const promoteValues = `promoteValues ${
-        options.promoteValues === undefined ? 'is default' : `is ${options.promoteValues}`
-      }`;
-      const promoteLongs = `promoteLongs ${
-        options.promoteLongs === undefined ? 'is default' : `is ${options.promoteLongs}`
-      }`;
-      const useBigInt64 = `useBigInt64 ${
-        options.useBigInt64 === undefined ? 'is default' : `is ${options.useBigInt64}`
-      }`;
+      const promoteValues = `promoteValues ${options.promoteValues === undefined ? 'is default' : `is ${options.promoteValues}`
+        }`;
+      const promoteLongs = `promoteLongs ${options.promoteLongs === undefined ? 'is default' : `is ${options.promoteLongs}`
+        }`;
+      const useBigInt64 = `useBigInt64 ${options.useBigInt64 === undefined ? 'is default' : `is ${options.useBigInt64}`
+        }`;
       const flagString = `${useBigInt64}, ${promoteValues}, and ${promoteLongs}`;
       if (entry.shouldThrow) {
         return `throws when ${flagString}`;
@@ -102,7 +99,7 @@ describe('BSON BigInt support', function () {
     }
   });
 
-  describe('BSON.serialize()', function () {
+  describe('BSON.serialize()', function() {
     // Index for the data type byte of a BSON document with a
     // NOTE: These offsets only apply for documents with the shape {a : <n>}
     // where n is a BigInt
@@ -138,13 +135,13 @@ describe('BSON BigInt support', function () {
       };
     }
 
-    it('serializes bigints with the correct BSON type', function () {
+    it('serializes bigints with the correct BSON type', function() {
       const testDoc = { a: 0n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       expect(serializedDoc.dataType).to.equal(BSON_DATA_LONG);
     });
 
-    it('serializes bigints into little-endian byte order', function () {
+    it('serializes bigints into little-endian byte order', function() {
       const testDoc = { a: 0x1234567812345678n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedResult = getSerializedDocParts(
@@ -158,7 +155,7 @@ describe('BSON BigInt support', function () {
       expect(expectedResult.value).to.equal(serializedDoc.value);
     });
 
-    it('serializes a BigInt that can be safely represented as a Number', function () {
+    it('serializes a BigInt that can be safely represented as a Number', function() {
       const testDoc = { a: 0x23n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedResult = getSerializedDocParts(
@@ -171,7 +168,7 @@ describe('BSON BigInt support', function () {
       expect(serializedDoc).to.deep.equal(expectedResult);
     });
 
-    it('serializes a BigInt in the valid range [-2^63, 2^63 - 1]', function () {
+    it('serializes a BigInt in the valid range [-2^63, 2^63 - 1]', function() {
       const testDoc = { a: 0xfffffffffffffff1n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedResult = getSerializedDocParts(
@@ -184,7 +181,7 @@ describe('BSON BigInt support', function () {
       expect(serializedDoc).to.deep.equal(expectedResult);
     });
 
-    it('wraps to negative on a BigInt that is larger than (2^63 -1)', function () {
+    it('wraps to negative on a BigInt that is larger than (2^63 -1)', function() {
       const maxIntPlusOne = { a: 2n ** 63n };
       const serializedMaxIntPlusOne = getSerializedDocParts(BSON.serialize(maxIntPlusOne));
       const expectedResultForMaxIntPlusOne = getSerializedDocParts(
@@ -197,7 +194,7 @@ describe('BSON BigInt support', function () {
       expect(serializedMaxIntPlusOne).to.deep.equal(expectedResultForMaxIntPlusOne);
     });
 
-    it('serializes BigInts at the edges of the valid range [-2^63, 2^63 - 1]', function () {
+    it('serializes BigInts at the edges of the valid range [-2^63, 2^63 - 1]', function() {
       const maxPositiveInt64 = { a: 2n ** 63n - 1n };
       const serializedMaxPositiveInt64 = getSerializedDocParts(BSON.serialize(maxPositiveInt64));
       const expectedSerializationForMaxPositiveInt64 = getSerializedDocParts(
@@ -221,7 +218,7 @@ describe('BSON BigInt support', function () {
       expect(serializedMinPositiveInt64).to.deep.equal(expectedSerializationForMinPositiveInt64);
     });
 
-    it('truncates a BigInt that is larger than a 64-bit int', function () {
+    it('truncates a BigInt that is larger than a 64-bit int', function() {
       const testDoc = { a: 2n ** 64n + 1n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedSerialization = getSerializedDocParts(
@@ -234,7 +231,7 @@ describe('BSON BigInt support', function () {
       expect(serializedDoc).to.deep.equal(expectedSerialization);
     });
 
-    it('serializes array of BigInts', function () {
+    it('serializes array of BigInts', function() {
       const testArr = { a: [1n] };
       const serializedArr = BSON.serialize(testArr);
       const expectedSerialization = bufferFromHexArray([
@@ -249,7 +246,7 @@ describe('BSON BigInt support', function () {
       expect(serializedArr).to.deep.equal(expectedSerialization);
     });
 
-    it('serializes Map with BigInt values', function () {
+    it('serializes Map with BigInt values', function() {
       const testMap = new Map();
       testMap.set('a', 1n);
       const serializedMap = getSerializedDocParts(BSON.serialize(testMap));
@@ -264,7 +261,7 @@ describe('BSON BigInt support', function () {
     });
   });
 
-  describe('EJSON.parse()', function () {
+  describe('EJSON.parse()', function() {
     type ParseOptions = {
       useBigInt64: boolean | undefined;
       relaxed: boolean | undefined;
@@ -312,7 +309,7 @@ describe('BSON BigInt support', function () {
       };
     }
 
-    describe('canonical input', function () {
+    describe('canonical input', function() {
       const canonicalInputTestTable = useBigInt64Values.flatMap(useBigInt64 => {
         return relaxedValues.flatMap(relaxed => {
           return genTestTable(
@@ -322,8 +319,8 @@ describe('BSON BigInt support', function () {
               useBigInt64IsSet
                 ? { a: 23n }
                 : relaxedIsSet
-                ? { a: 23 }
-                : { a: BSON.Long.fromNumber(23) }
+                  ? { a: 23 }
+                  : { a: BSON.Long.fromNumber(23) }
           );
         });
       });
@@ -340,18 +337,18 @@ describe('BSON BigInt support', function () {
       }
     });
 
-    describe('relaxed integer input', function () {
+    describe('relaxed integer input', function() {
       const relaxedIntegerInputTestTable = useBigInt64Values.flatMap(useBigInt64 => {
         return relaxedValues.flatMap(relaxed => {
           return genTestTable(
             useBigInt64,
             relaxed,
             (useBigInt64IsSet: boolean, relaxedIsSet: boolean) =>
-              useBigInt64IsSet
-                ? { a: 4294967296n }
-                : relaxedIsSet
+              relaxedIsSet
                 ? { a: 4294967296 }
-                : { a: BSON.Long.fromNumber(4294967296) }
+                : useBigInt64IsSet
+                  ? { a: 4294967296n }
+                  : { a: BSON.Long.fromNumber(4294967296) }
           );
         });
       });
@@ -367,7 +364,7 @@ describe('BSON BigInt support', function () {
       }
     });
 
-    describe('relaxed double input where double is outside of int32 range and useBigInt64 is true', function () {
+    describe('relaxed double input where double is outside of int32 range and useBigInt64 is true', function() {
       const relaxedDoubleInputTestTable = relaxedValues.flatMap(relaxed => {
         return genTestTable(true, relaxed, (_, relaxedIsSet: boolean) =>
           relaxedIsSet ? { a: 2147483647.9 } : { a: new BSON.Double(2147483647.9) }

test/node/long.test.ts

@@ -1,8 +1,8 @@
 import { expect } from 'chai';
-import { Long } from '../register-bson';
+import { Long, BSONError } from '../register-bson';
 
-describe('Long', function () {
-  it('accepts strings in the constructor', function () {
+describe('Long', function() {
+  it('accepts strings in the constructor', function() {
     expect(new Long('0').toString()).to.equal('0');
     expect(new Long('00').toString()).to.equal('0');
     expect(new Long('-1').toString()).to.equal('-1');
@@ -13,7 +13,7 @@ describe('Long', function () {
     expect(new Long('13835058055282163712', true).toString()).to.equal('13835058055282163712');
   });
 
-  it('accepts BigInts in Long constructor', function () {
+  it('accepts BigInts in Long constructor', function() {
     expect(new Long(0n).toString()).to.equal('0');
     expect(new Long(-1n).toString()).to.equal('-1');
     expect(new Long(-1n, true).toString()).to.equal('18446744073709551615');
@@ -23,8 +23,8 @@ describe('Long', function () {
     expect(new Long(13835058055282163712n, true).toString()).to.equal('13835058055282163712');
   });
 
-  describe('static fromExtendedJSON()', function () {
-    it('is not affected by the legacy flag', function () {
+  describe('static fromExtendedJSON()', function() {
+    it('is not affected by the legacy flag', function() {
       const ejsonDoc = { $numberLong: '123456789123456789' };
       const longRelaxedLegacy = Long.fromExtendedJSON(ejsonDoc, { legacy: true, relaxed: true });
       const longRelaxedNonLegacy = Long.fromExtendedJSON(ejsonDoc, {
@@ -40,5 +40,44 @@ describe('Long', function () {
       expect(longRelaxedLegacy).to.deep.equal(longRelaxedNonLegacy);
       expect(longCanonicalLegacy).to.deep.equal(longCanonicalNonLegacy);
     });
+
+    describe('rejects with BSONError', function() {
+      it('hex strings', function() {
+        expect(() => {
+          const ejsonDoc = { $numberLong: '0xffffffff' };
+          return Long.fromExtendedJSON(ejsonDoc);
+        }).to.throw(BSONError);
+      });
+      it('octal strings', function() {
+        expect(() => {
+          const ejsonDoc = { $numberLong: '0o1234567' };
+          return Long.fromExtendedJSON(ejsonDoc);
+        }).to.throw(BSONError);
+      });
+      it('strings longer than 22 characters', function() {
+        expect(() => {
+          const ejsonDoc = { $numberLong: '99999999999999999999999' }
+          return Long.fromExtendedJSON(ejsonDoc);
+        }).to.throw(BSONError);
+      });
+      it('strings with leading zeros', function() {
+        expect(() => {
+          const ejsonDoc = { $numberLong: '000123456' }
+          return Long.fromExtendedJSON(ejsonDoc);
+        }).to.throw(BSONError);
+      });
+      it('non-numeric strings', function() {
+        expect(() => {
+          const ejsonDoc = { $numberLong: 'hello world' }
+          return Long.fromExtendedJSON(ejsonDoc);
+        }).to.throw(BSONError);
+      })
+      it('strings encoding numbers larger than 64 bits wide when useBigInt64 is true', function() {
+        expect(() => {
+          const ejsonDoc = { $numberLong: 0xf_ffff_ffff_ffff_ffffn.toString() }
+          return Long.fromExtendedJSON(ejsonDoc, {useBigInt64: true});
+        }).to.throw(BSONError);
+      });
+    });
   });
 });

test/register-bson.js

@@ -31,6 +31,8 @@ chai.use(function (chai) {
     try {
       throwsAssertion.call(this, ...args);
     } catch (assertionError) {
+      console.log(JSON.stringify(assertionError), 2);
+      // FIXME(NODE-4874)
       if (assertionError.actual?.name === assertionError.expected) {
         return;
       }