@hubspot/local-dev-lib 0.0.2 → 0.0.4

package/config/CLIConfiguration.d.ts

@@ -0,0 +1,55 @@
+import { CLIConfig } from '../types/Config';
+import { CLIAccount, FlatAccountFields, OauthTokenInfo } from '../types/Accounts';
+import { CLIOptions } from '../types/CLIOptions';
+import { LogCallbacksArg } from '../types/LogCallbacks';
+declare const validateLogCallbackKeys: readonly ["noConfig", "noConfigAccounts", "emptyAccountConfig", "noAccountId", "duplicateAccountIds", "duplicateAccountNames", "nameContainsSpaces"];
+declare class CLIConfiguration {
+    options: CLIOptions;
+    useEnvConfig: boolean;
+    config: CLIConfig | null;
+    constructor();
+    init(options?: CLIOptions): void;
+    load(): CLIConfig | null;
+    configIsEmpty(): boolean;
+    delete(): void;
+    write(updatedConfig?: CLIConfig): CLIConfig | null;
+    validate(logCallbacks?: LogCallbacksArg<typeof validateLogCallbackKeys>): boolean;
+    getAccount(nameOrId: string | number | undefined): CLIAccount | null;
+    getAccountId(nameOrId: string | number): number | null;
+    getDefaultAccount(): string | number | null;
+    getResolvedDefaultAccountForCWD(nameOrId: string | number): CLIAccount | null;
+    getConfigAccountIndex(accountId: number): number;
+    isAccountInConfig(nameOrId: string | number): boolean;
+    getAndLoadConfigIfNeeded(options?: CLIOptions): CLIConfig;
+    getEnv(nameOrId?: string | number): string;
+    /**
+     * @throws {Error}
+     */
+    updateAccount(updatedAccountFields: FlatAccountFields<OauthTokenInfo>, writeUpdate?: boolean): CLIAccount | null;
+    /**
+     * @throws {Error}
+     */
+    updateDefaultAccount(defaultAccount: string | number): CLIConfig | null;
+    /**
+     * @throws {Error}
+     */
+    renameAccount(currentName: string, newName: string): void;
+    /**
+     * @throws {Error}
+     */
+    removeAccountFromConfig(nameOrId: string | number): boolean;
+    /**
+     * @throws {Error}
+     */
+    updateDefaultMode(defaultMode: string): CLIConfig | null;
+    /**
+     * @throws {Error}
+     */
+    updateHttpTimeout(timeout: string): CLIConfig | null;
+    /**
+     * @throws {Error}
+     */
+    updateAllowUsageTracking(isEnabled: boolean): CLIConfig | null;
+}
+declare const _default: CLIConfiguration;
+export default _default;

