@salesforce/core 2.33.1 → 2.35.0

package/lib/scratchOrgInfoApi.js

@@ -0,0 +1,331 @@
+"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.deploySettingsAndResolveUrl = exports.pollForScratchOrgInfo = exports.requestScratchOrgCreation = exports.authorizeScratchOrg = void 0;
+const kit_1 = require("@salesforce/kit");
+const ts_types_1 = require("@salesforce/ts-types");
+const ts_retry_promise_1 = require("ts-retry-promise");
+// Local
+const org_1 = require("./org");
+const logger_1 = require("./logger");
+const mapKeys_1 = require("./util/mapKeys");
+const authInfo_1 = require("./authInfo");
+const messages_1 = require("./messages");
+const sfdxError_1 = require("./sfdxError");
+const sfdcUrl_1 = require("./util/sfdcUrl");
+const myDomainResolver_1 = require("./status/myDomainResolver");
+const scratchOrgErrorCodes_1 = require("./scratchOrgErrorCodes");
+messages_1.Messages.importMessagesDirectory(__dirname);
+const messages = messages_1.Messages.loadMessages('@salesforce/core', 'scratchOrgInfoApi');
+/**
+ * Returns the url to be used to authorize into the new scratch org
+ *
+ * @param scratchOrgInfoComplete The completed ScratchOrgInfo
+ * @param hubOrgLoginUrl the hun org login url
+ * @param signupTargetLoginUrlConfig the login url
+ * @returns {string}
+ */
+const getOrgInstanceAuthority = function (scratchOrgInfoComplete, hubOrgLoginUrl, signupTargetLoginUrlConfig) {
+    const createdOrgInstance = scratchOrgInfoComplete.SignupInstance;
+    if (createdOrgInstance === 'utf8') {
+        return hubOrgLoginUrl;
+    }
+    let altUrl;
+    // For non-Falcon (ie - instance names not ending in -s) sandboxes, use the instance URL
+    if (createdOrgInstance && !createdOrgInstance.toLowerCase().endsWith('s')) {
+        altUrl = `https://${createdOrgInstance}.salesforce.com`;
+    }
+    else {
+        // For Falcon sandboxes, try the LoginURL instead; createdOrgInstance will not yield a valid URL
+        altUrl = scratchOrgInfoComplete.LoginUrl;
+    }
+    return signupTargetLoginUrlConfig !== null && signupTargetLoginUrlConfig !== void 0 ? signupTargetLoginUrlConfig : altUrl;
+};
+/**
+ * Returns OAuth2Options object
+ *
+ * @param hubOrg the environment hub org
+ * @param clientSecret The OAuth client secret. May be null for JWT OAuth flow.
+ * @param scratchOrgInfoComplete The completed ScratchOrgInfo which should contain an access token.
+ * @param retry auth retry attempts
+ * @param signupTargetLoginUrlConfig the login url
+ * @returns {OAuth2Options, number, number, number} options, retries, timeout, delay
+ */
+const buildOAuth2Options = async (options) => {
+    const logger = await logger_1.Logger.child('buildOAuth2Options');
+    const isJwtFlow = !!options.hubOrg.getConnection().getAuthInfoFields().privateKey;
+    const oauth2Options = {
+        loginUrl: getOrgInstanceAuthority(options.scratchOrgInfoComplete, options.hubOrg.getField(org_1.Org.Fields.LOGIN_URL), options.signupTargetLoginUrlConfig),
+    };
+    logger.debug(`isJwtFlow: ${isJwtFlow}`);
+    if (isJwtFlow && !process.env.SFDX_CLIENT_SECRET) {
+        oauth2Options.privateKeyFile = options.hubOrg.getConnection().getAuthInfoFields().privateKey;
+        const retries = (options === null || options === void 0 ? void 0 : options.retry) || kit_1.env.getNumber('SFDX_JWT_AUTH_RETRY_ATTEMPTS') || 0;
+        const timeoutInSeconds = kit_1.env.getNumber('SFDX_JWT_AUTH_RETRY_TIMEOUT') || 300;
+        const timeout = kit_1.Duration.seconds(timeoutInSeconds).milliseconds;
+        const delay = retries ? timeout / retries : 1000;
+        return {
+            options: oauth2Options,
+            retries,
+            timeout,
+            delay,
+        };
+    }
+    else {
+        // Web Server OAuth "auth code exchange" flow
+        if (process.env.SFDX_CLIENT_SECRET) {
+            oauth2Options.clientSecret = process.env.SFDX_CLIENT_SECRET;
+        }
+        else if (options.clientSecret) {
+            oauth2Options.clientSecret = options.clientSecret;
+        }
+        oauth2Options.redirectUri = options.scratchOrgInfoComplete.ConnectedAppCallbackUrl;
+        oauth2Options.authCode = options.scratchOrgInfoComplete.AuthCode;
+        return {
+            options: oauth2Options,
+            retries: 0,
+        };
+    }
+};
+/**
+ * Returns OAuth2Options object
+ *
+ * @param hubOrg the environment hub org
+ * @param username The OAuth client secret. May be null for JWT OAuth flow.
+ * @param oauth2Options The completed ScratchOrgInfo which should contain an access token.
+ * @param retries auth retry attempts
+ * @param timeout the login url
+ * @param delay the login url
+ * @returns {OAuth2Options, number, number, number} options, retries, timeout, delay
+ */
+const getAuthInfo = async (options) => {
+    const logger = await logger_1.Logger.child('getAuthInfo');
+    const retryAuthorize = ts_retry_promise_1.retryDecorator(async (opts) => authInfo_1.AuthInfo.create(opts), {
+        timeout: options.timeout,
+        delay: options.delay,
+        retries: options.retries,
+    });
+    if (options.retries) {
+        try {
+            return await retryAuthorize({
+                username: options.username,
+                parentUsername: options.hubOrg.getUsername(),
+                oauth2Options: options.oauth2Options,
+            });
+        }
+        catch (err) {
+            const error = err;
+            logger.error(error);
+            throw error.lastError || error;
+        }
+    }
+    else {
+        return authInfo_1.AuthInfo.create({
+            username: options.username,
+            parentUsername: options.hubOrg.getUsername(),
+            oauth2Options: options.oauth2Options,
+        });
+    }
+};
+/**
+ * after we successfully signup an org we need to trade the auth token for access and refresh token.
+ *
+ * @param scratchOrgInfoComplete - The completed ScratchOrgInfo which should contain an access token.
+ * @param hubOrg - the environment hub org
+ * @param clientSecret - The OAuth client secret. May be null for JWT OAuth flow.
+ * @param signupTargetLoginUrlConfig - Login url
+ * @param retry - auth retry attempts
+ * @returns {Promise<AuthInfo>}
+ */
+const authorizeScratchOrg = async (options) => {
+    var _a;
+    const { scratchOrgInfoComplete, hubOrg, clientSecret, signupTargetLoginUrlConfig, retry: maxRetries } = options;
+    const logger = await logger_1.Logger.child('authorizeScratchOrg');
+    logger.debug(`scratchOrgInfoComplete: ${JSON.stringify(scratchOrgInfoComplete, null, 4)}`);
+    // if we didn't have it marked as a devhub but just successfully used it as one, this will update the authFile, fix cache, etc
+    if (!hubOrg.isDevHubOrg()) {
+        await hubOrg.determineIfDevHubOrg(true);
+    }
+    const oAuth2Options = await buildOAuth2Options({
+        hubOrg,
+        clientSecret,
+        scratchOrgInfoComplete,
+        retry: maxRetries,
+        signupTargetLoginUrlConfig,
+    });
+    const authInfo = await getAuthInfo({
+        hubOrg,
+        username: scratchOrgInfoComplete.SignupUsername,
+        oauth2Options: oAuth2Options.options,
+        retries: oAuth2Options.retries,
+        timeout: oAuth2Options.timeout,
+        delay: oAuth2Options.delay,
+    });
+    await authInfo.save({
+        devHubUsername: hubOrg.getUsername(),
+        created: new Date((_a = scratchOrgInfoComplete.CreatedDate) !== null && _a !== void 0 ? _a : new Date()).valueOf().toString(),
+        expirationDate: scratchOrgInfoComplete.ExpirationDate,
+        clientId: scratchOrgInfoComplete.ConnectedAppConsumerKey,
+        createdOrgInstance: scratchOrgInfoComplete.SignupInstance,
+        isDevHub: false,
+        snapshot: scratchOrgInfoComplete.Snapshot,
+    });
+    return authInfo;
+};
+exports.authorizeScratchOrg = authorizeScratchOrg;
+const checkOrgDoesntExist = async (scratchOrgInfo) => {
+    const usernameKey = Object.keys(scratchOrgInfo).find((key) => key.toUpperCase() === 'USERNAME');
+    if (!usernameKey) {
+        return;
+    }
+    const username = ts_types_1.getString(scratchOrgInfo, usernameKey);
+    if (username && username.length > 0) {
+        try {
+            await authInfo_1.AuthInfo.create({ username: username.toLowerCase() });
+        }
+        catch (error) {
+            const sfdxError = sfdxError_1.SfdxError.wrap(error);
+            // if an AuthInfo couldn't be created that means no AuthFile exists.
+            if (sfdxError.name === 'NamedOrgNotFound') {
+                return;
+            }
+            // Something unexpected
+            throw sfdxError;
+        }
+        // An org file already exists
+        throw sfdxError_1.SfdxError.create('@salesforce/core', 'scratchOrgErrorCodes', 'C-1007');
+    }
+};
+/**
+ * This extracts orgPrefs/settings from the user input and performs a basic scratchOrgInfo request.
+ *
+ * @param hubOrg - the environment hub org
+ * @param scratchOrgRequest - An object containing the fields of the ScratchOrgInfo
+ * @param settings - An object containing org settings
+ * @returns {Promise<RecordResult>}
+ */
+const requestScratchOrgCreation = async (hubOrg, scratchOrgRequest, settings) => {
+    // If these were present, they were already used to initialize the scratchOrgSettingsGenerator.
+    // They shouldn't be submitted as part of the scratchOrgInfo.
+    delete scratchOrgRequest.settings;
+    delete scratchOrgRequest.objectSettings;
+    // We do not allow you to specify the old and the new way of doing post create settings
+    if (scratchOrgRequest.orgPreferences && settings.hasSettings()) {
+        // This is not allowed
+        throw new sfdxError_1.SfdxError('signupDuplicateSettingsSpecified');
+    }
+    // deprecated old style orgPreferences
+    if (scratchOrgRequest.orgPreferences) {
+        throw new sfdxError_1.SfdxError(messages.getMessage('deprecatedPrefFormat'));
+    }
+    const scratchOrgInfo = mapKeys_1.default(scratchOrgRequest, kit_1.upperFirst, true);
+    await checkOrgDoesntExist(scratchOrgInfo); // throw if it does exists.
+    try {
+        return await hubOrg.getConnection().sobject('ScratchOrgInfo').create(scratchOrgInfo);
+    }
+    catch (error) {
+        // this is a jsforce error which contains the property "fields" which regular error don't
+        const jsForceError = error;
+        if (jsForceError.errorCode === 'REQUIRED_FIELD_MISSING') {
+            throw new sfdxError_1.SfdxError(messages.getMessage('signupFieldsMissing', [jsForceError.fields.toString()]));
+        }
+        throw sfdxError_1.SfdxError.wrap(jsForceError);
+    }
+};
+exports.requestScratchOrgCreation = requestScratchOrgCreation;
+/**
+ * This retrieves the ScratchOrgInfo, polling until the status is Active or Error
+ *
+ * @param hubOrg
+ * @param scratchOrgInfoId - the id of the scratchOrgInfo that we are retrieving
+ * @param timeout - A Duration object
+ * @returns {Promise<ScratchOrgInfo>}
+ */
+const pollForScratchOrgInfo = async (hubOrg, scratchOrgInfoId, 
+// org:create specifies a default timeout of 6.  This longer default is for other consumers
+timeout = kit_1.Duration.minutes(15)) => {
+    const logger = await logger_1.Logger.child('scratchOrgInfoApi-pollForScratchOrgInfo');
+    logger.debug(`PollingTimeout in minutes: ${timeout.minutes}`);
+    const response = await ts_retry_promise_1.retry(async () => {
+        const resultInProgress = await hubOrg
+            .getConnection()
+            .sobject('ScratchOrgInfo')
+            .retrieve(scratchOrgInfoId);
+        logger.debug(`polling client result: ${JSON.stringify(resultInProgress, null, 4)}`);
+        // Once it's "done" we can return it
+        if (resultInProgress.Status === 'Active' || resultInProgress.Status === 'Error') {
+            return resultInProgress;
+        }
+        // all other statuses, OR lack of status (e.g. network errors) will cause a retry
+        throw new sfdxError_1.SfdxError(`Scratch org status is ${resultInProgress.Status}`);
+    }, {
+        retries: 'INFINITELY',
+        timeout: timeout.milliseconds,
+        delay: kit_1.Duration.seconds(2).milliseconds,
+        backoff: 'LINEAR',
+        maxBackOff: kit_1.Duration.seconds(30).milliseconds,
+    }).catch(() => {
+        throw new sfdxError_1.SfdxError(`The scratch org did not complete within ${timeout.minutes} minutes`, 'orgCreationTimeout', [
+            'Try your force:org:create command again with a longer --wait value',
+        ]);
+    });
+    return scratchOrgErrorCodes_1.checkScratchOrgInfoForErrors(response, hubOrg.getUsername(), logger);
+};
+exports.pollForScratchOrgInfo = pollForScratchOrgInfo;
+/**
+ * This authenticates into the newly created org and sets org preferences
+ *
+ * @param scratchOrgAuthInfo - an object containing the AuthInfo of the ScratchOrg
+ * @param apiVersion - the target api version
+ * @param orgSettings - The ScratchOrg settings
+ * @param scratchOrg - The scratchOrg Org info
+ * @returns {Promise<Optional<AuthInfo>>}
+ */
+const deploySettingsAndResolveUrl = async (scratchOrgAuthInfo, apiVersion, orgSettings, scratchOrg) => {
+    const logger = await logger_1.Logger.child('scratchOrgInfoApi-deploySettingsAndResolveUrl');
+    if (orgSettings.hasSettings()) {
+        // deploy the settings to the newly created scratch org
+        logger.debug(`deploying scratch org settings with apiVersion ${apiVersion}`);
+        try {
+            await orgSettings.createDeploy();
+            await orgSettings.deploySettingsViaFolder(scratchOrg, apiVersion);
+        }
+        catch (error) {
+            throw sfdxError_1.SfdxError.wrap(error);
+        }
+    }
+    const { instanceUrl } = scratchOrgAuthInfo.getFields();
+    if (instanceUrl) {
+        logger.debug(`processScratchOrgInfoResult - resultData.instanceUrl: ${instanceUrl}`);
+        const options = {
+            timeout: kit_1.Duration.minutes(3),
+            frequency: kit_1.Duration.seconds(10),
+            url: new sfdcUrl_1.SfdcUrl(instanceUrl),
+        };
+        try {
+            const resolver = await myDomainResolver_1.MyDomainResolver.create(options);
+            await resolver.resolve();
+        }
+        catch (error) {
+            const sfdxError = sfdxError_1.SfdxError.wrap(error);
+            logger.debug('processScratchOrgInfoResult - err: %s', error);
+            if (sfdxError.name === 'MyDomainResolverTimeoutError') {
+                sfdxError.setData({
+                    orgId: scratchOrgAuthInfo.getFields().orgId,
+                    username: scratchOrgAuthInfo.getFields().username,
+                    instanceUrl,
+                });
+                logger.debug('processScratchOrgInfoResult - err data: %s', sfdxError.data);
+            }
+            throw sfdxError;
+        }
+        return scratchOrgAuthInfo;
+    }
+};
+exports.deploySettingsAndResolveUrl = deploySettingsAndResolveUrl;
+//# sourceMappingURL=scratchOrgInfoApi.js.map

