@salesforce/core 4.0.0-v3.0 → 4.0.1

package/lib/org/scratchOrgInfoGenerator.js

@@ -0,0 +1,237 @@
+"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
+ */
+const fs_1 = require("fs");
+const kit_1 = require("@salesforce/kit");
+const ts_types_1 = require("@salesforce/ts-types");
+const sfProject_1 = require("../sfProject");
+const webOAuthServer_1 = require("../webOAuthServer");
+const messages_1 = require("../messages");
+const sfError_1 = require("../sfError");
+const scratchOrgFeatureDeprecation_1 = require("./scratchOrgFeatureDeprecation");
+const authInfo_1 = require("./authInfo");
+const messages = new messages_1.Messages('@salesforce/core', 'scratchOrgInfoGenerator', new Map([["Package2AncestorsIdsKeyNotSupportedError", "The package2AncestorIds key is no longer supported in a scratch org definition. Ancestors defined in sfdx-project.json will be included in the scratch org.\","], ["InvalidAncestorVersionFormatError", "The ancestor versionNumber must be in the format major.minor.patch but the value found is %s\","], ["NoMatchingAncestorError", "The ancestor for ancestorVersion %s can't be found. Package ID %s.\","], ["NoMatchingAncestorIdError", "The ancestor for ancestorId [%s] can't be found. Package ID %s.\""], ["AncestorNotReleasedError", "The ancestor package version [%s] specified in the sfdx-project.json file may exist hasn\u2019t been promoted and released. Release the ancestor package version before specifying it as the ancestor in a new package or patch version.\","], ["AncestorIdVersionMismatchError", "The ancestorVersion in sfdx-project.json is not the version expected for the ancestorId you supplied. ancestorVersion %s. ancestorID %s.\""], ["unsupportedSnapshotOrgCreateOptions", "Org snapshots don\u2019t support one or more options you specified: %s"]]));
+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 sfError_1.SfError('unrecognizedScratchOrgOption', 'durationDays');
+    }
+    if (key.toLowerCase() === 'snapshot') {
+        const foundInvalidFields = SNAPSHOT_UNSUPPORTED_OPTIONS.filter((invalidField) => invalidField in scratchOrgInfoPayload);
+        if (foundInvalidFields.length > 0) {
+            throw new sfError_1.SfError(messages.getMessage('unsupportedSnapshotOrgCreateOptions', [foundInvalidFields.join(', ')]), 'orgSnapshot');
+        }
+    }
+};
+/**
+ * Generates the package2AncestorIds scratch org property
+ *
+ * @param scratchOrgInfo - the scratchOrgInfo passed in by the user
+ * @param projectJson - sfProjectJson
+ * @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 sfError_1.SfError(messages.getMessage('Package2AncestorsIdsKeyNotSupportedError'), '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) => {
+        // 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
+        // package can be an ID, but not according to docs
+        const packageAliases = projectJson.get('packageAliases');
+        const packageId = packageAliases[(0, ts_types_1.ensureString)(packageDir.package)] ?? packageDir.package;
+        // Handle HIGHEST and NONE in ancestor(Version|Id).
+        // Precedence chain: NONE -> HIGHEST -> ancestorVersion & ancestoryId
+        if (packageDir.ancestorVersion === 'NONE' || packageDir.ancestorId === 'NONE') {
+            return '';
+        }
+        else if (packageDir.ancestorVersion === 'HIGHEST' || packageDir.ancestorId === 'HIGHEST') {
+            const query = 'SELECT Id FROM Package2Version ' +
+                `WHERE Package2Id = '${packageId}' AND IsReleased = True AND IsDeprecated = False AND PatchVersion = 0 ` +
+                'ORDER BY MajorVersion Desc, MinorVersion Desc, PatchVersion Desc, BuildNumber Desc LIMIT 1';
+            try {
+                return (await hubOrg.getConnection().singleRecordQuery(query, { tooling: true })).Id;
+            }
+            catch (err) {
+                if (packageDir.ancestorVersion === 'HIGHEST') {
+                    throw new sfError_1.SfError(messages.getMessage('NoMatchingAncestorError', [packageDir.ancestorVersion, packageDir.package]), 'NoMatchingAncestorError', [messages.getMessage('AncestorNotReleasedError', [packageDir.ancestorVersion])]);
+                }
+                else {
+                    throw new sfError_1.SfError(messages.getMessage('NoMatchingAncestorIdError', [packageDir.ancestorId, packageDir.package]), 'NoMatchingAncestorIdError', [messages.getMessage('AncestorNotReleasedError', [packageDir.ancestorId])]);
+                }
+            }
+        }
+        if (packageDir.ancestorVersion) {
+            if (!/^[0-9]+.[0-9]+.[0-9]+(.[0-9]+)?$/.test(packageDir.ancestorVersion)) {
+                throw messages.createError('InvalidAncestorVersionFormatError', [packageDir.ancestorVersion]);
+            }
+            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 sfError_1.SfError(messages.getMessage('NoMatchingAncestorError', [packageDir.ancestorVersion, packageDir.package]), 'NoMatchingAncestorError', [messages.getMessage('AncestorNotReleasedError', [packageDir.ancestorVersion])]);
+            }
+            if (packageDir.ancestorId && packageDir.ancestorId !== releasedAncestor.Id) {
+                throw messages.createError('AncestorIdVersionMismatchError', [
+                    packageDir.ancestorVersion,
+                    packageDir.ancestorId,
+                ]);
+            }
+            return releasedAncestor.Id;
+        }
+        if (packageDir?.ancestorId?.startsWith('05i')) {
+            // if it's already a 05i return it, otherwise query for it
+            return packageDir.ancestorId;
+        }
+        if (packageDir?.ancestorId?.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
+        if (packageDir.ancestorId && packageAliases?.[packageDir.ancestorId]) {
+            return packageAliases[packageDir.ancestorId];
+        }
+        throw new sfError_1.SfError(`Invalid ancestorId ${packageDir.ancestorId}`, 'InvalidAncestorId');
+    }));
+    // strip out '' due to NONE
+    return Array.from(new Set(ancestorIds.filter((id) => id !== ''))).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, }) => {
+    let sfProject;
+    try {
+        sfProject = await sfProject_1.SfProjectJson.create({});
+    }
+    catch (e) {
+        // project is not required
+    }
+    scratchOrgInfoPayload.orgName = scratchOrgInfoPayload.orgName ?? 'Company';
+    scratchOrgInfoPayload.package2AncestorIds =
+        !ignoreAncestorIds && sfProject?.hasPackages()
+            ? await (0, exports.getAncestorIds)(scratchOrgInfoPayload, sfProject, hubOrg)
+            : '';
+    // Use the Hub org's client ID value, if one wasn't provided to us, or the default
+    if (!scratchOrgInfoPayload.connectedAppConsumerKey) {
+        scratchOrgInfoPayload.connectedAppConsumerKey =
+            hubOrg.getConnection().getAuthInfoFields().clientId ?? authInfo_1.DEFAULT_CONNECTED_APP_INFO.clientId;
+    }
+    if (!nonamespace && sfProject?.get('namespace')) {
+        scratchOrgInfoPayload.namespace = sfProject.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
+ *
+ * definitionjson org definition in JSON format
+ * definitionfile path to an org definition file
+ * connectedAppConsumerKey The connected app consumer key. May be null for JWT OAuth flow.
+ * durationdays duration of the scratch org (in days) (default:1, min:1, max:30)
+ * nonamespace create the scratch org with no namespace
+ * noancestors do not include second-generation package ancestors in the scratch org
+ * orgConfig overrides definitionjson
+ *
+ * @returns scratchOrgInfoPayload: ScratchOrgInfoPayload;
+ ignoreAncestorIds: boolean;
+ warnings: string[];
+ */
+const getScratchOrgInfoPayload = async (options) => {
+    let warnings = [];
+    // orgConfig input overrides definitionjson (-j option; hidden/deprecated) overrides definitionfile (-f option)
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const scratchOrgInfoPayload = {
+        ...(options.definitionfile ? await parseDefinitionFile(options.definitionfile) : {}),
+        ...(options.definitionjson ? JSON.parse(options.definitionjson) : {}),
+        ...(options.orgConfig ?? {}),
+    };
+    // scratchOrgInfoPayload must be heads down camelcase.
+    Object.keys(scratchOrgInfoPayload).forEach((key) => {
+        if (key[0].toUpperCase() === key[0]) {
+            throw new sfError_1.SfError('InvalidJsonCasing', key);
+        }
+    });
+    // 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;
+const parseDefinitionFile = async (definitionFile) => {
+    try {
+        const fileData = await fs_1.promises.readFile(definitionFile, 'utf8');
+        const defFileContents = (0, kit_1.parseJson)(fileData);
+        return defFileContents;
+    }
+    catch (err) {
+        const error = err;
+        if (error.name === 'JsonParseError') {
+            throw new sfError_1.SfError(`An error occurred parsing ${definitionFile}`);
+        }
+        throw sfError_1.SfError.wrap(error);
+    }
+};
+//# sourceMappingURL=scratchOrgInfoGenerator.js.map

package/lib/org/scratchOrgLifecycleEvents.d.ts

@@ -0,0 +1,10 @@
+import { AuthFields } from './authInfo';
+import { ScratchOrgInfo } from './scratchOrgTypes';
+export declare const scratchOrgLifecycleEventName = "scratchOrgLifecycleEvent";
+export declare const scratchOrgLifecycleStages: readonly ["prepare request", "send request", "wait for org", "available", "authenticate", "deploy settings", "done"];
+export interface ScratchOrgLifecycleEvent {
+    stage: typeof scratchOrgLifecycleStages[number];
+    scratchOrgInfo?: ScratchOrgInfo;
+}
+export declare const emit: (event: ScratchOrgLifecycleEvent) => Promise<void>;
+export declare const emitPostOrgCreate: (authFields: AuthFields) => Promise<void>;

package/lib/org/scratchOrgLifecycleEvents.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPostOrgCreate = exports.emit = exports.scratchOrgLifecycleStages = exports.scratchOrgLifecycleEventName = 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 lifecycleEvents_1 = require("../lifecycleEvents");
+const emitter = lifecycleEvents_1.Lifecycle.getInstance();
+exports.scratchOrgLifecycleEventName = 'scratchOrgLifecycleEvent';
+exports.scratchOrgLifecycleStages = [
+    'prepare request',
+    'send request',
+    'wait for org',
+    'available',
+    'authenticate',
+    'deploy settings',
+    'done',
+];
+const emit = async (event) => emitter.emit(exports.scratchOrgLifecycleEventName, event);
+exports.emit = emit;
+const postOrgCreateHookFields = [
+    'accessToken',
+    'clientId',
+    'created',
+    'createdOrgInstance',
+    'devHubUsername',
+    'expirationDate',
+    'instanceUrl',
+    'loginUrl',
+    'orgId',
+    'username',
+];
+const isHookField = (key) => postOrgCreateHookFields.includes(key);
+const emitPostOrgCreate = async (authFields) => {
+    await emitter.emit('postorgcreate', Object.fromEntries(Object.entries(authFields).filter(([key]) => isHookField(key))));
+};
+exports.emitPostOrgCreate = emitPostOrgCreate;
+//# sourceMappingURL=scratchOrgLifecycleEvents.js.map

package/lib/org/scratchOrgSettingsGenerator.d.ts

@@ -0,0 +1,79 @@
+import { Duration } from '@salesforce/kit';
+import { JsonMap } from '@salesforce/ts-types';
+import { ScratchOrgInfo, ObjectSetting } from './scratchOrgTypes';
+import { Org } from './org';
+export declare enum RequestStatus {
+    Pending = "Pending",
+    InProgress = "InProgress",
+    Succeeded = "Succeeded",
+    SucceededPartial = "SucceededPartial",
+    Failed = "Failed",
+    Canceling = "Canceling",
+    Canceled = "Canceled"
+}
+export interface SettingType {
+    members: string[];
+    name: 'CustomObject' | 'RecordType' | 'BusinessProcess' | 'Settings';
+}
+export interface PackageFile {
+    '@': {
+        xmlns: string;
+    };
+    types: SettingType[];
+    version: string;
+}
+export declare const createObjectFileContent: ({ allRecordTypes, allBusinessProcesses, apiVersion, settingData, objectSettingsData, }: {
+    allRecordTypes?: string[] | undefined;
+    allBusinessProcesses?: string[] | undefined;
+    apiVersion: string;
+    settingData?: Record<string, unknown> | undefined;
+    objectSettingsData?: {
+        [objectName: string]: ObjectSetting;
+    } | undefined;
+}) => PackageFile;
+export declare const createRecordTypeAndBusinessProcessFileContent: (objectName: string, json: Record<string, unknown>, allRecordTypes: string[], allBusinessProcesses: string[]) => JsonMap;
+/**
+ * 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 allRecordTypes;
+    private allBusinessProcesses;
+    private readonly shapeDirName;
+    private readonly packageFilePath;
+    constructor(options?: {
+        mdApiTmpDir?: string;
+        shapeDirName?: string;
+        asDirectory?: boolean;
+    });
+    /** extract the settings from the scratch def file, if they are present. */
+    extract(scratchDef: ScratchOrgInfo): Promise<{
+        settings: Record<string, unknown> | undefined;
+        objectSettings: {
+            [objectName: string]: ObjectSetting;
+        } | undefined;
+    }>;
+    /** 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, timeout?: Duration): Promise<void>;
+    createDeployPackageContents(apiVersion: string): Promise<void>;
+    getShapeDirName(): string;
+    /**
+     * Returns the destination where the writer placed the settings content.
+     *
+     */
+    getDestinationPath(): string | undefined;
+    private writeObjectSettingsIfNeeded;
+    private writeSettingsIfNeeded;
+}

