@depup/mongodb 7.1.0-depup.0

package/src/operations/list_databases.ts

@@ -0,0 +1,68 @@
+import { type Connection } from '..';
+import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import type { Db } from '../db';
+import type { ClientSession } from '../sessions';
+import { maxWireVersion, MongoDBNamespace } from '../utils';
+import { CommandOperation, type CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
+
+/** @public */
+export interface ListDatabasesResult {
+  databases: ({ name: string; sizeOnDisk?: number; empty?: boolean } & Document)[];
+  totalSize?: number;
+  totalSizeMb?: number;
+  ok: 1 | 0;
+}
+
+/** @public */
+export interface ListDatabasesOptions extends Omit<CommandOperationOptions, 'rawData'> {
+  /** A query predicate that determines which databases are listed */
+  filter?: Document;
+  /** A flag to indicate whether the command should return just the database names, or return both database names and size information */
+  nameOnly?: boolean;
+  /** A flag that determines which databases are returned based on the user privileges when access control is enabled */
+  authorizedDatabases?: boolean;
+}
+
+/** @internal */
+export class ListDatabasesOperation extends CommandOperation<ListDatabasesResult> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  override options: ListDatabasesOptions;
+
+  constructor(db: Db, options?: ListDatabasesOptions) {
+    super(db, options);
+    this.options = options ?? {};
+    this.ns = new MongoDBNamespace('admin', '$cmd');
+  }
+
+  override get commandName() {
+    return 'listDatabases' as const;
+  }
+
+  override buildCommandDocument(connection: Connection, _session?: ClientSession): Document {
+    const cmd: Document = { listDatabases: 1 };
+
+    if (typeof this.options.nameOnly === 'boolean') {
+      cmd.nameOnly = this.options.nameOnly;
+    }
+
+    if (this.options.filter) {
+      cmd.filter = this.options.filter;
+    }
+
+    if (typeof this.options.authorizedDatabases === 'boolean') {
+      cmd.authorizedDatabases = this.options.authorizedDatabases;
+    }
+
+    // we check for undefined specifically here to allow falsy values
+    // eslint-disable-next-line no-restricted-syntax
+    if (maxWireVersion(connection) >= 9 && this.options.comment !== undefined) {
+      cmd.comment = this.options.comment;
+    }
+
+    return cmd;
+  }
+}
+
+defineAspects(ListDatabasesOperation, [Aspect.READ_OPERATION, Aspect.RETRYABLE]);

package/src/operations/operation.ts

