mongodb 6.5.0 → 6.6.0

package/src/operations/indexes.ts

@@ -1,9 +1,8 @@
 import type { Document } from '../bson';
 import type { Collection } from '../collection';
-import type { Db } from '../db';
-import { MongoCompatibilityError, MONGODB_ERROR_CODES, MongoError } from '../error';
+import { type AbstractCursorOptions } from '../cursor/abstract_cursor';
+import { MongoCompatibilityError } from '../error';
 import { type OneOrMore } from '../mongo_types';
-import { ReadPreference } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { isObject, maxWireVersion, type MongoDBNamespace } from '../utils';
@@ -13,8 +12,7 @@ import {
   type CommandOperationOptions,
   type OperationParent
 } from './command';
-import { indexInformation, type IndexInformationOptions } from './common_functions';
-import { AbstractOperation, Aspect, defineAspects } from './operation';
+import { Aspect, defineAspects } from './operation';
 
 const VALID_INDEX_OPTIONS = new Set([
   'background',
@@ -73,6 +71,29 @@ export type IndexSpecification = OneOrMore<
   | Map<string, IndexDirection>
 >;
 
+/** @public */
+export interface IndexInformationOptions extends ListIndexesOptions {
+  /**
+   * When `true`, an array of index descriptions is returned.
+   * When `false`, the driver returns an object that with keys corresponding to index names with values
+   * corresponding to the entries of the indexes' key.
+   *
+   * For example, the given the following indexes:
+   * ```
+   * [ { name: 'a_1', key: { a: 1 } }, { name: 'b_1_c_1' , key: { b: 1, c: 1 } }]
+   * ```
+   *
+   * When `full` is `true`, the above array is returned.  When `full` is `false`, the following is returned:
+   * ```
+   * {
+   *   'a_1': [['a', 1]],
+   *   'b_1_c_1': [['b', 1], ['c', 1]],
+   * }
+   * ```
+   */
+  full?: boolean;
+}
+
 /** @public */
 export interface IndexDescription
   extends Pick<
@@ -146,10 +167,11 @@ function isSingleIndexTuple(t: unknown): t is [string, IndexDirection] {
   return Array.isArray(t) && t.length === 2 && isIndexDirection(t[1]);
 }
 
-function makeIndexSpec(
-  indexSpec: IndexSpecification,
-  options?: CreateIndexesOptions
-): IndexDescription {
+/**
+ * Converts an `IndexSpecification`, which can be specified in multiple formats, into a
+ * valid `key` for the createIndexes command.
+ */
+function constructIndexDescriptionMap(indexSpec: IndexSpecification): Map<string, IndexDirection> {
   const key: Map<string, IndexDirection> = new Map();
 
   const indexSpecs =
@@ -172,46 +194,60 @@ function makeIndexSpec(
     }
   }
 
-  return { ...options, key };
+  return key;
 }
 
-/** @internal */
-export class IndexesOperation extends AbstractOperation<Document[]> {
-  override options: IndexInformationOptions;
-  collection: Collection;
-
-  constructor(collection: Collection, options: IndexInformationOptions) {
-    super(options);
-    this.options = options;
-    this.collection = collection;
-  }
+/**
+ * Receives an index description and returns a modified index description which has had invalid options removed
+ * from the description and has mapped the `version` option to the `v` option.
+ */
+function resolveIndexDescription(
+  description: IndexDescription
+): Omit<ResolvedIndexDescription, 'key'> {
+  const validProvidedOptions = Object.entries(description).filter(([optionName]) =>
+    VALID_INDEX_OPTIONS.has(optionName)
+  );
 
-  override get commandName() {
-    return 'listIndexes' as const;
-  }
+  return Object.fromEntries(
+    // we support the `version` option, but the `createIndexes` command expects it to be the `v`
+    validProvidedOptions.map(([name, value]) => (name === 'version' ? ['v', value] : [name, value]))
+  );
+}
 
-  override async execute(_server: Server, session: ClientSession | undefined): Promise<Document[]> {
-    const coll = this.collection;
-    const options = this.options;
+/**
+ * @public
+ * The index information returned by the listIndexes command. https://www.mongodb.com/docs/manual/reference/command/listIndexes/#mongodb-dbcommand-dbcmd.listIndexes
+ */
+export type IndexDescriptionInfo = Omit<IndexDescription, 'key' | 'version'> & {
+  key: { [key: string]: IndexDirection };
+  v?: IndexDescription['version'];
+} & Document;
 
-    return indexInformation(coll.s.db, coll.collectionName, {
-      full: true,
-      ...options,
-      readPreference: this.readPreference,
-      session
-    });
-  }
-}
+/** @public */
+export type IndexDescriptionCompact = Record<string, [name: string, direction: IndexDirection][]>;
+
+/**
+ * @internal
+ *
+ * Internally, the driver represents index description keys with `Map`s to preserve key ordering.
+ * We don't require users to specify maps, so we transform user provided descriptions into
+ * "resolved" by converting the `key` into a JS `Map`, if it isn't already a map.
+ *
+ * Additionally, we support the `version` option, but the `createIndexes` command uses the field `v`
+ * to specify the index version so we map the value of `version` to `v`, if provided.
+ */
+type ResolvedIndexDescription = Omit<IndexDescription, 'key' | 'version'> & {
+  key: Map<string, IndexDirection>;
+  v?: IndexDescription['version'];
+};
 
 /** @internal */
-export class CreateIndexesOperation<
-  T extends string | string[] = string[]
-> extends CommandOperation<T> {
+export class CreateIndexesOperation extends CommandOperation<string[]> {
   override options: CreateIndexesOptions;
   collectionName: string;
-  indexes: ReadonlyArray<Omit<IndexDescription, 'key'> & { key: Map<string, IndexDirection> }>;
+  indexes: ReadonlyArray<ResolvedIndexDescription>;
 
-  constructor(
+  private constructor(
     parent: OperationParent,
     collectionName: string,
     indexes: IndexDescription[],
@@ -221,16 +257,12 @@ export class CreateIndexesOperation<
 
     this.options = options ?? {};
     this.collectionName = collectionName;
-    this.indexes = indexes.map(userIndex => {
+    this.indexes = indexes.map((userIndex: IndexDescription): ResolvedIndexDescription => {
       // Ensure the key is a Map to preserve index key ordering
       const key =
         userIndex.key instanceof Map ? userIndex.key : new Map(Object.entries(userIndex.key));
-      const name = userIndex.name != null ? userIndex.name : Array.from(key).flat().join('_');
-      const validIndexOptions = Object.fromEntries(
-        Object.entries({ ...userIndex }).filter(([optionName]) =>
-          VALID_INDEX_OPTIONS.has(optionName)
-        )
-      );
+      const name = userIndex.name ?? Array.from(key).flat().join('_');
+      const validIndexOptions = resolveIndexDescription(userIndex);
       return {
         ...validIndexOptions,
         name,
@@ -239,11 +271,31 @@ export class CreateIndexesOperation<
     });
   }
 
+  static fromIndexDescriptionArray(
+    parent: OperationParent,
+    collectionName: string,
+    indexes: IndexDescription[],
+    options?: CreateIndexesOptions
+  ): CreateIndexesOperation {
+    return new CreateIndexesOperation(parent, collectionName, indexes, options);
+  }
+
+  static fromIndexSpecification(
+    parent: OperationParent,
+    collectionName: string,
+    indexSpec: IndexSpecification,
+    options: CreateIndexesOptions = {}
+  ): CreateIndexesOperation {
+    const key = constructIndexDescriptionMap(indexSpec);
+    const description: IndexDescription = { ...options, key };
+    return new CreateIndexesOperation(parent, collectionName, [description], options);
+  }
+
   override get commandName() {
     return 'createIndexes';
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
+  override async execute(server: Server, session: ClientSession | undefined): Promise<string[]> {
     const options = this.options;
     const indexes = this.indexes;
 
@@ -266,61 +318,7 @@ export class CreateIndexesOperation<
     await super.executeCommand(server, session, cmd);
 
     const indexNames = indexes.map(index => index.name || '');
-    return indexNames as T;
-  }
-}
-
-/** @internal */
-export class CreateIndexOperation extends CreateIndexesOperation<string> {
-  constructor(
-    parent: OperationParent,
-    collectionName: string,
-    indexSpec: IndexSpecification,
-    options?: CreateIndexesOptions
-  ) {
-    super(parent, collectionName, [makeIndexSpec(indexSpec, options)], options);
-  }
-
-  override async execute(server: Server, session: ClientSession | undefined): Promise<string> {
-    const indexNames = await super.execute(server, session);
-    return indexNames[0];
-  }
-}
-
-/** @internal */
-export class EnsureIndexOperation extends CreateIndexOperation {
-  db: Db;
-
-  constructor(
-    db: Db,
-    collectionName: string,
-    indexSpec: IndexSpecification,
-    options?: CreateIndexesOptions
-  ) {
-    super(db, collectionName, indexSpec, options);
-
-    this.readPreference = ReadPreference.primary;
-    this.db = db;
-    this.collectionName = collectionName;
-  }
-
-  override get commandName() {
-    return 'listIndexes';
-  }
-
-  override async execute(server: Server, session: ClientSession | undefined): Promise<string> {
-    const indexName = this.indexes[0].name;
-    const indexes = await this.db
-      .collection(this.collectionName)
-      .listIndexes({ session })
-      .toArray()
-      .catch(error => {
-        if (error instanceof MongoError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound)
-          return [];
-        throw error;
-      });
-    if (indexName && indexes.some(index => index.name === indexName)) return indexName;
-    return super.execute(server, session);
+    return indexNames;
   }
 }
 
@@ -347,15 +345,12 @@ export class DropIndexOperation extends CommandOperation<Document> {
 
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
     const cmd = { dropIndexes: this.collection.collectionName, index: this.indexName };
-    return super.executeCommand(server, session, cmd);
+    return await super.executeCommand(server, session, cmd);
   }
 }
 
 /** @public */
-export interface ListIndexesOptions extends Omit<CommandOperationOptions, 'writeConcern'> {
-  /** The batchSize for the returned command cursor or if pre 2.8 the systems batch collection */
-  batchSize?: number;
-}
+export type ListIndexesOptions = AbstractCursorOptions;
 
 /** @internal */
 export class ListIndexesOperation extends CommandOperation<Document> {
@@ -394,73 +389,7 @@ export class ListIndexesOperation extends CommandOperation<Document> {
       command.comment = this.options.comment;
     }
 
-    return super.executeCommand(server, session, command);
-  }
-}
-
-/** @internal */
-export class IndexExistsOperation extends AbstractOperation<boolean> {
-  override options: IndexInformationOptions;
-  collection: Collection;
-  indexes: string | string[];
-
-  constructor(
-    collection: Collection,
-    indexes: string | string[],
-    options: IndexInformationOptions
-  ) {
-    super(options);
-    this.options = options;
-    this.collection = collection;
-    this.indexes = indexes;
-  }
-
-  override get commandName() {
-    return 'listIndexes' as const;
-  }
-
-  override async execute(server: Server, session: ClientSession | undefined): Promise<boolean> {
-    const coll = this.collection;
-    const indexes = this.indexes;
-
-    const info = await indexInformation(coll.s.db, coll.collectionName, {
-      ...this.options,
-      readPreference: this.readPreference,
-      session
-    });
-    // Let's check for the index names
-    if (!Array.isArray(indexes)) return info[indexes] != null;
-    // All keys found return true
-    return indexes.every(indexName => info[indexName] != null);
-  }
-}
-
-/** @internal */
-export class IndexInformationOperation extends AbstractOperation<Document> {
-  override options: IndexInformationOptions;
-  db: Db;
-  name: string;
-
-  constructor(db: Db, name: string, options?: IndexInformationOptions) {
-    super(options);
-    this.options = options ?? {};
-    this.db = db;
-    this.name = name;
-  }
-
-  override get commandName() {
-    return 'listIndexes' as const;
-  }
-
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
-    const db = this.db;
-    const name = this.name;
-
-    return indexInformation(db, name, {
-      ...this.options,
-      readPreference: this.readPreference,
-      session
-    });
+    return await super.executeCommand(server, session, command);
   }
 }
 
@@ -470,6 +399,4 @@ defineAspects(ListIndexesOperation, [
   Aspect.CURSOR_CREATING
 ]);
 defineAspects(CreateIndexesOperation, [Aspect.WRITE_OPERATION]);
-defineAspects(CreateIndexOperation, [Aspect.WRITE_OPERATION]);
-defineAspects(EnsureIndexOperation, [Aspect.WRITE_OPERATION]);
 defineAspects(DropIndexOperation, [Aspect.WRITE_OPERATION]);

package/src/operations/insert.ts

@@ -6,10 +6,10 @@ import type { InferIdType } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import type { MongoDBNamespace } from '../utils';
+import { maybeAddIdToDocuments } from '../utils';
 import { WriteConcern } from '../write_concern';
 import { BulkWriteOperation } from './bulk_write';
 import { CommandOperation, type CommandOperationOptions } from './command';
-import { maybeAddIdToDocuments } from './common_functions';
 import { AbstractOperation, Aspect, defineAspects } from './operation';
 
 /** @internal */
@@ -47,7 +47,7 @@ export class InsertOperation extends CommandOperation<Document> {
       command.comment = options.comment;
     }
 
-    return super.executeCommand(server, session, command);
+    return await super.executeCommand(server, session, command);
   }
 }
 

package/src/operations/kill_cursors.ts

@@ -2,7 +2,7 @@ import type { Long } from '../bson';
 import { MongoRuntimeError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import type { MongoDBNamespace } from '../utils';
+import { type MongoDBNamespace, squashError } from '../utils';
 import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
 
 /**
@@ -47,8 +47,9 @@ export class KillCursorsOperation extends AbstractOperation {
     };
     try {
       await server.command(this.ns, killCursorsCommand, { session });
-    } catch {
+    } catch (error) {
       // The driver should never emit errors from killCursors, this is spec-ed behavior
+      squashError(error);
     }
   }
 }

package/src/operations/list_collections.ts

@@ -52,7 +52,11 @@ export class ListCollectionsOperation extends CommandOperation<Document> {
   }
 
   override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
-    return super.executeCommand(server, session, this.generateCommand(maxWireVersion(server)));
+    return await super.executeCommand(
+      server,
+      session,
+      this.generateCommand(maxWireVersion(server))
+    );
   }
 
   /* This is here for the purpose of unit testing the final command that gets sent. */

package/src/operations/list_databases.ts

@@ -63,7 +63,7 @@ export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult
       cmd.comment = this.options.comment;
     }
 
-    return super.executeCommand(server, session, cmd) as TODO_NODE_3286;
+    return await (super.executeCommand(server, session, cmd) as Promise<TODO_NODE_3286>);
   }
 }
 

package/src/operations/operation.ts

@@ -34,6 +34,9 @@ export interface OperationOptions extends BSONSerializeOptions {
   /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
   bypassPinningCheck?: boolean;
   omitReadPreference?: boolean;
+
+  /** @internal TODO(NODE-5688): make this public */
+  timeoutMS?: number;
 }
 
 /** @internal */

package/src/operations/run_command.ts

@@ -28,11 +28,12 @@ export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
 
   override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
     this.server = server;
-    return server.command(this.ns, this.command, {
+    const res: TODO_NODE_3286 = await server.command(this.ns, this.command, {
       ...this.options,
       readPreference: this.readPreference,
       session
-    }) as TODO_NODE_3286;
+    });
+    return res;
   }
 }
 