package/config/CLIConfiguration.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../utils/logger");
+const standardErrors_1 = require("../errors/standardErrors");
+const environment_1 = require("./environment");
+const configFile_1 = require("./configFile");
+const text_1 = require("../lib/text");
+const constants_1 = require("../constants");
+const auth_1 = require("../constants/auth");
+const config_1 = require("../constants/config");
+const i18nKey = 'config.cliConfiguration';
+const validateLogCallbackKeys = [
+    'noConfig',
+    'noConfigAccounts',
+    'emptyAccountConfig',
+    'noAccountId',
+    'duplicateAccountIds',
+    'duplicateAccountNames',
+    'nameContainsSpaces',
+];
+class CLIConfiguration {
+    options;
+    useEnvConfig;
+    config;
+    constructor() {
+        this.options = {};
+        this.useEnvConfig = false;
+        this.config = null;
+    }
+    init(options = {}) {
+        this.options = options;
+        this.load();
+    }
+    load() {
+        if (this.options.useEnv) {
+            const configFromEnv = (0, environment_1.loadConfigFromEnvironment)();
+            if (configFromEnv) {
+                (0, logger_1.debug)(`${i18nKey}.load.configFromEnv`, {
+                    accountId: configFromEnv.accounts[0].accountId,
+                });
+                this.useEnvConfig = true;
+                this.config = configFromEnv;
+            }
+        }
+        else {
+            const configFromFile = (0, configFile_1.loadConfigFromFile)();
+            (0, logger_1.debug)(`${i18nKey}.load.configFromFile`);
+            if (!configFromFile) {
+                (0, logger_1.debug)(`${i18nKey}.load.empty`);
+                this.config = { accounts: [] };
+            }
+            this.useEnvConfig = false;
+            this.config = configFromFile;
+        }
+        return this.config;
+    }
+    configIsEmpty() {
+        if (!(0, configFile_1.configFileExists)() || (0, configFile_1.configFileIsBlank)()) {
+            return true;
+        }
+        else {
+            this.load();
+            if (!!this.config &&
+                Object.keys(this.config).length === 1 &&
+                !!this.config.accounts) {
+                return true;
+            }
+        }
+        return false;
+    }
+    delete() {
+        if (!this.useEnvConfig && this.configIsEmpty()) {
+            (0, configFile_1.deleteConfigFile)();
+            this.config = null;
+        }
+    }
+    write(updatedConfig) {
+        if (!this.useEnvConfig) {
+            if (updatedConfig) {
+                this.config = updatedConfig;
+            }
+            if (this.config) {
+                (0, configFile_1.writeConfigToFile)(this.config);
+            }
+        }
+        return this.config;
+    }
+    validate(logCallbacks) {
+        const validateLogger = (0, logger_1.makeTypedLogger)(logCallbacks, 'config.cliConfiguration.validate');
+        if (!this.config) {
+            validateLogger('noConfig');
+            return false;
+        }
+        if (!Array.isArray(this.config.accounts)) {
+            validateLogger('noConfigAccounts');
+            return false;
+        }
+        const accountIdsMap = {};
+        const accountNamesMap = {};
+        return this.config.accounts.every(accountConfig => {
+            if (!accountConfig) {
+                validateLogger('emptyAccountConfig');
+                return false;
+            }
+            if (!accountConfig.accountId) {
+                validateLogger('noAccountId');
+                return false;
+            }
+            if (accountIdsMap[accountConfig.accountId]) {
+                validateLogger('duplicateAccountIds', {
+                    accountId: accountConfig.accountId,
+                });
+                return false;
+            }
+            if (accountConfig.name) {
+                if (accountNamesMap[accountConfig.name]) {
+                    validateLogger('duplicateAccountNames', {
+                        accountName: accountConfig.name,
+                    });
+                    return false;
+                }
+                if (/\s+/.test(accountConfig.name)) {
+                    validateLogger('nameContainsSpaces', {
+                        accountName: accountConfig.name,
+                    });
+                    return false;
+                }
+                accountNamesMap[accountConfig.name] = true;
+            }
+            accountIdsMap[accountConfig.accountId] = true;
+            return true;
+        });
+    }
+    getAccount(nameOrId) {
+        let name = null;
+        let accountId = null;
+        if (!this.config) {
+            return null;
+        }
+        const nameOrIdToCheck = nameOrId ? nameOrId : this.getDefaultAccount();
+        if (!nameOrIdToCheck) {
+            return null;
+        }
+        if (typeof nameOrIdToCheck === 'number') {
+            accountId = nameOrIdToCheck;
+        }
+        else if (/^\d+$/.test(nameOrIdToCheck)) {
+            accountId = parseInt(nameOrIdToCheck, 10);
+        }
+        else {
+            name = nameOrIdToCheck;
+        }
+        if (name) {
+            return this.config.accounts.find(a => a.name === name) || null;
+        }
+        else if (accountId) {
+            return this.config.accounts.find(a => accountId === a.accountId) || null;
+        }
+        return null;
+    }
+    getAccountId(nameOrId) {
+        const account = this.getAccount(nameOrId);
+        return account ? account.accountId : null;
+    }
+    getDefaultAccount() {
+        return this.config && this.config.defaultAccount
+            ? this.config.defaultAccount
+            : null;
+    }
+    // TODO a util that returns the account to use, respecting the values set in
+    // "defaultAccountOverrides"
+    // Example "defaultAccountOverrides":
+    //  - /src/brodgers/customer-project-1: customer-account1
+    //  - /src/brodgers/customer-project-2: customer-account2
+    // "/src/brodgers/customer-project-1" is the path to the project dir
+    // "customer-account1" is the name of the account to use as the default for the specified dir
+    // These defaults take precedence over the standard default account specified in the config
+    getResolvedDefaultAccountForCWD(nameOrId) {
+        return this.getAccount(nameOrId);
+    }
+    getConfigAccountIndex(accountId) {
+        return this.config
+            ? this.config.accounts.findIndex(account => account.accountId === accountId)
+            : -1;
+    }
+    isAccountInConfig(nameOrId) {
+        return (!!this.config && this.config.accounts && !!this.getAccountId(nameOrId));
+    }
+    getAndLoadConfigIfNeeded(options) {
+        if (!this.config) {
+            this.init(options);
+        }
+        return this.config;
+    }
+    getEnv(nameOrId) {
+        const accountConfig = this.getAccount(nameOrId);
+        if (accountConfig && accountConfig.accountId && accountConfig.env) {
+            return accountConfig.env;
+        }
+        if (this.config && this.config.env) {
+            return this.config.env;
+        }
+        return constants_1.ENVIRONMENTS.PROD;
+    }
+    /*
+     * Config Update Utils
+     */
+    /**
+     * @throws {Error}
+     */
+    updateAccount(updatedAccountFields, writeUpdate = true) {
+        const { accountId, apiKey, authType, clientId, clientSecret, defaultMode, env, name, parentAccountId, personalAccessKey, sandboxAccountType, scopes, tokenInfo, } = updatedAccountFields;
+        if (!accountId) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateAccount`);
+        }
+        if (!this.config) {
+            (0, logger_1.debug)(`${i18nKey}.updateAccount.noConfigToUpdate`);
+            return null;
+        }
+        const currentAccountConfig = this.getAccount(accountId);
+        let auth;
+        if (clientId || clientSecret || scopes || tokenInfo) {
+            auth = {
+                ...(currentAccountConfig ? currentAccountConfig.auth : {}),
+                clientId,
+                clientSecret,
+                scopes,
+                tokenInfo,
+            };
+        }
+        const nextAccountConfig = {
+            ...(currentAccountConfig ? currentAccountConfig : {}),
+        };
+        // Allow everything except for 'undefined' values to override the existing values
+        function safelyApplyUpdates(fieldName, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        newValue) {
+            if (typeof newValue !== 'undefined') {
+                nextAccountConfig[fieldName] = newValue;
+            }
+        }
+        const updatedEnv = (0, environment_1.getValidEnv)(env || (currentAccountConfig && currentAccountConfig.env), false);
+        const updatedDefaultMode = defaultMode &&
+            defaultMode.toLowerCase();
+        safelyApplyUpdates('name', name);
+        safelyApplyUpdates('env', updatedEnv);
+        safelyApplyUpdates('accountId', accountId);
+        safelyApplyUpdates('authType', authType);
+        safelyApplyUpdates('auth', auth);
+        if (nextAccountConfig.authType === auth_1.API_KEY_AUTH_METHOD.value) {
+            safelyApplyUpdates('apiKey', apiKey);
+        }
+        if (typeof updatedDefaultMode !== 'undefined') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            safelyApplyUpdates('defaultMode', config_1.DEFAULT_MODES[updatedDefaultMode]);
+        }
+        safelyApplyUpdates('personalAccessKey', personalAccessKey);
+        safelyApplyUpdates('sandboxAccountType', sandboxAccountType);
+        safelyApplyUpdates('parentAccountId', parentAccountId);
+        const completedAccountConfig = nextAccountConfig;
+        if (currentAccountConfig) {
+            (0, logger_1.debug)(`${i18nKey}.updateAccount.updating`, {
+                accountId,
+            });
+            const index = this.getConfigAccountIndex(accountId);
+            this.config.accounts[index] = completedAccountConfig;
+            (0, logger_1.debug)(`${i18nKey}.updateAccount.addingConfigEntry`, {
+                accountId,
+            });
+            if (this.config.accounts) {
+                this.config.accounts.push(completedAccountConfig);
+            }
+            else {
+                this.config.accounts = [completedAccountConfig];
+            }
+        }
+        if (writeUpdate) {
+            this.write();
+        }
+        return completedAccountConfig;
+    }
+    /**
+     * @throws {Error}
+     */
+    updateDefaultAccount(defaultAccount) {
+        if (!this.config) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
+        }
+        if (!defaultAccount ||
+            (typeof defaultAccount !== 'number' && typeof defaultAccount !== 'string')) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateDefaultAccount`);
+        }
+        this.config.defaultAccount = defaultAccount;
+        return this.write();
+    }
+    /**
+     * @throws {Error}
+     */
+    renameAccount(currentName, newName) {
+        if (!this.config) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
+        }
+        const accountId = this.getAccountId(currentName);
+        let accountConfigToRename = null;
+        if (accountId) {
+            accountConfigToRename = this.getAccount(accountId);
+        }
+        if (!accountConfigToRename) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.renameAccount`, { currentName });
+        }
+        if (accountId) {
+            this.updateAccount({ accountId, name: newName });
+        }
+        if (accountConfigToRename.name === this.getDefaultAccount()) {
+            this.updateDefaultAccount(newName);
+        }
+    }
+    /**
+     * @throws {Error}
+     */
+    removeAccountFromConfig(nameOrId) {
+        if (!this.config) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
+        }
+        const accountId = this.getAccountId(nameOrId);
+        if (!accountId) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.removeAccountFromConfig`, { nameOrId });
+        }
+        let removedAccountIsDefault = false;
+        const accountConfig = this.getAccount(accountId);
+        if (accountConfig) {
+            (0, logger_1.debug)(`${i18nKey}.removeAccountFromConfig`, { accountId });
+            const index = this.getConfigAccountIndex(accountId);
+            this.config.accounts.splice(index, 1);
+            if (this.getDefaultAccount() === accountConfig.name) {
+                removedAccountIsDefault = true;
+            }
+            this.write();
+        }
+        return removedAccountIsDefault;
+    }
+    /**
+     * @throws {Error}
+     */
+    updateDefaultMode(defaultMode) {
+        if (!this.config) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
+        }
+        const ALL_MODES = Object.values(config_1.DEFAULT_MODES);
+        if (!defaultMode || !ALL_MODES.find(m => m === defaultMode)) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateDefaultMode`, {
+                defaultMode,
+                validModes: (0, text_1.commaSeparatedValues)(ALL_MODES),
+            });
+        }
+        this.config.defaultMode = defaultMode;
+        return this.write();
+    }
+    /**
+     * @throws {Error}
+     */
+    updateHttpTimeout(timeout) {
+        if (!this.config) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
+        }
+        const parsedTimeout = parseInt(timeout);
+        if (isNaN(parsedTimeout) || parsedTimeout < config_1.MIN_HTTP_TIMEOUT) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateHttpTimeout`, {
+                timeout,
+                minTimeout: config_1.MIN_HTTP_TIMEOUT,
+            });
+        }
+        this.config.httpTimeout = parsedTimeout;
+        return this.write();
+    }
+    /**
+     * @throws {Error}
+     */
+    updateAllowUsageTracking(isEnabled) {
+        if (!this.config) {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
+        }
+        if (typeof isEnabled !== 'boolean') {
+            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateAllowUsageTracking`, {
+                isEnabled: `${isEnabled}`,
+            });
+        }
+        this.config.allowUsageTracking = isEnabled;
+        return this.write();
+    }
+}
+exports.default = new CLIConfiguration();

package/config/configFile.d.ts

@@ -0,0 +1,21 @@
+import { CLIConfig } from '../types/Config';
+export declare function getConfigFilePath(): string;
+export declare function configFileExists(): boolean;
+export declare function configFileIsBlank(): boolean;
+export declare function deleteConfigFile(): void;
+/**
+ * @throws {Error}
+ */
+export declare function readConfigFile(configPath: string): string;
+/**
+ * @throws {Error}
+ */
+export declare function parseConfig(configSource: string): CLIConfig;
+/**
+ * @throws {Error}
+ */
+export declare function loadConfigFromFile(): CLIConfig | null;
+/**
+ * @throws {Error}
+ */
+export declare function writeConfigToFile(config: CLIConfig): void;

package/config/configFile.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeConfigToFile = exports.loadConfigFromFile = exports.parseConfig = exports.readConfigFile = exports.deleteConfigFile = exports.configFileIsBlank = exports.configFileExists = exports.getConfigFilePath = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const logger_1 = require("../utils/logger");
+const fileSystemErrors_1 = require("../errors/fileSystemErrors");
+const standardErrors_1 = require("../errors/standardErrors");
+const constants_1 = require("../constants");
+const configUtils_1 = require("./configUtils");
+const i18nKey = 'config.configFile';
+function getConfigFilePath() {
+    return path_1.default.join(os_1.default.homedir(), constants_1.HUBSPOT_CONFIGURATION_FOLDER, constants_1.HUBSPOT_CONFIGURATION_FILE);
+}
+exports.getConfigFilePath = getConfigFilePath;
+function configFileExists() {
+    const configPath = getConfigFilePath();
+    return !!configPath && fs_extra_1.default.existsSync(configPath);
+}
+exports.configFileExists = configFileExists;
+function configFileIsBlank() {
+    const configPath = getConfigFilePath();
+    return !!configPath && fs_extra_1.default.readFileSync(configPath).length === 0;
+}
+exports.configFileIsBlank = configFileIsBlank;
+function deleteConfigFile() {
+    const configPath = getConfigFilePath();
+    fs_extra_1.default.unlinkSync(configPath);
+}
+exports.deleteConfigFile = deleteConfigFile;
+/**
+ * @throws {Error}
+ */
+function readConfigFile(configPath) {
+    let source = '';
+    try {
+        source = fs_extra_1.default.readFileSync(configPath).toString();
+    }
+    catch (err) {
+        (0, logger_1.debug)(`${i18nKey}.errorReading`, { configPath });
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath: configPath,
+            read: true,
+        });
+    }
+    return source;
+}
+exports.readConfigFile = readConfigFile;
+/**
+ * @throws {Error}
+ */
+function parseConfig(configSource) {
+    let parsed;
+    try {
+        parsed = js_yaml_1.default.load(configSource);
+    }
+    catch (err) {
+        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.parsing`, {}, err);
+    }
+    return parsed;
+}
+exports.parseConfig = parseConfig;
+/**
+ * @throws {Error}
+ */
+function loadConfigFromFile() {
+    const configPath = getConfigFilePath();
+    if (configPath) {
+        const source = readConfigFile(configPath);
+        if (!source) {
+            return null;
+        }
+        return parseConfig(source);
+    }
+    // TODO: Maybe use log callbacks here
+    (0, logger_1.debug)(`${i18nKey}.errorLoading`, { configPath });
+    return null;
+}
+exports.loadConfigFromFile = loadConfigFromFile;
+/**
+ * @throws {Error}
+ */
+function writeConfigToFile(config) {
+    let source;
+    try {
+        source = js_yaml_1.default.dump(JSON.parse(JSON.stringify((0, configUtils_1.getOrderedConfig)(config), null, 2)));
+    }
+    catch (err) {
+        (0, standardErrors_1.throwError)(err);
+    }
+    const configPath = getConfigFilePath();
+    try {
+        fs_extra_1.default.ensureFileSync(configPath);
+        fs_extra_1.default.writeFileSync(configPath, source);
+        (0, logger_1.debug)(`${i18nKey}.writeSuccess`, { configPath });
+    }
+    catch (err) {
+        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+            filepath: configPath,
+            write: true,
+        });
+    }
+}
+exports.writeConfigToFile = writeConfigToFile;

