mongodb 5.4.0 → 5.6.0

package/src/operations/search_indexes/create.ts

@@ -0,0 +1,48 @@
+import type { Document } from 'bson';
+
+import type { Collection } from '../../collection';
+import type { Server } from '../../sdam/server';
+import type { ClientSession } from '../../sessions';
+import type { Callback } from '../../utils';
+import { AbstractOperation } from '../operation';
+
+/** @internal */
+export interface SearchIndexDescription {
+  /** The name of the index. */
+  name?: string;
+
+  /** The index definition. */
+  description: Document;
+}
+
+/** @internal */
+export class CreateSearchIndexesOperation extends AbstractOperation<string[]> {
+  constructor(
+    private readonly collection: Collection,
+    private readonly descriptions: ReadonlyArray<SearchIndexDescription>
+  ) {
+    super();
+  }
+
+  execute(server: Server, session: ClientSession | undefined, callback: Callback<string[]>): void {
+    const namespace = this.collection.fullNamespace;
+    const command = {
+      createSearchIndexes: namespace.collection,
+      indexes: this.descriptions
+    };
+
+    server.command(namespace, command, { session }, (err, res) => {
+      if (err || !res) {
+        callback(err);
+        return;
+      }
+
+      const indexesCreated: Array<{ name: string }> = res?.indexesCreated ?? [];
+
+      callback(
+        undefined,
+        indexesCreated.map(({ name }) => name)
+      );
+    });
+  }
+}

package/src/operations/search_indexes/drop.ts

@@ -0,0 +1,35 @@
+import type { Document } from 'bson';
+
+import type { Collection } from '../../collection';
+import type { Server } from '../../sdam/server';
+import type { ClientSession } from '../../sessions';
+import type { Callback } from '../../utils';
+import { AbstractOperation } from '../operation';
+
+/** @internal */
+export class DropSearchIndexOperation extends AbstractOperation<void> {
+  constructor(private readonly collection: Collection, private readonly name: string) {
+    super();
+  }
+
+  execute(server: Server, session: ClientSession | undefined, callback: Callback<void>): void {
+    const namespace = this.collection.fullNamespace;
+
+    const command: Document = {
+      dropSearchIndex: namespace.collection
+    };
+
+    if (typeof this.name === 'string') {
+      command.name = this.name;
+    }
+
+    server.command(namespace, command, { session }, err => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      callback();
+    });
+  }
+}

package/src/operations/search_indexes/update.ts

@@ -0,0 +1,36 @@
+import type { Document } from 'bson';
+
+import type { Collection } from '../../collection';
+import type { Server } from '../../sdam/server';
+import type { ClientSession } from '../../sessions';
+import type { Callback } from '../../utils';
+import { AbstractOperation } from '../operation';
+
+/** @internal */
+export class UpdateSearchIndexOperation extends AbstractOperation<void> {
+  constructor(
+    private readonly collection: Collection,
+    private readonly name: string,
+    private readonly definition: Document
+  ) {
+    super();
+  }
+
+  execute(server: Server, session: ClientSession | undefined, callback: Callback<void>): void {
+    const namespace = this.collection.fullNamespace;
+    const command = {
+      updateSearchIndex: namespace.collection,
+      name: this.name,
+      definition: this.definition
+    };
+
+    server.command(namespace, command, { session }, err => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      callback();
+    });
+  }
+}

package/src/sdam/monitor.ts

