@likec4/core 1.31.0 → 1.32.0

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

@@ -1,16 +1,22 @@
 import { filter, isArray, map, pick, pipe } from 'remeda'
-import { nonexhaustive } from '../../../errors'
-import { type DeploymentConnectionModel, ElementModel, isDeployedInstance, isDeploymentNode } from '../../../model'
 import type {
   DeploymentElementModel,
   DeploymentRelationEndpoint,
   DeploymentRelationModel,
-} from '../../../model/DeploymentElementModel'
-import { isElementModel } from '../../../model/ElementModel'
-import { isDeploymentElementModel, isNestedElementOfDeployedInstanceModel } from '../../../model/guards'
-import type { RelationshipModel } from '../../../model/RelationModel'
-import type { AnyAux } from '../../../model/types'
+  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'
@@ -60,18 +66,18 @@ export function predicateToPatch(
   }
 }
 
-export function excludeModelRelations(
-  relationsToExclude: ReadonlySet<RelationshipModel<AnyAux>>,
+export function excludeModelRelations<M extends AnyAux>(
+  relationsToExclude: ReadonlySet<RelationshipModel<M>>,
   { stage, memory }: Pick<ExcludePredicateCtx, 'stage' | 'memory'>,
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
   // Optional filter to scope the connections to exclude
-  filterConnections: (c: DeploymentConnectionModel) => boolean = () => true,
+  filterConnections: (c: DeploymentConnectionModel<M>) => boolean = () => true,
 ): StageExclude {
   if (relationsToExclude.size === 0) {
     return stage
   }
   const toExclude = pipe(
-    memory.connections,
+    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)),
@@ -87,12 +93,12 @@ export function excludeModelRelations(
   if (toExclude.length === 0) {
     return stage
   }
-  return stage.excludeConnections(toExclude)
+  return stage.excludeConnections(toExclude as unknown as DeploymentConnectionModel[])
 }
 
 export function matchConnection<M extends AnyAux>(
   c: DeploymentConnectionModel<M>,
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
 ): boolean {
   return applyPredicate(c, where).nonEmpty()
 }
@@ -108,7 +114,7 @@ export function matchConnection<M extends AnyAux>(
  */
 export function applyPredicate<M extends AnyAux>(
   c: readonly DeploymentConnectionModel<M>[],
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
 ): readonly DeploymentConnectionModel<M>[]
 /**
  * Filters relations of the connection using the provided predicate.
@@ -119,7 +125,7 @@ export function applyPredicate<M extends AnyAux>(
  */
 export function applyPredicate<M extends AnyAux>(
   c: DeploymentConnectionModel<M>,
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
 ): DeploymentConnectionModel<M>
 /**
  * Creates a function that filters relations of the provided connections using the provided predicate.
@@ -130,13 +136,13 @@ export function applyPredicate<M extends AnyAux>(
  * @returns A function to create a filtered copy of connections
  */
 export function applyPredicate<M extends AnyAux>(
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | 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]
+    | [readonly DeploymentConnectionModel<M>[], OperatorPredicate<M> | null]
+    | [OperatorPredicate<M> | null]
+    | [c: DeploymentConnectionModel<M>, OperatorPredicate<M> | null]
 ):
   | DeploymentConnectionModel<M>
   | readonly DeploymentConnectionModel<M>[]
@@ -172,7 +178,7 @@ export function applyPredicate<M extends AnyAux>(
  */
 export function applyElementPredicate<M extends AnyAux>(
   c: readonly DeploymentElementModel<M>[],
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
 ): readonly DeploymentElementModel<M>[]
 /**
  * Checks element using the provided predicate.
@@ -183,7 +189,7 @@ export function applyElementPredicate<M extends AnyAux>(
  */
 export function applyElementPredicate<M extends AnyAux, E extends DeploymentElementModel<M>>(
   c: E,
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
 ): boolean
 /**
  * Creates a function that filters elemetns using the provided predicate.
@@ -192,13 +198,13 @@ export function applyElementPredicate<M extends AnyAux, E extends DeploymentElem
  * @returns A function to filter elements
  */
 export function applyElementPredicate<M extends AnyAux, E extends DeploymentElementModel<M>>(
-  where: OperatorPredicate<Filterable> | null,
+  where: OperatorPredicate<M> | null,
 ): (data: readonly E[]) => readonly E[]
 export function applyElementPredicate<M extends AnyAux, E extends DeploymentElementModel<M>>(
   ...args:
-    | [readonly E[], OperatorPredicate<Filterable> | null]
-    | [OperatorPredicate<Filterable> | null]
-    | [c: E, OperatorPredicate<Filterable> | null]
+    | [readonly E[], OperatorPredicate<M> | null]
+    | [OperatorPredicate<M> | null]
+    | [c: E, OperatorPredicate<M> | null]
 ):
   | boolean
   | readonly E[]
@@ -219,8 +225,8 @@ export function applyElementPredicate<M extends AnyAux, E extends DeploymentElem
 
 export function matchConnections<M extends AnyAux>(
   connections: readonly DeploymentConnectionModel<M>[],
-  where: OperatorPredicate<Filterable> | null,
-): readonly DeploymentConnectionModel[] {
+  where: OperatorPredicate<M> | null,
+): readonly DeploymentConnectionModel<M>[] {
   if (!where) {
     return connections
   }
@@ -240,9 +246,9 @@ export function matchConnections<M extends AnyAux>(
 function toFilterable<M extends AnyAux>(
   relationEndpoint: ElementModel<M> | DeploymentRelationEndpoint<M>,
   connectionEndpoint: DeploymentRelationEndpoint<M>,
-): Filterable {
-  if (isElementModel(relationEndpoint)) { // Element itself. Extend with tags of the deployed instance (TODO)
-    const deployedInstance = isDeploymentElementModel(connectionEndpoint) && isDeployedInstance(connectionEndpoint)
+): 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 {

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

@@ -1,7 +1,7 @@
 import { map, pipe } from 'remeda'
-import { findConnectionsWithin } from '../../../model/connection/deployment'
 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> = {
@@ -16,7 +16,8 @@ export const WildcardPredicate: PredicateExecutor<FqnExpr.Wildcard> = {
           children.push(...root.children())
         }
         return root
-      }))
+      }),
+    )
 
     stage.addExplicit(rootElements)
     if (children.length > 1) {

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

@@ -1,6 +1,6 @@
 import { forEach, only, pipe } from 'remeda'
-import { differenceConnections } from '../../../model/connection'
-import type { RelationshipModel } from '../../../model/RelationModel'
+import { differenceConnections } from '../../../model'
+import type { RelationshipModel } from '../../../model'
 import { isAncestor, sortByFqnHierarchically } from '../../../utils/fqn'
 import { ifilter, isome, toArray } from '../../../utils/iterable'
 import { DefaultMap } from '../../../utils/mnemonist'

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

@@ -1,10 +1,10 @@
 import { dropWhile, forEach, pipe, take, zip } from 'remeda'
-import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
 import { isIterable } from '../../../utils'
 import { toArray } from '../../../utils/iterable'
 import { type CtxConnection, type CtxElement, AbstractStageInclude } from '../../memory'
 import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
 import { type Ctx } from '../memory/memory'
+import { findConnection, findConnectionsBetween } from '../utils'
 
 type Elem = CtxElement<Ctx>
 type Connection = CtxConnection<Ctx>

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

@@ -1,34 +1,39 @@
-import { hasAtLeast, isEmpty, isNumber, isString } from 'remeda'
-import { invariant, nonexhaustive } from '../../errors'
-import type { LikeC4DeploymentModel } from '../../model'
-import type { DeploymentConnectionModel } from '../../model/connection/deployment'
-import type { ElementModel } from '../../model/ElementModel'
-import type { AnyAux } from '../../model/types'
+import { hasAtLeast, isEmpty, unique } from 'remeda'
+import type {
+  DeployedInstanceModel,
+  DeploymentConnectionModel,
+  DeploymentElementModel,
+  DeploymentNodeModel,
+  ElementModel,
+  LikeC4DeploymentModel,
+} from '../../model'
+import { deploymentConnection } from '../../model'
 import {
+  type AnyAux,
+  type aux,
   type ComputedEdge,
   type ComputedNode,
-  type DeploymentNodeKind,
   type DeploymentViewRule,
-  type Fqn,
-  type NonEmptyArray,
-  type Tag,
+  type scalar,
+  type Unknown,
   DefaultArrowType,
   FqnExpr,
   isViewRuleStyle,
 } from '../../types'
-import { nameFromFqn, parentFqn } from '../../utils'
+import { invariant, nameFromFqn, nonexhaustive, parentFqn } from '../../utils'
 import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
 import { type ComputedNodeSource, buildComputedNodes } from '../utils/buildComputedNodes'
 import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
-import { uniqueTags } from '../utils/uniqueTags'
-import type { Elem, Memory } from './_types'
+import type { Memory } from './_types'
+
+export const { findConnection, findConnectionsBetween, findConnectionsWithin } = deploymentConnection
 
 type Predicate<T> = (x: T) => boolean
 
-export function resolveElements(
-  model: LikeC4DeploymentModel,
-  expr: FqnExpr.DeploymentRef,
-): Elem[] {
+export function resolveElements<A extends AnyAux>(
+  model: LikeC4DeploymentModel<A>,
+  expr: FqnExpr.DeploymentRef<A>,
+): DeploymentElementModel<A>[] {
   const ref = model.element(expr.ref.deployment)
   if (ref.isDeploymentNode()) {
     if (expr.selector === 'children') {
@@ -44,10 +49,10 @@ export function resolveElements(
   return [ref]
 }
 
-export function resolveModelElements(
-  model: LikeC4DeploymentModel,
-  expr: FqnExpr.ModelRef,
-): ElementModel[] {
+export function resolveModelElements<A extends AnyAux>(
+  model: LikeC4DeploymentModel<A>,
+  expr: FqnExpr.ModelRef<A>,
+): ElementModel<A>[] {
   const ref = model.$model.element(expr.ref.model)
   if (expr.selector === 'children') {
     return [...ref.children()]
@@ -61,9 +66,12 @@ export function resolveModelElements(
   return [ref]
 }
 
-export function deploymentExpressionToPredicate<T extends { id: string; modelRef?: number | string }>(
-  target: FqnExpr,
-): Predicate<T> {
+export function deploymentExpressionToPredicate<
+  A extends AnyAux,
+  N extends { id: string | aux.DeploymentFqn<A>; modelRef?: aux.Fqn<A> | undefined },
+>(
+  target: FqnExpr<A>,
+): Predicate<N> {
   if (FqnExpr.isWildcard(target)) {
     return () => true
   }
@@ -86,21 +94,11 @@ export function deploymentExpressionToPredicate<T extends { id: string; modelRef
     return n => n.id === fqn
   }
   if (FqnExpr.isModelRef(target)) {
-    const modelFqn = (node: T) => {
-      if (isString(node.modelRef)) {
-        return node.modelRef
-      }
-      if (isNumber(node.modelRef)) {
-        return node.id
-      }
-      return null
-    }
-
     const fqn = target.ref.model
     if (target.selector === 'expanded') {
       const fqnWithDot = fqn + '.'
-      return (n) => {
-        const m = modelFqn(n)
+      return (n: N) => {
+        const m = n.modelRef ?? null
         if (!m) {
           return true
         }
@@ -109,8 +107,8 @@ export function deploymentExpressionToPredicate<T extends { id: string; modelRef
     }
     if (target.selector === 'descendants') {
       const fqnWithDot = fqn + '.'
-      return (n) => {
-        const m = modelFqn(n)
+      return (n: N) => {
+        const m = n.modelRef ?? null
         if (!m) {
           return true
         }
@@ -118,16 +116,16 @@ export function deploymentExpressionToPredicate<T extends { id: string; modelRef
       }
     }
     if (target.selector === 'children') {
-      return (n) => {
-        const m = modelFqn(n)
+      return (n: N) => {
+        const m = n.modelRef ?? null
         if (!m) {
           return true
         }
         return parentFqn(m) === fqn
       }
     }
-    return (n) => {
-      const m = modelFqn(n)
+    return (n: N) => {
+      const m = n.modelRef ?? null
       if (!m) {
         return true
       }
@@ -137,15 +135,21 @@ export function deploymentExpressionToPredicate<T extends { id: string; modelRef
   nonexhaustive(target)
 }
 
-export function toNodeSource(el: Elem): ComputedNodeSource {
+export function toNodeSource<A extends AnyAux>(
+  el: DeploymentNodeModel<A> | DeployedInstanceModel<A>,
+): ComputedNodeSource<A> {
   if (el.isDeploymentNode()) {
     const onlyOneInstance = el.onlyOneInstance()
     let { title, kind, id, ...$node } = el.$node
     const { icon, color, shape, ...style } = el.$node.style ?? {}
-
-    // If there is only one instance and title was not overriden
-    if (onlyOneInstance && title === nameFromFqn(el.id)) {
-      title = onlyOneInstance.title
+    let tags = [...el.tags]
+    // If there is only one instance
+    if (onlyOneInstance) {
+      tags = unique([...tags, ...onlyOneInstance.tags])
+      // If title was not overriden
+      if (title === nameFromFqn(el.id)) {
+        title = onlyOneInstance.title
+      }
     }
 
     return {
@@ -158,41 +162,42 @@ export function toNodeSource(el: Elem): ComputedNodeSource {
       ...(icon && { icon }),
       ...(color && { color }),
       ...(shape && { shape }),
+      tags,
       style: {
         ...style,
       },
-      deploymentRef: 1,
+      deploymentRef: id,
       kind,
-      id,
+      id: id as scalar.NodeId,
     }
   }
   invariant(el.isInstance(), 'Expected Instance')
   const instance = el.$instance
-  const element = el.element.$element
+  const element = el.element
 
   const icon = instance.style?.icon ?? element.icon
   const color = instance.style?.color ?? element.color
   const shape = instance.style?.shape ?? element.shape
 
   const links = [
-    ...(element.links ?? []),
+    ...element.links,
     ...(instance.links ?? []),
   ]
 
   const metadata = {
-    ...element.metadata,
+    ...element.getMetadata(),
     ...instance.metadata,
   }
 
-  const notation = instance.notation ?? element.notation
+  const notation = instance.notation ?? element.$element.notation
 
   return {
-    id: el.id,
-    kind: 'instance' as DeploymentNodeKind,
+    id: el.id as scalar.NodeId,
+    kind: 'instance' as unknown as aux.DeploymentKind<A>,
     title: instance.title ?? element.title,
     description: instance.description ?? element.description,
     technology: instance.technology ?? element.technology,
-    tags: uniqueTags([element, instance]) as NonEmptyArray<Tag>,
+    tags: [...el.tags],
     links: hasAtLeast(links, 1) ? links : null,
     ...icon && { icon },
     ...color && { color },
@@ -201,16 +206,16 @@ export function toNodeSource(el: Elem): ComputedNodeSource {
       ...element.style,
       ...instance.style,
     },
-    deploymentRef: el.id === instance.id ? 1 : instance.id,
-    modelRef: el.id === element.id ? 1 : element.id,
+    deploymentRef: instance.id,
+    modelRef: element.id,
     ...notation && { notation },
     ...!isEmpty(metadata) && ({ metadata }),
   }
 }
 
-export function toComputedEdges<M extends AnyAux>(
-  connections: ReadonlyArray<DeploymentConnectionModel<M>>,
-): ComputedEdge[] {
+export function toComputedEdges<A extends AnyAux>(
+  connections: ReadonlyArray<DeploymentConnectionModel<A>>,
+): ComputedEdge<A>[] {
   return connections.reduce((acc, e) => {
     // const modelRelations = []
     // const deploymentRelations = []
@@ -220,21 +225,21 @@ export function toComputedEdges<M extends AnyAux>(
     ]
     invariant(hasAtLeast(relations, 1), 'Edge must have at least one relation')
 
-    const source = e.source.id
-    const target = e.target.id
+    const source = e.source.id as scalar.NodeId
+    const target = e.target.id as scalar.NodeId
 
     const {
       title,
       ...props
     } = mergePropsFromRelationships(relations.map(r => r.$relationship)) // || relations.find(r => r.source === source && r.target === target)
 
-    const edge: ComputedEdge = {
+    const edge: ComputedEdge<A> = {
       id: e.id,
-      parent: e.boundary?.id ?? null,
+      parent: e.boundary?.id as scalar.NodeId ?? null,
       source,
       target,
       label: title ?? null,
-      relations: relations.map((r) => r.id as M['RelationId']),
+      relations: relations.map((r) => r.id),
       ...props,
     }
 
@@ -257,17 +262,19 @@ export function toComputedEdges<M extends AnyAux>(
 
     acc.push(edge)
     return acc
-  }, [] as ComputedEdge[])
+  }, [] as ComputedEdge<A>[])
 }
 
-export function buildNodes(memory: Memory): ReadonlyMap<Fqn, ComputedNode> {
+export function buildNodes<A extends AnyAux = Unknown>(
+  memory: Memory,
+): ReadonlyMap<aux.NodeId, ComputedNode<A>> {
   return buildComputedNodes([...memory.final].map(toNodeSource))
 }
 
-export function applyDeploymentViewRuleStyles(
-  rules: DeploymentViewRule[],
-  nodes: ComputedNode[],
-): ComputedNode[] {
+export function applyDeploymentViewRuleStyles<A extends AnyAux>(
+  rules: DeploymentViewRule<A>[],
+  nodes: ComputedNode<A>[],
+): ComputedNode<A>[] {
   for (const rule of rules) {
     if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
       continue

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

@@ -1,17 +1,24 @@
 import { partition } from 'remeda'
-import type { DynamicViewRule, DynamicViewStep, Fqn, ViewId, ViewRulePredicate } from '../../../types'
-import { type FakeElementIds, fakeModel } from '../../element-view/__test__/fixture'
+import type {
+  DynamicViewIncludeRule,
+  DynamicViewRule,
+  DynamicViewStep,
+  ElementViewPredicate,
+  Fqn,
+  ParsedDynamicView as DynamicView,
+  ViewId,
+} from '../../../types'
+import { type $Aux, type FakeElementIds, fakeModel } from '../../element-view/__test__/fixture'
 import { computeDynamicView } from '../compute'
 
 const emptyView = {
-  __: 'dynamic' as const,
+  _type: 'dynamic' as const,
   id: 'index' as ViewId,
   title: null,
   description: null,
   tags: null,
   links: null,
-  customColorDefinitions: {},
-  rules: []
+  rules: [],
 }
 
 type StepExpr = `${FakeElementIds} ${'->' | '<-'} ${FakeElementIds}`
@@ -25,7 +32,7 @@ export function $step(expr: StepExpr, props?: string | Partial<StepProps>): Dyna
       source: source as Fqn,
       target: target as Fqn,
       ...(typeof props === 'object' ? props : {}),
-      title: title ?? null
+      title: title ?? null,
     }
   }
   if (expr.includes(' <- ')) {
@@ -35,24 +42,26 @@ export function $step(expr: StepExpr, props?: string | Partial<StepProps>): Dyna
       target: target as Fqn,
       ...(typeof props === 'object' ? props : {}),
       title: title ?? null,
-      isBackward: true
+      isBackward: true,
     }
   }
   throw new Error(`Invalid step expression: ${expr}`)
 }
 
-export function compute(stepsAndRules: (DynamicViewStep | ViewRulePredicate)[]) {
+export function compute(
+  stepsAndRules: (DynamicViewStep<$Aux> | ElementViewPredicate<$Aux> | DynamicViewIncludeRule<$Aux>)[],
+) {
   const [steps, rules] = partition(stepsAndRules, (s): s is DynamicViewStep => 'source' in s)
   let view = computeDynamicView(
     fakeModel,
     {
       ...emptyView,
       steps,
-      rules: rules as DynamicViewRule[]
-    }
+      rules: rules as DynamicViewRule[],
+    } as DynamicView,
   )
   return Object.assign(view, {
     nodeIds: view.nodes.map((node) => node.id) as string[],
-    edgeIds: view.edges.map((edge) => edge.id) as string[]
+    edgeIds: view.edges.map((edge) => edge.id) as string[],
   })
 }