@hubspot/local-dev-lib 3.21.2-beta.0 → 4.0.0-beta.0

package/config/utils.js

@@ -0,0 +1,373 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleConfigFileSystemError = exports.validateConfigAccount = exports.getConfigAccountIndexById = exports.getConfigAccountByInferredIdentifier = exports.getConfigAccountByIdentifier = exports.getAccountIdentifierAndType = exports.buildConfigFromEnvironment = exports.parseConfig = exports.convertToDeprecatedConfig = exports.normalizeParsedConfig = exports.writeConfigFile = exports.formatConfigForWrite = exports.removeUndefinedFieldsFromConfigAccount = exports.readConfigFile = exports.doesConfigFileExistAtPath = exports.getConfigPathEnvironmentVariables = exports.getLocalConfigDefaultFilePath = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const config_1 = require("../constants/config");
+const auth_1 = require("../constants/auth");
+const FileSystemError_1 = require("../models/FileSystemError");
+const environment_1 = require("../lib/environment");
+const path_1 = require("../lib/path");
+const files_1 = require("../constants/files");
+const lang_1 = require("../utils/lang");
+const HubSpotConfigError_1 = require("../models/HubSpotConfigError");
+function getLocalConfigDefaultFilePath() {
+    return `${(0, path_1.getCwd)()}/${config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME}`;
+}
+exports.getLocalConfigDefaultFilePath = getLocalConfigDefaultFilePath;
+function getConfigPathEnvironmentVariables() {
+    const configFilePathFromEnvironment = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_CONFIG_PATH];
+    const useEnvironmentConfig = process.env[config_1.ENVIRONMENT_VARIABLES.USE_ENVIRONMENT_HUBSPOT_CONFIG] ===
+        'true';
+    if (configFilePathFromEnvironment && useEnvironmentConfig) {
+        throw new HubSpotConfigError_1.HubSpotConfigError((0, lang_1.i18n)('config.utils.getConfigPathEnvironmentVariables.invalidEnvironmentVariables'), config_1.HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES, config_1.HUBSPOT_CONFIG_OPERATIONS.READ);
+    }
+    return {
+        configFilePathFromEnvironment,
+        useEnvironmentConfig,
+    };
+}
+exports.getConfigPathEnvironmentVariables = getConfigPathEnvironmentVariables;
+function doesConfigFileExistAtPath(path) {
+    try {
+        return fs_extra_1.default.existsSync(path);
+    }
+    catch (error) {
+        const { message, type } = handleConfigFileSystemError(error, path);
+        throw new HubSpotConfigError_1.HubSpotConfigError(message, type, config_1.HUBSPOT_CONFIG_OPERATIONS.READ, { cause: error });
+    }
+}
+exports.doesConfigFileExistAtPath = doesConfigFileExistAtPath;
+function readConfigFile(configPath) {
+    try {
+        return fs_extra_1.default.readFileSync(configPath).toString();
+    }
+    catch (err) {
+        const { message, type } = handleConfigFileSystemError(err, configPath);
+        throw new HubSpotConfigError_1.HubSpotConfigError(message, type, config_1.HUBSPOT_CONFIG_OPERATIONS.READ, { cause: err });
+    }
+}
+exports.readConfigFile = readConfigFile;
+function removeUndefinedFieldsFromConfigAccount(account) {
+    Object.keys(account).forEach(k => {
+        const key = k;
+        if (account[key] === undefined) {
+            delete account[key];
+        }
+    });
+    if ('auth' in account && account.auth) {
+        if (account.authType === auth_1.OAUTH_AUTH_METHOD.value) {
+            Object.keys(account.auth).forEach(k => {
+                const key = k;
+                if (account.auth?.[key] === undefined) {
+                    delete account.auth?.[key];
+                }
+            });
+        }
+        if ('tokenInfo' in account.auth &&
+            typeof account.auth.tokenInfo === 'object') {
+            Object.keys(account.auth.tokenInfo).forEach(k => {
+                const key = k;
+                if (account.auth?.tokenInfo[key] === undefined) {
+                    delete account.auth?.tokenInfo[key];
+                }
+            });
+        }
+    }
+    return account;
+}
+exports.removeUndefinedFieldsFromConfigAccount = removeUndefinedFieldsFromConfigAccount;
+// Ensure written config files have fields in a consistent order
+function formatConfigForWrite(config) {
+    const { defaultAccount, defaultCmsPublishMode, httpTimeout, allowUsageTracking, accounts, ...rest } = config;
+    const orderedConfig = {
+        ...(defaultAccount && { defaultAccount }),
+        defaultCmsPublishMode,
+        httpTimeout,
+        allowUsageTracking,
+        ...rest,
+        accounts: accounts.map(account => {
+            const { name, accountId, env, authType, ...rest } = account;
+            const orderedAccount = {
+                name,
+                accountId,
+                env,
+                authType,
+                ...rest,
+                // using ...rest messes with the typing
+            };
+            return removeUndefinedFieldsFromConfigAccount(orderedAccount);
+        }),
+    };
+    return orderedConfig;
+}
+exports.formatConfigForWrite = formatConfigForWrite;
+function writeConfigFile(config, configPath) {
+    const formattedConfig = formatConfigForWrite(config);
+    const configToWrite = configPath == config_1.GLOBAL_CONFIG_PATH
+        ? formattedConfig
+        : convertToDeprecatedConfig(formattedConfig);
+    const source = js_yaml_1.default.dump(configToWrite);
+    try {
+        fs_extra_1.default.ensureFileSync(configPath);
+        fs_extra_1.default.writeFileSync(configPath, source);
+    }
+    catch (err) {
+        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+            filepath: configPath,
+            operation: 'write',
+        });
+    }
+}
+exports.writeConfigFile = writeConfigFile;
+function getAccountType(sandboxAccountType) {
+    if (sandboxAccountType) {
+        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;
+}
+function normalizeParsedConfig(parsedConfig) {
+    if (!parsedConfig.portals && !parsedConfig.accounts) {
+        parsedConfig.accounts = [];
+    }
+    if (parsedConfig.portals) {
+        parsedConfig.accounts = parsedConfig.portals.map(account => {
+            if (account.portalId) {
+                account.accountId = account.portalId;
+                delete account.portalId;
+            }
+            if (!account.accountType) {
+                account.accountType = getAccountType(account.sandboxAccountType);
+                delete account.sandboxAccountType;
+            }
+            return account;
+        });
+        delete parsedConfig.portals;
+    }
+    if (parsedConfig.defaultPortal) {
+        const defaultAccount = getConfigAccountByInferredIdentifier(parsedConfig.accounts, parsedConfig.defaultPortal);
+        if (defaultAccount) {
+            parsedConfig.defaultAccount = defaultAccount.accountId;
+        }
+        delete parsedConfig.defaultPortal;
+    }
+    if (parsedConfig.defaultMode) {
+        parsedConfig.defaultCmsPublishMode = parsedConfig.defaultMode;
+        delete parsedConfig.defaultMode;
+    }
+    return parsedConfig;
+}
+exports.normalizeParsedConfig = normalizeParsedConfig;
+function convertToDeprecatedConfig(config) {
+    const deprecatedConfig = structuredClone(config);
+    if (config.defaultAccount) {
+        const defaultAccount = getConfigAccountByIdentifier(config.accounts, config_1.ACCOUNT_IDENTIFIERS.ACCOUNT_ID, config.defaultAccount);
+        if (defaultAccount) {
+            deprecatedConfig.defaultPortal = defaultAccount.name;
+            delete deprecatedConfig.defaultAccount;
+        }
+    }
+    const portals = config.accounts.map(account => {
+        if (account.accountId) {
+            const deprecatedAccount = structuredClone(account);
+            deprecatedAccount.portalId = account.accountId;
+            // @ts-expect-error deleting accountId is intential since using deprecated config format
+            delete deprecatedAccount.accountId;
+            return deprecatedAccount;
+        }
+        return account;
+    });
+    deprecatedConfig.portals = portals;
+    delete deprecatedConfig.accounts;
+    return deprecatedConfig;
+}
+exports.convertToDeprecatedConfig = convertToDeprecatedConfig;
+function parseConfig(configSource, configPath) {
+    let parsedYaml;
+    try {
+        parsedYaml = js_yaml_1.default.load(configSource);
+    }
+    catch (err) {
+        throw new HubSpotConfigError_1.HubSpotConfigError((0, lang_1.i18n)('config.utils.parseConfig.error', { configPath: configPath }), config_1.HUBSPOT_CONFIG_ERROR_TYPES.YAML_PARSING, config_1.HUBSPOT_CONFIG_OPERATIONS.READ, { cause: err });
+    }
+    return normalizeParsedConfig(parsedYaml);
+}
+exports.parseConfig = parseConfig;
+function buildConfigFromEnvironment() {
+    const apiKey = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_API_KEY];
+    const clientId = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_CLIENT_ID];
+    const clientSecret = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_CLIENT_SECRET];
+    const personalAccessKey = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_PERSONAL_ACCESS_KEY];
+    const accountIdVar = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_ACCOUNT_ID] ||
+        process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_PORTAL_ID];
+    const refreshToken = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_REFRESH_TOKEN];
+    const hubspotEnvironment = process.env[config_1.ENVIRONMENT_VARIABLES.HUBSPOT_ENVIRONMENT];
+    const httpTimeoutVar = process.env[config_1.ENVIRONMENT_VARIABLES.HTTP_TIMEOUT];
+    const httpUseLocalhostVar = process.env[config_1.ENVIRONMENT_VARIABLES.HTTP_USE_LOCALHOST];
+    const allowUsageTrackingVar = process.env[config_1.ENVIRONMENT_VARIABLES.ALLOW_USAGE_TRACKING];
+    const defaultCmsPublishModeVar = process.env[config_1.ENVIRONMENT_VARIABLES.DEFAULT_CMS_PUBLISH_MODE];
+    if (!accountIdVar) {
+        throw new HubSpotConfigError_1.HubSpotConfigError((0, lang_1.i18n)('config.utils.buildConfigFromEnvironment.missingAccountId'), config_1.HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES, config_1.HUBSPOT_CONFIG_OPERATIONS.READ);
+    }
+    const accountId = parseInt(accountIdVar);
+    const httpTimeout = httpTimeoutVar ? parseInt(httpTimeoutVar) : undefined;
+    const httpUseLocalhost = httpUseLocalhostVar
+        ? httpUseLocalhostVar === 'true'
+        : undefined;
+    const allowUsageTracking = allowUsageTrackingVar
+        ? allowUsageTrackingVar === 'true'
+        : undefined;
+    const defaultCmsPublishMode = defaultCmsPublishModeVar === files_1.CMS_PUBLISH_MODE.draft ||
+        defaultCmsPublishModeVar === files_1.CMS_PUBLISH_MODE.publish
+        ? defaultCmsPublishModeVar
+        : undefined;
+    const env = (0, environment_1.getValidEnv)(hubspotEnvironment);
+    let account;
+    if (personalAccessKey) {
+        account = {
+            authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+            accountId,
+            personalAccessKey,
+            env,
+            name: accountIdVar,
+            auth: {
+                tokenInfo: {},
+            },
+        };
+    }
+    else if (clientId && clientSecret && refreshToken) {
+        account = {
+            authType: auth_1.OAUTH_AUTH_METHOD.value,
+            accountId,
+            auth: {
+                clientId,
+                clientSecret,
+                scopes: auth_1.OAUTH_SCOPES.map((scope) => scope.value),
+                tokenInfo: {
+                    refreshToken,
+                },
+            },
+            env,
+            name: accountIdVar,
+        };
+    }
+    else if (apiKey) {
+        account = {
+            authType: auth_1.API_KEY_AUTH_METHOD.value,
+            accountId,
+            apiKey,
+            env,
+            name: accountIdVar,
+        };
+    }
+    else {
+        throw new HubSpotConfigError_1.HubSpotConfigError((0, lang_1.i18n)('config.utils.buildConfigFromEnvironment.invalidAuthType'), config_1.HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES, config_1.HUBSPOT_CONFIG_OPERATIONS.READ);
+    }
+    return {
+        accounts: [account],
+        defaultAccount: accountId,
+        httpTimeout,
+        httpUseLocalhost,
+        allowUsageTracking,
+        defaultCmsPublishMode,
+    };
+}
+exports.buildConfigFromEnvironment = buildConfigFromEnvironment;
+function getAccountIdentifierAndType(accountIdentifier) {
+    const identifierAsNumber = typeof accountIdentifier === 'number'
+        ? accountIdentifier
+        : parseInt(accountIdentifier);
+    const isId = !isNaN(identifierAsNumber);
+    return {
+        identifier: isId ? identifierAsNumber : accountIdentifier,
+        identifierType: isId
+            ? config_1.ACCOUNT_IDENTIFIERS.ACCOUNT_ID
+            : config_1.ACCOUNT_IDENTIFIERS.NAME,
+    };
+}
+exports.getAccountIdentifierAndType = getAccountIdentifierAndType;
+function getConfigAccountByIdentifier(accounts, identifierFieldName, identifier) {
+    return accounts.find(account => account[identifierFieldName] === identifier);
+}
+exports.getConfigAccountByIdentifier = getConfigAccountByIdentifier;
+function getConfigAccountByInferredIdentifier(accounts, accountIdentifier) {
+    const { identifier, identifierType } = getAccountIdentifierAndType(accountIdentifier);
+    const account = getConfigAccountByIdentifier(accounts, identifierType, identifier);
+    if (account) {
+        return account;
+    }
+    // Fallback to handle accounts with numbers as names
+    return getConfigAccountByIdentifier(accounts, config_1.ACCOUNT_IDENTIFIERS.NAME, String(accountIdentifier));
+}
+exports.getConfigAccountByInferredIdentifier = getConfigAccountByInferredIdentifier;
+function getConfigAccountIndexById(accounts, id) {
+    return accounts.findIndex(account => account.accountId === id);
+}
+exports.getConfigAccountIndexById = getConfigAccountIndexById;
+function validateConfigAccount(account) {
+    const validationErrors = [];
+    if (!account || typeof account !== 'object') {
+        validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAccount'));
+        return { isValid: false, errors: validationErrors };
+    }
+    if (!account.accountId) {
+        validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAccountId'));
+        return { isValid: false, errors: validationErrors };
+    }
+    if (!account.authType) {
+        validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAuthType', {
+            accountId: account.accountId,
+        }));
+        return { isValid: false, errors: validationErrors };
+    }
+    if (account.authType === auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+        const isValidPersonalAccessKeyAccount = 'personalAccessKey' in account && Boolean(account.personalAccessKey);
+        if (!isValidPersonalAccessKeyAccount) {
+            validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingPersonalAccessKey', {
+                accountId: account.accountId,
+            }));
+        }
+    }
+    if (account.authType === auth_1.OAUTH_AUTH_METHOD.value) {
+        const isValidOAuthAccount = 'auth' in account && Boolean(account.auth);
+        if (!isValidOAuthAccount) {
+            validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAuth', {
+                accountId: account.accountId,
+            }));
+        }
+    }
+    if (account.authType === auth_1.API_KEY_AUTH_METHOD.value) {
+        const isValidAPIKeyAccount = 'apiKey' in account && Boolean(account.apiKey);
+        if (!isValidAPIKeyAccount) {
+            validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingApiKey', {
+                accountId: account.accountId,
+            }));
+        }
+    }
+    return { isValid: validationErrors.length === 0, errors: validationErrors };
+}
+exports.validateConfigAccount = validateConfigAccount;
+function handleConfigFileSystemError(error, path) {
+    let message;
+    let type = config_1.HUBSPOT_CONFIG_ERROR_TYPES.UNKNOWN;
+    if (error instanceof Error && 'code' in error) {
+        if (error.code === 'ENOENT') {
+            message = (0, lang_1.i18n)('config.utils.handleConfigFileSystemError.configNotFoundError', { path });
+            type = config_1.HUBSPOT_CONFIG_ERROR_TYPES.CONFIG_NOT_FOUND;
+        }
+        else if (error.code === 'EACCES') {
+            message = (0, lang_1.i18n)('config.utils.handleConfigFileSystemError.insufficientPermissionsError', { path });
+            type = config_1.HUBSPOT_CONFIG_ERROR_TYPES.INSUFFICIENT_PERMISSIONS;
+        }
+    }
+    return { message, type };
+}
+exports.handleConfigFileSystemError = handleConfigFileSystemError;

