@likec4/core 1.41.0 → 1.42.1

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

@@ -1,101 +0,0 @@
-import { anyPass, filter, pipe } from 'remeda'
-import type { AnyAux, LikeC4DeploymentModel, RelationshipModel } from '../../../model'
-import { type RelationExpr, FqnExpr } from '../../../types'
-import { invariant, isAncestor } from '../../../utils'
-import type { Connection, Elem, PredicateExecutor } from '../_types'
-import { findConnectionsBetween, resolveElements, resolveModelElements } from '../utils'
-import { resolveAscendingSiblings } from './relation-direct'
-import { applyPredicate, excludeModelRelations } from './utils'
-
-// from visible element incoming to this
-export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming> = {
-  include: ({ expr, model, memory, stage, where }) => {
-    const sources = [...memory.elements]
-
-    if (FqnExpr.isWildcard(expr.incoming)) {
-      for (const source of sources) {
-        if (source.allOutgoing.isEmpty) {
-          continue
-        }
-        const targets = [...resolveAscendingSiblings(source)]
-        const toInclude = applyPredicate(findConnectionsBetween(source, targets, 'directed'), where)
-        stage.addConnections(toInclude)
-      }
-      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) {
-      const toInclude = applyPredicate(findConnectionsBetween(source, targets, 'directed'), where)
-      stage.addConnections(toInclude)
-    }
-
-    return stage
-  },
-  exclude: ({ expr, model, memory, stage, where }) => {
-    if (FqnExpr.isElementTagExpr(expr.incoming) || FqnExpr.isElementKindExpr(expr.incoming)) {
-      throw new Error('element kind and tag expressions are not supported in exclude')
-    }
-    // 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 }, where)
-    }
-    if (FqnExpr.isWildcard(expr.incoming)) {
-      // non-sense
-      return stage
-    }
-
-    const isIncoming = filterIncomingConnections(resolveElements(model, expr.incoming))
-    const toExclude = pipe(
-      memory.connections,
-      filter(isIncoming),
-      applyPredicate(where),
-    )
-    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<A extends AnyAux>(
-  model: LikeC4DeploymentModel<A>,
-  moodelRef: FqnExpr.ModelRef<A>,
-): Set<RelationshipModel<A>> {
-  const targets = resolveModelElements(model, moodelRef)
-  return new Set(targets.flatMap(e => [...e.allIncoming]))
-}

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

@@ -1,95 +0,0 @@
-import { anyPass, filter, pipe } from 'remeda'
-import type { AnyAux, LikeC4DeploymentModel, RelationshipModel } from '../../../model'
-import { type RelationExpr, FqnExpr } from '../../../types'
-import { invariant, isAncestor } from '../../../utils'
-import type { Connection, Elem, PredicateExecutor } from '../_types'
-import { findConnection, findConnectionsBetween, resolveElements, resolveModelElements } from '../utils'
-import { resolveAscendingSiblings } from './relation-direct'
-import { applyPredicate, excludeModelRelations } from './utils'
-
-export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing> = {
-  include: ({ expr, model, memory, stage, where }) => {
-    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)) {
-          const toInclude = applyPredicate(findConnection(source, target, 'directed'), where)
-          stage.addConnections(toInclude)
-        }
-      }
-      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) {
-      const toInclude = applyPredicate(findConnectionsBetween(source, targets, 'directed'), where)
-      stage.addConnections(toInclude)
-    }
-
-    return stage
-  },
-  exclude: ({ expr, model, memory, stage, where }) => {
-    if (FqnExpr.isElementTagExpr(expr.outgoing) || FqnExpr.isElementKindExpr(expr.outgoing)) {
-      throw new Error('element kind and tag expressions are not supported in exclude')
-    }
-    // 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 }, where)
-    }
-    if (FqnExpr.isWildcard(expr.outgoing)) {
-      // non-sense
-      return stage
-    }
-
-    const isOutgoing = filterOutgoingConnections(resolveElements(model, expr.outgoing))
-    const toExclude = pipe(
-      memory.connections,
-      filter(isOutgoing),
-      applyPredicate(where),
-    )
-    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<A extends AnyAux>(
-  model: LikeC4DeploymentModel<A>,
-  moodelRef: FqnExpr.ModelRef<A>,
-): Set<RelationshipModel<A>> {
-  const targets = resolveModelElements(model, moodelRef)
-  return new Set(targets.flatMap(e => [...e.allOutgoing]))
-}

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

