@likec4/language-server 1.43.0 → 1.45.0

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

@@ -9,15 +9,15 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseGlobalDynamicPredicateGroup(astRule: ast.GlobalDynamicPredicateGroup): c4.DynamicViewIncludeRule[];
         parseGlobalStyleOrGroup(astRule: ast.GlobalStyle | ast.GlobalStyleGroup): c4.ElementViewRuleStyle[];
         parseViews(): void;
-        parseElementView(astNode: ast.ElementView, additionalStyles: any[]): import("../../ast").ParsedAstElementView;
+        parseElementView(astNode: ast.ElementView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstElementView;
         parseElementViewRule(astRule: ast.ViewRule): c4.ElementViewRule;
         parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ElementViewPredicate;
         parseViewRuleGlobalPredicateRef(astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef): c4.ViewRuleGlobalPredicateRef;
-        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): any;
+        parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>;
         parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ElementViewRuleGroup;
         parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ElementViewRuleStyle;
         parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle;
-        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: any[]): import("../../ast").ParsedAstDynamicView;
+        parseDynamicElementView(astNode: ast.DynamicView, additionalStyles: (c4.ViewRuleGlobalStyle | c4.ElementViewRuleStyle<c4.aux.Any>)[]): import("../../ast").ParsedAstDynamicView;
         parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule;
         parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule;
         parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicStepsParallel;
@@ -60,14 +60,14 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
@@ -102,7 +102,7 @@ export declare function GlobalsParser<TBase extends WithViewsParser>(B: TBase):
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
         parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
-        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4;
+        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4.FqnRef;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;

package/dist/model/parser/GlobalsParser.js

