@likec4/language-server 0.6.2 → 0.8.0

package/dist/model/fqn-index.js

@@ -0,0 +1,119 @@
+import { DocumentState, DONE_RESULT, getDocument, MultiMap, StreamImpl } from 'langium';
+import { ElementOps, isLikeC4LangiumDocument } from '../ast';
+import { logger } from '../logger';
+import { nameFromFqn, parentFqn } from '@likec4/core/utils';
+import '../elementRef';
+import { isNil } from 'rambdax';
+import '../generated/ast';
+const isFqnIndexedDocument = (doc) => isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.ComputedScopes && !isNil(doc.c4fqns);
+export class FqnIndex {
+    services;
+    // #fqnMap = new WeakMap<ast.Element, Fqn>()
+    // protected readonly descriptions: AstNodeDescriptionProvider
+    constructor(services) {
+        this.services = services;
+        // this.descriptions = services.workspace.AstNodeDescriptionProvider
+        // services.shared.workspace.DocumentBuilder.onUpdate((_changed, removed) => {
+        //   for (const uri of [..._changed, ...removed]) {
+        //     this.cleanIndexedElements(uri)
+        //   }
+        // })
+        // services.shared.workspace.DocumentBuilder.onBuildPhase(
+        //   DocumentState.Parsed,
+        //   (docs, _cancelToken) => {
+        //     for (const doc of docs) {
+        //       this.cleanIndexedElements(doc.uri)
+        //       this.doIndexElements(doc as LikeC4LangiumDocument)
+        //     }
+        //   }
+        // )
+    }
+    documents() {
+        return this.services.shared.workspace.LangiumDocuments.all.filter(isFqnIndexedDocument);
+    }
+    entries() {
+        return this.documents().flatMap(doc => doc.c4fqns.entries().map(([fqn, path]) => ({ fqn, path, doc })));
+    }
+    // private index() {
+    //   const index = new MultiMap<Fqn, {
+    //     path: string,
+    //     doc: LikeC4LangiumDocument
+    //   }>()
+    //   this.entries().toMap()
+    //   this.entries().forEach(({ fqn, path, doc }) => {
+    //     index.add(fqn, { path, doc })
+    //   })
+    //   // for (const doc of this.documents()) {
+    //   //   doc.c4fqns.entries().forEach(([fqn, path]) => {
+    //   //     index.add(fqn, { path, doc })
+    //   //   })
+    //   // }
+    //   return index
+    // }
+    get(el) {
+        let fqn = ElementOps.readId(el) ?? null;
+        const doc = getDocument(el);
+        if (fqn) {
+            if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
+                return fqn;
+            }
+            const path = this.services.workspace.AstNodeLocator.getAstNodePath(el);
+            logger.error(`Clean cached FQN ${fqn} at ${path}`);
+            ElementOps.writeId(el, null);
+            fqn = null;
+        }
+        return fqn;
+    }
+    byFqn(fqn) {
+        return this.documents()
+            .flatMap(doc => {
+            return doc.c4fqns.get(fqn).map(path => ({ path, doc }));
+        });
+    }
+    directChildrenOf(parent) {
+        return this
+            .entries()
+            .filter(e => parentFqn(e.fqn) === parent)
+            .map((e) => ({ ...e, name: nameFromFqn(e.fqn) }));
+    }
+    uniqueDescedants(parent) {
+        return new StreamImpl(() => {
+            const prefix = `${parent}.`;
+            const children = [];
+            const childrenNames = new Set();
+            const descedants = [];
+            this.entries().forEach(e => {
+                if (e.fqn.startsWith(prefix)) {
+                    const name = nameFromFqn(e.fqn);
+                    const entry = { ...e, name };
+                    if (parentFqn(e.fqn) === parent) {
+                        childrenNames.add(name);
+                        children.push(entry);
+                    }
+                    else {
+                        descedants.push(entry);
+                    }
+                }
+            });
+            if (children.length + descedants.length === 0) {
+                return null;
+            }
+            const nested = new MultiMap(children.map(entry => [entry.name, entry]));
+            for (const descedant of descedants) {
+                if (!childrenNames.has(descedant.name)) {
+                    nested.add(descedant.name, descedant);
+                }
+            }
+            return nested
+                .entriesGroupedByKey()
+                .flatMap(([_name, descrs]) => (descrs.length === 1 ? descrs : []))
+                .iterator();
+        }, iterator => {
+            if (iterator) {
+                return iterator.next();
+            }
+            return DONE_RESULT;
+        });
+    }
+}
+//# sourceMappingURL=fqn-index.js.map

