@hubspot/local-dev-lib 4.0.4 → 5.0.0-beta.1

package/config/migrate.js

@@ -1,26 +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.archiveConfigAtPath = exports.mergeConfigAccounts = exports.mergeConfigProperties = exports.migrateConfigAtPath = exports.getConfigAtPath = void 0;
-const fs_1 = __importDefault(require("fs"));
-const index_1 = require("./index");
-const config_1 = require("../constants/config");
-const utils_1 = require("./utils");
-const path_1 = __importDefault(require("path"));
-function getConfigAtPath(path) {
-    const configFileSource = (0, utils_1.readConfigFile)(path);
-    return (0, utils_1.parseConfig)(configFileSource, path);
+import fs from 'fs';
+import { createEmptyConfigFile, getGlobalConfigFilePath } from './index.js';
+import { ENV, DEFAULT_ACCOUNT, ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME, CONFIG_FLAGS, } from '../constants/config.js';
+import { parseConfig, readConfigFile, writeConfigFile } from './utils.js';
+import path from 'path';
+export function getConfigAtPath(path) {
+    const configFileSource = readConfigFile(path);
+    return parseConfig(configFileSource, path);
 }
-exports.getConfigAtPath = getConfigAtPath;
-function migrateConfigAtPath(path) {
-    (0, index_1.createEmptyConfigFile)(true);
+export function migrateConfigAtPath(path) {
+    createEmptyConfigFile(true);
     const configToMigrate = getConfigAtPath(path);
-    (0, utils_1.writeConfigFile)(configToMigrate, (0, index_1.getGlobalConfigFilePath)());
+    writeConfigFile(configToMigrate, getGlobalConfigFilePath());
 }
-exports.migrateConfigAtPath = migrateConfigAtPath;
-function mergeConfigProperties(toConfig, fromConfig, force) {
+export function mergeConfigProperties(toConfig, fromConfig, force) {
     const conflicts = [];
     if (force) {
         toConfig.defaultCmsPublishMode = fromConfig.defaultCmsPublishMode;
@@ -54,14 +46,14 @@ function mergeConfigProperties(toConfig, fromConfig, force) {
                 : toConfig.allowAutoUpdates;
         toConfig.defaultAccount ||= fromConfig.defaultAccount;
         const propertiesToCheck = [
-            config_1.CONFIG_FLAGS.DEFAULT_CMS_PUBLISH_MODE,
-            config_1.CONFIG_FLAGS.HTTP_TIMEOUT,
-            config_1.CONFIG_FLAGS.HTTP_USE_LOCALHOST,
-            config_1.CONFIG_FLAGS.ALLOW_USAGE_TRACKING,
-            config_1.CONFIG_FLAGS.AUTO_OPEN_BROWSER,
-            config_1.CONFIG_FLAGS.ALLOW_AUTO_UPDATES,
-            config_1.ENV,
-            config_1.DEFAULT_ACCOUNT,
+            CONFIG_FLAGS.DEFAULT_CMS_PUBLISH_MODE,
+            CONFIG_FLAGS.HTTP_TIMEOUT,
+            CONFIG_FLAGS.HTTP_USE_LOCALHOST,
+            CONFIG_FLAGS.ALLOW_USAGE_TRACKING,
+            CONFIG_FLAGS.AUTO_OPEN_BROWSER,
+            CONFIG_FLAGS.ALLOW_AUTO_UPDATES,
+            ENV,
+            DEFAULT_ACCOUNT,
         ];
         propertiesToCheck.forEach(prop => {
             if (toConfig[prop] !== undefined &&
@@ -81,7 +73,6 @@ function mergeConfigProperties(toConfig, fromConfig, force) {
     }
     return { configWithMergedProperties: toConfig, conflicts };
 }
-exports.mergeConfigProperties = mergeConfigProperties;
 function buildConfigWithMergedAccounts(toConfig, fromConfig) {
     const existingAccountIds = toConfig.accounts.map(({ accountId }) => accountId);
     const skippedAccountIds = [];
@@ -98,15 +89,13 @@ function buildConfigWithMergedAccounts(toConfig, fromConfig) {
         skippedAccountIds,
     };
 }
-function mergeConfigAccounts(toConfig, fromConfig) {
+export function mergeConfigAccounts(toConfig, fromConfig) {
     const { configWithMergedAccounts, skippedAccountIds } = buildConfigWithMergedAccounts(toConfig, fromConfig);
-    (0, utils_1.writeConfigFile)(configWithMergedAccounts, (0, index_1.getGlobalConfigFilePath)());
+    writeConfigFile(configWithMergedAccounts, getGlobalConfigFilePath());
     return { configWithMergedAccounts, skippedAccountIds };
 }
-exports.mergeConfigAccounts = mergeConfigAccounts;
-function archiveConfigAtPath(configPath) {
-    const dir = path_1.default.dirname(configPath);
-    const archivedConfigPath = path_1.default.join(dir, config_1.ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME);
-    fs_1.default.renameSync(configPath, archivedConfigPath);
+export function archiveConfigAtPath(configPath) {
+    const dir = path.dirname(configPath);
+    const archivedConfigPath = path.join(dir, ARCHIVED_HUBSPOT_CONFIG_YAML_FILE_NAME);
+    fs.renameSync(configPath, archivedConfigPath);
 }
-exports.archiveConfigAtPath = archiveConfigAtPath;

package/config/state.d.ts

@@ -1,3 +1,3 @@
-import { HubSpotState } from '../types/Config';
+import { HubSpotState } from '../types/Config.js';
 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;

package/config/state.js

@@ -1,48 +1,22 @@
-"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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setStateValue = exports.getStateValue = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const lang_1 = require("../utils/lang");
-const config_1 = require("../constants/config");
-const logger_1 = require("../lib/logger");
-const config_2 = require("../constants/config");
+import * as fs from 'fs';
+import * as path from 'path';
+import { i18n } from '../utils/lang.js';
+import { STATE_FILE_PATH } from '../constants/config.js';
+import { logger } from '../lib/logger.js';
+import { STATE_FLAGS } from '../constants/config.js';
 const i18nKey = 'config.state';
 const DEFAULT_STATE = {
-    [config_2.STATE_FLAGS.MCP_TOTAL_TOOL_CALLS]: 0,
+    [STATE_FLAGS.MCP_TOTAL_TOOL_CALLS]: 0,
 };
 function ensureCLIDirectory() {
     try {
-        const dir = path.dirname(config_1.STATE_FILE_PATH);
+        const dir = path.dirname(STATE_FILE_PATH);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
     }
     catch (error) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.ensureCLIDirectory.errors.cannotCreateDirectory`, {
+        throw new Error(i18n(`${i18nKey}.ensureCLIDirectory.errors.cannotCreateDirectory`, {
             error: error instanceof Error ? error.message : String(error),
         }));
     }
@@ -65,41 +39,39 @@ function sanitizeAndMerge(parsed) {
 }
 function getCurrentState() {
     try {
-        if (!fs.existsSync(config_1.STATE_FILE_PATH)) {
+        if (!fs.existsSync(STATE_FILE_PATH)) {
             return structuredClone(DEFAULT_STATE);
         }
-        const data = fs.readFileSync(config_1.STATE_FILE_PATH, 'utf-8');
+        const data = fs.readFileSync(STATE_FILE_PATH, 'utf-8');
         if (!data?.trim()) {
-            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.getCurrentState.debug.emptyStateFile`));
+            logger.debug(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`, {
+        logger.debug(i18n(`${i18nKey}.getCurrentState.errors.errorReading`, {
             error: error instanceof Error ? error.message : String(error),
         }));
         return structuredClone(DEFAULT_STATE);
     }
 }
-function getStateValue(key) {
+export function getStateValue(key) {
     ensureCLIDirectory();
     const state = getCurrentState();
     return state[key];
 }
-exports.getStateValue = getStateValue;
-function setStateValue(key, value) {
+export function setStateValue(key, value) {
     ensureCLIDirectory();
     const currentState = getCurrentState();
     const newState = { ...currentState, [key]: value };
     try {
-        fs.writeFileSync(config_1.STATE_FILE_PATH, JSON.stringify(newState, null, 2), 'utf-8');
+        fs.writeFileSync(STATE_FILE_PATH, JSON.stringify(newState, null, 2), 'utf-8');
     }
     catch (error) {
-        throw new Error((0, lang_1.i18n)(`${i18nKey}.setStateValue.errors.failedToWrite`, {
+        throw new Error(i18n(`${i18nKey}.setStateValue.errors.failedToWrite`, {
             error: error instanceof Error ? error.message : String(error),
         }));
     }
 }
-exports.setStateValue = setStateValue;

package/config/utils.d.ts

@@ -1,7 +1,7 @@
-import { ACCOUNT_IDENTIFIERS } from '../constants/config';
-import { HubSpotConfig, DeprecatedHubSpotConfigFields, HubSpotConfigErrorType, HubSpotConfigValidationResult } from '../types/Config';
-import { HubSpotConfigAccount } from '../types/Accounts';
-import { ValueOf } from '../types/Utils';
+import { ACCOUNT_IDENTIFIERS } from '../constants/config.js';
+import { HubSpotConfig, DeprecatedHubSpotConfigFields, HubSpotConfigErrorType, HubSpotConfigValidationResult } from '../types/Config.js';
+import { HubSpotConfigAccount } from '../types/Accounts.js';
+import { ValueOf } from '../types/Utils.js';
 export declare function getLocalConfigDefaultFilePath(): string;
 export declare function getConfigPathEnvironmentVariables(): {
     useEnvironmentConfig: boolean;

package/config/utils.js

@@ -1,57 +1,47 @@
-"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}`;
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import { HUBSPOT_ACCOUNT_TYPES, DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME, ENVIRONMENT_VARIABLES, ACCOUNT_IDENTIFIERS, HUBSPOT_CONFIG_ERROR_TYPES, HUBSPOT_CONFIG_OPERATIONS, GLOBAL_CONFIG_PATH, } from '../constants/config.js';
+import { PERSONAL_ACCESS_KEY_AUTH_METHOD, API_KEY_AUTH_METHOD, OAUTH_AUTH_METHOD, OAUTH_SCOPES, } from '../constants/auth.js';
+import { FileSystemError } from '../models/FileSystemError.js';
+import { getValidEnv } from '../lib/environment.js';
+import { getCwd } from '../lib/path.js';
+import { CMS_PUBLISH_MODE } from '../constants/files.js';
+import { i18n } from '../utils/lang.js';
+import { HubSpotConfigError } from '../models/HubSpotConfigError.js';
+export function getLocalConfigDefaultFilePath() {
+    return `${getCwd()}/${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] ===
+export function getConfigPathEnvironmentVariables() {
+    const configFilePathFromEnvironment = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_CONFIG_PATH];
+    const useEnvironmentConfig = process.env[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);
+        throw new HubSpotConfigError(i18n('config.utils.getConfigPathEnvironmentVariables.invalidEnvironmentVariables'), HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES, HUBSPOT_CONFIG_OPERATIONS.READ);
     }
     return {
         configFilePathFromEnvironment,
         useEnvironmentConfig,
     };
 }
-exports.getConfigPathEnvironmentVariables = getConfigPathEnvironmentVariables;
-function doesConfigFileExistAtPath(path) {
+export function doesConfigFileExistAtPath(path) {
     try {
-        return fs_extra_1.default.existsSync(path);
+        return fs.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 });
+        throw new HubSpotConfigError(message, type, HUBSPOT_CONFIG_OPERATIONS.READ, { cause: error });
     }
 }
-exports.doesConfigFileExistAtPath = doesConfigFileExistAtPath;
-function readConfigFile(configPath) {
+export function readConfigFile(configPath) {
     try {
-        return fs_extra_1.default.readFileSync(configPath).toString();
+        return fs.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 });
+        throw new HubSpotConfigError(message, type, HUBSPOT_CONFIG_OPERATIONS.READ, { cause: err });
     }
 }
-exports.readConfigFile = readConfigFile;
-function removeUndefinedFieldsFromConfigAccount(account) {
+export function removeUndefinedFieldsFromConfigAccount(account) {
     Object.keys(account).forEach(k => {
         const key = k;
         if (account[key] === undefined) {
@@ -59,7 +49,7 @@ function removeUndefinedFieldsFromConfigAccount(account) {
         }
     });
     if ('auth' in account && account.auth) {
-        if (account.authType === auth_1.OAUTH_AUTH_METHOD.value) {
+        if (account.authType === OAUTH_AUTH_METHOD.value) {
             Object.keys(account.auth).forEach(k => {
                 const key = k;
                 if (account.auth?.[key] === undefined) {
@@ -79,9 +69,8 @@ function removeUndefinedFieldsFromConfigAccount(account) {
     }
     return account;
 }
-exports.removeUndefinedFieldsFromConfigAccount = removeUndefinedFieldsFromConfigAccount;
 // Ensure written config files have fields in a consistent order
-function formatConfigForWrite(config) {
+export function formatConfigForWrite(config) {
     const { defaultAccount, defaultCmsPublishMode, httpTimeout, allowUsageTracking, accounts, ...rest } = config;
     const orderedConfig = {
         ...(defaultAccount && { defaultAccount }),
@@ -104,37 +93,35 @@ function formatConfigForWrite(config) {
     };
     return orderedConfig;
 }
-exports.formatConfigForWrite = formatConfigForWrite;
-function writeConfigFile(config, configPath) {
+export function writeConfigFile(config, configPath) {
     const formattedConfig = formatConfigForWrite(config);
-    const configToWrite = configPath == config_1.GLOBAL_CONFIG_PATH
+    const configToWrite = configPath == GLOBAL_CONFIG_PATH
         ? formattedConfig
         : convertToDeprecatedConfig(formattedConfig);
-    const source = js_yaml_1.default.dump(configToWrite);
+    const source = yaml.dump(configToWrite);
     try {
-        fs_extra_1.default.ensureFileSync(configPath);
-        fs_extra_1.default.writeFileSync(configPath, source);
+        fs.ensureFileSync(configPath);
+        fs.writeFileSync(configPath, source);
     }
     catch (err) {
-        throw new FileSystemError_1.FileSystemError({ cause: err }, {
+        throw new 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;
+            return HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX;
         }
         if (sandboxAccountType.toUpperCase() === 'STANDARD') {
-            return config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
+            return HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
         }
     }
-    return config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD;
+    return HUBSPOT_ACCOUNT_TYPES.STANDARD;
 }
-function normalizeParsedConfig(parsedConfig) {
+export function normalizeParsedConfig(parsedConfig) {
     if (!parsedConfig.portals && !parsedConfig.accounts) {
         parsedConfig.accounts = [];
     }
@@ -165,11 +152,10 @@ function normalizeParsedConfig(parsedConfig) {
     }
     return parsedConfig;
 }
-exports.normalizeParsedConfig = normalizeParsedConfig;
-function convertToDeprecatedConfig(config) {
+export function convertToDeprecatedConfig(config) {
     const deprecatedConfig = structuredClone(config);
     if (config.defaultAccount) {
-        const defaultAccount = getConfigAccountByIdentifier(config.accounts, config_1.ACCOUNT_IDENTIFIERS.ACCOUNT_ID, config.defaultAccount);
+        const defaultAccount = getConfigAccountByIdentifier(config.accounts, ACCOUNT_IDENTIFIERS.ACCOUNT_ID, config.defaultAccount);
         if (defaultAccount) {
             deprecatedConfig.defaultPortal = defaultAccount.name;
             delete deprecatedConfig.defaultAccount;
@@ -189,33 +175,31 @@ function convertToDeprecatedConfig(config) {
     delete deprecatedConfig.accounts;
     return deprecatedConfig;
 }
-exports.convertToDeprecatedConfig = convertToDeprecatedConfig;
-function parseConfig(configSource, configPath) {
+export function parseConfig(configSource, configPath) {
     let parsedYaml;
     try {
-        parsedYaml = js_yaml_1.default.load(configSource);
+        parsedYaml = yaml.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 });
+        throw new HubSpotConfigError(i18n('config.utils.parseConfig.error', { configPath: configPath }), HUBSPOT_CONFIG_ERROR_TYPES.YAML_PARSING, 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];
+export function buildConfigFromEnvironment() {
+    const apiKey = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_API_KEY];
+    const clientId = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_CLIENT_ID];
+    const clientSecret = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_CLIENT_SECRET];
+    const personalAccessKey = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_PERSONAL_ACCESS_KEY];
+    const accountIdVar = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_ACCOUNT_ID] ||
+        process.env[ENVIRONMENT_VARIABLES.HUBSPOT_PORTAL_ID];
+    const refreshToken = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_REFRESH_TOKEN];
+    const hubspotEnvironment = process.env[ENVIRONMENT_VARIABLES.HUBSPOT_ENVIRONMENT];
+    const httpTimeoutVar = process.env[ENVIRONMENT_VARIABLES.HTTP_TIMEOUT];
+    const httpUseLocalhostVar = process.env[ENVIRONMENT_VARIABLES.HTTP_USE_LOCALHOST];
+    const allowUsageTrackingVar = process.env[ENVIRONMENT_VARIABLES.ALLOW_USAGE_TRACKING];
+    const defaultCmsPublishModeVar = process.env[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);
+        throw new HubSpotConfigError(i18n('config.utils.buildConfigFromEnvironment.missingAccountId'), HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES, HUBSPOT_CONFIG_OPERATIONS.READ);
     }
     const accountId = parseInt(accountIdVar);
     const httpTimeout = httpTimeoutVar ? parseInt(httpTimeoutVar) : undefined;
@@ -225,15 +209,15 @@ function buildConfigFromEnvironment() {
     const allowUsageTracking = allowUsageTrackingVar
         ? allowUsageTrackingVar === 'true'
         : undefined;
-    const defaultCmsPublishMode = defaultCmsPublishModeVar === files_1.CMS_PUBLISH_MODE.draft ||
-        defaultCmsPublishModeVar === files_1.CMS_PUBLISH_MODE.publish
+    const defaultCmsPublishMode = defaultCmsPublishModeVar === CMS_PUBLISH_MODE.draft ||
+        defaultCmsPublishModeVar === CMS_PUBLISH_MODE.publish
         ? defaultCmsPublishModeVar
         : undefined;
-    const env = (0, environment_1.getValidEnv)(hubspotEnvironment);
+    const env = getValidEnv(hubspotEnvironment);
     let account;
     if (personalAccessKey) {
         account = {
-            authType: auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
+            authType: PERSONAL_ACCESS_KEY_AUTH_METHOD.value,
             accountId,
             personalAccessKey,
             env,
@@ -245,12 +229,12 @@ function buildConfigFromEnvironment() {
     }
     else if (clientId && clientSecret && refreshToken) {
         account = {
-            authType: auth_1.OAUTH_AUTH_METHOD.value,
+            authType: OAUTH_AUTH_METHOD.value,
             accountId,
             auth: {
                 clientId,
                 clientSecret,
-                scopes: auth_1.OAUTH_SCOPES.map((scope) => scope.value),
+                scopes: OAUTH_SCOPES.map((scope) => scope.value),
                 tokenInfo: {
                     refreshToken,
                 },
@@ -261,7 +245,7 @@ function buildConfigFromEnvironment() {
     }
     else if (apiKey) {
         account = {
-            authType: auth_1.API_KEY_AUTH_METHOD.value,
+            authType: API_KEY_AUTH_METHOD.value,
             accountId,
             apiKey,
             env,
@@ -269,7 +253,7 @@ function buildConfigFromEnvironment() {
         };
     }
     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);
+        throw new HubSpotConfigError(i18n('config.utils.buildConfigFromEnvironment.invalidAuthType'), HUBSPOT_CONFIG_ERROR_TYPES.INVALID_ENVIRONMENT_VARIABLES, HUBSPOT_CONFIG_OPERATIONS.READ);
     }
     return {
         accounts: [account],
@@ -280,8 +264,7 @@ function buildConfigFromEnvironment() {
         defaultCmsPublishMode,
     };
 }
-exports.buildConfigFromEnvironment = buildConfigFromEnvironment;
-function getAccountIdentifierAndType(accountIdentifier) {
+export function getAccountIdentifierAndType(accountIdentifier) {
     const identifierAsNumber = typeof accountIdentifier === 'number'
         ? accountIdentifier
         : parseInt(accountIdentifier);
@@ -289,85 +272,79 @@ function getAccountIdentifierAndType(accountIdentifier) {
     return {
         identifier: isId ? identifierAsNumber : accountIdentifier,
         identifierType: isId
-            ? config_1.ACCOUNT_IDENTIFIERS.ACCOUNT_ID
-            : config_1.ACCOUNT_IDENTIFIERS.NAME,
+            ? ACCOUNT_IDENTIFIERS.ACCOUNT_ID
+            : ACCOUNT_IDENTIFIERS.NAME,
     };
 }
-exports.getAccountIdentifierAndType = getAccountIdentifierAndType;
-function getConfigAccountByIdentifier(accounts, identifierFieldName, identifier) {
+export function getConfigAccountByIdentifier(accounts, identifierFieldName, identifier) {
     return accounts.find(account => account[identifierFieldName] === identifier);
 }
-exports.getConfigAccountByIdentifier = getConfigAccountByIdentifier;
-function getConfigAccountByInferredIdentifier(accounts, accountIdentifier) {
+export 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));
+    return getConfigAccountByIdentifier(accounts, ACCOUNT_IDENTIFIERS.NAME, String(accountIdentifier));
 }
-exports.getConfigAccountByInferredIdentifier = getConfigAccountByInferredIdentifier;
-function getConfigAccountIndexById(accounts, id) {
+export function getConfigAccountIndexById(accounts, id) {
     return accounts.findIndex(account => account.accountId === id);
 }
-exports.getConfigAccountIndexById = getConfigAccountIndexById;
-function validateConfigAccount(account) {
+export function validateConfigAccount(account) {
     const validationErrors = [];
     if (!account || typeof account !== 'object') {
-        validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAccount'));
+        validationErrors.push(i18n('config.utils.validateConfigAccount.missingAccount'));
         return { isValid: false, errors: validationErrors };
     }
     if (!account.accountId) {
-        validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAccountId'));
+        validationErrors.push(i18n('config.utils.validateConfigAccount.missingAccountId'));
         return { isValid: false, errors: validationErrors };
     }
     if (!account.authType) {
-        validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAuthType', {
+        validationErrors.push(i18n('config.utils.validateConfigAccount.missingAuthType', {
             accountId: account.accountId,
         }));
         return { isValid: false, errors: validationErrors };
     }
-    if (account.authType === auth_1.PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+    if (account.authType === 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', {
+            validationErrors.push(i18n('config.utils.validateConfigAccount.missingPersonalAccessKey', {
                 accountId: account.accountId,
             }));
         }
     }
-    if (account.authType === auth_1.OAUTH_AUTH_METHOD.value) {
+    if (account.authType === OAUTH_AUTH_METHOD.value) {
         const isValidOAuthAccount = 'auth' in account && Boolean(account.auth);
         if (!isValidOAuthAccount) {
-            validationErrors.push((0, lang_1.i18n)('config.utils.validateConfigAccount.missingAuth', {
+            validationErrors.push(i18n('config.utils.validateConfigAccount.missingAuth', {
                 accountId: account.accountId,
             }));
         }
     }
-    if (account.authType === auth_1.API_KEY_AUTH_METHOD.value) {
+    if (account.authType === 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', {
+            validationErrors.push(i18n('config.utils.validateConfigAccount.missingApiKey', {
                 accountId: account.accountId,
             }));
         }
     }
     return { isValid: validationErrors.length === 0, errors: validationErrors };
 }
-exports.validateConfigAccount = validateConfigAccount;
-function handleConfigFileSystemError(error, path) {
+export function handleConfigFileSystemError(error, path) {
     let message;
-    let type = config_1.HUBSPOT_CONFIG_ERROR_TYPES.UNKNOWN;
+    let type = 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;
+            message = i18n('config.utils.handleConfigFileSystemError.configNotFoundError', { path });
+            type = 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;
+            message = i18n('config.utils.handleConfigFileSystemError.insufficientPermissionsError', { path });
+            type = HUBSPOT_CONFIG_ERROR_TYPES.INSUFFICIENT_PERMISSIONS;
         }
     }
     return { message, type };
 }
-exports.handleConfigFileSystemError = handleConfigFileSystemError;

package/constants/api.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SANDBOX_TIMEOUT = exports.HTTP_METHOD_PREPOSITIONS = exports.HTTP_METHOD_VERBS = void 0;
-exports.HTTP_METHOD_VERBS = {
+export const HTTP_METHOD_VERBS = {
     delete: 'delete',
     get: 'request',
     patch: 'update',
     post: 'post',
     put: 'update',
 };
-exports.HTTP_METHOD_PREPOSITIONS = {
+export const HTTP_METHOD_PREPOSITIONS = {
     delete: 'of',
     get: 'for',
     patch: 'to',
     post: 'to',
     put: 'to',
 };
-exports.SANDBOX_TIMEOUT = 60000;
+export const SANDBOX_TIMEOUT = 60000;