Function cleanup

src/cursor/abstract_cursor.ts:987–1055

@internal

(timeoutMS?: number, error?: Error)

  /** @internal */
  private async cleanup(timeoutMS?: number, error?: Error) {
    this.abortListener?.[kDispose]();
    this.isClosed = true;
    const timeoutContextForKillCursors = (): CursorTimeoutContext | undefined => {
      if (timeoutMS != null) {
        this.timeoutContext?.clear();
        return new CursorTimeoutContext(
          TimeoutContext.create({
            serverSelectionTimeoutMS: this.client.s.options.serverSelectionTimeoutMS,
            timeoutMS
          }),
          this
        );
      } else {
        return this.timeoutContext?.refreshed();
      }
    };

    const withEmitClose = async (fn: () => Promise<void>) => {
      try {
        await fn();
      } finally {
        this.emitClose();
      }
    };

    const close = async () => {
      // if no session has been defined on the cursor, the cursor was never initialized
      // or the cursor was re-wound and never re-iterated.  In either case, we
      //   1. do not need to end the session (there is no session after all)
      //   2. do not need to kill the cursor server-side
      const session = this.cursorSession;
      if (!session) return;

      try {
        if (
          !this.isKilled &&
          this.cursorId &&
          !this.cursorId.isZero() &&
          this.cursorNamespace &&
          this.selectedServer &&
          !session.hasEnded
        ) {
          this.isKilled = true;
          const cursorId = this.cursorId;
          this.cursorId = Long.ZERO;

          await executeOperation(
            this.cursorClient,
            new KillCursorsOperation(cursorId, this.cursorNamespace, this.selectedServer, {
              session
            }),
            timeoutContextForKillCursors()
          );
        }
      } catch (error) {
        squashError(error);
      } finally {