package/config/configUtils.d.ts

@@ -0,0 +1,24 @@
+import { CLIConfig } from '../types/Config';
+import { AuthType, CLIAccount } from '../types/Accounts';
+export declare function getOrderedAccount(unorderedAccount: CLIAccount): CLIAccount;
+export declare function getOrderedConfig(unorderedConfig: CLIConfig): CLIConfig;
+type PersonalAccessKeyOptions = {
+    accountId: number;
+    personalAccessKey: string;
+    env: string;
+};
+type OAuthOptions = {
+    accountId: number;
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
+    scopes: Array<string>;
+    env: string;
+};
+type APIKeyOptions = {
+    accountId: number;
+    apiKey: string;
+    env: string;
+};
+export declare function generateConfig(type: AuthType, options: PersonalAccessKeyOptions | OAuthOptions | APIKeyOptions): CLIConfig | null;
+export {};

package/config/configUtils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConfig = exports.getOrderedConfig = exports.getOrderedAccount = void 0;
+const logger_1 = require("../utils/logger");
+const auth_1 = require("../constants/auth");
+function getOrderedAccount(unorderedAccount) {
+    const { name, accountId, env, authType, ...rest } = unorderedAccount;
+    return {
+        name,
+        accountId,
+        env,
+        authType,
+        ...rest,
+    };
+}
+exports.getOrderedAccount = getOrderedAccount;
+function getOrderedConfig(unorderedConfig) {
+    const { defaultAccount, defaultMode, httpTimeout, allowUsageTracking, accounts, ...rest } = unorderedConfig;
+    return {
+        ...(defaultAccount && { defaultAccount }),
+        defaultMode,
+        httpTimeout,
+        allowUsageTracking,
+        ...rest,
+        accounts: accounts.map(getOrderedAccount),
+    };
+}
+exports.getOrderedConfig = getOrderedConfig;
+function generatePersonalAccessKeyAccountConfig({ accountId, personalAccessKey, env, }) {
+    return {
+        authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+        accountId,
+        personalAccessKey,
+        env,
+    };
+}
+function generateOauthAccountConfig({ accountId, clientId, clientSecret, refreshToken, scopes, env, }) {
+    return {
+        authType: auth_1.OAUTH_AUTH_METHOD.value,
+        accountId,
+        auth: {
+            clientId,
+            clientSecret,
+            scopes,
+            tokenInfo: {
+                refreshToken,
+            },
+        },
+        env,
+    };
+}
+function generateApiKeyAccountConfig({ accountId, apiKey, env, }) {
+    return {
+        authType: auth_1.API_KEY_AUTH_METHOD.value,
+        accountId,
+        apiKey,
+        env,
+    };
+}
+function generateConfig(type, options) {
+    if (!options) {
+        return null;
+    }
+    const config = { accounts: [] };
+    let configAccount;
+    switch (type) {
+        case auth_1.API_KEY_AUTH_METHOD.value:
+            configAccount = generateApiKeyAccountConfig(options);
+            break;
+        case auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value:
+            configAccount = generatePersonalAccessKeyAccountConfig(options);
+            break;
+        case auth_1.OAUTH_AUTH_METHOD.value:
+            configAccount = generateOauthAccountConfig(options);
+            break;
+        default:
+            (0, logger_1.debug)('config.configUtils.unknownType', { type });
+            return null;
+    }
+    if (configAccount) {
+        config.accounts.push(configAccount);
+    }
+    return config;
+}
+exports.generateConfig = generateConfig;

package/config/environment.d.ts

@@ -0,0 +1,3 @@
+import { CLIConfig } from '../types/Config';
+export declare function getValidEnv(env?: string | null, useProdDefault?: boolean): string | undefined;
+export declare function loadConfigFromEnvironment(): CLIConfig | null;