put bsonOptions property on parents

Author: HanaPearlman

src/bson.ts

@@ -1,3 +1,4 @@
+import type { OperationParent } from './operations/command';
 // import type * as _BSON from 'bson';
 // let BSON: typeof _BSON = require('bson');
 // try {
@@ -71,30 +72,23 @@ export function pluckBSONSerializeOptions(options: BSONSerializeOptions): BSONSe
 }
 
 /**
- * Merge the given BSONSerializeOptions, preferring options over parentOptions, and optionally
+ * Merge the given BSONSerializeOptions, preferring options over the parent's options, and
  * substituting defaults for values not set.
  *
  * @internal
- *
- * @param options - The primary options to use
- * @param parentOptions - The secondary options to use
- * @param includeDefaultOptions - Whether to include default options for any values not set
  */
-export function inheritBSONOptions(
+export function resolveBSONOptions(
   options?: BSONSerializeOptions,
-  parentOptions?: BSONSerializeOptions,
-  includeDefaultOptions?: boolean
+  parent?: OperationParent
 ): BSONSerializeOptions {
-  const defaults = {
-    raw: false,
-    promoteLongs: true,
-    promoteValues: true,
-    promoteBuffers: false,
-    ignoreUndefined: false,
-    serializeFunctions: false,
-    fieldsAsRaw: {}
+  const parentOptions = parent?.bsonOptions;
+  return {
+    raw: options?.raw ?? parentOptions?.raw ?? false,
+    promoteLongs: options?.promoteLongs ?? parentOptions?.promoteLongs ?? true,
+    promoteValues: options?.promoteValues ?? parentOptions?.promoteValues ?? true,
+    promoteBuffers: options?.promoteBuffers ?? parentOptions?.promoteBuffers ?? false,
+    ignoreUndefined: options?.ignoreUndefined ?? parentOptions?.ignoreUndefined ?? false,
+    serializeFunctions: options?.serializeFunctions ?? parentOptions?.serializeFunctions ?? false,
+    fieldsAsRaw: options?.fieldsAsRaw ?? parentOptions?.fieldsAsRaw ?? {}
   };
-
-  const base = includeDefaultOptions ? defaults : {};
-  return pluckBSONSerializeOptions({ ...base, ...parentOptions, ...options });
 }

src/collection.ts

@@ -8,7 +8,7 @@ import {
   MongoDBNamespace,
   Callback
 } from './utils';
-import { ObjectId, Document, BSONSerializeOptions, inheritBSONOptions } from './bson';
+import { ObjectId, Document, BSONSerializeOptions, resolveBSONOptions } from './bson';
 import { MongoError } from './error';
 import { UnorderedBulkOperation } from './bulk/unordered';
 import { OrderedBulkOperation } from './bulk/ordered';
@@ -126,6 +126,7 @@ export interface CollectionPrivate {
   options: any;
   namespace: MongoDBNamespace;
   readPreference?: ReadPreference;
+  bsonOptions: BSONSerializeOptions;
   slaveOk?: boolean;
   collectionHint?: Hint;
   readConcern?: ReadConcern;
@@ -182,13 +183,11 @@ export class Collection implements OperationParent {
         }
       },
       readPreference: ReadPreference.fromOptions(options),
+      bsonOptions: resolveBSONOptions(options, db),
       readConcern: ReadConcern.fromOptions(options),
       writeConcern: WriteConcern.fromOptions(options),
       slaveOk: options == null || options.slaveOk == null ? db.slaveOk : options.slaveOk
     };
-
-    // Modify internal state with inherited BSON options
-    this.s.options = { ...this.s.options, ...inheritBSONOptions(options, db.s.options, false) };
   }
 
   /**
@@ -236,6 +235,10 @@ export class Collection implements OperationParent {
     return this.s.readPreference;
   }
 
+  get bsonOptions(): BSONSerializeOptions {
+    return this.s.bsonOptions;
+  }
+
   /**
    * The current writeConcern of the collection. If not explicitly defined for
    * this collection, will be inherited from the parent DB
@@ -1284,7 +1287,7 @@ export class Collection implements OperationParent {
     options = options || {};
     // Give function's options precedence over session options.
     if (options.ignoreUndefined == null) {
-      options.ignoreUndefined = this.s.options.ignoreUndefined;
+      options.ignoreUndefined = this.bsonOptions.ignoreUndefined;
     }
 
     return new UnorderedBulkOperation(this, options);
@@ -1295,7 +1298,7 @@ export class Collection implements OperationParent {
     options = options || {};
     // Give function's options precedence over session's options.
     if (options.ignoreUndefined == null) {
-      options.ignoreUndefined = this.s.options.ignoreUndefined;
+      options.ignoreUndefined = this.bsonOptions.ignoreUndefined;
     }
 
     return new OrderedBulkOperation(this, options);

src/db.ts

@@ -2,7 +2,7 @@ import { deprecate } from 'util';
 import { emitDeprecatedOptionWarning, Callback } from './utils';
 import { loadAdmin } from './dynamic_loaders';
 import { AggregationCursor, CommandCursor } from './cursor';
-import { ObjectId, Code, Document, BSONSerializeOptions } from './bson';
+import { ObjectId, Code, Document, BSONSerializeOptions, resolveBSONOptions } from './bson';
 import { ReadPreference, ReadPreferenceLike } from './read_preference';
 import { MongoError } from './error';
 import { Collection, CollectionOptions } from './collection';
@@ -94,6 +94,7 @@ export interface DbPrivate {
   readPreference?: ReadPreference;
   pkFactory: PkFactory;
   readConcern?: ReadConcern;
+  bsonOptions: BSONSerializeOptions;
   writeConcern?: WriteConcern;
   namespace: MongoDBNamespace;
 }
@@ -171,6 +172,8 @@ export class Db implements OperationParent {
       logger: new Logger('Db', options),
       // Unpack read preference
       readPreference: ReadPreference.fromOptions(options),
+      // Merge bson options TODO: include client bson options, after NODE-2850
+      bsonOptions: resolveBSONOptions(options),
       // Set up the primary key factory or fallback to ObjectId
       pkFactory: options?.pkFactory ?? {
         createPk() {
@@ -218,6 +221,10 @@ export class Db implements OperationParent {
     return this.s.readPreference;
   }
 
+  get bsonOptions(): BSONSerializeOptions {
+    return this.s.bsonOptions;
+  }
+
   // get the write Concern
   get writeConcern(): WriteConcern | undefined {
     return this.s.writeConcern;

src/mongo_client.ts

@@ -10,7 +10,7 @@ import { connect, validOptions } from './operations/connect';
 import { PromiseProvider } from './promise_provider';
 import { Logger } from './logger';
 import { ReadConcern, ReadConcernLevelLike, ReadConcernLike } from './read_concern';
-import type { BSONSerializeOptions, Document } from './bson';
+import { BSONSerializeOptions, Document, resolveBSONOptions } from './bson';
 import type { AutoEncryptionOptions } from './deps';
 import type { CompressorName } from './cmap/wire_protocol/compression';
 import type { AuthMechanism } from './cmap/auth/defaultAuthProviders';
@@ -222,6 +222,7 @@ export interface MongoClientPrivate {
   readConcern?: ReadConcern;
   writeConcern?: WriteConcern;
   readPreference: ReadPreference;
+  bsonOptions: BSONSerializeOptions;
   namespace: MongoDBNamespace;
   logger: Logger;
 }
@@ -284,6 +285,7 @@ export class MongoClient extends EventEmitter implements OperationParent {
       readConcern: ReadConcern.fromOptions(options),
       writeConcern: WriteConcern.fromOptions(options),
       readPreference: ReadPreference.fromOptions(options) || ReadPreference.primary,
+      bsonOptions: resolveBSONOptions(options),
       namespace: new MongoDBNamespace('admin'),
       logger: options?.logger ?? new Logger('MongoClient')
     };
@@ -301,6 +303,10 @@ export class MongoClient extends EventEmitter implements OperationParent {
     return this.s.readPreference;
   }
 
+  get bsonOptions(): BSONSerializeOptions {
+    return this.s.bsonOptions;
+  }
+
   get logger(): Logger {
     return this.s.logger;
   }

src/operations/bulk_write.ts

@@ -1,6 +1,6 @@
 import { applyRetryableWrites, applyWriteConcern, Callback } from '../utils';
 import { OperationBase } from './operation';
-import { inheritBSONOptions } from '../bson';
+import { resolveBSONOptions } from '../bson';
 import { WriteConcern } from '../write_concern';
 import type { Collection } from '../collection';
 import type {
@@ -27,7 +27,7 @@ export class BulkWriteOperation extends OperationBase<BulkWriteOptions, BulkWrit
     this.operations = operations;
 
     // Assign BSON serialize options to OperationBase, preferring options over collection options
-    this.bsonOptions = inheritBSONOptions(options, collection.s.options, true);
+    this.bsonOptions = resolveBSONOptions(options, collection);
   }
 
   execute(server: Server, callback: Callback<BulkWriteResult>): void {

src/operations/command.ts

@@ -7,7 +7,7 @@ import { commandSupportsReadConcern } from '../sessions';
 import { MongoError } from '../error';
 import type { Logger } from '../logger';
 import type { Server } from '../sdam/server';
-import { BSONSerializeOptions, Document, inheritBSONOptions } from '../bson';
+import { BSONSerializeOptions, Document, resolveBSONOptions } from '../bson';
 import type { CollationOptions } from '../cmap/wire_protocol/write_command';
 import type { ReadConcernLike } from './../read_concern';
 
@@ -37,14 +37,12 @@ export interface CommandOperationOptions extends OperationOptions, WriteConcernO
 
 /** @internal */
 export interface OperationParent {
-  s: {
-    namespace: MongoDBNamespace;
-    options?: BSONSerializeOptions;
-  };
+  s: { namespace: MongoDBNamespace };
   readConcern?: ReadConcern;
   writeConcern?: WriteConcern;
   readPreference?: ReadPreference;
   logger?: Logger;
+  bsonOptions?: BSONSerializeOptions;
 }
 
 /** @internal */
