@salesforce/core 4.0.0-v3.0 → 4.0.1

package/lib/stateAggregator/accessors/aliasAccessor.d.ts

@@ -0,0 +1,98 @@
+import { AsyncOptionalCreatable } from '@salesforce/kit';
+import { Nullable } from '@salesforce/ts-types';
+import { AuthFields, ConfigContents } from '../../exported';
+import { SfToken } from './tokenAccessor';
+export type Aliasable = string | (Partial<AuthFields> & Partial<SfToken>);
+export declare class AliasAccessor extends AsyncOptionalCreatable {
+    private config;
+    /**
+     * Returns all the aliases for all the values
+     */
+    getAll(): ConfigContents<string>;
+    /**
+     * Returns all the aliases for a given entity
+     *
+     * @param entity the aliasable entity that you want to get the aliases of
+     */
+    getAll(entity: Aliasable): string[];
+    /**
+     * Returns the first alias found for a given entity
+     *
+     * @param entity the aliasable entity that you want to get the alias of
+     */
+    get(entity: Aliasable): Nullable<string>;
+    /**
+     * Returns the value that corresponds to the given alias if it exists
+     *
+     * @param alias the alias that corresponds to a value
+     */
+    getValue(alias: string): Nullable<string>;
+    /**
+     * Returns the username that corresponds to the given alias if it exists
+     *
+     * @param alias the alias that corresponds to a username
+     */
+    getUsername(alias: string): Nullable<string>;
+    /**
+     * If the provided string is an alias, it returns the corresponding value.
+     * If the provided string is not an alias, we assume that the provided string
+     * is the value and return it.
+     *
+     * This method is helpful when you don't know if the string you have is a value
+     * or an alias.
+     *
+     * @param valueOrAlias a string that might be a value or might be an alias
+     */
+    resolveValue(valueOrAlias: string): string;
+    /**
+     * If the provided string is an alias, it returns the corresponding username.
+     * If the provided string is not an alias, we assume that the provided string
+     * is the username and return it.
+     *
+     * This method is helpful when you don't know if the string you have is a username
+     * or an alias.
+     *
+     * @param usernameOrAlias a string that might be a username or might be an alias
+     */
+    resolveUsername(usernameOrAlias: string): string;
+    /**
+     * If the provided string is an alias, return it.
+     * If the provided string is not an alias, return the username of the provided alias
+     *
+     * This method is helpful when you don't know if the string you have is a username
+     * or an alias.
+     *
+     * @param usernameOrAlias a string that might be a username or might be an alias
+     */
+    resolveAlias(usernameOrAlias: string): Nullable<string>;
+    /**
+     * Set an alias for the given aliasable entity
+     *
+     * @param alias the alias you want to set
+     * @param entity the aliasable entity that's being aliased
+     */
+    set(alias: string, entity: Aliasable): void;
+    /**
+     * Unset the given alias.
+     *
+     */
+    unset(alias: string): void;
+    /**
+     * Unsets all the aliases for the given entity.
+     *
+     * @param entity the aliasable entity for which you want to unset all aliases
+     */
+    unsetAll(entity: Aliasable): void;
+    write(): Promise<ConfigContents>;
+    /**
+     * Returns true if the provided alias exists
+     *
+     * @param alias the alias you want to check
+     */
+    has(alias: string): boolean;
+    protected init(): Promise<void>;
+    /**
+     * Returns the username of given aliasable entity
+     */
+    private getNameOf;
+}

package/lib/stateAggregator/accessors/aliasAccessor.js

