@domainlang/language 0.6.0 → 0.7.0

package/src/validation/import.ts

@@ -5,6 +5,7 @@ import { Cancellation } from 'langium';
 import type { DomainLangAstType, ImportStatement } from '../generated/ast.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
 import type { WorkspaceManager } from '../services/workspace-manager.js';
+import type { ImportResolver } from '../services/import-resolver.js';
 import type { ExtendedDependencySpec, ModelManifest, LockFile } from '../services/types.js';
 import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
@@ -15,15 +16,18 @@ import { ValidationMessages, buildCodeDescription, IssueCodes } from './constant
  * the shared WorkspaceManager service with its cached manifest/lock file reading.
  *
  * Checks:
+ * - All import URIs resolve to existing files
  * - External imports require manifest + alias
  * - Local path dependencies stay inside workspace  
  * - Lock file exists for external dependencies
  */
 export class ImportValidator {
     private readonly workspaceManager: WorkspaceManager;
+    private readonly importResolver: ImportResolver;
 
     constructor(services: DomainLangServices) {
         this.workspaceManager = services.imports.WorkspaceManager;
+        this.importResolver = services.imports.ImportResolver;
     }
 
     /**
@@ -48,6 +52,13 @@ export class ImportValidator {
             return;
         }
 
+        // First, verify the import resolves to a valid file
+        // This catches renamed/moved/deleted files immediately
+        const resolveError = await this.validateImportResolves(imp, document, accept);
+        if (resolveError) {
+            return; // Don't continue with other validations if can't resolve
+        }
+
         if (!this.isExternalImport(imp.uri)) {
             return;
         }
@@ -117,6 +128,63 @@ export class ImportValidator {
         return true;
     }
 
+    /**
+     * Validates that an import URI resolves to an existing file.
+     * Returns true if there was an error (import doesn't resolve).
+     */
+    private async validateImportResolves(
+        imp: ImportStatement,
+        document: LangiumDocument,
+        accept: ValidationAcceptor
+    ): Promise<boolean> {
+        if (!imp.uri) {
+            return true; // Error already reported
+        }
+
+        const docDir = path.dirname(document.uri.fsPath);
+        
+        try {
+            const resolvedUri = await this.importResolver.resolveFrom(docDir, imp.uri);
+            
+            // Check if the resolved file actually exists
+            const filePath = resolvedUri.fsPath;
+            const exists = await this.fileExists(filePath);
+            
+            if (!exists) {
+                accept('error', ValidationMessages.IMPORT_UNRESOLVED(imp.uri), {
+                    node: imp,
+                    property: 'uri',
+                    codeDescription: buildCodeDescription('language.md', 'imports'),
+                    data: { code: IssueCodes.ImportUnresolved, uri: imp.uri }
+                });
+                return true;
+            }
+            
+            return false;
+        } catch {
+            // Resolution failed - report as unresolved import
+            accept('error', ValidationMessages.IMPORT_UNRESOLVED(imp.uri), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportUnresolved, uri: imp.uri }
+            });
+            return true;
+        }
+    }
+
+    /**
+     * Checks if a file exists (async).
+     */
+    private async fileExists(filePath: string): Promise<boolean> {
+        try {
+            const stat = await fs.stat(filePath);
+            return stat.isFile();
+        } catch {
+            return false;
+        }
+    }
+
     /**
      * Gets the normalized dependency configuration for an alias.
      */
@@ -296,8 +364,13 @@ export function createImportChecks(services: DomainLangServices): ValidationChec
     return {
         // Langium 4.x supports async validators via MaybePromise<void>
         ImportStatement: async (imp, accept, cancelToken) => {
-            const document = imp.$document;
-            if (!document) return;
+            // Get document from root (Model), not from ImportStatement
+            // Langium sets $document only on the root AST node
+            const root = imp.$container;
+            const document = root?.$document;
+            if (!document) {
+                return;
+            }
 
             await validator.checkImportPath(imp, accept, document, cancelToken);
         }

package/src/validation/maps.ts

@@ -1,6 +1,6 @@
 import type { ValidationAcceptor } from 'langium';
 import type { ContextMap, DomainMap } from '../generated/ast.js';
-import { ValidationMessages, buildCodeDescription } from './constants.js';
+import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
 /**
  * Validates that a context map contains at least one bounded context.
@@ -22,6 +22,36 @@ function validateContextMapHasContexts(
     }
 }
 
+/**
+ * Validates that MultiReference items in a context map resolve.
+ * Langium doesn't report errors for unresolved MultiReference items by default,
+ * so we need custom validation to catch these cases.
+ * 
+ * @param map - The context map to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateContextMapReferences(
+    map: ContextMap,
+    accept: ValidationAcceptor
+): void {
+    if (!map.boundedContexts) return;
+    
+    for (const multiRef of map.boundedContexts) {
+        // A MultiReference has a $refText (the source text) and items (resolved refs)
+        // If $refText exists but items is empty, the reference didn't resolve
+        const refText = multiRef.$refText;
+        if (refText && multiRef.items.length === 0) {
+            accept('error', ValidationMessages.UNRESOLVED_REFERENCE('BoundedContext', refText), {
+                node: map,
+                // Find the CST node for this specific reference
+                property: 'boundedContexts',
+                index: map.boundedContexts.indexOf(multiRef),
+                code: IssueCodes.UnresolvedReference
+            });
+        }
+    }
+}
+
 /**
  * Validates that a context map has at least one relationship if it contains multiple contexts.
  * Multiple unrelated contexts should have documented relationships.
@@ -66,11 +96,38 @@ function validateDomainMapHasDomains(
     }
 }
 
+/**
+ * Validates that MultiReference items in a domain map resolve.
+ * 
+ * @param map - The domain map to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateDomainMapReferences(
+    map: DomainMap,
+    accept: ValidationAcceptor
+): void {
+    if (!map.domains) return;
+    
+    for (const multiRef of map.domains) {
+        const refText = multiRef.$refText;
+        if (refText && multiRef.items.length === 0) {
+            accept('error', ValidationMessages.UNRESOLVED_REFERENCE('Domain', refText), {
+                node: map,
+                property: 'domains',
+                index: map.domains.indexOf(multiRef),
+                code: IssueCodes.UnresolvedReference
+            });
+        }
+    }
+}
+
 export const contextMapChecks = [
     validateContextMapHasContexts,
+    validateContextMapReferences,
     validateContextMapHasRelationships
 ];
 
 export const domainMapChecks = [
-    validateDomainMapHasDomains
+    validateDomainMapHasDomains,
+    validateDomainMapReferences
 ];