package/dist/model/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fqn-index';
+export * from './model-builder';
+export * from './model-locator';
+//# sourceMappingURL=index.d.ts.map

package/dist/model/index.js

@@ -0,0 +1,4 @@
+export * from './fqn-index';
+export * from './model-builder';
+export * from './model-locator';
+//# sourceMappingURL=index.js.map

package/dist/model/model-builder.d.ts

@@ -0,0 +1,27 @@
+import type * as c4 from '@likec4/core/types';
+import { ast, type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4ModelBuilder {
+    private services;
+    private fqnIndex;
+    private langiumDocuments;
+    constructor(services: LikeC4Services);
+    private get connection();
+    private documents;
+    buildModel(): c4.LikeC4Model | undefined;
+    /**
+     * @returns if the document was changed
+     */
+    protected parseDocument(doc: LikeC4LangiumDocument): boolean;
+    private parseElement;
+    private parseRelation;
+    private parseElementExpression;
+    private parseExpression;
+    private parseViewRule;
+    private parseElementView;
+    protected resolveFqn(node: ast.Element | ast.ExtendElement): c4.Fqn;
+    private getAstNodePath;
+    private convertTags;
+    private notifyClient;
+}
+//# sourceMappingURL=model-builder.d.ts.map

package/dist/model/model-builder.js

@@ -0,0 +1,339 @@
+import { computeViews } from '@likec4/core/compute-view';
+import { DefaultElementShape, DefaultThemeColor } from '@likec4/core/types';
+import { compareByFqnHierarchically, parentFqn } from '@likec4/core/utils';
+import { A, O, flow, pipe } from '@mobily/ts-belt';
+import { DocumentState, getDocument, interruptAndCheck } from 'langium';
+import objectHash from 'object-hash';
+import { clone, isNil, mergeDeepRight, omit, reduce } from 'rambdax';
+import invariant from 'tiny-invariant';
+import { toAutoLayout } from '../ast';
+import { ElementViewOps, ast, c4hash, cleanParsedModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, resolveRelationPoints, streamModel, toElementStyle } from '../ast';
+import { elementRef, strictElementRefFqn } from '../elementRef';
+import { logger } from '../logger';
+import { Rpc } from '../protocol';
+import { failExpectedNever } from '../utils';
+export class LikeC4ModelBuilder {
+    services;
+    fqnIndex;
+    langiumDocuments;
+    constructor(services) {
+        this.services = services;
+        this.fqnIndex = services.likec4.FqnIndex;
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, async (docs, cancelToken) => {
+            let countOfChangedDocs = 0;
+            try {
+                for (const doc of docs) {
+                    await interruptAndCheck(cancelToken);
+                    try {
+                        if (isLikeC4LangiumDocument(doc) && this.parseDocument(doc)) {
+                            countOfChangedDocs++;
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`Error parsing document ${doc.uri.toString()}`);
+                    }
+                }
+            }
+            finally {
+                if (countOfChangedDocs > 0 && !cancelToken.isCancellationRequested) {
+                    await this.notifyClient();
+                }
+            }
+        });
+    }
+    get connection() {
+        return this.services.shared.lsp.Connection;
+    }
+    documents() {
+        return this.langiumDocuments.all.toArray().filter(isParsedLikeC4LangiumDocument);
+    }
+    buildModel() {
+        const docs = this.documents();
+        if (docs.length === 0) {
+            return;
+        }
+        try {
+            const c4Specification = reduce((acc, doc) => mergeDeepRight(acc, doc.c4Specification), {
+                kinds: {}
+            }, docs);
+            // const c4Specification = docs.reduce<ParsedAstSpecification>((acc, doc) => {
+            //   return mergeDeepRight(acc, doc.c4Specification)
+            // }, {
+            //   kinds: {}
+            // })
+            const toModelElement = (el) => {
+                const kind = c4Specification.kinds[el.kind];
+                if (kind) {
+                    return {
+                        ...(kind.shape !== DefaultElementShape ? { shape: kind.shape } : {}),
+                        ...(kind.color !== DefaultThemeColor ? { color: kind.color } : {}),
+                        ...omit(['astPath'], el)
+                    };
+                }
+                return null;
+            };
+            const toModelRelation = (rel) => {
+                return omit(['astPath'], rel);
+            };
+            const elements = pipe(docs.flatMap(d => d.c4Elements), A.filterMap(flow(toModelElement, O.fromNullable)), A.sort(compareByFqnHierarchically), A.reduce({}, (acc, el) => {
+                const parent = parentFqn(el.id);
+                if (!parent || parent in acc) {
+                    if (el.id in acc) {
+                        logger.warn(`Duplicate element id: ${el.id}`);
+                    }
+                    acc[el.id] = el;
+                }
+                return acc;
+            }));
+            const relations = pipe(docs.flatMap(d => d.c4Relations), A.filterMap(flow(toModelRelation, O.fromPredicate(({ source, target }) => source in elements && target in elements))), A.reduce({}, (acc, el) => {
+                if (el.id in acc) {
+                    logger.warn(`Duplicate relation id: ${el.id}`);
+                }
+                acc[el.id] = el;
+                return acc;
+            }));
+            const toModelView = (view) => {
+                let title = view.title;
+                if (!title && view.viewOf) {
+                    title = elements[view.viewOf]?.title;
+                }
+                return {
+                    ...omit(['astPath', 'rules', 'title'], view),
+                    ...(!!title ? { title } : {}),
+                    rules: clone(view.rules)
+                };
+            };
+            const views = pipe(docs.flatMap(d => d.c4Views), A.filterMap(flow(toModelView, O.fromPredicate(v => isNil(v.viewOf) || v.viewOf in elements))), A.reduce({}, (acc, v) => {
+                if (v.id in acc) {
+                    logger.warn(`Duplicate view id: ${v.id}`);
+                }
+                acc[v.id] = v;
+                return acc;
+            }));
+            return computeViews({
+                elements,
+                relations,
+                views
+            });
+        }
+        catch (e) {
+            logger.error(e);
+            return;
+        }
+    }
+    /**
+     * @returns if the document was changed
+     */
+    parseDocument(doc) {
+        const { elements, relations, views, specification } = cleanParsedModel(doc);
+        const spec = doc.parseResult.value.specification;
+        if (spec) {
+            for (const { kind, style } of spec.elementKinds) {
+                try {
+                    const styleProps = toElementStyle(style?.props);
+                    specification.kinds[kind.name] = {
+                        color: styleProps.color ?? DefaultThemeColor,
+                        shape: styleProps.shape ?? DefaultElementShape
+                    };
+                }
+                catch (e) {
+                    logger.warn(e);
+                }
+            }
+        }
+        for (const el of streamModel(doc)) {
+            if (ast.isElement(el)) {
+                try {
+                    elements.push(this.parseElement(el));
+                }
+                catch (e) {
+                    logger.warn(e);
+                }
+                continue;
+            }
+            if (ast.isRelation(el)) {
+                try {
+                    relations.push(this.parseRelation(el));
+                }
+                catch (e) {
+                    logger.warn(e);
+                }
+                continue;
+            }
+            failExpectedNever(el);
+        }
+        const docviews = doc.parseResult.value.views?.views;
+        if (docviews) {
+            for (const view of docviews) {
+                try {
+                    const v = this.parseElementView(view);
+                    ElementViewOps.writeId(view, v.id);
+                    views.push(v);
+                }
+                catch (e) {
+                    logger.warn(e);
+                }
+            }
+        }
+        const prevHash = doc.c4hash ?? '';
+        doc.c4hash = c4hash(doc);
+        return prevHash !== doc.c4hash;
+    }
+    parseElement(astNode) {
+        const id = this.resolveFqn(astNode);
+        invariant(astNode.kind.ref, 'Element kind is not resolved: ' + astNode.name);
+        const kind = astNode.kind.ref.name;
+        const tags = (astNode.body && this.convertTags(astNode.body)) ?? [];
+        const styleProps = astNode.body?.props.find(ast.isElementStyleProperty)?.props;
+        const { color, shape } = toElementStyle(styleProps);
+        const astPath = this.getAstNodePath(astNode);
+        let [title, description, technology] = astNode.props;
+        const bodyProps = astNode.body?.props.filter((p) => ast.isElementStringProperty(p)) ?? [];
+        title = title ?? bodyProps.find(p => p.key === 'title')?.value;
+        description = description ?? bodyProps.find(p => p.key === 'description')?.value;
+        technology = technology ?? bodyProps.find(p => p.key === 'technology')?.value;
+        return {
+            id,
+            kind,
+            astPath,
+            title: title ?? astNode.name,
+            ...(technology && { technology }),
+            ...(description && { description }),
+            ...(tags.length > 0 ? { tags } : {}),
+            ...(shape && shape !== DefaultElementShape ? { shape } : {}),
+            ...(color && color !== DefaultThemeColor ? { color } : {})
+        };
+    }
+    parseRelation(astNode) {
+        const coupling = resolveRelationPoints(astNode);
+        const target = this.resolveFqn(coupling.target);
+        const source = this.resolveFqn(coupling.source);
+        const hashdata = {
+            astPath: this.getAstNodePath(astNode),
+            source,
+            target
+        };
+        const id = objectHash(hashdata);
+        const title = astNode.title ?? astNode.definition?.props.find(p => p.key === 'title')?.value ?? '';
+        return {
+            id,
+            ...hashdata,
+            title
+        };
+    }
+    parseElementExpression(astNode) {
+        if (ast.isWildcardExpression(astNode)) {
+            return {
+                wildcard: true
+            };
+        }
+        if (ast.isElementRefExpression(astNode)) {
+            const element = elementRef(astNode.id);
+            invariant(element, 'Element not found ' + astNode.id.$cstNode?.text);
+            return {
+                element: this.resolveFqn(element),
+                isDescedants: astNode.isDescedants
+            };
+        }
+        failExpectedNever(astNode);
+    }
+    parseExpression(astNode) {
+        if (ast.isElementExpression(astNode)) {
+            return this.parseElementExpression(astNode);
+        }
+        if (ast.isIncomingExpression(astNode)) {
+            return {
+                incoming: this.parseElementExpression(astNode.target)
+            };
+        }
+        if (ast.isOutgoingExpression(astNode)) {
+            return {
+                outgoing: this.parseElementExpression(astNode.source)
+            };
+        }
+        if (ast.isInOutExpression(astNode)) {
+            return {
+                inout: this.parseElementExpression(astNode.inout.target)
+            };
+        }
+        if (ast.isRelationExpression(astNode)) {
+            return {
+                source: this.parseElementExpression(astNode.source),
+                target: this.parseElementExpression(astNode.target)
+            };
+        }
+        failExpectedNever(astNode);
+    }
+    parseViewRule(astRule) {
+        if (ast.isViewRuleExpression(astRule)) {
+            const exprs = astRule.expressions.map(n => this.parseExpression(n));
+            return {
+                isInclude: astRule.isInclude,
+                exprs
+            };
+        }
+        if (ast.isViewRuleStyle(astRule)) {
+            const styleProps = toElementStyle(astRule.props);
+            return {
+                targets: astRule.targets.map(n => this.parseElementExpression(n)),
+                style: {
+                    ...styleProps
+                }
+            };
+        }
+        if (ast.isViewRuleAutoLayout(astRule)) {
+            return {
+                autoLayout: toAutoLayout(astRule.direction)
+            };
+        }
+        failExpectedNever(astRule);
+    }
+    parseElementView(astNode) {
+        const viewOfEl = astNode.viewOf && elementRef(astNode.viewOf);
+        const viewOf = viewOfEl && this.resolveFqn(viewOfEl);
+        const astPath = this.getAstNodePath(astNode);
+        let id = astNode.name;
+        if (!id) {
+            const doc = getDocument(astNode).uri.toString();
+            id = objectHash({
+                doc,
+                astPath,
+                viewOf: viewOf ?? null
+            });
+        }
+        const title = astNode.properties.find(p => p.key === 'title')?.value;
+        const description = astNode.properties.find(p => p.key === 'description')?.value;
+        return {
+            id,
+            astPath,
+            ...(viewOf && { viewOf }),
+            ...(title && { title }),
+            ...(description && { description }),
+            rules: astNode.rules.map(n => this.parseViewRule(n))
+        };
+    }
+    resolveFqn(node) {
+        if (ast.isExtendElement(node)) {
+            return strictElementRefFqn(node.element);
+        }
+        const fqn = this.fqnIndex.get(node);
+        invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
+        return fqn;
+    }
+    getAstNodePath(node) {
+        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
+    }
+    convertTags(el) {
+        return el.tags?.value.map(tagRef => tagRef.ref?.name) ?? [];
+    }
+    async notifyClient() {
+        const connection = this.connection;
+        if (!connection) {
+            return;
+        }
+        logger.debug('Send onDidChangeModel');
+        await connection.sendNotification(Rpc.onDidChangeModel);
+    }
+}
+//# sourceMappingURL=model-builder.js.map

