@likec4/core 1.19.0 → 1.19.2

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, 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)
@@ -109,7 +109,7 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
 
         connections = pipe(
           sources,
-          flatMap(s => findConnectionsBetween(s, targets, dir)),
+          flatMap(s => matchConnections(findConnectionsBetween(s, targets, dir), where)),
           filter(c => isSource(c) && isTarget(c)),
         )
       }
@@ -126,90 +126,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(matchConnections(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 +217,50 @@ 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
+}
+
+function matchConnections<M extends AnyAux>(
+  connections: readonly DeploymentConnectionModel<M>[],
+  where: OperatorPredicate<Filterable> | null,
+): readonly DeploymentConnectionModel[] {
+  if (!where) {
+    return connections
+  }
+
+  return pipe(
+    connections,
+    filter(c => matchConnection(c, where)),
+  )
+}

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

@@ -1,24 +1,27 @@
+import { filter, pipe } from 'remeda'
 import { invariant } from '../../../errors'
 import { findConnectionsBetween } from '../../../model/connection/deployment'
 import type { RelationshipModel } from '../../../model/RelationModel'
 import type { AnyAux } from '../../../model/types'
-import { FqnExpr, type RelationExpr } from '../../../types/expression-v2'
+import { type RelationExpr, FqnExpr } from '../../../types/expression-v2'
 import { union } from '../../../utils/set'
 import type { PredicateExecutor } from '../_types'
 import { resolveElements, resolveModelElements } from '../utils'
-import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
+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 }) => {
+  include: ({ expr, model, memory, stage, where }) => {
     const sources = [...memory.elements]
 
     if (FqnExpr.isWildcard(expr.inout)) {
       for (const source of sources) {
         const targets = [...resolveAscendingSiblings(source)]
-        stage.addConnections(findConnectionsBetween(source, targets, 'both'))
+        const toInclude = matchConnections(findConnectionsBetween(source, targets, 'both'), where)
+        stage.addConnections(toInclude)
       }
       return stage
     }
@@ -26,12 +29,13 @@ export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
 
     const targets = resolveElements(model, expr.inout)
     for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, 'both'))
+      const toInclude = matchConnections(findConnectionsBetween(source, targets, 'both'), where)
+      stage.addConnections(toInclude)
     }
 
     return stage
   },
-  exclude: ({ expr, model, memory, stage }) => {
+  exclude: ({ expr, model, memory, stage, where }) => {
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.inout)) {
       const elements = resolveModelElements(model, expr.inout)
@@ -42,7 +46,7 @@ export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
         new Set<RelationshipModel<AnyAux>>(),
         ...elements.flatMap(e => [e.allIncoming, e.allOutgoing]),
       )
-      return excludeModelRelations(excludedRelations, { stage, memory })
+      return excludeModelRelations(excludedRelations, { stage, memory }, where)
     }
 
     if (FqnExpr.isWildcard(expr.inout)) {
@@ -54,7 +58,11 @@ export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
     const isIncoming = filterIncomingConnections(elements)
     const isOutgoing = filterOutgoingConnections(elements)
 
-    const toExclude = memory.connections.filter(c => isIncoming(c) !== isOutgoing(c))
+    const toExclude = pipe(
+      memory.connections,
+      filter(c => isIncoming(c) !== isOutgoing(c)),
+      applyPredicate(where),
+    )
     stage.excludeConnections(toExclude)
     return stage
   },

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

@@ -1,18 +1,18 @@
-import { anyPass } from 'remeda'
+import { anyPass, filter, pipe } from 'remeda'
 import { invariant } from '../../../errors'
+import type { AnyAux, RelationshipModel } from '../../../model'
 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 RelationExpr, FqnExpr } from '../../../types'
+import { isAncestor } from '../../../utils'
 import type { Connection, Elem, PredicateExecutor } from '../_types'
 import { resolveElements, resolveModelElements } from '../utils'
-import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
+import { resolveAscendingSiblings } from './relation-direct'
+import { applyPredicate, excludeModelRelations, matchConnection, matchConnections } from './utils'
 
 // from visible element incoming to this
 export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming> = {
-  include: ({ expr, model, memory, stage }) => {
+  include: ({ expr, model, memory, stage, where }) => {
     const sources = [...memory.elements]
 
     if (FqnExpr.isWildcard(expr.incoming)) {
@@ -21,7 +21,8 @@ export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming>
           continue
         }
         const targets = [...resolveAscendingSiblings(source)]
-        stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+        const toInclude = applyPredicate(findConnectionsBetween(source, targets, 'directed'), where)
+        stage.addConnections(toInclude)
       }
       return stage
     }
@@ -29,16 +30,17 @@ export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming>
 
     const targets = resolveElements(model, expr.incoming)
     for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+      const toInclude = applyPredicate(findConnectionsBetween(source, targets, 'directed'), where)
+      stage.addConnections(toInclude)
     }
 
     return stage
   },
