@likec4/core 1.30.0 → 1.32.0

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

@@ -1,20 +1,22 @@
-import { mapValues } from 'remeda'
-import { nonexhaustive } from '../errors'
+import { indexBy, values } from 'remeda'
 import { LikeC4Model } from '../model'
 import {
+  type AnyAux,
   type ComputedLikeC4ModelData,
   type ComputedView,
-  type LikeC4View,
   type ParsedLikeC4ModelData,
+  type ParsedView,
+  _stage,
   isDeploymentView,
   isDynamicView,
   isElementView,
 } from '../types'
+import { nonexhaustive } from '../utils'
 import { computeDeploymentView } from './deployment-view/compute'
 import { computeDynamicView } from './dynamic-view/compute'
 import { computeElementView } from './element-view/compute'
 
-export type ComputeViewResult<V extends ComputedView = ComputedView> =
+export type ComputeViewResult<V> =
   | {
     isSuccess: true
     error?: undefined
@@ -26,27 +28,26 @@ export type ComputeViewResult<V extends ComputedView = ComputedView> =
     view: undefined
   }
 
-export function unsafeComputeView(
-  viewsource: LikeC4View,
-  likec4model: LikeC4Model,
-): ComputedView {
+export function unsafeComputeView<A extends AnyAux>(
+  viewsource: ParsedView<A>,
+  likec4model: LikeC4Model<any>,
+): ComputedView<A> {
   switch (true) {
-    case isDeploymentView(viewsource): {
+    case isElementView(viewsource):
+      return computeElementView(likec4model, viewsource)
+    case isDeploymentView(viewsource):
       return computeDeploymentView(likec4model, viewsource)
-    }
     case isDynamicView(viewsource):
       return computeDynamicView(likec4model, viewsource)
-    case isElementView(viewsource):
-      return computeElementView(likec4model, viewsource)
     default:
       nonexhaustive(viewsource)
   }
 }
 
-export function computeView<V extends LikeC4View>(
-  viewsource: V,
-  likec4model: LikeC4Model,
-): ComputeViewResult {
+export function computeView<A extends AnyAux>(
+  viewsource: ParsedView<A>,
+  likec4model: LikeC4Model<A>,
+): ComputeViewResult<ComputedView<A>> {
   try {
     return {
       isSuccess: true,
@@ -61,23 +62,19 @@ export function computeView<V extends LikeC4View>(
   }
 }
 
-export function computeViews<P extends ParsedLikeC4ModelData>(parsed: P): ComputedLikeC4ModelData {
-  const { views, ...rest } = parsed as Omit<P, '__'>
-  const likec4model = LikeC4Model.create({
-    ...rest,
-    views: {},
-  })
-  const compute = (source: LikeC4View): ComputedView => {
-    const result = computeView(source, likec4model)
-    if (result.isSuccess) {
-      return result.view
-    } else {
-      throw result.error
-    }
-  }
+export function computeParsedModelData<A extends AnyAux>(
+  parsed: ParsedLikeC4ModelData<A>,
+): ComputedLikeC4ModelData<A> {
+  const likec4model = LikeC4Model.create(parsed)
+  const views = values(parsed.views as Record<string, ParsedView<A>>)
+    .map(v => unsafeComputeView(v, likec4model))
   return {
-    ...rest,
-    __: 'computed',
-    views: mapValues(parsed.views, compute),
-  }
+    ...parsed,
+    [_stage]: 'computed',
+    views: indexBy(views, v => v.id),
+  } as ComputedLikeC4ModelData<A>
+}
+
+export function computeLikeC4Model<A extends AnyAux>(parsed: ParsedLikeC4ModelData<A>): LikeC4Model.Computed<A> {
+  return LikeC4Model.create(computeParsedModelData(parsed))
 }

package/src/compute-view/deployment-view/__test__/TestHelper.ts

@@ -11,10 +11,17 @@ import {
 } from '../../../builder'
 import * as viewhelpers from '../../../builder/Builder.view-common'
 import { mkViewBuilder } from '../../../builder/Builder.views'
+import type { AnyAux, LikeC4Model } from '../../../model'
 import { differenceConnections } from '../../../model/connection'
-import type { ComputedDeploymentView, DeploymentView, DeploymentViewRule, ViewId } from '../../../types'
-import { imap, toArray } from '../../../utils/iterable'
-import { difference as differenceSet } from '../../../utils/set'
+import {
+  type ComputedDeploymentView,
+  type DeploymentViewRule,
+  type ParsedDeploymentView as DeploymentView,
+  type ViewId,
+  _stage,
+  _type,
+} from '../../../types'
+import { difference as differenceSet, imap, invariant, toArray } from '../../../utils'
 import { withReadableEdges } from '../../utils/with-readable-edges'
 import { processPredicates as processPredicatesImpl } from '../compute'
 import { Memory } from '../memory'
@@ -36,7 +43,9 @@ type Elem = Memory['Ctx']['Element']
 type Connection = Memory['Ctx']['Connection']
 
 export class TestHelper<T extends AnyTypes> {
-  model: Types.ToLikeC4Model<T>
+  Aux!: Types.ToAux<T>
+
+  model: LikeC4Model.Computed<typeof this.Aux>
 
   static $include = viewhelpers.$include
   static $exclude = viewhelpers.$exclude
@@ -54,17 +63,18 @@ export class TestHelper<T extends AnyTypes> {
     private builder: Builder<T>,
     private _expect: ExpectStatic,
   ) {
-    this.model = builder.toLikeC4Model() as Types.ToLikeC4Model<T>
+    this.model = builder.toLikeC4Model()
   }
 
   computeView = (...rules: DeploymentRulesBuilderOp<T>[]) => {
+    const view = this.builder
+      .clone()
+      .views(_ => _.deploymentView('dev').with(...rules))
+      .toLikeC4Model()
+      .view('dev')
+    invariant(view.isDeploymentView())
     return withReadableEdges(
-      this.builder
-        .clone()
-        .views(_ => _.deploymentView('dev').with(...rules))
-        .toLikeC4Model()
-        .view('dev')
-        .$view as ComputedDeploymentView<'dev'>,
+      view.$view,
       ' -> ',
     )
   }
@@ -175,7 +185,7 @@ class ProcessPredicates<T extends AnyTypes> {
     return processor
   }
 
-  public viewrules: ReadonlyArray<DeploymentViewRule> = []
+  public viewrules: ReadonlyArray<DeploymentViewRule<AnyAux>> = []
 
   public previousMemory: Memory = Memory.empty()
   public memory: Memory = Memory.empty()
@@ -216,9 +226,12 @@ class ProcessPredicates<T extends AnyTypes> {
   next(...predicates: DeploymentRulesBuilderOp<T>[]): this {
     const view = {
       id: 'test' as ViewId,
-      __: 'deployment',
+      [_stage]: 'parsed',
+      [_type]: 'deployment',
       rules: [],
-    } as any as Writable<DeploymentView>
+      title: null,
+      description: null,
+    } as Writable<DeploymentView<typeof this.t.model.Aux>>
     let vb = mkViewBuilder(view) as any
     this.predicates = [
       ...this.predicates,

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

@@ -2,7 +2,7 @@ import { map, prop } from 'remeda'
 import type { DeploymentRulesBuilderOp } from '../../../builder'
 import { Builder } from '../../../builder'
 import { LikeC4Model } from '../../../model'
-import type { DeploymentView } from '../../../types'
+import type { ParsedDeploymentView as DeploymentView } from '../../../types'
 import { withReadableEdges } from '../../utils/with-readable-edges'
 import { computeDeploymentView } from '../compute'
 
@@ -57,7 +57,17 @@ const {
     zone: {},
     node: {},
   },
-  tags: ['old', 'next', 'temp'],
+  tags: {
+    old: {
+      color: 'red',
+    },
+    next: {
+      color: 'green',
+    },
+    temp: {
+      color: 'blue',
+    },
+  },
   relationships: { 'https': {} },
 })
 
@@ -194,12 +204,9 @@ export function computeView(...rules: DeploymentRulesBuilderOp<Types>[]) {
       ),
     ).build()
 
-  const model = LikeC4Model.create({
-    ...modelsource,
-    views: {},
-  })
+  const model = LikeC4Model.fromParsed(modelsource)
 
-  const view = withReadableEdges(computeDeploymentView(model, modelsource.views.index as DeploymentView))
+  const view = withReadableEdges(computeDeploymentView(model, modelsource.views.index as DeploymentView<any>))
 
   return Object.assign(view, {
     nodeIds: map(view.nodes, prop('id')) as string[],
@@ -217,10 +224,5 @@ export function computeNodesAndEdges(...rules: DeploymentRulesBuilderOp<Types>[]
 }
 
 export function createModel() {
-  const modelsource = builder.build()
-
-  return LikeC4Model.create({
-    ...modelsource,
-    views: {},
-  })
+  return LikeC4Model.fromParsed(builder.build())
 }

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

@@ -1,6 +1,6 @@
-import { LikeC4DeploymentModel } from '../../model/DeploymentModel'
-import type { RelationshipModel } from '../../model/RelationModel'
-import type { ExpressionV2, Filterable, OperatorPredicate } from '../../types'
+import type { RelationshipModel } from '../../model'
+import { LikeC4DeploymentModel } from '../../model'
+import type { AnyAux, Expression, OperatorPredicate } from '../../types'
 import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
 
 export { Memory, type Stage } from './memory'
@@ -13,26 +13,26 @@ export type Connection = Ctx['Connection']
 export type ElementWhere = Where<Elem>
 export type ElementWhereFilter = (elements: readonly Elem[]) => Elem[]
 export type ConnectionWhere = Where<Connection>
-export type RelationshipWhere = Where<RelationshipModel>
+export type RelationshipWhere = Where<RelationshipModel<any>>
 export type ConnectionWhereFilter = (connections: readonly Connection[]) => Connection[]
 
 export type Connections = ReadonlyArray<Connection>
 
-export interface PredicateCtx<Expr extends ExpressionV2 = ExpressionV2> {
+export interface PredicateCtx<Expr = Expression<AnyAux>> {
   expr: Expr
   stage: Stage
-  model: LikeC4DeploymentModel
+  model: LikeC4DeploymentModel<AnyAux>
   memory: Memory
-  where: OperatorPredicate<Filterable> | null
+  where: OperatorPredicate<AnyAux> | null
 }
-export interface IncludePredicateCtx<Expr extends ExpressionV2 = ExpressionV2> extends PredicateCtx<Expr> {
+export interface IncludePredicateCtx<Expr = Expression<AnyAux>> extends PredicateCtx<Expr> {
   stage: StageInclude
 }
-export interface ExcludePredicateCtx<Expr extends ExpressionV2 = ExpressionV2> extends PredicateCtx<Expr> {
+export interface ExcludePredicateCtx<Expr = Expression<AnyAux>> extends PredicateCtx<Expr> {
   stage: StageExclude
 }
 
-export interface PredicateExecutor<Expr extends ExpressionV2> {
+export interface PredicateExecutor<Expr extends Expression<AnyAux> = Expression<AnyAux>> {
   include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
   exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
 }

package/src/compute-view/deployment-view/clean-connections.ts

@@ -12,23 +12,21 @@ import {
   reduce,
   values,
 } from 'remeda'
-import { invariant } from '../../errors'
+import type { RelationshipModel } from '../../model'
 import {
   DeploymentConnectionModel,
   differenceConnections,
   isNestedConnection,
   mergeConnections,
+  RelationshipsAccum,
   sortConnectionsByBoundaryHierarchy,
-} from '../../model/connection'
-import { findConnection } from '../../model/connection/deployment'
-import { RelationshipsAccum } from '../../model/DeploymentElementModel'
-import type { RelationshipModel } from '../../model/RelationModel'
+} from '../../model'
+import { invariant } from '../../utils'
 import { imap, toArray } from '../../utils/iterable'
 import { DefaultMap } from '../../utils/mnemonist'
 import { intersection, union } from '../../utils/set'
 import type { Connection, Connections } from './_types'
-
-const filterEmptyConnection = filter((c: DeploymentConnectionModel<any>) => c.nonEmpty())
+import { findConnection } from './utils'
 
 type MapOfExcludesFromConnection = DefaultMap<DeploymentConnectionModel, Set<RelationshipModel>>
 function findCrossBoundarySameSourceOrTarget(connections: Connections): MapOfExcludesFromConnection {

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

@@ -1,10 +1,11 @@
 import { findLast, map } from 'remeda'
-import { type LikeC4DeploymentModel, LikeC4Model } from '../../model'
-import type { AnyAux } from '../../model/types'
-import type { DeploymentViewRule } from '../../types'
+import { type DeploymentConnectionModel, type LikeC4DeploymentModel, LikeC4Model } from '../../model'
+import type { AnyAux, DeploymentViewRule } from '../../types'
 import {
   type ComputedDeploymentView,
-  type DeploymentView,
+  type ParsedDeploymentView as DeploymentView,
+  _stage,
+  _type,
   isViewRuleAutoLayout,
   isViewRulePredicate,
 } from '../../types'
@@ -17,9 +18,9 @@ import { predicateToPatch } from './predicates'
 import { StageFinal } from './stages/stage-final'
 import { applyDeploymentViewRuleStyles, buildNodes, toComputedEdges } from './utils'
 
-export function processPredicates<M extends AnyAux>(
-  model: LikeC4DeploymentModel<M>,
-  rules: DeploymentViewRule[],
+export function processPredicates(
+  model: LikeC4DeploymentModel<any>,
+  rules: DeploymentViewRule<any>[],
 ) {
   let memory = Memory.empty()
 
@@ -44,13 +45,13 @@ export function computeDeploymentView<M extends AnyAux>(
     docUri: _docUri, // exclude docUri
     rules, // exclude rules
     ...view
-  }: DeploymentView,
-): ComputedDeploymentView<M['ViewId']> {
-  const memory = processPredicates<M>(likec4model.deployment, rules)
+  }: DeploymentView<NoInfer<M>>,
+): ComputedDeploymentView<M> {
+  const memory = processPredicates(likec4model.deployment, rules)
 
-  const nodesMap = buildNodes(memory)
+  const nodesMap = buildNodes<M>(memory)
 
-  const computedEdges = toComputedEdges(memory.connections)
+  const computedEdges = toComputedEdges(memory.connections as unknown as DeploymentConnectionModel<M>[])
 
   linkNodesWithEdges(nodesMap, computedEdges)
 
@@ -70,6 +71,8 @@ export function computeDeploymentView<M extends AnyAux>(
 
   return calcViewLayoutHash({
     ...view,
+    [_stage]: 'computed',
+    [_type]: 'deployment',
     autoLayout: {
       direction: autoLayoutRule?.direction ?? 'TB',
       ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
@@ -84,7 +87,7 @@ export function computeDeploymentView<M extends AnyAux>(
     }),
     ...(elementNotations.length > 0 && {
       notation: {
-        elements: elementNotations,
+        nodes: elementNotations,
       },
     }),
   })

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

@@ -1,12 +1,11 @@
 import { isDeepEqual } from 'remeda'
-import { type DeploymentConnectionModel, differenceConnections } from '../../../model/connection'
-import type { DeploymentElementModel } from '../../../model/DeploymentElementModel'
-import type { AnyAux } from '../../../model/types'
-import type { ExpressionV2 } from '../../../types'
+import type { DeploymentElementModel } from '../../../model'
+import { type DeploymentConnectionModel, differenceConnections } from '../../../model'
+import type { AnyAux, Expression } from '../../../types'
 import { difference as differenceSet } from '../../../utils'
 import { customInspectSymbol } from '../../../utils/const'
 import { toArray } from '../../../utils/iterable'
-import { AbstractMemory, type ComputeCtx, type StageExpression } from '../../memory'
+import { type ComputeCtx, type StageExpression, AbstractMemory } from '../../memory'
 import { StageExclude } from '../stages/stage-exclude'
 import { StageInclude } from '../stages/stage-include'
 
@@ -16,7 +15,7 @@ export type Ctx = ComputeCtx<
   Memory,
   StageInclude,
   StageExclude,
-  ExpressionV2
+  Expression<AnyAux>
 >
 
 export class Memory extends AbstractMemory<Ctx> {

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

@@ -1,12 +1,11 @@
 import { filter, forEach, pipe, reduce } from 'remeda'
-import { isDeployedInstance } from '../../../model'
-import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/deployment'
-import type { DeploymentElementModel, DeploymentNodeModel } from '../../../model/DeploymentElementModel'
+import type { DeploymentElementModel, DeploymentNodeModel } from '../../../model'
+import { isDeployedInstanceModel as isDeployedInstance } from '../../../model'
 import type { FqnExpr } from '../../../types'
 import type { Elem, IncludePredicateCtx, PredicateExecutor } from '../_types'
 import { cleanCrossBoundary, cleanRedundantRelationships } from '../clean-connections'
 import type { StageInclude } from '../memory'
-import { deploymentExpressionToPredicate } from '../utils'
+import { deploymentExpressionToPredicate, findConnectionsBetween, findConnectionsWithin } from '../utils'
 import { applyElementPredicate } from './utils'
 
 export const DeploymentRefPredicate: PredicateExecutor<FqnExpr.DeploymentRef> = {
@@ -46,7 +45,7 @@ export const DeploymentRefPredicate: PredicateExecutor<FqnExpr.DeploymentRef> =
     const exprPredicate = deploymentExpressionToPredicate(expr)
     const toExclude = pipe(
       [...memory.elements],
-      filter<DeploymentElementModel>(exprPredicate),
+      filter(exprPredicate),
       applyElementPredicate(where),
     )
     stage.exclude(toExclude)

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

@@ -1,18 +1,26 @@
-import { filter, flatMap, isNonNullish, map, pick, pipe } from 'remeda'
-import { invariant } from '../../../errors'
-import type { DeploymentConnectionModel } from '../../../model/connection/deployment'
-import { findConnection, findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/deployment'
+import { filter, flatMap, isNonNullish, map, pipe } from 'remeda'
+import type {
+  DeploymentConnectionModel,
+  DeploymentElementModel,
+  LikeC4DeploymentModel,
+  RelationshipModel,
+} from '../../../model'
 import {
   type ConnectionModel,
   findConnectionsBetween as findModelConnectionsBetween,
 } from '../../../model/connection/model'
-import type { DeploymentElementModel, DeploymentRelationModel } from '../../../model/DeploymentElementModel'
-import type { LikeC4DeploymentModel } from '../../../model/DeploymentModel'
-import type { RelationshipModel } from '../../../model/RelationModel'
-import type { AnyAux } from '../../../model/types'
-import { type Filterable, type OperatorPredicate, type RelationExpr, FqnExpr } from '../../../types'
+import type { AnyAux } from '../../../types'
+import { type RelationExpr, FqnExpr } from '../../../types'
+import { invariant } from '../../../utils'
 import type { PredicateExecutor } from '../_types'
-import { deploymentExpressionToPredicate, resolveElements, resolveModelElements } from '../utils'
+import {
+  deploymentExpressionToPredicate,
+  findConnection,
+  findConnectionsBetween,
+  findConnectionsWithin,
+  resolveElements,
+  resolveModelElements,
+} from '../utils'
 import { filterIncomingConnections, resolveAllImcomingRelations } from './relation-incoming'
 import { filterOutgoingConnections, resolveAllOutgoingRelations } from './relation-outgoing'
 import { applyPredicate, excludeModelRelations } from './utils'
@@ -30,7 +38,7 @@ export const resolveAscendingSiblings = (element: DeploymentElementModel) => {
   return siblings
 }
 
-const resolveWildcard = (model: LikeC4DeploymentModel, nonWildcard: FqnExpr.DeploymentRef) => {
+const resolveWildcard = (model: LikeC4DeploymentModel<AnyAux>, nonWildcard: FqnExpr.DeploymentRef) => {
   const sources = resolveElements(model, nonWildcard)
   return sources.map(source => {
     const targets = resolveAscendingSiblings(source)
@@ -210,59 +218,26 @@ export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
   },
 }
 
-function resolveRelationsBetweenModelElements({
+function resolveRelationsBetweenModelElements<A extends AnyAux>({
   source,
   target,
   expr,
   model,
 }: {
-  source: FqnExpr.ModelRef
-  target: FqnExpr.ModelRef
-  expr: RelationExpr.Direct
-  model: LikeC4DeploymentModel
+  source: FqnExpr.ModelRef<A>
+  target: FqnExpr.ModelRef<A>
+  expr: RelationExpr.Direct<A>
+  model: LikeC4DeploymentModel<A>
 }) {
   const sources = resolveModelElements(model, source)
   const targets = resolveModelElements(model, target)
 
   const dir = expr.isBidirectional ? 'both' : 'directed'
 
-  const modelConnections = [] as ConnectionModel[]
+  const modelConnections = [] as ConnectionModel<A>[]
   for (const source of sources) {
     modelConnections.push(...findModelConnectionsBetween(source, targets, dir))
   }
 
   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
-}

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

@@ -1,12 +1,10 @@
 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 { type RelationExpr, FqnExpr } from '../../../types/expression-v2'
+import type { RelationshipModel } from '../../../model'
+import { type RelationExpr, FqnExpr } from '../../../types'
+import { invariant } from '../../../utils'
 import { union } from '../../../utils/set'
 import type { PredicateExecutor } from '../_types'
-import { resolveElements, resolveModelElements } from '../utils'
+import { findConnectionsBetween, resolveElements, resolveModelElements } from '../utils'
 import { resolveAscendingSiblings } from './relation-direct'
 import { filterIncomingConnections } from './relation-incoming'
 import { filterOutgoingConnections } from './relation-outgoing'
@@ -46,7 +44,7 @@ export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
         return stage
       }
       const excludedRelations = union(
-        new Set<RelationshipModel<AnyAux>>(),
+        new Set<RelationshipModel>(),
         ...elements.flatMap(e => [e.allIncoming, e.allOutgoing]),
       )
       return excludeModelRelations(excludedRelations, { stage, memory }, where)

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

@@ -1,13 +1,9 @@
 import { anyPass, filter, pipe } 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 type { AnyAux, LikeC4DeploymentModel, RelationshipModel } from '../../../model'
 import { type RelationExpr, FqnExpr } from '../../../types'
-import { isAncestor } from '../../../utils'
+import { invariant, isAncestor } from '../../../utils'
 import type { Connection, Elem, PredicateExecutor } from '../_types'
-import { resolveElements, resolveModelElements } from '../utils'
+import { findConnectionsBetween, resolveElements, resolveModelElements } from '../utils'
 import { resolveAscendingSiblings } from './relation-direct'
 import { applyPredicate, excludeModelRelations } from './utils'
 
@@ -96,10 +92,10 @@ export function filterIncomingConnections(
 //   }
 // }
 
-export function resolveAllImcomingRelations(
-  model: LikeC4DeploymentModel,
-  moodelRef: FqnExpr.ModelRef,
-): Set<RelationshipModel<AnyAux>> {
+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,12 +1,9 @@
 import { anyPass, filter, pipe } from 'remeda'
-import { invariant } from '../../../errors'
-import { findConnection, findConnectionsBetween } from '../../../model/connection/deployment'
-import type { LikeC4DeploymentModel } from '../../../model/DeploymentModel'
-import type { RelationshipModel } from '../../../model/RelationModel'
+import type { AnyAux, LikeC4DeploymentModel, RelationshipModel } from '../../../model'
 import { type RelationExpr, FqnExpr } from '../../../types'
-import { isAncestor } from '../../../utils'
+import { invariant, isAncestor } from '../../../utils'
 import type { Connection, Elem, PredicateExecutor } from '../_types'
-import { resolveElements, resolveModelElements } from '../utils'
+import { findConnection, findConnectionsBetween, resolveElements, resolveModelElements } from '../utils'
 import { resolveAscendingSiblings } from './relation-direct'
 import { applyPredicate, excludeModelRelations } from './utils'
 
@@ -89,10 +86,10 @@ export function filterOutgoingConnections(
   // }
 }
 
-export function resolveAllOutgoingRelations(
-  model: LikeC4DeploymentModel,
-  moodelRef: FqnExpr.ModelRef,
-): Set<RelationshipModel> {
+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]))
 }