@domainlang/language 0.6.0 → 0.8.0

package/src/lsp/domain-lang-document-symbol-provider.ts

@@ -0,0 +1,254 @@
+/**
+ * Custom DocumentSymbolProvider for DomainLang.
+ *
+ * Extends Langium's DefaultDocumentSymbolProvider to add meaningful
+ * `detail` text to outline items, improving the Outline view, breadcrumbs,
+ * and Go to Symbol experience.
+ *
+ * The default provider handles the full AST walk, child nesting, and
+ * range computation. We only override `getSymbol` to enrich the detail
+ * property with DDD-relevant information (descriptions, visions, counts).
+ *
+ * @module lsp/domain-lang-document-symbol-provider
+ */
+
+import type { AstNode, LangiumDocument } from 'langium';
+import { DocumentSymbol, SymbolKind } from 'vscode-languageserver';
+import { CstUtils } from 'langium';
+import { DefaultDocumentSymbolProvider } from 'langium/lsp';
+import {
+    isDomain,
+    isBoundedContext,
+    isContextMap,
+    isDomainMap,
+    isNamespaceDeclaration,
+    isRelationship,
+    isThisRef,
+} from '../generated/ast.js';
+import type { BoundedContext, Relationship, MetadataEntry } from '../generated/ast.js';
+
+/**
+ * Enriches document symbols with DDD-specific detail text and grouping.
+ *
+ * Detail text shown in the Outline view next to each symbol:
+ * - Domain: vision or description
+ * - BoundedContext: description or domain name
+ * - ContextMap: number of contained contexts
+ * - DomainMap: number of contained domains
+ * - Namespace: qualified namespace name
+ * - Relationship: formatted endpoint summary (e.g., "OrderContext -> PaymentContext")
+ * 
+ * Grouping: Creates synthetic folder nodes for collections in the grammar:
+ * - BoundedContext: decisions, terminology, relationships, metadata
+ * 
+ * Note: Relationship and MetadataEntry symbols are created manually (not via NameProvider)
+ * to avoid polluting the global scope/reference system. These are display-only synthetic symbols.
+ */
+export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvider {
+
+    protected override getSymbol(document: LangiumDocument, astNode: AstNode): DocumentSymbol[] {
+        try {
+            const symbols = super.getSymbol(document, astNode);
+            const detail = this.getDetailText(astNode);
+            if (detail !== undefined) {
+                for (const symbol of symbols) {
+                    symbol.detail = detail;
+                }
+            }
+            return symbols;
+        } catch (error) {
+            console.error('Error in DomainLangDocumentSymbolProvider.getSymbol:', error);
+            return super.getSymbol(document, astNode);
+        }
+    }
+
+    /**
+     * Override to add synthetic grouping folders for collections.
+     * Groups decisions, terminology, relationships, and metadata under folder nodes.
+     */
+    protected override getChildSymbols(document: LangiumDocument, astNode: AstNode): DocumentSymbol[] | undefined {
+        // Only group for BoundedContext nodes
+        if (!isBoundedContext(astNode)) {
+            return super.getChildSymbols(document, astNode);
+        }
+
+        const grouped: DocumentSymbol[] = [];
+
+        // Process each collection type
+        this.addDecisionsFolder(document, astNode, grouped);
+        this.addTerminologyFolder(document, astNode, grouped);
+        this.addRelationshipsFolder(astNode, grouped);
+        this.addMetadataFolder(astNode, grouped);
+
+        return grouped.length > 0 ? grouped : undefined;
+    }
+
+    /** Adds decisions folder if collection is non-empty. */
+    private addDecisionsFolder(document: LangiumDocument, bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.decisions && bc.decisions.length > 0) {
+            const symbols = bc.decisions.flatMap(d => this.getSymbol(document, d));
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('decisions', symbols));
+            }
+        }
+    }
+
+    /** Adds terminology folder if collection is non-empty. */
+    private addTerminologyFolder(document: LangiumDocument, bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.terminology && bc.terminology.length > 0) {
+            const symbols = bc.terminology.flatMap(t => this.getSymbol(document, t));
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('terminology', symbols));
+            }
+        }
+    }
+
+    /** Adds relationships folder with manually created symbols. */
+    private addRelationshipsFolder(bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.relationships && bc.relationships.length > 0) {
+            const symbols = bc.relationships.map(r => this.createRelationshipSymbol(r)).filter((s): s is DocumentSymbol => s !== undefined);
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('relationships', symbols));
+            }
+        }
+    }
+
+    /** Adds metadata folder with manually created symbols. */
+    private addMetadataFolder(bc: BoundedContext, grouped: DocumentSymbol[]): void {
+        if (bc.metadata && bc.metadata.length > 0) {
+            const symbols = bc.metadata.map(m => this.createMetadataSymbol(m)).filter((s): s is DocumentSymbol => s !== undefined);
+            if (symbols.length > 0) {
+                grouped.push(this.createFolderSymbol('metadata', symbols));
+            }
+        }
+    }
+
+    /**
+     * Creates a synthetic folder DocumentSymbol for grouping children.
+     */
+    private createFolderSymbol(name: string, children: DocumentSymbol[]): DocumentSymbol {
+        // Use the first child's range for the folder
+        const firstChild = children[0];
+        
+        return DocumentSymbol.create(
+            name,
+            `${children.length} items`,
+            SymbolKind.Object,
+            firstChild.range,
+            firstChild.selectionRange,
+            children
+        );
+    }
+
+    /**
+     * Creates a DocumentSymbol for a Relationship node.
+     */
+    private createRelationshipSymbol(rel: Relationship): DocumentSymbol | undefined {
+        const cstNode = rel.$cstNode;
+        if (!cstNode) return undefined;
+
+        const left = isThisRef(rel.left) ? 'this' : rel.left?.link?.ref?.name ?? '?';
+        const right = isThisRef(rel.right) ? 'this' : rel.right?.link?.ref?.name ?? '?';
+        const name = `${left} → ${right}`;
+
+        const range = CstUtils.toDocumentSegment(cstNode).range;
+        return DocumentSymbol.create(
+            name,
+            undefined,
+            SymbolKind.Interface,
+            range,
+            range
+        );
+    }
+
+    /**
+     * Creates a DocumentSymbol for a MetadataEntry node.
+     */
+    private createMetadataSymbol(meta: MetadataEntry): DocumentSymbol | undefined {
+        const cstNode = meta.$cstNode;
+        if (!cstNode) return undefined;
+
+        const name = meta.key?.ref?.name ?? 'unknown';
+        const range = CstUtils.toDocumentSegment(cstNode).range;
+
+        return DocumentSymbol.create(
+            name,
+            meta.value,
+            SymbolKind.Field,
+            range,
+            range
+        );
+    }
+
+    /**
+     * Returns DDD-specific detail text for a given AST node.
+     * Shown alongside the symbol name in the Outline view.
+     */
+    private getDetailText(node: AstNode): string | undefined {
+        if (isDomain(node))              return "Domain — " + (node.vision ?? node.description);
+        if (isBoundedContext(node))      return this.getBcDetail(node);
+        if (isContextMap(node))          return this.pluralize('context', node.boundedContexts?.length ?? 0);
+        if (isDomainMap(node))           return this.pluralize('domain', node.domains?.length ?? 0);
+        if (isNamespaceDeclaration(node)) return node.name;
+        if (isRelationship(node))        return this.formatRelationshipDetail(node);
+        return undefined;
+    }
+
+    /** Builds BC detail: "BC for DomainName — description". */
+    private getBcDetail(node: BoundedContext): string | undefined {
+        const parts: string[] = [];
+        if (node.domain?.ref?.name) {
+            parts.push(`BC for ${node.domain.ref.name}`);
+        }
+        if (node.description) {
+            parts.push(node.description);
+        }
+        return parts.length > 0 ? parts.join(' — ') : undefined;
+    }
+
+    /** Returns "N item(s)" or undefined when count is 0. */
+    private pluralize(label: string, count: number): string | undefined {
+        if (count === 0) return undefined;
+        const suffix = count === 1 ? '' : 's';
+        return `${count} ${label}${suffix}`;
+    }
+
+    /**
+     * Formats a relationship as a compact detail string:
+     * e.g., "OrderContext -> PaymentContext"
+     */
+    private formatRelationshipDetail(
+        node: ReturnType<typeof Object> & { left?: unknown; right?: unknown; arrow?: string }
+    ): string | undefined {
+        try {
+            // We know this is a Relationship node thanks to isRelationship guard above
+            const rel = node as { left?: { link?: { $refText?: string } }; right?: { link?: { $refText?: string } }; arrow?: string };
+            const leftName = this.getRefName(rel.left);
+            const rightName = this.getRefName(rel.right);
+            const arrow = rel.arrow ?? '->';
+            if (leftName && rightName) {
+                return `${leftName} ${arrow} ${rightName}`;
+            }
+            return undefined;
+        } catch {
+            return undefined;
+        }
+    }
+
+    /**
+     * Gets a display name from a BoundedContextRef.
+     */
+    private getRefName(ref: unknown): string | undefined {
+        if (!ref || typeof ref !== 'object') return undefined;
+
+        // Check for ThisRef
+        const refObj = ref as Record<string, unknown>;
+        if (refObj.$type === 'ThisRef' || isThisRef(ref as AstNode)) {
+            return 'this';
+        }
+
+        // Check for named reference
+        const link = refObj.link as { $refText?: string } | undefined;
+        return link?.$refText;
+    }
+}