@@ -0,0 +1,146 @@
+"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.AliasAccessor = void 0;
+const kit_1 = require("@salesforce/kit");
+const aliasesConfig_1 = require("../../config/aliasesConfig");
+const sfError_1 = require("../../sfError");
+class AliasAccessor extends kit_1.AsyncOptionalCreatable {
+    getAll(entity) {
+        // This will only return aliases under "orgs". This will need to be modified
+        // if/when we want to support more aliases groups.
+        const all = (this.config.getGroup() ?? {});
+        if (entity) {
+            const value = this.getNameOf(entity);
+            return Object.entries(all)
+                .filter((entry) => entry[1] === value)
+                .map((entry) => entry[0]);
+        }
+        else {
+            return all;
+        }
+    }
+    /**
+     * Returns the first alias found for a given entity
+     *
+     * @param entity the aliasable entity that you want to get the alias of
+     */
+    get(entity) {
+        return this.getAll(entity).find((alias) => alias) ?? null;
+    }
+    /**
+     * Returns the value that corresponds to the given alias if it exists
+     *
+     * @param alias the alias that corresponds to a value
+     */
+    getValue(alias) {
+        return this.getAll()[alias] ?? null;
+    }
+    /**
+     * Returns the username that corresponds to the given alias if it exists
+     *
+     * @param alias the alias that corresponds to a username
+     */
+    getUsername(alias) {
+        return this.getAll()[alias] ?? null;
+    }
+    /**
+     * If the provided string is an alias, it returns the corresponding value.
+     * If the provided string is not an alias, we assume that the provided string
+     * is the value and return it.
+     *
+     * This method is helpful when you don't know if the string you have is a value
+     * or an alias.
+     *
+     * @param valueOrAlias a string that might be a value or might be an alias
+     */
+    resolveValue(valueOrAlias) {
+        return this.getValue(valueOrAlias) ?? valueOrAlias;
+    }
+    /**
+     * If the provided string is an alias, it returns the corresponding username.
+     * If the provided string is not an alias, we assume that the provided string
+     * is the username and return it.
+     *
+     * This method is helpful when you don't know if the string you have is a username
+     * or an alias.
+     *
+     * @param usernameOrAlias a string that might be a username or might be an alias
+     */
+    resolveUsername(usernameOrAlias) {
+        return this.getUsername(usernameOrAlias) ?? usernameOrAlias;
+    }
+    /**
+     * If the provided string is an alias, return it.
+     * If the provided string is not an alias, return the username of the provided alias
+     *
+     * This method is helpful when you don't know if the string you have is a username
+     * or an alias.
+     *
+     * @param usernameOrAlias a string that might be a username or might be an alias
+     */
+    resolveAlias(usernameOrAlias) {
+        if (this.has(usernameOrAlias))
+            return usernameOrAlias;
+        return Object.entries(this.getAll()).find(([, username]) => username === usernameOrAlias)?.[0];
+    }
+    /**
+     * Set an alias for the given aliasable entity
+     *
+     * @param alias the alias you want to set
+     * @param entity the aliasable entity that's being aliased
+     */
+    set(alias, entity) {
+        this.config.set(alias, this.getNameOf(entity));
+    }
+    /**
+     * Unset the given alias.
+     *
+     */
+    unset(alias) {
+        this.config.unset(alias);
+    }
+    /**
+     * Unsets all the aliases for the given entity.
+     *
+     * @param entity the aliasable entity for which you want to unset all aliases
+     */
+    unsetAll(entity) {
+        const aliases = this.getAll(entity);
+        aliases.forEach((alias) => this.unset(alias));
+    }
+    async write() {
+        return this.config.write();
+    }
+    /**
+     * Returns true if the provided alias exists
+     *
+     * @param alias the alias you want to check
+     */
+    has(alias) {
+        return this.config.has(alias);
+    }
+    async init() {
+        this.config = await aliasesConfig_1.AliasesConfig.create(aliasesConfig_1.AliasesConfig.getDefaultOptions());
+    }
+    /**
+     * Returns the username of given aliasable entity
+     */
+    // eslint-disable-next-line class-methods-use-this
+    getNameOf(entity) {
+        if (typeof entity === 'string')
+            return entity;
+        const aliaseeName = entity.username ?? entity.user;
+        if (!aliaseeName) {
+            throw new sfError_1.SfError(`Invalid aliasee, it must contain a user or username property: ${JSON.stringify(entity)}`);
+        }
+        return aliaseeName;
+    }
+}
+exports.AliasAccessor = AliasAccessor;
+//# sourceMappingURL=aliasAccessor.js.map

