@hubspot/cli 7.7.21-experimental.0 → 7.7.21-experimental.1

package/lib/__tests__/developerTestAccounts.test.js

@@ -1,27 +1,62 @@
-import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { mockHubSpotHttpError } from '../testUtils.js';
-import * as errorHandlers from '../errorHandlers/index.js';
-import { getHasDevTestAccounts, handleDeveloperTestAccountCreateError, validateDevTestAccountUsageLimits, } from '../developerTestAccounts.js';
+"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_1 = require("@hubspot/local-dev-lib/config");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_2 = require("@hubspot/local-dev-lib/constants/config");
+const developerTestAccounts_1 = require("@hubspot/local-dev-lib/api/developerTestAccounts");
+const testUtils_1 = require("../testUtils");
+const errorHandlers = __importStar(require("../errorHandlers"));
+const developerTestAccounts_2 = require("../developerTestAccounts");
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/local-dev-lib/api/developerTestAccounts');
 vi.mock('../errorHandlers');
-const mockedGetAccountId = getAccountId;
-const mockedGetConfigAccounts = getConfigAccounts;
-const mockedFetchDeveloperTestAccounts = fetchDeveloperTestAccounts;
+const mockedGetAccountId = config_1.getAccountId;
+const mockedGetConfigAccounts = config_1.getConfigAccounts;
+const mockedFetchDeveloperTestAccounts = developerTestAccounts_1.fetchDeveloperTestAccounts;
 const APP_DEVELOPER_ACCOUNT_1 = {
     name: 'app-developer-1',
     accountId: 123,
-    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
     env: 'prod',
 };
 const APP_DEVELOPER_ACCOUNT_2 = {
     name: 'app-developer-2',
     accountId: 456,
-    accountType: HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
+    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER,
     env: 'prod',
 };
 const accounts = [
@@ -31,7 +66,7 @@ const accounts = [
         name: 'test-account',
         accountId: 789,
         parentAccountId: APP_DEVELOPER_ACCOUNT_1.accountId,
-        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
         env: 'prod',
     },
 ];
@@ -40,19 +75,19 @@ describe('lib/developerTestAccounts', () => {
         it('should return true if there are developer test accounts associated with the account', () => {
             mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
             mockedGetConfigAccounts.mockReturnValueOnce(accounts);
-            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
+            const result = (0, developerTestAccounts_2.getHasDevTestAccounts)(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(true);
         });
         it('should return false if there are no developer test accounts associated with the account', () => {
             mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_2.accountId);
             mockedGetConfigAccounts.mockReturnValueOnce(accounts);
-            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_2);
+            const result = (0, developerTestAccounts_2.getHasDevTestAccounts)(APP_DEVELOPER_ACCOUNT_2);
             expect(result).toBe(false);
         });
         it('should return false if there are no accounts configured', () => {
             mockedGetAccountId.mockReturnValueOnce(APP_DEVELOPER_ACCOUNT_1.accountId);
             mockedGetConfigAccounts.mockReturnValueOnce(undefined);
-            const result = getHasDevTestAccounts(APP_DEVELOPER_ACCOUNT_1);
+            const result = (0, developerTestAccounts_2.getHasDevTestAccounts)(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(false);
         });
     });
