@salesforce/core 3.31.4 → 3.31.7

package/lib/status/myDomainResolver.js

@@ -1,125 +1,125 @@
-"use strict";
-/*
- * 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.MyDomainResolver = void 0;
-const dns_1 = require("dns");
-const url_1 = require("url");
-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 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 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.
- *
- * ```
- * (async () => {
- *  const options: MyDomainResolver.Options = {
- *      url: new URL('http://mydomain.salesforce.com'),
- *      timeout: Duration.minutes(5),
- *      frequency: Duration.seconds(10)
- *  };
- *  const resolver: MyDomainResolver = await MyDomainResolver.create(options);
- *  const ipAddress: AnyJson = await resolver.resolve();
- *  console.log(`Successfully resolved host: ${options.url} to address: ${ipAddress}`);
- * })();
- * ```
- */
-class MyDomainResolver extends kit_1.AsyncOptionalCreatable {
-    /**
-     * Constructor
-     * **Do not directly construct instances of this class -- use {@link MyDomainResolver.create} instead.**
-     *
-     * @param options The options for the class instance
-     */
-    constructor(options) {
-        super(options);
-        this.options = options ?? { url: MyDomainResolver.DEFAULT_DOMAIN };
-    }
-    getTimeout() {
-        return this.options.timeout ?? kit_1.Duration.seconds(DNS_TIMEOUT);
-    }
-    getFrequency() {
-        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
-     * given the optional interval. Returns the resolved ip address.
-     *
-     * If SFDX_DISABLE_DNS_CHECK environment variable is set to true, it will immediately return the host without
-     * executing the dns loookup.
-     */
-    async resolve() {
-        if (new kit_1.Env().getBoolean('SFDX_DISABLE_DNS_CHECK', false)) {
-            this.logger.debug('SFDX_DISABLE_DNS_CHECK set to true. Skipping DNS check...');
-            return this.options.url.host;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        const pollingOptions = {
-            async poll() {
-                const { host } = self.options.url;
-                let dnsResult;
-                try {
-                    self.logger.debug(`Attempting to resolve url: ${host}`);
-                    if (new sfdcUrl_1.SfdcUrl(self.options.url).isLocalUrl()) {
-                        return {
-                            completed: true,
-                            payload: '127.0.0.1',
-                        };
-                    }
-                    dnsResult = await (0, util_1.promisify)(dns_1.lookup)(host);
-                    self.logger.debug(`Successfully resolved host: ${host} result: ${JSON.stringify(dnsResult)}`);
-                    return {
-                        completed: true,
-                        payload: dnsResult.address,
-                    };
-                }
-                catch (e) {
-                    self.logger.debug(`An error occurred trying to resolve: ${host}`);
-                    self.logger.debug(`Error: ${e.message}`);
-                    self.logger.debug('Re-trying dns lookup again....');
-                    return {
-                        completed: false,
-                    };
-                }
-            },
-            timeout: this.getTimeout(),
-            frequency: this.getFrequency(),
-            timeoutErrorName: 'MyDomainResolverTimeoutError',
-        };
-        const client = await pollingClient_1.PollingClient.create(pollingOptions);
-        return (0, ts_types_1.ensureString)(await client.subscribe());
-    }
-    async getCnames() {
-        try {
-            await this.resolve();
-            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}`);
-            this.logger.debug(`Error: ${e.message}`);
-            return [];
-        }
-    }
-    /**
-     * Used to initialize asynchronous components.
-     */
-    async init() {
-        this.logger = await logger_1.Logger.child('MyDomainResolver');
-    }
-}
-exports.MyDomainResolver = MyDomainResolver;
-MyDomainResolver.DEFAULT_DOMAIN = new url_1.URL('https://login.salesforce.com');
+"use strict";
+/*
+ * 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.MyDomainResolver = void 0;
+const dns_1 = require("dns");
+const url_1 = require("url");
+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 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 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.
+ *
+ * ```
+ * (async () => {
+ *  const options: MyDomainResolver.Options = {
+ *      url: new URL('http://mydomain.salesforce.com'),
+ *      timeout: Duration.minutes(5),
+ *      frequency: Duration.seconds(10)
+ *  };
+ *  const resolver: MyDomainResolver = await MyDomainResolver.create(options);
+ *  const ipAddress: AnyJson = await resolver.resolve();
+ *  console.log(`Successfully resolved host: ${options.url} to address: ${ipAddress}`);
+ * })();
+ * ```
+ */
+class MyDomainResolver extends kit_1.AsyncOptionalCreatable {
+    /**
+     * Constructor
+     * **Do not directly construct instances of this class -- use {@link MyDomainResolver.create} instead.**
+     *
+     * @param options The options for the class instance
+     */
+    constructor(options) {
+        super(options);
+        this.options = options ?? { url: MyDomainResolver.DEFAULT_DOMAIN };
+    }
+    getTimeout() {
+        return this.options.timeout ?? kit_1.Duration.seconds(DNS_TIMEOUT);
+    }
+    getFrequency() {
+        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
+     * given the optional interval. Returns the resolved ip address.
+     *
+     * If SFDX_DISABLE_DNS_CHECK environment variable is set to true, it will immediately return the host without
+     * executing the dns loookup.
+     */
+    async resolve() {
+        if (new kit_1.Env().getBoolean('SFDX_DISABLE_DNS_CHECK', false)) {
+            this.logger.debug('SFDX_DISABLE_DNS_CHECK set to true. Skipping DNS check...');
+            return this.options.url.host;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const pollingOptions = {
+            async poll() {
+                const { host } = self.options.url;
+                let dnsResult;
+                try {
+                    self.logger.debug(`Attempting to resolve url: ${host}`);
+                    if (new sfdcUrl_1.SfdcUrl(self.options.url).isLocalUrl()) {
+                        return {
+                            completed: true,
+                            payload: '127.0.0.1',
+                        };
+                    }
+                    dnsResult = await (0, util_1.promisify)(dns_1.lookup)(host);
+                    self.logger.debug(`Successfully resolved host: ${host} result: ${JSON.stringify(dnsResult)}`);
+                    return {
+                        completed: true,
+                        payload: dnsResult.address,
+                    };
+                }
+                catch (e) {
+                    self.logger.debug(`An error occurred trying to resolve: ${host}`);
+                    self.logger.debug(`Error: ${e.message}`);
+                    self.logger.debug('Re-trying dns lookup again....');
+                    return {
+                        completed: false,
+                    };
+                }
+            },
+            timeout: this.getTimeout(),
+            frequency: this.getFrequency(),
+            timeoutErrorName: 'MyDomainResolverTimeoutError',
+        };
+        const client = await pollingClient_1.PollingClient.create(pollingOptions);
+        return (0, ts_types_1.ensureString)(await client.subscribe());
+    }
+    async getCnames() {
+        try {
+            await this.resolve();
+            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}`);
+            this.logger.debug(`Error: ${e.message}`);
+            return [];
+        }
+    }
+    /**
+     * Used to initialize asynchronous components.
+     */
+    async init() {
+        this.logger = await logger_1.Logger.child('MyDomainResolver');
+    }
+}
+exports.MyDomainResolver = MyDomainResolver;
+MyDomainResolver.DEFAULT_DOMAIN = new url_1.URL('https://login.salesforce.com');
 //# sourceMappingURL=myDomainResolver.js.map

