fix(util-endpoints): evaluateTemplate implementation without RegExp or Function argument

Author: trivikr

packages/util-endpoints/src/utils/evaluateErrorRule.ts

@@ -14,6 +14,6 @@ export const evaluateErrorRule = (errorRule: ErrorRuleObject, options: EvaluateO
     evaluateExpression(error, "Error", {
       ...options,
       referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-    })
+    }) as string
   );
 };

packages/util-endpoints/src/utils/evaluateTemplate.ts

@@ -1,38 +1,46 @@
 import { getAttr } from "../lib";
 import { EvaluateOptions } from "../types";
 
-const ATTR_SHORTHAND_REGEX = new RegExp("\\${([\\w]+)#([\\w]+)}", "g");
-
 export const evaluateTemplate = (template: string, options: EvaluateOptions) => {
-  const templateToEvaluate = template
-    // Replace `{value}` with `${value}`
-    .replace(new RegExp(`\{([^{}]+)\}`, "g"), "${$1}")
-    // Replace `{${value}}` with `{value}`
-    .replace(new RegExp(`\{\\$\{([^{}]+)\}\}`, "g"), "{$1}");
+  const evaluatedTemplateArr: Array<String> = [];
 
   const templateContext = {
     ...options.endpointParams,
     ...options.referenceRecord,
-  };
-
-  const attrShortHandList = templateToEvaluate.match(ATTR_SHORTHAND_REGEX) || [];
-
-  const attrShortHandMap = attrShortHandList.reduce((acc, attrShortHand) => {
-    const indexOfHash = attrShortHand.indexOf("#");
-    const refName = attrShortHand.substring(2, indexOfHash);
-    const attrName = attrShortHand.substring(indexOfHash + 1, attrShortHand.length - 1);
-    acc[attrShortHand] = getAttr(templateContext[refName] as Record<string, any>, attrName) as string;
-    return acc;
-  }, {} as Record<string, string>);
-
-  const templateWithAttr = Object.entries(attrShortHandMap).reduce(
-    (acc, [shortHand, value]) => acc.replace(shortHand, value),
-    templateToEvaluate
-  );
-
-  const templateContextNames = Object.keys(templateContext);
-  const templateContextValues = Object.values(templateContext);
-  const templateWithTildeEscaped = templateWithAttr.replace(/\`/g, "\\`");
-
-  return new Function(...templateContextNames, `return \`${templateWithTildeEscaped}\``)(...templateContextValues);
+  } as Record<string, string>;
+
+  for (let i = 0; i < template.length; i++) {
+    const char = template[i];
+    const nextChar = template[i + 1];
+
+    if (char === "{") {
+      if (nextChar === "{") {
+        // Escaped expression, skip next char
+        i++;
+        evaluatedTemplateArr.push(char);
+      } else {
+        const closingBraceIndex = template.indexOf("}", i);
+        const parameterName = template.substring(i + 1, closingBraceIndex);
+
+        if (parameterName.includes("#")) {
+          const [refName, attrName] = parameterName.split("#");
+          evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName) as string);
+        } else {
+          evaluatedTemplateArr.push(templateContext[parameterName]);
+        }
+
+        i = closingBraceIndex;
+      }
+    } else if (char === "}") {
+      if (nextChar === "}") {
+        // Escaped expression, skip next char
+        i++;
+      }
+      evaluatedTemplateArr.push(char);
+    } else {
+      evaluatedTemplateArr.push(char);
+    }
+  }
+
+  return evaluatedTemplateArr.join("");
 };