@@ -63,7 +98,7 @@ describe('lib/developerTestAccounts', () => {
         });
         it('should return null if the account id is not found', async () => {
             mockedGetAccountId.mockReturnValueOnce(undefined);
-            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            const result = await (0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(null);
         });
         it('should return null if there is no developer test account data', async () => {
@@ -71,7 +106,7 @@ describe('lib/developerTestAccounts', () => {
             mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
                 data: null,
             });
-            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            const result = await (0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toBe(null);
         });
         it('should return the test account data if the account has not reached the limit', async () => {
@@ -83,7 +118,7 @@ describe('lib/developerTestAccounts', () => {
             mockedFetchDeveloperTestAccounts.mockResolvedValueOnce({
                 data: testAccountData,
             });
-            const result = await validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1);
+            const result = await (0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1);
             expect(result).toEqual(expect.objectContaining(testAccountData));
         });
         it('should throw an error if the account has reached the limit', async () => {
@@ -94,14 +129,14 @@ describe('lib/developerTestAccounts', () => {
                     results: [{}],
                 },
             });
-            await expect(validateDevTestAccountUsageLimits(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
+            await expect((0, developerTestAccounts_2.validateDevTestAccountUsageLimits)(APP_DEVELOPER_ACCOUNT_1)).rejects.toThrow();
         });
     });
     describe('handleDeveloperTestAccountCreateError()', () => {
         let loggerErrorSpy;
         let logErrorSpy;
         beforeEach(() => {
-            loggerErrorSpy = vi.spyOn(logger, 'error');
+            loggerErrorSpy = vi.spyOn(logger_1.logger, 'error');
             logErrorSpy = vi.spyOn(errorHandlers, 'logError');
         });
         afterEach(() => {
@@ -109,36 +144,36 @@ describe('lib/developerTestAccounts', () => {
             logErrorSpy.mockRestore();
         });
         it('should log and throw an error if the account is missing the required scopes', () => {
-            const missingScopesError = mockHubSpotHttpError('Missing scopes error', {
+            const missingScopesError = (0, testUtils_1.mockHubSpotHttpError)('Missing scopes error', {
                 status: 403,
                 data: {
                     message: 'Missing scopes error',
                     category: 'MISSING_SCOPES',
                 },
             });
-            expect(() => handleDeveloperTestAccountCreateError(missingScopesError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Missing scopes error');
+            expect(() => (0, developerTestAccounts_2.handleDeveloperTestAccountCreateError)(missingScopesError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Missing scopes error');
             expect(loggerErrorSpy).toHaveBeenCalled();
         });
         it('should log and throw an error if the account is missing the required scopes', () => {
-            const portalLimitReachedError = mockHubSpotHttpError('Portal limit reached error', {
+            const portalLimitReachedError = (0, testUtils_1.mockHubSpotHttpError)('Portal limit reached error', {
                 status: 400,
                 data: {
                     message: 'Portal limit reached error',
                     errorType: 'TEST_PORTAL_LIMIT_REACHED',
                 },
             });
-            expect(() => handleDeveloperTestAccountCreateError(portalLimitReachedError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Portal limit reached error');
+            expect(() => (0, developerTestAccounts_2.handleDeveloperTestAccountCreateError)(portalLimitReachedError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Portal limit reached error');
             expect(loggerErrorSpy).toHaveBeenCalled();
         });
         it('should log a generic error message for an unknown error type', () => {
-            const someUnknownError = mockHubSpotHttpError('Some unknown error', {
+            const someUnknownError = (0, testUtils_1.mockHubSpotHttpError)('Some unknown error', {
                 status: 400,
                 data: {
                     message: 'Some unknown error',
                     category: 'SOME_UNKNOWN_ERROR',
                 },
             });
-            expect(() => handleDeveloperTestAccountCreateError(someUnknownError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Some unknown error');
+            expect(() => (0, developerTestAccounts_2.handleDeveloperTestAccountCreateError)(someUnknownError, APP_DEVELOPER_ACCOUNT_1.accountId, 'prod', 10)).toThrow('Some unknown error');
             expect(logErrorSpy).toHaveBeenCalled();
         });
     });

package/lib/__tests__/hasFeature.test.js

@@ -1,7 +1,9 @@
-import { fetchEnabledFeatures } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { hasFeature } from '../hasFeature.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const localDevAuth_1 = require("@hubspot/local-dev-lib/api/localDevAuth");
+const hasFeature_1 = require("../hasFeature");
 vi.mock('@hubspot/local-dev-lib/api/localDevAuth');
-const mockedFetchEnabledFeatures = fetchEnabledFeatures;
+const mockedFetchEnabledFeatures = localDevAuth_1.fetchEnabledFeatures;
 describe('lib/hasFeature', () => {
     describe('hasFeature()', () => {
         const accountId = 123;
@@ -18,17 +20,17 @@ describe('lib/hasFeature', () => {
         });
         it('should return true if the feature is enabled', async () => {
             // @ts-expect-error test data
-            const result = await hasFeature(accountId, 'feature-1');
+            const result = await (0, hasFeature_1.hasFeature)(accountId, 'feature-1');
             expect(result).toBe(true);
         });
         it('should return false if the feature is not enabled', async () => {
             // @ts-expect-error test data
-            const result = await hasFeature(accountId, 'feature-2');
+            const result = await (0, hasFeature_1.hasFeature)(accountId, 'feature-2');
             expect(result).toBe(false);
         });
         it('should return false if the feature is not present', async () => {
             // @ts-expect-error test data
-            const result = await hasFeature(accountId, 'feature-4');
+            const result = await (0, hasFeature_1.hasFeature)(accountId, 'feature-4');
             expect(result).toBe(false);
         });
     });

package/lib/__tests__/npm.test.js

@@ -1,6 +1,11 @@
-import util from 'util';
-import { isGloballyInstalled, getLatestCliVersion, DEFAULT_PACKAGE_MANAGER, } from '../npm.js';
-import pkg from '../../package.json' with { type: 'json' };
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const npm_1 = require("../npm");
+const package_json_1 = __importDefault(require("../../package.json"));
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('../ui/SpinniesManager');
 describe('lib/npm', () => {
@@ -12,24 +17,24 @@ describe('lib/npm', () => {
     }
     beforeEach(() => {
         execMock = vi.fn();
-        util.promisify = mockedPromisify(execMock);
+        util_1.default.promisify = mockedPromisify(execMock);
     });
     describe('isGloballyInstalled()', () => {
         it('should return true when exec is successful', async () => {
-            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+            const actual = await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER);
             expect(actual).toBe(true);
             expect(execMock).toHaveBeenCalledTimes(1);
-            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
+            expect(execMock).toHaveBeenCalledWith(`${npm_1.DEFAULT_PACKAGE_MANAGER} --version`);
         });
         it('should return false when exec is unsuccessful', async () => {
             execMock.mockImplementationOnce(() => {
                 throw new Error('unsuccessful');
             });
-            util.promisify = mockedPromisify(execMock);
-            const actual = await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER);
+            util_1.default.promisify = mockedPromisify(execMock);
+            const actual = await (0, npm_1.isGloballyInstalled)(npm_1.DEFAULT_PACKAGE_MANAGER);
             expect(actual).toBe(false);
             expect(execMock).toHaveBeenCalledTimes(1);
-            expect(execMock).toHaveBeenCalledWith(`${DEFAULT_PACKAGE_MANAGER} --version`);
+            expect(execMock).toHaveBeenCalledWith(`${npm_1.DEFAULT_PACKAGE_MANAGER} --version`);
         });
     });
     describe('getLatestCliVersion()', () => {
@@ -39,19 +44,19 @@ describe('lib/npm', () => {
             execMock.mockResolvedValueOnce({
                 stdout: JSON.stringify({ latest, next }),
             });
-            util.promisify = mockedPromisify(execMock);
-            const actual = await getLatestCliVersion();
+            util_1.default.promisify = mockedPromisify(execMock);
+            const actual = await (0, npm_1.getLatestCliVersion)();
             expect(actual).toEqual({ latest, next });
-            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+            expect(execMock).toHaveBeenCalledWith(`npm info ${package_json_1.default.name} dist-tags --json`);
         });
         it('should throw any errors that encounter with the check', async () => {
             const errorMessage = 'unsuccessful';
             execMock.mockImplementationOnce(() => {
                 throw new Error(errorMessage);
             });
-            util.promisify = mockedPromisify(execMock);
-            await expect(() => getLatestCliVersion()).rejects.toThrow(errorMessage);
-            expect(execMock).toHaveBeenCalledWith(`npm info ${pkg.name} dist-tags --json`);
+            util_1.default.promisify = mockedPromisify(execMock);
+            await expect(() => (0, npm_1.getLatestCliVersion)()).rejects.toThrow(errorMessage);
+            expect(execMock).toHaveBeenCalledWith(`npm info ${package_json_1.default.name} dist-tags --json`);
         });
     });
 });

package/lib/__tests__/oauth.test.js

@@ -1,21 +1,26 @@
-import express from 'express';
-import open from 'open';
-import { OAuth2Manager } from '@hubspot/local-dev-lib/models/OAuth2Manager';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { addOauthToAccountConfig } from '@hubspot/local-dev-lib/oauth';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
-import { DEFAULT_OAUTH_SCOPES } from '@hubspot/local-dev-lib/constants/auth';
-import { authenticateWithOauth } from '../oauth.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const open_1 = __importDefault(require("open"));
+const OAuth2Manager_1 = require("@hubspot/local-dev-lib/models/OAuth2Manager");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const oauth_1 = require("@hubspot/local-dev-lib/oauth");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
+const oauth_2 = require("../oauth");
 vi.mock('express');
 vi.mock('open');
 vi.mock('@hubspot/local-dev-lib/models/OAuth2Manager');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('@hubspot/local-dev-lib/oauth');
 vi.mock('@hubspot/local-dev-lib/logger');
-const mockedExpress = express;
-const mockedOAuth2Manager = OAuth2Manager;
-const mockedGetAccountConfig = getAccountConfig;
+const mockedExpress = express_1.default;
+const mockedOAuth2Manager = OAuth2Manager_1.OAuth2Manager;
+const mockedGetAccountConfig = config_1.getAccountConfig;
 describe('lib/oauth', () => {
     const mockExpressReq = {
         query: { code: 'test-auth-code' },
@@ -26,7 +31,7 @@ describe('lib/oauth', () => {
         clientId: 'test-client-id',
         clientSecret: 'test-client-secret',
         scopes: ['test-scope'],
-        env: ENVIRONMENTS.PROD,
+        env: environments_1.ENVIRONMENTS.PROD,
     };
     beforeEach(() => {
         mockedExpress.mockReturnValue({
@@ -50,18 +55,18 @@ describe('lib/oauth', () => {
             };
             mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
             mockedGetAccountConfig.mockReturnValue({
-                env: ENVIRONMENTS.PROD,
+                env: environments_1.ENVIRONMENTS.PROD,
             });
-            await authenticateWithOauth(mockAccountConfig);
+            await (0, oauth_2.authenticateWithOauth)(mockAccountConfig);
             // Verify OAuth2Manager was initialized correctly
             expect(mockedOAuth2Manager).toHaveBeenCalledWith({
                 ...mockAccountConfig,
-                env: ENVIRONMENTS.PROD,
+                env: environments_1.ENVIRONMENTS.PROD,
             });
             // Verify logger was called
-            expect(logger.log).toHaveBeenCalledWith('Authorizing');
+            expect(logger_1.logger.log).toHaveBeenCalledWith('Authorizing');
             // Verify OAuth tokens were added to config
-            expect(addOauthToAccountConfig).toHaveBeenCalledWith(mockOAuth2Manager);
+            expect(oauth_1.addOauthToAccountConfig).toHaveBeenCalledWith(mockOAuth2Manager);
         });
         it('should handle missing clientId', async () => {
             const invalidConfig = {
@@ -74,8 +79,8 @@ describe('lib/oauth', () => {
             const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {
                 throw new Error('exit');
             });
-            await expect(authenticateWithOauth(invalidConfig)).rejects.toThrow('exit');
-            expect(logger.error).toHaveBeenCalled();
+            await expect((0, oauth_2.authenticateWithOauth)(invalidConfig)).rejects.toThrow('exit');
+            expect(logger_1.logger.error).toHaveBeenCalled();
             expect(exitSpy).toHaveBeenCalled();
             exitSpy.mockRestore();
         });
@@ -89,9 +94,9 @@ describe('lib/oauth', () => {
                 exchangeForTokens: vi.fn().mockResolvedValue({}),
             };
             mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
-            await authenticateWithOauth(configWithoutScopes);
+            await (0, oauth_2.authenticateWithOauth)(configWithoutScopes);
             // Verify default scopes were used
-            expect(open).toHaveBeenCalledWith(expect.stringContaining(encodeURIComponent(DEFAULT_OAUTH_SCOPES.join(' '))), expect.anything());
+            expect(open_1.default).toHaveBeenCalledWith(expect.stringContaining(encodeURIComponent(auth_1.DEFAULT_OAUTH_SCOPES.join(' '))), expect.anything());
         });
         it('should handle OAuth exchange failure', async () => {
             const mockOAuth2Manager = {
@@ -101,7 +106,7 @@ describe('lib/oauth', () => {
                     .mockRejectedValue(new Error('Exchange failed')),
             };
             mockedOAuth2Manager.mockImplementation(() => mockOAuth2Manager);
-            await authenticateWithOauth(mockAccountConfig);
+            await (0, oauth_2.authenticateWithOauth)(mockAccountConfig);
             expect(mockExpressResp.send).toHaveBeenCalledWith(expect.stringContaining('Authorization failed'));
         });
     });

package/lib/__tests__/parsing.test.js

@@ -1,34 +1,36 @@
-import { parseStringToNumber } from '../parsing.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parsing_1 = require("../parsing");
 describe('lib/parsing', () => {
     describe('parseStringToNumber', () => {
         it('should parse valid integer strings', () => {
-            expect(parseStringToNumber('123')).toBe(123);
-            expect(parseStringToNumber('0')).toBe(0);
-            expect(parseStringToNumber('-456')).toBe(-456);
-            expect(parseStringToNumber('999')).toBe(999);
+            expect((0, parsing_1.parseStringToNumber)('123')).toBe(123);
+            expect((0, parsing_1.parseStringToNumber)('0')).toBe(0);
+            expect((0, parsing_1.parseStringToNumber)('-456')).toBe(-456);
+            expect((0, parsing_1.parseStringToNumber)('999')).toBe(999);
         });
         it('should parse strings with leading zeros', () => {
-            expect(parseStringToNumber('007')).toBe(7);
-            expect(parseStringToNumber('0123')).toBe(123);
+            expect((0, parsing_1.parseStringToNumber)('007')).toBe(7);
+            expect((0, parsing_1.parseStringToNumber)('0123')).toBe(123);
         });
         it('should throw error for strings with leading whitespace', () => {
-            expect(() => parseStringToNumber('  42')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('\t123')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('  42')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('\t123')).toThrow('Unable to parse string to number');
         });
         it('should throw error for invalid number strings', () => {
-            expect(() => parseStringToNumber('abc')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('NaN')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('abc')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('NaN')).toThrow('Unable to parse string to number');
         });
         it('should throw error for strings with non-numeric characters', () => {
-            expect(() => parseStringToNumber('123abc')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('456def')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('12.34')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('123abc')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('456def')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('12.34')).toThrow('Unable to parse string to number');
         });
         it('should throw error for strings with mixed content', () => {
-            expect(() => parseStringToNumber('123 456')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('1,234')).toThrow('Unable to parse string to number');
-            expect(() => parseStringToNumber('1.23e4')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('123 456')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('1,234')).toThrow('Unable to parse string to number');
+            expect(() => (0, parsing_1.parseStringToNumber)('1.23e4')).toThrow('Unable to parse string to number');
         });
     });
 });

package/lib/__tests__/polling.test.js

@@ -1,5 +1,7 @@
-import { poll, DEFAULT_POLLING_STATES } from '../polling.js';
-import { DEFAULT_POLLING_DELAY } from '../constants.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const polling_1 = require("../polling");
+const constants_1 = require("../constants");
 // Helper to create a mock polling callback
 const createMockCallback = (responses) => {
     let callCount = 0;
@@ -19,56 +21,56 @@ describe('lib/polling', () => {
     describe('poll()', () => {
         it('should resolve when status is SUCCESS', async () => {
             const mockCallback = createMockCallback([
-                { status: DEFAULT_POLLING_STATES.STARTED },
-                { status: DEFAULT_POLLING_STATES.SUCCESS },
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.SUCCESS },
             ]);
-            const pollPromise = poll(mockCallback);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
             // Fast-forward through two polling intervals
-            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
             const result = await pollPromise;
-            expect(result.status).toBe(DEFAULT_POLLING_STATES.SUCCESS);
+            expect(result.status).toBe(polling_1.DEFAULT_POLLING_STATES.SUCCESS);
             expect(mockCallback).toHaveBeenCalledTimes(2);
         });
         it('should reject when status is ERROR', async () => {
             const mockCallback = createMockCallback([
-                { status: DEFAULT_POLLING_STATES.STARTED },
-                { status: DEFAULT_POLLING_STATES.ERROR },
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.ERROR },
             ]);
-            const pollPromise = poll(mockCallback);
-            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
             await expect(pollPromise).rejects.toEqual({
-                status: DEFAULT_POLLING_STATES.ERROR,
+                status: polling_1.DEFAULT_POLLING_STATES.ERROR,
             });
             expect(mockCallback).toHaveBeenCalledTimes(2);
         });
         it('should reject when status is FAILURE', async () => {
             const mockCallback = createMockCallback([
-                { status: DEFAULT_POLLING_STATES.STARTED },
-                { status: DEFAULT_POLLING_STATES.FAILURE },
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.FAILURE },
             ]);
-            const pollPromise = poll(mockCallback);
-            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
             await expect(pollPromise).rejects.toEqual({
-                status: DEFAULT_POLLING_STATES.FAILURE,
+                status: polling_1.DEFAULT_POLLING_STATES.FAILURE,
             });
         });
         it('should reject when status is REVERTED', async () => {
             const mockCallback = createMockCallback([
-                { status: DEFAULT_POLLING_STATES.STARTED },
-                { status: DEFAULT_POLLING_STATES.REVERTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.STARTED },
+                { status: polling_1.DEFAULT_POLLING_STATES.REVERTED },
             ]);
-            const pollPromise = poll(mockCallback);
-            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY * 2);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY * 2);
             await expect(pollPromise).rejects.toEqual({
-                status: DEFAULT_POLLING_STATES.REVERTED,
+                status: polling_1.DEFAULT_POLLING_STATES.REVERTED,
             });
         });
         it('should reject when callback throws an error', async () => {
             const mockCallback = vi
                 .fn()
                 .mockRejectedValue(new Error('Network error'));
-            const pollPromise = poll(mockCallback);
-            vi.advanceTimersByTime(DEFAULT_POLLING_DELAY);
+            const pollPromise = (0, polling_1.poll)(mockCallback);
+            vi.advanceTimersByTime(constants_1.DEFAULT_POLLING_DELAY);
             await expect(pollPromise).rejects.toThrow('Network error');
             expect(mockCallback).toHaveBeenCalledTimes(1);
         });

package/lib/__tests__/process.test.js

@@ -1,35 +1,40 @@
-import readline from 'readline';
-import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
-import { handleExit, handleKeypress, TERMINATION_SIGNALS } from '../process.js';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const process_1 = require("../process");
 vi.mock('readline');
 vi.mock('@hubspot/local-dev-lib/logger');
-const mockedReadline = readline;
-const mockedLogger = logger;
-const mockedSetLogLevel = setLogLevel;
+const mockedReadline = readline_1.default;
+const mockedLogger = logger_1.logger;
+const mockedSetLogLevel = logger_1.setLogLevel;
 const processRemoveListenerSpy = vi.spyOn(process, 'removeAllListeners');
 const processOnSpy = vi.spyOn(process, 'on');
 describe('lib/process', () => {
     describe('handleExit()', () => {
         const mockCallback = vi.fn();
         it('should set up listeners for all termination signals', () => {
-            handleExit(mockCallback);
-            TERMINATION_SIGNALS.forEach(signal => {
+            (0, process_1.handleExit)(mockCallback);
+            process_1.TERMINATION_SIGNALS.forEach(signal => {
                 expect(processRemoveListenerSpy).toHaveBeenCalledWith(signal);
                 expect(processOnSpy).toHaveBeenCalledWith(signal, expect.any(Function));
             });
         });
         it('should handle SIGHUP signal correctly', async () => {
-            handleExit(mockCallback);
+            (0, process_1.handleExit)(mockCallback);
             // Get the callback function passed to process.on for SIGHUP
             const sighupCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGHUP')?.[1];
             expect(sighupCallback).toBeDefined();
             sighupCallback();
-            expect(mockedSetLogLevel).toHaveBeenCalledWith(LOG_LEVEL.NONE);
+            expect(mockedSetLogLevel).toHaveBeenCalledWith(logger_1.LOG_LEVEL.NONE);
             expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: true });
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGHUP'));
         });
         it('should handle non-SIGHUP signals correctly', async () => {
-            handleExit(mockCallback);
+            (0, process_1.handleExit)(mockCallback);
             // Get the callback function passed to process.on for SIGINT
             const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
             expect(sigintCallback).toBeDefined();
@@ -39,7 +44,7 @@ describe('lib/process', () => {
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGINT'));
         });
         it('should prevent duplicate exit handling', async () => {
-            handleExit(mockCallback);
+            (0, process_1.handleExit)(mockCallback);
             // Get the callback function passed to process.on for SIGINT
             const sigintCallback = processOnSpy.mock.calls.find(call => call[0] === 'SIGINT')?.[1];
             expect(sigintCallback).toBeDefined();
@@ -62,7 +67,7 @@ describe('lib/process', () => {
             });
             mockedReadline.createInterface.mockReturnValue({});
             mockedReadline.emitKeypressEvents.mockImplementation(() => { });
-            handleKeypress(mockCallback);
+            (0, process_1.handleKeypress)(mockCallback);
             expect(mockedReadline.createInterface).toHaveBeenCalledWith(process.stdin, process.stdout);
             expect(mockedReadline.emitKeypressEvents).toHaveBeenCalledWith(process.stdin);
             expect(process.stdin.setRawMode).toHaveBeenCalledWith(true);
@@ -78,7 +83,7 @@ describe('lib/process', () => {
                     removeAllListeners: vi.fn(),
                 },
             });
-            handleKeypress(mockCallback);
+            (0, process_1.handleKeypress)(mockCallback);
             expect(process.stdin.setRawMode).toBeUndefined();
         });
     });