@likec4/language-server 1.2.0 → 1.2.2

package/src/model-change/ModelChanges.ts

@@ -0,0 +1,120 @@
+import { invariant, nonexhaustive } from '@likec4/core'
+import { Location, Range, TextEdit } from 'vscode-languageserver-protocol'
+import { type ParsedLikeC4LangiumDocument } from '../ast'
+import type { LikeC4ModelLocator } from '../model'
+import type { LikeC4Services } from '../module'
+import type { ChangeViewRequestParams } from '../protocol'
+import { changeElementStyle } from './changeElementStyle'
+import { changeViewLayout } from './changeViewLayout'
+
+function unionRangeOfAllEdits(ranges: Range[]): Range {
+  let startLine = Number.MAX_SAFE_INTEGER
+  let endLine = Number.MIN_SAFE_INTEGER
+
+  let startCharacter = Number.MAX_SAFE_INTEGER
+  let endCharacter = Number.MIN_SAFE_INTEGER
+
+  for (const { start, end } of ranges) {
+    if (start.line <= startLine) {
+      if (startLine == start.line) {
+        startCharacter = Math.min(start.character, startCharacter)
+      } else {
+        startLine = start.line
+        startCharacter = start.character
+      }
+    }
+    if (endLine <= end.line) {
+      if (endLine == end.line) {
+        endCharacter = Math.max(end.character, endCharacter)
+      } else {
+        endLine = end.line
+        endCharacter = end.character
+      }
+    }
+  }
+  return Range.create(startLine, startCharacter, endLine, endCharacter)
+}
+
+export class LikeC4ModelChanges {
+  private locator: LikeC4ModelLocator
+
+  constructor(private services: LikeC4Services) {
+    this.locator = services.likec4.ModelLocator
+  }
+
+  public async applyChange(changeView: ChangeViewRequestParams): Promise<Location | null> {
+    const lspConnection = this.services.shared.lsp.Connection
+    invariant(lspConnection, 'LSP Connection not available')
+    let result: Location | null = null
+    await this.services.shared.workspace.WorkspaceLock.write(async () => {
+      const { doc, edits } = this.convertToTextEdit(changeView)
+      const textDocument = {
+        uri: doc.textDocument.uri,
+        version: doc.textDocument.version
+      }
+      if (!edits.length) {
+        return
+      }
+      const applyResult = await lspConnection.workspace.applyEdit({
+        label: `LikeC4 - change view ${changeView.viewId}`,
+        edit: {
+          changes: {
+            [textDocument.uri]: edits
+          }
+        }
+      })
+      if (!applyResult.applied) {
+        lspConnection.window.showErrorMessage(`Failed to apply changes ${applyResult.failureReason}`)
+        return
+      }
+      result = {
+        uri: textDocument.uri,
+        range: unionRangeOfAllEdits(edits.map(edit => edit.range))
+      }
+    })
+    return result
+  }
+
+  protected convertToTextEdit({ viewId, changes }: ChangeViewRequestParams): {
+    doc: ParsedLikeC4LangiumDocument
+    ranges: Range[]
+    edits: TextEdit[]
+  } {
+    const lookup = this.locator.locateViewAst(viewId)
+    if (!lookup) {
+      throw new Error(`View not found: ${viewId}`)
+    }
+    const ranges = [] as Range[]
+    const edits = [] as TextEdit[]
+    for (const change of changes) {
+      switch (change.op) {
+        case 'change-element-style': {
+          const { edits: elementEdits, modifiedRange } = changeElementStyle(this.services, {
+            ...lookup,
+            targets: change.targets,
+            style: change.style
+          })
+          ranges.push(modifiedRange)
+          edits.push(...elementEdits)
+          break
+        }
+        case 'change-autolayout': {
+          const edit = changeViewLayout(this.services, {
+            ...lookup,
+            layout: change.layout
+          })
+          edits.push(edit)
+          ranges.push(edit.range)
+          break
+        }
+        default:
+          nonexhaustive(change)
+      }
+    }
+    return {
+      doc: lookup.doc,
+      ranges,
+      edits
+    }
+  }
+}

package/src/model-change/changeElementStyle.ts

