@likec4/language-server 0.33.1 → 0.35.0

package/dist/model/model-builder.js

@@ -1,71 +1,20 @@
-import { ModelIndex, assignNavigateTo, compareByFqnHierarchically, computeView, invariant, isNonEmptyArray, nonexhaustive, parentFqn } from '@likec4/core';
-import { DocumentState, getDocument } from 'langium';
-import objectHash from 'object-hash';
+import { ModelIndex, assignNavigateTo, compareByFqnHierarchically, computeView, parentFqn } from '@likec4/core';
 import { clone } from 'rambdax';
 import * as R from 'remeda';
-import stripIndent from 'strip-indent';
-import { ElementViewOps, ast, cleanParsedModel, isLikeC4LangiumDocument, isValidLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle, toElementStyleExcludeDefaults } from '../ast';
-import { elementRef, strictElementRefFqn } from '../elementRef';
-import { logger } from '../logger';
+import { isValidLikeC4LangiumDocument } from '../ast';
+import { logError, logWarnError, logger } from '../logger';
 import { Rpc } from '../protocol';
-import { failExpectedNever } from '../utils';
-export class LikeC4ModelBuilder {
-    services;
-    fqnIndex;
-    langiumDocuments;
-    cachedModel = {};
-    constructor(services) {
-        this.services = services;
-        this.fqnIndex = services.likec4.FqnIndex;
-        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, (docs, cancelToken) => {
-            let countOfChangedDocs = 0;
-            for (const doc of docs) {
-                if (!isLikeC4LangiumDocument(doc)) {
-                    continue;
-                }
-                countOfChangedDocs++;
-                try {
-                    this.parseDocument(doc);
-                }
-                catch (e) {
-                    logger.error(`Error parsing document ${doc.uri.toString()}`);
-                    logger.error(e);
-                }
-            }
-            if (countOfChangedDocs > 0) {
-                this.cleanCache();
-                this.notifyClient(cancelToken);
-            }
-        });
-    }
-    cleanCache() {
-        delete this.cachedModel.last;
-    }
-    documents() {
-        return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
-    }
-    buildModel() {
-        if ('last' in this.cachedModel) {
-            logger.debug('returning cached model');
-            return this.cachedModel.last;
-        }
-        return (this.cachedModel.last = this._buildModel());
-    }
-    _buildModel() {
-        logger.debug('_buildModel');
-        const docs = this.documents();
-        if (docs.length === 0) {
-            logger.debug('No documents to build model from');
-            return null;
-        }
-        // TODO:
-        try {
-            const c4Specification = {
-                kinds: {}
-            };
-            R.forEach(R.map(docs, R.prop('c4Specification')), spec => Object.assign(c4Specification.kinds, spec.kinds));
-            const toModelElement = ({ astPath, tags, links, ...parsed }) => {
+import { printDocs } from '../utils';
+function buildModel(docs) {
+    const c4Specification = {
+        kinds: {}
+    };
+    R.forEach(R.map(docs, R.prop('c4Specification')), spec => Object.assign(c4Specification.kinds, spec.kinds));
+    const toModelElement = (doc) => {
+        const base = new URL(doc.uri.toString());
+        const resolveLinks = (links) => links.map((l) => new URL(l, base).toString());
+        return ({ astPath, tags, links, ...parsed }) => {
+            try {
                 const kind = c4Specification.kinds[parsed.kind];
                 if (kind) {
                     return {
@@ -73,310 +22,132 @@ export class LikeC4ModelBuilder {
                         description: null,
                         technology: null,
                         tags: tags ?? null,
-                        links: links ?? null,
+                        links: links ? resolveLinks(links) : null,
                         ...parsed
                     };
                 }
-                return null;
-            };
-            const elements = R.pipe(R.flatMap(docs, d => d.c4Elements), R.map(toModelElement), R.compact, R.sort(compareByFqnHierarchically), R.reduce((acc, el) => {
-                const parent = parentFqn(el.id);
-                if (parent && R.isNil(acc[parent])) {
-                    logger.warn(`No parent found for ${el.id}`);
-                    return acc;
-                }
-                if (el.id in acc) {
-                    // should not happen, as validated
-                    logger.warn(`Duplicate element id: ${el.id}`);
-                    return acc;
-                }
-                acc[el.id] = el;
-                return acc;
-            }, {}));
-            const toModelRelation = ({ astPath, source, target, ...model }) => {
-                if (source in elements && target in elements) {
-                    return {
-                        source,
-                        target,
-                        ...model
-                    };
-                }
-                return null;
-            };
-            const relations = R.pipe(R.flatMap(docs, d => d.c4Relations), R.map(toModelRelation), R.compact, R.mapToObj(r => [r.id, r]));
-            const modelIndex = ModelIndex.from({ elements, relations });
-            const toModelView = (view) => {
-                // eslint-disable-next-line prefer-const
-                let { astPath, rules, title, description, tags, links, ...model } = view;
-                if (!title && view.viewOf) {
-                    title = elements[view.viewOf]?.title;
-                }
-                if (!title && view.id === 'index') {
-                    title = 'Landscape view';
-                }
-                return computeView({
-                    ...model,
-                    title: title ?? null,
-                    description: description ?? null,
-                    tags: tags ?? null,
-                    links: links ?? null,
-                    rules: clone(rules)
-                }, modelIndex);
-            };
-            const views = R.pipe(R.flatMap(docs, d => d.c4Views), R.map(toModelView), R.compact);
-            assignNavigateTo(views);
-            return {
-                elements,
-                relations,
-                views: R.mapToObj(views, v => [v.id, v])
-            };
-        }
-        catch (e) {
-            logger.error(e);
-            return null;
-        }
-    }
-    /**
-     * @returns if the document was changed
-     */
-    parseDocument(doc) {
-        const { elements, relations, views, specification } = cleanParsedModel(doc);
-        const specs = doc.parseResult.value.specification?.specs.filter(ast.isSpecificationElementKind);
-        if (specs) {
-            for (const { kind, style } of specs) {
-                try {
-                    specification.kinds[kind.name] = toElementStyleExcludeDefaults(style?.props);
-                }
-                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;
             }
-            nonexhaustive(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);
-                }
+            catch (e) {
+                logWarnError(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 = this.convertTags(astNode.body);
-        const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
-        const styleProps = toElementStyleExcludeDefaults(stylePropsAst);
-        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;
-        const links = astNode.body?.props.filter(ast.isLinkProperty).map(p => p.value);
-        return {
-            id,
-            kind,
-            astPath,
-            title: title ? stripIndent(title).trim() : astNode.name,
-            ...(tags && { tags }),
-            ...(links && isNonEmptyArray(links) && { links }),
-            ...(technology && { technology }),
-            ...(description && { description: stripIndent(description).trim() }),
-            ...styleProps
-        };
-    }
-    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.body?.props.find(p => p.key === 'title')?.value ?? '';
-        return {
-            id,
-            ...hashdata,
-            title
+            return null;
         };
-    }
-    parseElementExpression(astNode) {
-        if (ast.isWildcardExpression(astNode)) {
-            return {
-                wildcard: true
-            };
-        }
-        if (ast.isElementKindExpression(astNode)) {
-            invariant(astNode.kind.ref, 'ElementKindExpression kind is not resolved: ' + astNode.$cstNode?.text);
+    };
+    const elements = R.pipe(R.flatMap(docs, d => d.c4Elements.map(toModelElement(d))), R.compact, R.sort(compareByFqnHierarchically), R.reduce((acc, el) => {
+        const parent = parentFqn(el.id);
+        if (parent && R.isNil(acc[parent])) {
+            logWarnError(`No parent found for ${el.id}`);
+            return acc;
+        }
+        if (el.id in acc) {
+            // should not happen, as validated
+            logWarnError(`Duplicate element id: ${el.id}`);
+            return acc;
+        }
+        acc[el.id] = el;
+        return acc;
+    }, {}));
+    const toModelRelation = ({ astPath, source, target, ...model }) => {
+        if (source in elements && target in elements) {
             return {
-                elementKind: astNode.kind.ref.name,
-                isEqual: astNode.isEqual
+                source,
+                target,
+                ...model
             };
         }
-        if (ast.isElementTagExpression(astNode)) {
-            invariant(astNode.tag.ref, 'ElementTagExpression tag is not resolved: ' + astNode.$cstNode?.text);
-            return {
-                elementTag: astNode.tag.ref.name,
-                isEqual: astNode.isEqual
-            };
+        return null;
+    };
+    const relations = R.pipe(R.flatMap(docs, d => d.c4Relations), R.map(toModelRelation), R.compact, R.mapToObj(r => [r.id, r]));
+    const modelIndex = ModelIndex.from({ elements, relations });
+    const toModelView = (view) => {
+        try {
+            // eslint-disable-next-line prefer-const
+            let { astPath, rules, title, description, tags, links, ...model } = view;
+            if (!title && view.viewOf) {
+                title = elements[view.viewOf]?.title;
+            }
+            if (!title && view.id === 'index') {
+                title = 'Landscape view';
+            }
+            const computeResult = computeView({
+                ...model,
+                title: title ?? null,
+                description: description ?? null,
+                tags: tags ?? null,
+                links: links ?? null,
+                rules: clone(rules)
+            }, modelIndex);
+            if (!computeResult.isSuccess) {
+                logWarnError(computeResult.error);
+                return null;
+            }
+            return computeResult.view;
         }
-        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
-            };
+        catch (e) {
+            logError(e);
+            return null;
         }
-        failExpectedNever(astNode);
+    };
+    const views = R.pipe(R.flatMap(docs, d => d.c4Views), R.map(toModelView), R.compact);
+    assignNavigateTo(views);
+    return {
+        elements,
+        relations,
+        views: R.mapToObj(views, v => [v.id, v])
+    };
+}
+export class LikeC4ModelBuilder {
+    services;
+    langiumDocuments;
+    cachedModel = {};
+    constructor(services) {
+        this.services = services;
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        services.likec4.ModelParser.onParsed(() => {
+            this.cleanCache();
+            this.notifyClient();
+        });
     }
-    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);
+    cleanCache() {
+        delete this.cachedModel.last;
     }
-    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);
+    documents() {
+        return this.langiumDocuments.all.filter(isValidLikeC4LangiumDocument).toArray();
     }
-    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
-            });
+    buildModel() {
+        if ('last' in this.cachedModel) {
+            logger.debug('[ModelBuilder] returning cached model');
+            return this.cachedModel.last;
         }
-        const title = astNode.props.find(p => p.key === 'title')?.value;
-        const description = astNode.props.find(p => p.key === 'description')?.value;
-        const tags = this.convertTags(astNode);
-        const links = astNode.props.filter(ast.isLinkProperty).map(p => p.value);
-        return {
-            id,
-            astPath,
-            ...(viewOf && { viewOf }),
-            ...(title && { title }),
-            ...(description && { description }),
-            ...(tags && { tags }),
-            ...(links && isNonEmptyArray(links) && { links }),
-            rules: astNode.rules.map(n => this.parseViewRule(n))
-        };
-    }
-    resolveFqn(node) {
-        if (ast.isExtendElement(node)) {
-            return strictElementRefFqn(node.element);
+        try {
+            const docs = this.documents();
+            if (docs.length === 0) {
+                logger.debug('[ModelBuilder] No documents to build model from');
+                return null;
+            }
+            logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:\n${printDocs(docs)}`);
+            return (this.cachedModel.last = buildModel(docs));
         }
-        const fqn = this.fqnIndex.getFqn(node);
-        invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`);
-        return fqn;
-    }
-    getAstNodePath(node) {
-        return this.services.workspace.AstNodeLocator.getAstNodePath(node);
-    }
-    convertTags(withTags) {
-        if (!withTags) {
+        catch (e) {
+            logError(e);
             return null;
         }
-        const tags = withTags.tags?.value.flatMap(({ ref }) => (ref ? ref.name : []));
-        return tags && isNonEmptyArray(tags) ? tags : null;
     }
     scheduledCb = null;
-    notifyClient(cancelToken) {
+    notifyClient() {
         const connection = this.services.shared.lsp.Connection;
         if (!connection) {
             return;
         }
         if (this.scheduledCb) {
-            logger.debug('debounce scheduled onDidChangeModel');
+            logger.debug('[ModelBuilder] debounce onDidChangeModel');
             clearTimeout(this.scheduledCb);
         }
         this.scheduledCb = setTimeout(() => {
-            logger.debug('send onDidChangeModel');
             this.scheduledCb = null;
-            if (!cancelToken.isCancellationRequested) {
-                void connection.sendNotification(Rpc.onDidChangeModel, '');
-            }
-        }, 300);
+            logger.debug('[ModelBuilder] send onDidChangeModel');
+            void connection.sendNotification(Rpc.onDidChangeModel, '');
+        }, 200);
     }
 }
 //# sourceMappingURL=model-builder.js.map

package/dist/model/model-locator.js

@@ -1,5 +1,7 @@
+import { InvalidModelError } from '@likec4/core';
 import { findNodeForProperty, getDocument } from 'langium';
-import { ElementOps, ast, isParsedLikeC4LangiumDocument } from '../ast';
+import { ast, isParsedLikeC4LangiumDocument } from '../ast';
+import {} from './fqn-index';
 export class LikeC4ModelLocator {
     services;
     fqnIndex;
@@ -13,7 +15,7 @@ export class LikeC4ModelLocator {
         return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument);
     }
     getParsedElement(astNode) {
-        const fqn = ElementOps.readId(astNode) ?? null;
+        const fqn = this.fqnIndex.getFqn(astNode);
         if (!fqn)
             return null;
         const doc = getDocument(astNode);
@@ -23,28 +25,18 @@ export class LikeC4ModelLocator {
         return doc.c4Elements.find(e => e.id === fqn) ?? null;
     }
     locateElement(fqn, property = 'name') {
-        for (const doc of this.documents()) {
-            if (!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
-            };
+        const entry = this.fqnIndex.byFqn(fqn).head();
+        if (!entry) {
+            return null;
         }
-        return null;
+        const propertyNode = findNodeForProperty(entry.el.$cstNode, property) ?? entry.el.$cstNode;
+        if (!propertyNode) {
+            return null;
+        }
+        return {
+            uri: entry.doc.uri.toString(),
+            range: propertyNode.range
+        };
     }
     locateRelation(relationId) {
         for (const doc of this.documents()) {
@@ -68,6 +60,9 @@ export class LikeC4ModelLocator {
                     };
                 }
             }
+            if (node.arr == null) {
+                throw new InvalidModelError('Relation.arr is not defined, but should be');
+            }
             const targetNode = findNodeForProperty(node.$cstNode, 'arr');
             if (!targetNode) {
                 return null;
@@ -75,7 +70,7 @@ export class LikeC4ModelLocator {
             return {
                 uri: doc.uri.toString(),
                 range: {
-                    start: targetNode.range.end,
+                    start: targetNode.range.start,
                     end: targetNode.range.end
                 }
             };

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

@@ -0,0 +1,27 @@
+import { type c4 } from '@likec4/core';
+import type { LangiumDocument } from 'langium';
+import { Disposable, type CancellationToken } from 'vscode-languageserver-protocol';
+import type { LikeC4LangiumDocument } from '../ast';
+import { ast } from '../ast';
+import type { LikeC4Services } from '../module';
+export type ModelParsedListener = () => void;
+export declare class LikeC4ModelParser {
+    private services;
+    private fqnIndex;
+    protected readonly listeners: ModelParsedListener[];
+    constructor(services: LikeC4Services);
+    onParsed(callback: ModelParsedListener): Disposable;
+    protected onValidated(docs: LangiumDocument[], cancelToken: CancellationToken): Promise<void>;
+    protected parseDocument(doc: LikeC4LangiumDocument, cancelToken: CancellationToken): Promise<void>;
+    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 notifyListeners;
+}
+//# sourceMappingURL=model-parser.d.ts.map