package/lib/scratchOrgInfoGenerator.d.ts

@@ -0,0 +1,62 @@
+import { Org } from './org';
+import { SfdxProjectJson } from './sfdxProject';
+import { ScratchOrgInfo } from './scratchOrgInfoApi';
+declare type PartialScratchOrgInfo = Pick<ScratchOrgInfo, 'ConnectedAppConsumerKey' | 'AuthCode' | 'Snapshot' | 'Status' | 'LoginUrl' | 'SignupEmail' | 'SignupUsername' | 'SignupInstance' | 'Username'>;
+export interface ScratchOrgInfoPayload extends PartialScratchOrgInfo {
+    orgName: string;
+    package2AncestorIds: string;
+    features: string | string[];
+    connectedAppConsumerKey: string;
+    namespace: string;
+    connectedAppCallbackUrl: string;
+}
+/**
+ * Generates the package2AncestorIds scratch org property
+ *
+ * @param scratchOrgInfo - the scratchOrgInfo passed in by the user
+ * @param projectJson - sfdxProjectJson
+ * @param hubOrg - the hub org, in case we need to do queries
+ */
+export declare const getAncestorIds: (scratchOrgInfo: ScratchOrgInfoPayload, projectJson: SfdxProjectJson, hubOrg: Org) => Promise<string>;
+/**
+ * Takes in a scratchOrgInfo and fills in the missing fields
+ *
+ * @param hubOrg the environment hub org
+ * @param scratchOrgInfoPayload - the scratchOrgInfo passed in by the user
+ * @param nonamespace create the scratch org with no namespace
+ * @param ignoreAncestorIds true if the sfdx-project.json ancestorId keys should be ignored
+ */
+export declare const generateScratchOrgInfo: ({ hubOrg, scratchOrgInfoPayload, nonamespace, ignoreAncestorIds, }: {
+    hubOrg: Org;
+    scratchOrgInfoPayload: ScratchOrgInfoPayload;
+    nonamespace?: boolean | undefined;
+    ignoreAncestorIds?: boolean | undefined;
+}) => Promise<ScratchOrgInfoPayload>;
+/**
+ * Returns a valid signup json
+ *
+ * @param definitionjson org definition in JSON format
+ * @param definitionfile path to an org definition file
+ * @param connectedAppConsumerKey The connected app consumer key. May be null for JWT OAuth flow.
+ * @param durationdays duration of the scratch org (in days) (default:1, min:1, max:30)
+ * @param nonamespace create the scratch org with no namespace
+ * @param noancestors do not include second-generation package ancestors in the scratch org
+ * @param orgConfig overrides definitionjson
+ * @returns scratchOrgInfoPayload: ScratchOrgInfoPayload;
+            ignoreAncestorIds: boolean;
+            warnings: string[];
+ */
+export declare const getScratchOrgInfoPayload: (options: {
+    definitionjson?: string;
+    definitionfile?: string;
+    connectedAppConsumerKey?: string;
+    durationDays: number;
+    nonamespace?: boolean;
+    noancestors?: boolean;
+    orgConfig?: Record<string, unknown>;
+}) => Promise<{
+    scratchOrgInfoPayload: ScratchOrgInfoPayload;
+    ignoreAncestorIds: boolean;
+    warnings: string[];
+}>;
+export {};

