mongodb 6.8.0-dev.20240822.sha.f5254030 → 6.8.0-dev.20240829.sha.6d65ae77

package/src/mongo_types.ts

@@ -34,11 +34,11 @@ export type InferIdType<TSchema> = TSchema extends { _id: infer IdType }
     ? never // explicitly forbid empty objects as the type of _id
     : IdType
   : TSchema extends { _id?: infer IdType }
-  ? // optional _id defined - return ObjectId | IdType
-    unknown extends IdType
-    ? ObjectId // infer the _id type as ObjectId if the type of _id is unknown
-    : IdType
-  : ObjectId; // user has not defined _id on schema
+    ? // optional _id defined - return ObjectId | IdType
+      unknown extends IdType
+      ? ObjectId // infer the _id type as ObjectId if the type of _id is unknown
+      : IdType
+    : ObjectId; // user has not defined _id on schema
 
 /** Add an _id field to an object shaped type @public */
 export type WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & { _id: InferIdType<TSchema> };
@@ -68,8 +68,8 @@ export type OptionalUnlessRequiredId<TSchema> = TSchema extends { _id: any }
 export type EnhancedOmit<TRecordOrUnion, KeyUnion> = string extends keyof TRecordOrUnion
   ? TRecordOrUnion // TRecordOrUnion has indexed type e.g. { _id: string; [k: string]: any; } or it is "any"
   : TRecordOrUnion extends any
-  ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> // discriminated unions
-  : never;
+    ? Pick<TRecordOrUnion, Exclude<keyof TRecordOrUnion, KeyUnion>> // discriminated unions
+    : never;
 
 /** Remove the _id field from an object shaped type @public */
 export type WithoutId<TSchema> = Omit<TSchema, '_id'>;
@@ -88,9 +88,8 @@ export type Condition<T> = AlternativeType<T> | FilterOperators<AlternativeType<
  * array types can be searched using their element type
  * @public
  */
-export type AlternativeType<T> = T extends ReadonlyArray<infer U>
-  ? T | RegExpOrString<U>
-  : RegExpOrString<T>;
+export type AlternativeType<T> =
+  T extends ReadonlyArray<infer U> ? T | RegExpOrString<U> : RegExpOrString<T>;
 
 /** @public */
 export type RegExpOrString<T> = T extends string ? BSONRegExp | RegExp | T : T;
@@ -192,9 +191,10 @@ export type IntegerType = number | Int32 | Long | bigint;
 export type NumericType = IntegerType | Decimal128 | Double;
 
 /** @public */
