@domainlang/language 0.1.82 → 0.4.1

package/src/validation/constants.ts

@@ -13,11 +13,63 @@
 
 import type { CodeDescription } from 'vscode-languageserver-types';
 
+// ============================================================================
+// Issue Codes for Code Actions
+// ============================================================================
+
+/**
+ * Diagnostic codes used to identify validation issues.
+ * Code actions match on these codes to provide quick fixes.
+ * 
+ * Naming convention: CATEGORY_SPECIFIC_ISSUE
+ */
+export const IssueCodes = {
+    // Import & Dependency Issues
+    ImportMissingUri: 'import-missing-uri',
+    ImportRequiresManifest: 'import-requires-manifest',
+    ImportNotInManifest: 'import-not-in-manifest',
+    ImportNotInstalled: 'import-not-installed',
+    ImportConflictingSourcePath: 'import-conflicting-source-path',
+    ImportMissingSourceOrPath: 'import-missing-source-or-path',
+    ImportMissingRef: 'import-missing-ref',
+    ImportAbsolutePath: 'import-absolute-path',
+    ImportEscapesWorkspace: 'import-escapes-workspace',
+    
+    // Domain Issues
+    DomainNoVision: 'domain-no-vision',
+    DomainCircularHierarchy: 'domain-circular-hierarchy',
+    
+    // Bounded Context Issues
+    BoundedContextNoDescription: 'bounded-context-no-description',
+    BoundedContextNoDomain: 'bounded-context-no-domain',
+    BoundedContextClassificationConflict: 'bounded-context-classification-conflict',
+    BoundedContextTeamConflict: 'bounded-context-team-conflict',
+    
+    // Integration Pattern Issues
+    SharedKernelNotBidirectional: 'shared-kernel-not-bidirectional',
+    AclOnWrongSide: 'acl-on-wrong-side',
+    ConformistOnWrongSide: 'conformist-on-wrong-side',
+    TooManyPatterns: 'too-many-patterns',
+    
+    // Context/Domain Map Issues
+    ContextMapNoContexts: 'context-map-no-contexts',
+    ContextMapNoRelationships: 'context-map-no-relationships',
+    DomainMapNoDomains: 'domain-map-no-domains',
+    
+    // Metadata Issues
+    MetadataMissingName: 'metadata-missing-name',
+    
+    // General Issues
+    DuplicateElement: 'duplicate-element'
+} as const;
+
+export type IssueCode = typeof IssueCodes[keyof typeof IssueCodes];
+
 // ============================================================================
 // Documentation Link Utilities
 // ============================================================================
 
-const REPO_BASE = 'https://github.com/larsbaunwall/DomainLang/blob/main';
+const REPO_BASE = 'https://github.com/DomainLang/DomainLang/blob/main';
 const DOCS_BASE = `${REPO_BASE}/dsl/domain-lang/docs`;
 
 /**
@@ -49,6 +101,13 @@ export const ValidationMessages = {
     DOMAIN_NO_VISION: (name: string) => 
         `Domain '${name}' is missing a vision statement.`,
     
+    /**
+     * Error message when a circular domain hierarchy is detected.
+     * @param cycle - Array of domain names forming the cycle
+     */
+    DOMAIN_CIRCULAR_HIERARCHY: (cycle: string[]) =>
+        `Circular domain hierarchy detected: ${cycle.join(' → ')}.`,
+    
     /**
      * Warning message when a bounded context lacks a description.
      * @param name - The name of the bounded context
@@ -120,5 +179,126 @@ export const ValidationMessages = {
      * Suggests possible syntax confusion.
      */
     TOO_MANY_PATTERNS: (count: number, side: 'left' | 'right') =>
