@likec4/core 1.41.0 → 1.42.1

package/src/compute-view/deployment-view/compute.ts

@@ -1,94 +0,0 @@
-import { findLast, map } from 'remeda'
-import { type DeploymentConnectionModel, type LikeC4DeploymentModel, LikeC4Model } from '../../model'
-import type { AnyAux, DeploymentViewRule } from '../../types'
-import {
-  type ComputedDeploymentView,
-  type ParsedDeploymentView as DeploymentView,
-  _stage,
-  _type,
-  isViewRuleAutoLayout,
-  isViewRulePredicate,
-} from '../../types'
-import { buildElementNotations } from '../utils/buildElementNotations'
-import { linkNodesWithEdges } from '../utils/link-nodes-with-edges'
-import { topologicalSort } from '../utils/topological-sort'
-import { calcViewLayoutHash } from '../utils/view-hash'
-import { Memory } from './memory'
-import { predicateToPatch } from './predicates'
-import { StageFinal } from './stages/stage-final'
-import { applyDeploymentViewRuleStyles, buildNodes, toComputedEdges } from './utils'
-
-export function processPredicates(
-  model: LikeC4DeploymentModel<any>,
-  rules: DeploymentViewRule<any>[],
-) {
-  let memory = Memory.empty()
-
-  for (const rule of rules) {
-    if (isViewRulePredicate(rule)) {
-      const op = 'include' in rule ? 'include' : 'exclude'
-      const exprs = rule.include ?? rule.exclude
-      for (const expr of exprs) {
-        let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
-        const ctx = { expr, model, stage, memory, where: null }
-        stage = predicateToPatch(op, ctx) ?? stage
-        memory = stage.commit()
-      }
-    }
-  }
-  return StageFinal.for(memory).commit()
-}
-
-export function computeDeploymentView<M extends AnyAux>(
-  likec4model: LikeC4Model<M>,
-  {
-    docUri: _docUri, // exclude docUri
-    rules, // exclude rules
-    ...view
-  }: DeploymentView<NoInfer<M>>,
-): ComputedDeploymentView<M> {
-  const memory = processPredicates(likec4model.deployment, rules)
-
-  const nodesMap = buildNodes<M>(memory)
-
-  const computedEdges = toComputedEdges(memory.connections as unknown as DeploymentConnectionModel<M>[])
-
-  linkNodesWithEdges(nodesMap, computedEdges)
-
-  const sorted = topologicalSort({
-    nodes: nodesMap,
-    edges: computedEdges,
-  })
-
-  const nodes = applyDeploymentViewRuleStyles(
-    rules,
-    sorted.nodes,
-  )
-
-  const autoLayoutRule = findLast(rules, isViewRuleAutoLayout)
-
-  const elementNotations = buildElementNotations(nodes)
-
-  return calcViewLayoutHash({
-    ...view,
-    [_stage]: 'computed',
-    [_type]: 'deployment',
-    autoLayout: {
-      direction: autoLayoutRule?.direction ?? 'TB',
-      ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
-      ...(autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }),
-    },
-    edges: sorted.edges,
-    nodes: map(nodes, n => {
-      if (n.icon === 'none') {
-        delete n.icon
-      }
-      return n
-    }),
-    ...(elementNotations.length > 0 && {
-      notation: {
-        nodes: elementNotations,
-      },
-    }),
-  })
-}

package/src/compute-view/deployment-view/memory/index.ts

@@ -1,9 +0,0 @@
-import type { StageExclude } from '../stages/stage-exclude'
-import type { StageInclude } from '../stages/stage-include'
-
-export { StageExclude } from '../stages/stage-exclude'
-export { StageInclude } from '../stages/stage-include'
-export { Memory } from './memory'
-export type { Ctx } from './memory'
-
-export type Stage = StageInclude | StageExclude

package/src/compute-view/deployment-view/memory/memory.ts

