@salesforce/core 3.13.0 → 3.15.0

package/lib/globalInfo/accessors/sandboxAccessor.d.ts

@@ -0,0 +1,36 @@
+import { Nullable } from '@salesforce/ts-types';
+import { GlobalInfo } from '../globalInfoConfig';
+import { SfSandbox, SfSandboxes } from '../types';
+export declare class SandboxAccessor {
+    private globalInfo;
+    constructor(globalInfo: GlobalInfo);
+    /**
+     * Returns all the sandboxes (or all the sandboxes for a given prod org)
+     *
+     * @param entity entity as a string should be a production org username
+     * and when entity is a SfSandbox, the prod org entity.prodOrgUsername will
+     * used in the filter.
+     */
+    getAll(entity?: string | SfSandbox): SfSandboxes;
+    /**
+     * Returns the SfSandbox config entry that corresponds to the given
+     * sandbox org id if it exists
+     *
+     * @param sandboxOrgId the sandboxOrgId that corresponds to a sandbox
+     */
+    get(sandboxOrgId?: string): Nullable<SfSandbox>;
+    /**
+     * Returns true if the given sandbox org id exists
+     *
+     * @param sandboxOrgId the sandboxOrgId that corresponds to a sandbox
+     */
+    has(sandboxOrgId?: string): boolean;
+    /**
+     * Set an sandboxOrgId for the given sandbox entity
+     *
+     * @param sandboxOrgId the sandboxOrgId you want to set
+     * @param entity the sandbox entity
+     */
+    set(sandboxOrgId: string, entity: SfSandbox): void;
+    unset(sandboxOrgId: string): void;
+}

package/lib/globalInfo/accessors/sandboxAccessor.js

@@ -0,0 +1,63 @@
+"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.SandboxAccessor = void 0;
+const types_1 = require("../types");
+class SandboxAccessor {
+    constructor(globalInfo) {
+        this.globalInfo = globalInfo;
+    }
+    /**
+     * Returns all the sandboxes (or all the sandboxes for a given prod org)
+     *
+     * @param entity entity as a string should be a production org username
+     * and when entity is a SfSandbox, the prod org entity.prodOrgUsername will
+     * used in the filter.
+     */
+    getAll(entity) {
+        const all = this.globalInfo.get(types_1.SfInfoKeys.SANDBOXES) || {};
+        if (!entity) {
+            return all;
+        }
+        const prodOrgUsername = typeof entity === 'string' ? entity : entity.prodOrgUsername;
+        return Object.fromEntries(Object.entries(all).filter(([, value]) => value.prodOrgUsername === prodOrgUsername));
+    }
+    /**
+     * Returns the SfSandbox config entry that corresponds to the given
+     * sandbox org id if it exists
+     *
+     * @param sandboxOrgId the sandboxOrgId that corresponds to a sandbox
+     */
+    get(sandboxOrgId) {
+        var _a;
+        return sandboxOrgId ? (_a = this.getAll()[sandboxOrgId]) !== null && _a !== void 0 ? _a : null : null;
+    }
+    /**
+     * Returns true if the given sandbox org id exists
+     *
+     * @param sandboxOrgId the sandboxOrgId that corresponds to a sandbox
+     */
+    has(sandboxOrgId) {
+        var _a;
+        return !!(sandboxOrgId ? (_a = this.getAll()[sandboxOrgId]) !== null && _a !== void 0 ? _a : null : null);
+    }
+    /**
+     * Set an sandboxOrgId for the given sandbox entity
+     *
+     * @param sandboxOrgId the sandboxOrgId you want to set
+     * @param entity the sandbox entity
+     */
+    set(sandboxOrgId, entity) {
+        this.globalInfo.set(`${types_1.SfInfoKeys.SANDBOXES}["${sandboxOrgId}"]`, entity);
+    }
+    unset(sandboxOrgId) {
+        delete this.globalInfo.get(types_1.SfInfoKeys.SANDBOXES)[sandboxOrgId];
+    }
+}
+exports.SandboxAccessor = SandboxAccessor;
+//# sourceMappingURL=sandboxAccessor.js.map

