@hubspot/local-dev-lib 0.0.4 → 0.0.6

package/api/projects.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelStagedBuild = exports.fetchDeployComponentsMetadata = exports.fetchProjectSettings = exports.getDeployStructure = exports.getDeployStatus = exports.deployProject = exports.getBuildStructure = exports.getBuildStatus = exports.fetchProjectBuilds = exports.fetchPlatformVersions = exports.deleteProject = exports.downloadProject = exports.fetchProject = exports.uploadProject = exports.createProject = exports.fetchProjects = void 0;
+const http_1 = __importDefault(require("../http"));
+const fs_1 = __importDefault(require("fs"));
+const PROJECTS_API_PATH = 'dfs/v1/projects';
+const PROJECTS_DEPLOY_API_PATH = 'dfs/deploy/v1';
+const DEVELOPER_PROJECTS_API_PATH = 'developer/projects/v1';
+async function fetchProjects(accountId) {
+    return http_1.default.get(accountId, {
+        url: PROJECTS_API_PATH,
+    });
+}
+exports.fetchProjects = fetchProjects;
+async function createProject(accountId, name) {
+    return http_1.default.post(accountId, {
+        url: PROJECTS_API_PATH,
+        body: {
+            name,
+        },
+    });
+}
+exports.createProject = createProject;
+async function uploadProject(accountId, projectName, projectFile, uploadMessage, platformVersion) {
+    const formData = {
+        file: fs_1.default.createReadStream(projectFile),
+        uploadMessage,
+    };
+    if (platformVersion) {
+        formData.platformVersion = platformVersion;
+    }
+    return http_1.default.post(accountId, {
+        url: `${PROJECTS_API_PATH}/upload/${encodeURIComponent(projectName)}`,
+        timeout: 60000,
+        formData,
+    });
+}
+exports.uploadProject = uploadProject;
+async function fetchProject(accountId, projectName) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}`,
+    });
+}
+exports.fetchProject = fetchProject;
+async function downloadProject(accountId, projectName, buildId) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/builds/${buildId}/archive-full`,
+        encoding: null,
+        headers: { accept: 'application/zip', contentType: 'application/json' },
+    });
+}
+exports.downloadProject = downloadProject;
+async function deleteProject(accountId, projectName) {
+    return http_1.default.delete(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}`,
+    });
+}
+exports.deleteProject = deleteProject;
+async function fetchPlatformVersions(accountId) {
+    return http_1.default.get(accountId, {
+        url: `${DEVELOPER_PROJECTS_API_PATH}/platformVersion`,
+    });
+}
+exports.fetchPlatformVersions = fetchPlatformVersions;
+async function fetchProjectBuilds(accountId, projectName, query) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/builds`,
+        query,
+    });
+}
+exports.fetchProjectBuilds = fetchProjectBuilds;
+async function getBuildStatus(accountId, projectName, buildId) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/builds/${buildId}/status`,
+    });
+}
+exports.getBuildStatus = getBuildStatus;
+async function getBuildStructure(accountId, projectName, buildId) {
+    return http_1.default.get(accountId, {
+        url: `dfs/v1/builds/by-project-name/${encodeURIComponent(projectName)}/builds/${buildId}/structure`,
+    });
+}
+exports.getBuildStructure = getBuildStructure;
+async function deployProject(accountId, projectName, buildId) {
+    return http_1.default.post(accountId, {
+        url: `${PROJECTS_DEPLOY_API_PATH}/deploys/queue/async`,
+        body: {
+            projectName,
+            buildId,
+        },
+    });
+}
+exports.deployProject = deployProject;
+async function getDeployStatus(accountId, projectName, deployId) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_DEPLOY_API_PATH}/deploy-status/projects/${encodeURIComponent(projectName)}/deploys/${deployId}`,
+    });
+}
+exports.getDeployStatus = getDeployStatus;
+async function getDeployStructure(accountId, projectName, deployId) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_DEPLOY_API_PATH}/deploys/by-project-name/${encodeURIComponent(projectName)}/deploys/${deployId}/structure`,
+    });
+}
+exports.getDeployStructure = getDeployStructure;
+async function fetchProjectSettings(accountId, projectName) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/settings`,
+    });
+}
+exports.fetchProjectSettings = fetchProjectSettings;
+async function fetchDeployComponentsMetadata(accountId, projectId) {
+    return http_1.default.get(accountId, {
+        url: `${PROJECTS_API_PATH}/by-id/${projectId}/deploy-components-metadata`,
+    });
+}
+exports.fetchDeployComponentsMetadata = fetchDeployComponentsMetadata;
+async function cancelStagedBuild(accountId, projectName) {
+    return http_1.default.post(accountId, {
+        url: `${PROJECTS_API_PATH}/${encodeURIComponent(projectName)}/builds/staged/cancel`,
+    });
+}
+exports.cancelStagedBuild = cancelStagedBuild;