package/constants/config.d.ts

@@ -33,3 +33,43 @@ export declare const HUBSPOT_ACCOUNT_TYPE_STRINGS: {
     readonly APP_DEVELOPER: string;
     readonly STANDARD: string;
 };
+export declare const CONFIG_FLAGS: {
+    readonly USE_CUSTOM_OBJECT_HUBFILE: "useCustomObjectHubfile";
+    readonly HTTP_USE_LOCALHOST: "httpUseLocalhost";
+};
+export declare const ENVIRONMENT_VARIABLES: {
+    readonly HUBSPOT_API_KEY: "HUBSPOT_API_KEY";
+    readonly HUBSPOT_CLIENT_ID: "HUBSPOT_CLIENT_ID";
+    readonly HUBSPOT_CLIENT_SECRET: "HUBSPOT_CLIENT_SECRET";
+    readonly HUBSPOT_PERSONAL_ACCESS_KEY: "HUBSPOT_PERSONAL_ACCESS_KEY";
+    readonly HUBSPOT_ACCOUNT_ID: "HUBSPOT_ACCOUNT_ID";
+    readonly HUBSPOT_PORTAL_ID: "HUBSPOT_PORTAL_ID";
+    readonly HUBSPOT_REFRESH_TOKEN: "HUBSPOT_REFRESH_TOKEN";
+    readonly HUBSPOT_ENVIRONMENT: "HUBSPOT_ENVIRONMENT";
+    readonly HTTP_TIMEOUT: "HTTP_TIMEOUT";
+    readonly HTTP_USE_LOCALHOST: "HTTP_USE_LOCALHOST";
+    readonly ALLOW_USAGE_TRACKING: "ALLOW_USAGE_TRACKING";
+    readonly DEFAULT_CMS_PUBLISH_MODE: "DEFUALT_CMS_PUBLISH_MODE";
+    readonly USE_ENVIRONMENT_HUBSPOT_CONFIG: "USE_ENVIRONMENT_HUBSPOT_CONFIG";
+    readonly HUBSPOT_CONFIG_PATH: "HUBSPOT_CONFIG_PATH";
+};
+export declare const ACCOUNT_IDENTIFIERS: {
+    readonly ACCOUNT_ID: "accountId";
+    readonly NAME: "name";
+};
+export declare const HUBSPOT_CONFIG_ERROR_TYPES: {
+    readonly CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND";
+    readonly INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS";
+    readonly ACCOUNT_NOT_FOUND: "ACCOUNT_NOT_FOUND";
+    readonly NO_DEFAULT_ACCOUNT: "NO_DEFAULT_ACCOUNT";
+    readonly INVALID_ENVIRONMENT_VARIABLES: "ENVIRONMENT_VARIABLES";
+    readonly YAML_PARSING: "YAML_PARSING";
+    readonly INVALID_ACCOUNT: "INVALID_ACCOUNT";
+    readonly INVALID_FIELD: "INVALID_FIELD";
+    readonly UNKNOWN: "UNKNOWN";
+};
+export declare const HUBSPOT_CONFIG_OPERATIONS: {
+    readonly READ: "READ";
+    readonly WRITE: "WRITE";
+    readonly DELETE: "DELETE";
+};

