@likec4/language-server 1.18.0 → 1.19.1

package/src/model/parser/ViewsParser.ts

@@ -0,0 +1,428 @@
+import type * as c4 from '@likec4/core'
+import { invariant, isNonEmptyArray, nonexhaustive } from '@likec4/core'
+import { isArray, isDefined, isNonNullish, isTruthy } from 'remeda'
+import type { Writable } from 'type-fest'
+import {
+  ast,
+  type ParsedAstDynamicView,
+  type ParsedAstElementView,
+  toAutoLayout,
+  toColor,
+  toElementStyle,
+  ViewOps
+} from '../../ast'
+import type { NotationProperty } from '../../generated/ast'
+import { logger, logWarnError } from '../../logger'
+import { stringHash } from '../../utils'
+import { elementRef } from '../../utils/elementRef'
+import { parseViewManualLayout } from '../../view-utils/manual-layout'
+import { removeIndent, toSingleLine } from './Base'
+import type { WithDeploymentView } from './DeploymentViewParser'
+import type { WithPredicates } from './PredicatesParser'
+
+export type WithViewsParser = ReturnType<typeof ViewsParser>
+
+export function ViewsParser<TBase extends WithPredicates & WithDeploymentView>(B: TBase) {
+  return class ViewsParser extends B {
+    parseViews() {
+      const isValid = this.isValid
+      for (const viewBlock of this.doc.parseResult.value.views) {
+        const localStyles = viewBlock.styles.flatMap(s => {
+          try {
+            return isValid(s) ? this.parseViewRuleStyleOrGlobalRef(s) : []
+          } catch (e) {
+            logWarnError(e)
+            return []
+          }
+        })
+
+        for (const view of viewBlock.views) {
+          try {
+            if (!isValid(view)) {
+              continue
+            }
+            switch (true) {
+              case ast.isElementView(view):
+                this.doc.c4Views.push(this.parseElementView(view, localStyles))
+                break
+              case ast.isDynamicView(view):
+                this.doc.c4Views.push(this.parseDynamicElementView(view, localStyles))
+                break
+              case ast.isDeploymentView(view):
+                this.doc.c4Views.push(this.parseDeploymentView(view))
+                break
+              default:
+                nonexhaustive(view)
+            }
+          } catch (e) {
+            logWarnError(e)
+          }
+        }
+      }
+    }
+
+    parseElementView(astNode: ast.ElementView, additionalStyles: c4.ViewRuleStyleOrGlobalRef[]): ParsedAstElementView {
+      const body = astNode.body
+      invariant(body, 'ElementView body is not defined')
+      const astPath = this.getAstNodePath(astNode)
+
+      let viewOf = null as c4.Fqn | null
+      if ('viewOf' in astNode) {
+        const viewOfEl = elementRef(astNode.viewOf)
+        const _viewOf = viewOfEl && this.resolveFqn(viewOfEl)
+        if (!_viewOf) {
+          logger.warn('viewOf is not resolved: ' + astNode.$cstNode?.text)
+        } else {
+          viewOf = _viewOf
+        }
+      }
+
+      let id = astNode.name
+      if (!id) {
+        id = 'view_' + stringHash(
+          this.doc.uri.toString(),
+          astPath,
+          viewOf ?? ''
+        ) as c4.ViewId
+      }
+
+      const title = toSingleLine(body.props.find(p => p.key === 'title')?.value) ?? null
+      const description = removeIndent(body.props.find(p => p.key === 'description')?.value) ?? null
+
+      const tags = this.convertTags(body)
+      const links = this.convertLinks(body)
+
+      const manualLayout = parseViewManualLayout(astNode)
+
+      const view: ParsedAstElementView = {
+        __: 'element',
+        id: id as c4.ViewId,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: [
+          ...additionalStyles,
+          ...body.rules.flatMap(n => {
+            try {
+              return this.isValid(n) ? this.parseViewRule(n) : []
+            } catch (e) {
+              logWarnError(e)
+              return []
+            }
+          })
+        ],
+        ...(viewOf && { viewOf }),
+        ...(manualLayout && { manualLayout })
+      }
+      ViewOps.writeId(astNode, view.id)
+
+      if ('extends' in astNode) {
+        const extendsView = astNode.extends.view.ref
+        invariant(extendsView?.name, 'view extends is not resolved: ' + astNode.$cstNode?.text)
+        return Object.assign(view, {
+          extends: extendsView.name as c4.ViewId
+        })
+      }
+
+      return view
+    }
+
+    parseViewRule(astRule: ast.ViewRule): c4.ViewRule {
+      if (ast.isViewRulePredicate(astRule)) {
+        return this.parseViewRulePredicate(astRule)
+      }
+      if (ast.isViewRuleGlobalPredicateRef(astRule)) {
+        return this.parseViewRuleGlobalPredicateRef(astRule)
+      }
+      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+        return this.parseViewRuleStyleOrGlobalRef(astRule)
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule)
+      }
+      if (ast.isViewRuleGroup(astRule)) {
+        return this.parseViewRuleGroup(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseViewRulePredicate(astNode: ast.ViewRulePredicate): c4.ViewRulePredicate {
+      const exprs = [] as c4.Expression[]
+      let predicate = astNode.predicates
+      while (predicate) {
+        const { value, prev } = predicate
+        try {
+          if (isTruthy(value) && this.isValid(value as any)) {
+            exprs.unshift(this.parsePredicate(value))
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        if (!prev) {
+          break
+        }
+        predicate = prev
+      }
+      return ast.isIncludePredicate(astNode) ? { include: exprs } : { exclude: exprs }
+    }
+
+    parseViewRuleGlobalPredicateRef(
+      astRule: ast.ViewRuleGlobalPredicateRef | ast.DynamicViewGlobalPredicateRef
+    ): c4.ViewRuleGlobalPredicateRef {
+      return {
+        predicateId: astRule.predicate.$refText as c4.GlobalPredicateId
+      }
+    }
+
+    parseViewRuleStyleOrGlobalRef(astRule: ast.ViewRuleStyleOrGlobalRef): c4.ViewRuleStyleOrGlobalRef {
+      if (ast.isViewRuleStyle(astRule)) {
+        return this.parseViewRuleStyle(astRule)
+      }
+      if (ast.isViewRuleGlobalStyle(astRule)) {
+        return this.parseViewRuleGlobalStyle(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseViewRuleGroup(astNode: ast.ViewRuleGroup): c4.ViewRuleGroup {
+      const groupRules = [] as c4.ViewRuleGroup['groupRules']
+      for (const rule of astNode.groupRules) {
+        try {
+          if (!this.isValid(rule)) {
+            continue
+          }
+          if (ast.isViewRulePredicate(rule)) {
+            groupRules.push(this.parseViewRulePredicate(rule))
+            continue
+          }
+          if (ast.isViewRuleGroup(rule)) {
+            groupRules.push(this.parseViewRuleGroup(rule))
+            continue
+          }
+          nonexhaustive(rule)
+        } catch (e) {
+          logWarnError(e)
+        }
+      }
+      return {
+        title: toSingleLine(astNode.title) ?? null,
+        groupRules,
+        ...toElementStyle(astNode.props, this.isValid)
+      }
+    }
+
+    parseViewRuleStyle(astRule: ast.ViewRuleStyle | ast.GlobalStyle): c4.ViewRuleStyle {
+      const styleProps = astRule.props.filter(ast.isStyleProperty)
+      const targets = astRule.target
+      const notation = astRule.props.find(ast.isNotationProperty)
+      return this.parseRuleStyle(styleProps, targets, notation)
+    }
+
+    parseRuleStyle(
+      styleProperties: ast.StyleProperty[],
+      elementExpressionsIterator: ast.ElementExpressionsIterator,
+      notationProperty?: NotationProperty
+    ): c4.ViewRuleStyle {
+      const styleProps = toElementStyle(styleProperties, this.isValid)
+      const notation = removeIndent(notationProperty?.value)
+      const targets = this.parseElementExpressionsIterator(elementExpressionsIterator)
+      return {
+        targets,
+        ...(notation && { notation }),
+        style: {
+          ...styleProps
+        }
+      }
+    }
+
+    parseViewRuleGlobalStyle(astRule: ast.ViewRuleGlobalStyle): c4.ViewRuleGlobalStyle {
+      return {
+        styleId: astRule.style.$refText as c4.GlobalStyleID
+      }
+    }
+
+    parseDynamicElementView(
+      astNode: ast.DynamicView,
+      additionalStyles: c4.ViewRuleStyleOrGlobalRef[]
+    ): ParsedAstDynamicView {
+      const body = astNode.body
+      invariant(body, 'DynamicElementView body is not defined')
+      // only valid props
+      const isValid = this.isValid
+      const props = body.props.filter(isValid)
+      const astPath = this.getAstNodePath(astNode)
+
+      let id = astNode.name
+      if (!id) {
+        id = 'dynamic_' + 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 {
+        __: 'dynamic',
+        id: id as c4.ViewId,
+        astPath,
+        title,
+        description,
+        tags,
+        links: isNonEmptyArray(links) ? links : null,
+        rules: [
+          ...additionalStyles,
+          ...body.rules.flatMap(n => {
+            try {
+              return isValid(n) ? this.parseDynamicViewRule(n) : []
+            } catch (e) {
+              logWarnError(e)
+              return []
+            }
+          }, [] as Array<c4.DynamicViewRule>)
+        ],
+        steps: body.steps.reduce((acc, n) => {
+          try {
+            if (isValid(n)) {
+              if (ast.isDynamicViewParallelSteps(n)) {
+                acc.push(this.parseDynamicParallelSteps(n))
+              } else {
+                acc.push(this.parseDynamicStep(n))
+              }
+            }
+          } catch (e) {
+            logWarnError(e)
+          }
+          return acc
+        }, [] as c4.DynamicViewStepOrParallel[]),
+        ...(manualLayout && { manualLayout })
+      }
+    }
+
+    parseDynamicViewRule(astRule: ast.DynamicViewRule): c4.DynamicViewRule {
+      if (ast.isDynamicViewIncludePredicate(astRule)) {
+        return this.parseDynamicViewIncludePredicate(astRule)
+      }
+      if (ast.isDynamicViewGlobalPredicateRef(astRule)) {
+        return this.parseViewRuleGlobalPredicateRef(astRule)
+      }
+      if (ast.isViewRuleStyleOrGlobalRef(astRule)) {
+        return this.parseViewRuleStyleOrGlobalRef(astRule)
+      }
+      if (ast.isViewRuleAutoLayout(astRule)) {
+        return toAutoLayout(astRule)
+      }
+      nonexhaustive(astRule)
+    }
+
+    parseDynamicViewIncludePredicate(astRule: ast.DynamicViewIncludePredicate): c4.DynamicViewIncludeRule {
+      const include = [] as c4.ElementPredicateExpression[]
+      let iter: ast.DynamicViewPredicateIterator | undefined = astRule.predicates
+      while (iter) {
+        try {
+          if (isNonNullish(iter.value) && this.isValid(iter.value as any)) {
+            const c4expr = this.parseElementPredicate(iter.value)
+            include.unshift(c4expr)
+          }
+        } catch (e) {
+          logWarnError(e)
+        }
+        iter = iter.prev
+      }
+      return { include }
+    }
+
+    parseDynamicParallelSteps(node: ast.DynamicViewParallelSteps): c4.DynamicViewParallelSteps {
+      return {
+        __parallel: node.steps.map(step => this.parseDynamicStep(step))
+      }
+    }
+
+    parseDynamicStep(node: ast.DynamicViewStep): c4.DynamicViewStep {
+      const sourceEl = elementRef(node.source)
+      if (!sourceEl) {
+        throw new Error('Invalid reference to source')
+      }
+      const targetEl = elementRef(node.target)
+      if (!targetEl) {
+        throw new Error('Invalid reference to target')
+      }
+      let source = this.resolveFqn(sourceEl)
+      let target = this.resolveFqn(targetEl)
+      const title = removeIndent(node.title) ?? null
+
+      let step: Writable<c4.DynamicViewStep> = {
+        source,
+        target,
+        title
+      }
+      if (node.isBackward) {
+        step = {
+          source: target,
+          target: source,
+          title,
+          isBackward: true
+        }
+      }
+      if (!isArray(node.custom?.props)) {
+        return step
+      }
+      for (const prop of node.custom.props) {
+        try {
+          switch (true) {
+            case ast.isRelationNavigateToProperty(prop): {
+              const viewId = prop.value.view.ref?.name
+              if (isTruthy(viewId)) {
+                step.navigateTo = viewId as c4.ViewId
+              }
+              break
+            }
+            case ast.isRelationStringProperty(prop):
+            case ast.isNotationProperty(prop):
+            case ast.isNotesProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = removeIndent(prop.value) ?? ''
+              }
+              break
+            }
+            case ast.isArrowProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = prop.value
+              }
+              break
+            }
+            case ast.isColorProperty(prop): {
+              const value = toColor(prop)
+              if (isDefined(value)) {
+                step[prop.key] = value
+              }
+              break
+            }
+            case ast.isLineProperty(prop): {
+              if (isDefined(prop.value)) {
+                step[prop.key] = prop.value
+              }
+              break
+            }
+            default:
+              nonexhaustive(prop)
+          }
+        }
+        catch (e) {
+          logWarnError(e)
+        }
+      }
+      return step
+    }
+  }
+}

package/src/module.ts

@@ -1,16 +1,27 @@
-import { DocumentCache, EmptyFileSystem, inject, type Module, WorkspaceCache } from 'langium'
+import { GraphvizLayouter, GraphvizWasmAdapter } from '@likec4/layouts'
+import {
+  type Module,
+  DocumentCache,
+  EmptyFileSystem,
+  inject,
+  WorkspaceCache,
+} from 'langium'
 import {
-  createDefaultModule,
-  createDefaultSharedModule,
   type DefaultSharedModuleContext,
   type LangiumServices,
   type LangiumSharedServices,
   type PartialLangiumServices,
-  type PartialLangiumSharedServices
+  type PartialLangiumSharedServices,
+  createDefaultModule,
+  createDefaultSharedModule,
 } from 'langium/lsp'
+import { LikeC4DocumentationProvider } from './documentation'
 import { LikeC4Formatter } from './formatting/LikeC4Formatter'
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module'
-import { logErrorToTelemetry, logToLspConnection } from './logger'
+import {
+  LikeC4GeneratedModule,
+  LikeC4GeneratedSharedModule,
+} from './generated/module'
+import { logger, logToLspConnection } from './logger'
 import {
   LikeC4CodeLensProvider,
   LikeC4CompletionProvider,
@@ -18,14 +29,29 @@ import {
   LikeC4DocumentLinkProvider,
   LikeC4DocumentSymbolProvider,
   LikeC4HoverProvider,
-  LikeC4SemanticTokenProvider
+  LikeC4SemanticTokenProvider,
 } from './lsp'
-import { DeploymentsIndex, FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
+import {
+  DeploymentsIndex,
+  FqnIndex,
+  LikeC4ModelBuilder,
+  LikeC4ModelLocator,
+  LikeC4ModelParser,
+} from './model'
 import { LikeC4ModelChanges } from './model-change/ModelChanges'
-import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
+import {
+  LikeC4NameProvider,
+  LikeC4ScopeComputation,
+  LikeC4ScopeProvider,
+} from './references'
 import { Rpc } from './Rpc'
-import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared'
+import {
+  LikeC4WorkspaceManager,
+  NodeKindProvider,
+  WorkspaceSymbolProvider,
+} from './shared'
 import { registerValidationChecks } from './validation'
+import { LikeC4Views } from './views'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
@@ -48,22 +74,27 @@ const LikeC4SharedModule: Module<
 > = {
   lsp: {
     NodeKindProvider: services => new NodeKindProvider(services),
-    WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services)
+    WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services),
   },
   workspace: {
-    WorkspaceManager: services => new LikeC4WorkspaceManager(services)
-  }
+    WorkspaceManager: services => new LikeC4WorkspaceManager(services),
+  },
 }
 
 /**
  * Declaration of custom services - add your own service classes here.
  */
 export interface LikeC4AddedServices {
+  documentation: {
+    DocumentationProvider: LikeC4DocumentationProvider
+  }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   WorkspaceCache: WorkspaceCache<string, any>
   DocumentCache: DocumentCache<string, any>
   Rpc: Rpc
   likec4: {
+    Views: LikeC4Views
+    Layouter: GraphvizLayouter
     DeploymentsIndex: DeploymentsIndex
     FqnIndex: FqnIndex
     ModelParser: LikeC4ModelParser
@@ -96,16 +127,24 @@ function bind<T>(Type: Constructor<T, [LikeC4Services]>) {
 }
 
 export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices> = {
+  documentation: {
+    DocumentationProvider: bind(LikeC4DocumentationProvider),
+  },
   WorkspaceCache: (services: LikeC4Services) => new WorkspaceCache(services.shared),
   DocumentCache: (services: LikeC4Services) => new DocumentCache(services.shared),
   Rpc: bind(Rpc),
   likec4: {
+    Layouter: (_services: LikeC4Services) => {
+      logger.debug('Creating GraphvizLayouter with GraphvizWasmAdapter')
+      return new GraphvizLayouter(new GraphvizWasmAdapter())
+    },
+    Views: bind(LikeC4Views),
     DeploymentsIndex: bind(DeploymentsIndex),
     ModelChanges: bind(LikeC4ModelChanges),
     FqnIndex: bind(FqnIndex),
     ModelParser: bind(LikeC4ModelParser),
     ModelBuilder: bind(LikeC4ModelBuilder),
-    ModelLocator: bind(LikeC4ModelLocator)
+    ModelLocator: bind(LikeC4ModelLocator),
   },
   lsp: {
     // RenameProvider: bind(LikeC4RenameProvider),
@@ -116,22 +155,22 @@ export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC
     HoverProvider: bind(LikeC4HoverProvider),
     CodeLensProvider: bind(LikeC4CodeLensProvider),
     DocumentLinkProvider: bind(LikeC4DocumentLinkProvider),
-    Formatter: bind(LikeC4Formatter)
+    Formatter: bind(LikeC4Formatter),
   },
   references: {
     NameProvider: bind(LikeC4NameProvider),
     ScopeComputation: bind(LikeC4ScopeComputation),
-    ScopeProvider: bind(LikeC4ScopeProvider)
-  }
+    ScopeProvider: bind(LikeC4ScopeProvider),
+  },
 }
 
 export type LanguageServicesContext = Partial<DefaultSharedModuleContext>
 
 export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(
   context: LanguageServicesContext,
-  module: Module<I, I1>,
+  module?: Module<I, I1>,
   module2?: Module<I, I2>,
-  module3?: Module<I, I3>
+  module3?: Module<I, I3>,
 ): { shared: LikeC4SharedServices; likec4: I } {
   const shared = createSharedServices(context)
   const modules = [
@@ -140,7 +179,7 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
     LikeC4Module,
     module,
     module2,
-    module3
+    module3,
   ].reduce(_merge, {}) as Module<I>
 
   const likec4 = inject(modules)
@@ -161,17 +200,16 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
 export function createSharedServices(context: LanguageServicesContext = {}): LikeC4SharedServices {
   const moduleContext: DefaultSharedModuleContext = {
     ...EmptyFileSystem,
-    ...context
+    ...context,
   }
   if (context.connection) {
     logToLspConnection(context.connection)
-    logErrorToTelemetry(context.connection)
   }
 
   return inject(
     createDefaultSharedModule(moduleContext),
     LikeC4GeneratedSharedModule,
-    LikeC4SharedModule
+    LikeC4SharedModule,
   )
 }
 
@@ -180,11 +218,19 @@ export function createLanguageServices(context: LanguageServicesContext = {}): {
   likec4: LikeC4Services
 } {
   const shared = createSharedServices(context)
-  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module)
+  const likec4 = inject(
+    createDefaultModule({ shared }),
+    LikeC4GeneratedModule,
+    LikeC4Module,
+  )
   shared.ServiceRegistry.register(likec4)
   registerValidationChecks(likec4)
 
-  if (context.connection) {
+  if (!context.connection) {
+    // We don't run inside a language server
+    // Therefore, initialize the configuration provider instantly
+    shared.workspace.ConfigurationProvider.initialized({})
+  } else {
     likec4.Rpc.init()
   }
 

package/src/protocol.ts

@@ -1,11 +1,12 @@
 import type {
   ComputedLikeC4Model,
   ComputedView,
+  DiagramView,
   Fqn,
   ParsedLikeC4Model,
   RelationId,
   ViewChange,
-  ViewId
+  ViewId,
 } from '@likec4/core'
 import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc'
 import type { DocumentUri, Location } from 'vscode-languageserver-types'
@@ -16,8 +17,9 @@ export type OnDidChangeModelNotification = typeof onDidChangeModel
 // #endregion
 
 // #region To server
+
 export const fetchModel = new RequestType0<{ model: ParsedLikeC4Model | null }, void>(
-  'likec4/fetchModel'
+  'likec4/fetchModel',
 )
 export type FetchModelRequest = typeof fetchModel
 
@@ -26,21 +28,44 @@ export const fetchComputedModel = new RequestType<
   { model: ComputedLikeC4Model | null },
   void
 >(
-  'likec4/fetchComputedModel'
+  'likec4/fetchComputedModel',
 )
 export type FetchComputedModelRequest = typeof fetchComputedModel
 
 export const computeView = new RequestType<{ viewId: ViewId }, { view: ComputedView | null }, void>(
-  'likec4/computeView'
+  'likec4/computeView',
 )
 export type ComputeViewRequest = typeof computeView
 
+/**
+ * Request to layout a view.
+ */
+export const layoutView = new RequestType<
+  { viewId: ViewId },
+  {
+    result:
+      | {
+        dot: string
+        diagram: DiagramView
+      }
+      | null
+  },
+  void
+>('likec4/layout-view')
+export type LayoutViewRequest = typeof layoutView
+
+/**
+ * Request to build documents.
+ */
 export interface BuildDocumentsParams {
   docs: DocumentUri[]
 }
 export const buildDocuments = new RequestType<BuildDocumentsParams, void, void>('likec4/build')
 export type BuildDocumentsRequest = typeof buildDocuments
 
+/**
+ * Request to locate an element, relation, deployment or view.
+ */
 export type LocateParams =
   | {
     element: Fqn