@hubspot/local-dev-lib 0.0.10 → 0.1.0-experimental.0

package/config/CLIConfiguration.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("../utils/logger");
-const standardErrors_1 = require("../errors/standardErrors");
+exports.CLIConfiguration = void 0;
+const logger_1 = require("../lib/logger");
 const environment_1 = require("./environment");
 const environment_2 = require("../lib/environment");
 const configFile_1 = require("./configFile");
@@ -10,17 +10,9 @@ const environments_1 = require("../constants/environments");
 const auth_1 = require("../constants/auth");
 const config_1 = require("../constants/config");
 const files_1 = require("../constants/files");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'config.cliConfiguration';
-const validateLogCallbackKeys = [
-    'noConfig',
-    'noConfigAccounts',
-    'emptyAccountConfig',
-    'noAccountId',
-    'duplicateAccountIds',
-    'duplicateAccountNames',
-    'nameContainsSpaces',
-];
-class CLIConfiguration {
+class _CLIConfiguration {
     options;
     useEnvConfig;
     config;
@@ -47,22 +39,22 @@ class CLIConfiguration {
         if (this.options.useEnv) {
             const configFromEnv = (0, environment_1.loadConfigFromEnvironment)();
             if (configFromEnv) {
-                (0, logger_1.debug)(`${i18nKey}.load.configFromEnv`, {
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.load.configFromEnv`, {
                     accountId: configFromEnv.accounts[0].accountId,
-                });
+                }));
                 this.useEnvConfig = true;
-                this.config = configFromEnv;
+                this.config = this.handleLegacyCmsPublishMode(configFromEnv);
             }
         }
         else {
             const configFromFile = (0, configFile_1.loadConfigFromFile)();
-            (0, logger_1.debug)(`${i18nKey}.load.configFromFile`);
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.load.configFromFile`));
             if (!configFromFile) {
-                (0, logger_1.debug)(`${i18nKey}.load.empty`);
+                logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.load.empty`));
                 this.config = { accounts: [] };
             }
             this.useEnvConfig = false;
-            this.config = configFromFile;
+            this.config = this.handleLegacyCmsPublishMode(configFromFile);
         }
         return this.config;
     }
@@ -97,48 +89,54 @@ class CLIConfiguration {
         }
         return this.config;
     }
-    validate(logCallbacks) {
-        const validateLogger = (0, logger_1.makeTypedLogger)(logCallbacks);
+    validate() {
         if (!this.config) {
-            validateLogger('noConfig');
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.noConfig`));
             return false;
         }
         if (!Array.isArray(this.config.accounts)) {
-            validateLogger('noConfigAccounts');
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.noConfigAccounts`));
             return false;
         }
         const accountIdsMap = {};
         const accountNamesMap = {};
         return this.config.accounts.every(accountConfig => {
             if (!accountConfig) {
-                validateLogger('emptyAccountConfig');
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.emptyAccountConfig`));
                 return false;
             }
             if (!accountConfig.accountId) {
-                validateLogger('noAccountId');
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.noAccountId`));
                 return false;
             }
             if (accountIdsMap[accountConfig.accountId]) {
-                validateLogger('duplicateAccountIds', `${i18nKey}.validate.duplicateAccountIds`, {
+                logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.duplicateAccountIds`, {
                     accountId: accountConfig.accountId,
-                });
+                }));
                 return false;
             }
             if (accountConfig.name) {
-                if (accountNamesMap[accountConfig.name]) {
-                    validateLogger('duplicateAccountNames', `${i18nKey}.validate.duplicateAccountNames`, {
+                if (accountNamesMap[accountConfig.name.toLowerCase()]) {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.duplicateAccountNames`, {
                         accountName: accountConfig.name,
-                    });
+                    }));
                     return false;
                 }
                 if (/\s+/.test(accountConfig.name)) {
-                    validateLogger('nameContainsSpaces', `${i18nKey}.validate.nameContainsSpaces`, {
+                    logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.validate.nameContainsSpaces`, {
                         accountName: accountConfig.name,
-                    });
+                    }));
                     return false;
                 }
                 accountNamesMap[accountConfig.name] = true;
             }
+            if (!accountConfig.accountType) {
+                this.addOrUpdateAccount({
+                    ...accountConfig,
+                    accountId: accountConfig.accountId,
+                    accountType: this.getAccountType(undefined, accountConfig.sandboxAccountType),
+                });
+            }
             accountIdsMap[accountConfig.accountId] = true;
             return true;
         });
