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

package/lib/__tests__/projectProfiles.test.js

@@ -1,15 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
-const en_1 = require("../../lang/en");
-const ui_1 = require("../ui");
-const logger_1 = require("../ui/logger");
-const exitCodes_1 = require("../enums/exitCodes");
-const projectProfiles_1 = require("../projectProfiles");
+import path from 'path';
+import { loadHsProfileFile, getHsProfileFilename, getAllHsProfiles, } from '@hubspot/project-parsing-lib';
+import { lib } from '../../lang/en.js';
+import { uiBetaTag, uiLine } from '../ui/index.js';
+import { uiLogger } from '../ui/logger.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { logProfileHeader, logProfileFooter, loadProfile, exitIfUsingProfiles, } from '../projectProfiles.js';
 // Mock dependencies
 vi.mock('@hubspot/project-parsing-lib');
 vi.mock('../ui');
@@ -19,21 +14,21 @@ vi.mock('../../lang/en');
 const mockExit = vi.spyOn(process, 'exit').mockImplementation(code => {
     throw new Error(`Process.exit called with code ${code}`);
 });
-const mockedLoadHsProfileFile = project_parsing_lib_1.loadHsProfileFile;
-const mockedGetHsProfileFilename = project_parsing_lib_1.getHsProfileFilename;
-const mockedGetAllHsProfiles = project_parsing_lib_1.getAllHsProfiles;
-const mockedUiBetaTag = ui_1.uiBetaTag;
-const mockedUiLine = ui_1.uiLine;
-const mockedUiLogger = logger_1.uiLogger;
+const mockedLoadHsProfileFile = loadHsProfileFile;
+const mockedGetHsProfileFilename = getHsProfileFilename;
+const mockedGetAllHsProfiles = getAllHsProfiles;
+const mockedUiBetaTag = uiBetaTag;
+const mockedUiLine = uiLine;
+const mockedUiLogger = uiLogger;
 describe('lib/projectProfiles', () => {
     describe('logProfileHeader()', () => {
         it('should log profile header with correct format', () => {
             const profileName = 'test-profile';
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            (0, projectProfiles_1.logProfileHeader)(profileName);
+            logProfileHeader(profileName);
             expect(mockedUiLine).toHaveBeenCalled();
-            expect(mockedUiBetaTag).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.usingProfile(filename));
+            expect(mockedUiBetaTag).toHaveBeenCalledWith(lib.projectProfiles.logs.usingProfile(filename));
             expect(mockedUiLogger.log).toHaveBeenCalledWith('');
         });
     });
@@ -46,16 +41,16 @@ describe('lib/projectProfiles', () => {
             },
         };
         it('should log profile footer with account ID', () => {
-            (0, projectProfiles_1.logProfileFooter)(mockProfile);
-            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            logProfileFooter(mockProfile);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
             expect(mockedUiLine).toHaveBeenCalled();
             expect(mockedUiLogger.log).toHaveBeenCalledWith('');
         });
         it('should log variables when includeVariables is true', () => {
-            (0, projectProfiles_1.logProfileFooter)(mockProfile, true);
-            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            logProfileFooter(mockProfile, true);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
             expect(mockedUiLogger.log).toHaveBeenCalledWith('');
-            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileVariables);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileVariables);
             expect(mockedUiLogger.log).toHaveBeenCalledWith('  key1: value1');
             expect(mockedUiLogger.log).toHaveBeenCalledWith('  key2: value2');
             expect(mockedUiLine).toHaveBeenCalled();
@@ -74,25 +69,25 @@ describe('lib/projectProfiles', () => {
             accountId: 123,
         };
         it('should return undefined when project config is missing', () => {
-            const result = (0, projectProfiles_1.loadProfile)(null, mockProjectDir, mockProfileName);
+            const result = loadProfile(null, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.noProjectConfig);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.noProjectConfig);
         });
         it('should return undefined when profile is not found', () => {
             mockedLoadHsProfileFile.mockReturnValue(null);
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
         });
         it('should return undefined when profile has no account ID', () => {
             mockedLoadHsProfileFile.mockReturnValue({});
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
         });
         it('should return undefined when profile loading fails', () => {
             mockedLoadHsProfileFile.mockImplementation(() => {
@@ -100,15 +95,15 @@ describe('lib/projectProfiles', () => {
             });
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
         });
         it('should return profile when loading succeeds', () => {
             mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toEqual(mockProfile);
-            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path_1.default.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
         });
     });
     describe('exitIfUsingProfiles()', () => {
@@ -120,15 +115,15 @@ describe('lib/projectProfiles', () => {
         const mockProjectDir = '/test/project';
         it('should not exit when no profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue([]);
-            await (0, projectProfiles_1.exitIfUsingProfiles)(mockProjectConfig, mockProjectDir);
+            await exitIfUsingProfiles(mockProjectConfig, mockProjectDir);
             expect(mockedUiLogger.error).not.toHaveBeenCalled();
             expect(mockExit).not.toHaveBeenCalled();
         });
         it('should exit with error when profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue(['profile1', 'profile2']);
-            await expect((0, projectProfiles_1.exitIfUsingProfiles)(mockProjectConfig, mockProjectDir)).rejects.toThrow(`Process.exit called with code ${exitCodes_1.EXIT_CODES.ERROR}`);
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
-            expect(mockExit).toHaveBeenCalledWith(exitCodes_1.EXIT_CODES.ERROR);
+            await expect(exitIfUsingProfiles(mockProjectConfig, mockProjectDir)).rejects.toThrow(`Process.exit called with code ${EXIT_CODES.ERROR}`);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.exitIfUsingProfiles.errors.noProfileSpecified);
+            expect(mockExit).toHaveBeenCalledWith(EXIT_CODES.ERROR);
         });
     });
 });

