@salesforce/core 3.13.0 → 3.15.0

package/lib/org/org.js

@@ -14,7 +14,6 @@ const ts_types_1 = require("@salesforce/ts-types");
 const config_1 = require("../config/config");
 const configAggregator_1 = require("../config/configAggregator");
 const orgUsersConfig_1 = require("../config/orgUsersConfig");
-const sandboxOrgConfig_1 = require("../config/sandboxOrgConfig");
 const global_1 = require("../global");
 const lifecycleEvents_1 = require("../lifecycleEvents");
 const logger_1 = require("../logger");
@@ -23,6 +22,7 @@ const sfdc_1 = require("../util/sfdc");
 const webOAuthServer_1 = require("../webOAuthServer");
 const messages_1 = require("../messages");
 const globalInfo_1 = require("../globalInfo");
+const pollingClient_1 = require("../status/pollingClient");
 const connection_1 = require("./connection");
 const authInfo_1 = require("./authInfo");
 const scratchOrgCreate_1 = require("./scratchOrgCreate");
@@ -35,11 +35,12 @@ const messages = messages_1.Messages.load('@salesforce/core', 'org', [
     'noDevHubFound',
     'notADevHub',
     'noUsernameFound',
-    'orgPollingTimeout',
     'sandboxDeleteFailed',
     'sandboxInfoCreateFailed',
     'sandboxNotFound',
     'scratchOrgNotFound',
+    'AuthInfoOrgIdUndefined',
+    'sandboxCreateNotComplete',
 ]);
 var OrgTypes;
 (function (OrgTypes) {
@@ -52,6 +53,7 @@ var SandboxEvents;
     SandboxEvents["EVENT_ASYNC_RESULT"] = "asyncResult";
     SandboxEvents["EVENT_RESULT"] = "result";
     SandboxEvents["EVENT_AUTH"] = "auth";
+    SandboxEvents["EVENT_RESUME"] = "resume";
 })(SandboxEvents = exports.SandboxEvents || (exports.SandboxEvents = {}));
 /**
  * Provides a way to manage a locally authenticated Org.
@@ -95,23 +97,88 @@ class Org extends kit_1.AsyncOptionalCreatable {
      * @param sandboxReq SandboxRequest options to create the sandbox with
      * @param options Wait: The amount of time to wait before timing out, Interval: The time interval between polling
      */
