@likec4/language-server 1.2.2 → 1.4.0

package/src/model-graph/compute-view/predicates.ts

@@ -0,0 +1,404 @@
+import type { Element } from '@likec4/core'
+import { Expr, invariant, nonexhaustive, parentFqn } from '@likec4/core'
+import type { Predicate } from 'rambdax'
+import { isNullish as isNil } from 'remeda'
+import type { ComputeCtx } from './compute'
+
+export function includeElementRef(this: ComputeCtx, expr: Expr.ElementRefExpr) {
+  // Get the elements that are already in the Ctx before any mutations
+  // Because we need to add edges between them and the new elements
+  const currentElements = [...this.resolvedElements]
+
+  const elements = expr.isDescedants === true
+    ? this.graph.childrenOrElement(expr.element)
+    : [this.graph.element(expr.element)]
+
+  this.addElement(...elements)
+
+  if (elements.length > 1) {
+    this.addEdges(this.graph.edgesWithin(elements))
+  }
+
+  if (currentElements.length > 0 && elements.length > 0) {
+    for (const el of elements) {
+      this.addEdges(this.graph.anyEdgesBetween(el, currentElements))
+    }
+  }
+}
+
+export function excludeElementRef(this: ComputeCtx, expr: Expr.ElementRefExpr) {
+  const elements = expr.isDescedants === true
+    ? this.graph.children(expr.element)
+    : [this.graph.element(expr.element)]
+  this.excludeElement(...elements)
+}
+
+export function includeExpandedElementExpr(this: ComputeCtx, expr: Expr.ExpandedElementExpr) {
+  const currentElements = [...this.resolvedElements]
+
+  // Always add parent
+  const parent = this.graph.element(expr.expanded)
+  this.addElement(parent)
+  const anyEdgesBetween = this.graph.anyEdgesBetween(parent, currentElements)
+
+  this.addEdges(anyEdgesBetween)
+
+  const expanded = [] as Element[]
+
+  for (const el of this.graph.children(expr.expanded)) {
+    this.addImplicit(el)
+    if (anyEdgesBetween.length > 0) {
+      const edges = this.graph.anyEdgesBetween(el, currentElements)
+      if (edges.length > 0) {
+        this.addEdges(edges)
+        expanded.push(el)
+      }
+    }
+  }
+  if (expanded.length > 1) {
+    this.addEdges(this.graph.edgesWithin(expanded))
+  }
+}
+
+export function includeWildcardRef(this: ComputeCtx, _expr: Expr.WildcardExpr) {
+  const root = this.root
+  if (root) {
+    const currentElements = [...this.resolvedElements]
+    const _elRoot = this.graph.element(root)
+    this.addElement(_elRoot)
+
+    const children = this.graph.children(root)
+    const hasChildren = children.length > 0
+    if (hasChildren) {
+      this.addElement(...children)
+      this.addEdges(this.graph.edgesWithin(children))
+    } else {
+      children.push(_elRoot)
+    }
+
+    // All neighbours that may have relations with root or its children
+    const neighbours = [
+      ...currentElements,
+      ...this.graph.siblings(root),
+      ...this.graph.ancestors(root).flatMap(a => this.graph.siblings(a.id))
+    ]
+
+    for (const el of children) {
+      this.addEdges(this.graph.anyEdgesBetween(el, neighbours))
+    }
+
+    // If root has no children
+    if (!hasChildren) {
+      // Any edges with siblings?
+      const edgesWithSiblings = this.graph.anyEdgesBetween(_elRoot, this.graph.siblings(root))
+      if (edgesWithSiblings.length === 0) {
+        // If no edges with siblings, i.e. root is orphan
+        // Lets add parent for better view
+        const _parentId = parentFqn(root)
+        const parent = _parentId && this.graph.element(_parentId)
+        if (parent) {
+          this.addElement(parent)
+        }
+      }
+    }
+  } else {
+    // Take root elements
+    this.addElement(...this.graph.rootElements)
+    this.addEdges(this.graph.edgesWithin(this.graph.rootElements))
+  }
+}
+
+export function excludeWildcardRef(this: ComputeCtx, _expr: Expr.WildcardExpr) {
+  const root = this.root
+  if (root) {
+    this.excludeElement(
+      this.graph.element(root),
+      ...this.graph.children(root)
+    )
+    this.excludeRelation(
+      ...this.graph.internal(root),
+      ...this.graph.incoming(root),
+      ...this.graph.outgoing(root)
+    )
+  } else {
+    this.reset()
+  }
+}
+
+const asElementPredicate = (
+  expr: Expr.ElementKindExpr | Expr.ElementTagExpr
+): Predicate<Element> => {
+  if (expr.isEqual) {
+    if (Expr.isElementKindExpr(expr)) {
+      return e => e.kind === expr.elementKind
+    } else {
+      return ({ tags }) => !!tags && tags.includes(expr.elementTag)
+    }
+  } else {
+    if (Expr.isElementKindExpr(expr)) {
+      return e => e.kind !== expr.elementKind
+    } else {
+      return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag)
+    }
+  }
+}
+export function includeElementKindOrTag(
+  this: ComputeCtx,
+  expr: Expr.ElementKindExpr | Expr.ElementTagExpr
+) {
+  const elements = this.graph.elements.filter(asElementPredicate(expr))
+  if (elements.length > 0) {
+    const currentElements = [...this.resolvedElements]
+    this.addElement(...elements)
+    this.addEdges(this.graph.edgesWithin(elements))
+    for (const el of elements) {
+      this.addEdges(this.graph.anyEdgesBetween(el, currentElements))
+    }
+  }
+}
+
+export function excludeElementKindOrTag(
+  this: ComputeCtx,
+  expr: Expr.ElementKindExpr | Expr.ElementTagExpr
+) {
+  const elements = this.graph.elements.filter(asElementPredicate(expr))
+  if (elements.length > 0) {
+    this.excludeElement(...elements)
+  }
+}
+
+function resolveNeighbours(this: ComputeCtx, expr: Expr.ElementExpression): Element[] {
+  if (Expr.isElementRef(expr)) {
+    return this.graph.ascendingSiblings(expr.element)
+  }
+  return this.root ? this.graph.ascendingSiblings(this.root) : this.graph.rootElements
+}
+
+function resolveElements(this: ComputeCtx, expr: Expr.ElementExpression): Element[] {
+  if (Expr.isWildcard(expr)) {
+    if (this.root) {
+      return [...this.graph.children(this.root), this.graph.element(this.root)]
+    } else {
+      return this.graph.rootElements
+    }
+  }
+  if (Expr.isElementKindExpr(expr)) {
+    return this.graph.elements.filter(el => {
+      if (expr.isEqual) {
+        return el.kind === expr.elementKind
+      }
+      return el.kind !== expr.elementKind
+    })
+  }
+  if (Expr.isElementTagExpr(expr)) {
+    return this.graph.elements.filter(el => {
+      const tags = el.tags
+      if (expr.isEqual) {
+        return !!tags && tags.includes(expr.elementTag)
+      }
+      return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag)
+    })
+  }
+  if (Expr.isExpandedElementExpr(expr)) {
+    return [this.graph.element(expr.expanded)]
+  }
+
+  // Type guard
+  if (!Expr.isElementRef(expr)) {
+    return nonexhaustive(expr)
+  }
+
+  if (this.root === expr.element && expr.isDescedants !== true) {
+    return [...this.graph.children(this.root), this.graph.element(this.root)]
+  }
+
+  if (expr.isDescedants) {
+    return this.graph.childrenOrElement(expr.element)
+  } else {
+    return [this.graph.element(expr.element)]
+  }
+}
+
+// --------------------------------
+//  Incoming Expr
+
+function edgesIncomingExpr(this: ComputeCtx, expr: Expr.ElementExpression) {
+  if (Expr.isWildcard(expr)) {
+    if (!this.root) {
+      return []
+    }
+    const sources = this.graph.ascendingSiblings(this.root)
+    const targets = [...this.graph.children(this.root), this.graph.element(this.root)]
+    return this.graph.edgesBetween(sources, targets)
+  }
+  const targets = resolveElements.call(this, expr)
+  if (targets.length === 0) {
+    return []
+  }
+  const currentElements = [...this.resolvedElements]
+  if (currentElements.length === 0) {
+    currentElements.push(...resolveNeighbours.call(this, expr))
+  }
+  return this.graph.edgesBetween(currentElements, targets)
+}
+
+export function includeIncomingExpr(this: ComputeCtx, expr: Expr.IncomingExpr) {
+  const edges = edgesIncomingExpr.call(this, expr.incoming)
+  this.addEdges(edges)
+  this.addImplicit(...edges.map(e => e.target))
+}
+export function excludeIncomingExpr(this: ComputeCtx, expr: Expr.IncomingExpr) {
+  const edges = edgesIncomingExpr.call(this, expr.incoming)
+  this.excludeRelation(...edges.flatMap(e => e.relations))
+}
+
+// --------------------------------
+//  Outgoing Expr
+
+function edgesOutgoingExpr(this: ComputeCtx, expr: Expr.ElementExpression) {
+  if (Expr.isWildcard(expr)) {
+    if (!this.root) {
+      return []
+    }
+    const targets = this.graph.ascendingSiblings(this.root)
+    const sources = [...this.graph.children(this.root), this.graph.element(this.root)]
+    return this.graph.edgesBetween(sources, targets)
+  }
+  const sources = resolveElements.call(this, expr)
+  if (sources.length === 0) {
+    return []
+  }
+  const targets = [...this.resolvedElements]
+  if (targets.length === 0) {
+    targets.push(...resolveNeighbours.call(this, expr))
+  }
+  return this.graph.edgesBetween(sources, targets)
+}
+
+export function includeOutgoingExpr(this: ComputeCtx, expr: Expr.OutgoingExpr) {
+  const edges = edgesOutgoingExpr.call(this, expr.outgoing)
+  this.addEdges(edges)
+  this.addImplicit(...edges.map(e => e.source))
+}
+export function excludeOutgoingExpr(this: ComputeCtx, expr: Expr.OutgoingExpr) {
+  const edges = edgesOutgoingExpr.call(this, expr.outgoing)
+  this.excludeRelation(...edges.flatMap(e => e.relations))
+}
+
+// --------------------------------
+//  InOut Expr
+type EdgePredicateResult = {
+  implicits: Element[]
+  edges: ComputeCtx.Edge[]
+}
+
+namespace EdgePredicateResult {
+  export const Empty: EdgePredicateResult = {
+    implicits: [],
+    edges: []
+  }
+}
+function edgesInOutExpr(this: ComputeCtx, expr: Expr.InOutExpr): EdgePredicateResult {
+  if (Expr.isWildcard(expr.inout)) {
+    if (!this.root) {
+      return EdgePredicateResult.Empty
+    }
+    const neighbours = this.graph.ascendingSiblings(this.root)
+    return {
+      edges: this.graph.anyEdgesBetween(this.graph.element(this.root), neighbours),
+      implicits: []
+    }
+  }
+  const elements = resolveElements.call(this, expr.inout)
+  if (elements.length === 0) {
+    return EdgePredicateResult.Empty
+  }
+  const currentElements = [...this.resolvedElements]
+  if (currentElements.length === 0) {
+    currentElements.push(...resolveNeighbours.call(this, expr.inout))
+  }
+  return elements.reduce<EdgePredicateResult>((acc, el) => {
+    const edges = this.graph.anyEdgesBetween(el, currentElements)
+    if (edges.length > 0) {
+      acc.implicits.push(el)
+      acc.edges.push(...edges)
+    }
+    return acc
+  }, { implicits: [], edges: [] })
+}
+
+export function includeInOutExpr(this: ComputeCtx, expr: Expr.InOutExpr) {
+  const { implicits, edges } = edgesInOutExpr.call(this, expr)
+  this.addEdges(edges)
+  this.addImplicit(...implicits)
+}
+export function excludeInOutExpr(this: ComputeCtx, expr: Expr.InOutExpr) {
+  const { edges } = edgesInOutExpr.call(this, expr)
+  this.excludeRelation(...edges.flatMap(e => e.relations))
+}
+
+/**
+ * Expand element to its children and itself, if it is the root (and not ".*")
+ * Example:
+ *
+ *   view of api {
+ *     include some -> api
+ *   }
+ *
+ * Transform to:
+ *
+ *   view of api {
+ *     include  some -> api.*, some -> api
+ *   }
+ */
+function resolveRelationExprElements(this: ComputeCtx, expr: Expr.ElementExpression) {
+  if (Expr.isElementRef(expr) && this.root === expr.element && expr.isDescedants !== true) {
+    return [...this.graph.children(expr.element), this.graph.element(expr.element)]
+  }
+  return resolveElements.call(this, expr)
+}
+
+export function includeRelationExpr(this: ComputeCtx, expr: Expr.RelationExpr) {
+  let sources, targets
+  if (Expr.isWildcard(expr.source) && !Expr.isWildcard(expr.target)) {
+    sources = resolveNeighbours.call(this, expr.target)
+    targets = resolveRelationExprElements.call(this, expr.target)
+  } else if (!Expr.isWildcard(expr.source) && Expr.isWildcard(expr.target)) {
+    sources = resolveRelationExprElements.call(this, expr.source)
+    targets = resolveNeighbours.call(this, expr.source)
+  } else {
+    sources = resolveRelationExprElements.call(this, expr.source)
+    targets = resolveRelationExprElements.call(this, expr.target)
+  }
+  const edges = this.graph.edgesBetween(sources, targets)
+  if (expr.isBidirectional === true) {
+    edges.push(...this.graph.edgesBetween(targets, sources))
+  }
+  this.addEdges(edges)
+}
+
+export function excludeRelationExpr(this: ComputeCtx, expr: Expr.RelationExpr) {
+  const sources = resolveRelationExprElements.call(this, expr.source)
+  const targets = resolveRelationExprElements.call(this, expr.target)
+  const edges = this.graph.edgesBetween(sources, targets)
+  if (expr.isBidirectional === true) {
+    edges.push(...this.graph.edgesBetween(targets, sources))
+  }
+
+  const relations = new Set(edges.flatMap(e => e.relations))
+  this.excludeRelation(...relations)
+}
+
+export function includeCustomElement(this: ComputeCtx, expr: Expr.CustomElementExpr) {
+  // Get the elements that are already in the Ctx before any mutations
+  // Because we need to add edges between them and the new elements
+  const currentElements = [...this.resolvedElements]
+
+  const el = this.graph.element(expr.custom.element)
+
+  this.addElement(el)
+
+  if (currentElements.length > 0) {
+    this.addEdges(this.graph.anyEdgesBetween(el, currentElements))
+  }
+}