@@ -1,96 +0,0 @@
-import { isDeepEqual } from 'remeda'
-import type { DeploymentElementModel } from '../../../model'
-import { type DeploymentConnectionModel, differenceConnections } from '../../../model'
-import type { AnyAux, Expression } from '../../../types'
-import { difference as differenceSet } from '../../../utils'
-import { customInspectSymbol } from '../../../utils/const'
-import { toArray } from '../../../utils/iterable'
-import { type ComputeCtx, type StageExpression, AbstractMemory } from '../../memory'
-import { StageExclude } from '../stages/stage-exclude'
-import { StageInclude } from '../stages/stage-include'
-
-export type Ctx = ComputeCtx<
-  DeploymentElementModel<AnyAux>,
-  DeploymentConnectionModel<AnyAux>,
-  Memory,
-  StageInclude,
-  StageExclude,
-  Expression<AnyAux>
->
-
-export class Memory extends AbstractMemory<Ctx> {
-  static empty(): Memory {
-    return new Memory({
-      elements: new Set(),
-      explicits: new Set(),
-      final: new Set(),
-      connections: [],
-    })
-  }
-
-  override stageInclude(expr: StageExpression<Ctx>): StageInclude {
-    return new StageInclude(this, expr)
-  }
-  override stageExclude(expr: StageExpression<Ctx>): StageExclude {
-    return new StageExclude(this, expr)
-  }
-
-  override mutableState(): Ctx['MutableState'] {
-    return ({
-      elements: new Set(this.state.elements),
-      explicits: new Set(this.state.explicits),
-      final: new Set(this.state.final),
-      connections: [...this.state.connections],
-    })
-  }
-
-  override update(newstate: Partial<Ctx['MutableState']>): Memory {
-    return new Memory({
-      ...this.state,
-      ...newstate,
-    })
-  }
-
-  equals(other: unknown): boolean {
-    return other instanceof Memory && isDeepEqual(this.state, other.state)
-  }
-
-  diff(state: Memory) {
-    const current = this
-    return {
-      added: {
-        elements: toArray(differenceSet(state.elements, current.elements)),
-        explicits: toArray(differenceSet(state.explicits, current.explicits)),
-        final: toArray(differenceSet(state.final, current.final)),
-        connections: toArray(differenceConnections(state.connections, current.connections)),
-      },
-      removed: {
-        elements: toArray(differenceSet(current.elements, state.elements)),
-        explicits: toArray(differenceSet(current.explicits, state.explicits)),
-        final: toArray(differenceSet(current.final, state.final)),
-        connections: differenceConnections(current.connections, state.connections),
-      },
-    }
-  }
-
-  public override toString(): string {
-    return [
-      'final:',
-      ...[...this.final].map(e => '  ' + e.id),
-      'connections:',
-      ...this.connections.map(c => '  ' + c.expression),
-    ].join('\n')
-  }
-
-  [customInspectSymbol](_depth: unknown, _inspectOptions: unknown, _inspect: unknown) {
-    const asString = this.toString()
-
-    // // Trick so that node displays the name of the constructor
-    // Object.defineProperty(asString, 'constructor', {
-    //   value: this.constructor,
-    //   enumerable: false,
-    // })
-
-    return asString
-  }
-}

package/src/compute-view/deployment-view/predicates/deploymentRefs-where.ts

@@ -1,18 +0,0 @@
-import { type FqnExpr, type RelationExpr, whereOperatorAsPredicate } from '../../../types'
-import type { PredicateExecutor } from '../_types'
-import type { StageExclude, StageInclude } from '../memory'
-import { predicateToPatch } from './utils'
-
-// relation matches the condition
-export const WhereDeploymentRefPredicate: PredicateExecutor<FqnExpr.Where> = {
-  include: ({ expr, model, memory, stage }) => {
-    const where = whereOperatorAsPredicate(expr.where.condition)
-
-    return predicateToPatch('include', { expr: expr.where.expr, model, stage, memory, where }) as StageInclude
-  },
-  exclude: ({ expr, model, memory, stage }) => {
-    const where = whereOperatorAsPredicate(expr.where.condition)
-
-    return predicateToPatch('exclude', { expr: expr.where.expr, model, stage, memory, where }) as StageExclude
-  },
-}

package/src/compute-view/deployment-view/predicates/deploymentRefs.ts

