@salesforce/core 3.7.5 → 3.7.8

package/lib/org/scratchOrgCreate.d.ts

@@ -0,0 +1,43 @@
+import { Duration } from '@salesforce/kit';
+import { Org } from './org';
+import { ScratchOrgInfo } from './scratchOrgInfoApi';
+import { AuthFields, AuthInfo } from './authInfo';
+export declare const DEFAULT_STREAM_TIMEOUT_MINUTES = 6;
+export interface ScratchOrgCreateResult {
+    username?: string;
+    scratchOrgInfo?: ScratchOrgInfo;
+    authInfo?: AuthInfo;
+    authFields?: AuthFields;
+    warnings: string[];
+}
+/**
+ * interface ScratchOrgCreateOptions
+ *
+ * @param hubOrg the environment hub org
+ * @param connectedAppConsumerKey The connected app consumer key.
+ * @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 wait the streaming client socket timeout (in minutes) must be an instance of the Duration utility class (default:6, min:2)
+ * @param retry number of scratch org auth retries after scratch org is successfully signed up (default:0, min:0, max:10)
+ * @param apiversion target server instance API version
+ * @param definitionjson org definition in JSON format
+ * @param definitionfile path to an org definition file
+ * @param orgConfig overrides definitionjson
+ * @param clientSecret OAuth client secret of personal connected app
+ */
+export interface ScratchOrgCreateOptions {
+    hubOrg: Org;
+    connectedAppConsumerKey?: string;
+    durationDays?: number;
+    nonamespace?: boolean;
+    noancestors?: boolean;
+    wait?: Duration;
+    retry?: number;
+    apiversion?: string;
+    definitionjson?: string;
+    definitionfile?: string;
+    orgConfig?: Record<string, unknown>;
+    clientSecret?: string;
+}
+export declare const scratchOrgCreate: (options: ScratchOrgCreateOptions) => Promise<ScratchOrgCreateResult>;

