[FEAT] [EXPERIMENTAL] exposed a mechanism to force a reconnect.

nats-base-client/core.ts

@@ -41,6 +41,7 @@ export enum DebugEvents {
   Reconnecting = "reconnecting",
   PingTimer = "pingTimer",
   StaleConnection = "staleConnection",
+  ClientInitiatedReconnect = "client initiated reconnect",
 }
 
 export enum ErrorCode {
@@ -657,7 +658,31 @@ export interface NatsConnection {
    */
   rtt(): Promise<number>;
 
+  /**
+   * Returns a {@link ServicesAPI} which allows you to build services
+   * using NATS.
+   */
   services: ServicesAPI;
+
+  /**
+   * Use of this API is experimental, and it is subject to be removed.
+   *
+   * reconnect() enables a client to force a reconnect. A reconnect will disconnect
+   * the client, and possibly initiate a reconnect to the cluster.  Note that all
+   * reconnect caveats apply:
+   *
+   * - If the reconnection policy given to the client doesn't allow reconnects, the
+   * connection will close.
+   *
+   * - Messages that are inbound or outbound could  be lost.
+   *
+   * - All requests that are in flight will be rejected.
+   *
+   * Note that the returned promise will reject if the client is already closed, or if
+   * it is in the process of draining. If the client is currently disconnected,
+   * this API has no effect, as the client is already attempting to reconnect.
+   */
+  reconnect(): Promise<void>;
 }
 
 /**

nats-base-client/nats.ts

@@ -534,6 +534,20 @@ export class NatsConnectionImpl implements NatsConnection {
     }
     return this._services;
   }
+
+  reconnect(): Promise<void> {
+    if (this.isClosed()) {
+      return Promise.reject(
+        NatsError.errorForCode(ErrorCode.ConnectionClosed),
+      );
+    }
+    if (this.isDraining()) {
+      return Promise.reject(
+        NatsError.errorForCode(ErrorCode.ConnectionDraining),
+      );
+    }
+    return this.protocol.reconnect();
+  }
 }
 
 export class ServicesFactory implements ServicesAPI {

nats-base-client/protocol.ts

@@ -505,6 +505,17 @@ export class ProtocolHandler implements Dispatcher<ParserEvent> {
     this.transport.disconnect();
   }
 
+  public reconnect(): Promise<void> {
+    if (this.connected) {
+      this.dispatchStatus({
+        type: DebugEvents.ClientInitiatedReconnect,
+        data: "",
+      });
+      this.transport.disconnect();
+    }
+    return Promise.resolve();
+  }
+
   async disconnected(err?: Error): Promise<void> {
     this.dispatchStatus(
       {

tests/authenticator_test.ts

@@ -36,6 +36,7 @@ import {
 } from "https://raw.githubusercontent.com/nats-io/jwt.js/main/src/jwt.ts";
 import { assertBetween } from "./helpers/mod.ts";
 import { deadline, delay } from "../nats-base-client/util.ts";
+import { NatsConnectionImpl } from "../nats-base-client/nats.ts";
 
 function disconnectReconnect(nc: NatsConnection): Promise<void> {
   const done = deferred<void>();
@@ -67,17 +68,17 @@ async function testAuthenticatorFn(
     return fn(nonce);
   };
   conf = Object.assign({}, conf, { debug });
-  let { ns, nc } = await setup(conf, {
+  const { ns, nc } = await setup(conf, {
     authenticator,
   });
 
   const cycle = disconnectReconnect(nc);
 
   await delay(2000);
   called = 0;
-  await ns.stop();
+  const nci = nc as NatsConnectionImpl;
+  nci.reconnect();
   await delay(1000);
-  ns = await deadline(ns.restart(), 4000);
   await deadline(cycle, 4000);
   assertBetween(called, 1, 10);
   await nc.flush();

tests/reconnect_test.ts

@@ -407,6 +407,8 @@ Deno.test("reconnect - stale connections don't close", async () => {
     pingInterval: 2000,
     reconnectTimeWait: 500,
     ignoreAuthErrorAbort: true,
+    // need a timeout, otherwise the default is 20s and we leak resources
+    timeout: 2000,
   });
 
   let stales = 0;
@@ -427,6 +429,8 @@ Deno.test("reconnect - stale connections don't close", async () => {
     return c.close();
   });
   assert(stales >= 3, `stales ${stales}`);
+  // there could be a redial timer waiting here for 2s
+  await delay(2000);
 });
 
 Deno.test("reconnect - protocol errors don't close client", async () => {