package/src/model-graph/dynamic-view/__test__/fixture.ts

@@ -0,0 +1,56 @@
+import type { DynamicViewRule, DynamicViewStep, Fqn, ViewID, ViewRuleExpression } from '@likec4/core'
+import { partition } from 'remeda'
+import { type FakeElementIds, fakeModel } from '../../compute-view/__test__/fixture'
+import { computeDynamicView } from '../index'
+
+const emptyView = {
+  __: 'dynamic' as const,
+  id: 'index' as ViewID,
+  title: null,
+  description: null,
+  tags: null,
+  links: null,
+  rules: []
+}
+
+type StepExpr = `${FakeElementIds} ${'->' | '<-'} ${FakeElementIds}`
+
+export function $step(expr: StepExpr, title?: string): DynamicViewStep {
+  if (expr.includes(' -> ')) {
+    const [source, target] = expr.split(' -> ')
+    return {
+      source: source as Fqn,
+      target: target as Fqn,
+      title: title ?? null
+    }
+  }
+  if (expr.includes(' <- ')) {
+    const [target, source] = expr.split(' <- ')
+    return {
+      source: source as Fqn,
+      target: target as Fqn,
+      title: title ?? null,
+      isBackward: true
+    }
+  }
+  throw new Error(`Invalid step expression: ${expr}`)
+}
+
+export function compute(stepsAndRules: (DynamicViewStep | ViewRuleExpression)[]) {
+  const [steps, rules] = partition(stepsAndRules, (s): s is DynamicViewStep => 'source' in s)
+  const result = computeDynamicView(
+    {
+      ...emptyView,
+      steps,
+      rules: rules as DynamicViewRule[]
+    },
+    fakeModel
+  )
+  if (!result.isSuccess) {
+    throw result.error
+  }
+  return Object.assign(result.view, {
+    nodeIds: result.view.nodes.map((node) => node.id) as string[],
+    edgeIds: result.view.edges.map((edge) => edge.id) as string[]
+  })
+}