package/constants/config.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HUBSPOT_ACCOUNT_TYPE_STRINGS = exports.HUBSPOT_ACCOUNT_TYPES = exports.MCP_TOTAL_TOOL_CALLS_STATE = exports.MIN_HTTP_TIMEOUT = exports.DEFAULT_PORTAL = exports.DEFAULT_ACCOUNT = exports.ALLOW_AUTO_UPDATES = exports.AUTO_OPEN_BROWSER = exports.ALLOW_USAGE_TRACKING = exports.HTTP_USE_LOCALHOST = exports.ENV = exports.HTTP_TIMEOUT = exports.DEFAULT_CMS_PUBLISH_MODE = exports.DEFAULT_ACCOUNT_OVERRIDE_ERROR_ACCOUNT_NOT_FOUND = exports.DEFAULT_ACCOUNT_OVERRIDE_ERROR_INVALID_ID = exports.DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME = exports.STATE_FILE_PATH = exports.GLOBAL_CONFIG_PATH = exports.HUBSPOT_STATE_FILE = exports.HUBSPOT_CONFIGURATION_FILE = exports.HUBSPOT_CONFIGURATION_FOLDER = exports.ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME = exports.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME = void 0;
+exports.HUBSPOT_CONFIG_OPERATIONS = exports.HUBSPOT_CONFIG_ERROR_TYPES = exports.ACCOUNT_IDENTIFIERS = exports.ENVIRONMENT_VARIABLES = exports.CONFIG_FLAGS = exports.HUBSPOT_ACCOUNT_TYPE_STRINGS = exports.HUBSPOT_ACCOUNT_TYPES = exports.MCP_TOTAL_TOOL_CALLS_STATE = exports.MIN_HTTP_TIMEOUT = exports.DEFAULT_PORTAL = exports.DEFAULT_ACCOUNT = exports.ALLOW_AUTO_UPDATES = exports.AUTO_OPEN_BROWSER = exports.ALLOW_USAGE_TRACKING = exports.HTTP_USE_LOCALHOST = exports.ENV = exports.HTTP_TIMEOUT = exports.DEFAULT_CMS_PUBLISH_MODE = exports.DEFAULT_ACCOUNT_OVERRIDE_ERROR_ACCOUNT_NOT_FOUND = exports.DEFAULT_ACCOUNT_OVERRIDE_ERROR_INVALID_ID = exports.DEFAULT_ACCOUNT_OVERRIDE_FILE_NAME = exports.STATE_FILE_PATH = exports.GLOBAL_CONFIG_PATH = exports.HUBSPOT_STATE_FILE = exports.HUBSPOT_CONFIGURATION_FILE = exports.HUBSPOT_CONFIGURATION_FOLDER = exports.ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME = exports.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME = void 0;
 const lang_1 = require("../utils/lang");
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
@@ -42,3 +42,43 @@ exports.HUBSPOT_ACCOUNT_TYPE_STRINGS = {
     APP_DEVELOPER: (0, lang_1.i18n)('lib.accountTypes.appDeveloper'),
     STANDARD: (0, lang_1.i18n)('lib.accountTypes.standard'),
 };
