Error handling robustness

Cleanup of some things I missed yesterday...

src/pages/EditMonitor.vue

@@ -301,7 +301,7 @@
                                     </div>
                                     <div class="flex-grow-1">
                                         <label for="expectedValue" class="form-label">{{ $t("Expected Value") }}</label>
-                                        <input v-if="monitor.jsonPathOperator !== 'contains' && monitor.jsonPathOperator !== '=='" id="expectedValue" v-model="monitor.expectedValue" type="number" class="form-control" required step=".01">
+                                        <input v-if="monitor.jsonPathOperator !== 'contains' && monitor.jsonPathOperator !== '==' && monitor.jsonPathOperator !== '!='" id="expectedValue" v-model="monitor.expectedValue" type="number" class="form-control" required step=".01">
                                         <input v-else id="expectedValue" v-model="monitor.expectedValue" type="text" class="form-control" required>
                                     </div>
                                 </div>

src/util.js

@@ -405,43 +405,43 @@ async function evaluateJsonQuery(data, jsonPath, jsonPathOperator, expectedValue
     catch (_a) {
         response = typeof data === "number" || typeof data === "object" ? data : data.toString();
     }
-    if (jsonPath && typeof data === "object") {
+    try {
-        try {
+        response = (jsonPath) ? await jsonata(jsonPath).evaluate(response) : response;
-            response = await jsonata(jsonPath).evaluate(response);
+        let jsonQueryExpression;
+        switch (jsonPathOperator) {
+            case ">":
+            case ">=":
+            case "<":
+            case "<=":
+                jsonQueryExpression = `$.value ${jsonPathOperator} $.expected`;
+                break;
+            case "!=":
+                jsonQueryExpression = "$string($.value) != $string($.expected)";
+                break;
+            case "==":
+                jsonQueryExpression = "$string($.value) = $string($.expected)";
+                break;
+            case "contains":
+                jsonQueryExpression = "$contains($string($.value), $string($.expected))";
+                break;
+            default:
+                throw new Error(`Invalid condition ${jsonPathOperator}`);
         }
-        catch (err) {
+        const expression = jsonata(jsonQueryExpression);
-            throw new Error(`Error evaluating JSON query: ${err.message}`);
+        const status = await expression.evaluate({
+            value: response,
+            expected: expectedValue
+        });
+        if (response === undefined || status === undefined) {
+            throw new Error("Query evaluation returned undefined. Check query syntax and the structure of the response data");
         }
+        return {
+            status,
+            response
+        };
     }
-    let jsonQueryExpression;
+    catch (err) {
-    switch (jsonPathOperator) {
+        throw new Error(`Error evaluating JSON query: ${err.message}. Response from server was: ${response}`);
-        case ">":
-        case ">=":
-        case "<":
-        case "<=":
-        case "!=":
-            jsonQueryExpression = `$.value ${jsonPathOperator} $.expected`;
-            break;
-        case "==":
-            jsonQueryExpression = "$string($.value) = $string($.expected)";
-            break;
-        case "contains":
-            jsonQueryExpression = "$contains($string($.value), $string($.expected))";
-            break;
-        default:
-            throw new Error(`Invalid condition ${jsonPathOperator}`);
-    }
-    const expression = jsonata(jsonQueryExpression);
-    const status = await expression.evaluate({
-        value: response.toString(),
-        expected: expectedValue.toString()
-    });
-    if (response === undefined || status === undefined) {
-        throw new Error("Query evaluation returned undefined. Check your query syntax and the structure of the response data.");
     }
-    return {
-        status,
-        response
-    };
 }
 exports.evaluateJsonQuery = evaluateJsonQuery;

src/util.ts

@@ -663,49 +663,48 @@ export async function evaluateJsonQuery(data: any, jsonPath: string, jsonPathOpe
         response = typeof data === "number" || typeof data === "object" ? data : data.toString();
     }
 
-    // If a JSON path is provided, pre-evaluate the data using it.
+    try {
-    if (jsonPath && typeof data === "object") {
+        // If a JSON path is provided, pre-evaluate the data using it.
-        try {
+        response = (jsonPath) ? await jsonata(jsonPath).evaluate(response) : response;
-            response = await jsonata(jsonPath).evaluate(response);
+
-        } catch (err: any) {
+        // Perform the comparison logic using the chosen operator
-            throw new Error(`Error evaluating JSON query: ${err.message}`);
+        let jsonQueryExpression;
+        switch (jsonPathOperator) {
+            case ">":
+            case ">=":
+            case "<":
+            case "<=":
+                jsonQueryExpression = `$.value ${jsonPathOperator} $.expected`;
+                break;
+            case "!=":
+                jsonQueryExpression = "$string($.value) != $string($.expected)";
+                break;
+            case "==":
+                jsonQueryExpression = "$string($.value) = $string($.expected)";
+                break;
+            case "contains":
+                jsonQueryExpression = "$contains($string($.value), $string($.expected))";
+                break;
+            default:
+                throw new Error(`Invalid condition ${jsonPathOperator}`);
         }
-    }
 
-    // Perform the comparison logic using the chosen operator
+        // Evaluate the JSON Query Expression
-    // Perform the comparison logic using the chosen operator
+        const expression = jsonata(jsonQueryExpression);
-    let jsonQueryExpression;
+        const status = await expression.evaluate({
-    switch (jsonPathOperator) {
+            value: response,
-        case ">":
+            expected: expectedValue
-        case ">=":
+        });
-        case "<":
-        case "<=":
-        case "!=":
-            jsonQueryExpression = `$.value ${jsonPathOperator} $.expected`;
-            break;
-        case "==":
-            jsonQueryExpression = "$string($.value) = $string($.expected)";
-            break;
-        case "contains":
-            jsonQueryExpression = "$contains($string($.value), $string($.expected))";
-            break;
-        default:
-            throw new Error(`Invalid condition ${jsonPathOperator}`);
-    }
 
-    // Evaluate the JSON Query Expression
+        if (response === undefined || status === undefined) {
-    const expression = jsonata(jsonQueryExpression);
+            throw new Error("Query evaluation returned undefined. Check query syntax and the structure of the response data");
-    const status = await expression.evaluate({
+        }
-        value: response.toString(),
-        expected: expectedValue.toString()
-    });
 
-    if (response === undefined || status === undefined) {
+        return {
-        throw new Error("Query evaluation returned undefined. Check your query syntax and the structure of the response data.");
+            status,  // The evaluation of the json query
+            response // The response from the server or result from initial json-query evaluation
+        };
+    } catch (err: any) {
+        throw new Error(`Error evaluating JSON query: ${err.message}. Response from server was: ${response}`);
     }
-
-    return {
-        status,  // The evaluation of the json query
-        response // The response from the server or result from initial json-query evaluation
-    };
 }