@domainlang/language 0.6.0 → 0.8.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;
         }
@@ -67,35 +78,36 @@ export class ImportValidator {
             return;
         }
 
-        const alias = imp.uri.split('/')[0];
-        const dependency = this.getDependency(manifest, alias);
+        // Find the matching dependency by key (owner/package format)
+        const match = this.findDependency(manifest, imp.uri);
 
-        if (!dependency) {
-            accept('error', ValidationMessages.IMPORT_NOT_IN_MANIFEST(alias), {
+        if (!match) {
+            accept('error', ValidationMessages.IMPORT_NOT_IN_MANIFEST(imp.uri), {
                 node: imp,
                 property: 'uri',
                 codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportNotInManifest, alias }
+                data: { code: IssueCodes.ImportNotInManifest, alias: imp.uri }
             });
             return;
         }
 
-        this.validateDependencyConfig(dependency, alias, accept, imp);
+        const { key, dependency } = match;
+        this.validateDependencyConfig(dependency, key, accept, imp);
 
         // External source dependencies require lock file and cached packages
         if (dependency.source) {
             const lockFile = await this.workspaceManager.getLockFile();
             if (!lockFile) {
-                accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
+                accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(key), {
                     node: imp,
                     property: 'uri',
                     codeDescription: buildCodeDescription('language.md', 'imports'),
-                    data: { code: IssueCodes.ImportNotInstalled, alias }
+                    data: { code: IssueCodes.ImportNotInstalled, alias: key }
                 });
                 return;
             }
 
-            await this.validateCachedPackage(dependency, alias, lockFile, accept, imp);
+            await this.validateCachedPackage(dependency, key, lockFile, accept, imp);
         }
     }
 
@@ -118,20 +130,111 @@ export class ImportValidator {
     }
 
     /**
-     * Gets the normalized dependency configuration for an alias.
+     * 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;
+        }
+    }
+
+    /**
+     * Finds the dependency configuration that matches the import specifier.
+     * 
+     * Dependencies can be keyed as:
+     * - owner/package (recommended, matches "owner/package" or "owner/package/subpath")
+     * - short-alias (matches "short-alias" or "short-alias/subpath")
+     * 
+     * @returns The matching key and normalized dependency, or undefined if not found
+     */
+    private findDependency(
+        manifest: ModelManifest,
+        specifier: string
+    ): { key: string; dependency: ExtendedDependencySpec } | undefined {
+        const dependencies = manifest.dependencies;
+        if (!dependencies) {
+            return undefined;
+        }
+
+        // Sort keys by length descending to match most specific first
+        const sortedKeys = Object.keys(dependencies).sort((a, b) => b.length - a.length);
+
+        for (const key of sortedKeys) {
+            // Exact match or prefix match (key followed by /)
+            if (specifier === key || specifier.startsWith(`${key}/`)) {
+                const dependency = this.getDependency(manifest, key);
+                if (dependency) {
+                    return { key, dependency };
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Gets the normalized dependency configuration for a key.
      */
-    private getDependency(manifest: ModelManifest, alias: string): ExtendedDependencySpec | undefined {
-        const dep = manifest.dependencies?.[alias];
+    private getDependency(manifest: ModelManifest, key: string): ExtendedDependencySpec | undefined {
+        const dep = manifest.dependencies?.[key];
         if (!dep) {
             return undefined;
         }
 
         if (typeof dep === 'string') {
-            return { source: alias, ref: dep };
+            return { source: key, ref: dep };
         }
 
         if (!dep.source && !dep.path) {
-            return { ...dep, source: alias };
+            return { ...dep, source: key };
         }
 
         return dep;
@@ -296,8 +399,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,7 @@
 import type { ValidationAcceptor } from 'langium';
-import type { ContextMap, DomainMap } from '../generated/ast.js';
-import { ValidationMessages, buildCodeDescription } from './constants.js';
+import type { ContextMap, DomainMap, Relationship, BoundedContextRef } from '../generated/ast.js';
+import { isThisRef } from '../generated/ast.js';
+import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
 /**
  * Validates that a context map contains at least one bounded context.
@@ -22,6 +23,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 +97,94 @@ 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
+            });
+        }
+    }
+}
+
+/**
+ * Gets a canonical name for a BoundedContextRef for comparison purposes.
+ */
+function getRefKey(ref: BoundedContextRef): string {
+    if (isThisRef(ref)) {
+        return 'this';
+    }
+    return ref.link?.$refText ?? '';
+}
+
+/**
+ * Builds a canonical key for a relationship for duplicate detection.
+ * The key captures both endpoints, arrow direction, and integration patterns.
+ */
+function buildRelationshipKey(rel: Relationship): string {
+    const left = getRefKey(rel.left);
+    const right = getRefKey(rel.right);
+    const leftPatterns = (rel.leftPatterns ?? []).slice().sort((a, b) => a.localeCompare(b)).join(',');
+    const rightPatterns = (rel.rightPatterns ?? []).slice().sort((a, b) => a.localeCompare(b)).join(',');
+    return `[${leftPatterns}]${left}${rel.arrow}[${rightPatterns}]${right}`;
+}
+
+/**
+ * Validates that a context map does not contain duplicate relationships.
+ * Two relationships are considered duplicate if they have the same endpoints,
+ * direction, and integration patterns.
+ * 
+ * @param map - The context map to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateNoDuplicateRelationships(
+    map: ContextMap,
+    accept: ValidationAcceptor
+): void {
+    if (!map.relationships || map.relationships.length < 2) return;
+
+    const seen = new Map<string, number>();
+    for (let i = 0; i < map.relationships.length; i++) {
+        const rel = map.relationships[i];
+        const key = buildRelationshipKey(rel);
+        
+        if (seen.has(key)) {
+            accept('warning', ValidationMessages.CONTEXT_MAP_DUPLICATE_RELATIONSHIP(
+                getRefKey(rel.left), getRefKey(rel.right)
+            ), {
+                node: rel,
+                property: 'arrow',
+                codeDescription: buildCodeDescription('language.md', 'context-maps')
+            });
+        } else {
+            seen.set(key, i);
+        }
+    }
+}
+
 export const contextMapChecks = [
     validateContextMapHasContexts,
-    validateContextMapHasRelationships
+    validateContextMapReferences,
+    validateContextMapHasRelationships,
+    validateNoDuplicateRelationships
 ];
 
 export const domainMapChecks = [
-    validateDomainMapHasDomains
+    validateDomainMapHasDomains,
+    validateDomainMapReferences
 ];