-        `Too many integration patterns (${count}) on ${side} side. Typically use 1-2 patterns per side.`
+        `Too many integration patterns (${count}) on ${side} side. Typically use 1-2 patterns per side.`,
+
+    // ========================================================================
+    // Import & Dependency Validation (PRS-010 Phase 8)
+    // ========================================================================
+
+    /**
+     * Error when import statement has no URI.
+     */
+    IMPORT_MISSING_URI: () =>
+        `Import statement must have a URI. Use: import "package" or import "./local-path"`,
+
+    /**
+     * Error when external dependency requires model.yaml but none exists.
+     * @param specifier - The import specifier (e.g., "core", "domainlang/patterns")
+     */
+    IMPORT_REQUIRES_MANIFEST: (specifier: string) =>
+        `External dependency '${specifier}' requires model.yaml.\n` +
+        `Hint: Create model.yaml and add the dependency:\n` +
+        `  dependencies:\n` +
+        `    ${specifier}:\n` +
+        `      ref: v1.0.0`,
+
+    /**
+     * Error when import specifier not found in manifest dependencies.
+     * @param alias - The dependency alias/specifier
+     */
+    IMPORT_NOT_IN_MANIFEST: (alias: string) =>
+        `Import '${alias}' not found in model.yaml dependencies.\n` +
+        `Hint: Run 'dlang add ${alias} <source>@<ref>' to add it, or manually add to model.yaml:\n` +
+        `  dependencies:\n` +
+        `    ${alias}:\n` +
+        `      ref: v1.0.0`,
+
+    /**
+     * Error when dependency not installed (no lock file entry).
+     * @param alias - The dependency alias
+     */
+    IMPORT_NOT_INSTALLED: (alias: string) =>
+        `Dependency '${alias}' not installed.\n` +
+        `Hint: Run 'dlang install' to fetch dependencies and generate model.lock.`,
+
+    /**
+     * Error when dependency has conflicting source and path definitions.
+     * @param alias - The dependency alias
+     */
+    IMPORT_CONFLICTING_SOURCE_PATH: (alias: string) =>
+        `Dependency '${alias}' cannot define both 'source' and 'path' in model.yaml.\n` +
+        `Hint: Use 'source' for git-based packages or 'path' for local workspace packages.`,
+
+    /**
+     * Error when dependency is missing both source and path.
+     * @param alias - The dependency alias
+     */
+    IMPORT_MISSING_SOURCE_OR_PATH: (alias: string) =>
+        `Dependency '${alias}' must define either 'source' or 'path' in model.yaml.\n` +
+        `Hint: Add 'source: owner/repo' for git packages, or 'path: ./local/path' for local packages.`,
+
+    /**
+     * Error when git dependency is missing ref (tag, branch, or commit).
+     * @param alias - The dependency alias
+     */
+    IMPORT_MISSING_REF: (alias: string) =>
+        `Dependency '${alias}' must specify a git ref in model.yaml.\n` +
+        `Hint: Add a git ref: 'ref: v1.0.0' (tag), 'ref: main' (branch), or a commit SHA.`,
+
+    /**
+     * Error when local path uses absolute path.
+     * @param alias - The dependency alias
+     * @param absolutePath - The absolute path that was specified
+     */
+    IMPORT_ABSOLUTE_PATH: (alias: string, absolutePath: string) =>
+        `Local path dependency '${alias}' cannot use absolute path '${absolutePath}'.\n` +
+        `Hint: Use a relative path from the workspace root, e.g., 'path: ./packages/shared'.`,
+
+    /**
+     * Error when local path escapes workspace boundary.
+     * @param alias - The dependency alias
+     */
+    IMPORT_ESCAPES_WORKSPACE: (alias: string) =>
+        `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.`,
+
+    // ========================================================================
+    // Context Map & Domain Map Validation
+    // ========================================================================
+
+    /**
+     * Warning when context map contains no bounded contexts.
+     * @param name - The context map name
+     */
+    CONTEXT_MAP_NO_CONTEXTS: (name: string) =>
+        `Context Map '${name}' contains no bounded contexts.\n` +
+        `Hint: Use 'contains ContextA, ContextB' to specify which contexts are in the map.`,
+
+    /**
+     * Info when context map has multiple contexts but no relationships.
+     * @param name - The context map name
+     * @param count - Number of contexts
+     */
+    CONTEXT_MAP_NO_RELATIONSHIPS: (name: string, count: number) =>
+        `Context Map '${name}' contains ${count} contexts but no documented relationships.\n` +
+        `Hint: Add relationships to show how contexts integrate (e.g., '[OHS] A -> [CF] B').`,
+
+    /**
+     * Warning when domain map contains no domains.
+     * @param name - The domain map name
+     */
+    DOMAIN_MAP_NO_DOMAINS: (name: string) =>
+        `Domain Map '${name}' contains no domains.\n` +
+        `Hint: Use 'contains DomainA, DomainB' to specify which domains are in the map.`,
+
+    // ========================================================================
+    // Metadata Validation
+    // ========================================================================
+
+    /**
+     * Error when metadata is missing a name.
+     */
+    METADATA_MISSING_NAME: () =>
+        `Metadata must have a name.\n` +
+        `Hint: Define metadata with: Metadata MyMetadata { ... }`
 } as const;

