@salesforce/core 3.7.0 → 3.7.4

package/lib/org/org.js

@@ -6,7 +6,7 @@
  * 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.Org = void 0;
+exports.Org = exports.SandboxEvents = exports.OrgTypes = void 0;
 const path_1 = require("path");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
@@ -21,11 +21,37 @@ const fs_1 = require("../util/fs");
 const sfdc_1 = require("../util/sfdc");
 const globalInfo_1 = require("../globalInfo");
 const messages_1 = require("../messages");
+const lifecycleEvents_1 = require("../lifecycleEvents");
+const webOAuthServer_1 = require("../webOAuthServer");
 const connection_1 = require("./connection");
 const authInfo_1 = require("./authInfo");
 const orgConfigProperties_1 = require("./orgConfigProperties");
 messages_1.Messages.importMessagesDirectory(__dirname);
-const messages = messages_1.Messages.load('@salesforce/core', 'org', ['notADevHub', 'noUsernameFound']);
+const messages = messages_1.Messages.load('@salesforce/core', 'org', [
+    'deleteOrgHubError',
+    'insufficientAccessToDelete',
+    'missingAuthUsername',
+    'noDevHubFound',
+    'notADevHub',
+    'noUsernameFound',
+    'orgPollingTimeout',
+    'sandboxDeleteFailed',
+    'sandboxInfoCreateFailed',
+    'sandboxNotFound',
+    'scratchOrgNotFound',
+]);
+var OrgTypes;
+(function (OrgTypes) {
+    OrgTypes["Scratch"] = "scratch";
+    OrgTypes["Sandbox"] = "sandbox";
+})(OrgTypes = exports.OrgTypes || (exports.OrgTypes = {}));
+var SandboxEvents;
+(function (SandboxEvents) {
+    SandboxEvents["EVENT_STATUS"] = "status";
+    SandboxEvents["EVENT_ASYNC_RESULT"] = "asyncResult";
+    SandboxEvents["EVENT_RESULT"] = "result";
+    SandboxEvents["EVENT_AUTH"] = "auth";
+})(SandboxEvents = exports.SandboxEvents || (exports.SandboxEvents = {}));
 /**
  * Provides a way to manage a locally authenticated Org.
  *
@@ -61,6 +87,33 @@ class Org extends kit_1.AsyncOptionalCreatable {
         this.status = Org.Status.UNKNOWN;
         this.options = options || {};
     }
+    /**
+     * create a sandbox from a production org
+     * 'this' needs to be a production org with sandbox licenses available
+     *
+     * @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);
+        const createResult = await this.connection.tooling.create('SandboxInfo', sandboxReq);
+        this.logger.debug('Return from calling tooling.create: %s ', 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);
+        return this.pollStatusAndAuth({
+            sandboxProcessObj: sandboxCreationProgress,
+            retries,
+            shouldPoll: retries > 0,
+            pollInterval,
+        });
+    }
     /**
      * Clean all data files in the org's data path. Usually <workspace>/.sfdx/orgs/<username>.
      *
@@ -71,11 +124,11 @@ class Org extends kit_1.AsyncOptionalCreatable {
         let dataPath;
         try {
             const rootFolder = await config_1.Config.resolveRootFolder(false);
-            dataPath = path_1.join(rootFolder, global_1.Global.SFDX_STATE_FOLDER, orgDataPath ? orgDataPath : 'orgs');
+            dataPath = (0, path_1.join)(rootFolder, global_1.Global.SFDX_STATE_FOLDER, orgDataPath ? orgDataPath : 'orgs');
             this.logger.debug(`cleaning data for path: ${dataPath}`);
         }
         catch (err) {
-            if (err.name === 'InvalidProjectWorkspaceError') {
+            if (err instanceof Error && err.name === 'InvalidProjectWorkspaceError') {
                 // If we aren't in a project dir, we can't clean up data files.
                 // If the user unlink this org outside of the workspace they used it in,
                 // data files will be left over.
@@ -113,6 +166,13 @@ class Org extends kit_1.AsyncOptionalCreatable {
         // So, just in case no users are added to this org we will try the remove again.
         await this.removeAuth();
     }
+    /**
+     * Check if org is a sandbox org by checking its SandboxOrgConfig.
+     *
+     */
+    async isSandbox() {
+        return !!(await this.getSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME));
+    }
     /**
      * Check that this org is a scratch org by asking the dev hub if it knows about it.
      *
@@ -133,12 +193,12 @@ class Org extends kit_1.AsyncOptionalCreatable {
         const DEV_HUB_SOQL = `SELECT CreatedDate,Edition,ExpirationDate FROM ActiveScratchOrg WHERE ScratchOrg='${trimmedId}'`;
         try {
             const results = await devHubConnection.query(DEV_HUB_SOQL);
-            if (ts_types_1.getNumber(results, 'records.length') !== 1) {
+            if ((0, ts_types_1.getNumber)(results, 'records.length') !== 1) {
                 throw new sfdxError_1.SfdxError('No results', 'NoResultsError');
             }
         }
         catch (err) {
-            if (err.name === 'INVALID_TYPE') {
+            if (err instanceof Error && err.name === 'INVALID_TYPE') {
                 throw messages.createError('notADevHub', [devHubConnection.getUsername()]);
             }
             throw err;
@@ -153,7 +213,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
             return this;
         }
         else if (this.getField(Org.Fields.DEV_HUB_USERNAME)) {
-            const devHubUsername = ts_types_1.ensureString(this.getField(Org.Fields.DEV_HUB_USERNAME));
+            const devHubUsername = (0, ts_types_1.ensureString)(this.getField(Org.Fields.DEV_HUB_USERNAME));
             return Org.create({
                 connection: await connection_1.Connection.create({
                     authInfo: await authInfo_1.AuthInfo.create({ username: devHubUsername }),
@@ -170,13 +230,43 @@ class Org extends kit_1.AsyncOptionalCreatable {
      */
     isDevHubOrg() {
         const isDevHub = this.getField(Org.Fields.IS_DEV_HUB);
-        if (ts_types_1.isBoolean(isDevHub)) {
+        if ((0, ts_types_1.isBoolean)(isDevHub)) {
             return isDevHub;
         }
         else {
             return false;
         }
     }
+    /**
+     * Will delete 'this' instance remotely and any files locally
+     *
+     * @param controllingOrg username or Org that 'this.devhub' or 'this.production' refers to. AKA a DevHub for a scratch org, or a Production Org for a sandbox
+     */
+    async deleteFrom(controllingOrg) {
+        if (typeof controllingOrg === 'string') {
+            controllingOrg = await Org.create({
+                aggregator: this.configAggregator,
+                aliasOrUsername: controllingOrg,
+            });
+        }
+        if (await this.isSandbox()) {
+            await this.deleteSandbox(controllingOrg);
+        }
+        else {
+            await this.deleteScratchOrg(controllingOrg);
+        }
+    }
+    /**
+     * Will delete 'this' instance remotely and any files locally
+     */
+    async delete() {
+        if (await this.isSandbox()) {
+            await this.deleteSandbox();
+        }
+        else {
+            await this.deleteScratchOrg();
+        }
+    }
     /**
      * Returns `true` if the org is a Dev Hub.
      *
@@ -189,7 +279,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
      */
     async determineIfDevHubOrg(forceServerCheck = false) {
         const cachedIsDevHub = this.getField(Org.Fields.IS_DEV_HUB);
-        if (!forceServerCheck && ts_types_1.isBoolean(cachedIsDevHub)) {
+        if (!forceServerCheck && (0, ts_types_1.isBoolean)(cachedIsDevHub)) {
             return cachedIsDevHub;
         }
         if (this.isDevHubOrg()) {
@@ -205,7 +295,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
         catch (err) {
             /* Not a dev hub */
         }
-        const username = ts_types_1.ensure(this.getUsername());
+        const username = (0, ts_types_1.ensure)(this.getUsername());
         const authInfo = await authInfo_1.AuthInfo.create({ username });
         await authInfo.save({ isDevHub });
         // Reset the connection with the updated auth file
@@ -221,7 +311,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
      */
     isScratch() {
         const isScratch = this.getField(Org.Fields.IS_SCRATCH);
-        if (ts_types_1.isBoolean(isScratch)) {
+        if ((0, ts_types_1.isBoolean)(isScratch)) {
             return isScratch;
         }
         else {
@@ -243,22 +333,6 @@ class Org extends kit_1.AsyncOptionalCreatable {
         }
         return cache;
     }
-    /**
-     * Returns `true` if the org is a sandbox.
-     *
-     * **Note** This relies on a cached value in the auth file. If that property
-     * is not cached, this method will **always return false even if the org is a
-     * sandbox**. If you need accuracy, use the {@link Org.determineIfDevHubOrg} method.
-     */
-    isSandbox() {
-        const isSandbox = this.getField(Org.Fields.IS_SANDBOX);
-        if (ts_types_1.isBoolean(isSandbox)) {
-            return isSandbox;
-        }
-        else {
-            return false;
-        }
-    }
     /**
      * Returns `true` if the org is a sandbox.
      *
@@ -323,8 +397,8 @@ class Org extends kit_1.AsyncOptionalCreatable {
     async readUserAuthFiles() {
         const config = await this.retrieveOrgUsersConfig();
         const contents = await config.read();
-        const thisUsername = ts_types_1.ensure(this.getUsername());
-        const usernames = ts_types_1.ensureJsonArray(contents.usernames || [thisUsername]);
+        const thisUsername = (0, ts_types_1.ensure)(this.getUsername());
+        const usernames = (0, ts_types_1.ensureJsonArray)(contents.usernames || [thisUsername]);
         return Promise.all(usernames.map((username) => {
             if (username === thisUsername) {
                 return authInfo_1.AuthInfo.create({
@@ -332,7 +406,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
                 });
             }
             else {
-                return authInfo_1.AuthInfo.create({ username: ts_types_1.ensureString(username) });
+                return authInfo_1.AuthInfo.create({ username: (0, ts_types_1.ensureString)(username) });
             }
         }));
     }
@@ -357,18 +431,18 @@ class Org extends kit_1.AsyncOptionalCreatable {
         if (!auth) {
             throw new sfdxError_1.SfdxError('Missing auth info', 'MissingAuthInfo');
         }
-        const authInfo = ts_types_1.isString(auth) ? await authInfo_1.AuthInfo.create({ username: auth }) : auth;
+        const authInfo = (0, ts_types_1.isString)(auth) ? await authInfo_1.AuthInfo.create({ username: auth }) : auth;
         this.logger.debug(`adding username ${authInfo.getFields().username}`);
         const orgConfig = await this.retrieveOrgUsersConfig();
         const contents = await orgConfig.read();
         // TODO: This is kind of screwy because contents values can be `AnyJson | object`...
         // needs config refactoring to improve
         const usernames = contents.usernames || [];
-        if (!ts_types_1.isArray(usernames)) {
+        if (!(0, ts_types_1.isArray)(usernames)) {
             throw new sfdxError_1.SfdxError('Usernames is not an array', 'UnexpectedDataFormat');
         }
         let shouldUpdate = false;
-        const thisUsername = ts_types_1.ensure(this.getUsername());
+        const thisUsername = (0, ts_types_1.ensure)(this.getUsername());
         if (!usernames.includes(thisUsername)) {
             usernames.push(thisUsername);
             shouldUpdate = true;
@@ -395,7 +469,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
         if (!auth) {
             throw new sfdxError_1.SfdxError('Missing auth info', 'MissingAuthInfoError');
         }
-        const authInfo = ts_types_1.isString(auth) ? await authInfo_1.AuthInfo.create({ username: auth }) : auth;
+        const authInfo = (0, ts_types_1.isString)(auth) ? await authInfo_1.AuthInfo.create({ username: auth }) : auth;
         this.logger.debug(`removing username ${authInfo.getFields().username}`);
         const orgConfig = await this.retrieveOrgUsersConfig();
         const contents = await orgConfig.read();
@@ -502,7 +576,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
             }
             this.connection = await connection_1.Connection.create({
                 // If no username is provided or resolvable from an alias, AuthInfo will throw an SfdxError.
-                authInfo: await authInfo_1.AuthInfo.create({ username }),
+                authInfo: await authInfo_1.AuthInfo.create({ username, isDevHub: this.options.isDevHub }),
             });
         }
         else {
@@ -516,6 +590,105 @@ class Org extends kit_1.AsyncOptionalCreatable {
     getDefaultOptions() {
         throw new sfdxError_1.SfdxError('Not Supported', 'NotSupportedError');
     }
+    async queryProduction(org, field, value) {
+        return org.connection.singleRecordQuery(`SELECT SandboxInfoId FROM SandboxProcess WHERE ${field} ='${value}' AND Status NOT IN ('D', 'E')`, { tooling: true });
+    }
+    async destorySandbox(org, id) {
+        return org.getConnection().tooling.delete('SandboxInfo', id);
+    }
+    async destoryScratchOrg(org, id) {
+        return org.getConnection().delete('ActiveScratchOrg', id);
+    }
+    /**
+     * this method will delete the sandbox org from the production org and clean up any local files
+     *
+     * @param prodOrg - Production org associated with this sandbox
+     * @private
+     */
+    async deleteSandbox(prodOrg) {
+        prodOrg !== null && prodOrg !== void 0 ? prodOrg : (prodOrg = await Org.create({
+            aggregator: this.configAggregator,
+            aliasOrUsername: await this.getSandboxOrgConfigField(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME),
+        }));
+        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}`);
+            try {
+                result = await this.queryProduction(prodOrg, 'SandboxOrganization', trimmedId);
+            }
+            catch {
+                throw messages.createError('sandboxNotFound', [trimmedId]);
+            }
+        }
+        // const deleteResult = await prodOrg.connection.tooling.delete('SandboxInfo', result.SandboxInfoId);
+        const deleteResult = await this.destorySandbox(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 this Org is a scratch org, calling this method will delete the scratch org from the DevHub and clean up any local files
+     *
+     * @param devHub - optional DevHub Org of the to-be-deleted scratch org
+     * @private
+     */
+    async deleteScratchOrg(devHub) {
+        // if we didn't get a devHub, we'll get it from the this org
+        devHub !== null && devHub !== void 0 ? devHub : (devHub = await this.getDevHubOrg());
+        if (!devHub) {
+            throw messages.createError('noDevHubFound');
+        }
+        if (devHub.getOrgId() === this.getOrgId()) {
+            // we're attempting to delete a DevHub
+            throw messages.createError('deleteOrgHubError');
+        }
+        try {
+            const devHubConn = devHub.getConnection();
+            const username = this.getUsername();
+            const activeScratchOrgRecordId = (await devHubConn.singleRecordQuery(`SELECT Id FROM ActiveScratchOrg WHERE SignupUsername='${username}'`)).Id;
+            this.logger.trace(`found matching ActiveScratchOrg with SignupUsername: ${username}.  Deleting...`);
+            await this.destoryScratchOrg(devHub, activeScratchOrgRecordId);
+            await this.remove();
+        }
+        catch (err) {
+            this.logger.info(err instanceof Error ? err.message : err);
+            if (err instanceof Error && (err.name === 'INVALID_TYPE' || err.name === 'INSUFFICIENT_ACCESS_OR_READONLY')) {
+                // most likely from devHubConn.delete
+                this.logger.info('Insufficient privilege to access ActiveScratchOrgs.');
+                throw messages.createError('insufficientAccessToDelete');
+            }
+            if (err instanceof Error && err.name === connection_1.SingleRecordQueryErrors.NoRecords) {
+                // most likely from singleRecordQuery
+                this.logger.info('The above error can be the result of deleting an expired or already deleted org.');
+                this.logger.info('attempting to cleanup the auth file');
+                await this.removeAuth();
+                throw messages.createError('scratchOrgNotFound');
+            }
+            throw err;
+        }
+    }
     /**
      * Delete an auth info file from the local file system and any related cache information for
      * this Org. You don't want to call this method directly. Instead consider calling Org.remove()
@@ -548,7 +721,7 @@ class Org extends kit_1.AsyncOptionalCreatable {
     async retrieveSandboxOrgConfig() {
         return await sandboxOrgConfig_1.SandboxOrgConfig.create(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(this.getOrgId()));
     }
-    manageDelete(cb, dirPath, throwWhenRemoveFails) {
+    async manageDelete(cb, dirPath, throwWhenRemoveFails) {
         return cb().catch((e) => {
             if (throwWhenRemoveFails) {
                 throw e;
@@ -610,6 +783,170 @@ class Org extends kit_1.AsyncOptionalCreatable {
             await this.manageDelete(async () => await sandboxOrgConfig.unlink(), sandboxOrgConfig.getPath(), throwWhenRemoveFails);
         }
     }
+    async writeSandboxAuthFile(sandboxProcessObj, sandboxRes) {
+        this.logger.debug('writeSandboxAuthFile sandboxProcessObj: %s, sandboxRes: %s', sandboxProcessObj, sandboxRes);
+        if (sandboxRes.authUserName) {
+            const productionAuthFields = this.connection.getAuthInfoFields();
+            this.logger.debug('Result from getAuthInfoFields: AuthFields %s', productionAuthFields);
+            // let's do headless auth via jwt (if we have privateKey) or web auth
+            const oauth2Options = {
+                loginUrl: sandboxRes.loginUrl,
+                instanceUrl: sandboxRes.instanceUrl,
+                username: sandboxRes.authUserName,
+            };
+            // If we don't have a privateKey then we assume it's web auth.
+            if (!productionAuthFields.privateKey) {
+                oauth2Options.redirectUri = `http://localhost:${await webOAuthServer_1.WebOAuthServer.determineOauthPort()}/OauthRedirect`;
+                oauth2Options.authCode = sandboxRes.authCode;
+            }
+            const authInfo = await authInfo_1.AuthInfo.create({
+                username: sandboxRes.authUserName,
+                oauth2Options,
+                parentUsername: productionAuthFields.username,
+            });
+            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);
+            await lifecycleEvents_1.Lifecycle.getInstance().emit(SandboxEvents.EVENT_RESULT, {
+                sandboxProcessObj,
+                sandboxRes,
+            });
+        }
+        else {
+            // no authed sandbox user, error
+            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;
+        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 sfdxError_1.SfdxError.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,
+                });
+            }
+            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;
+    }
+    /**
+     * query SandboxProcess via SandboxInfoId
+     *
+     * @param id SandboxInfoId 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'`;
+        return await this.connection.singleRecordQuery(queryStr, {
+            tooling: true,
+        });
+    }
+    /**
+     * determines if the sandbox has successfully been created
+     *
+     * @param sandboxProcessObj sandbox signup progeress
+     * @private
+     */
+    async sandboxSignupComplete(sandboxProcessObj) {
+        this.logger.debug('sandboxSignupComplete called with SandboxProcessObject %s', sandboxProcessObj);
+        if (!sandboxProcessObj.EndDate) {
+            return;
+        }
+        try {
+            // call server side /sandboxAuth API to auth the sandbox org user with the connected app
+            const authFields = this.connection.getAuthInfoFields();
+            const callbackUrl = `http://localhost:${await webOAuthServer_1.WebOAuthServer.determineOauthPort()}/OauthRedirect`;
+            const sandboxReq = {
+                // the sandbox signup has been completed on production, we have production clientId by this point
+                clientId: authFields.clientId,
+                sandboxName: sandboxProcessObj.SandboxName,
+                callbackUrl,
+            };
+            this.logger.debug('Calling sandboxAuth with SandboxUserAuthRequest %s', sandboxReq);
+            const url = `${this.connection.tooling._baseUrl()}/sandboxAuth`;
+            const params = {
+                method: 'POST',
+                url,
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(sandboxReq),
+            };
+            const result = await this.connection.tooling.request(params);
+            this.logger.debug('Result of calling sandboxAuth %s', result);
+            return result;
+        }
+        catch (err) {
+            const error = err;
+            // 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());
+            }
+            else {
+                // If it fails for any unexpected reason, just pass that through
+                throw sfdxError_1.SfdxError.wrap(error);
+            }
+        }
+    }
 }
 exports.Org = Org;
 (function (Org) {

package/lib/org/orgConfigProperties.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ORG_CONFIG_ALLOWED_PROPERTIES = exports.OrgConfigProperties = void 0;
 const path_1 = require("path");
 const messages_1 = require("../messages");
-messages_1.Messages.importMessagesDirectory(path_1.join(__dirname));
+messages_1.Messages.importMessagesDirectory((0, path_1.join)(__dirname));
 const messages = messages_1.Messages.load('@salesforce/core', 'config', ['targetOrg', 'targetDevHub']);
 var OrgConfigProperties;
 (function (OrgConfigProperties) {

package/lib/org/permissionSetAssignment.js

@@ -61,7 +61,7 @@ class PermissionSetAssignment {
             query += ` AND NamespacePrefix='${nsPrefix}'`;
         }
         const result = await this.org.getConnection().query(query);
-        const permissionSetId = ts_types_1.getString(result, 'records[0].Id');
+        const permissionSetId = (0, ts_types_1.getString)(result, 'records[0].Id');
         if (!permissionSetId) {
             if (nsPrefix) {
                 throw messages.createError('assignCommandPermissionSetNotFoundForNSError', [permSetName, nsPrefix]);
@@ -77,8 +77,8 @@ class PermissionSetAssignment {
         const createResponse = await this.org
             .getConnection()
             .sobject('PermissionSetAssignment')
-            .create(kit_1.mapKeys(assignment, (value, key) => kit_1.upperFirst(key)));
-        if (ts_types_1.hasArray(createResponse, 'errors') && createResponse.errors.length > 0) {
+            .create((0, kit_1.mapKeys)(assignment, (value, key) => (0, kit_1.upperFirst)(key)));
+        if ((0, ts_types_1.hasArray)(createResponse, 'errors') && createResponse.errors.length > 0) {
             let message = messages.getMessage('errorsEncounteredCreatingAssignment');
             const errors = createResponse.errors;
             if (errors && errors.length > 0) {