@hubspot/cli 8.1.0 → 8.1.1-experimental.0

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

@@ -1,231 +0,0 @@
-import { WebSocketServer } from 'ws';
-import { isPortManagerServerRunning, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES, LOCAL_DEV_UI_MESSAGE_SEND_TYPES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
-import LocalDevWebsocketServer from '../localDev/LocalDevWebsocketServer.js';
-vi.mock('ws');
-vi.mock('@hubspot/local-dev-lib/portManager');
-describe('LocalDevWebsocketServer', () => {
-    let mockLocalDevProcess;
-    let mockWebSocket;
-    let mockWebSocketServer;
-    let server;
-    beforeEach(() => {
-        mockWebSocket = {
-            on: vi.fn(),
-            send: vi.fn(),
-            close: vi.fn(),
-        };
-        mockWebSocketServer = {
-            on: vi.fn(),
-            close: vi.fn(),
-        };
-        mockLocalDevProcess = {
-            addStateListener: vi.fn(),
-            removeStateListener: vi.fn(),
-            uploadProject: vi.fn().mockResolvedValue({}),
-            sendDevServerMessage: vi.fn(),
-            projectData: {
-                name: 'test-project',
-                id: 123,
-                latestBuild: { id: 'build-1', status: 'SUCCESS' },
-                deployedBuild: { id: 'build-1', status: 'SUCCESS' },
-            },
-            targetProjectAccountId: 456,
-            targetTestingAccountId: 789,
-        };
-        WebSocketServer.mockImplementation(() => mockWebSocketServer);
-        server = new LocalDevWebsocketServer(mockLocalDevProcess, true);
-    });
-    function startServerAndConnect(ws) {
-        const connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
-        connectionCallback(ws ?? mockWebSocket, {
-            headers: { origin: 'https://app.hubspot.com' },
-        });
-    }
-    describe('start()', () => {
-        beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
-            });
-            await server.start();
-        });
-        it('should send WEBSOCKET_SERVER_CONNECTED message when valid connection is established', () => {
-            startServerAndConnect();
-            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
-        });
-        it('should send project data on connection', () => {
-            startServerAndConnect();
-            expect(mockWebSocket.send).toHaveBeenCalledWith(JSON.stringify({
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
-                data: {
-                    projectName: 'test-project',
-                    projectId: 123,
-                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
-                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
-                    targetProjectAccountId: 456,
-                    targetTestingAccountId: 789,
-                },
-            }));
-        });
-        it('should setup state listeners on connection', () => {
-            startServerAndConnect();
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('projectNodes', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('appData', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('uploadWarnings', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledWith('devServersStarted', expect.any(Function));
-        });
-    });
-    describe('message handling', () => {
-        beforeEach(async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
-            });
-            await server.start();
-            startServerAndConnect();
-        });
-        it('should handle UPLOAD message type', () => {
-            const messageCallback = mockWebSocket.on.mock.calls.find(call => call[0] === 'message')[1];
-            messageCallback(JSON.stringify({ type: LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES.UPLOAD }));
-            expect(mockLocalDevProcess.uploadProject).toHaveBeenCalled();
-        });
-    });
-    describe('shutdown()', () => {
-        it('should close the websocket server', async () => {
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
-            });
-            await server.start();
-            server.shutdown();
-            expect(mockWebSocketServer.close).toHaveBeenCalled();
-        });
-    });
-    describe('multiple connections', () => {
-        let mockWebSocket1;
-        let mockWebSocket2;
-        let mockWebSocket3;
-        let connectionCallback;
-        beforeEach(async () => {
-            mockWebSocket1 = {
-                on: vi.fn(),
-                send: vi.fn(),
-                close: vi.fn(),
-            };
-            mockWebSocket2 = {
-                on: vi.fn(),
-                send: vi.fn(),
-                close: vi.fn(),
-            };
-            mockWebSocket3 = {
-                on: vi.fn(),
-                send: vi.fn(),
-                close: vi.fn(),
-            };
-            isPortManagerServerRunning.mockResolvedValue(true);
-            requestPorts.mockResolvedValue({
-                'local-dev-ui-websocket-server': 1234,
-            });
-            await server.start();
-            connectionCallback = mockWebSocketServer.on.mock.calls[0][1];
-        });
-        it('should handle multiple valid connections simultaneously', () => {
-            connectionCallback(mockWebSocket1, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app-na2.hubspotqa.com' },
-            });
-            connectionCallback(mockWebSocket3, {
-                headers: { origin: 'https://local.hubspot.com' },
-            });
-            expect(mockWebSocket1.on).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(mockWebSocket2.on).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(mockWebSocket3.on).toHaveBeenCalledWith('message', expect.any(Function));
-            expect(mockLocalDevProcess.addStateListener).toHaveBeenCalledTimes(12);
-            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledTimes(3);
-            expect(mockLocalDevProcess.sendDevServerMessage).toHaveBeenCalledWith(LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED);
-            expect(mockWebSocket1.close).not.toHaveBeenCalled();
-            expect(mockWebSocket2.close).not.toHaveBeenCalled();
-            expect(mockWebSocket3.close).not.toHaveBeenCalled();
-        });
-        it('should send project data to each connection independently', () => {
-            connectionCallback(mockWebSocket1, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app-eu1.hubspotqa.com' },
-            });
-            const expectedProjectData = JSON.stringify({
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_DATA,
-                data: {
-                    projectName: 'test-project',
-                    projectId: 123,
-                    latestBuild: { id: 'build-1', status: 'SUCCESS' },
-                    deployedBuild: { id: 'build-1', status: 'SUCCESS' },
-                    targetProjectAccountId: 456,
-                    targetTestingAccountId: 789,
-                },
-            });
-            expect(mockWebSocket1.send).toHaveBeenCalledWith(expectedProjectData);
-            expect(mockWebSocket2.send).toHaveBeenCalledWith(expectedProjectData);
-        });
-        it('should properly cleanup listeners when connections close', () => {
-            connectionCallback(mockWebSocket1, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://app-ap1.hubspotqa.com' },
-            });
-            const closeCallbacks1 = mockWebSocket1.on.mock.calls
-                .filter(call => call[0] === 'close')
-                .map(call => call[1]);
-            const closeCallbacks2 = mockWebSocket2.on.mock.calls
-                .filter(call => call[0] === 'close')
-                .map(call => call[1]);
-            expect(closeCallbacks1).toHaveLength(4);
-            expect(closeCallbacks2).toHaveLength(4);
-            closeCallbacks1.forEach(callback => callback());
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(4);
-            closeCallbacks2.forEach(callback => callback());
-            expect(mockLocalDevProcess.removeStateListener).toHaveBeenCalledTimes(8);
-        });
-        it('should broadcast state changes to all connected clients', () => {
-            connectionCallback(mockWebSocket1, {
-                headers: { origin: 'https://app.hubspot.com' },
-            });
-            connectionCallback(mockWebSocket2, {
-                headers: { origin: 'https://local.hubspotqa.com' },
-            });
-            const projectNodesListeners = mockLocalDevProcess.addStateListener.mock.calls
-                .filter(call => call[0] === 'projectNodes')
-                .map(call => call[1]);
-            expect(projectNodesListeners).toHaveLength(2);
-            const mockProjectNodes = {
-                component1: {
-                    uid: 'component1',
-                    componentType: 'APP',
-                    localDev: {
-                        componentRoot: '/test/path',
-                        componentConfigPath: '/test/path/config.json',
-                        configUpdatedSinceLastUpload: false,
-                        removed: false,
-                        parsingErrors: [],
-                    },
-                    componentDeps: {},
-                    metaFilePath: '/test/path',
-                    config: {},
-                    files: [],
-                },
-            };
-            projectNodesListeners.forEach(listener => listener(mockProjectNodes));
-            const expectedMessage = JSON.stringify({
-                type: LOCAL_DEV_UI_MESSAGE_SEND_TYPES.UPDATE_PROJECT_NODES,
-                data: mockProjectNodes,
-            });
-            expect(mockWebSocket1.send).toHaveBeenCalledWith(expectedMessage);
-            expect(mockWebSocket2.send).toHaveBeenCalledWith(expectedMessage);
-        });
-    });
-});