@@ -0,0 +1,176 @@
+import { type Fqn, invariant, isAncestor, type NonEmptyArray, nonNullable } from '@likec4/core'
+import { GrammarUtils } from 'langium'
+import { entries, filter, findLast, isNumber, last, partition, toPairs } from 'remeda'
+import { type Range, TextEdit } from 'vscode-languageserver-protocol'
+import { ast, type ParsedAstElementView, type ParsedAstView, type ParsedLikeC4LangiumDocument } from '../ast'
+import type { FqnIndex } from '../model'
+import type { LikeC4Services } from '../module'
+import type { ChangeView } from '../protocol'
+
+const { findNodeForKeyword, findNodeForProperty } = GrammarUtils
+
+const asViewStyleRule = (target: string, style: ChangeView.ChangeElementStyle['style'], indent = 0) => {
+  const indentStr = indent > 0 ? ' '.repeat(indent) : ''
+  return [
+    indentStr + `style ${target} {`,
+    ...entries.strict(style).map(([key, value]) =>
+      indentStr + `  ${key} ${key === 'opacity' ? value.toString() + '%' : value}`
+    ),
+    indentStr + `}`
+  ]
+}
+
+type ChangeElementStyleArg = {
+  view: ParsedAstView
+  doc: ParsedLikeC4LangiumDocument
+  viewAst: ast.LikeC4View
+  targets: NonEmptyArray<Fqn>
+  style: ChangeView.ChangeElementStyle['style']
+}
+
+/**
+ * - is ViewRuleStyle
+ * - has exactly one target
+ * - the target is an ElementRef to the given fqn
+ */
+const isMatchingViewRule =
+  (fqn: string, index: FqnIndex) => (rule: ast.ViewRule | ast.DynamicViewRule): rule is ast.ViewRuleStyle => {
+    if (!ast.isViewRuleStyle(rule)) {
+      return false
+    }
+    const [target, ...rest] = rule.targets
+    if (!target || rest.length > 0 || !ast.isElementRef(target)) {
+      return false
+    }
+    const ref = target.el.ref
+    const _fqn = ref ? index.getFqn(ref) : null
+    return _fqn === fqn
+  }
+
+export function changeElementStyle(services: LikeC4Services, {
+  view,
+  viewAst,
+  targets,
+  style
+}: ChangeElementStyleArg): {
+  modifiedRange: Range
+  edits: TextEdit[]
+} {
+  const viewCstNode = viewAst.$cstNode
+  invariant(viewCstNode, 'viewCstNode')
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end
+    ?? viewAst.body.$cstNode?.range.end
+  invariant(insertPos, 'insertPos is not defined')
+  const indent = viewCstNode.range.start.character + 2
+  const fqnIndex = services.likec4.FqnIndex
+  const styleRules = filter(viewAst.body.rules, ast.isViewRuleStyle)
+  const viewOf = view.__ === 'element' ? view.viewOf : null
+  // Find existing rules
+  const existing = [] as Array<{ fqn: Fqn; rule: ast.ViewRuleStyle }>
+  const insert = [] as Array<{ fqn: Fqn }>
+  // const existingRules = [] as Array<{ fqn: Fqn, rule: ast.ViewRuleStyle }>
+  targets.forEach(target => {
+    const rule = findLast(styleRules, isMatchingViewRule(target, fqnIndex))
+    // remove viewOf from the target to shorten the fqn
+    const fqn = (viewOf && isAncestor(viewOf, target) ? target.substring(viewOf.length + 1) : target) as Fqn
+    if (rule) {
+      existing.push({ fqn, rule })
+    } else {
+      insert.push({ fqn })
+    }
+  })
+
+  const modifiedRange = {
+    start: insertPos,
+    end: insertPos
+  }
+
+  const includeRange = (range: Range) => {
+    if (range.start.line <= modifiedRange.start.line) {
+      if (range.start.line == modifiedRange.start.line) {
+        modifiedRange.start.character = Math.min(range.start.character, modifiedRange.start.character)
+      } else {
+        modifiedRange.start = range.start
+      }
+    }
+    if (range.end.line >= modifiedRange.end.line) {
+      if (range.end.line == modifiedRange.end.line) {
+        modifiedRange.end.character = Math.max(range.end.character, modifiedRange.end.character)
+      } else {
+        modifiedRange.end = range.end
+      }
+    }
+  }
+
+  const edits = [] as TextEdit[]
+
+  if (insert.length > 0) {
+    const linesToInsert = insert.flatMap(({ fqn }) => asViewStyleRule(fqn, style, indent))
+    edits.push(
+      TextEdit.insert(
+        insertPos,
+        '\n' + linesToInsert.join('\n')
+      )
+    )
+    modifiedRange.start = {
+      line: insertPos.line + 1,
+      character: indent + 1
+    }
+    modifiedRange.end = {
+      line: insertPos.line + linesToInsert.length,
+      character: (last(linesToInsert)?.length ?? 0)
+    }
+  }
+
+  if (existing.length > 0) {
+    for (const { rule } of existing) {
+      const ruleCstNode = rule.$cstNode
+      invariant(ruleCstNode, 'RuleCstNode not found')
+      for (const [key, _value] of entries.strict(style)) {
+        const value = key === 'opacity' ? _value.toString() + '%' : _value
+        const ruleProp = rule.styleprops.find(p => p.key === key)
+        // replace existing  property
+        if (ruleProp && ruleProp.$cstNode) {
+          const { range: { start, end } } = nonNullable(
+            findNodeForProperty(ruleProp.$cstNode, 'value'),
+            'cant find value cst node'
+          )
+          includeRange({
+            start,
+            end: {
+              line: start.line,
+              character: start.character + value.length
+            }
+          })
+          edits.push(TextEdit.replace({ start, end }, value))
+          continue
+        }
+        // insert new style property right after the opening brace
+        const insertPos = findNodeForKeyword(ruleCstNode, '{')?.range.end
+        invariant(insertPos, 'Opening brace not found')
+        const indentStr = ' '.repeat(2 + ruleCstNode.range.start.character)
+        const insertKeyValue = indentStr + key + ' ' + value
+        edits.push(
+          TextEdit.insert(
+            insertPos,
+            '\n' + insertKeyValue
+          )
+        )
+        includeRange({
+          start: {
+            line: insertPos.line + 1,
+            character: indentStr.length
+          },
+          end: {
+            line: insertPos.line + 1,
+            character: insertKeyValue.length
+          }
+        })
+      }
+    }
+  }
+  return {
+    modifiedRange,
+    edits
+  }
+}

