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

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

@@ -0,0 +1,179 @@
+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

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

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

@@ -0,0 +1,236 @@
+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

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