@domainlang/language 0.11.0 → 0.12.0

package/src/lsp/domain-lang-code-lens-provider.ts

@@ -0,0 +1,54 @@
+import { AstUtils, type LangiumDocument } from 'langium';
+import type { CodeLens, CodeLensParams } from 'vscode-languageserver';
+import { isContextMap, type ContextMap, type Model } from '../generated/ast.js';
+
+const OPEN_DIAGRAM_COMMAND = 'domainlang.diagram.open';
+
+/**
+ * Provides contextual code lenses for context map diagram actions.
+ */
+export class DomainLangCodeLensProvider {
+    async provideCodeLens(document: LangiumDocument, _params: CodeLensParams): Promise<CodeLens[]> {
+        try {
+            const model = (document as LangiumDocument<Model>).parseResult?.value;
+            if (!model) {
+                return [];
+            }
+
+            const contextMaps: ContextMap[] = [];
+
+            if (isContextMap(model)) {
+                contextMaps.push(model);
+            }
+
+            for (const node of AstUtils.streamAllContents(model)) {
+                if (isContextMap(node)) {
+                    contextMaps.push(node);
+                }
+            }
+
+            return contextMaps.flatMap((contextMap) => {
+                const range = contextMap.$cstNode?.range;
+                if (!range) {
+                    return [];
+                }
+
+                return [{
+                    range: {
+                        start: { line: range.start.line, character: 0 },
+                        end: { line: range.start.line, character: 0 },
+                    },
+                    command: {
+                        title: 'Open diagram',
+                        command: OPEN_DIAGRAM_COMMAND,
+                        arguments: [{
+                            uri: document.uri.toString(),
+                        }],
+                    },
+                }];
+            });
+        } catch {
+            return [];
+        }
+    }
+}

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

@@ -147,8 +147,8 @@ export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvi
         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 left = isThisRef(rel.left) ? 'this' : rel.left?.link?.$refText ?? '?';
+        const right = isThisRef(rel.right) ? 'this' : rel.right?.link?.$refText ?? '?';
         const name = `${left} → ${right}`;
 
         const range = CstUtils.toDocumentSegment(cstNode).range;
@@ -168,7 +168,7 @@ export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvi
         const cstNode = meta.$cstNode;
         if (!cstNode) return undefined;
 
-        const name = meta.key?.ref?.name ?? 'unknown';
+        const name = meta.key?.$refText ?? 'unknown';
         const range = CstUtils.toDocumentSegment(cstNode).range;
 
         return DocumentSymbol.create(
@@ -197,8 +197,8 @@ export class DomainLangDocumentSymbolProvider extends DefaultDocumentSymbolProvi
     /** 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.domain?.$refText) {
+            parts.push(`BC for ${node.domain.$refText}`);
         }
         if (node.description) {
             parts.push(node.description);

package/src/lsp/tool-handlers.ts

@@ -337,54 +337,68 @@ function executeListQuery(
     entityType: QueryEntityType,
     filters: QueryFilters
 ): Record<string, unknown>[] {
-    switch (entityType) {
-        case 'domains': {
-            let builder = query.domains();
-            if (filters.name) builder = builder.withName(filters.name);
-            if (filters.fqn) builder = builder.withFqn(filters.fqn);
-            return builder.toArray().map((d) => serializeNode(d, query));
-        }
-        case 'bcs': {
-            let builder = query.boundedContexts();
-            if (filters.domain) builder = builder.inDomain(filters.domain);
-            if (filters.team) builder = builder.withTeam(filters.team);
-            if (filters.classification)
-                builder = builder.withClassification(filters.classification);
-            if (filters.metadata) {
-                const [key, value] = filters.metadata.split('=');
-                builder = builder.withMetadata(key, value);
-            }
-            if (filters.name) builder = builder.withName(filters.name) as ReturnType<Query['boundedContexts']>;
-            if (filters.fqn) builder = builder.withFqn(filters.fqn) as ReturnType<Query['boundedContexts']>;
-            return builder.toArray().map((bc) => serializeNode(bc, query));
-        }
-        case 'teams': {
-            let builder = query.teams();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((t) => serializeNode(t, query));
-        }
-        case 'classifications': {
-            let builder = query.classifications();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((c) => serializeNode(c, query));
-        }
-        case 'relationships': {
-            const rels = query.relationships().toArray();
-            return rels.map((r) => serializeRelationship(r));
-        }
-        case 'context-maps': {
-            let builder = query.contextMaps();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((cm) => serializeNode(cm, query));
-        }
-        case 'domain-maps': {
-            let builder = query.domainMaps();
-            if (filters.name) builder = builder.withName(filters.name);
-            return builder.toArray().map((dm) => serializeNode(dm, query));
-        }
-        default:
-            return [];
+    const handlers: Record<QueryEntityType, (activeQuery: Query, activeFilters: QueryFilters) => Record<string, unknown>[]> = {
+        domains: listDomains,
+        bcs: listBoundedContexts,
+        teams: listTeams,
+        classifications: listClassifications,
+        relationships: listRelationships,
+        'context-maps': listContextMaps,
+        'domain-maps': listDomainMaps,
+    };
+
+    return handlers[entityType](query, filters);
+}
+
+function listDomains(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.domains();
+    if (filters.name) builder = builder.withName(filters.name);
+    if (filters.fqn) builder = builder.withFqn(filters.fqn);
+    return builder.toArray().map((domain) => serializeNode(domain, query));
+}
+
+function listBoundedContexts(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.boundedContexts();
+    if (filters.domain) builder = builder.inDomain(filters.domain);
+    if (filters.team) builder = builder.withTeam(filters.team);
+    if (filters.classification) {
+        builder = builder.withClassification(filters.classification);
     }
+    if (filters.metadata) {
+        const [key, value] = filters.metadata.split('=');
+        builder = builder.withMetadata(key, value);
+    }
+    if (filters.name) builder = builder.withName(filters.name) as ReturnType<Query['boundedContexts']>;
+    if (filters.fqn) builder = builder.withFqn(filters.fqn) as ReturnType<Query['boundedContexts']>;
+    return builder.toArray().map((boundedContext) => serializeNode(boundedContext, query));
+}
+
+function listTeams(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.teams();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((team) => serializeNode(team, query));
+}
+
+function listClassifications(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.classifications();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((classification) => serializeNode(classification, query));
+}
+
+function listRelationships(query: Query, _filters: QueryFilters): Record<string, unknown>[] {
+    return query.relationships().toArray().map((relationship) => serializeRelationship(relationship));
+}
+
+function listContextMaps(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.contextMaps();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((contextMap) => serializeNode(contextMap, query));
+}
+
+function listDomainMaps(query: Query, filters: QueryFilters): Record<string, unknown>[] {
+    let builder = query.domainMaps();
+    if (filters.name) builder = builder.withName(filters.name);
+    return builder.toArray().map((domainMap) => serializeNode(domainMap, query));
 }
 
 /**