@@ -196,19 +194,30 @@ class CLIConfiguration {
     getResolvedDefaultAccountForCWD(nameOrId) {
         return this.getAccount(nameOrId);
     }
-    getConfigAccountIndex(accountId) {
+    getAccountIndex(accountId) {
         return this.config
             ? this.config.accounts.findIndex(account => account.accountId === accountId)
             : -1;
     }
     getConfigForAccount(accountId) {
         if (this.config) {
-            this.config.accounts.find(account => account.accountId === accountId) ||
-                null;
+            return (this.config.accounts.find(account => account.accountId === accountId) ||
+                null);
+        }
+        return null;
+    }
+    getConfigAccounts() {
+        if (this.config) {
+            return this.config.accounts || null;
         }
         return null;
     }
     isAccountInConfig(nameOrId) {
+        if (typeof nameOrId === 'string') {
+            return (!!this.config &&
+                this.config.accounts &&
+                !!this.getAccountId(nameOrId.toLowerCase()));
+        }
         return (!!this.config && this.config.accounts && !!this.getAccountId(nameOrId));
     }
     getAndLoadConfigIfNeeded(options) {
@@ -227,23 +236,41 @@ class CLIConfiguration {
         }
         return environments_1.ENVIRONMENTS.PROD;
     }
+    // Deprecating sandboxAccountType in favor of accountType
+    getAccountType(accountType, sandboxAccountType) {
+        if (accountType) {
+            return accountType;
+        }
+        if (typeof sandboxAccountType === 'string') {
+            if (sandboxAccountType.toUpperCase() === 'DEVELOPER') {
+                return config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
+            }
+            if (sandboxAccountType.toUpperCase() === 'STANDARD') {
+                return config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
+            }
+        }
+        return config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD;
+    }
     /*
      * Config Update Utils
      */
     /**
      * @throws {Error}
      */
-    updateAccount(updatedAccountFields, writeUpdate = true) {
-        const { accountId, apiKey, authType, clientId, clientSecret, defaultMode, env, name, parentAccountId, personalAccessKey, sandboxAccountType, scopes, tokenInfo, } = updatedAccountFields;
+    addOrUpdateAccount(updatedAccountFields, writeUpdate = true) {
+        const { accountId, accountType, apiKey, authType, clientId, clientSecret, defaultCmsPublishMode, env, name, parentAccountId, personalAccessKey, sandboxAccountType, scopes, tokenInfo, } = updatedAccountFields;
         if (!accountId) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateAccount.errors.accountIdRequired`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateAccount.errors.accountIdRequired`));
         }
         if (!this.config) {
-            (0, logger_1.debug)(`${i18nKey}.updateAccount.noConfigToUpdate`);
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateAccount.noConfigToUpdate`));
             return null;
         }
+        // Check whether the account is already listed in the config.yml file.
         const currentAccountConfig = this.getAccount(accountId);
-        let auth = {};
+        // For accounts that are already in the config.yml file, sets the auth property.
+        let auth = (currentAccountConfig && currentAccountConfig.auth) || {};
+        // For accounts not already in the config.yml file, sets the auth property.
         if (clientId || clientSecret || scopes || tokenInfo) {
             auth = {
                 ...(currentAccountConfig ? currentAccountConfig.auth : {}),
@@ -265,7 +292,9 @@ class CLIConfiguration {
             }
         }
         const updatedEnv = (0, environment_2.getValidEnv)(env || (currentAccountConfig && currentAccountConfig.env));
-        const updatedDefaultMode = defaultMode && defaultMode.toLowerCase();
+        const updatedDefaultCmsPublishMode = defaultCmsPublishMode &&
+            defaultCmsPublishMode.toLowerCase();
+        const updatedAccountType = accountType || (currentAccountConfig && currentAccountConfig.accountType);
         safelyApplyUpdates('name', name);
         safelyApplyUpdates('env', updatedEnv);
         safelyApplyUpdates('accountId', accountId);
@@ -274,29 +303,36 @@ class CLIConfiguration {
         if (nextAccountConfig.authType === auth_1.API_KEY_AUTH_METHOD.value) {
             safelyApplyUpdates('apiKey', apiKey);
         }
-        if (typeof updatedDefaultMode !== 'undefined') {
+        if (typeof updatedDefaultCmsPublishMode !== 'undefined') {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            safelyApplyUpdates('defaultMode', files_1.MODE[updatedDefaultMode]);
+            safelyApplyUpdates('defaultCmsPublishMode', files_1.CMS_PUBLISH_MODE[updatedDefaultCmsPublishMode]);
         }
         safelyApplyUpdates('personalAccessKey', personalAccessKey);
+        // Deprecating sandboxAccountType in favor of the more generic accountType
         safelyApplyUpdates('sandboxAccountType', sandboxAccountType);
+        safelyApplyUpdates('accountType', this.getAccountType(updatedAccountType, sandboxAccountType));
         safelyApplyUpdates('parentAccountId', parentAccountId);
         const completedAccountConfig = nextAccountConfig;
+        if (!Object.hasOwn(this.config, 'accounts')) {
+            this.config.accounts = [];
+        }
         if (currentAccountConfig) {
-            (0, logger_1.debug)(`${i18nKey}.updateAccount.updating`, {
+            logger_1.logger.debug((0, lang_1.i18n)(`${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) {
+            }));
+            const index = this.getAccountIndex(accountId);
+            if (index < 0) {
                 this.config.accounts.push(completedAccountConfig);
             }
             else {
-                this.config.accounts = [completedAccountConfig];
+                this.config.accounts[index] = completedAccountConfig;
             }
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.updateAccount.addingConfigEntry`, {
+                accountId,
+            }));
+        }
+        else {
+            this.config.accounts.push(completedAccountConfig);
         }
         if (writeUpdate) {
             this.write();
@@ -308,11 +344,11 @@ class CLIConfiguration {
      */
     updateDefaultAccount(defaultAccount) {
         if (!this.config) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.noConfigLoaded`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
         }
         if (!defaultAccount ||
             (typeof defaultAccount !== 'number' && typeof defaultAccount !== 'string')) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateDefaultAccount.errors.invalidInput`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateDefaultAccount.errors.invalidInput`));
         }
         this.config.defaultAccount = defaultAccount;
         return this.write();
