bson 6.3.0 → 6.5.0

package/src/parser/deserializer.ts

@@ -14,7 +14,8 @@ import { ObjectId } from '../objectid';
 import { BSONRegExp } from '../regexp';
 import { BSONSymbol } from '../symbol';
 import { Timestamp } from '../timestamp';
-import { BSONDataView, ByteUtils } from '../utils/byte_utils';
+import { ByteUtils } from '../utils/byte_utils';
+import { NumberUtils } from '../utils/number_utils';
 import { validateUtf8 } from '../validate_utf8';
 
 /** @public */
@@ -91,11 +92,7 @@ export function internalDeserialize(
   options = options == null ? {} : options;
   const index = options && options.index ? options.index : 0;
   // Read the document size
-  const size =
-    buffer[index] |
-    (buffer[index + 1] << 8) |
-    (buffer[index + 2] << 16) |
-    (buffer[index + 3] << 24);
+  const size = NumberUtils.getInt32LE(buffer, index);
 
   if (size < 5) {
     throw new BSONError(`bson size must be >= 5, is ${size}`);
@@ -164,7 +161,7 @@ function deserializeObject(
   // Reflects utf-8 validation setting regardless of global or specific key validation
   let validationSetting: boolean;
   // Set of keys either to enable or disable validation on
-  const utf8KeysSet = new Set();
+  let utf8KeysSet;
 
   // Check for boolean uniformity and empty validation option
   const utf8ValidatedKeys = validation.utf8;
@@ -190,6 +187,8 @@ function deserializeObject(
 
   // Add keys to set that will either be validated or not based on validationSetting
   if (!globalUTFValidation) {
+    utf8KeysSet = new Set();
+
     for (const key of Object.keys(utf8ValidatedKeys)) {
       utf8KeysSet.add(key);
     }
@@ -202,8 +201,8 @@ function deserializeObject(
   if (buffer.length < 5) throw new BSONError('corrupt bson message < 5 bytes long');
 
   // Read the document size
-  const size =
-    buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
+  const size = NumberUtils.getInt32LE(buffer, index);
+  index += 4;
 
   // Ensure buffer is valid size
   if (size < 5 || size > buffer.length) throw new BSONError('corrupt bson message');
@@ -217,7 +216,6 @@ function deserializeObject(
   let isPossibleDBRef = isArray ? false : null;
 
   // While we have more left data left keep parsing
-  const dataview = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   while (!done) {
     // Read the type
     const elementType = buffer[index++];
@@ -240,7 +238,7 @@ function deserializeObject(
 
     // shouldValidateKey is true if the key should be validated, false otherwise
     let shouldValidateKey = true;
-    if (globalUTFValidation || utf8KeysSet.has(name)) {
+    if (globalUTFValidation || utf8KeysSet?.has(name)) {
       shouldValidateKey = validationSetting;
     } else {
       shouldValidateKey = !validationSetting;
@@ -254,11 +252,8 @@ function deserializeObject(
     index = i + 1;
 
     if (elementType === constants.BSON_DATA_STRING) {
-      const stringSize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const stringSize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
       if (
         stringSize <= 0 ||
         stringSize > buffer.length - index ||
@@ -269,37 +264,25 @@ function deserializeObject(
       value = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
       index = index + stringSize;
     } else if (elementType === constants.BSON_DATA_OID) {
-      const oid = ByteUtils.allocate(12);
-      oid.set(buffer.subarray(index, index + 12));
+      const oid = ByteUtils.allocateUnsafe(12);
+      for (let i = 0; i < 12; i++) oid[i] = buffer[index + i];
       value = new ObjectId(oid);
       index = index + 12;
     } else if (elementType === constants.BSON_DATA_INT && promoteValues === false) {
-      value = new Int32(
-        buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24)
-      );
+      value = new Int32(NumberUtils.getInt32LE(buffer, index));
+      index += 4;
     } else if (elementType === constants.BSON_DATA_INT) {
-      value =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
-    } else if (elementType === constants.BSON_DATA_NUMBER && promoteValues === false) {
-      value = new Double(dataview.getFloat64(index, true));
-      index = index + 8;
+      value = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
     } else if (elementType === constants.BSON_DATA_NUMBER) {
-      value = dataview.getFloat64(index, true);
-      index = index + 8;
+      value = NumberUtils.getFloat64LE(buffer, index);
+      index += 8;
+      if (promoteValues === false) value = new Double(value);
     } else if (elementType === constants.BSON_DATA_DATE) {
-      const lowBits =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
-      const highBits =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const lowBits = NumberUtils.getInt32LE(buffer, index);
+      const highBits = NumberUtils.getInt32LE(buffer, index + 4);
+      index += 8;
+
       value = new Date(new Long(lowBits, highBits).toNumber());
     } else if (elementType === constants.BSON_DATA_BOOLEAN) {
       if (buffer[index] !== 0 && buffer[index] !== 1)
@@ -307,11 +290,8 @@ function deserializeObject(
       value = buffer[index++] === 1;
     } else if (elementType === constants.BSON_DATA_OBJECT) {
       const _index = index;
-      const objectSize =
-        buffer[index] |
-        (buffer[index + 1] << 8) |
-        (buffer[index + 2] << 16) |
-        (buffer[index + 3] << 24);
+      const objectSize = NumberUtils.getInt32LE(buffer, index);
+
       if (objectSize <= 0 || objectSize > buffer.length - index)
         throw new BSONError('bad embedded document length in bson');
 
@@ -329,11 +309,7 @@ function deserializeObject(
       index = index + objectSize;
     } else if (elementType === constants.BSON_DATA_ARRAY) {
       const _index = index;
-      const objectSize =
-        buffer[index] |
-        (buffer[index + 1] << 8) |
-        (buffer[index + 2] << 16) |
-        (buffer[index + 3] << 24);
+      const objectSize = NumberUtils.getInt32LE(buffer, index);
       let arrayOptions: DeserializeOptions = options;
 
       // Stop index
@@ -357,46 +333,38 @@ function deserializeObject(
     } else if (elementType === constants.BSON_DATA_NULL) {
       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) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
-      const highBits =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
-      const long = new Long(lowBits, highBits);
       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()
-            : long;
+        value = NumberUtils.getBigInt64LE(buffer, index);
+        index += 8;
       } else {
-        value = long;
+        // Unpack the low and high bits
+        const lowBits = NumberUtils.getInt32LE(buffer, index);
+        const highBits = NumberUtils.getInt32LE(buffer, index + 4);
+        index += 8;
+
+        const long = new Long(lowBits, highBits);
+        // Promote the long if possible
+        if (promoteLongs && promoteValues === true) {
+          value =
+            long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
+              ? long.toNumber()
+              : long;
+        } else {
+          value = long;
+        }
       }
     } else if (elementType === constants.BSON_DATA_DECIMAL128) {
       // Buffer to contain the decimal bytes
-      const bytes = ByteUtils.allocate(16);
+      const bytes = ByteUtils.allocateUnsafe(16);
       // Copy the next 16 bytes into the bytes buffer
-      bytes.set(buffer.subarray(index, index + 16), 0);
+      for (let i = 0; i < 16; i++) bytes[i] = buffer[index + i];
       // Update index
       index = index + 16;
       // Assign the new Decimal128 value
       value = new Decimal128(bytes);
     } else if (elementType === constants.BSON_DATA_BINARY) {
-      let binarySize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      let binarySize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
       const totalBinarySize = binarySize;
       const subType = buffer[index++];
 
@@ -411,11 +379,8 @@ function deserializeObject(
       if (buffer['slice'] != null) {
         // If we have subtype 2 skip the 4 bytes for the size
         if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-          binarySize =
-            buffer[index++] |
-            (buffer[index++] << 8) |
-            (buffer[index++] << 16) |
-            (buffer[index++] << 24);
+          binarySize = NumberUtils.getInt32LE(buffer, index);
+          index += 4;
           if (binarySize < 0)
             throw new BSONError('Negative binary type element size found for subtype 0x02');
           if (binarySize > totalBinarySize - 4)
@@ -433,14 +398,10 @@ function deserializeObject(
           }
         }
       } else {
-        const _buffer = ByteUtils.allocate(binarySize);
         // If we have subtype 2 skip the 4 bytes for the size
         if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-          binarySize =
-            buffer[index++] |
-            (buffer[index++] << 8) |
-            (buffer[index++] << 16) |
-            (buffer[index++] << 24);
+          binarySize = NumberUtils.getInt32LE(buffer, index);
+          index += 4;
           if (binarySize < 0)
             throw new BSONError('Negative binary type element size found for subtype 0x02');
           if (binarySize > totalBinarySize - 4)
@@ -449,13 +410,12 @@ function deserializeObject(
             throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
         }
 
-        // Copy the data
-        for (i = 0; i < binarySize; i++) {
-          _buffer[i] = buffer[index + i];
-        }
-
         if (promoteBuffers && promoteValues) {
-          value = _buffer;
+          value = ByteUtils.allocateUnsafe(binarySize);
+          // Copy the data
+          for (i = 0; i < binarySize; i++) {
+            value[i] = buffer[index + i];
+          }
         } else {
           value = new Binary(buffer.slice(index, index + binarySize), subType);
           if (subType === constants.BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
@@ -539,11 +499,8 @@ function deserializeObject(
       // Set the object
       value = new BSONRegExp(source, regExpOptions);
     } else if (elementType === constants.BSON_DATA_SYMBOL) {
-      const stringSize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const stringSize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
       if (
         stringSize <= 0 ||
         stringSize > buffer.length - index ||
@@ -555,31 +512,18 @@ function deserializeObject(
       value = promoteValues ? symbol : new BSONSymbol(symbol);
       index = index + stringSize;
     } else if (elementType === constants.BSON_DATA_TIMESTAMP) {
-      // We intentionally **do not** use bit shifting here
-      // Bit shifting in javascript coerces numbers to **signed** int32s
-      // We need to keep i, and t unsigned
-      const i =
-        buffer[index++] +
-        buffer[index++] * (1 << 8) +
-        buffer[index++] * (1 << 16) +
-        buffer[index++] * (1 << 24);
-      const t =
-        buffer[index++] +
-        buffer[index++] * (1 << 8) +
-        buffer[index++] * (1 << 16) +
-        buffer[index++] * (1 << 24);
-
-      value = new Timestamp({ i, t });
+      value = new Timestamp({
+        i: NumberUtils.getUint32LE(buffer, index),
+        t: NumberUtils.getUint32LE(buffer, index + 4)
+      });
+      index += 8;
     } else if (elementType === constants.BSON_DATA_MIN_KEY) {
       value = new MinKey();
     } else if (elementType === constants.BSON_DATA_MAX_KEY) {
       value = new MaxKey();
     } else if (elementType === constants.BSON_DATA_CODE) {
-      const stringSize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const stringSize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
       if (
         stringSize <= 0 ||
         stringSize > buffer.length - index ||
@@ -599,11 +543,8 @@ function deserializeObject(
       // Update parse index position
       index = index + stringSize;
     } else if (elementType === constants.BSON_DATA_CODE_W_SCOPE) {
-      const totalSize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const totalSize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
 
       // Element cannot be shorter than totalSize + stringSize + documentSize + terminator
       if (totalSize < 4 + 4 + 4 + 1) {
@@ -611,11 +552,8 @@ function deserializeObject(
       }
 
       // Get the code string size
-      const stringSize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const stringSize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
       // Check if we have a valid string
       if (
         stringSize <= 0 ||
@@ -637,11 +575,7 @@ function deserializeObject(
       // Parse the element
       const _index = index;
       // Decode the size of the object document
-      const objectSize =
-        buffer[index] |
-        (buffer[index + 1] << 8) |
-        (buffer[index + 2] << 16) |
-        (buffer[index + 3] << 24);
+      const objectSize = NumberUtils.getInt32LE(buffer, index);
       // Decode the scope object
       const scopeObject = deserializeObject(buffer, _index, options, false);
       // Adjust the index
@@ -660,11 +594,8 @@ function deserializeObject(
       value = new Code(functionString, scopeObject);
     } else if (elementType === constants.BSON_DATA_DBPOINTER) {
       // Get the code string size
-      const stringSize =
-        buffer[index++] |
-        (buffer[index++] << 8) |
-        (buffer[index++] << 16) |
-        (buffer[index++] << 24);
+      const stringSize = NumberUtils.getInt32LE(buffer, index);
+      index += 4;
       // Check if we have a valid string
       if (
         stringSize <= 0 ||
@@ -683,8 +614,8 @@ function deserializeObject(
       index = index + stringSize;
 
       // Read the oid
-      const oidBuffer = ByteUtils.allocate(12);
-      oidBuffer.set(buffer.subarray(index, index + 12), 0);
+      const oidBuffer = ByteUtils.allocateUnsafe(12);
+      for (let i = 0; i < 12; i++) oidBuffer[i] = buffer[index + i];
       const oid = new ObjectId(oidBuffer);
 
       // Update the index

package/src/parser/on_demand/index.ts

@@ -0,0 +1,28 @@
+import { type BSONError, BSONOffsetError } from '../../error';
+import { type BSONElement, parseToElements } from './parse_to_elements';
+/**
+ * @experimental
+ * @public
+ *
+ * A new set of BSON APIs that are currently experimental and not intended for production use.
+ */
+export type OnDemand = {
+  BSONOffsetError: {
+    new (message: string, offset: number): BSONOffsetError;
+    isBSONError(value: unknown): value is BSONError;
+  };
+  parseToElements: (this: void, bytes: Uint8Array, startOffset?: number) => Iterable<BSONElement>;
+};
+
+/**
+ * @experimental
+ * @public
+ */
+const onDemand: OnDemand = Object.create(null);
+
+onDemand.parseToElements = parseToElements;
+onDemand.BSONOffsetError = BSONOffsetError;
+
+Object.freeze(onDemand);
+
+export { onDemand };

package/src/parser/on_demand/parse_to_elements.ts

@@ -0,0 +1,174 @@
+/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
+import { BSONOffsetError } from '../../error';
+
+/**
+ * @internal
+ *
+ * @remarks
+ * - This enum is const so the code we produce will inline the numbers
+ * - `minKey` is set to 255 so unsigned comparisons succeed
+ * - Modify with caution, double check the bundle contains literals
+ */
+const enum t {
+  double = 1,
+  string = 2,
+  object = 3,
+  array = 4,
+  binData = 5,
+  undefined = 6,
+  objectId = 7,
+  bool = 8,
+  date = 9,
+  null = 10,
+  regex = 11,
+  dbPointer = 12,
+  javascript = 13,
+  symbol = 14,
+  javascriptWithScope = 15,
+  int = 16,
+  timestamp = 17,
+  long = 18,
+  decimal = 19,
+  minKey = 255,
+  maxKey = 127
+}
+
+/**
+ * @public
+ * @experimental
+ */
+export type BSONElement = [
+  type: number,
+  nameOffset: number,
+  nameLength: number,
+  offset: number,
+  length: number
+];
+
+/** Parses a int32 little-endian at offset, throws if it is negative */
+function getSize(source: Uint8Array, offset: number): number {
+  if (source[offset + 3] > 127) {
+    throw new BSONOffsetError('BSON size cannot be negative', offset);
+  }
+  return (
+    source[offset] |
+    (source[offset + 1] << 8) |
+    (source[offset + 2] << 16) |
+    (source[offset + 3] << 24)
+  );
+}
+
+/**
+ * Searches for null terminator of a BSON element's value (Never the document null terminator)
+ * **Does not** bounds check since this should **ONLY** be used within parseToElements which has asserted that `bytes` ends with a `0x00`.
+ * So this will at most iterate to the document's terminator and error if that is the offset reached.
+ */
+function findNull(bytes: Uint8Array, offset: number): number {
+  let nullTerminatorOffset = offset;
+
+  for (; bytes[nullTerminatorOffset] !== 0x00; nullTerminatorOffset++);
+
+  if (nullTerminatorOffset === bytes.length - 1) {
+    // We reached the null terminator of the document, not a value's
+    throw new BSONOffsetError('Null terminator not found', offset);
+  }
+
+  return nullTerminatorOffset;
+}
+
+/**
+ * @public
+ * @experimental
+ */
+export function parseToElements(bytes: Uint8Array, startOffset = 0): Iterable<BSONElement> {
+  if (bytes.length < 5) {
+    throw new BSONOffsetError(
+      `Input must be at least 5 bytes, got ${bytes.length} bytes`,
+      startOffset
+    );
+  }
+
+  const documentSize = getSize(bytes, startOffset);
+
+  if (documentSize > bytes.length - startOffset) {
+    throw new BSONOffsetError(
+      `Parsed documentSize (${documentSize} bytes) does not match input length (${bytes.length} bytes)`,
+      startOffset
+    );
+  }
+
+  if (bytes[startOffset + documentSize - 1] !== 0x00) {
+    throw new BSONOffsetError('BSON documents must end in 0x00', startOffset + documentSize);
+  }
+
+  const elements: BSONElement[] = [];
+  let offset = startOffset + 4;
+
+  while (offset <= documentSize + startOffset) {
+    const type = bytes[offset];
+    offset += 1;
+
+    if (type === 0) {
+      if (offset - startOffset !== documentSize) {
+        throw new BSONOffsetError(`Invalid 0x00 type byte`, offset);
+      }
+      break;
+    }
+
+    const nameOffset = offset;
+    const nameLength = findNull(bytes, offset) - nameOffset;
+    offset += nameLength + 1;
+
+    let length: number;
+
+    if (type === t.double || type === t.long || type === t.date || type === t.timestamp) {
+      length = 8;
+    } else if (type === t.int) {
+      length = 4;
+    } else if (type === t.objectId) {
+      length = 12;
+    } else if (type === t.decimal) {
+      length = 16;
+    } else if (type === t.bool) {
+      length = 1;
+    } else if (type === t.null || type === t.undefined || type === t.maxKey || type === t.minKey) {
+      length = 0;
+    }
+    // Needs a size calculation
+    else if (type === t.regex) {
+      length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset;
+    } else if (type === t.object || type === t.array || type === t.javascriptWithScope) {
+      length = getSize(bytes, offset);
+    } else if (
+      type === t.string ||
+      type === t.binData ||
+      type === t.dbPointer ||
+      type === t.javascript ||
+      type === t.symbol
+    ) {
+      length = getSize(bytes, offset) + 4;
+      if (type === t.binData) {
+        // binary subtype
+        length += 1;
+      }
+      if (type === t.dbPointer) {
+        // dbPointer's objectId
+        length += 12;
+      }
+    } else {
+      throw new BSONOffsetError(
+        `Invalid 0x${type.toString(16).padStart(2, '0')} type byte`,
+        offset
+      );
+    }
+
+    if (length > documentSize) {
+      throw new BSONOffsetError('value reports length larger than document', offset);
+    }
+
+    elements.push([type, nameOffset, nameLength, offset, length]);
+    offset += length;
+  }
+
+  return elements;
+}