@salesforce/core 4.0.0-v3.0 → 4.0.1

package/lib/stateAggregator/accessors/tokenAccessor.js

@@ -0,0 +1,80 @@
+"use strict";
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenAccessor = void 0;
+const kit_1 = require("@salesforce/kit");
+const tokensConfig_1 = require("../../config/tokensConfig");
+class TokenAccessor extends kit_1.AsyncOptionalCreatable {
+    /**
+     * Return all tokens.
+     *
+     * @param decrypt
+     * @returns {SfTokens}
+     */
+    getAll(decrypt = false) {
+        return this.config.getContents(decrypt) || {};
+    }
+    /**
+     * Return a token for the provided name.
+     *
+     * @param name
+     * @param decrypt
+     * @returns {Optional<SfToken>}
+     */
+    get(name, decrypt = false) {
+        return this.config.get(name, decrypt);
+    }
+    /**
+     * Return true if a given name has a token associated with it.
+     *
+     * @param name
+     * @returns {boolean}
+     */
+    has(name) {
+        return !!this.getAll()[name];
+    }
+    /**
+     * Set the token for the provided name.
+     *
+     * @param name
+     * @param token
+     */
+    set(name, token) {
+        this.config.set(name, token);
+    }
+    /**
+     * Update the token for the provided name.
+     *
+     * @param name
+     * @param token
+     */
+    update(name, token) {
+        this.config.update(name, token);
+    }
+    /**
+     * Unet the token for the provided name.
+     *
+     * @param name
+     */
+    unset(name) {
+        this.config.unset(name);
+    }
+    /**
+     * Write the contents to the token file.
+     *
+     * @returns {Promise<SfTokens>}
+     */
+    async write() {
+        return this.config.write();
+    }
+    async init() {
+        this.config = await tokensConfig_1.TokensConfig.create();
+    }
+}
+exports.TokenAccessor = TokenAccessor;
+//# sourceMappingURL=tokenAccessor.js.map

package/lib/stateAggregator/index.d.ts

@@ -0,0 +1,4 @@
+export * from './accessors/orgAccessor';
+export * from './accessors/aliasAccessor';
+export * from './accessors/tokenAccessor';
+export * from './stateAggregator';

package/lib/stateAggregator/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./accessors/orgAccessor"), exports);
+__exportStar(require("./accessors/aliasAccessor"), exports);
+__exportStar(require("./accessors/tokenAccessor"), exports);
+__exportStar(require("./stateAggregator"), exports);
+//# sourceMappingURL=index.js.map

package/lib/stateAggregator/stateAggregator.d.ts

@@ -0,0 +1,25 @@
+import { AsyncOptionalCreatable } from '@salesforce/kit';
+import { AliasAccessor } from './accessors/aliasAccessor';
+import { OrgAccessor } from './accessors/orgAccessor';
+import { SandboxAccessor } from './accessors/sandboxAccessor';
+import { TokenAccessor } from './accessors/tokenAccessor';
+export declare class StateAggregator extends AsyncOptionalCreatable {
+    private static instanceMap;
+    aliases: AliasAccessor;
+    orgs: OrgAccessor;
+    sandboxes: SandboxAccessor;
+    tokens: TokenAccessor;
+    /**
+     * Reuse a StateAggregator if one was already created for the current global state directory
+     * Otherwise, create one and adds it to map for future reuse.
+     * HomeDir might be stubbed in tests
+     */
+    static getInstance(): Promise<StateAggregator>;
+    /**
+     * Clear the cache to force reading from disk.
+     *
+     * *NOTE: Only call this method if you must and you know what you are doing.*
+     */
+    static clearInstance(path?: string): void;
+    protected init(): Promise<void>;
+}

package/lib/stateAggregator/stateAggregator.js

