Merge pull request #704 from nats-io/easier-resolve

[FIX] simpler way to noResolve

Author: aricart

nats-base-client/core.ts

@@ -340,7 +340,14 @@ export interface Server {
   tlsName: string;
 
   resolve(
-    opts: Partial<{ fn: DnsResolveFn; randomize: boolean; debug?: boolean }>,
+    opts: Partial<
+      {
+        fn: DnsResolveFn;
+        randomize: boolean;
+        debug?: boolean;
+        resolve?: boolean;
+      }
+    >,
   ): Promise<Server[]>;
 }
 
@@ -1404,10 +1411,12 @@ export interface ConnectionOptions {
   noAsyncTraces?: boolean;
 
   /**
-   * When true, the connect function will remove any name resolution provided by
-   * the transport. In some environments (browsers) this is a no-op option.
+   * When false, the connect function will not perform any hostname resolution. Note that
+   * by default this option will be true if the client supports hostname resolution.
+   * Note that on clients that don't supported (mainly the websocket client, setting this
+   * option to true, will throw an exception as this option is not available.
    */
-  noResolve?: boolean;
+  resolve?: boolean;
 }
 
 /**

nats-base-client/options.ts

@@ -135,6 +135,12 @@ export function parseOptions(opts?: ConnectionOptions): ConnectionOptions {
     }
   }
 
+  // if not set - we set it
+  if (options.resolve === undefined) {
+    // set a default based on whether the client can resolve or not
+    options.resolve = typeof getResolveFn() === "function";
+  }
+
   if (options.resolve) {
     if (typeof getResolveFn() !== "function") {
       throw new NatsError(

nats-base-client/protocol.ts

@@ -594,10 +594,12 @@ export class ProtocolHandler implements Dispatcher<ParserEvent> {
   }
 
   async _doDial(srv: Server): Promise<void> {
+    const { resolve } = this.options;
     const alts = await srv.resolve({
       fn: getResolveFn(),
       debug: this.options.debug,
       randomize: !this.options.noRandomize,
+      resolve,
     });
 
     let lastErr: Error | null = null;

nats-base-client/servers.ts

@@ -138,12 +138,13 @@ export class ServerImpl implements Server {
         fn: DnsResolveFn;
         randomize: boolean;
         resolve: boolean;
-        debug?: boolean;
+        debug: boolean;
       }
     >,
   ): Promise<Server[]> {
-    if (!opts.fn) {
+    if (!opts.fn || opts.resolve === false) {
       // we cannot resolve - transport doesn't support it
+      // or user opted out
       // don't add - to resolves or we get a circ reference
       return [this];
     }

src/connect.ts

@@ -27,7 +27,7 @@ export function connect(opts: ConnectionOptions = {}): Promise<NatsConnection> {
     factory: (): Transport => {
       return new DenoTransport();
     },
-    dnsResolveFn: opts.noResolve === true ? undefined : denoResolveHost,
+    dnsResolveFn: denoResolveHost,
   } as TransportFactory);
 
   return NatsConnectionImpl.connect(opts);

tests/basics_test.ts

@@ -48,7 +48,6 @@ import {
   collect,
   deferred,
   delay,
-  getResolveFn,
   headers,
   isIP,
   NatsConnectionImpl,
@@ -1427,9 +1426,23 @@ Deno.test("basics - respond message", async () => {
 });
 
 Deno.test("basics - noResolve", async () => {
-  const { ns, nc } = await setup({}, { noResolve: true });
-  assertEquals(getResolveFn(), undefined);
-  await cleanup(ns, nc);
+  const token = Deno.env.get("NGS_CI_USER");
+  if (token === undefined) {
+    disabled(
+      `skipping: NGS_CI_USER is not available in the environment`,
+    );
+    return;
+  }
+
+  const nci = await connect({
+    servers: "connect.ngs.global",
+    authenticator: jwtAuthenticator(token),
+    resolve: false,
+  }) as NatsConnectionImpl;
+
+  const srv = nci.protocol.servers.getCurrentServer();
+  assertEquals(srv.resolves, undefined);
+  await nci.close();
 });
 
 class MM implements Msg {