@hubspot/cli 7.4.2-experimental.0 → 7.4.2

package/lib/configMigrate.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMigration = handleMigration;
+exports.handleMerge = handleMerge;
+const migrate_1 = require("@hubspot/local-dev-lib/config/migrate");
+const config_1 = require("@hubspot/local-dev-lib/constants/config");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const promptUtils_1 = require("./prompts/promptUtils");
+const lang_1 = require("./lang");
+const usageTracking_1 = require("./usageTracking");
+async function handleMigration(accountId, configPath) {
+    const { shouldMigrateConfig } = await (0, promptUtils_1.promptUser)({
+        name: 'shouldMigrateConfig',
+        type: 'confirm',
+        message: (0, lang_1.i18n)('lib.configMigrate.migrateConfigPrompt', {
+            deprecatedConfigPath: (0, migrate_1.getConfigPath)(configPath, false) ||
+                config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
+            globalConfigPath: config_1.GLOBAL_CONFIG_PATH,
+        }),
+    });
+    if (!shouldMigrateConfig) {
+        (0, usageTracking_1.trackCommandMetadataUsage)('config-migrate', {
+            command: 'hs config migrate',
+            type: 'migration',
+            step: 'Reject migration via prompt',
+        }, accountId);
+        return;
+    }
+    const deprecatedConfig = (0, migrate_1.getDeprecatedConfig)(configPath);
+    (0, migrate_1.migrateConfig)(deprecatedConfig);
+    (0, usageTracking_1.trackCommandMetadataUsage)('config-migrate', {
+        command: 'hs config migrate',
+        type: 'migration',
+        step: 'Confirm migration via prompt',
+        successful: true,
+    }, accountId);
+    logger_1.logger.success((0, lang_1.i18n)('lib.configMigrate.migrationSuccess', {
+        globalConfigPath: config_1.GLOBAL_CONFIG_PATH,
+    }));
+    return;
+}
+async function mergeConfigProperties(globalConfig, deprecatedConfig, force) {
+    const { initialConfig, conflicts, } = (0, migrate_1.mergeConfigProperties)(globalConfig, deprecatedConfig, force);
+    if (conflicts.length > 0) {
+        for (const conflict of conflicts) {
+            const { property, newValue, oldValue } = conflict;
+            const { shouldOverwrite } = await (0, promptUtils_1.promptUser)({
+                name: 'shouldOverwrite',
+                type: 'confirm',
+                message: (0, lang_1.i18n)('lib.configMigrate.mergeConfigConflictPrompt', {
+                    property,
+                    oldValue: `${oldValue}`,
+                    newValue: `${newValue}`,
+                }),
+            });
+            if (shouldOverwrite) {
+                // @ts-expect-error Cannot reconcile CLIConfig_NEW and CLIConfig_DEPRECATED
+                initialConfig[property] = oldValue;
+            }
+        }
+    }
+    return initialConfig;
+}
+async function handleMerge(accountId, configPath, force) {
+    const { shouldMergeConfigs } = await (0, promptUtils_1.promptUser)({
+        name: 'shouldMergeConfigs',
+        type: 'confirm',
+        message: (0, lang_1.i18n)('lib.configMigrate.mergeConfigsPrompt', {
+            deprecatedConfigPath: (0, migrate_1.getConfigPath)(configPath, false) ||
+                config_1.DEFAULT_HUBSPOT_CONFIG_YAML_FILE_NAME,
+            globalConfigPath: config_1.GLOBAL_CONFIG_PATH,
+        }),
+    });
+    if (!shouldMergeConfigs) {
+        (0, usageTracking_1.trackCommandMetadataUsage)('config-migrate', {
+            command: 'hs config migrate',
+            type: 'merge',
+            step: 'Reject merge via prompt',
+        }, accountId);
+        return;
+    }
+    const deprecatedConfig = (0, migrate_1.getDeprecatedConfig)(configPath);
+    const globalConfig = (0, migrate_1.getGlobalConfig)();
+    if (!deprecatedConfig || !globalConfig) {
+        return;
+    }
+    const mergedConfig = await mergeConfigProperties(globalConfig, deprecatedConfig, force);
+    const { skippedAccountIds } = (0, migrate_1.mergeExistingConfigs)(mergedConfig, deprecatedConfig);
+    if (skippedAccountIds.length > 0) {
+        logger_1.logger.log((0, lang_1.i18n)('lib.configMigrate.skippedExistingAccounts', {
+            skippedAccountIds: skippedAccountIds.join(', '),
+        }));
+    }
+    logger_1.logger.success((0, lang_1.i18n)('lib.configMigrate.mergeSuccess', {
+        globalConfigPath: config_1.GLOBAL_CONFIG_PATH,
+    }));
+    (0, usageTracking_1.trackCommandMetadataUsage)('config-migrate', {
+        command: 'hs config migrate',
+        type: 'merge',
+        step: 'Confirm merge via prompt',
+        successful: true,
+    }, accountId);
+    return;
+}

