@salesforce/core 3.19.0 → 3.19.3

package/lib/org/scratchOrgCreate.js

@@ -13,7 +13,7 @@ const messages_1 = require("../messages");
 const logger_1 = require("../logger");
 const configAggregator_1 = require("../config/configAggregator");
 const sfProject_1 = require("../sfProject");
-const globalInfo_1 = require("../globalInfo");
+const stateAggregator_1 = require("../stateAggregator");
 const org_1 = require("./org");
 const scratchOrgInfoApi_1 = require("./scratchOrgInfoApi");
 const scratchOrgSettingsGenerator_1 = require("./scratchOrgSettingsGenerator");
@@ -24,7 +24,6 @@ const scratchOrgCache_1 = require("./scratchOrgCache");
 const scratchOrgErrorCodes_1 = require("./scratchOrgErrorCodes");
 messages_1.Messages.importMessagesDirectory(__dirname);
 const messages = messages_1.Messages.load('@salesforce/core', 'scratchOrgCreate', [
-    'SourceStatusResetFailureError',
     'DurationDaysValidationMaxError',
     'DurationDaysValidationMinError',
     'RetryNotIntError',
@@ -74,12 +73,10 @@ const scratchOrgResume = async (jobId) => {
     // At this point, the scratch org is "good".
     // Some hubs have all the usernames set to `null`
     const username = (_a = soi.Username) !== null && _a !== void 0 ? _a : soi.SignupUsername;
-    // re-auth only if the org isn't in GlobalInfo
-    const globalInfo = await globalInfo_1.GlobalInfo.getInstance();
-    const scratchOrgAuthInfo = globalInfo.orgs.has(username)
-        ? await authInfo_1.AuthInfo.create({
-            username,
-        })
+    // re-auth only if the org isn't in StateAggregator
+    const stateAggregator = await stateAggregator_1.StateAggregator.getInstance();
+    const scratchOrgAuthInfo = (await stateAggregator.orgs.exists(username))
+        ? await authInfo_1.AuthInfo.create({ username })
         : await (0, scratchOrgInfoApi_1.authorizeScratchOrg)({
             scratchOrgInfoComplete: soi,
             hubOrg,

package/lib/{globalInfo → stateAggregator}/accessors/aliasAccessor.d.ts

@@ -1,8 +1,13 @@
+import { AsyncOptionalCreatable } from '@salesforce/kit';
 import { Nullable } from '@salesforce/ts-types';
+import { ConfigContents } from '../../exported';
 import { GlobalInfo } from '../globalInfoConfig';
 import { SfAliases, SfOrg, SfToken } from '../types';
 export declare type Aliasable = string | Partial<SfOrg> | Partial<SfToken>;
-export declare class AliasAccessor {
+/**
+ * @deprecated
+ */
+export declare class GlobalInfoAliasAccessor {
     private globalInfo;
     constructor(globalInfo: GlobalInfo);
     /**
@@ -81,3 +86,76 @@ export declare class AliasAccessor {
      */
     private getNameOf;
 }
+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;
+    /**
+     * 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(alias: string): void;
+    /**
+     * This method 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>;
+    protected init(): Promise<void>;
+    /**
+     * Returns the username of given aliasable entity
+     */
+    private getNameOf;
+}

package/lib/{globalInfo → stateAggregator}/accessors/aliasAccessor.js

@@ -6,10 +6,15 @@
  * 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;
+exports.AliasAccessor = exports.GlobalInfoAliasAccessor = void 0;
+const kit_1 = require("@salesforce/kit");
+const aliasesConfig_1 = require("../../config/aliasesConfig");
 const sfError_1 = require("../../sfError");
 const types_1 = require("../types");
-class AliasAccessor {
+/**
+ * @deprecated
+ */
+class GlobalInfoAliasAccessor {
     constructor(globalInfo) {
         this.globalInfo = globalInfo;
     }
@@ -126,5 +131,117 @@ class AliasAccessor {
         return aliaseeName;
     }
 }
+exports.GlobalInfoAliasAccessor = GlobalInfoAliasAccessor;
+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) {
+        var _a;
+        return (_a = this.getAll(entity).find((alias) => alias)) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Returns the value that corresponds to the given alias if it exists
+     *
+     * @param alias the alias that corresponds to a value
+     */
+    getValue(alias) {
+        var _a;
+        return (_a = this.getAll()[alias]) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Returns the username that corresponds to the given alias if it exists
+     *
+     * @param alias the alias that corresponds to a username
+     */
+    getUsername(alias) {
+        var _a;
+        return (_a = this.getAll()[alias]) !== null && _a !== void 0 ? _a : 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) {
+        var _a;
+        return (_a = this.getValue(valueOrAlias)) !== null && _a !== void 0 ? _a : 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) {
+        var _a;
+        return (_a = this.getUsername(usernameOrAlias)) !== null && _a !== void 0 ? _a : usernameOrAlias;
+    }
+    /**
+     * 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(alias) {
+        this.config.unset(alias);
+    }
+    /**
+     * This method 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();
+    }
+    async init() {
+        this.config = await aliasesConfig_1.AliasesConfig.create(aliasesConfig_1.AliasesConfig.getDefaultOptions());
+    }
+    /**
+     * Returns the username of given aliasable entity
+     */
+    getNameOf(entity) {
+        var _a;
+        if (typeof entity === 'string')
+            return entity;
+        const aliaseeName = (_a = entity.username) !== null && _a !== void 0 ? _a : 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,50 @@
+import { JsonMap, Nullable, Optional } from '@salesforce/ts-types';
+import { AsyncOptionalCreatable } from '@salesforce/kit';
+import { AuthInfoConfig } from '../../config/authInfoConfig';
+import { GlobalInfo } from '../globalInfoConfig';
+import { SfOrgs, SfOrg } from '../types';
+import { AuthFields } from '../../org';
+import { ConfigFile } from '../../config/configFile';
+import { ConfigContents } from '../../config/configStore';
+/**
+ * @deprecated
+ */
+export declare class GlobalInfoOrgAccessor {
+    private globalInfo;
+    constructor(globalInfo: GlobalInfo);
+    getAll(decrypt?: boolean): SfOrgs;
+    get(username: string, decrypt?: boolean): Optional<SfOrg>;
+    has(username: string): boolean;
+    set(username: string, org: SfOrg): void;
+    update(username: string, org: Partial<SfOrg>): void;
+    unset(username: string): void;
+}
+export declare abstract class BaseOrgAccessor<T extends ConfigFile, P extends ConfigContents> extends AsyncOptionalCreatable {
+    private configs;
+    private contents;
+    private logger;
+    read(username: string, decrypt?: boolean, throwOnNotFound?: boolean): Promise<Nullable<P>>;
+    readAll(decrypt?: boolean): Promise<P[]>;
+    get(username: string, decrypt?: boolean): Nullable<P>;
+    getAll(decrypt?: boolean): P[];
+    has(username: string): boolean;
+    exists(username: string): Promise<boolean>;
+    hasFile(username: string): Promise<boolean>;
+    list(): Promise<string[]>;
+    set(username: string, org: P): void;
+    update(username: string, org: Partial<P> & JsonMap): void;
+    remove(username: string): Promise<void>;
+    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,197 @@
+"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 = exports.GlobalInfoOrgAccessor = 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 types_1 = require("../types");
+const logger_1 = require("../../logger");
+/**
+ * @deprecated
+ */
+class GlobalInfoOrgAccessor {
+    constructor(globalInfo) {
+        this.globalInfo = globalInfo;
+    }
+    getAll(decrypt = false) {
+        return this.globalInfo.get(types_1.SfInfoKeys.ORGS, decrypt);
+    }
+    get(username, decrypt = false) {
+        const auth = this.globalInfo.get(`${types_1.SfInfoKeys.ORGS}["${username}"]`, decrypt);
+        // For legacy, some things wants the username in the returned auth info.
+        if (auth && !auth.username)
+            auth.username = username;
+        return auth;
+    }
+    has(username) {
+        return !!this.getAll()[username];
+    }
+    set(username, org) {
+        var _a;
+        // For legacy, and to keep things standard, some things wants the username in auth info.
+        (_a = org.username) !== null && _a !== void 0 ? _a : (org.username = username);
+        this.globalInfo.set(`${types_1.SfInfoKeys.ORGS}["${username}"]`, org);
+    }
+    update(username, org) {
+        var _a;
+        // For legacy, and to keep things standard, some things wants the username in auth info.
+        (_a = org.username) !== null && _a !== void 0 ? _a : (org.username = username);
+        this.globalInfo.update(`${types_1.SfInfoKeys.ORGS}["${username}"]`, org);
+    }
+    unset(username) {
+        delete this.globalInfo.get(types_1.SfInfoKeys.ORGS)[username];
+    }
+}
+exports.GlobalInfoOrgAccessor = GlobalInfoOrgAccessor;
+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();
+    }
+    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;
+        }
+    }
+    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);
+            });
+            await Promise.all(promises);
+        }
+        return this.getAll(decrypt);
+    }
+    get(username, decrypt = false) {
+        const config = this.configs.get(username);
+        if (config) {
+            this.contents.set(username, config.getContents(decrypt));
+        }
+        return this.contents.get(username);
+    }
+    getAll(decrypt = false) {
+        return [...this.configs.keys()].reduce((orgs, username) => {
+            const org = this.get(username, decrypt);
+            return org && !(0, kit_1.isEmpty)(org) ? orgs.concat([org]) : orgs;
+        }, []);
+    }
+    has(username) {
+        return this.contents.has(username);
+    }
+    async exists(username) {
+        const config = this.configs.get(username);
+        return config ? await config.exists() : false;
+    }
+    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;
+        }
+    }
+    async list() {
+        return this.getAllFiles();
+    }
+    set(username, org) {
+        var _a, _b;
+        const config = this.configs.get(username);
+        if (config) {
+            config.setContentsFromObject(org);
+            const contents = config.getContents();
+            (_a = contents.username) !== null && _a !== void 0 ? _a : (contents.username = username);
+            this.contents.set(username, contents);
+        }
+        else {
+            // @ts-ignore
+            (_b = org.username) !== null && _b !== void 0 ? _b : (org.username = username);
+            this.contents.set(username, org);
+        }
+    }
+    update(username, org) {
+        const existing = this.get(username) || {};
+        const merged = Object.assign({}, existing, org);
+        return this.set(username, merged);
+    }
+    async remove(username) {
+        var _a;
+        await ((_a = this.configs.get(username)) === null || _a === void 0 ? void 0 : _a.unlink());
+        this.configs.delete(username);
+        this.contents.delete(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 config = this.configs.get(username);
+            config.setContentsFromObject(contents);
+            return (await config.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 {
+    async initAuthFile(username, throwOnNotFound = false) {
+        return authInfoConfig_1.AuthInfoConfig.create({
+            ...authInfoConfig_1.AuthInfoConfig.getOptions(username),
+            throwOnNotFound,
+        });
+    }
+    getFileRegex() {
+        // The regular expression that filters files stored in $HOME/.sfdx
+        return /^[^.][^@]*@[^.]+(\.[^.\s]+)+\.json$/;
+    }
+    getFileExtension() {
+        return '.json';
+    }
+}
+exports.OrgAccessor = OrgAccessor;
+//# sourceMappingURL=orgAccessor.js.map

package/lib/{globalInfo → stateAggregator}/accessors/sandboxAccessor.d.ts

@@ -1,7 +1,13 @@
 import { Nullable } from '@salesforce/ts-types';
+import { SandboxOrgConfig } from '../../config/sandboxOrgConfig';
+import { SandboxFields } from '../../org';
 import { GlobalInfo } from '../globalInfoConfig';
 import { SfSandbox, SfSandboxes } from '../types';
-export declare class SandboxAccessor {
+import { BaseOrgAccessor } from './orgAccessor';
+/**
+ * @deprecated
+ */
+export declare class GlobalInfoSandboxAccessor {
     private globalInfo;
     constructor(globalInfo: GlobalInfo);
     /**
@@ -34,3 +40,8 @@ export declare class SandboxAccessor {
     set(sandboxOrgId: string, entity: SfSandbox): void;
     unset(sandboxOrgId: string): void;
 }
+export declare class SandboxAccessor extends BaseOrgAccessor<SandboxOrgConfig, SandboxFields> {
+    protected initAuthFile(username: string, throwOnNotFound?: boolean): Promise<SandboxOrgConfig>;
+    protected getFileRegex(): RegExp;
+    protected getFileExtension(): string;
+}

package/lib/{globalInfo → stateAggregator}/accessors/sandboxAccessor.js

@@ -6,9 +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.SandboxAccessor = void 0;
+exports.SandboxAccessor = exports.GlobalInfoSandboxAccessor = void 0;
+const sandboxOrgConfig_1 = require("../../config/sandboxOrgConfig");
 const types_1 = require("../types");
-class SandboxAccessor {
+const orgAccessor_1 = require("./orgAccessor");
+/**
+ * @deprecated
+ */
+class GlobalInfoSandboxAccessor {
     constructor(globalInfo) {
         this.globalInfo = globalInfo;
     }
@@ -59,5 +64,20 @@ class SandboxAccessor {
         delete this.globalInfo.get(types_1.SfInfoKeys.SANDBOXES)[sandboxOrgId];
     }
 }
+exports.GlobalInfoSandboxAccessor = GlobalInfoSandboxAccessor;
+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,28 @@
+import { AsyncOptionalCreatable } from '@salesforce/kit';
+import { Optional } from '@salesforce/ts-types';
+import { GlobalInfo } from '../globalInfoConfig';
+import { SfTokens, SfToken, Timestamp } from '../types';
+/**
+ * @deprecated
+ */
+export declare class GlobaInfoTokenAccessor {
+    private globalInfo;
+    constructor(globalInfo: GlobalInfo);
+    getAll(decrypt?: boolean): SfTokens;
+    get(name: string, decrypt?: boolean): Optional<SfToken & Timestamp>;
+    has(name: string): boolean;
+    set(name: string, token: SfToken): void;
+    update(name: string, token: Partial<SfToken>): void;
+    unset(name: string): void;
+}
+export declare class TokenAccessor extends AsyncOptionalCreatable {
+    private config;
+    getAll(decrypt?: boolean): SfTokens;
+    get(name: string, decrypt?: boolean): Optional<SfToken & Timestamp>;
+    has(name: string): boolean;
+    set(name: string, token: SfToken): void;
+    update(name: string, token: Partial<SfToken>): void;
+    unset(name: string): void;
+    write(): Promise<SfTokens>;
+    protected init(): Promise<void>;
+}

package/lib/{globalInfo → stateAggregator}/accessors/tokenAccessor.js

@@ -6,9 +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.TokenAccessor = void 0;
+exports.TokenAccessor = exports.GlobaInfoTokenAccessor = void 0;
+const kit_1 = require("@salesforce/kit");
+const tokensConfig_1 = require("../../config/tokensConfig");
 const types_1 = require("../types");
-class TokenAccessor {
+/**
+ * @deprecated
+ */
+class GlobaInfoTokenAccessor {
     constructor(globalInfo) {
         this.globalInfo = globalInfo;
     }
@@ -31,5 +36,32 @@ class TokenAccessor {
         delete this.globalInfo.get(types_1.SfInfoKeys.TOKENS)[name];
     }
 }
+exports.GlobaInfoTokenAccessor = GlobaInfoTokenAccessor;
+class TokenAccessor extends kit_1.AsyncOptionalCreatable {
+    getAll(decrypt = false) {
+        return this.config.getContents(decrypt) || {};
+    }
+    get(name, decrypt = false) {
+        return this.config.get(name, decrypt);
+    }
+    has(name) {
+        return !!this.getAll()[name];
+    }
+    set(name, token) {
+        this.config.set(name, token);
+    }
+    update(name, token) {
+        this.config.update(name, token);
+    }
+    unset(name) {
+        this.config.unset(name);
+    }
+    async write() {
+        return this.config.write();
+    }
+    async init() {
+        this.config = await tokensConfig_1.TokensConfig.create();
+    }
+}
 exports.TokenAccessor = TokenAccessor;
 //# sourceMappingURL=tokenAccessor.js.map

package/lib/{globalInfo → stateAggregator}/globalInfoConfig.d.ts

@@ -1,12 +1,15 @@
 import { AnyJson } from '@salesforce/ts-types';
 import { ConfigFile } from '../config/configFile';
 import { ConfigValue } from '../config/configStore';
-import { OrgAccessor } from './accessors/orgAccessor';
-import { TokenAccessor } from './accessors/tokenAccessor';
-import { AliasAccessor } from './accessors/aliasAccessor';
+import { GlobalInfoOrgAccessor } from './accessors/orgAccessor';
+import { GlobaInfoTokenAccessor } from './accessors/tokenAccessor';
+import { GlobalInfoAliasAccessor } from './accessors/aliasAccessor';
 import { SfInfo } from './types';
-import { SandboxAccessor } from './accessors/sandboxAccessor';
+import { GlobalInfoSandboxAccessor } from './accessors/sandboxAccessor';
 export declare function deepCopy<T extends AnyJson>(data: T): T;
+/**
+ * @deprecated use StateAggregator instead.
+ */
 export declare class GlobalInfo extends ConfigFile<ConfigFile.Options, SfInfo> {
     protected static encryptedKeys: RegExp[];
     private static EMPTY_DATA_MODEL;
@@ -25,10 +28,10 @@ export declare class GlobalInfo extends ConfigFile<ConfigFile.Options, SfInfo> {
      * Gets default options for the SfConfig
      */
     static getDefaultOptions(): ConfigFile.Options;
-    get orgs(): OrgAccessor;
-    get tokens(): TokenAccessor;
-    get aliases(): AliasAccessor;
-    get sandboxes(): SandboxAccessor;
+    get orgs(): GlobalInfoOrgAccessor;
+    get tokens(): GlobaInfoTokenAccessor;
+    get aliases(): GlobalInfoAliasAccessor;
+    get sandboxes(): GlobalInfoSandboxAccessor;
     set(key: string, value: ConfigValue): void;
     write(newContents?: SfInfo): Promise<SfInfo>;
     protected init(): Promise<void>;