@@ -0,0 +1,84 @@
+import { nonexhaustive } from '@likec4/core';
+import { loggable } from '@likec4/log';
+import { hasAtLeast, isTruthy } from 'remeda';
+import { ast } from '../../ast';
+import { serverLogger } from '../../logger';
+const logger = serverLogger.getChild('GlobalsParser');
+export function GlobalsParser(B) {
+    return class GlobalsParser extends B {
+        parseGlobals() {
+            const { parseResult, c4Globals } = this.doc;
+            const isValid = this.isValid;
+            const globals = parseResult.value.globals.filter(isValid);
+            const elRelPredicates = globals.flatMap(r => r.predicates.filter(isValid));
+            for (const predicate of elRelPredicates) {
+                try {
+                    const globalPredicateId = predicate.name;
+                    if (!isTruthy(globalPredicateId)) {
+                        continue;
+                    }
+                    if (globalPredicateId in c4Globals.predicates) {
+                        logger.warn(`Global predicate named "${globalPredicateId}" is already defined`);
+                        continue;
+                    }
+                    this.parseAndStoreGlobalPredicateGroupOrDynamic(predicate, globalPredicateId, c4Globals);
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            const styles = globals.flatMap(r => r.styles.filter(isValid));
+            for (const style of styles) {
+                try {
+                    const globalStyleId = style.id.name;
+                    if (!isTruthy(globalStyleId)) {
+                        continue;
+                    }
+                    if (globalStyleId in c4Globals.styles) {
+                        logger.warn(`Global style named "${globalStyleId}" is already defined`);
+                        continue;
+                    }
+                    const styles = this.parseGlobalStyleOrGroup(style);
+                    if (hasAtLeast(styles, 1)) {
+                        c4Globals.styles[globalStyleId] = styles;
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+        }
+        parseAndStoreGlobalPredicateGroupOrDynamic(astRule, id, c4Globals) {
+            if (ast.isGlobalPredicateGroup(astRule)) {
+                const predicates = this.parseGlobalPredicateGroup(astRule);
+                if (hasAtLeast(predicates, 1)) {
+                    c4Globals.predicates[id] = predicates;
+                }
+                return;
+            }
+            if (ast.isGlobalDynamicPredicateGroup(astRule)) {
+                const predicates = this.parseGlobalDynamicPredicateGroup(astRule);
+                if (hasAtLeast(predicates, 1)) {
+                    c4Globals.dynamicPredicates[id] = predicates;
+                }
+                return;
+            }
+            nonexhaustive(astRule);
+        }
+        parseGlobalPredicateGroup(astRule) {
+            return astRule.predicates.map(p => this.parseViewRulePredicate(p));
+        }
+        parseGlobalDynamicPredicateGroup(astRule) {
+            return astRule.predicates.map(p => this.parseDynamicViewIncludePredicate(p));
+        }
+        parseGlobalStyleOrGroup(astRule) {
+            if (ast.isGlobalStyle(astRule)) {
+                return [this.parseViewRuleStyle(astRule)];
+            }
+            if (ast.isGlobalStyleGroup(astRule)) {
+                return astRule.styles.map(s => this.parseViewRuleStyle(s));
+            }
+            nonexhaustive(astRule);
+        }
+    };
+}

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

@@ -1,4 +1,3 @@
-import { type ProjectId } from '@likec4/core';
 import type { ast } from '../../ast';
 import type { Base } from './Base';
 export declare function ImportsParser<TBase extends Base>(B: TBase): {
@@ -8,23 +7,23 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
         readonly services: import("../..").LikeC4Services;
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
-        resolveFqn(node: ast.FqnReferenceable): ProjectId;
-        getAstNodePath(node: ProjectId): any;
+        resolveFqn(node: ast.FqnReferenceable): import("@likec4/core").Fqn;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
-        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): ProjectId | undefined;
+        parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): import("@likec4/core").MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): import("@likec4/core").NonEmptyArray<import("@likec4/core").Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E): ProjectId<ProjectId> | null;
-        convertLinks(source?: ast.LinkProperty["$container"]): ProjectId[] | undefined;
-        parseLinks(source?: ast.LinkProperty["$container"]): ProjectId[] | undefined;
-        parseIconProperty(prop: ast.IconProperty | undefined): ProjectId | undefined;
+        }>(withTags?: E): import("@likec4/core").NonEmptyArray<import("@likec4/core").Tag> | null;
+        convertLinks(source?: ast.LinkProperty["$container"]): import("@likec4/core").Link[] | undefined;
+        parseLinks(source?: ast.LinkProperty["$container"]): import("@likec4/core").Link[] | undefined;
+        parseIconProperty(prop: ast.IconProperty | undefined): import("@likec4/core").IconUrl | undefined;
         parseImageAlias(value: string): string | undefined;
-        parseColorLiteral(astNode: ast.ColorLiteral): ProjectId | undefined;
+        parseColorLiteral(astNode: ast.ColorLiteral): import("@likec4/core").ColorLiteral | undefined;
         parseElementStyle(elementProps: Array<ast.ElementProperty> | ast.ElementStyleProperty | undefined): import("../../ast").ParsedElementStyle;
         parseStyleProps(styleProps: Array<ast.StyleProperty> | undefined): import("../../ast").ParsedElementStyle;
         parseBaseProps(props: {
@@ -39,8 +38,8 @@ export declare function ImportsParser<TBase extends Base>(B: TBase): {
             technology?: string | undefined;
         }): {
             title?: string;
-            summary?: ProjectId;
-            description?: ProjectId;
+            summary?: import("@likec4/core").MarkdownOrString;
+            description?: import("@likec4/core").MarkdownOrString;
             technology?: string;
         };
     };

package/dist/model/parser/ImportsParser.js

@@ -0,0 +1,24 @@
+import { nonNullable } from '@likec4/core';
+import { loggable } from '@likec4/log';
+import { serverLogger } from '../../logger';
+const logger = serverLogger.getChild('ImportsParser');
+export function ImportsParser(B) {
+    return class ImportsParser extends B {
+        parseImports() {
+            const imports = this.doc.parseResult.value.imports ?? [];
+            for (const importsFromPoject of imports) {
+                const project = importsFromPoject.project;
+                let imported = importsFromPoject.imports;
+                while (imported) {
+                    try {
+                        this.doc.c4Imports.set(project, this.resolveFqn(nonNullable(imported.imported.ref, `ElementRef is empty of imported: ${imported.imported.$refText}`)));
+                    }
+                    catch (e) {
+                        logger.warn(loggable(e));
+                    }
+                    imported = imported.prev;
+                }
+            }
+        }
+    };
+}

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

@@ -32,14 +32,14 @@ export declare function ModelParser<TBase extends WithExpressionV2>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;

package/dist/model/parser/ModelParser.js

@@ -0,0 +1,165 @@
+import { invariant, isNonEmptyArray, LinkedList, nonexhaustive, nonNullable } from '@likec4/core';
+import { exact, FqnRef } from '@likec4/core/types';
+import { loggable } from '@likec4/log';
+import { filter, first, isDefined, isEmpty, isTruthy, map, mapToObj, pipe } from 'remeda';
+import { ast, toRelationshipStyle, } from '../../ast';
+import { logger as mainLogger } from '../../logger';
+import { stringHash } from '../../utils/stringHash';
+const logger = mainLogger.getChild('ModelParser');
+function* streamModel(doc) {
+    const traverseStack = LinkedList.from(doc.parseResult.value.models.flatMap(m => m.elements));
+    const relations = [];
+    let el;
+    while ((el = traverseStack.shift())) {
+        if (ast.isRelation(el)) {
+            relations.push(el);
+            continue;
+        }
+        if (el.body && el.body.elements && el.body.elements.length > 0) {
+            for (const child of el.body.elements) {
+                traverseStack.push(child);
+            }
+        }
+        yield el;
+    }
+    yield* relations;
+    return;
+}
+export function ModelParser(B) {
+    return class ModelParser extends B {
+        parseModel() {
+            const doc = this.doc;
+            for (const el of streamModel(doc)) {
+                try {
+                    if (ast.isElement(el)) {
+                        doc.c4Elements.push(this.parseElement(el));
+                        continue;
+                    }
+                    if (ast.isRelation(el)) {
+                        if (this.isValid(el)) {
+                            doc.c4Relations.push(this.parseRelation(el));
+                        }
+                        continue;
+                    }
+                    if (ast.isExtendElement(el)) {
+                        const parsed = this.parseExtendElement(el);
+                        if (parsed) {
+                            doc.c4ExtendElements.push(parsed);
+                        }
+                        continue;
+                    }
+                    nonexhaustive(el);
+                }
+                catch (e) {
+                    const astPath = this.getAstNodePath(el);
+                    const error = loggable(e);
+                    const message = e instanceof Error ? e.message : String(error);
+                    logger.warn(`Error on {eltype}: ${message}\n document: {path}\n astpath: {astPath}\n${error}`, {
+                        path: doc.uri.path,
+                        eltype: el.$type,
+                        astPath,
+                    });
+                }
+            }
+        }
+        parseElement(astNode) {
+            const isValid = this.isValid;
+            const id = this.resolveFqn(astNode);
+            const kind = nonNullable(astNode.kind.ref, 'Element kind is not resolved').name;
+            const tags = this.parseTags(astNode.body);
+            const style = this.parseElementStyle(astNode.body?.props);
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const astPath = this.getAstNodePath(astNode);
+            let [_title, _summary, _technology] = astNode.props ?? [];
+            const bodyProps = pipe(astNode.body?.props ?? [], filter(isValid), filter(ast.isElementStringProperty), mapToObj(p => [p.key, p.value]));
+            const { title, ...descAndTech } = this.parseBaseProps(bodyProps, {
+                title: _title,
+                summary: _summary,
+                technology: _technology,
+            });
+            const links = this.parseLinks(astNode.body);
+            return exact({
+                id,
+                kind,
+                astPath,
+                title: title ?? astNode.name,
+                metadata,
+                tags: tags ?? undefined,
+                ...(links && isNonEmptyArray(links) && { links }),
+                ...descAndTech,
+                style,
+            });
+        }
+        parseExtendElement(astNode) {
+            const id = this.resolveFqn(astNode);
+            const tags = this.parseTags(astNode.body);
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const astPath = this.getAstNodePath(astNode);
+            const links = this.parseLinks(astNode.body) ?? [];
+            if (!tags && isEmpty(metadata ?? {}) && isEmpty(links)) {
+                return null;
+            }
+            return exact({
+                id,
+                astPath,
+                metadata,
+                tags,
+                links: isNonEmptyArray(links) ? links : null,
+            });
+        }
+        _resolveRelationSource(node) {
+            if (isDefined(node.source)) {
+                const source = this.parseFqnRef(node.source);
+                invariant(FqnRef.isModelRef(source) || FqnRef.isImportRef(source), 'Relation source must be a model reference');
+                return source;
+            }
+            if (ast.isElementBody(node.$container)) {
+                return {
+                    model: this.resolveFqn(node.$container.$container),
+                };
+            }
+            if (ast.isExtendElementBody(node.$container)) {
+                return {
+                    model: this.resolveFqn(node.$container.$container),
+                };
+            }
+            throw new Error('RelationRefError: Invalid container for sourceless relation');
+        }
+        parseRelation(astNode) {
+            const isValid = this.isValid;
+            const source = this._resolveRelationSource(astNode);
+            const target = this.parseFqnRef(astNode.target);
+            invariant(FqnRef.isModelRef(target) || FqnRef.isImportRef(target), 'Target must be a model reference');
+            const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body);
+            const links = this.parseLinks(astNode.body);
+            const kind = (astNode.kind ?? astNode.dotKind?.kind)?.ref?.name;
+            const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty));
+            const astPath = this.getAstNodePath(astNode);
+            const bodyProps = pipe(astNode.body?.props ?? [], filter(ast.isRelationStringProperty), filter(p => isTruthy(p.value)), mapToObj(p => [p.key, p.value]));
+            const navigateTo = pipe(astNode.body?.props ?? [], filter(ast.isRelationNavigateToProperty), map(p => p.value.view.ref?.name), filter(isTruthy), first());
+            const { title = '', description, technology } = this.parseBaseProps(bodyProps, {
+                // inline props
+                title: astNode.title,
+                description: astNode.description,
+                technology: astNode.technology,
+            });
+            const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty);
+            const id = stringHash(astPath, source.model, target.model);
+            return exact({
+                id,
+                astPath,
+                source,
+                target,
+                title,
+                metadata,
+                kind,
+                tags: tags ?? undefined,
+                links: isNonEmptyArray(links) ? links : undefined,
+                navigateTo: navigateTo ? navigateTo : undefined,
+                description,
+                technology,
+                ...toRelationshipStyle(styleProp?.props, isValid),
+            });
+        }
+    };
+}

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