package/api/sandboxHubs.d.ts

@@ -0,0 +1,6 @@
+import { Environment } from '../types/Config';
+import { SandboxHubData, SandboxResponse, SandboxUsageLimitsResponse } from '../types/Sandbox';
+export declare function createSandbox(accountId: number, name: string, type: string): Promise<SandboxResponse>;
+export declare function deleteSandbox(parentAccountId: number, sandboxAccountId: number): Promise<void>;
+export declare function getSandboxUsageLimits(parentAccountId: number): Promise<SandboxUsageLimitsResponse>;
+export declare function fetchSandboxHubData(accessToken: string, portalId: number, env?: Environment): Promise<SandboxHubData>;

package/api/sandboxHubs.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSandboxHubData = exports.getSandboxUsageLimits = exports.deleteSandbox = exports.createSandbox = void 0;
+const axios_1 = __importDefault(require("axios"));
+const http_1 = __importDefault(require("../http"));
+const getAxiosConfig_1 = require("../http/getAxiosConfig");
+const environments_1 = require("../constants/environments");
+const api_1 = require("../constants/api");
+const SANDBOX_API_PATH = 'sandbox-hubs/v1';
+const SANDBOX_API_PATH_V2 = 'sandbox-hubs/v2';
+async function createSandbox(accountId, name, type) {
+    return http_1.default.post(accountId, {
+        body: { name, type, generatePersonalAccessKey: true },
+        timeout: api_1.SANDBOX_TIMEOUT,
+        url: SANDBOX_API_PATH_V2, // Create uses v2 for sandbox type and PAK generation support
+    });
+}
+exports.createSandbox = createSandbox;
+async function deleteSandbox(parentAccountId, sandboxAccountId) {
+    return http_1.default.delete(parentAccountId, {
+        url: `${SANDBOX_API_PATH}/${sandboxAccountId}`,
+    });
+}
+exports.deleteSandbox = deleteSandbox;
+async function getSandboxUsageLimits(parentAccountId) {
+    return http_1.default.get(parentAccountId, {
+        url: `${SANDBOX_API_PATH}/parent/${parentAccountId}/usage`,
+    });
+}
+exports.getSandboxUsageLimits = getSandboxUsageLimits;
+async function fetchSandboxHubData(accessToken, portalId, env = environments_1.ENVIRONMENTS.PROD) {
+    const axiosConfig = (0, getAxiosConfig_1.getAxiosConfig)({
+        env,
+        url: `${SANDBOX_API_PATH}/self`,
+        params: { portalId },
+    });
+    const reqWithToken = {
+        ...axiosConfig,
+        headers: {
+            ...axiosConfig.headers,
+            Authorization: `Bearer ${accessToken}`,
+        },
+    };
+    const { data } = await (0, axios_1.default)(reqWithToken);
+    return data;
+}
+exports.fetchSandboxHubData = fetchSandboxHubData;

package/api/sandboxSync.d.ts

@@ -0,0 +1,4 @@
+import { InitiateSyncResponse, Task, SyncTask, FetchTypesResponse } from '../types/Sandbox';
+export declare function initiateSync(fromHubId: number, toHubId: number, tasks: Array<SyncTask>, sandboxHubId: number): Promise<InitiateSyncResponse>;
+export declare function fetchTaskStatus(accountId: number, taskId: number): Promise<Task>;
+export declare function fetchTypes(accountId: number, toHubId: number): Promise<FetchTypesResponse>;