package/src/model-change/changeViewLayout.ts

@@ -0,0 +1,41 @@
+import { type AutoLayoutDirection, invariant } from '@likec4/core'
+import { GrammarUtils } from 'langium'
+import { last } from 'remeda'
+import { TextEdit } from 'vscode-languageserver-protocol'
+import { ast, type ParsedAstView, type ParsedLikeC4LangiumDocument, toAstViewLayoutDirection } from '../ast'
+import type { LikeC4Services } from '../module'
+
+const { findNodeForProperty } = GrammarUtils
+
+type ChangeViewLayoutArg = {
+  view: ParsedAstView
+  doc: ParsedLikeC4LangiumDocument
+  viewAst: ast.LikeC4View
+  layout: AutoLayoutDirection
+}
+
+export function changeViewLayout(_services: LikeC4Services, {
+  viewAst,
+  layout
+}: ChangeViewLayoutArg): TextEdit {
+  const viewCstNode = viewAst.$cstNode
+  invariant(viewCstNode, 'viewCstNode')
+  const newlayout = toAstViewLayoutDirection(layout)
+  const existingRule = viewAst.body.rules.findLast(ast.isViewRuleAutoLayout) as ast.ViewRuleAutoLayout | undefined
+
+  if (existingRule && existingRule.$cstNode) {
+    const directionCstNode = findNodeForProperty(existingRule.$cstNode, 'direction')
+    if (directionCstNode) {
+      return TextEdit.replace(directionCstNode.range, newlayout)
+    }
+    return TextEdit.replace(existingRule.$cstNode.range, `autoLayout ${newlayout}`)
+  }
+
+  const insertPos = last(viewAst.body.rules)?.$cstNode?.range.end
+    ?? viewAst.body.$cstNode?.range.end
+  invariant(insertPos, 'insertPos is not defined')
+  const indent = ' '.repeat(2 + viewCstNode.range.start.character)
+  const insert = `\n\n${indent}autoLayout ${newlayout}`
+
+  return TextEdit.insert(insertPos, insert)
+}

package/src/module.ts

