@likec4/language-server 1.21.1 → 1.22.0

package/src/model/model-locator.ts

@@ -1,146 +0,0 @@
-import type * as c4 from '@likec4/core'
-import type { LangiumDocuments } from 'langium'
-import { AstUtils, GrammarUtils } from 'langium'
-import { isString } from 'remeda'
-import type { Location } from 'vscode-languageserver-types'
-import type { ParsedAstElement } from '../ast'
-import { ast, isParsedLikeC4LangiumDocument } from '../ast'
-import type { LikeC4Services } from '../module'
-import type { DeploymentsIndex } from './deployments-index'
-import { type FqnIndex } from './fqn-index'
-
-const { findNodeForKeyword, findNodeForProperty } = GrammarUtils
-const { getDocument } = AstUtils
-
-export class LikeC4ModelLocator {
-  private fqnIndex: FqnIndex
-  private deploymentsIndex: DeploymentsIndex
-  private langiumDocuments: LangiumDocuments
-
-  constructor(private services: LikeC4Services) {
-    this.fqnIndex = services.likec4.FqnIndex
-    this.deploymentsIndex = services.likec4.DeploymentsIndex
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments
-  }
-
-  private documents() {
-    return this.langiumDocuments.all.filter(isParsedLikeC4LangiumDocument)
-  }
-
-  public getParsedElement(astNodeOrFqn: ast.Element | c4.Fqn): ParsedAstElement | null {
-    if (isString(astNodeOrFqn)) {
-      const fqn = astNodeOrFqn
-      const entry = this.fqnIndex.byFqn(astNodeOrFqn).head()
-      if (!entry) {
-        return null
-      }
-      const doc = this.langiumDocuments.getDocument(entry.documentUri)
-      if (!doc || !isParsedLikeC4LangiumDocument(doc)) {
-        return null
-      }
-      return doc.c4Elements.find(e => e.id === fqn) ?? null
-    }
-
-    const fqn = this.fqnIndex.getFqn(astNodeOrFqn)
-    if (!fqn) return null
-    const doc = getDocument(astNodeOrFqn)
-    if (!isParsedLikeC4LangiumDocument(doc)) {
-      return null
-    }
-    return doc.c4Elements.find(e => e.id === fqn) ?? null
-  }
-
-  public locateElement(fqn: c4.Fqn, _prop?: string): Location | null {
-    const entry = this.fqnIndex.byFqn(fqn).head()
-    const docsegment = entry?.nameSegment ?? entry?.selectionSegment
-    if (!entry || !docsegment) {
-      return null
-    }
-    return {
-      uri: entry.documentUri.toString(),
-      range: docsegment.range
-    }
-  }
-  public locateDeploymentElement(fqn: c4.Fqn, _prop?: string): Location | null {
-    const entry = this.deploymentsIndex.byFqn(fqn).head()
-    const docsegment = entry?.nameSegment ?? entry?.selectionSegment
-    if (!entry || !docsegment) {
-      return null
-    }
-    return {
-      uri: entry.documentUri.toString(),
-      range: docsegment.range
-    }
-  }
-
-  public locateRelation(relationId: c4.RelationId): Location | null {
-    for (const doc of this.documents()) {
-      const relation = doc.c4Relations.find(r => r.id === relationId)
-        ?? doc.c4DeploymentRelations.find(r => r.id === relationId)
-      if (!relation) {
-        continue
-      }
-      const node = this.services.workspace.AstNodeLocator.getAstNode(
-        doc.parseResult.value,
-        relation.astPath
-      )
-      if (!ast.isRelation(node) && !ast.isDeploymentRelation(node)) {
-        continue
-      }
-
-      let targetNode = node.title ? findNodeForProperty(node.$cstNode, 'title') : undefined
-      targetNode ??= node.kind ? findNodeForProperty(node.$cstNode, 'kind') : undefined
-      targetNode ??= findNodeForProperty(node.$cstNode, 'target')
-      targetNode ??= node.$cstNode
-
-      if (!targetNode) {
-        continue
-      }
-
-      return {
-        uri: doc.uri.toString(),
-        range: targetNode.range
-      }
-    }
-    return null
-  }
-
-  public locateViewAst(viewId: c4.ViewId) {
-    for (const doc of this.documents()) {
-      const view = doc.c4Views.find(r => r.id === viewId)
-      if (!view) {
-        continue
-      }
-      const viewAst = this.services.workspace.AstNodeLocator.getAstNode(
-        doc.parseResult.value,
-        view.astPath
-      )
-      if (ast.isLikeC4View(viewAst)) {
-        return {
-          doc,
-          view,
-          viewAst
-        }
-      }
-    }
-    return null
-  }
-
-  public locateView(viewId: c4.ViewId): Location | null {
-    const res = this.locateViewAst(viewId)
-    if (!res) {
-      return null
-    }
-    const node = res.viewAst
-    let targetNode = node.name ? findNodeForProperty(node.$cstNode, 'name') : undefined
-    targetNode ??= findNodeForKeyword(node.$cstNode, 'view')
-    targetNode ??= node.$cstNode
-    if (!targetNode) {
-      return null
-    }
-    return {
-      uri: res.doc.uri.toString(),
-      range: targetNode.range
-    }
-  }
-}

