mongodb 6.8.0-dev.20240905.sha.65e0e15c → 6.8.1

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,8 +88,9 @@ 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;
@@ -191,10 +192,9 @@ 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,7 +412,6 @@ 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;
@@ -481,31 +480,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
@@ -522,41 +521,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,9 +9,8 @@ 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;
+const MIN_WIRE_VERSION_$OUT_READ_CONCERN_SUPPORT = 8 as const;
 
 /** @public */
 export interface AggregateOptions extends CommandOperationOptions {

package/src/operations/bulk_write.ts

@@ -13,11 +13,11 @@ import { AbstractOperation, Aspect, defineAspects } from './operation';
 export class BulkWriteOperation extends AbstractOperation<BulkWriteResult> {
   override options: BulkWriteOptions;
   collection: Collection;
-  operations: ReadonlyArray<AnyBulkWriteOperation>;
+  operations: AnyBulkWriteOperation[];
 
   constructor(
     collection: Collection,
-    operations: ReadonlyArray<AnyBulkWriteOperation>,
+    operations: AnyBulkWriteOperation[],
     options: BulkWriteOptions
   ) {
     super(options);

package/src/operations/command.ts

@@ -104,7 +104,7 @@ export abstract class CommandOperation<T> extends AbstractOperation<T> {
     if (this.hasAspect(Aspect.EXPLAINABLE)) {
       return this.explain == null;
     }
-    return super.canRetryWrite;
+    return true;
   }
 
   public async executeCommand<T extends MongoDBResponseConstructor>(

package/src/operations/execute_operation.ts

@@ -24,15 +24,16 @@ import {
 } from '../sdam/server_selection';
 import type { Topology } from '../sdam/topology';
 import type { ClientSession } from '../sessions';
-import { supportsRetryableWrites } from '../utils';
+import { squashError, supportsRetryableWrites } from '../utils';
 import { AbstractOperation, Aspect } from './operation';
 
 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.
@@ -44,9 +45,10 @@ type ResultTypeFromOperation<TOperation> =
  * not provided.
  *
  * The expectation is that this function:
- * - Connects the MongoClient if it has not already been connected, see {@link autoConnect}
+ * - Connects the MongoClient if it has not already been connected
  * - Creates a session if none is provided and cleans up the session it creates
- * - Tries an operation and retries under certain conditions, see {@link tryOperation}
+ * - Selects a server based on readPreference or various factors
+ * - Retries an operation if it fails for certain errors, see {@link retryOperation}
  *
  * @typeParam T - The operation's type
  * @typeParam TResult - The type of the operation's result, calculated from T
@@ -63,7 +65,23 @@ export async function executeOperation<
     throw new MongoRuntimeError('This method requires a valid operation instance');
   }
 
-  const topology = await autoConnect(client);
+  if (client.topology == null) {
+    // Auto connect on operation
+    if (client.s.hasBeenClosed) {
+      throw new MongoNotConnectedError('Client must be connected before running operations');
+    }
+    client.s.options[Symbol.for('@@mdb.skipPingOnConnect')] = true;
+    try {
+      await client.connect();
+    } finally {
+      delete client.s.options[Symbol.for('@@mdb.skipPingOnConnect')];
+    }
+  }
+
+  const { topology } = client;
+  if (topology == null) {
+    throw new MongoRuntimeError('client.connect did not create a topology but also did not throw');
+  }
 
   // The driver sessions spec mandates that we implicitly create sessions for operations
   // that are not explicitly provided with a session.
@@ -90,6 +108,7 @@ export async function executeOperation<
   const inTransaction = !!session?.inTransaction();
 
   const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
+  const hasWriteAspect = operation.hasAspect(Aspect.WRITE_OPERATION);
 
   if (
     inTransaction &&
@@ -105,73 +124,6 @@ export async function executeOperation<
     session.unpin();
   }
 
-  try {
-    return await tryOperation(operation, {
-      topology,
-      session,
-      readPreference
-    });
-  } finally {
-    if (session?.owner != null && session.owner === owner) {
-      await session.endSession();
-    }
-  }
-}
-
-/**
- * Connects a client if it has not yet been connected
- * @internal
- */
-async function autoConnect(client: MongoClient): Promise<Topology> {
-  if (client.topology == null) {
-    if (client.s.hasBeenClosed) {
-      throw new MongoNotConnectedError('Client must be connected before running operations');
-    }
-    client.s.options[Symbol.for('@@mdb.skipPingOnConnect')] = true;
-    try {
-      await client.connect();
-      if (client.topology == null) {
-        throw new MongoRuntimeError(
-          'client.connect did not create a topology but also did not throw'
-        );
-      }
-      return client.topology;
-    } finally {
-      delete client.s.options[Symbol.for('@@mdb.skipPingOnConnect')];
-    }
-  }
-  return client.topology;
-}
-
-/** @internal */
-type RetryOptions = {
-  session: ClientSession | undefined;
-  readPreference: ReadPreference;
-  topology: Topology;
-};
-
-/**
- * Executes an operation and retries as appropriate
- * @internal
- *
- * @remarks
- * Implements behaviour described in [Retryable Reads](https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.md) and [Retryable
- * Writes](https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.md) specification
- *
- * This function:
- * - performs initial server selection
- * - attempts to execute an operation
- * - retries the operation if it meets the criteria for a retryable read or a retryable write
- *
- * @typeParam T - The operation's type
- * @typeParam TResult - The type of the operation's result, calculated from T
- *
- * @param operation - The operation to execute
- * */
-async function tryOperation<
-  T extends AbstractOperation<TResult>,
-  TResult = ResultTypeFromOperation<T>
->(operation: T, { topology, session, readPreference }: RetryOptions): Promise<TResult> {
   let selector: ReadPreference | ServerSelector;
 
   if (operation.hasAspect(Aspect.MUST_SELECT_SAME_SERVER)) {
@@ -187,14 +139,30 @@ async function tryOperation<
     selector = readPreference;
   }
 
-  let server = await topology.selectServer(selector, {
+  const server = await topology.selectServer(selector, {
     session,
     operationName: operation.commandName
   });
 
-  const hasReadAspect = operation.hasAspect(Aspect.READ_OPERATION);
-  const hasWriteAspect = operation.hasAspect(Aspect.WRITE_OPERATION);
-  const inTransaction = session?.inTransaction() ?? false;
+  if (session == null) {
+    // No session also means it is not retryable, early exit
+    return await operation.execute(server, undefined);
+  }
+
+  if (!operation.hasAspect(Aspect.RETRYABLE)) {
+    // non-retryable operation, early exit
+    try {
+      return await operation.execute(server, session);
+    } finally {
+      if (session?.owner != null && session.owner === owner) {
+        try {
+          await session.endSession();
+        } catch (error) {
+          squashError(error);
+        }
+      }
+    }
+  }
 
   const willRetryRead = topology.s.options.retryReads && !inTransaction && operation.canRetryRead;
 
@@ -204,79 +172,105 @@ async function tryOperation<
     supportsRetryableWrites(server) &&
     operation.canRetryWrite;
 
-  const willRetry =
-    operation.hasAspect(Aspect.RETRYABLE) &&
-    session != null &&
-    ((hasReadAspect && willRetryRead) || (hasWriteAspect && willRetryWrite));
+  const willRetry = (hasReadAspect && willRetryRead) || (hasWriteAspect && willRetryWrite);
 
-  if (hasWriteAspect && willRetryWrite && session != null) {
+  if (hasWriteAspect && willRetryWrite) {
     operation.options.willRetryWrite = true;
     session.incrementTransactionNumber();
   }
 
-  // TODO(NODE-6231): implement infinite retry within CSOT timeout here
-  const maxTries = willRetry ? 2 : 1;
-  let previousOperationError: MongoError | undefined;
-  let previousServer: ServerDescription | undefined;
-
-  // TODO(NODE-6231): implement infinite retry within CSOT timeout here
-  for (let tries = 0; tries < maxTries; tries++) {
-    if (previousOperationError) {
-      if (hasWriteAspect && previousOperationError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
-        throw new MongoServerError({
-          message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
-          errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
-          originalError: previousOperationError
-        });
+  try {
+    return await operation.execute(server, session);
+  } catch (operationError) {
+    if (willRetry && operationError instanceof MongoError) {
+      return await retryOperation(operation, operationError, {
+        session,
+        topology,
+        selector,
+        previousServer: server.description
+      });
+    }
+    throw operationError;
+  } finally {
+    if (session?.owner != null && session.owner === owner) {
+      try {
+        await session.endSession();
+      } catch (error) {
+        squashError(error);
       }
+    }
+  }
+}
 
-      if (hasWriteAspect && !isRetryableWriteError(previousOperationError))
-        throw previousOperationError;
+/** @internal */
+type RetryOptions = {
+  session: ClientSession;
+  topology: Topology;
+  selector: ReadPreference | ServerSelector;
+  previousServer: ServerDescription;
+};
 
-      if (hasReadAspect && !isRetryableReadError(previousOperationError))
-        throw previousOperationError;
+async function retryOperation<
+  T extends AbstractOperation<TResult>,
+  TResult = ResultTypeFromOperation<T>
+>(
+  operation: T,
+  originalError: MongoError,
+  { session, topology, selector, previousServer }: RetryOptions
+): Promise<TResult> {
+  const isWriteOperation = operation.hasAspect(Aspect.WRITE_OPERATION);
+  const isReadOperation = operation.hasAspect(Aspect.READ_OPERATION);
 
-      if (
-        previousOperationError instanceof MongoNetworkError &&
-        operation.hasAspect(Aspect.CURSOR_CREATING) &&
-        session != null &&
-        session.isPinned &&
-        !session.inTransaction()
-      ) {
-        session.unpin({ force: true, forceClear: true });
-      }
+  if (isWriteOperation && originalError.code === MMAPv1_RETRY_WRITES_ERROR_CODE) {
+    throw new MongoServerError({
+      message: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+      errmsg: MMAPv1_RETRY_WRITES_ERROR_MESSAGE,
+      originalError
+    });
+  }
 
-      server = await topology.selectServer(selector, {
-        session,
-        operationName: operation.commandName,
-        previousServer
-      });
+  if (isWriteOperation && !isRetryableWriteError(originalError)) {
+    throw originalError;
+  }
 
-      if (hasWriteAspect && !supportsRetryableWrites(server)) {
-        throw new MongoUnexpectedServerResponseError(
-          'Selected server does not support retryable writes'
-        );
-      }
-    }
+  if (isReadOperation && !isRetryableReadError(originalError)) {
+    throw originalError;
+  }
 
-    try {
-      return await operation.execute(server, session);
-    } catch (operationError) {
-      if (!(operationError instanceof MongoError)) throw operationError;
+  if (
+    originalError instanceof MongoNetworkError &&
+    session.isPinned &&
+    !session.inTransaction() &&
+    operation.hasAspect(Aspect.CURSOR_CREATING)
+  ) {
+    // If we have a cursor and the initial command fails with a network error,
+    // we can retry it on another connection. So we need to check it back in, clear the
+    // pool for the service id, and retry again.
+    session.unpin({ force: true, forceClear: true });
+  }
 
-      if (
-        previousOperationError != null &&
-        operationError.hasErrorLabel(MongoErrorLabel.NoWritesPerformed)
-      ) {
-        throw previousOperationError;
-      }
-      previousServer = server.description;
-      previousOperationError = operationError;
-    }
+  // select a new server, and attempt to retry the operation
+  const server = await topology.selectServer(selector, {
+    session,
+    operationName: operation.commandName,
+    previousServer
+  });
+
+  if (isWriteOperation && !supportsRetryableWrites(server)) {
+    throw new MongoUnexpectedServerResponseError(
+      'Selected server does not support retryable writes'
+    );
   }
 
-  throw (
-    previousOperationError ??
-    new MongoRuntimeError('Tried to propagate retryability error, but no error was found.')
-  );
+  try {
+    return await operation.execute(server, session);
+  } catch (retryError) {
+    if (
+      retryError instanceof MongoError &&
+      retryError.hasErrorLabel(MongoErrorLabel.NoWritesPerformed)
+    ) {
+      throw originalError;
+    }
+    throw retryError;
+  }
 }

package/src/operations/find_and_modify.ts

@@ -192,7 +192,12 @@ export class FindAndModifyOperation extends CommandOperation<Document> {
       ...this.cmdBase
     };
 
-    decorateWithCollation(cmd, coll, options);
+    // Have we specified collation
+    try {
+      decorateWithCollation(cmd, coll, options);
+    } catch (err) {
+      return err;
+    }
 
     if (options.hint) {
       // TODO: once this method becomes a CommandOperation we will have the server
@@ -209,7 +214,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,7 +5,8 @@ import { MongoInvalidArgumentError, MongoServerError } from '../error';
 import type { InferIdType } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { maybeAddIdToDocuments, type MongoDBNamespace } from '../utils';
+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';
@@ -103,9 +104,9 @@ export interface InsertManyResult<TSchema = Document> {
 export class InsertManyOperation extends AbstractOperation<InsertManyResult> {
   override options: BulkWriteOptions;
   collection: Collection;
-  docs: ReadonlyArray<Document>;
+  docs: Document[];
 
-  constructor(collection: Collection, docs: ReadonlyArray<Document>, options: BulkWriteOptions) {
+  constructor(collection: Collection, docs: Document[], options: BulkWriteOptions) {
     super(options);
 
     if (!Array.isArray(docs)) {

package/src/operations/operation.ts

@@ -17,6 +17,11 @@ export const Aspect = {
 /** @public */
 export type Hint = string | Document;
 
+// eslint-disable-next-line @typescript-eslint/ban-types
+export interface OperationConstructor extends Function {
+  aspects?: Set<symbol>;
+}
+
 /** @public */
 export interface OperationOptions extends BSONSerializeOptions {
   /** Specify ClientSession for this command */
@@ -58,12 +63,10 @@ export abstract class AbstractOperation<TResult = any> {
 
   [kSession]: ClientSession | undefined;
 
-  static aspects?: Set<symbol>;
-
   constructor(options: OperationOptions = {}) {
     this.readPreference = this.hasAspect(Aspect.WRITE_OPERATION)
       ? ReadPreference.primary
-      : (ReadPreference.fromOptions(options) ?? ReadPreference.primary);
+      : ReadPreference.fromOptions(options) ?? ReadPreference.primary;
 
     // Pull the BSON serialize options from the already-resolved options
     this.bsonOptions = resolveBSONOptions(options);
@@ -82,7 +85,7 @@ export abstract class AbstractOperation<TResult = any> {
   abstract execute(server: Server, session: ClientSession | undefined): Promise<TResult>;
 
   hasAspect(aspect: symbol): boolean {
-    const ctor = this.constructor as { aspects?: Set<symbol> };
+    const ctor = this.constructor as OperationConstructor;
     if (ctor.aspects == null) {
       return false;
     }
@@ -99,16 +102,16 @@ export abstract class AbstractOperation<TResult = any> {
   }
 
   get canRetryRead(): boolean {
-    return this.hasAspect(Aspect.RETRYABLE) && this.hasAspect(Aspect.READ_OPERATION);
+    return true;
   }
 
   get canRetryWrite(): boolean {
-    return this.hasAspect(Aspect.RETRYABLE) && this.hasAspect(Aspect.WRITE_OPERATION);
+    return true;
   }
 }
 
 export function defineAspects(
-  operation: { aspects?: Set<symbol> },
+  operation: OperationConstructor,
   aspects: symbol | symbol[] | Set<symbol>
 ): Set<symbol> {
   if (!Array.isArray(aspects) && !(aspects instanceof Set)) {