@likec4/core 1.19.1 → 1.19.2

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/model/DeploymentElementModel.ts

@@ -11,6 +11,7 @@ import {
   type ElementShape as C4ElementShape,
   type IteratorLike,
   type Link,
+  type RelationshipKind,
   type Tag,
   type Tag as C4Tag,
   type ThemeColor,
@@ -62,6 +63,10 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
     return this.$node.tags ?? []
   }
 
+  get kind(): DeploymentNodeKind | string | null {
+    return this.$node.kind ?? null
+  }
+
   get description(): string | null {
     return this.$node.description ?? null
   }
@@ -223,7 +228,7 @@ export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDepl
     return this.$model.parent(this)
   }
 
-  get kind(): DeploymentNodeKind {
+  override get kind(): DeploymentNodeKind {
     return this.$node.kind
   }
 
@@ -367,6 +372,10 @@ export class DeployedInstanceModel<M extends AnyAux = AnyAux> extends AbstractDe
     return this.$instance.tags ?? []
   }
 
+  override get kind(): string | null {
+    return this.$instance.kind ?? null
+  }
+
   override get description(): string | null {
     return this.$instance.description ?? this.element.description
   }
@@ -514,6 +523,10 @@ export class DeploymentRelationModel<M extends AnyAux = AnyAux> {
     return this.$relationship.tags ?? []
   }
 
+  get kind(): RelationshipKind | null {
+    return this.$relationship.kind ?? null
+  }
+
   get navigateTo(): LikeC4ViewModel<M> | null {
     return this.$relationship.navigateTo ? this.$model.$model.view(this.$relationship.navigateTo) : null
   }

package/src/model/RelationModel.ts

@@ -67,6 +67,10 @@ export class RelationshipModel<M extends AnyAux = AnyAux> {
     return this.$relationship.tags ?? []
   }
 
+  get kind(): string | null {
+    return this.$relationship.kind ?? null
+  }
+
   get links(): ReadonlyArray<Link> {
     return this.$relationship.links ?? []
   }

package/src/model/connection/deployment/DeploymentConnectionModel.ts

@@ -110,11 +110,21 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
     yield* this.relations.deployment
   }
 
+  /**
+   * Merge with another connections, if it has the same source and target.
+   * Returns new connection with union of relationships.
+   */
+  public mergeWith(others: DeploymentConnectionModel<M>[]): DeploymentConnectionModel<M>
   /**
    * Merge with another connection, if it has the same source and target.
    * Returns new connection with union of relationships.
    */
-  public mergeWith(other: DeploymentConnectionModel<M>) {
+  public mergeWith(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>
+  public mergeWith(other: DeploymentConnectionModel<M> | DeploymentConnectionModel<M>[]): DeploymentConnectionModel<M> {
+    if (Array.isArray(other)) {
+      return other.reduce((acc, o) => acc.mergeWith(o), this)
+    }
+
     invariant(this.source.id === other.source.id, 'Cannot merge connections with different sources')
     invariant(this.target.id === other.target.id, 'Cannot merge connections with different targets')
     return new DeploymentConnectionModel(

package/src/types/deployments.ts

@@ -42,6 +42,7 @@ export interface DeployedInstance {
   readonly title?: string
   readonly description?: string | null
   readonly technology?: string | null
+  readonly kind?: string | null // TODO: ensure the property is set
   readonly tags?: NonEmptyArray<Tag> | null
   readonly links?: NonEmptyArray<Link> | null
   readonly style?: DeploymentElementStyle

package/src/types/expression-v2.ts

@@ -2,6 +2,7 @@ import { invariant } from '../errors'
 import type { ExclusiveUnion } from './_common'
 import type { DeploymentRef as DeploymentModelRef, PredicateSelector } from './deployments'
 import type { Fqn } from './element'
+import type { WhereOperator } from './operators'
 
 export namespace FqnRef {
   /**
@@ -131,6 +132,15 @@ export namespace RelationExpr {
   export const isInOut = (expr: ExpressionV2): expr is InOut => {
     return 'inout' in expr
   }
+  export type Where<D = Fqn, M = Fqn> = {
+    where: {
+      expr: ExpressionV2<D, M>
+      condition: WhereOperator<string, string>
+    }
+  }
+  export const isWhere = (expr: ExpressionV2): expr is Where => {
+    return 'where' in expr
+  }
 }
 
 export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
@@ -138,6 +148,7 @@ export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
+  Where: RelationExpr.Where<D, M>
 }>
 
 /**
@@ -154,6 +165,7 @@ export type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
+  RelationPredicateOrWhere: RelationExpr.Where<D, M>
 }>
 
 export namespace ExpressionV2 {

package/src/types/index.ts

@@ -121,6 +121,7 @@ export type {
   Filterable,
   KindEqual,
   NotOperator,
+  OperatorPredicate,
   OrOperator,
   TagEqual,
   WhereOperator,

package/src/types/operators.ts

@@ -61,19 +61,19 @@ export type WhereOperator<Tag, Kind> =
   | OrOperator<Tag, Kind>
 
 export type Filterable<
-  FTag extends string = string,
-  FKind extends string = string
+  FTag extends string | null = string | null,
+  FKind extends string | null = string | null,
 > = {
   tags?: readonly FTag[] | null
   kind?: FKind
 }
 
-type OperatorPredicate<V extends Filterable> = (value: V) => boolean
+export type OperatorPredicate<V extends Filterable> = (value: V) => boolean
 
 export function whereOperatorAsPredicate<
   FTag extends string = string,
-  FKind extends string = string
->(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable<FTag, FKind>> {
+  FKind extends string = string,
+>(operator: WhereOperator<FTag, FKind>): OperatorPredicate<Filterable> {
   switch (true) {
     case isTagEqual(operator): {
       if ('eq' in operator.tag) {