fix(util-endpoints): evaluateTemplate implementation without RegExp/Function (#4136)

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.spec.ts

@@ -13,11 +13,9 @@ describe(evaluateTemplate.name, () => {
     jest.clearAllMocks();
   });
 
-  it("should escape tilde while processing expression", () => {
-    const template = "foo `bar` baz";
-    // This test verifies that tilde is unescaped after processing.
-    expect(evaluateTemplate(template, mockOptions)).toBe(template);
-    expect(getAttr).not.toHaveBeenCalled();
+  it("should not escape template without braces", () => {
+    const templateWithoutBraces = "foo bar baz";
+    expect(evaluateTemplate(templateWithoutBraces, mockOptions)).toEqual(templateWithoutBraces);
   });
 
   describe("should replace `{parameterName}` with value", () => {
@@ -33,7 +31,7 @@ describe(evaluateTemplate.name, () => {
     });
   });
 
-  it("should not replace string escaped {{value}}", () => {
+  it("should escape values within double braces like {{value}}", () => {
     const value = "bar";
     expect(evaluateTemplate("foo {{value1}} bar {{value2}} baz", { ...mockOptions, endpointParams: { value } })).toBe(
       "foo {value1} bar {value2} baz"
@@ -56,4 +54,15 @@ describe(evaluateTemplate.name, () => {
     expect(getAttr).toHaveBeenNthCalledWith(1, ref1, "key1");
     expect(getAttr).toHaveBeenNthCalledWith(2, ref2, "key2");
   });
+
+  describe("should not change template with incomplete braces", () => {
+    it.each([
+      "incomplete opening bracket '{' in template",
+      "incomplete closing bracket '}' in template",
+      "incomplete opening escape '{{' in template",
+      "incomplete closing escape '}}' in template",
+    ])("%s", (template) => {
+      expect(evaluateTemplate(template, mockOptions)).toEqual(template);
+    });
+  });
 });

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

@@ -1,38 +1,50 @@
 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: 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>;
+
+  let currentIndex = 0;
+  while (currentIndex < template.length) {
+    const openingBraceIndex = template.indexOf("{", currentIndex);
+
+    if (openingBraceIndex === -1) {
+      // No more opening braces, add the rest of the template and break.
+      evaluatedTemplateArr.push(template.slice(currentIndex));
+      break;
+    }
+
+    evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
+    const closingBraceIndex = template.indexOf("}", openingBraceIndex);
+
+    if (closingBraceIndex === -1) {
+      // No more closing braces, add the rest of the template and break.
+      evaluatedTemplateArr.push(template.slice(openingBraceIndex));
+      break;
+    }
+
+    if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
+      // Escaped expression. Do not evaluate.
+      evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
+      currentIndex = closingBraceIndex + 2;
+    }
+
+    const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
+
+    if (parameterName.includes("#")) {
+      const [refName, attrName] = parameterName.split("#");
+      evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName) as string);
+    } else {
+      evaluatedTemplateArr.push(templateContext[parameterName]);
+    }
+
+    currentIndex = closingBraceIndex + 1;
+  }
+
+  return evaluatedTemplateArr.join("");
 };