@futdevpro/fsm-dynamo 1.11.31 → 1.11.33

package/src/_collections/utils/json-error-helper.util.ts

@@ -39,13 +39,30 @@ export class DyFM_JsonErrorHelper {
     contextLines: number = 5
   ): JsonErrorLineInfo | null {
     try {
-      // Extract position from error message (e.g., "at position 10" or "Unexpected end of JSON input at position 17")
+      // Extract position from various error message formats
       let positionMatch = errorMessage.match(/at position (\d+)/);
       if (!positionMatch) {
         // Handle "Unexpected end of JSON input at position 17" format
         positionMatch = errorMessage.match(/Unexpected end of JSON input at position (\d+)/);
       }
       if (!positionMatch) {
+        // Handle "Unexpected token" format which might include position
+        positionMatch = errorMessage.match(/position (\d+)/);
+      }
+      
+      if (!positionMatch) {
+        // For "Unexpected token" errors without explicit position, try to find it from the token
+        const tokenMatch = errorMessage.match(/Unexpected token '(.)'|Unexpected token (.)/);
+        if (tokenMatch && jsonInput.includes('\n')) {
+          const token = tokenMatch[1] || tokenMatch[2];
+          if (token) {
+            // Find the first occurrence of this token (this is a simple heuristic)
+            const tokenPosition = jsonInput.indexOf(token);
+            if (tokenPosition !== -1) {
+              return this.createLineInfoFromPosition(jsonInput, tokenPosition, contextLines);
+            }
+          }
+        }
         return null;
       }
       
@@ -60,54 +77,74 @@ export class DyFM_JsonErrorHelper {
         return null;
       }
       
-      // Split input into lines to find the line number
-      const lines = jsonInput.split('\n');
-      let currentPosition = 0;
-      let lineNumber = 1;
-      let characterPosition = 0;
-      
-      for (let i = 0; i < lines.length; i++) {
-        const lineLength = lines[i].length;
-        if (currentPosition + lineLength >= position) {
-          lineNumber = i + 1;
-          characterPosition = position - currentPosition;
-          break;
-        }
-        currentPosition += lineLength + 1; // +1 for newline character
-      }
-      
-      // If we didn't find the line in the loop, it's at the end
-      if (characterPosition === 0) {
-        lineNumber = lines.length;
-        characterPosition = position - currentPosition;
-      }
-      
-      // Ensure character position is not negative
-      if (characterPosition < 0) {
-        characterPosition = 0;
-      }
-      
-      // Ensure line number is within bounds
-      if (lineNumber > lines.length) {
-        lineNumber = lines.length;
-      }
-      
-      // Get surrounding context (±contextLines)
-      const contextStart = Math.max(0, lineNumber - contextLines - 1);
-      const contextEnd = Math.min(lines.length, lineNumber + contextLines);
-      const contextLinesArray = lines.slice(contextStart, contextEnd);
-      
-      return {
-        lineNumber,
-        contextLines: contextLinesArray,
-        characterPosition
-      };
+      return this.createLineInfoFromPosition(jsonInput, position, contextLines);
     } catch (error) {
       // If we can't parse the error, return null to fall back to simple preview
       return null;
     }
   }
 