@@ -322,7 +358,7 @@ class CLIConfiguration {
      */
     renameAccount(currentName, newName) {
         if (!this.config) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.noConfigLoaded`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
         }
         const accountId = this.getAccountId(currentName);
         let accountConfigToRename = null;
@@ -330,12 +366,17 @@ class CLIConfiguration {
             accountConfigToRename = this.getAccount(accountId);
         }
         if (!accountConfigToRename) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.renameAccount.errors.invalidName`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.renameAccount.errors.invalidName`, {
                 currentName,
-            });
+            }));
         }
         if (accountId) {
-            this.updateAccount({ accountId, name: newName, env: this.getEnv() });
+            this.addOrUpdateAccount({
+                accountId,
+                name: newName,
+                env: this.getEnv(),
+                accountType: accountConfigToRename.accountType,
+            });
         }
         if (accountConfigToRename.name === this.getDefaultAccount()) {
             this.updateDefaultAccount(newName);
@@ -343,20 +384,23 @@ class CLIConfiguration {
     }
     /**
      * @throws {Error}
+     * TODO: this does not account for the special handling of sandbox account deletes
      */
     removeAccountFromConfig(nameOrId) {
         if (!this.config) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.noConfigLoaded`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
         }
         const accountId = this.getAccountId(nameOrId);
         if (!accountId) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.removeAccountFromConfig.errors.invalidId`, { nameOrId });
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.removeAccountFromConfig.errors.invalidId`, {
+                nameOrId,
+            }));
         }
         let removedAccountIsDefault = false;
         const accountConfig = this.getAccount(accountId);
         if (accountConfig) {
-            (0, logger_1.debug)(`${i18nKey}.removeAccountFromConfig.deleting`, { accountId });
-            const index = this.getConfigAccountIndex(accountId);
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.removeAccountFromConfig.deleting`, { accountId }));
+            const index = this.getAccountIndex(accountId);
             this.config.accounts.splice(index, 1);
             if (this.getDefaultAccount() === accountConfig.name) {
                 removedAccountIsDefault = true;
@@ -368,18 +412,19 @@ class CLIConfiguration {
     /**
      * @throws {Error}
      */
-    updateDefaultMode(defaultMode) {
+    updateDefaultCmsPublishMode(defaultCmsPublishMode) {
         if (!this.config) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.noConfigLoaded`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
         }
-        const ALL_MODES = Object.values(files_1.MODE);
-        if (!defaultMode || !ALL_MODES.find(m => m === defaultMode)) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateDefaultMode.errors.invalidMode`, {
-                defaultMode,
-                validModes: (0, text_1.commaSeparatedValues)(ALL_MODES),
-            });
+        const ALL_CMS_PUBLISH_MODES = Object.values(files_1.CMS_PUBLISH_MODE);
+        if (!defaultCmsPublishMode ||
+            !ALL_CMS_PUBLISH_MODES.find(m => m === defaultCmsPublishMode)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateDefaultCmsPublishMode.errors.invalidCmsPublishMode`, {
+                defaultCmsPublishMode,
+                validCmsPublishModes: (0, text_1.commaSeparatedValues)(ALL_CMS_PUBLISH_MODES),
+            }));
         }
