@microtronics/studio-cli 0.50.0 → 0.52.0

package/out/dde/dde.js

@@ -43,6 +43,7 @@ const globals_1 = require("../globals");
 const api_1 = require("./fileGenerators/api");
 const helper_1 = require("../helper");
 const registryAPI_1 = require("../registryAPI");
+var yamlRangeToLineInformation = helper_1.Helper.yamlRangeToLineInformation;
 exports.DDE_PATH = defaultFiles_1.DefaultFiles.filePaths.dde.path;
 // create file cache.
 // yaml & json
@@ -64,24 +65,59 @@ var DDE;
      * @param cwd
      * @param fs
      * @param fileName
+     * @param globalDefines
      */
-    async function validate(cwd, fs, logger, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
+    async function validate(cwd, fs, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE, globalDefines) {
+        const diagnostics = [];
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const allLibraryFiles = await getDependencies(cwd, fs, manifest);
+        // If global defines are provided, apply template substitution to library YAML
+        if (globalDefines) {
+            for (const libraryFile of allLibraryFiles) {
+                const { result, unresolvedKeys } = globals_1.Globals.replaceDefineTemplates(libraryFile.yaml, globalDefines);
+                libraryFile.yaml = result;
+                for (const key of unresolvedKeys) {
+                    diagnostics.push({
+                        file: libraryFile.path,
+                        level: 'error',
+                        message: `Unresolved define template: {{${key}}}`,
+                        line: 0,
+                        startCharacter: 0,
+                        endCharacter: 0
+                    });
+                }
+            }
+        }
         for (const libraryFile of allLibraryFiles) {
-            await validateJsonSchema(libraryFile.path, libraryFile.yaml, logger);
+            diagnostics.push(...validateJsonSchema(libraryFile.path, libraryFile.yaml));
         }
         // read project dde
         const mainDdePath = vscode_uri_1.Utils.joinPath(cwd, exports.DDE_PATH, fileName);
-        const mainDdeYaml = await readYamlFile(mainDdePath, fs);
-        await validateJsonSchema(mainDdePath, mainDdeYaml, logger);
+        let mainDdeYaml = await readYamlFile(mainDdePath, fs);
+        // Apply template substitution to main DDE YAML
+        if (globalDefines) {
+            const { result, unresolvedKeys } = globals_1.Globals.replaceDefineTemplates(mainDdeYaml, globalDefines);
+            mainDdeYaml = result;
+            for (const key of unresolvedKeys) {
+                diagnostics.push({
+                    file: mainDdePath,
+                    level: 'error',
+                    message: `Unresolved define template: {{${key}}}`,
+                    line: 0,
+                    startCharacter: 0,
+                    endCharacter: 0
+                });
+            }
+        }
+        diagnostics.push(...validateJsonSchema(mainDdePath, mainDdeYaml));
         return {
             manifest,
             libraryFiles: allLibraryFiles,
             main: {
                 path: mainDdePath,
                 yaml: mainDdeYaml
-            }
+            },
+            diagnostics
         };
     }
     DDE.validate = validate;