@@ -0,0 +1,197 @@
+import { normalizeError } from '@likec4/core'
+import { EmptyFileSystem, inject, type Module, WorkspaceCache } from 'langium'
+import {
+  createDefaultModule,
+  createDefaultSharedModule,
+  type DefaultSharedModuleContext,
+  type LangiumServices,
+  type LangiumSharedServices,
+  type PartialLangiumServices,
+  type PartialLangiumSharedServices
+} from 'langium/lsp'
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module'
+import { logger } from './logger'
+import {
+  LikeC4CodeLensProvider,
+  LikeC4DocumentHighlightProvider,
+  LikeC4DocumentLinkProvider,
+  LikeC4DocumentSymbolProvider,
+  LikeC4HoverProvider,
+  LikeC4SemanticTokenProvider
+} from './lsp'
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model'
+import { LikeC4ModelChanges } from './model-change/ModelChanges'
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references'
+import { Rpc } from './Rpc'
+import { LikeC4WorkspaceManager, NodeKindProvider, WorkspaceSymbolProvider } from './shared'
+import { registerValidationChecks } from './validation'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T
+
+interface LikeC4AddedSharedServices {
+  lsp: {
+    NodeKindProvider: NodeKindProvider
+    WorkspaceSymbolProvider: WorkspaceSymbolProvider
+  }
+  workspace: {
+    WorkspaceManager: LikeC4WorkspaceManager
+  }
+}
+
+export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices
+
+const LikeC4SharedModule: Module<
+  LikeC4SharedServices,
+  PartialLangiumSharedServices & LikeC4AddedSharedServices
+> = {
+  lsp: {
+    NodeKindProvider: services => new NodeKindProvider(services),
+    WorkspaceSymbolProvider: services => new WorkspaceSymbolProvider(services)
+  },
+  workspace: {
+    WorkspaceManager: services => new LikeC4WorkspaceManager(services)
+  }
+}
+
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export interface LikeC4AddedServices {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  WorkspaceCache: WorkspaceCache<string, any>
+  Rpc: Rpc
+  likec4: {
+    FqnIndex: FqnIndex
+    ModelParser: LikeC4ModelParser
+    ModelBuilder: LikeC4ModelBuilder
+    ModelLocator: LikeC4ModelLocator
+    ModelChanges: LikeC4ModelChanges
+  }
+  lsp: {
+    DocumentHighlightProvider: LikeC4DocumentHighlightProvider
+    DocumentSymbolProvider: LikeC4DocumentSymbolProvider
+    SemanticTokenProvider: LikeC4SemanticTokenProvider
+    HoverProvider: LikeC4HoverProvider
+    CodeLensProvider: LikeC4CodeLensProvider
+    DocumentLinkProvider: LikeC4DocumentLinkProvider
+  }
+  references: {
+    ScopeComputation: LikeC4ScopeComputation
+    ScopeProvider: LikeC4ScopeProvider
+  }
+  shared?: LikeC4SharedServices
+}
+
+export type LikeC4Services = LangiumServices & LikeC4AddedServices
+
+function bind<T>(Type: Constructor<T, [LikeC4Services]>) {
+  return (services: LikeC4Services) => new Type(services)
+}
+
+export const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices> = {
+  WorkspaceCache: (services: LikeC4Services) => new WorkspaceCache(services.shared),
+  Rpc: bind(Rpc),
+  likec4: {
+    ModelChanges: bind(LikeC4ModelChanges),
+    FqnIndex: bind(FqnIndex),
+    ModelParser: bind(LikeC4ModelParser),
+    ModelBuilder: bind(LikeC4ModelBuilder),
+    ModelLocator: bind(LikeC4ModelLocator)
+  },
+  lsp: {
+    DocumentHighlightProvider: bind(LikeC4DocumentHighlightProvider),
+    DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
+    SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
+    HoverProvider: bind(LikeC4HoverProvider),
+    CodeLensProvider: bind(LikeC4CodeLensProvider),
+    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
+  },
+  references: {
+    ScopeComputation: bind(LikeC4ScopeComputation),
+    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>,
+  module2?: Module<I, I2>,
+  module3?: Module<I, I3>
+): { shared: LikeC4SharedServices; likec4: I } {
+  const shared = createSharedServices(context)
+  const modules = [
+    createDefaultModule({ shared }),
+    LikeC4GeneratedModule,
+    LikeC4Module,
+    module,
+    module2,
+    module3
+  ].reduce(_merge, {}) as Module<I>
+
+  const likec4 = inject(modules)
+  shared.ServiceRegistry.register(likec4)
+  registerValidationChecks(likec4)
+  likec4.Rpc.init()
+  return { shared, likec4 }
+}
+
+export function createSharedServices(context: LanguageServicesContext = {}): LikeC4SharedServices {
+  const connection = context.connection
+  if (connection) {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const original = logger.error.bind(logger)
+    logger.error = (arg: unknown) => {
+      if (typeof arg === 'string') {
+        original(arg)
+        connection.telemetry.logEvent({ eventName: 'error', error: arg })
+        return
+      }
+      const error = normalizeError(arg)
+      original(error)
+      connection.telemetry.logEvent({ eventName: 'error', error: error.stack ?? error.message })
+    }
+  }
+
+  const moduleContext: DefaultSharedModuleContext = {
+    ...EmptyFileSystem,
+    ...context
+  }
+
+  return inject(
+    createDefaultSharedModule(moduleContext),
+    LikeC4GeneratedSharedModule,
+    LikeC4SharedModule
+  )
+}
+
+export function createLanguageServices(context: LanguageServicesContext = {}): {
+  shared: LikeC4SharedServices
+  likec4: LikeC4Services
+} {
+  const shared = createSharedServices(context)
+  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module)
+  shared.ServiceRegistry.register(likec4)
+  registerValidationChecks(likec4)
+  likec4.Rpc.init()
+  return { shared, likec4 }
+}
+
+// Copied from langium/src/dependency-injection.ts as it is not exported
+function _merge(target: Module<any>, source?: Module<any>): Module<unknown> {
+  if (source) {
+    for (const [key, value2] of Object.entries(source)) {
+      if (value2 !== undefined) {
+        const value1 = target[key]
+        if (value1 !== null && value2 !== null && typeof value1 === 'object' && typeof value2 === 'object') {
+          target[key] = _merge(value1, value2)
+        } else {
+          target[key] = value2
+        }
+      }
+    }
+  }
+  return target
+}

