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

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

@@ -0,0 +1,152 @@
+import { afterEach, describe, it, expect, vi, beforeEach } from 'vitest';
+import * as devServer from '@hubspot/app-functions-dev-server';
+import startDevServer from "../server.js";
+import { DevServerState } from "../DevServerState.js";
+import { createMockLogger, createDevServerConfig, createMockViteDevServer, } from "./factories.js";
+const useMock = vi.fn();
+vi.mock('@hubspot/app-functions-dev-server', () => ({
+    AppProxyService: vi.fn(() => vi.fn((req, res, next) => next())),
+    AppFunctionExecutionService: vi.fn(() => vi.fn((req, res, next) => next())),
+}));
+vi.mock('express', () => {
+    const expressMock = () => ({
+        use: useMock,
+        get: vi.fn(),
+        listen: (__, callback) => {
+            // simulate async listen
+            const serverMock = {
+                on: vi.fn(function (event) {
+                    if (event === 'error') {
+                        // Don't call error handler in tests
+                    }
+                    return this;
+                }),
+                close: vi.fn((cb) => cb && cb()),
+            };
+            setTimeout(callback, 1);
+            return serverMock;
+        },
+    });
+    expressMock.static = vi.fn(() => vi.fn());
+    return { default: expressMock };
+});
+describe('server', () => {
+    let logger;
+    let devServerConfig;
+    beforeEach(() => {
+        logger = createMockLogger();
+        devServerConfig = createDevServerConfig(logger);
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('startDevServer', () => {
+        beforeEach(() => {
+            useMock.mockClear();
+            vi.mocked(devServer.AppFunctionExecutionService).mockReturnValue(vi.fn());
+            vi.mocked(devServer.AppProxyService).mockReturnValue(vi.fn());
+            vi.clearAllMocks();
+        });
+        it('should add the AppProxyService middleware when localDevUrlMapping is provided', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: {
+                    'https://inbound.com': 'http://localhost',
+                },
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function), 
+            // This is the AppProxyService middleware
+            expect.any(Function));
+            expect(devServer.AppProxyService).toHaveBeenCalledTimes(1);
+            expect(devServer.AppProxyService).toHaveBeenCalledWith({
+                accountId: devServerConfig.accountId,
+                allowedUrls: [],
+                localDevUrlMapping: devServerState.localDevUrlMapping,
+                logger: devServerState.logger,
+            });
+        });
+        it('should not add the AppProxyService middleware when the localDevUrlMapping is empty', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: {},
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function));
+            expect(devServer.AppProxyService).toHaveBeenCalledTimes(0);
+        });
+        it('should not add the AppProxyService middleware when localDevUrlMapping is not provided', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: undefined,
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(useMock).toHaveBeenNthCalledWith(3, '/api/crm-extensibility/execution/internal/v3', expect.any(Function));
+            expect(devServer.AppProxyService).toHaveBeenCalledTimes(0);
+        });
+        it('should add the AppFunctionExecutionService middleware if is a private app', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                localDevUrlMapping: {
+                    'https://inbound.com': 'http://localhost',
+                },
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(devServer.AppFunctionExecutionService).toHaveBeenCalledTimes(1);
+        });
+        it('should not add the AppFunctionExecutionService middleware if is a public app', async () => {
+            const devServerState = new DevServerState({
+                ...devServerConfig,
+                appConfig: { isPublicApp: true },
+                localDevUrlMapping: {
+                    'https://inbound.com': 'http://localhost',
+                },
+            });
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(devServer.AppFunctionExecutionService).not.toHaveBeenCalled();
+        });
+        it('should return httpServer and shutdown function', async () => {
+            const devServerState = new DevServerState(devServerConfig);
+            const result = await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(result).toHaveProperty('httpServer');
+            expect(result).toHaveProperty('shutdown');
+            expect(typeof result.shutdown).toBe('function');
+        });
+        it('should initialize ExtensionsWebSocket on devServerState', async () => {
+            const devServerState = new DevServerState(devServerConfig);
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(devServerState.extensionsWebSocket).toBeDefined();
+        });
+        it('should trigger WebSocket setup after initialization', async () => {
+            const triggerSpy = vi.spyOn(DevServerState.prototype, 'triggerWebSocketSetup');
+            const devServerState = new DevServerState(devServerConfig);
+            await startDevServer({
+                devServerState,
+                viteDevServer: createMockViteDevServer(),
+            });
+            expect(triggerSpy).toHaveBeenCalledTimes(1);
+            triggerSpy.mockRestore();
+        });
+    });
+});