package/src/model/model-parser-where.ts

@@ -1,84 +0,0 @@
-import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
-import { isAndOperator, isOrOperator } from '@likec4/core'
-import type * as c4 from '@likec4/core'
-import { ast } from '../ast'
-
-const parseEquals = (
-  { operator, not }: ast.WhereKindEqual | ast.WhereTagEqual,
-  value: string,
-): c4.EqualOperator<string> => {
-  if (operator.startsWith('!=')) {
-    return {
-      neq: value,
-    }
-  }
-  if (operator.startsWith('=')) {
-    return {
-      eq: value,
-    }
-  }
-  return not ? { neq: value } : { eq: value }
-}
-
-function parseParticipant(astNode: ast.WhereExpression): ast.Participant | null {
-  if (!ast.isWhereRelationParticipantKind(astNode) && !ast.isWhereRelationParticipantTag(astNode)) {
-    return null
-  }
-
-  return astNode.participant
-}
-
-export function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator<string, string> {
-  switch (true) {
-    case ast.isWhereTagEqual(astNode): {
-      const tag = astNode.value?.ref?.name
-      const participant = parseParticipant(astNode)
-      invariant(tag, 'Expected tag name')
-      const tagOperator = { tag: parseEquals(astNode, tag) }
-      return participant ? { participant, operator: tagOperator } : tagOperator
-    }
-    case ast.isWhereKindEqual(astNode): {
-      const kind = astNode.value?.ref?.name
-      const participant = parseParticipant(astNode)
-      invariant(kind, 'Expected kind name')
-      const kindOperator = { kind: parseEquals(astNode, kind) }
-      return participant ? { participant, operator: kindOperator } : kindOperator
-    }
-    case ast.isWhereElementNegation(astNode) || ast.isWhereRelationNegation(astNode): {
-      return {
-        not: parseWhereClause(astNode.value),
-      }
-    }
-    case ast.isWhereBinaryExpression(astNode): {
-      const left = parseWhereClause(astNode.left)
-      const right = parseWhereClause(astNode.right)
-      const operator = astNode.operator.toLowerCase() as Lowercase<ast.WhereBinaryExpression['operator']>
-      switch (operator) {
-        case 'and': {
-          const operands = [
-            isAndOperator(left) ? left.and : left,
-            isAndOperator(right) ? right.and : right,
-          ].flat()
-          invariant(isNonEmptyArray(operands), 'Expected non-empty array')
-          return {
-            and: operands,
-          }
-        }
-        case 'or': {
-          const operands = [
-            isOrOperator(left) ? left.or : left,
-            isOrOperator(right) ? right.or : right,
-          ].flat()
-          invariant(isNonEmptyArray(operands), 'Expected non-empty array')
-          return {
-            or: operands,
-          }
-        }
-        default:
-          nonexhaustive(operator)
-      }
-    }
-    default:
-      nonexhaustive(astNode)
-  }
-}

package/src/model/model-parser.ts

