@likec4/core 1.18.0 → 1.19.0

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

@@ -0,0 +1,144 @@
+import { pipe, reduce } from 'remeda'
+import { isDeployedInstance } from '../../../model'
+import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/deployment'
+import type { DeploymentElementModel, DeploymentNodeModel } from '../../../model/DeploymentElementModel'
+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 } from '../utils'
+
+export const DeploymentRefPredicate: PredicateExecutor<FqnExpr.DeploymentRef> = {
+  include: (ctx) => {
+    const { expr } = ctx
+    const el = ctx.model.element(expr.ref.deployment)
+
+    if (isDeployedInstance(el)) {
+      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: {
+        ctx.stage.addExplicit(el)
+        ctx.stage.connectWithExisting(el)
+      }
+    }
+    return ctx.stage
+  },
+
+  exclude: ({ expr, stage, memory }) => {
+    const exprPredicate = deploymentExpressionToPredicate(expr)
+    stage.exclude([...memory.elements].filter(exprPredicate))
+    return stage
+  },
+}
+
+/**
+ * include node.*
+ */
+function includeDeployedNodeChildren(
+  node: DeploymentNodeModel,
+  { stage }: IncludePredicateCtx,
+) {
+  const children = [...node.children()]
+  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 }: IncludePredicateCtx,
+) {
+  const children = [...node.children()]
+  stage.addImplicit(node)
+  stage.connectWithExisting(node)
+
+  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 }: IncludePredicateCtx,
+) {
+  const dfs = (node: DeploymentNodeModel): DeploymentElementModel[] => {
+    const children = [] as DeploymentElementModel[]
+    for (const child of node.children()) {
+      if (child.isDeploymentNode()) {
+        children.push(...dfs(child))
+      }
+      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')
+  // stage.addImplicit(descendants)
+
+  const allconnected = findConnectedElements(stage)
+  descendants.forEach((desc) => {
+    if (allconnected.has(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/relation-direct.ts

@@ -1,130 +1,237 @@
-import { identity, isNonNullish } from 'remeda'
+import { filter, flatMap, isNonNullish, map, pipe } 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'
+import { findConnection, findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/deployment'
+import { findConnectionsBetween as findModelConnectionsBetween } from '../../../model/connection/model'
+import type { ConnectionModel } from '../../../model/connection/model/ConnectionModel'
+import type { DeploymentElementModel } from '../../../model/DeploymentElementModel'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import { type RelationExpr, FqnExpr } from '../../../types'
+import { hasIntersection, intersection } from '../../../utils/set'
+import type { ExcludePredicateCtx, PredicateExecutor } from '../_types'
+import type { StageExclude } from '../memory'
+import { deploymentExpressionToPredicate, resolveElements, resolveModelElements } from '../utils'
+import { filterIncomingConnections, resolveAllImcomingRelations } from './relation-incoming'
+import { filterOutgoingConnections, resolveAllOutgoingRelations } from './relation-outgoing'
 
-const isRef = DeploymentElementExpression.isRef
+// 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
-    }
+  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 resolveIfWildcard = (model: LikeC4DeploymentModel, nonWildcard: DeploymentElementExpression.Ref) => {
+const resolveWildcard = (model: LikeC4DeploymentModel, nonWildcard: FqnExpr.DeploymentRef) => {
   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
+  return sources.map(source => {
+    const targets = resolveAscendingSiblings(source)
+    return [source, targets] as const
+  })
 }
 
-export const DirectRelationPredicate: PredicateExecutor<DeploymentRelationExpression.Direct> = {
-  include: (expr, { model, stage }) => {
-    const sourceIsWildcard = DeploymentElementExpression.isWildcard(expr.source)
-    const targetIsWildcard = DeploymentElementExpression.isWildcard(expr.target)
+export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
+  include: ({ expr: { source, target, isBidirectional = false }, model, stage }) => {
+    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 sources, targets
+    let connections
 
     switch (true) {
+      // * -> *
       case sourceIsWildcard && targetIsWildcard: {
-        sources = [...model.instances()]
-        targets = sources.slice()
+        connections = findConnectionsWithin(model.instances()).map(c => {
+          stage.addImplicit(c.boundary)
+          return c
+        })
         break
       }
-      case targetIsWildcard && isRef(expr.source): {
-        const [
-          resolvedSources,
-          resolvedTargets
-        ] = resolveIfWildcard(model, expr.source)
-        sources = resolvedSources
-        targets = resolvedTargets
+
+      // 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 = sources
+          .flatMap(source => {
+            const targets = resolveAscendingSiblings(source)
+            return findConnectionsBetween(source, targets, dir)
+          })
+          .filter(postFilter)
         break
       }
-      case sourceIsWildcard && isRef(expr.target): {
-        const [
-          resolvedSources,
-          resolvedTargets
-        ] = resolveIfWildcard(model, expr.target)
-        // Swap sources and targets
-        sources = resolvedTargets
-        targets = resolvedSources
+      // * -> 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 = targets
+          .flatMap(target => {
+            const sources = resolveAscendingSiblings(target)
+            return [...sources].flatMap(source => findConnection(source, target, dir))
+          })
+          .filter(postFilter)
         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)
-      }
-    }
+        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)
 
-    if (sources.length === 0 || targets.length === 0) {
-      return identity()
-    }
+        const isSource = filterOutgoingConnections(sources)
+        const isTarget = filterIncomingConnections(targets)
 
-    const dir = expr.isBidirectional ? 'both' : 'directed'
-    for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, dir))
+        connections = pipe(
+          sources,
+          flatMap(s => findConnectionsBetween(s, targets, dir)),
+          filter(c => isSource(c) && isTarget(c)),
+        )
+      }
     }
 
-    if (stage.connections.length === 0) {
-      return identity()
-    }
+    stage.addConnections(connections)
 
-    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 (FqnExpr.isDeploymentRef(source) && isNonNullish(source.selector)) {
+      stage.addImplicit(model.element(source.ref.deployment))
     }
-    if (isRef(expr.target) && isNonNullish(expr.target.selector)) {
-      stage.addImplicit(model.element(expr.target.ref))
+    if (FqnExpr.isDeploymentRef(target) && isNonNullish(target.selector)) {
+      stage.addImplicit(model.element(target.ref.deployment))
     }
 
-    return stage.patch()
+    return stage
   },
-  exclude: (expr, { memory, stage }) => {
+  exclude: ({ expr, model, memory, stage }) => {
     // * -> *
     // Exclude all connections
     if (
-      DeploymentElementExpression.isWildcard(expr.source)
-      && DeploymentElementExpression.isWildcard(expr.target)
+      FqnExpr.isWildcard(expr.source)
+      && FqnExpr.isWildcard(expr.target)
     ) {
       stage.excludeConnections(memory.connections)
-      return stage.patch()
+      return stage
+    }
+
+    if (FqnExpr.isModelRef(expr.source) && FqnExpr.isModelRef(expr.target)) {
+      const toExclude = resolveRelationsBetweenModelElements({
+        source: expr.source,
+        target: expr.target,
+        expr,
+        model,
+      })
+      return excludeModelRelations(toExclude, { stage, memory })
+    }
+
+    if (FqnExpr.isModelRef(expr.source)) {
+      if (FqnExpr.isWildcard(expr.target)) {
+        const toExclude = resolveAllOutgoingRelations(model, expr.source)
+        return excludeModelRelations(toExclude, { stage, memory })
+      }
+      const allOutgoing = resolveAllOutgoingRelations(model, expr.source)
+      const isTarget = deploymentExpressionToPredicate(expr.target)
+      return excludeModelRelations(
+        allOutgoing,
+        { stage, memory },
+        c => isTarget(c.target),
+      )
+    }
+
+    if (FqnExpr.isModelRef(expr.target)) {
+      const toExclude = resolveAllImcomingRelations(model, expr.target)
+      const isSource = deploymentExpressionToPredicate(expr.source)
+      return excludeModelRelations(
+        toExclude,
+        { stage, memory },
+        c => isSource(c.source),
+      )
     }
 
     const isSource = deploymentExpressionToPredicate(expr.source)
     const isTarget = deploymentExpressionToPredicate(expr.target)
 
     const satisfies = (connection: DeploymentConnectionModel) => {
-      return isSource(connection.source) && isTarget(connection.target)
+      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()
+    return stage
+  },
+}
+
+export function excludeModelRelations(
+  relationsToExclude: ReadonlySet<RelationshipModel<AnyAux>>,
+  { stage, memory }: Pick<ExcludePredicateCtx, 'stage' | 'memory'>,
+  // Optional filter to scope the connections to exclude
+  filterConnections: (c: DeploymentConnectionModel) => boolean = () => true,
+): StageExclude {
+  if (relationsToExclude.size === 0) {
+    return stage
+  }
+  const toExclude = pipe(
+    memory.connections,
+    // Find connections that have at least one relation in common with the excluded relations
+    filter(c => filterConnections(c) && hasIntersection(c.relations.model, relationsToExclude)),
+    map(c =>
+      c.update({
+        deployment: null,
+        model: intersection(c.relations.model, relationsToExclude),
+      })
+    ),
+  )
+  if (toExclude.length === 0) {
+    return stage
+  }
+  return stage.excludeConnections(toExclude)
+}
+
+function resolveRelationsBetweenModelElements({
+  source,
+  target,
+  expr,
+  model,
+}: {
+  source: FqnExpr.ModelRef
+  target: FqnExpr.ModelRef
+  expr: RelationExpr.Direct
+  model: LikeC4DeploymentModel
+}) {
+  const sources = resolveModelElements(model, source)
+  const targets = resolveModelElements(model, target)
+
+  const dir = expr.isBidirectional ? 'both' : 'directed'
+
+  const modelConnections = [] as ConnectionModel[]
+  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,43 +1,61 @@
-import { identity } from 'remeda'
-import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
+import { invariant } from '../../../errors'
 import { findConnectionsBetween } from '../../../model/connection/deployment'
-import { DeploymentElementExpression, type DeploymentRelationExpression } from '../../../types/deployments'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import { FqnExpr, type RelationExpr } from '../../../types/expression-v2'
+import { union } from '../../../utils/set'
 import type { PredicateExecutor } from '../_types'
-import { deploymentExpressionToPredicate, resolveElements } from '../utils'
-import { resolveAscendingSiblings } from './relation-direct'
+import { resolveElements, resolveModelElements } from '../utils'
+import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
+import { filterIncomingConnections } from './relation-incoming'
+import { filterOutgoingConnections } from './relation-outgoing'
 
 //
-export const InOutRelationPredicate: PredicateExecutor<DeploymentRelationExpression.InOut> = {
-  include: (expr, { model, memory, stage }) => {
+export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
+  include: ({ expr, model, memory, stage }) => {
     const sources = [...memory.elements]
-    if (DeploymentElementExpression.isWildcard(expr.inout)) {
+
+    if (FqnExpr.isWildcard(expr.inout)) {
       for (const source of sources) {
         const targets = [...resolveAscendingSiblings(source)]
         stage.addConnections(findConnectionsBetween(source, targets, 'both'))
       }
-      return stage.patch()
+      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) {
       stage.addConnections(findConnectionsBetween(source, targets, 'both'))
     }
 
-    return stage.patch()
+    return stage
   },
-  exclude: (expr, { memory, stage }) => {
-    const isSourceOrTarget = deploymentExpressionToPredicate(expr.inout)
-
-    const satisfies = (connection: DeploymentConnectionModel) => {
-      return isSourceOrTarget(connection.source) || isSourceOrTarget(connection.target)
+  exclude: ({ expr, model, memory, stage }) => {
+    // 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<AnyAux>>(),
+        ...elements.flatMap(e => [e.allIncoming, e.allOutgoing]),
+      )
+      return excludeModelRelations(excludedRelations, { stage, memory })
     }
 
-    const toExclude = memory.connections.filter(satisfies)
-    if (toExclude.length === 0) {
-      return identity()
+    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 = memory.connections.filter(c => isIncoming(c) !== isOutgoing(c))
     stage.excludeConnections(toExclude)
-    return stage.patch()
-  }
+    return stage
+  },
 }

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

@@ -1,16 +1,21 @@
-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'
+import { anyPass } from 'remeda'
+import { invariant } from '../../../errors'
+import { findConnectionsBetween } from '../../../model/connection/deployment'
+import type { LikeC4DeploymentModel } from '../../../model/DeploymentModel'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import { FqnExpr, type RelationExpr } from '../../../types'
+import { isAncestor } from '../../../utils/fqn'
+import type { Connection, Elem, PredicateExecutor } from '../_types'
+import { resolveElements, resolveModelElements } from '../utils'
+import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
 
 // from visible element incoming to this
-export const IncomingRelationPredicate: PredicateExecutor<DeploymentRelationExpression.Incoming> = {
-  include: (expr, { model, memory, stage }) => {
+export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming> = {
+  include: ({ expr, model, memory, stage }) => {
     const sources = [...memory.elements]
-    if (DeploymentElementExpression.isWildcard(expr.incoming)) {
+
+    if (FqnExpr.isWildcard(expr.incoming)) {
       for (const source of sources) {
         if (source.allOutgoing.isEmpty) {
           continue
@@ -18,29 +23,73 @@ export const IncomingRelationPredicate: PredicateExecutor<DeploymentRelationExpr
         const targets = [...resolveAscendingSiblings(source)]
         stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
       }
-      return stage.patch()
+      return stage
     }
+    invariant(FqnExpr.isDeploymentRef(expr.incoming), 'Only deployment refs are supported in include')
 
     const targets = resolveElements(model, expr.incoming)
     for (const source of sources) {
       stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
     }
 
-    return stage.patch()
+    return stage
   },
-  exclude: (expr, { memory, stage }) => {
-    const isTarget = deploymentExpressionToPredicate(expr.incoming)
-
-    const satisfies = (connection: DeploymentConnectionModel) => {
-      return isTarget(connection.target)
+  exclude: ({ expr, model, memory, stage }) => {
+    // Exclude all connections that have model relationshps with the elements
+    if (FqnExpr.isModelRef(expr.incoming)) {
+      const excludedRelations = resolveAllImcomingRelations(model, expr.incoming)
+      return excludeModelRelations(excludedRelations, { stage, memory })
     }
-
-    const toExclude = memory.connections.filter(satisfies)
-    if (toExclude.length === 0) {
-      return identity()
+    if (FqnExpr.isWildcard(expr.incoming)) {
+      // non-sense
+      return stage
     }
 
+    const isIncoming = filterIncomingConnections(resolveElements(model, expr.incoming))
+    const toExclude = memory.connections.filter(isIncoming)
     stage.excludeConnections(toExclude)
-    return stage.patch()
-  }
+    return stage
+  },
+}
+
+export function filterIncomingConnections(
+  targets: Elem[],
+): (connection: Connection) => boolean {
+  return anyPass(
+    targets.map(target => {
+      const satisfies = (el: Elem) => el === target || isAncestor(target, el)
+      return (connection: Connection) => {
+        return !satisfies(connection.source) && satisfies(connection.target)
+      }
+    }),
+  )
+}
+//   model: LikeC4DeploymentModel,
+//   model: LikeC4DeploymentModel,
+//   expr: FqnExpr.DeploymentRef
+// ): (connection: Connection) => boolean {
+//   if (FqnExpr.isWildcard(expr)) {
+//     return () => true
+//   }
+//   if (isNullish(expr.selector)) {
+//     // -> element
+//     const target = model.element(expr.ref.deployment)
+//     const isInside = (el: Elem) => el === target || isAncestor(target, el)
+//     return (connection) => {
+//       return !isInside(connection.source) && isInside(connection.target)
+//     }
+//   }
+
+//   const isTarget = deploymentExpressionToPredicate(expr)
+//   return (connection) => {
+//     return isTarget(connection.target)
+//   }
+// }
+
+export function resolveAllImcomingRelations(
+  model: LikeC4DeploymentModel,
+  moodelRef: FqnExpr.ModelRef,
+): Set<RelationshipModel<AnyAux>> {
+  const targets = resolveModelElements(model, moodelRef)
+  return new Set(targets.flatMap(e => [...e.allIncoming]))
 }