@@ -37,14 +37,14 @@ export declare function PredicatesParser<TBase extends WithExpressionV2>(B: TBas
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;

package/dist/model/parser/PredicatesParser.js

@@ -0,0 +1,45 @@
+import { nonexhaustive } from '@likec4/core';
+import { ast } from '../../ast';
+export function PredicatesParser(B) {
+    return class PredicatesParser extends B {
+        parsePredicate(astNode) {
+            return this.parseExpressionV2(astNode);
+        }
+        parseElementPredicate(astNode) {
+            if (ast.isFqnExprWith(astNode)) {
+                return this.parseFqnExprWith(astNode);
+            }
+            if (ast.isFqnExprOrWhere(astNode)) {
+                return this.parseFqnExprOrWhere(astNode);
+            }
+            nonexhaustive(astNode);
+        }
+        parseElementPredicateOrWhere(astNode) {
+            return this.parseFqnExprOrWhere(astNode);
+        }
+        parseElementExpression(astNode) {
+            return this.parseFqnExpr(astNode);
+        }
+        parseElementPredicateWhere(astNode) {
+            return this.parseFqnExprWhere(astNode);
+        }
+        parseElementPredicateWith(astNode) {
+            return this.parseFqnExprWith(astNode);
+        }
+        parseRelationPredicate(astNode) {
+            return this.parseRelationExprOrWith(astNode);
+        }
+        parseRelationPredicateOrWhere(astNode) {
+            return this.parseRelationExprOrWhere(astNode);
+        }
+        parseRelationPredicateWhere(astNode) {
+            return this.parseRelationExprWhere(astNode);
+        }
+        parseRelationPredicateWith(astNode) {
+            return this.parseRelationExprWith(astNode);
+        }
+        parseRelationExpression(astNode) {
+            return this.parseRelationExpr(astNode);
+        }
+    };
+}

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

@@ -15,14 +15,14 @@ export declare function SpecificationParser<TBase extends Base>(B: TBase): {
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;

package/dist/model/parser/SpecificationParser.js

@@ -0,0 +1,113 @@
+import * as c4 from '@likec4/core';
+import { exact } from '@likec4/core';
+import { nonNullable } from '@likec4/core/utils';
+import { loggable } from '@likec4/log';
+import { filter, isNonNullish, isNullish, isTruthy, mapToObj, omitBy, pipe } from 'remeda';
+import { ast, parseMarkdownAsString, toRelationshipStyle } from '../../ast';
+import { serverLogger } from '../../logger';
+import { removeIndent } from './Base';
+const logger = serverLogger.getChild('SpecificationParser');
+export function SpecificationParser(B) {
+    return class SpecificationParser extends B {
+        parseSpecification() {
+            const { parseResult: { value: { specifications, }, }, c4Specification, } = this.doc;
+            const isValid = this.isValid;
+            for (const elementSpec of specifications.flatMap(s => s.elements.filter(isValid))) {
+                try {
+                    Object.assign(c4Specification.elements, this.parseElementSpecificationNode(elementSpec));
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            for (const deploymentNodeSpec of specifications.flatMap(s => s.deploymentNodes.filter(isValid))) {
+                try {
+                    Object.assign(c4Specification.deployments, this.parseElementSpecificationNode(deploymentNodeSpec));
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            const relations_specs = specifications.flatMap(s => s.relationships.filter(this.isValid));
+            for (const { kind, props } of relations_specs) {
+                try {
+                    const kindName = kind.name;
+                    if (!isTruthy(kindName)) {
+                        continue;
+                    }
+                    if (kindName in c4Specification.relationships) {
+                        logger.warn(`Relationship kind "${kindName}" is already defined`);
+                        continue;
+                    }
+                    const bodyProps = pipe(props.filter(ast.isSpecificationRelationshipStringProperty) ?? [], filter(p => this.isValid(p) && isNonNullish(p.value)), mapToObj(p => [p.key, removeIndent(parseMarkdownAsString(p.value))]), omitBy(isNullish));
+                    c4Specification.relationships[kindName] = {
+                        ...bodyProps,
+                        ...toRelationshipStyle(props.filter(ast.isRelationshipStyleProperty), this.isValid),
+                    };
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            const tags_specs = specifications.flatMap(s => s.tags.filter(this.isValid));
+            for (const tagSpec of tags_specs) {
+                try {
+                    const tag = tagSpec.tag.name;
+                    const astPath = this.getAstNodePath(tagSpec.tag);
+                    const color = tagSpec.color && this.parseColorLiteral(tagSpec.color);
+                    if (tag in c4Specification.tags) {
+                        logger.warn(`Tag {tag} is already defined, skipping duplicate`, { tag });
+                        continue;
+                    }
+                    if (isTruthy(tag)) {
+                        c4Specification.tags[tag] = {
+                            astPath,
+                            ...(color ? { color } : {}),
+                        };
+                    }
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+            const colors_specs = specifications.flatMap(s => s.colors.filter(isValid));
+            for (const { name, color } of colors_specs) {
+                try {
+                    const colorName = name.name;
+                    if (colorName in c4Specification.colors) {
+                        logger.warn(`Custom color "${colorName}" is already defined`);
+                        continue;
+                    }
+                    c4Specification.colors[colorName] = {
+                        color: nonNullable(this.parseColorLiteral(color), `Color "${colorName}" is not valid: ${color}`),
+                    };
+                }
+                catch (e) {
+                    logger.warn(loggable(e));
+                }
+            }
+        }
+        parseElementSpecificationNode(specAst) {
+            const { kind, props } = specAst;
+            const kindName = kind.name;
+            if (!isTruthy(kindName)) {
+                throw new Error('DeploymentNodeKind name is not resolved');
+            }
+            const tags = this.parseTags(specAst);
+            const style = this.parseElementStyle(props.find(ast.isElementStyleProperty));
+            const links = this.parseLinks(specAst);
+            const bodyProps = pipe(props.filter(ast.isSpecificationElementStringProperty) ?? [], filter(p => this.isValid(p)), mapToObj(p => [p.key, p.value]));
+            const baseProps = this.parseBaseProps(bodyProps);
+            const notation = removeIndent(parseMarkdownAsString(bodyProps.notation));
+            return {
+                [kindName]: exact({
+                    ...baseProps,
+                    notation,
+                    tags: tags ?? undefined,
+                    ...(links && c4.isNonEmptyArray(links) && { links }),
+                    style,
+                }),
+            };
+        }
+    };
+}

package/dist/model/parser/ValueConverter.js

@@ -0,0 +1,12 @@
+import { DefaultValueConverter, ValueConverter } from 'langium';
+export class LikeC4ValueConverter extends DefaultValueConverter {
+    runConverter(rule, input, cstNode) {
+        if (rule.name === 'MarkdownString') {
+            if ((input.startsWith('"""') && input.endsWith('"""')) || (input.startsWith(`'''`) && input.endsWith(`'''`))) {
+                input = input.slice(2, -2);
+            }
+            return ValueConverter.convertString(input);
+        }
+        return super.runConverter(rule, input, cstNode);
+    }
+}

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

@@ -62,14 +62,14 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         readonly doc: import("../../ast").ParsedLikeC4LangiumDocument;
         get project(): import("../../workspace").Project;
         resolveFqn(node: ast.FqnReferenceable): c4.Fqn;
-        getAstNodePath(node: c4): any;
+        getAstNodePath(node: import("langium").AstNode): string;
         getMetadata(metadataAstNode: ast.MetadataProperty | undefined): {
             [key: string]: string | string[];
         } | undefined;
         parseMarkdownOrString(markdownOrString: ast.MarkdownOrString | undefined): c4.MarkdownOrString | undefined;
         convertTags<E extends {
             tags?: ast.Tags;
-        }>(withTags?: E | undefined): any;
+        }>(withTags?: E | undefined): c4.NonEmptyArray<c4.Tag<string>> | null;
         parseTags<E extends {
             tags?: ast.Tags;
         }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null;
@@ -104,7 +104,7 @@ export declare function ViewsParser<TBase extends WithPredicates & WithDeploymen
         parseDeploymentNode(astNode: ast.DeploymentNode): import("../../ast").ParsedAstDeployment.Node;
         parseDeployedInstance(astNode: ast.DeployedInstance): import("../../ast").ParsedAstDeployment.Instance;
         parseExtendDeployment(astNode: ast.ExtendDeployment): import("../../ast").ParsedAstExtend | null;
-        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4;
+        _resolveDeploymentRelationSource(node: ast.DeploymentRelation): c4.FqnRef;
         parseDeploymentRelation(astNode: ast.DeploymentRelation): import("../../ast").ParsedAstDeploymentRelation;
     };
 } & TBase;