@@ -1,86 +0,0 @@
-import { invariant } from '@likec4/core'
-import { type LangiumDocument, DocumentCache, DocumentState } from 'langium'
-import { DefaultWeakMap } from 'mnemonist'
-import { pipe } from 'remeda'
-import type { LikeC4DocumentProps, ParsedLikeC4LangiumDocument } from '../ast'
-import { isFqnIndexedDocument } from '../ast'
-import type { LikeC4Services } from '../module'
-import { BaseParser } from './parser/Base'
-import { DeploymentModelParser } from './parser/DeploymentModelParser'
-import { DeploymentViewParser } from './parser/DeploymentViewParser'
-import { ExpressionV2Parser } from './parser/FqnRefParser'
-import { GlobalsParser } from './parser/GlobalsParser'
-import { ModelParser } from './parser/ModelParser'
-import { PredicatesParser } from './parser/PredicatesParser'
-import { SpecificationParser } from './parser/SpecificationParser'
-import { ViewsParser } from './parser/ViewsParser'
-
-export type ModelParsedListener = () => void
-
-const DocumentParserFromMixins = pipe(
-  BaseParser,
-  ExpressionV2Parser,
-  ModelParser,
-  DeploymentModelParser,
-  DeploymentViewParser,
-  PredicatesParser,
-  SpecificationParser,
-  ViewsParser,
-  GlobalsParser,
-)
-
-export class DocumentParser extends DocumentParserFromMixins {
-}
-
-export class LikeC4ModelParser {
-  private cachedParsers: DocumentCache<string, DocumentParser>
-
-  constructor(private services: LikeC4Services) {
-    this.cachedParsers = new DocumentCache(services.shared, DocumentState.Validated)
-  }
-
-  parse(doc: LangiumDocument): ParsedLikeC4LangiumDocument {
-    invariant(isFqnIndexedDocument(doc), `Not a FqnIndexedDocument: ${doc.uri.toString(true)}`)
-    try {
-      const props: Required<Omit<LikeC4DocumentProps, 'c4fqnIndex' | 'diagnostics'>> = {
-        c4Specification: {
-          tags: new Set(),
-          elements: {},
-          relationships: {},
-          colors: {},
-          deployments: {},
-        },
-        c4Elements: [],
-        c4ExtendElements: [],
-        c4Relations: [],
-        c4Deployments: [],
-        c4DeploymentRelations: [],
-        c4Globals: {
-          predicates: {},
-          dynamicPredicates: {},
-          styles: {},
-        },
-        c4Views: [],
-      }
-      doc = Object.assign(doc, props)
-      const parser = this.forDocument(doc)
-      parser.parseSpecification()
-      parser.parseModel()
-      parser.parseGlobals()
-      parser.parseDeployment()
-      parser.parseViews()
-      return parser.doc
-    } catch (cause) {
-      throw new Error(`Error parsing document ${doc.uri.toString()}`, { cause })
-    }
-  }
-
-  forDocument(doc: LangiumDocument): DocumentParser {
-    invariant(isFqnIndexedDocument(doc), `Not a FqnIndexedDocument: ${doc.uri.toString(true)}`)
-    return this.cachedParsers.get(
-      doc.uri,
-      'DocumentParser',
-      () => new DocumentParser(this.services, doc as ParsedLikeC4LangiumDocument),
-    )
-  }
-}

package/src/model/parser/Base.ts

@@ -1,113 +0,0 @@
-import type * as c4 from '@likec4/core'
-import { invariant, isNonEmptyArray } from '@likec4/core'
-import type { AstNode } from 'langium'
-import { filter, flatMap, fromEntries, isEmpty, isNonNullish, isTruthy, map, pipe, unique } 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) || isEmpty(metadataAstNode.props)) {
-      return undefined
-    }
-    const data = pipe(
-      metadataAstNode.props,
-      map(p => [p.key, removeIndent(p.value)] as [string, string]),
-      filter(([_, value]) => isTruthy(value)),
-      fromEntries(),
-    )
-    return isEmpty(data) ? undefined : data
-  }
-
-  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
-    }
-    let 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 = unique(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

@@ -1,192 +0,0 @@
-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,
-      }
-    }
-  }
-}