package/dist/model/model-locator.d.ts

@@ -0,0 +1,17 @@
+import type * as c4 from '@likec4/core/types';
+import type { Location } from 'vscode-languageserver';
+import type { ParsedAstElement } from '../ast';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare class LikeC4ModelLocator {
+    private services;
+    private fqnIndex;
+    private langiumDocuments;
+    constructor(services: LikeC4Services);
+    private documents;
+    getParsedElement(astNode: ast.Element): ParsedAstElement | null;
+    locateElement(fqn: c4.Fqn, property?: string): Location | null;
+    locateRelation(relationId: c4.RelationID): Location | null;
+    locateView(viewId: c4.ViewID): Location | null;
+}
+//# sourceMappingURL=model-locator.d.ts.map

package/dist/model/model-locator.js

@@ -0,0 +1,116 @@
+import { findNodeForKeyword, findNodeForProperty, getDocument } from 'langium';
+import { ast, isParsedLikeC4LangiumDocument } from '../ast';
+export class LikeC4ModelLocator {
+    services;
+    fqnIndex;
+    langiumDocuments;
+    constructor(services) {
+        this.services = services;
+        this.fqnIndex = services.likec4.FqnIndex;
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+    }
+    documents() {
+        return this.langiumDocuments.all.toArray().filter(isParsedLikeC4LangiumDocument);
+    }
+    getParsedElement(astNode) {
+        const doc = getDocument(astNode);
+        if (!isParsedLikeC4LangiumDocument(doc)) {
+            return null;
+        }
+        const fqn = this.fqnIndex.get(astNode);
+        if (!fqn)
+            return null;
+        return doc.c4Elements.find(e => e.id === fqn) ?? null;
+    }
+    locateElement(fqn, property = 'name') {
+        for (const doc of this.documents()) {
+            if (doc.c4fqns && !doc.c4fqns.has(fqn)) {
+                continue;
+            }
+            const element = doc.c4Elements.find(e => e.id === fqn);
+            if (!element) {
+                continue;
+            }
+            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, element.astPath);
+            if (!ast.isElement(node)) {
+                continue;
+            }
+            const propertyNode = findNodeForProperty(node.$cstNode, property) ?? node.$cstNode;
+            if (!propertyNode) {
+                return null;
+            }
+            return {
+                uri: doc.uri.toString(),
+                range: propertyNode.range
+            };
+        }
+        return null;
+    }
+    locateRelation(relationId) {
+        for (const doc of this.documents()) {
+            const relation = doc.c4Relations.find(r => r.id === relationId);
+            if (!relation) {
+                continue;
+            }
+            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, relation.astPath);
+            if (!ast.isRelation(node)) {
+                continue;
+            }
+            if (node.title) {
+                const targetNode = findNodeForProperty(node.$cstNode, 'title');
+                if (targetNode) {
+                    return {
+                        uri: doc.uri.toString(),
+                        range: {
+                            start: targetNode.range.start,
+                            end: targetNode.range.start
+                        }
+                    };
+                }
+            }
+            const targetNode = findNodeForKeyword(node.$cstNode, '->');
+            if (!targetNode) {
+                return null;
+            }
+            return {
+                uri: doc.uri.toString(),
+                range: {
+                    start: targetNode.range.end,
+                    end: targetNode.range.end
+                }
+            };
+        }
+        return null;
+    }
+    locateView(viewId) {
+        for (const doc of this.documents()) {
+            const view = doc.c4Views.find(r => r.id === viewId);
+            if (!view) {
+                continue;
+            }
+            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, view.astPath);
+            if (!ast.isElementView(node)) {
+                continue;
+            }
+            let targetNode = node.$cstNode;
+            if (node.name) {
+                targetNode = findNodeForProperty(node.$cstNode, 'name') ?? targetNode;
+            }
+            else if (node.viewOf) {
+                targetNode = findNodeForProperty(node.$cstNode, 'viewOf') ?? targetNode;
+            }
+            if (!targetNode) {
+                return null;
+            }
+            return {
+                uri: doc.uri.toString(),
+                range: {
+                    start: targetNode.range.start,
+                    end: targetNode.range.start
+                }
+            };
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=model-locator.js.map

package/dist/module.d.ts

@@ -0,0 +1,21 @@
+import type { DefaultSharedModuleContext, LangiumServices, LangiumSharedServices, Module, PartialLangiumServices } from 'langium';
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator } from './model';
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export interface LikeC4AddedServices {
+    likec4: {
+        FqnIndex: FqnIndex;
+        ModelBuilder: LikeC4ModelBuilder;
+        ModelLocator: LikeC4ModelLocator;
+    };
+}
+export type LikeC4Services = LangiumServices & LikeC4AddedServices;
+export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+type LanguageServicesContext = Partial<DefaultSharedModuleContext>;
+export declare function createLanguageServices(context?: LanguageServicesContext): {
+    shared: LangiumSharedServices;
+    likec4: LikeC4Services;
+};
+export {};
+//# sourceMappingURL=module.d.ts.map