package/api/sandboxSync.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTypes = exports.fetchTaskStatus = exports.initiateSync = void 0;
+const http_1 = __importDefault(require("../http"));
+const api_1 = require("../constants/api");
+const SANDBOXES_SYNC_API_PATH = 'sandboxes-sync/v1';
+async function initiateSync(fromHubId, toHubId, tasks, sandboxHubId) {
+    return http_1.default.post(fromHubId, {
+        body: {
+            command: 'SYNC',
+            fromHubId,
+            toHubId,
+            sandboxHubId,
+            tasks,
+        },
+        timeout: api_1.SANDBOX_TIMEOUT,
+        url: `${SANDBOXES_SYNC_API_PATH}/tasks/initiate/async`,
+    });
+}
+exports.initiateSync = initiateSync;
+async function fetchTaskStatus(accountId, taskId) {
+    return http_1.default.get(accountId, {
+        url: `${SANDBOXES_SYNC_API_PATH}/tasks/${taskId}`,
+    });
+}
+exports.fetchTaskStatus = fetchTaskStatus;
+async function fetchTypes(accountId, toHubId) {
+    return http_1.default.get(accountId, {
+        url: `${SANDBOXES_SYNC_API_PATH}/types${toHubId ? `?toHubId=${toHubId}` : ''}`,
+    });
+}
+exports.fetchTypes = fetchTypes;

package/api/secrets.d.ts

@@ -0,0 +1,8 @@
+type FetchSecretsResponse = {
+    results: Array<string>;
+};
+export declare function addSecret(accountId: number, key: string, value: string): Promise<void>;
+export declare function updateSecret(accountId: number, key: string, value: string): Promise<void>;
+export declare function deleteSecret(accountId: number, key: string): Promise<void>;
+export declare function fetchSecrets(accountId: number): Promise<FetchSecretsResponse>;
+export {};

package/api/secrets.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSecrets = exports.deleteSecret = exports.updateSecret = exports.addSecret = void 0;
+const http_1 = __importDefault(require("../http"));
+const SECRETS_API_PATH = 'cms/v3/functions/secrets';
+async function addSecret(accountId, key, value) {
+    return http_1.default.post(accountId, {
+        url: SECRETS_API_PATH,
+        body: {
+            key,
+            secret: value,
+        },
+    });
+}
+exports.addSecret = addSecret;
+async function updateSecret(accountId, key, value) {
+    return http_1.default.put(accountId, {
+        url: SECRETS_API_PATH,
+        body: {
+            key,
+            secret: value,
+        },
+    });
+}
+exports.updateSecret = updateSecret;
+async function deleteSecret(accountId, key) {
+    return http_1.default.delete(accountId, {
+        url: `${SECRETS_API_PATH}/${key}`,
+    });
+}
+exports.deleteSecret = deleteSecret;
+async function fetchSecrets(accountId) {
+    return http_1.default.get(accountId, {
+        url: `${SECRETS_API_PATH}`,
+    });
+}
+exports.fetchSecrets = fetchSecrets;

package/api/validateHubl.d.ts

@@ -0,0 +1,2 @@
+import { Validation, HublValidationOptions } from '../types/HublValidation';
+export declare function validateHubl(accountId: number, sourceCode: string, hublValidationOptions?: HublValidationOptions): Promise<Validation>;

package/api/validateHubl.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHubl = void 0;
+const http_1 = __importDefault(require("../http"));
+const HUBL_VALIDATE_API_PATH = 'cos-rendering/v1/internal/validate';
+async function validateHubl(accountId, sourceCode, hublValidationOptions) {
+    return http_1.default.post(accountId, {
+        url: HUBL_VALIDATE_API_PATH,
+        body: {
+            template_source: sourceCode,
+            ...hublValidationOptions,
+        },
+    });
+}
+exports.validateHubl = validateHubl;

package/config/CLIConfiguration.d.ts

@@ -1,35 +1,40 @@
-import { CLIConfig } from '../types/Config';
-import { CLIAccount, FlatAccountFields, OauthTokenInfo } from '../types/Accounts';
+import { CLIConfig_NEW, Environment } from '../types/Config';
+import { CLIAccount_NEW, FlatAccountFields_NEW } 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;
+    config: CLIConfig_NEW | null;
+    active: boolean;
     constructor();
