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

[FIX] simpler way to noResolve

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 {