bson 7.2.0 → 7.3.1

package/src/parser/serializer.ts

@@ -1,8 +1,8 @@
 import { Binary, validateBinaryVector } from '../binary';
 import type { BSONSymbol, DBRef, Document, MaxKey } from '../bson';
+import { bsonType } from '../bson_value';
 import type { Code } from '../code';
 import * as constants from '../constants';
-import type { DBRefLike } from '../db_ref';
 import type { Decimal128 } from '../decimal128';
 import type { Double } from '../double';
 import { BSONError, BSONVersionError } from '../error';
@@ -45,12 +45,6 @@ export interface SerializeOptions {
 const regexp = /\x00/; // eslint-disable-line no-control-regex
 const ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);
 
-/*
- * isArray indicates if we are writing to a BSON array (type 0x04)
- * which forces the "key" which really an array index as a string to be written as ascii
- * This will catch any errors in index as a string generation
- */
-
 function serializeString(buffer: Uint8Array, key: string, value: string, index: number) {
   // Encode String type
   buffer[index++] = constants.BSON_DATA_STRING;
@@ -213,7 +207,7 @@ function serializeMinMax(buffer: Uint8Array, key: string, value: MinKey | MaxKey
   // Write the type of either min or max key
   if (value === null) {
     buffer[index++] = constants.BSON_DATA_NULL;
-  } else if (value._bsontype === 'MinKey') {
+  } else if (value[bsonType] === 'MinKey') {
     buffer[index++] = constants.BSON_DATA_MIN_KEY;
   } else {
     buffer[index++] = constants.BSON_DATA_MAX_KEY;
@@ -268,46 +262,6 @@ function serializeBuffer(buffer: Uint8Array, key: string, value: Uint8Array, ind
   return index;
 }
 
-function serializeObject(
-  buffer: Uint8Array,
-  key: string,
-  value: Document,
-  index: number,
-  checkKeys: boolean,
-  depth: number,
-  serializeFunctions: boolean,
-  ignoreUndefined: boolean,
-  path: Set<Document>
-) {
-  if (path.has(value)) {
-    throw new BSONError('Cannot convert circular structure to BSON');
-  }
-
-  path.add(value);
-
-  // Write the type
-  buffer[index++] = Array.isArray(value) ? constants.BSON_DATA_ARRAY : constants.BSON_DATA_OBJECT;
-  // Number of written bytes
-  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
-  // Encode the name
-  index = index + numberOfWrittenBytes;
-  buffer[index++] = 0;
-  const endIndex = serializeInto(
-    buffer,
-    value,
-    checkKeys,
-    index,
-    depth + 1,
-    serializeFunctions,
-    ignoreUndefined,
-    path
-  );
-
-  path.delete(value);
-
-  return endIndex;
-}
-
 function serializeDecimal128(buffer: Uint8Array, key: string, value: Decimal128, index: number) {
   buffer[index++] = constants.BSON_DATA_DECIMAL128;
   // Number of written bytes
@@ -323,7 +277,7 @@ function serializeDecimal128(buffer: Uint8Array, key: string, value: Decimal128,
 function serializeLong(buffer: Uint8Array, key: string, value: Long, index: number) {
   // Write the type
   buffer[index++] =
-    value._bsontype === 'Long' ? constants.BSON_DATA_LONG : constants.BSON_DATA_TIMESTAMP;
+    value[bsonType] === 'Long' ? constants.BSON_DATA_LONG : constants.BSON_DATA_TIMESTAMP;
   // Number of written bytes
   const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
   // Encode the name
@@ -391,85 +345,6 @@ function serializeFunction(buffer: Uint8Array, key: string, value: Function, ind
   return index;
 }
 
-function serializeCode(
-  buffer: Uint8Array,
-  key: string,
-  value: Code,
-  index: number,
-  checkKeys = false,
-  depth = 0,
-  serializeFunctions = false,
-  ignoreUndefined = true,
-  path: Set<Document>
-) {
-  if (value.scope && typeof value.scope === 'object') {
-    // Write the type
-    buffer[index++] = constants.BSON_DATA_CODE_W_SCOPE;
-    // Number of written bytes
-    const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
-    // Encode the name
-    index = index + numberOfWrittenBytes;
-    buffer[index++] = 0;
-
-    // Starting index
-    let startIndex = index;
-
-    // Serialize the function
-    // Get the function string
-    const functionString = value.code;
-    // Index adjustment
-    index = index + 4;
-    // Write string into buffer
-    const codeSize = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
-    // Write the size of the string to buffer
-    NumberUtils.setInt32LE(buffer, index, codeSize);
-    // Write end 0
-    buffer[index + 4 + codeSize - 1] = 0;
-    // Write the
-    index = index + codeSize + 4;
-
-    // Serialize the scope value
-    const endIndex = serializeInto(
-      buffer,
-      value.scope,
-      checkKeys,
-      index,
-      depth + 1,
-      serializeFunctions,
-      ignoreUndefined,
-      path
-    );
-    index = endIndex - 1;
-
-    // Writ the total
-    const totalSize = endIndex - startIndex;
-
-    // Write the total size of the object
-    startIndex += NumberUtils.setInt32LE(buffer, startIndex, totalSize);
-    // Write trailing zero
-    buffer[index++] = 0;
-  } else {
-    buffer[index++] = constants.BSON_DATA_CODE;
-    // Number of written bytes
-    const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
-    // Encode the name
-    index = index + numberOfWrittenBytes;
-    buffer[index++] = 0;
-    // Function string
-    const functionString = value.code.toString();
-    // Write the string
-    const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
-    // Write the size of the string to buffer
-    NumberUtils.setInt32LE(buffer, index, size);
-    // Update index
-    index = index + 4 + size - 1;
-    // Write zero
-    buffer[index++] = 0;
-  }
-
-  return index;
-}
-
 function serializeBinary(buffer: Uint8Array, key: string, value: Binary, index: number) {
   // Write the type
   buffer[index++] = constants.BSON_DATA_BINARY;
@@ -528,52 +403,98 @@ function serializeSymbol(buffer: Uint8Array, key: string, value: BSONSymbol, ind
   return index;
 }
 
-function serializeDBRef(
-  buffer: Uint8Array,
-  key: string,
-  value: DBRef,
-  index: number,
-  depth: number,
-  serializeFunctions: boolean,
-  path: Set<Document>
-) {
-  // Write the type
-  buffer[index++] = constants.BSON_DATA_OBJECT;
-  // Number of written bytes
-  const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
-
-  // Encode the name
-  index = index + numberOfWrittenBytes;
-  buffer[index++] = 0;
-
-  let startIndex = index;
-  let output: DBRefLike = {
-    $ref: value.collection || value.namespace, // "namespace" was what library 1.x called "collection"
-    $id: value.oid
-  };
+interface SerializationFrame {
+  /** Original object passed to this frame — used for cycle-detection (path.delete). */
+  sourceObject: Document;
+  /** True when serializing a BSON array; affects key format and type byte. */
+  isArray: boolean;
+  /** Buffer offset where this object's 4-byte size field will be written. */
+  objectSizeIndex: number;
+  /** Buffer offset for code-with-scope wrapper size, or null if not applicable. */
+  codeSizeIndex: number | null;
+  /**
+   * Object being iterated. For plain objects this may be the toBSON() result of
+   * sourceObject; for arrays and Maps it equals sourceObject.
+   */
+  iterTarget: Document;
+  /**
+   * Pre-computed Object.keys() of iterTarget for plain objects.
+   * Null for arrays (use keyIndex as numeric index) and Maps (use mapIterator).
+   */
+  keys: string[] | null;
+  /** Next index into keys[] for plain objects, or next array index for arrays. */
+  keyIndex: number;
+  /** Active iterator for Map objects; null for arrays and plain objects. */
+  mapIterator: IterableIterator<[unknown, unknown]> | null;
+  /** The enclosing frame, or null at the root. The stack is a linked list via this field. */
+  prev: SerializationFrame | null;
+  /** Whether to validate keys for this frame's document (may differ from caller, e.g. DBRef uses false). */
+  checkKeys: boolean;
+  /** Whether undefined values are skipped (may differ from caller, e.g. DBRef uses true). */
+  ignoreUndefined: boolean;
+}
 
-  if (value.db != null) {
-    output.$db = value.db;
+function makeFrame(
+  sourceObject: Document,
+  objectSizeIndex: number,
+  codeSizeIndex: number | null,
+  prev: SerializationFrame | null,
+  checkKeys: boolean,
+  ignoreUndefined: boolean
+): SerializationFrame {
+  if (Array.isArray(sourceObject)) {
+    return {
+      sourceObject,
+      isArray: true,
+      objectSizeIndex,
+      codeSizeIndex,
+      iterTarget: sourceObject,
+      keys: null,
+      keyIndex: 0,
+      mapIterator: null,
+      prev,
+      checkKeys,
+      ignoreUndefined
+    };
   }
-
-  output = Object.assign(output, value.fields);
-  const endIndex = serializeInto(
-    buffer,
-    output,
-    false,
-    index,
-    depth + 1,
-    serializeFunctions,
-    true,
-    path
-  );
-
-  // Calculate object size
-  const size = endIndex - startIndex;
-  // Write the size
-  startIndex += NumberUtils.setInt32LE(buffer, index, size);
-  // Set index
-  return endIndex;
+  if (sourceObject instanceof Map || isMap(sourceObject)) {
+    return {
+      sourceObject,
+      isArray: false,
+      objectSizeIndex,
+      codeSizeIndex,
+      iterTarget: sourceObject,
+      keys: null,
+      keyIndex: 0,
+      mapIterator: (sourceObject as Map<unknown, unknown>).entries(),
+      prev,
+      checkKeys,
+      ignoreUndefined
+    };
+  }
+  // Plain object: call toBSON() if defined to obtain the object to iterate.
+  let target: Document = sourceObject;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (typeof (target as any)?.toBSON === 'function') {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    target = (target as any).toBSON() as Document;
+    if (target != null && typeof target !== 'object') {
+      throw new BSONError('toBSON function did not return an object');
+    }
+  }
+  return {
+    sourceObject,
+    isArray: false,
+    objectSizeIndex,
+    codeSizeIndex,
+    iterTarget: target,
+    keys: Object.keys(target as object),
+    keyIndex: 0,
+    mapIterator: null,
+    prev,
+    checkKeys,
+    ignoreUndefined
+  };
 }
 
 export function serializeInto(
@@ -581,7 +502,6 @@ export function serializeInto(
   object: Document,
   checkKeys: boolean,
   startingIndex: number,
-  depth: number,
   serializeFunctions: boolean,
   ignoreUndefined: boolean,
   path: Set<Document> | null
@@ -619,336 +539,210 @@ export function serializeInto(
     path = new Set();
   }
 
-  // Push the object to the path
   path.add(object);
 
-  // Start place to serialize into
+  let currentFrame: SerializationFrame | null = makeFrame(
+    object,
+    startingIndex,
+    null,
+    null,
+    checkKeys,
+    ignoreUndefined
+  );
   let index = startingIndex + 4;
 
-  // Special case isArray
-  if (Array.isArray(object)) {
-    // Get object keys
-    for (let i = 0; i < object.length; i++) {
-      const key = `${i}`;
-      let value = object[i];
-
-      // Is there an override value
-      if (typeof value?.toBSON === 'function') {
-        value = value.toBSON();
-      }
-
-      // Check the type of the value
-      const type = typeof value;
-
-      if (value === undefined) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (value === null) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (type === 'string') {
-        index = serializeString(buffer, key, value, index);
-      } else if (type === 'number') {
-        index = serializeNumber(buffer, key, value, index);
-      } else if (type === 'bigint') {
-        index = serializeBigInt(buffer, key, value, index);
-      } else if (type === 'boolean') {
-        index = serializeBoolean(buffer, key, value, index);
-      } else if (type === 'object' && value._bsontype == null) {
-        if (value instanceof Date || isDate(value)) {
-          index = serializeDate(buffer, key, value, index);
-        } else if (value instanceof Uint8Array || isUint8Array(value)) {
-          index = serializeBuffer(buffer, key, value, index);
-        } else if (value instanceof RegExp || isRegExp(value)) {
-          index = serializeRegExp(buffer, key, value, index);
-        } else {
-          index = serializeObject(
-            buffer,
-            key,
-            value,
-            index,
-            checkKeys,
-            depth,
-            serializeFunctions,
-            ignoreUndefined,
-            path
-          );
+  while (currentFrame !== null) {
+    const frame: SerializationFrame = currentFrame;
+
+    // Advance to the next key-value pair, or finalize the frame if exhausted.
+    let key: string;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let value: any;
+    if (frame.mapIterator !== null) {
+      const next = frame.mapIterator.next();
+      if (next.done) {
+        buffer[index++] = 0x00;
+        NumberUtils.setInt32LE(buffer, frame.objectSizeIndex, index - frame.objectSizeIndex);
+        if (frame.codeSizeIndex !== null) {
+          NumberUtils.setInt32LE(buffer, frame.codeSizeIndex, index - frame.codeSizeIndex);
         }
-      } else if (type === 'object') {
-        if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
-          throw new BSONVersionError();
-        } else if (value._bsontype === 'ObjectId') {
-          index = serializeObjectId(buffer, key, value, index);
-        } else if (value._bsontype === 'Decimal128') {
-          index = serializeDecimal128(buffer, key, value, index);
-        } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-          index = serializeLong(buffer, key, value, index);
-        } else if (value._bsontype === 'Double') {
-          index = serializeDouble(buffer, key, value, index);
-        } else if (value._bsontype === 'Code') {
-          index = serializeCode(
-            buffer,
-            key,
-            value,
-            index,
-            checkKeys,
-            depth,
-            serializeFunctions,
-            ignoreUndefined,
-            path
-          );
-        } else if (value._bsontype === 'Binary') {
-          index = serializeBinary(buffer, key, value, index);
-        } 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);
-        } else if (value._bsontype === 'BSONRegExp') {
-          index = serializeBSONRegExp(buffer, key, value, index);
-        } else if (value._bsontype === 'Int32') {
-          index = serializeInt32(buffer, key, value, index);
-        } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-          index = serializeMinMax(buffer, key, value, index);
-        } else if (typeof value._bsontype !== 'undefined') {
-          throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-        }
-      } else if (type === 'function' && serializeFunctions) {
-        index = serializeFunction(buffer, key, value, index);
+        path.delete(frame.sourceObject);
+        currentFrame = frame.prev;
+        continue;
       }
-    }
-  } else if (object instanceof Map || isMap(object)) {
-    const iterator = object.entries();
-    let done = false;
-
-    while (!done) {
-      // Unpack the next entry
-      const entry = iterator.next();
-      done = !!entry.done;
-      // Are we done, then skip and terminate
-      if (done) continue;
-
-      // Get the entry values
-      const key = entry.value ? entry.value[0] : undefined;
-      let value = entry.value ? entry.value[1] : undefined;
-
-      if (typeof value?.toBSON === 'function') {
-        value = value.toBSON();
-      }
-
-      // Check the type of the value
-      const type = typeof value;
-
-      // Check the key and throw error if it's illegal
-      if (typeof key === 'string' && !ignoreKeys.has(key)) {
-        if (key.match(regexp) != null) {
-          // The BSON spec doesn't allow keys with null bytes because keys are
-          // null-terminated.
-          throw new BSONError('key ' + key + ' must not contain null bytes');
-        }
-
-        if (checkKeys) {
-          if ('$' === key[0]) {
-            throw new BSONError('key ' + key + " must not start with '$'");
-          } else if (key.includes('.')) {
-            throw new BSONError('key ' + key + " must not contain '.'");
-          }
+      key = next.value[0] as string;
+      value = next.value[1];
+    } else if (frame.keys !== null) {
+      if (frame.keyIndex >= frame.keys.length) {
+        buffer[index++] = 0x00;
+        NumberUtils.setInt32LE(buffer, frame.objectSizeIndex, index - frame.objectSizeIndex);
+        if (frame.codeSizeIndex !== null) {
+          NumberUtils.setInt32LE(buffer, frame.codeSizeIndex, index - frame.codeSizeIndex);
         }
+        path.delete(frame.sourceObject);
+        currentFrame = frame.prev;
+        continue;
       }
-
-      if (value === undefined) {
-        if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);
-      } else if (value === null) {
-        index = serializeNull(buffer, key, value, index);
-      } else if (type === 'string') {
-        index = serializeString(buffer, key, value, index);
-      } else if (type === 'number') {
-        index = serializeNumber(buffer, key, value, index);
-      } else if (type === 'bigint') {
-        index = serializeBigInt(buffer, key, value, index);
-      } else if (type === 'boolean') {
-        index = serializeBoolean(buffer, key, value, index);
-      } else if (type === 'object' && value._bsontype == null) {
-        if (value instanceof Date || isDate(value)) {
-          index = serializeDate(buffer, key, value, index);
-        } else if (value instanceof Uint8Array || isUint8Array(value)) {
-          index = serializeBuffer(buffer, key, value, index);
-        } else if (value instanceof RegExp || isRegExp(value)) {
-          index = serializeRegExp(buffer, key, value, index);
-        } else {
-          index = serializeObject(
-            buffer,
-            key,
-            value,
-            index,
-            checkKeys,
-            depth,
-            serializeFunctions,
-            ignoreUndefined,
-            path
-          );
+      key = frame.keys[frame.keyIndex++];
+      value = (frame.iterTarget as Record<string, unknown>)[key];
+    } else {
+      // Array: use keyIndex as the numeric index.
+      const arr = frame.iterTarget as unknown[];
+      if (frame.keyIndex >= arr.length) {
+        buffer[index++] = 0x00;
+        NumberUtils.setInt32LE(buffer, frame.objectSizeIndex, index - frame.objectSizeIndex);
+        if (frame.codeSizeIndex !== null) {
+          NumberUtils.setInt32LE(buffer, frame.codeSizeIndex, index - frame.codeSizeIndex);
         }
-      } else if (type === 'object') {
-        if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
-          throw new BSONVersionError();
-        } else if (value._bsontype === 'ObjectId') {
-          index = serializeObjectId(buffer, key, value, index);
-        } else if (value._bsontype === 'Decimal128') {
-          index = serializeDecimal128(buffer, key, value, index);
-        } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-          index = serializeLong(buffer, key, value, index);
-        } else if (value._bsontype === 'Double') {
-          index = serializeDouble(buffer, key, value, index);
-        } else if (value._bsontype === 'Code') {
-          index = serializeCode(
-            buffer,
-            key,
-            value,
-            index,
-            checkKeys,
-            depth,
-            serializeFunctions,
-            ignoreUndefined,
-            path
-          );
-        } else if (value._bsontype === 'Binary') {
-          index = serializeBinary(buffer, key, value, index);
-        } 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);
-        } else if (value._bsontype === 'BSONRegExp') {
-          index = serializeBSONRegExp(buffer, key, value, index);
-        } else if (value._bsontype === 'Int32') {
-          index = serializeInt32(buffer, key, value, index);
-        } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-          index = serializeMinMax(buffer, key, value, index);
-        } else if (typeof value._bsontype !== 'undefined') {
-          throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-        }
-      } else if (type === 'function' && serializeFunctions) {
-        index = serializeFunction(buffer, key, value, index);
+        path.delete(frame.sourceObject);
+        currentFrame = frame.prev;
+        continue;
       }
+      const i = frame.keyIndex++;
+      key = String(i);
+      value = arr[i];
     }
-  } else {
-    if (typeof object?.toBSON === 'function') {
-      // Provided a custom serialization method
-      object = object.toBSON();
-      if (object != null && typeof object !== 'object') {
-        throw new BSONError('toBSON function did not return an object');
-      }
+
+    if (typeof value?.toBSON === 'function') {
+      value = value.toBSON();
     }
 
-    // Iterate over all the keys
-    for (const key of Object.keys(object)) {
-      let value = object[key];
-      // Is there an override value
-      if (typeof value?.toBSON === 'function') {
-        value = value.toBSON();
+    if (!frame.isArray && typeof key === 'string' && !(key[0] === '$' && ignoreKeys.has(key))) {
+      if (regexp.test(key)) {
+        throw new BSONError('key ' + key + ' must not contain null bytes');
       }
-
-      // Check the type of the value
-      const type = typeof value;
-
-      // Check the key and throw error if it's illegal
-      if (typeof key === 'string' && !ignoreKeys.has(key)) {
-        if (key.match(regexp) != null) {
-          // The BSON spec doesn't allow keys with null bytes because keys are
-          // null-terminated.
-          throw new BSONError('key ' + key + ' must not contain null bytes');
-        }
-
-        if (checkKeys) {
-          if ('$' === key[0]) {
-            throw new BSONError('key ' + key + " must not start with '$'");
-          } else if (key.includes('.')) {
-            throw new BSONError('key ' + key + " must not contain '.'");
-          }
+      if (frame.checkKeys) {
+        if ('$' === key[0]) {
+          throw new BSONError('key ' + key + " must not start with '$'");
+        } else if (key.includes('.')) {
+          throw new BSONError('key ' + key + " must not contain '.'");
         }
       }
+    }
+
+    const type = typeof value;
 
-      if (value === undefined) {
-        if (ignoreUndefined === false) index = serializeNull(buffer, key, value, index);
-      } else if (value === null) {
+    if (value === undefined) {
+      if (frame.isArray || frame.ignoreUndefined === false) {
         index = serializeNull(buffer, key, value, index);
-      } else if (type === 'string') {
-        index = serializeString(buffer, key, value, index);
-      } else if (type === 'number') {
-        index = serializeNumber(buffer, key, value, index);
-      } else if (type === 'bigint') {
-        index = serializeBigInt(buffer, key, value, index);
-      } else if (type === 'boolean') {
-        index = serializeBoolean(buffer, key, value, index);
-      } else if (type === 'object' && value._bsontype == null) {
-        if (value instanceof Date || isDate(value)) {
-          index = serializeDate(buffer, key, value, index);
-        } else if (value instanceof Uint8Array || isUint8Array(value)) {
-          index = serializeBuffer(buffer, key, value, index);
-        } else if (value instanceof RegExp || isRegExp(value)) {
-          index = serializeRegExp(buffer, key, value, index);
-        } else {
-          index = serializeObject(
-            buffer,
-            key,
-            value,
-            index,
-            checkKeys,
-            depth,
-            serializeFunctions,
-            ignoreUndefined,
-            path
-          );
+      }
+    } else if (value === null) {
+      index = serializeNull(buffer, key, value, index);
+    } else if (type === 'string') {
+      index = serializeString(buffer, key, value, index);
+    } else if (type === 'number') {
+      index = serializeNumber(buffer, key, value, index);
+    } else if (type === 'bigint') {
+      index = serializeBigInt(buffer, key, value, index);
+    } else if (type === 'boolean') {
+      index = serializeBoolean(buffer, key, value, index);
+    } else if (type === 'object' && value._bsontype == null) {
+      if (value instanceof Date || isDate(value)) {
+        index = serializeDate(buffer, key, value, index);
+      } else if (value instanceof Uint8Array || isUint8Array(value)) {
+        index = serializeBuffer(buffer, key, value, index);
+      } else if (value instanceof RegExp || isRegExp(value)) {
+        index = serializeRegExp(buffer, key, value, index);
+      } else {
+        if (path.has(value)) {
+          throw new BSONError('Cannot convert circular structure to BSON');
         }
-      } else if (type === 'object') {
-        if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
-          throw new BSONVersionError();
-        } else if (value._bsontype === 'ObjectId') {
-          index = serializeObjectId(buffer, key, value, index);
-        } else if (value._bsontype === 'Decimal128') {
-          index = serializeDecimal128(buffer, key, value, index);
-        } else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-          index = serializeLong(buffer, key, value, index);
-        } else if (value._bsontype === 'Double') {
-          index = serializeDouble(buffer, key, value, index);
-        } else if (value._bsontype === 'Code') {
-          index = serializeCode(
-            buffer,
-            key,
-            value,
+        const nestedIsArray = Array.isArray(value);
+        buffer[index++] = nestedIsArray ? constants.BSON_DATA_ARRAY : constants.BSON_DATA_OBJECT;
+        index += ByteUtils.encodeUTF8Into(buffer, key, index);
+        buffer[index++] = 0x00;
+        const nestedStartIndex = index;
+        path.add(value);
+        currentFrame = makeFrame(
+          value,
+          nestedStartIndex,
+          null,
+          frame,
+          frame.checkKeys,
+          frame.ignoreUndefined
+        );
+        index += 4;
+      }
+    } else if (type === 'object') {
+      if (value[constants.BSON_VERSION_SYMBOL] !== constants.BSON_MAJOR_VERSION) {
+        throw new BSONVersionError();
+      }
+      const tag = value[bsonType];
+      if (tag === 'ObjectId') {
+        index = serializeObjectId(buffer, key, value, index);
+      } else if (tag === 'Decimal128') {
+        index = serializeDecimal128(buffer, key, value, index);
+      } else if (tag === 'Long' || tag === 'Timestamp') {
+        index = serializeLong(buffer, key, value, index);
+      } else if (tag === 'Double') {
+        index = serializeDouble(buffer, key, value, index);
+      } else if (tag === 'Code') {
+        const codeValue = value as Code;
+        if (codeValue.scope && typeof codeValue.scope === 'object') {
+          buffer[index++] = constants.BSON_DATA_CODE_W_SCOPE;
+          index += ByteUtils.encodeUTF8Into(buffer, key, index);
+          buffer[index++] = 0x00;
+          const codeTotalSizeIndex = index;
+          index += 4;
+          const functionString = codeValue.code;
+          const codeSize = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
+          NumberUtils.setInt32LE(buffer, index, codeSize);
+          buffer[index + 4 + codeSize - 1] = 0;
+          index = index + codeSize + 4;
+          const scope = codeValue.scope;
+          if (path.has(scope)) {
+            throw new BSONError('Cannot convert circular structure to BSON');
+          }
+          path.add(scope);
+          currentFrame = makeFrame(
+            scope,
             index,
-            checkKeys,
-            depth,
-            serializeFunctions,
-            ignoreUndefined,
-            path
+            codeTotalSizeIndex,
+            frame,
+            frame.checkKeys,
+            frame.ignoreUndefined
           );
-        } else if (value._bsontype === 'Binary') {
-          index = serializeBinary(buffer, key, value, index);
-        } 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);
-        } else if (value._bsontype === 'BSONRegExp') {
-          index = serializeBSONRegExp(buffer, key, value, index);
-        } else if (value._bsontype === 'Int32') {
-          index = serializeInt32(buffer, key, value, index);
-        } else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-          index = serializeMinMax(buffer, key, value, index);
-        } else if (typeof value._bsontype !== 'undefined') {
-          throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+          index += 4;
+        } else {
+          buffer[index++] = constants.BSON_DATA_CODE;
+          index += ByteUtils.encodeUTF8Into(buffer, key, index);
+          buffer[index++] = 0x00;
+          const functionString = codeValue.code.toString();
+          const size = ByteUtils.encodeUTF8Into(buffer, functionString, index + 4) + 1;
+          NumberUtils.setInt32LE(buffer, index, size);
+          index = index + 4 + size - 1;
+          buffer[index++] = 0;
         }
-      } else if (type === 'function' && serializeFunctions) {
-        index = serializeFunction(buffer, key, value, index);
+      } else if (tag === 'Binary') {
+        index = serializeBinary(buffer, key, value, index);
+      } else if (tag === 'BSONSymbol') {
+        index = serializeSymbol(buffer, key, value, index);
+      } else if (tag === 'DBRef') {
+        const dbref = value as DBRef;
+        const orderedValues: Document = Object.assign(
+          { $ref: dbref.collection, $id: dbref.oid },
+          dbref.db != null ? { $db: dbref.db } : null,
+          dbref.fields
+        );
+        buffer[index++] = constants.BSON_DATA_OBJECT;
+        index += ByteUtils.encodeUTF8Into(buffer, key, index);
+        buffer[index++] = 0x00;
+        path.add(orderedValues);
+        currentFrame = makeFrame(orderedValues, index, null, frame, false, true);
+        index += 4;
+      } else if (tag === 'BSONRegExp') {
+        index = serializeBSONRegExp(buffer, key, value, index);
+      } else if (tag === 'Int32') {
+        index = serializeInt32(buffer, key, value, index);
+      } else if (tag === 'MinKey' || tag === 'MaxKey') {
+        index = serializeMinMax(buffer, key, value, index);
+      } else if (typeof value._bsontype !== 'undefined') {
+        throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
       }
+    } else if (type === 'function' && serializeFunctions) {
+      index = serializeFunction(buffer, key, value, index);
     }
   }
 
-  // Remove the path
-  path.delete(object);
-
-  // Final padding byte for object
-  buffer[index++] = 0x00;
-
-  // Final size
-  const size = index - startingIndex;
-  // Write the size of the object
-  startingIndex += NumberUtils.setInt32LE(buffer, startingIndex, size);
   return index;
 }