package/src/validation/domain.ts

@@ -21,4 +21,57 @@ function validateDomainHasVision(
     }
 }
 
-export const domainChecks = [validateDomainHasVision]; 
+/**
+ * Validates that a domain hierarchy does not contain circular references.
+ * 
+ * The `Domain A in B` syntax expresses subdomain containment.
+ * Circular containment (A in B, B in C, C in A) is semantically invalid
+ * because it violates the fundamental concept of domain decomposition.
+ * 
+ * @param domain - The domain to validate
+ * @param accept - The validation acceptor for reporting issues
+ */
+function validateNoCyclicDomainHierarchy(
+    domain: Domain,
+    accept: ValidationAcceptor
+): void {
+    // Only check if this domain has a parent
+    if (!domain.parent?.ref) {
+        return;
+    }
+    
+    const visited = new Set<Domain>();
+    const path: string[] = [domain.name];
+    let current: Domain | undefined = domain.parent.ref;
+    
+    while (current) {
+        // Check if we've encountered this domain before (cycle detected)
+        if (visited.has(current)) {
+            // We found a cycle - report it
+            path.push(current.name);
+            accept('error', ValidationMessages.DOMAIN_CIRCULAR_HIERARCHY(path), {
+                node: domain,
+                property: 'parent',
+                codeDescription: buildCodeDescription('language.md', 'domain-hierarchy')
+            });
+            return;
+        }
+        
+        // Check if we've looped back to the starting domain
+        if (current === domain) {
+            path.push(domain.name);
+            accept('error', ValidationMessages.DOMAIN_CIRCULAR_HIERARCHY(path), {
+                node: domain,
+                property: 'parent',
+                codeDescription: buildCodeDescription('language.md', 'domain-hierarchy')
+            });
+            return;
+        }
+        
+        visited.add(current);
+        path.push(current.name);
+        current = current.parent?.ref;
+    }
+}
+
+export const domainChecks = [validateDomainHasVision, validateNoCyclicDomainHierarchy]; 

package/src/validation/import.ts

