Sm/w 8206747

src/connection.ts

@@ -4,8 +4,8 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
-
-import { maxBy, merge } from '@salesforce/kit';
+import { URL } from 'url';
+import { Duration, maxBy, merge } from '@salesforce/kit';
 import { asString, ensure, getNumber, isString, JsonCollection, JsonMap, Optional } from '@salesforce/ts-types';
 import {
   Connection as JSForceConnection,
@@ -17,6 +17,8 @@ import {
   Tooling as JSForceTooling,
 } from 'jsforce';
 import { AuthFields, AuthInfo } from './authInfo';
+import { MyDomainResolver } from './status/myDomainResolver';
+
 import { ConfigAggregator } from './config/configAggregator';
 import { Logger } from './logger';
 import { SfdxError } from './sfdxError';
@@ -36,6 +38,8 @@ export const SFDX_HTTP_HEADERS = {
   'user-agent': clientId,
 };
 
+const ORG_NOT_FOUND_ERROR_NAME = 'Org Not Found';
+
 // This interface is so we can add the autoFetchQuery method to both the Connection
 // and Tooling classes and get nice typing info for it within editors.  JSForce is
 // unlikely to accept a PR for this method, but that would be another approach.
@@ -119,6 +123,8 @@ export class Connection extends JSForceConnection {
 
     const conn = new this(options);
     await conn.init();
+    // verifies that subsequent requests to org will not hit DNS errors
+
     if (!versionFromConfig) {
       await conn.useLatestApiVersion();
     }
@@ -178,6 +184,7 @@ export class Connection extends JSForceConnection {
    * Retrieves the highest api version that is supported by the target server instance.
    */
   public async retrieveMaxApiVersion(): Promise<string> {
+    await this.isResolvable();
     type Versioned = { version: string };
     const versions = (await this.request(`${this.instanceUrl}/services/data`)) as Versioned[];
     this.logger.debug(`response for org versions: ${versions}`);
@@ -191,11 +198,39 @@ export class Connection extends JSForceConnection {
     try {
       this.setApiVersion(await this.retrieveMaxApiVersion());
     } catch (err) {
+      if (err.name === ORG_NOT_FOUND_ERROR_NAME) {
+        throw err; // throws on DNS connection errors
+      }
       // Don't fail if we can't use the latest, just use the default
       this.logger.warn('Failed to set the latest API version:', err);
     }
   }
 
+  /**
+   * Verify that instance has a reachable DNS entry, otherwise will throw error
+   */
+  public async isResolvable(): Promise<boolean> {
+    if (!this.options.connectionOptions?.instanceUrl) {
+      throw new SfdxError('Connection has no instanceUrl', 'NoInstanceUrl', [
+        'Make sure the instanceUrl is set in your command or config',
+      ]);
+    }
+    const resolver = await MyDomainResolver.create({
+      url: new URL(this.options.connectionOptions.instanceUrl),
+      timeout: Duration.seconds(10),
+      frequency: Duration.seconds(10),
+    });
+    try {
+      await resolver.resolve();
+      return true;
+    } catch (e) {
+      throw new SfdxError('The org cannot be found', ORG_NOT_FOUND_ERROR_NAME, [
+        'Verify that the org still exists',
+        'If your org is newly created, wait a minute and run your command again',
+      ]);
+    }
+  }
+
   /**
    * Get the API version used for all connection requests.
    */

test/unit/connectionTest.ts

@@ -9,12 +9,15 @@ import { get, JsonMap } from '@salesforce/ts-types';
 import { assert, expect } from 'chai';
 import * as jsforce from 'jsforce';
 import { AuthInfo } from '../../src/authInfo';
+import { MyDomainResolver } from '../../src/status/myDomainResolver';
+
 import { ConfigAggregator, ConfigInfo } from '../../src/config/configAggregator';
 import { Connection, SFDX_HTTP_HEADERS } from '../../src/connection';
-import { testSetup } from '../../src/testSetup';
+import { testSetup, shouldThrow } from '../../src/testSetup';
 
 // Setup the test environment.
 const $$ = testSetup();
+const TEST_IP = '1.1.1.1';
 
 describe('Connection', () => {
   const testConnectionOptions = { loginUrl: 'connectionTest/loginUrl' };
@@ -27,15 +30,36 @@ describe('Connection', () => {
     getConnectionOptions: () => testConnectionOptions,
   };
 
+  const testAuthInfoWithDomain = {
+    ...testAuthInfo,
+    getConnectionOptions: () => ({
+      ...testConnectionOptions,
+      instanceUrl: 'https://connectionTest/instanceUrl',
+    }),
+  };
+
   beforeEach(() => {
     $$.SANDBOXES.CONNECTION.restore();
     $$.SANDBOX.stub(process, 'emitWarning');
+    $$.SANDBOX.stub(MyDomainResolver.prototype, 'resolve').resolves(TEST_IP);
+
     initializeStub = $$.SANDBOX.stub(jsforce.Connection.prototype, 'initialize').returns();
     requestMock = $$.SANDBOX.stub(jsforce.Connection.prototype, 'request')
       .onFirstCall()
       .returns(Promise.resolve([{ version: '42.0' }]));
   });
 
+  it('create() should throw on DNS errors', async () => {
+    $$.SANDBOX.restore();
+    $$.SANDBOX.stub(MyDomainResolver.prototype, 'resolve').rejects({ name: 'Org Not Found' });
+
+    try {
+      await shouldThrow(Connection.create({ authInfo: testAuthInfoWithDomain as AuthInfo }));
+    } catch (e) {
+      expect(e).to.have.property('name', 'Org Not Found');
+    }
+  });
+
   it('create() should create a connection using AuthInfo and SFDX options', async () => {
     const conn = await Connection.create({ authInfo: testAuthInfo as AuthInfo });
 
@@ -73,8 +97,9 @@ describe('Connection', () => {
       headers: SFDX_HTTP_HEADERS,
     };
 
-    const conn = await Connection.create({ authInfo: testAuthInfo as AuthInfo });
-
+    const conn = await Connection.create({
+      authInfo: testAuthInfoWithDomain as AuthInfo,
+    });
     // Test passing a string to conn.request()
     const response1 = await conn.request(testUrl);
     expect(requestMock.called).to.be.true;
@@ -88,7 +113,9 @@ describe('Connection', () => {
     requestMock.onSecondCall().returns(Promise.resolve(testResponse));
     const testUrl = 'connectionTest/request/url/describe';
 
-    const conn = await Connection.create({ authInfo: testAuthInfo as AuthInfo });
+    const conn = await Connection.create({
+      authInfo: testAuthInfoWithDomain as AuthInfo,
+    });
 
     // Test passing a RequestInfo object and options to conn.request()
     const requestInfo = { method: 'POST', url: testUrl };
@@ -107,7 +134,9 @@ describe('Connection', () => {
     const testResponse = { success: true };
     requestMock.onSecondCall().returns(Promise.resolve(testResponse));
 
-    const conn = await Connection.create({ authInfo: testAuthInfo as AuthInfo });
+    const conn = await Connection.create({
+      authInfo: testAuthInfoWithDomain as AuthInfo,
+    });
 
     const testUrl = '/services/data/v42.0/tooling/sobjects';
     const requestInfo = { method: 'GET', url: testUrl };
@@ -197,7 +226,9 @@ describe('Connection', () => {
   it('autoFetch() should reject the promise upon query error', async () => {
     const errorMsg = 'QueryFailed';
     requestMock.onSecondCall().throws(new Error(errorMsg));
-    const conn = await Connection.create({ authInfo: testAuthInfo as AuthInfo });
+    const conn = await Connection.create({
+      authInfo: testAuthInfoWithDomain as AuthInfo,
+    });
 
     try {
       await conn.autoFetchQuery('TEST_SOQL');

test/unit/orgTest.ts

@@ -27,6 +27,7 @@ import { Global } from '../../src/global';
 import { Org } from '../../src/org';
 import { MockTestOrgData, testSetup } from '../../src/testSetup';
 import { fs } from '../../src/util/fs';
+import { MyDomainResolver } from '../../src/status/myDomainResolver';
 
 const $$ = testSetup();
 
@@ -38,6 +39,8 @@ describe('Org Tests', () => {
   beforeEach(async () => {
     testData = new MockTestOrgData();
     $$.configStubs.AuthInfoConfig = { contents: await testData.getConfig() };
+    $$.SANDBOX.stub(MyDomainResolver.prototype, 'resolve').resolves('1.1.1.1');
+
     stubMethod($$.SANDBOX, Connection.prototype, 'useLatestApiVersion').returns(Promise.resolve());
   });
 
@@ -122,6 +125,9 @@ describe('Org Tests', () => {
       const org: Org = await Org.create({
         connection: await Connection.create({
           authInfo: await AuthInfo.create({ username: testData.username }),
+          connectionOptions: {
+            instanceUrl: 'https://orgTest.instanceUrl',
+          },
         }),
       });
       const apiVersion = await org.retrieveMaxApiVersion();