@hubspot/project-parsing-lib 0.11.2 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hubspot/project-parsing-lib",
-    "version": "0.11.2",
+    "version": "0.12.0",
     "description": "Parsing library for converting projects directory structures to their intermediate representation",
     "license": "Apache-2.0",
     "type": "module",

package/src/lib/profiles.js

@@ -1,7 +1,14 @@
 import { PROFILE_FILE_PREFIX } from './constants.js';
 import { errorMessages } from '../lang/copy.js';
 const profileFilenameRegex = new RegExp(`^${PROFILE_FILE_PREFIX}\\.([^.]+)\\.json$`);
+// Regex to match variable placeholders like ${variableName}
 const profileInsertRegex = /\${(.*?)}/g;
+// Helper to check if string is a single variable reference (e.g., "${port}" but not "http://${port}")
+// Returns the variable key if it matches, null otherwise
+function isSingleVariableReference(str) {
+    const match = str.match(/^\${([^}]+)}$/);
+    return match ? match[1] : null;
+}
 export function getIsProfileFile(filename) {
     return profileFilenameRegex.test(filename);
 }
@@ -20,56 +27,85 @@ export function getHsProfileVariables(hsProfileContents) {
 }
 export function validateProfileVariables(profileVariables, filename) {
     const errors = [];
-    Object.entries(profileVariables).forEach(([key, value]) => {
+    for (const [variableKey, variableValue] of Object.entries(profileVariables)) {
         try {
-            validateProfileVariable(typeof value, key, filename);
+            const variableType = typeof variableValue;
+            validateProfileVariable(variableType, variableKey, filename);
         }
-        catch (e) {
-            if (e instanceof Error) {
-                errors.push(e.message);
-            }
-            else {
-                errors.push(`${e}`);
-            }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(errorMessage);
         }
-    });
+    }
     return {
         success: errors.length === 0,
         errors,
     };
 }
-function validateProfileVariable(profileVariableType, key, file) {
-    if (profileVariableType === 'undefined') {
-        throw new Error(errorMessages.profile.missingValue(key, file));
+function validateProfileVariable(variableType, variableKey, filename) {
+    const allowedTypes = ['string', 'number', 'boolean'];
+    if (variableType === 'undefined') {
+        throw new Error(errorMessages.profile.missingValue(variableKey, filename));
     }
-    if (!['string', 'number', 'boolean'].includes(profileVariableType)) {
-        throw new Error(errorMessages.profile.invalidValue(key));
+    if (!allowedTypes.includes(variableType)) {
+        throw new Error(errorMessages.profile.invalidValue(variableKey));
     }
 }
 function interpolate(file, template, profileVariables) {
-    return template.replace(profileInsertRegex, (__match, key) => {
-        const profileVariableType = typeof profileVariables[key];
-        validateProfileVariable(profileVariableType, key, file);
-        return String(profileVariables[key]);
+    return template.replace(profileInsertRegex, (_fullMatch, variableKey) => {
+        const variableValue = profileVariables[variableKey];
+        const variableType = typeof variableValue;
+        validateProfileVariable(variableType, variableKey, file);
+        return String(variableValue);
     });
 }
+function replaceVariablesInValue(value, file, profileVariables) {
+    // Handle string values with variable substitution
+    if (typeof value === 'string') {
+        // If the entire value is a single variable (e.g., "${port}"),
+        // return the typed value to preserve number/boolean types
+        const variableKey = isSingleVariableReference(value);
+        if (variableKey) {
+            const variableValue = profileVariables[variableKey];
+            const variableType = typeof variableValue;
+            validateProfileVariable(variableType, variableKey, file);
+            return variableValue;
+        }
+        // Otherwise, perform string interpolation (no-op if no variables found)
+        // For strings with multiple variables (e.g., "http://${host}:${port}"),
+        // this converts all values to strings
+        return interpolate(file, value, profileVariables);
+    }
+    // Recursively handle arrays
+    if (Array.isArray(value)) {
+        return value.map(item => replaceVariablesInValue(item, file, profileVariables));
+    }
+    // Recursively handle objects
+    if (value !== null && typeof value === 'object') {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = replaceVariablesInValue(val, file, profileVariables);
+        }
+        return result;
+    }
+    // Return primitive values as-is
+    return value;
+}
 export function applyHsProfileVariables(fileParseResults, hsProfileContents) {
     const profileVariables = getHsProfileVariables(hsProfileContents);
     return fileParseResults.map(fileParseResult => {
         const { content, file } = fileParseResult;
-        if (content && content.config) {
-            let interpolatedConfig = content.config;
-            interpolatedConfig = JSON.parse(interpolate(file, JSON.stringify(content.config), profileVariables));
-            if (interpolatedConfig) {
-                return {
-                    ...fileParseResult,
-                    content: {
-                        ...content,
-                        config: interpolatedConfig,
-                    },
-                };
-            }
+        // Only process files that have content with a config section
+        if (!content?.config) {
+            return fileParseResult;
         }
-        return fileParseResult;
+        const configWithVariablesReplaced = replaceVariablesInValue(content.config, file, profileVariables);
+        return {
+            ...fileParseResult,
+            content: {
+                ...content,
+                config: configWithVariablesReplaced,
+            },
+        };
     });
 }