@@ -0,0 +1,46 @@
+"use strict";
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAggregator = void 0;
+const kit_1 = require("@salesforce/kit");
+const global_1 = require("../global");
+const aliasAccessor_1 = require("./accessors/aliasAccessor");
+const orgAccessor_1 = require("./accessors/orgAccessor");
+const sandboxAccessor_1 = require("./accessors/sandboxAccessor");
+const tokenAccessor_1 = require("./accessors/tokenAccessor");
+class StateAggregator extends kit_1.AsyncOptionalCreatable {
+    /**
+     * Reuse a StateAggregator if one was already created for the current global state directory
+     * Otherwise, create one and adds it to map for future reuse.
+     * HomeDir might be stubbed in tests
+     */
+    static async getInstance() {
+        if (!StateAggregator.instanceMap.has(global_1.Global.DIR)) {
+            StateAggregator.instanceMap.set(global_1.Global.DIR, await StateAggregator.create());
+        }
+        // TS assertion is valid because there either was one OR it was just now instantiated
+        return StateAggregator.instanceMap.get(global_1.Global.DIR);
+    }
+    /**
+     * Clear the cache to force reading from disk.
+     *
+     * *NOTE: Only call this method if you must and you know what you are doing.*
+     */
+    static clearInstance(path = global_1.Global.DIR) {
+        StateAggregator.instanceMap.delete(path);
+    }
+    async init() {
+        this.orgs = await orgAccessor_1.OrgAccessor.create();
+        this.sandboxes = await sandboxAccessor_1.SandboxAccessor.create();
+        this.aliases = await aliasAccessor_1.AliasAccessor.create();
+        this.tokens = await tokenAccessor_1.TokenAccessor.create();
+    }
+}
+exports.StateAggregator = StateAggregator;
+StateAggregator.instanceMap = new Map();
+//# sourceMappingURL=stateAggregator.js.map

package/lib/status/myDomainResolver.d.ts

