@likec4/language-server 1.18.0 → 1.19.0

package/src/model/parser/ModelParser.ts

@@ -0,0 +1,141 @@
+import type * as c4 from '@likec4/core'
+import { isNonEmptyArray, nonexhaustive, nonNullable } from '@likec4/core'
+import { filter, first, isNonNullish, isTruthy, map, mapToObj, pipe } from 'remeda'
+import {
+  type ParsedAstElement,
+  type ParsedAstRelation,
+  ast,
+  resolveRelationPoints,
+  streamModel,
+  toElementStyle,
+  toRelationshipStyleExcludeDefaults,
+} from '../../ast'
+import { logWarnError } from '../../logger'
+import { stringHash } from '../../utils/stringHash'
+import { type Base, removeIndent, toSingleLine } from './Base'
+
+export type WithModel = ReturnType<typeof ModelParser>
+
+export function ModelParser<TBase extends Base>(B: TBase) {
+  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
+          }
+          nonexhaustive(el)
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+    }
+
+    parseElement(astNode: ast.Element): ParsedAstElement {
+      const isValid = this.isValid
+      const id = this.resolveFqn(astNode)
+      const kind = nonNullable(astNode.kind.ref, 'Element kind is not resolved').name as c4.ElementKind
+      const tags = this.parseTags(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 astPath = this.getAstNodePath(astNode)
+
+      let [title, description, technology] = astNode.props ?? []
+
+      const bodyProps = pipe(
+        astNode.body?.props ?? [],
+        filter(isValid),
+        filter(ast.isElementStringProperty),
+        mapToObj(p => [p.key, p.value || undefined]),
+      )
+
+      title = removeIndent(title ?? bodyProps.title)
+      description = removeIndent(bodyProps.description ?? description)
+      technology = toSingleLine(bodyProps.technology ?? technology)
+
+      const links = this.parseLinks(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,
+        astPath,
+        title: title ?? astNode.name,
+        ...(metadata && { metadata }),
+        ...(tags && { tags }),
+        ...(links && isNonEmptyArray(links) && { links }),
+        ...(isTruthy(technology) && { technology }),
+        ...(isTruthy(description) && { description }),
+        style,
+      }
+    }
+
+    parseRelation(astNode: ast.Relation): ParsedAstRelation {
+      const isValid = this.isValid
+      const coupling = resolveRelationPoints(astNode)
+      const target = this.resolveFqn(coupling.target)
+      const source = this.resolveFqn(coupling.source)
+      const tags = this.parseTags(astNode) ?? this.parseTags(astNode.body)
+      const links = this.parseLinks(astNode.body)
+      const kind = astNode.kind?.ref?.name as (c4.RelationshipKind | undefined)
+      const metadata = this.getMetadata(astNode.body?.props.find(ast.isMetadataProperty))
+      const astPath = this.getAstNodePath(astNode)
+
+      const bodyProps = mapToObj(
+        astNode.body?.props.filter(ast.isRelationStringProperty).filter(p => isNonNullish(p.value)) ?? [],
+        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 = 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(
+        astPath,
+        source,
+        target,
+      ) as c4.RelationId
+      return {
+        id,
+        astPath,
+        source,
+        target,
+        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 }),
+      }
+    }
+  }
+}

package/src/model/parser/PredicatesParser.ts