+exports.CONFIG_FLAGS = {
+    USE_CUSTOM_OBJECT_HUBFILE: 'useCustomObjectHubfile',
+    HTTP_USE_LOCALHOST: 'httpUseLocalhost',
+};
+exports.ENVIRONMENT_VARIABLES = {
+    HUBSPOT_API_KEY: 'HUBSPOT_API_KEY',
+    HUBSPOT_CLIENT_ID: 'HUBSPOT_CLIENT_ID',
+    HUBSPOT_CLIENT_SECRET: 'HUBSPOT_CLIENT_SECRET',
+    HUBSPOT_PERSONAL_ACCESS_KEY: 'HUBSPOT_PERSONAL_ACCESS_KEY',
+    HUBSPOT_ACCOUNT_ID: 'HUBSPOT_ACCOUNT_ID',
+    HUBSPOT_PORTAL_ID: 'HUBSPOT_PORTAL_ID',
+    HUBSPOT_REFRESH_TOKEN: 'HUBSPOT_REFRESH_TOKEN',
+    HUBSPOT_ENVIRONMENT: 'HUBSPOT_ENVIRONMENT',
+    HTTP_TIMEOUT: 'HTTP_TIMEOUT',
+    HTTP_USE_LOCALHOST: 'HTTP_USE_LOCALHOST',
+    ALLOW_USAGE_TRACKING: 'ALLOW_USAGE_TRACKING',
+    DEFAULT_CMS_PUBLISH_MODE: 'DEFUALT_CMS_PUBLISH_MODE',
+    USE_ENVIRONMENT_HUBSPOT_CONFIG: 'USE_ENVIRONMENT_HUBSPOT_CONFIG',
+    HUBSPOT_CONFIG_PATH: 'HUBSPOT_CONFIG_PATH',
+};
+exports.ACCOUNT_IDENTIFIERS = {
+    ACCOUNT_ID: 'accountId',
+    NAME: 'name',
+};
+exports.HUBSPOT_CONFIG_ERROR_TYPES = {
+    CONFIG_NOT_FOUND: 'CONFIG_NOT_FOUND',
+    INSUFFICIENT_PERMISSIONS: 'INSUFFICIENT_PERMISSIONS',
+    ACCOUNT_NOT_FOUND: 'ACCOUNT_NOT_FOUND',
+    NO_DEFAULT_ACCOUNT: 'NO_DEFAULT_ACCOUNT',
+    INVALID_ENVIRONMENT_VARIABLES: 'ENVIRONMENT_VARIABLES',
+    YAML_PARSING: 'YAML_PARSING',
+    INVALID_ACCOUNT: 'INVALID_ACCOUNT',
+    INVALID_FIELD: 'INVALID_FIELD',
+    UNKNOWN: 'UNKNOWN',
+};
+exports.HUBSPOT_CONFIG_OPERATIONS = {
+    READ: 'READ',
+    WRITE: 'WRITE',
+    DELETE: 'DELETE',
+};