package/src/lsp/domain-lang-index-manager.ts

@@ -3,6 +3,9 @@ import { DefaultIndexManager, DocumentState } from 'langium';
 import { CancellationToken } from 'vscode-jsonrpc';
 import { resolveImportPath } from '../utils/import-utils.js';
 import type { Model } from '../generated/ast.js';
+import type { ImportResolver } from '../services/import-resolver.js';
+import type { DomainLangServices } from '../domain-lang-module.js';
+import type { ImportInfo } from '../services/types.js';
 
 /**
  * Custom IndexManager that extends Langium's default to:
@@ -17,6 +20,7 @@ import type { Model } from '../generated/ast.js';
  * **How it works:**
  * - When a document is indexed, we ensure all its imports are also loaded
  * - Maintains a reverse dependency graph: importedUri → Set<importingUri>
+ * - Also tracks import specifiers to detect when file moves affect resolution
  * - Overrides `isAffected()` to also check this graph
  * - This integrates with Langium's native `DocumentBuilder.update()` flow
  * 
@@ -35,6 +39,14 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      */
     private readonly importDependencies = new Map<string, Set<string>>();
     
+    /**
+     * Maps document URI to its import information (specifier, alias, resolved URI).
+     * Used for scope resolution with aliases and detecting when file moves affect imports.
+     * Key: importing document URI
+     * Value: Array of ImportInfo objects
+     */
+    private readonly documentImportInfo = new Map<string, ImportInfo[]>();
+    
     /**
      * Tracks documents that have had their imports loaded to avoid redundant work.
      * Cleared on workspace config changes.
@@ -46,11 +58,41 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      */
     private readonly sharedServices: LangiumSharedCoreServices;
 