@@ -0,0 +1,291 @@
+import type * as c4 from '@likec4/core'
+import { invariant, nonexhaustive } from '@likec4/core'
+import { isDefined, isTruthy } from 'remeda'
+import { ast, parseAstOpacityProperty, toColor } from '../../ast'
+import { logWarnError } from '../../logger'
+import { elementRef } from '../../utils/elementRef'
+import { parseWhereClause } from '../model-parser-where'
+import { type Base, removeIndent } from './Base'
+
+export type WithPredicates = ReturnType<typeof PredicatesParser>
+
+export function PredicatesParser<TBase extends Base>(B: TBase) {
+  return class PredicatesParser extends B {
+    parsePredicate(astNode: ast.Predicate): c4.Expression {
+      if (ast.isElementPredicate(astNode)) {
+        return this.parseElementPredicate(astNode)
+      }
+      if (ast.isRelationPredicate(astNode)) {
+        return this.parseRelationPredicate(astNode)
+      }
+      nonexhaustive(astNode)
+    }
+
+    parseElementPredicate(astNode: ast.ElementPredicate): c4.ElementPredicateExpression {
+      if (ast.isElementPredicateWith(astNode)) {
+        return this.parseElementPredicateWith(astNode)
+      }
+      if (ast.isElementPredicateWhere(astNode)) {
+        return this.parseElementPredicateWhere(astNode)
+      }
+      if (ast.isElementExpression(astNode)) {
+        return this.parseElementExpression(astNode)
+      }
+      nonexhaustive(astNode)
+    }
+
+    parseElementExpressionsIterator(astNode: ast.ElementExpressionsIterator): c4.ElementExpression[] {
+      const exprs = [] as c4.ElementExpression[]
+      let iter: ast.ElementExpressionsIterator['prev'] = astNode
+      while (iter) {
+        try {
+          if (iter.value) {
+            exprs.unshift(this.parseElementExpression(iter.value))
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        iter = iter.prev
+      }
+      return exprs
+    }
+
+    parseElementExpression(astNode: ast.ElementExpression): c4.ElementExpression {
+      if (ast.isWildcardExpression(astNode)) {
+        return {
+          wildcard: true
+        }
+      }
+      if (ast.isElementKindExpression(astNode)) {
+        invariant(astNode.kind?.ref, 'ElementKindExpr kind is not resolved: ' + astNode.$cstNode?.text)
+        return {
+          elementKind: astNode.kind.ref.name as c4.ElementKind,
+          isEqual: astNode.isEqual
+        }
+      }
+      if (ast.isElementTagExpression(astNode)) {
+        invariant(astNode.tag?.ref, 'ElementTagExpr tag is not resolved: ' + astNode.$cstNode?.text)
+        let elementTag = astNode.tag.$refText
+        if (elementTag.startsWith('#')) {
+          elementTag = elementTag.slice(1)
+        }
+        return {
+          elementTag: elementTag as c4.Tag,
+          isEqual: astNode.isEqual
+        }
+      }
+      if (ast.isExpandElementExpression(astNode)) {
+        const elementNode = elementRef(astNode.expand)
+        invariant(elementNode, 'Element not found ' + astNode.expand.$cstNode?.text)
+        const expanded = this.resolveFqn(elementNode)
+        return {
+          expanded
+        }
+      }
+      if (ast.isElementDescedantsExpression(astNode)) {
+        const elementNode = elementRef(astNode.parent)
+        invariant(elementNode, 'Element not found ' + astNode.parent.$cstNode?.text)
+        const element = this.resolveFqn(elementNode)
+        return {
+          element,
+          isChildren: astNode.suffix === '.*',
+          isDescendants: astNode.suffix === '.**'
+        }
+      }
+      if (ast.isElementRef(astNode)) {
+        const elementNode = elementRef(astNode)
+        invariant(elementNode, 'Element not found ' + astNode.$cstNode?.text)
+        const element = this.resolveFqn(elementNode)
+        return {
+          element
+        }
+      }
+      nonexhaustive(astNode)
+    }
+
+    parseElementPredicateWhere(astNode: ast.ElementPredicateWhere): c4.ElementWhereExpr {
+      const expr = this.parseElementExpression(astNode.subject)
+      return {
+        where: {
+          expr,
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: '--always-true--' }
+          }
+        }
+      }
+    }
+
+    parseElementPredicateWith(astNode: ast.ElementPredicateWith): c4.CustomElementExpr {
+      const expr = this.parseElementPredicate(astNode.subject)
+      const props = astNode.custom?.props ?? []
+      return props.reduce(
+        (acc, prop) => {
+          if (!this.isValid(prop)) {
+            return acc
+          }
+          if (ast.isNavigateToProperty(prop)) {
+            const viewId = prop.value.view.$refText
+            if (isTruthy(viewId)) {
+              acc.custom.navigateTo = viewId as c4.ViewId
+            }
+            return acc
+          }
+          if (ast.isElementStringProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = removeIndent(prop.value) || ''
+            }
+            return acc
+          }
+          if (ast.isIconProperty(prop)) {
+            const value = prop.libicon?.ref?.name ?? prop.value
+            if (isDefined(value)) {
+              acc.custom[prop.key] = value as c4.IconUrl
+            }
+            return acc
+          }
+          if (ast.isColorProperty(prop)) {
+            const value = toColor(prop)
+            if (isDefined(value)) {
+              acc.custom[prop.key] = value
+            }
+            return acc
+          }
+          if (ast.isShapeProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = prop.value
+            }
+            return acc
+          }
+          if (ast.isBorderProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = prop.value
+            }
+            return acc
+          }
+          if (ast.isOpacityProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.custom[prop.key] = parseAstOpacityProperty(prop)
+            }
+            return acc
+          }
+          if (ast.isNotationProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.custom[prop.key] = removeIndent(prop.value)
+            }
+            return acc
+          }
+          nonexhaustive(prop)
+        },
+        {
+          custom: {
+            expr
+          }
+        } as c4.CustomElementExpr
+      )
+    }
+
+    parseRelationPredicate(astNode: ast.RelationPredicate): c4.RelationPredicateExpression {
+      if (ast.isRelationPredicateWith(astNode)) {
+        let relation = ast.isRelationPredicateWhere(astNode.subject)
+          ? this.parseRelationPredicateWhere(astNode.subject)
+          : this.parseRelationExpression(astNode.subject)
+
+        return this.parseRelationPredicateWith(astNode, relation)
+      }
+      if (ast.isRelationPredicateWhere(astNode)) {
+        return this.parseRelationPredicateWhere(astNode)
+      }
+      if (ast.isRelationExpression(astNode)) {
+        return this.parseRelationExpression(astNode)
+      }
+      nonexhaustive(astNode)
+    }
+
+    parseRelationPredicateWhere(astNode: ast.RelationPredicateWhere): c4.RelationWhereExpr {
+      const expr = this.parseRelationExpression(astNode.subject)
+      return {
+        where: {
+          expr,
+          condition: astNode.where ? parseWhereClause(astNode.where) : {
+            kind: { neq: '--always-true--' }
+          }
+        }
+      }
+    }
+
+    parseRelationPredicateWith(
+      astNode: ast.RelationPredicateWith,
+      relation: c4.RelationExpression | c4.RelationWhereExpr
+    ): c4.CustomRelationExpr {
+      const props = astNode.custom?.props ?? []
+      return props.reduce(
+        (acc, prop) => {
+          if (ast.isRelationStringProperty(prop) || ast.isNotationProperty(prop) || ast.isNotesProperty(prop)) {
+            if (isDefined(prop.value)) {
+              acc.customRelation[prop.key] = removeIndent(prop.value) ?? ''
+            }
+            return acc
+          }
+          if (ast.isArrowProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.customRelation[prop.key] = prop.value
+            }
+            return acc
+          }
+          if (ast.isColorProperty(prop)) {
+            const value = toColor(prop)
+            if (isTruthy(value)) {
+              acc.customRelation[prop.key] = value
+            }
+            return acc
+          }
+          if (ast.isLineProperty(prop)) {
+            if (isTruthy(prop.value)) {
+              acc.customRelation[prop.key] = prop.value
+            }
+            return acc
+          }
+          if (ast.isRelationNavigateToProperty(prop)) {
+            const viewId = prop.value.view.ref?.name
+            if (isTruthy(viewId)) {
+              acc.customRelation.navigateTo = viewId as c4.ViewId
+            }
+            return acc
+          }
+          nonexhaustive(prop)
+        },
+        {
+          customRelation: {
+            relation
+          }
+        } as c4.CustomRelationExpr
+      )
+    }
+
+    parseRelationExpression(astNode: ast.RelationExpression): c4.RelationExpression {
+      if (ast.isDirectedRelationExpression(astNode)) {
+        return {
+          source: this.parseElementExpression(astNode.source.from),
+          target: this.parseElementExpression(astNode.target),
+          isBidirectional: astNode.source.isBidirectional
+        }
+      }
+      if (ast.isInOutRelationExpression(astNode)) {
+        return {
+          inout: this.parseElementExpression(astNode.inout.to)
+        }
+      }
+      if (ast.isOutgoingRelationExpression(astNode)) {
+        return {
+          outgoing: this.parseElementExpression(astNode.from)
+        }
+      }
+      if (ast.isIncomingRelationExpression(astNode)) {
+        return {
+          incoming: this.parseElementExpression(astNode.to)
+        }
+      }
+      nonexhaustive(astNode)
+    }
+  }
+}

