@hubspot/local-dev-lib 0.4.3-experimental.0 → 0.5.0-experimental.1

package/config/migrate.d.ts

@@ -1,22 +1,17 @@
-import { CLIConfig_DEPRECATED, CLIConfig_NEW, Environment } from '../types/Config';
-import { CmsPublishMode } from '../types/Files';
-export declare function getDeprecatedConfig(configPath?: string): CLIConfig_DEPRECATED | null;
-export declare function getGlobalConfig(): CLIConfig_NEW | null;
-export declare function configFileExists(useHiddenConfig?: boolean, configPath?: string): boolean;
-export declare function getConfigPath(configPath?: string, useHiddenConfig?: boolean): string | null;
-export declare function migrateConfig(deprecatedConfig: CLIConfig_DEPRECATED | null): void;
-type ConflictValue = boolean | string | number | CmsPublishMode | Environment;
+import { HubSpotConfig } from '../types/Config';
+import { ValueOf } from '../types/Utils';
+export declare function getConfigAtPath(path: string): HubSpotConfig;
+export declare function migrateConfigAtPath(path: string): void;
 export type ConflictProperty = {
-    property: keyof CLIConfig_NEW;
-    oldValue: ConflictValue;
-    newValue: ConflictValue;
+    property: keyof HubSpotConfig;
+    oldValue: ValueOf<HubSpotConfig>;
+    newValue: ValueOf<Required<HubSpotConfig>>;
 };
