@likec4/core 1.17.1 → 1.18.0

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

@@ -0,0 +1,146 @@
+import { hasAtLeast } from 'remeda'
+import { invariant } from '../../../errors'
+import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/deployment'
+import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
+import type { DeployedInstanceModel, DeploymentNodeModel } from '../../../model/DeploymentElementModel'
+import type { DeploymentElementExpression } from '../../../types'
+import type { PredicateCtx, PredicateExecutor } from '../_types'
+import { deploymentExpressionToPredicate } from '../utils'
+
+export const DeploymentRefPredicate: PredicateExecutor<DeploymentElementExpression.Ref> = {
+  include: (expr, ctx) => {
+    const el = ctx.model.element(expr.ref.id)
+
+    if (el.isInstance()) {
+      includeDeployedInstance(el, ctx)
+      return ctx.stage.patch()
+    }
+    invariant(el.isDeploymentNode(), 'Type inference failed')
+    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:
+        includeDeployedNode(el, ctx)
+        break
+    }
+    return ctx.stage.patch()
+  },
+
+  exclude: (expr, { stage, memory }) => {
+    const exprPredicate = deploymentExpressionToPredicate(expr)
+    stage.exclude([...memory.elements].filter(exprPredicate))
+    return stage.patch()
+  }
+}
+
+function includeDeployedInstance(
+  instance: DeployedInstanceModel,
+  { memory, stage }: PredicateCtx
+) {
+  stage.addExplicit(instance)
+  stage.addConnections(findConnectionsBetween(instance, memory.elements))
+}
+
+/**
+ * include node
+ */
+function includeDeployedNode(
+  node: DeploymentNodeModel,
+  { memory, stage }: PredicateCtx
+) {
+  stage.addExplicit(node)
+  stage.addConnections(findConnectionsBetween(node, memory.elements))
+}
+
+/**
+ * include node.*
+ */
+function includeDeployedNodeChildren(
+  node: DeploymentNodeModel,
+  { memory, stage }: PredicateCtx
+) {
+  const children = [...node.children()]
+  if (children.length === 0) {
+    return
+  }
+  stage.addExplicit(children)
+
+  if (hasAtLeast(children, 2)) {
+    stage.addConnections(findConnectionsWithin(children))
+  }
+  for (const child of children) {
+    stage.addConnections(findConnectionsBetween(child, memory.elements))
+  }
+}
+
+/**
+ * include node._
+ */
+function includeDeployedNodeWithExpanded(
+  node: DeploymentNodeModel,
+  { memory, stage }: PredicateCtx
+) {
+  const children = [...node.children()]
+  stage.addImplicit(node)
+
+  const connections = [] as DeploymentConnectionModel[]
+
+  for (const child of children) {
+    const found = findConnectionsBetween(child, memory.elements)
+    if (found.length > 0) {
+      // on first connection, add node as explicit
+      if (connections.length === 0) {
+        stage.addExplicit(node)
+      }
+      stage.addExplicit(child)
+      connections.push(...found)
+    }
+  }
+
+  if (connections.length > 0) {
+    // First connections inside
+    stage.addConnections([
+      ...findConnectionsWithin(children),
+      ...connections
+    ])
+  }
+
+  stage.addConnections(
+    findConnectionsBetween(node, memory.elements)
+  )
+}
+
+/**
+ * include node.**
+ */
+function includeDeployedNodeDescendants(
+  node: DeploymentNodeModel,
+  { memory, stage }: PredicateCtx
+) {
+  const descendants = [...node.descendants()]
+  if (descendants.length === 0) {
+    return
+  }
+  for (const child of descendants) {
+    if (child.isInstance()) {
+      stage.addExplicit(child)
+    } else {
+      stage.addImplicit(child)
+    }
+  }
+
+  if (hasAtLeast(descendants, 2)) {
+    stage.addConnections(findConnectionsWithin(descendants))
+  }
+
+  for (const child of descendants) {
+    stage.addConnections(findConnectionsBetween(child, memory.elements))
+  }
+}

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