package/lib/scratchOrgInfoGenerator.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScratchOrgInfoPayload = exports.generateScratchOrgInfo = exports.getAncestorIds = void 0;
+/*
+ * 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
+ */
+// Node
+const fs_1 = require("fs");
+// @salesforce
+const kit_1 = require("@salesforce/kit");
+const ts_types_1 = require("@salesforce/ts-types");
+const sfdc_1 = require("./util/sfdc");
+const sfdxProject_1 = require("./sfdxProject");
+const webOAuthServer_1 = require("./webOAuthServer");
+const messages_1 = require("./messages");
+const sfdxError_1 = require("./sfdxError");
+const scratchOrgFeatureDeprecation_1 = require("./scratchOrgFeatureDeprecation");
+const defaultConnectedAppInfo = {
+    clientId: 'PlatformCLI',
+    legacyClientId: 'SalesforceDevelopmentExperience',
+    legacyClientSecret: '1384510088588713504',
+};
+messages_1.Messages.importMessagesDirectory(__dirname);
+const messages = messages_1.Messages.loadMessages('@salesforce/core', 'scratchOrgInfoGenerator');
+const SNAPSHOT_UNSUPPORTED_OPTIONS = [
+    'features',
+    'orgPreferences',
+    'edition',
+    'sourceOrg',
+    'settingsPath',
+    'releaseVersion',
+    'language',
+];
+// A validator function to ensure any options parameters entered by the user adhere
+// to a allowlist of valid option settings. Because org:create allows options to be
+// input either key=value pairs or within the definition file, this validator is
+// executed within the ctor and also after parsing/normalization of the definition file.
+const optionsValidator = (key, scratchOrgInfoPayload) => {
+    if (key.toLowerCase() === 'durationdays') {
+        throw new sfdxError_1.SfdxError('unrecognizedScratchOrgOption', 'durationDays');
+    }
+    if (key.toLowerCase() === 'snapshot') {
+        const foundInvalidFields = SNAPSHOT_UNSUPPORTED_OPTIONS.filter((invalidField) => invalidField in scratchOrgInfoPayload);
+        if (foundInvalidFields.length > 0) {
+            throw new sfdxError_1.SfdxError(messages.getMessage('unsupportedSnapshotOrgCreateOptions', [foundInvalidFields.join(', ')]), 'orgSnapshot');
+        }
+    }
+};
+/**
+ * Generates the package2AncestorIds scratch org property
+ *
+ * @param scratchOrgInfo - the scratchOrgInfo passed in by the user
+ * @param projectJson - sfdxProjectJson
+ * @param hubOrg - the hub org, in case we need to do queries
+ */
+const getAncestorIds = async (scratchOrgInfo, projectJson, hubOrg) => {
+    if (Reflect.has(scratchOrgInfo, 'package2AncestorIds')) {
+        throw new sfdxError_1.SfdxError(messages.getMessage('errorpackage2AncestorIdsKeyNotSupported'), 'DeprecationError');
+    }
+    const packagesWithAncestors = (await projectJson.getPackageDirectories())
+        // check that the package has any ancestor types (id or version)
+        .filter((packageDir) => packageDir.ancestorId || packageDir.ancestorVersion);
+    if (packagesWithAncestors.length === 0) {
+        return '';
+    }
+    const ancestorIds = await Promise.all(packagesWithAncestors.map(async (packageDir) => {
+        var _a, _b, _c;
+        // ancestorID can be 05i, or 04t, alias; OR "ancestorVersion": "4.6.0.1"
+        // according to docs, 05i is not ok: https://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev2gp_config_file.htm
+        if (packageDir.ancestorVersion) {
+            if (!/^[0-9]+.[0-9]+.[0-9]+(.[0-9]+)?$/.test(packageDir.ancestorVersion)) {
+                throw sfdxError_1.SfdxError.create('@salesforce/core', 'scratchOrgInfoGenerator', 'errorInvalidAncestorVersionFormat', [
+                    packageDir.ancestorVersion,
+                ]);
+            }
+            // package can be an ID, but not according to docs
+            const packageAliases = projectJson.get('packageAliases');
+            const packageId = (_a = packageAliases[ts_types_1.ensureString(packageDir.package)]) !== null && _a !== void 0 ? _a : packageDir.package;
+            const [major, minor, patch] = packageDir.ancestorVersion.split('.');
+            let releasedAncestor;
+            try {
+                releasedAncestor = await hubOrg
+                    .getConnection()
+                    .singleRecordQuery(`SELECT Id, IsReleased FROM Package2Version WHERE Package2Id = '${packageId}' AND MajorVersion = ${major} AND MinorVersion = ${minor} AND PatchVersion = ${patch} and IsReleased = true`, { tooling: true });
+            }
+            catch (err) {
+                throw new sfdxError_1.SfdxError(messages.getMessage('errorNoMatchingAncestor', [packageDir.ancestorVersion, packageDir.package]), 'ErrorNoMatchingAncestor', [messages.getMessage('errorAncestorNotReleased', [packageDir.ancestorVersion])]);
+            }
+            if (packageDir.ancestorId && packageDir.ancestorId !== releasedAncestor.Id) {
+                throw sfdxError_1.SfdxError.create('@salesforce/core', 'scratchOrgInfogenerator', 'ErrorAncestorIdVersionMismatch', [
+                    packageDir.ancestorVersion,
+                    packageDir.ancestorId,
+                ]);
+            }
+            return releasedAncestor.Id;
+        }
+        if ((_b = packageDir === null || packageDir === void 0 ? void 0 : packageDir.ancestorId) === null || _b === void 0 ? void 0 : _b.startsWith('05i')) {
+            // if it's already a 05i return it, otherwise query for it
+            return packageDir.ancestorId;
+        }
+        if ((_c = packageDir === null || packageDir === void 0 ? void 0 : packageDir.ancestorId) === null || _c === void 0 ? void 0 : _c.startsWith('04t')) {
+            // query for the Id
+            return (await hubOrg
+                .getConnection()
+                .singleRecordQuery(`SELECT Id FROM Package2Version WHERE SubscriberPackageVersionId = '${packageDir.ancestorId}'`, { tooling: true })).Id;
+        }
+        // ancestorID can be an alias get it from projectJson
+        const packageAliases = projectJson.get('packageAliases');
+        if (packageDir.ancestorId && (packageAliases === null || packageAliases === void 0 ? void 0 : packageAliases[packageDir.ancestorId])) {
+            return packageAliases[packageDir.ancestorId];
+        }
+        throw new sfdxError_1.SfdxError(`Invalid ancestorId ${packageDir.ancestorId}`, 'InvalidAncestorId');
+    }));
+    return Array.from(new Set(ancestorIds)).join(';');
+};
+exports.getAncestorIds = getAncestorIds;
+/**
+ * Takes in a scratchOrgInfo and fills in the missing fields
+ *
+ * @param hubOrg the environment hub org
+ * @param scratchOrgInfoPayload - the scratchOrgInfo passed in by the user
+ * @param nonamespace create the scratch org with no namespace
+ * @param ignoreAncestorIds true if the sfdx-project.json ancestorId keys should be ignored
+ */
+const generateScratchOrgInfo = async ({ hubOrg, scratchOrgInfoPayload, nonamespace, ignoreAncestorIds, }) => {
+    var _a, _b;
+    let sfdxProject;
+    try {
+        sfdxProject = await sfdxProject_1.SfdxProjectJson.create({});
+    }
+    catch (e) {
+        // project is not required
+    }
+    scratchOrgInfoPayload.orgName = (_a = scratchOrgInfoPayload.orgName) !== null && _a !== void 0 ? _a : 'Company';
+    scratchOrgInfoPayload.package2AncestorIds =
+        !ignoreAncestorIds && (sfdxProject === null || sfdxProject === void 0 ? void 0 : sfdxProject.hasPackages())
+            ? await exports.getAncestorIds(scratchOrgInfoPayload, sfdxProject, hubOrg)
+            : '';
+    // Use the Hub org's client ID value, if one wasn't provided to us, or the default
+    if (!scratchOrgInfoPayload.connectedAppConsumerKey) {
+        scratchOrgInfoPayload.connectedAppConsumerKey =
+            (_b = hubOrg.getConnection().getAuthInfoFields().clientId) !== null && _b !== void 0 ? _b : defaultConnectedAppInfo.clientId;
+    }
+    if (!nonamespace && (sfdxProject === null || sfdxProject === void 0 ? void 0 : sfdxProject.get('namespace'))) {
+        scratchOrgInfoPayload.namespace = sfdxProject.get('namespace');
+    }
+    // we already have the info, and want to get rid of configApi, so this doesn't use that
+    scratchOrgInfoPayload.connectedAppCallbackUrl = `http://localhost:${await webOAuthServer_1.WebOAuthServer.determineOauthPort()}/OauthRedirect`;
+    return scratchOrgInfoPayload;
+};
+exports.generateScratchOrgInfo = generateScratchOrgInfo;
+/**
+ * Returns a valid signup json
+ *
+ * @param definitionjson org definition in JSON format
+ * @param definitionfile path to an org definition file
+ * @param connectedAppConsumerKey The connected app consumer key. May be null for JWT OAuth flow.
+ * @param durationdays duration of the scratch org (in days) (default:1, min:1, max:30)
+ * @param nonamespace create the scratch org with no namespace
+ * @param noancestors do not include second-generation package ancestors in the scratch org
+ * @param orgConfig overrides definitionjson
+ * @returns scratchOrgInfoPayload: ScratchOrgInfoPayload;
+            ignoreAncestorIds: boolean;
+            warnings: string[];
+ */
+const getScratchOrgInfoPayload = async (options) => {
+    var _a;
+    let warnings = [];
+    // orgConfig input overrides definitionjson (-j option; hidden/deprecated)
+    const definitionJson = options.definitionjson ? JSON.parse(options.definitionjson) : {};
+    const orgConfigInput = { ...definitionJson, ...((_a = options.orgConfig) !== null && _a !== void 0 ? _a : {}) };
+    let scratchOrgInfoPayload = orgConfigInput;
+    // the -f option
+    if (options.definitionfile) {
+        try {
+            const fileData = await fs_1.promises.readFile(options.definitionfile, 'utf8');
+            const defFileContents = kit_1.parseJson(fileData);
+            // definitionjson and orgConfig override file input
+            scratchOrgInfoPayload = { ...defFileContents, ...orgConfigInput };
+        }
+        catch (err) {
+            const error = err;
+            if (error.name === 'JsonParseError') {
+                throw new sfdxError_1.SfdxError(`An error occurred parsing ${options.definitionfile}`);
+            }
+            throw sfdxError_1.SfdxError.wrap(error);
+        }
+    }
+    // scratchOrgInfoPayload must be heads down camelcase.
+    const upperCaseKey = sfdc_1.sfdc.findUpperCaseKeys(scratchOrgInfoPayload);
+    if (upperCaseKey) {
+        throw new sfdxError_1.SfdxError('InvalidJsonCasing', upperCaseKey);
+    }
+    // Now run the fully resolved user input against the validator
+    Object.keys(scratchOrgInfoPayload).forEach((key) => {
+        optionsValidator(key, scratchOrgInfoPayload);
+    });
+    if (options.connectedAppConsumerKey) {
+        scratchOrgInfoPayload.connectedAppConsumerKey = options.connectedAppConsumerKey;
+    }
+    scratchOrgInfoPayload.durationDays = options.durationDays;
+    // Throw warnings for deprecated scratch org features.
+    const scratchOrgFeatureDeprecation = new scratchOrgFeatureDeprecation_1.ScratchOrgFeatureDeprecation();
+    // convert various supported array and string formats to a semi-colon-delimited string
+    if (scratchOrgInfoPayload.features) {
+        if (typeof scratchOrgInfoPayload.features === 'string') {
+            scratchOrgInfoPayload.features = scratchOrgInfoPayload.features.split(/[;,]/);
+        }
+        warnings = scratchOrgFeatureDeprecation.getFeatureWarnings(scratchOrgInfoPayload.features);
+        scratchOrgInfoPayload.features = scratchOrgInfoPayload.features.map((feature) => feature.trim());
+        scratchOrgInfoPayload.features = scratchOrgFeatureDeprecation
+            .filterDeprecatedFeatures(scratchOrgInfoPayload.features)
+            .join(';');
+    }
+    return {
+        scratchOrgInfoPayload,
+        // Ignore ancestor ids only when 'nonamespace' or 'noancestors' options are specified
+        ignoreAncestorIds: options.nonamespace || options.noancestors || false,
+        warnings,
+    };
+};
+exports.getScratchOrgInfoPayload = getScratchOrgInfoPayload;
+//# sourceMappingURL=scratchOrgInfoGenerator.js.map