package/lib/org/scratchOrgCreate.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scratchOrgCreate = exports.DEFAULT_STREAM_TIMEOUT_MINUTES = void 0;
+/*
+ * Copyright (c) 2020, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+const kit_1 = require("@salesforce/kit");
+const ts_types_1 = require("@salesforce/ts-types");
+const messages_1 = require("../messages");
+const logger_1 = require("../logger");
+const configAggregator_1 = require("../config/configAggregator");
+const sfProject_1 = require("../sfProject");
+const sfError_1 = require("../sfError");
+const org_1 = require("./org");
+const scratchOrgInfoApi_1 = require("./scratchOrgInfoApi");
+const scratchOrgSettingsGenerator_1 = require("./scratchOrgSettingsGenerator");
+const scratchOrgInfoGenerator_1 = require("./scratchOrgInfoGenerator");
+const connection_1 = require("./connection");
+messages_1.Messages.importMessagesDirectory(__dirname);
+const messages = messages_1.Messages.load('@salesforce/core', 'scratchOrgCreate', [
+    'SourceStatusResetFailureError',
+    'DurationDaysValidationMaxError',
+    'DurationDaysValidationMinError',
+    'RetryNotIntError',
+    'WaitValidationMaxError',
+    'DurationDaysNotIntError',
+]);
+exports.DEFAULT_STREAM_TIMEOUT_MINUTES = 6;
+const validateDuration = (durationDays) => {
+    const min = 1;
+    const max = 30;
+    if (Number.isInteger(durationDays)) {
+        if (durationDays < min) {
+            throw messages.createError('DurationDaysValidationMinError', [min, durationDays]);
+        }
+        if (durationDays > max) {
+            throw messages.createError('DurationDaysValidationMaxError', [max, durationDays]);
+        }
+        return;
+    }
+    throw messages.createError('DurationDaysNotIntError');
+};
+const validateRetry = (retry) => {
+    if (!Number.isInteger(retry)) {
+        throw messages.createError('RetryNotIntError');
+    }
+};
+const validateWait = (wait) => {
+    const min = 2;
+    if (wait.minutes < min) {
+        throw messages.createError('WaitValidationMaxError', [min, wait.minutes]);
+    }
+};
+const scratchOrgCreate = async (options) => {
+    var _a;
+    const logger = await logger_1.Logger.child('scratchOrgCreate');
+    logger.debug('scratchOrgCreate');
+    const { hubOrg, connectedAppConsumerKey, durationDays = 1, nonamespace, noancestors, wait = kit_1.Duration.minutes(exports.DEFAULT_STREAM_TIMEOUT_MINUTES), retry = 0, apiversion, definitionjson, definitionfile, orgConfig, clientSecret = undefined, } = options;
+    validateDuration(durationDays);
+    validateRetry(retry);
+    validateWait(wait);
+    const { scratchOrgInfoPayload, ignoreAncestorIds, warnings } = await (0, scratchOrgInfoGenerator_1.getScratchOrgInfoPayload)({
+        definitionjson,
+        definitionfile,
+        connectedAppConsumerKey,
+        durationDays,
+        nonamespace,
+        noancestors,
+        orgConfig,
+    });
+    const scratchOrgInfo = await (0, scratchOrgInfoGenerator_1.generateScratchOrgInfo)({
+        hubOrg,
+        scratchOrgInfoPayload,
+        nonamespace,
+        ignoreAncestorIds,
+    });
+    // gets the scratch org settings (will use in both signup paths AND to deploy the settings)
+    const settingsGenerator = new scratchOrgSettingsGenerator_1.default();
+    await settingsGenerator.extract(scratchOrgInfo);
+    logger.debug(`the scratch org def file has settings: ${settingsGenerator.hasSettings()}`);
+    // creates the scratch org info in the devhub
+    const scratchOrgInfoRequestResult = await (0, scratchOrgInfoApi_1.requestScratchOrgCreation)(hubOrg, scratchOrgInfo, settingsGenerator);
+    const scratchOrgInfoId = (0, ts_types_1.ensureString)((0, ts_types_1.getString)(scratchOrgInfoRequestResult, 'id'));
+    logger.debug(`scratch org has recordId ${scratchOrgInfoId}`);
+    const scratchOrgInfoResult = await (0, scratchOrgInfoApi_1.pollForScratchOrgInfo)(hubOrg, scratchOrgInfoId, wait);
+    const signupTargetLoginUrlConfig = await getSignupTargetLoginUrl();
+    const scratchOrgAuthInfo = await (0, scratchOrgInfoApi_1.authorizeScratchOrg)({
+        scratchOrgInfoComplete: scratchOrgInfoResult,
+        hubOrg,
+        clientSecret,
+        signupTargetLoginUrlConfig,
+        retry: retry || 0,
+    });
+    // we'll need this scratch org connection later;
+    const connection = await connection_1.Connection.create({ authInfo: scratchOrgAuthInfo });
+    const scratchOrg = await org_1.Org.create({ connection }); // scartchOrg should come from command
+    const username = scratchOrg.getUsername();
+    logger.debug(`scratch org username ${username}`);
+    const configAggregator = new configAggregator_1.ConfigAggregator();
+    const authInfo = await (0, scratchOrgInfoApi_1.deploySettingsAndResolveUrl)(scratchOrgAuthInfo, (_a = apiversion !== null && apiversion !== void 0 ? apiversion : configAggregator.getPropertyValue('apiVersion')) !== null && _a !== void 0 ? _a : (await scratchOrg.retrieveMaxApiVersion()), settingsGenerator, scratchOrg);
+    logger.trace('Settings deployed to org');
+    /** updating the revision num to zero during org:creation if source members are created during org:create.This only happens for some specific scratch org definition file.*/
+    await updateRevisionCounterToZero(scratchOrg);
+    return {
+        username,
+        scratchOrgInfo: scratchOrgInfoResult,
+        authInfo,
+        authFields: authInfo === null || authInfo === void 0 ? void 0 : authInfo.getFields(),
+        warnings,
+    };
+};
+exports.scratchOrgCreate = scratchOrgCreate;
+const getSignupTargetLoginUrl = async () => {
+    try {
+        const project = await sfProject_1.SfProject.resolve();
+        const projectJson = await project.resolveProjectConfig();
+        return projectJson.signupTargetLoginUrl;
+    }
+    catch {
+        // a project isn't required for org:create
+    }
+};
+const updateRevisionCounterToZero = async (scratchOrg) => {
+    const conn = scratchOrg.getConnection();
+    const queryResult = await conn.tooling.sobject('SourceMember').find({ RevisionCounter: { $gt: 0 } }, ['Id']);
+    try {
+        await conn.tooling
+            .sobject('SourceMember')
+            .update(queryResult.map((record) => ({ Id: record.Id, RevisionCounter: 0 })));
+    }
+    catch (err) {
+        const message = messages.getMessage('SourceStatusResetFailureError', [
+            scratchOrg.getOrgId(),
+            scratchOrg.getUsername(),
+        ]);
+        throw new sfError_1.SfError(message, 'SourceStatusResetFailure');
+    }
+};
+//# sourceMappingURL=scratchOrgCreate.js.map

