@memberjunction/metadata-sync 2.52.0 → 2.54.0

package/dist/services/ValidationService.js

@@ -27,6 +27,7 @@ exports.ValidationService = void 0;
 const core_1 = require("@memberjunction/core");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const provider_utils_1 = require("../lib/provider-utils");
 class ValidationService {
     metadata;
     errors = [];
@@ -34,6 +35,7 @@ class ValidationService {
     entityDependencies = new Map();
     processedEntities = new Set();
     options;
+    userRoleCache = new Map();
     constructor(options = {}) {
         this.metadata = new core_1.Metadata();
         this.options = {
@@ -41,7 +43,7 @@ class ValidationService {
             outputFormat: 'human',
             maxNestingDepth: 10,
             checkBestPractices: true,
-            ...options
+            ...options,
         };
     }
     /**
@@ -55,11 +57,15 @@ class ValidationService {
                 type: 'entity',
                 severity: 'error',
                 file: dir,
-                message: 'No .mj-sync.json configuration file found in directory'
+                message: 'No .mj-sync.json configuration file found in directory',
             });
             return this.getResult();
         }
         const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        // Load user role configuration and cache if enabled
+        if (config.userRoleValidation?.enabled) {
+            await this.loadUserRoles();
+        }
         const directories = await this.getDirectoriesInOrder(dir, config);
         let totalFiles = 0;
         let totalEntities = 0;
@@ -86,26 +92,56 @@ class ValidationService {
                 totalEntities,
                 totalErrors: this.errors.length,
                 totalWarnings: this.warnings.length,
-                fileResults
-            }
+                fileResults,
+            },
         };
     }
     /**
      * Validates a single entity directory
      */
     async validateEntityDirectory(dir) {
-        const configPath = path.join(dir, '.mj-sync.json');
-        if (!fs.existsSync(configPath)) {
+        // Check for .mj-folder.json first (new format)
+        let configPath = path.join(dir, '.mj-folder.json');
+        let config;
+        if (fs.existsSync(configPath)) {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            // .mj-folder.json uses entityName field
+            if (!config.entityName) {
+                this.addError({
+                    type: 'validation',
+                    severity: 'error',
+                    file: configPath,
+                    message: 'Missing entityName field in .mj-folder.json',
+                });
+                return null;
+            }
+            config.entity = config.entityName; // Normalize to entity field
+        }
+        else {
+            // Fall back to .mj-sync.json (legacy format)
+            configPath = path.join(dir, '.mj-sync.json');
+            if (!fs.existsSync(configPath)) {
+                return null;
+            }
+            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }
+        // Validate entity name exists
+        if (!config.entity || config.entity.trim() === '') {
+            this.addError({
+                type: 'validation',
+                severity: 'error',
+                file: configPath,
+                message: 'Entity name is empty or missing',
+            });
             return null;
         }
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
         const entityInfo = this.metadata.EntityByName(config.entity);
         if (!entityInfo) {
             this.addError({
                 type: 'entity',
                 severity: 'error',
                 file: configPath,
-                message: `Entity "${config.entity}" not found in metadata`
+                message: `Entity "${config.entity}" not found in metadata`,
             });
             return null;
         }
@@ -125,7 +161,6 @@ class ValidationService {
      */
     async validateFile(filePath, entityInfo, config) {
         const fileErrors = [];
-        const fileWarnings = [];
         let entityCount = 0;
         try {
             const content = fs.readFileSync(filePath, 'utf8');
@@ -141,17 +176,17 @@ class ValidationService {
                 type: 'entity',
                 severity: 'error',
                 file: filePath,
-                message: `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`
+                message: `Failed to parse JSON: ${error instanceof Error ? error.message : String(error)}`,
             });
         }
         // Collect errors and warnings for this file
-        const currentFileErrors = this.errors.filter(e => e.file === filePath);
-        const currentFileWarnings = this.warnings.filter(w => w.file === filePath);
+        const currentFileErrors = this.errors.filter((e) => e.file === filePath);
+        const currentFileWarnings = this.warnings.filter((w) => w.file === filePath);
         return {
             file: filePath,
             entityCount,
             errors: currentFileErrors,
-            warnings: currentFileWarnings
+            warnings: currentFileWarnings,
         };
     }
     /**
@@ -166,7 +201,7 @@ class ValidationService {
                 entity: entityInfo.Name,
                 file: filePath,
                 message: `Nesting depth ${depth} exceeds recommended maximum of ${this.options.maxNestingDepth}`,
-                suggestion: 'Consider flattening the data structure or increasing maxNestingDepth'
+                suggestion: 'Consider flattening the data structure or increasing maxNestingDepth',
             });
         }
         // Validate fields
@@ -185,7 +220,7 @@ class ValidationService {
                         severity: 'error',
                         entity: entityInfo.Name,
                         file: filePath,
-                        message: `Related entity "${relatedEntityName}" not found in metadata`
+                        message: `Related entity "${relatedEntityName}" not found in metadata`,
                     });
                     continue;
                 }
@@ -216,7 +251,7 @@ class ValidationService {
                             entity: entityInfo.Name,
                             field: fieldName,
                             file: filePath,
-                            message: `Field "${fieldName}" does not exist on entity "${entityInfo.Name}"`
+                            message: `Field "${fieldName}" does not exist on entity "${entityInfo.Name}"`,
                         });
                         continue;
                     }
@@ -232,7 +267,7 @@ class ValidationService {
                         entity: entityInfo.Name,
                         field: fieldName,
                         file: filePath,
-                        message: `Field "${fieldName}" does not exist on entity "${entityInfo.Name}"`
+                        message: `Field "${fieldName}" does not exist on entity "${entityInfo.Name}"`,
                     });
                     continue;
                 }
@@ -246,7 +281,7 @@ class ValidationService {
                     field: fieldName,
                     file: filePath,
                     message: `Field "${fieldName}" is a system field and cannot be set`,
-                    suggestion: 'Remove this field from your metadata file'
+                    suggestion: 'Remove this field from your metadata file',
                 });
                 continue;
             }
@@ -294,7 +329,7 @@ class ValidationService {
                     field: field.Name,
                     file: filePath,
                     message: `Required field "${field.Name}" is missing`,
-                    suggestion: `Add "${field.Name}" to the fields object`
+                    suggestion: `Add "${field.Name}" to the fields object`,
                 });
             }
         }
@@ -306,7 +341,34 @@ class ValidationService {
         if (typeof value === 'string' && value.startsWith('@')) {
             await this.validateReference(value, fieldInfo, entityInfo, filePath, parentContext);
         }
-        // Add type validation here if needed
+        // Validate UserID fields against allowed roles
+        if (fieldInfo.Name === 'UserID' && typeof value === 'string' && value.length > 0) {
+            // Get the sync config from the file's directory
+            const dir = path.dirname(filePath);
+            // Walk up to find the root sync config with userRoleValidation
+            let currentDir = dir;
+            let config = null;
+            while (currentDir && currentDir !== path.parse(currentDir).root) {
+                const currentConfigPath = path.join(currentDir, '.mj-sync.json');
+                if (fs.existsSync(currentConfigPath)) {
+                    try {
+                        const currentConfig = JSON.parse(fs.readFileSync(currentConfigPath, 'utf8'));
+                        if (currentConfig.userRoleValidation) {
+                            config = currentConfig;
+                            break;
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+                currentDir = path.dirname(currentDir);
+            }
+            if (config?.userRoleValidation?.enabled) {
+                await this.validateUserRole(value, entityInfo.Name, fieldInfo.Name, filePath, config);
+            }
+        }
+        // Add other type validation here if needed
     }
     /**
      * Validates special references (@file:, @lookup:, etc.)
@@ -320,7 +382,7 @@ class ValidationService {
                 entity: entityInfo.Name,
                 field: fieldInfo.Name,
                 file: filePath,
-                message: `Invalid reference format: "${reference}"`
+                message: `Invalid reference format: "${reference}"`,
             });
             return;
         }
@@ -348,32 +410,53 @@ class ValidationService {
     parseReference(reference) {
         const patterns = [
             ['@file:', /^@file:(.+)$/],
-            ['@lookup:', /^@lookup:([^.]+)\.([^=]+)=(.+)$/],
+            ['@lookup:', /^@lookup:([^.]+)\.(.+)$/],
             ['@template:', /^@template:(.+)$/],
             ['@parent:', /^@parent:(.+)$/],
             ['@root:', /^@root:(.+)$/],
-            ['@env:', /^@env:(.+)$/]
+            ['@env:', /^@env:(.+)$/],
         ];
         for (const [type, pattern] of patterns) {
             const match = reference.match(pattern);
             if (match) {
                 if (type === '@lookup:') {
-                    const [, entity, field, valueAndOptions] = match;
-                    const [value, ...options] = valueAndOptions.split('?');
-                    const createIfMissing = options.includes('create');
+                    const [, entity, remaining] = match;
+                    // Check if this has ?create syntax
+                    const hasCreate = remaining.includes('?create');
+                    const lookupPart = hasCreate ? remaining.split('?')[0] : remaining;
+                    // Parse all lookup fields (can be multiple with &)
+                    const lookupPairs = lookupPart.split('&');
+                    const fields = [];
+                    for (const pair of lookupPairs) {
+                        const fieldMatch = pair.match(/^(.+?)=(.+)$/);
+                        if (fieldMatch) {
+                            const [, field, value] = fieldMatch;
+                            fields.push({ field: field.trim(), value: value.trim() });
+                        }
+                    }
+                    // For backward compatibility, use the first field as primary
+                    const primaryField = fields.length > 0 ? fields[0] : { field: '', value: '' };
+                    // Parse additional fields for creation if ?create is present
                     const additionalFields = {};
-                    for (const option of options) {
-                        if (option.includes('&')) {
-                            const pairs = option.split('&');
-                            for (const pair of pairs) {
-                                const [key, val] = pair.split('=');
-                                if (key && val && key !== 'create') {
-                                    additionalFields[key] = val;
-                                }
+                    if (hasCreate && remaining.includes('?create&')) {
+                        const createPart = remaining.split('?create&')[1];
+                        const pairs = createPart.split('&');
+                        for (const pair of pairs) {
+                            const [key, val] = pair.split('=');
+                            if (key && val) {
+                                additionalFields[key] = decodeURIComponent(val);
                             }
                         }
                     }
-                    return { type, value, entity, field, createIfMissing, additionalFields };
+                    return {
+                        type,
+                        value: primaryField.value,
+                        entity,
+                        field: primaryField.field,
+                        fields, // Include all fields for validation
+                        createIfMissing: hasCreate,
+                        additionalFields
+                    };
                 }
                 return { type, value: match[1] };
             }
@@ -394,7 +477,24 @@ class ValidationService {
                 field: fieldName,
                 file: sourceFile,
                 message: `File reference not found: "${filePath}"`,
-                suggestion: `Create file at: ${resolvedPath}`
+                suggestion: `Create file at: ${resolvedPath}`,
+            });
+            return;
+        }
+        // Read the file and check for {@include} references
+        try {
+            const content = fs.readFileSync(resolvedPath, 'utf-8');
+            await this.validateIncludeReferences(content, resolvedPath, new Set([resolvedPath]));
+        }
+        catch (error) {
+            this.addError({
+                type: 'reference',
+                severity: 'error',
+                entity: entityName,
+                field: fieldName,
+                file: sourceFile,
+                message: `Failed to read file reference: "${filePath}"`,
+                details: error instanceof Error ? error.message : String(error),
             });
         }
     }
@@ -411,21 +511,41 @@ class ValidationService {
                 field: fieldName,
                 file: sourceFile,
                 message: `Lookup entity "${parsed.entity}" not found`,
-                suggestion: 'Check entity name spelling and case'
+                suggestion: 'Check entity name spelling and case',
             });
             return;
         }
-        const lookupField = lookupEntity.Fields.find((f) => f.Name === parsed.field);
-        if (!lookupField) {
-            this.addError({
-                type: 'reference',
-                severity: 'error',
-                entity: entityName,
-                field: fieldName,
-                file: sourceFile,
-                message: `Lookup field "${parsed.field}" not found on entity "${parsed.entity}"`,
-                suggestion: `Available fields: ${lookupEntity.Fields.map((f) => f.Name).join(', ')}`
-            });
+        // For multi-field lookups, validate all fields
+        if (parsed.fields && parsed.fields.length > 0) {
+            for (const { field } of parsed.fields) {
+                const lookupField = lookupEntity.Fields.find((f) => f.Name === field);
+                if (!lookupField) {
+                    this.addError({
+                        type: 'reference',
+                        severity: 'error',
+                        entity: entityName,
+                        field: fieldName,
+                        file: sourceFile,
+                        message: `Lookup field "${field}" not found on entity "${parsed.entity}"`,
+                        suggestion: `Available fields: ${lookupEntity.Fields.map((f) => f.Name).join(', ')}`,
+                    });
+                }
+            }
+        }
+        else if (parsed.field) {
+            // Fallback for single field lookup (backward compatibility)
+            const lookupField = lookupEntity.Fields.find((f) => f.Name === parsed.field);
+            if (!lookupField) {
+                this.addError({
+                    type: 'reference',
+                    severity: 'error',
+                    entity: entityName,
+                    field: fieldName,
+                    file: sourceFile,
+                    message: `Lookup field "${parsed.field}" not found on entity "${parsed.entity}"`,
+                    suggestion: `Available fields: ${lookupEntity.Fields.map((f) => f.Name).join(', ')}`,
+                });
+            }
         }
         // Track dependency
         this.addEntityDependency(entityName, parsed.entity);
@@ -444,7 +564,7 @@ class ValidationService {
                 field: fieldName,
                 file: sourceFile,
                 message: `Template file not found: "${templatePath}"`,
-                suggestion: `Create template at: ${resolvedPath}`
+                suggestion: `Create template at: ${resolvedPath}`,
             });
             return;
         }
@@ -460,14 +580,14 @@ class ValidationService {
                 field: fieldName,
                 file: sourceFile,
                 message: `Template file is not valid JSON: "${templatePath}"`,
-                details: error instanceof Error ? error.message : String(error)
+                details: error instanceof Error ? error.message : String(error),
             });
         }
     }
     /**
      * Validates @parent: references
      */
-    validateParentReference(fieldName, parentContext, sourceFile, entityName, currentFieldName) {
+    validateParentReference(_fieldName, parentContext, sourceFile, entityName, currentFieldName) {
         if (!parentContext) {
             this.addError({
                 type: 'reference',
@@ -476,14 +596,14 @@ class ValidationService {
                 field: currentFieldName,
                 file: sourceFile,
                 message: `@parent: reference used but no parent context exists`,
-                suggestion: '@parent: can only be used in nested/related entities'
+                suggestion: '@parent: can only be used in nested/related entities',
             });
         }
     }
     /**
      * Validates @root: references
      */
-    validateRootReference(fieldName, parentContext, sourceFile, entityName, currentFieldName) {
+    validateRootReference(_fieldName, parentContext, sourceFile, entityName, currentFieldName) {
         if (!parentContext) {
             this.addError({
                 type: 'reference',
@@ -492,7 +612,7 @@ class ValidationService {
                 field: currentFieldName,
                 file: sourceFile,
                 message: `@root: reference used but no root context exists`,
-                suggestion: '@root: can only be used in nested/related entities'
+                suggestion: '@root: can only be used in nested/related entities',
             });
         }
     }
@@ -504,7 +624,7 @@ class ValidationService {
             this.entityDependencies.set(entityName, {
                 entityName,
                 dependsOn: new Set(),
-                file: filePath
+                file: filePath,
             });
         }
         // Track dependencies from lookups in fields
@@ -523,11 +643,15 @@ class ValidationService {
      * Add an entity dependency
      */
     addEntityDependency(from, to) {
+        // Don't add self-references as dependencies (e.g., ParentID in hierarchical structures)
+        if (from === to) {
+            return;
+        }
         if (!this.entityDependencies.has(from)) {
             this.entityDependencies.set(from, {
                 entityName: from,
                 dependsOn: new Set(),
-                file: ''
+                file: '',
             });
         }
         this.entityDependencies.get(from).dependsOn.add(to);
@@ -546,7 +670,7 @@ class ValidationService {
         // Check for circular dependencies
         const visited = new Set();
         const recursionStack = new Set();
-        for (const [entity, deps] of this.entityDependencies) {
+        for (const [entity] of this.entityDependencies) {
             if (!visited.has(entity)) {
                 this.checkCircularDependency(entity, visited, recursionStack);
             }
@@ -563,7 +687,7 @@ class ValidationService {
                     entity: violation.entity,
                     file: violation.file,
                     message: `Entity '${violation.entity}' depends on '${violation.dependency}' but is processed before it`,
-                    suggestion: `Reorder directories to: [${suggestedOrder.join(', ')}]`
+                    suggestion: `Reorder directories to: [${suggestedOrder.join(', ')}]`,
                 });
             }
         }
@@ -594,7 +718,7 @@ class ValidationService {
                         entity: entity,
                         file: deps.file,
                         message: `Circular dependency detected: ${cyclePath}`,
-                        suggestion: 'Restructure your entities to avoid circular references'
+                        suggestion: 'Restructure your entities to avoid circular references',
                     });
                     return true;
                 }
@@ -607,12 +731,13 @@ class ValidationService {
      * Get directories in order based on config
      */
     async getDirectoriesInOrder(rootDir, config) {
-        const allDirs = fs.readdirSync(rootDir)
-            .filter(f => fs.statSync(path.join(rootDir, f)).isDirectory())
-            .filter(d => !d.startsWith('.'));
+        const allDirs = fs
+            .readdirSync(rootDir)
+            .filter((f) => fs.statSync(path.join(rootDir, f)).isDirectory())
+            .filter((d) => !d.startsWith('.'));
         if (config.directoryOrder && Array.isArray(config.directoryOrder)) {
             const ordered = config.directoryOrder.filter((d) => allDirs.includes(d));
-            const remaining = allDirs.filter(d => !ordered.includes(d)).sort();
+            const remaining = allDirs.filter((d) => !ordered.includes(d)).sort();
             return [...ordered, ...remaining];
         }
         return allDirs.sort();
@@ -621,14 +746,13 @@ class ValidationService {
      * Get files matching pattern
      */
     async getMatchingFiles(dir, pattern) {
-        const files = fs.readdirSync(dir)
-            .filter(f => fs.statSync(path.join(dir, f)).isFile());
+        const files = fs.readdirSync(dir).filter((f) => fs.statSync(path.join(dir, f)).isFile());
         // Simple glob pattern matching
         if (pattern === '*.json') {
-            return files.filter(f => f.endsWith('.json') && !f.startsWith('.mj-'));
+            return files.filter((f) => f.endsWith('.json') && !f.startsWith('.mj-'));
         }
         else if (pattern === '.*.json') {
-            return files.filter(f => f.startsWith('.') && f.endsWith('.json') && !f.startsWith('.mj-'));
+            return files.filter((f) => f.startsWith('.') && f.endsWith('.json') && !f.startsWith('.mj-'));
         }
         return files;
     }
@@ -660,7 +784,7 @@ class ValidationService {
                         violations.push({
                             entity: entityName,
                             dependency: dep,
-                            file: deps.file
+                            file: deps.file,
                         });
                     }
                 }
@@ -714,6 +838,7 @@ class ValidationService {
         this.warnings = [];
         this.entityDependencies.clear();
         this.processedEntities.clear();
+        this.userRoleCache.clear();
     }
     /**
      * Get validation result
@@ -728,10 +853,163 @@ class ValidationService {
                 totalEntities: 0,
                 totalErrors: this.errors.length,
                 totalWarnings: this.warnings.length,
-                fileResults: new Map()
-            }
+                fileResults: new Map(),
+            },
         };
     }
+    /**
+     * Load user roles from the database into cache
+     */
+    async loadUserRoles() {
+        try {
+            const rv = new core_1.RunView();
+            const systemUser = (0, provider_utils_1.getSystemUser)();
+            // Load all user roles with role names
+            const result = await rv.RunView({
+                EntityName: 'User Roles',
+                ExtraFilter: '',
+                OrderBy: 'UserID',
+                MaxRows: 10000,
+            }, systemUser);
+            if (!result.Success) {
+                this.addWarning({
+                    type: 'validation',
+                    severity: 'warning',
+                    file: 'system',
+                    message: 'Failed to load user roles for validation',
+                    details: result.ErrorMessage,
+                });
+                return;
+            }
+            // Group roles by UserID
+            for (const userRole of result.Results || []) {
+                const userId = userRole.UserID;
+                const roleName = userRole.Role;
+                if (!this.userRoleCache.has(userId)) {
+                    this.userRoleCache.set(userId, []);
+                }
+                this.userRoleCache.get(userId).push(roleName);
+            }
+            if (this.options.verbose) {
+                console.log(`Loaded roles for ${this.userRoleCache.size} users`);
+            }
+        }
+        catch (error) {
+            this.addWarning({
+                type: 'validation',
+                severity: 'warning',
+                file: 'system',
+                message: 'Error loading user roles for validation',
+                details: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Validate a UserID field value against allowed roles
+     */
+    async validateUserRole(userId, entityName, fieldName, filePath, config) {
+        // Skip if user role validation is not enabled
+        if (!config.userRoleValidation?.enabled) {
+            return;
+        }
+        const userRoles = this.userRoleCache.get(userId);
+        const allowedRoles = config.userRoleValidation.allowedRoles || [];
+        const allowUsersWithoutRoles = config.userRoleValidation.allowUsersWithoutRoles || false;
+        if (!userRoles || userRoles.length === 0) {
+            if (!allowUsersWithoutRoles) {
+                this.addError({
+                    type: 'validation',
+                    severity: 'error',
+                    entity: entityName,
+                    field: fieldName,
+                    file: filePath,
+                    message: `UserID '${userId}' does not have any assigned roles`,
+                    suggestion: allowedRoles.length > 0
+                        ? `User must have one of these roles: ${allowedRoles.join(', ')}`
+                        : 'Assign appropriate roles to this user or set allowUsersWithoutRoles: true',
+                });
+            }
+            return;
+        }
+        // Check if user has at least one allowed role
+        if (allowedRoles.length > 0) {
+            const hasAllowedRole = userRoles.some((role) => allowedRoles.includes(role));
+            if (!hasAllowedRole) {
+                this.addError({
+                    type: 'validation',
+                    severity: 'error',
+                    entity: entityName,
+                    field: fieldName,
+                    file: filePath,
+                    message: `UserID '${userId}' has roles [${userRoles.join(', ')}] but none are in allowed list`,
+                    suggestion: `Allowed roles: ${allowedRoles.join(', ')}`,
+                });
+            }
+        }
+    }
+    /**
+     * Validates {@include} references within file content
+     *
+     * Recursively checks all {@include path} references in file content to ensure:
+     * - Referenced files exist
+     * - No circular references occur
+     * - Include paths are valid
+     *
+     * @param content - The file content to validate
+     * @param filePath - Path of the file being validated
+     * @param visitedPaths - Set of already visited paths for circular reference detection
+     */
+    async validateIncludeReferences(content, filePath, visitedPaths) {
+        // Pattern to match {@include path} references
+        const includePattern = /\{@include\s+([^\}]+)\s*\}/g;
+        let match;
+        while ((match = includePattern.exec(content)) !== null) {
+            const [fullMatch, includePath] = match;
+            const trimmedPath = includePath.trim();
+            // Resolve the include path relative to the current file's directory
+            const currentDir = path.dirname(filePath);
+            const resolvedPath = path.resolve(currentDir, trimmedPath);
+            // Check for circular reference
+            if (visitedPaths.has(resolvedPath)) {
+                this.addError({
+                    type: 'reference',
+                    severity: 'error',
+                    file: filePath,
+                    message: `Circular {@include} reference detected: "${trimmedPath}"`,
+                    details: `Path ${resolvedPath} is already being processed`,
+                    suggestion: 'Restructure your includes to avoid circular references',
+                });
+                continue;
+            }
+            // Check if the included file exists
+            if (!fs.existsSync(resolvedPath)) {
+                this.addError({
+                    type: 'reference',
+                    severity: 'error',
+                    file: filePath,
+                    message: `{@include} file not found: "${trimmedPath}"`,
+                    suggestion: `Create file at: ${resolvedPath}`,
+                });
+                continue;
+            }
+            // Recursively validate the included file
+            try {
+                const includedContent = fs.readFileSync(resolvedPath, 'utf-8');
+                const newVisitedPaths = new Set(visitedPaths);
+                newVisitedPaths.add(resolvedPath);
+                await this.validateIncludeReferences(includedContent, resolvedPath, newVisitedPaths);
+            }
+            catch (error) {
+                this.addError({
+                    type: 'reference',
+                    severity: 'error',
+                    file: filePath,
+                    message: `Failed to read {@include} file: "${trimmedPath}"`,
+                    details: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
 }
 exports.ValidationService = ValidationService;
 //# sourceMappingURL=ValidationService.js.map