@@ -1,154 +0,0 @@
-import { filter, forEach, pipe, reduce } from 'remeda'
-import type { DeploymentElementModel, DeploymentNodeModel } from '../../../model'
-import { isDeployedInstanceModel as isDeployedInstance } from '../../../model'
-import type { FqnExpr } from '../../../types'
-import type { Elem, IncludePredicateCtx, PredicateExecutor } from '../_types'
-import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
-import type { StageInclude } from '../memory'
-import { deploymentExpressionToPredicate, findConnectionsBetween, findConnectionsWithin } from '../utils'
-import { applyElementPredicate } from './utils'
-
-export const DeploymentRefPredicate: PredicateExecutor<FqnExpr.DeploymentRef> = {
-  include: (ctx) => {
-    const { expr, where } = ctx
-    const el = ctx.model.element(expr.ref.deployment)
-
-    if (isDeployedInstance(el)) {
-      if (applyElementPredicate(el, where)) {
-        ctx.stage.addExplicit(el)
-        ctx.stage.connectWithExisting(el)
-      }
-      return ctx.stage
-    }
-
-    switch (true) {
-      case expr.selector === 'expanded':
-        includeDeployedNodeWithExpanded(el, ctx)
-        break
-      case expr.selector === 'children':
-        includeDeployedNodeChildren(el, ctx)
-        break
-      case expr.selector === 'descendants':
-        includeDeployedNodeDescendants(el, ctx)
-        break
-      default: {
-        if (applyElementPredicate(el, where)) {
-          ctx.stage.addExplicit(el)
-          ctx.stage.connectWithExisting(el)
-        }
-      }
-    }
-    return ctx.stage
-  },
-
-  exclude: ({ expr, stage, memory, where }) => {
-    const exprPredicate = deploymentExpressionToPredicate(expr)
-    const toExclude = pipe(
-      [...memory.elements],
-      filter(exprPredicate),
-      applyElementPredicate(where),
-    )
-    stage.exclude(toExclude)
-    return stage
-  },
-}
-
-/**
- * include node.*
- */
-function includeDeployedNodeChildren(
-  node: DeploymentNodeModel,
-  { stage, where }: IncludePredicateCtx,
-) {
-  const children = applyElementPredicate([...node.children()], where)
-  if (children.length === 0) {
-    return
-  }
-  stage.addImplicit(node)
-
-  stage.addConnections(findConnectionsWithin(children))
-  stage.connectWithExisting(children)
-
-  stage.addExplicit(children)
-}
-
-/**
- * include node._
- */
-function includeDeployedNodeWithExpanded(
-  node: DeploymentNodeModel,
-  { memory, stage, where }: IncludePredicateCtx,
-) {
-  stage.addImplicit(node)
-  stage.connectWithExisting(node)
-
-  const children = applyElementPredicate([...node.children()], where)
-  let hasConnectionsWithVisible = false
-  for (const child of children) {
-    if (findConnectionsBetween(child, memory.elements).length > 0) {
-      hasConnectionsWithVisible = true
-      break
-    }
-  }
-
-  if (hasConnectionsWithVisible) {
-    stage.connectWithExisting(children, 'in')
-    stage.addConnections(findConnectionsWithin(children))
-    stage.connectWithExisting(children, 'out')
-  }
-  stage.addImplicit(children)
-
-  if (stage.connections.length > 0) {
-    stage.addExplicit(node)
-  }
-}
-
-/**
- * include node.**
- */
-function includeDeployedNodeDescendants(
-  node: DeploymentNodeModel,
-  { stage, where }: IncludePredicateCtx,
-) {
-  const dfs = (node: DeploymentNodeModel): DeploymentElementModel[] => {
-    const children = [] as DeploymentElementModel[]
-    for (const child of node.children()) {
-      if (child.isDeploymentNode()) {
-        children.push(...dfs(child))
-      }
-      if (applyElementPredicate(child, where)) {
-        children.push(child)
-      }
-    }
-    stage.connectWithExisting(children, 'in')
-    stage.addConnections(findConnectionsWithin(children))
-    stage.addImplicit(children)
-    return children
-  }
-
-  const descendants = dfs(node)
-  if (descendants.length === 0) {
-    return
-  }
-  stage.connectWithExisting(descendants, 'out')
-
-  const allConnected = findConnectedElements(stage)
-  pipe(
-    descendants,
-    filter(desc => allConnected.has(desc)),
-    forEach(desc => stage.addExplicit(desc)),
-  )
-}
-
-function findConnectedElements(stage: StageInclude) {
-  return pipe(
-    stage.mergedConnections(),
-    cleanCrossBoundary,
-    cleanRedundantRelationships,
-    reduce((acc, c) => {
-      acc.add(c.source)
-      acc.add(c.target)
-      return acc
-    }, new Set<Elem>()),
-  )
-}

