@likec4/language-server 1.2.0 → 1.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -9,6 +9,7 @@
   "files": [
     "dist",
     "contrib",
+    "src",
     "!**/__mocks__/",
     "!**/__tests__/",
     "!**/*.spec.*",
@@ -61,21 +62,18 @@
     }
   },
   "scripts": {
-    "typecheck": "tsc -b",
+    "typecheck": "tsc --noEmit",
     "watch:langium": "langium generate --watch",
     "watch:ts": "tsc --watch",
     "generate": "langium generate",
-    "prepack": "unbuild",
-    "build:turbo": "run -T turbo build --filter='language-server'",
-    "build": "unbuild",
     "dev": "run-p 'watch:*'",
     "lint": "run -T eslint src/ --fix",
     "clean": "run -T rimraf dist contrib",
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "1.2.0",
-    "@likec4/graph": "1.2.0",
+    "@likec4/core": "1.2.1",
+    "@likec4/graph": "1.2.1",
     "@total-typescript/ts-reset": "^0.5.1",
     "fast-equals": "^5.0.1",
     "langium": "^3.0.0",
@@ -92,15 +90,15 @@
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
-    "@types/node": "^20.13.0",
+    "@likec4/tsconfig": "1.2.1",
+    "@types/node": "^20.14.2",
     "@types/object-hash": "^3.0.6",
     "@types/string-hash": "^1",
     "execa": "^9.1.0",
     "langium-cli": "3.0.3",
     "npm-run-all2": "^6.1.2",
     "typescript": "^5.4.5",
-    "unbuild": "^2.0.0",
-    "vitest": "~1.5.2"
+    "vitest": "~1.5.3"
   },
   "packageManager": "yarn@4.3.0"
 }

package/src/Rpc.ts

@@ -0,0 +1,108 @@
+import { debounce } from 'remeda'
+import { logError, logger } from './logger'
+import type { LikeC4Services } from './module'
+
+import { nonexhaustive } from '@likec4/core'
+import { Disposable, URI, UriUtils } from 'langium'
+import { isLikeC4LangiumDocument } from './ast'
+import {
+  buildDocuments,
+  changeView,
+  computeView,
+  fetchComputedModel,
+  fetchModel,
+  locate,
+  onDidChangeModel
+} from './protocol'
+
+export class Rpc implements Disposable {
+  private disposables = [] as Array<Disposable>
+
+  constructor(private services: LikeC4Services) {}
+
+  init() {
+    const modelBuilder = this.services.likec4.ModelBuilder
+    const modelLocator = this.services.likec4.ModelLocator
+    const modelEditor = this.services.likec4.ModelChanges
+    const connection = this.services.shared.lsp.Connection
+    if (!connection) {
+      logger.warn(`[ServerRpc] no connection, not initializing`)
+      return
+    }
+    logger.info(`[ServerRpc] init`)
+    const LangiumDocuments = this.services.shared.workspace.LangiumDocuments
+    const DocumentBuilder = this.services.shared.workspace.DocumentBuilder
+
+    const notifyModelParsed = debounce(
+      () =>
+        void connection.sendNotification(onDidChangeModel, '').catch(e => {
+          logger.error(`[ServerRpc] error sending onDidChangeModel: ${e}`)
+          return Promise.resolve()
+        }),
+      {
+        timing: 'both',
+        waitMs: 350,
+        maxWaitMs: 1000
+      }
+    )
+
+    this.disposables.push(
+      Disposable.create(() => {
+        notifyModelParsed.cancel()
+      }),
+      modelBuilder.onModelParsed(() => notifyModelParsed.call()),
+      connection.onRequest(fetchComputedModel, async cancelToken => {
+        const model = await modelBuilder.buildComputedModel(cancelToken)
+        return { model }
+      }),
+      connection.onRequest(fetchModel, async cancelToken => {
+        const model = await modelBuilder.buildModel(cancelToken)
+        return { model }
+      }),
+      connection.onRequest(computeView, async ({ viewId }, cancelToken) => {
+        const view = await modelBuilder.computeView(viewId, cancelToken)
+        return { view }
+      }),
+      connection.onRequest(buildDocuments, async ({ docs }, cancelToken) => {
+        const changed = docs.map(d => URI.parse(d))
+        const notChanged = (uri: URI) => changed.every(c => !UriUtils.equals(c, uri))
+        const deleted = LangiumDocuments.all
+          .filter(d => isLikeC4LangiumDocument(d) && notChanged(d.uri))
+          .map(d => d.uri)
+          .toArray()
+        logger.debug(
+          `[ServerRpc] received request to build:
+  changed (total ${changed.length}):${docs.map(d => '\n    - ' + d).join('')}
+  deleted (total ${deleted.length}):${deleted.map(d => '\n    - ' + d.toString()).join('\n')}`
+        )
+        await DocumentBuilder.update(changed, deleted, cancelToken)
+      }),
+      connection.onRequest(locate, params => {
+        if ('element' in params) {
+          return modelLocator.locateElement(params.element, params.property ?? 'name')
+        }
+        if ('relation' in params) {
+          return modelLocator.locateRelation(params.relation)
+        }
+        if ('view' in params) {
+          return modelLocator.locateView(params.view)
+        }
+        nonexhaustive(params)
+      }),
+      connection.onRequest(changeView, async (request, _cancelToken) => {
+        return await modelEditor.applyChange(request)
+      })
+    )
+  }
+
+  dispose() {
+    let item
+    while (item = this.disposables.pop()) {
+      try {
+        item.dispose()
+      } catch (e) {
+        logError(e)
+      }
+    }
+  }
+}