package/src/model/parser/SpecificationParser.ts

@@ -0,0 +1,133 @@
+import type * as c4 from '@likec4/core'
+import type { HexColorLiteral } from '@likec4/core'
+import { filter, isNonNullish, isTruthy, mapToObj, pipe } from 'remeda'
+import { ast, toElementStyle, toRelationshipStyleExcludeDefaults } from '../../ast'
+import { logger, logWarnError } from '../../logger'
+import { type Base, removeIndent } from './Base'
+
+export function SpecificationParser<TBase extends Base>(B: TBase) {
+  return class SpecificationParser extends B {
+    parseSpecification() {
+      const {
+        parseResult: {
+          value: {
+            specifications
+          }
+        },
+        c4Specification
+      } = this.doc
+      const isValid = this.isValid
+
+      const element_specs = specifications.flatMap(s => s.elements.filter(this.isValid))
+      for (const { kind, props } of element_specs) {
+        try {
+          const kindName = kind.name as c4.ElementKind
+          if (!isTruthy(kindName)) {
+            continue
+          }
+          if (kindName in c4Specification.elements) {
+            logger.warn(`Element kind "${kindName}" is already defined`)
+            continue
+          }
+          const style = props.find(ast.isElementStyleProperty)
+          const bodyProps = pipe(
+            props.filter(ast.isSpecificationElementStringProperty) ?? [],
+            filter(p => this.isValid(p) && isNonNullish(p.value)),
+            mapToObj(p => [p.key, removeIndent(p.value)] satisfies [string, string])
+          )
+          c4Specification.elements[kindName] = {
+            ...bodyProps,
+            style: {
+              ...toElementStyle(style?.props, this.isValid)
+            }
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+
+      const relations_specs = specifications.flatMap(s => s.relationships.filter(this.isValid))
+      for (const { kind, props } of relations_specs) {
+        try {
+          const kindName = kind.name as c4.RelationshipKind
+          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(p.value)] satisfies [string, string])
+          )
+          c4Specification.relationships[kindName] = {
+            ...bodyProps,
+            ...toRelationshipStyleExcludeDefaults(props, this.isValid)
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+
+      const tags_specs = specifications.flatMap(s => s.tags.filter(this.isValid))
+      for (const tagSpec of tags_specs) {
+        const tag = tagSpec.tag.name as c4.Tag
+        if (isTruthy(tag)) {
+          c4Specification.tags.add(tag)
+        }
+      }
+
+      const deploymentNodes_specs = specifications.flatMap(s => s.deploymentNodes.filter(isValid))
+      for (const deploymentNode of deploymentNodes_specs) {
+        try {
+          Object.assign(c4Specification.deployments, this.parseSpecificationDeploymentNodeKind(deploymentNode))
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+
+      const colors_specs = specifications.flatMap(s => s.colors.filter(isValid))
+      for (const { name, color } of colors_specs) {
+        try {
+          const colorName = name.name as c4.CustomColor
+          if (colorName in c4Specification.colors) {
+            logger.warn(`Custom color "${colorName}" is already defined`)
+            continue
+          }
+
+          c4Specification.colors[colorName] = {
+            color: color as HexColorLiteral
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+    }
+
+    parseSpecificationDeploymentNodeKind(
+      { kind, props }: ast.SpecificationDeploymentNodeKind
+    ): { [key: c4.DeploymentNodeKind]: c4.DeploymentNodeKindSpecification } {
+      const kindName = kind.name as c4.DeploymentNodeKind
+      if (!isTruthy(kindName)) {
+        throw new Error('DeploymentNodeKind name is not resolved')
+      }
+
+      const style = props.find(ast.isElementStyleProperty)
+      const bodyProps = pipe(
+        props.filter(ast.isSpecificationElementStringProperty) ?? [],
+        filter(p => this.isValid(p) && isNonNullish(p.value)),
+        mapToObj(p => [p.key, removeIndent(p.value)] satisfies [string, string])
+      )
+      return {
+        [kindName]: {
+          ...bodyProps,
+          style: {
+            ...toElementStyle(style?.props, this.isValid)
+          }
+        }
+      }
+    }
+  }
+}