package/lib/org/scratchOrgErrorCodes.d.ts

@@ -0,0 +1,4 @@
+import { Optional } from '@salesforce/ts-types';
+import { Logger } from '../logger';
+import { ScratchOrgInfo } from './scratchOrgInfoApi';
+export declare const checkScratchOrgInfoForErrors: (orgInfo: Optional<ScratchOrgInfo>, hubUsername: Optional<string>, logger: Logger) => ScratchOrgInfo;

package/lib/org/scratchOrgErrorCodes.js

@@ -0,0 +1,62 @@
+"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.checkScratchOrgInfoForErrors = void 0;
+const messages_1 = require("../messages");
+const sfError_1 = require("../sfError");
+const WORKSPACE_CONFIG_FILENAME = 'sfdx-project.json';
+messages_1.Messages.importMessagesDirectory(__dirname);
+const messages = messages_1.Messages.loadMessages('@salesforce/core', 'scratchOrgErrorCodes');
+const namedMessages = messages_1.Messages.load('@salesforce/core', 'scratchOrgErrorCodes', [
+    'SignupFailedActionError',
+    'SignupFailedUnknownError',
+    'SignupFailedError',
+    'SignupUnexpectedError',
+]);
+// getMessage will throw when the code isn't found
+// and we don't know whether a given code takes arguments or not
+const optionalErrorCodeMessage = (errorCode, args) => {
+    try {
+        // only apply args if message requires them
+        let message = messages.getMessage(errorCode);
+        if (message.includes('%s')) {
+            message = messages.getMessage(errorCode, args);
+        }
+        return message;
+    }
+    catch {
+        // generic error message
+        return undefined;
+    }
+};
+const checkScratchOrgInfoForErrors = (orgInfo, hubUsername, logger) => {
+    if (!orgInfo) {
+        throw new sfError_1.SfError('No scratch org info found.', 'ScratchOrgInfoNotFound');
+    }
+    if (orgInfo.Status === 'Active') {
+        return orgInfo;
+    }
+    if (orgInfo.Status === 'Error' && orgInfo.ErrorCode) {
+        const message = optionalErrorCodeMessage(orgInfo.ErrorCode, [WORKSPACE_CONFIG_FILENAME]);
+        if (message) {
+            throw new sfError_1.SfError(message, 'RemoteOrgSignupFailed', [
+                namedMessages.getMessage('SignupFailedActionError', [orgInfo.ErrorCode]),
+            ]);
+        }
+        throw new sfError_1.SfError(namedMessages.getMessage('SignupFailedError', [orgInfo.ErrorCode]));
+    }
+    if (orgInfo.Status === 'Error') {
+        // Maybe the request object can help the user somehow
+        logger.error('No error code on signup error! Logging request.');
+        logger.error(orgInfo);
+        throw new sfError_1.SfError(namedMessages.getMessage('SignupFailedUnknownError', [orgInfo.Id, hubUsername]), 'signupFailedUnknown');
+    }
+    throw new sfError_1.SfError(namedMessages.getMessage('SignupUnexpectedError'), 'UnexpectedSignupStatus');
+};
+exports.checkScratchOrgInfoForErrors = checkScratchOrgInfoForErrors;
+//# sourceMappingURL=scratchOrgErrorCodes.js.map

package/lib/org/scratchOrgFeatureDeprecation.d.ts

@@ -0,0 +1,26 @@
+interface FeatureTypes {
+    simpleFeatureMapping: {
+        [key: string]: string[];
+    };
+    quantifiedFeatureMapping: Record<string, string | number | boolean | null | undefined>;
+    deprecatedFeatures: string[];
+}
+export declare class ScratchOrgFeatureDeprecation {
+    private featureTypes;
+    constructor(options?: FeatureTypes);
+    /**
+     * Gets list of feature warnings that should be logged
+     *
+     * @param features The requested features.
+     * @returns List of string feature warnings.
+     */
+    getFeatureWarnings(features: string | string[]): string[];
+    /**
+     * Removes all deprecated features for the organization.
+     *
+     * @param features List of features to filter
+     * @returns feature array with proper mapping.
+     */
+    filterDeprecatedFeatures(features: string[]): string[];
+}
+export {};