@@ -0,0 +1,130 @@
+import { identity, isNonNullish } from 'remeda'
+import { invariant } from '../../../errors'
+import type { LikeC4DeploymentModel } from '../../../model'
+import { findConnectionsBetween } from '../../../model/connection/deployment'
+import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
+import { DeploymentElementModel } from '../../../model/DeploymentElementModel'
+import { DeploymentElementExpression, type DeploymentRelationExpression } from '../../../types/deployments'
+import { union } from '../../../utils/set'
+import type { PredicateExecutor } from '../_types'
+import { deploymentExpressionToPredicate, resolveElements } from '../utils'
+
+const isRef = DeploymentElementExpression.isRef
+
+export const resolveAscendingSiblings = (element: DeploymentElementModel) => {
+  const siblings = new Set<DeploymentElementModel>()
+  for (let sibling of element.ascendingSiblings()) {
+    if (element.isInstance() && sibling.isDeploymentNode()) {
+      // we flatten nodes that contain only one instance
+      sibling = sibling.onlyOneInstance() ?? sibling
+    }
+    siblings.add(sibling)
+  }
+  return siblings
+}
+
+const resolveIfWildcard = (model: LikeC4DeploymentModel, nonWildcard: DeploymentElementExpression.Ref) => {
+  const sources = resolveElements(model, nonWildcard)
+  const [head, ...rest] = sources.map(s => resolveAscendingSiblings(s))
+  if (head) {
+    let targets = rest.length > 0 ? union(head, ...rest) : head
+    return [sources, [...targets]] as const
+  }
+  return [sources, []] as const
+}
+
+export const DirectRelationPredicate: PredicateExecutor<DeploymentRelationExpression.Direct> = {
+  include: (expr, { model, stage }) => {
+    const sourceIsWildcard = DeploymentElementExpression.isWildcard(expr.source)
+    const targetIsWildcard = DeploymentElementExpression.isWildcard(expr.target)
+
+    let sources, targets
+
+    switch (true) {
+      case sourceIsWildcard && targetIsWildcard: {
+        sources = [...model.instances()]
+        targets = sources.slice()
+        break
+      }
+      case targetIsWildcard && isRef(expr.source): {
+        const [
+          resolvedSources,
+          resolvedTargets
+        ] = resolveIfWildcard(model, expr.source)
+        sources = resolvedSources
+        targets = resolvedTargets
+        break
+      }
+      case sourceIsWildcard && isRef(expr.target): {
+        const [
+          resolvedSources,
+          resolvedTargets
+        ] = resolveIfWildcard(model, expr.target)
+        // Swap sources and targets
+        sources = resolvedTargets
+        targets = resolvedSources
+        break
+      }
+      default: {
+        invariant(isRef(expr.source), 'Type inference failed')
+        invariant(isRef(expr.target), 'Type inference failed')
+        sources = resolveElements(model, expr.source)
+        targets = resolveElements(model, expr.target)
+      }
+    }
+
+    if (sources.length === 0 || targets.length === 0) {
+      return identity()
+    }
+
+    const dir = expr.isBidirectional ? 'both' : 'directed'
+    for (const source of sources) {
+      stage.addConnections(findConnectionsBetween(source, targets, dir))
+    }
+
+    if (stage.connections.length === 0) {
+      return identity()
+    }
+
+    for (const c of stage.connections) {
+      if (c.source.isInstance() && c.target.isInstance() && c.boundary) {
+        stage.addImplicit(c.boundary)
+      }
+    }
+    if (isRef(expr.source) && isNonNullish(expr.source.selector)) {
+      stage.addImplicit(model.element(expr.source.ref))
+    }
+    if (isRef(expr.target) && isNonNullish(expr.target.selector)) {
+      stage.addImplicit(model.element(expr.target.ref))
+    }
+
+    return stage.patch()
+  },
+  exclude: (expr, { memory, stage }) => {
+    // * -> *
+    // Exclude all connections
+    if (
+      DeploymentElementExpression.isWildcard(expr.source)
+      && DeploymentElementExpression.isWildcard(expr.target)
+    ) {
+      stage.excludeConnections(memory.connections)
+      return stage.patch()
+    }
+
+    const isSource = deploymentExpressionToPredicate(expr.source)
+    const isTarget = deploymentExpressionToPredicate(expr.target)
+
+    const satisfies = (connection: DeploymentConnectionModel) => {
+      return isSource(connection.source) && isTarget(connection.target)
+        || (expr.isBidirectional && isSource(connection.target) && isTarget(connection.source))
+    }
+
+    const toExclude = memory.connections.filter(satisfies)
+    if (toExclude.length === 0) {
+      return identity()
+    }
+
+    stage.excludeConnections(toExclude)
+    return stage.patch()
+  }
+}

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

