Method connectOnce

packages/event-service/src/client.ts:143–238

()

    }

    if (this.authRecoveryAttempts >= MAX_AUTH_RECOVERY_ATTEMPTS) {
      this.stopAfterUnauthorized();
      return true;
    }

    const decision = await this.onUnauthorized();
    if (decision === 'stop' || this.destroyed) {
      this.stopAfterUnauthorized();
      return true;
    }

    this.authRecoveryAttempts++;
    this.scheduleReconnect();
    return true;
  }

  private stopAfterUnauthorized(): void {
    this.destroyed = true;
    if (this.reconnectTimer !== null) {
      clearTimeout(this.reconnectTimer);
      this.reconnectTimer = null;
    }
  }

  private async connectOnce(): Promise<void> {
    const gen = this.generation;

    // Close any existing socket to avoid leaking connections.
    if (this.ws) {
      const oldWs = this.ws;
      this.ws = null;
      oldWs.close();
    }

    const token = await this.getToken();
    if (gen !== this.generation || this.destroyed) return;
    const ticket = await fetchConnectionTicket(this.url, token);
    // disconnect() may have run while we were awaiting the token. Bail before
    // creating the socket so we don't leak a WebSocket + ping timer past
    // provider unmount (e.g. sign-out, navigation, strict-mode remount).
    if (gen !== this.generation || this.destroyed) return;

    return new Promise((resolve, reject) => {
      const ws = new WebSocket(connectUrlFor(this.url, ticket), [WEBSOCKET_PROTOCOL]);
      this.ws = ws;

      // Guard against double-resolution: the handshake timeout, the
      // WebSocket 'error' event, and disconnect() can all try to settle
      // this promise.
      let settled = false;
      const settleResolve = (): void => {
        if (settled) return;
        settled = true;
        this.clearHandshakeTimer();
        this.abortHandshake = null;
        resolve();
      };
      const settleReject = (err: Error): void => {