@likec4/core 1.19.1 → 1.20.0

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@likec4/core",
-  "version": "1.19.1",
+  "version": "1.20.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
   "repository": {
     "type": "git",
-    "url": "https://github.com/likec4/likec4.git",
+    "url": "git+https://github.com/likec4/likec4.git",
     "directory": "packages/core"
   },
   "bugs": "https://github.com/likec4/likec4/issues",
@@ -16,7 +16,8 @@
     "lint": "run -T eslint src/ --fix",
     "test": "vitest run --no-isolate",
     "test:watch": "vitest",
-    "clean": "rm -r -f dist"
+    "clean": "rm -r -f dist",
+    "package": "yarn pack"
   },
   "files": [
     "dist",
@@ -30,50 +31,74 @@
   "exports": {
     ".": {
       "sources": "./src/index.ts",
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
       "default": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js",
-        "default": "./dist/index.js"
+        "types": "./dist/index.d.mts",
+        "import": "./dist/index.mjs",
+        "default": "./dist/index.mjs"
       }
     },
     "./builder": {
       "sources": "./src/builder/index.ts",
+      "require": {
+        "types": "./dist/builder/index.d.cts",
+        "default": "./dist/builder/index.cjs"
+      },
       "default": {
-        "types": "./dist/builder/index.d.ts",
-        "import": "./dist/builder/index.js",
-        "default": "./dist/builder/index.js"
+        "types": "./dist/builder/index.d.mts",
+        "import": "./dist/builder/index.mjs",
+        "default": "./dist/builder/index.mjs"
       }
     },
     "./compute-view": {
       "sources": "./src/compute-view/index.ts",
+      "require": {
+        "types": "./dist/compute-view/index.d.cts",
+        "default": "./dist/compute-view/index.cjs"
+      },
       "default": {
-        "types": "./dist/compute-view/index.d.ts",
-        "import": "./dist/compute-view/index.js",
-        "default": "./dist/compute-view/index.js"
+        "types": "./dist/compute-view/index.d.mts",
+        "import": "./dist/compute-view/index.mjs",
+        "default": "./dist/compute-view/index.mjs"
       }
     },
     "./model": {
       "sources": "./src/model/index.ts",
+      "require": {
+        "types": "./dist/model/index.d.cts",
+        "default": "./dist/model/index.cjs"
+      },
       "default": {
-        "types": "./dist/model/index.d.ts",
-        "import": "./dist/model/index.js",
-        "default": "./dist/model/index.js"
+        "types": "./dist/model/index.d.mts",
+        "import": "./dist/model/index.mjs",
+        "default": "./dist/model/index.mjs"
       }
     },
     "./utils": {
       "sources": "./src/utils/index.ts",
+      "require": {
+        "types": "./dist/utils/index.d.cts",
+        "default": "./dist/utils/index.cjs"
+      },
       "default": {
-        "types": "./dist/utils/index.d.ts",
-        "import": "./dist/utils/index.js",
-        "default": "./dist/utils/index.js"
+        "types": "./dist/utils/index.d.mts",
+        "import": "./dist/utils/index.mjs",
+        "default": "./dist/utils/index.mjs"
       }
     },
     "./types": {
       "sources": "./src/types/index.ts",
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/types/index.cjs"
+      },
       "default": {
-        "types": "./dist/types/index.d.ts",
-        "import": "./dist/types/index.js",
-        "default": "./dist/types/index.js"
+        "types": "./dist/types/index.d.mts",
+        "import": "./dist/types/index.mjs",
+        "default": "./dist/types/index.mjs"
       }
     }
   },
@@ -85,7 +110,8 @@
     "type-fest": "4.28.1"
   },
   "devDependencies": {
-    "@likec4/tsconfig": "1.19.1",
+    "@dagrejs/dagre": "1.1.4",
+    "@likec4/tsconfig": "1.20.0",
     "@mantine/colors-generator": "7.15.2",
     "@types/natural-compare-lite": "^1.4.2",
     "@types/object-hash": "^3.0.6",
@@ -98,11 +124,11 @@
     "natural-compare-lite": "^1.4.0",
     "object-hash": "^3.0.0",
     "obliterator": "^2.0.4",
-    "remeda": "^2.17.4",
+    "remeda": "^2.19.0",
     "turbo": "^2.3.3",
-    "typescript": "^5.7.2",
-    "unbuild": "^3.1.0",
+    "typescript": "^5.7.3",
+    "unbuild": "^3.2.0",
     "vitest": "^2.1.8"
   },