@@ -54,10 +55,11 @@ export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T>
 
   override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
     this.server = server;
-    return server.command(this.ns, this.command, {
+    const res: TODO_NODE_3286 = await server.command(this.ns, this.command, {
       ...this.options,
       readPreference: this.readPreference,
       session
-    }) as TODO_NODE_3286;
+    });
+    return res;
   }
 }

package/src/operations/search_indexes/create.ts

@@ -8,12 +8,15 @@ import { AbstractOperation } from '../operation';
 /**
  * @public
  */
-export interface SearchIndexDescription {
+export interface SearchIndexDescription extends Document {
   /** The name of the index. */
   name?: string;
 
   /** The index definition. */
   definition: Document;
+
+  /** The type of the index.  Currently `search` or `vectorSearch` are supported. */
+  type?: string;
 }
 
 /** @internal */

package/src/operations/stats.ts

@@ -30,7 +30,7 @@ export class DbStatsOperation extends CommandOperation<Document> {
       command.scale = this.options.scale;
     }
 
-    return super.executeCommand(server, session, command);
+    return await super.executeCommand(server, session, command);
   }
 }
 

package/src/operations/update.ts

@@ -122,7 +122,7 @@ export class UpdateOperation extends CommandOperation<Document> {
       }
     }
 
-    return super.executeCommand(server, session, command);
+    return await super.executeCommand(server, session, command);
   }
 }
 
