@likec4/language-server 1.17.1 → 1.19.0

package/src/model/parser/Base.ts

@@ -0,0 +1,107 @@
+import type * as c4 from '@likec4/core'
+import { invariant, isNonEmptyArray } from '@likec4/core'
+import type { AstNode } from 'langium'
+import { filter, flatMap, isNonNullish, isTruthy, mapToObj, pipe } from 'remeda'
+import stripIndent from 'strip-indent'
+import { type ParsedLikeC4LangiumDocument, type ParsedLink, ast } from '../../ast'
+import type { LikeC4Services } from '../../module'
+import { getFqnElementRef } from '../../utils/elementRef'
+import { type IsValidFn, checksFromDiagnostics } from '../../validation'
+
+// the class which this mixin is applied to
+export type GConstructor<T = {}> = new(...args: any[]) => T
+
+export function toSingleLine<T extends string | undefined | null>(str: T): T {
+  return (isNonNullish(str) ? removeIndent(str).split('\n').join(' ') : undefined) as T
+}
+
+export function removeIndent<T extends string | undefined | null>(str: T): T {
+  return (isNonNullish(str) ? stripIndent(str).trim() : undefined) as T
+}
+
+export type Base = GConstructor<BaseParser>
+
+export class BaseParser {
+  isValid: IsValidFn
+
+  constructor(
+    public readonly services: LikeC4Services,
+    public readonly doc: ParsedLikeC4LangiumDocument,
+  ) {
+    // do nothing
+    this.isValid = checksFromDiagnostics(doc).isValid
+  }
+
+  resolveFqn(node: ast.FqnReferenceable): c4.Fqn {
+    if (ast.isDeploymentElement(node)) {
+      return this.services.likec4.DeploymentsIndex.getFqn(node)
+    }
+    if (ast.isExtendElement(node)) {
+      return getFqnElementRef(node.element)
+    }
+    const fqn = this.services.likec4.FqnIndex.getFqn(node)
+    invariant(fqn, `Not indexed element: ${this.getAstNodePath(node)}`)
+    return fqn
+  }
+
+  getAstNodePath(node: AstNode) {
+    return this.services.workspace.AstNodeLocator.getAstNodePath(node)
+  }
+
+  getMetadata(metadataAstNode: ast.MetadataProperty | undefined): { [key: string]: string } | undefined {
+    if (!metadataAstNode || !this.isValid(metadataAstNode)) {
+      return undefined
+    }
+    return mapToObj(metadataAstNode.props, p => [p.key, removeIndent(p.value)] as [string, string])
+  }
+
+  convertTags<E extends { tags?: ast.Tags }>(withTags?: E) {
+    return this.parseTags(withTags)
+  }
+  parseTags<E extends { tags?: ast.Tags }>(withTags?: E): c4.NonEmptyArray<c4.Tag> | null {
+    let iter = withTags?.tags
+    if (!iter) {
+      return null
+    }
+    const tags = [] as c4.Tag[]
+    while (iter) {
+      try {
+        if (this.isValid(iter)) {
+          const values = iter.values.map(t => t.ref?.name).filter(isTruthy) as c4.Tag[]
+          if (values.length > 0) {
+            tags.push(...values)
+          }
+        }
+      } catch (e) {
+        // ignore
+      }
+      iter = iter.prev
+    }
+    tags.reverse()
+    return isNonEmptyArray(tags) ? tags : null
+  }
+
+  convertLinks(source?: ast.LinkProperty['$container']): ParsedLink[] | undefined {
+    return this.parseLinks(source)
+  }
+  parseLinks(source?: ast.LinkProperty['$container']): ParsedLink[] | undefined {
+    if (!source?.props || source.props.length === 0) {
+      return undefined
+    }
+    return pipe(
+      source.props,
+      filter(ast.isLinkProperty),
+      flatMap(p => {
+        if (!this.isValid(p)) {
+          return []
+        }
+        const url = p.value
+        if (isTruthy(url)) {
+          const title = isTruthy(p.title) ? toSingleLine(p.title) : undefined
+          return title ? { url, title } : { url }
+        }
+        return []
+      }),
+    )
+  }
+}

package/src/model/parser/DeploymentModelParser.ts