+    /**
+     * DI-injected import resolver. Set via late-binding because
+     * IndexManager (shared module) is created before ImportResolver (language module).
+     * Falls back to standalone resolveImportPath when not set.
+     */
+    private importResolver: ImportResolver | undefined;
+
     constructor(services: LangiumSharedCoreServices) {
         super(services);
         this.sharedServices = services;
     }
 
+    /**
+     * Late-binds the language-specific services after DI initialization.
+     * Called from `createDomainLangServices()` after the language module is created.
+     *
+     * This is necessary because the IndexManager lives in the shared module,
+     * which is created before the language module that provides ImportResolver.
+     */
+    setLanguageServices(services: DomainLangServices): void {
+        this.importResolver = services.imports.ImportResolver;
+    }
+
+    /**
+     * Resolves an import path using the DI-injected ImportResolver when available,
+     * falling back to the standalone resolver for backwards compatibility.
+     */
+    private async resolveImport(document: LangiumDocument, specifier: string): Promise<URI> {
+        if (this.importResolver) {
+            return this.importResolver.resolveForDocument(document, specifier);
+        }
+        // Fallback for contexts where language services aren't wired (e.g., tests)
+        return resolveImportPath(document, specifier);
+    }
+
     /**
      * Extends the default content update to:
      * 1. Ensure all imported documents are loaded
@@ -115,7 +157,9 @@ export class DomainLangIndexManager extends DefaultIndexManager {
 
     /**
      * Tracks import dependencies for a document.
-     * For each import in the document, records that the imported URI is depended upon.
+     * For each import in the document, records:
+     * 1. That the imported URI is depended upon (for direct change detection)
+     * 2. The import specifier and alias (for scope resolution)
      */
     private async trackImportDependencies(document: LangiumDocument): Promise<void> {
         const importingUri = document.uri.toString();
@@ -123,6 +167,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
         // First, remove old dependencies from this document
         // (in case imports changed)
         this.removeDocumentFromDependencies(importingUri);
+        this.documentImportInfo.delete(importingUri);
 
         // Skip if document isn't ready (no parse result)
         if (document.state < DocumentState.Parsed) {
@@ -134,13 +179,22 @@ export class DomainLangIndexManager extends DefaultIndexManager {
             return;
         }
 
+        const importInfoList: ImportInfo[] = [];
+        
         for (const imp of model.imports) {
             if (!imp.uri) continue;
 
             try {
-                const resolvedUri = await resolveImportPath(document, imp.uri);
+                const resolvedUri = await this.resolveImport(document, imp.uri);
                 const importedUri = resolvedUri.toString();
 
+                // Track the full import info (specifier, alias, resolved URI)
+                importInfoList.push({
+                    specifier: imp.uri,
+                    alias: imp.alias,
+                    resolvedUri: importedUri
+                });
+
                 // Add to reverse dependency graph: importedUri → importingUri
                 let dependents = this.importDependencies.get(importedUri);
                 if (!dependents) {
@@ -149,9 +203,18 @@ export class DomainLangIndexManager extends DefaultIndexManager {
                 }
                 dependents.add(importingUri);
             } catch {
-                // Import resolution failed - validation will report the error
+                // Import resolution failed - still track the specifier with empty resolution
+                importInfoList.push({
+                    specifier: imp.uri,
+                    alias: imp.alias,
+                    resolvedUri: ''
+                });
             }
         }
+        
+        if (importInfoList.length > 0) {
+            this.documentImportInfo.set(importingUri, importInfoList);
+        }
     }
 
     /**
@@ -188,7 +251,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
             if (!imp.uri) continue;
 
             try {
-                const resolvedUri = await resolveImportPath(document, imp.uri);
+                const resolvedUri = await this.resolveImport(document, imp.uri);
                 const importedUriString = resolvedUri.toString();
                 
                 // Skip if already loaded
@@ -199,8 +262,10 @@ export class DomainLangIndexManager extends DefaultIndexManager {
                 // Load or create the imported document
                 const importedDoc = await langiumDocuments.getOrCreateDocument(resolvedUri);
                 
-                // If document is new (not yet indexed), add to batch
-                if (importedDoc.state < DocumentState.IndexedContent) {
+                // If document is not yet validated, add to batch for building
+                // This ensures all imported documents reach Validated state,
+                // preventing "workspace state is already Validated" errors
+                if (importedDoc.state < DocumentState.Validated) {
                     newDocs.push(importedDoc);
                 }
             } catch {
@@ -208,7 +273,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
             }
         }
 
-        // Build any newly discovered documents
+        // Build any newly discovered documents to Validated state
         // This triggers indexing which will recursively load their imports
         if (newDocs.length > 0) {
             await documentBuilder.build(newDocs, { validation: true });
@@ -243,6 +308,7 @@ export class DomainLangIndexManager extends DefaultIndexManager {
      */
     clearImportDependencies(): void {
         this.importDependencies.clear();
+        this.documentImportInfo.clear();
         this.importsLoaded.clear();
     }
 
@@ -253,4 +319,181 @@ export class DomainLangIndexManager extends DefaultIndexManager {
     markForReprocessing(uri: string): void {
         this.importsLoaded.delete(uri);
     }
+
+    /**
+     * Gets all documents that import the given URI.
+     * Used to find documents that need rebuilding when a file changes.
+     * 
+     * @param uri - The URI of the changed/deleted file
+     * @returns Set of URIs (as strings) of documents that import this file
+     */
+    getDependentDocuments(uri: string): Set<string> {
+        return this.importDependencies.get(uri) ?? new Set();
+    }
+
+    /**
+     * Gets the resolved import URIs for a document.
+     * Returns only URIs where import resolution succeeded (non-empty resolved URI).
+     * 
+     * @param documentUri - The URI of the document
+     * @returns Set of resolved import URIs, or empty set if none
+     */
+    getResolvedImports(documentUri: string): Set<string> {
+        const importInfoList = this.documentImportInfo.get(documentUri);
+        if (!importInfoList) {
+            return new Set();
+        }
+        
+        const resolved = new Set<string>();
+        for (const info of importInfoList) {
+            // Only include successfully resolved imports (non-empty string)
+            if (info.resolvedUri) {
+                resolved.add(info.resolvedUri);
+            }
+        }
+        return resolved;
+    }
+
+    /**
+     * Gets the full import information (including aliases) for a document.
+     * Used by the scope provider to implement alias-prefixed name resolution.
+     * 
+     * @param documentUri - The URI of the document
+     * @returns Array of ImportInfo objects, or empty array if none
+     */
+    getImportInfo(documentUri: string): ImportInfo[] {
+        return this.documentImportInfo.get(documentUri) ?? [];
+    }
+
+    /**
+     * Gets all documents that would be affected by changes to the given URIs.
+     * This includes direct dependents and transitive dependents.
+     * 
+     * @param changedUris - URIs of changed/deleted files
+     * @returns Set of all affected document URIs
+     */
+    getAllAffectedDocuments(changedUris: Iterable<string>): Set<string> {
+        const affected = new Set<string>();
+        const toProcess = [...changedUris];
+        
+        while (toProcess.length > 0) {
+            const uri = toProcess.pop();
+            if (!uri) {
+                continue;
+            }
+            const dependents = this.importDependencies.get(uri);
+            if (dependents) {
+                for (const dep of dependents) {
+                    if (!affected.has(dep)) {
+                        affected.add(dep);
+                        // Also check transitive dependents
+                        toProcess.push(dep);
+                    }
+                }
+            }
+        }
+        
+        return affected;
+    }
+
+    /**
+     * Gets documents that have import specifiers which might be affected by file moves.
+     * 
+     * When a file is moved/renamed, import specifiers that previously resolved to it
+     * (or could now resolve to it) need to be re-evaluated. This method finds documents
+     * whose imports might resolve differently after the file system change.
+     * 
+     * @param changedUris - URIs of changed/deleted/created files
+     * @returns Set of document URIs that should be rebuilt
+     */
+    getDocumentsWithPotentiallyAffectedImports(changedUris: Iterable<string>): Set<string> {
+        const changedPaths = this.extractPathSegments(changedUris);
+        return this.findDocumentsMatchingPaths(changedPaths);
+    }
+
+    /**
+     * Extracts path segments from URIs for fuzzy matching.
+     */
+    private extractPathSegments(uris: Iterable<string>): Set<string> {
+        const paths = new Set<string>();
+        
+        for (const uri of uris) {
+            this.addPathSegmentsFromUri(uri, paths);
+        }
+        
+        return paths;
+    }
+
+    /**
+     * Adds path segments from a single URI to the set.
+     */
+    private addPathSegmentsFromUri(uri: string, paths: Set<string>): void {
+        try {
+            const url = new URL(uri);
+            const pathParts = url.pathname.split('/').filter(p => p.length > 0);
+            
+            // Add filename
+            const fileName = pathParts.at(-1);
+            if (fileName) {
+                paths.add(fileName);
+            }
+            
+            // Add parent/filename combination
+            if (pathParts.length >= 2) {
+                paths.add(pathParts.slice(-2).join('/'));
+            }
+            
+            // Add grandparent/parent/filename combination
+            if (pathParts.length >= 3) {
+                paths.add(pathParts.slice(-3).join('/'));
+            }
+        } catch {
+            // Invalid URI, skip
+        }
+    }
+
+    /**
+     * Finds documents with import specifiers matching any of the given paths.
+     */
+    private findDocumentsMatchingPaths(changedPaths: Set<string>): Set<string> {
+        const affected = new Set<string>();
+
+        for (const [docUri, importInfoList] of this.documentImportInfo) {
+            if (this.hasMatchingSpecifierOrResolvedUri(importInfoList, changedPaths)) {
+                affected.add(docUri);
+            }
+        }
+
+        return affected;
+    }
+
+    /**
+     * Checks if any specifier OR its resolved URI matches the changed paths.
+     * 
+     * This handles both regular imports and path aliases:
+     * - Regular: `./domains/sales.dlang` matches path `sales.dlang`
+     * - Aliased: `@domains/sales.dlang` resolves to `/full/path/domains/sales.dlang`
+     *   When the file moves, the resolved URI matches but the specifier doesn't
+     * 
+     * We check both to ensure moves of aliased imports trigger revalidation.
+     */
+    private hasMatchingSpecifierOrResolvedUri(importInfoList: ImportInfo[], changedPaths: Set<string>): boolean {
+        for (const info of importInfoList) {
+            const normalizedSpecifier = info.specifier.replace(/^[.@/]+/, '');
+            
+            for (const changedPath of changedPaths) {
+                // Check the raw specifier (handles relative imports)
+                if (info.specifier.includes(changedPath) || changedPath.endsWith(normalizedSpecifier)) {
+                    return true;
+                }
+                
+                // Check the resolved URI (handles path aliases like @domains/...)
+                // The resolved URI contains the full file path which matches moved files
+                if (info.resolvedUri?.includes(changedPath)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 }