package/src/compute-view/deployment-view/predicates/index.ts

@@ -1,8 +0,0 @@
-export * from './deploymentRefs'
-export * from './relation-direct'
-export * from './relation-in-out'
-export * from './relation-incoming'
-export * from './relation-outgoing'
-export * from './relation-where'
-export * from './utils'
-export * from './wildcard'

package/src/compute-view/deployment-view/predicates/relation-direct.ts

@@ -1,243 +0,0 @@
-import { filter, flatMap, isNonNullish, map, pipe } from 'remeda'
-import type {
-  DeploymentConnectionModel,
-  DeploymentElementModel,
-  LikeC4DeploymentModel,
-  RelationshipModel,
-} from '../../../model'
-import {
-  type ConnectionModel,
-  findConnectionsBetween as findModelConnectionsBetween,
-} from '../../../model/connection/model'
-import type { AnyAux } from '../../../types'
-import { type RelationExpr, FqnExpr } from '../../../types'
-import { invariant } from '../../../utils'
-import type { PredicateExecutor } from '../_types'
-import {
-  deploymentExpressionToPredicate,
-  findConnection,
-  findConnectionsBetween,
-  findConnectionsWithin,
-  resolveElements,
-  resolveModelElements,
-} from '../utils'
-import { filterIncomingConnections, resolveAllImcomingRelations } from './relation-incoming'
-import { filterOutgoingConnections, resolveAllOutgoingRelations } from './relation-outgoing'
-import { applyPredicate, excludeModelRelations } from './utils'
-
-export const resolveAscendingSiblings = (element: DeploymentElementModel) => {
-  const siblings = new Set<DeploymentElementModel>()
-  for (let sibling of element.descendingSiblings()) {
-    // TODO: investigate if this is necessary
-    // if (element.isInstance() && sibling.isDeploymentNode()) {
-    //   // we flatten nodes that contain only one instance
-    //   sibling = sibling.onlyOneInstance() ?? sibling
-    // }
-    siblings.add(sibling)
-  }
-  return siblings
-}
-
-const resolveWildcard = (model: LikeC4DeploymentModel<AnyAux>, nonWildcard: FqnExpr.DeploymentRef) => {
-  const sources = resolveElements(model, nonWildcard)
-  return sources.map(source => {
-    const targets = resolveAscendingSiblings(source)
-    return [source, targets] as const
-  })
-}
-
-export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
-  include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
-    if (FqnExpr.isElementTagExpr(source) || FqnExpr.isElementKindExpr(source)) {
-      throw new Error('element kind and tag expressions are not supported in include')
-    }
-    if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) {
-      throw new Error('element kind and tag expressions are not supported in include')
-    }
-    invariant(!FqnExpr.isModelRef(source), 'Invalid source model ref in direct relation')
-    invariant(!FqnExpr.isModelRef(target), 'Invalid target model ref in direct relation')
-    const sourceIsWildcard = FqnExpr.isWildcard(source)
-    const targetIsWildcard = FqnExpr.isWildcard(target)
-
-    const dir = isBidirectional ? 'both' : 'directed'
-
-    let connections
-
-    switch (true) {
-      // * -> *
-      case sourceIsWildcard && targetIsWildcard: {
-        connections = pipe(
-          findConnectionsWithin(model.instances()),
-          applyPredicate(where),
-          map(c => {
-            stage.addImplicit(c.boundary)
-            return c
-          }),
-        )
-        break
-      }
-
-      // source -> *; source <-> *
-      case !sourceIsWildcard && targetIsWildcard: {
-        const sources = resolveElements(model, source)
-        const isSource = filterOutgoingConnections(sources)
-
-        let postFilter = isSource
-        if (isBidirectional) {
-          const isTarget = filterIncomingConnections(sources)
-          postFilter = c => isSource(c) !== isTarget(c)
-        }
-
-        connections = pipe(
-          sources,
-          flatMap(source => {
-            const targets = resolveAscendingSiblings(source)
-            return findConnectionsBetween(source, targets, dir)
-          }),
-          filter(postFilter),
-          applyPredicate(where),
-        )
-        break
-      }
-      // * -> target; * <-> target
-      case sourceIsWildcard && !targetIsWildcard: {
-        const targets = resolveElements(model, target)
-        const isTarget = filterIncomingConnections(targets)
-
-        let postFilter = isTarget
-        if (isBidirectional) {
-          const isSource = filterOutgoingConnections(targets)
-          postFilter = c => isSource(c) !== isTarget(c)
-        }
-
-        connections = pipe(
-          targets,
-          flatMap(target => {
-            const sources = resolveAscendingSiblings(target)
-            return [...sources].flatMap(source => findConnection(source, target, dir))
-          }),
-          filter(postFilter),
-          applyPredicate(where),
-        )
-        break
-      }
-      default: {
-        invariant(!sourceIsWildcard, 'Inferrence failed - source should be a deployment ref')
-        invariant(!targetIsWildcard, 'Inferrence failed - target should be a deployment ref')
-        const sources = resolveElements(model, source)
-        const targets = resolveElements(model, target)
-
-        const isSource = filterOutgoingConnections(sources)
-        const isTarget = filterIncomingConnections(targets)
-
-        connections = pipe(
-          sources,
-          flatMap(s => findConnectionsBetween(s, targets, dir)),
-          filter(c => isSource(c) && isTarget(c)),
-          applyPredicate(where),
-        )
-      }
-    }
-
-    stage.addConnections(connections)
-
-    if (FqnExpr.isDeploymentRef(source) && isNonNullish(source.selector)) {
-      stage.addImplicit(model.element(source.ref.deployment))
-    }
-    if (FqnExpr.isDeploymentRef(target) && isNonNullish(target.selector)) {
-      stage.addImplicit(model.element(target.ref.deployment))
-    }
-
-    return stage
-  },
-  exclude: ({ expr, model, memory, stage, where }) => {
-    const isTarget = deploymentExpressionToPredicate(expr.target)
-    const isSource = deploymentExpressionToPredicate(expr.source)
-
-    let modelRelationsToExclude: ReadonlySet<RelationshipModel<AnyAux>>
-    switch (true) {
-      // * -> *
-      case FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target):
-        stage.excludeConnections(applyPredicate(memory.connections, where))
-        return stage
-
-      // model -> model
-      case FqnExpr.isModelRef(expr.source) && FqnExpr.isModelRef(expr.target):
-        modelRelationsToExclude = resolveRelationsBetweenModelElements({
-          source: expr.source,
-          target: expr.target,
-          expr,
-          model,
-        })
-        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where)
-
-      // model -> *
-      case FqnExpr.isModelRef(expr.source) && FqnExpr.isWildcard(expr.target):
-        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source)
-        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where)
-
-      // model -> deployment
-      case FqnExpr.isModelRef(expr.source):
-        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source)
-        return excludeModelRelations(
-          modelRelationsToExclude,
-          { stage, memory },
-          where,
-          c => isTarget(c.target),
-        )
-
-      // deployment -> model
-      case FqnExpr.isModelRef(expr.target):
-        modelRelationsToExclude = resolveAllImcomingRelations(model, expr.target)
-        return excludeModelRelations(
-          modelRelationsToExclude,
-          { stage, memory },
-          where,
-          c => isSource(c.source),
-        )
-
-      // deployment -> deployment
-      default:
-        const satisfies = (connection: DeploymentConnectionModel) => {
-          return (isSource(connection.source) && isTarget(connection.target))
-            || (expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source))
-        }
-
-        const deploymentRelationsToExclude = pipe(
-          memory.connections,
-          filter(satisfies),
-          applyPredicate(where),
-        )
-        if (deploymentRelationsToExclude.length === 0) {
-          return stage
-        }
-
-        stage.excludeConnections(deploymentRelationsToExclude)
-        return stage
-    }
-  },
-}
-
-function resolveRelationsBetweenModelElements<A extends AnyAux>({
-  source,
-  target,
-  expr,
-  model,
-}: {
-  source: FqnExpr.ModelRef<A>
-  target: FqnExpr.ModelRef<A>
-  expr: RelationExpr.Direct<A>
-  model: LikeC4DeploymentModel<A>
-}) {
-  const sources = resolveModelElements(model, source)
-  const targets = resolveModelElements(model, target)
-
-  const dir = expr.isBidirectional ? 'both' : 'directed'
-
-  const modelConnections = [] as ConnectionModel<A>[]
-  for (const source of sources) {
-    modelConnections.push(...findModelConnectionsBetween(source, targets, dir))
-  }
-
-  return new Set(modelConnections.flatMap(c => [...c.relations]))
-}