@@ -1,171 +1,295 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import type { ValidationAcceptor, ValidationChecks } from 'langium';
-import type { DomainLangAstType, ImportStatement, Model } from '../generated/ast.js';
-import { resolveImportPath } from '../utils/import-utils.js';
+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 { ExtendedDependencySpec, ModelManifest, LockFile } from '../services/types.js';
+import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
 /**
  * Validates import statements in DomainLang.
- * 
+ *
+ * Uses async validators (Langium 4.x supports MaybePromise<void>) to leverage
+ * the shared WorkspaceManager service with its cached manifest/lock file reading.
+ *
  * Checks:
- * - Import paths are resolvable
- * - Named imports exist in target document
- * - Import aliases don't conflict with local names
+ * - External imports require manifest + alias
+ * - Local path dependencies stay inside workspace  
+ * - Lock file exists for external dependencies
  */
 export class ImportValidator {
-    private readonly documents: DomainLangServices['shared']['workspace']['LangiumDocuments'];
+    private readonly workspaceManager: WorkspaceManager;
 
     constructor(services: DomainLangServices) {
-        this.documents = services.shared.workspace.LangiumDocuments;
+        this.workspaceManager = services.imports.WorkspaceManager;
     }
 
     /**
-     * Validates that an import path is resolvable.
+     * Validates an import statement asynchronously.
+     *
+     * Langium validators can return MaybePromise<void>, enabling async operations
+     * like reading manifests via the shared, cached WorkspaceManager.
      */
     async checkImportPath(
         imp: ImportStatement,
         accept: ValidationAcceptor,
-        document: LangiumDocument
+        document: LangiumDocument,
+        _cancelToken: Cancellation.CancellationToken
     ): Promise<void> {
         if (!imp.uri) {
-            accept('error', 'Import statement must have a URI', { 
+            accept('error', ValidationMessages.IMPORT_MISSING_URI(), {
                 node: imp,
-                keyword: 'import'
+                keyword: 'import',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportMissingUri }
             });
             return;
         }
 
-        try {
-            await resolveImportPath(document, imp.uri);
-        } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            accept('error', `Cannot resolve import: ${message}`, {
+        if (!this.isExternalImport(imp.uri)) {
+            return;
+        }
+
+        // Initialize workspace manager from document location
+        const docDir = path.dirname(document.uri.fsPath);
+        await this.workspaceManager.initialize(docDir);
+
+        const manifest = await this.workspaceManager.getManifest();
+        if (!manifest) {
+            accept('error', ValidationMessages.IMPORT_REQUIRES_MANIFEST(imp.uri), {
                 node: imp,
-                property: 'uri'
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportRequiresManifest, specifier: imp.uri }
             });
+            return;
         }
-    }
 
-    /**
-     * Validates that named imports exist in the target document.
-     */
-    async checkNamedImports(
-        imp: ImportStatement,
-        accept: ValidationAcceptor,
-        document: LangiumDocument
-    ): Promise<void> {
-        // Only check if we have named imports
-        if (!imp.symbols || imp.symbols.length === 0) {
+        const alias = imp.uri.split('/')[0];
+        const dependency = this.getDependency(manifest, alias);
+
+        if (!dependency) {
+            accept('error', ValidationMessages.IMPORT_NOT_IN_MANIFEST(alias), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportNotInManifest, alias }
+            });
             return;
         }
 
-        if (!imp.uri) {
-            return; // Already reported by checkImportPath
-        }
+        this.validateDependencyConfig(dependency, alias, accept, imp);
 
-        try {
-            // Resolve the target document
-            const targetUri = await resolveImportPath(document, imp.uri);
-            const targetDoc = await this.documents.getOrCreateDocument(targetUri);
-            
-            if (!targetDoc.parseResult?.value) {
-                accept('error', `Cannot load imported document: ${imp.uri}`, {
+        // 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), {
                     node: imp,
-                    property: 'uri'
+                    property: 'uri',
+                    codeDescription: buildCodeDescription('language.md', 'imports'),
+                    data: { code: IssueCodes.ImportNotInstalled, alias }
                 });
                 return;
             }
 
-            // Get all exported symbols from target document
-            const targetModel = targetDoc.parseResult.value as Model;
-            const exportedSymbols = this.getExportedSymbols(targetModel);
-
-            // Check each imported symbol
-            for (const symbol of imp.symbols) {
-                if (!exportedSymbols.has(symbol)) {
-                    accept('error', 
-                        `Symbol '${symbol}' not found in ${imp.uri}`,
-                        {
-                            node: imp,
-                            property: 'symbols'
-                        }
-                    );
-                }
-            }
-        } catch {
-            // Import path error already reported by checkImportPath
-            return;
+            await this.validateCachedPackage(dependency, alias, lockFile, accept, imp);
         }
     }
 
     /**
-     * Gets all exportable symbols from a model.
-     * 
-     * In DomainLang, top-level declarations are implicitly exported:
-     * - Domains
-     * - BoundedContexts
-     * - Classifications
-     * - Groups
+     * Determines if an import URI is external (requires manifest).
+     *
+     * Per PRS-010:
+     * - Local relative: ./path, ../path
+     * - Path aliases: @/path, @alias/path (resolved via manifest paths section)
+     * - External: owner/package (requires manifest dependencies)
      */
-    private getExportedSymbols(model: Model): Set<string> {
-        const symbols = new Set<string>();
-
-        // Iterate through all structure elements
-        for (const element of model.children ?? []) {
-            // Check if element has a name and add it
-            if ('name' in element && typeof element.name === 'string') {
-                symbols.add(element.name);
-            }
+    private isExternalImport(uri: string): boolean {
+        if (uri.startsWith('./') || uri.startsWith('../')) {
+            return false;
+        }
+        if (uri.startsWith('@')) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Gets the normalized dependency configuration for an alias.
+     */
+    private getDependency(manifest: ModelManifest, alias: string): ExtendedDependencySpec | undefined {
+        const dep = manifest.dependencies?.[alias];
+        if (!dep) {
+            return undefined;
+        }
+
+        if (typeof dep === 'string') {
+            return { source: alias, ref: dep };
+        }
+
+        if (!dep.source && !dep.path) {
+            return { ...dep, source: alias };
         }
 
-        return symbols;
+        return dep;
     }
 
     /**
-     * Checks for unused imports.
-     * 
-     * This is a warning, not an error, to avoid being too strict.
+     * Validates dependency configuration.
      */
-    checkUnusedImports(
-        imp: ImportStatement,
-        _accept: ValidationAcceptor,
-        _model: Model
+    private validateDependencyConfig(
+        dependency: ExtendedDependencySpec,
+        alias: string,
+        accept: ValidationAcceptor,
+        imp: ImportStatement
+    ): void {
+        if (dependency.source && dependency.path) {
+            accept('error', ValidationMessages.IMPORT_CONFLICTING_SOURCE_PATH(alias), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportConflictingSourcePath, alias }
+            });
+            return;
+        }
+
+        if (!dependency.source && !dependency.path) {
+            accept('error', ValidationMessages.IMPORT_MISSING_SOURCE_OR_PATH(alias), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportMissingSourceOrPath, alias }
+            });
+            return;
+        }
+
+        if (dependency.source && !dependency.ref) {
+            accept('error', ValidationMessages.IMPORT_MISSING_REF(alias), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportMissingRef, alias }
+            });
+        }
+
+        if (dependency.path) {
+            this.validateLocalPathDependency(dependency.path, alias, accept, imp);
+        }
+    }
+
+    /**
+     * Validates local path dependencies stay within workspace.
+     */
+    private validateLocalPathDependency(
+        dependencyPath: string,
+        alias: string,
+        accept: ValidationAcceptor,
+        imp: ImportStatement
     ): void {
-        // Skip check for wildcard imports (no named imports)
-        if (!imp.symbols || imp.symbols.length === 0) {
+        if (path.isAbsolute(dependencyPath)) {
+            accept('error', ValidationMessages.IMPORT_ABSOLUTE_PATH(alias, dependencyPath), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportAbsolutePath, alias, path: dependencyPath }
+            });
+            return;
+        }
+
+        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 }
+            });
+        }
+    }
+
+    /**
+     * Validates that external dependency is in lock file and cached.
+     */
+    private async validateCachedPackage(
+        dependency: ExtendedDependencySpec,
+        alias: string,
+        lockFile: LockFile,
+        accept: ValidationAcceptor,
+        imp: ImportStatement
+    ): Promise<void> {
+        // Source is guaranteed to exist when this method is called (see caller)
+        const packageKey = dependency.source ?? alias;
+        const lockedDep = lockFile.dependencies[packageKey];
+
+        if (!lockedDep) {
+            accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
+                node: imp,
+                property: 'uri',
+                codeDescription: buildCodeDescription('language.md', 'imports'),
+                data: { code: IssueCodes.ImportNotInstalled, alias }
+            });
             return;
         }
 