package/lib/stateAggregator/accessors/orgAccessor.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+import { Nullable } from '@salesforce/ts-types';
+import { AsyncOptionalCreatable } from '@salesforce/kit';
+import { AuthInfoConfig } from '../../config/authInfoConfig';
+import { AuthFields } from '../../org';
+import { ConfigFile } from '../../config/configFile';
+import { ConfigContents } from '../../config/configStore';
+export declare abstract class BaseOrgAccessor<T extends ConfigFile, P extends ConfigContents> extends AsyncOptionalCreatable {
+    private configs;
+    private contents;
+    private logger;
+    /**
+     * Read the auth file for the given username. Once the file has been read, it can be re-accessed with the `get` method.
+     *
+     * @param username username to read
+     * @param decrypt if true, decrypt encrypted values
+     * @param throwOnNotFound throw if file is not found for username
+     */
+    read(username: string, decrypt?: boolean, throwOnNotFound?: boolean): Promise<Nullable<P>>;
+    /**
+     * Read all the auth files under the global state directory
+     *
+     * @param decrypt if true, decrypt encrypted values
+     */
+    readAll(decrypt?: boolean): Promise<P[]>;
+    get(username: string, decrypt?: boolean, throwOnNotFound?: true): P;
+    /**
+     * Return the contents of all the auth files from cache. The `read` or `readAll` methods must be called first in order to populate the cache.
+     *
+     * @param decrypt if true, decrypt encrypted values
+     * @returns
+     */
+    getAll(decrypt?: boolean): P[];
+    /**
+     * Returns true if the username has been cached.
+     *
+     * @param username
+     */
+    has(username: string): boolean;
+    /**
+     * Returns true if there is an auth file for the given username. The `read` or `readAll` methods must be called first in order to populate the cache.
+     *
+     * @param username
+     */
+    exists(username: string): Promise<boolean>;
+    /**
+     * Return the file stats for a given userame's auth file.
+     *
+     * @param username
+     */
+    stat(username: string): Promise<Nullable<fs.Stats>>;
+    /**
+     * Returns true if there is an auth file for the given username
+     *
+     * @param username
+     */
+    hasFile(username: string): Promise<boolean>;
+    /**
+     * Return all auth files under the global state directory.
+     */
+    list(): Promise<string[]>;
+    /**
+     * Set the contents for a given username.
+     *
+     * @param username
+     * @param org
+     */
+    set(username: string, org: P): void;
+    /**
+     * Update the contents for a given username.
+     *
+     * @param username
+     * @param org
+     */
+    update(username: string, org: Partial<P>): void;
+    /**
+     * Delete the auth file for a given username.
+     *
+     * @param username
+     */
+    remove(username: string): Promise<void>;
+    /**
+     * Write the contents of the auth file for a given username.
+     *
+     * @param username
+     */
+    write(username: string): Promise<Nullable<P>>;
+    protected init(): Promise<void>;
+    private getAllFiles;
+    private parseUsername;
+    private parseFilename;
+    protected abstract initAuthFile(username: string, throwOnNotFound?: boolean): Promise<T>;
+    protected abstract getFileRegex(): RegExp;
+    protected abstract getFileExtension(): string;
+}
+export declare class OrgAccessor extends BaseOrgAccessor<AuthInfoConfig, AuthFields> {
+    protected initAuthFile(username: string, throwOnNotFound?: boolean): Promise<AuthInfoConfig>;
+    protected getFileRegex(): RegExp;
+    protected getFileExtension(): string;
+}

package/lib/stateAggregator/accessors/orgAccessor.js