@@ -0,0 +1,181 @@
+import { type Connection, type MongoError } from '..';
+import { type BSONSerializeOptions, type Document, resolveBSONOptions } from '../bson';
+import { type MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { type Abortable } from '../mongo_types';
+import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
+import type { Server, ServerCommandOptions } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
+import type { MongoDBNamespace } from '../utils';
+
+export const Aspect = {
+  READ_OPERATION: Symbol('READ_OPERATION'),
+  WRITE_OPERATION: Symbol('WRITE_OPERATION'),
+  RETRYABLE: Symbol('RETRYABLE'),
+  EXPLAINABLE: Symbol('EXPLAINABLE'),
+  SKIP_COLLATION: Symbol('SKIP_COLLATION'),
+  CURSOR_CREATING: Symbol('CURSOR_CREATING'),
+  MUST_SELECT_SAME_SERVER: Symbol('MUST_SELECT_SAME_SERVER'),
+  COMMAND_BATCHING: Symbol('COMMAND_BATCHING'),
+  SUPPORTS_RAW_DATA: Symbol('SUPPORTS_RAW_DATA')
+} as const;
+
+/** @public */
+export type Hint = string | Document;
+
+/** @public */
+export interface OperationOptions extends BSONSerializeOptions {
+  /** Specify ClientSession for this command */
+  session?: ClientSession;
+  willRetryWrite?: boolean;
+
+  /** The preferred read preference (ReadPreference.primary, ReadPreference.primary_preferred, ReadPreference.secondary, ReadPreference.secondary_preferred, ReadPreference.nearest). */
+  readPreference?: ReadPreferenceLike;
+
+  /** @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction */
+  bypassPinningCheck?: boolean;
+
+  /** @internal Hint to `executeOperation` to omit maxTimeMS */
+  omitMaxTimeMS?: boolean;
+
+  /**
+   * @experimental
+   * Specifies the time an operation will run until it throws a timeout error
+   */
+  timeoutMS?: number;
+}
+
+/**
+ * This class acts as a parent class for any operation and is responsible for setting this.options,
+ * as well as setting and getting a session.
+ * Additionally, this class implements `hasAspect`, which determines whether an operation has
+ * a specific aspect.
+ * @internal
+ */
+export abstract class AbstractOperation<TResult = any> {
+  ns!: MongoDBNamespace;
+  readPreference: ReadPreference;
+  server!: Server;
+  bypassPinningCheck: boolean;
+
+  // BSON serialization options
+  bsonOptions?: BSONSerializeOptions;
+
+  options: OperationOptions & Abortable;
+
+  /** Specifies the time an operation will run until it throws a timeout error. */
+  timeoutMS?: number;
+
+  private _session: ClientSession | undefined;
+
+  static aspects?: Set<symbol>;
+
+  constructor(options: OperationOptions & Abortable = {}) {
+    this.readPreference = this.hasAspect(Aspect.WRITE_OPERATION)
+      ? ReadPreference.primary
+      : (ReadPreference.fromOptions(options) ?? ReadPreference.primary);
+
+    // Pull the BSON serialize options from the already-resolved options
+    this.bsonOptions = resolveBSONOptions(options);
+
+    this._session = options.session != null ? options.session : undefined;
+
+    this.options = options;
+    this.bypassPinningCheck = !!options.bypassPinningCheck;
+  }
+
+  /** Must match the first key of the command object sent to the server.
+  Command name should be stateless (should not use 'this' keyword) */
+  abstract get commandName(): string;
+
+  hasAspect(aspect: symbol): boolean {
+    const ctor = this.constructor as { aspects?: Set<symbol> };
+    if (ctor.aspects == null) {
+      return false;
+    }
+
+    return ctor.aspects.has(aspect);
+  }
+
+  // Make sure the session is not writable from outside this class.
+  get session(): ClientSession | undefined {
+    return this._session;
+  }
+
+  set session(session: ClientSession) {
+    this._session = session;
+  }
+
+  clearSession() {
+    this._session = undefined;
+  }
+
+  resetBatch(): boolean {
+    return true;
+  }
+
+  get canRetryRead(): boolean {
+    return this.hasAspect(Aspect.RETRYABLE) && this.hasAspect(Aspect.READ_OPERATION);
+  }
+
+  get canRetryWrite(): boolean {
+    return this.hasAspect(Aspect.RETRYABLE) && this.hasAspect(Aspect.WRITE_OPERATION);
+  }
+  abstract SERVER_COMMAND_RESPONSE_TYPE: typeof MongoDBResponse;
+
+  /**
+   * Build a raw command document.
+   */
+  abstract buildCommand(connection: Connection, session?: ClientSession): Document;
+
+  /**
+   * Builds an instance of `ServerCommandOptions` to be used for operation execution.
+   */
+  abstract buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions;
+
+  /**
+   * Given an instance of a MongoDBResponse, map the response to the correct result type.  For
+   * example, a `CountOperation` might map the response as follows:
+   *
+   * ```typescript
+   *  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+   *    return response.toObject(this.bsonOptions).n ?? 0;
+   *  }
+   *
+   *  // or, with type safety:
+   *  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+   *    return response.getNumber('n') ?? 0;
+   *  }
+   * ```
+   */
+  handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): TResult {
+    return response.toObject(this.bsonOptions) as TResult;
+  }
+
+  /**
+   * Optional.
+   *
+   * If the operation performs error handling, such as wrapping, renaming the error, or squashing errors
+   * this method can be overridden.
+   */
+  handleError(error: MongoError): TResult | never {
+    throw error;
+  }
+}
+
+export function defineAspects(
+  operation: { aspects?: Set<symbol> },
+  aspects: symbol | symbol[] | Set<symbol>
+): Set<symbol> {
+  if (!Array.isArray(aspects) && !(aspects instanceof Set)) {
+    aspects = [aspects];
+  }
+
+  aspects = new Set(aspects);
+  Object.defineProperty(operation, 'aspects', {
+    value: aspects,
+    writable: false
+  });
+
+  return aspects;
+}

package/src/operations/profiling_level.ts

