error handle for variable types

Author: dgarcia3atlassiancom

packages/core/src/formatters/base.ts

@@ -659,9 +659,28 @@ export abstract class BaseFormatter {
     fullStringModifiers: FullStringModifiers
   ): ParseValueToVariable {
     // get variableType and propertyName from baseString without regex
-    const variableType = baseString.split('.')[0].toLowerCase();
+    let variableType = baseString.split('.')[0].toLowerCase();
+    let foundVariableType: boolean = false;
+    Object.keys(this.regexBuilder.hardcodedParseValueKeysForRegexMatching).forEach((key) => {
+      if (variableType == key.toLowerCase()) {
+        variableType = key;
+        foundVariableType = true;
+      }
+    });
+    if (!foundVariableType) return () => ({ error: `{unknown_variableType(${variableType})}` }); // should never happen
     baseString = baseString.substring(variableType.length + 1);
-    const propertyName = baseString.split('::')[0].toLowerCase();
+    
+    let propertyName = baseString.split('::')[0].toLowerCase(); // TODO: replace with this.regexBuilder.modifierPrefix || this.regexBuilder.comparatorWrapper
+    let foundPropertyName: boolean = false;
+    const sectionOfVariableType = this.regexBuilder.hardcodedParseValueKeysForRegexMatching[variableType as keyof ParseValue]!;
+    Object.keys(sectionOfVariableType).forEach((key) => {
+      if (propertyName == key.toLowerCase()) {
+        propertyName = key;
+        foundPropertyName = true;
+      }
+    });
+    if (!foundPropertyName) return () => ({ error: `{unknown_propertyName(${variableType}.${propertyName})}` }); // should never happen
+
     const allModifiers = baseString.substring(propertyName.length);
     let sortedModMatches: string[] = [];
     if (allModifiers.length) {
@@ -872,7 +891,7 @@ class BaseFormatterRegexBuilder {
   public checkTFSplit = '"||"';
   public modifierPrefix = '::';
   public comparatorWrapper = '::';
-  private hardcodedParseValueKeysForRegexMatching: ParseValue;
+  public hardcodedParseValueKeysForRegexMatching: ParseValue;
   constructor(hardcodedParseValueKeysForRegexMatching: ParseValue) {
     this.hardcodedParseValueKeysForRegexMatching =
       hardcodedParseValueKeysForRegexMatching;
@@ -884,19 +903,29 @@ class BaseFormatterRegexBuilder {
    */
   public buildVariableRegexPattern(): string {
     // Get all valid variable names (keys as well as subkeys) from ParseValue structure
-    const validVariableNames = Object.keys(
+
+    // enforce non-duplicate section keys (case-insensitive)
+    const sectionKeys = new Set<string>();
+    Object.keys(
       this.hardcodedParseValueKeysForRegexMatching
-    ).flatMap((sectionKey) => {
+    ).forEach((key) => {
+      if (sectionKeys.has(key.toLowerCase())) throw new Error(`Must Remove Case-Insensitive Duplicate: '${key}' in ParseValue`);
+      sectionKeys.add(key.toLowerCase());
+    });
+
+    const validVariableNames = [...sectionKeys].flatMap((sectionKey) => {
       const section =
         this.hardcodedParseValueKeysForRegexMatching[
           sectionKey as keyof ParseValue
         ];
-      if (section && typeof section === 'object' && section !== null) {
-        if (sectionKey.toLowerCase() != sectionKey) throw new Error(`Key '${sectionKey}' in ParseValue must be lowercased`);
+      if (section) {
+        const sectionSubKeys = new Set<string>();
         Object.keys(section).forEach((key) => {
-          if (key.toLowerCase() != key) throw new Error(`Section key '${sectionKey}.${key}' in ParseValue must be lowercased`);
+          if (sectionSubKeys.has(key.toLowerCase())) throw new Error(`Must Remove Case-Insensitive Duplicate: '${sectionKey}.${key}' in ParseValue`);
+          sectionSubKeys.add(key.toLowerCase());
         });
-        return `${sectionKey}\\.(${Object.keys(section).join('|')})`;
+        
+        return `${sectionKey}\\.(${[...sectionSubKeys].join('|')})`;
       }
       return []; // @flatMap
     });