@domainlang/language 0.5.2 → 0.7.0

package/src/utils/manifest-utils.ts

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import YAML from 'yaml';
+import type { ModelManifest } from '../services/types.js';
+
+const DEFAULT_MANIFEST_FILENAME = 'model.yaml';
+const DEFAULT_ENTRY_FILE = 'index.dlang';
+
+/**
+ * Checks if a file exists at the given path.
+ */
+export async function fileExists(targetPath: string): Promise<boolean> {
+    try {
+        await fs.access(targetPath);
+        return true;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+
+/**
+ * Finds the nearest model.yaml manifest by walking up from startPath.
+ * 
+ * @param startPath - Directory to start searching from
+ * @returns Absolute path to model.yaml, or undefined if not found
+ */
+export async function findNearestManifest(startPath: string): Promise<string | undefined> {
+    let current = path.resolve(startPath);
+    const { root } = path.parse(current);
+
+    while (true) {
+        const candidate = path.join(current, DEFAULT_MANIFEST_FILENAME);
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+
+        if (current === root) {
+            return undefined;
+        }
+
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+
+/**
+ * Finds the workspace root (directory containing model.yaml).
+ * 
+ * @param startPath - Directory to start searching from
+ * @returns Absolute path to workspace root, or undefined if no manifest found
+ */
+export async function findWorkspaceRoot(startPath: string): Promise<string | undefined> {
+    const manifestPath = await findNearestManifest(startPath);
+    return manifestPath ? path.dirname(manifestPath) : undefined;
+}
+
+/**
+ * Reads and parses a model.yaml manifest.
+ * 
+ * @param manifestPath - Absolute path to model.yaml
+ * @returns Parsed manifest, or undefined if file doesn't exist
+ * @throws Error if file exists but cannot be parsed
+ */
+export async function readManifest(manifestPath: string): Promise<ModelManifest | undefined> {
+    try {
+        const content = await fs.readFile(manifestPath, 'utf-8');
+        return (YAML.parse(content) ?? {}) as ModelManifest;
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+
+/**
+ * Reads the entry point from a manifest file.
+ * 
+ * @param manifestPath - Absolute path to model.yaml
+ * @returns Entry file path (relative), defaults to 'index.dlang'
+ */
+export async function readEntryFromManifest(manifestPath: string): Promise<string> {
+    try {
+        const manifest = await readManifest(manifestPath);
+        return manifest?.model?.entry ?? DEFAULT_ENTRY_FILE;
+    } catch {
+        return DEFAULT_ENTRY_FILE;
+    }
+}
+
+/**
+ * Gets the absolute entry file path for a manifest.
+ * 
+ * @param manifestPath - Absolute path to model.yaml
+ * @returns Absolute path to the entry file
+ */
+export async function getEntryPath(manifestPath: string): Promise<string> {
+    const entry = await readEntryFromManifest(manifestPath);
+    return path.resolve(path.dirname(manifestPath), entry);
+}
+
+/**
+ * Discovers all manifest files within given directories.
+ * Only checks direct children, not recursive subdirectories.
+ * 
+ * @param directories - Array of absolute directory paths to search
+ * @returns Array of manifest info objects
+ */
+export async function findManifestsInDirectories(
+    directories: string[]
+): Promise<Array<{ manifestPath: string; entryPath: string }>> {
+    const results: Array<{ manifestPath: string; entryPath: string }> = [];
+
+    for (const dir of directories) {
+        const manifestPath = await findNearestManifest(dir);
+        if (manifestPath) {
+            const entryPath = await getEntryPath(manifestPath);
+            results.push({ manifestPath, entryPath });
+        }
+    }
+
+    return results;
+}
+
+/** Default manifest filename */
+export { DEFAULT_MANIFEST_FILENAME, DEFAULT_ENTRY_FILE };

package/src/validation/constants.ts

@@ -34,6 +34,7 @@ export const IssueCodes = {
     ImportMissingRef: 'import-missing-ref',
     ImportAbsolutePath: 'import-absolute-path',
     ImportEscapesWorkspace: 'import-escapes-workspace',
+    ImportUnresolved: 'import-unresolved',
     
     // Domain Issues
     DomainNoVision: 'domain-no-vision',
@@ -56,6 +57,9 @@ export const IssueCodes = {
     ContextMapNoRelationships: 'context-map-no-relationships',
     DomainMapNoDomains: 'domain-map-no-domains',
     
+    // Reference Issues
+    UnresolvedReference: 'unresolved-reference',
+    
     // Metadata Issues
     MetadataMissingName: 'metadata-missing-name',
     
@@ -262,6 +266,14 @@ export const ValidationMessages = {
         `Local path dependency '${alias}' escapes workspace boundary.\n` +
         `Hint: Local dependencies must be within the workspace. Consider moving the dependency or using a git-based source.`,
 
+    /**
+     * Error when import path cannot be resolved to a file.
+     * @param uri - The import URI that couldn't be resolved
+     */
+    IMPORT_UNRESOLVED: (uri: string) =>
+        `Cannot resolve import '${uri}'.\n` +
+        `Hint: Check that the file exists and the path is correct.`,
+
     // ========================================================================
     // Context Map & Domain Map Validation
     // ========================================================================
@@ -291,6 +303,18 @@ export const ValidationMessages = {
         `Domain Map '${name}' contains no domains.\n` +
         `Hint: Use 'contains DomainA, DomainB' to specify which domains are in the map.`,
 
+    // ========================================================================
+    // Reference Resolution Validation
+    // ========================================================================
+
+    /**
+     * Error when a reference cannot be resolved (for MultiReferences).
+     * @param type - The type being referenced (e.g., 'BoundedContext')
+     * @param name - The unresolved name
+     */
+    UNRESOLVED_REFERENCE: (type: string, name: string) =>
+        `Could not resolve reference to ${type} named '${name}'.`,
+
     // ========================================================================
     // Metadata Validation
     // ========================================================================

package/src/validation/import.ts

@@ -1,11 +1,11 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import type { ValidationAcceptor, ValidationChecks } from 'langium';
+import type { ValidationAcceptor, ValidationChecks, LangiumDocument } from 'langium';
 import { Cancellation } from 'langium';
 import type { DomainLangAstType, ImportStatement } from '../generated/ast.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
-import type { LangiumDocument } from 'langium';
 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';
 
@@ -16,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;
     }
 
     /**
@@ -49,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;
         }
@@ -118,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.
      */
@@ -200,17 +267,23 @@ export class ImportValidator {
             return;
         }
 
-        const workspaceRoot = this.workspaceManager.getWorkspaceRoot();
-        const resolvedPath = path.resolve(workspaceRoot, dependencyPath);
-        const relativeToWorkspace = path.relative(workspaceRoot, resolvedPath);
+        try {
+            const workspaceRoot = this.workspaceManager.getWorkspaceRoot();
+            const resolvedPath = path.resolve(workspaceRoot, dependencyPath);
+            const relativeToWorkspace = path.relative(workspaceRoot, resolvedPath);
 
-        if (relativeToWorkspace.startsWith('..') || path.isAbsolute(relativeToWorkspace)) {
-            accept('error', ValidationMessages.IMPORT_ESCAPES_WORKSPACE(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportEscapesWorkspace, alias }
-            });
+            if (relativeToWorkspace.startsWith('..') || path.isAbsolute(relativeToWorkspace)) {
+                accept('error', ValidationMessages.IMPORT_ESCAPES_WORKSPACE(alias), {
+                    node: imp,
+                    property: 'uri',
+                    codeDescription: buildCodeDescription('language.md', 'imports'),
+                    data: { code: IssueCodes.ImportEscapesWorkspace, alias }
+                });
+            }
+        } catch (error) {
+            // WorkspaceManager not initialized - skip workspace boundary check
+            // This can happen for standalone files without model.yaml
+            console.warn(`Could not validate workspace boundary for path dependency: ${error}`);
         }
     }
 
@@ -238,17 +311,22 @@ export class ImportValidator {
             return;
         }
 
-        const workspaceRoot = this.workspaceManager.getWorkspaceRoot();
-        const cacheDir = this.getCacheDirectory(workspaceRoot, packageKey, lockedDep.commit);
+        try {
+            const workspaceRoot = this.workspaceManager.getWorkspaceRoot();
+            const cacheDir = this.getCacheDirectory(workspaceRoot, packageKey, lockedDep.commit);
 
-        const cacheExists = await this.directoryExists(cacheDir);
-        if (!cacheExists) {
-            accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportNotInstalled, alias }
-            });
+            const cacheExists = await this.directoryExists(cacheDir);
+            if (!cacheExists) {
+                accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
+                    node: imp,
+                    property: 'uri',
+                    codeDescription: buildCodeDescription('language.md', 'imports'),
+                    data: { code: IssueCodes.ImportNotInstalled, alias }
+                });
+            }
+        } catch (error) {
+            // WorkspaceManager not initialized - log warning but continue
+            console.warn(`Could not validate cached package for ${alias}: ${error}`);
         }
     }
 
@@ -286,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
 ];

package/out/lsp/hover/ddd-pattern-explanations.d.ts

@@ -1,50 +0,0 @@
-/**
- * DDD Pattern Explanations for Hover Documentation
- *
- * Provides plain-English explanations for DDD integration patterns,
- * relationship types, and decision categories.
- */
-/**
- * Explanations for DDD integration role patterns (e.g., PL, ACL, SK).
- */
-export declare const rolePatternExplanations: Record<string, string>;
-/**
- * Explanations for relationship types (e.g., Partnership, CustomerSupplier).
- */
-export declare const relationshipTypeExplanations: Record<string, string>;
-/**
- * Explanations for relationship arrows.
- */
-export declare const arrowExplanations: Record<string, string>;
-/**
- * Explanations for decision categories.
- */
-export declare const decisionCategoryExplanations: Record<string, string>;
-/**
- * Explanations for common DDD classifications.
- */
-export declare const classificationExplanations: Record<string, string>;
-/**
- * Get explanation for a role pattern.
- */
-export declare function explainRolePattern(role: string): string | undefined;
-/**
- * Get explanation for a relationship type.
- */
-export declare function explainRelationshipType(type: string): string | undefined;
-/**
- * Get explanation for an arrow symbol.
- */
-export declare function explainArrow(arrow: string): string | undefined;
-/**
- * Get explanation for a decision category.
- */
-export declare function explainDecisionCategory(category: string): string | undefined;
-/**
- * Get explanation for a classification.
- */
-export declare function explainClassification(name: string): string | undefined;
-/**
- * Generate relationship explanation from roles and type.
- */
-export declare function generateRelationshipExplanation(leftRoles: string[] | undefined, arrow: string | undefined, rightRoles: string[] | undefined, type: string | undefined): string;