@hubspot/cli 7.6.0-beta.5 → 7.6.0-beta.6

package/lib/__tests__/parsing.test.js

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

package/lib/__tests__/polling.test.js

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

package/lib/__tests__/process.test.js

@@ -1,40 +1,35 @@
-"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");
+import readline from 'readline';
+import { logger, setLogLevel, LOG_LEVEL } from '@hubspot/local-dev-lib/logger';
+import { handleExit, handleKeypress, TERMINATION_SIGNALS } from '../process.js';
 vi.mock('readline');
 vi.mock('@hubspot/local-dev-lib/logger');
-const mockedReadline = readline_1.default;
-const mockedLogger = logger_1.logger;
-const mockedSetLogLevel = logger_1.setLogLevel;
+const mockedReadline = readline;
+const mockedLogger = logger;
+const mockedSetLogLevel = 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', () => {
-            (0, process_1.handleExit)(mockCallback);
-            process_1.TERMINATION_SIGNALS.forEach(signal => {
+            handleExit(mockCallback);
+            TERMINATION_SIGNALS.forEach(signal => {
                 expect(processRemoveListenerSpy).toHaveBeenCalledWith(signal);
                 expect(processOnSpy).toHaveBeenCalledWith(signal, expect.any(Function));
             });
         });
         it('should handle SIGHUP signal correctly', async () => {
-            (0, process_1.handleExit)(mockCallback);
+            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(logger_1.LOG_LEVEL.NONE);
+            expect(mockedSetLogLevel).toHaveBeenCalledWith(LOG_LEVEL.NONE);
             expect(mockCallback).toHaveBeenCalledWith({ isSIGHUP: true });
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGHUP'));
         });
         it('should handle non-SIGHUP signals correctly', async () => {
-            (0, process_1.handleExit)(mockCallback);
+            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();
@@ -44,7 +39,7 @@ describe('lib/process', () => {
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('SIGINT'));
         });
         it('should prevent duplicate exit handling', async () => {
-            (0, process_1.handleExit)(mockCallback);
+            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();
@@ -67,7 +62,7 @@ describe('lib/process', () => {
             });
             mockedReadline.createInterface.mockReturnValue({});
             mockedReadline.emitKeypressEvents.mockImplementation(() => { });
-            (0, process_1.handleKeypress)(mockCallback);
+            handleKeypress(mockCallback);
             expect(mockedReadline.createInterface).toHaveBeenCalledWith(process.stdin, process.stdout);
             expect(mockedReadline.emitKeypressEvents).toHaveBeenCalledWith(process.stdin);
             expect(process.stdin.setRawMode).toHaveBeenCalledWith(true);
@@ -83,7 +78,7 @@ describe('lib/process', () => {
                     removeAllListeners: vi.fn(),
                 },
             });
-            (0, process_1.handleKeypress)(mockCallback);
+            handleKeypress(mockCallback);
             expect(process.stdin.setRawMode).toBeUndefined();
         });
     });

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 /),