package/lib/status/pollingClient.d.ts

@@ -1,85 +1,85 @@
-import { AsyncOptionalCreatable, Duration } from '@salesforce/kit';
-import { AnyJson } from '@salesforce/ts-types';
-import { Logger } from '../logger';
-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
- * want to use this? It can impact Salesforce API usage.
- *
- * ```
- * const options: PollingClient.Options = {
- *      async poll(): Promise<StatusResult>  {
- *       return Promise.resolve({ completed: true, payload: 'Hello World' });
- *     },
- *     frequency: Duration.milliseconds(10),
- *      timeout: Duration.minutes(1)
- *   };
- * const client = await PollingClient.create(options);
- * const pollResult = await client.subscribe();
- * console.log(`pollResult: ${pollResult}`);
- * ```
- */
-export declare class PollingClient extends AsyncOptionalCreatable<PollingClient.Options> {
-    protected logger: Logger;
-    private options;
-    /**
-     * Constructor
-     *
-     * @param options Polling client options
-     * @ignore
-     */
-    constructor(options?: PollingClient.Options);
-    /**
-     * Asynchronous initializer.
-     */
-    init(): Promise<void>;
-    /**
-     * Returns a promise to call the specified polling function using the interval and timeout specified
-     * in the polling options.
-     */
-    subscribe<T = AnyJson>(): Promise<T>;
-}
-export declare namespace PollingClient {
-    /**
-     * Options for the polling client.
-     */
-    interface Options {
-        /**
-         * Polling function.
-         */
-        poll: () => Promise<StatusResult>;
-        /**
-         * How frequent should the polling function be called.
-         */
-        frequency: Duration;
-        /**
-         * Hard timeout for polling.
-         */
-        timeout: Duration;
-        /**
-         * Change the name of the timeout error.
-         *
-         * ```
-         * if (err.name === 'MyChangedName) ...
-         * ```
-         */
-        timeoutErrorName?: string;
-    }
-    /**
-     * Default options set for polling. The default options specify a timeout of 3 minutes and polling frequency of 15
-     * seconds;
-     */
-    class DefaultPollingOptions implements PollingClient.Options {
-        frequency: Duration;
-        poll: () => Promise<StatusResult>;
-        timeout: Duration;
-        /**
-         * constructor
-         *
-         * @param poll The function used for polling status.
-         * {@link StatusResult}
-         */
-        constructor(poll: () => Promise<StatusResult>);
-    }
-}
+import { AsyncOptionalCreatable, Duration } from '@salesforce/kit';
+import { AnyJson } from '@salesforce/ts-types';
+import { Logger } from '../logger';
+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
+ * want to use this? It can impact Salesforce API usage.
+ *
+ * ```
+ * const options: PollingClient.Options = {
+ *      async poll(): Promise<StatusResult>  {
+ *       return Promise.resolve({ completed: true, payload: 'Hello World' });
+ *     },
+ *     frequency: Duration.milliseconds(10),
+ *      timeout: Duration.minutes(1)
+ *   };
+ * const client = await PollingClient.create(options);
+ * const pollResult = await client.subscribe();
+ * console.log(`pollResult: ${pollResult}`);
+ * ```
+ */
+export declare class PollingClient extends AsyncOptionalCreatable<PollingClient.Options> {
+    protected logger: Logger;
+    private options;
+    /**
+     * Constructor
+     *
+     * @param options Polling client options
+     * @ignore
+     */
+    constructor(options?: PollingClient.Options);
+    /**
+     * Asynchronous initializer.
+     */
+    init(): Promise<void>;
+    /**
+     * Returns a promise to call the specified polling function using the interval and timeout specified
+     * in the polling options.
+     */
+    subscribe<T = AnyJson>(): Promise<T>;
+}
+export declare namespace PollingClient {
+    /**
+     * Options for the polling client.
+     */
+    interface Options {
+        /**
+         * Polling function.
+         */
+        poll: () => Promise<StatusResult>;
+        /**
+         * How frequent should the polling function be called.
+         */
+        frequency: Duration;
+        /**
+         * Hard timeout for polling.
+         */
+        timeout: Duration;
+        /**
+         * Change the name of the timeout error.
+         *
+         * ```
+         * if (err.name === 'MyChangedName) ...
+         * ```
+         */
+        timeoutErrorName?: string;
+    }
+    /**
+     * Default options set for polling. The default options specify a timeout of 3 minutes and polling frequency of 15
+     * seconds;
+     */
+    class DefaultPollingOptions implements PollingClient.Options {
+        frequency: Duration;
+        poll: () => Promise<StatusResult>;
+        timeout: Duration;
+        /**
+         * constructor
+         *
+         * @param poll The function used for polling status.
+         * {@link StatusResult}
+         */
+        constructor(poll: () => Promise<StatusResult>);
+    }
+}