package/constants/environments.d.ts

@@ -2,14 +2,3 @@ export declare const ENVIRONMENTS: {
     readonly PROD: "prod";
     readonly QA: "qa";
 };
-export declare const ENVIRONMENT_VARIABLES: {
-    readonly HUBSPOT_API_KEY: "HUBSPOT_API_KEY";
-    readonly HUBSPOT_CLIENT_ID: "HUBSPOT_CLIENT_ID";
-    readonly HUBSPOT_CLIENT_SECRET: "HUBSPOT_CLIENT_SECRET";
-    readonly HUBSPOT_PERSONAL_ACCESS_KEY: "HUBSPOT_PERSONAL_ACCESS_KEY";
-    readonly HUBSPOT_ACCOUNT_ID: "HUBSPOT_ACCOUNT_ID";
-    readonly HUBSPOT_PORTAL_ID: "HUBSPOT_PORTAL_ID";
-    readonly HUBSPOT_REFRESH_TOKEN: "HUBSPOT_REFRESH_TOKEN";
-    readonly HUBSPOT_ENVIRONMENT: "HUBSPOT_ENVIRONMENT";
-    readonly HTTP_TIMEOUT: "HTTP_TIMEOUT";
-};

package/constants/environments.js

@@ -1,18 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENVIRONMENT_VARIABLES = exports.ENVIRONMENTS = void 0;
+exports.ENVIRONMENTS = void 0;
 exports.ENVIRONMENTS = {
     PROD: 'prod',
     QA: 'qa',
 };