package/lib/org/scratchOrgFeatureDeprecation.js

@@ -0,0 +1,110 @@
+"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.ScratchOrgFeatureDeprecation = void 0;
+/**
+ * Certain Org Features require a translation or should be deprecated.
+ * Encapsulates feature mappings and deprecated features.
+ */
+const ts_types_1 = require("@salesforce/ts-types");
+// Local
+const messages_1 = require("../messages");
+messages_1.Messages.importMessagesDirectory(__dirname);
+const messages = messages_1.Messages.load('@salesforce/core', 'scratchOrgFeatureDeprecation', [
+    'quantifiedFeatureWithoutQuantityWarning',
+    'mappedFeatureWarning',
+    'deprecatedFeatureWarning',
+]);
+const FEATURE_TYPES = {
+    // simpleFeatureMapping holds a set of direct replacement values for features.
+    simpleFeatureMapping: {
+        SALESWAVE: ['DEVELOPMENTWAVE'],
+        SERVICEWAVE: ['DEVELOPMENTWAVE'],
+    },
+    quantifiedFeatureMapping: {},
+    deprecatedFeatures: [
+        'EXPANDEDSOURCETRACKING',
+        'LISTCUSTOMSETTINGCREATION',
+        'AppNavCapabilities',
+        'EditInSubtab',
+        'OldNewRecordFlowConsole',
+        'OldNewRecordFlowStd',
+        'DesktopLayoutStandardOff',
+        'SplitViewOnStandardOff',
+        'PopOutUtilities',
+    ],
+};
+class ScratchOrgFeatureDeprecation {
+    // Allow override for testing.
+    constructor(options = FEATURE_TYPES) {
+        this.featureTypes = options;
+        this.featureTypes.deprecatedFeatures = this.featureTypes.deprecatedFeatures.map((deprecatedFeature) => deprecatedFeature.toUpperCase());
+        // Make all of the keys in simpleFeatureMapping upper case.
+        const sfm = {};
+        Object.keys(this.featureTypes.simpleFeatureMapping).forEach((key) => {
+            sfm[key.toUpperCase()] = this.featureTypes.simpleFeatureMapping[key];
+        });
+        this.featureTypes.simpleFeatureMapping = sfm;
+    }
+    /**
+     * Gets list of feature warnings that should be logged
+     *
+     * @param features The requested features.
+     * @returns List of string feature warnings.
+     */
+    getFeatureWarnings(features) {
+        /* Get warning messages for deprecated features and feature mappings.*/
+        const featureWarningMessages = [];
+        const requestedFeatures = ((0, ts_types_1.isString)(features) ? features : features.join(';')).toUpperCase();
+        /* If a public quantified feature is defined without a quantity, throw a warning.*/
+        Object.keys(this.featureTypes.quantifiedFeatureMapping).forEach((key) => {
+            if (new RegExp(`${key};|${key},|${key}$`, 'i').test(requestedFeatures)) {
+                featureWarningMessages.push(messages.getMessage('quantifiedFeatureWithoutQuantityWarning', [
+                    key,
+                    this.featureTypes.quantifiedFeatureMapping[key],
+                ]));
+            }
+        });
+        /* If a simply mapped feature is defined, log a warning.*/
+        Object.keys(this.featureTypes.simpleFeatureMapping).forEach((key) => {
+            if (new RegExp(`${key};|${key},|${key}$`, 'i').test(requestedFeatures)) {
+                const tokens = '[' + this.featureTypes.simpleFeatureMapping[key].map((v) => "'" + v + "'").join(',') + ']';
+                featureWarningMessages.push(messages.getMessage('mappedFeatureWarning', [key, tokens]));
+            }
+        });
+        /* If a deprecated feature is identified as deprecated, throw a warning.*/
+        this.featureTypes.deprecatedFeatures.forEach((deprecatedFeature) => {
+            if (requestedFeatures.includes(deprecatedFeature)) {
+                featureWarningMessages.push(messages.getMessage('deprecatedFeatureWarning', [deprecatedFeature]));
+            }
+        });
+        return featureWarningMessages;
+    }
+    /**
+     * Removes all deprecated features for the organization.
+     *
+     * @param features List of features to filter
+     * @returns feature array with proper mapping.
+     */
+    filterDeprecatedFeatures(features) {
+        return features.reduce((previousValue, currentValue) => {
+            const feature = currentValue.toUpperCase();
+            if (this.featureTypes.deprecatedFeatures.includes(feature)) {
+                return previousValue;
+            }
+            else if (this.featureTypes.simpleFeatureMapping[feature]) {
+                /* If a simply mapped feature is specified, then perform the mapping. */
+                const simpleFeatureMapping = this.featureTypes.simpleFeatureMapping[feature];
+                return [...previousValue, ...simpleFeatureMapping];
+            }
+            return [...previousValue, currentValue];
+        }, []);
+    }
+}
+exports.ScratchOrgFeatureDeprecation = ScratchOrgFeatureDeprecation;
+//# sourceMappingURL=scratchOrgFeatureDeprecation.js.map