-        // For now, just a placeholder - would require tracking symbol usage
-        // across the entire document, which is complex
-        // TODO: Implement symbol usage tracking
+        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 }
+            });
+        }
+    }
+
+    /**
+     * Gets the cache directory for a dependency.
+     * Per PRS-010: Project-local cache at .dlang/packages/{owner}/{repo}/{commit}/
+     */
+    private getCacheDirectory(workspaceRoot: string, source: string, commitHash: string): string {
+        const [owner, repo] = source.split('/');
+        return path.join(workspaceRoot, '.dlang', 'packages', owner, repo, commitHash);
+    }
+
+    /**
+     * Checks if a directory exists (async).
+     */
+    private async directoryExists(dirPath: string): Promise<boolean> {
+        try {
+            const stat = await fs.stat(dirPath);
+            return stat.isDirectory();
+        } catch {
+            return false;
+        }
     }
 }
 
 /**
  * Creates validation checks for import statements.
+ *
+ * Returns async validators that leverage the shared WorkspaceManager
+ * for cached manifest/lock file reading.
  */
-export function createImportChecks(_services: DomainLangServices): ValidationChecks<DomainLangAstType> {
+export function createImportChecks(services: DomainLangServices): ValidationChecks<DomainLangAstType> {
+    const validator = new ImportValidator(services);
 
     return {
-        ImportStatement: (imp, accept) => {
+        // Langium 4.x supports async validators via MaybePromise<void>
+        ImportStatement: async (imp, accept, cancelToken) => {
             const document = imp.$document;
             if (!document) return;
 
-            // Note: Langium's validation is synchronous, so async checks won't
-            // execute during document validation. These checks will run during
-            // the build phase when documents are fully loaded.
-            
-            // For now, just do basic syntax validation
-            if (!imp.uri) {
-                accept('error', 'Import statement must have a URI', { 
-                    node: imp,
-                    keyword: 'import'
-                });
-            }
-
-            // TODO: Implement async validation in a separate build phase
-            // This would require using DocumentBuilder.onBuildPhase() or similar
+            await validator.checkImportPath(imp, accept, document, cancelToken);
         }
     };
 }