@likec4/core 1.17.1 → 1.19.0

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

@@ -0,0 +1,237 @@
+import { filter, flatMap, isNonNullish, map, pipe } from 'remeda'
+import { invariant } from '../../../errors'
+import type { 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 { deploymentExpressionToPredicate, resolveElements, resolveModelElements } from '../utils'
+import { filterIncomingConnections, resolveAllImcomingRelations } from './relation-incoming'
+import { filterOutgoingConnections, resolveAllOutgoingRelations } from './relation-outgoing'
+
+// const isRef = DeploymentElementExpression.isRef
+
+export const resolveAscendingSiblings = (element: DeploymentElementModel) => {
+  const siblings = new Set<DeploymentElementModel>()
+  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 resolveWildcard = (model: LikeC4DeploymentModel, nonWildcard: FqnExpr.DeploymentRef) => {
+  const sources = resolveElements(model, nonWildcard)
+  return sources.map(source => {
+    const targets = resolveAscendingSiblings(source)
+    return [source, targets] as const
+  })
+}
+
+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 connections
+
+    switch (true) {
+      // * -> *
+      case sourceIsWildcard && targetIsWildcard: {
+        connections = findConnectionsWithin(model.instances()).map(c => {
+          stage.addImplicit(c.boundary)
+          return c
+        })
+        break
+      }
+
+      // 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
+      }
+      // * -> 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(!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)
+
+        const isSource = filterOutgoingConnections(sources)
+        const isTarget = filterIncomingConnections(targets)
+
+        connections = pipe(
+          sources,
+          flatMap(s => findConnectionsBetween(s, targets, dir)),
+          filter(c => isSource(c) && isTarget(c)),
+        )
+      }
+    }
+
+    stage.addConnections(connections)
+
+    if (FqnExpr.isDeploymentRef(source) && isNonNullish(source.selector)) {
+      stage.addImplicit(model.element(source.ref.deployment))
+    }
+    if (FqnExpr.isDeploymentRef(target) && isNonNullish(target.selector)) {
+      stage.addImplicit(model.element(target.ref.deployment))
+    }
+
+    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
+    }
+
+    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))
+        || (expr.isBidirectional && isSource(connection.target) && isTarget(connection.source))
+    }
+
+    const toExclude = memory.connections.filter(satisfies)
+
+    stage.excludeConnections(toExclude)
+    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

@@ -0,0 +1,61 @@
+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 { union } from '../../../utils/set'
+import type { PredicateExecutor } from '../_types'
+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<RelationExpr.InOut> = {
+  include: ({ expr, model, memory, stage }) => {
+    const sources = [...memory.elements]
+
+    if (FqnExpr.isWildcard(expr.inout)) {
+      for (const source of sources) {
+        const targets = [...resolveAscendingSiblings(source)]
+        stage.addConnections(findConnectionsBetween(source, targets, 'both'))
+      }
+      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
+  },
+  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 })
+    }
+
+    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
+  },
+}

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

@@ -0,0 +1,95 @@
+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<RelationExpr.Incoming> = {
+  include: ({ expr, model, memory, stage }) => {
+    const sources = [...memory.elements]
+
+    if (FqnExpr.isWildcard(expr.incoming)) {
+      for (const source of sources) {
+        if (source.allOutgoing.isEmpty) {
+          continue
+        }
+        const targets = [...resolveAscendingSiblings(source)]
+        stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+      }
+      return stage
+    }
+    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
+  },
+  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 })
+    }
+    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
+  },
+}
+
+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]))
+}

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

@@ -0,0 +1,88 @@
+import { anyPass } 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 { isAncestor } from '../../../utils'
+import type { Connection, Elem, PredicateExecutor } from '../_types'
+import { resolveElements, resolveModelElements } from '../utils'
+import { excludeModelRelations, resolveAscendingSiblings } from './relation-direct'
+
+export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing> = {
+  include: ({ expr, model, memory, stage }) => {
+    const targets = [...memory.elements]
+
+    // * -> (to visible elements)
+    // outgoing from wildcard to visible element
+    if (FqnExpr.isWildcard(expr.outgoing)) {
+      for (const target of targets) {
+        if (target.allIncoming.isEmpty) {
+          continue
+        }
+        for (const source of resolveAscendingSiblings(target)) {
+          stage.addConnections(findConnection(source, target, 'directed'))
+        }
+      }
+      return stage
+    }
+    invariant(FqnExpr.isDeploymentRef(expr.outgoing), 'Only deployment refs are supported in include')
+
+    const sources = resolveElements(model, expr.outgoing)
+    for (const source of sources) {
+      stage.addConnections(findConnectionsBetween(source, targets, 'directed'))
+    }
+
+    return stage
+  },
+  exclude: ({ expr, model, memory, stage }) => {
+    // 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 })
+    }
+    if (FqnExpr.isWildcard(expr.outgoing)) {
+      // non-sense
+      return stage
+    }
+
+    const isOutgoing = filterOutgoingConnections(resolveElements(model, expr.outgoing))
+    const toExclude = memory.connections.filter(isOutgoing)
+    stage.excludeConnections(toExclude)
+    return stage
+  },
+}
+
+export function filterOutgoingConnections(
+  sources: Elem[],
+): (connection: Connection) => boolean {
+  return anyPass(
+    sources.map(source => {
+      const satisfies = (el: Elem) => el === source || isAncestor(source, el)
+      return (connection: Connection) => {
+        return satisfies(connection.source) && !satisfies(connection.target)
+      }
+    }),
+  )
+  // if (FqnExpr.isDeploymentRef(expr) && isNullish(expr.selector)) {
+  //   // element ->
+  //   const source = model.element(expr.ref.deployment)
+  //   const isInside = (el: Elem) => el === source || isAncestor(source, el)
+  //   return (connection: Connection) => {
+  //     return isInside(connection.source) && !isInside(connection.target)
+  //   }
+  // } else {
+  //   const isSource = deploymentExpressionToPredicate(expr)
+  //   return (connection: Connection) => {
+  //     return isSource(connection.source)
+  //   }
+  // }
+}
+
+export function resolveAllOutgoingRelations(
+  model: LikeC4DeploymentModel,
+  moodelRef: FqnExpr.ModelRef,
+): Set<RelationshipModel> {
+  const targets = resolveModelElements(model, moodelRef)
+  return new Set(targets.flatMap(e => [...e.allOutgoing]))
+}

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

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

package/src/compute-view/deployment-view/stages/stage-exclude.ts

@@ -0,0 +1,5 @@
+import { AbstractStageExclude } from '../../memory'
+import { type Ctx } from '../memory/memory'
+
+export class StageExclude extends AbstractStageExclude<Ctx> {
+}