@likec4/core 1.31.0 → 1.32.1

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

@@ -1,19 +1,23 @@
 import { filter, findLast, forEach, map, pipe } from 'remeda'
-import { invariant, nonexhaustive, nonNullable } from '../../errors'
 import { ConnectionModel } from '../../model/connection/model/ConnectionModel'
-import { type ElementModel } from '../../model/ElementModel'
 import { LikeC4Model } from '../../model/LikeC4Model'
 import type { RelationshipModel } from '../../model/RelationModel'
-import type { AnyAux } from '../../model/types'
-import type {
-  ComputedElementView,
-  ElementView,
-  NodeId,
-  ViewRule,
+import {
+  type AnyAux,
+  type ComputedElementView,
+  type ElementViewRule,
+  type ModelGlobals,
+  type NodeId,
+  type ParsedElementView,
+  isViewRuleAutoLayout,
+  isViewRuleGroup,
+  isViewRulePredicate,
+  ModelExpression,
+  ModelFqnExpr,
+  ModelRelationExpr,
+  whereOperatorAsPredicate,
 } from '../../types'
-import { isViewRuleAutoLayout, isViewRuleGroup, isViewRulePredicate, whereOperatorAsPredicate } from '../../types'
-import { ModelLayer } from '../../types/expression-v2-model'
-import { sortParentsFirst } from '../../utils'
+import { invariant, nonexhaustive, nonNullable, sortParentsFirst } from '../../utils'
 import { DefaultMap } from '../../utils/mnemonist'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
 import { applyCustomRelationProperties } from '../utils/applyCustomRelationProperties'
@@ -39,35 +43,37 @@ import { buildNodes, NoFilter, NoWhere, toComputedEdges } from './utils'
 
 function processElementPredicate(
   // ...args:
-  //   | [expr: ModelLayer.AnyFqnExpr, op: 'include', IncludePredicateCtx<ModelLayer.AnyFqnExpr>]
-  //   | [expr: ModelLayer.AnyFqnExpr, op: 'exclude', ExcludePredicateCtx<ModelLayer.AnyFqnExpr>]
-  expr: ModelLayer.AnyFqnExpr,
+  //   | [expr: ModelAnyFqnExpr, op: 'include', IncludePredicateCtx<ModelAnyFqnExpr>]
+  //   | [expr: ModelAnyFqnExpr, op: 'exclude', ExcludePredicateCtx<ModelAnyFqnExpr>]
+  expr: ModelFqnExpr.Any,
   op: 'include' | 'exclude',
-  ctx: Omit<PredicateCtx<ModelLayer.AnyFqnExpr>, 'expr'>,
+  ctx: Omit<PredicateCtx<ModelFqnExpr.Any>, 'expr'>,
 ): Stage {
   switch (true) {
-    case ModelLayer.FqnExpr.isCustom(expr): {
+    case ModelFqnExpr.isCustom(expr): {
       if (op === 'include') {
         return processElementPredicate(expr.custom.expr, op, ctx)
       }
       return ctx.stage
     }
-    case ModelLayer.FqnExpr.isWhere(expr): {
+    case ModelFqnExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition)
-      const filterWhere = filter<Elem>(where)
-      return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere } as any)
+      const filterWhere = (elements: ReadonlyArray<Elem>) => {
+        return filter(elements, where)
+      }
+      return processElementPredicate(expr.where.expr, op, { ...ctx, where, filterWhere })
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
       return ExpandedElementPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case ModelLayer.FqnExpr.isWildcard(expr): {
+    case ModelFqnExpr.isWildcard(expr): {
       return WildcardPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case ModelLayer.FqnExpr.isElementKindExpr(expr):
-    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
+    case ModelFqnExpr.isElementKindExpr(expr):
+    case ModelFqnExpr.isElementTagExpr(expr): {
       return ElementKindOrTagPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case ModelLayer.FqnExpr.isModelRef(expr): {
+    case ModelFqnExpr.isModelRef(expr): {
       return ElementRefPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
     default:
@@ -75,18 +81,18 @@ function processElementPredicate(
   }
 }
 function processRelationtPredicate(
-  expr: ModelLayer.AnyRelationExpr,
+  expr: ModelRelationExpr.Any,
   op: 'include' | 'exclude',
-  ctx: Omit<PredicateCtx<ModelLayer.AnyRelationExpr>, 'expr'>,
+  ctx: Omit<PredicateCtx<ModelRelationExpr.Any>, 'expr'>,
 ): Stage {
   switch (true) {
-    case ModelLayer.RelationExpr.isCustom(expr): {
+    case ModelRelationExpr.isCustom(expr): {
       if (op === 'include') {
         return processRelationtPredicate(expr.customRelation.expr, op, ctx)
       }
       return ctx.stage
     }
-    case ModelLayer.RelationExpr.isWhere(expr): {
+    case ModelRelationExpr.isWhere(expr): {
       const where = whereOperatorAsPredicate(expr.where.condition)
       const filterRelations = (relations: ReadonlySet<RelationshipModel>) => {
         return new Set(filter([...relations], where))
@@ -104,16 +110,16 @@ function processRelationtPredicate(
         filterWhere,
       })
     }
-    case ModelLayer.RelationExpr.isInOut(expr): {
+    case ModelRelationExpr.isInOut(expr): {
       return InOutRelationPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case ModelLayer.RelationExpr.isDirect(expr): {
+    case ModelRelationExpr.isDirect(expr): {
       return DirectRelationExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case ModelLayer.RelationExpr.isOutgoing(expr): {
+    case ModelRelationExpr.isOutgoing(expr): {
       return OutgoingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
-    case ModelLayer.RelationExpr.isIncoming(expr): {
+    case ModelRelationExpr.isIncoming(expr): {
       return IncomingExprPredicate[op]({ ...ctx, expr } as any) ?? ctx.stage
     }
     default:
@@ -121,10 +127,10 @@ function processRelationtPredicate(
   }
 }
 
-export function processPredicates<M extends AnyAux>(
-  model: LikeC4Model<M>,
+export function processPredicates<A extends AnyAux>(
+  model: LikeC4Model<A>,
   memory: Memory,
-  rules: ViewRule[],
+  rules: ElementViewRule<A>[],
 ): Memory {
   const ctx = {
     model,
@@ -146,14 +152,14 @@ export function processPredicates<M extends AnyAux>(
       for (const expr of exprs) {
         let stage = op === 'include' ? memory.stageInclude(expr) : memory.stageExclude(expr)
         switch (true) {
-          case ModelLayer.isAnyFqnExpr(expr):
+          case ModelExpression.isFqnExpr(expr):
             stage = processElementPredicate(expr, op, {
               ...ctx,
               stage,
               memory,
             } as any) ?? stage
             break
-          case ModelLayer.isAnyRelationExpr(expr):
+          case ModelExpression.isRelationExpr(expr):
             stage = processRelationtPredicate(expr, op, {
               ...ctx,
               stage,
@@ -170,17 +176,20 @@ export function processPredicates<M extends AnyAux>(
   return StageFinal.for(memory).commit()
 }
 
-export function computeElementView<M extends AnyAux>(
-  likec4model: LikeC4Model<M>,
+export function computeElementView<A extends AnyAux>(
+  likec4model: LikeC4Model<any>,
   {
     docUri: _docUri, // exclude docUri
-    rules, // exclude rules
+    rules: _rules, // exclude rules
     ...view
-  }: ElementView,
-): ComputedElementView<M['ViewId']> {
-  rules = resolveGlobalRulesInElementView(rules, likec4model.globals())
-  const scope = view.viewOf ? likec4model.element(view.viewOf) : null
-  let memory = processPredicates<M>(
+  }: ParsedElementView<A>,
+): ComputedElementView<A> {
+  const rules = resolveGlobalRulesInElementView(
+    _rules,
+    likec4model.globals as unknown as ModelGlobals<A>,
+  )
+  const scope = view.viewOf ? likec4model.asComputed.element(view.viewOf) : null
+  let memory = processPredicates(
     likec4model,
     Memory.empty(scope),
     rules,
@@ -192,9 +201,9 @@ export function computeElementView<M extends AnyAux>(
   }
   memory = assignElementsToGroups(memory)
 
-  const nodesMap = buildNodes(memory)
+  const nodesMap = buildNodes<A>(memory)
 
-  const computedEdges = toComputedEdges(memory.connections)
+  const computedEdges = toComputedEdges(memory.connections as unknown as readonly ConnectionModel<A>[])
 
   linkNodesWithEdges(nodesMap, computedEdges)
 
@@ -213,10 +222,11 @@ export function computeElementView<M extends AnyAux>(
 
   const autoLayoutRule = findLast(rules, isViewRuleAutoLayout)
 
-  const elementNotations = buildElementNotations(nodes)
+  const nodeNotations = buildElementNotations(nodes)
 
   return calcViewLayoutHash({
     ...view,
+    _stage: 'computed',
     autoLayout: {
       direction: autoLayoutRule?.direction ?? 'TB',
       ...(autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep }),
@@ -229,9 +239,9 @@ export function computeElementView<M extends AnyAux>(
       }
       return n
     }),
-    ...(elementNotations.length > 0 && {
+    ...(nodeNotations.length > 0 && {
       notation: {
-        elements: elementNotations,
+        nodes: nodeNotations,
       },
     }),
   })
@@ -246,7 +256,7 @@ function assignElementsToGroups(memory: Memory) {
   }
   const groupAssignments = new DefaultMap<NodeId, Set<Elem>>(() => new Set())
 
-  const assignedTo = new Map<ElementModel, NodesGroup['id']>()
+  const assignedTo = new Map<Elem, NodesGroup['id']>()
 
   const isAncestorAssigned = (el: Elem) => {
     for (const parent of el.ancestors()) {

package/src/compute-view/element-view/memory/NodeGroup.ts

@@ -1,15 +1,14 @@
-import { ElementKind } from '../../../types/element'
-import { type NodeId, type ViewRuleGroup } from '../../../types/view'
-import type { Elem } from '../_types'
+import type { ElementModel } from '../../../model'
+import { type AnyAux, type ElementViewRuleGroup, type NodeId, GroupElementKind } from '../../../types'
 
-export class NodesGroup {
-  static readonly kind = ElementKind.Group
+export class NodesGroup<A extends AnyAux = AnyAux> {
+  static readonly kind = GroupElementKind
 
   constructor(
     public readonly id: NodeId,
-    public readonly viewRule: ViewRuleGroup,
+    public readonly viewRule: ElementViewRuleGroup<A>,
     public readonly parent: NodeId | null = null,
-    public readonly elements: ReadonlySet<Elem> = new Set<Elem>(),
+    public readonly elements: ReadonlySet<ElementModel<A>> = new Set<ElementModel<A>>(),
   ) {
   }
 
@@ -17,12 +16,12 @@ export class NodesGroup {
     return this.elements.size === 0
   }
 
-  update(elements: ReadonlySet<Elem>): NodesGroup {
+  update(elements: ReadonlySet<ElementModel<AnyAux>>): NodesGroup<A> {
     return new NodesGroup(
       this.id,
       this.viewRule,
       this.parent,
-      elements,
+      elements as unknown as ReadonlySet<ElementModel<A>>,
     )
   }
 

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

@@ -1,45 +1,45 @@
-import { nonNullable } from '../../../errors'
-import type { ConnectionModel } from '../../../model/connection'
-import type { ElementModel } from '../../../model/ElementModel'
-import type { ModelLayer } from '../../../types/expression-v2-model'
-import type { NodeId, ViewRuleGroup } from '../../../types/view'
+import type { ConnectionModel, ElementModel } from '../../../model'
+import type { aux, ElementViewRuleGroup as ViewRuleGroup, ModelExpression, NodeId, scalar } from '../../../types'
+import { nonNullable } from '../../../utils'
 import { Stack } from '../../../utils/mnemonist'
 import { type ComputeCtx, type CtxElement, type MutableState, type StageExpression, AbstractMemory } from '../../memory'
 import { NodesGroup } from './NodeGroup'
 import { ActiveGroupStageExclude, StageExclude } from './stage-exclude'
 import { ActiveGroupStageInclude, StageInclude } from './stage-include'
 
+type A = aux.Any
+
 export interface Ctx extends
   ComputeCtx<
-    ElementModel,
-    ConnectionModel,
+    ElementModel<A>,
+    ConnectionModel<A>,
     Memory<Ctx>,
     StageInclude<Ctx>,
     StageExclude,
-    ModelLayer.Expression
+    ModelExpression<A>
   >
 {
   MutableState: {
-    elements: Set<ElementModel>
-    explicits: Set<ElementModel>
-    final: Set<ElementModel>
-    connections: ConnectionModel[]
-    groups: NodesGroup[]
+    elements: Set<ElementModel<A>>
+    explicits: Set<ElementModel<A>>
+    final: Set<ElementModel<A>>
+    connections: ConnectionModel<A>[]
+    groups: NodesGroup<A>[]
     /*
      * The group where explict element was added first time
      * May be a root group
      */
-    explicitFirstSeenIn: Map<ElementModel, NodesGroup['id']>
+    explicitFirstSeenIn: Map<ElementModel<A>, scalar.NodeId>
     /**
      * The group where element (implicit or explicit) was last seen (added or updated)
      * Exclude root group
      */
-    lastSeenIn: Map<ElementModel, NodesGroup['id']>
+    lastSeenIn: Map<ElementModel<A>, scalar.NodeId>
   }
 }
 
 export class Memory<C extends Ctx = Ctx> extends AbstractMemory<C> {
-  static empty(scope: CtxElement<Ctx> | null): Memory {
+  static empty<EC extends Ctx>(scope: ElementModel<any> | null): Memory<EC> {
     return new Memory({
       elements: new Set(),
       explicits: new Set(),
@@ -58,22 +58,22 @@ export class Memory<C extends Ctx = Ctx> extends AbstractMemory<C> {
     super(state)
   }
 
-  public get groups(): ReadonlyArray<NodesGroup> {
+  public get groups(): ReadonlyArray<NodesGroup<A>> {
     return this.state.groups
   }
 
-  public get explicitFirstSeenIn(): ReadonlyMap<ElementModel, NodesGroup['id']> {
+  public get explicitFirstSeenIn(): ReadonlyMap<ElementModel<A>, scalar.NodeId> {
     return this.state.explicitFirstSeenIn
   }
 
-  public get lastSeenIn(): ReadonlyMap<ElementModel, NodesGroup['id']> {
+  public get lastSeenIn(): ReadonlyMap<ElementModel<A>, scalar.NodeId> {
     return this.state.lastSeenIn
   }
 
-  override stageInclude(expr: StageExpression<Ctx>): StageInclude {
+  override stageInclude(expr: StageExpression<C>): StageInclude {
     return new StageInclude(this, expr)
   }
-  override stageExclude(expr: StageExpression<Ctx>): StageExclude {
+  override stageExclude(expr: StageExpression<C>): StageExclude {
     return new StageExclude(this, expr)
   }
 
@@ -108,7 +108,7 @@ export interface ActiveGroupCtx extends Ctx {
 export class ActiveGroupMemory extends Memory<ActiveGroupCtx> {
   static enter(
     memory: Memory,
-    rule: ViewRuleGroup,
+    rule: ViewRuleGroup<any>,
   ): ActiveGroupMemory {
     const groupId = `@gr${memory.groups.length + 1}` as NodeId
     if (memory instanceof ActiveGroupMemory) {

package/src/compute-view/element-view/memory/stage-include.ts

@@ -1,11 +1,13 @@
 import { dropWhile, forEach, pipe, take, zip } from 'remeda'
-import { findConnection, findConnectionsBetween } from '../../../model/connection/model'
-import { ModelLayer } from '../../../types/expression-v2-model'
+import { modelConnection } from '../../../model'
+import { ModelExpression } from '../../../types'
 import { difference, isAncestor, isIterable } from '../../../utils'
 import { toArray } from '../../../utils/iterable'
 import { type CtxConnection, type StageExpression, AbstractStageInclude } from '../../memory'
 import { type ActiveGroupCtx, type ActiveGroupMemory, type Ctx } from './memory'
 
+const { findConnection, findConnectionsBetween } = modelConnection
+
 export type Elem = Ctx['Element']
 
 export class StageInclude<C extends Ctx = Ctx> extends AbstractStageInclude<C> {
@@ -62,7 +64,7 @@ export class StageInclude<C extends Ctx = Ctx> extends AbstractStageInclude<C> {
   }
 
   protected override processConnections(connections: CtxConnection<Ctx>[]) {
-    if (ModelLayer.isAnyRelationExpr(this.expression)) {
+    if (ModelExpression.isRelationExpr(this.expression)) {
       return connections
     }
 

package/src/compute-view/element-view/predicates/_utils.ts

@@ -1,29 +1,33 @@
 import { anyPass } from 'remeda'
-import { nonexhaustive } from '../../../errors'
-import type { LikeC4Model } from '../../../model/LikeC4Model'
-import { ModelLayer } from '../../../types/expression-v2-model'
-import { isDescendantOf } from '../../../utils/fqn'
-import { ifilter, toArray } from '../../../utils/iterable'
+import type { ElementModel, LikeC4Model } from '../../../model'
+import { modelConnection } from '../../../model'
+import { type AnyAux, FqnRef, ModelFqnExpr } from '../../../types'
+import { ifilter, isDescendantOf, nonexhaustive, toArray } from '../../../utils'
 import type { Elem, Memory, PredicateCtx } from '../_types'
 
+export const { findConnection, findConnectionsBetween, findConnectionsWithin } = modelConnection
+
 /**
  * Resolve elements from the model based on the given expression
  */
 
-export function resolveElements(model: LikeC4Model, expr: ModelLayer.FqnExpr.NonWildcard): Elem[] {
+export function resolveElements<A extends AnyAux>(
+  model: LikeC4Model<A>,
+  expr: ModelFqnExpr.NonWildcard<A>,
+): ElementModel<A>[] {
   switch (true) {
-    case ModelLayer.FqnExpr.isElementKindExpr(expr): {
+    case ModelFqnExpr.isElementKindExpr(expr): {
       return [...ifilter(model.elements(), el => {
         return expr.isEqual === (el.kind === expr.elementKind)
       })]
     }
-    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
+    case ModelFqnExpr.isElementTagExpr(expr): {
       return [...ifilter(model.elements(), el => {
         return expr.isEqual === el.tags.includes(expr.elementTag)
       })]
     }
     case expr.selector === 'expanded': {
-      const element = model.element(ModelLayer.FqnRef.toFqn(expr.ref))
+      const element = model.element(FqnRef.flatten(expr.ref))
       return [
         element,
         ...element.children(),
@@ -31,12 +35,12 @@ export function resolveElements(model: LikeC4Model, expr: ModelLayer.FqnExpr.Non
     }
     case expr.selector === 'children':
     case expr.selector === 'descendants': {
-      const element = model.element(ModelLayer.FqnRef.toFqn(expr.ref))
+      const element = model.element(FqnRef.flatten(expr.ref))
       let children = expr.selector === 'children' ? toArray(element.children()) : toArray(element.descendants())
       return children && children.length > 0 ? children : [element]
     }
-    case ModelLayer.FqnExpr.isModelRef(expr): {
-      return [model.element(ModelLayer.FqnRef.toFqn(expr.ref))]
+    case ModelFqnExpr.isModelRef(expr): {
+      return [model.element(FqnRef.flatten(expr.ref))]
     }
     default:
       nonexhaustive(expr)
@@ -70,14 +74,14 @@ export function includeDescendantsFromMemory(elements: Elem[], memory: Memory):
  * Combination of `resolveElements` and `includeDescendantsFromMemory`
  */
 export function resolveAndIncludeFromMemory(
-  nonWildcard: ModelLayer.FqnExpr.NonWildcard,
+  nonWildcard: ModelFqnExpr.NonWildcard,
   { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
 ): Elem[] {
   const resolved = resolveElements(model, nonWildcard)
   // We include from memory only if the expression is:
   // - expanded element
   // - element reference with or with children (but not descendants - they are already included)
-  if (ModelLayer.FqnExpr.isModelRef(nonWildcard)) {
+  if (ModelFqnExpr.isModelRef(nonWildcard)) {
     if (nonWildcard.selector === 'descendants') {
       return resolved
     }

package/src/compute-view/element-view/predicates/element-expand.ts

@@ -1,11 +1,10 @@
-import { findConnectionsWithin } from '../../../model/connection/model'
-import { ModelLayer } from '../../../types/expression-v2-model'
+import { type AnyAux, type ModelFqnExpr, FqnRef } from '../../../types'
 import type { Elem, PredicateExecutor } from '../_types'
-import { resolveElements } from './_utils'
+import { findConnectionsWithin, resolveElements } from './_utils'
 
-export const ExpandedElementPredicate: PredicateExecutor<ModelLayer.FqnExpr.ModelRef> = {
+export const ExpandedElementPredicate: PredicateExecutor<ModelFqnExpr.Ref<AnyAux>> = {
   include: ({ expr, model, stage, where }) => {
-    const parent = model.element(ModelLayer.FqnRef.toFqn(expr.ref))
+    const parent = model.element(FqnRef.flatten(expr.ref))
     if (where(parent)) {
       stage.addExplicit(parent)
       stage.connectWithExisting(parent)

package/src/compute-view/element-view/predicates/element-kind-tag.ts

@@ -1,10 +1,9 @@
-import { findConnectionsWithin } from '../../../model/connection/model'
-import type { ModelLayer } from '../../../types/expression-v2-model'
+import type { AnyAux, ModelFqnExpr } from '../../../types'
 import type { PredicateExecutor } from '../_types'
-import { resolveElements } from './_utils'
+import { findConnectionsWithin, resolveElements } from './_utils'
 
 export const ElementKindOrTagPredicate: PredicateExecutor<
-  ModelLayer.FqnExpr.ElementKindExpr | ModelLayer.FqnExpr.ElementTagExpr
+  ModelFqnExpr.ElementKindExpr<AnyAux> | ModelFqnExpr.ElementTagExpr<AnyAux>
 > = {
   include: ({ expr, model, stage, filterWhere }) => {
     const elements = filterWhere(resolveElements(model, expr))

package/src/compute-view/element-view/predicates/element-ref.ts

@@ -1,9 +1,8 @@
-import { findConnectionsWithin } from '../../../model/connection/model'
-import { ModelLayer } from '../../../types/expression-v2-model'
+import type { AnyAux, ModelFqnExpr } from '../../../types'
 import type { Elem, PredicateExecutor } from '../_types'
-import { resolveElements } from './_utils'
+import { findConnectionsWithin, resolveElements } from './_utils'
 
-export const ElementRefPredicate: PredicateExecutor<ModelLayer.FqnExpr.ModelRef> = {
+export const ElementRefPredicate: PredicateExecutor<ModelFqnExpr.Ref<AnyAux>> = {
   include: ({ expr, model, stage, filterWhere }) => {
     const elements = filterWhere(resolveElements(model, expr))
     if (elements.length === 0) {

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

@@ -1,19 +1,23 @@
 import { concat, constant, flatMap, hasAtLeast, map, partition, pipe, piped, prop, when } from 'remeda'
-import { invariant } from '../../../errors'
-import { ConnectionModel, findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
-import type { RelationshipModel } from '../../../model/RelationModel'
-import type { AnyAux } from '../../../model/types'
-import { ModelLayer } from '../../../types/expression-v2-model'
-import { isSameHierarchy } from '../../../utils'
+import type { RelationshipModel } from '../../../model'
+import { ConnectionModel } from '../../../model'
+import { type AnyAux, type ModelRelationExpr, FqnRef, ModelFqnExpr } from '../../../types'
+import { invariant, isSameHierarchy } from '../../../utils'
 import { ifilter, iflat, iunique, toArray, toSet } from '../../../utils/iterable'
 import { intersection, union } from '../../../utils/set'
 import type { Elem, PredicateCtx, PredicateExecutor } from '../_types'
 import { NoWhere } from '../utils'
-import { includeDescendantsFromMemory, resolveAndIncludeFromMemory, resolveElements } from './_utils'
+import {
+  findConnectionsBetween,
+  findConnectionsWithin,
+  includeDescendantsFromMemory,
+  resolveAndIncludeFromMemory,
+  resolveElements,
+} from './_utils'
 
-const isWildcard = ModelLayer.FqnExpr.isWildcard
+const isWildcard = ModelFqnExpr.isWildcard
 
-export const DirectRelationExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Direct> = {
+export const DirectRelationExprPredicate: PredicateExecutor<ModelRelationExpr.Direct<AnyAux>> = {
   include: ({ expr: { source, target, isBidirectional = false }, memory, model, stage, where, filterWhere }) => {
     const sourceIsWildcard = isWildcard(source)
     const targetIsWildcard = isWildcard(target)
@@ -283,7 +287,7 @@ export const DirectRelationExprPredicate: PredicateExecutor<ModelLayer.RelationE
  * Resolve elements for both source and target, when one of them is a wildcard
  */
 function resolveWildcard(
-  nonWildcard: ModelLayer.FqnExpr.NonWildcard,
+  nonWildcard: ModelFqnExpr.NonWildcard,
   { memory, model }: Pick<PredicateCtx, 'model' | 'memory'>,
 ): [elements: Elem[], wildcard: Elem[]] {
   let sources = resolveElements(model, nonWildcard)
@@ -291,8 +295,8 @@ function resolveWildcard(
     return [[], []]
   }
 
-  if (ModelLayer.FqnExpr.isModelRef(nonWildcard)) {
-    const parent = model.element(ModelLayer.FqnRef.toFqn(nonWildcard.ref))
+  if (ModelFqnExpr.isModelRef(nonWildcard)) {
+    const parent = model.element(FqnRef.flatten(nonWildcard.ref))
     const targets = toArray(parent.ascendingSiblings())
     return [
       includeDescendantsFromMemory(sources, memory),

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

@@ -1,16 +1,15 @@
 import { unique } from 'remeda'
-import { type ConnectionModel, findConnectionsBetween } from '../../../model/connection/model'
-import type { RelationshipModel } from '../../../model/RelationModel'
-import type { AnyAux } from '../../../model/types'
-import { ModelLayer } from '../../../types/expression-v2-model'
+import { type ConnectionModel } from '../../../model'
+import type { RelationshipModel } from '../../../model'
+import { type AnyAux, type ModelRelationExpr, ModelFqnExpr } from '../../../types'
 import { toArray, toSet } from '../../../utils/iterable/to'
 import type { PredicateExecutor } from '../_types'
-import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
+import { findConnectionsBetween, resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const InOutRelationPredicate: PredicateExecutor<ModelLayer.RelationExpr.InOut> = {
+export const InOutRelationPredicate: PredicateExecutor<ModelRelationExpr.InOut<AnyAux>> = {
   include: ({ expr: { inout }, scope, model, memory, stage, filterWhere }) => {
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (ModelLayer.FqnExpr.isWildcard(inout)) {
+    if (ModelFqnExpr.isWildcard(inout)) {
       if (!scope) {
         return
       }
@@ -46,7 +45,7 @@ export const InOutRelationPredicate: PredicateExecutor<ModelLayer.RelationExpr.I
   },
   exclude: ({ expr: { inout }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (ModelLayer.FqnExpr.isWildcard(inout)) {
+    if (ModelFqnExpr.isWildcard(inout)) {
       if (!scope) {
         return
       }