-        this.config.defaultMode = defaultMode;
+        this.config.defaultCmsPublishMode = defaultCmsPublishMode;
         return this.write();
     }
     /**
@@ -387,14 +432,14 @@ class CLIConfiguration {
      */
     updateHttpTimeout(timeout) {
         if (!this.config) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.noConfigLoaded`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
         }
         const parsedTimeout = parseInt(timeout);
         if (isNaN(parsedTimeout) || parsedTimeout < config_1.MIN_HTTP_TIMEOUT) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateHttpTimeout.errors.invalidTimeout`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateHttpTimeout.errors.invalidTimeout`, {
                 timeout,
                 minTimeout: config_1.MIN_HTTP_TIMEOUT,
-            });
+            }));
         }
         this.config.httpTimeout = parsedTimeout;
         return this.write();
@@ -404,12 +449,12 @@ class CLIConfiguration {
      */
     updateAllowUsageTracking(isEnabled) {
         if (!this.config) {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.noConfigLoaded`);
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noConfigLoaded`));
         }
         if (typeof isEnabled !== 'boolean') {
-            (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateAllowUsageTracking.errors.invalidInput`, {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.updateAllowUsageTracking.errors.invalidInput`, {
                 isEnabled: `${isEnabled}`,
-            });
+            }));
         }
         this.config.allowUsageTracking = isEnabled;
         return this.write();
@@ -420,5 +465,12 @@ class CLIConfiguration {
         }
         return this.config.allowUsageTracking !== false;
     }
+    handleLegacyCmsPublishMode(config) {
+        if (config?.defaultMode) {
+            config.defaultCmsPublishMode = config.defaultMode;
+            delete config.defaultMode;
+        }
+        return config;
+    }
 }
-exports.default = new CLIConfiguration();
+exports.CLIConfiguration = new _CLIConfiguration();

package/config/configFile.js

@@ -8,11 +8,11 @@ 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 logger_1 = require("../lib/logger");
 const config_1 = require("../constants/config");
 const configUtils_1 = require("./configUtils");
+const lang_1 = require("../utils/lang");
+const FileSystemError_1 = require("../models/FileSystemError");
 const i18nKey = 'config.configFile';
 function getConfigFilePath() {
     return path_1.default.join(os_1.default.homedir(), config_1.HUBSPOT_CONFIGURATION_FOLDER, config_1.HUBSPOT_CONFIGURATION_FILE);
@@ -42,10 +42,10 @@ function readConfigFile(configPath) {
         source = fs_extra_1.default.readFileSync(configPath).toString();
     }
     catch (err) {
-        (0, logger_1.debug)(`${i18nKey}.errorReading`, { configPath });
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errorReading`, { configPath }));
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: configPath,
-            read: true,
+            operation: 'read',
         });
     }
     return source;
@@ -60,7 +60,7 @@ function parseConfig(configSource) {
         parsed = js_yaml_1.default.load(configSource);
     }
     catch (err) {
-        (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.errors.parsing`, {}, err);
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.parsing`), { cause: err });
     }
     return parsed;
 }
@@ -77,7 +77,7 @@ function loadConfigFromFile() {
         }
         return parseConfig(source);
     }
-    (0, logger_1.debug)(`${i18nKey}.errorLoading`, { configPath });
+    logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errorLoading`, { configPath }));
     return null;
 }
 exports.loadConfigFromFile = loadConfigFromFile;
@@ -85,23 +85,17 @@ 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 source = js_yaml_1.default.dump(JSON.parse(JSON.stringify((0, configUtils_1.getOrderedConfig)(config), null, 2)));
     const configPath = getConfigFilePath();
     try {
         fs_extra_1.default.ensureFileSync(configPath);
         fs_extra_1.default.writeFileSync(configPath, source);
-        (0, logger_1.debug)(`${i18nKey}.writeSuccess`, { configPath });
+        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.writeSuccess`, { configPath }));
     }
     catch (err) {
-        (0, fileSystemErrors_1.throwFileSystemError)(err, {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
             filepath: configPath,
-            write: true,
+            operation: 'write',
         });
     }
 }

package/config/configUtils.d.ts

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