package/dist/lib/__tests__/test-utils/ast.d.ts

@@ -0,0 +1 @@
+export declare const localParse: (code: string) => import("acorn").Program;

package/dist/lib/__tests__/test-utils/ast.js

@@ -0,0 +1,4 @@
+import { parse } from 'acorn';
+export const localParse = (code) => {
+    return parse(code, { ecmaVersion: 'latest', sourceType: 'module' });
+};

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

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

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

@@ -0,0 +1,176 @@
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach, } from 'vitest';
+import { OUTPUT_DIR } from "../constants.js";
+import { getUrlSafeFileName, stripAnsiColorCodes, loadManifest, buildSourceId, isNodeModule, isExtensionFile, generateHash, } from "../utils.js";
+import fs from 'fs';
+import path from 'path';
+describe('utils', () => {
+    describe('getUrlSafeFileName', () => {
+        it('should uri encode the filename', () => {
+            const fileName = 'test File ?@#$%^&*()Name who would name a file like this!';
+            const actual = getUrlSafeFileName(`${fileName}.tsx`);
+            expect(actual).toEqual(`${encodeURIComponent(fileName)}.js`);
+        });
+    });
+    describe('stripAnsiColorCodes', () => {
+        it('should strip all color codes out of a string', () => {
+            const withColorCodes = '\x1B[33mThis is a test\x1B[39m';
+            const actual = stripAnsiColorCodes(withColorCodes);
+            expect(actual).toEqual('This is a test');
+        });
+        it('should return null if the provided string is null', () => {
+            const actual = stripAnsiColorCodes(undefined);
+            expect(actual).toEqual(null);
+        });
+        it('should return null if the provided string is undefined', () => {
+            const actual = stripAnsiColorCodes(undefined);
+            expect(actual).toEqual(null);
+        });
+        it('should return null if the provided string is empty', () => {
+            const actual = stripAnsiColorCodes('');
+            expect(actual).toEqual(null);
+        });
+    });
+    describe('loadManifest', () => {
+        beforeEach(() => {
+            vi.spyOn(fs, 'readFileSync').mockReturnValue(JSON.stringify({
+                manifest: true,
+            }));
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('should return the manifest file when it is able to load it from disk', () => {
+            const actual = loadManifest(OUTPUT_DIR, 'test-file-name');
+            expect(fs.readFileSync).toHaveBeenCalledTimes(1);
+            expect(actual).toStrictEqual({
+                manifest: true,
+            });
+        });
+        it('should return an empty object when it fails to load from disk', () => {
+            vi.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
+                throw new Error('OH NO!');
+            });
+            const actual = loadManifest(OUTPUT_DIR, 'test-file-name');
+            expect(actual).toStrictEqual({});
+        });
+    });
+    describe('buildSourceId', () => {
+        it('should return null when there is no uid in app config', () => {
+            expect(buildSourceId({}, { data: { uid: 'some-uid' } })).toBe(null);
+        });
+        it('should return null when there is no uid in extension config', () => {
+            expect(buildSourceId({ uid: 'some-uid' }, { data: {} })).toBe(null);
+        });
+        it('should return a valid sourceId', () => {
+            const appUID = 'app-uid';
+            const extensionUID = 'extension-uid';
+            expect(buildSourceId({ uid: appUID }, { data: { uid: extensionUID } })).toBe(`${appUID}::${extensionUID}`);
+        });
+    });
+    describe('isNodeModule', () => {
+        it('should return false if the path is undefined', () => {
+            expect(isNodeModule(undefined)).toBe(false);
+        });
+        it('should return false if the path is not a node_modules', () => {
+            expect(isNodeModule('foo.js')).toBe(false);
+        });
+        it('should return true if the path is a node_modules', () => {
+            expect(isNodeModule('node_modules/foo.js')).toBe(true);
+        });
+    });
+    describe('isExtensionFile', () => {
+        /**
+         * This function relies on the file system. Mocking doesn't allow us to fully test all scenarios.
+         * In order to effectively test it, we need to create a temporary directory structure.
+         * Being thorough here allows us to safely mock it elsewhere.
+         */
+        const tempDir = path.join(__dirname, 'temp');
+        const extensionDir = path.join(tempDir, 'test/path/extension');
+        const indexFile = path.join(extensionDir, 'index.js');
+        const nestedFile = path.join(extensionDir, 'src/file.ts');
+        const otherFile = path.join(tempDir, 'different/path/file.ts');
+        const relativeOtherFile = path.join(tempDir, '../different/path/file.ts');
+        beforeAll(() => {
+            fs.mkdirSync(extensionDir, { recursive: true });
+            fs.mkdirSync(path.dirname(nestedFile), { recursive: true });
+            fs.mkdirSync(path.dirname(otherFile), { recursive: true });
+            fs.mkdirSync(path.dirname(relativeOtherFile), { recursive: true });
+            fs.writeFileSync(otherFile, '');
+            fs.writeFileSync(nestedFile, '');
+            fs.writeFileSync(indexFile, '');
+            fs.writeFileSync(relativeOtherFile, '');
+        });
+        afterAll(() => {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            fs.rmSync(relativeOtherFile, { recursive: true, force: true });
+        });
+        it('should return false if filepath is undefined', () => {
+            expect(isExtensionFile(undefined, extensionDir)).toBe(false);
+        });
+        it('should return true if file is within extension path', () => {
+            expect(isExtensionFile(nestedFile, extensionDir)).toBe(true);
+            expect(isExtensionFile(indexFile, extensionDir)).toBe(true);
+        });
+        it('should return false if file is outside extension path', () => {
+            expect(isExtensionFile(otherFile, extensionDir)).toBe(false);
+        });
+        it('should handle relative paths correctly', () => {
+            const originalCwd = process.cwd();
+            process.chdir(tempDir);
+            expect(isExtensionFile('./test/path/extension/src/file.ts', './test/path/extension')).toBe(true);
+            expect(isExtensionFile('../different/path/file.ts', './test/path/extension')).toBe(false);
+            process.chdir(originalCwd);
+        });
+        it('should return true if the extension path is nested within the provided path', () => {
+            const originalCwd = process.cwd();
+            process.chdir(tempDir);
+            expect(isExtensionFile('../temp/test/path/extension/src/file.ts', './test/path/extension/')).toBe(true);
+            process.chdir(originalCwd);
+        });
+    });
+    describe('generateHash', () => {
+        it('should generate consistent hashes for same inputs', () => {
+            const hash1 = generateHash('test', ['a', 'b'], { foo: 'bar' });
+            const hash2 = generateHash('test', ['a', 'b'], { foo: 'bar' });
+            expect(hash1).toBe(hash2);
+        });
+        it('should handle different types of arguments', () => {
+            expect(generateHash('test')).toBe('364492');
+            expect(generateHash(123)).toBe('be32');
+            expect(generateHash(['a', 'b'])).toBe('171f6');
+            expect(generateHash({ foo: 'bar' })).toBe('4a4201ac');
+            expect(generateHash(null)).toBe('33c587');
+            expect(generateHash(undefined)).toBe('42201c7f');
+        });
+        it('should generate the correct hash for multiple arguments', () => {
+            const hash1 = generateHash('arg1', ['foo', 'bar']);
+            const hash2 = generateHash('test', ['a', 'c', 'd', 'e']);
+            expect(hash1).toBe('1ec304f1');
+            expect(hash2).toBe('607ad458');
+        });
+        it('should normalize arrays regardless of order', () => {
+            const hash1 = generateHash(['a', 'b', 'c']);
+            const hash2 = generateHash(['c', 'a', 'b']);
+            expect(hash1).toBe(hash2);
+        });
+        it('should normalize objects regardless of key order', () => {
+            const hash1 = generateHash({ a: 1, b: 2 });
+            const hash2 = generateHash({ b: 2, a: 1 });
+            expect(hash1).toBe(hash2);
+        });
+        it('should return an empty string and log an error if an error is thrown', () => {
+            // Mock console.error to prevent it from logging to the console
+            const consoleErrorSpy = vi
+                .spyOn(console, 'error')
+                .mockImplementation(() => { });
+            // Create an argument that will cause an error.
+            const circularReference = {};
+            circularReference.self = circularReference;
+            const hash = generateHash(circularReference);
+            expect(hash).toBe('');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('Error generating hash: ', expect.any(TypeError));
+            // Restore console.error
+            consoleErrorSpy.mockRestore();
+        });
+    });
+});