package/lib/globalInfo/globalInfoConfig.d.ts

@@ -5,6 +5,7 @@ import { OrgAccessor } from './accessors/orgAccessor';
 import { TokenAccessor } from './accessors/tokenAccessor';
 import { AliasAccessor } from './accessors/aliasAccessor';
 import { SfInfo } from './types';
+import { SandboxAccessor } from './accessors/sandboxAccessor';
 export declare function deepCopy<T extends AnyJson>(data: T): T;
 export declare class GlobalInfo extends ConfigFile<ConfigFile.Options, SfInfo> {
     protected static encryptedKeys: RegExp[];
@@ -27,6 +28,7 @@ export declare class GlobalInfo extends ConfigFile<ConfigFile.Options, SfInfo> {
     get orgs(): OrgAccessor;
     get tokens(): TokenAccessor;
     get aliases(): AliasAccessor;
+    get sandboxes(): SandboxAccessor;
     set(key: string, value: ConfigValue): void;
     write(newContents?: SfInfo): Promise<SfInfo>;
     protected init(): Promise<void>;

package/lib/globalInfo/globalInfoConfig.js

@@ -15,6 +15,7 @@ const orgAccessor_1 = require("./accessors/orgAccessor");
 const tokenAccessor_1 = require("./accessors/tokenAccessor");
 const aliasAccessor_1 = require("./accessors/aliasAccessor");
 const types_1 = require("./types");
+const sandboxAccessor_1 = require("./accessors/sandboxAccessor");
 function deepCopy(data) {
     return JSON.parse(JSON.stringify(data));
 }
@@ -64,6 +65,9 @@ class GlobalInfo extends configFile_1.ConfigFile {
     get aliases() {
         return new aliasAccessor_1.AliasAccessor(this);
     }
+    get sandboxes() {
+        return new sandboxAccessor_1.SandboxAccessor(this);
+    }
     set(key, value) {
         if ((0, ts_types_1.isPlainObject)(value)) {
             value = this.timestamp(value);
@@ -101,5 +105,6 @@ GlobalInfo.EMPTY_DATA_MODEL = {
     [types_1.SfInfoKeys.ORGS]: {},
     [types_1.SfInfoKeys.TOKENS]: {},
     [types_1.SfInfoKeys.ALIASES]: {},
+    [types_1.SfInfoKeys.SANDBOXES]: {},
 };
 //# sourceMappingURL=globalInfoConfig.js.map

package/lib/globalInfo/sfdxDataHandler.d.ts

@@ -1,5 +1,5 @@
 import { ConfigFile } from '../config/configFile';
-import { SfInfo, SfInfoKeys, SfOrg, SfOrgs } from './types';
+import { SfInfo, SfInfoKeys, SfOrg, SfOrgs, SfSandbox } from './types';
 interface Handler<T extends SfInfoKeys> {
     sfKey: T;
     merge: (sfData: SfInfo) => Promise<Partial<SfInfo>>;
@@ -11,7 +11,7 @@ interface Changes<T> {
     deleted: string[];
 }
 export declare class SfdxDataHandler {
-    handlers: (AuthHandler | AliasesHandler)[];
+    handlers: (AuthHandler | AliasesHandler | SandboxesHandler)[];
     private original;
     write(latest?: SfInfo): Promise<void>;
     merge(sfData?: SfInfo): Promise<SfInfo>;
@@ -40,4 +40,14 @@ export declare class AliasesHandler extends BaseHandler<SfInfoKeys.ALIASES> {
     merge(sfData?: SfInfo): Promise<Partial<SfInfo>>;
     write(latest: SfInfo): Promise<void>;
 }
+export declare class SandboxesHandler extends BaseHandler<SfInfoKeys.SANDBOXES> {
+    private static sandboxFilenameFilterRegEx;
+    sfKey: typeof SfInfoKeys.SANDBOXES;
+    merge(sfData?: SfInfo): Promise<Partial<SfInfo>>;
+    migrate(): Promise<Pick<SfInfo, SfInfoKeys.SANDBOXES>>;
+    write(latest: SfInfo, original: SfInfo): Promise<void>;
+    listAllSandboxFiles(): Promise<string[]>;
+    listAllSandboxes(): Promise<SfSandbox[]>;
+    private findChanges;
+}
 export {};

package/lib/globalInfo/sfdxDataHandler.js

@@ -6,13 +6,14 @@
  * 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.AliasesHandler = exports.AuthHandler = exports.SfdxDataHandler = void 0;
+exports.SandboxesHandler = exports.AliasesHandler = exports.AuthHandler = exports.SfdxDataHandler = void 0;
 const path_1 = require("path");
 const fs = require("fs");
 const kit_1 = require("@salesforce/kit");
 const ts_types_1 = require("@salesforce/ts-types");
 const global_1 = require("../global");
 const configFile_1 = require("../config/configFile");
+const sandboxOrgConfig_1 = require("../config/sandboxOrgConfig");
 const globalInfoConfig_1 = require("./globalInfoConfig");
 const types_1 = require("./types");
 function isEqual(object1, object2) {
@@ -28,13 +29,11 @@ function isEqual(object1, object2) {
 }
 class SfdxDataHandler {
     constructor() {
-        this.handlers = [new AuthHandler(), new AliasesHandler()];
+        this.handlers = [new AuthHandler(), new AliasesHandler(), new SandboxesHandler()];
     }
     async write(latest = globalInfoConfig_1.GlobalInfo.emptyDataModel) {
-        for (const handler of this.handlers) {
-            await handler.write(latest, this.original);
-            this.setOriginal(latest);
-        }
+        await Promise.all(this.handlers.map((handler) => handler.write(latest, this.original)));
+        this.setOriginal(latest);
     }
     async merge(sfData = globalInfoConfig_1.GlobalInfo.emptyDataModel) {
         let merged = (0, globalInfoConfig_1.deepCopy)(sfData);
@@ -67,13 +66,13 @@ class BaseHandler {
             });
             (0, kit_1.set)(merged, `${key}["${k}"]`, Object.assign({}, older, newer));
         }
-        // Keys that exist in .sfdx but not .sf are added becase we assume
+        // Keys that exist in .sfdx but not .sf are added because we assume
         // that this means the key was created using sfdx.
         // However, this is not always a valid assumption because it could
         // also mean that the key was deleted using sf, in which case we
         // do not want to migrate the sfdx key to sf.
         // Programmatically differentiating between a new key and a deleted key
-        // would be nearly impossible. Instead we should ensure that whenever
+        // would be nearly impossible. Instead, we should ensure that whenever
         // sf deletes a key it also deletes it in sfdx. This way, we can safely
         // assume that we should migrate any keys that exist in in .sfdx
         const unhandledSfdxKeys = sfdxKeys.filter((k) => !sfKeys.includes(k));
@@ -103,17 +102,17 @@ class AuthHandler extends BaseHandler {
     }
     async write(latest, original) {
         const { changed, deleted } = await this.findChanges(latest, original);
-        for (const [username, authData] of Object.entries(changed)) {
-            if (authData) {
-                const config = await this.createAuthFileConfig(username);
-                config.setContentsFromObject(authData);
-                await config.write();
-            }
-        }
-        for (const username of deleted) {
+        await Promise.all(Object.entries(changed)
+            .filter(([, authData]) => authData)
+            .map(async ([username, authData]) => {
             const config = await this.createAuthFileConfig(username);
-            await config.unlink();
-        }
+            config.setContentsFromObject(authData);
+            return config.write();
+        }));
+        await Promise.all(deleted.map(async (username) => {
+            const config = await this.createAuthFileConfig(username);
+            return config.unlink();
+        }));
     }
     async findChanges(latest, original) {
         var _a;
@@ -146,16 +145,14 @@ class AuthHandler extends BaseHandler {
     }
     async listAllAuthorizations() {
         const filenames = await this.listAllAuthFiles();
-        const auths = [];
-        for (const filename of filenames) {
-            const username = (0, path_1.basename)(filename, (0, path_1.extname)(filename));
+        return Promise.all(filenames
+            .map((f) => (0, path_1.basename)(f, (0, path_1.extname)(f)))
+            .map(async (username) => {
             const configFile = await this.createAuthFileConfig(username);
             const contents = configFile.getContents();
             const stat = await configFile.stat();
-            const auth = Object.assign(contents, { timestamp: stat.mtime.toISOString() });
-            auths.push(auth);
-        }
-        return auths;
+            return { ...contents, timestamp: stat.mtime.toISOString() };
+        }));
     }
 }
 exports.AuthHandler = AuthHandler;
@@ -215,4 +212,98 @@ class AliasesHandler extends BaseHandler {
 }
 exports.AliasesHandler = AliasesHandler;
 AliasesHandler.SFDX_ALIASES_FILENAME = 'alias.json';
+class SandboxesHandler extends BaseHandler {
+    constructor() {
+        super(...arguments);
+        this.sfKey = types_1.SfInfoKeys.SANDBOXES;
+    }
+    async merge(sfData = globalInfoConfig_1.GlobalInfo.emptyDataModel) {
+        var _a, _b;
+        const sfdxData = await this.migrate();
+        const merged = (0, globalInfoConfig_1.deepCopy)(sfData);
+        // Only merge the key this handler is responsible for.
+        const key = this.sfKey;
+        const sfKeys = Object.keys((_a = sfData[key]) !== null && _a !== void 0 ? _a : {});
+        const sfdxKeys = Object.keys((_b = sfdxData[key]) !== null && _b !== void 0 ? _b : {});
+        // sandbox entries for .sf and .sfdx contain static data. Given there
+        // can be no mutation during the life of the sandbox, having to merge common keys
+        // is unnecessary.
+        // Keys that exist in .sfdx but not .sf are added because we assume
+        // that this means the key was created using sfdx.
+        // However, this is not always a valid assumption because it could
+        // also mean that the key was deleted using sf, in which case we
+        // do not want to migrate the sfdx key to sf.
+        // Programmatically differentiating between a new key and a deleted key
+        // would be nearly impossible. Instead, we should ensure that whenever
+        // sf deletes a key it also deletes it in sfdx. This way, we can safely
+        // assume that we should migrate any keys that exist in .sfdx
+        const unhandledSfdxKeys = sfdxKeys.filter((k) => !sfKeys.includes(k));
+        for (const k of unhandledSfdxKeys) {
+            (0, kit_1.set)(merged, `${key}["${k}"]`, sfdxData[key][k]);
+        }
+        // Keys that exist in .sf but not .sfdx are deleted because we assume
+        // that this means the key was deleted while using sfdx.
+        // We can make this assumption because keys that are created by sf will
+        // always be migrated back to sfdx
+        const unhandledSfKeys = sfKeys.filter((k) => !sfdxKeys.includes(k));
+        for (const k of unhandledSfKeys) {
+            delete merged[key][k];
+        }
+        return merged;
+    }
+    async migrate() {
+        const oldSandboxes = await this.listAllSandboxes();
+        const newSandboxes = Object.fromEntries(oldSandboxes.map((old) => [old.sandboxOrgId, old]));
+        return { [this.sfKey]: newSandboxes };
+    }
+    async write(latest, original) {
+        const { changed, deleted } = await this.findChanges(latest, original);
+        for (const sandboxData of Object.values(changed)) {
+            if (sandboxData) {
+                const orgId = sandboxData.sandboxOrgId;
+                const sandboxConfig = new sandboxOrgConfig_1.SandboxOrgConfig(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(orgId));
+                sandboxConfig.set(sandboxOrgConfig_1.SandboxOrgConfig.Fields.PROD_ORG_USERNAME, sandboxData.prodOrgUsername);
+                await sandboxConfig.write();
+            }
+        }
+        for (const username of deleted) {
+            const originalSandbox = original.sandboxes[username];
+            const orgId = originalSandbox.sandboxOrgId;
+            const sandboxConfig = new sandboxOrgConfig_1.SandboxOrgConfig(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(orgId));
+            await sandboxConfig.unlink();
+        }
+    }
+    async listAllSandboxFiles() {
+        const globalFiles = await fs.promises.readdir(global_1.Global.SFDX_DIR);
+        return globalFiles.filter((file) => file.match(SandboxesHandler.sandboxFilenameFilterRegEx));
+    }
+    async listAllSandboxes() {
+        return Promise.all((await this.listAllSandboxFiles()).map(async (filename) => {
+            const matches = filename.match(SandboxesHandler.sandboxFilenameFilterRegEx);
+            const orgId = matches ? matches[1] : '';
+            const sandboxConfig = new sandboxOrgConfig_1.SandboxOrgConfig(sandboxOrgConfig_1.SandboxOrgConfig.getOptions(orgId));
+            const stat = await sandboxConfig.stat();
+            const contents = { ...(await sandboxConfig.read(true)), sandboxOrgId: orgId };
+            const sandbox = Object.assign(contents, { timestamp: stat.mtime.toISOString() });
+            return sandbox;
+        }));
+    }
+    async findChanges(latest, original) {
+        var _a;
+        const latestSandboxes = latest.sandboxes;
+        const originalSandboxes = original.sandboxes;
+        const changed = {};
+        for (const [sandboxOrgId, sandbox] of Object.entries(latestSandboxes)) {
+            const originalSandbox = (_a = originalSandboxes[sandboxOrgId]) !== null && _a !== void 0 ? _a : {};
+            if (!isEqual(sandbox, originalSandbox)) {
+                changed[sandboxOrgId] = sandbox;
+            }
+        }
+        const deleted = Object.keys(originalSandboxes).filter((sandboxOrgId) => !latestSandboxes[sandboxOrgId]);
+        return { changed, deleted };
+    }
+}
+exports.SandboxesHandler = SandboxesHandler;
+// The regular expression that filters files stored in $HOME/.sfdx
+SandboxesHandler.sandboxFilenameFilterRegEx = /^(00D.*?)\.sandbox\.json$/;
 //# sourceMappingURL=sfdxDataHandler.js.map

package/lib/globalInfo/types.d.ts

@@ -2,7 +2,8 @@ import { JsonMap } from '@salesforce/ts-types';
 export declare enum SfInfoKeys {
     ORGS = "orgs",
     TOKENS = "tokens",
-    ALIASES = "aliases"
+    ALIASES = "aliases",
+    SANDBOXES = "sandboxes"
 }
 export declare type Timestamp = {
     timestamp: string;
@@ -32,8 +33,25 @@ export interface SfTokens {
 export interface SfAliases {
     [alias: string]: string;
 }
+export declare type SfSandbox = {
+    sandboxOrgId: string;
+    prodOrgUsername: string;
+    sandboxName?: string;
+    sandboxUsername?: string;
+    sandboxProcessId?: string;
+    sandboxInfoId?: string;
+} & Timestamp & SfEntry;
+/**
+ * The key will always be the sandbox username and the value will always be the
+ * production org username
+ * { "user@salesforce.com.mysandbox": "user@salesforce.com" }
+ */
+export interface SfSandboxes {
+    [sandboxOrgId: string]: SfSandbox;
+}
 export declare type SfInfo = {
     [SfInfoKeys.ORGS]: SfOrgs;
     [SfInfoKeys.TOKENS]: SfTokens;
     [SfInfoKeys.ALIASES]: SfAliases;
+    [SfInfoKeys.SANDBOXES]: SfSandboxes;
 };

package/lib/globalInfo/types.js

@@ -6,5 +6,6 @@ var SfInfoKeys;
     SfInfoKeys["ORGS"] = "orgs";
     SfInfoKeys["TOKENS"] = "tokens";
     SfInfoKeys["ALIASES"] = "aliases";
+    SfInfoKeys["SANDBOXES"] = "sandboxes";
 })(SfInfoKeys = exports.SfInfoKeys || (exports.SfInfoKeys = {}));
 //# sourceMappingURL=types.js.map

package/lib/org/authInfo.d.ts

@@ -46,6 +46,7 @@ export declare type OrgAuthorization = {
     configs: Nullable<string[]>;
     isScratchOrg?: boolean;
     isDevHub?: boolean;
+    isSandbox?: boolean;
     instanceUrl?: string;
     accessToken?: string;
     error?: string;
@@ -60,7 +61,7 @@ export interface AccessTokenOptions {
     instanceUrl?: string;
 }
 export declare type AuthSideEffects = {
-    alias: string;
+    alias?: string;
     setDefault: boolean;
     setDefaultDevHub: boolean;
 };

package/lib/org/authInfo.js

@@ -130,7 +130,7 @@ class AuthInfo extends kit_1.AsyncOptionalCreatable {
      * @returns {string}
      */
     static getDefaultInstanceUrl() {
-        const configuredInstanceUrl = configAggregator_1.ConfigAggregator.getValue('instanceUrl').value;
+        const configuredInstanceUrl = configAggregator_1.ConfigAggregator.getValue(orgConfigProperties_1.OrgConfigProperties.ORG_INSTANCE_URL).value;
         return configuredInstanceUrl || sfdcUrl_1.SfdcUrl.PRODUCTION;
     }
     /**
@@ -166,6 +166,7 @@ class AuthInfo extends kit_1.AsyncOptionalCreatable {
                     instanceUrl,
                     isScratchOrg: Boolean(devHubUsername),
                     isDevHub: isDevHub || false,
+                    isSandbox: globalInfo.sandboxes.has(orgId),
                     orgId: orgId,
                     accessToken: authInfo.getConnectionOptions().accessToken,
                     oauthMethod: authInfo.isJwt() ? 'jwt' : authInfo.isOauth() ? 'web' : 'token',

package/lib/org/connection.js

@@ -86,7 +86,7 @@ class Connection extends jsforce_1.Connection {
         if (!baseOptions.version) {
             // Set the API version obtained from the config aggregator.
             const configAggregator = options.configAggregator || (await configAggregator_1.ConfigAggregator.create());
-            baseOptions.version = (0, ts_types_1.asString)(configAggregator.getInfo('apiVersion').value);
+            baseOptions.version = (0, ts_types_1.asString)(configAggregator.getInfo('org-api-version').value);
         }
         const providedOptions = options.authInfo.getConnectionOptions();
         // Get connection options from auth info and create a new jsForce connection
@@ -102,7 +102,7 @@ class Connection extends jsforce_1.Connection {
                 }
             }
             else {
-                conn.logger.debug(`The apiVersion ${baseOptions.version} was found from ${((_b = options.connectionOptions) === null || _b === void 0 ? void 0 : _b.version) ? 'passed in options' : 'config'}`);
+                conn.logger.debug(`The org-api-version ${baseOptions.version} was found from ${((_b = options.connectionOptions) === null || _b === void 0 ? void 0 : _b.version) ? 'passed in options' : 'config'}`);
             }
         }
         catch (err) {
@@ -334,7 +334,7 @@ class Connection extends jsforce_1.Connection {
     async autoFetchQuery(soql, queryOptions = {}) {
         const config = await configAggregator_1.ConfigAggregator.create();
         // take the limit from the calling function, then the config, then default 10,000
-        const maxFetch = config.getInfo('maxQueryLimit').value || queryOptions.maxFetch || 10000;
+        const maxFetch = config.getInfo('org-max-query-limit').value || queryOptions.maxFetch || 10000;
         const options = Object.assign(queryOptions, {
             autoFetch: true,
             maxFetch,
@@ -418,7 +418,7 @@ class Connection extends jsforce_1.Connection {
             // so get the latest.
             await useLatest();
         }
-        this.logger.debug(`Loaded latest apiVersion ${version}`);
+        this.logger.debug(`Loaded latest org-api-version ${version}`);
         return version;
     }
 }