@@ -2,7 +2,7 @@
 import { URL } from 'url';
 import { AsyncOptionalCreatable, Duration } from '@salesforce/kit';
 /**
- * A class used to resolve MyDomains. After a ScratchOrg is created it's host name my not be propagated to the
+ * A class used to resolve MyDomains. After a ScratchOrg is created its host name my not be propagated to the
  * Salesforce DNS service. This service is not exclusive to Salesforce My Domain URL and could be used for any hostname.
  *
  * ```

package/lib/status/myDomainResolver.js

@@ -13,14 +13,14 @@ const util_1 = require("util");
 const ts_types_1 = require("@salesforce/ts-types");
 const kit_1 = require("@salesforce/kit");
 const logger_1 = require("../logger");
-const sfdc_1 = require("../util/sfdc");
+const sfdcUrl_1 = require("../util/sfdcUrl");
 const pollingClient_1 = require("./pollingClient");
 // Timeout for DNS lookup polling defaults to 3 seconds and should always be at least 3 seconds
 const DNS_TIMEOUT = Math.max(3, new kit_1.Env().getNumber('SFDX_DNS_TIMEOUT', 3));
 // Retry frequency for DNS lookup polling defaults to 1 second and should be at least 1 second
 const DNS_RETRY_FREQ = Math.max(1, new kit_1.Env().getNumber('SFDX_DNS_RETRY_FREQUENCY', 1));
 /**
- * A class used to resolve MyDomains. After a ScratchOrg is created it's host name my not be propagated to the
+ * A class used to resolve MyDomains. After a ScratchOrg is created its host name my not be propagated to the
  * Salesforce DNS service. This service is not exclusive to Salesforce My Domain URL and could be used for any hostname.
  *
  * ```
@@ -45,13 +45,13 @@ class MyDomainResolver extends kit_1.AsyncOptionalCreatable {
      */
     constructor(options) {
         super(options);
-        this.options = options || { url: MyDomainResolver.DEFAULT_DOMAIN };
+        this.options = options ?? { url: MyDomainResolver.DEFAULT_DOMAIN };
     }
     getTimeout() {
-        return this.options.timeout || kit_1.Duration.seconds(DNS_TIMEOUT);
+        return this.options.timeout ?? kit_1.Duration.seconds(DNS_TIMEOUT);
     }
     getFrequency() {
-        return this.options.frequency || kit_1.Duration.seconds(DNS_RETRY_FREQ);
+        return this.options.frequency ?? kit_1.Duration.seconds(DNS_RETRY_FREQ);
     }
     /**
      * Method that performs the dns lookup of the host. If the lookup fails the internal polling client will try again
@@ -69,17 +69,17 @@ class MyDomainResolver extends kit_1.AsyncOptionalCreatable {
         const self = this;
         const pollingOptions = {
             async poll() {
-                const host = self.options.url.host;
+                const { host } = self.options.url;
                 let dnsResult;
                 try {
                     self.logger.debug(`Attempting to resolve url: ${host}`);
-                    if (sfdc_1.sfdc.isLocalUrl(host)) {
+                    if (new sfdcUrl_1.SfdcUrl(self.options.url).isLocalUrl()) {
                         return {
                             completed: true,
                             payload: '127.0.0.1',
                         };
                     }
-                    dnsResult = await util_1.promisify(dns_1.lookup)(host);
+                    dnsResult = await (0, util_1.promisify)(dns_1.lookup)(host);
                     self.logger.debug(`Successfully resolved host: ${host} result: ${JSON.stringify(dnsResult)}`);
                     return {
                         completed: true,
@@ -100,12 +100,12 @@ class MyDomainResolver extends kit_1.AsyncOptionalCreatable {
             timeoutErrorName: 'MyDomainResolverTimeoutError',
         };
         const client = await pollingClient_1.PollingClient.create(pollingOptions);
-        return ts_types_1.ensureString(await client.subscribe());
+        return (0, ts_types_1.ensureString)(await client.subscribe());
     }
     async getCnames() {
         try {
             await this.resolve();
-            return await util_1.promisify(dns_1.resolveCname)(this.options.url.host);
+            return await (0, util_1.promisify)(dns_1.resolveCname)(this.options.url.host);
         }
         catch (e) {
             this.logger.debug(`An error occurred trying to resolve: ${this.options.url.host}`);

package/lib/status/pollingClient.d.ts

@@ -1,7 +1,7 @@
 import { AsyncOptionalCreatable, Duration } from '@salesforce/kit';
 import { AnyJson } from '@salesforce/ts-types';
 import { Logger } from '../logger';
-import { StatusResult } from './client';
+import { StatusResult } from './types';
 /**
  * This is a polling client that can be used to poll the status of long running tasks. It can be used as a replacement
  * for Streaming when streaming topics are not available or when streaming handshakes are failing. Why wouldn't you
@@ -23,8 +23,6 @@ import { StatusResult } from './client';
 export declare class PollingClient extends AsyncOptionalCreatable<PollingClient.Options> {
     protected logger: Logger;
     private options;
-    private timeout?;
-    private interval?;
     /**
      * Constructor
      *
@@ -40,9 +38,7 @@ export declare class PollingClient extends AsyncOptionalCreatable<PollingClient.
      * Returns a promise to call the specified polling function using the interval and timeout specified
      * in the polling options.
      */
