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

package/lib/projects/__tests__/LocalDevProcess.test.js

@@ -1,31 +1,26 @@
-"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 upload_1 = require("../upload");
-const config_1 = require("../config");
-const LocalDevProcess_1 = __importDefault(require("../localDev/LocalDevProcess"));
-const LocalDevLogger_1 = __importDefault(require("../localDev/LocalDevLogger"));
-const DevServerManagerV2_1 = __importDefault(require("../localDev/DevServerManagerV2"));
-const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
-const vitest_1 = require("vitest");
+import path from 'path';
+import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { handleProjectUpload } from '../upload.js';
+import { getProjectConfig } from '../config.js';
+import LocalDevProcess from '../localDev/LocalDevProcess.js';
+import LocalDevLogger from '../localDev/LocalDevLogger.js';
+import DevServerManagerV2 from '../localDev/DevServerManagerV2.js';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { vi } from 'vitest';
 // Mock @hubspot/ui-extensions-dev-server
-vitest_1.vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+vi.mock('@hubspot/ui-extensions-dev-server', () => ({
     DevModeUnifiedInterface: {
-        setup: vitest_1.vi.fn().mockResolvedValue(undefined),
-        start: vitest_1.vi.fn().mockResolvedValue(undefined),
-        fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
-        cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
+        setup: vi.fn().mockResolvedValue(undefined),
+        start: vi.fn().mockResolvedValue(undefined),
+        fileChange: vi.fn().mockResolvedValue(undefined),
+        cleanup: vi.fn().mockResolvedValue(undefined),
     },
 }));