@@ -0,0 +1,46 @@
+import { BSONType, type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import type { Db } from '../db';
+import { MongoUnexpectedServerResponseError } from '../error';
+import { CommandOperation, type CommandOperationOptions } from './command';
+
+/** @public */
+export type ProfilingLevelOptions = Omit<CommandOperationOptions, 'rawData'>;
+
+class ProfilingLevelResponse extends MongoDBResponse {
+  get was() {
+    return this.get('was', BSONType.int, true);
+  }
+}
+
+/** @internal */
+export class ProfilingLevelOperation extends CommandOperation<string> {
+  override SERVER_COMMAND_RESPONSE_TYPE = ProfilingLevelResponse;
+  override options: ProfilingLevelOptions;
+
+  constructor(db: Db, options: ProfilingLevelOptions) {
+    super(db, options);
+    this.options = options;
+  }
+
+  override get commandName() {
+    return 'profile' as const;
+  }
+
+  override buildCommandDocument(_connection: Connection): Document {
+    return { profile: -1 };
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string {
+    if (response.ok === 1) {
+      const was = response.was;
+      if (was === 0) return 'off';
+      if (was === 1) return 'slow_only';
+      if (was === 2) return 'all';
+      throw new MongoUnexpectedServerResponseError(`Illegal profiling level value ${was}`);
+    } else {
+      throw new MongoUnexpectedServerResponseError('Error with profile command');
+    }
+  }
+}

package/src/operations/remove_user.ts

@@ -0,0 +1,36 @@
+import { type Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import type { Db } from '../db';
+import { CommandOperation, type CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
+
+/** @public */
+export type RemoveUserOptions = Omit<CommandOperationOptions, 'rawData'>;
+
+/** @internal */
+export class RemoveUserOperation extends CommandOperation<boolean> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  override options: RemoveUserOptions;
+  username: string;
+
+  constructor(db: Db, username: string, options: RemoveUserOptions) {
+    super(db, options);
+    this.options = options;
+    this.username = username;
+  }
+
+  override get commandName() {
+    return 'dropUser' as const;
+  }
+
+  override buildCommandDocument(_connection: Connection): Document {
+    return { dropUser: this.username };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): boolean {
+    return true;
+  }
+}
+
+defineAspects(RemoveUserOperation, [Aspect.WRITE_OPERATION]);

package/src/operations/rename.ts

@@ -0,0 +1,60 @@
+import { type Connection } from '..';
+import type { Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { Collection } from '../collection';
+import type { ClientSession } from '../sessions';
+import { MongoDBNamespace } from '../utils';
+import { CommandOperation, type CommandOperationOptions } from './command';
+import { Aspect, defineAspects } from './operation';
+
+/** @public */
+export interface RenameOptions extends Omit<CommandOperationOptions, 'rawData'> {
+  /** Drop the target name collection if it previously exists. */
+  dropTarget?: boolean;
+  /**
+   * @deprecated
+   *
+   * This option has been dead code since at least Node driver version 4.x. It will
+   * be removed in a future major release.
+   */
+  new_collection?: boolean;
+}
+
+/** @internal */
+export class RenameOperation extends CommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  collection: Collection;
+  newName: string;
+  override options: RenameOptions;
+
+  constructor(collection: Collection, newName: string, options: RenameOptions) {
+    super(collection, options);
+    this.collection = collection;
+    this.newName = newName;
+    this.options = options;
+    this.ns = new MongoDBNamespace('admin', '$cmd');
+  }
+
+  override get commandName(): string {
+    return 'renameCollection' as const;
+  }
+
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    const renameCollection = this.collection.namespace;
+    const to = this.collection.s.namespace.withCollection(this.newName).toString();
+    const dropTarget =
+      typeof this.options.dropTarget === 'boolean' ? this.options.dropTarget : false;
+
+    return {
+      renameCollection,
+      to,
+      dropTarget
+    };
+  }
+
+  override handleOk(_response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    return new Collection(this.collection.db, this.newName, this.collection.s.options);
+  }
+}
+
+defineAspects(RenameOperation, [Aspect.WRITE_OPERATION]);

package/src/operations/run_command.ts

@@ -0,0 +1,79 @@
+import { type Abortable } from '..';
+import type { BSONSerializeOptions, Document } from '../bson';
+import { type Connection } from '../cmap/connection';
+import { CursorResponse, MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { AbstractOperation } from '../operations/operation';
+import type { ReadPreferenceLike } from '../read_preference';
+import type { ServerCommandOptions } from '../sdam/server';
+import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
+import { type MongoDBNamespace } from '../utils';
+
+/** @public */
+export type RunCommandOptions = {
+  /** Specify ClientSession for this command */
+  session?: ClientSession;
+  /** The read preference */
+  readPreference?: ReadPreferenceLike;
+  /**
+   * @experimental
+   * Specifies the time an operation will run until it throws a timeout error
+   */
+  timeoutMS?: number;
+  /** @internal */
+  omitMaxTimeMS?: boolean;
+
+  /**
+   * @internal Hints to `executeOperation` that this operation should not unpin on an ended transaction
+   * This is only used by the driver for transaction commands
+   */
+  bypassPinningCheck?: boolean;
+} & BSONSerializeOptions &
+  Abortable;
+
+/** @internal */
+export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  command: Document;
+  override options: RunCommandOptions;
+
+  constructor(namespace: MongoDBNamespace, command: Document, options: RunCommandOptions) {
+    super(options);
+    this.command = command;
+    this.options = options;
+    this.ns = namespace.withCollection('$cmd');
+  }
+
+  override get commandName() {
+    return 'runCommand' as const;
+  }
+
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+    return this.command;
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      ...this.options,
+      session: this.session,
+      timeoutContext,
+      signal: this.options.signal,
+      readPreference: this.options.readPreference
+    };
+  }
+}
+
+/**
+ * @internal
+ *
+ * A specialized subclass of RunCommandOperation for cursor-creating commands.
+ */
+export class RunCursorCommandOperation extends RunCommandOperation {
+  override SERVER_COMMAND_RESPONSE_TYPE = CursorResponse;
+
+  override handleOk(
+    response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>
+  ): CursorResponse {
+    return response;
+  }
+}