-    init(options?: CLIOptions): void;
-    load(): CLIConfig | null;
+    setActive(isActive: boolean): void;
+    isActive(): boolean;
+    init(options?: CLIOptions): CLIConfig_NEW | null;
+    load(): CLIConfig_NEW | null;
     configIsEmpty(): boolean;
     delete(): void;
-    write(updatedConfig?: CLIConfig): CLIConfig | null;
+    write(updatedConfig?: CLIConfig_NEW): CLIConfig_NEW | null;
     validate(logCallbacks?: LogCallbacksArg<typeof validateLogCallbackKeys>): boolean;
-    getAccount(nameOrId: string | number | undefined): CLIAccount | null;
-    getAccountId(nameOrId: string | number): number | null;
+    getAccount(nameOrId: string | number | undefined): CLIAccount_NEW | null;
+    isConfigFlagEnabled(flag: keyof CLIConfig_NEW, defaultValue?: boolean): boolean;
+    getAccountId(nameOrId?: string | number): number | null;
     getDefaultAccount(): string | number | null;
-    getResolvedDefaultAccountForCWD(nameOrId: string | number): CLIAccount | null;
+    getResolvedDefaultAccountForCWD(nameOrId: string | number): CLIAccount_NEW | null;
     getConfigAccountIndex(accountId: number): number;
+    getConfigForAccount(accountId?: number): CLIAccount_NEW | null;
     isAccountInConfig(nameOrId: string | number): boolean;
-    getAndLoadConfigIfNeeded(options?: CLIOptions): CLIConfig;
-    getEnv(nameOrId?: string | number): string;
+    getAndLoadConfigIfNeeded(options?: CLIOptions): CLIConfig_NEW;
+    getEnv(nameOrId?: string | number): Environment;
     /**
      * @throws {Error}
      */
-    updateAccount(updatedAccountFields: FlatAccountFields<OauthTokenInfo>, writeUpdate?: boolean): CLIAccount | null;
+    updateAccount(updatedAccountFields: Partial<FlatAccountFields_NEW>, writeUpdate?: boolean): FlatAccountFields_NEW | null;
     /**
      * @throws {Error}
      */
-    updateDefaultAccount(defaultAccount: string | number): CLIConfig | null;
+    updateDefaultAccount(defaultAccount: string | number): CLIConfig_NEW | null;
     /**
      * @throws {Error}
      */
@@ -41,15 +46,16 @@ declare class CLIConfiguration {
     /**
      * @throws {Error}
      */
-    updateDefaultMode(defaultMode: string): CLIConfig | null;
+    updateDefaultMode(defaultMode: string): CLIConfig_NEW | null;
     /**
      * @throws {Error}
      */
-    updateHttpTimeout(timeout: string): CLIConfig | null;
+    updateHttpTimeout(timeout: string): CLIConfig_NEW | null;
     /**
      * @throws {Error}
      */
-    updateAllowUsageTracking(isEnabled: boolean): CLIConfig | null;
+    updateAllowUsageTracking(isEnabled: boolean): CLIConfig_NEW | null;
+    isTrackingAllowed(): boolean;
 }
 declare const _default: CLIConfiguration;
 export default _default;

package/config/CLIConfiguration.js

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../utils/logger");
 const standardErrors_1 = require("../errors/standardErrors");
 const environment_1 = require("./environment");
+const environment_2 = require("../lib/environment");
 const configFile_1 = require("./configFile");
 const text_1 = require("../lib/text");