package/src/node/index.ts

@@ -0,0 +1,20 @@
+import { startLanguageServer as startLanguim } from 'langium/lsp'
+import { NodeFileSystem } from 'langium/node'
+import { createConnection, ProposedFeatures } from 'vscode-languageserver/node'
+import { createLanguageServices } from '../module'
+
+export function startLanguageServer() {
+  /* browser specific setup code */
+  const connection = createConnection(ProposedFeatures.all)
+
+  // Inject the shared services and language-specific services
+  const services = createLanguageServices({ connection, ...NodeFileSystem })
+
+  // Start the language server with the shared services
+  startLanguim(services.shared)
+
+  return {
+    ...services,
+    connection
+  }
+}

package/src/protocol.ts

@@ -0,0 +1,87 @@
+import type {
+  AutoLayoutDirection,
+  BorderStyle,
+  ComputedView,
+  ElementShape,
+  Fqn,
+  LikeC4ComputedModel,
+  LikeC4Model,
+  NonEmptyArray,
+  RelationID,
+  ThemeColor,
+  ViewID
+} from '@likec4/core'
+import type { DocumentUri, Location } from 'vscode-languageserver-protocol'
+import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol'
+
+// #region From server
+export const onDidChangeModel = new NotificationType<string>('likec4/onDidChangeModel')
+export type OnDidChangeModelNotification = typeof onDidChangeModel
+// #endregion
+
+// #region To server
+export const fetchModel = new RequestType0<{ model: LikeC4Model | null }, void>(
+  'likec4/fetchModel'
+)
+export type FetchModelRequest = typeof fetchModel
+
+export const fetchComputedModel = new RequestType0<{ model: LikeC4ComputedModel | null }, void>(
+  'likec4/fetchComputedModel'
+)
+export type FetchComputedModelRequest = typeof fetchComputedModel
+
+export const computeView = new RequestType<{ viewId: ViewID }, { view: ComputedView | null }, void>(
+  'likec4/computeView'
+)
+export type ComputeViewRequest = typeof computeView
+
+export interface BuildDocumentsParams {
+  docs: DocumentUri[]
+}
+export const buildDocuments = new RequestType<BuildDocumentsParams, void, void>('likec4/build')
+export type BuildDocumentsRequest = typeof buildDocuments
+
+export type LocateParams =
+  | {
+    element: Fqn
+    property?: string
+  }
+  | {
+    relation: RelationID
+  }
+  | {
+    view: ViewID
+  }
+export const locate = new RequestType<LocateParams, Location | null, void>('likec4/locate')
+export type LocateRequest = typeof locate
+// #endregion
+
+export namespace ChangeView {
+
+  export interface ChangeAutoLayout {
+    op: 'change-autolayout'
+    layout: AutoLayoutDirection
+  }
+
+  export interface ChangeElementStyle {
+    op: 'change-element-style'
+    style: {
+      border?: BorderStyle
+      opacity?: number
+      shape?: ElementShape
+      color?: ThemeColor
+    }
+    targets: NonEmptyArray<Fqn>
+  }
+}
+
+export type ChangeView =
+  | ChangeView.ChangeAutoLayout
+  | ChangeView.ChangeElementStyle
+
+export interface ChangeViewRequestParams {
+  viewId: ViewID
+  changes: NonEmptyArray<ChangeView>
+}
+export const changeView = new RequestType<ChangeViewRequestParams, Location | null, void>('likec4/change-view')
+export type ChangeViewRequest = typeof changeView

package/src/references/index.ts

@@ -0,0 +1,2 @@
+export * from './scope-computation'
+export * from './scope-provider'