-export type FilterOperations<T> = T extends Record<string, any>
-  ? { [key in keyof T]?: FilterOperators<T[key]> }
-  : FilterOperators<T>;
+export type FilterOperations<T> =
+  T extends Record<string, any>
+    ? { [key in keyof T]?: FilterOperators<T[key]> }
+    : FilterOperators<T>;
 
 /** @public */
 export type KeysOfAType<TSchema, Type> = {
@@ -412,6 +412,7 @@ export declare interface TypedEventEmitter<Events extends EventsDescription> ext
  * @public
  */
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class TypedEventEmitter<Events extends EventsDescription> extends EventEmitter {
   /** @internal */
   protected mongoLogger?: MongoLogger;
@@ -480,31 +481,31 @@ export class CancellationToken extends TypedEventEmitter<{ cancel(): void }> {}
 export type Join<T extends unknown[], D extends string> = T extends []
   ? ''
   : T extends [string | number]
-  ? `${T[0]}`
-  : T extends [string | number, ...infer R]
-  ? `${T[0]}${D}${Join<R, D>}`
-  : string;
+    ? `${T[0]}`
+    : T extends [string | number, ...infer R]
+      ? `${T[0]}${D}${Join<R, D>}`
+      : string;
 
 /** @public */
 export type PropertyType<Type, Property extends string> = string extends Property
   ? unknown
   : Property extends keyof Type
-  ? Type[Property]
-  : Property extends `${number}`
-  ? Type extends ReadonlyArray<infer ArrayType>
-    ? ArrayType
-    : unknown
-  : Property extends `${infer Key}.${infer Rest}`
-  ? Key extends `${number}`
-    ? Type extends ReadonlyArray<infer ArrayType>
-      ? PropertyType<ArrayType, Rest>
-      : unknown
-    : Key extends keyof Type
-    ? Type[Key] extends Map<string, infer MapType>
-      ? MapType
-      : PropertyType<Type[Key], Rest>
-    : unknown
-  : unknown;
+    ? Type[Property]
+    : Property extends `${number}`
+      ? Type extends ReadonlyArray<infer ArrayType>
+        ? ArrayType
+        : unknown
+      : Property extends `${infer Key}.${infer Rest}`
+        ? Key extends `${number}`
+          ? Type extends ReadonlyArray<infer ArrayType>
+            ? PropertyType<ArrayType, Rest>
+            : unknown
+          : Key extends keyof Type
+            ? Type[Key] extends Map<string, infer MapType>
+              ? MapType
+              : PropertyType<Type[Key], Rest>
+            : unknown
+        : unknown;
 
 /**
  * @public
@@ -521,41 +522,41 @@ export type PropertyType<Type, Property extends string> = string extends Propert
 export type NestedPaths<Type, Depth extends number[]> = Depth['length'] extends 8
   ? []
   : Type extends
-      | string
-      | number
-      | bigint
-      | boolean
-      | Date
-      | RegExp
-      | Buffer
-      | Uint8Array
-      | ((...args: any[]) => any)
-      | { _bsontype: string }
-  ? []
-  : Type extends ReadonlyArray<infer ArrayType>
-  ? [] | [number, ...NestedPaths<ArrayType, [...Depth, 1]>]
-  : Type extends Map<string, any>
-  ? [string]
-  : Type extends object
-  ? {
-      [Key in Extract<keyof Type, string>]: Type[Key] extends Type // type of value extends the parent
-        ? [Key]
-        : // for a recursive union type, the child will never extend the parent type.
-        // but the parent will still extend the child
-        Type extends Type[Key]
-        ? [Key]
-        : Type[Key] extends ReadonlyArray<infer ArrayType> // handling recursive types with arrays
-        ? Type extends ArrayType // is the type of the parent the same as the type of the array?
-          ? [Key] // yes, it's a recursive array type
-          : // for unions, the child type extends the parent
-          ArrayType extends Type
-          ? [Key] // we have a recursive array union
-          : // child is an array, but it's not a recursive array
-            [Key, ...NestedPaths<Type[Key], [...Depth, 1]>]
-        : // child is not structured the same as the parent
-          [Key, ...NestedPaths<Type[Key], [...Depth, 1]>] | [Key];
-    }[Extract<keyof Type, string>]
-  : [];
+        | string
+        | number
+        | bigint
+        | boolean
+        | Date
+        | RegExp
+        | Buffer
+        | Uint8Array
+        | ((...args: any[]) => any)
+        | { _bsontype: string }
+    ? []
+    : Type extends ReadonlyArray<infer ArrayType>
+      ? [] | [number, ...NestedPaths<ArrayType, [...Depth, 1]>]
+      : Type extends Map<string, any>
+        ? [string]
+        : Type extends object
+          ? {
+              [Key in Extract<keyof Type, string>]: Type[Key] extends Type // type of value extends the parent
+                ? [Key]
+                : // for a recursive union type, the child will never extend the parent type.
+                  // but the parent will still extend the child
+                  Type extends Type[Key]
+                  ? [Key]
+                  : Type[Key] extends ReadonlyArray<infer ArrayType> // handling recursive types with arrays
+                    ? Type extends ArrayType // is the type of the parent the same as the type of the array?
+                      ? [Key] // yes, it's a recursive array type
+                      : // for unions, the child type extends the parent
+                        ArrayType extends Type
+                        ? [Key] // we have a recursive array union
+                        : // child is an array, but it's not a recursive array
+                          [Key, ...NestedPaths<Type[Key], [...Depth, 1]>]
+                    : // child is not structured the same as the parent
+                      [Key, ...NestedPaths<Type[Key], [...Depth, 1]>] | [Key];
+            }[Extract<keyof Type, string>]
+          : [];
 
 /**
  * @public

package/src/operations/aggregate.ts

@@ -9,8 +9,9 @@ import { type CollationOptions, CommandOperation, type CommandOperationOptions }
 import { Aspect, defineAspects, type Hint } from './operation';
 
 /** @internal */
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
 export const DB_AGGREGATE_COLLECTION = 1 as const;
-const MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT = 8 as const;
+const MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT = 8;
 
 /** @public */
 export interface AggregateOptions extends CommandOperationOptions {

package/src/operations/client_bulk_write/command_builder.ts

@@ -0,0 +1,283 @@
+import { type Document } from '../../bson';
+import { DocumentSequence } from '../../cmap/commands';
+import type { Filter, OptionalId, UpdateFilter, WithoutId } from '../../mongo_types';
+import { type CollationOptions } from '../command';
+import { type Hint } from '../operation';
+import type {
+  AnyClientBulkWriteModel,
+  ClientBulkWriteOptions,
+  ClientDeleteManyModel,
+  ClientDeleteOneModel,
+  ClientInsertOneModel,
+  ClientReplaceOneModel,
+  ClientUpdateManyModel,
+  ClientUpdateOneModel
+} from './common';
+
+/** @internal */
+export interface ClientBulkWriteCommand {
+  bulkWrite: 1;
+  errorsOnly: boolean;
+  ordered: boolean;
+  ops: DocumentSequence;
+  nsInfo: DocumentSequence;
+  bypassDocumentValidation?: boolean;
+  let?: Document;
+}
+
+/** @internal */
+export class ClientBulkWriteCommandBuilder {
+  models: AnyClientBulkWriteModel[];
+  options: ClientBulkWriteOptions;
+
+  /**
+   * Create the command builder.
+   * @param models - The client write models.
+   */
+  constructor(models: AnyClientBulkWriteModel[], options: ClientBulkWriteOptions) {
+    this.models = models;
+    this.options = options;
+  }
+
+  /**
+   * Gets the errorsOnly value for the command, which is the inverse of the
+   * user provided verboseResults option. Defaults to true.
+   */
+  get errorsOnly(): boolean {
+    if ('verboseResults' in this.options) {
+      return !this.options.verboseResults;
+    }
+    return true;
+  }
+
+  /**
+   * Build the bulk write commands from the models.
+   */
+  buildCommands(): ClientBulkWriteCommand[] {
+    // Iterate the models to build the ops and nsInfo fields.
+    const operations = [];
+    let currentNamespaceIndex = 0;
+    const namespaces = new Map<string, number>();
+    for (const model of this.models) {
+      const ns = model.namespace;
+      const index = namespaces.get(ns);
+      if (index != null) {
+        operations.push(buildOperation(model, index));
+      } else {
+        namespaces.set(ns, currentNamespaceIndex);
+        operations.push(buildOperation(model, currentNamespaceIndex));
+        currentNamespaceIndex++;
+      }
+    }
+
+    const nsInfo = Array.from(namespaces.keys(), ns => ({ ns }));
+
+    // The base command.
+    const command: ClientBulkWriteCommand = {
+      bulkWrite: 1,
+      errorsOnly: this.errorsOnly,
+      ordered: this.options.ordered ?? true,
+      ops: new DocumentSequence(operations),
+      nsInfo: new DocumentSequence(nsInfo)
+    };
+    // Add bypassDocumentValidation if it was present in the options.
+    if (this.options.bypassDocumentValidation != null) {
+      command.bypassDocumentValidation = this.options.bypassDocumentValidation;
+    }
+    // Add let if it was present in the options.
+    if (this.options.let) {
+      command.let = this.options.let;
+    }
+    return [command];
+  }
+}
+
+/** @internal */
+interface ClientInsertOperation {
+  insert: number;
+  document: OptionalId<Document>;
+}
+
+/**
+ * Build the insert one operation.
+ * @param model - The insert one model.
+ * @param index - The namespace index.
+ * @returns the operation.
+ */
+export const buildInsertOneOperation = (
+  model: ClientInsertOneModel,
+  index: number
+): ClientInsertOperation => {
+  const document: ClientInsertOperation = {
+    insert: index,
+    document: model.document
+  };
+  return document;
+};
+
+/** @internal */
+export interface ClientDeleteOperation {
+  delete: number;
+  multi: boolean;
+  filter: Filter<Document>;
+  hint?: Hint;
+  collation?: CollationOptions;
+}
+
+/**
+ * Build the delete one operation.
+ * @param model - The insert many model.
+ * @param index - The namespace index.
+ * @returns the operation.
+ */
+export const buildDeleteOneOperation = (model: ClientDeleteOneModel, index: number): Document => {
+  return createDeleteOperation(model, index, false);
+};
+
+/**
+ * Build the delete many operation.
+ * @param model - The delete many model.
+ * @param index - The namespace index.
+ * @returns the operation.
+ */
+export const buildDeleteManyOperation = (model: ClientDeleteManyModel, index: number): Document => {
+  return createDeleteOperation(model, index, true);
+};
+
+/**
+ * Creates a delete operation based on the parameters.
+ */
+function createDeleteOperation(
+  model: ClientDeleteOneModel | ClientDeleteManyModel,
+  index: number,
+  multi: boolean
+): ClientDeleteOperation {
+  const document: ClientDeleteOperation = {
+    delete: index,
+    multi: multi,
+    filter: model.filter
+  };
+  if (model.hint) {
+    document.hint = model.hint;
+  }
+  if (model.collation) {
+    document.collation = model.collation;
+  }
+  return document;
+}
+
+/** @internal */
+export interface ClientUpdateOperation {
+  update: number;
+  multi: boolean;
+  filter: Filter<Document>;
+  updateMods: UpdateFilter<Document> | Document[];
+  hint?: Hint;
+  upsert?: boolean;
+  arrayFilters?: Document[];
+}
+
+/**
+ * Build the update one operation.
+ * @param model - The update one model.
+ * @param index - The namespace index.
+ * @returns the operation.
+ */
+export const buildUpdateOneOperation = (
+  model: ClientUpdateOneModel,
+  index: number
+): ClientUpdateOperation => {
+  return createUpdateOperation(model, index, false);
+};
+
+/**
+ * Build the update many operation.
+ * @param model - The update many model.
+ * @param index - The namespace index.
+ * @returns the operation.
+ */
+export const buildUpdateManyOperation = (
+  model: ClientUpdateManyModel,
+  index: number
+): ClientUpdateOperation => {
+  return createUpdateOperation(model, index, true);
+};
+
+/**
+ * Creates a delete operation based on the parameters.
+ */
+function createUpdateOperation(
+  model: ClientUpdateOneModel | ClientUpdateManyModel,
+  index: number,
+  multi: boolean
+): ClientUpdateOperation {
+  const document: ClientUpdateOperation = {
+    update: index,
+    multi: multi,
+    filter: model.filter,
+    updateMods: model.update
+  };
+  if (model.hint) {
+    document.hint = model.hint;
+  }
+  if (model.upsert) {
+    document.upsert = model.upsert;
+  }
+  if (model.arrayFilters) {
+    document.arrayFilters = model.arrayFilters;
+  }
+  return document;
+}
+
+/** @internal */
+export interface ClientReplaceOneOperation {
+  update: number;
+  multi: boolean;
+  filter: Filter<Document>;
+  updateMods: WithoutId<Document>;
+  hint?: Hint;
+  upsert?: boolean;
+}
+
+/**
+ * Build the replace one operation.
+ * @param model - The replace one model.
+ * @param index - The namespace index.
+ * @returns the operation.
+ */
+export const buildReplaceOneOperation = (
+  model: ClientReplaceOneModel,
+  index: number
+): ClientReplaceOneOperation => {
+  const document: ClientReplaceOneOperation = {
+    update: index,
+    multi: false,
+    filter: model.filter,
+    updateMods: model.replacement
+  };
+  if (model.hint) {
+    document.hint = model.hint;
+  }
+  if (model.upsert) {
+    document.upsert = model.upsert;
+  }
+  return document;
+};
+
+/** @internal */
+export function buildOperation(model: AnyClientBulkWriteModel, index: number): Document {
+  switch (model.name) {
+    case 'insertOne':
+      return buildInsertOneOperation(model, index);
+    case 'deleteOne':
+      return buildDeleteOneOperation(model, index);
+    case 'deleteMany':
+      return buildDeleteManyOperation(model, index);
+    case 'updateOne':
+      return buildUpdateOneOperation(model, index);
+    case 'updateMany':
+      return buildUpdateManyOperation(model, index);
+    case 'replaceOne':
+      return buildReplaceOneOperation(model, index);
+  }
+}

package/src/operations/client_bulk_write/common.ts

@@ -0,0 +1,146 @@
+import { type Document } from '../../bson';
+import type { Filter, OptionalId, UpdateFilter, WithoutId } from '../../mongo_types';
+import type { CollationOptions, CommandOperationOptions } from '../../operations/command';
+import type { Hint } from '../../operations/operation';
+
+/** @public */
+export interface ClientBulkWriteOptions extends CommandOperationOptions {
+  /**
+   * If true, when an insert fails, don't execute the remaining writes.
+   * If false, continue with remaining inserts when one fails.
+   * @defaultValue `true` - inserts are ordered by default
+   */
+  ordered?: boolean;
+  /**
+   * Allow driver to bypass schema validation.
+   * @defaultValue `false` - documents will be validated by default
+   **/
+  bypassDocumentValidation?: boolean;
+  /** Map of parameter names and values that can be accessed using $$var (requires MongoDB 5.0). */
+  let?: Document;
+  /**
+   * Whether detailed results for each successful operation should be included in the returned
+   * BulkWriteResult.
+   */
+  verboseResults?: boolean;
+}
+
+/** @public */
+export interface ClientWriteModel {
+  /** The namespace for the write. */
+  namespace: string;
+}
+
+/** @public */
+export interface ClientInsertOneModel extends ClientWriteModel {
+  name: 'insertOne';
+  /** The document to insert. */
+  document: OptionalId<Document>;
+}
+
+/** @public */
+export interface ClientDeleteOneModel extends ClientWriteModel {
+  name: 'deleteOne';
+  /**
+   * The filter used to determine if a document should be deleted.
+   * For a deleteOne operation, the first match is removed.
+   */
+  filter: Filter<Document>;
+  /** Specifies a collation. */
+  collation?: CollationOptions;
+  /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+  hint?: Hint;
+}
+
+/** @public */
+export interface ClientDeleteManyModel extends ClientWriteModel {
+  name: 'deleteMany';
+  /**
+   * The filter used to determine if a document should be deleted.
+   * For a deleteMany operation, all matches are removed.
+   */
+  filter: Filter<Document>;
+  /** Specifies a collation. */
+  collation?: CollationOptions;
+  /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+  hint?: Hint;
+}
+
+/** @public */
+export interface ClientReplaceOneModel extends ClientWriteModel {
+  name: 'replaceOne';
+  /**
+   * The filter used to determine if a document should be replaced.
+   * For a replaceOne operation, the first match is replaced.
+   */
+  filter: Filter<Document>;
+  /** The document with which to replace the matched document. */
+  replacement: WithoutId<Document>;
+  /** Specifies a collation. */
+  collation?: CollationOptions;
+  /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+  hint?: Hint;
+  /** When true, creates a new document if no document matches the query. */
+  upsert?: boolean;
+}
+
+/** @public */
+export interface ClientUpdateOneModel extends ClientWriteModel {
+  name: 'updateOne';
+  /**
+   * The filter used to determine if a document should be updated.
+   * For an updateOne operation, the first match is updated.
+   */
+  filter: Filter<Document>;
+  /**
+   * The modifications to apply. The value can be either:
+   * UpdateFilter<Document> - A document that contains update operator expressions,
+   * Document[] - an aggregation pipeline.
+   */
+  update: UpdateFilter<Document> | Document[];
+  /** A set of filters specifying to which array elements an update should apply. */
+  arrayFilters?: Document[];
+  /** Specifies a collation. */
+  collation?: CollationOptions;
+  /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+  hint?: Hint;
+  /** When true, creates a new document if no document matches the query. */
+  upsert?: boolean;
+}
+
+/** @public */
+export interface ClientUpdateManyModel extends ClientWriteModel {
+  name: 'updateMany';
+  /**
+   * The filter used to determine if a document should be updated.
+   * For an updateMany operation, all matches are updated.
+   */
+  filter: Filter<Document>;
+  /**
+   * The modifications to apply. The value can be either:
+   * UpdateFilter<Document> - A document that contains update operator expressions,
+   * Document[] - an aggregation pipeline.
+   */
+  update: UpdateFilter<Document> | Document[];
+  /** A set of filters specifying to which array elements an update should apply. */
+  arrayFilters?: Document[];
+  /** Specifies a collation. */
+  collation?: CollationOptions;
+  /** The index to use. If specified, then the query system will only consider plans using the hinted index. */
+  hint?: Hint;
+  /** When true, creates a new document if no document matches the query. */
+  upsert?: boolean;
+}
+
+/**
+ * Used to represent any of the client bulk write models that can be passed as an array
+ * to MongoClient#bulkWrite.
+ * @public
+ */
+export type AnyClientBulkWriteModel =
+  | ClientInsertOneModel
+  | ClientReplaceOneModel
+  | ClientUpdateOneModel
+  | ClientUpdateManyModel
+  | ClientDeleteOneModel
+  | ClientDeleteManyModel;

package/src/operations/execute_operation.ts

@@ -31,9 +31,8 @@ const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 const MMAPv1_RETRY_WRITES_ERROR_MESSAGE =
   'This MongoDB deployment does not support retryable writes. Please add retryWrites=false to your connection string.';
 
-type ResultTypeFromOperation<TOperation> = TOperation extends AbstractOperation<infer K>
-  ? K
-  : never;
+type ResultTypeFromOperation<TOperation> =
+  TOperation extends AbstractOperation<infer K> ? K : never;
 
 /**
  * Executes the given operation with provided arguments.
@@ -276,5 +275,8 @@ async function tryOperation<
     }
   }
 
-  throw previousOperationError;
+  throw (
+    previousOperationError ??
+    new MongoRuntimeError('Tried to propagate retryability error, but no error was found.')
+  );
 }

package/src/operations/find_and_modify.ts

@@ -209,7 +209,7 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
 
     // Execute the command
     const result = await super.executeCommand(server, session, cmd);
-    return options.includeResultMetadata ? result : result.value ?? null;
+    return options.includeResultMetadata ? result : (result.value ?? null);
   }
 }
 

package/src/operations/insert.ts

@@ -5,8 +5,7 @@ import { MongoInvalidArgumentError, MongoServerError } from '../error';
 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 { maybeAddIdToDocuments, type MongoDBNamespace } from '../utils';
 import { WriteConcern } from '../write_concern';
 import { BulkWriteOperation } from './bulk_write';
 import { CommandOperation, type CommandOperationOptions } from './command';