-    subscribe(): Promise<AnyJson>;
-    private doPoll;
-    private clearAll;
+    subscribe<T = AnyJson>(): Promise<T>;
 }
 export declare namespace PollingClient {
     /**

package/lib/status/pollingClient.js

@@ -1,17 +1,18 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PollingClient = void 0;
 /*
  * Copyright (c) 2020, salesforce.com, inc.
  * All rights reserved.
  * 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
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PollingClient = void 0;
-const timers_1 = require("timers");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
+const ts_retry_promise_1 = require("ts-retry-promise");
 const logger_1 = require("../logger");
-const sfdxError_1 = require("../sfdxError");
+const sfError_1 = require("../sfError");
+const lifecycleEvents_1 = require("../lifecycleEvents");
 /**
  * This is a polling client that can be used to poll the status of long running tasks. It can be used as a replacement
  * for Streaming when streaming topics are not available or when streaming handshakes are failing. Why wouldn't you
@@ -39,7 +40,7 @@ class PollingClient extends kit_1.AsyncOptionalCreatable {
      */
     constructor(options) {
         super(options);
-        this.options = ts_types_1.ensure(options);
+        this.options = (0, ts_types_1.ensure)(options);
     }
     /**
      * Asynchronous initializer.
@@ -51,70 +52,43 @@ class PollingClient extends kit_1.AsyncOptionalCreatable {
      * Returns a promise to call the specified polling function using the interval and timeout specified
      * in the polling options.
      */
-    subscribe() {
-        // This promise is held open while setInterval tries to resolve or reject.
-        // If set interval can't do it then the timeout will reject.
-        return new Promise((resolve, reject) => {
-            // Use set interval to periodically call the polling function
-            // This try catch enables support for time{0} since setInterval only supports
-            // time {1}. In other words, we should call first then wait for the first interval.
-            this.doPoll()
-                .then((result) => {
-                if (result && result.completed) {
-                    resolve(result.payload);
-                }
-                else {
-                    this.interval = timers_1.setInterval(
-                    // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                    PollingClient.prototype.doPoll.bind(this, resolve, reject), this.options.frequency.milliseconds);
+    async subscribe() {
+        let errorInPollingFunction; // keep this around for returning in the catch block
+        const doPoll = async () => {
+            let result;
+            try {
+                result = await this.options.poll();
+            }
+            catch (error) {
+                const err = (errorInPollingFunction = error);
+                if (['ETIMEDOUT', 'ENOTFOUND', 'ECONNRESET', 'socket hang up'].some((retryableNetworkError) => err.message.includes(retryableNetworkError))) {
+                    this.logger.debug('Network error on the request', err);
+                    await lifecycleEvents_1.Lifecycle.getInstance().emitWarning('Network error occurred. Continuing to poll.');
+                    throw sfError_1.SfError.wrap(err);
                 }
-            })
-                .catch(() => {
-                this.interval = timers_1.setInterval(
-                // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                PollingClient.prototype.doPoll.bind(this, resolve, reject), this.options.frequency.milliseconds);
-            });
-            // hard polling timeout.
-            this.timeout = setTimeout(() => {
-                this.logger.debug('Polling timed out');
-                this.clearAll();
-                // @todo should go in messages.
-                reject(new sfdxError_1.SfdxError('The client has timed out.', this.options.timeoutErrorName || 'PollingClientTimeout'));
-            }, this.options.timeout.milliseconds);
+                // there was an actual error thrown, so we don't want to keep retrying
+                throw new ts_retry_promise_1.NotRetryableError(err.name);
+            }
+            if (result.completed) {
+                return result.payload;
+            }
+            throw new Error('Operation did not complete.  Retrying...'); // triggers a retry
+        };
+        const finalResult = (0, ts_retry_promise_1.retryDecorator)(doPoll, {
+            timeout: this.options.timeout.milliseconds,
+            delay: this.options.frequency.milliseconds,
+            retries: 'INFINITELY',
         });
-    }
-    async doPoll(resolve, reject) {
         try {
-            // Poll can be an async function.
-            const sample = await this.options.poll();
-            if (sample.completed) {
-                this.clearAll();
-                if (resolve) {
-                    resolve(sample.payload);
-                }
-                else {
-                    return sample;
-                }
-            }
+            return await finalResult();
         }
-        catch (e) {
-            this.clearAll();
-            if (reject) {
-                reject(e);
+        catch (error) {
+            if (errorInPollingFunction) {
+                throw errorInPollingFunction;
             }
-            else {
-                throw e;
-            }
-        }
-    }
-    clearAll() {
-        if (this.interval) {
-            this.logger.debug('Clearing the polling interval');
-            clearInterval(this.interval);
-        }
-        if (this.timeout) {
-            this.logger.debug('Clearing the timeout interval');
-            clearTimeout(this.timeout);
+            await lifecycleEvents_1.Lifecycle.getInstance().emit('POLLING_TIME_OUT', error);
+            this.logger.debug('Polling timed out');
+            throw new sfError_1.SfError('The client has timed out.', this.options.timeoutErrorName ?? 'PollingClientTimeout');
         }
     }
 }

package/lib/status/streamingClient.d.ts

@@ -1,75 +1,8 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
 import { AsyncOptionalCreatable, Duration, Env } from '@salesforce/kit/lib';
-import { AnyFunction, AnyJson, JsonMap } from '@salesforce/ts-types/lib';
+import { AnyJson } from '@salesforce/ts-types/lib';
 import { Org } from '../org/org';
-import { StatusResult } from './client';
-/**
- * Types for defining extensions.
- */
-export interface StreamingExtension {
-    /**
-     * Extension for outgoing message.
-     *
-     * @param message The message.
-     * @param callback The callback to invoke after the message is processed.
-     */
-    outgoing?: (message: JsonMap, callback: AnyFunction) => void;
-    /**
-     * Extension for the incoming message.
-     *
-     * @param message The message.
-     * @param callback The callback to invoke after the message is processed.
-     */
-    incoming?: (message: JsonMap, callback: AnyFunction) => void;
-}
-/**
- * Function type for processing messages
- */
-export declare type StreamProcessor = (message: JsonMap) => StatusResult;
-/**
- * Comet client interface. The is to allow for mocking the inner streaming Cometd implementation.
- * The Faye implementation is used by default but it could be used to adapt another Cometd impl.
- */
-export declare abstract class CometClient extends EventEmitter {
-    /**
-     * Disable polling features.
-     *
-     * @param label Polling feature label.
-     */
-    abstract disable(label: string): void;
-    /**
-     * Add a custom extension to the underlying client.
-     *
-     * @param extension The json function for the extension.
-     */
-    abstract addExtension(extension: StreamingExtension): void;
-    /**
-     * Sets an http header name/value.
-     *
-     * @param name The header name.
-     * @param value The header value.
-     */
-    abstract setHeader(name: string, value: string): void;
-    /**
-     * handshake with the streaming channel
-     *
-     * @param callback Callback for the handshake when it successfully completes. The handshake should throw
-     * errors when errors are encountered.
-     */
-    abstract handshake(callback: () => void): void;
-    /**
-     * Subscribes to Comet topics. Subscribe should perform a handshake if one hasn't been performed yet.
-     *
-     * @param channel The topic to subscribe to.
-     * @param callback The callback to execute once a message has been received.
-     */
-    abstract subscribe(channel: string, callback: (message: JsonMap) => void): CometSubscription;
-    /**
-     * Method to call to disconnect the client from the server.
-     */
-    abstract disconnect(): void;
-}
+import { CometClient, CometSubscription, Message, StatusResult, StreamingExtension, StreamProcessor } from './types';
+export { CometClient, CometSubscription, Message, StatusResult, StreamingExtension, StreamProcessor };
 /**
  * Inner streaming client interface. This implements the Cometd behavior.
  * Also allows for mocking the functional behavior.
@@ -88,13 +21,6 @@ export interface StreamingClientIfc {
      */
     setLogger: (logLine: (message: string) => void) => void;
 }
-/**
- * The subscription object returned from the cometd subscribe object.
- */
-export interface CometSubscription {
-    callback(callback: () => void): void;
-    errback(callback: (error: Error) => void): void;
-}
 /**
  * Api wrapper to support Salesforce streaming. The client contains an internal implementation of a cometd specification.
  *
@@ -187,12 +113,12 @@ export declare class StreamingClient extends AsyncOptionalCreatable<StreamingCli
      * Subscribe to streaming events. When the streaming processor that's set in the options completes execution it
      * returns a payload in the StatusResult object. The payload is just echoed here for convenience.
      *
-     * **Throws** *{@link SfdxError}{ name: '{@link StreamingClient.TimeoutErrorType.SUBSCRIBE}'}* When the subscribe timeout occurs.
+     * **Throws** *{@link SfError}{ name: '{@link StreamingClient.TimeoutErrorType.SUBSCRIBE}'}* When the subscribe timeout occurs.
      *
      * @param streamInit This function should call the platform apis that result in streaming updates on push topics.
      * {@link StatusResult}
      */
-    subscribe(streamInit?: () => Promise<void>): Promise<AnyJson>;
+    subscribe(streamInit?: () => Promise<void>): Promise<AnyJson | void>;
     /**
      * Handler for incoming streaming messages.
      *
@@ -261,7 +187,6 @@ export declare namespace StreamingClient {
         handshakeTimeout: Duration;
         channel: string;
         streamingImpl: StreamingClientIfc;
-        private envDep;
         /**
          * Constructor for DefaultStreamingOptions
          *