package/src/operations/search_indexes/create.ts

@@ -0,0 +1,56 @@
+import { type Document } from '../../bson';
+import { type Connection } from '../../cmap/connection';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
+import type { Collection } from '../../collection';
+import type { ServerCommandOptions } from '../../sdam/server';
+import type { ClientSession } from '../../sessions';
+import { type TimeoutContext } from '../../timeout';
+import { AbstractOperation } from '../operation';
+
+/**
+ * @public
+ */
+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 */
+export class CreateSearchIndexesOperation extends AbstractOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  private readonly collection: Collection;
+  private readonly descriptions: ReadonlyArray<SearchIndexDescription>;
+
+  constructor(collection: Collection, descriptions: ReadonlyArray<SearchIndexDescription>) {
+    super();
+    this.collection = collection;
+    this.descriptions = descriptions;
+    this.ns = collection.fullNamespace;
+  }
+
+  override get commandName() {
+    return 'createSearchIndexes' as const;
+  }
+
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+    const namespace = this.collection.fullNamespace;
+    return {
+      createSearchIndexes: namespace.collection,
+      indexes: this.descriptions
+    };
+  }
+
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): string[] {
+    return super.handleOk(response).indexesCreated.map((val: { name: string }) => val.name);
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
+  }
+}

package/src/operations/search_indexes/drop.ts

@@ -0,0 +1,58 @@
+import { type Connection, type MongoError } from '../..';
+import type { Document } from '../../bson';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
+import type { Collection } from '../../collection';
+import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
+import type { ServerCommandOptions } from '../../sdam/server';
+import type { ClientSession } from '../../sessions';
+import { type TimeoutContext } from '../../timeout';
+import { AbstractOperation } from '../operation';
+
+/** @internal */
+export class DropSearchIndexOperation extends AbstractOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+
+  private readonly collection: Collection;
+  private readonly name: string;
+
+  constructor(collection: Collection, name: string) {
+    super();
+    this.collection = collection;
+    this.name = name;
+    this.ns = collection.fullNamespace;
+  }
+
+  override get commandName() {
+    return 'dropSearchIndex' as const;
+  }
+
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+    const namespace = this.collection.fullNamespace;
+
+    const command: Document = {
+      dropSearchIndex: namespace.collection
+    };
+
+    if (typeof this.name === 'string') {
+      command.name = this.name;
+    }
+
+    return command;
+  }
+
+  override handleOk(_response: MongoDBResponse): void {
+    // do nothing
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
+  }
+
+  override handleError(error: MongoError): void {
+    const isNamespaceNotFoundError =
+      error instanceof MongoServerError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound;
+    if (!isNamespaceNotFoundError) {
+      throw error;
+    }
+  }
+}

package/src/operations/search_indexes/update.ts

@@ -0,0 +1,45 @@
+import type { Document } from '../../bson';
+import { type Connection } from '../../cmap/connection';
+import { MongoDBResponse } from '../../cmap/wire_protocol/responses';
+import type { Collection } from '../../collection';
+import type { ServerCommandOptions } from '../../sdam/server';
+import type { ClientSession } from '../../sessions';
+import { type TimeoutContext } from '../../timeout';
+import { AbstractOperation } from '../operation';
+
+/** @internal */
+export class UpdateSearchIndexOperation extends AbstractOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
+  private readonly collection: Collection;
+  private readonly name: string;
+  private readonly definition: Document;
+
+  constructor(collection: Collection, name: string, definition: Document) {
+    super();
+    this.collection = collection;
+    this.name = name;
+    this.definition = definition;
+    this.ns = collection.fullNamespace;
+  }
+
+  override get commandName() {
+    return 'updateSearchIndex' as const;
+  }
+
+  override buildCommand(_connection: Connection, _session?: ClientSession): Document {
+    const namespace = this.collection.fullNamespace;
+    return {
+      updateSearchIndex: namespace.collection,
+      name: this.name,
+      definition: this.definition
+    };
+  }
+
+  override handleOk(_response: MongoDBResponse): void {
+    // no response.
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return { session: this.session, timeoutContext };
+  }
+}