@@ -94,16 +130,23 @@ var DDE;
      */
     async function compileDDE(cwd, fs, logger, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
-        const validated = await validate(cwd, fs, logger, fileName);
+        // Read global defines and pass to validate for template substitution
+        const resolvedConfig = await globals_1.Globals.read(cwd, fs, logger);
+        const validated = await validate(cwd, fs, fileName, resolvedConfig.flat);
+        // If schema validation found errors, return early with validation diagnostics
+        const validationErrors = validated.diagnostics.filter(d => d.level === 'error');
+        if (validationErrors.length > 0) {
+            return { ddeJSON: null, diagnostics: validated.diagnostics };
+        }
         const historyJson = await getHistoryJson(cwd, fs, logger);
         const preCompiler = new yamlDdePreCompiler_1.YamlPreCompiler.PreCompiler(manifest, validated.libraryFiles, historyJson);
         const libraryDiagnostics = preCompiler.parseLibraries();
         const librariesHaveError = libraryDiagnostics.find(diagnostics => diagnostics.level === 'error');
         if (librariesHaveError) {
-            return { ddeJSON: null, diagnostics: libraryDiagnostics };
+            return { ddeJSON: null, diagnostics: [...validated.diagnostics, ...libraryDiagnostics] };
         }
         const { ddeJSON, diagnostics } = preCompiler.parseMainDDE(validated.main.path, validated.main.yaml);
-        return { ddeJSON, diagnostics };
+        return { ddeJSON, diagnostics: [...validated.diagnostics, ...diagnostics] };
     }
     DDE.compileDDE = compileDDE;
     const ajv = new ajv_1.default({
@@ -115,20 +158,56 @@ var DDE;
     (0, ajv_formats_1.default)(ajv);
     const validateDynamicDde = ajv.compile(DDE.DDE_SCHEMA);
     /**
-     * Validate a given dde file against the dynamic dde schema
-     * @param ddeFilePath
-     * @param yaml
-     * @param logger
+     * Validate a given dde file against the dynamic dde schema.
+     * Returns structured diagnostics with YAML source positions instead of throwing.
+     * @param ddeFilePath - URI of the YAML file being validated
+     * @param yaml - Raw YAML content to validate
+     * @returns Array of diagnostics for any YAML syntax or schema validation errors
      */
-    async function validateJsonSchema(ddeFilePath, yaml, logger) {
-        const json = (0, yaml_1.parseDocument)(yaml).toJSON();
+    function validateJsonSchema(ddeFilePath, yaml) {
+        const lineCounter = new yaml_1.LineCounter();
+        const yamlDoc = (0, yaml_1.parseDocument)(yaml, { lineCounter, keepSourceTokens: true });
+        // Collect YAML syntax errors as diagnostics
+        const diagnostics = [];
+        for (const yamlError of yamlDoc.errors) {
+            const lineInfo = yamlError.pos
+                ? yamlRangeToLineInformation(lineCounter, [yamlError.pos[0], yamlError.pos[1], yamlError.pos[1]])
+                : { line: 0, startCharacter: 0, endCharacter: 0 };
+            diagnostics.push({
+                file: ddeFilePath,
+                level: 'error',
+                message: yamlError.message,
+                ...lineInfo
+            });
+        }
+        // If the YAML has syntax errors, skip schema validation
+        if (diagnostics.length > 0) {
+            return diagnostics;
+        }
+        const json = yamlDoc.toJSON();
         const result = validateDynamicDde(json);
         if (!result) {
-            const errors = validateDynamicDde.errors || [];
-            const error = new Error(`${vscode_uri_1.Utils.basename(ddeFilePath)} has "${errors.length}" errors"`);
-            errors.forEach(error => logger.error(error));
-            throw error;
+            const allErrors = validateDynamicDde.errors || [];
+            // Filter out redundant 'if' keyword errors (the 'then'/'else' errors are more informative)
+            const errors = allErrors.filter(e => e.keyword !== 'if');
+            // Map each unique error message to a diagnostic with YAML source position
+            const seenMessages = new Set();
+            for (const error of errors) {
+                const msg = formatValidationError(error);
+                if (seenMessages.has(msg)) {
+                    continue;
+                }
+                seenMessages.add(msg);
+                const lineInfo = resolveYamlLineInfo(yamlDoc, lineCounter, error);
+                diagnostics.push({
+                    file: ddeFilePath,
+                    level: 'error',
+                    message: msg,
+                    ...lineInfo
+                });
+            }
         }
+        return diagnostics;
     }
     DDE.validateJsonSchema = validateJsonSchema;
     /**
@@ -309,14 +388,15 @@ var DDE;
      * Generate all dde related dlo files
      * @param cwd
      * @param fs
+     * @param logger
      * @param ddeJSON
      */
     async function exportAutoDloFiles(cwd, fs, logger, ddeJSON) {
         await clearAutoDloDir(cwd, fs);
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const dependencies = await getDependencies(cwd, fs, manifest);
-        const globalDefines = await globals_1.Globals.read(cwd, fs);
-        const autoInc = (0, dlo_1.generateAutoIncFromMap)(ddeJSON, globalDefines, manifest);
+        const resolvedConfig = await globals_1.Globals.read(cwd, fs, logger);
+        const autoInc = (0, dlo_1.generateAutoIncFromMap)(ddeJSON, resolvedConfig.flat, manifest);
         const appAutoDDE = new dlo_1.AutoDDEGenerator(manifest, ddeJSON, null);
         const appDDEInc = appAutoDDE.generate();
         // generate AutoDDe Files for the libraries:
@@ -423,4 +503,111 @@ async function getDependencies(cwd, fs, manifest) {
     }
     return ddeFiles;
 }
+/**
+ * Extract a custom error message from the schema's errorMessage metadata.
+ * Supports both string and object formats (e.g. { required: { field: "msg" } }).
+ * @param schemaErrorMessage - The errorMessage property from the parent schema
+ * @param keyword - The ajv error keyword
+ * @param params - The ajv error params
+ */
+function extractCustomErrorMessage(schemaErrorMessage, keyword, params) {
+    if (typeof schemaErrorMessage === 'string') {
+        return schemaErrorMessage;
+    }
+    if (typeof schemaErrorMessage !== 'object' || schemaErrorMessage === null) {
+        return '';
+    }
+    const keywordMessages = schemaErrorMessage[keyword];
+    if (typeof keywordMessages === 'string') {
+        return keywordMessages;
+    }
+    if (typeof keywordMessages !== 'object' || keywordMessages === null) {
+        return '';
+    }
+    const paramKey = params?.missingProperty;
+    return paramKey ? (keywordMessages[paramKey] ?? '') : '';
+}
+/**
+ * Build a human-readable message for a specific ajv error keyword.
+ * @param keyword - The ajv error keyword
+ * @param params - The ajv error params
+ * @param message - The default ajv error message
+ * @param parentSchema - The parent schema object (available in verbose mode)
+ */
+function buildKeywordMessage(keyword, params, message, parentSchema) {
+    const keywordMessageMap = {
+        required: () => `Missing required property '${params.missingProperty}'.`,
+        additionalProperties: () => `Unknown property '${params.additionalProperty}' is not allowed.`,
+        type: () => `Must be of type '${params.type}'.`,
+        enum: () => `Must be one of the allowed values: ${JSON.stringify(params.allowedValues)}.`,
+        pattern: () => `Value does not match the required pattern. ${parentSchema?.patternErrorMessage ?? message}`,
+        minimum: () => `${message}.`,
+        maximum: () => `${message}.`,
+        exclusiveMinimum: () => `${message}.`,
+        exclusiveMaximum: () => `${message}.`,
+        not: () => `This value is not allowed here. ${parentSchema?.description ?? ''}`.trimEnd(),
+        anyOf: () => `Value does not match any of the allowed schemas. ${parentSchema?.description ?? ''}`.trimEnd(),
+        oneOf: () => `Value does not match any of the allowed schemas. ${parentSchema?.description ?? ''}`.trimEnd()
+    };
+    const formatter = keywordMessageMap[keyword];
+    return formatter ? formatter() : message;
+}
+/**
+ * Format a single ajv validation error into a human-readable string.
+ * Uses the schema's errorMessage/description metadata when available (verbose mode)
+ * to provide more meaningful messages than the default ajv output.
+ * @param error - The ajv error object (verbose mode includes parentSchema)
+ */
+function formatValidationError(error) {
+    const path = error.instancePath || '/';
+    const parentSchema = error.parentSchema;
+    const customMessage = extractCustomErrorMessage(parentSchema?.errorMessage, error.keyword, error.params);
+    if (customMessage) {
+        return `${path}: ${customMessage}`;
+    }
+    const message = error.message || 'unknown validation error';
+    return `${path}: ${buildKeywordMessage(error.keyword, error.params, message, parentSchema)}`;
+}
+/**
+ * Resolve the YAML AST node range for a given AJV error's instancePath.
+ * Walks the parsed YAML document tree using the JSON Pointer segments from the error.
+ * Falls back to parent nodes when the exact path cannot be resolved.
+ * @param yamlDoc - The parsed YAML document with source positions
+ * @param instancePath - AJV instancePath (JSON Pointer format, e.g. "/measurement/temperature/type")
+ * @returns The YAML source range [offset, offsetEnd, srcTokenEnd] or null if unresolvable
+ */
+function resolveYamlNodeRange(yamlDoc, instancePath) {
+    const segments = instancePath
+        .split('/')
+        .filter(Boolean)
+        .map(s => {
+        const num = Number(s);
+        return Number.isNaN(num) ? s : num;
+    });
+    // Try to find the exact node, falling back to parent nodes
+    for (let depth = segments.length; depth >= 0; depth--) {
+        const path = segments.slice(0, depth);
+        const node = yamlDoc.getIn(path, true);
+        if (node?.range) {
+            return node.range;
+        }
+    }
+    return null;
+}
+/**
+ * Resolve YAML source line information for an AJV validation error.
+ * Uses the error's instancePath to locate the corresponding YAML AST node
+ * and converts its range to line/character positions.
+ * @param yamlDoc - The parsed YAML document
+ * @param lineCounter - The YAML LineCounter used during parsing
+ * @param error - The AJV error object
+ * @returns Object with line, startCharacter, and endCharacter
+ */
+function resolveYamlLineInfo(yamlDoc, lineCounter, error) {
+    const nodeRange = resolveYamlNodeRange(yamlDoc, error.instancePath || '');
+    if (nodeRange) {
+        return yamlRangeToLineInformation(lineCounter, nodeRange);
+    }
+    return { line: 0, startCharacter: 0, endCharacter: 0 };
+}
 //# sourceMappingURL=dde.js.map