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

package/dist/lib/ExtensionsWebSocket.js

@@ -1,110 +0,0 @@
-import { WebSocket, WebSocketServer } from 'ws';
-export const ALLOWED_ORIGIN_PATTERNS = [
-    /^https?:\/\/localhost(:\d+)?$/,
-    /^https?:\/\/([\w-]+\.)?hubspot(qa)?\.com(:\d+)?$/,
-];
-export function isAllowedOrigin(origin) {
-    if (!origin)
-        return false;
-    return ALLOWED_ORIGIN_PATTERNS.some((pattern) => pattern.test(origin));
-}
-export class ExtensionsWebSocket {
-    wss;
-    logger;
-    keepAliveIntervalId;
-    clientAliveness = new WeakMap();
-    constructor(httpServer, devServerState) {
-        this.logger = devServerState.logger;
-        this.wss = new WebSocketServer({ noServer: true });
-        this.setupUpgradeHandler(httpServer);
-        this.setupErrorHandlers();
-        this.startKeepAlive();
-    }
-    setupUpgradeHandler(httpServer) {
-        httpServer.on('upgrade', (request, socket, head) => {
-            if (!isAllowedOrigin(request.headers.origin)) {
-                this.logger.debug(`Rejected WebSocket: ${request.headers.origin}`);
-                socket.destroy();
-                return;
-            }
-            this.wss.handleUpgrade(request, socket, head, (ws) => {
-                this.setupClientHandlers(ws);
-                this.wss.emit('connection', ws, request);
-            });
-        });
-    }
-    setupErrorHandlers() {
-        this.wss.on('error', (error) => {
-            this.logger.error(`WebSocket server error: ${error}`);
-        });
-    }
-    setupClientHandlers(ws) {
-        ws.on('error', (error) => {
-            this.logger.debug(`Client error: ${error.message}`);
-        });
-        ws.on('close', (code, reason) => {
-            this.logger.debug(`Client disconnected: ${code} ${reason}`);
-        });
-        ws.on('pong', () => {
-            this.clientAliveness.set(ws, true);
-        });
-    }
-    startKeepAlive() {
-        this.keepAliveIntervalId = setInterval(() => {
-            this.wss.clients.forEach((client) => {
-                if (this.clientAliveness.get(client) === false) {
-                    return client.terminate();
-                }
-                this.clientAliveness.set(client, false);
-                client.ping();
-            });
-        }, 30000);
-    }
-    broadcast(message) {
-        if (this.wss.clients.size === 0) {
-            this.logger.debug('No clients connected, message not sent');
-            return;
-        }
-        const data = JSON.stringify(message);
-        let successCount = 0;
-        let failCount = 0;
-        this.wss.clients.forEach((client) => {
-            if (client.readyState === WebSocket.OPEN) {
-                try {
-                    client.send(data);
-                    successCount++;
-                }
-                catch (error) {
-                    failCount++;
-                    this.logger.debug(`Failed to send to client: ${error}`);
-                }
-            }
-        });
-        if (failCount > 0) {
-            this.logger.warn(`Sent to ${successCount} clients, ${failCount} failed`);
-        }
-    }
-    onConnection(handler) {
-        this.wss.on('connection', handler);
-    }
-    get clientCount() {
-        return this.wss.clients.size;
-    }
-    async close() {
-        if (this.keepAliveIntervalId) {
-            clearInterval(this.keepAliveIntervalId);
-        }
-        this.wss.clients.forEach((client) => {
-            this.logger.debug('Terminating WebSocket client connection');
-            client.terminate();
-        });
-        return new Promise((resolve, reject) => {
-            this.wss.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
-    }
-}

package/dist/lib/__mocks__/config.d.ts

@@ -1,2 +0,0 @@
-import { LocalAppConfig } from '../types.ts';
-export declare const localConfig: LocalAppConfig;

package/dist/lib/__mocks__/config.js

@@ -1,5 +0,0 @@
-export const localConfig = {
-    proxy: {
-        'https://example.com': 'https://google.com',
-    },
-};

package/dist/lib/__mocks__/isExtensionFile.d.ts

@@ -1,5 +0,0 @@
-/**
- * For testing purposes, we need to mock the isExtensionFile function when not testing it directly.
- * This approximates the logic without requiring files to exist on disk.
- */
-export declare function isExtensionFileMock(filepath: string, extensionPath: string): boolean;

package/dist/lib/__mocks__/isExtensionFile.js

@@ -1,11 +0,0 @@
-import path from 'path';
-/**
- * For testing purposes, we need to mock the isExtensionFile function when not testing it directly.
- * This approximates the logic without requiring files to exist on disk.
- */
-export function isExtensionFileMock(filepath, extensionPath) {
-    const resolvedFilePath = path.resolve(process.cwd(), filepath);
-    const resolvedExtensionPath = path.resolve(process.cwd(), extensionPath);
-    const relativePath = path.relative(resolvedExtensionPath, resolvedFilePath);
-    return !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
-}

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

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

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

@@ -1,155 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
-import DevModeInterface from "../DevModeInterface.js";
-import { DevModeParentInterface } from "../DevModeParentInterface.js";
-import * as config from "../config.js";
-import { appComponent, appComponentTwoCards, appConfig, cardConfig, cardConfigTwo, } 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('DevModeInterface', () => {
-    describe('setup', () => {
-        let parentSetupSpy;
-        let mockPromptModule;
-        let setActiveApp;
-        let logger;
-        const cardKey = `${appConfig.uid}::${cardConfig.data.uid}`;
-        const components = {
-            'my application': appComponent,
-        };
-        const expectedConfig = {
-            ...cardConfig,
-            appConfig,
-        };
-        beforeEach(() => {
-            DevModeInterface._reset();
-            logger = {
-                info: vi.fn(),
-                debug: vi.fn(),
-                warn: vi.fn(),
-                error: vi.fn(),
-            };
-            DevModeInterface.logger = logger;
-            mockPromptModule = vi.fn().mockResolvedValue({
-                extensions: [{ ...cardConfig, appConfig }],
-            });
-            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 components', async () => {
-            const components = {
-                'not a valid application': {
-                    config: {
-                        name: 'I do not have an extensions object',
-                    },
-                    path: '/path/to/my/application',
-                },
-            };
-            await expect(DevModeInterface.setup({
-                // @ts-expect-error - Trying to trigger an error with missing fields
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            })).rejects.toThrowError('No extensions to run');
-        });
-        it('should directly set configs when there is only one choice', async () => {
-            await DevModeInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(parentSetupSpy).toHaveBeenCalledWith({
-                choices: [
-                    {
-                        name: 'my application/Meme Card',
-                        value: expectedConfig,
-                    },
-                ],
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(DevModeInterface.configs).toStrictEqual([expectedConfig]);
-        });
-        it('should prompt the user when there is more than once choice', async () => {
-            const twoCardComponents = {
-                'my application': appComponentTwoCards,
-            };
-            const cardKeyTwo = `${appConfig.uid}::${cardConfigTwo.data.uid}`;
-            vi.mocked(config.loadExtensionConfig).mockReturnValue({
-                [cardKey]: cardConfig,
-                [cardKeyTwo]: cardConfigTwo,
-            });
-            await DevModeInterface.setup({
-                components: twoCardComponents,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(parentSetupSpy).toHaveBeenCalledWith({
-                choices: [
-                    {
-                        name: 'my application/Meme Card',
-                        value: expectedConfig,
-                    },
-                    {
-                        name: 'my application/Another Meme Card',
-                        value: {
-                            ...cardConfigTwo,
-                            appConfig,
-                        },
-                    },
-                ],
-                components: twoCardComponents,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(mockPromptModule).toHaveBeenCalledTimes(1);
-            expect(DevModeInterface.configs).toStrictEqual([expectedConfig]);
-        });
-        it('should call setActiveApp with the correct arg', async () => {
-            await DevModeInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(setActiveApp).toHaveBeenCalledTimes(1);
-            expect(setActiveApp).toHaveBeenCalledWith(appConfig.uid);
-        });
-        it('should not run setup if it has already been configured', async () => {
-            DevModeInterface.isConfigured = true;
-            await DevModeInterface.setup({
-                components,
-                logger,
-                setActiveApp,
-                urls,
-            });
-            expect(logger.debug).toHaveBeenCalledWith('Dev server has already been configured, skipping');
-            expect(DevModeInterface.configs).toBeUndefined();
-        });
-    });
-});

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

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

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

@@ -1,179 +0,0 @@
-import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, } from 'vitest';
-import DevModeInterface from "../DevModeInterface.js";
-import { cardConfig } from "./fixtures/extensionConfig.js";
-import { DevServerState } from "../DevServerState.js";
-import { EXPRESS_DEFAULT_PORT, EXPRESS_SERVER_ID, PLATFORM_VERSION, } from "../constants.js";
-import { urls } from "./fixtures/urls.js";
-import { localConfig } from "../__mocks__/config.js";
-vi.mock('../config.ts', () => ({
-    loadLocalConfig: vi.fn(() => localConfig),
-    buildSourceId: vi.fn(),
-    getUrlSafeFileName: vi.fn(),
-}));
-vi.mock('../dev.ts', () => ({
-    startDevMode: vi.fn(() => {
-        return function () { };
-    }),
-}));
-import { loadLocalConfig } from "../config.js";
-import { startDevMode } from "../dev.js";
-const accountId = 12345;
-describe('DevModeUnifiedInterface', () => {
-    let consoleMock;
-    let logger;
-    beforeAll(() => {
-        consoleMock = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    });
-    beforeEach(() => {
-        vi.clearAllMocks();
-        DevModeInterface._reset();
-        DevModeInterface.logger = logger;
-        logger = {
-            info: vi.fn(),
-            debug: vi.fn(),
-            warn: vi.fn(),
-            error: vi.fn(),
-        };
-        DevModeInterface.logger = logger;
-    });
-    afterAll(() => {
-        consoleMock.mockRestore();
-    });
-    describe('start', () => {
-        it('should not start the dev server again if it has already been started', () => {
-            const requestPorts = vi.fn();
-            DevModeInterface.isRunning = true;
-            DevModeInterface.start({ requestPorts });
-            expect(logger.debug).toHaveBeenCalledWith('Dev server is already running, not starting again');
-            expect(requestPorts).not.toHaveBeenCalled();
-        });
-        it('should use the values returned from requestPorts for the service ports', async () => {
-            DevModeInterface.configs = [cardConfig];
-            DevModeInterface.urls = urls;
-            const ports = {
-                [EXPRESS_SERVER_ID]: 8675309,
-            };
-            const requestPorts = vi.fn().mockReturnValue(ports);
-            await DevModeInterface.start({
-                accountId,
-                requestPorts,
-            });
-            expect(requestPorts).toHaveBeenCalledTimes(1);
-            expect(DevModeInterface.devServerState.expressPort).toBe(ports[EXPRESS_SERVER_ID]);
-        });
-        it('should use the default ports when the call to requestPorts fails', async () => {
-            DevModeInterface.logger = logger;
-            DevModeInterface.configs = [cardConfig];
-            DevModeInterface.urls = urls;
-            const requestPorts = vi.fn().mockImplementation(() => {
-                throw new Error("AH AH AH, YOU DIDN'T SAY THE MAGIC WORD");
-            });
-            await DevModeInterface.start({
-                accountId,
-                requestPorts,
-            });
-            expect(requestPorts).toHaveBeenCalledTimes(1);
-            expect(logger.debug).toHaveBeenCalledWith('Call to port manager failed, using default ports');
-            expect(DevModeInterface.devServerState.expressPort).toBe(EXPRESS_DEFAULT_PORT);
-        });
-        it('should load the local config', async () => {
-            DevModeInterface.configs = [cardConfig];
-            DevModeInterface.urls = urls;
-            const accountId = 12345;
-            await DevModeInterface.start({
-                accountId,
-            });
-            expect(loadLocalConfig).toHaveBeenCalledTimes(1);
-            expect(loadLocalConfig).toHaveBeenCalledWith(DevModeInterface.configs[0].path, DevModeInterface.logger);
-            expect(DevModeInterface.devServerState?.localDevUrlMapping).toEqual(localConfig.proxy);
-        });
-        it('should not call startDevMode if it is unable to load the extension config', async () => {
-            DevModeInterface.configs = undefined;
-            const errorMessage = 'Unable to load the required extension configuration files';
-            await expect(DevModeInterface.start({})).rejects.toThrowError(errorMessage);
-            expect(startDevMode).not.toHaveBeenCalled();
-        });
-        it('should call startDevMode', async () => {
-            DevModeInterface.configs = [cardConfig];
-            DevModeInterface.logger = logger;
-            DevModeInterface.urls = urls;
-            await DevModeInterface.start({
-                accountId,
-            });
-            const expectedState = new DevServerState({
-                localDevUrlMapping: localConfig.proxy,
-                extensionConfigs: [cardConfig],
-                accountId,
-                platformVersion: PLATFORM_VERSION.V20231,
-                expressPort: EXPRESS_DEFAULT_PORT,
-                logger,
-                urls,
-                appConfig: cardConfig.appConfig,
-            });
-            expect(startDevMode).toHaveBeenCalledTimes(1);
-            expect(startDevMode).toHaveBeenCalledWith(expectedState);
-        });
-        it('should assign the method returned from startDevMode to shutdown', async () => {
-            DevModeInterface.configs = [cardConfig];
-            DevModeInterface.urls = urls;
-            const shutdown = async () => { };
-            vi.mocked(startDevMode).mockImplementationOnce(async () => shutdown);
-            DevModeInterface.isRunning = false;
-            await DevModeInterface.start({});
-            expect(DevModeInterface.shutdown).toStrictEqual(shutdown);
-        });
-    });
-    describe('fileChange', () => {
-        it('should call onUploadRequired when it is defined and a cardConfig is edited', () => {
-            const cardConfigPath = cardConfig.extensionConfigPath;
-            DevModeInterface.devServerState = new DevServerState({
-                extensionConfigs: [cardConfig],
-                accountId,
-                expressPort: 1234,
-                platformVersion: PLATFORM_VERSION.V20251,
-                logger,
-                urls,
-            });
-            DevModeInterface.onUploadRequired = vi.fn();
-            DevModeInterface.fileChange(cardConfigPath, '');
-            expect(DevModeInterface.onUploadRequired).toHaveBeenCalledTimes(1);
-        });
-        it('should not call onUploadRequired when it is not a card config', () => {
-            DevModeInterface.devServerState = undefined;
-            DevModeInterface.onUploadRequired = vi.fn();
-            DevModeInterface.fileChange('some/other/file.jsx', '');
-            expect(DevModeInterface.onUploadRequired).not.toHaveBeenCalled();
-        });
-        it('should not call onUploadRequired extensionConfigPath is undefined', () => {
-            DevModeInterface.onUploadRequired = vi.fn();
-            DevModeInterface.fileChange('some/other/file.jsx', '');
-            expect(DevModeInterface.onUploadRequired).not.toHaveBeenCalled();
-        });
-    });
-    describe('cleanup', () => {
-        it('should call shutdown when cleanup is invoked', async () => {
-            const shutdown = vi
-                .fn()
-                .mockImplementation(() => Promise.resolve());
-            DevModeInterface.isRunning = true;
-            DevModeInterface.shutdown = shutdown;
-            await DevModeInterface.cleanup();
-            expect(shutdown).toHaveBeenCalledTimes(1);
-        });
-        it('should reset the dev server state', async () => {
-            const shutdown = vi
-                .fn()
-                .mockImplementation(() => Promise.resolve());
-            DevModeInterface.isRunning = true;
-            DevModeInterface.shutdown = shutdown;
-            await DevModeInterface.cleanup();
-            expect(DevModeInterface.configs).toBeUndefined();
-            expect(DevModeInterface.devServerState).toBeUndefined();
-            expect(DevModeInterface.onUploadRequired).toBeUndefined();
-            expect(DevModeInterface.shutdown).toBeUndefined();
-            expect(DevModeInterface.urls).toBeUndefined();
-            expect(DevModeInterface.isConfigured).toBe(false);
-            expect(DevModeInterface.isRunning).toBe(false);
-        });
-    });
-});

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

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