package/config/configUtils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateConfig = exports.getOrderedConfig = exports.getOrderedAccount = void 0;
-const logger_1 = require("../utils/logger");
+const logger_1 = require("../lib/logger");
 const auth_1 = require("../constants/auth");
+const lang_1 = require("../utils/lang");
 const i18nKey = 'config.configUtils';
 function getOrderedAccount(unorderedAccount) {
     const { name, accountId, env, authType, ...rest } = unorderedAccount;
@@ -16,10 +17,10 @@ function getOrderedAccount(unorderedAccount) {
 }
 exports.getOrderedAccount = getOrderedAccount;
 function getOrderedConfig(unorderedConfig) {
-    const { defaultAccount, defaultMode, httpTimeout, allowUsageTracking, accounts, ...rest } = unorderedConfig;
+    const { defaultAccount, defaultCmsPublishMode, httpTimeout, allowUsageTracking, accounts, ...rest } = unorderedConfig;
     return {
         ...(defaultAccount && { defaultAccount }),
-        defaultMode,
+        defaultCmsPublishMode,
         httpTimeout,
         allowUsageTracking,
         ...rest,
@@ -75,7 +76,7 @@ function generateConfig(type, options) {
             configAccount = generateOauthAccountConfig(options);
             break;
         default:
-            (0, logger_1.debug)(`${i18nKey}.unknownType`, { type });
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.unknownType`, { type }));
             return null;
     }
     if (configAccount) {

package/config/config_DEPRECATED.d.ts

@@ -1,6 +1,6 @@
 import { CLIConfig_DEPRECATED, Environment } from '../types/Config';
-import { CLIAccount_DEPRECATED, FlatAccountFields_DEPRECATED } from '../types/Accounts';
-import { Mode } from '../types/Files';
+import { AccountType, CLIAccount_DEPRECATED, FlatAccountFields_DEPRECATED, UpdateAccountConfigOptions } from '../types/Accounts';
+import { CmsPublishMode } from '../types/Files';
 import { CLIOptions, WriteConfigOptions } from '../types/CLIOptions';
 export declare const getConfig: () => CLIConfig_DEPRECATED | null;
 export declare function setConfig(updatedConfig?: CLIConfig_DEPRECATED): CLIConfig_DEPRECATED | null;
@@ -14,9 +14,10 @@ export declare function accountNameExistsInConfig(name: string): boolean;
 export declare function getOrderedAccount(unorderedAccount: CLIAccount_DEPRECATED): CLIAccount_DEPRECATED;
 export declare function getOrderedConfig(unorderedConfig: CLIConfig_DEPRECATED): {
     portals: CLIAccount_DEPRECATED[];
+    defaultMode?: CmsPublishMode | undefined;
     env?: Environment | undefined;
     httpUseLocalhost?: boolean | undefined;
-    defaultMode: string | undefined;
+    defaultCmsPublishMode: CmsPublishMode | undefined;
     httpTimeout: number | undefined;
     allowUsageTracking: boolean | undefined;
     defaultPortal?: string | number | undefined;
@@ -27,15 +28,13 @@ export declare function isTrackingAllowed(): boolean;
 export declare function getAndLoadConfigIfNeeded(options?: {}): Partial<CLIConfig_DEPRECATED>;
 export declare function findConfig(directory: string): string | null;
 export declare function getEnv(nameOrId?: string | number): Environment;
+export declare function getAccountType(accountType?: AccountType, sandboxAccountType?: string | null): AccountType;
 export declare function getAccountConfig(accountId: number | undefined): CLIAccount_DEPRECATED | undefined;
 export declare function getAccountId(nameOrId?: string | number): number | undefined;
 /**
  * @throws {Error}
  */
 export declare function removeSandboxAccountFromConfig(nameOrId: string | number): boolean;
-type UpdateAccountConfigOptions = Partial<FlatAccountFields_DEPRECATED> & {
-    environment?: Environment;
-};
 /**
  * @throws {Error}
  */
@@ -47,7 +46,7 @@ export declare function updateDefaultAccount(defaultAccount: string | number): v
 /**
  * @throws {Error}
  */
-export declare function updateDefaultMode(defaultMode: Mode): void;
+export declare function updateDefaultCmsPublishMode(defaultCmsPublishMode: CmsPublishMode): void;
 /**
  * @throws {Error}
  */
@@ -75,4 +74,3 @@ export declare function loadConfigFromEnvironment({ useEnv, }?: {
     portals: Array<CLIAccount_DEPRECATED>;
 } | undefined;
 export declare function isConfigFlagEnabled(flag: keyof CLIConfig_DEPRECATED): boolean;
-export {};