package/src/compute-view/deployment-view/predicates/relation-in-out.ts

@@ -1,70 +0,0 @@
-import { filter, pipe } from 'remeda'
-import type { RelationshipModel } from '../../../model'
-import { type RelationExpr, FqnExpr } from '../../../types'
-import { invariant } from '../../../utils'
-import { union } from '../../../utils/set'
-import type { PredicateExecutor } from '../_types'
-import { findConnectionsBetween, resolveElements, resolveModelElements } from '../utils'
-import { resolveAscendingSiblings } from './relation-direct'
-import { filterIncomingConnections } from './relation-incoming'
-import { filterOutgoingConnections } from './relation-outgoing'
-import { applyPredicate, excludeModelRelations, matchConnections } from './utils'
-
-//
-export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
-  include: ({ expr, model, memory, stage, where }) => {
-    const sources = [...memory.elements]
-
-    if (FqnExpr.isWildcard(expr.inout)) {
-      for (const source of sources) {
-        const targets = [...resolveAscendingSiblings(source)]
-        const toInclude = matchConnections(findConnectionsBetween(source, targets, 'both'), where)
-        stage.addConnections(toInclude)
-      }
-      return stage
-    }
-    invariant(FqnExpr.isDeploymentRef(expr.inout), 'Only deployment refs are supported in include')
-
-    const targets = resolveElements(model, expr.inout)
-    for (const source of sources) {
-      const toInclude = matchConnections(findConnectionsBetween(source, targets, 'both'), where)
-      stage.addConnections(toInclude)
-    }
-
-    return stage
-  },
-  exclude: ({ expr, model, memory, stage, where }) => {
-    if (FqnExpr.isElementTagExpr(expr.inout) || FqnExpr.isElementKindExpr(expr.inout)) {
-      throw new Error('element kind and tag expressions are not supported in exclude')
-    }
-    // Exclude all connections that have model relationshps with the elements
-    if (FqnExpr.isModelRef(expr.inout)) {
-      const elements = resolveModelElements(model, expr.inout)
-      if (elements.length === 0) {
-        return stage
-      }
-      const excludedRelations = union(
-        new Set<RelationshipModel>(),
-        ...elements.flatMap(e => [e.allIncoming, e.allOutgoing]),
-      )
-      return excludeModelRelations(excludedRelations, { stage, memory }, where)
-    }
-
-    if (FqnExpr.isWildcard(expr.inout)) {
-      // non-sense
-      return stage
-    }
-
-    const elements = resolveElements(model, expr.inout)
-    const isIncoming = filterIncomingConnections(elements)
-    const isOutgoing = filterOutgoingConnections(elements)
-
-    const toExclude = pipe(
-      memory.connections,
-      filter(c => isIncoming(c) !== isOutgoing(c)),
-      applyPredicate(where),
-    )
-    stage.excludeConnections(toExclude)
-    return stage
-  },
-}