-exports.ENVIRONMENT_VARIABLES = {
-    HUBSPOT_API_KEY: 'HUBSPOT_API_KEY',
-    HUBSPOT_CLIENT_ID: 'HUBSPOT_CLIENT_ID',
-    HUBSPOT_CLIENT_SECRET: 'HUBSPOT_CLIENT_SECRET',
-    HUBSPOT_PERSONAL_ACCESS_KEY: 'HUBSPOT_PERSONAL_ACCESS_KEY',
-    HUBSPOT_ACCOUNT_ID: 'HUBSPOT_ACCOUNT_ID',
-    HUBSPOT_PORTAL_ID: 'HUBSPOT_PORTAL_ID',
-    HUBSPOT_REFRESH_TOKEN: 'HUBSPOT_REFRESH_TOKEN',
-    HUBSPOT_ENVIRONMENT: 'HUBSPOT_ENVIRONMENT',
-    HTTP_TIMEOUT: 'HTTP_TIMEOUT',
-};

package/errors/index.d.ts

@@ -1,6 +1,7 @@
 import { HubSpotHttpError } from '../models/HubSpotHttpError';
 import { BaseError } from '../types/Error';
 import { FileSystemError } from '../models/FileSystemError';
+import { HubSpotConfigError } from '../models/HubSpotConfigError';
 export declare function isSpecifiedError(err: unknown, { statusCode, category, subCategory, errorType, code, }: {
     statusCode?: number;
     category?: string;
@@ -17,3 +18,4 @@ export declare function isHubSpotHttpError(error?: unknown): error is HubSpotHtt
 export declare function isGithubRateLimitError(err: unknown): boolean;
 export declare function isSystemError(err: unknown): err is BaseError;
 export declare function isFileSystemError(err: unknown): err is FileSystemError;
+export declare function isHubSpotConfigError(err: unknown): err is HubSpotConfigError;

package/errors/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFileSystemError = exports.isSystemError = exports.isGithubRateLimitError = exports.isHubSpotHttpError = exports.isValidationError = exports.isAuthError = exports.isTimeoutError = exports.isGatingError = exports.isMissingScopeError = exports.isSpecifiedError = void 0;
+exports.isHubSpotConfigError = exports.isFileSystemError = exports.isSystemError = exports.isGithubRateLimitError = exports.isHubSpotHttpError = exports.isValidationError = exports.isAuthError = exports.isTimeoutError = exports.isGatingError = exports.isMissingScopeError = exports.isSpecifiedError = void 0;
 const HubSpotHttpError_1 = require("../models/HubSpotHttpError");
 const FileSystemError_1 = require("../models/FileSystemError");
+const HubSpotConfigError_1 = require("../models/HubSpotConfigError");
 function isSpecifiedError(err, { statusCode, category, subCategory, errorType, code, }) {
     if (!isHubSpotHttpError(err)) {
         return false;
@@ -70,3 +71,7 @@ function isFileSystemError(err) {
     return err instanceof FileSystemError_1.FileSystemError;
 }
 exports.isFileSystemError = isFileSystemError;
+function isHubSpotConfigError(err) {
+    return err instanceof HubSpotConfigError_1.HubSpotConfigError;
+}
+exports.isHubSpotConfigError = isHubSpotConfigError;

package/http/getAxiosConfig.js

@@ -41,7 +41,13 @@ const DEFAULT_TRANSITIONAL = {
 };
 function getAxiosConfig(options) {
     const { env, localHostOverride, headers, ...rest } = options;
-    const config = (0, config_1.getAndLoadConfigIfNeeded)();
+    let config;
+    try {
+        config = (0, config_1.getConfig)();
+    }
+    catch (e) {
+        config = null;
+    }
     let httpTimeout = 15000;
     let httpUseLocalhost = false;
     if (config && config.httpTimeout) {

package/http/index.js

@@ -39,6 +39,7 @@ const oauth_1 = require("../lib/oauth");
 const logger_1 = require("../lib/logger");
 const lang_1 = require("../utils/lang");
 const HubSpotHttpError_1 = require("../models/HubSpotHttpError");
+const auth_1 = require("../constants/auth");
 const localDevAuth_1 = require("../api/localDevAuth");
 const util = __importStar(require("util"));
 const trackUsage_1 = require("../lib/trackUsage");
@@ -89,11 +90,11 @@ function addUserAgentHeader(key, value) {
     getAxiosConfig_1.USER_AGENTS[key] = value;
 }
 exports.addUserAgentHeader = addUserAgentHeader;
-async function withOauth(accountId, accountConfig, axiosConfig) {
+async function withOauth(account, axiosConfig) {
     const { headers } = axiosConfig;
-    const oauth = (0, oauth_1.getOauthManager)(accountId, accountConfig);
+    const oauth = (0, oauth_1.getOauthManager)(account);
     if (!oauth) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.withOauth`, { accountId }));
+        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.withOauth`, { accountId: account.accountId }));
     }
     const accessToken = await oauth.accessToken();
     return {
@@ -126,26 +127,29 @@ function withPortalId(portalId, axiosConfig) {
     };
 }
 async function withAuth(accountId, options) {
-    const accountConfig = (0, config_1.getAccountConfig)(accountId);
-    if (!accountConfig) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.withAuth`, { accountId }));
-    }
-    const { env, authType, apiKey } = accountConfig;
+    const account = (0, config_1.getConfigAccountById)(accountId);
+    const { env, authType } = account;
     const axiosConfig = withPortalId(accountId, (0, getAxiosConfig_1.getAxiosConfig)({ env, ...options }));
-    if (authType === 'personalaccesskey') {
+    if (authType === auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
         return withPersonalAccessKey(accountId, axiosConfig);
     }
-    if (authType === 'oauth2') {
-        return withOauth(accountId, accountConfig, axiosConfig);
+    if (authType === auth_1.OAUTH_AUTH_METHOD.value) {
+        return withOauth(account, axiosConfig);
     }
-    const { params } = axiosConfig;
-    return {
-        ...axiosConfig,
-        params: {
-            ...params,
-            hapikey: apiKey,
-        },
-    };
+    if (authType === auth_1.API_KEY_AUTH_METHOD.value) {
+        const { params } = axiosConfig;
+        return {
+            ...axiosConfig,
+            params: {
+                ...params,
+                hapikey: account.apiKey,
+            },
+        };
+    }
+    throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.invalidAuthType`, {
+        accountId,
+        authType,
+    }));
 }
 async function getRequest(accountId, options) {
     const { params, ...rest } = options;