fix(NODE-4999): Write Concern 0 Must Not Affect Read Operations

src/change_stream.ts

@@ -594,7 +594,7 @@ export class ChangeStream<
     super();
 
     this.pipeline = pipeline;
-    this.options = options;
+    this.options = { ...options, writeConcern: undefined };
 
     if (parent instanceof Collection) {
       this.type = CHANGE_DOMAIN_TYPES.COLLECTION;

src/operations/aggregate.ts

@@ -65,6 +65,8 @@ export class AggregateOperation<T = Document> extends CommandOperation<T> {
 
     if (this.hasWriteStage) {
       this.trySecondaryWrite = true;
+    } else {
+      this.options.writeConcern = undefined;
     }
 
     if (this.explain && this.writeConcern) {

src/operations/find.ts

@@ -77,7 +77,7 @@ export class FindOperation extends CommandOperation<Document> {
   ) {
     super(collection, options);
 
-    this.options = options;
+    this.options = { ...options, writeConcern: undefined };
     this.ns = ns;
 
     if (typeof filter !== 'object' || Array.isArray(filter)) {

src/operations/indexes.ts

@@ -394,7 +394,7 @@ export class ListIndexesOperation extends CommandOperation<Document> {
   constructor(collection: Collection, options?: ListIndexesOptions) {
     super(collection, options);
 
-    this.options = options ?? {};
+    this.options = { ...options, writeConcern: undefined };
     this.collectionNamespace = collection.s.namespace;
   }
 

src/operations/list_collections.ts

@@ -28,7 +28,7 @@ export class ListCollectionsOperation extends CommandOperation<string[]> {
   constructor(db: Db, filter: Document, options?: ListCollectionsOptions) {
     super(db, options);
 
-    this.options = options ?? {};
+    this.options = { ...options, writeConcern: undefined };
     this.db = db;
     this.filter = filter;
     this.nameOnly = !!this.options.nameOnly;

test/integration/read-write-concern/write_concern.test.js

@@ -1,10 +1,10 @@
-'use strict';
-
 const { expect } = require('chai');
-const { LEGACY_HELLO_COMMAND } = require('../../../src/constants');
 
-const mock = require('../../tools/mongodb-mock/index');
 const { MongoClient } = require('../../../src');
+const { LEGACY_HELLO_COMMAND } = require('../../../src/constants');
+const mock = require('../../tools/mongodb-mock/index');
+
+const { setTimeout } = require('timers');
 
 describe('Write Concern', function () {
   it('should respect writeConcern from uri', function (done) {
@@ -72,4 +72,91 @@ describe('Write Concern', function () {
         });
     });
   });
+
+  describe('must not affect read operations', function () {
+    describe('when writeConcern = 0', function () {
+      describe('does not throw an error when getMore is called on cursor', function () {
+        let client;
+        let db;
+        let col;
+
+        beforeEach(async function () {
+          client = this.configuration.newClient({ writeConcern: { w: 0 } });
+          await client.connect();
+          db = client.db('writeConcernTest');
+          col = db.collection('writeConcernTest');
+
+          const docs = [];
+          for (let i = 0; i < 100; i++) {
+            docs.push({ a: i, b: i + 1 });
+          }
+
+          await col.insertMany(docs);
+        });
+
+        afterEach(async function () {
+          await db.dropDatabase();
+          await client.close();
+        });
+
+        it('find', async function () {
+          const findResult = col.find({}, { batchSize: 2 });
+          const err = await findResult.toArray().catch(e => e);
+
+          expect(err).to.not.be.instanceOf(Error);
+        });
+
+        it('listCollections', async function () {
+          let collections = [];
+          for (let i = 0; i < 10; i++) {
+            collections.push(`writeConcernTestCol${i + 1}`);
+          }
+
+          for (const colName of collections) {
+            await db.createCollection(colName).catch(() => null);
+          }
+
+          const cols = db.listCollections({}, { batchSize: 2 });
+
+          const err = await cols.toArray().catch(e => e);
+
+          expect(err).to.not.be.instanceOf(Error);
+        });
+
+        it('aggregate', async function () {
+          const aggResult = col.aggregate([{ $match: { a: { $gte: 0 } } }], { batchSize: 2 });
+          const err = await aggResult.toArray().catch(e => e);
+
+          expect(err).to.not.be.instanceOf(Error);
+        });
+
+        it('listIndexes', async function () {
+          await col.createIndex({ a: 1 });
+          await col.createIndex({ b: -1 });
+          await col.createIndex({ a: 1, b: -1 });
+
+          const listIndexesResult = col.listIndexes({ batchSize: 2 });
+          const err = await listIndexesResult.toArray().catch(e => e);
+
+          expect(err).to.not.be.instanceOf(Error);
+        });
+
+        it('changeStream', async function () {
+          if (this.configuration.options.replicaSet) {
+            let changeStream = col.watch(undefined, { batchSize: 2 });
+
+            setTimeout(() => {
+              col.updateMany({}, [{ $addFields: { A: 1 } }]);
+            }, 500);
+
+            const err = await changeStream.next().catch(e => e);
+
+            expect(err).to.not.be.instanceOf(Error);
+          } else {
+            this.skip();
+          }
+        });
+      });
+    });
+  });
 });