package/lib/__tests__/sandboxSync.test.js

@@ -1,41 +1,36 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const sandboxSync_1 = require("@hubspot/local-dev-lib/api/sandboxSync");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const testUtils_1 = require("../testUtils");
-const sandboxes_1 = require("../sandboxes");
-const sandboxSync_2 = require("../sandboxSync");
-const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getAccountId } from '@hubspot/local-dev-lib/config';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import { getAvailableSyncTypes } from '../sandboxes.js';
+import { syncSandbox } from '../sandboxSync.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
 vi.mock('@hubspot/local-dev-lib/config');
 vi.mock('../sandboxes');
 vi.mock('../ui/SpinniesManager');
-const mockedLogger = logger_1.logger;
-const mockedInitiateSync = sandboxSync_1.initiateSync;
-const mockedGetAccountId = config_1.getAccountId;
-const mockedGetAvailableSyncTypes = sandboxes_1.getAvailableSyncTypes;
-const mockedSpinniesInit = SpinniesManager_1.default.init;
-const mockedSpinniesAdd = SpinniesManager_1.default.add;
-const mockedSpinniesSucceed = SpinniesManager_1.default.succeed;
-const mockedSpinniesFail = SpinniesManager_1.default.fail;
+const mockedLogger = logger;
+const mockedInitiateSync = initiateSync;
+const mockedGetAccountId = getAccountId;
+const mockedGetAvailableSyncTypes = getAvailableSyncTypes;
+const mockedSpinniesInit = SpinniesManager.init;
+const mockedSpinniesAdd = SpinniesManager.add;
+const mockedSpinniesSucceed = SpinniesManager.succeed;
+const mockedSpinniesFail = SpinniesManager.fail;
 describe('lib/sandboxSync', () => {
     const mockEnv = 'qa';
     const mockParentAccount = {
         name: 'Parent Account',
         portalId: 123,
-        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
         env: mockEnv,
     };
     const mockChildAccount = {
         name: 'Child Account',
         portalId: 456,
-        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         env: mockEnv,
     };
     const mockSyncTasks = [{ type: 'mock-sync-type' }];
@@ -48,7 +43,7 @@ describe('lib/sandboxSync', () => {
     describe('syncSandbox()', () => {
         it('successfully syncs a sandbox with provided sync tasks', async () => {
             mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
             expect(mockedSpinniesInit).toHaveBeenCalled();
             expect(mockedSpinniesAdd).toHaveBeenCalled();
             expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.portalId, mockChildAccount.portalId, mockSyncTasks, mockChildAccount.portalId);
@@ -56,7 +51,7 @@ describe('lib/sandboxSync', () => {
         });
         it('fetches sync types when no tasks are provided', async () => {
             mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, []);
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, []);
             expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
             expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
             expect(mockedInitiateSync).toHaveBeenCalled();
@@ -65,10 +60,10 @@ describe('lib/sandboxSync', () => {
             mockedGetAccountId.mockReset();
             mockedGetAccountId.mockReturnValue(null);
             const errorRegex = new RegExp(`Couldn't sync ${mockChildAccount.portalId} because your account has been removed from`);
-            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
         });
         it('handles sync in progress error', async () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+            const error = mockHubSpotHttpError('', {
                 status: 429,
                 data: {
                     category: 'RATE_LIMITS',
@@ -76,12 +71,12 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
             expect(mockedSpinniesFail).toHaveBeenCalled();
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because there's another sync in progress/));
         });
         it('handles invalid user error', async () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+            const error = mockHubSpotHttpError('', {
                 status: 403,
                 data: {
                     category: 'BANNED',
@@ -89,12 +84,12 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
             expect(mockedSpinniesFail).toHaveBeenCalled();
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/because your account has been removed from/));
         });
         it('handles not super admin error', async () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+            const error = mockHubSpotHttpError('', {
                 status: 403,
                 data: {
                     category: 'BANNED',
@@ -102,12 +97,12 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
             expect(mockedSpinniesFail).toHaveBeenCalled();
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because you are not a super admin in/));
         });
         it('handles sandbox not found error', async () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
+            const error = mockHubSpotHttpError('', {
                 status: 404,
                 data: {
                     category: 'OBJECT_NOT_FOUND',
@@ -115,13 +110,13 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
             expect(mockedSpinniesFail).toHaveBeenCalled();
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/may have been deleted through the UI/));
         });
         it('displays slim info message when specified', async () => {
             mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
+            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
             expect(mockedLogger.info).not.toHaveBeenCalled();
             expect(mockedSpinniesSucceed).toHaveBeenCalledWith('sandboxSync', expect.objectContaining({
                 text: expect.stringMatching(/Initiated sync of object definitions from production to /),

package/lib/__tests__/sandboxes.test.js

@@ -1,31 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const sandboxHubs_1 = require("@hubspot/local-dev-lib/api/sandboxHubs");
-const sandboxSync_1 = require("@hubspot/local-dev-lib/api/sandboxSync");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const testUtils_1 = require("../testUtils");
-const sandboxes_1 = require("../sandboxes");
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
+import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { mockHubSpotHttpError } from '../testUtils.js';
+import { getSandboxTypeAsString, getHasSandboxesByType, getAvailableSyncTypes, validateSandboxUsageLimits, handleSandboxCreateError, } from '../sandboxes.js';
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/local-dev-lib/api/sandboxHubs');
 vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
 vi.mock('@hubspot/local-dev-lib/config');
-const mockedGetAccountId = config_1.getAccountId;
-const mockedGetSandboxUsageLimits = sandboxHubs_1.getSandboxUsageLimits;
-const mockedFetchTypes = sandboxSync_1.fetchTypes;
-const mockedGetConfigAccounts = config_1.getConfigAccounts;
-const mockedLogger = logger_1.logger;
+const mockedGetAccountId = getAccountId;
+const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
+const mockedFetchTypes = fetchTypes;
+const mockedGetConfigAccounts = getConfigAccounts;
+const mockedLogger = logger;
 describe('lib/sandboxes', () => {
     describe('getSandboxTypeAsString()', () => {
         it('returns "development" for development sandbox type', () => {
-            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
+            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
         });
         it('returns "standard" for standard sandbox type', () => {
-            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
+            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
         });
         it('returns "standard" for undefined input', () => {
-            expect((0, sandboxes_1.getSandboxTypeAsString)(undefined)).toBe('standard');
+            expect(getSandboxTypeAsString(undefined)).toBe('standard');
         });
     });
     describe('getHasSandboxesByType()', () => {
@@ -33,7 +31,7 @@ describe('lib/sandboxes', () => {
             name: 'Parent Account',
             portalId: 123,
             authType: undefined,
-            accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
             env: 'qa',
         };
         it('returns true when sandbox of specified type exists', () => {
@@ -43,14 +41,14 @@ describe('lib/sandboxes', () => {
                 {
                     ...mockParentAccount,
                     parentAccountId: 123,
-                    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                    accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 },
             ]);
-            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
+            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
         });
         it('returns false when no sandbox of specified type exists', () => {
             mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
-            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
+            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
         });
     });
     describe('getAvailableSyncTypes()', () => {
@@ -71,12 +69,12 @@ describe('lib/sandboxes', () => {
             mockedFetchTypes.mockResolvedValue({
                 data: { results: mockSyncTypes },
             });
-            const result = await (0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount);
+            const result = await getAvailableSyncTypes(mockParentAccount, mockChildAccount);
             expect(result).toEqual([{ type: 'type1' }, { type: 'type2' }]);
         });
         it('throws error when sync types fetch fails', async () => {
             mockedFetchTypes.mockResolvedValue({ data: { results: null } });
-            await expect((0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
+            await expect(getAvailableSyncTypes(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
         });
     });
     describe('validateSandboxUsageLimits()', () => {
@@ -93,7 +91,7 @@ describe('lib/sandboxes', () => {
                     usage: { DEVELOPER: { available: 1, limit: 3 } },
                 },
             });
-            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
+            await expect(validateSandboxUsageLimits(mockAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
         });
         it('throws error when development sandbox limit is reached', async () => {
             mockedGetAccountId.mockReturnValue(mockAccount.portalId);
@@ -103,7 +101,7 @@ describe('lib/sandboxes', () => {
                     usage: { DEVELOPER: { available: 0, limit: 1 } },
                 },
             });
-            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
+            await expect(validateSandboxUsageLimits(mockAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
         });
     });
     describe('handleSandboxCreateError()', () => {
@@ -111,37 +109,37 @@ describe('lib/sandboxes', () => {
         const mockName = 'Test Sandbox';
         const mockAccountId = 123;
         it('handles missing scope error', () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('missing scopes error', {
+            const error = mockHubSpotHttpError('missing scopes error', {
                 status: 403,
                 data: {
                     message: 'Missing scopes error',
                     category: 'MISSING_SCOPES',
                 },
             });
-            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/The personal access key you provided doesn't include sandbox permissions/));
             expect(mockedLogger.info).toHaveBeenCalledWith(expect.stringMatching(/To update CLI permissions for/));
         });
         it('handles user access not allowed error', () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('user access not allowed error', {
+            const error = mockHubSpotHttpError('user access not allowed error', {
                 status: 403,
                 data: {
                     category: 'BANNED',
                     subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
                 },
             });
-            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/your permission set doesn't allow you to create the sandbox/));
         });
         it('handles 403 gating error', () => {
-            const error = (0, testUtils_1.mockHubSpotHttpError)('403 gating error', {
+            const error = mockHubSpotHttpError('403 gating error', {
                 status: 403,
                 data: {
                     category: 'BANNED',
                     subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
                 },
             });
-            expect(() => (0, sandboxes_1.handleSandboxCreateError)(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
             expect(mockedLogger.error).toHaveBeenCalledWith(expect.stringMatching(/does not have access to development sandboxes/));
         });
     });

package/lib/__tests__/serverlessLogs.test.js

@@ -1,11 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const mock_stdin_1 = __importDefault(require("mock-stdin"));
-const serverlessFunctionLogs_1 = require("../ui/serverlessFunctionLogs");
-const serverlessLogs_1 = require("../serverlessLogs");
+import mockStdIn from 'mock-stdin';
+import { outputLogs } from '../ui/serverlessFunctionLogs.js';
+import { tailLogs } from '../serverlessLogs.js';
 vi.mock('../ui/serverlessFunctionLogs');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('../ui/SpinniesManager', () => ({
@@ -26,7 +21,7 @@ describe('lib/serverlessLogs', () => {
         beforeEach(() => {
             // @ts-ignore - we don't need to mock the entire process object
             vi.spyOn(process, 'exit').mockImplementation(() => { });
-            stdinMock = mock_stdin_1.default.stdin();
+            stdinMock = mockStdIn.stdin();
         });
         afterEach(() => {
             vi.clearAllTimers();
@@ -69,7 +64,7 @@ describe('lib/serverlessLogs', () => {
                 });
             });
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
             vi.runOnlyPendingTimers();
             expect(fetchLatest).toHaveBeenCalled();
             expect(tailCall).toHaveBeenCalledTimes(2);
@@ -125,9 +120,9 @@ describe('lib/serverlessLogs', () => {
             };
             const tailCall = vi.fn(() => Promise.resolve({ data: latestLogResponse }));
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
             vi.runOnlyPendingTimers();
-            expect(serverlessFunctionLogs_1.outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
             expect(tailCall).toHaveBeenCalledTimes(2);
         });
         it('handles no logs', async () => {
@@ -146,7 +141,7 @@ describe('lib/serverlessLogs', () => {
                 stackTrace: [],
                 statusCode: 404,
             }));
-            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
             vi.runOnlyPendingTimers();
             expect(tailCall).toHaveBeenCalledTimes(2);
         });