@@ -95,7 +93,7 @@ export abstract class CommandOperation<
     }
 
     // Assign BSON serialize options to OperationBase, preferring options over parent options.
-    this.bsonOptions = inheritBSONOptions(options, parent?.s.options, true);
+    this.bsonOptions = resolveBSONOptions(options, parent);
   }
 
   abstract execute(server: Server, callback: Callback<TResult>): void;

src/operations/common_functions.ts

@@ -250,7 +250,8 @@ export function updateDocuments(
   // Do we return the actual result document
   // Either use override on the function, or go back to default on either the collection
   // level or db
-  finalOptions.serializeFunctions = options.serializeFunctions || coll.s.options.serializeFunctions;
+  finalOptions.serializeFunctions =
+    options.serializeFunctions || coll.bsonOptions.serializeFunctions;
 
   // Execute the operation
   const op: Document = { q: selector, u: document };

src/operations/find_one.ts

@@ -1,6 +1,6 @@
 import { OperationBase } from './operation';
 import type { Callback } from '../utils';
-import { Document, inheritBSONOptions } from '../bson';
+import { Document, resolveBSONOptions } from '../bson';
 import type { Collection } from '../collection';
 import type { FindOptions } from './find';
 import { MongoError } from '../error';
@@ -18,7 +18,7 @@ export class FindOneOperation extends OperationBase<FindOptions, Document> {
     this.query = query;
 
     // Assign BSON serialize options to OperationBase, preferring options over collection options
-    this.bsonOptions = inheritBSONOptions(options, collection.s.options, true);
+    this.bsonOptions = resolveBSONOptions(options, collection);
   }
 
   execute(server: Server, callback: Callback<Document>): void {

src/operations/insert_many.ts

@@ -4,7 +4,7 @@ import { MongoError } from '../error';
 import { prepareDocs } from './common_functions';
 import type { Callback } from '../utils';
 import type { Collection } from '../collection';
-import { ObjectId, Document, inheritBSONOptions } from '../bson';
+import { ObjectId, Document, resolveBSONOptions } from '../bson';
 import type { BulkWriteResult, BulkWriteOptions } from '../bulk/common';
 import type { Server } from '../sdam/server';
 
@@ -32,7 +32,7 @@ export class InsertManyOperation extends OperationBase<BulkWriteOptions, InsertM
     this.docs = docs;
 
     // Assign BSON serialize options to OperationBase, preferring options over collection options
-    this.bsonOptions = inheritBSONOptions(options, collection.s.options, true);
+    this.bsonOptions = resolveBSONOptions(options, collection);
   }
 
   execute(server: Server, callback: Callback<InsertManyResult>): void {

test/functional/mongo_client.test.js

@@ -57,8 +57,8 @@ describe('MongoClient', function () {
 
         test.equal(true, db.s.options.forceServerObjectId);
         test.equal(1, db.s.pkFactory.createPk());
-        test.equal(true, db.s.options.serializeFunctions);
-        test.equal(true, db.s.options.raw);
+        test.equal(true, db.bsonOptions.serializeFunctions);
+        test.equal(true, db.bsonOptions.raw);
         test.equal(10, db.s.options.numberOfRetries);
         test.equal(0, db.s.options.bufferMaxEntries);