-    async createSandbox(sandboxReq, options) {
-        var _a;
-        this.logger.debug('CreateSandbox called with SandboxRequest: %s ', sandboxReq);
+    async createSandbox(sandboxReq, options = {
+        wait: kit_1.Duration.minutes(6),
+        async: false,
+        interval: kit_1.Duration.seconds(30),
+    }) {
+        this.logger.debug('CreateSandbox called with SandboxRequest:', sandboxReq);
         const createResult = await this.connection.tooling.create('SandboxInfo', sandboxReq);
-        this.logger.debug('Return from calling tooling.create: %s ', createResult);
+        this.logger.debug('Return from calling tooling.create:', createResult);
         if (Array.isArray(createResult) || !createResult.success) {
             throw messages.createError('sandboxInfoCreateFailed', [JSON.stringify(createResult)]);
         }
-        const sandboxCreationProgress = await this.querySandboxProcess(createResult.id);
-        this.logger.debug('Return from calling singleRecordQuery with tooling: %s', sandboxCreationProgress);
-        const retries = options.wait ? options.wait.seconds / kit_1.Duration.seconds(30).seconds : 0;
-        this.logger.debug('pollStatusAndAuth sandboxProcessObj %s, maxPollingRetries %i', sandboxCreationProgress, retries);
-        const pollInterval = (_a = options.interval) !== null && _a !== void 0 ? _a : kit_1.Duration.seconds(30);
+        const sandboxCreationProgress = await this.querySandboxProcessBySandboxInfoId(createResult.id);
+        this.logger.debug('Return from calling singleRecordQuery with tooling:', sandboxCreationProgress);
+        const isAsync = !!options.async;
+        if (isAsync) {
+            // The user didn't want us to poll, so simply return the status
+            await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_ASYNC_RESULT, sandboxCreationProgress);
+            return sandboxCreationProgress;
+        }
+        const [wait, pollInterval] = this.validateWaitOptions(options);
+        this.logger.debug(`create - pollStatusAndAuth sandboxProcessObj, max wait time of ${wait.minutes} minutes`, sandboxCreationProgress);
+        return this.pollStatusAndAuth({
+            sandboxProcessObj: sandboxCreationProgress,
+            wait,
+            pollInterval,
+        });
+    }
+    /**
+     * resume a sandbox creation from a production org
+     * 'this' needs to be a production org with sandbox licenses available
+     *
+     * @param resumeSandboxRequest SandboxRequest options to create the sandbox with
+     * @param options Wait: The amount of time to wait (default: 30 minutes) before timing out,
+     * Interval: The time interval (default: 30 seconds) between polling
+     */
+    async resumeSandbox(resumeSandboxRequest, options = {
+        wait: kit_1.Duration.minutes(0),
+        async: false,
+        interval: kit_1.Duration.seconds(30),
+    }) {
+        var _a;
+        this.logger.debug('ResumeSandbox called with ResumeSandboxRequest:', resumeSandboxRequest);
+        let sandboxCreationProgress;
+        // seed the sandboxCreationProgress via the resumeSandboxRequest options
+        if (resumeSandboxRequest.SandboxName) {
+            sandboxCreationProgress = await this.querySandboxProcessBySandboxName(resumeSandboxRequest.SandboxName);
+        }
+        else if (resumeSandboxRequest.SandboxProcessObjId) {
+            sandboxCreationProgress = await this.querySandboxProcessById(resumeSandboxRequest.SandboxProcessObjId);
+        }
+        else {
+            throw messages.createError('sandboxNotFound', [
+                (_a = resumeSandboxRequest.SandboxName) !== null && _a !== void 0 ? _a : resumeSandboxRequest.SandboxProcessObjId,
+            ]);
+        }
+        this.logger.debug('Return from calling singleRecordQuery with tooling:', sandboxCreationProgress);
+        await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_RESUME, sandboxCreationProgress);
+        const [wait, pollInterval] = this.validateWaitOptions(options);
+        // if wait is 0, return the sandboxCreationProgress immediately
+        if (wait.seconds === 0) {
+            if (sandboxCreationProgress.Status === 'Completed') {
+                // check to see if sandbox can authenticate via sandboxAuth endpoint
+                const sandboxInfo = await this.sandboxSignupComplete(sandboxCreationProgress);
+                if (sandboxInfo) {
+                    await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_AUTH, sandboxInfo);
+                    try {
+                        this.logger.debug('sandbox signup complete with', sandboxInfo);
+                        await this.writeSandboxAuthFile(sandboxCreationProgress, sandboxInfo);
+                        return sandboxCreationProgress;
+                    }
+                    catch (err) {
+                        // eat the error, we don't want to throw an error if we can't write the file
+                    }
+                }
+            }
+            await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_ASYNC_RESULT, sandboxCreationProgress);
+            throw messages.createError('sandboxCreateNotComplete');
+        }
+        this.logger.debug(`resume - pollStatusAndAuth sandboxProcessObj, max wait time of ${wait.minutes} minutes`, sandboxCreationProgress);
         return this.pollStatusAndAuth({
             sandboxProcessObj: sandboxCreationProgress,
-            retries,
-            shouldPoll: retries > 0,
+            wait,
             pollInterval,
         });
     }
@@ -156,9 +223,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
         return await orgUsersConfig_1.OrgUsersConfig.create(orgUsersConfig_1.OrgUsersConfig.getOptions(this.getOrgId()));
     }
     /**
-     * Removes the scratch org config file at $HOME/.sfdx/[name].json, any project level org
-     * files, all user auth files for the org, matching default config settings, and any
-     * matching aliases.
+     * Cleans up all org related artifacts including users, sandbox config(if a sandbox and auth file.
      *
      * @param throwWhenRemoveFails Determines if the call should throw an error or fail silently.
      */