@@ -1,18 +0,0 @@
-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

@@ -1,282 +0,0 @@
-import { filter, isArray, map, pick, pipe } from 'remeda'
-import type {
-  DeploymentElementModel,
-  DeploymentRelationEndpoint,
-  DeploymentRelationModel,
-  RelationshipModel,
-} from '../../../model'
-import {
-  type DeploymentConnectionModel,
-  ElementModel,
-  isDeployedInstanceModel as isDeployedInstance,
-  isDeploymentElementModel,
-  isDeploymentNodeModel as isDeploymentNode,
-  isElementModel,
-  isNestedElementOfDeployedInstanceModel,
-} from '../../../model'
-import type { AnyAux } from '../../../types'
-import { type Filterable, type OperatorPredicate, FqnExpr, RelationExpr } from '../../../types'
-import { nonexhaustive } from '../../../utils'
-import { hasIntersection, intersection } from '../../../utils/set'
-import type { ExcludePredicateCtx, PredicateCtx } from '../_types'
-import type { StageExclude, StageInclude } from '../memory'
-import { DeploymentRefPredicate } from './deploymentRefs'
-import { WhereDeploymentRefPredicate } from './deploymentRefs-where'
-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.isElementTagExpr(expr):
-    case FqnExpr.isElementKindExpr(expr):
-      throw new Error('element kind and tag expressions are not supported in deployment view rules')
-    case RelationExpr.isCustom(expr):
-    case FqnExpr.isCustom(expr):
-    case FqnExpr.isModelRef(expr):
-      // Ignore model refs in deployment view
-      return undefined
-    case FqnExpr.isWhere(expr):
-      return WhereDeploymentRefPredicate[op]({ ...ctx, expr, where } as any)
-    case RelationExpr.isWhere(expr):
-      return WhereRelationPredicate[op]({ ...ctx, expr, where } as any)
-    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)
-    default:
-      nonexhaustive(expr)
-  }
-}
-
-export function excludeModelRelations<M extends AnyAux>(
-  relationsToExclude: ReadonlySet<RelationshipModel<M>>,
-  { stage, memory }: Pick<ExcludePredicateCtx, 'stage' | 'memory'>,
-  where: OperatorPredicate<M> | null,
-  // Optional filter to scope the connections to exclude
-  filterConnections: (c: DeploymentConnectionModel<M>) => boolean = () => true,
-): StageExclude {
-  if (relationsToExclude.size === 0) {
-    return stage
-  }
-  const toExclude = pipe(
-    memory.connections as unknown as readonly DeploymentConnectionModel<M>[],
-    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 as unknown as DeploymentConnectionModel[])
-}
-
-export function matchConnection<M extends AnyAux>(
-  c: DeploymentConnectionModel<M>,
-  where: OperatorPredicate<M> | 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<M> | 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<M> | 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<M> | null,
-): (data: readonly DeploymentConnectionModel<M>[]) => readonly DeploymentConnectionModel<M>[]
-export function applyPredicate<M extends AnyAux>(
-  ...args:
-    | [readonly DeploymentConnectionModel<M>[], OperatorPredicate<M> | null]
-    | [OperatorPredicate<M> | null]
-    | [c: DeploymentConnectionModel<M>, OperatorPredicate<M> | 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())
-  }
-
-  return c.update({
-    model: new Set([...c.relations.model.values()].filter(r => where(toFilterableRelation(c)(r)))),
-    deployment: new Set([...c.relations.deployment.values()].filter(r => where(toFilterableRelation(c)(r)))),
-  })
-}
-
-/**
- * Checks elements using the provided predicate.
- *
- * @param c The collection of element to apply the predicate to
- * @param where The predicate
- * @returns Returns array of elements those match the predicate
- */
-export function applyElementPredicate<M extends AnyAux>(
-  c: readonly DeploymentElementModel<M>[],
-  where: OperatorPredicate<M> | null,
-): readonly DeploymentElementModel<M>[]
-/**
- * Checks element using the provided predicate.
- *
- * @param c The element to apply the predicate to
- * @param where The predicate
- * @returns The result of the check
- */
-export function applyElementPredicate<M extends AnyAux, E extends DeploymentElementModel<M>>(
-  c: E,
-  where: OperatorPredicate<M> | null,
-): boolean
-/**
- * Creates a function that filters elemetns using the provided predicate.
- *
- * @param where The predicate
- * @returns A function to filter elements
- */
-export function applyElementPredicate<M extends AnyAux, E extends DeploymentElementModel<M>>(
-  where: OperatorPredicate<M> | null,
-): (data: readonly E[]) => readonly E[]
-export function applyElementPredicate<M extends AnyAux, E extends DeploymentElementModel<M>>(
-  ...args:
-    | [readonly E[], OperatorPredicate<M> | null]
-    | [OperatorPredicate<M> | null]
-    | [c: E, OperatorPredicate<M> | null]
-):
-  | boolean
-  | readonly E[]
-  | ((data: readonly E[]) => readonly E[])
-{
-  if (args.length === 1) {
-    return x => applyElementPredicate(x, args[0]) as readonly E[]
-  }
-
-  const [c, where] = args
-
-  if (isArray(c)) {
-    return c.filter(x => applyElementPredicate(x, where))
-  }
-
-  return where?.(toFilterable(c, c)) ?? true
-}
-
-export function matchConnections<M extends AnyAux>(
-  connections: readonly DeploymentConnectionModel<M>[],
-  where: OperatorPredicate<M> | null,
-): readonly DeploymentConnectionModel<M>[] {
-  if (!where) {
-    return connections
-  }
-
-  return pipe(
-    connections,
-    filter(c => matchConnection(c, where)),
-  )
-}
-
-/**
- * Builds filterable presentation for relation endpoint. Enriches model properties with deployment properties when needed.
- * @param relationEndpoint Endpoint for which to build presentation
- * @param connectionEndpoint Endpoint of connection which was build from the relation.
- * @returns Presentation of the endpoint for usage in predicates
- */
-function toFilterable<M extends AnyAux>(
-  relationEndpoint: ElementModel<M> | DeploymentRelationEndpoint<M>,
-  connectionEndpoint: DeploymentRelationEndpoint<M>,
-): Filterable<M> {
-  if (isElementModel<M>(relationEndpoint)) { // Element itself. Extend with tags of the deployed instance (TODO)
-    const deployedInstance = isDeploymentElementModel<M>(connectionEndpoint) && isDeployedInstance(connectionEndpoint)
-      ? connectionEndpoint
-      : null
-    return {
-      kind: relationEndpoint.kind,
-      tags: [...relationEndpoint.tags, ...(deployedInstance?.tags ?? [])],
-    }
-  }
-  if (isNestedElementOfDeployedInstanceModel(relationEndpoint)) { // Nested element. Has no own instance. No need to extend
-    return pick(relationEndpoint.element, ['tags', 'kind'])
-  }
-  if (isDeployedInstance(relationEndpoint)) { // Deployed instance. Extend with tags of the model element
-    return {
-      kind: relationEndpoint.element.kind,
-      tags: [...relationEndpoint.tags, ...relationEndpoint.element.tags],
-    }
-  }
-  if (isDeploymentNode(relationEndpoint)) { // Deployment node. Has no representation in model. No need to extend
-    return pick(relationEndpoint, ['tags', 'kind'])
-  }
-
-  nonexhaustive(relationEndpoint)
-}
-
-function toFilterableRelation<M extends AnyAux>(c: DeploymentConnectionModel<M>) {
-  return (relation: RelationshipModel<M> | DeploymentRelationModel<M>) => ({
-    tags: relation.tags,
-    kind: relation.kind,
-    source: toFilterable(relation.source, c.source),
-    target: toFilterable(relation.target, c.target),
-  })
-}

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

@@ -1,41 +0,0 @@
-import { map, pipe } from 'remeda'
-import type { FqnExpr } from '../../../types'
-import { type Elem, type PredicateExecutor } from '../_types'
-import { findConnectionsWithin } from '../utils'
-import { applyElementPredicate } from './utils'
-
-export const WildcardPredicate: PredicateExecutor<FqnExpr.Wildcard> = {
-  include: ({ model, stage, where }) => {
-    const children = [] as Elem[]
-
-    const rootElements = pipe(
-      [...model.roots()],
-      applyElementPredicate(where),
-      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, where }) => {
-    const elementsToExclude = pipe(
-      [...memory.elements],
-      applyElementPredicate(where),
-    )
-
-    stage.exclude(elementsToExclude)
-
-    return stage
-  },
-}

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

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