848 improve schema validation errors (#849)

* implement bulk validation error position algorithm

* update settings schema AI options

* ensure path filtering matches only full path segments

* apply formatting changes

---------

Co-authored-by: Logende <[email protected]>

Author: Logende

meta_configurator/src/components/panels/code-editor/setupAnnotations.ts

@@ -1,9 +1,9 @@
 import {type Annotation, Editor} from 'brace';
 import type {ErrorObject} from 'ajv';
-import {jsonPointerToPath} from '@/utility/pathUtils';
+import {jsonPointerToPath, pathToJsonPointer} from '@/utility/pathUtils';
 import {determineCursorPosition} from '@/components/panels/code-editor/aceUtility';
 import {computed} from 'vue';
-import {useDataConverter} from '@/dataformats/formatRegistry';
+import {useDataConverter, usePathIndexLink} from '@/dataformats/formatRegistry';
 import {watchDebounced} from '@vueuse/core';
 import type {SessionMode} from '@/store/sessionMode';
 import {getValidationForMode} from '@/data/useDataLink';
@@ -12,6 +12,7 @@ import {useSettings} from '@/settings/useSettings';
 /**
  * Sets up the editor to show validation errors.
  * @param editor the ace editor
+ * @param mode
  */
 export function setupAnnotationsFromValidationErrors(editor: Editor, mode: SessionMode) {
   const validationAnnotations = computed(() => {
@@ -22,11 +23,21 @@ export function setupAnnotationsFromValidationErrors(editor: Editor, mode: Sessi
     }
 
     let {errors} = getValidationForMode(mode).currentValidationResult.value;
-    const maxErrorsToShow = useSettings().value.performance.maxErrorsToShow;
+
+    const supportsBulkPathDetermination = usePathIndexLink().determineIndexesOfPaths !== undefined;
+
+    const maxErrorsToShow = supportsBulkPathDetermination
+      ? useSettings().value.performance.maxErrorsToShowBulkValidation
+      : useSettings().value.performance.maxErrorsToShow;
     if (errors.length > maxErrorsToShow) {
       errors = errors.slice(0, maxErrorsToShow);
     }
-    return errors.map(error => validationErrorToAnnotation(editor, error));
+
+    if (supportsBulkPathDetermination) {
+      return validationErrorsToAnnotations(editor, errors);
+    } else {
+      return errors.map(error => validationErrorToAnnotation(editor, error));
+    }
   });
 
   watchDebounced(
@@ -46,3 +57,42 @@ function validationErrorToAnnotation(editor: Editor, error: ErrorObject): Annota
     type: 'error',
   };
 }
+
+// optimized version that uses bulk path index determination
+function validationErrorsToAnnotations(editor: Editor, errors: ErrorObject[]): Annotation[] {
+  const result: Annotation[] = [];
+  const positions = usePathIndexLink().determineIndexesOfPaths!(
+    editor.getValue(),
+    errors.map(error => jsonPointerToPath(error.instancePath))
+  );
+
+  const cachedPositionsForIndices: {[index: number]: {row: number; column: number}} = {};
+
+  for (const error of errors) {
+    const instancePathTranslated = jsonPointerToPath(error.instancePath);
+    // note that we use our own pathToJsonPointer here, to ensure consistent serialization
+    const instancePathKey = pathToJsonPointer(instancePathTranslated);
+    if (!(instancePathKey in positions)) {
+      continue;
+    }
+
+    const index = positions[instancePathKey];
+    let position;
+    if (index in cachedPositionsForIndices) {
+      position = cachedPositionsForIndices[index];
+    } else {
+      position = editor.session.doc.indexToPosition(index, 0);
+      cachedPositionsForIndices[index] = position;
+    }
+
+    const annotation: Annotation = {
+      row: position.row,
+      column: position.column,
+      text: error.message ?? 'Validation error',
+      type: 'error',
+    };
+    result.push(annotation);
+  }
+
+  return result;
+}

meta_configurator/src/components/panels/gui-editor/PropertyMetadata.vue

@@ -14,7 +14,7 @@ import {focus, makeEditableAndSelectContents} from '@/utility/focusUtils';
 import {useSettings} from '@/settings/useSettings';
 import type {SessionMode} from '@/store/sessionMode';
 import {getSessionForMode, getUserSelectionForMode} from '@/data/useDataLink';
-import type {ValidationResult} from '@/schema/validationService';
+import type {ValidationResult} from '@/schema/validationUtils';
 import {
   getDisplayNameOfNode,
   isDeprecated,

meta_configurator/src/dataformats/pathIndexLink.ts

@@ -14,6 +14,17 @@ export interface PathIndexLink {
    */
   determineIndexOfPath(dataString: string, path: Path): number;
 
+  /**
+   * (Optional) Determines the indexes of the first character of the data at the given paths.
+   * This method can be implemented for performance optimization to avoid multiple calls to
+   * `determineIndexOfPath`.
+   *
+   * @param dataString the unparsed data
+   * @param paths      the paths to determine the cursor positions for
+   * @return an object which represents the mappings from path to index
+   */
+  determineIndexesOfPaths?(dataString: string, paths: Path[]): {[pathKey: string]: number};
+
   /**
    * Determines the path for the data that is at the given index of the data string.
    *

meta_configurator/src/dataformats/pathIndexLinkJson.ts

@@ -1,5 +1,5 @@
 import type {PathIndexLink} from '@/dataformats/pathIndexLink';
-import type {Path} from '@/utility/path';
+import {type Path} from '@/utility/path';
 import type {
   CstDocument,
   CstNode,
@@ -10,6 +10,7 @@ import type {
 } from 'json-cst';
 import {parse} from 'json-cst';
 import {errorService} from '@/main';
+import {pathToJsonPointer, pathToString} from '@/utility/pathUtils';
 
 /**
  * Implementation of PathIndexLink for JSON data.
@@ -27,7 +28,6 @@ export class PathIndexLinkJson implements PathIndexLink {
       const cst = this.getCst(editorContent);
       return this.determineIndexStep(cst.root, currentPath);
     } catch (e) {
-      errorService.onError(e);
       errorService.onError(e);
       return 0;
     }
@@ -157,4 +157,70 @@ export class PathIndexLinkJson implements PathIndexLink {
     const childPath = this.determinePathStep(currentNode.valueNode, targetCharacter);
     return childPath ?? [];
   }
+
+  // performance optimization to avoid multiple calls to determineIndexOfPath
+  determineIndexesOfPaths(editorContent: string, paths: Path[]): {[pathKey: string]: number} {
+    if (editorContent.length === 0) {
+      return {};
+    }
+    try {
+      const cst = this.getCst(editorContent);
+      const result = {};
+      // transform paths into a set of path keys for faster lookup
+      const pathSet = new Set<string>();
+      for (const path of paths) {
+        pathSet.add(pathToJsonPointer(path));
+      }
+      this.traverseCstForIndexesForPaths(cst.root, pathSet, [], result);
+      return result;
+    } catch (e) {
+      errorService.onError(e);
+      return {};
+    }
+  }
+
+  // traverses the complete cst, always keeping track of the current path. When having a match with one of the requested paths, the index is stored in the result object.
+  // only ends when end of cst is reached or all paths have been found
+  private traverseCstForIndexesForPaths(
+    currentNode: CstNode,
+    paths: Set<string>,
+    currentPath: Path,
+    result: {[pathKey: string]: number}
+  ) {
+    const pathKey = pathToJsonPointer(currentPath);
+    if (paths.has(pathKey) && !(pathKey in result)) {
+      result[pathKey] = currentNode.range.start;
+      if (Object.keys(result).length === paths.size) {
+        return; // all paths found
+      }
+    }
+    switch (currentNode.kind) {
+      case 'object':
+        for (const childNode of currentNode.children) {
+          this.traverseCstForIndexesForPaths(
+            childNode,
+            paths,
+            currentPath.concat([childNode.key]),
+            result
+          );
+        }
+        break;
+      case 'object-property':
+        this.traverseCstForIndexesForPaths(currentNode.valueNode, paths, currentPath, result);
+        break;
+      case 'array':
+        let index = 0;
+        for (const childNode of currentNode.children) {
+          this.traverseCstForIndexesForPaths(childNode, paths, currentPath.concat([index]), result);
+          index++;
+        }
+        break;
+      case 'array-element':
+        this.traverseCstForIndexesForPaths(currentNode.valueNode, paths, currentPath, result);
+        break;
+      default:
+        // do nothing for primitive nodes
+        break;
+    }
+  }
 }

meta_configurator/src/schema/validationUtils.ts

@@ -50,7 +50,10 @@ export class ValidationResult {
    */
   public filterForPath(path: Path): ValidationResult {
     const jsonPointer = pathToJsonPointer(path);
-    const filteredErrors = this.errors.filter(error => error.instancePath.startsWith(jsonPointer));
+    const filteredErrors = this.errors.filter(error => {
+      const instancePath = error.instancePath;
+      return instancePath === jsonPointer || instancePath.startsWith(jsonPointer + '/');
+    });
     return new ValidationResult(filteredErrors);
   }
 

meta_configurator/src/settings/defaultSettingsData.ts

@@ -15,6 +15,7 @@ export const SETTINGS_DATA_DEFAULT = {
     minObjectPropertyCountToPreserve: 16, // when large document is trimmed, this is minimum count of object properties to be preserved
     maxShownChildrenInGuiEditor: 50,
     maxErrorsToShow: 15,
+    maxErrorsToShowBulkValidation: 200,
   },
   codeEditor: {
     fontSize: 14,

meta_configurator/src/settings/settingsSchema.ts

@@ -52,6 +52,7 @@ export const SETTINGS_SCHEMA: TopLevelSchema = {
         'minObjectPropertyCountToPreserve',
         'maxShownChildrenInGuiEditor',
         'maxErrorsToShow',
+        'maxErrorsToShowBulkValidation',
       ],
       additionalProperties: false,
       description: 'Performance related settings belong here.',
@@ -98,6 +99,13 @@ export const SETTINGS_SCHEMA: TopLevelSchema = {
           default: 15,
           minimum: 1,
         },
+        maxErrorsToShowBulkValidation: {
+          type: 'integer',
+          description:
+            'The maximum number of validation errors to show in case of internal use of bulk validation, which is supported only for some data formats.',
+          default: 200,
+          minimum: 1,
+        },
       },
     },
     codeEditor: {
@@ -489,7 +497,7 @@ export const SETTINGS_SCHEMA: TopLevelSchema = {
             // Perplexity (OpenAI-compatible)
             'https://api.perplexity.ai/',
             // OpenRouter (aggregator, OpenAI-compatible)
-            'https://api.openrouter.ai/v1/',
+            // 'https://api.openrouter.ai/v1/', seems to not support this kind of authentication
             // Academic / institutional deployments (OpenAI-compatible)
             'https://chat-ai.academiccloud.de/v1/',
             'https://api.helmholtz-blablador.fz-juelich.de/v1/',

meta_configurator/src/settings/settingsTypes.ts

@@ -27,6 +27,7 @@ export interface SettingsInterfacePerformance {
   minObjectPropertyCountToPreserve: number; // when large document is trimmed, this is minimum count of object properties to be preserved
   maxShownChildrenInGuiEditor: number;
   maxErrorsToShow: number;
+  maxErrorsToShowBulkValidation: number;
 }
 
 export interface SettingsInterfaceCodeEditor {