@hubspot/ui-extensions-dev-server 1.0.1 → 1.1.0

package/dist/lib/__tests__/DevModeUnifiedInterface.spec.js

@@ -1,236 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import DevModeUnifiedInterface from "../DevModeUnifiedInterface.js";
-import { DevModeParentInterface } from "../DevModeParentInterface.js";
-import * as config from "../config.js";
-import { cardConfig, cardConfigTwo, transformedUnifiedAppConfig, transformedUnifiedAppConfigTwoCards, transformedUnifiedCardOneConfig, transformedUnifiedCardTwoConfig, unifiedAppConfig, unifiedCardOneConfig, unifiedCardTwoConfig, settingsExtensionConfig, settingsExtensionTransformedData, appHomesConfig, appHomesTransformedData, } from "./fixtures/extensionConfig.js";
-import inquirer from 'inquirer';
-import { urls } from "./fixtures/urls.js";
-vi.mock('../config.ts', async () => {
-    const actual = await vi.importActual('../config.ts');
-    return {
-        ...actual,
-        loadExtensionConfig: vi.fn(),
-    };
-});
-vi.mock('inquirer', () => ({
-    default: {
-        createPromptModule: vi.fn(),
-    },
-}));
-describe('DevModeUnifiedInterface', () => {
-    describe('setup', () => {
-        let parentSetupSpy;
-        let mockPromptModule;
-        let setActiveApp;
-        let logger;
-        const cardKey = `${unifiedAppConfig.uid}::${cardConfig.data.uid}`;
-        const components = {
-            application_name: unifiedAppConfig,
-            card_one: unifiedCardOneConfig,
-        };
-        const expectedConfig = {
-            ...transformedUnifiedCardOneConfig,
-            appConfig: transformedUnifiedAppConfig,
-        };
-        const cardOneChoiceName = `${unifiedAppConfig.config.name}/${unifiedCardOneConfig.config.name}`;
-        beforeEach(() => {
-            DevModeUnifiedInterface._reset();
-            logger = {
-                info: vi.fn(),
-                debug: vi.fn(),
-                warn: vi.fn(),
-                error: vi.fn(),
-            };
-            DevModeUnifiedInterface.logger = logger;
-            mockPromptModule = vi.fn().mockResolvedValue({
-                extensions: [expectedConfig],
-            });
-            vi.mocked(inquirer.createPromptModule).mockReturnValue(mockPromptModule);
-            setActiveApp = vi.fn(() => {
-                return Promise.resolve();
-            });
-            parentSetupSpy = vi.spyOn(DevModeParentInterface.prototype, 'parentSetup');
-            vi.mocked(config.loadExtensionConfig).mockReturnValue({
-                [cardKey]: cardConfig,
-            });
-        });
-        afterEach(() => {
-            vi.clearAllMocks();
-        });
-        it('should throw an error if no extensions are parsed from the provided arguments', async () => {
-            const badComponents = {
-                'not a valid application': {
-                    config: {
-                        name: 'I do not have an extensions object',
-                    },
-                    path: '/path/to/my/application',
-                },
-            };
-            await expect(DevModeUnifiedInterface.setup({
-                // @ts-expect-error - We're trying to trigger an error with bad data
-                components: badComponents,
-                logger,
-                setActiveApp,
-                urls,
-            })).rejects.toThrowError('No extensions to run');
-        });
-        it('should directly set configs when there is only one choice', async () => {
-            await DevModeUnifiedInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(parentSetupSpy).toHaveBeenCalledWith({
-                choices: [
-                    {
-                        name: cardOneChoiceName,
-                        value: expectedConfig,
-                    },
-                ],
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(DevModeUnifiedInterface.configs).toStrictEqual([expectedConfig]);
-        });
-        it('should prompt the user when there is more than one choice', async () => {
-            const twoCardComponents = {
-                ...components,
-                card_two: unifiedCardTwoConfig,
-            };
-            const cardOneKey = `${unifiedAppConfig.uid}::${unifiedCardOneConfig.uid}`;
-            const cardTwoKey = `${unifiedAppConfig.uid}::${unifiedCardTwoConfig.uid}`;
-            vi.mocked(config.loadExtensionConfig).mockReturnValue({
-                [cardOneKey]: cardConfig,
-                [cardTwoKey]: cardConfigTwo,
-            });
-            await DevModeUnifiedInterface.setup({
-                components: twoCardComponents,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(parentSetupSpy).toHaveBeenCalledWith({
-                choices: [
-                    {
-                        name: cardOneChoiceName,
-                        value: {
-                            ...transformedUnifiedCardOneConfig,
-                            appConfig: transformedUnifiedAppConfigTwoCards,
-                        },
-                    },
-                    {
-                        name: `${unifiedAppConfig.config.name}/${unifiedCardTwoConfig.config.name}`,
-                        value: {
-                            ...transformedUnifiedCardTwoConfig,
-                            appConfig: transformedUnifiedAppConfigTwoCards,
-                        },
-                    },
-                ],
-                components: twoCardComponents,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(mockPromptModule).toHaveBeenCalledTimes(1);
-            expect(DevModeUnifiedInterface.configs).toStrictEqual([expectedConfig]);
-        });
-        it('should call setActiveApp with the correct arg', async () => {
-            await DevModeUnifiedInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(setActiveApp).toHaveBeenCalledTimes(1);
-            expect(setActiveApp).toHaveBeenCalledWith(unifiedAppConfig.uid);
-        });
-        it('should not run setup if it has already been configured', async () => {
-            DevModeUnifiedInterface.isConfigured = true;
-            await DevModeUnifiedInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(logger.debug).toHaveBeenCalledWith('Dev server has already been configured, skipping');
-            expect(DevModeUnifiedInterface.configs).toBeUndefined();
-        });
-        it('should generate the correct configs for a settings card', async () => {
-            const settingsComponents = {
-                application_name: unifiedAppConfig,
-                card_one: unifiedCardOneConfig,
-                card_settings: settingsExtensionConfig,
-            };
-            mockPromptModule = vi.fn().mockResolvedValue({
-                extensions: [expectedConfig, settingsExtensionTransformedData],
-            });
-            vi.mocked(inquirer.createPromptModule).mockReturnValue(mockPromptModule);
-            await DevModeUnifiedInterface.setup({
-                components: settingsComponents,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(mockPromptModule).toHaveBeenCalledTimes(1);
-            expect(DevModeUnifiedInterface.configs).toStrictEqual([
-                expectedConfig,
-                settingsExtensionTransformedData,
-            ]);
-            expect(DevModeUnifiedInterface.configs?.[1]).toHaveProperty('data.title', 'Settings');
-        });
-        it('should generate the correct configs for a pages extension', async () => {
-            const pagesComponents = {
-                application_name: unifiedAppConfig,
-                card_one: unifiedCardOneConfig,
-                app_homes: appHomesConfig,
-            };
-            mockPromptModule = vi.fn().mockResolvedValue({
-                extensions: [expectedConfig, appHomesTransformedData],
-            });
-            vi.mocked(inquirer.createPromptModule).mockReturnValue(mockPromptModule);
-            await DevModeUnifiedInterface.setup({
-                components: pagesComponents,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(mockPromptModule).toHaveBeenCalledTimes(1);
-            expect(DevModeUnifiedInterface.configs).toStrictEqual([
-                expectedConfig,
-                appHomesTransformedData,
-            ]);
-            expect(DevModeUnifiedInterface.configs?.[1]).toHaveProperty('data.title', 'App Home');
-        });
-        it('should use profileData variables when provided', async () => {
-            const profileData = {
-                API_KEY: 'test-key-123',
-                DEBUG_MODE: true,
-                MAX_RETRIES: 5,
-            };
-            await DevModeUnifiedInterface.setup({
-                components,
-                profileData,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            const appConfig = DevModeUnifiedInterface.configs?.[0]
-                ?.appConfig;
-            expect(appConfig?.variables).toStrictEqual(profileData);
-        });
-        it('should use empty object for variables when no profileData provided', async () => {
-            await DevModeUnifiedInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            const appConfig = DevModeUnifiedInterface.configs?.[0]
-                ?.appConfig;
-            expect(appConfig?.variables).toStrictEqual({});
-        });
-    });
-});

package/dist/lib/__tests__/ExtensionsWebSocket.spec.d.ts

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

package/dist/lib/__tests__/ExtensionsWebSocket.spec.js

@@ -1,304 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { ExtensionsWebSocket, isAllowedOrigin, } from "../ExtensionsWebSocket.js";
-import { DevServerState } from "../DevServerState.js";
-import { createMockLogger, createDevServerConfig } from "./factories.js";
-const MOCK_INTERVAL_ID = 123;
-let mockClients;
-let mockWss;
-let upgradeHandler = null;
-vi.mock('ws', () => ({
-    WebSocketServer: vi.fn(() => {
-        mockClients = new Set();
-        const listeners = {};
-        let isClosed = false;
-        mockWss = {
-            clients: mockClients,
-            on: vi.fn((event, handler) => {
-                if (!listeners[event])
-                    listeners[event] = [];
-                listeners[event].push(handler);
-            }),
-            emit: vi.fn((event, ...args) => {
-                listeners[event]?.forEach((handler) => handler(...args));
-            }),
-            handleUpgrade: vi.fn((request, socket, head, callback) => {
-                const mockClient = createMockWebSocket();
-                mockClients.add(mockClient);
-                callback(mockClient);
-            }),
-            close: vi.fn((callback) => {
-                if (isClosed) {
-                    callback?.(new Error('The server is not running'));
-                }
-                else {
-                    isClosed = true;
-                    callback?.();
-                }
-            }),
-        };
-        return mockWss;
-    }),
-    WebSocket: { OPEN: 1, CLOSED: 3 },
-}));
-function createMockWebSocket() {
-    const listeners = {};
-    const mockWs = {
-        readyState: 1,
-        on: vi.fn((event, handler) => {
-            if (!listeners[event])
-                listeners[event] = [];
-            listeners[event].push(handler);
-        }),
-        once: vi.fn(),
-        emit: vi.fn((event, ...args) => {
-            listeners[event]?.forEach((handler) => handler(...args));
-        }),
-        send: vi.fn(),
-        close: vi.fn(() => {
-            mockWs.readyState = 3;
-            mockClients.delete(mockWs);
-            listeners['close']?.forEach((handler) => handler());
-        }),
-        terminate: vi.fn(() => {
-            mockWs.readyState = 3;
-            mockClients.delete(mockWs);
-        }),
-        ping: vi.fn(),
-    };
-    return mockWs;
-}
-let mockHttpServer;
-let devServerState;
-let extensionsWebSocket;
-function createMockHttpServer() {
-    const listeners = {};
-    return {
-        on: vi.fn((event, handler) => {
-            if (!listeners[event])
-                listeners[event] = [];
-            listeners[event].push(handler);
-            if (event === 'upgrade') {
-                upgradeHandler = handler;
-            }
-        }),
-        emit: vi.fn((event, ...args) => {
-            listeners[event]?.forEach((handler) => handler(...args));
-        }),
-        listen: vi.fn(),
-        close: vi.fn(),
-    };
-}
-function simulateClientConnection(origin = 'http://localhost') {
-    if (!upgradeHandler)
-        throw new Error('upgradeHandler not initialized');
-    const mockRequest = { headers: { origin } };
-    const mockSocket = { destroy: vi.fn() };
-    upgradeHandler(mockRequest, mockSocket, Buffer.from([]));
-    return {
-        mockRequest,
-        mockSocket,
-        client: Array.from(mockClients)[mockClients.size - 1],
-    };
-}
-describe('ExtensionsWebSocket', () => {
-    describe('isAllowedOrigin', () => {
-        it('should return false for undefined origin', () => {
-            expect(isAllowedOrigin(undefined)).toBe(false);
-        });
-        it('should return true for localhost origins', () => {
-            expect(isAllowedOrigin('http://localhost')).toBe(true);
-            expect(isAllowedOrigin('https://localhost')).toBe(true);
-            expect(isAllowedOrigin('https://localhost:8080')).toBe(true);
-            expect(isAllowedOrigin('https://localhost:5173')).toBe(true);
-        });
-        it('should return true for hubspot.com origins', () => {
-            expect(isAllowedOrigin('https://app.hubspot.com')).toBe(true);
-            expect(isAllowedOrigin('http://hubspot.com')).toBe(true);
-            expect(isAllowedOrigin('https://api.hubspot.com:443')).toBe(true);
-        });
-        it('should return true for hubspotqa.com origins', () => {
-            expect(isAllowedOrigin('https://app.hubspotqa.com')).toBe(true);
-            expect(isAllowedOrigin('http://hubspotqa.com')).toBe(true);
-            expect(isAllowedOrigin('https://api.hubspotqa.com:443')).toBe(true);
-        });
-        it('should return false for non-allowed origins', () => {
-            expect(isAllowedOrigin('https://evil.com')).toBe(false);
-            expect(isAllowedOrigin('http://example.com')).toBe(false);
-            expect(isAllowedOrigin('https://hubspot.com.evil.com')).toBe(false);
-        });
-    });
-    describe('ExtensionsWebSocket class', () => {
-        beforeEach(() => {
-            const logger = createMockLogger();
-            const config = createDevServerConfig(logger);
-            devServerState = new DevServerState(config);
-            mockHttpServer = createMockHttpServer();
-            mockClients = new Set();
-        });
-        afterEach(() => {
-            vi.useRealTimers();
-            vi.clearAllMocks();
-            mockClients.clear();
-        });
-        describe('constructor', () => {
-            it('should create an ExtensionsWebSocket instance', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                expect(extensionsWebSocket).toBeDefined();
-            });
-        });
-        describe('setupUpgradeHandler', () => {
-            it('should reject connections from non-allowed origins', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const mockSocket = {
-                    destroy: vi.fn(),
-                };
-                const mockRequest = {
-                    headers: {
-                        origin: 'https://evil.com',
-                    },
-                };
-                mockHttpServer.emit('upgrade', mockRequest, mockSocket, Buffer.from([]));
-                expect(mockSocket.destroy).toHaveBeenCalled();
-                expect(devServerState.logger.debug).toHaveBeenCalledWith('Rejected WebSocket: https://evil.com');
-            });
-            it('should accept connections from allowed origins', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                simulateClientConnection('http://localhost');
-                expect(extensionsWebSocket.clientCount).toBe(1);
-            });
-        });
-        describe('broadcast', () => {
-            it('should log when no clients are connected', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                extensionsWebSocket.broadcast({ event: 'test' });
-                expect(devServerState.logger.debug).toHaveBeenCalledWith('No clients connected, message not sent');
-            });
-            it('should send messages to all connected clients', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client: client1 } = simulateClientConnection();
-                const { client: client2 } = simulateClientConnection();
-                extensionsWebSocket.broadcast({ event: 'test', data: 'hello' });
-                expect(client1.send).toHaveBeenCalledWith(JSON.stringify({ event: 'test', data: 'hello' }));
-                expect(client2.send).toHaveBeenCalledWith(JSON.stringify({ event: 'test', data: 'hello' }));
-            });
-            it('should handle send failures gracefully', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                vi.mocked(client.send).mockImplementation(() => {
-                    throw new Error('Send failed');
-                });
-                extensionsWebSocket.broadcast({ event: 'test' });
-                expect(devServerState.logger.warn).toHaveBeenCalledWith('Sent to 0 clients, 1 failed');
-            });
-        });
-        describe('onConnection', () => {
-            it('should register connection handler', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                let connectionHandlerCalled = false;
-                extensionsWebSocket.onConnection(() => {
-                    connectionHandlerCalled = true;
-                });
-                simulateClientConnection();
-                expect(connectionHandlerCalled).toBe(true);
-            });
-        });
-        describe('clientCount', () => {
-            it('should return 0 when no clients are connected', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                expect(extensionsWebSocket.clientCount).toBe(0);
-            });
-            it('should return correct count of connected clients', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                simulateClientConnection();
-                simulateClientConnection();
-                expect(extensionsWebSocket.clientCount).toBe(2);
-            });
-        });
-        describe('keepAlive', () => {
-            it('should terminate clients that do not respond to ping', () => {
-                let keepAliveCallback;
-                const setIntervalSpy = vi
-                    .spyOn(global, 'setInterval')
-                    .mockImplementation((fn) => {
-                    keepAliveCallback = fn;
-                    return MOCK_INTERVAL_ID;
-                });
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                // First keepAlive call: marks client as not alive and sends ping
-                keepAliveCallback();
-                // Second keepAlive call: should terminate since client didn't respond
-                keepAliveCallback();
-                expect(client.terminate).toHaveBeenCalled();
-                setIntervalSpy.mockRestore();
-            });
-        });
-        describe('client handlers', () => {
-            it('should log client errors', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                client.emit('error', new Error('Test error'));
-                expect(devServerState.logger.debug).toHaveBeenCalledWith('Client error: Test error');
-            });
-            it('should log client disconnections', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                client.close();
-                const debugCalls = vi.mocked(devServerState.logger.debug).mock.calls;
-                const hasDisconnectLog = debugCalls.some((call) => call[0].includes('Client disconnected'));
-                expect(hasDisconnectLog).toBe(true);
-            });
-        });
-        describe('close', () => {
-            it('should terminate all clients before closing', async () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client: client1 } = simulateClientConnection();
-                const { client: client2 } = simulateClientConnection();
-                expect(extensionsWebSocket.clientCount).toBe(2);
-                await extensionsWebSocket.close();
-                expect(client1.terminate).toHaveBeenCalled();
-                expect(client2.terminate).toHaveBeenCalled();
-                expect(extensionsWebSocket.clientCount).toBe(0);
-            });
-            it('should close the WebSocket server after clients disconnect', async () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                expect(extensionsWebSocket.clientCount).toBe(1);
-                client.close();
-                await extensionsWebSocket.close();
-                expect(extensionsWebSocket.clientCount).toBe(0);
-            });
-            it('should stop keep-alive mechanism after close', async () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                const clearIntervalSpy = vi.spyOn(global, 'clearInterval');
-                client.close();
-                await extensionsWebSocket.close();
-                expect(clearIntervalSpy).toHaveBeenCalled();
-                clearIntervalSpy.mockRestore();
-            });
-            it('should reject when close is called multiple times', async () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                await extensionsWebSocket.close();
-                await expect(extensionsWebSocket.close()).rejects.toThrow('The server is not running');
-            });
-            it('should not broadcast after close', async () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const { client } = simulateClientConnection();
-                client.close();
-                await extensionsWebSocket.close();
-                extensionsWebSocket.broadcast({ event: 'test' });
-                expect(devServerState.logger.debug).toHaveBeenCalledWith('No clients connected, message not sent');
-            });
-        });
-        describe('error handlers', () => {
-            it('should log WebSocket server errors', () => {
-                extensionsWebSocket = new ExtensionsWebSocket(mockHttpServer, devServerState);
-                const testError = new Error('Server error');
-                const errorHandler = vi.mocked(mockWss.on).mock.calls.find((call) => call[0] === 'error')?.[1];
-                errorHandler?.(testError);
-                expect(devServerState.logger.error).toHaveBeenCalledWith('WebSocket server error: Error: Server error');
-            });
-        });
-    });
-});

package/dist/lib/__tests__/ast.spec.d.ts

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