@hubspot/ui-extensions-dev-server 0.9.2 → 0.9.4

package/dist/lib/DevModeParentInterface.d.ts

@@ -12,7 +12,7 @@ export declare abstract class DevModeParentInterface {
     protected abstract _generateAppExtensionMappings(components: ProjectComponentMap | UnifiedProjectComponentMap): AppExtensionMapping[];
     _getPlatformVersion(projectConfig?: ProjectConfig): PlatformVersion;
     _reset(): void;
-    parentSetup({ onUploadRequired, promptUser, logger, urls, setActiveApp, choices, }: DevModeBaseSetupArguments): Promise<void>;
+    parentSetup({ onUploadRequired, logger, urls, setActiveApp, choices, }: DevModeBaseSetupArguments): Promise<void>;
     start({ requestPorts, accountId, projectConfig, }: DevModeStartArguments): Promise<void>;
     fileChange(filePath: string, __event: unknown): Promise<void>;
     cleanup(): Promise<void>;

package/dist/lib/DevModeParentInterface.js

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DevModeParentInterface = void 0;
 const constants_1 = require("./constants");
@@ -16,6 +19,7 @@ const config_1 = require("./config");
 const constants_2 = require("./constants");
 const utils_1 = require("./utils");
 const DevServerState_1 = require("./DevServerState");
+const inquirer_1 = __importDefault(require("inquirer"));
 const defaultLogger = {
     info: (...args) => {
         console.log(...args);
@@ -63,7 +67,7 @@ class DevModeParentInterface {
         this.isConfigured = false;
         this.isRunning = false;
     }
-    parentSetup({ onUploadRequired, promptUser, logger, urls, setActiveApp, choices = [], }) {
+    parentSetup({ onUploadRequired, logger, urls, setActiveApp, choices = [], }) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isConfigured) {
@@ -80,7 +84,8 @@ class DevModeParentInterface {
                 this.configs = [choices[0].value];
             }
             else {
-                const answers = yield promptUser({
+                const promptModule = inquirer_1.default.createPromptModule();
+                const answers = yield promptModule({
                     type: 'checkbox',
                     name: 'extensions',
                     message: 'Which extension(s) would you like to run?',

package/dist/lib/ast.d.ts

@@ -1,5 +1,11 @@
-import { SourceCodeMetadata, SourceCodeChecks, Logger } from './types';
+import { SourceCodeMetadata, SourceCodeChecks, Logger, NodeValue } from './types';
 import { Program, Node } from 'estree';
+/**
+ * This is a simple utility function to rebuild the value from a node.
+ * It'll work for simple stuff, but it's likely to fail in complicated cases.
+ * Use with caution!
+ */
+export declare function getValueFromNode(node: Node, state: SourceCodeMetadata): NodeValue;
 /**
  * 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.
@@ -12,4 +18,5 @@ export declare function traverseAbstractSyntaxTree(ast: Program, checks: SourceC
         importedHooks: {};
         dependencies: never[];
     };
+    variableDeclarations: Map<string, NodeValue>;
 };

package/dist/lib/ast.js

@@ -4,7 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseAbstractSyntaxTree = exports.checkForOutOfBoundsImageImports = void 0;
+exports.traverseAbstractSyntaxTree = exports.checkForOutOfBoundsImageImports = exports.getValueFromNode = void 0;
+const UNSUPPORTED_SPREAD = Symbol('unsupported-spread');
 const path_1 = __importDefault(require("path"));
 // @ts-expect-error no type defs
 const estraverse_1 = require("estraverse");
@@ -53,6 +54,205 @@ function _checkForFunctionMetadata(node, parent, output, functionName) {
         output.functions[functionName].defined = true;
     }
 }
+function _collectVariableDeclarations(node, state) {
+    if (!node) {
+        return;
+    }
+    // Handle variable declarations (const, let, var)
+    if (node.type === 'VariableDeclaration') {
+        node.declarations.forEach((declaration) => {
+            if (declaration.type === 'VariableDeclarator' &&
+                declaration.id.type === 'Identifier' &&
+                declaration.init) {
+                const variableName = declaration.id.name;
+                const value = getValueFromNode(declaration.init, state);
+                state.variableDeclarations.set(variableName, value);
+            }
+        });
+    }
+    // Handle assignment expressions for let variables (e.g., myVar = newValue)
+    if (node.type === 'AssignmentExpression' && node.left.type === 'Identifier') {
+        const variableName = node.left.name;
+        if (state.variableDeclarations.has(variableName)) {
+            const value = getValueFromNode(node.right, state);
+            state.variableDeclarations.set(variableName, value);
+        }
+    }
+}
+/**
+ * This is a simple utility function to rebuild the value from a node.
+ * It'll work for simple stuff, but it's likely to fail in complicated cases.
+ * Use with caution!
+ */
+function getValueFromNode(node, state) {
+    switch (node.type) {
+        case 'Literal':
+            return node.value;
+        case 'Identifier': {
+            const name = node.name;
+            switch (name) {
+                case 'undefined':
+                    return undefined;
+                case 'NaN':
+                    return NaN;
+                case 'Infinity':
+                    return Infinity;
+                default:
+                    if (state.variableDeclarations.has(name)) {
+                        return state.variableDeclarations.get(name);
+                    }
+                    return name;
+            }
+        }
+        case 'ArrayExpression': {
+            const arrayValue = [];
+            if (node.elements.length === 0) {
+                return arrayValue;
+            }
+            // Arrays have to be built from their elements, to handle special cases like nested arrays from spread operators.
+            node.elements.forEach((element) => {
+                if (typeof element === 'object' && element !== null) {
+                    if (element.type === 'SpreadElement') {
+                        const value = getValueFromNode(element, state);
+                        if (Array.isArray(value)) {
+                            arrayValue.push(...value);
+                        }
+                        else {
+                            arrayValue.push(value);
+                        }
+                    }
+                    else {
+                        const value = getValueFromNode(element, state);
+                        arrayValue.push(value);
+                    }
+                }
+                else {
+                    arrayValue.push(element);
+                }
+            });
+            return arrayValue;
+        }
+        case 'ObjectExpression': {
+            const obj = {};
+            node.properties.forEach((prop) => {
+                switch (prop.type) {
+                    case 'Property': {
+                        const property = prop;
+                        let key = undefined;
+                        if (property.key.type === 'Identifier') {
+                            key = property.key.name;
+                        }
+                        else if (property.key.type === 'Literal') {
+                            key = String(property.key.value);
+                        }
+                        if (key) {
+                            obj[key] = getValueFromNode(property.value, state);
+                        }
+                        break;
+                    }
+                    case 'SpreadElement': {
+                        const spreadValue = getValueFromNode(prop, state);
+                        if (spreadValue !== UNSUPPORTED_SPREAD &&
+                            spreadValue &&
+                            typeof spreadValue === 'object') {
+                            Object.assign(obj, spreadValue);
+                        }
+                        break;
+                    }
+                    default:
+                        // Ignore unsupported property types, as we don't have a key for them.
+                        // This could be a computed property or something else we don't handle.
+                        break;
+                }
+            });
+            return obj;
+        }
+        /**
+         * Spread elements are a bit tricky. They can be used to directly spread an array or object,
+         * or they can be used to spread a variable that is defined elsewhere. Our strategy is to return
+         * whatever element should be spread, and then handle the spreading in the parent array or object.
+         *
+         * There are also trickier cases we don't handle, like spreading a function call that returns an
+         * array or object. When the spread element is unsupported, we return a special symbol.
+         */
+        case 'SpreadElement':
+            if (node.argument) {
+                if (node.argument.type === 'Identifier' && node.argument.name) {
+                    return state.variableDeclarations.get(node.argument.name) || null;
+                }
+                else if (node.argument.type === 'ArrayExpression' ||
+                    node.argument.type === 'ObjectExpression') {
+                    return getValueFromNode(node.argument, state);
+                }
+            }
+            return UNSUPPORTED_SPREAD;
+        /**
+         * Template literals are built of an alternating sequence of static
+         * strings and expressions. We will concatenate the static strings and
+         * evaluate the expressions to build the final string.
+         */
+        case 'TemplateLiteral': {
+            let result = '';
+            if (node.expressions && node.quasis) {
+                const { quasis, expressions } = node;
+                for (let i = 0; i < quasis.length; i++) {
+                    // Prefer cooked value if available, otherwise use raw.
+                    result += quasis[i].value.cooked || quasis[i].value.raw;
+                    if (i < expressions.length) {
+                        const expression = expressions[i];
+                        const expressionValue = getValueFromNode(expression, state);
+                        if (expressionValue === null ||
+                            expressionValue === undefined ||
+                            typeof expressionValue === 'string' ||
+                            typeof expressionValue === 'number' ||
+                            typeof expressionValue === 'boolean') {
+                            result += String(expressionValue);
+                        }
+                        else if (Array.isArray(expressionValue)) {
+                            result += expressionValue.join(',');
+                        }
+                        else if (typeof expressionValue === 'object') {
+                            result += '[object Object]';
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+        case 'UnaryExpression': {
+            const arg = getValueFromNode(node.argument, state);
+            switch (node.operator) {
+                case '-':
+                    return typeof arg === 'number' ? -arg : NaN;
+                case '+':
+                    return typeof arg === 'number' ? +arg : NaN;
+                case '!':
+                    return !arg;
+                case 'typeof':
+                    return typeof arg;
+                default:
+                    return undefined;
+            }
+        }
+        // Member expressions are used to access properties of objects.
+        case 'MemberExpression': {
+            if (node.property.type === 'Identifier' && node.property.name) {
+                // We have to recursively get the value of the object, due to the way that nested objects are parsed.
+                const objectData = getValueFromNode(node.object, state);
+                if (objectData &&
+                    typeof objectData === 'object' &&
+                    !Array.isArray(objectData) &&
+                    !(objectData instanceof RegExp)) {
+                    return objectData[node.property.name];
+                }
+            }
+            return undefined;
+        }
+        default:
+            return `Unsupported node type: ${node.type}`;
+    }
+}
+exports.getValueFromNode = getValueFromNode;
 /**
  * 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.
@@ -132,40 +332,47 @@ function _collectDataDependencies(node, output, logger) {
             // Then we handle each hook individually, as the usages and tracking format are different.
             if (hookName === 'useCrmProperties') {
                 const propertyType = 'CrmRecordProperties';
-                // Get the first argument, the properties array
                 const propertiesNode = node.arguments[0];
+                const optionsNode = node.arguments[1];
                 const requestedProperties = [];
-                // If the first argument is an array with at least one element, collect the properties.
-                if (propertiesNode &&
-                    propertiesNode.type === 'ArrayExpression' &&
-                    propertiesNode.elements.length > 0) {
-                    propertiesNode.elements.forEach((element) => {
-                        /**
-                         * We only support strings for now, and ignore the rest.
-                         * This might be more generalized in the future as we support more hooks.
-                         */
-                        if (element &&
-                            element.type === 'Literal' &&
-                            typeof element.value === 'string') {
-                            requestedProperties.push(element.value);
-                        }
-                        else {
-                            logger.warn(`Invalid property type in useCrmProperties: ${element ? element.type : 'undefined'}`);
+                const resolveValue = (astNode) => {
+                    if (!astNode)
+                        return null;
+                    if (astNode.type === 'Identifier' &&
+                        output.variableDeclarations.has(astNode.name)) {
+                        return output.variableDeclarations.get(astNode.name);
+                    }
+                    return getValueFromNode(astNode, output);
+                };
+                const propertiesValue = resolveValue(propertiesNode);
+                if (propertiesValue && Array.isArray(propertiesValue)) {
+                    propertiesValue.forEach((val) => {
+                        if (typeof val === 'string') {
+                            requestedProperties.push(val);
                         }
                     });
-                    if (requestedProperties.length > 0) {
-                        output.dataDependencies.dependencies.push({
-                            /**
-                             * This refID is a hash of the property type and the requested properties.
-                             * This should allow us to create the same hash at execution time, to find the correct data from BE.
-                             */
-                            referenceId: (0, utils_1.generateHash)(propertyType, requestedProperties),
-                            properties: {
-                                type: propertyType,
-                                recordProperties: requestedProperties,
-                            },
-                        });
+                }
+                if (requestedProperties.length > 0) {
+                    let options = {};
+                    const optionsValue = resolveValue(optionsNode);
+                    if (optionsValue &&
+                        typeof optionsValue === 'object' &&
+                        !Array.isArray(optionsValue) &&
+                        !(optionsValue instanceof RegExp)) {
+                        options = optionsValue;
                     }
+                    output.dataDependencies.dependencies.push({
+                        /**
+                         * This referenceId is a hash of the property type and the requested properties.
+                         * This should allow us to create the same hash at execution time, to find the correct data from BE.
+                         */
+                        referenceId: (0, utils_1.generateHash)(propertyType, requestedProperties),
+                        properties: {
+                            type: propertyType,
+                            recordProperties: requestedProperties,
+                            options,
+                        },
+                    });
                 }
             }
         }
@@ -184,6 +391,7 @@ function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
             importedHooks: {},
             dependencies: [],
         },
+        variableDeclarations: new Map(),
     };
     try {
         (0, estraverse_1.traverse)(ast, {
@@ -193,6 +401,7 @@ function traverseAbstractSyntaxTree(ast, checks, extensionPath, logger) {
                         _checkForFunctionMetadata(node, parent, state, check.functionName);
                     });
                     checkForOutOfBoundsImageImports(node, state, extensionPath);
+                    _collectVariableDeclarations(node, state);
                     _collectDataDependencies(node, state, logger);
                 }
                 catch (e) {

package/dist/lib/plugins/codeBlockingPlugin.js

@@ -18,6 +18,7 @@ const codeBlockingPlugin = ({ logger, extensionPath }) => {
                     importedHooks: {},
                     dependencies: [],
                 },
+                variableDeclarations: new Map(),
             };
             const requireFunctionName = 'require';
             try {

package/dist/lib/types.d.ts

@@ -1,6 +1,5 @@
 import { PLATFORM_VERSION, PRIVATE_APP, PUBLIC_APP } from './constants';
 import { LocalDevUrlMapping } from '@hubspot/app-functions-dev-server';
-import { PromptModule } from 'inquirer';
 export interface ObjectTypes {
     name: string;
 }
@@ -203,8 +202,15 @@ export type DataDependency = {
     properties: {
         type: string;
         recordProperties: string[];
+        options: {
+            [key: string]: any;
+        };
     };
 };
+export type NodeValue = string | number | boolean | null | undefined | RegExp | bigint | symbol | NodeValue[] | NodeObject;
+export type NodeObject = {
+    [key: string]: NodeValue;
+};
 export interface SourceCodeMetadata {
     functions: {
         [functionName: string]: FunctionMetadata;
@@ -216,6 +222,7 @@ export interface SourceCodeMetadata {
         };
         dependencies: DataDependency[];
     };
+    variableDeclarations: Map<string, NodeValue>;
 }
 export interface FunctionInvocationCheck {
     functionName: string;
@@ -243,7 +250,6 @@ export interface DevModeStartArguments {
 }
 export interface DevModeBaseSetupArguments {
     onUploadRequired?: VoidFunction;
-    promptUser: PromptModule;
     logger: Logger;
     urls: {
         api: string;

package/dist/lib/utils.d.ts

@@ -16,6 +16,7 @@ export declare function extractAllowedUrls(appConfig?: AppConfig): string[];
 /**
  * This function generates a deterministic hash from any number of arguments
  * Arrays and objects are stringified to ensure it works for all types.
+ * Uses the same simple hash algorithm as the browser version for consistency.
  */
 export declare function generateHash(...args: unknown[]): string;
 /**

package/dist/lib/utils.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isImage = exports.generateHash = exports.extractAllowedUrls = exports.throwUnhandledPlatformVersionError = exports.UnhandledPlatformVersionError = exports.isExtensionFile = exports.isNodeModule = exports.buildSourceId = exports.loadManifest = exports.stripAnsiColorCodes = exports.getUrlSafeFileName = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const crypto_1 = require("crypto");
 const constants_1 = require("./constants");
 function getUrlSafeFileName(filePath) {
     const { name } = path_1.default.parse(filePath);
@@ -86,9 +85,18 @@ function extractAllowedUrls(appConfig) {
     return appConfig.allowedUrls;
 }
 exports.extractAllowedUrls = extractAllowedUrls;
+function simpleHash(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input.charCodeAt(i);
+        hash = (hash * 31 + char) % 2147483647;
+    }
+    return Math.abs(hash).toString(16);
+}
 /**
  * This function generates a deterministic hash from any number of arguments
  * Arrays and objects are stringified to ensure it works for all types.
+ * Uses the same simple hash algorithm as the browser version for consistency.
  */
 function generateHash(...args) {
     try {
@@ -102,9 +110,9 @@ function generateHash(...args) {
             }
             return String(arg);
         });
+        // Return the hash of the joined strings.
         const input = [...normalizedArgs].join('::');
-        // Return the hash of the joined string.
-        return (0, crypto_1.createHash)('md5').update(input).digest('hex');
+        return simpleHash(input);
     }
     catch (e) {
         console.error('Error generating hash: ', e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/ui-extensions-dev-server",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "",
   "bin": {
     "uie": "./dist/lib/bin/cli.js"
@@ -70,5 +70,5 @@
       "optional": true
     }
   },
-  "gitHead": "931c7cf7cc3f87a54909e67a0a7df74e4eee2c3b"
+  "gitHead": "65046f5f3ce4c51652bc454e4425b57bd33aedbf"
 }