-  exclude: ({ expr, model, memory, stage }) => {
+  exclude: ({ expr, model, memory, stage, where }) => {
     // 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 })
+      return excludeModelRelations(excludedRelations, { stage, memory }, where)
     }
     if (FqnExpr.isWildcard(expr.incoming)) {
       // non-sense
@@ -46,7 +48,11 @@ export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming>
     }
 
     const isIncoming = filterIncomingConnections(resolveElements(model, expr.incoming))
-    const toExclude = memory.connections.filter(isIncoming)
+    const toExclude = pipe(
+      memory.connections,
+      filter(isIncoming),
+      applyPredicate(where),
+    )
     stage.excludeConnections(toExclude)
     return stage
   },

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

@@ -1,16 +1,17 @@
-import { anyPass } from 'remeda'
+import { anyPass, filter, pipe } from 'remeda'
 import { invariant } from '../../../errors'
 import type { LikeC4DeploymentModel } from '../../../model'
 import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
 import type { RelationshipModel } from '../../../model/RelationModel'
-import { FqnExpr, type RelationExpr } from '../../../types'
+import { type RelationExpr, FqnExpr } from '../../../types'
 import { isAncestor } from '../../../utils'
 import type { Connection, Elem, PredicateExecutor } from '../_types'
 import { resolveElements, resolveModelElements } from '../utils'
-import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
+import { resolveAscendingSiblings } from './relation-direct'
+import { applyPredicate, excludeModelRelations } from './utils'
 
 export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing> = {
-  include: ({ expr, model, memory, stage }) => {
+  include: ({ expr, model, memory, stage, where }) => {
     const targets = [...memory.elements]
 
     // * -> (to visible elements)
@@ -21,7 +22,8 @@ export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing>
           continue
         }
         for (const source of resolveAscendingSiblings(target)) {
-          stage.addConnections(findConnection(source, target, 'directed'))
+          const toInclude = applyPredicate(findConnection(source, target, 'directed'), where)
+          stage.addConnections(toInclude)
         }
       }
       return stage
@@ -30,16 +32,17 @@ export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing>
 
     const sources = resolveElements(model, expr.outgoing)
     for (const source of sources) {
-      stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+      const toInclude = applyPredicate(findConnectionsBetween(source, targets, 'directed'), where)
+      stage.addConnections(toInclude)
     }
 
     return stage
   },
-  exclude: ({ expr, model, memory, stage }) => {
+  exclude: ({ expr, model, memory, stage, where }) => {
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.outgoing)) {
       const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing)
-      return excludeModelRelations(excludedRelations, { stage, memory })
+      return excludeModelRelations(excludedRelations, { stage, memory }, where)
     }
     if (FqnExpr.isWildcard(expr.outgoing)) {
       // non-sense
@@ -47,7 +50,11 @@ export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing>
     }
 
     const isOutgoing = filterOutgoingConnections(resolveElements(model, expr.outgoing))
-    const toExclude = memory.connections.filter(isOutgoing)
+    const toExclude = pipe(
+      memory.connections,
+      filter(isOutgoing),
+      applyPredicate(where),
+    )
     stage.excludeConnections(toExclude)
     return stage
   },

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

@@ -0,0 +1,18 @@
+import { whereOperatorAsPredicate, type RelationExpr } from '../../../types'
+import type { PredicateExecutor } from '../_types'
+import type { StageExclude, StageInclude } from '../memory'
+import { predicateToPatch } from './utils'
+
+// relation matches the condition
+export const WhereRelationPredicate: PredicateExecutor<RelationExpr.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/utils.ts