package/dist/lib/ast.d.ts

@@ -1,4 +1,4 @@
-import { SourceCodeMetadata, SourceCodeChecks, Logger, NodeValue } from './types';
+import { SourceCodeMetadata, SourceCodeChecks, Logger, NodeValue } from './types.ts';
 import { Program, Node } from 'estree';
 /**
  * We only support image imports that are within the extension directory.

package/dist/lib/ast.js

@@ -1,16 +1,8 @@
-"use strict";
-/* eslint-disable hubspot-dev/no-unsupported-ts-syntax */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkForOutOfBoundsImageImports = checkForOutOfBoundsImageImports;
-exports.traverseAbstractSyntaxTree = traverseAbstractSyntaxTree;
-const path_1 = __importDefault(require("path"));
+import path from 'path';
 // @ts-expect-error no type defs
-const estraverse_1 = require("estraverse");
-const utils_1 = require("./utils");
-const parsing_utils_1 = require("./parsing-utils");
+import { traverse } from 'estraverse';
+import { generateHash, isExtensionFile, isImage } from "./utils.js";
+import { getValueFromNode, isFunctionInvoked, isIdentifierDefined, isVariableImported, } from "./parsing-utils.js";
 const PARSED_HOOKS = ['useCrmProperties', 'useAssociations'];
 function _checkForFunctionMetadata(node, parent, output, functionName) {
     if (!node) {
@@ -19,7 +11,7 @@ function _checkForFunctionMetadata(node, parent, output, functionName) {
     if (!output.functions[functionName]) {
         output.functions[functionName] = {};
     }
-    if ((0, parsing_utils_1.isFunctionInvoked)(node, functionName)) {
+    if (isFunctionInvoked(node, functionName)) {
         output.functions[functionName].invoked = true;
         // If the function is invoked before being defined we will assume it is a global function
         output.functions[functionName].scope = output.functions[functionName]
@@ -27,8 +19,8 @@ function _checkForFunctionMetadata(node, parent, output, functionName) {
             ? 'Local'
             : 'Global';
     }
-    else if ((0, parsing_utils_1.isIdentifierDefined)(node, parent, functionName) ||
-        (0, parsing_utils_1.isVariableImported)(node, functionName)) {
+    else if (isIdentifierDefined(node, parent, functionName) ||
+        isVariableImported(node, functionName)) {
         output.functions[functionName].defined = true;
     }
 }
@@ -43,7 +35,7 @@ function _collectVariableDeclarations(node, state) {
                 declaration.id.type === 'Identifier' &&
                 declaration.init) {
                 const variableName = declaration.id.name;
-                const result = (0, parsing_utils_1.getValueFromNode)(declaration.init, state);
+                const result = getValueFromNode(declaration.init, state);
                 if (result.status === 'SUCCESS') {
                     state.variableDeclarations.set(variableName, result.nodeValue);
                 }
@@ -54,7 +46,7 @@ function _collectVariableDeclarations(node, state) {
     if (node.type === 'AssignmentExpression' && node.left.type === 'Identifier') {
         const variableName = node.left.name;
         if (state.variableDeclarations.has(variableName)) {
-            const result = (0, parsing_utils_1.getValueFromNode)(node.right, state);
+            const result = getValueFromNode(node.right, state);
             if (result.status === 'SUCCESS') {
                 state.variableDeclarations.set(variableName, result.nodeValue);
             }
@@ -65,7 +57,7 @@ function _collectVariableDeclarations(node, state) {
  * We only support image imports that are within the extension directory.
  * This function will check if an image is out of bounds and collect any that are out of bounds, so we can warn the user before they run into build issues.
  */
-function checkForOutOfBoundsImageImports(node, output, extensionPath) {
+export function checkForOutOfBoundsImageImports(node, output, extensionPath) {
     if (!node) {
         return;
     }
@@ -73,12 +65,12 @@ function checkForOutOfBoundsImageImports(node, output, extensionPath) {
         typeof node.source.value === 'string') {
         const importPath = node.source.value;
         // Only do the check for images.
-        if (!(0, utils_1.isImage)(importPath)) {
+        if (!isImage(importPath)) {
             return;
         }
         // Build the full path to the import, using the extension path as the base.
-        const absoluteImportPath = path_1.default.resolve(extensionPath, importPath);
-        if (!(0, utils_1.isExtensionFile)(absoluteImportPath, extensionPath)) {
+        const absoluteImportPath = path.resolve(extensionPath, importPath);
+        if (!isExtensionFile(absoluteImportPath, extensionPath)) {
             output.badImports.push(importPath);
         }
     }
@@ -91,7 +83,7 @@ function _processCrmPropertiesHook(node, output) {
     const optionsNode = node.arguments[1];
     const requestedProperties = [];
     const propertiesResult = propertiesNode
-        ? (0, parsing_utils_1.getValueFromNode)(propertiesNode, output)
+        ? getValueFromNode(propertiesNode, output)
         : null;
     if (propertiesResult &&
         propertiesResult.status === 'SUCCESS' &&
@@ -105,7 +97,7 @@ function _processCrmPropertiesHook(node, output) {
     if (requestedProperties.length > 0) {
         let options = {};
         const optionsResult = optionsNode
-            ? (0, parsing_utils_1.getValueFromNode)(optionsNode, output)
+            ? getValueFromNode(optionsNode, output)
             : null;
         if (optionsResult &&
             optionsResult.status === 'SUCCESS' &&
@@ -116,7 +108,7 @@ function _processCrmPropertiesHook(node, output) {
             options = optionsResult.nodeValue;
         }
         output.dataDependencies.dependencies.push({
-            referenceId: (0, utils_1.generateHash)(propertyType, requestedProperties),
+            referenceId: generateHash(propertyType, requestedProperties),
             properties: {
                 type: propertyType,
                 recordProperties: requestedProperties,
@@ -132,7 +124,7 @@ function _processAssociationsHook(node, output) {
     const requestNode = node.arguments[0];
     const optionsNode = node.arguments[1];
     const requestResult = requestNode
-        ? (0, parsing_utils_1.getValueFromNode)(requestNode, output)
+        ? getValueFromNode(requestNode, output)
         : null;
     if (!requestResult ||
         requestResult.status === 'FAIL' ||
@@ -158,7 +150,7 @@ function _processAssociationsHook(node, output) {
     const paginationOptions = {};
     const otherOptions = {};
     const optionsResult = optionsNode
-        ? (0, parsing_utils_1.getValueFromNode)(optionsNode, output)
+        ? getValueFromNode(optionsNode, output)
         : null;
     if (optionsResult &&
         optionsResult.status === 'SUCCESS' &&
@@ -179,7 +171,7 @@ function _processAssociationsHook(node, output) {
     }
     const sortedPropertiesForHash = [...propertiesArray].sort();
     output.dataDependencies.dependencies.push({
-        referenceId: (0, utils_1.generateHash)(propertyType, toObjectTypeId, sortedPropertiesForHash.join('-')),
+        referenceId: generateHash(propertyType, toObjectTypeId, sortedPropertiesForHash.join('-')),
         properties: {
             type: propertyType,
             toObjectTypeId,
@@ -206,6 +198,7 @@ function _collectDataDependencies(node, output, logger) {
             node.specifiers.forEach((specifier) => {
                 // If the specifier is an ImportSpecifier and the imported name is one of our tracked hooks, we will track it.
                 if (specifier.type === 'ImportSpecifier' &&
+                    specifier.imported.type === 'Identifier' &&
                     PARSED_HOOKS.includes(specifier.imported.name)) {
                     // The local name is the name the hook is imported as in the file, and the imported name is the original name of the hook.
                     output.dataDependencies.importedHooks[`${specifier.local.name}`] =
@@ -253,7 +246,7 @@ function _collectDataDependencies(node, output, logger) {
 }
 // Traverses an ESTree as defined by the EsTree spec https://github.com/estree/estree
 // Uses the checks array to search the source code for matches
-function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
+export function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
     const state = {
         functions: {},
         badImports: [],
@@ -264,7 +257,7 @@ function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
         variableDeclarations: new Map(),
     };
     try {
-        (0, estraverse_1.traverse)(ast, {
+        traverse(ast, {
             enter(node, parent) {
                 try {
                     checks.forEach((check) => {