-vitest_1.vi.mock('@hubspot/project-parsing-lib');
-vitest_1.vi.mock('../upload');
-vitest_1.vi.mock('../config');
-vitest_1.vi.mock('../localDev/LocalDevLogger');
-vitest_1.vi.mock('../localDev/DevServerManagerV2');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../upload');
+vi.mock('../config');
+vi.mock('../localDev/LocalDevLogger');
+vi.mock('../localDev/DevServerManagerV2');
 // Tests for LocalDevProcess and LocalDevState
 describe('LocalDevProcess', () => {
     let mockLocalDevLogger;
@@ -79,51 +74,51 @@ describe('LocalDevProcess', () => {
         projectId: 789,
         isGithubLinked: false,
         initialProjectNodes: {},
-        env: environments_1.ENVIRONMENTS.PROD,
+        env: ENVIRONMENTS.PROD,
         deployedBuild: mockBuild,
         projectName: 'test-project',
     };
     beforeEach(() => {
-        vitest_1.vi.clearAllMocks();
+        vi.clearAllMocks();
         mockLocalDevLogger = {
-            resetSpinnies: vitest_1.vi.fn(),
-            devServerSetupError: vitest_1.vi.fn(),
-            devServerStartError: vitest_1.vi.fn(),
-            devServerCleanupError: vitest_1.vi.fn(),
-            missingComponentsWarning: vitest_1.vi.fn(),
-            noDeployedBuild: vitest_1.vi.fn(),
-            startupMessage: vitest_1.vi.fn(),
-            monitorConsoleOutput: vitest_1.vi.fn(),
-            cleanupStart: vitest_1.vi.fn(),
-            cleanupError: vitest_1.vi.fn(),
-            cleanupSuccess: vitest_1.vi.fn(),
-            uploadInitiated: vitest_1.vi.fn(),
-            projectConfigMismatch: vitest_1.vi.fn(),
-            uploadError: vitest_1.vi.fn(),
-            uploadSuccess: vitest_1.vi.fn(),
-            clearUploadWarnings: vitest_1.vi.fn(),
-            fileChangeError: vitest_1.vi.fn(),
-            uploadWarning: vitest_1.vi.fn(),
+            resetSpinnies: vi.fn(),
+            devServerSetupError: vi.fn(),
+            devServerStartError: vi.fn(),
+            devServerCleanupError: vi.fn(),
+            missingComponentsWarning: vi.fn(),
+            noDeployedBuild: vi.fn(),
+            startupMessage: vi.fn(),
+            monitorConsoleOutput: vi.fn(),
+            cleanupStart: vi.fn(),
+            cleanupError: vi.fn(),
+            cleanupSuccess: vi.fn(),
+            uploadInitiated: vi.fn(),
+            projectConfigMismatch: vi.fn(),
+            uploadError: vi.fn(),
+            uploadSuccess: vi.fn(),
+            clearUploadWarnings: vi.fn(),
+            fileChangeError: vi.fn(),
+            uploadWarning: vi.fn(),
         };
         mockDevServerManager = {
-            setup: vitest_1.vi.fn().mockResolvedValue(undefined),
-            start: vitest_1.vi.fn().mockResolvedValue(undefined),
-            cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
-            fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
+            setup: vi.fn().mockResolvedValue(undefined),
+            start: vi.fn().mockResolvedValue(undefined),
+            cleanup: vi.fn().mockResolvedValue(undefined),
+            fileChange: vi.fn().mockResolvedValue(undefined),
         };
         // Mock constructors
-        LocalDevLogger_1.default.mockImplementation(() => mockLocalDevLogger);
-        DevServerManagerV2_1.default.mockImplementation(() => mockDevServerManager);
+        LocalDevLogger.mockImplementation(() => mockLocalDevLogger);
+        DevServerManagerV2.mockImplementation(() => mockDevServerManager);
         // Create process instance
-        process = new LocalDevProcess_1.default(mockOptions);
+        process = new LocalDevProcess(mockOptions);
         // Mock process.exit
-        vitest_1.vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+        vi.spyOn(global.process, 'exit').mockImplementation((code) => {
             throw new Error(`Process.exit called with code ${code}`);
         });
     });
     describe('start()', () => {
         it('should exit if no deployed build exists', async () => {
-            const processWithoutBuild = new LocalDevProcess_1.default({
+            const processWithoutBuild = new LocalDevProcess({
                 ...mockOptions,
                 deployedBuild: undefined,
             });
@@ -156,7 +151,7 @@ describe('LocalDevProcess', () => {
                 config: {},
                 files: [],
             };
-            const processWithNode = new LocalDevProcess_1.default({
+            const processWithNode = new LocalDevProcess({
                 ...mockOptions,
                 initialProjectNodes: {
                     component3: mockNode,
@@ -187,13 +182,13 @@ describe('LocalDevProcess', () => {
     describe('updateProjectNodes()', () => {
         it('should update project nodes with translated representation', async () => {
             const mockNodes = { node1: { uid: 'node1' } };
-            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+            translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: mockNodes,
             });
             // @ts-expect-error testing private method
             await process.updateProjectNodes();
-            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path_1.default.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
             }, { projectNodesAtLastUpload: {} });
@@ -202,18 +197,18 @@ describe('LocalDevProcess', () => {
     });
     describe('uploadProject()', () => {
         it('should not upload if project config is invalid', async () => {
-            config_1.getProjectConfig.mockResolvedValue({
+            getProjectConfig.mockResolvedValue({
                 projectConfig: null,
             });
             await process.uploadProject();
             expect(mockLocalDevLogger.projectConfigMismatch).toHaveBeenCalled();
-            expect(upload_1.handleProjectUpload).not.toHaveBeenCalled();
+            expect(handleProjectUpload).not.toHaveBeenCalled();
         });
         it('should handle upload error', async () => {
-            config_1.getProjectConfig.mockResolvedValue({
+            getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
-            upload_1.handleProjectUpload.mockResolvedValue({
+            handleProjectUpload.mockResolvedValue({
                 uploadError: new Error('Upload failed'),
             });
             const success = await process.uploadProject();
@@ -222,10 +217,10 @@ describe('LocalDevProcess', () => {
         });
         it('should handle successful upload', async () => {
             await process.handleConfigFileChange();
-            config_1.getProjectConfig.mockResolvedValue({
+            getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
-            upload_1.handleProjectUpload.mockResolvedValue({
+            handleProjectUpload.mockResolvedValue({
                 uploadError: null,
             });
             const success = await process.uploadProject();
@@ -238,19 +233,19 @@ describe('LocalDevProcess', () => {
             const initialProjectNodes = { existingNode: { uid: 'existingNode' } };
             // @ts-expect-error accessing private property for testing
             process.state._projectNodesAtLastUpload = initialProjectNodes;
-            config_1.getProjectConfig.mockResolvedValue({
+            getProjectConfig.mockResolvedValue({
                 projectConfig: mockOptions.projectConfig,
             });
-            upload_1.handleProjectUpload.mockResolvedValue({
+            handleProjectUpload.mockResolvedValue({
                 uploadError: null,
             });
-            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+            translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: mockNodes,
             });
             const success = await process.uploadProject();
             // Verify translateForLocalDev was called without projectNodesAtLastUpload option
-            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path_1.default.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
             }, { projectNodesAtLastUpload: undefined });
@@ -281,14 +276,14 @@ describe('LocalDevProcess', () => {
     });
     describe('handleConfigFileChange()', () => {
         beforeEach(() => {
-            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+            translateForLocalDev.mockResolvedValue({
                 intermediateNodesIndexedByUid: {},
             });
         });
         it('should update project nodes and show upload warning', async () => {
             await process.handleConfigFileChange();
-            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
-                projectSourceDir: path_1.default.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
+            expect(translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path.join(mockOptions.projectDir, mockOptions.projectConfig.srcDir),
                 platformVersion: mockOptions.projectConfig.platformVersion,
                 accountId: mockOptions.targetProjectAccountId,
             }, { projectNodesAtLastUpload: {} });
@@ -297,7 +292,7 @@ describe('LocalDevProcess', () => {
     });
     describe('addStateListener()', () => {
         it('should add state listener', () => {
-            const listener = vitest_1.vi.fn();
+            const listener = vi.fn();
             const key = 'projectNodes';
             process.addStateListener(key, listener);
             // @ts-expect-error
@@ -305,7 +300,7 @@ describe('LocalDevProcess', () => {
             expect(listener).toHaveBeenCalled();
         });
         it('should call listener immediately when callOnInit is true', () => {
-            const listener = vitest_1.vi.fn();
+            const listener = vi.fn();
             const key = 'projectNodes';
             process.addStateListener(key, listener, true);
             expect(listener).toHaveBeenCalledWith(process.projectNodes);

package/lib/projects/__tests__/LocalDevWebsocketServer.test.js

@@ -1,14 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ws_1 = require("ws");
-const portManager_1 = require("@hubspot/local-dev-lib/portManager");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const constants_1 = require("../../constants");
-const LocalDevWebsocketServer_1 = __importDefault(require("../localDev/LocalDevWebsocketServer"));
-const en_1 = require("../../../lang/en");
+import { WebSocketServer } from 'ws';
+import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
+import LocalDevWebsocketServer from '../localDev/LocalDevWebsocketServer.js';
+import { lib } from '../../../lang/en.js';
 vi.mock('ws');
 vi.mock('@hubspot/local-dev-lib/portManager');
 vi.mock('@hubspot/local-dev-lib/logger');
@@ -38,28 +33,28 @@ describe('LocalDevWebsocketServer', () => {
             sendDevServerMessage: vi.fn(),
         };
         // Mock WebSocketServer constructor
-        ws_1.WebSocketServer.mockImplementation(() => mockWebSocketServer);
+        WebSocketServer.mockImplementation(() => mockWebSocketServer);
         // Create server instance
-        server = new LocalDevWebsocketServer_1.default(mockLocalDevProcess, true);
+        server = new LocalDevWebsocketServer(mockLocalDevProcess, true);
     });
     describe('start()', () => {
         it('should throw error if port manager is not running', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(false);
+            isPortManagerServerRunning.mockResolvedValue(false);
             await expect(server.start()).rejects.toThrow();
         });
         it('should start websocket server successfully', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
-            expect(ws_1.WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
+            expect(WebSocketServer).toHaveBeenCalledWith({ port: 1234 });
             expect(mockWebSocketServer.on).toHaveBeenCalledWith('connection', expect.any(Function));
-            expect(logger_1.logger.log).toHaveBeenCalled();
+            expect(logger.log).toHaveBeenCalled();
         });
         it('should accept connection from valid origin', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -74,8 +69,8 @@ describe('LocalDevWebsocketServer', () => {
             expect(mockWebSocket.close).not.toHaveBeenCalled();
         });
         it('should reject connection from invalid origin', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -85,13 +80,13 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket, {
                 headers: { origin: 'https://malicious-site.com' },
             });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed('https://malicious-site.com'));
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed('https://malicious-site.com'));
             expect(mockWebSocket.on).not.toHaveBeenCalled();
             expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
         });
         it('should reject connection with no origin header', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -101,13 +96,13 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket, {
                 headers: {},
             });
-            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, en_1.lib.LocalDevWebsocketServer.errors.originNotAllowed());
+            expect(mockWebSocket.close).toHaveBeenCalledWith(1008, lib.LocalDevWebsocketServer.errors.originNotAllowed());
             expect(mockWebSocket.on).not.toHaveBeenCalled();
             expect(mockLocalDevProcess.addStateListener).not.toHaveBeenCalled();
         });
         it('should send WEBSOCKET_SERVER_CONNECTED message when valid connection is established', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -117,13 +112,13 @@ describe('LocalDevWebsocketServer', () => {
             connectionCallback(mockWebSocket, {
                 headers: { origin: 'https://app.hubspot.com' },
             });
-            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
+            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
         });
     });
     describe('message handling', () => {
         beforeEach(async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();
@@ -135,7 +130,7 @@ describe('LocalDevWebsocketServer', () => {
         it('should handle UPLOAD message type', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const message = {
-                type: constants_1.LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD,
+                type: LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD,
             };
             messageCallback(JSON.stringify(message));
             expect(mockLocalDevProcess.uploadProject).toHaveBeenCalled();
@@ -144,7 +139,7 @@ describe('LocalDevWebsocketServer', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const message = {};
             messageCallback(JSON.stringify(message));
-            expect(logger_1.logger.error).toHaveBeenCalled();
+            expect(logger.error).toHaveBeenCalled();
         });
         it('should log error for unknown message type', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
@@ -152,19 +147,19 @@ describe('LocalDevWebsocketServer', () => {
                 type: 'UNKNOWN_TYPE',
             };
             messageCallback(JSON.stringify(message));
-            expect(logger_1.logger.error).toHaveBeenCalled();
+            expect(logger.error).toHaveBeenCalled();
         });
         it('should log error for invalid JSON', () => {
             const messageCallback = mockWebSocket.on.mock.calls[0][1];
             const invalidJson = 'invalid json';
             messageCallback(invalidJson);
-            expect(logger_1.logger.error).toHaveBeenCalled();
+            expect(logger.error).toHaveBeenCalled();
         });
     });
     describe('shutdown()', () => {
         it('should close the websocket server', async () => {
-            portManager_1.isPortManagerServerRunning.mockResolvedValue(true);
-            portManager_1.requestPorts.mockResolvedValue({
+            isPortManagerServerRunning.mockResolvedValue(true);
+            requestPorts.mockResolvedValue({
                 'local-dev-ui-websocket-server': 1234,
             });
             await server.start();

package/lib/projects/__tests__/ProjectLogsManager.test.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ProjectLogsManager_1 = require("../ProjectLogsManager");
-const config_1 = require("../config");
-const ensureProjectExists_1 = require("../ensureProjectExists");
-const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+import { ProjectLogsManager } from '../ProjectLogsManager.js';
+import { getProjectConfig } from '../config.js';
+import { ensureProjectExists } from '../ensureProjectExists.js';
+import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
 const SUBCOMPONENT_TYPES = {
     APP_ID: 'APP_ID',
     PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
@@ -57,10 +55,10 @@ describe('lib/projects/ProjectLogsManager', () => {
         },
     ];
     beforeEach(() => {
-        ProjectLogsManager_1.ProjectLogsManager.reset();
-        config_1.getProjectConfig.mockResolvedValue(projectConfig);
-        ensureProjectExists_1.ensureProjectExists.mockResolvedValue(projectDetails);
-        projects_1.fetchProjectComponentsMetadata.mockResolvedValue({
+        ProjectLogsManager.reset();
+        getProjectConfig.mockResolvedValue(projectConfig);
+        ensureProjectExists.mockResolvedValue(projectDetails);
+        fetchProjectComponentsMetadata.mockResolvedValue({
             data: {
                 topLevelComponentMetadata: [
                     {
@@ -85,59 +83,59 @@ describe('lib/projects/ProjectLogsManager', () => {
     });
     describe('init', () => {
         it('should load the project config', async () => {
-            await ProjectLogsManager_1.ProjectLogsManager.init(accountId);
-            expect(config_1.getProjectConfig).toHaveBeenCalledTimes(1);
+            await ProjectLogsManager.init(accountId);
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
         });
         it('should throw an error if there is a problem with the config', async () => {
-            config_1.getProjectConfig.mockResolvedValue({});
-            await expect(async () => ProjectLogsManager_1.ProjectLogsManager.init(accountId)).rejects.toThrow('No project detected. Run this command again from a project directory.');
-            expect(config_1.getProjectConfig).toHaveBeenCalledTimes(1);
+            getProjectConfig.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('No project detected. Run this command again from a project directory.');
+            expect(getProjectConfig).toHaveBeenCalledTimes(1);
         });
         it('should ensure the project exists', async () => {
-            await ProjectLogsManager_1.ProjectLogsManager.init(accountId);
-            expect(ensureProjectExists_1.ensureProjectExists).toHaveBeenCalledTimes(1);
-            expect(ensureProjectExists_1.ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
+            await ProjectLogsManager.init(accountId);
+            expect(ensureProjectExists).toHaveBeenCalledTimes(1);
+            expect(ensureProjectExists).toHaveBeenCalledWith(accountId, projectName, {
                 allowCreate: false,
             });
         });
         it('should throw an error if there is data missing from the project details', async () => {
-            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({});
-            await expect(async () => ProjectLogsManager_1.ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
+            ensureProjectExists.mockResolvedValue({});
+            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
         });
         it('should set all of the expected fields correctly', async () => {
-            await ProjectLogsManager_1.ProjectLogsManager.init(accountId);
-            expect(ProjectLogsManager_1.ProjectLogsManager.projectId).toEqual(projectId);
-            expect(ProjectLogsManager_1.ProjectLogsManager.projectName).toEqual(projectName);
-            expect(ProjectLogsManager_1.ProjectLogsManager.accountId).toEqual(accountId);
-            expect(ProjectLogsManager_1.ProjectLogsManager.functions).toEqual(functions);
+            await ProjectLogsManager.init(accountId);
+            expect(ProjectLogsManager.projectId).toEqual(projectId);
+            expect(ProjectLogsManager.projectName).toEqual(projectName);
+            expect(ProjectLogsManager.accountId).toEqual(accountId);
+            expect(ProjectLogsManager.functions).toEqual(functions);
         });
     });
     describe('fetchFunctionDetails', () => {
         it('should throw an error if the projectId is null when the method is called', async () => {
-            await expect(async () => ProjectLogsManager_1.ProjectLogsManager.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
+            await expect(async () => ProjectLogsManager.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
         });
         it('should fetch the component metadata', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.projectId = projectId;
-            ProjectLogsManager_1.ProjectLogsManager.accountId = accountId;
-            await ProjectLogsManager_1.ProjectLogsManager.fetchFunctionDetails();
-            expect(projects_1.fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
-            expect(projects_1.fetchProjectComponentsMetadata).toHaveBeenCalledWith(accountId, projectId);
+            ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager.fetchFunctionDetails();
+            expect(fetchProjectComponentsMetadata).toHaveBeenCalledTimes(1);
+            expect(fetchProjectComponentsMetadata).toHaveBeenCalledWith(accountId, projectId);
         });
         it('should set the functions correctly', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.projectId = projectId;
-            ProjectLogsManager_1.ProjectLogsManager.accountId = accountId;
-            await ProjectLogsManager_1.ProjectLogsManager.fetchFunctionDetails();
-            expect(ProjectLogsManager_1.ProjectLogsManager.functions).toEqual(functions);
+            ProjectLogsManager.projectId = projectId;
+            ProjectLogsManager.accountId = accountId;
+            await ProjectLogsManager.fetchFunctionDetails();
+            expect(ProjectLogsManager.functions).toEqual(functions);
         });
     });
     describe('getFunctionNames', () => {
         it('should return an empty array if functions is empty', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.functions = [];
-            expect(ProjectLogsManager_1.ProjectLogsManager.getFunctionNames()).toEqual([]);
+            ProjectLogsManager.functions = [];
+            expect(ProjectLogsManager.getFunctionNames()).toEqual([]);
         });
         it('should return an array of the componentNames', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.functions = functions;
-            expect(ProjectLogsManager_1.ProjectLogsManager.getFunctionNames()).toEqual([
+            ProjectLogsManager.functions = functions;
+            expect(ProjectLogsManager.getFunctionNames()).toEqual([
                 'function1',
                 'function2',
             ]);
@@ -145,13 +143,13 @@ describe('lib/projects/ProjectLogsManager', () => {
     });
     describe('setFunction', () => {
         it('should throw an error when functions is empty', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.functions = [];
-            expect(() => ProjectLogsManager_1.ProjectLogsManager.setFunction('foo')).toThrow(`There aren't any functions in this project`);
+            ProjectLogsManager.functions = [];
+            expect(() => ProjectLogsManager.setFunction('foo')).toThrow(`There aren't any functions in this project`);
         });
         it('should throw an error when the provided function is invalid', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.functions = functions;
+            ProjectLogsManager.functions = functions;
             const badName = 'foo';
-            expect(() => ProjectLogsManager_1.ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
+            expect(() => ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
         });
         it('should set the data correctly for public functions', async () => {
             const functionToChoose = {
@@ -165,27 +163,27 @@ describe('lib/projects/ProjectLogsManager', () => {
                     endpoint: { path: 'yooooooo', methods: ['GET'] },
                 },
             };
-            ProjectLogsManager_1.ProjectLogsManager.functions = [functionToChoose];
-            ProjectLogsManager_1.ProjectLogsManager.setFunction('function1');
-            expect(ProjectLogsManager_1.ProjectLogsManager.functionName).toEqual('function1');
-            expect(ProjectLogsManager_1.ProjectLogsManager.endpointName).toEqual('yooooooo');
-            expect(ProjectLogsManager_1.ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
-            expect(ProjectLogsManager_1.ProjectLogsManager.isPublicFunction).toEqual(true);
+            ProjectLogsManager.functions = [functionToChoose];
+            ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager.endpointName).toEqual('yooooooo');
+            expect(ProjectLogsManager.selectedFunction).toEqual(functionToChoose);
+            expect(ProjectLogsManager.isPublicFunction).toEqual(true);
         });
         it('should set the data correctly for public functions', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.functions = functions;
-            ProjectLogsManager_1.ProjectLogsManager.setFunction('function1');
-            expect(ProjectLogsManager_1.ProjectLogsManager.selectedFunction).toEqual(function1);
-            expect(ProjectLogsManager_1.ProjectLogsManager.functionName).toEqual('function1');
-            expect(ProjectLogsManager_1.ProjectLogsManager.isPublicFunction).toEqual(false);
+            ProjectLogsManager.functions = functions;
+            ProjectLogsManager.setFunction('function1');
+            expect(ProjectLogsManager.selectedFunction).toEqual(function1);
+            expect(ProjectLogsManager.functionName).toEqual('function1');
+            expect(ProjectLogsManager.isPublicFunction).toEqual(false);
         });
     });
     describe('reset', () => {
         it('should reset all the values', async () => {
-            ProjectLogsManager_1.ProjectLogsManager.projectName = 'value';
-            expect(ProjectLogsManager_1.ProjectLogsManager.projectName).toBeDefined();
-            ProjectLogsManager_1.ProjectLogsManager.reset();
-            expect(ProjectLogsManager_1.ProjectLogsManager.projectName).toBeUndefined();
+            ProjectLogsManager.projectName = 'value';
+            expect(ProjectLogsManager.projectName).toBeDefined();
+            ProjectLogsManager.reset();
+            expect(ProjectLogsManager.projectName).toBeUndefined();
         });
     });
 });

package/lib/projects/__tests__/buildAndDeploy.test.js

@@ -1,25 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const buildAndDeploy_1 = require("../buildAndDeploy");
+import { useV3Api } from '../buildAndDeploy.js';
 describe('buildAndDeploy', () => {
     describe('useV3Api', () => {
         it('returns true if platform version is UNSTABLE', () => {
-            expect((0, buildAndDeploy_1.useV3Api)('UNSTABLE')).toBe(true);
+            expect(useV3Api('UNSTABLE')).toBe(true);
         });
         it('returns true if platform version is equal to the minimum', () => {
-            expect((0, buildAndDeploy_1.useV3Api)('2025.2')).toBe(true);
+            expect(useV3Api('2025.2')).toBe(true);
         });
         it('returns true if platform version is greater than the minimum', () => {
-            expect((0, buildAndDeploy_1.useV3Api)('2026.2')).toBe(true);
+            expect(useV3Api('2026.2')).toBe(true);
         });
         it('returns false if platform version is less than the minimum', () => {
-            expect((0, buildAndDeploy_1.useV3Api)('2025.0')).toBe(false);
+            expect(useV3Api('2025.0')).toBe(false);
         });
         it('returns false if platform version is invalid', () => {
-            expect((0, buildAndDeploy_1.useV3Api)(null)).toBe(false);
+            expect(useV3Api(null)).toBe(false);
         });
         it('returns false for an invalid platform version', () => {
-            expect((0, buildAndDeploy_1.useV3Api)('notplaformversion')).toBe(false);
+            expect(useV3Api('notplaformversion')).toBe(false);
         });
     });
 });