@@ -0,0 +1,192 @@
+import type * as c4 from '@likec4/core'
+import { FqnRef, isNonEmptyArray, nameFromFqn, nonexhaustive, nonNullable } from '@likec4/core'
+import { filter, first, isTruthy, map, mapToObj, pipe } from 'remeda'
+import {
+  type ParsedAstDeployment,
+  type ParsedAstDeploymentRelation,
+  ast,
+  streamDeploymentModel,
+  toElementStyle,
+  toRelationshipStyleExcludeDefaults,
+} from '../../ast'
+import { logWarnError } from '../../logger'
+import { elementRef } from '../../utils/elementRef'
+import { stringHash } from '../../utils/stringHash'
+import { removeIndent, toSingleLine } from './Base'
+import type { WithExpressionV2 } from './FqnRefParser'
+
+export type WithDeploymentModel = ReturnType<typeof DeploymentModelParser>
+
+export function DeploymentModelParser<TBase extends WithExpressionV2>(B: TBase) {
+  return class DeploymentModelParser extends B {
+    parseDeployment() {
+      const doc = this.doc
+      for (const el of streamDeploymentModel(doc)) {
+        try {
+          switch (true) {
+            case ast.isDeploymentRelation(el): {
+              if (this.isValid(el)) {
+                doc.c4DeploymentRelations.push(this.parseDeploymentRelation(el))
+              }
+              break
+            }
+            case ast.isDeployedInstance(el):
+              doc.c4Deployments.push(this.parseDeployedInstance(el))
+              break
+            case ast.isDeploymentNode(el): {
+              doc.c4Deployments.push(this.parseDeploymentNode(el))
+              break
+            }
+            default:
+              nonexhaustive(el)
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+    }
+
+    parseDeploymentNode(astNode: ast.DeploymentNode): ParsedAstDeployment.Node {
+      const isValid = this.isValid
+      const id = this.resolveFqn(astNode)
+      const kind = nonNullable(astNode.kind.ref, 'DeploymentKind not resolved').name as c4.DeploymentNodeKind
+      const tags = this.convertTags(astNode.body)
+      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props
+      const style = toElementStyle(stylePropsAst, isValid)
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
+
+      const bodyProps = pipe(
+        astNode.body?.props ?? [],
+        filter(isValid),
+        filter(ast.isElementStringProperty),
+        mapToObj(p => [p.key, p.value || undefined]),
+      )
+
+      const title = removeIndent(astNode.title ?? bodyProps.title)
+      const description = removeIndent(bodyProps.description)
+      const technology = toSingleLine(bodyProps.technology)
+
+      const links = this.convertLinks(astNode.body)
+
+      // Property has higher priority than from style
+      const iconProp = astNode.body?.props.find(ast.isIconProperty)
+      if (iconProp && isValid(iconProp)) {
+        const value = iconProp.libicon?.ref?.name ?? iconProp.value
+        if (isTruthy(value)) {
+          style.icon = value as c4.IconUrl
+        }
+      }
+
+      return {
+        id,
+        kind,
+        title: title ?? nameFromFqn(id),
+        ...(metadata && { metadata }),
+        ...(tags && { tags }),
+        ...(links && isNonEmptyArray(links) && { links }),
+        ...(isTruthy(technology) && { technology }),
+        ...(isTruthy(description) && { description }),
+        style,
+      }
+    }
+
+    parseDeployedInstance(astNode: ast.DeployedInstance): ParsedAstDeployment.Instance {
+      const isValid = this.isValid
+      const id = this.resolveFqn(astNode)
+      const element = this.resolveFqn(nonNullable(elementRef(astNode.element), 'DeployedInstance element not found'))
+
+      const tags = this.convertTags(astNode.body)
+      const stylePropsAst = astNode.body?.props.find(ast.isElementStyleProperty)?.props
+      const style = toElementStyle(stylePropsAst, isValid)
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
+
+      const bodyProps = pipe(
+        astNode.body?.props ?? [],
+        filter(isValid),
+        filter(ast.isElementStringProperty),
+        mapToObj(p => [p.key, p.value || undefined]),
+      )
+
+      const title = removeIndent(astNode.title ?? bodyProps.title)
+      const description = removeIndent(bodyProps.description)
+      const technology = toSingleLine(bodyProps.technology)
+
+      const links = this.convertLinks(astNode.body)
+
+      // Property has higher priority than from style
+      const iconProp = astNode.body?.props.find(ast.isIconProperty)
+      if (iconProp && isValid(iconProp)) {
+        const value = iconProp.libicon?.ref?.name ?? iconProp.value
+        if (isTruthy(value)) {
+          style.icon = value as c4.IconUrl
+        }
+      }
+
+      return {
+        id,
+        element,
+        ...(metadata && { metadata }),
+        ...(title && { title }),
+        ...(tags && { tags }),
+        ...(links && isNonEmptyArray(links) && { links }),
+        ...(isTruthy(technology) && { technology }),
+        ...(isTruthy(description) && { description }),
+        style,
+      }
+    }
+
+    parseDeploymentRelation(astNode: ast.DeploymentRelation): ParsedAstDeploymentRelation {
+      const isValid = this.isValid
+      const astPath = this.getAstNodePath(astNode)
+      const source = FqnRef.toDeploymentRef(this.parseFqnRef(astNode.source))
+      const target = FqnRef.toDeploymentRef(this.parseFqnRef(astNode.target))
+
+      const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body)
+      const links = this.convertLinks(astNode.body)
+      const kind = astNode.kind?.ref?.name as (c4.RelationshipKind | undefined)
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
+
+      const bodyProps = mapToObj(
+        astNode.body?.props.filter(ast.isRelationStringProperty) ?? [],
+        p => [p.key, p.value as string | undefined],
+      )
+
+      const navigateTo = pipe(
+        astNode.body?.props ?? [],
+        filter(ast.isRelationNavigateToProperty),
+        map(p => p.value.view.ref?.name),
+        filter(isTruthy),
+        first(),
+      )
+
+      const title = removeIndent(astNode.title ?? bodyProps.title)
+      const description = removeIndent(bodyProps.description)
+      const technology = toSingleLine(astNode.technology) ?? removeIndent(bodyProps.technology)
+
+      const styleProp = astNode.body?.props.find(ast.isRelationStyleProperty)
+
+      const id = stringHash(
+        'deployment',
+        astPath,
+        source.id,
+        target.id,
+      ) as c4.RelationId
+
+      return {
+        id,
+        source,
+        target,
+        ...title && { title },
+        ...(metadata && { metadata }),
+        ...(isTruthy(technology) && { technology }),
+        ...(isTruthy(description) && { description }),
+        ...(kind && { kind }),
+        ...(tags && { tags }),
+        ...(isNonEmptyArray(links) && { links }),
+        ...toRelationshipStyleExcludeDefaults(styleProp?.props, isValid),
+        ...(navigateTo && { navigateTo: navigateTo as c4.ViewId }),
+        astPath,
+      }
+    }
+  }
+}

package/src/model/parser/DeploymentViewParser.ts

@@ -0,0 +1,116 @@
+import type * as c4 from '@likec4/core'
+import { FqnExpr, invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
+import { isNonNullish } from 'remeda'
+import { ast, type ParsedAstDeploymentView, toAutoLayout, toElementStyle, ViewOps } from '../../ast'
+import { logWarnError } from '../../logger'
+import { stringHash } from '../../utils'
+import { parseViewManualLayout } from '../../view-utils/manual-layout'
+import { removeIndent, toSingleLine } from './Base'
+import type { WithDeploymentModel } from './DeploymentModelParser'
+import type { WithExpressionV2 } from './FqnRefParser'
+
+export type WithDeploymentView = ReturnType<typeof DeploymentViewParser>
+
+export function DeploymentViewParser<TBase extends WithExpressionV2 & WithDeploymentModel>(B: TBase) {
+  return class DeploymentViewParser extends B {
+    parseDeploymentView(
+      astNode: ast.DeploymentView
+    ): ParsedAstDeploymentView {
+      const body = astNode.body
+      invariant(body, 'DynamicElementView body is not defined')
+      // only valid props
+      const props = body.props.filter(this.isValid)
+      const astPath = this.getAstNodePath(astNode)
+
+      let id = astNode.name
+      if (!id) {
+        id = 'deployment_' + stringHash(
+          this.doc.uri.toString(),
+          astPath
+        ) as c4.ViewId
+      }
+
+      const title = toSingleLine(props.find(p => p.key === 'title')?.value) ?? null
+      const description = removeIndent(props.find(p => p.key === 'description')?.value) ?? null
+
+      const tags = this.convertTags(body)
+      const links = this.convertLinks(body)
+
+      ViewOps.writeId(astNode, id as c4.ViewId)
+
+      const manualLayout = parseViewManualLayout(astNode)
+
+      return {
+        __: 'deployment',
+        id: id as c4.ViewId,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: body.rules.flatMap(n => {
+          try {
+            return this.isValid(n) ? this.parseDeploymentViewRule(n) : []
+          } catch (e) {
+            logWarnError(e)
+            return []
+          }
+        }),
+        ...(manualLayout && { manualLayout })
+      }
+    }
+
+    parseDeploymentViewRule(astRule: ast.DeploymentViewRule): c4.DeploymentViewRule {
+      if (ast.isDeploymentViewRulePredicate(astRule)) {
+        return this.parseDeploymentViewRulePredicate(astRule)
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule)
+      }
+      if (ast.isDeploymentViewRuleStyle(astRule)) {
+        return this.parseDeploymentViewRuleStyle(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseDeploymentViewRulePredicate(astRule: ast.DeploymentViewRulePredicate): c4.DeploymentViewRulePredicate {
+      const exprs = [] as c4.ExpressionV2[]
+      let iterator: ast.DeploymentViewRulePredicateExpression | undefined = astRule.expr
+      while (iterator) {
+        try {
+          const expr = iterator.value
+          if (isNonNullish(expr) && this.isValid(expr)) {
+            switch (true) {
+              case ast.isFqnExpr(expr):
+                exprs.unshift(this.parseFqnExpr(expr))
+                break
+              case ast.isRelationExpr(expr):
+                exprs.unshift(this.parseRelationExpr(expr))
+                break
+              default:
+                nonexhaustive(expr)
+            }
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        iterator = iterator.prev
+      }
+      return astRule.isInclude ? { include: exprs } : { exclude: exprs }
+    }
+
+    parseDeploymentViewRuleStyle(astRule: ast.DeploymentViewRuleStyle): c4.DeploymentViewRuleStyle {
+      const styleProps = astRule.props.filter(ast.isStyleProperty)
+      const notationProperty = astRule.props.find(ast.isNotationProperty)
+      const notation = removeIndent(notationProperty?.value)
+      const targets = this.parseFqnExpressions(astRule.targets)
+      return {
+        targets,
+        ...(notation && { notation }),
+        style: {
+          ...toElementStyle(styleProps, this.isValid)
+        }
+      }
+    }
+  }
+}

package/src/model/parser/FqnRefParser.ts

@@ -0,0 +1,118 @@
+import type * as c4 from '@likec4/core'
+import { nonexhaustive, nonNullable } from '@likec4/core'
+import { isNonNullish } from 'remeda'
+import { ast } from '../../ast'
+import { logWarnError } from '../../logger'
+import { instanceRef } from '../../utils/fqnRef'
+import type { Base } from './Base'
+
+export type WithExpressionV2 = ReturnType<typeof ExpressionV2Parser>
+
+export function ExpressionV2Parser<TBase extends Base>(B: TBase) {
+  return class ExpressionV2Parser extends B {
+    parseFqnRef(astNode: ast.FqnRef): c4.FqnRef {
+      const refValue = nonNullable(
+        astNode.value.ref,
+        `FqnRef is empty ${astNode.$cstNode?.range.start.line}:${astNode.$cstNode?.range.start.character}`,
+      )
+      if (ast.isElement(refValue)) {
+        const deployedInstanceAst = instanceRef(astNode)
+        if (!deployedInstanceAst) {
+          return {
+            model: this.resolveFqn(refValue),
+          }
+        }
+        const deployment = this.resolveFqn(deployedInstanceAst)
+        const element = this.resolveFqn(refValue)
+        return {
+          deployment,
+          element,
+        }
+      }
+
+      if (ast.isDeploymentElement(refValue)) {
+        return {
+          deployment: this.resolveFqn(refValue),
+        }
+      }
+      nonexhaustive(refValue)
+    }
+
+    parseFqnExpr(astNode: ast.FqnExpr): c4.FqnExpr {
+      if (ast.isWildcardExpression(astNode)) {
+        return {
+          wildcard: true,
+        }
+      }
+      if (ast.isFqnRefExpr(astNode)) {
+        return this.parseFqnRefExpr(astNode)
+      }
+      nonexhaustive(astNode)
+    }
+
+    parseFqnRefExpr(astNode: ast.FqnRefExpr): c4.FqnExpr.NonWildcard {
+      const ref = this.parseFqnRef(astNode.ref)
+      switch (true) {
+        case astNode.selector === '._':
+          return {
+            ref,
+            selector: 'expanded',
+          } as c4.FqnExpr.NonWildcard
+        case astNode.selector === '.**':
+          return {
+            ref,
+            selector: 'descendants',
+          } as c4.FqnExpr.NonWildcard
+        case astNode.selector === '.*':
+          return {
+            ref,
+            selector: 'children',
+          } as c4.FqnExpr.NonWildcard
+        default:
+          return { ref } as c4.FqnExpr.NonWildcard
+      }
+    }
+
+    parseFqnExpressions(astNode: ast.FqnExpressions): c4.FqnExpr[] {
+      const exprs = [] as c4.FqnExpr[]
+      let iter: ast.FqnExpressions['prev'] = astNode
+      while (iter) {
+        try {
+          if (isNonNullish(iter.value) && this.isValid(iter.value)) {
+            exprs.push(this.parseFqnExpr(iter.value))
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        iter = iter.prev
+      }
+      return exprs.reverse()
+    }
+
+    parseRelationExpr(astNode: ast.RelationExpr): c4.RelationExpr {
+      if (ast.isDirectedRelationExpr(astNode)) {
+        return {
+          source: this.parseFqnExpr(astNode.source.from),
+          target: this.parseFqnExpr(astNode.target),
+          isBidirectional: astNode.source.isBidirectional,
+        }
+      }
+      if (ast.isInOutRelationExpr(astNode)) {
+        return {
+          inout: this.parseFqnExpr(astNode.inout.to),
+        }
+      }
+      if (ast.isOutgoingRelationExpr(astNode)) {
+        return {
+          outgoing: this.parseFqnExpr(astNode.from),
+        }
+      }
+      if (ast.isIncomingRelationExpr(astNode)) {
+        return {
+          incoming: this.parseFqnExpr(astNode.to),
+        }
+      }
+      nonexhaustive(astNode)
+    }
+  }
+}

package/src/model/parser/GlobalsParser.ts

@@ -0,0 +1,96 @@
+import type * as c4 from '@likec4/core'
+import { nonexhaustive } from '@likec4/core'
+import { isTruthy } from 'remeda'
+import { ast, type ParsedAstGlobals } from '../../ast'
+import { logger, logWarnError } from '../../logger'
+import type { WithViewsParser } from './ViewsParser'
+
+export function GlobalsParser<TBase extends WithViewsParser>(B: TBase) {
+  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 as c4.GlobalPredicateId
+          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) {
+          logWarnError(e)
+        }
+      }
+
+      const styles = globals.flatMap(r => r.styles.filter(isValid))
+      for (const style of styles) {
+        try {
+          const globalStyleId = style.id.name as c4.GlobalStyleID
+          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 (styles.length > 0) {
+            c4Globals.styles[globalStyleId] = styles as c4.NonEmptyArray<c4.ViewRuleStyle>
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+    }
+
+    parseAndStoreGlobalPredicateGroupOrDynamic(
+      astRule: ast.GlobalPredicateGroup | ast.GlobalDynamicPredicateGroup,
+      id: c4.GlobalPredicateId,
+      c4Globals: ParsedAstGlobals
+    ) {
+      if (ast.isGlobalPredicateGroup(astRule)) {
+        const predicates = this.parseGlobalPredicateGroup(astRule)
+        if (predicates.length > 0) {
+          c4Globals.predicates[id] = predicates as c4.NonEmptyArray<c4.ViewRulePredicate>
+        }
+        return
+      }
+      if (ast.isGlobalDynamicPredicateGroup(astRule)) {
+        const predicates = this.parseGlobalDynamicPredicateGroup(astRule)
+        if (predicates.length > 0) {
+          c4Globals.dynamicPredicates[id] = predicates as c4.NonEmptyArray<c4.DynamicViewIncludeRule>
+        }
+        return
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseGlobalPredicateGroup(astRule: ast.GlobalPredicateGroup): c4.ViewRulePredicate[] {
+      return astRule.predicates.map(p => this.parseViewRulePredicate(p))
+    }
+
+    parseGlobalDynamicPredicateGroup(astRule: ast.GlobalDynamicPredicateGroup): c4.DynamicViewIncludeRule[] {
+      return astRule.predicates.map(p => this.parseDynamicViewIncludePredicate(p))
+    }
+
+    parseGlobalStyleOrGroup(astRule: ast.GlobalStyle | ast.GlobalStyleGroup): c4.ViewRuleStyle[] {
+      if (ast.isGlobalStyle(astRule)) {
+        return [this.parseViewRuleStyle(astRule)]
+      }
+      if (ast.isGlobalStyleGroup(astRule)) {
+        return astRule.styles.map(s => this.parseViewRuleStyle(s))
+      }
+      nonexhaustive(astRule)
+    }
+  }
+}