package/lib/scratchOrgSettingsGenerator.d.ts

@@ -0,0 +1,56 @@
+import { JsonMap } from '@salesforce/ts-types';
+import { Org } from './org';
+import { ScratchOrgInfo } from './scratchOrgInfoApi';
+export declare enum RequestStatus {
+    Pending = "Pending",
+    InProgress = "InProgress",
+    Succeeded = "Succeeded",
+    SucceededPartial = "SucceededPartial",
+    Failed = "Failed",
+    Canceling = "Canceling",
+    Canceled = "Canceled"
+}
+export interface ObjectSetting extends JsonMap {
+    sharingModel?: string;
+    defaultRecordType?: string;
+}
+export interface BusinessProcessFileContent extends JsonMap {
+    fullName: string;
+    isActive: boolean;
+    values: [
+        {
+            fullName: string;
+            default?: boolean;
+        }
+    ];
+}
+/**
+ * Helper class for dealing with the settings that are defined in a scratch definition file.  This class knows how to extract the
+ * settings from the definition, how to expand them into a MD directory and how to generate a package.xml.
+ */
+export default class SettingsGenerator {
+    private settingData?;
+    private objectSettingsData?;
+    private logger;
+    private writer;
+    private shapeDirName;
+    constructor();
+    /** extract the settings from the scratch def file, if they are present. */
+    extract(scratchDef: ScratchOrgInfo): Promise<void>;
+    /** True if we are currently tracking setting or object setting data. */
+    hasSettings(): boolean;
+    /** Create temporary deploy directory used to upload the scratch org shape.
+     * This will create the dir, all of the .setting files and minimal object files needed for objectSettings
+     */
+    createDeploy(): Promise<void>;
+    /**
+     * Deploys the settings to the org.
+     */
+    deploySettingsViaFolder(scratchOrg: Org, apiVersion: string): Promise<void>;
+    private writeObjectSettingsIfNeeded;
+    private writeSettingsIfNeeded;
+    private createPackageXml;
+    private createObjectFileContent;
+    private createRecordTypeFileContent;
+    private createBusinessProcessFileContent;
+}