package/lib/projects/__tests__/ProjectLogsManager.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,302 +0,0 @@
-import { ProjectLogsManager } from '../ProjectLogsManager.js';
-import { getProjectConfig } from '../config.js';
-import { ensureProjectExists } from '../ensureProjectExists.js';
-import { fetchProjectComponentsMetadata } from '@hubspot/local-dev-lib/api/projects';
-import { fetchAppMetadataBySourceId } from '@hubspot/local-dev-lib/api/appsDev';
-import { getDeployedProjectNodes } from '../localDev/helpers/project.js';
-import { isV2Project } from '../platformVersion.js';
-const SUBCOMPONENT_TYPES = {
-    APP_ID: 'APP_ID',
-    PACKAGE_LOCK_FILE: 'PACKAGE_LOCK_FILE',
-    CRM_CARD_V2: 'CRM_CARD_V2',
-    CARD_V2: 'CARD_V2',
-    SERVERLESS_PKG: 'SERVERLESS_PKG',
-    SERVERLESS_ROUTE: 'SERVERLESS_ROUTE',
-    SERVERLESS_FUNCTION: 'SERVERLESS_FUNCTION',
-    APP_FUNCTION: 'APP_FUNCTION',
-    AUTOMATION_ACTION: 'AUTOMATION_ACTION',
-    REACT_EXTENSION: 'REACT_EXTENSION',
-};
-vi.mock('../../projects/config');
-vi.mock('../../projects/ensureProjectExists');
-vi.mock('@hubspot/local-dev-lib/api/projects');
-vi.mock('@hubspot/local-dev-lib/api/appsDev');
-vi.mock('../../projects/localDev/helpers/project');
-vi.mock('../../projects/platformVersion');
-describe('lib/projects/ProjectLogsManager', () => {
-    const accountId = 12345678;
-    const appId = 999999;
-    const projectName = 'super cool test project';
-    const projectConfig = {
-        projectConfig: {
-            name: projectName,
-            srcDir: 'src',
-            platformVersion: '2024.1',
-        },
-    };
-    const projectId = 987654321;
-    const projectDetails = {
-        project: {
-            id: projectId,
-            deployedBuild: {
-                subbuildStatuses: {},
-            },
-        },
-    };
-    const function1 = {
-        componentName: 'function1',
-        appId,
-    };
-    const functions = [
-        function1,
-        {
-            componentName: 'function2',
-            appId,
-        },
-    ];
-    const legacyApiFunctions = [
-        {
-            componentName: 'function1',
-            type: {
-                name: SUBCOMPONENT_TYPES.APP_FUNCTION,
-            },
-            deployOutput: {
-                appId,
-                appFunctionName: 'function1',
-            },
-        },
-        {
-            componentName: 'function2',
-            type: {
-                name: SUBCOMPONENT_TYPES.APP_FUNCTION,
-            },
-            deployOutput: {
-                appId,
-                appFunctionName: 'function2',
-            },
-        },
-    ];
-    beforeEach(() => {
-        ProjectLogsManager.reset();
-        isV2Project.mockReturnValue(false);
-        getProjectConfig.mockResolvedValue(projectConfig);
-        ensureProjectExists.mockResolvedValue(projectDetails);
-        fetchProjectComponentsMetadata.mockResolvedValue({
-            data: {
-                topLevelComponentMetadata: [
-                    {
-                        type: {
-                            name: 'PRIVATE_APP',
-                        },
-                        deployOutput: {
-                            appId,
-                        },
-                        featureComponents: [
-                            ...legacyApiFunctions,
-                            {
-                                type: {
-                                    name: 'NOT_AN_APP_FUNCTION',
-                                },
-                            },
-                        ],
-                    },
-                ],
-            },
-        });
-    });
-    describe('init', () => {
-        it('should load the project config', async () => {
-            await ProjectLogsManager.init(accountId);
-            expect(getProjectConfig).toHaveBeenCalledTimes(1);
-        });
-        it('should throw an error if there is a problem with the config', async () => {
-            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.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.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.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.fetchFunctionDetails()).rejects.toThrow('No project detected. Run this command again from a project directory.');
-        });
-        it('should fetch the component metadata', async () => {
-            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.projectId = projectId;
-            ProjectLogsManager.accountId = accountId;
-            await ProjectLogsManager.fetchFunctionDetails();
-            expect(ProjectLogsManager.functions).toEqual(functions);
-        });
-    });
-    describe('v2 project init', () => {
-        const v2ProjectConfig = {
-            projectConfig: {
-                name: projectName,
-                srcDir: 'src',
-                platformVersion: '2025.2',
-            },
-        };
-        const deployedBuildId = 555;
-        const v2ProjectDetails = {
-            project: {
-                id: projectId,
-                deployedBuild: {
-                    buildId: deployedBuildId,
-                    subbuildStatuses: {},
-                },
-            },
-        };
-        const appUid = 'my-app';
-        const fnUid1 = 'my-app/app.functions/function1';
-        const fnUid2 = 'my-app/app.functions/function2';
-        const deployedNodes = {
-            [appUid]: {
-                componentType: 'APPLICATION',
-                componentDeps: {},
-                metaFilePath: 'src/app/app-hsmeta.json',
-                uid: appUid,
-                config: {},
-                files: {},
-            },
-            [fnUid1]: {
-                componentType: 'APP_FUNCTION',
-                componentDeps: { app: appUid },
-                metaFilePath: 'src/app/app.functions/function1.functions/function-hsmeta.json',
-                uid: fnUid1,
-                config: { endpoint: { path: '/my-endpoint' } },
-                files: {},
-            },
-            [fnUid2]: {
-                componentType: 'APP_FUNCTION',
-                componentDeps: { app: appUid },
-                metaFilePath: 'src/app/app.functions/function2.functions/function-hsmeta.json',
-                uid: fnUid2,
-                config: {},
-                files: {},
-            },
-        };
-        beforeEach(() => {
-            getProjectConfig.mockResolvedValue(v2ProjectConfig);
-            ensureProjectExists.mockResolvedValue(v2ProjectDetails);
-            isV2Project.mockReturnValue(true);
-            getDeployedProjectNodes.mockResolvedValue(deployedNodes);
-            fetchAppMetadataBySourceId.mockResolvedValue({
-                data: { id: appId },
-            });
-        });
-        it('should populate functions correctly for v2 projects', async () => {
-            await ProjectLogsManager.init(accountId);
-            expect(getDeployedProjectNodes).toHaveBeenCalledWith(v2ProjectConfig.projectConfig, accountId, deployedBuildId);
-            expect(fetchAppMetadataBySourceId).toHaveBeenCalledWith(projectId, appUid, accountId);
-            expect(ProjectLogsManager.functions).toEqual([
-                {
-                    componentName: fnUid1,
-                    appId,
-                    endpoint: { path: '/my-endpoint' },
-                },
-                {
-                    componentName: fnUid2,
-                    appId,
-                    endpoint: undefined,
-                },
-            ]);
-        });
-        it('should throw noDeployedBuild when buildId is missing', async () => {
-            ensureProjectExists.mockResolvedValue({
-                project: {
-                    id: projectId,
-                    deployedBuild: {
-                        buildId: undefined,
-                        subbuildStatuses: {},
-                    },
-                },
-            });
-            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow('This project has not been deployed yet. Deploy the project first, then try again.');
-        });
-        it('should throw noFunctionsInProject when no function nodes exist', async () => {
-            getDeployedProjectNodes.mockResolvedValue({
-                [appUid]: deployedNodes[appUid],
-            });
-            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There aren't any functions in this project/);
-        });
-        it('should throw a user-friendly error when getDeployedProjectNodes fails', async () => {
-            getDeployedProjectNodes.mockRejectedValue(new Error('download failed'));
-            await expect(async () => ProjectLogsManager.init(accountId)).rejects.toThrow(/There was an error fetching project details/);
-        });
-    });
-    describe('getFunctionNames', () => {
-        it('should return an empty array if functions is empty', async () => {
-            ProjectLogsManager.functions = [];
-            expect(ProjectLogsManager.getFunctionNames()).toEqual([]);
-        });
-        it('should return an array of the componentNames', async () => {
-            ProjectLogsManager.functions = functions;
-            expect(ProjectLogsManager.getFunctionNames()).toEqual([
-                'function1',
-                'function2',
-            ]);
-        });
-    });
-    describe('setFunction', () => {
-        it('should throw an error when functions is empty', async () => {
-            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.functions = functions;
-            const badName = 'foo';
-            expect(() => ProjectLogsManager.setFunction(badName)).toThrow(`No function with name "${badName}"`);
-        });
-        it('should set the data correctly for public functions', async () => {
-            const functionToChoose = {
-                componentName: 'function1',
-                appId: 123,
-                endpoint: { path: 'yooooooo' },
-            };
-            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 private functions', async () => {
-            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.projectName = 'value';
-            expect(ProjectLogsManager.projectName).toBeDefined();
-            ProjectLogsManager.reset();
-            expect(ProjectLogsManager.projectName).toBeUndefined();
-        });
-    });
-});

package/lib/projects/__tests__/UIExtensionsDevModeInterface.test.d.ts

@@ -1 +0,0 @@
-export {};