package/src/model-graph/dynamic-view/compute.ts

@@ -0,0 +1,198 @@
+import type { ComputedDynamicView, ComputedEdge, DynamicView, EdgeId, Element, RelationID } from '@likec4/core'
+import {
+  ancestorsFqn,
+  commonAncestor,
+  DefaultArrowType,
+  DefaultLineStyle,
+  DefaultRelationshipColor,
+  invariant,
+  isCustomElement,
+  isDynamicViewIncludeRule,
+  isElementRef,
+  isExpandedElementExpr,
+  isViewRuleAutoLayout,
+  nonNullable,
+  parentFqn,
+  StepEdgeId
+} from '@likec4/core'
+import { isTruthy, unique } from 'remeda'
+import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
+import { applyElementCustomProperties } from '../utils/applyElementCustomProperties'
+import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
+import { buildComputeNodes } from '../utils/buildComputeNodes'
+
+export namespace DynamicViewComputeCtx {
+  export interface Step {
+    source: Element
+    target: Element
+    title: string | null
+    relations: RelationID[]
+    isBackward: boolean
+  }
+}
+
+export class DynamicViewComputeCtx {
+  // Intermediate state
+  private explicits = new Set<Element>()
+  private steps = [] as DynamicViewComputeCtx.Step[]
+
+  public static compute(view: DynamicView, graph: LikeC4ModelGraph): ComputedDynamicView {
+    return new DynamicViewComputeCtx(view, graph).compute()
+  }
+
+  private constructor(
+    protected view: DynamicView,
+    protected graph: LikeC4ModelGraph
+  ) {}
+
+  protected compute(): ComputedDynamicView {
+    // reset ctx
+    const { rules, steps, ...view } = this.view
+
+    // const sources = new Set<Element>()
+    // const stepsStack = new Set<string>()
+
+    // const sourcesOf = new Map<Fqn, Set<Element>>()
+
+    for (let step of steps) {
+      const source = this.graph.element(step.source)
+      const target = this.graph.element(step.target)
+
+      this.explicits.add(source)
+      this.explicits.add(target)
+
+      const { title, relations } = this.findRelations(source, target)
+
+      this.steps.push({
+        source,
+        target,
+        title: step.title ?? title,
+        relations,
+        isBackward: step.isBackward ?? false
+      })
+    }
+
+    for (const rule of rules) {
+      if (isDynamicViewIncludeRule(rule)) {
+        for (const expr of rule.include) {
+          if (isElementRef(expr)) {
+            this.explicits.add(this.graph.element(expr.element))
+            continue
+          }
+          if (isExpandedElementExpr(expr)) {
+            this.explicits.add(this.graph.element(expr.expanded))
+            continue
+          }
+          if (isCustomElement(expr)) {
+            this.explicits.add(this.graph.element(expr.custom.element))
+            continue
+          }
+          console.warn('Unsupported include expression: ', expr)
+        }
+      }
+    }
+
+    const elements = [...this.explicits]
+    const nodesMap = buildComputeNodes(elements)
+
+    const edges = this.steps.map(({ source, target, relations, ...step }, index) => {
+      const sourceNode = nodesMap.get(source.id)
+      const targetNode = nodesMap.get(target.id)
+      invariant(sourceNode, `Source node ${source.id} not found`)
+      invariant(targetNode, `Target node ${target.id} not found`)
+      const stepNum = index + 1
+      const edge: ComputedEdge = {
+        id: StepEdgeId(stepNum),
+        parent: commonAncestor(source.id, target.id),
+        source: source.id,
+        target: target.id,
+        label: step.title,
+        relations,
+        color: DefaultRelationshipColor,
+        line: DefaultLineStyle,
+        head: DefaultArrowType
+      }
+      if (step.isBackward) {
+        edge.dir = 'back'
+      }
+
+      while (edge.parent && !nodesMap.has(edge.parent)) {
+        edge.parent = parentFqn(edge.parent)
+      }
+      sourceNode.outEdges.push(edge.id)
+      targetNode.inEdges.push(edge.id)
+      // Process edge source ancestors
+      for (const sourceAncestor of ancestorsFqn(edge.source)) {
+        if (sourceAncestor === edge.parent) {
+          break
+        }
+        nodesMap.get(sourceAncestor)?.outEdges.push(edge.id)
+      }
+      // Process target hierarchy
+      for (const targetAncestor of ancestorsFqn(edge.target)) {
+        if (targetAncestor === edge.parent) {
+          break
+        }
+        nodesMap.get(targetAncestor)?.inEdges.push(edge.id)
+      }
+      return edge
+    })
+
+    const nodes = applyElementCustomProperties(
+      rules,
+      applyViewRuleStyles(
+        rules,
+        // Keep order of elements
+        elements.map(e => nonNullable(nodesMap.get(e.id)))
+      )
+    )
+
+    const autoLayoutRule = rules.findLast(isViewRuleAutoLayout)
+
+    return {
+      ...view,
+      autoLayout: autoLayoutRule?.autoLayout ?? 'LR',
+      nodes,
+      edges
+    }
+  }
+
+  private findRelations(source: Element, target: Element): {
+    title: string | null
+    relations: RelationID[]
+  } {
+    const relationships = this.graph.edgesBetween(source, target).flatMap(e => e.relations)
+    const relations = unique(relationships.map(r => r.id))
+    if (relationships.length === 0) {
+      return { title: null, relations }
+    }
+    let relation
+    if (relationships.length === 1) {
+      relation = relationships[0]
+    } else {
+      relation = relationships.find(r => r.source === source.id && r.target === target.id)
+    }
+
+    if (relation && isTruthy(relation.title)) {
+      return {
+        title: relation.title,
+        relations
+      }
+    }
+
+    // This edge represents mutliple relations
+    // We use label if only it is the same for all relations
+    const labels = unique(relationships.flatMap(r => (isTruthy(r.title) ? r.title : [])))
+    if (labels.length === 1) {
+      return {
+        title: labels[0]!,
+        relations
+      }
+    }
+
+    return {
+      title: null,
+      relations
+    }
+  }
+}

package/src/model-graph/dynamic-view/index.ts

@@ -0,0 +1,29 @@
+import { type ComputedDynamicView, type DynamicView } from '@likec4/core'
+import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
+import { DynamicViewComputeCtx } from './compute'
+
+type ComputeViewResult =
+  | {
+    isSuccess: true
+    view: ComputedDynamicView
+  }
+  | {
+    isSuccess: false
+    error: Error
+    view: undefined
+  }
+
+export function computeDynamicView(view: DynamicView, graph: LikeC4ModelGraph): ComputeViewResult {
+  try {
+    return {
+      isSuccess: true,
+      view: DynamicViewComputeCtx.compute(view, graph)
+    }
+  } catch (e) {
+    return {
+      isSuccess: false,
+      error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
+      view: undefined
+    }
+  }
+}

package/src/model-graph/index.ts

@@ -0,0 +1,3 @@
+export * from './compute-view'
+export * from './dynamic-view'
+export * from './LikeC4ModelGraph'