+  /**
+   * Helper method to create line info from a character position
+   */
+  private static createLineInfoFromPosition(
+    jsonInput: string, 
+    position: number, 
+    contextLines: number
+  ): JsonErrorLineInfo {
+    // Handle undefined or invalid input
+    if (!jsonInput || typeof jsonInput !== 'string') {
+      return {
+        lineNumber: 1,
+        contextLines: ['(invalid or empty input)'],
+        characterPosition: 0
+      };
+    }
+    
+    // Split input into lines to find the line number
+    const lines = jsonInput.split('\n');
+    let currentPosition = 0;
+    let lineNumber = 1;
+    let characterPosition = 0;
+    
+    for (let i = 0; i < lines.length; i++) {
+      const lineLength = lines[i].length;
+      if (currentPosition + lineLength >= position) {
+        lineNumber = i + 1;
+        characterPosition = position - currentPosition;
+        break;
+      }
+      currentPosition += lineLength + 1; // +1 for newline character
+    }
+    
+    // If we didn't find the line in the loop, it's at the end
+    if (characterPosition === 0 && lineNumber === 1) {
+      lineNumber = lines.length;
+      characterPosition = position - currentPosition;
+    }
+    
+    // Ensure character position is not negative
+    if (characterPosition < 0) {
+      characterPosition = 0;
+    }
+    
+    // Ensure line number is within bounds
+    if (lineNumber > lines.length) {
+      lineNumber = lines.length;
+    }
+    
+    // Get surrounding context (±contextLines)
+    const contextStart = Math.max(0, lineNumber - contextLines - 1);
+    const contextEnd = Math.min(lines.length, lineNumber + contextLines);
+    const contextLinesArray = lines.slice(contextStart, contextEnd);
+    
+    return {
+      lineNumber,
+      contextLines: contextLinesArray,
+      characterPosition
+    };
+  }
+
   /**
    * Formats JSON error information for logging
    * Creates a formatted string showing the error location and context
@@ -152,13 +189,39 @@ export class DyFM_JsonErrorHelper {
   static parseJsonWithEnhancedError(
     jsonString: string, 
     reviver?: (key: string, value: any) => any,
-    contextLines: number = 5
+    contextLines: number = 2
   ): any {
+    // Prevent infinite recursion and handle invalid input
+    if (!jsonString || typeof jsonString !== 'string') {
+      throw new Error(`Invalid JSON input: expected string, got ${typeof jsonString}`);
+    }
+
     try {
       return JSON.parse(jsonString, reviver);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const lineInfo = this.extractLineInfoFromJsonError(errorMessage, jsonString, contextLines);
+      const originalJsonString = jsonString;
+      
+      // First try to extract line info from the original JSON
+      let lineInfo = this.extractLineInfoFromJsonError(errorMessage, originalJsonString, contextLines);
+      
+      // If no line info was found and the JSON is on a single line, try formatting it
+      if (!lineInfo && !originalJsonString.includes('\n')) {
+        try {
+          const formattedJson = this.formatJsonForBetterErrors(originalJsonString);
+          
+          // Try parsing the formatted JSON to get a new error with position info
+          try {
+            JSON.parse(formattedJson, reviver);
+          } catch (formattedError) {
+            const formattedErrorMessage = formattedError instanceof Error ? formattedError.message : String(formattedError);
+            lineInfo = this.extractLineInfoFromJsonError(formattedErrorMessage, formattedJson, contextLines);
+          }
+        } catch (formatError) {
+          // If formatting fails, skip enhanced error reporting
+          lineInfo = null;
+        }
+      }
       
       if (lineInfo) {
         const formattedError = this.formatJsonErrorForLogging(lineInfo, errorMessage);
@@ -169,4 +232,31 @@ export class DyFM_JsonErrorHelper {
       }
     }
   }
+
+  /**
+   * Formats single-line JSON with line breaks for better error reporting
+   */
+  private static formatJsonForBetterErrors(jsonString: string): string {
+    if (!jsonString || typeof jsonString !== 'string') {
+      return jsonString || '';
+    }
+    
+    return jsonString
+      .replace(/,/g, ',\n  ')
+      .replace(/{/g, '{\n  ')
+      .replace(/}/g, '\n}')
+      .replace(/\[/g, '[\n  ')
+      .replace(/\]/g, '\n]')
+      .replace(/\n\s*\n/g, '\n') // Remove double newlines
+      .replace(/^\s+|\s+$/gm, function(match, offset, string) {
+        // Trim but preserve indentation structure
+        if (!string || typeof string !== 'string') {
+          return match;
+        }
+        const lines = string.slice(0, offset).split('\n');
+        const depth = (string.slice(0, offset).match(/{|\[/g) || []).length - 
+                     (string.slice(0, offset).match(/}|\]/g) || []).length;
+        return '  '.repeat(Math.max(0, depth));
+      });
+  }
 }