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

package/lib/__tests__/projectProfiles.test.js

@@ -1,10 +1,15 @@
-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';
+"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");
 // Mock dependencies
 vi.mock('@hubspot/project-parsing-lib');
 vi.mock('../ui');
@@ -14,21 +19,21 @@ vi.mock('../../lang/en');
 const mockExit = vi.spyOn(process, 'exit').mockImplementation(code => {
     throw new Error(`Process.exit called with code ${code}`);
 });
-const mockedLoadHsProfileFile = loadHsProfileFile;
-const mockedGetHsProfileFilename = getHsProfileFilename;
-const mockedGetAllHsProfiles = getAllHsProfiles;
-const mockedUiBetaTag = uiBetaTag;
-const mockedUiLine = uiLine;
-const mockedUiLogger = uiLogger;
+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;
 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);
-            logProfileHeader(profileName);
+            (0, projectProfiles_1.logProfileHeader)(profileName);
             expect(mockedUiLine).toHaveBeenCalled();
-            expect(mockedUiBetaTag).toHaveBeenCalledWith(lib.projectProfiles.logs.usingProfile(filename));
+            expect(mockedUiBetaTag).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.usingProfile(filename));
             expect(mockedUiLogger.log).toHaveBeenCalledWith('');
         });
     });
@@ -41,16 +46,16 @@ describe('lib/projectProfiles', () => {
             },
         };
         it('should log profile footer with account ID', () => {
-            logProfileFooter(mockProfile);
-            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            (0, projectProfiles_1.logProfileFooter)(mockProfile);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
             expect(mockedUiLine).toHaveBeenCalled();
             expect(mockedUiLogger.log).toHaveBeenCalledWith('');
         });
         it('should log variables when includeVariables is true', () => {
-            logProfileFooter(mockProfile, true);
-            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
+            (0, projectProfiles_1.logProfileFooter)(mockProfile, true);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileTargetAccount(mockProfile.accountId));
             expect(mockedUiLogger.log).toHaveBeenCalledWith('');
-            expect(mockedUiLogger.log).toHaveBeenCalledWith(lib.projectProfiles.logs.profileVariables);
+            expect(mockedUiLogger.log).toHaveBeenCalledWith(en_1.lib.projectProfiles.logs.profileVariables);
             expect(mockedUiLogger.log).toHaveBeenCalledWith('  key1: value1');
             expect(mockedUiLogger.log).toHaveBeenCalledWith('  key2: value2');
             expect(mockedUiLine).toHaveBeenCalled();
@@ -69,25 +74,25 @@ describe('lib/projectProfiles', () => {
             accountId: 123,
         };
         it('should return undefined when project config is missing', () => {
-            const result = loadProfile(null, mockProjectDir, mockProfileName);
+            const result = (0, projectProfiles_1.loadProfile)(null, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.noProjectConfig);
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.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 = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.profileNotFound(filename));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.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 = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.missingAccountId(filename));
         });
         it('should return undefined when profile loading fails', () => {
             mockedLoadHsProfileFile.mockImplementation(() => {
@@ -95,15 +100,15 @@ describe('lib/projectProfiles', () => {
             });
             const filename = 'test-profile.hsprofile';
             mockedGetHsProfileFilename.mockReturnValue(filename);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toBeUndefined();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
+            expect(mockedUiLogger.error).toHaveBeenCalledWith(en_1.lib.projectProfiles.loadProfile.errors.failedToLoadProfile(filename));
         });
         it('should return profile when loading succeeds', () => {
             mockedLoadHsProfileFile.mockReturnValue(mockProfile);
-            const result = loadProfile(mockProjectConfig, mockProjectDir, mockProfileName);
+            const result = (0, projectProfiles_1.loadProfile)(mockProjectConfig, mockProjectDir, mockProfileName);
             expect(result).toEqual(mockProfile);
-            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
+            expect(mockedLoadHsProfileFile).toHaveBeenCalledWith(path_1.default.join(mockProjectDir, mockProjectConfig.srcDir), mockProfileName);
         });
     });
     describe('exitIfUsingProfiles()', () => {
@@ -115,15 +120,15 @@ describe('lib/projectProfiles', () => {
         const mockProjectDir = '/test/project';
         it('should not exit when no profiles exist', async () => {
             mockedGetAllHsProfiles.mockResolvedValue([]);
-            await exitIfUsingProfiles(mockProjectConfig, mockProjectDir);
+            await (0, projectProfiles_1.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(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);
+            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);
         });
     });
 });