@@ -0,0 +1,43 @@
+import { identity } from 'remeda'
+import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
+import { findConnectionsBetween } from '../../../model/connection/deployment'
+import { DeploymentElementExpression, type DeploymentRelationExpression } from '../../../types/deployments'
+import type { PredicateExecutor } from '../_types'
+import { deploymentExpressionToPredicate, resolveElements } from '../utils'
+import { resolveAscendingSiblings } from './relation-direct'
+
+//
+export const InOutRelationPredicate: PredicateExecutor<DeploymentRelationExpression.InOut> = {
+  include: (expr, { model, memory, stage }) => {
+    const sources = [...memory.elements]
+    if (DeploymentElementExpression.isWildcard(expr.inout)) {
+      for (const source of sources) {
+        const targets = [...resolveAscendingSiblings(source)]
+        stage.addConnections(findConnectionsBetween(source, targets, 'both'))
+      }
+      return stage.patch()
+    }
+
+    const targets = resolveElements(model, expr.inout)
+    for (const source of sources) {
+      stage.addConnections(findConnectionsBetween(source, targets, 'both'))
+    }
+
+    return stage.patch()
+  },
+  exclude: (expr, { memory, stage }) => {
+    const isSourceOrTarget = deploymentExpressionToPredicate(expr.inout)
+
+    const satisfies = (connection: DeploymentConnectionModel) => {
+      return isSourceOrTarget(connection.source) || isSourceOrTarget(connection.target)
+    }
+
+    const toExclude = memory.connections.filter(satisfies)
+    if (toExclude.length === 0) {
+      return identity()
+    }
+
+    stage.excludeConnections(toExclude)
+    return stage.patch()
+  }
+}

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

@@ -0,0 +1,46 @@
+import { identity } from 'remeda'
+import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
+import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
+import { DeploymentElementExpression, type DeploymentRelationExpression } from '../../../types/deployments'
+import type { PredicateExecutor } from '../_types'
+import { deploymentExpressionToPredicate, resolveElements } from '../utils'
+import { resolveAscendingSiblings } from './relation-direct'
+
+// from visible element incoming to this
+export const IncomingRelationPredicate: PredicateExecutor<DeploymentRelationExpression.Incoming> = {
+  include: (expr, { model, memory, stage }) => {
+    const sources = [...memory.elements]
+    if (DeploymentElementExpression.isWildcard(expr.incoming)) {
+      for (const source of sources) {
+        if (source.allOutgoing.isEmpty) {
+          continue
+        }
+        const targets = [...resolveAscendingSiblings(source)]
+        stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+      }
+      return stage.patch()
+    }
+
+    const targets = resolveElements(model, expr.incoming)
+    for (const source of sources) {
+      stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+    }
+
+    return stage.patch()
+  },
+  exclude: (expr, { memory, stage }) => {
+    const isTarget = deploymentExpressionToPredicate(expr.incoming)
+
+    const satisfies = (connection: DeploymentConnectionModel) => {
+      return isTarget(connection.target)
+    }
+
+    const toExclude = memory.connections.filter(satisfies)
+    if (toExclude.length === 0) {
+      return identity()
+    }
+
+    stage.excludeConnections(toExclude)
+    return stage.patch()
+  }
+}

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

@@ -0,0 +1,49 @@
+import { identity } from 'remeda'
+import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
+import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
+import { DeploymentElementExpression, type DeploymentRelationExpression } from '../../../types/deployments'
+import type { PredicateExecutor } from '../_types'
+import { deploymentExpressionToPredicate, resolveElements } from '../utils'
+import { resolveAscendingSiblings } from './relation-direct'
+
+export const OutgoingRelationPredicate: PredicateExecutor<DeploymentRelationExpression.Outgoing> = {
+  include: (expr, { model, memory, stage }) => {
+    const targets = [...memory.elements]
+
+    // * -> (to visible elements)
+    // outgoing from wildcard to visible element
+    if (DeploymentElementExpression.isWildcard(expr.outgoing)) {
+      for (const target of targets) {
+        if (target.allIncoming.isEmpty) {
+          continue
+        }
+        for (const source of resolveAscendingSiblings(target)) {
+          stage.addConnections(findConnection(source, target, 'directed'))
+        }
+      }
+      return stage.patch()
+    }
+
+    const sources = resolveElements(model, expr.outgoing)
+    for (const source of sources) {
+      stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+    }
+
+    return stage.patch()
+  },
+  exclude: (expr, { memory, stage }) => {
+    const isSource = deploymentExpressionToPredicate(expr.outgoing)
+
+    const satisfies = (connection: DeploymentConnectionModel) => {
+      return isSource(connection.source)
+    }
+
+    const toExclude = memory.connections.filter(satisfies)
+    if (toExclude.length === 0) {
+      return identity()
+    }
+
+    stage.excludeConnections(toExclude)
+    return stage.patch()
+  }
+}

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

