@likec4/core 1.30.0 → 1.32.0

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

@@ -1,24 +1,17 @@
 import { anyPass, unique } from 'remeda'
-import { nonexhaustive } from '../../../errors'
-import type { LikeC4Model } from '../../../model'
-import {
-  type ConnectionModel,
-  Connection,
-  findConnection,
-  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, type LikeC4Model, type RelationshipModel, Connection } from '../../../model'
+import type { ModelRelationExpr } from '../../../types'
+import { type AnyAux, FqnRef, ModelFqnExpr } from '../../../types'
+import { nonexhaustive } from '../../../utils'
 import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
 import type { ConnectionWhere, PredicateExecutor } from '../_types'
-import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
+import { findConnection, findConnectionsBetween, resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const IncomingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Incoming> = {
+export const IncomingExprPredicate: PredicateExecutor<ModelRelationExpr.Incoming<AnyAux>> = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.incoming
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (ModelLayer.FqnExpr.isWildcard(target)) {
+    if (ModelFqnExpr.isWildcard(target)) {
       if (!scope) {
         return
       }
@@ -61,7 +54,7 @@ export const IncomingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.In
   },
   exclude: ({ expr: { incoming }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (ModelLayer.FqnExpr.isWildcard(incoming)) {
+    if (ModelFqnExpr.isWildcard(incoming)) {
       if (!scope) {
         return
       }
@@ -80,24 +73,24 @@ export const IncomingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.In
 
 export function incomingConnectionPredicate(
   model: LikeC4Model,
-  expr: ModelLayer.FqnExpr.NonWildcard,
+  expr: ModelFqnExpr.NonWildcard,
 ): ConnectionWhere {
   switch (true) {
-    case ModelLayer.FqnExpr.isElementKindExpr(expr):
-    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
+    case ModelFqnExpr.isElementKindExpr(expr):
+    case ModelFqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr)
       return (connection) => isElement(connection.target)
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'children': {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'children': {
+      const fqn = FqnRef.flatten(expr.ref)
       return anyPass(
         [...model.children(fqn)].map(
           el => Connection.isIncoming(el.id),
         ),
       )
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
+      const fqn = FqnRef.flatten(expr.ref)
       return anyPass([
         Connection.isInside(fqn),
         ...[...model.children(fqn)].map(
@@ -105,15 +98,15 @@ export function incomingConnectionPredicate(
         ),
       ])
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
+      const fqn = FqnRef.flatten(expr.ref)
       return anyPass([
         Connection.isIncoming(fqn),
         Connection.isInside(fqn),
       ])
     }
-    case ModelLayer.FqnExpr.isModelRef(expr): {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr): {
+      const fqn = FqnRef.flatten(expr.ref)
       return Connection.isIncoming(fqn)
     }
     default:

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

@@ -1,20 +1,19 @@
 import { anyPass, unique } from 'remeda'
-import { nonexhaustive } from '../../../errors'
-import { type ConnectionModel, Connection, findConnectionsBetween } from '../../../model/connection/model'
-import type { LikeC4Model } from '../../../model/LikeC4Model'
-import type { RelationshipModel } from '../../../model/RelationModel'
-import type { AnyAux } from '../../../model/types'
-import { ModelLayer } from '../../../types/expression-v2-model'
+import type { LikeC4Model, RelationshipModel } from '../../../model'
+import { type ConnectionModel, Connection } from '../../../model'
+import type { AnyAux } from '../../../types'
+import { type ModelRelationExpr, FqnRef, ModelFqnExpr } from '../../../types'
+import { nonexhaustive } from '../../../utils'
 import { toSet } from '../../../utils/iterable/to'
 import { elementExprToPredicate } from '../../utils/elementExpressionToPredicate'
 import type { ConnectionWhere, PredicateExecutor } from '../_types'
-import { resolveAndIncludeFromMemory, resolveElements } from './_utils'
+import { findConnectionsBetween, resolveAndIncludeFromMemory, resolveElements } from './_utils'
 
-export const OutgoingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Outgoing> = {
+export const OutgoingExprPredicate: PredicateExecutor<ModelRelationExpr.Outgoing<AnyAux>> = {
   include: ({ expr, scope, model, memory, stage, filterWhere }) => {
     const target = expr.outgoing
     const connections = [] as ConnectionModel<AnyAux>[]
-    if (ModelLayer.FqnExpr.isWildcard(target)) {
+    if (ModelFqnExpr.isWildcard(target)) {
       if (!scope) {
         return
       }
@@ -57,7 +56,7 @@ export const OutgoingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Ou
   },
   exclude: ({ expr: { outgoing }, model, scope, stage, where }) => {
     const excluded = [] as RelationshipModel[]
-    if (ModelLayer.FqnExpr.isWildcard(outgoing)) {
+    if (ModelFqnExpr.isWildcard(outgoing)) {
       if (!scope) {
         return
       }
@@ -78,24 +77,24 @@ export const OutgoingExprPredicate: PredicateExecutor<ModelLayer.RelationExpr.Ou
 
 export function outgoingConnectionPredicate(
   model: LikeC4Model,
-  expr: ModelLayer.FqnExpr.NonWildcard,
+  expr: ModelFqnExpr.NonWildcard,
 ): ConnectionWhere {
   switch (true) {
-    case ModelLayer.FqnExpr.isElementKindExpr(expr):
-    case ModelLayer.FqnExpr.isElementTagExpr(expr): {
+    case ModelFqnExpr.isElementKindExpr(expr):
+    case ModelFqnExpr.isElementTagExpr(expr): {
       const isElement = elementExprToPredicate(expr)
       return (connection) => isElement(connection.source)
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'children': {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'children': {
+      const fqn = FqnRef.flatten(expr.ref)
       return anyPass(
         [...model.children(fqn)].map(
           el => Connection.isOutgoing(el.id),
         ),
       )
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'descendants': {
+      const fqn = FqnRef.flatten(expr.ref)
       return anyPass([
         Connection.isInside(fqn),
         ...[...model.children(fqn)].map(
@@ -103,15 +102,15 @@ export function outgoingConnectionPredicate(
         ),
       ])
     }
-    case ModelLayer.FqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr) && expr.selector === 'expanded': {
+      const fqn = FqnRef.flatten(expr.ref)
       return anyPass([
         Connection.isOutgoing(fqn),
         Connection.isInside(fqn),
       ])
     }
-    case ModelLayer.FqnExpr.isModelRef(expr): {
-      const fqn = ModelLayer.FqnRef.toFqn(expr.ref)
+    case ModelFqnExpr.isModelRef(expr): {
+      const fqn = FqnRef.flatten(expr.ref)
       return Connection.isOutgoing(fqn)
     }
     default:

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

@@ -1,12 +1,12 @@
 import { filter } from 'remeda'
-import { findConnectionsBetween, findConnectionsWithin } from '../../../model/connection/model'
-import type { ModelLayer } from '../../../types/expression-v2-model'
+import type { ModelFqnExpr } from '../../../types'
 import { ifilter, toArray } from '../../../utils/iterable'
 import { toSet } from '../../../utils/iterable/to'
 import { type PredicateExecutor, Memory } from '../_types'
 import { NoWhere } from '../utils'
+import { findConnectionsBetween, findConnectionsWithin } from './_utils'
 
-export const WildcardPredicate: PredicateExecutor<ModelLayer.FqnExpr.Wildcard> = {
+export const WildcardPredicate: PredicateExecutor<ModelFqnExpr.Wildcard> = {
   include: ({ scope, model, stage, memory, where }) => {
     if (!scope) {
       const rootElements = [...model.roots()].filter(where)

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

@@ -1,23 +1,22 @@
 import { filter, hasAtLeast, only } from 'remeda'
-import { invariant } from '../../errors'
-import { type ComputedEdge, type ComputedNode, type Fqn } from '../../types'
-import { type ComputedNodeSource, buildComputedNodes } from '../utils/buildComputedNodes'
+import type { ConnectionModel } from '../../model'
+import {
+  type AnyAux,
+  type ComputedEdge,
+  type ComputedNode,
+  type scalar,
+} from '../../types'
+import { invariant } from '../../utils'
+import { buildComputedNodes, elementModelToNodeSource } from '../utils/buildComputedNodes'
 import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
-import type { Connection, Elem, Memory } from './_types'
+import type { Memory } from './_types'
 
 export const NoWhere = () => true
 export const NoFilter = <T>(x: T[] | readonly T[]): T[] => x as T[]
 
-export function toNodeSource(el: Elem): ComputedNodeSource {
-  return {
-    ...el.$element,
-    modelRef: 1,
-  }
-}
-
-export function toComputedEdges(
-  connections: ReadonlyArray<Connection>,
-): ComputedEdge[] {
+export function toComputedEdges<A extends AnyAux>(
+  connections: ReadonlyArray<ConnectionModel<A>>,
+): ComputedEdge<A>[] {
   return connections.reduce((acc, e) => {
     // const modelRelations = []
     // const deploymentRelations = []
@@ -41,11 +40,11 @@ export function toComputedEdges(
       )?.$relationship,
     )
 
-    const edge: ComputedEdge = {
+    const edge: ComputedEdge<A> = {
       id: e.id,
-      parent: e.boundary?.id ?? null,
-      source,
-      target,
+      parent: e.boundary?.id as scalar.NodeId ?? null,
+      source: source as scalar.NodeId,
+      target: target as scalar.NodeId,
       label: title ?? null,
       relations: relations.map((r) => r.id),
       ...props,
@@ -53,11 +52,14 @@ export function toComputedEdges(
 
     acc.push(edge)
     return acc
-  }, [] as ComputedEdge[])
+  }, [] as ComputedEdge<A>[])
 }
 
-export function buildNodes(memory: Memory): ReadonlyMap<Fqn, ComputedNode> {
-  // typecast to MutableMemory
-  // invariant(memory instanceof MutableMemory, 'Expected MutableMemory')
-  return buildComputedNodes([...memory.final].map(toNodeSource), memory.groups)
+export function buildNodes<A extends AnyAux>(
+  memory: Memory,
+): ReadonlyMap<scalar.NodeId, ComputedNode<A>> {
+  return buildComputedNodes(
+    [...memory.final].map(elementModelToNodeSource),
+    memory.groups,
+  )
 }

package/src/compute-view/index.ts

@@ -1,4 +1,4 @@
-export { computeView, computeViews, unsafeComputeView } from './compute-view'
+export { computeLikeC4Model, computeParsedModelData, computeView, unsafeComputeView } from './compute-view'
 export type { ComputeViewResult } from './compute-view'
 export { resolveRulesExtendedViews } from './utils/resolve-extended-views'
 export { viewsWithReadableEdges, withReadableEdges } from './utils/with-readable-edges'

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

@@ -1,7 +1,6 @@
 import { isBoolean, pipe } from 'remeda'
-import { invariant } from '../../errors'
-import { findAscendingConnections } from '../../model/connection'
-import { difference, intersection, isDescendantOf, isIterable } from '../../utils'
+import { findAscendingConnections } from '../../model'
+import { difference, intersection, invariant, isDescendantOf, isIterable } from '../../utils'
 import { ifilter, isome, toSet } from '../../utils/iterable'
 import type { AnyCtx, CtxConnection, CtxElement, MutableState, StageExclude, StageExpression } from './_types'
 
@@ -209,7 +208,7 @@ export abstract class AbstractStageExclude<T extends AnyCtx> implements StageExc
       state = this.removeElements(state)
     }
 
-    //state = this.moveDisconnectedExplicitsToImplicits(state)
+    // state = this.moveDisconnectedExplicitsToImplicits(state)
 
     return this.memory.update(this.postcommit(state))
   }

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

@@ -1,5 +1,5 @@
 import { partition } from 'remeda'
-import { mergeConnections } from '../../model/connection'
+import { mergeConnections } from '../../model'
 import { intersection, isIterable, union } from '../../utils'
 import type {
   AnyCtx,

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

@@ -1,11 +1,12 @@
 import type { Connection } from '../../model/connection'
 import type { DeploymentElementModel } from '../../model/DeploymentElementModel'
 import type { ElementModel } from '../../model/ElementModel'
+import type { AnyAux } from '../../types'
 
-type Element = ElementModel | DeploymentElementModel
+type Element<A extends AnyAux> = ElementModel<A> | DeploymentElementModel<A>
 
 export interface ComputeCtx<
-  E extends Element,
+  E extends Element<AnyAux>,
   C extends Connection<E, any>,
   M extends ComputeMemory<any>,
   Inc extends StageInclude<any>,

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

@@ -1,6 +1,5 @@
-import { type ElementModel } from '../../model/ElementModel'
-import type { RelationshipModel } from '../../model/RelationModel'
-import type { AnyAux } from '../../model/types'
+import type { ElementModel, RelationshipModel } from '../../model'
+import type { AnyAux, Unknown } from '../../types'
 
 // type Pair = {
 //   left: ReadonlySet<ElementModel>
@@ -8,7 +7,7 @@ import type { AnyAux } from '../../model/types'
 //   right: ReadonlySet<ElementModel>
 // }
 
-export type RelationshipsViewData<M extends AnyAux = AnyAux> = {
+export type RelationshipsViewData<M extends AnyAux = Unknown> = {
   incomers: ReadonlySet<ElementModel<M>>
   incoming: ReadonlySet<RelationshipModel<M>>
   subjects: ReadonlySet<ElementModel<M>>

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

@@ -1,10 +1,7 @@
 import { pipe } from 'remeda'
-import { invariant } from '../../errors'
-import type { ElementModel } from '../../model/ElementModel'
-import type { LikeC4Model } from '../../model/LikeC4Model'
-import type { RelationshipModel } from '../../model/RelationModel'
-import type { AnyAux } from '../../model/types'
-import type { LikeC4ViewModel } from '../../model/view/LikeC4ViewModel'
+import type { ElementModel, LikeC4Model, LikeC4ViewModel, RelationshipModel } from '../../model'
+import type { AnyAux, aux } from '../../types'
+import { invariant } from '../../utils'
 import { isDescendantOf, sortParentsFirst } from '../../utils/fqn'
 import { ifilter, imap, toArray, toSet } from '../../utils/iterable'
 import type { RelationshipsViewData } from './_types'
@@ -104,10 +101,10 @@ function computeRelationships<const M extends AnyAux>(
   }
 }
 
-export function computeRelationshipsView<const M extends AnyAux>(
-  subjectId: NoInfer<M['Element']>,
+export function computeRelationshipsView<M extends AnyAux>(
+  subjectId: aux.ElementId<M>,
   likec4model: LikeC4Model<M>,
-  scopeViewId: NoInfer<M['View']> | null,
+  scopeViewId: aux.ViewId<M> | null,
   scope: 'global' | 'view' = 'global',
 ): RelationshipsViewData<M> {
   let subjectExistsInScope = true
@@ -132,8 +129,8 @@ export function computeRelationshipsView<const M extends AnyAux>(
   )
 }
 
-function computeScopedRelationshipsView<const M extends AnyAux>(
-  subjectId: NoInfer<M['Element']>,
+function computeScopedRelationshipsView<M extends AnyAux>(
+  subjectId: NoInfer<aux.ElementId<M>>,
   view: LikeC4ViewModel<M>,
   likec4model: LikeC4Model<M>,
 ): RelationshipsViewData<M> {

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

@@ -1,10 +1,9 @@
 import dagre, { type EdgeConfig, type GraphLabel } from '@dagrejs/dagre'
 import { concat, filter, forEachObj, groupBy, map, mapToObj, pipe, prop, reduce, tap } from 'remeda'
-import { invariant } from '../../errors'
 import type { ElementModel } from '../../model/ElementModel'
 import type { RelationshipModel } from '../../model/RelationModel'
 import type { DiagramNode, DiagramView, Fqn, NodeId } from '../../types'
-import { sortParentsFirst } from '../../utils'
+import { invariant, sortParentsFirst } from '../../utils'
 import { toArray } from '../../utils/iterable'
 import { DefaultMap } from '../../utils/mnemonist'
 import type { RelationshipsViewData } from './_types'
@@ -43,7 +42,7 @@ const Sizes = {
 }
 type NodeData = {
   portId: string
-  element: ElementModel
+  element: ElementModel<any>
   isCompound: boolean
 }
 function createGraph() {
@@ -80,7 +79,7 @@ const PortSuffix = '-port'
 
 function createNodes(
   prefix: string,
-  elements: ReadonlySet<ElementModel>,
+  elements: ReadonlySet<ElementModel<any>>,
   g: G,
 ) {
   const graphNodes = new DefaultMap<Fqn, { id: string; portId: string }>(key => ({
@@ -315,11 +314,12 @@ export function layoutRelationshipsView(data: RelationshipsViewData): Pick<Diagr
     return {
       id: id as NodeId,
       parent: parentId as NodeId ?? null,
-      position: [position.x, position.y],
       title: element.title,
+      ...position,
+      position: [position.x, position.y],
       description: element.description,
       technology: element.technology,
-      tags: null,
+      tags: [],
       links: null,
       color: element.color,
       shape: element.shape,

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

@@ -1,10 +1,10 @@
-import { nonNullable } from '../../errors'
 import type { ElementModel } from '../../model/ElementModel'
-import type { AnyAux } from '../../model/types'
+import type { AnyAux, aux } from '../../types'
+import { nonNullable } from '../../utils'
 import { isAncestor, isDescendantOf, sortParentsFirst } from '../../utils/fqn'
 import { DefaultMap } from '../../utils/mnemonist'
 
-export function treeFromElements<const M extends AnyAux>(elements: Iterable<ElementModel<M>>) {
+export function treeFromElements<M extends AnyAux>(elements: Iterable<ElementModel<M>>) {
   const sorted = sortParentsFirst([...elements]) as ReadonlyArray<ElementModel<M>>
   const root = new Set(sorted)
   const map = new Map(sorted.map(e => [e._literalId, e]))
@@ -32,7 +32,7 @@ export function treeFromElements<const M extends AnyAux>(elements: Iterable<Elem
 
   return {
     sorted,
-    byId: (id: M['Element']): ElementModel<M> => nonNullable(map.get(id), `Element not found by id: ${id}`),
+    byId: (id: aux.ElementId<M>): ElementModel<M> => nonNullable(map.get(id), `Element not found by id: ${id}`),
     root: root as ReadonlySet<ElementModel<M>>,
     parent: (el: ElementModel<M>): ElementModel<M> | null => parents.get(el),
     children: (el: ElementModel<M>): ReadonlyArray<ElementModel<M>> => children.get(el),

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

@@ -1,14 +1,14 @@
-import { nonNullable } from '../../errors'
-import type { ComputedNode, Fqn } from '../../types'
+import type { AnyAux, ComputedNode } from '../../types'
+import { nonNullable } from '../../utils'
 
 /**
  * Returns the ancestors of given computed node, starting with the direct parent and ending with the root node.
  */
-export function ancestorsOfNode(
-  node: ComputedNode,
-  nodes: ReadonlyMap<Fqn, ComputedNode>
-): ReadonlyArray<ComputedNode> {
-  const ancestors = [] as ComputedNode[]
+export function ancestorsOfNode<A extends AnyAux>(
+  node: ComputedNode<A>,
+  nodes: ReadonlyMap<string, ComputedNode<A>>,
+): ReadonlyArray<ComputedNode<A>> {
+  const ancestors = [] as ComputedNode<A>[]
   let parentId = node.parent
   while (parentId) {
     const parentNode = nonNullable(nodes.get(parentId), `Parent node ${parentId} not found`)

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

@@ -1,15 +1,20 @@
 import { isEmpty, isNullish, omitBy } from 'remeda'
 import {
-  type ViewRule,
-  ComputedNode,
+  type AnyAux,
+  type ComputedNode,
+  type ElementViewRule,
+  type ModelExpression,
+  isGroupElementKind,
   isViewRuleGroup,
   isViewRulePredicate,
-  ModelLayer,
+  ModelFqnExpr,
 } from '../../types'
 import { elementExprToPredicate } from './elementExpressionToPredicate'
 
-export function flattenGroupRules<T extends ModelLayer.Expression>(guard: (expr: ModelLayer.Expression) => expr is T) {
-  return (rule: ViewRule): Array<T> => {
+export function flattenGroupRules<A extends AnyAux, T extends ModelExpression<A>>(
+  guard: (expr: ModelExpression<A>) => expr is T,
+) {
+  return (rule: ElementViewRule<A>): Array<T> => {
     if (isViewRuleGroup(rule)) {
       return rule.groupRules.flatMap(flattenGroupRules(guard))
     }
@@ -21,8 +26,11 @@ export function flattenGroupRules<T extends ModelLayer.Expression>(guard: (expr:
   }
 }
 
-export function applyCustomElementProperties(_rules: ViewRule[], _nodes: ComputedNode[]) {
-  const rules = _rules.flatMap(flattenGroupRules(ModelLayer.FqnExpr.isCustom))
+export function applyCustomElementProperties<A extends AnyAux>(
+  _rules: ElementViewRule<A>[],
+  _nodes: ComputedNode<A>[],
+) {
+  const rules = _rules.flatMap(flattenGroupRules(ModelFqnExpr.isCustom))
   if (rules.length === 0) {
     return _nodes
   }
@@ -44,7 +52,7 @@ export function applyCustomElementProperties(_rules: ViewRule[], _nodes: Compute
     const notEmpty = !isEmpty(rest)
     const satisfies = elementExprToPredicate(expr)
     nodes.forEach((node, i) => {
-      if (ComputedNode.isNodesGroup(node) || !satisfies(node)) {
+      if (isGroupElementKind(node) || !satisfies(node)) {
         return
       }
       if (notEmpty) {

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

@@ -1,14 +1,14 @@
 import { isNullish, omitBy, pick } from 'remeda'
-import { type ComputedEdge, type ComputedNode, type ViewRule, ModelLayer } from '../../types'
+import { type AnyAux, type ComputedEdge, type ComputedNode, type ElementViewRule, ModelRelationExpr } from '../../types'
 import { flattenGroupRules } from './applyCustomElementProperties'
 import { relationExpressionToPredicates } from './relationExpressionToPredicates'
 
-export function applyCustomRelationProperties(
-  _rules: ViewRule[],
-  nodes: ComputedNode[],
-  _edges: Iterable<ComputedEdge>,
-): ComputedEdge[] {
-  const rules = _rules.flatMap(flattenGroupRules(ModelLayer.RelationExpr.isCustom))
+export function applyCustomRelationProperties<A extends AnyAux>(
+  _rules: ElementViewRule<A>[],
+  nodes: ComputedNode<A>[],
+  _edges: Iterable<ComputedEdge<A>>,
+): ComputedEdge<A>[] {
+  const rules = _rules.flatMap(flattenGroupRules(ModelRelationExpr.isCustom))
   const edges = Array.from(_edges)
   if (rules.length === 0 || edges.length === 0) {
     return edges
@@ -25,8 +25,18 @@ export function applyCustomRelationProperties(
     const props = omitBy(customprops, isNullish)
     const satisfies = relationExpressionToPredicates(expr)
     edges.forEach((edge, i) => {
-      const source = nodes.find(n => n.id === edge.source)
-      const target = nodes.find(n => n.id === edge.target)
+      let source, target
+      for (const node of nodes) {
+        if (node.id === edge.source) {
+          source = node
+        }
+        if (node.id === edge.target) {
+          target = node
+        }
+        if (source && target) {
+          break
+        }
+      }
       if (!source || !target) {
         return
       }

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

@@ -1,19 +1,24 @@
 import { anyPass, filter, forEach, isDefined, isNot, pipe } from 'remeda'
-import { type ViewRule, type ViewRuleStyle, ComputedNode, isViewRuleStyle } from '../../types'
+import {
+  type AnyAux,
+  type AnyViewRuleStyle,
+  type ComputedNode,
+  type ElementViewRule,
+  isGroupElementKind,
+  isViewRuleStyle,
+} from '../../types'
 import { elementExprToPredicate } from './elementExpressionToPredicate'
 
 type Predicate<T> = (x: T) => boolean
 
-type CommonViewRuleStyle = Pick<ViewRuleStyle, 'style' | 'notation'>
-
-export function applyViewRuleStyle<Rule extends CommonViewRuleStyle>(
-  rule: Rule,
-  predicates: Predicate<ComputedNode>[],
-  nodes: ComputedNode[],
-) {
+export function applyViewRuleStyle<A extends AnyAux>(
+  rule: Pick<AnyViewRuleStyle<A>, 'style' | 'notation'>,
+  predicates: Predicate<ComputedNode<A>>[],
+  nodes: ComputedNode<A>[],
+): void {
   pipe(
     nodes,
-    filter(isNot(ComputedNode.isNodesGroup)),
+    filter(isNot(isGroupElementKind)),
     filter(anyPass(predicates)),
     forEach(n => {
       n.shape = rule.style.shape ?? n.shape
@@ -53,7 +58,10 @@ export function applyViewRuleStyle<Rule extends CommonViewRuleStyle>(
   )
 }
 
-export function applyViewRuleStyles(rules: ViewRule[], nodes: ComputedNode[]) {
+export function applyViewRuleStyles<A extends AnyAux, N extends ComputedNode<A>[]>(
+  rules: ElementViewRule<A>[],
+  nodes: N,
+): N {
   for (const rule of rules) {
     if (!isViewRuleStyle(rule) || rule.targets.length === 0) {
       continue