@@ -0,0 +1,240 @@
+"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.OrgAccessor = exports.BaseOrgAccessor = void 0;
+const fs = require("fs");
+const path = require("path");
+const kit_1 = require("@salesforce/kit");
+const authInfoConfig_1 = require("../../config/authInfoConfig");
+const global_1 = require("../../global");
+const logger_1 = require("../../logger");
+const messages_1 = require("../../messages");
+function chunk(array, chunkSize) {
+    const final = [];
+    for (let i = 0, len = array.length; i < len; i += chunkSize)
+        final.push(array.slice(i, i + chunkSize));
+    return final;
+}
+class BaseOrgAccessor extends kit_1.AsyncOptionalCreatable {
+    constructor() {
+        super(...arguments);
+        this.configs = new Map();
+        this.contents = new Map();
+    }
+    /**
+     * Read the auth file for the given username. Once the file has been read, it can be re-accessed with the `get` method.
+     *
+     * @param username username to read
+     * @param decrypt if true, decrypt encrypted values
+     * @param throwOnNotFound throw if file is not found for username
+     */
+    async read(username, decrypt = false, throwOnNotFound = true) {
+        try {
+            const config = await this.initAuthFile(username, throwOnNotFound);
+            this.configs.set(username, config);
+            return this.get(username, decrypt);
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    /**
+     * Read all the auth files under the global state directory
+     *
+     * @param decrypt if true, decrypt encrypted values
+     */
+    async readAll(decrypt = false) {
+        const fileChunks = chunk(await this.getAllFiles(), 50);
+        for (const fileChunk of fileChunks) {
+            const promises = fileChunk.map(async (f) => {
+                const username = this.parseUsername(f);
+                const config = await this.initAuthFile(username);
+                this.configs.set(username, config);
+            });
+            // eslint-disable-next-line no-await-in-loop
+            await Promise.all(promises);
+        }
+        return this.getAll(decrypt);
+    }
+    /**
+     * Return the contents of the username's auth file from cache.
+     * The `read` or `readAll` methods must be called first in order to populate the cache.
+     * If throwOnNotFound is not true, an empty object {} is returned if the org is not found.
+     *
+     * @param username username to get
+     * @param decrypt if true, decrypt encrypted values
+     * @param throwOnNotFound if true, throw if the auth file does not already exist in the cache
+     */
+    get(username, decrypt = false, throwOnNotFound = false) {
+        const config = this.configs.get(username);
+        if (throwOnNotFound && config?.keys().length === 0) {
+            const messages = new messages_1.Messages('@salesforce/core', 'core', new Map([["authInfoCreationError", "Must pass a username and/or OAuth options when creating an AuthInfo instance."], ["authInfoOverwriteError", "Cannot create an AuthInfo instance that will overwrite existing auth data."], ["authInfoOverwriteError.actions", ["Create the AuthInfo instance using existing auth data by just passing the username. E.g., `AuthInfo.create({ username: 'my@user.org' });`."]], ["authCodeExchangeError", "Error authenticating with auth code due to: %s"], ["authCodeUsernameRetrievalError", "Could not retrieve the username after successful auth code exchange.\n\nDue to: %s"], ["jwtAuthError", "Error authenticating with JWT config due to: %s"], ["jwtAuthErrors", "Error authenticating with JWT.\nErrors encountered:\n%s"], ["refreshTokenAuthError", "Error authenticating with the refresh token due to: %s"], ["orgDataNotAvailableError", "An attempt to refresh the authentication token failed with a 'Data Not Found Error'. The org identified by username %s does not appear to exist. Likely cause is that the org was deleted by another user or has expired."], ["orgDataNotAvailableError.actions", ["Run `sfdx force:org:list --clean` to remove stale org authentications.", "Use `sfdx force:config:set` to update the defaultusername.", "Use `sfdx force:org:create` to create a new org.", "Use `sfdx auth` to authenticate an existing org."]], ["namedOrgNotFound", "No authorization information found for %s."], ["noAliasesFound", "Nothing to set."], ["invalidFormat", "Setting aliases must be in the format <key>=<value> but found: [%s]."], ["invalidJsonCasing", "All JSON input must have heads down camelcase keys. E.g., `{ sfdcLoginUrl: \"https://login.salesforce.com\" }`\nFound \"%s\" at %s"], ["missingClientId", "Client ID is required for JWT authentication."]]));
+            throw messages.createError('namedOrgNotFound', [username]);
+        }
+        if (config) {
+            this.contents.set(username, config.getContents(decrypt));
+        }
+        return this.contents.get(username);
+    }
+    /**
+     * Return the contents of all the auth files from cache. The `read` or `readAll` methods must be called first in order to populate the cache.
+     *
+     * @param decrypt if true, decrypt encrypted values
+     * @returns
+     */
+    getAll(decrypt = false) {
+        return [...this.configs.keys()].map((username) => this.get(username, decrypt)).filter((org) => !(0, kit_1.isEmpty)(org));
+    }
+    /**
+     * Returns true if the username has been cached.
+     *
+     * @param username
+     */
+    has(username) {
+        return this.contents.has(username);
+    }
+    /**
+     * Returns true if there is an auth file for the given username. The `read` or `readAll` methods must be called first in order to populate the cache.
+     *
+     * @param username
+     */
+    async exists(username) {
+        const config = this.configs.get(username);
+        return config ? config.exists() : false;
+    }
+    /**
+     * Return the file stats for a given userame's auth file.
+     *
+     * @param username
+     */
+    async stat(username) {
+        const config = this.configs.get(username);
+        return config ? config.stat() : null;
+    }
+    /**
+     * Returns true if there is an auth file for the given username
+     *
+     * @param username
+     */
+    async hasFile(username) {
+        try {
+            await fs.promises.access(this.parseFilename(username));
+            return true;
+        }
+        catch {
+            this.logger.debug(`No auth file found for ${username}`);
+            return false;
+        }
+    }
+    /**
+     * Return all auth files under the global state directory.
+     */
+    async list() {
+        return this.getAllFiles();
+    }
+    /**
+     * Set the contents for a given username.
+     *
+     * @param username
+     * @param org
+     */
+    set(username, org) {
+        const config = this.configs.get(username);
+        if (config) {
+            config.setContentsFromObject(org);
+            const contents = config.getContents();
+            contents.username ??= username;
+            this.contents.set(username, contents);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            org.username ??= username;
+            this.contents.set(username, org);
+        }
+    }
+    /**
+     * Update the contents for a given username.
+     *
+     * @param username
+     * @param org
+     */
+    update(username, org) {
+        const existing = this.get(username) || {};
+        const merged = Object.assign({}, existing, org);
+        return this.set(username, merged);
+    }
+    /**
+     * Delete the auth file for a given username.
+     *
+     * @param username
+     */
+    async remove(username) {
+        await this.configs.get(username)?.unlink();
+        this.configs.delete(username);
+        this.contents.delete(username);
+    }
+    /**
+     * Write the contents of the auth file for a given username.
+     *
+     * @param username
+     */
+    async write(username) {
+        const config = this.configs.get(username);
+        if (config) {
+            return (await config.write());
+        }
+        else {
+            const contents = this.contents.get(username) ?? {};
+            await this.read(username, false, false);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const readConfig = this.configs.get(username);
+            readConfig.setContentsFromObject(contents);
+            return (await readConfig.write());
+        }
+    }
+    async init() {
+        this.logger = await logger_1.Logger.child(this.constructor.name);
+    }
+    async getAllFiles() {
+        const regex = this.getFileRegex();
+        try {
+            return (await fs.promises.readdir(global_1.Global.DIR)).filter((file) => regex.test(file));
+        }
+        catch {
+            return [];
+        }
+    }
+    parseUsername(filename) {
+        return filename.replace(this.getFileExtension(), '');
+    }
+    parseFilename(username) {
+        return path.join(global_1.Global.DIR, `${username}${this.getFileExtension()}`);
+    }
+}
+exports.BaseOrgAccessor = BaseOrgAccessor;
+class OrgAccessor extends BaseOrgAccessor {
+    // eslint-disable-next-line class-methods-use-this
+    async initAuthFile(username, throwOnNotFound = false) {
+        return authInfoConfig_1.AuthInfoConfig.create({
+            ...authInfoConfig_1.AuthInfoConfig.getOptions(username),
+            throwOnNotFound,
+        });
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getFileRegex() {
+        // The regular expression that filters files stored in $HOME/.sfdx
+        return /^[^.][^@]*@[^.]+(\.[^.\s]+)+\.json$/;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getFileExtension() {
+        return '.json';
+    }
+}
+exports.OrgAccessor = OrgAccessor;
+//# sourceMappingURL=orgAccessor.js.map

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

@@ -0,0 +1,8 @@
+import { SandboxOrgConfig } from '../../config/sandboxOrgConfig';
+import { SandboxFields } from '../../org';
+import { BaseOrgAccessor } from './orgAccessor';
+export declare class SandboxAccessor extends BaseOrgAccessor<SandboxOrgConfig, SandboxFields> {
+    protected initAuthFile(username: string, throwOnNotFound?: boolean): Promise<SandboxOrgConfig>;
+    protected getFileRegex(): RegExp;
+    protected getFileExtension(): string;
+}

package/lib/stateAggregator/accessors/sandboxAccessor.js

@@ -0,0 +1,28 @@
+"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
+ */
+/* eslint-disable class-methods-use-this */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxAccessor = void 0;
+const sandboxOrgConfig_1 = require("../../config/sandboxOrgConfig");
+const orgAccessor_1 = require("./orgAccessor");
+class SandboxAccessor extends orgAccessor_1.BaseOrgAccessor {
+    async initAuthFile(username, throwOnNotFound = false) {
+        return sandboxOrgConfig_1.SandboxOrgConfig.create({
+            ...sandboxOrgConfig_1.SandboxOrgConfig.getOptions(username),
+            throwOnNotFound,
+        });
+    }
+    getFileRegex() {
+        return /^(00D.*?)\.sandbox\.json$/;
+    }
+    getFileExtension() {
+        return '.sandbox.json';
+    }
+}
+exports.SandboxAccessor = SandboxAccessor;
+//# sourceMappingURL=sandboxAccessor.js.map

package/lib/stateAggregator/accessors/tokenAccessor.d.ts

@@ -0,0 +1,63 @@
+import { AsyncOptionalCreatable } from '@salesforce/kit';
+import { JsonMap, Optional } from '@salesforce/ts-types';
+export type SfToken = {
+    token: string;
+    url: string;
+    user?: string;
+    timestamp: string;
+} & JsonMap;
+export type SfTokens = {
+    [key: string]: SfToken;
+};
+export declare class TokenAccessor extends AsyncOptionalCreatable {
+    private config;
+    /**
+     * Return all tokens.
+     *
+     * @param decrypt
+     * @returns {SfTokens}
+     */
+    getAll(decrypt?: boolean): SfTokens;
+    /**
+     * Return a token for the provided name.
+     *
+     * @param name
+     * @param decrypt
+     * @returns {Optional<SfToken>}
+     */
+    get(name: string, decrypt?: boolean): Optional<SfToken>;
+    /**
+     * Return true if a given name has a token associated with it.
+     *
+     * @param name
+     * @returns {boolean}
+     */
+    has(name: string): boolean;
+    /**
+     * Set the token for the provided name.
+     *
+     * @param name
+     * @param token
+     */
+    set(name: string, token: Partial<SfToken>): void;
+    /**
+     * Update the token for the provided name.
+     *
+     * @param name
+     * @param token
+     */
+    update(name: string, token: Partial<SfToken>): void;
+    /**
+     * Unet the token for the provided name.
+     *
+     * @param name
+     */
+    unset(name: string): void;
+    /**
+     * Write the contents to the token file.
+     *
+     * @returns {Promise<SfTokens>}
+     */
+    write(): Promise<SfTokens>;
+    protected init(): Promise<void>;
+}