@@ -168,7 +233,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
         if (this.getConnection().isUsingAccessToken()) {
             return Promise.resolve();
         }
-        await this.removeSandboxConfig(throwWhenRemoveFails);
+        await this.removeSandboxConfig();
         await this.removeUsers(throwWhenRemoveFails);
         await this.removeUsersConfig();
         // An attempt to remove this org's auth file occurs in this.removeUsersConfig. That's because this org's usersname is also
@@ -182,7 +247,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
      *
      */
     async isSandbox() {
-        return !!(await this.getSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME));
+        return (await globalInfo_1.GlobalInfo.getInstance()).sandboxes.has(this.getOrgId());
     }
     /**
      * Check that this org is a scratch org by asking the dev hub if it knows about it.
@@ -491,25 +556,22 @@ class Org extends kit_1.AsyncOptionalCreatable {
         return this;
     }
     /**
-     * Sets the key/value pair in the sandbox config for this org. For convenience `this` object is returned.
-     *
+     * set the sandbox config related to this given org
      *
-     * @param {key} The key for this value
-     * @param {value} The value to save
+     * @param orgId {string} orgId of the sandbox
+     * @param config {SfSandbox} config of the sandbox
      */
-    async setSandboxOrgConfigField(field, value) {
-        const sandboxOrgConfig = await this.retrieveSandboxOrgConfig();
-        sandboxOrgConfig.set(field, value);
-        await sandboxOrgConfig.write();
+    async setSandboxConfig(orgId, config) {
+        (await globalInfo_1.GlobalInfo.getInstance()).sandboxes.set(orgId, config);
         return this;
     }
     /**
-     * Returns an org config field. Returns undefined if the field is not set or invalid.
+     * get the sandbox config for the given orgId
+     *
+     * @param orgId {string} orgId of the sandbox
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async getSandboxOrgConfigField(field) {
-        const sandboxOrgConfig = await this.retrieveSandboxOrgConfig();
-        return sandboxOrgConfig.get(field);
+    async getSandboxConfig(orgId) {
+        return (await globalInfo_1.GlobalInfo.getInstance()).sandboxes.get(orgId);
     }
     /**
      * Retrieves the highest api version that is supported by the target server instance. If the apiVersion configured for
@@ -566,6 +628,53 @@ class Org extends kit_1.AsyncOptionalCreatable {
     getConnection() {
         return this.connection;
     }
+    async supportsSourceTracking() {
+        if (this.isScratch()) {
+            return true;
+        }
+        const conn = this.getConnection();
+        try {
+            await conn.tooling.sobject('SourceMember').describe();
+            return true;
+        }
+        catch (err) {
+            if (err.message.includes('The requested resource does not exist')) {
+                return false;
+            }
+            throw err;
+        }
+    }
+    /**
+     * query SandboxProcess via sandbox name
+     *
+     * @param name SandboxName to query for
+     * @private
+     */
+    async querySandboxProcessBySandboxName(name) {
+        return await this.querySandboxProcess(`SandboxName='${name}'`);
+    }
+    /**
+     * query SandboxProcess via SandboxInfoId
+     *
+     * @param id SandboxInfoId to query for
+     * @private
+     */
+    async querySandboxProcessBySandboxInfoId(id) {
+        return await this.querySandboxProcess(`SandboxInfoId='${id}'`);
+        const queryStr = `SELECT Id, Status, SandboxName, SandboxInfoId, LicenseType, CreatedDate, CopyProgress, SandboxOrganization, SourceId, Description, EndDate FROM SandboxProcess WHERE SandboxInfoId='${id}' AND Status != 'D'`;
+        return await this.connection.singleRecordQuery(queryStr, {
+            tooling: true,
+        });
+    }
+    /**
+     * query SandboxProcess via Id
+     *
+     * @param id SandboxProcessId to query for
+     * @private
+     */
+    async querySandboxProcessById(id) {
+        return await this.querySandboxProcess(`Id='${id}'`);
+    }
     /**
      * Initialize async components.
      */
@@ -617,47 +726,53 @@ class Org extends kit_1.AsyncOptionalCreatable {
      * @private
      */
     async deleteSandbox(prodOrg) {
+        const sandbox = await this.getSandboxConfig(this.getOrgId());
         prodOrg !== null && prodOrg !== void 0 ? prodOrg : (prodOrg = await Org.create({
             aggregator: this.configAggregator,
-            aliasOrUsername: await this.getSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME),
+            aliasOrUsername: sandbox === null || sandbox === void 0 ? void 0 : sandbox.prodOrgUsername,
         }));
-        let result;
-        // attempt to locate sandbox id by username
-        try {
-            // try to calculate sandbox name from the production org
-            // production org: admin@integrationtesthub.org
-            // this.getUsername: admin@integrationtesthub.org.dev1
-            // sandboxName in Production: dev1
-            const sandboxName = (this.getUsername() || '').split(`${prodOrg.getUsername()}.`)[1];
-            if (!sandboxName) {
-                this.logger.debug('Could not construct a sandbox name');
-                throw new Error();
-            }
-            this.logger.debug(`attempting to locate sandbox with username ${sandboxName}`);
-            result = await this.queryProduction(prodOrg, 'SandboxName', sandboxName);
-            if (!result) {
-                this.logger.debug(`Failed to find sandbox with username: ${sandboxName}`);
-                throw new Error();
-            }
-        }
-        catch {
-            // if an error is thrown, don't panic yet. we'll try querying by orgId
-            const trimmedId = sfdc_1.sfdc.trimTo15(this.getOrgId());
-            this.logger.debug(`defaulting to trimming id from ${this.getOrgId()} to ${trimmedId}`);
+        let sandboxInfoId = sandbox === null || sandbox === void 0 ? void 0 : sandbox.sandboxInfoId;
+        if (!sandboxInfoId) {
+            let result;
             try {
-                result = await this.queryProduction(prodOrg, 'SandboxOrganization', trimmedId);
+                // grab sandboxName from config or try to calculate from the sandbox username
+                const sandboxName = (sandbox === null || sandbox === void 0 ? void 0 : sandbox.sandboxName) || (this.getUsername() || '').split(`${prodOrg.getUsername()}.`)[1];
+                if (!sandboxName) {
+                    this.logger.debug('Sandbox name is not available');
+                    // jump to query by orgId
+                    throw new Error();
+                }
+                this.logger.debug(`attempting to locate sandbox with sandbox ${sandboxName}`);
+                try {
+                    result = await this.queryProduction(prodOrg, 'SandboxName', sandboxName);
+                }
+                catch (err) {
+                    this.logger.debug(`Failed to find sandbox with sandbox name: ${sandboxName}`);
+                    // jump to query by orgId
+                    throw err;
+                }
             }
             catch {
-                throw messages.createError('sandboxNotFound', [trimmedId]);
+                // if an error is thrown, don't panic yet. we'll try querying by orgId
+                const trimmedId = sfdc_1.sfdc.trimTo15(this.getOrgId());
+                this.logger.debug(`defaulting to trimming id from ${this.getOrgId()} to ${trimmedId}`);
+                try {
+                    result = await this.queryProduction(prodOrg, 'SandboxOrganization', trimmedId);
+                    sandboxInfoId = result.SandboxInfoId;
+                }
+                catch {
+                    // eating exceptions when trying to find sandbox process record by orgId
+                    // allows idempotent cleanup of sandbox orgs
+                    this.logger.debug(`Failed find a SandboxProcess for the sandbox org: ${this.getOrgId()}`);
+                }
             }
         }
-        // const deleteResult = await prodOrg.connection.tooling.delete('SandboxInfo', result.SandboxInfoId);
-        const deleteResult = await this.destroySandbox(prodOrg, result.SandboxInfoId);
-        this.logger.debug('Return from calling tooling.delete: %o ', deleteResult);
-        await this.remove();
-        if (Array.isArray(deleteResult) || !deleteResult.success) {
-            throw messages.createError('sandboxDeleteFailed', [JSON.stringify(deleteResult)]);
+        if (sandboxInfoId) {
+            const deleteResult = await this.destroySandbox(prodOrg, sandboxInfoId);
+            this.logger.debug('Return from calling tooling.delete: ', deleteResult);
         }
+        // cleanup remaining artifacts
+        await this.remove();
     }
     /**
      * If this Org is a scratch org, calling this method will delete the scratch org from the DevHub and clean up any local files
@@ -725,12 +840,6 @@ class Org extends kit_1.AsyncOptionalCreatable {
             await config.unlink();
         }
     }
-    /**
-     * @ignore
-     */
-    async retrieveSandboxOrgConfig() {
-        return await sandboxOrgConfig_1.SandboxOrgConfig.create(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(this.getOrgId()));
-    }
     async manageDelete(cb, dirPath, throwWhenRemoveFails) {
         return cb().catch((e) => {
             if (throwWhenRemoveFails) {
@@ -775,22 +884,16 @@ class Org extends kit_1.AsyncOptionalCreatable {
         }));
         await globalInfo.write();
     }
-    /**
-     * Remove an associate sandbox config.
-     *
-     * @param throwWhenRemoveFails true if manageDelete should throw or not if the deleted fails.
-     */
-    async removeSandboxConfig(throwWhenRemoveFails) {
-        const sandboxOrgConfig = await this.retrieveSandboxOrgConfig();
-        if (await sandboxOrgConfig.exists()) {
-            await this.manageDelete(async () => await sandboxOrgConfig.unlink(), sandboxOrgConfig.getPath(), throwWhenRemoveFails);
-        }
+    async removeSandboxConfig() {
+        const globalInfo = await globalInfo_1.GlobalInfo.getInstance();
+        globalInfo.sandboxes.unset(this.getOrgId());
+        await globalInfo.write();
     }
     async writeSandboxAuthFile(sandboxProcessObj, sandboxRes) {
-        this.logger.debug('writeSandboxAuthFile sandboxProcessObj: %s, sandboxRes: %s', sandboxProcessObj, sandboxRes);
+        this.logger.debug(`writeSandboxAuthFile sandboxProcessObj: ${JSON.stringify(sandboxProcessObj)}, sandboxRes: ${JSON.stringify(sandboxRes)}`);
         if (sandboxRes.authUserName) {
             const productionAuthFields = this.connection.getAuthInfoFields();
-            this.logger.debug('Result from getAuthInfoFields: AuthFields %s', productionAuthFields);
+            this.logger.debug('Result from getAuthInfoFields: AuthFields', productionAuthFields);
             // let's do headless auth via jwt (if we have privateKey) or web auth
             const oauth2Options = {
                 loginUrl: sandboxRes.loginUrl,
@@ -802,16 +905,34 @@ class Org extends kit_1.AsyncOptionalCreatable {
                 oauth2Options.redirectUri = `http://localhost:${await webOAuthServer_1.WebOAuthServer.determineOauthPort()}/OauthRedirect`;
                 oauth2Options.authCode = sandboxRes.authCode;
             }
+            else {
+                oauth2Options.privateKey = productionAuthFields.privateKey;
+                oauth2Options.clientId = productionAuthFields.clientId;
+            }
             const authInfo = await authInfo_1.AuthInfo.create({
                 username: sandboxRes.authUserName,
                 oauth2Options,
                 parentUsername: productionAuthFields.username,
             });
+            this.logger.debug('Creating AuthInfo for sandbox', sandboxRes.authUserName, productionAuthFields.username, oauth2Options);
+            // save auth info for new sandbox
             await authInfo.save();
-            const sandboxOrg = await Org.create({ aliasOrUsername: authInfo.getUsername() });
-            await sandboxOrg.setSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME, 
-            // we couldn't get this far into the process without a production org so username will be there
-            productionAuthFields.username);
+            if (!authInfo.getFields().orgId) {
+                throw messages.createError('AuthInfoOrgIdUndefined');
+            }
+            // set the sandbox config value
+            const sfSandbox = {
+                sandboxUsername: sandboxRes.authUserName,
+                sandboxOrgId: authInfo.getFields().orgId,
+                prodOrgUsername: this.getUsername(),
+                sandboxName: sandboxProcessObj.SandboxName,
+                sandboxProcessId: sandboxProcessObj.Id,
+                sandboxInfoId: sandboxProcessObj.SandboxInfoId,
+                timestamp: new Date().toISOString(),
+            };
+            await this.setSandboxConfig(authInfo.getFields().orgId, sfSandbox);
+            const globalInfo = await globalInfo_1.GlobalInfo.getInstance();
+            await globalInfo.write();
             await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_RESULT, {
                 sandboxProcessObj,
                 sandboxRes,
@@ -822,84 +943,56 @@ class Org extends kit_1.AsyncOptionalCreatable {
             throw messages.createError('missingAuthUsername', [sandboxProcessObj.SandboxName]);
         }
     }
-    /**
-     * Polls for the new sandbox to be created - and will write the associated auth files
-     *
-     * @private
-     * @param options
-     *  sandboxProcessObj: The in-progress sandbox signup request
-     *  retries: the number of retries to poll for every 30s
-     *  shouldPoll: wait for polling, or just return
-     *  pollInterval: Duration to sleep between poll events, default 30 seconds
-     */
     async pollStatusAndAuth(options) {
-        var _a;
-        const { sandboxProcessObj, retries, shouldPoll, pollInterval } = options;
-        this.logger.debug('PollStatusAndAuth called with SandboxProcessObject%s, retries %s', sandboxProcessObj, retries);
-        const lifecycle = lifecycleEvents_1.Lifecycle.getInstance();
-        let pollFinished = false;
+        this.logger.debug('PollStatusAndAuth called with SandboxProcessObject', options.sandboxProcessObj, options.wait.minutes, options.pollInterval.seconds);
+        let remainingWait = options.wait;
         let waitingOnAuth = false;
-        const sandboxInfo = await this.sandboxSignupComplete(sandboxProcessObj);
-        if (sandboxInfo) {
-            await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_AUTH, sandboxInfo);
-            try {
-                this.logger.debug('sandbox signup complete with %s', sandboxInfo);
-                await this.writeSandboxAuthFile(sandboxProcessObj, sandboxInfo);
-                pollFinished = true;
-            }
-            catch (err) {
-                const error = err;
-                this.logger.debug('Exception while calling writeSandboxAuthFile %s', err);
-                if ((error === null || error === void 0 ? void 0 : error.name) === 'JwtAuthError' && ((_a = error === null || error === void 0 ? void 0 : error.stack) === null || _a === void 0 ? void 0 : _a.includes("user hasn't approved"))) {
-                    waitingOnAuth = true;
-                }
-                else {
-                    throw sfError_1.SfError.wrap(error);
+        const pollingClient = await pollingClient_1.PollingClient.create({
+            poll: async () => {
+                var _a;
+                const sandboxProcessObj = await this.querySandboxProcessBySandboxInfoId(options.sandboxProcessObj.SandboxInfoId);
+                // check to see if sandbox can authenticate via sandboxAuth endpoint
+                const sandboxInfo = await this.sandboxSignupComplete(sandboxProcessObj);
+                if (sandboxInfo) {
+                    await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_AUTH, sandboxInfo);
+                    try {
+                        this.logger.debug('sandbox signup complete with', sandboxInfo);
+                        await this.writeSandboxAuthFile(sandboxProcessObj, sandboxInfo);
+                        return { completed: true, payload: sandboxProcessObj };
+                    }
+                    catch (err) {
+                        const error = err;
+                        this.logger.debug('Exception while calling writeSandboxAuthFile', err);
+                        if ((error === null || error === void 0 ? void 0 : error.name) === 'JwtAuthError' && ((_a = error === null || error === void 0 ? void 0 : error.stack) === null || _a === void 0 ? void 0 : _a.includes("user hasn't approved"))) {
+                            waitingOnAuth = true;
+                        }
+                        else {
+                            throw sfError_1.SfError.wrap(error);
+                        }
+                    }
                 }
-            }
-        }
-        if (!pollFinished) {
-            if (retries > 0) {
-                // emit the signup progress of the sandbox and query the production org again after waiting the interval
-                await Promise.all([
-                    await lifecycle.emit(SandboxEvents.EVENT_STATUS, {
-                        sandboxProcessObj,
-                        interval: pollInterval.seconds,
-                        retries,
-                        waitingOnAuth,
-                    }),
-                    await (0, kit_1.sleep)(pollInterval),
-                ]);
-                const polledSandboxProcessObj = await this.querySandboxProcess(sandboxProcessObj.SandboxInfoId);
-                return this.pollStatusAndAuth({
-                    sandboxProcessObj: polledSandboxProcessObj,
-                    retries: retries - 1,
-                    shouldPoll,
-                    pollInterval,
+                await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_STATUS, {
+                    sandboxProcessObj,
+                    remainingWait: remainingWait.seconds,
+                    interval: options.pollInterval.seconds,
+                    waitingOnAuth,
                 });
-            }
-            else {
-                if (shouldPoll) {
-                    // timed out on retries
-                    throw messages.createError('orgPollingTimeout', [sandboxProcessObj.Status]);
-                }
-                else {
-                    // The user didn't want us to poll, so simply return the status
-                    // simply report status and exit
-                    await lifecycle.emit(SandboxEvents.EVENT_ASYNC_RESULT, sandboxProcessObj);
-                }
-            }
-        }
-        return sandboxProcessObj;
+                remainingWait = kit_1.Duration.seconds(remainingWait.seconds - options.pollInterval.seconds);
+                return { completed: false, payload: sandboxProcessObj };
+            },
+            frequency: options.pollInterval,
+            timeout: options.wait,
+        });
+        return pollingClient.subscribe();
     }
     /**
-     * query SandboxProcess via SandboxInfoId
+     * query SandboxProcess using supplied where clause
      *
-     * @param id SandboxInfoId to query for
+     * @param where clause to query for
      * @private
      */
-    async querySandboxProcess(id) {
-        const queryStr = `SELECT Id, Status, SandboxName, SandboxInfoId, LicenseType, CreatedDate, CopyProgress, SandboxOrganization, SourceId, Description, EndDate FROM SandboxProcess WHERE SandboxInfoId='${id}' AND Status != 'D'`;
+    async querySandboxProcess(where) {
+        const queryStr = `SELECT Id, Status, SandboxName, SandboxInfoId, LicenseType, CreatedDate, CopyProgress, SandboxOrganization, SourceId, Description, EndDate FROM SandboxProcess WHERE ${where} AND Status != 'D'`;
         return await this.connection.singleRecordQuery(queryStr, {
             tooling: true,
         });
@@ -907,11 +1000,11 @@ class Org extends kit_1.AsyncOptionalCreatable {
     /**
      * determines if the sandbox has successfully been created
      *
-     * @param sandboxProcessObj sandbox signup progeress
+     * @param sandboxProcessObj sandbox signup progress
      * @private
      */
     async sandboxSignupComplete(sandboxProcessObj) {
-        this.logger.debug('sandboxSignupComplete called with SandboxProcessObject %s', sandboxProcessObj);
+        this.logger.debug('sandboxSignupComplete called with SandboxProcessObject', sandboxProcessObj);
         if (!sandboxProcessObj.EndDate) {
             return;
         }
@@ -925,7 +1018,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
                 sandboxName: sandboxProcessObj.SandboxName,
                 callbackUrl,
             };
-            this.logger.debug('Calling sandboxAuth with SandboxUserAuthRequest %s', sandboxReq);
+            this.logger.debug('Calling sandboxAuth with SandboxUserAuthRequest', sandboxReq);
             const url = `${this.connection.tooling._baseUrl()}/sandboxAuth`;
             const params = {
                 method: 'POST',
@@ -934,7 +1027,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
                 body: JSON.stringify(sandboxReq),
             };
             const result = await this.connection.tooling.request(params);
-            this.logger.debug('Result of calling sandboxAuth %s', result);
+            this.logger.debug('Result of calling sandboxAuth', result);
             return result;
         }
         catch (err) {
@@ -942,7 +1035,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
             // There are cases where the endDate is set before the sandbox has actually completed.
             // In that case, the sandboxAuth call will throw a specific exception.
             if ((error === null || error === void 0 ? void 0 : error.name) === 'INVALID_STATUS') {
-                this.logger.debug('Error while authenticating the user %s', error === null || error === void 0 ? void 0 : error.toString());
+                this.logger.debug('Error while authenticating the user', error === null || error === void 0 ? void 0 : error.toString());
             }
             else {
                 // If it fails for any unexpected reason, just pass that through
@@ -950,6 +1043,15 @@ class Org extends kit_1.AsyncOptionalCreatable {
             }
         }
     }
+    validateWaitOptions(options) {
+        var _a, _b;
+        const wait = (_a = options.wait) !== null && _a !== void 0 ? _a : kit_1.Duration.minutes(30);
+        const interval = (_b = options.interval) !== null && _b !== void 0 ? _b : kit_1.Duration.seconds(30);
+        let pollInterval = options.async ? kit_1.Duration.seconds(0) : interval;
+        // pollInterval cannot be > wait.
+        pollInterval = pollInterval.seconds > wait.seconds ? wait : pollInterval;
+        return [wait, pollInterval];
+    }
 }
 exports.Org = Org;
 (function (Org) {

package/lib/org/scratchOrgCache.d.ts

@@ -0,0 +1,19 @@
+import { JsonMap } from '@salesforce/ts-types';
+import { TTLConfig } from '../config/ttlConfig';
+export declare type CachedOptions = {
+    hubUsername: string;
+    /** stores the scratch definition, including settings/objectSettings */
+    definitionjson: JsonMap;
+    hubBaseUrl: string;
+    /** may be required for auth*/
+    clientSecret?: string;
+    signupTargetLoginUrlConfig?: string;
+    apiVersion?: string;
+    alias?: string;
+    setDefault?: boolean;
+};
+export declare class ScratchOrgCache extends TTLConfig<TTLConfig.Options, CachedOptions> {
+    static getFileName(): string;
+    static getDefaultOptions(): TTLConfig.Options;
+    static unset(key: string): Promise<void>;
+}

package/lib/org/scratchOrgCache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScratchOrgCache = 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 global_1 = require("../global");
+const ttlConfig_1 = require("../config/ttlConfig");
+class ScratchOrgCache extends ttlConfig_1.TTLConfig {
+    static getFileName() {
+        return 'scratch-create-cache.json';
+    }
+    static getDefaultOptions() {
+        return {
+            isGlobal: true,
+            isState: true,
+            filename: ScratchOrgCache.getFileName(),
+            stateFolder: global_1.Global.SF_STATE_FOLDER,
+            ttl: kit_1.Duration.days(1),
+        };
+    }
+    static async unset(key) {
+        const cache = await ScratchOrgCache.create();
+        cache.unset(key);
+        await cache.write();
+    }
+}
+exports.ScratchOrgCache = ScratchOrgCache;
+//# sourceMappingURL=scratchOrgCache.js.map