package/lib/org/scratchOrgSettingsGenerator.js

@@ -0,0 +1,277 @@
+"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.createRecordTypeAndBusinessProcessFileContent = exports.createObjectFileContent = exports.RequestStatus = void 0;
+const path = require("path");
+const kit_1 = require("@salesforce/kit");
+const ts_types_1 = require("@salesforce/ts-types");
+const js2xmlparser = require("js2xmlparser");
+const logger_1 = require("../logger");
+const sfError_1 = require("../sfError");
+const pollingClient_1 = require("../status/pollingClient");
+const zipWriter_1 = require("../util/zipWriter");
+const directoryWriter_1 = require("../util/directoryWriter");
+var RequestStatus;
+(function (RequestStatus) {
+    RequestStatus["Pending"] = "Pending";
+    RequestStatus["InProgress"] = "InProgress";
+    RequestStatus["Succeeded"] = "Succeeded";
+    RequestStatus["SucceededPartial"] = "SucceededPartial";
+    RequestStatus["Failed"] = "Failed";
+    RequestStatus["Canceling"] = "Canceling";
+    RequestStatus["Canceled"] = "Canceled";
+})(RequestStatus = exports.RequestStatus || (exports.RequestStatus = {}));
+const breakPolling = ['Succeeded', 'SucceededPartial', 'Failed', 'Canceled'];
+const createObjectFileContent = ({ allRecordTypes = [], allBusinessProcesses = [], apiVersion, settingData, objectSettingsData, }) => {
+    const output = {
+        '@': {
+            xmlns: 'http://soap.sforce.com/2006/04/metadata',
+        },
+        types: [],
+    };
+    if (settingData) {
+        const strings = Object.keys(settingData).map((item) => (0, kit_1.upperFirst)(item).replace('Settings', ''));
+        output.types.push({ members: strings, name: 'Settings' });
+    }
+    if (objectSettingsData) {
+        const strings = Object.keys(objectSettingsData).map((item) => (0, kit_1.upperFirst)(item));
+        output.types.push({ members: strings, name: 'CustomObject' });
+        if (allRecordTypes.length > 0) {
+            output.types.push({ members: allRecordTypes, name: 'RecordType' });
+        }
+        if (allBusinessProcesses.length > 0) {
+            output.types.push({ members: allBusinessProcesses, name: 'BusinessProcess' });
+        }
+    }
+    return { ...output, ...{ version: apiVersion } };
+};
+exports.createObjectFileContent = createObjectFileContent;
+const calculateBusinessProcess = (objectName, defaultRecordType) => {
+    let businessProcessName = null;
+    let businessProcessPicklistVal = null;
+    // These four objects require any record type to specify a "business process"--
+    // a restricted set of items from a standard picklist on the object.
+    if (['Case', 'Lead', 'Opportunity', 'Solution'].includes(objectName)) {
+        businessProcessName = (0, kit_1.upperFirst)(defaultRecordType) + 'Process';
+        switch (objectName) {
+            case 'Case':
+                businessProcessPicklistVal = 'New';
+                break;
+            case 'Lead':
+                businessProcessPicklistVal = 'New - Not Contacted';
+                break;
+            case 'Opportunity':
+                businessProcessPicklistVal = 'Prospecting';
+                break;
+            case 'Solution':
+                businessProcessPicklistVal = 'Draft';
+        }
+    }
+    return [businessProcessName, businessProcessPicklistVal];
+};
+const createRecordTypeAndBusinessProcessFileContent = (objectName, json, allRecordTypes, allBusinessProcesses) => {
+    let output = {
+        '@': {
+            xmlns: 'http://soap.sforce.com/2006/04/metadata',
+        },
+    };
+    const name = (0, kit_1.upperFirst)(objectName);
+    const sharingModel = json.sharingModel;
+    if (sharingModel) {
+        output = {
+            ...output,
+            sharingModel: (0, kit_1.upperFirst)(sharingModel),
+        };
+    }
+    const defaultRecordType = json.defaultRecordType;
+    if (typeof defaultRecordType === 'string') {
+        // We need to keep track of these globally for when we generate the package XML.
+        allRecordTypes.push(`${name}.${(0, kit_1.upperFirst)(defaultRecordType)}`);
+        const [businessProcessName, businessProcessPicklistVal] = calculateBusinessProcess(name, defaultRecordType);
+        // Create the record type
+        const recordTypes = {
+            fullName: (0, kit_1.upperFirst)(defaultRecordType),
+            label: (0, kit_1.upperFirst)(defaultRecordType),
+            active: true,
+        };
+        output = {
+            ...output,
+            recordTypes: {
+                ...recordTypes,
+            },
+        };
+        if (businessProcessName) {
+            // We need to keep track of these globally for the package.xml
+            const values = {
+                fullName: businessProcessPicklistVal,
+            };
+            if (name !== 'Opportunity') {
+                values.default = true;
+            }
+            allBusinessProcesses.push(`${name}.${businessProcessName}`);
+            output = {
+                ...output,
+                recordTypes: {
+                    ...recordTypes,
+                    businessProcess: businessProcessName,
+                },
+                businessProcesses: {
+                    fullName: businessProcessName,
+                    isActive: true,
+                    values,
+                },
+            };
+        }
+    }
+    return output;
+};
+exports.createRecordTypeAndBusinessProcessFileContent = createRecordTypeAndBusinessProcessFileContent;
+/**
+ * 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.
+ */
+class SettingsGenerator {
+    constructor(options) {
+        this.allRecordTypes = [];
+        this.allBusinessProcesses = [];
+        this.logger = logger_1.Logger.childFromRoot('SettingsGenerator');
+        // If SFDX_MDAPI_TEMP_DIR is set, copy settings to that dir for people to inspect.
+        const mdApiTmpDir = options?.mdApiTmpDir ?? kit_1.env.getString('SFDX_MDAPI_TEMP_DIR');
+        this.shapeDirName = options?.shapeDirName ?? `shape_${Date.now()}`;
+        this.packageFilePath = path.join(this.shapeDirName, 'package.xml');
+        let storePath;
+        if (!options?.asDirectory) {
+            storePath = mdApiTmpDir ? path.join(mdApiTmpDir, `${this.shapeDirName}.zip`) : undefined;
+            this.writer = new zipWriter_1.ZipWriter(storePath);
+        }
+        else {
+            storePath = mdApiTmpDir ? path.join(mdApiTmpDir, this.shapeDirName) : undefined;
+            this.writer = new directoryWriter_1.DirectoryWriter(storePath);
+        }
+    }
+    /** extract the settings from the scratch def file, if they are present. */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async extract(scratchDef) {
+        this.logger.debug('extracting settings from scratch definition file');
+        this.settingData = scratchDef.settings;
+        this.objectSettingsData = scratchDef.objectSettings;
+        this.logger.debug('settings are', this.settingData);
+        return { settings: this.settingData, objectSettings: this.objectSettingsData };
+    }
+    /** True if we are currently tracking setting or object setting data. */
+    hasSettings() {
+        return !(0, kit_1.isEmpty)(this.settingData) || !(0, kit_1.isEmpty)(this.objectSettingsData);
+    }
+    /** 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
+     */
+    async createDeploy() {
+        const settingsDir = path.join(this.shapeDirName, 'settings');
+        const objectsDir = path.join(this.shapeDirName, 'objects');
+        await Promise.all([
+            this.writeSettingsIfNeeded(settingsDir),
+            this.writeObjectSettingsIfNeeded(objectsDir, this.allRecordTypes, this.allBusinessProcesses),
+        ]);
+    }
+    /**
+     * Deploys the settings to the org.
+     */
+    async deploySettingsViaFolder(scratchOrg, apiVersion, timeout = kit_1.Duration.minutes(10)) {
+        const username = scratchOrg.getUsername();
+        const logger = await logger_1.Logger.child('deploySettingsViaFolder');
+        await this.createDeployPackageContents(apiVersion);
+        const connection = scratchOrg.getConnection();
+        logger.debug(`deploying to apiVersion: ${apiVersion}`);
+        connection.setApiVersion(apiVersion);
+        const { id } = await connection.deploy(this.writer.buffer, {});
+        logger.debug(`deploying settings id ${id}`);
+        let result = await connection.metadata.checkDeployStatus(id);
+        const pollingOptions = {
+            async poll() {
+                try {
+                    result = await connection.metadata.checkDeployStatus(id, true);
+                    logger.debug(`Deploy id: ${id} status: ${result.status}`);
+                    if (breakPolling.includes(result.status)) {
+                        return {
+                            completed: true,
+                            payload: result.status,
+                        };
+                    }
+                    return {
+                        completed: false,
+                    };
+                }
+                catch (error) {
+                    logger.debug(`An error occurred trying to check deploy id: ${id}`);
+                    logger.debug(`Error: ${error.message}`);
+                    logger.debug('Re-trying deploy check again....');
+                    return {
+                        completed: false,
+                    };
+                }
+            },
+            timeout,
+            frequency: kit_1.Duration.seconds(1),
+            timeoutErrorName: 'DeployingSettingsTimeoutError',
+        };
+        const client = await pollingClient_1.PollingClient.create(pollingOptions);
+        const status = await client.subscribe();
+        if (status !== RequestStatus.Succeeded) {
+            const componentFailures = (0, ts_types_1.ensureObject)(result.details).componentFailures;
+            const failures = (Array.isArray(componentFailures) ? componentFailures : [componentFailures])
+                .map((failure) => failure.problem)
+                .join('\n');
+            const error = new sfError_1.SfError(`A scratch org was created with username ${username}, but the settings failed to deploy due to: \n${failures}`, 'ProblemDeployingSettings');
+            error.setData(result);
+            throw error;
+        }
+    }
+    async createDeployPackageContents(apiVersion) {
+        const packageObjectProps = (0, exports.createObjectFileContent)({
+            allRecordTypes: this.allRecordTypes,
+            allBusinessProcesses: this.allBusinessProcesses,
+            apiVersion,
+            settingData: this.settingData,
+            objectSettingsData: this.objectSettingsData,
+        });
+        const xml = js2xmlparser.parse('Package', packageObjectProps);
+        await this.writer.addToStore(xml, this.packageFilePath);
+        await this.writer.finalize();
+    }
+    getShapeDirName() {
+        return this.shapeDirName;
+    }
+    /**
+     * Returns the destination where the writer placed the settings content.
+     *
+     */
+    getDestinationPath() {
+        return this.writer.getDestinationPath();
+    }
+    async writeObjectSettingsIfNeeded(objectsDir, allRecordTypes, allbusinessProcesses) {
+        if (this.objectSettingsData) {
+            await Promise.all(Object.entries(this.objectSettingsData).map(([item, value]) => {
+                const fileContent = (0, exports.createRecordTypeAndBusinessProcessFileContent)(item, value, allRecordTypes, allbusinessProcesses);
+                const xml = js2xmlparser.parse('CustomObject', fileContent);
+                return this.writer.addToStore(xml, path.join(objectsDir, (0, kit_1.upperFirst)(item) + '.object'));
+            }));
+        }
+    }
+    async writeSettingsIfNeeded(settingsDir) {
+        if (this.settingData) {
+            await Promise.all(Object.entries(this.settingData).map(([item, value]) => {
+                const typeName = (0, kit_1.upperFirst)(item);
+                const fname = typeName.replace('Settings', '');
+                const fileContent = js2xmlparser.parse(typeName, value);
+                return this.writer.addToStore(fileContent, path.join(settingsDir, fname + '.settings'));
+            }));
+        }
+    }
+}
+exports.default = SettingsGenerator;
+//# sourceMappingURL=scratchOrgSettingsGenerator.js.map