package/src/ast.ts

@@ -0,0 +1,443 @@
+import {
+  type c4,
+  DefaultArrowType,
+  DefaultLineStyle,
+  DefaultRelationshipColor,
+  nonexhaustive,
+  RelationRefError
+} from '@likec4/core'
+import type { AstNode, DiagnosticInfo, LangiumDocument, MultiMap } from 'langium'
+import { AstUtils, DocumentState } from 'langium'
+import { clamp, isNullish } from 'remeda'
+import type { ConditionalPick, SetRequired, ValueOf } from 'type-fest'
+import type { Diagnostic } from 'vscode-languageserver-protocol'
+import { DiagnosticSeverity } from 'vscode-languageserver-protocol'
+import { elementRef } from './elementRef'
+import type { LikeC4Grammar } from './generated/ast'
+import * as ast from './generated/ast'
+import { LikeC4LanguageMetaData } from './generated/module'
+
+export { ast }
+
+const idattr = Symbol.for('idattr')
+
+declare module './generated/ast' {
+  export interface Element {
+    [idattr]?: c4.Fqn | undefined
+  }
+  export interface ElementView {
+    [idattr]?: c4.ViewID | undefined
+  }
+  export interface DynamicView {
+    [idattr]?: c4.ViewID | undefined
+  }
+}
+
+type ParsedElementStyle = {
+  shape?: c4.ElementShape
+  icon?: c4.IconUrl
+  color?: c4.ThemeColor
+  border?: c4.BorderStyle
+  opacity?: number
+}
+
+export interface ParsedAstSpecification {
+  kinds: Record<c4.ElementKind, ParsedElementStyle>
+  relationships: Record<
+    c4.RelationshipKind,
+    {
+      color?: c4.ThemeColor
+      line?: c4.RelationshipLineType
+      head?: c4.RelationshipArrowType
+      tail?: c4.RelationshipArrowType
+    }
+  >
+}
+
+export interface ParsedAstElement {
+  id: c4.Fqn
+  astPath: string
+  kind: c4.ElementKind
+  title: string
+  description?: string
+  technology?: string
+  tags?: c4.NonEmptyArray<c4.Tag>
+  links?: c4.NonEmptyArray<string>
+  style: ParsedElementStyle
+}
+
+export interface ParsedAstRelation {
+  id: c4.RelationID
+  astPath: string
+  source: c4.Fqn
+  target: c4.Fqn
+  kind?: c4.RelationshipKind
+  tags?: c4.NonEmptyArray<c4.Tag>
+  title: string
+  color?: c4.ThemeColor
+  line?: c4.RelationshipLineType
+  head?: c4.RelationshipArrowType
+  tail?: c4.RelationshipArrowType
+  links?: c4.NonEmptyArray<string>
+}
+
+export interface ParsedAstElementView {
+  __: 'element'
+  id: c4.ViewID
+  viewOf?: c4.Fqn
+  extends?: c4.ViewID
+  astPath: string
+  title: string | null
+  description: string | null
+  tags: c4.NonEmptyArray<c4.Tag> | null
+  links: c4.NonEmptyArray<string> | null
+  rules: c4.ViewRule[]
+}
+
+export interface ParsedAstDynamicView {
+  __: 'dynamic'
+  id: c4.ViewID
+  astPath: string
+  title: string | null
+  description: string | null
+  tags: c4.NonEmptyArray<c4.Tag> | null
+  links: c4.NonEmptyArray<string> | null
+  steps: c4.DynamicViewStep[]
+  rules: Array<c4.DynamicViewRule>
+}
+
+export type ParsedAstView = ParsedAstElementView | ParsedAstDynamicView
+export const ViewOps = {
+  writeId<T extends ast.LikeC4View>(node: T, id: c4.ViewID): T {
+    node[idattr] = id
+    return node
+  },
+  readId(node: ast.LikeC4View): c4.ViewID | undefined {
+    return node[idattr]
+  }
+}
+
+export const ElementOps = {
+  writeId(node: ast.Element, id: c4.Fqn | null) {
+    if (isNullish(id)) {
+      node[idattr] = undefined
+    } else {
+      node[idattr] = id
+    }
+    return node
+  },
+  readId(node: ast.Element) {
+    return node[idattr]
+  }
+}
+
+export interface DocFqnIndexEntry {
+  name: string
+  el: WeakRef<ast.Element>
+  path: string
+}
+
+// export type LikeC4AstNode = ast.LikeC4AstType[keyof ast.LikeC4AstType]
+export type LikeC4AstNode = ValueOf<ConditionalPick<ast.LikeC4AstType, AstNode>>
+type LikeC4DocumentDiagnostic = Diagnostic & DiagnosticInfo<LikeC4AstNode>
+
+export interface LikeC4DocumentProps {
+  diagnostics?: Array<LikeC4DocumentDiagnostic>
+  c4Specification?: ParsedAstSpecification
+  c4Elements?: ParsedAstElement[]
+  c4Relations?: ParsedAstRelation[]
+  c4Views?: ParsedAstView[]
+  // Fqn -> Element
+  c4fqns?: MultiMap<c4.Fqn, DocFqnIndexEntry>
+}
+
+export interface LikeC4LangiumDocument
+  extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, LikeC4DocumentProps
+{}
+export interface FqnIndexedDocument
+  extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, SetRequired<LikeC4DocumentProps, 'c4fqns'>
+{}
+
+// export type ParsedLikeC4LangiumDocument = SetRequired<FqnIndexedDocument, keyof  LikeC4DocumentProps>
+export interface ParsedLikeC4LangiumDocument
+  extends Omit<LangiumDocument<LikeC4Grammar>, 'diagnostics'>, Required<LikeC4DocumentProps>
+{}
+
+export function cleanParsedModel(doc: LikeC4LangiumDocument) {
+  const props: Required<Omit<LikeC4DocumentProps, 'c4fqns' | 'diagnostics'>> = {
+    c4Specification: {
+      kinds: {},
+      relationships: {}
+    },
+    c4Elements: [],
+    c4Relations: [],
+    c4Views: []
+  }
+  return Object.assign(doc, props) as ParsedLikeC4LangiumDocument
+}
+
+export function isFqnIndexedDocument(doc: LangiumDocument): doc is FqnIndexedDocument {
+  return isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !!doc.c4fqns
+}
+
+export function isLikeC4LangiumDocument(doc: LangiumDocument): doc is LikeC4LangiumDocument {
+  return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId
+}
+
+export function isParsedLikeC4LangiumDocument(
+  doc: LangiumDocument
+): doc is ParsedLikeC4LangiumDocument {
+  return (
+    isLikeC4LangiumDocument(doc)
+    && doc.state == DocumentState.Validated
+    && !!doc.c4Specification
+    && !!doc.c4Elements
+    && !!doc.c4Relations
+    && !!doc.c4Views
+    && !!doc.c4fqns
+  )
+}
+
+type Guard<N extends AstNode> = (n: AstNode) => n is N
+type Guarded<G> = G extends Guard<infer N> ? N : never
+
+function validatableAstNodeGuards<const Predicates extends Guard<AstNode>[]>(
+  predicates: Predicates
+) {
+  return (n: AstNode): n is Guarded<Predicates[number]> => predicates.some(p => p(n))
+}
+const isValidatableAstNode = validatableAstNodeGuards([
+  ast.isCustomElementExprBody,
+  ast.isViewRulePredicateExpr,
+  ast.isDynamicViewRulePredicate,
+  ast.isViewProperty,
+  ast.isStyleProperty,
+  ast.isTags,
+  ast.isViewRule,
+  ast.isDynamicViewRule,
+  ast.isDynamicViewStep,
+  ast.isElementViewBody,
+  ast.isDynamicViewBody,
+  ast.isLikeC4View,
+  ast.isRelationProperty,
+  ast.isRelationBody,
+  ast.isRelation,
+  ast.isElementProperty,
+  ast.isElementBody,
+  ast.isElement,
+  ast.isExtendElementBody,
+  ast.isExtendElement,
+  ast.isSpecificationElementKind,
+  ast.isSpecificationRelationshipKind,
+  ast.isSpecificationTag,
+  ast.isSpecificationRule,
+  ast.isModelViews,
+  ast.isModel
+])
+type ValidatableAstNode = Guarded<typeof isValidatableAstNode>
+
+export function checksFromDiagnostics(doc: LikeC4LangiumDocument) {
+  const errors = doc.diagnostics?.filter(d => d.severity === DiagnosticSeverity.Error) ?? []
+  const invalidNodes = new WeakSet(
+    errors.flatMap(d => {
+      return AstUtils.getContainerOfType(d.node, isValidatableAstNode) ?? []
+    }) ?? []
+  )
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const isValid = (n: ValidatableAstNode) => !invalidNodes.has(n)
+  return {
+    isValid,
+    invalidNodes
+  }
+}
+export type ChecksFromDiagnostics = ReturnType<typeof checksFromDiagnostics>
+
+export function* streamModel(doc: LikeC4LangiumDocument, isValid: ChecksFromDiagnostics['isValid']) {
+  const traverseStack = doc.parseResult.value.models.flatMap(m => (isValid(m) ? m.elements : []))
+  const relations = [] as ast.Relation[]
+  let el
+  while ((el = traverseStack.shift())) {
+    if (!isValid(el)) {
+      continue
+    }
+    if (ast.isRelation(el)) {
+      relations.push(el)
+      continue
+    }
+    if (ast.isExtendElement(el)) {
+      if (el.body && el.body.elements.length > 0) {
+        traverseStack.push(...el.body.elements)
+      }
+      continue
+    }
+    if (el.body && el.body.elements.length > 0) {
+      for (const nested of el.body.elements) {
+        if (ast.isRelation(nested)) {
+          relations.push(nested)
+        } else {
+          traverseStack.push(nested)
+        }
+      }
+    }
+    yield el
+  }
+  for (const relation of relations) {
+    yield relation
+  }
+}
+
+export function resolveRelationPoints(node: ast.Relation): {
+  source: ast.Element
+  target: ast.Element
+} {
+  const target = elementRef(node.target)
+  if (!target) {
+    throw new RelationRefError('Invalid reference to target')
+  }
+  if (ast.isExplicitRelation(node)) {
+    const source = elementRef(node.source)
+    if (!source) {
+      throw new RelationRefError('Invalid reference to source')
+    }
+    return {
+      source,
+      target
+    }
+  }
+  return {
+    source: node.$container.$container,
+    target
+  }
+}
+
+export function parseAstOpacityProperty({ value }: ast.OpacityProperty): number {
+  const opacity = parseFloat(value)
+  return isNaN(opacity) ? 100 : clamp(opacity, { min: 0, max: 100 })
+}
+
+export function toElementStyle(props?: Array<ast.StyleProperty>) {
+  const result = {} as ParsedElementStyle
+  if (!props || props.length === 0) {
+    return result
+  }
+  for (const prop of props) {
+    switch (true) {
+      case ast.isBorderProperty(prop): {
+        result.border = prop.value
+        break
+      }
+      case ast.isColorProperty(prop): {
+        result.color = prop.value
+        break
+      }
+      case ast.isShapeProperty(prop): {
+        result.shape = prop.value
+        break
+      }
+      case ast.isIconProperty(prop): {
+        result.icon = prop.value as c4.IconUrl
+        break
+      }
+      case ast.isOpacityProperty(prop): {
+        result.opacity = parseAstOpacityProperty(prop)
+        break
+      }
+      default:
+        // @ts-expect-error
+        nonexhaustive(prop.$type)
+    }
+  }
+  return result
+}
+
+export function toRelationshipStyle(props?: ast.SpecificationRelationshipKind['props']) {
+  const result = {} as {
+    color?: c4.ThemeColor
+    line?: c4.RelationshipLineType
+    head?: c4.RelationshipArrowType
+    tail?: c4.RelationshipArrowType
+  }
+  if (!props || props.length === 0) {
+    return result
+  }
+  for (const prop of props) {
+    if (ast.isColorProperty(prop)) {
+      result.color = prop.value
+      continue
+    }
+    if (ast.isLineProperty(prop)) {
+      result.line = prop.value
+      continue
+    }
+    if (ast.isArrowProperty(prop)) {
+      switch (prop.key) {
+        case 'head': {
+          result.head = prop.value
+          break
+        }
+        case 'tail': {
+          result.tail = prop.value
+          break
+        }
+        default: {
+          nonexhaustive(prop)
+        }
+      }
+      continue
+    }
+    nonexhaustive(prop)
+  }
+  return result
+}
+
+export function toRelationshipStyleExcludeDefaults(
+  props?: ast.SpecificationRelationshipKind['props']
+) {
+  const { color, line, head, tail } = toRelationshipStyle(props)
+  return {
+    ...(color && color !== DefaultRelationshipColor ? { color } : {}),
+    ...(line && line !== DefaultLineStyle ? { line } : {}),
+    ...(head && head !== DefaultArrowType ? { head } : {}),
+    ...(tail ? { tail } : {})
+  }
+}
+
+export function toAutoLayout(
+  direction: ast.ViewLayoutDirection
+): c4.ViewRuleAutoLayout['autoLayout'] {
+  switch (direction) {
+    case 'TopBottom': {
+      return 'TB'
+    }
+    case 'BottomTop': {
+      return 'BT'
+    }
+    case 'LeftRight': {
+      return 'LR'
+    }
+    case 'RightLeft': {
+      return 'RL'
+    }
+    default:
+      nonexhaustive(direction)
+  }
+}
+
+export function toAstViewLayoutDirection(c4: c4.ViewRuleAutoLayout['autoLayout']): ast.ViewLayoutDirection {
+  switch (c4) {
+    case 'TB': {
+      return 'TopBottom'
+    }
+    case 'BT': {
+      return 'BottomTop'
+    }
+    case 'LR': {
+      return 'LeftRight'
+    }
+    case 'RL': {
+      return 'RightLeft'
+    }
+    default:
+      nonexhaustive(c4)
+  }
+}