package/lib/org/scratchOrgInfoApi.d.ts

@@ -0,0 +1,94 @@
+import { Optional } from '@salesforce/ts-types';
+import { Duration } from '@salesforce/kit';
+import { SaveResult } from 'jsforce';
+import { AuthInfo } from './authInfo';
+import { Org } from './org';
+import SettingsGenerator, { ObjectSetting } from './scratchOrgSettingsGenerator';
+export interface ScratchOrgInfo {
+    AdminEmail?: string;
+    readonly CreatedDate?: string;
+    ConnectedAppCallbackUrl?: string;
+    ConnectedAppConsumerKey?: string;
+    Country?: string;
+    Description?: string;
+    DurationDays?: string;
+    Edition?: string;
+    readonly ErrorCode?: string;
+    readonly ExpirationDate?: string;
+    Features?: string;
+    HasSampleData?: boolean;
+    readonly Id?: string;
+    Language?: string;
+    LoginUrl: string;
+    readonly Name?: string;
+    Namespace?: string;
+    OrgName?: string;
+    Release?: 'Current' | 'Previous' | 'Preview';
+    readonly ScratchOrg?: string;
+    SourceOrg?: string;
+    readonly AuthCode: string;
+    Snapshot: string;
+    readonly Status: 'New' | 'Creating' | 'Active' | 'Error' | 'Deleted';
+    readonly SignupEmail: string;
+    readonly SignupUsername: string;
+    readonly SignupInstance: string;
+    Username: string;
+    settings?: Record<string, unknown>;
+    objectSettings?: {
+        [objectName: string]: ObjectSetting;
+    };
+    orgPreferences?: {
+        enabled: string[];
+        disabled: string[];
+    };
+}
+export interface JsForceError extends Error {
+    errorCode: string;
+    fields: string[];
+}
+/**
+ * after we successfully signup an org we need to trade the auth token for access and refresh token.
+ *
+ * scratchOrgInfoComplete - The completed ScratchOrgInfo which should contain an access token.
+ * hubOrg - the environment hub org
+ * clientSecret - The OAuth client secret. May be null for JWT OAuth flow.
+ * signupTargetLoginUrlConfig - Login url
+ * retry - auth retry attempts
+ *
+ * @returns {Promise<AuthInfo>}
+ */
+export declare const authorizeScratchOrg: (options: {
+    scratchOrgInfoComplete: ScratchOrgInfo;
+    hubOrg: Org;
+    clientSecret?: string;
+    signupTargetLoginUrlConfig?: string;
+    retry?: number;
+}) => Promise<AuthInfo>;
+/**
+ * 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<SaveResult>}
+ */
+export declare const requestScratchOrgCreation: (hubOrg: Org, scratchOrgRequest: ScratchOrgInfo, settings: SettingsGenerator) => Promise<SaveResult>;
+/**
+ * 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>}
+ */
+export declare const pollForScratchOrgInfo: (hubOrg: Org, scratchOrgInfoId: string, timeout?: Duration) => Promise<ScratchOrgInfo>;
+/**
+ * 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>>}
+ */
+export declare const deploySettingsAndResolveUrl: (scratchOrgAuthInfo: AuthInfo, apiVersion: string, orgSettings: SettingsGenerator, scratchOrg: Org) => Promise<Optional<AuthInfo>>;