types(connection): add Connection.prototype.bulkWrite() to types

test/connection.test.js

@@ -1720,7 +1720,8 @@ describe('connections:', function() {
     const Test = db.model('Test', new Schema({ name: { type: String, required: true } }));
 
     await Test.deleteMany({});
-    await db.bulkWrite([{ model: 'Test', name: 'insertOne', document: { name: 'test1' } }]);
+    const res = await db.bulkWrite([{ model: 'Test', name: 'insertOne', document: { name: 'test1' } }]);
+    assert.equal(res.insertedCount, 1);
     assert.ok(await Test.exists({ name: 'test1' }));
 
     await db.bulkWrite([{ model: Test, name: 'insertOne', document: { name: 'test2' } }]);

test/types/connection.test.ts

@@ -154,3 +154,20 @@ function schemaInstanceMethodsAndQueryHelpersOnConnection() {
 
   const TestModel = connection.model<User, UserModel, UserQueryHelpers>('User', userSchema);
 }
+
+async function gh15359() {
+  const res = await conn.bulkWrite([{ model: 'Test', name: 'insertOne', document: { name: 'test1' } }]);
+  expectType<number>(res.insertedCount);
+  expectError(res.mongoose.validationErrors);
+
+  const res2 = await conn.bulkWrite([{ model: 'Test', name: 'insertOne', document: { name: 'test2' } }], { ordered: false });
+  expectType<number>(res2.insertedCount);
+  expectType<Error[] | undefined>(res2.mongoose?.validationErrors);
+
+  const res3 = await conn.bulkWrite([
+    { model: 'Test', name: 'updateOne', filter: { name: 'test5' }, update: { $set: { num: 42 } } },
+    { model: 'Test', name: 'updateOne', filter: { name: 'test4' }, update: { $set: { num: 'not a number' } } }
+  ], { ordered: false });
+  expectType<number>(res3.insertedCount);
+  expectType<Error[] | undefined>(res3.mongoose?.validationErrors);
+}

types/connection.d.ts

@@ -58,12 +58,34 @@ declare module 'mongoose' {
     sanitizeFilter?: boolean;
   }
 
+  export type AnyConnectionBulkWriteModel<TSchema extends AnyObject> = Omit<mongodb.ClientInsertOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientReplaceOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientUpdateOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientUpdateManyModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientDeleteOneModel<TSchema>, 'namespace'>
+    | Omit<mongodb.ClientDeleteManyModel<TSchema>, 'namespace'>;
+
+  export type ConnectionBulkWriteModel<SchemaMap extends Record<string, AnyObject> = Record<string, AnyObject>> = {
+      [ModelName in keyof SchemaMap]: AnyConnectionBulkWriteModel<SchemaMap[ModelName]> & {
+          model: ModelName;
+      };
+  }[keyof SchemaMap];
+
   class Connection extends events.EventEmitter implements SessionStarter {
     aggregate<ResultType = unknown>(pipeline?: PipelineStage[] | null, options?: AggregateOptions): Aggregate<Array<ResultType>>;
 
     /** Returns a promise that resolves when this connection successfully connects to MongoDB */
     asPromise(): Promise<this>;
 
+    bulkWrite<TSchemaMap extends Record<string, AnyObject>>(
+      ops: Array<ConnectionBulkWriteModel<TSchemaMap>>,
+      options: mongodb.ClientBulkWriteOptions & { ordered: false }
+    ): Promise<mongodb.ClientBulkWriteResult & { mongoose?: { validationErrors: Error[], results: Array<Error | mongodb.WriteError | null> } }>;
+    bulkWrite<TSchemaMap extends Record<string, AnyObject>>(
+      ops: Array<ConnectionBulkWriteModel<TSchemaMap>>,
+      options?: mongodb.ClientBulkWriteOptions
+    ): Promise<mongodb.ClientBulkWriteResult>;
+
     /** Closes the connection */
     close(force?: boolean): Promise<void>;