@@ -0,0 +1,29 @@
+import { findConnectionsWithin } from '../../../model/connection/deployment'
+import type { DeploymentElementExpression } from '../../../types/deployments'
+import type { Elem, PredicateExecutor } from '../_types'
+import { MutableMemory } from '../Memory'
+
+export const WildcardPredicate: PredicateExecutor<DeploymentElementExpression.Wildcard> = {
+  include: (_, { model, stage }) => {
+    const children = [] as Elem[]
+
+    const rootElements = [...model.roots()].map(root => {
+      const onlyOneInstance = root.onlyOneInstance()
+      if (onlyOneInstance) {
+        children.push(onlyOneInstance)
+        return onlyOneInstance
+      }
+      children.push(...root.children())
+      return root
+    })
+
+    stage.addExplicit(rootElements)
+    if (children.length > 1) {
+      stage.addConnections(findConnectionsWithin(children))
+    }
+    return stage.patch()
+  },
+  exclude: () => {
+    return () => MutableMemory.empty()
+  }
+}

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

@@ -0,0 +1,212 @@
+import { hasAtLeast, isEmpty } from 'remeda'
+import { invariant, nonexhaustive } from '../../errors'
+import type { LikeC4DeploymentModel } from '../../model'
+import type { DeploymentConnectionModel } from '../../model/connection/deployment'
+import type { AnyAux } from '../../model/types'
+import {
+  type ComputedEdge,
+  type ComputedNode,
+  DefaultArrowType,
+  DeploymentElementExpression,
+  type DeploymentNodeKind,
+  type DeploymentViewRule,
+  type Fqn,
+  isViewRuleStyle,
+  type NonEmptyArray,
+  type Tag
+} from '../../types'
+import { nameFromFqn, parentFqn } from '../../utils'
+import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
+import { buildComputedNodes, type ComputedNodeSource } from '../utils/buildComputedNodes'
+import { deriveEdgePropsFromRelationships } from '../utils/derive-edge-props-from-relationships'
+import { uniqueTags } from '../utils/uniqueTags'
+import type { Elem } from './_types'
+import { type Memory, MutableMemory } from './Memory'
+
+type Predicate<T> = (x: T) => boolean
+
+export function resolveElements(
+  model: LikeC4DeploymentModel,
+  expr: DeploymentElementExpression.Ref
+) {
+  const ref = model.element(expr.ref)
+  if (ref.isDeploymentNode()) {
+    if (expr.selector === 'children') {
+      return [...ref.children()]
+    }
+    if (expr.selector === 'expanded') {
+      return [ref, ...ref.children()]
+    }
+    if (expr.selector === 'descendants') {
+      return [...ref.descendants()]
+    }
+  }
+  return [ref]
+}
+
+export function deploymentExpressionToPredicate<T extends { id: string }>(
+  target: DeploymentElementExpression
+): Predicate<T> {
+  if (DeploymentElementExpression.isWildcard(target)) {
+    return () => true
+  }
+  if (DeploymentElementExpression.isRef(target)) {
+    const fqn = target.ref.id
+    if (target.selector === 'expanded') {
+      const fqnWithDot = fqn + '.'
+      return n => n.id === fqn || n.id.startsWith(fqnWithDot)
+    }
+    if (target.selector === 'descendants') {
+      const fqnWithDot = fqn + '.'
+      return n => n.id.startsWith(fqnWithDot)
+    }
+    if (target.selector === 'children') {
+      return n => parentFqn(n.id) === fqn
+    }
+    return n => n.id === fqn
+  }
+  nonexhaustive(target)
+}
+
+export function toNodeSource(el: Elem): ComputedNodeSource {
+  if (el.isDeploymentNode()) {
+    const onlyOneInstance = el.onlyOneInstance()
+    let { title, kind, id, ...$node } = el.$node
+    const { icon, color, shape, ...style } = el.$node.style ?? {}
+
+    // If there is only one instance and title was not overriden
+    if (onlyOneInstance && title === nameFromFqn(el.id)) {
+      title = onlyOneInstance.title
+    }
+
+    return {
+      ...(onlyOneInstance && {
+        ...toNodeSource(onlyOneInstance),
+        modelRef: onlyOneInstance.$element.id
+      }),
+      title,
+      ...$node,
+      ...(icon && { icon }),
+      ...(color && { color }),
+      ...(shape && { shape }),
+      style: {
+        ...style
+      },
+      deploymentRef: 1,
+      kind,
+      id
+    }
+  }
+  invariant(el.isInstance(), 'Expected Instance')
+  const instance = el.$instance
+  const element = el.$element.$element
+
+  const icon = instance.style?.icon ?? element.icon
+  const color = instance.style?.color ?? element.color
+  const shape = instance.style?.shape ?? element.shape
+
+  const links = [
+    ...(element.links ?? []),
+    ...(instance.links ?? [])
+  ]
+
+  const metadata = {
+    ...element.metadata,
+    ...instance.metadata
+  }
+
+  const notation = instance.notation ?? element.notation
+
+  return {
+    id: el.id,
+    kind: 'instance' as DeploymentNodeKind,
+    title: instance.title ?? element.title,
+    description: instance.description ?? element.description,
+    technology: instance.technology ?? element.technology,
+    tags: uniqueTags([element, instance]) as NonEmptyArray<Tag>,
+    links: hasAtLeast(links, 1) ? links : null,
+    ...icon && { icon },
+    ...color && { color },
+    ...shape && { shape },
+    style: {
+      ...element.style,
+      ...instance.style
+    },
+    deploymentRef: el.id === instance.id ? 1 : instance.id,
+    modelRef: el.id === element.id ? 1 : element.id,
+    ...notation && { notation },
+    ...!isEmpty(metadata) && ({ metadata })
+  }
+}
+
+export function toComputedEdges<M extends AnyAux>(
+  connections: ReadonlyArray<DeploymentConnectionModel<M>>
+): ComputedEdge[] {
+  return connections.reduce((acc, e) => {
+    // const modelRelations = []
+    // const deploymentRelations = []
+    const relations = [
+      ...e.relations.model,
+      ...e.relations.deployment
+    ]
+    invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
+
+    const source = e.source.id
+    const target = e.target.id
+
+    const {
+      title,
+      ...props
+    } = deriveEdgePropsFromRelationships(relations.map(r => r.$relationship)) // || relations.find(r => r.source === source && r.target === target)
+
+    const edge: ComputedEdge = {
+      id: e.id,
+      parent: e.boundary?.id ?? null,
+      source,
+      target,
+      label: title ?? null,
+      relations: relations.map((r) => r.id as M['RelationId']),
+      ...props
+    }
+
+    // If exists same edge but in opposite direction
+    const existing = acc.find(e => e.source === target && e.target === source)
+    if (existing && edge.label === existing.label) {
+      existing.dir = 'both'
+      const head = existing.head ?? edge.head ?? DefaultArrowType
+      existing.head ??= head
+      existing.tail ??= head
+
+      if (edge.color) {
+        existing.color ??= edge.color
+      }
+      if (edge.line) {
+        existing.line ??= edge.line
+      }
+      return acc
+    }
+
+    acc.push(edge)
+    return acc
+  }, [] as ComputedEdge[])
+}
+
+export function buildNodes(memory: Memory): ReadonlyMap<Fqn, ComputedNode> {
+  // typecast to MutableMemory
+  invariant(memory instanceof MutableMemory, 'Expected MutableMemory')
+  return buildComputedNodes([...memory.finalElements].map(toNodeSource))
+}
+
+export function applyDeploymentViewRuleStyles(
+  rules: DeploymentViewRule[],
+  nodes: ComputedNode[]
+) {
+  for (const rule of rules) {
+    if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
+      continue
+    }
+    const predicates = rule.targets.map(deploymentExpressionToPredicate)
+    applyViewRuleStyle(rule, predicates, nodes)
+  }
+  return nodes
+}