-export declare function mergeConfigProperties(globalConfig: CLIConfig_NEW, deprecatedConfig: CLIConfig_DEPRECATED, force?: boolean): {
-    initialConfig: CLIConfig_NEW;
+export declare function mergeConfigProperties(toConfig: HubSpotConfig, fromConfig: HubSpotConfig, force?: boolean): {
+    configWithMergedProperties: HubSpotConfig;
     conflicts: Array<ConflictProperty>;
 };
-export declare function mergeExistingConfigs(globalConfig: CLIConfig_NEW, deprecatedConfig: CLIConfig_DEPRECATED): {
-    finalConfig: CLIConfig_NEW;
+export declare function mergeConfigAccounts(toConfig: HubSpotConfig, fromConfig: HubSpotConfig): {
+    configWithMergedAccounts: HubSpotConfig;
     skippedAccountIds: Array<string | number>;
 };
-export {};

package/config/migrate.js

@@ -1,186 +1,104 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeExistingConfigs = exports.mergeConfigProperties = exports.migrateConfig = exports.getConfigPath = exports.configFileExists = exports.getGlobalConfig = exports.getDeprecatedConfig = void 0;
-const config_DEPRECATED = __importStar(require("./config_DEPRECATED"));
-const CLIConfiguration_1 = require("./CLIConfiguration");
+exports.mergeConfigAccounts = exports.mergeConfigProperties = exports.migrateConfigAtPath = exports.getConfigAtPath = void 0;
+const fs_1 = __importDefault(require("fs"));
 const index_1 = require("./index");
-const configFile_1 = require("./configFile");
 const config_1 = require("../constants/config");
-const lang_1 = require("../utils/lang");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const i18nKey = 'config.migrate';
-function getDeprecatedConfig(configPath) {
-    return config_DEPRECATED.loadConfig(configPath);
+const utils_1 = require("./utils");
+function getConfigAtPath(path) {
+    const configFileSource = (0, utils_1.readConfigFile)(path);
+    return (0, utils_1.parseConfig)(configFileSource, path);
 }
-exports.getDeprecatedConfig = getDeprecatedConfig;
-function getGlobalConfig() {
-    if (CLIConfiguration_1.CLIConfiguration.isActive()) {
-        return CLIConfiguration_1.CLIConfiguration.config;
-    }
-    return null;
-}
-exports.getGlobalConfig = getGlobalConfig;
-function configFileExists(useHiddenConfig = false, configPath) {
-    return useHiddenConfig
-        ? (0, configFile_1.configFileExists)()
-        : Boolean(config_DEPRECATED.getConfigPath(configPath));
-}
-exports.configFileExists = configFileExists;
-function getConfigPath(configPath, useHiddenConfig = false) {
-    if (useHiddenConfig) {
-        return (0, configFile_1.getConfigFilePath)();
-    }
-    return config_DEPRECATED.getConfigPath(configPath);
+exports.getConfigAtPath = getConfigAtPath;
+function migrateConfigAtPath(path) {
+    (0, index_1.createEmptyConfigFile)(true);
+    const configToMigrate = getConfigAtPath(path);
+    (0, utils_1.writeConfigFile)(configToMigrate, (0, utils_1.getGlobalConfigFilePath)());
+    fs_1.default.unlinkSync(path);
 }
-exports.getConfigPath = getConfigPath;
-function writeGlobalConfigFile(updatedConfig, isMigrating = false) {
-    const updatedConfigJson = JSON.stringify(updatedConfig);
-    if (isMigrating) {
-        (0, index_1.createEmptyConfigFile)({}, true);
-    }
-    (0, index_1.loadConfig)('');
-    try {
-        (0, index_1.writeConfig)({ source: updatedConfigJson });
-        const oldConfigPath = config_DEPRECATED.getConfigPath();
-        if (oldConfigPath) {
-            const dir = path_1.default.dirname(oldConfigPath);
-            const newConfigPath = path_1.default.join(dir, config_1.ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME);
-            fs_1.default.renameSync(oldConfigPath, newConfigPath);
-        }
-    }
-    catch (error) {
-        (0, index_1.deleteEmptyConfigFile)();
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.writeConfig`, { configPath: config_1.GLOBAL_CONFIG_PATH }), { cause: error });
-    }
-}
-function migrateConfig(deprecatedConfig) {
-    if (!deprecatedConfig) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noDeprecatedConfig`));
-    }
-    const { defaultPortal, portals, ...rest } = deprecatedConfig;
-    const updatedConfig = {
-        ...rest,
-        defaultAccount: defaultPortal,
-        accounts: portals
-            .filter(({ portalId }) => portalId !== undefined)
-            .map(({ portalId, ...rest }) => ({
-            ...rest,
-            accountId: portalId,
-        })),
-    };
-    writeGlobalConfigFile(updatedConfig, true);
-}
-exports.migrateConfig = migrateConfig;
-function mergeConfigProperties(globalConfig, deprecatedConfig, force) {
-    const propertiesToCheck = [
-        config_1.DEFAULT_CMS_PUBLISH_MODE,
-        config_1.HTTP_TIMEOUT,
-        config_1.ENV,
-        config_1.HTTP_USE_LOCALHOST,
-        config_1.ALLOW_USAGE_TRACKING,
-        config_1.AUTO_OPEN_BROWSER,
-        config_1.ALLOW_AUTO_UPDATES,
-    ];
+exports.migrateConfigAtPath = migrateConfigAtPath;
+function mergeConfigProperties(toConfig, fromConfig, force) {
     const conflicts = [];
-    propertiesToCheck.forEach(prop => {
-        if (prop in deprecatedConfig) {
-            if (force ||
-                !(prop in globalConfig) ||
-                globalConfig[prop] === deprecatedConfig[prop]) {
-                // @ts-expect-error Cannot reconcile CLIConfig_NEW and CLIConfig_DEPRECATED types
-                globalConfig[prop] = deprecatedConfig[prop];
-            }
-            else {
+    if (force) {
+        toConfig.defaultCmsPublishMode = fromConfig.defaultCmsPublishMode;
+        toConfig.httpTimeout = fromConfig.httpTimeout;
+        toConfig.env = fromConfig.env;
+        toConfig.httpUseLocalhost = fromConfig.httpUseLocalhost;
+        toConfig.allowUsageTracking = fromConfig.allowUsageTracking;
+        toConfig.autoOpenBrowser = fromConfig.autoOpenBrowser;
+        toConfig.allowAutoUpdates = fromConfig.allowAutoUpdates;
+        toConfig.defaultAccount = fromConfig.defaultAccount;
+    }
+    else {
+        toConfig.defaultCmsPublishMode ||= fromConfig.defaultCmsPublishMode;
+        toConfig.httpTimeout ||= fromConfig.httpTimeout;
+        toConfig.env ||= fromConfig.env;
+        toConfig.httpUseLocalhost =
+            toConfig.httpUseLocalhost === undefined
+                ? fromConfig.httpUseLocalhost
+                : toConfig.httpUseLocalhost;
+        toConfig.allowUsageTracking =
+            toConfig.allowUsageTracking === undefined
+                ? fromConfig.allowUsageTracking
+                : toConfig.allowUsageTracking;
+        toConfig.autoOpenBrowser =
+            toConfig.autoOpenBrowser === undefined
+                ? fromConfig.autoOpenBrowser
+                : toConfig.autoOpenBrowser;
+        toConfig.allowAutoUpdates =
+            toConfig.allowAutoUpdates === undefined
+                ? fromConfig.allowAutoUpdates
+                : toConfig.allowAutoUpdates;
+        toConfig.defaultAccount ||= fromConfig.defaultAccount;
+        const propertiesToCheck = [
+            config_1.DEFAULT_CMS_PUBLISH_MODE,
+            config_1.HTTP_TIMEOUT,
+            config_1.ENV,
+            config_1.HTTP_USE_LOCALHOST,
+            config_1.ALLOW_USAGE_TRACKING,
+            config_1.AUTO_OPEN_BROWSER,
+            config_1.ALLOW_AUTO_UPDATES,
+            config_1.DEFAULT_ACCOUNT,
+        ];
+        propertiesToCheck.forEach(prop => {
+            if (toConfig[prop] !== undefined && toConfig[prop] !== fromConfig[prop]) {
                 conflicts.push({
                     property: prop,
-                    oldValue: deprecatedConfig[prop],
-                    newValue: globalConfig[prop],
+                    oldValue: fromConfig[prop],
+                    newValue: toConfig[prop],
                 });
             }
-        }
-    });
-    if (globalConfig.flags || deprecatedConfig.flags) {
-        globalConfig.flags = Array.from(new Set([
-            ...(globalConfig.flags || []),
-            ...(deprecatedConfig.flags || []),
-        ]));
-    }
-    if (config_1.DEFAULT_ACCOUNT in globalConfig &&
-        config_1.DEFAULT_PORTAL in deprecatedConfig &&
-        globalConfig.defaultAccount !== deprecatedConfig.defaultPortal) {
-        if (force) {
-            globalConfig.defaultAccount = deprecatedConfig.defaultPortal;
-        }
-        else {
-            conflicts.push({
-                property: config_1.DEFAULT_ACCOUNT,
-                oldValue: deprecatedConfig.defaultPortal,
-                newValue: globalConfig.defaultAccount,
-            });
-        }
+        });
     }
-    else if (config_1.DEFAULT_PORTAL in deprecatedConfig) {
-        globalConfig.defaultAccount = deprecatedConfig.defaultPortal;
+    // Merge flags
+    if (toConfig.flags || fromConfig.flags) {
+        toConfig.flags = Array.from(new Set([...(toConfig.flags || []), ...(fromConfig.flags || [])]));
     }
-    return { initialConfig: globalConfig, conflicts };
+    return { configWithMergedProperties: toConfig, conflicts };
 }
 exports.mergeConfigProperties = mergeConfigProperties;
-function mergeAccounts(globalConfig, deprecatedConfig) {
-    let existingAccountIds = [];
+function buildConfigWithMergedAccounts(toConfig, fromConfig) {
+    const existingAccountIds = toConfig.accounts.map(({ accountId }) => accountId);
     const skippedAccountIds = [];
-    if (globalConfig.accounts && deprecatedConfig.portals) {
-        existingAccountIds = globalConfig.accounts.map(account => account.accountId);
-        const newAccounts = deprecatedConfig.portals
-            .filter(portal => {
-            const isExisting = existingAccountIds.includes(portal.portalId);
-            if (isExisting) {
-                skippedAccountIds.push(portal.portalId);
-            }
-            return !isExisting;
-        })
-            .map(({ portalId, ...rest }) => ({
-            ...rest,
-            accountId: portalId,
-        }));
-        if (newAccounts.length > 0) {
-            globalConfig.accounts.push(...newAccounts);
+    fromConfig.accounts.forEach(account => {
+        if (existingAccountIds.includes(account.accountId)) {
+            skippedAccountIds.push(account.accountId);
         }
-    }
+        else {
+            toConfig.accounts.push(account);
+        }
+    });
     return {
-        finalConfig: globalConfig,
+        configWithMergedAccounts: toConfig,
         skippedAccountIds,
     };
 }
-function mergeExistingConfigs(globalConfig, deprecatedConfig) {
-    const { finalConfig, skippedAccountIds } = mergeAccounts(globalConfig, deprecatedConfig);
-    writeGlobalConfigFile(finalConfig);
-    return { finalConfig, skippedAccountIds };
+function mergeConfigAccounts(toConfig, fromConfig) {
+    const { configWithMergedAccounts, skippedAccountIds } = buildConfigWithMergedAccounts(toConfig, fromConfig);
+    (0, utils_1.writeConfigFile)(configWithMergedAccounts, (0, utils_1.getGlobalConfigFilePath)());
+    return { configWithMergedAccounts, skippedAccountIds };
 }
-exports.mergeExistingConfigs = mergeExistingConfigs;
+exports.mergeConfigAccounts = mergeConfigAccounts;

package/config/state.d.ts

@@ -1,3 +1,3 @@
-import { HubSpotState } from '../types/Config';
-export declare function getStateValue<K extends keyof HubSpotState>(key: K): HubSpotState[K];
-export declare function setStateValue<K extends keyof HubSpotState>(key: K, value: HubSpotState[K]): void;
+import { CLIState } from '../types/Config';
+export declare function getStateValue<K extends keyof CLIState>(key: K): CLIState[K];
+export declare function setStateValue<K extends keyof CLIState>(key: K, value: CLIState[K]): void;

package/config/state.js

@@ -46,41 +46,19 @@ function ensureCLIDirectory() {
         }));
     }
 }
-function sanitizeAndMerge(parsed) {
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        return structuredClone(DEFAULT_STATE);
-    }
-    const state = parsed;
-    const result = structuredClone(DEFAULT_STATE);
-    for (const key in DEFAULT_STATE) {
-        const typedKey = key;
-        if (key in state &&
-            typeof state[typedKey] === typeof DEFAULT_STATE[typedKey]) {
-            result[typedKey] = state[typedKey];
-        }
-        // keys not in parsed file remain as DEFAULT values
-    }
-    return result;
-}
 function getCurrentState() {
     try {
-        if (!fs.existsSync(config_1.STATE_FILE_PATH)) {
-            return structuredClone(DEFAULT_STATE);
+        if (fs.existsSync(config_1.STATE_FILE_PATH)) {
+            const data = fs.readFileSync(config_1.STATE_FILE_PATH, 'utf-8');
+            return JSON.parse(data);
         }
-        const data = fs.readFileSync(config_1.STATE_FILE_PATH, 'utf-8');
-        if (!data?.trim()) {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.getCurrentState.debug.emptyStateFile`));
-            return structuredClone(DEFAULT_STATE);
-        }
-        const parsed = JSON.parse(data);
-        return sanitizeAndMerge(parsed);
     }
     catch (error) {
-        logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.getCurrentState.errors.errorReading`, {
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.getCurrentState.errors.errorReading`, {
             error: error instanceof Error ? error.message : String(error),
         }));
-        return structuredClone(DEFAULT_STATE);
     }
+    return DEFAULT_STATE;
 }
 function getStateValue(key) {
     ensureCLIDirectory();
@@ -90,7 +68,13 @@ function getStateValue(key) {
 exports.getStateValue = getStateValue;
 function setStateValue(key, value) {
     ensureCLIDirectory();
-    const currentState = getCurrentState();
+    let currentState = DEFAULT_STATE;
+    try {
+        currentState = getCurrentState();
+    }
+    catch (error) {
+        logger_1.logger.debug(error);
+    }
     const newState = { ...currentState, [key]: value };
     try {
         fs.writeFileSync(config_1.STATE_FILE_PATH, JSON.stringify(newState, null, 2), 'utf-8');

package/config/utils.d.ts

@@ -0,0 +1,74 @@
+import { ACCOUNT_IDENTIFIERS } from '../constants/config';
+import { HubSpotConfig, DeprecatedHubSpotConfigFields } from '../types/Config';
+import { HubSpotConfigAccount, AccountType, TokenInfo } from '../types/Accounts';
+import { ValueOf } from '../types/Utils';
+export declare function getGlobalConfigFilePath(): string;
+export declare function getLocalConfigFilePath(): string | null;
+export declare function getLocalConfigDefaultFilePath(): string;
+export declare function getConfigPathEnvironmentVariables(): {
+    useEnvironmentConfig: boolean;
+    configFilePathFromEnvironment: string | undefined;
+};
+export declare function readConfigFile(configPath: string): string;
+export declare function removeUndefinedFieldsFromConfigAccount<T extends HubSpotConfigAccount | Partial<HubSpotConfigAccount> = HubSpotConfigAccount>(account: T): T;
+export declare function formatConfigForWrite(config: HubSpotConfig): {
+    accounts: ({
+        personalAccessKey: string;
+        auth: {
+            tokenInfo: TokenInfo;
+        };
+        accountType?: AccountType | undefined;
+        defaultCmsPublishMode?: import("../types/Files").CmsPublishMode | undefined;
+        parentAccountId?: number | undefined;
+        name: string;
+        accountId: number;
+        env: import("../types/Config").Environment;
+        authType: "apikey" | "oauth2" | "personalaccesskey";
+    } | {
+        auth: {
+            clientId: string;
+            clientSecret: string;
+            scopes: string[];
+            tokenInfo: TokenInfo;
+        };
+        accountType?: AccountType | undefined;
+        defaultCmsPublishMode?: import("../types/Files").CmsPublishMode | undefined;
+        parentAccountId?: number | undefined;
+        name: string;
+        accountId: number;
+        env: import("../types/Config").Environment;
+        authType: "apikey" | "oauth2" | "personalaccesskey";
+    } | {
+        apiKey: string;
+        accountType?: AccountType | undefined;
+        defaultCmsPublishMode?: import("../types/Files").CmsPublishMode | undefined;
+        parentAccountId?: number | undefined;
+        name: string;
+        accountId: number;
+        env: import("../types/Config").Environment;
+        authType: "apikey" | "oauth2" | "personalaccesskey";
+    })[];
+    allowAutoUpdates?: boolean | undefined;
+    defaultMode?: import("../types/Files").CmsPublishMode | undefined;
+    env?: import("../types/Config").Environment | undefined;
+    httpUseLocalhost?: boolean | undefined;
+    autoOpenBrowser?: boolean | undefined;
+    useCustomObjectHubfile?: boolean | undefined;
+    flags?: string[] | undefined;
+    defaultCmsPublishMode: import("../types/Files").CmsPublishMode | undefined;
+    httpTimeout: number | undefined;
+    allowUsageTracking: boolean | undefined;
+    defaultAccount?: number | undefined;
+};
+export declare function writeConfigFile(config: HubSpotConfig, configPath: string): void;
+export declare function normalizeParsedConfig(parsedConfig: HubSpotConfig & DeprecatedHubSpotConfigFields): HubSpotConfig;
+export declare function parseConfig(configSource: string, configPath: string): HubSpotConfig;
+export declare function buildConfigFromEnvironment(): HubSpotConfig;
+export declare function getAccountIdentifierAndType(accountIdentifier: string | number): {
+    identifier: string | number;
+    identifierType: ValueOf<typeof ACCOUNT_IDENTIFIERS>;
+};
+export declare function getConfigAccountByIdentifier(accounts: Array<HubSpotConfigAccount>, identifierFieldName: ValueOf<typeof ACCOUNT_IDENTIFIERS>, identifier: string | number): HubSpotConfigAccount | undefined;
+export declare function getConfigAccountByInferredIdentifier(accounts: Array<HubSpotConfigAccount>, accountIdentifier: string | number): HubSpotConfigAccount | undefined;
+export declare function getConfigAccountIndexById(accounts: Array<HubSpotConfigAccount>, id: number): number;
+export declare function isConfigAccountValid(account: Partial<HubSpotConfigAccount>): boolean;