@@ -0,0 +1,183 @@
+import { filter, isArray, map, pick, pipe } from 'remeda'
+import { nonexhaustive } from '../../../errors'
+import type { DeploymentConnectionModel } from '../../../model'
+import type { DeploymentElementModel, DeploymentRelationModel } from '../../../model/DeploymentElementModel'
+import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux } from '../../../model/types'
+import { type Filterable, type OperatorPredicate, FqnExpr, RelationExpr } from '../../../types'
+import { hasIntersection, intersection } from '../../../utils/set'
+import type { ExcludePredicateCtx, PredicateCtx } from '../_types'
+import type { StageExclude, StageInclude } from '../memory'
+import { DeploymentRefPredicate } from './elements'
+import { DirectRelationPredicate } from './relation-direct'
+import { InOutRelationPredicate } from './relation-in-out'
+import { IncomingRelationPredicate } from './relation-incoming'
+import { OutgoingRelationPredicate } from './relation-outgoing'
+import { WhereRelationPredicate } from './relation-where'
+import { WildcardPredicate } from './wildcard'
+
+/**
+ * Builds a patch object from an expression
+ */
+export function predicateToPatch(
+  op: 'include' | 'exclude',
+  { expr, where, ...ctx }: PredicateCtx,
+): StageExclude | StageInclude | undefined {
+  switch (true) {
+    case FqnExpr.isModelRef(expr):
+      // Ignore model refs in deployment view
+      return undefined
+    case FqnExpr.isDeploymentRef(expr):
+      return DeploymentRefPredicate[op]({ ...ctx, expr, where } as any)
+    case FqnExpr.isWildcard(expr):
+      return WildcardPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isDirect(expr):
+      return DirectRelationPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isInOut(expr):
+      return InOutRelationPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isOutgoing(expr):
+      return OutgoingRelationPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isIncoming(expr):
+      return IncomingRelationPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isWhere(expr):
+      return WhereRelationPredicate[op]({ ...ctx, expr, where } as any)
+    default:
+      nonexhaustive(expr)
+  }
+}
+
+export function excludeModelRelations(
+  relationsToExclude: ReadonlySet<RelationshipModel<AnyAux>>,
+  { stage, memory }: Pick<ExcludePredicateCtx, 'stage' | 'memory'>,
+  where: OperatorPredicate<Filterable> | null,
+  // 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,
+    filter(c => filterConnections(c)),
+    // Find connections that have at least one relation in common with the excluded relations
+    filter(c => hasIntersection(c.relations.model, relationsToExclude)),
+    map(c =>
+      c.update({
+        deployment: null,
+        model: intersection(c.relations.model, relationsToExclude),
+      })
+    ),
+    applyPredicate(where),
+    filter(c => c.nonEmpty()),
+  )
+  if (toExclude.length === 0) {
+    return stage
+  }
+  return stage.excludeConnections(toExclude)
+}
+
+export function matchConnection<M extends AnyAux>(
+  c: DeploymentConnectionModel<M>,
+  where: OperatorPredicate<Filterable> | null,
+): boolean {
+  return applyPredicate(c, where).nonEmpty()
+}
+
+/**
+ * Filters relations of the provided connections using the provided predicate.
+ * And copy of the connection with the filtered relations will be created.
+ * Connections left without relations are removed from resulting collection.
+ *
+ * @param c The connection to apply the predicate to
+ * @param where The predicate
+ * @returns A copy of the connection with the filtered relations
+ */
+export function applyPredicate<M extends AnyAux>(
+  c: readonly DeploymentConnectionModel<M>[],
+  where: OperatorPredicate<Filterable> | null,
+): readonly DeploymentConnectionModel<M>[]
+/**
+ * Filters relations of the connection using the provided predicate.
+ *
+ * @param c The connection to apply the predicate to
+ * @param where The predicate
+ * @returns A deep copy of the original collection with the filtered relations
+ */
+export function applyPredicate<M extends AnyAux>(
+  c: DeploymentConnectionModel<M>,
+  where: OperatorPredicate<Filterable> | null,
+): DeploymentConnectionModel<M>
+/**
+ * Creates a function that filters relations of the provided connections using the provided predicate.
+ * Connections left without relations are removed from resulting collection.
+ *
+ * @param c The connection to apply the predicate to
+ * @param where The predicate
+ * @returns A function to create a filtered copy of connections
+ */
+export function applyPredicate<M extends AnyAux>(
+  where: OperatorPredicate<Filterable> | null,
+): (data: readonly DeploymentConnectionModel<M>[]) => readonly DeploymentConnectionModel<M>[]
+export function applyPredicate<M extends AnyAux>(
+  ...args:
+    | [readonly DeploymentConnectionModel<M>[], OperatorPredicate<Filterable> | null]
+    | [OperatorPredicate<Filterable> | null]
+    | [c: DeploymentConnectionModel<M>, OperatorPredicate<Filterable> | null]
+):
+  | DeploymentConnectionModel<M>
+  | readonly DeploymentConnectionModel<M>[]
+  | ((data: readonly DeploymentConnectionModel<M>[]) => readonly DeploymentConnectionModel<M>[])
+{
+  if (args.length === 1) {
+    return x => applyPredicate(x, args[0])
+  }
+
+  const [c, where] = args
+  if (where === null) {
+    return c
+  }
+
+  if (isArray(c)) {
+    return c
+      .map(x => applyPredicate(x, where))
+      .filter(x => x.nonEmpty())
+  }
+
+  const map = toFilterableRelation(c.source, c.target)
+  return c.update({
+    model: new Set([...c.relations.model.values()].filter(r => where(map(r)))),
+    deployment: new Set([...c.relations.deployment.values()].filter(r => where(map(r)))),
+  })
+}
+
+export function matchConnections<M extends AnyAux>(
+  connections: readonly DeploymentConnectionModel<M>[],
+  where: OperatorPredicate<Filterable> | null,
+): readonly DeploymentConnectionModel[] {
+  if (!where) {
+    return connections
+  }
+
+  return pipe(
+    connections,
+    filter(c => matchConnection(c, where)),
+  )
+}
+
+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),
+  })
+}

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

@@ -37,7 +37,7 @@ export function treeFromMemoryState<T extends AnyCtx, M extends ComputeMemory<T>
     root: root as ReadonlySet<CtxElement<T>>,
     connected: connected as ReadonlySet<CtxElement<T>>,
     hasInOut: (el: CtxElement<T>) => memory.connections.some(Connection.isAnyInOut(el.id)),
-    parents: (el: CtxElement<T>) => children.get(el),
+    parent: (el: CtxElement<T>) => parents.get(el),
     children: (el: CtxElement<T>) => children.get(el),
   }
 }