@@ -144,8 +144,8 @@ export class UpdateOneOperation extends UpdateOperation {
     server: Server,
     session: ClientSession | undefined
   ): Promise<UpdateResult> {
-    const res = await super.execute(server, session);
-    if (this.explain != null) return res as TODO_NODE_3286;
+    const res: TODO_NODE_3286 = await super.execute(server, session);
+    if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 
@@ -178,8 +178,8 @@ export class UpdateManyOperation extends UpdateOperation {
     server: Server,
     session: ClientSession | undefined
   ): Promise<UpdateResult> {
-    const res = await super.execute(server, session);
-    if (this.explain != null) return res as TODO_NODE_3286;
+    const res: TODO_NODE_3286 = await super.execute(server, session);
+    if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 
@@ -231,8 +231,8 @@ export class ReplaceOneOperation extends UpdateOperation {
     server: Server,
     session: ClientSession | undefined
   ): Promise<UpdateResult> {
-    const res = await super.execute(server, session);
-    if (this.explain != null) return res as TODO_NODE_3286;
+    const res: TODO_NODE_3286 = await super.execute(server, session);
+    if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
 

package/src/sdam/common.ts

@@ -55,10 +55,16 @@ export function drainTimerQueue(queue: TimerQueue): void {
   queue.clear();
 }
 
-/** @public */
+/**
+ * @public
+ * Gossiped in component for the cluster time tracking the state of user databases
+ * across the cluster. It may optionally include a signature identifying the process that
+ * generated such a value.
+ */
 export interface ClusterTime {
   clusterTime: Timestamp;
-  signature: {
+  /** Used to validate the identity of a request or response's ClusterTime. */
+  signature?: {
     hash: Binary;
     keyId: Long;
   };