-const constants_1 = require("../constants");
+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 i18nKey = 'config.cliConfiguration';
 const validateLogCallbackKeys = [
     'noConfig',
@@ -22,14 +24,24 @@ class CLIConfiguration {
     options;
     useEnvConfig;
     config;
+    active;
     constructor() {
         this.options = {};
         this.useEnvConfig = false;
         this.config = null;
+        this.active = false;
+    }
+    setActive(isActive) {
+        this.active = isActive;
+    }
+    isActive() {
+        return this.active;
     }
     init(options = {}) {
         this.options = options;
         this.load();
+        this.setActive(true);
+        return this.config;
     }
     load() {
         if (this.options.useEnv) {
@@ -158,6 +170,12 @@ class CLIConfiguration {
         }
         return null;
     }
+    isConfigFlagEnabled(flag, defaultValue = false) {
+        if (this.config && typeof this.config[flag] !== 'undefined') {
+            return Boolean(this.config[flag]);
+        }
+        return defaultValue;
+    }
     getAccountId(nameOrId) {
         const account = this.getAccount(nameOrId);
         return account ? account.accountId : null;
@@ -183,6 +201,13 @@ class CLIConfiguration {
             ? this.config.accounts.findIndex(account => account.accountId === accountId)
             : -1;
     }
+    getConfigForAccount(accountId) {
+        if (this.config) {
+            this.config.accounts.find(account => account.accountId === accountId) ||
+                null;
+        }
+        return null;
+    }
     isAccountInConfig(nameOrId) {
         return (!!this.config && this.config.accounts && !!this.getAccountId(nameOrId));
     }
@@ -200,7 +225,7 @@ class CLIConfiguration {
         if (this.config && this.config.env) {
             return this.config.env;
         }
-        return constants_1.ENVIRONMENTS.PROD;
+        return environments_1.ENVIRONMENTS.PROD;
     }
     /*
      * Config Update Utils
@@ -218,7 +243,7 @@ class CLIConfiguration {
             return null;
         }
         const currentAccountConfig = this.getAccount(accountId);
-        let auth;
+        let auth = {};
         if (clientId || clientSecret || scopes || tokenInfo) {
             auth = {
                 ...(currentAccountConfig ? currentAccountConfig.auth : {}),
@@ -239,9 +264,8 @@ class CLIConfiguration {
                 nextAccountConfig[fieldName] = newValue;
             }
         }
-        const updatedEnv = (0, environment_1.getValidEnv)(env || (currentAccountConfig && currentAccountConfig.env), false);
-        const updatedDefaultMode = defaultMode &&
-            defaultMode.toLowerCase();
+        const updatedEnv = (0, environment_2.getValidEnv)(env || (currentAccountConfig && currentAccountConfig.env));
+        const updatedDefaultMode = defaultMode && defaultMode.toLowerCase();
         safelyApplyUpdates('name', name);
         safelyApplyUpdates('env', updatedEnv);
         safelyApplyUpdates('accountId', accountId);
@@ -252,7 +276,7 @@ class CLIConfiguration {
         }
         if (typeof updatedDefaultMode !== 'undefined') {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            safelyApplyUpdates('defaultMode', config_1.DEFAULT_MODES[updatedDefaultMode]);
+            safelyApplyUpdates('defaultMode', files_1.MODE[updatedDefaultMode]);
         }
         safelyApplyUpdates('personalAccessKey', personalAccessKey);
         safelyApplyUpdates('sandboxAccountType', sandboxAccountType);
@@ -309,7 +333,7 @@ class CLIConfiguration {
             (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.renameAccount`, { currentName });
         }
         if (accountId) {
-            this.updateAccount({ accountId, name: newName });
+            this.updateAccount({ accountId, name: newName, env: this.getEnv() });
         }
         if (accountConfigToRename.name === this.getDefaultAccount()) {
             this.updateDefaultAccount(newName);
@@ -346,7 +370,7 @@ class CLIConfiguration {
         if (!this.config) {
             (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.noConfigLoaded`);
         }
-        const ALL_MODES = Object.values(config_1.DEFAULT_MODES);
+        const ALL_MODES = Object.values(files_1.MODE);
         if (!defaultMode || !ALL_MODES.find(m => m === defaultMode)) {
             (0, standardErrors_1.throwErrorWithMessage)(`${i18nKey}.updateDefaultMode`, {
                 defaultMode,
@@ -388,5 +412,11 @@ class CLIConfiguration {
         this.config.allowUsageTracking = isEnabled;
         return this.write();
     }
+    isTrackingAllowed() {
+        if (!this.config) {
+            return true;
+        }
+        return this.config.allowUsageTracking !== false;
+    }
 }
 exports.default = new CLIConfiguration();

package/config/configFile.d.ts

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

package/config/configFile.js

@@ -11,11 +11,11 @@ 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 config_1 = require("../constants/config");
 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);
+    return path_1.default.join(os_1.default.homedir(), config_1.HUBSPOT_CONFIGURATION_FOLDER, config_1.HUBSPOT_CONFIGURATION_FILE);
 }
 exports.getConfigFilePath = getConfigFilePath;
 function configFileExists() {

package/config/configUtils.d.ts

@@ -1,11 +1,11 @@
-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;
+import { CLIConfig_NEW, Environment } from '../types/Config';
+import { AuthType, CLIAccount_NEW } 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: string;
+    env: Environment;
 };
 type OAuthOptions = {
     accountId: number;
@@ -13,12 +13,12 @@ type OAuthOptions = {
     clientSecret: string;
     refreshToken: string;
     scopes: Array<string>;
-    env: string;
+    env: Environment;
 };
 type APIKeyOptions = {
     accountId: number;
     apiKey: string;
-    env: string;
+    env: Environment;
 };
-export declare function generateConfig(type: AuthType, options: PersonalAccessKeyOptions | OAuthOptions | APIKeyOptions): CLIConfig | null;
+export declare function generateConfig(type: AuthType, options: PersonalAccessKeyOptions | OAuthOptions | APIKeyOptions): CLIConfig_NEW | null;
 export {};

package/config/config_DEPRECATED.d.ts

@@ -0,0 +1,78 @@
+import { CLIConfig_DEPRECATED, Environment } from '../types/Config';
+import { CLIAccount_DEPRECATED, FlatAccountFields_DEPRECATED } from '../types/Accounts';
+import { Mode } 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;
+export declare function getConfigAccounts(config?: CLIConfig_DEPRECATED): Array<CLIAccount_DEPRECATED> | undefined;
+export declare function getConfigDefaultAccount(config?: CLIConfig_DEPRECATED): string | number | undefined;
+export declare function getConfigAccountId(account: CLIAccount_DEPRECATED): number | undefined;
+export declare function setConfigPath(path: string | null): string | null;
+export declare function getConfigPath(path?: string | null): string | null;
+export declare function validateConfig(): boolean;
+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[];
+    env?: Environment | undefined;
+    httpUseLocalhost?: boolean | undefined;
+    defaultMode: string | undefined;
+    httpTimeout: number | undefined;
+    allowUsageTracking: boolean | undefined;
+    defaultPortal?: string | number | undefined;
+};
+export declare function writeConfig(options?: WriteConfigOptions): void;
+export declare function loadConfig(path?: string, options?: CLIOptions): CLIConfig_DEPRECATED | null;
+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 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}
+ */
+export declare function updateAccountConfig(configOptions: UpdateAccountConfigOptions): FlatAccountFields_DEPRECATED;
+/**
+ * @throws {Error}
+ */
+export declare function updateDefaultAccount(defaultAccount: string | number): void;
+/**
+ * @throws {Error}
+ */
+export declare function updateDefaultMode(defaultMode: Mode): void;
+/**
+ * @throws {Error}
+ */
+export declare function updateHttpTimeout(timeout: string): void;
+/**
+ * @throws {Error}
+ */
+export declare function updateAllowUsageTracking(isEnabled: boolean): void;
+/**
+ * @throws {Error}
+ */
+export declare function renameAccount(currentName: string, newName: string): Promise<void>;
+/**
+ * @throws {Error}
+ */
+export declare function deleteAccount(accountName: string): Promise<void>;
+export declare function createEmptyConfigFile({ path }?: {
+    path?: string;
+}): void;
+export declare function deleteEmptyConfigFile(): void;
+export declare function deleteConfigFile(): void;
+export declare function loadConfigFromEnvironment({ useEnv, }?: {
+    useEnv?: boolean;
+}): {
+    portals: Array<CLIAccount_DEPRECATED>;
+} | undefined;
+export declare function isConfigFlagEnabled(flag: keyof CLIConfig_DEPRECATED): boolean;
+export {};