-  "packageManager": "yarn@4.5.3"
+  "packageManager": "yarn@4.6.0"
 }

package/src/builder/Builder.view-common.ts

@@ -6,11 +6,12 @@ import {
   type CustomRelationExpr,
   type ElementExpression as C4ElementExpression,
   type Expression as C4Expression,
-  isElementPredicateExpr,
   type NonEmptyArray,
   type ViewRuleStyle,
   type WhereOperator,
+  isElementPredicateExpr,
 } from '../types'
+import type { KindEqual, Participant, TagEqual } from '../types/operators'
 import type { AnyTypes, Types } from './_types'
 
 export interface LikeC4ViewBuilder<
@@ -59,10 +60,14 @@ export namespace ViewPredicate {
 
   export type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`
   export type WhereKind<Kind extends string> = `kind ${'is' | 'is not'} ${Kind}`
+  export type WhereParticipant<Types extends AnyTypes> = `${Participant}.${
+    | WhereTag<Types['Tag']>
+    | WhereKind<Types['ElementKind']>}`
 
   export type WhereEq<Types extends AnyTypes> =
     | ViewPredicate.WhereTag<Types['Tag']>
     | ViewPredicate.WhereKind<Types['ElementKind']>
+    | ViewPredicate.WhereParticipant<Types>
 
   export type WhereOperator<Types extends AnyTypes> = ViewPredicate.WhereEq<Types> | {
     and: NonEmptyArray<ViewPredicate.WhereOperator<Types>>
@@ -116,6 +121,20 @@ function parseWhere(where: ViewPredicate.WhereOperator<AnyTypes>): WhereOperator
             eq: op.replace('kind is ', ''),
           },
         }
+      case op.startsWith('source.'):
+        return {
+          operator: parseWhere(op.replace('source.', '') as ViewPredicate.WhereOperator<AnyTypes>) as
+            | KindEqual<string>
+            | TagEqual<string>,
+          participant: 'source',
+        }
+      case op.startsWith('target.'):
+        return {
+          operator: parseWhere(op.replace('target.', '') as ViewPredicate.WhereOperator<AnyTypes>) as
+            | KindEqual<string>
+            | TagEqual<string>,
+          participant: 'target',
+        }
       default:
         throw new Error(`Unknown where operator: ${where}`)
     }
@@ -189,6 +208,7 @@ function $exclude<B extends LikeC4ViewBuilder<AnyTypes, any, any>>(
     | [B['Expr']]
     | [B['TypedExpr']]
     | [B['Expr'], ViewPredicate.Custom<B['Types']>]
+    | [B['TypedExpr'], ViewPredicate.Custom<B['Types']>]
 ): (b: B) => B {
   return (b) => {
     let expr = b.$expr(args[0]) as C4Expression

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

@@ -57,6 +57,8 @@ const {
     zone: {},
     node: {},
   },
+  tags: ['old', 'next', 'temp'],
+  relationships: { 'https': {} },
 })
 
 export const builder = b
@@ -91,13 +93,22 @@ export const builder = b
     model(
       $m.rel('customer', 'cloud', 'uses services'),
       $m.rel('customer', 'cloud.frontend.mobile', 'opens mobile app'),
-      $m.rel('customer', 'cloud.frontend.dashboard', 'opens in browser'),
+      $m.rel('customer', 'cloud.frontend.dashboard', {
+        title: 'opens in browser',
+        tags: ['old'],
+      }),
       $m.rel('cloud.frontend.dashboard', 'cloud.auth', {
         title: 'authenticates',
         color: 'green',
       }),
-      $m.rel('cloud.frontend.dashboard', 'cloud.backend.api', 'fetches data'),
-      $m.rel('cloud.frontend.dashboard', 'cloud.media', 'fetches media'),
+      $m.rel('cloud.frontend.dashboard', 'cloud.backend.api', {
+        title: 'fetches data',
+        tags: ['old'],
+      }),
+      $m.rel('cloud.frontend.dashboard', 'cloud.media', {
+        title: 'fetches media',
+        tags: ['temp'],
+      }),
       $m.rel('cloud.frontend.mobile', 'cloud.auth', {
         title: 'authenticates',
         color: 'amber',
@@ -137,6 +148,14 @@ export const builder = b
           instanceOf('db', 'aws.rds'),
         ),
       ),
+      env('dev').with(
+        node('devCustomer').with(
+          instanceOf('instance', 'customer'),
+        ),
+        node('devCloud').with(
+          instanceOf('instance', 'cloud'),
+        ),
+      ),
       env('acc').with(
         node('testCustomer').with(
           instanceOf('instance', 'customer'),
@@ -196,3 +215,12 @@ export function computeNodesAndEdges(...rules: DeploymentRulesBuilderOp<Types>[]
     edges: edgeIds,
   }
 }
+
+export function createModel() {
+  const modelsource = builder.build()
+
+  return LikeC4Model.create({
+    ...modelsource,
+    views: {},
+  })
+}

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

@@ -1,6 +1,6 @@
 import { LikeC4DeploymentModel } from '../../model'
 import type { RelationshipModel } from '../../model/RelationModel'
-import type { ExpressionV2 } from '../../types'
+import type { ExpressionV2, Filterable, OperatorPredicate } from '../../types'
 import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
 
 export { Memory, type Stage } from './memory'
@@ -23,6 +23,7 @@ export interface PredicateCtx<Expr extends ExpressionV2 = ExpressionV2> {
   stage: Stage
   model: LikeC4DeploymentModel
   memory: Memory
+  where: OperatorPredicate<Filterable> | null
 }
 export interface IncludePredicateCtx<Expr extends ExpressionV2 = ExpressionV2> extends PredicateCtx<Expr> {
   stage: StageInclude

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

@@ -1,27 +1,19 @@
 import { findLast, map } from 'remeda'
-import { nonexhaustive } from '../../errors'
 import { type LikeC4DeploymentModel, LikeC4Model } from '../../model'
 import type { AnyAux } from '../../model/types'
 import type { DeploymentViewRule } from '../../types'
 import {
   type ComputedDeploymentView,
   type DeploymentView,
-  FqnExpr,
   isViewRuleAutoLayout,
   isViewRulePredicate,
 } from '../../types'
-import { RelationExpr } from '../../types/expression-v2'
 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 { DeploymentRefPredicate } from './predicates/elements'
-import { DirectRelationPredicate } from './predicates/relation-direct'
-import { InOutRelationPredicate } from './predicates/relation-in-out'
-import { IncomingRelationPredicate } from './predicates/relation-incoming'
-import { OutgoingRelationPredicate } from './predicates/relation-outgoing'
-import { WildcardPredicate } from './predicates/wildcard'
+import { predicateToPatch } from './predicates'
 import { StageFinal } from './stages/stage-final'
 import { applyDeploymentViewRuleStyles, buildNodes, toComputedEdges } from './utils'
 
@@ -37,32 +29,8 @@ export function processPredicates<M extends AnyAux>(
       const exprs = rule.include ?? rule.exclude
       for (const expr of exprs) {
         let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
-        const ctx = { model, stage, memory }
-        switch (true) {
-          case FqnExpr.isModelRef(expr):
-            // Ignore model refs in deployment view
-            break
-          case FqnExpr.isDeploymentRef(expr):
-            stage = DeploymentRefPredicate[op]({ ...ctx, expr } as any) ?? stage
-            break
-          case FqnExpr.isWildcard(expr):
-            stage = WildcardPredicate[op]({ ...ctx, expr } as any) ?? stage
-            break
-          case RelationExpr.isDirect(expr):
-            stage = DirectRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
-            break
-          case RelationExpr.isInOut(expr):
-            stage = InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
-            break
-          case RelationExpr.isOutgoing(expr):
-            stage = OutgoingRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
-            break
-          case RelationExpr.isIncoming(expr):
-            stage = IncomingRelationPredicate[op]({ ...ctx, expr } as any) ?? stage
-            break
-          default:
-            nonexhaustive(expr)
-        }
+        const ctx = { expr, model, stage, memory, where: null }
+        stage = predicateToPatch(op, ctx) ?? stage
         memory = stage.commit()
       }
     }
@@ -78,7 +46,7 @@ export function computeDeploymentView<M extends AnyAux>(
     ...view
   }: DeploymentView,
 ): ComputedDeploymentView<M['ViewId']> {
-  let memory = processPredicates<M>(likec4model.deployment, rules)
+  const memory = processPredicates<M>(likec4model.deployment, rules)
 
   const nodesMap = buildNodes(memory)
 

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

@@ -0,0 +1,8 @@
+export * from './elements'
+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,22 +1,22 @@
-import { filter, flatMap, isNonNullish, map, pipe } from 'remeda'
+import { filter, flatMap, isNonNullish, map, pick, pipe } from 'remeda'
 import { invariant } from '../../../errors'
-import type { LikeC4DeploymentModel } from '../../../model'
+import type {
+  ConnectionModel,
+  DeploymentElementModel,
+  DeploymentRelationModel,
+  LikeC4DeploymentModel,
+} from '../../../model'
 import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
 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 { type Filterable, type OperatorPredicate, type RelationExpr, FqnExpr } from '../../../types'
+import type { PredicateExecutor } from '../_types'
 import { deploymentExpressionToPredicate, resolveElements, resolveModelElements } from '../utils'
 import { filterIncomingConnections, resolveAllImcomingRelations } from './relation-incoming'
 import { filterOutgoingConnections, resolveAllOutgoingRelations } from './relation-outgoing'
-
-// const isRef = DeploymentElementExpression.isRef
+import { applyPredicate, excludeModelRelations } from './utils'
 
 export const resolveAscendingSiblings = (element: DeploymentElementModel) => {
   const siblings = new Set<DeploymentElementModel>()
@@ -40,7 +40,7 @@ const resolveWildcard = (model: LikeC4DeploymentModel, nonWildcard: FqnExpr.Depl
 }
 
 export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
-  include: ({ expr: { source, target, isBidirectional = false }, model, stage }) => {
+  include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
     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)
@@ -53,10 +53,14 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
     switch (true) {
       // * -> *
       case sourceIsWildcard && targetIsWildcard: {
-        connections = findConnectionsWithin(model.instances()).map(c => {
-          stage.addImplicit(c.boundary)
-          return c
-        })
+        connections = pipe(
+          findConnectionsWithin(model.instances()),
+          applyPredicate(where),
+          map(c => {
+            stage.addImplicit(c.boundary)
+            return c
+          }),
+        )
         break
       }
 
@@ -71,12 +75,15 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
           postFilter = c => isSource(c) !== isTarget(c)
         }
 
-        connections = sources
-          .flatMap(source => {
+        connections = pipe(
+          sources,
+          flatMap(source => {
             const targets = resolveAscendingSiblings(source)
             return findConnectionsBetween(source, targets, dir)
-          })
-          .filter(postFilter)
+          }),
+          filter(postFilter),
+          applyPredicate(where),
+        )
         break
       }
       // * -> target; * <-> target
@@ -90,12 +97,15 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
           postFilter = c => isSource(c) !== isTarget(c)
         }
 
-        connections = targets
-          .flatMap(target => {
+        connections = pipe(
+          targets,
+          flatMap(target => {
             const sources = resolveAscendingSiblings(target)
             return [...sources].flatMap(source => findConnection(source, target, dir))
-          })
-          .filter(postFilter)
+          }),
+          filter(postFilter),
+          applyPredicate(where),
+        )
         break
       }
       default: {
@@ -111,6 +121,7 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
           sources,
           flatMap(s => findConnectionsBetween(s, targets, dir)),
           filter(c => isSource(c) && isTarget(c)),
+          applyPredicate(where),
         )
       }
     }
@@ -126,90 +137,72 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
 
     return stage
   },
-  exclude: ({ expr, model, memory, stage }) => {
-    // * -> *
-    // Exclude all connections
-    if (
-      FqnExpr.isWildcard(expr.source)
-      && FqnExpr.isWildcard(expr.target)
-    ) {
-      stage.excludeConnections(memory.connections)
-      return stage
-    }
+  exclude: ({ expr, model, memory, stage, where }) => {
+    const isTarget = deploymentExpressionToPredicate(expr.target)
+    const isSource = deploymentExpressionToPredicate(expr.source)
 
-    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 })
-    }
+    let modelRelationsToExclude: ReadonlySet<RelationshipModel<AnyAux>>
+    switch (true) {
+      // * -> *
+      case FqnExpr.isWildcard(expr.source) && FqnExpr.isWildcard(expr.target):
+        stage.excludeConnections(applyPredicate(memory.connections, where))
+        return stage
 
-    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),
-      )
-    }
+      // 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)
 
-    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),
-      )
-    }
+      // model -> *
+      case FqnExpr.isModelRef(expr.source) && FqnExpr.isWildcard(expr.target):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source)
+        return excludeModelRelations(modelRelationsToExclude, { stage, memory }, where)
 
-    const isSource = deploymentExpressionToPredicate(expr.source)
-    const isTarget = deploymentExpressionToPredicate(expr.target)
+      // model -> deployment
+      case FqnExpr.isModelRef(expr.source):
+        modelRelationsToExclude = resolveAllOutgoingRelations(model, expr.source)
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          c => isTarget(c.target),
+        )
 
-    const satisfies = (connection: DeploymentConnectionModel) => {
-      return (isSource(connection.source) && isTarget(connection.target))
-        || (expr.isBidirectional && isSource(connection.target) && isTarget(connection.source))
-    }
+      // deployment -> model
+      case FqnExpr.isModelRef(expr.target):
+        modelRelationsToExclude = resolveAllImcomingRelations(model, expr.target)
+        return excludeModelRelations(
+          modelRelationsToExclude,
+          { stage, memory },
+          where,
+          c => isSource(c.source),
+        )
 
-    const toExclude = memory.connections.filter(satisfies)
+      // deployment -> deployment
+      default:
+        const satisfies = (connection: DeploymentConnectionModel) => {
+          return (isSource(connection.source) && isTarget(connection.target))
+            || (expr.isBidirectional === true && isSource(connection.target) && isTarget(connection.source))
+        }
 
-    stage.excludeConnections(toExclude)
-    return stage
-  },
-}
+        const deploymentRelationsToExclude = pipe(
+          memory.connections,
+          filter(satisfies),
+          applyPredicate(where),
+        )
+        if (deploymentRelationsToExclude.length === 0) {
+          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)
+        stage.excludeConnections(deploymentRelationsToExclude)
+        return stage
+    }
+  },
 }
 
 function resolveRelationsBetweenModelElements({
@@ -235,3 +228,36 @@ function resolveRelationsBetweenModelElements({
 
   return new Set(modelConnections.flatMap(c => [...c.relations]))
 }
+
+function elementToFilterable<M extends AnyAux>(element: DeploymentElementModel<M>) {
+  return pick(element, ['tags', 'kind'])
+}
+
+function toFilterableRelation<M extends AnyAux>(
+  source: DeploymentElementModel<M>,
+  target: DeploymentElementModel<M>,
+) {
+  return (
+    relation: RelationshipModel<M> | DeploymentRelationModel<M>,
+  ) => ({
+    tags: relation.tags,
+    kind: relation.kind,
+    source: elementToFilterable(source),
+    target: elementToFilterable(target),
+  })
+}
+
+function matchConnection<M extends AnyAux>(
+  c: DeploymentConnectionModel<M>,
+  where: OperatorPredicate<Filterable> | null,
+): boolean {
+  if (!where) {
+    return true
+  }
+
+  return [
+    ...Array.from(c.relations.deployment.values()).map(toFilterableRelation(c.source, c.target)),
+    ...Array.from(c.relations.model.values()).map(toFilterableRelation(c.source, c.target)),
+  ]
+    .filter(where).length > 0
+}