package/src/browser/index.ts

@@ -0,0 +1,30 @@
+import { startLanguageServer as startLanguim } from 'langium/lsp'
+import { BrowserMessageReader, BrowserMessageWriter, createConnection } from 'vscode-languageserver/browser'
+import { createLanguageServices } from '../module'
+
+// This is an example copied as is from here:
+// https://github.com/microsoft/vscode-extension-samples/blob/main/lsp-web-extension-sample/server/src/browserServerMain.ts
+// the only addition is the following line:
+declare const self: DedicatedWorkerGlobalScope
+
+export function startLanguageServer() {
+  /* browser specific setup code */
+
+  const messageReader = new BrowserMessageReader(self)
+  const messageWriter = new BrowserMessageWriter(self)
+
+  const connection = createConnection(messageReader, messageWriter)
+
+  // Inject the shared services and language-specific services
+  const services = createLanguageServices({ connection })
+
+  // Start the language server with the shared services
+  startLanguim(services.shared)
+
+  return {
+    ...services,
+    connection,
+    messageReader,
+    messageWriter
+  }
+}

package/src/elementRef.ts

@@ -0,0 +1,26 @@
+import { type c4 } from '@likec4/core'
+import type { ast } from './ast'
+/**
+ * Returns referenced AST Element
+ */
+export function elementRef(node: ast.ElementRef | ast.FqnElementRef) {
+  return node.el.ref
+}
+
+/**
+ * Returns FQN of FqnElementRef
+ * a.b.c.d - for c node returns a.b.c
+ */
+export function getFqnElementRef(node: ast.FqnElementRef): c4.Fqn {
+  // invariant(isElementRefHead(node), 'Expected head StrictElementRef')
+  const name = [node.el.$refText]
+  let parent = node.parent
+  while (parent) {
+    name.push(parent.el.$refText)
+    parent = parent.parent
+  }
+  if (name.length === 1) {
+    return name[0] as c4.Fqn
+  }
+  return name.reverse().join('.') as c4.Fqn
+}