package/lib/status/pollingClient.js

@@ -1,116 +1,116 @@
-"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
- */
-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 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
- * want to use this? It can impact Salesforce API usage.
- *
- * ```
- * const options: PollingClient.Options = {
- *      async poll(): Promise<StatusResult>  {
- *       return Promise.resolve({ completed: true, payload: 'Hello World' });
- *     },
- *     frequency: Duration.milliseconds(10),
- *      timeout: Duration.minutes(1)
- *   };
- * const client = await PollingClient.create(options);
- * const pollResult = await client.subscribe();
- * console.log(`pollResult: ${pollResult}`);
- * ```
- */
-class PollingClient extends kit_1.AsyncOptionalCreatable {
-    /**
-     * Constructor
-     *
-     * @param options Polling client options
-     * @ignore
-     */
-    constructor(options) {
-        super(options);
-        this.options = (0, ts_types_1.ensure)(options);
-    }
-    /**
-     * Asynchronous initializer.
-     */
-    async init() {
-        this.logger = await logger_1.Logger.child(this.constructor.name);
-    }
-    /**
-     * Returns a promise to call the specified polling function using the interval and timeout specified
-     * in the polling options.
-     */
-    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);
-                }
-                // 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',
-        });
-        try {
-            return await finalResult();
-        }
-        catch (error) {
-            if (errorInPollingFunction) {
-                throw errorInPollingFunction;
-            }
-            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');
-        }
-    }
-}
-exports.PollingClient = PollingClient;
-(function (PollingClient) {
-    /**
-     * Default options set for polling. The default options specify a timeout of 3 minutes and polling frequency of 15
-     * seconds;
-     */
-    class DefaultPollingOptions {
-        /**
-         * constructor
-         *
-         * @param poll The function used for polling status.
-         * {@link StatusResult}
-         */
-        constructor(poll) {
-            this.poll = poll;
-            this.timeout = kit_1.Duration.minutes(3);
-            this.frequency = kit_1.Duration.seconds(15);
-        }
-    }
-    PollingClient.DefaultPollingOptions = DefaultPollingOptions;
-})(PollingClient = exports.PollingClient || (exports.PollingClient = {}));
+"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
+ */
+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 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
+ * want to use this? It can impact Salesforce API usage.
+ *
+ * ```
+ * const options: PollingClient.Options = {
+ *      async poll(): Promise<StatusResult>  {
+ *       return Promise.resolve({ completed: true, payload: 'Hello World' });
+ *     },
+ *     frequency: Duration.milliseconds(10),
+ *      timeout: Duration.minutes(1)
+ *   };
+ * const client = await PollingClient.create(options);
+ * const pollResult = await client.subscribe();
+ * console.log(`pollResult: ${pollResult}`);
+ * ```
+ */
+class PollingClient extends kit_1.AsyncOptionalCreatable {
+    /**
+     * Constructor
+     *
+     * @param options Polling client options
+     * @ignore
+     */
+    constructor(options) {
+        super(options);
+        this.options = (0, ts_types_1.ensure)(options);
+    }
+    /**
+     * Asynchronous initializer.
+     */
+    async init() {
+        this.logger = await logger_1.Logger.child(this.constructor.name);
+    }
+    /**
+     * Returns a promise to call the specified polling function using the interval and timeout specified
+     * in the polling options.
+     */
+    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);
+                }
+                // 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',
+        });
+        try {
+            return await finalResult();
+        }
+        catch (error) {
+            if (errorInPollingFunction) {
+                throw errorInPollingFunction;
+            }
+            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');
+        }
+    }
+}
+exports.PollingClient = PollingClient;
+(function (PollingClient) {
+    /**
+     * Default options set for polling. The default options specify a timeout of 3 minutes and polling frequency of 15
+     * seconds;
+     */
+    class DefaultPollingOptions {
+        /**
+         * constructor
+         *
+         * @param poll The function used for polling status.
+         * {@link StatusResult}
+         */
+        constructor(poll) {
+            this.poll = poll;
+            this.timeout = kit_1.Duration.minutes(3);
+            this.frequency = kit_1.Duration.seconds(15);
+        }
+    }
+    PollingClient.DefaultPollingOptions = DefaultPollingOptions;
+})(PollingClient = exports.PollingClient || (exports.PollingClient = {}));
 //# sourceMappingURL=pollingClient.js.map