package/lib/__tests__/sandboxSync.test.js

@@ -1,36 +1,41 @@
-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';
+"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"));
 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;
-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;
+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;
 describe('lib/sandboxSync', () => {
     const mockEnv = 'qa';
     const mockParentAccount = {
         name: 'Parent Account',
         portalId: 123,
-        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
         env: mockEnv,
     };
     const mockChildAccount = {
         name: 'Child Account',
         portalId: 456,
-        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
         env: mockEnv,
     };
     const mockSyncTasks = [{ type: 'mock-sync-type' }];
@@ -43,7 +48,7 @@ describe('lib/sandboxSync', () => {
     describe('syncSandbox()', () => {
         it('successfully syncs a sandbox with provided sync tasks', async () => {
             mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
+            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
             expect(mockedSpinniesInit).toHaveBeenCalled();
             expect(mockedSpinniesAdd).toHaveBeenCalled();
             expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.portalId, mockChildAccount.portalId, mockSyncTasks, mockChildAccount.portalId);
@@ -51,7 +56,7 @@ describe('lib/sandboxSync', () => {
         });
         it('fetches sync types when no tasks are provided', async () => {
             mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, []);
+            await (0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, []);
             expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
             expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
             expect(mockedInitiateSync).toHaveBeenCalled();
@@ -60,10 +65,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(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
+            await expect((0, sandboxSync_2.syncSandbox)(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
         });
         it('handles sync in progress error', async () => {
-            const error = mockHubSpotHttpError('', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
                 status: 429,
                 data: {
                     category: 'RATE_LIMITS',
@@ -71,12 +76,12 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect((0, sandboxSync_2.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 = mockHubSpotHttpError('', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
                 status: 403,
                 data: {
                     category: 'BANNED',
@@ -84,12 +89,12 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect((0, sandboxSync_2.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 = mockHubSpotHttpError('', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
                 status: 403,
                 data: {
                     category: 'BANNED',
@@ -97,12 +102,12 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect((0, sandboxSync_2.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 = mockHubSpotHttpError('', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('', {
                 status: 404,
                 data: {
                     category: 'OBJECT_NOT_FOUND',
@@ -110,13 +115,13 @@ describe('lib/sandboxSync', () => {
                 },
             });
             mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
+            await expect((0, sandboxSync_2.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 syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
+            await (0, sandboxSync_2.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,29 +1,31 @@
-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';
+"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");
 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 = getAccountId;
-const mockedGetSandboxUsageLimits = getSandboxUsageLimits;
-const mockedFetchTypes = fetchTypes;
-const mockedGetConfigAccounts = getConfigAccounts;
-const mockedLogger = logger;
+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;
 describe('lib/sandboxes', () => {
     describe('getSandboxTypeAsString()', () => {
         it('returns "development" for development sandbox type', () => {
-            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
+            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe('development');
         });
         it('returns "standard" for standard sandbox type', () => {
-            expect(getSandboxTypeAsString(HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
+            expect((0, sandboxes_1.getSandboxTypeAsString)(config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)).toBe('standard');
         });
         it('returns "standard" for undefined input', () => {
-            expect(getSandboxTypeAsString(undefined)).toBe('standard');
+            expect((0, sandboxes_1.getSandboxTypeAsString)(undefined)).toBe('standard');
         });
     });
     describe('getHasSandboxesByType()', () => {
@@ -31,7 +33,7 @@ describe('lib/sandboxes', () => {
             name: 'Parent Account',
             portalId: 123,
             authType: undefined,
-            accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+            accountType: config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
             env: 'qa',
         };
         it('returns true when sandbox of specified type exists', () => {
@@ -41,14 +43,14 @@ describe('lib/sandboxes', () => {
                 {
                     ...mockParentAccount,
                     parentAccountId: 123,
-                    accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+                    accountType: config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
                 },
             ]);
-            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
+            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(true);
         });
         it('returns false when no sandbox of specified type exists', () => {
             mockedGetConfigAccounts.mockReturnValue([mockParentAccount]);
-            expect(getHasSandboxesByType(mockParentAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
+            expect((0, sandboxes_1.getHasSandboxesByType)(mockParentAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)).toBe(false);
         });
     });
     describe('getAvailableSyncTypes()', () => {
@@ -69,12 +71,12 @@ describe('lib/sandboxes', () => {
             mockedFetchTypes.mockResolvedValue({
                 data: { results: mockSyncTypes },
             });
-            const result = await getAvailableSyncTypes(mockParentAccount, mockChildAccount);
+            const result = await (0, sandboxes_1.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(getAvailableSyncTypes(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
+            await expect((0, sandboxes_1.getAvailableSyncTypes)(mockParentAccount, mockChildAccount)).rejects.toThrow(/Unable to fetch available sandbox sync types/);
         });
     });
     describe('validateSandboxUsageLimits()', () => {
@@ -91,7 +93,7 @@ describe('lib/sandboxes', () => {
                     usage: { DEVELOPER: { available: 1, limit: 3 } },
                 },
             });
-            await expect(validateSandboxUsageLimits(mockAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
+            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).resolves.not.toThrow();
         });
         it('throws error when development sandbox limit is reached', async () => {
             mockedGetAccountId.mockReturnValue(mockAccount.portalId);
@@ -101,7 +103,7 @@ describe('lib/sandboxes', () => {
                     usage: { DEVELOPER: { available: 0, limit: 1 } },
                 },
             });
-            await expect(validateSandboxUsageLimits(mockAccount, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
+            await expect((0, sandboxes_1.validateSandboxUsageLimits)(mockAccount, config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'qa')).rejects.toThrow(/reached the limit of 1 development sandbox/);
         });
     });
     describe('handleSandboxCreateError()', () => {
@@ -109,37 +111,37 @@ describe('lib/sandboxes', () => {
         const mockName = 'Test Sandbox';
         const mockAccountId = 123;
         it('handles missing scope error', () => {
-            const error = mockHubSpotHttpError('missing scopes error', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('missing scopes error', {
                 status: 403,
                 data: {
                     message: 'Missing scopes error',
                     category: 'MISSING_SCOPES',
                 },
             });
-            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(() => (0, sandboxes_1.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 = mockHubSpotHttpError('user access not allowed error', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('user access not allowed error', {
                 status: 403,
                 data: {
                     category: 'BANNED',
                     subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
                 },
             });
-            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(() => (0, sandboxes_1.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 = mockHubSpotHttpError('403 gating error', {
+            const error = (0, testUtils_1.mockHubSpotHttpError)('403 gating error', {
                 status: 403,
                 data: {
                     category: 'BANNED',
                     subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
                 },
             });
-            expect(() => handleSandboxCreateError(error, mockEnv, mockName, mockAccountId)).toThrow(error);
+            expect(() => (0, sandboxes_1.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,6 +1,11 @@
-import mockStdIn from 'mock-stdin';
-import { outputLogs } from '../ui/serverlessFunctionLogs.js';
-import { tailLogs } from '../serverlessLogs.js';
+"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");
 vi.mock('../ui/serverlessFunctionLogs');
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('../ui/SpinniesManager', () => ({
@@ -21,7 +26,7 @@ describe('lib/serverlessLogs', () => {
         beforeEach(() => {
             // @ts-ignore - we don't need to mock the entire process object
             vi.spyOn(process, 'exit').mockImplementation(() => { });
-            stdinMock = mockStdIn.stdin();
+            stdinMock = mock_stdin_1.default.stdin();
         });
         afterEach(() => {
             vi.clearAllTimers();
@@ -64,7 +69,7 @@ describe('lib/serverlessLogs', () => {
                 });
             });
             // @ts-ignore - headers is not used in the actual function and does not need to be mocked
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
             vi.runOnlyPendingTimers();
             expect(fetchLatest).toHaveBeenCalled();
             expect(tailCall).toHaveBeenCalledTimes(2);
@@ -120,9 +125,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 tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
             vi.runOnlyPendingTimers();
-            expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(serverlessFunctionLogs_1.outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
             expect(tailCall).toHaveBeenCalledTimes(2);
         });
         it('handles no logs', async () => {
@@ -141,7 +146,7 @@ describe('lib/serverlessLogs', () => {
                 stackTrace: [],
                 statusCode: 404,
             }));
-            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            await (0, serverlessLogs_1.tailLogs)(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
             vi.runOnlyPendingTimers();
             expect(tailCall).toHaveBeenCalledTimes(2);
         });