@@ -111,7 +111,7 @@ export class Monitor extends TypedEventEmitter<MonitorEvents> {
     const connectOptions = Object.assign(
       {
         id: '<monitor>' as const,
-        generation: server.s.pool.generation,
+        generation: server.pool.generation,
         connectionType: Connection,
         cancellationToken,
         hostAddress: server.description.hostAddress

package/src/sdam/server.ts

@@ -87,10 +87,6 @@ export interface ServerPrivate {
   options: ServerOptions;
   /** The current state of the Server */
   state: string;
-  /** The topology this server is a part of */
-  topology: Topology;
-  /** A connection pool for this server */
-  pool: ConnectionPool;
   /** MongoDB server API version */
   serverApi?: ServerApi;
   /** A count of the operations currently running against the server. */
@@ -114,6 +110,10 @@ export type ServerEvents = {
 export class Server extends TypedEventEmitter<ServerEvents> {
   /** @internal */
   s: ServerPrivate;
+  /** @internal */
+  topology: Topology;
+  /** @internal */
+  pool: ConnectionPool;
   serverApi?: ServerApi;
   hello?: Document;
   [kMonitor]: Monitor | null;
@@ -143,20 +143,21 @@ export class Server extends TypedEventEmitter<ServerEvents> {
 
     const poolOptions = { hostAddress: description.hostAddress, ...options };
 
+    this.topology = topology;
+    this.pool = new ConnectionPool(this, poolOptions);
+
     this.s = {
       description,
       options,
       state: STATE_CLOSED,
-      topology,
-      pool: new ConnectionPool(this, poolOptions),
       operationCount: 0
     };
 
     for (const event of [...CMAP_EVENTS, ...APM_EVENTS]) {
-      this.s.pool.on(event, (e: any) => this.emit(event, e));
+      this.pool.on(event, (e: any) => this.emit(event, e));
     }
 
-    this.s.pool.on(Connection.CLUSTER_TIME_RECEIVED, (clusterTime: ClusterTime) => {
+    this.pool.on(Connection.CLUSTER_TIME_RECEIVED, (clusterTime: ClusterTime) => {
       this.clusterTime = clusterTime;
     });
 
@@ -192,11 +193,11 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   }
 
   get clusterTime(): ClusterTime | undefined {
-    return this.s.topology.clusterTime;
+    return this.topology.clusterTime;
   }
 
   set clusterTime(clusterTime: ClusterTime | undefined) {
-    this.s.topology.clusterTime = clusterTime;
+    this.topology.clusterTime = clusterTime;
   }
 
   get description(): ServerDescription {
@@ -215,7 +216,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   }
 
   get loadBalanced(): boolean {
-    return this.s.topology.description.type === TopologyType.LoadBalanced;
+    return this.topology.description.type === TopologyType.LoadBalanced;
   }
 
   /**
@@ -261,7 +262,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       this[kMonitor]?.close();
     }
 
-    this.s.pool.close(options, err => {
+    this.pool.close(options, err => {
       stateTransition(this, STATE_CLOSED);
       this.emit('closed');
       if (typeof callback === 'function') {
@@ -330,7 +331,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     //       balanced code makes a recursive call).  Instead, we increment the count after this
     //       check.
     if (this.loadBalanced && session && conn == null && isPinnableCommand(cmd, session)) {
-      this.s.pool.checkOut((err, checkedOut) => {
+      this.pool.checkOut((err, checkedOut) => {
         if (err || checkedOut == null) {
           if (callback) return callback(err);
           return;
@@ -342,13 +343,13 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       return;
     }
 
-    this.s.operationCount += 1;
+    this.incrementOperationCount();
 
-    this.s.pool.withConnection(
+    this.pool.withConnection(
       conn,
       (err, conn, cb) => {
         if (err || !conn) {
-          this.s.operationCount -= 1;
+          this.decrementOperationCount();
           if (!err) {
             return cb(new MongoRuntimeError('Failed to create connection without error'));
           }
@@ -363,7 +364,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
           cmd,
           finalOptions,
           makeOperationHandler(this, conn, cmd, finalOptions, (error, response) => {
-            this.s.operationCount -= 1;
+            this.decrementOperationCount();
             cb(error, response);
           })
         );
@@ -382,7 +383,7 @@ export class Server extends TypedEventEmitter<ServerEvents> {
     }
 
     const isStaleError =
-      error.connectionGeneration && error.connectionGeneration < this.s.pool.generation;
+      error.connectionGeneration && error.connectionGeneration < this.pool.generation;
     if (isStaleError) {
       return;
     }
@@ -398,14 +399,14 @@ export class Server extends TypedEventEmitter<ServerEvents> {
         error.addErrorLabel(MongoErrorLabel.ResetPool);
         markServerUnknown(this, error);
       } else if (connection) {
-        this.s.pool.clear({ serviceId: connection.serviceId });
+        this.pool.clear({ serviceId: connection.serviceId });
       }
     } else {
       if (isSDAMUnrecoverableError(error)) {
         if (shouldHandleStateChangeError(this, error)) {
           const shouldClearPool = maxWireVersion(this) <= 7 || isNodeShuttingDownError(error);
           if (this.loadBalanced && connection && shouldClearPool) {
-            this.s.pool.clear({ serviceId: connection.serviceId });
+            this.pool.clear({ serviceId: connection.serviceId });
           }
 
           if (!this.loadBalanced) {
@@ -419,6 +420,20 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       }
     }
   }
+
+  /**
+   * Decrement the operation count, returning the new count.
+   */
+  private decrementOperationCount(): number {
+    return (this.s.operationCount -= 1);
+  }
+
+  /**
+   * Increment the operation count, returning the new count.
+   */
+  private incrementOperationCount(): number {
+    return (this.s.operationCount += 1);
+  }
 }
 
 function calculateRoundTripTime(oldRtt: number, duration: number): number {
@@ -514,7 +529,7 @@ function makeOperationHandler(
       return callback(error);
     }
 
-    if (connectionIsStale(server.s.pool, connection)) {
+    if (connectionIsStale(server.pool, connection)) {
       return callback(error);
     }
 
@@ -532,7 +547,7 @@ function makeOperationHandler(
       }
 
       if (
-        (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
+        (isRetryableWritesEnabled(server.topology) || isTransactionCommand(cmd)) &&
         supportsRetryableWrites(server) &&
         !inActiveTransaction(session, cmd)
       ) {
@@ -540,7 +555,7 @@ function makeOperationHandler(
       }
     } else {
       if (
-        (isRetryableWritesEnabled(server.s.topology) || isTransactionCommand(cmd)) &&
+        (isRetryableWritesEnabled(server.topology) || isTransactionCommand(cmd)) &&
         needsRetryableWriteLabel(error, maxWireVersion(server)) &&
         !inActiveTransaction(session, cmd)
       ) {

package/src/sdam/topology.ts

@@ -227,9 +227,14 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
   /**
    * @param seedlist - a list of HostAddress instances to connect to
    */
-  constructor(seeds: string | string[] | HostAddress | HostAddress[], options: TopologyOptions) {
+  constructor(
+    client: MongoClient,
+    seeds: string | string[] | HostAddress | HostAddress[],
+    options: TopologyOptions
+  ) {
     super();
 
+    this.client = client;
     this.selectServerAsync = promisify(
       (
         selector: string | ReadPreference | ServerSelector,
@@ -787,7 +792,7 @@ function updateServers(topology: Topology, incomingServerDescription?: ServerDes
           MongoErrorLabel.InterruptInUseConnections
         );
 
-        server.s.pool.clear({ interruptInUseConnections });
+        server.pool.clear({ interruptInUseConnections });
       } else if (incomingServerDescription.error == null) {
         const newTopologyType = topology.s.description.type;
         const shouldMarkPoolReady =
@@ -795,7 +800,7 @@ function updateServers(topology: Topology, incomingServerDescription?: ServerDes
           (incomingServerDescription.type !== ServerType.Unknown &&
             newTopologyType === TopologyType.Single);
         if (shouldMarkPoolReady) {
-          server.s.pool.ready();
+          server.pool.ready();
         }
       }
     }

package/src/sessions.ts

@@ -505,7 +505,7 @@ export function maybeClearPinnedConnection(
     const loadBalancer = servers[0];
 
     if (options?.error == null || options?.force) {
-      loadBalancer.s.pool.checkIn(conn);
+      loadBalancer.pool.checkIn(conn);
       conn.emit(
         UNPINNED,
         session.transaction.state !== TxnState.NO_TRANSACTION
@@ -514,7 +514,7 @@ export function maybeClearPinnedConnection(
       );
 
       if (options?.forceClear) {
-        loadBalancer.s.pool.clear({ serviceId: conn.serviceId });
+        loadBalancer.pool.clear({ serviceId: conn.serviceId });
       }
     }
 

package/src/utils.ts

@@ -288,10 +288,8 @@ export function getTopology(provider: TopologyProvider): Topology {
   // MongoClient or ClientSession or AbstractCursor
   if ('topology' in provider && provider.topology) {
     return provider.topology;
-  } else if ('s' in provider && 'client' in provider.s && provider.s.client.topology) {
-    return provider.s.client.topology;
-  } else if ('s' in provider && 'db' in provider.s && provider.s.db.s.client.topology) {
-    return provider.s.db.s.client.topology;
+  } else if ('client' in provider && provider.client.topology) {
+    return provider.client.topology;
   }
 
   throw new MongoNotConnectedError('MongoClient must be connected to perform this operation');
@@ -304,16 +302,13 @@ export function ns(ns: string): MongoDBNamespace {
 
 /** @public */
 export class MongoDBNamespace {
-  db: string;
-  collection: string | undefined;
   /**
    * Create a namespace object
    *
    * @param db - database name
    * @param collection - collection name
    */
-  constructor(db: string, collection?: string) {
-    this.db = db;
+  constructor(public db: string, public collection?: string) {
     this.collection = collection === '' ? undefined : collection;
   }
 
@@ -321,8 +316,8 @@ export class MongoDBNamespace {
     return this.collection ? `${this.db}.${this.collection}` : this.db;
   }
 
-  withCollection(collection: string): MongoDBNamespace {
-    return new MongoDBNamespace(this.db, collection);
+  withCollection(collection: string): MongoDBCollectionNamespace {
+    return new MongoDBCollectionNamespace(this.db, collection);
   }
 
   static fromString(namespace?: string): MongoDBNamespace {
@@ -337,6 +332,19 @@ export class MongoDBNamespace {
   }
 }
 
+/**
+ * @public
+ *
+ * A class representing a collection's namespace.  This class enforces (through Typescript) that
+ * the `collection` portion of the namespace is defined and should only be
+ * used in scenarios where this can be guaranteed.
+ */
+export class MongoDBCollectionNamespace extends MongoDBNamespace {
+  constructor(db: string, override collection: string) {
+    super(db, collection);
+  }
+}
+
 /** @internal */
 export function* makeCounter(seed = 0): Generator<number> {
   let count = seed;