package/lib/doctor/Diagnosis.d.ts

@@ -11,16 +11,15 @@ interface Section {
 export declare class Diagnosis {
     private readonly prefixes;
     private readonly diagnosis;
-    private readonly indentation;
     private errorCount;
     private warningCount;
     constructor({ diagnosticInfo, accountId }: DiagnosisOptions);
-    private indent;
     getErrorCount(): number;
     getWarningCount(): number;
     addCliSection(section: Section): void;
     addProjectSection(section: Section): void;
     addCLIConfigSection(section: Section): void;
+    addDefaultAccountOverrideFileSection(section: Section): void;
     toString(): string;
     private generateSections;
 }

package/lib/doctor/Diagnosis.js

@@ -5,12 +5,12 @@ const spinniesUtils_1 = require("../ui/spinniesUtils");
 const chalk_1 = require("chalk");
 const interpolation_1 = require("../interpolation");
 const ui_1 = require("../ui");
+const index_1 = require("../ui/index");
 const { i18n } = require('../lang');
 const i18nKey = `lib.doctor.diagnosis`;
 class Diagnosis {
     prefixes;
     diagnosis;
-    indentation = '  ';
     errorCount = 0;
     warningCount = 0;
     constructor({ diagnosticInfo, accountId }) {
@@ -29,6 +29,10 @@ class Diagnosis {
                 header: i18n(`${i18nKey}.cliConfig.header`),
                 sections: [],
             },
+            defaultAccountOverrideFile: {
+                header: i18n(`${i18nKey}.defaultAccountOverrideFile.header`),
+                sections: [],
+            },
             project: {
                 header: i18n(`${i18nKey}.projectConfig.header`),
                 subheaders: [
@@ -53,9 +57,6 @@ class Diagnosis {
             ];
         }
     }
-    indent(level) {
-        return this.indentation.repeat(level);
-    }
     getErrorCount() {
         return this.errorCount;
     }
@@ -71,6 +72,9 @@ class Diagnosis {
     addCLIConfigSection(section) {
         this.diagnosis.cliConfig.sections.push(section);
     }
+    addDefaultAccountOverrideFileSection(section) {
+        this.diagnosis.defaultAccountOverrideFile.sections.push(section);
+    }
     toString() {
         const output = [];
         for (const value of Object.values(this.diagnosis)) {
@@ -108,9 +112,9 @@ class Diagnosis {
             else if (section.type === 'warning') {
                 this.warningCount++;
             }
-            output.push(`${this.indent(1)}${this.prefixes[section.type]} ${section.message}`);
+            output.push(`${(0, index_1.indent)(1)}${this.prefixes[section.type]} ${section.message}`);
             if (section.secondaryMessaging) {
-                output.push(`${this.indent(2)}- ${section.secondaryMessaging}`);
+                output.push(`${(0, index_1.indent)(2)}- ${section.secondaryMessaging}`);
             }
         });
         return output.join('\n');

package/lib/doctor/DiagnosticInfoBuilder.d.ts

@@ -21,6 +21,7 @@ export interface DiagnosticInfo extends FilesInfo {
         npm: string | null;
     };
     config: string | null;
+    defaultAccountOverrideFile: string | null | undefined;
     configSettings: {
         [key: string]: unknown;
     };

package/lib/doctor/DiagnosticInfoBuilder.js

@@ -64,6 +64,7 @@ class DiagnosticInfoBuilder {
             arch,
             path: mainModule?.path,
             config: (0, config_2.getConfigPath)(),
+            defaultAccountOverrideFile: (0, config_1.getDefaultAccountOverrideFilePath)(),
             configSettings: this.configSettings,
             versions: {
                 [hubspotCli]: package_json_1.default.version,

package/lib/doctor/Doctor.d.ts

@@ -10,6 +10,7 @@ export declare class Doctor {
     private performCliChecks;
     private performProjectChecks;
     private performCliConfigChecks;
+    private performDefaultAccountOverrideFileChecks;
     private performCliConfigSettingsChecks;
     private checkIfAccessTokenValid;
     private checkIfNodeIsInstalled;

package/lib/doctor/Doctor.js

@@ -51,6 +51,7 @@ class Doctor {
             ...this.performCliConfigChecks(),
             ...(this.projectConfig?.projectConfig ? this.performProjectChecks() : []),
         ]);
+        this.performDefaultAccountOverrideFileChecks();
         this.performCliConfigSettingsChecks();
         SpinniesManager_1.default.succeed('runningDiagnostics', {
             text: i18n(`${i18nKey}.diagnosticsComplete`),
@@ -88,6 +89,23 @@ class Doctor {
         }
         return [this.checkIfAccessTokenValid()];
     }
+    performDefaultAccountOverrideFileChecks() {
+        const localI18nKey = `${i18nKey}.defaultAccountOverrideFileChecks`;
+        if (this.diagnosticInfo?.defaultAccountOverrideFile) {
+            this.diagnosis?.addDefaultAccountOverrideFileSection({
+                type: 'warning',
+                message: i18n(`${localI18nKey}.overrideActive`, {
+                    defaultAccountOverrideFile: this.diagnosticInfo.defaultAccountOverrideFile,
+                }),
+            });
+            this.diagnosis?.addDefaultAccountOverrideFileSection({
+                type: 'warning',
+                message: i18n(`${localI18nKey}.overrideAccountId`, {
+                    overrideAccountId: (0, config_1.getCWDAccountOverride)(),
+                }),
+            });
+        }
+    }
     performCliConfigSettingsChecks() {
         if (this.diagnosticInfo?.configSettings.httpUseLocalhost) {
             this.diagnosis?.addCLIConfigSection({

package/lib/middleware/__test__/configMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/configMiddleware.test.js

@@ -0,0 +1,194 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const cliConfig = __importStar(require("@hubspot/local-dev-lib/config"));
+const validation = __importStar(require("../../validation"));
+const exitCodes_1 = require("../../enums/exitCodes");
+const configMiddleware_1 = require("../configMiddleware");
+jest.mock('@hubspot/local-dev-lib/logger', () => ({
+    logger: {
+        error: jest.fn(),
+        log: jest.fn(),
+    },
+}));
+jest.mock('@hubspot/local-dev-lib/config');
+jest.mock('../../validation');
+const validateAccountSpy = jest.spyOn(validation, 'validateAccount');
+const loadConfigSpy = jest.spyOn(cliConfig, 'loadConfig');
+const getAccountIdSpy = jest.spyOn(cliConfig, 'getAccountId');
+const configFileExistsSpy = jest.spyOn(cliConfig, 'configFileExists');
+const getConfigPathSpy = jest.spyOn(cliConfig, 'getConfigPath');
+const validateConfigSpy = jest.spyOn(cliConfig, 'validateConfig');
+const processExitSpy = jest.spyOn(process, 'exit');
+describe('lib/middleware/configMiddleware', () => {
+    beforeEach(() => {
+        processExitSpy.mockImplementation(code => {
+            throw new Error(`Process.exit called with code ${code}`);
+        });
+        getConfigPathSpy.mockReturnValue('/path/to/config');
+    });
+    describe('handleDeprecatedEnvVariables()', () => {
+        it('should handle deprecated HUBSPOT_PORTAL_ID environment variable', () => {
+            const originalEnv = process.env;
+            process.env = {
+                ...originalEnv,
+                HUBSPOT_PORTAL_ID: '123',
+                HUBSPOT_ACCOUNT_ID: undefined,
+            };
+            const argv = {
+                _: ['some-command'],
+                useEnv: true,
+                $0: 'hs',
+            };
+            (0, configMiddleware_1.handleDeprecatedEnvVariables)(argv);
+            expect(logger_1.logger.log).toHaveBeenCalledWith(expect.stringContaining('The HUBSPOT_PORTAL_ID environment variable is deprecated. Please use HUBSPOT_ACCOUNT_ID instead.'));
+            expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('123');
+            process.env = originalEnv;
+        });
+        it('should not handle HUBSPOT_PORTAL_ID if HUBSPOT_ACCOUNT_ID is set', () => {
+            const originalEnv = process.env;
+            process.env = {
+                ...originalEnv,
+                HUBSPOT_PORTAL_ID: '123',
+                HUBSPOT_ACCOUNT_ID: '456',
+            };
+            const argv = {
+                _: ['some-command'],
+                useEnv: true,
+                $0: 'hs',
+            };
+            (0, configMiddleware_1.handleDeprecatedEnvVariables)(argv);
+            expect(logger_1.logger.log).not.toHaveBeenCalled();
+            expect(process.env.HUBSPOT_ACCOUNT_ID).toBe('456');
+            process.env = originalEnv;
+        });
+    });
+    describe('injectAccountIdMiddleware()', () => {
+        it('should use HUBSPOT_ACCOUNT_ID from environment when useEnv is true', async () => {
+            const originalEnv = process.env;
+            process.env = {
+                ...originalEnv,
+                HUBSPOT_ACCOUNT_ID: '123',
+            };
+            const argv = {
+                _: ['some-command'],
+                useEnv: true,
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.injectAccountIdMiddleware)(argv);
+            expect(argv.providedAccountId).toBeUndefined();
+            expect(argv.derivedAccountId).toBe(123);
+            expect(getAccountIdSpy).not.toHaveBeenCalled();
+            process.env = originalEnv;
+        });
+        it('should use getAccountId when useEnv is false', async () => {
+            getAccountIdSpy.mockReturnValue(456);
+            const argv = {
+                _: ['some-command'],
+                account: 'test-account',
+                useEnv: false,
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.injectAccountIdMiddleware)(argv);
+            expect(argv.providedAccountId).toBe('test-account');
+            expect(argv.derivedAccountId).toBe(456);
+            expect(getAccountIdSpy).toHaveBeenCalledWith('test-account');
+        });
+    });
+    describe('loadConfigMiddleware()', () => {
+        it('should exit with error when config file exists and --config flag is used', async () => {
+            configFileExistsSpy.mockReturnValue(true);
+            const argv = {
+                _: ['some-command'],
+                config: 'custom-config.json',
+                $0: 'hs',
+            };
+            await expect((0, configMiddleware_1.loadConfigMiddleware)(argv)).rejects.toThrow();
+            expect(processExitSpy).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+            expect(logger_1.logger.error).toHaveBeenCalledWith('A configuration file already exists at /path/to/config. To specify a new configuration file, delete the existing one and try again.');
+        });
+        it('should load config and validate for non-init commands', async () => {
+            configFileExistsSpy.mockReturnValue(false);
+            loadConfigSpy.mockReturnValue({});
+            validateConfigSpy.mockReturnValue(true);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.loadConfigMiddleware)(argv);
+            expect(loadConfigSpy).toHaveBeenCalled();
+            expect(validateConfigSpy).toHaveBeenCalled();
+        });
+        it('should skip validation for init command', async () => {
+            configFileExistsSpy.mockReturnValue(false);
+            const argv = {
+                _: ['init'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.loadConfigMiddleware)(argv);
+            expect(loadConfigSpy).not.toHaveBeenCalled();
+            expect(validateConfigSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('validateAccountOptions()', () => {
+        it('should validate account for non-skipped commands', async () => {
+            validateAccountSpy.mockResolvedValue(true);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.validateAccountOptions)(argv);
+            expect(validateAccountSpy).toHaveBeenCalledWith(argv);
+        });
+        it('should skip validation for init command', async () => {
+            const argv = {
+                _: ['init'],
+                $0: 'hs',
+            };
+            await (0, configMiddleware_1.validateAccountOptions)(argv);
+            expect(validateAccountSpy).not.toHaveBeenCalled();
+        });
+        it('should exit with error when account validation fails', async () => {
+            validateAccountSpy.mockResolvedValue(false);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            await expect((0, configMiddleware_1.validateAccountOptions)(argv)).rejects.toThrow();
+            expect(processExitSpy).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+        });
+    });
+});

package/lib/middleware/__test__/gitMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/gitMiddleware.test.js

@@ -0,0 +1,76 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = __importStar(require("@hubspot/local-dev-lib/config"));
+const gitUI = __importStar(require("../../ui/git"));
+const gitMiddleware_1 = require("../gitMiddleware");
+jest.mock('@hubspot/local-dev-lib/config');
+jest.mock('../../ui/git');
+const getConfigPathSpy = jest.spyOn(config, 'getConfigPath');
+const checkAndWarnGitInclusionSpy = jest.spyOn(gitUI, 'checkAndWarnGitInclusion');
+describe('lib/middleware/gitMiddleware', () => {
+    describe('checkAndWarnGitInclusionMiddleware()', () => {
+        it('should call checkAndWarnGitInclusion when command is provided and config path exists', () => {
+            const mockConfigPath = '/path/to/config';
+            getConfigPathSpy.mockReturnValue(mockConfigPath);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            (0, gitMiddleware_1.checkAndWarnGitInclusionMiddleware)(argv);
+            expect(getConfigPathSpy).toHaveBeenCalledTimes(1);
+            expect(checkAndWarnGitInclusionSpy).toHaveBeenCalledWith(mockConfigPath);
+        });
+        it('should not call checkAndWarnGitInclusion when no command is provided', () => {
+            const argv = {
+                _: [],
+                $0: 'hs',
+            };
+            (0, gitMiddleware_1.checkAndWarnGitInclusionMiddleware)(argv);
+            expect(getConfigPathSpy).not.toHaveBeenCalled();
+            expect(checkAndWarnGitInclusionSpy).not.toHaveBeenCalled();
+        });
+        it('should not call checkAndWarnGitInclusion when config path is null', () => {
+            getConfigPathSpy.mockReturnValue(null);
+            const argv = {
+                _: ['some-command'],
+                $0: 'hs',
+            };
+            (0, gitMiddleware_1.checkAndWarnGitInclusionMiddleware)(argv);
+            expect(getConfigPathSpy).toHaveBeenCalledTimes(1);
+            expect(checkAndWarnGitInclusionSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/lib/middleware/__test__/notificationsMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/notificationsMiddleware.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { notifyAboutUpdates } = require('../notificationsMiddleware');
+describe('lib/middleware/notificationsMiddleware', () => {
+    describe('notifyAboutUpdates()', () => {
+        it('should safely execute without throwing an error', () => {
+            expect(() => notifyAboutUpdates()).not.toThrow();
+        });
+    });
+});

package/lib/middleware/__test__/requestMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/requestMiddleware.test.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("@hubspot/local-dev-lib/http");
+const requestMiddleware_1 = require("../requestMiddleware");
+const package_json_1 = __importDefault(require("../../../package.json"));
+jest.mock('@hubspot/local-dev-lib/http', () => ({
+    addUserAgentHeader: jest.fn(),
+}));
+describe('lib/middleware/requestMiddleware', () => {
+    describe('setRequestHeaders()', () => {
+        it('should call addUserAgentHeader with correct parameters', () => {
+            (0, requestMiddleware_1.setRequestHeaders)();
+            expect(http_1.addUserAgentHeader).toHaveBeenCalledTimes(1);
+            expect(http_1.addUserAgentHeader).toHaveBeenCalledWith('HubSpot CLI', package_json_1.default.version);
+        });
+    });
+});

package/lib/middleware/__test__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/middleware/__test__/utils.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const targetCommandMap = {
+    init: { target: true },
+    account: {
+        target: true,
+        subCommands: {
+            use: { target: true },
+        },
+    },
+    project: {
+        subCommands: {
+            deploy: { target: true },
+        },
+    },
+};
+describe('lib/middleware/utils', () => {
+    describe('isTargetedCommand()', () => {
+        it('should return true for a direct target command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['init'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return true for a command with a subcommand', () => {
+            const result = (0, utils_1.isTargetedCommand)(['account'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return true for a nested target command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['project', 'deploy'], targetCommandMap);
+            expect(result).toBe(true);
+        });
+        it('should return false for a non-existent command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-targeted command', () => {
+            const result = (0, utils_1.isTargetedCommand)(['auth'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a command with a targeted subcommand', () => {
+            const result = (0, utils_1.isTargetedCommand)(['project'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for a non-existent subcommand', () => {
+            const result = (0, utils_1.isTargetedCommand)(['auth', 'nonexistent'], targetCommandMap);
+            expect(result).toBe(false);
+        });
+        it('should return false for an empty command array', () => {
+            const result = (0, utils_1.isTargetedCommand)([], targetCommandMap);
+            expect(result).toBe(false);
+        });
+    });
+});

package/lib/middleware/__test__/yargsChecksMiddleware.test.d.ts

@@ -0,0 +1 @@
+export {};