@likec4/core 1.30.0 → 1.32.0

package/src/model/DeploymentModel.ts

@@ -1,18 +1,16 @@
 import { values } from 'remeda'
-import type { LiteralUnion } from 'type-fest'
-import { invariant, nonNullable } from '../errors'
 import {
-  type ComputedDeploymentView,
-  type DeploymentRef,
-  type DeploymentRelation,
-  type GenericLikeC4ModelData,
+  type Any,
+  type DeploymentElement,
+  type DeploymentRelationship,
   type IteratorLike,
-  type Tag as C4Tag,
-  DeploymentElement,
+  FqnRef,
+  isDeploymentNode,
 } from '../types'
+import * as aux from '../types/aux'
+import { invariant, nonNullable } from '../utils'
 import { ancestorsFqn, parentFqn, sortParentsFirst } from '../utils/fqn'
 import { getOrCreate } from '../utils/getOrCreate'
-import { isString } from '../utils/guards'
 import { DefaultMap } from '../utils/mnemonist'
 import {
   type DeployedInstancesIterator,
@@ -25,48 +23,59 @@ import {
   NestedElementOfDeployedInstanceModel,
 } from './DeploymentElementModel'
 import type { LikeC4Model } from './LikeC4Model'
-import { type AnyAux, type IncomingFilter, type OutgoingFilter, getId } from './types'
+import {
+  type $ModelData,
+  type DeploymentOrFqn,
+  type ElementOrFqn,
+  type IncomingFilter,
+  type OutgoingFilter,
+  type RelationOrId,
+  getId,
+} from './types'
 import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
 
-export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
-  readonly #elements = new Map<M['Deployment'], DeploymentElementModel<M>>()
+export class LikeC4DeploymentModel<A extends Any = Any> {
+  readonly #elements = new Map<aux.DeploymentFqn<A>, DeploymentElementModel<A>>()
   // Parent element for given FQN
-  readonly #parents = new Map<M['Deployment'], DeploymentNodeModel<M>>()
+  readonly #parents = new Map<aux.DeploymentFqn<A>, DeploymentNodeModel<A>>()
   // Children elements for given FQN
-  readonly #children = new DefaultMap<M['Deployment'], Set<DeploymentElementModel<M>>>(() => new Set())
+  readonly #children = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentElementModel<A>>>(() => new Set())
 
   // Keep track of instances of the logical element
-  readonly #instancesOf = new DefaultMap<M['Element'], Set<DeployedInstanceModel<M>>>(() => new Set())
+  readonly #instancesOf = new DefaultMap<aux.Fqn<A>, Set<DeployedInstanceModel<A>>>(() => new Set())
 
-  readonly #rootElements = new Set<DeploymentNodeModel<M>>()
+  readonly #rootElements = new Set<DeploymentNodeModel<A>>()
 
-  readonly #relations = new Map<M['RelationId'], DeploymentRelationModel<M>>()
+  readonly #relations = new Map<aux.RelationId, DeploymentRelationModel<A>>()
 
   // Incoming to an element or its descendants
-  readonly #incoming = new DefaultMap<M['Deployment'], Set<DeploymentRelationModel<M>>>(() => new Set())
+  readonly #incoming = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentRelationModel<A>>>(() => new Set())
 
   // Outgoing from an element or its descendants
-  readonly #outgoing = new DefaultMap<M['Deployment'], Set<DeploymentRelationModel<M>>>(() => new Set())
+  readonly #outgoing = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentRelationModel<A>>>(() => new Set())
 
   // Relationships inside the element, among descendants
-  readonly #internal = new DefaultMap<M['Deployment'], Set<DeploymentRelationModel<M>>>(() => new Set())
+  readonly #internal = new DefaultMap<aux.DeploymentFqn<A>, Set<DeploymentRelationModel<A>>>(() => new Set())
 
-  // readonly #views = new Map<ViewID, LikeC4ViewModel<M>>()
+  // readonly #views = new Map<ViewID, LikeC4ViewModel<A>>()
 
-  readonly #allTags = new DefaultMap<C4Tag, Set<DeploymentElementModel<M> | DeploymentRelationModel<M>>>(() =>
-    new Set()
+  readonly #allTags = new DefaultMap<aux.Tag<A>, Set<DeploymentElementModel<A> | DeploymentRelationModel<A>>>(
+    () => new Set(),
   )
 
   readonly #nestedElementsOfDeployment = new Map<
-    `${M['Deployment']}@${M['Element']}`,
-    NestedElementOfDeployedInstanceModel<M>
+    `${aux.DeploymentId<A>}@${aux.ElementId<A>}`,
+    NestedElementOfDeployedInstanceModel<A>
   >()
 
+  public readonly $deployments: $ModelData<A>['deployments']
+
   constructor(
-    public readonly $model: LikeC4Model<M>,
-    public readonly $deployments: GenericLikeC4ModelData['deployments'],
+    public readonly $model: LikeC4Model<A>,
   ) {
-    for (const element of sortParentsFirst(values($deployments.elements))) {
+    const $deployments = this.$deployments = $model.$data.deployments
+    const elements = values($deployments.elements as Record<string, DeploymentElement<A>>)
+    for (const element of sortParentsFirst(elements)) {
       const el = this.addElement(element)
       for (const tag of el.tags) {
         this.#allTags.get(tag).add(el)
@@ -83,23 +92,23 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
     }
   }
 
-  public element(el: M['DeploymentOrFqn']): DeploymentElementModel<M> {
+  public element(el: DeploymentOrFqn<A>): DeploymentElementModel<A> {
     if (el instanceof DeploymentNodeModel || el instanceof DeployedInstanceModel) {
       return el
     }
     const id = getId(el)
     return nonNullable(this.#elements.get(id), `Element ${id} not found`)
   }
-  public findElement(el: M['Deployment']): DeploymentElementModel<M> | null {
-    return this.#elements.get(el) ?? null
+  public findElement(el: aux.LooseDeploymentId<A>): DeploymentElementModel<A> | null {
+    return this.#elements.get(el as aux.DeploymentFqn<A>) ?? null
   }
 
-  public node(el: M['DeploymentOrFqn']): DeploymentNodeModel<M> {
+  public node(el: DeploymentOrFqn<A>): DeploymentNodeModel<A> {
     const element = this.element(el)
     invariant(element.isDeploymentNode(), `Element ${element.id} is not a deployment node`)
     return element
   }
-  public findNode(el: M['Deployment']): DeploymentNodeModel<M> | null {
+  public findNode(el: aux.LooseDeploymentId<A>): DeploymentNodeModel<A> | null {
     const element = this.findElement(el)
     if (!element) {
       return null
@@ -108,12 +117,12 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
     return element
   }
 
-  public instance(el: M['DeploymentOrFqn']): DeployedInstanceModel<M> {
+  public instance(el: DeploymentOrFqn<A>): DeployedInstanceModel<A> {
     const element = this.element(el)
     invariant(element.isInstance(), `Element ${element.id} is not a deployed instance`)
     return element
   }
-  public findInstance(el: M['Deployment']): DeployedInstanceModel<M> | null {
+  public findInstance(el: aux.LooseDeploymentId<A>): DeployedInstanceModel<A> | null {
     const element = this.findElement(el)
     if (!element) {
       return null
@@ -125,21 +134,21 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
   /**
    * Returns the root elements of the model.
    */
-  public roots(): DeploymentNodesIterator<M> {
+  public roots(): DeploymentNodesIterator<A> {
     return this.#rootElements.values()
   }
 
   /**
    * Returns all elements in the model.
    */
-  public elements(): DeploymentElementsIterator<M> {
+  public elements(): DeploymentElementsIterator<A> {
     return this.#elements.values()
   }
 
   /**
    * Returns all elements in the model.
    */
-  public *nodes(): DeploymentNodesIterator<M> {
+  public *nodes(): DeploymentNodesIterator<A> {
     for (const element of this.#elements.values()) {
       if (element.isDeploymentNode()) {
         yield element
@@ -148,7 +157,16 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  public *instances(): DeployedInstancesIterator<M> {
+  public *nodesOfKind(kind: aux.DeploymentKind<A>): DeploymentNodesIterator<A> {
+    for (const node of this.#elements.values()) {
+      if (node.isDeploymentNode() && node.kind === kind) {
+        yield node
+      }
+    }
+    return
+  }
+
+  public *instances(): DeployedInstancesIterator<A> {
     for (const element of this.#elements.values()) {
       if (element.isInstance()) {
         yield element
@@ -160,7 +178,7 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
   /**
    * Iterate over all instances of the given logical element.
    */
-  public *instancesOf(element: M['ElementOrFqn']): DeployedInstancesIterator<M> {
+  public *instancesOf(element: ElementOrFqn<A>): DeployedInstancesIterator<A> {
     const id = getId(element)
     const instances = this.#instancesOf.get(id)
     if (instances) {
@@ -169,37 +187,39 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  public deploymentRef(ref: DeploymentRef): DeploymentElementModel<M> | NestedElementOfDeployedInstanceModel<M> {
-    if ('element' in ref) {
-      const { id, element } = ref
-      return getOrCreate(this.#nestedElementsOfDeployment, `${id}@${element}`, () => {
-        return new NestedElementOfDeployedInstanceModel(this.instance(id), this.$model.element(element))
+  public deploymentRef(
+    ref: FqnRef.DeploymentRef<A>,
+  ): DeploymentElementModel<A> | NestedElementOfDeployedInstanceModel<A> {
+    if (FqnRef.isInsideInstanceRef(ref)) {
+      const { deployment, element } = ref
+      return getOrCreate(this.#nestedElementsOfDeployment, `${deployment}@${element}`, () => {
+        return new NestedElementOfDeployedInstanceModel(this.instance(deployment), this.$model.element(element))
       })
     }
-    return this.element(ref)
+    return this.element(ref.deployment)
   }
 
   /**
    * Returns all relationships in the model.
    */
-  public relationships(): IteratorLike<DeploymentRelationModel<M>> {
+  public relationships(): IteratorLike<DeploymentRelationModel<A>> {
     return this.#relations.values()
   }
 
   /**
    * Returns a specific relationship by its ID.
    */
-  public relationship(id: M['RelationId']): DeploymentRelationModel<M> {
-    return nonNullable(this.#relations.get(id), `DeploymentRelationModel ${id} not found`)
+  public relationship(id: RelationOrId): DeploymentRelationModel<A> {
+    return nonNullable(this.#relations.get(getId(id)), `DeploymentRelationModel ${id} not found`)
   }
-  public findRelationship(id: LiteralUnion<M['RelationId'], string>): DeploymentRelationModel<M> | null {
-    return this.#relations.get(id as M['RelationId']) ?? null
+  public findRelationship(id: string): DeploymentRelationModel<A> | null {
+    return this.#relations.get(id as aux.RelationId) ?? null
   }
 
   /**
    * Returns all deployment views in the model.
    */
-  public *views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>> {
+  public *views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>> {
     for (const view of this.$model.views()) {
       if (view.isDeploymentView()) {
         yield view
@@ -212,7 +232,7 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
    * Returns the parent element of given element.
    * @see ancestors
    */
-  public parent(element: M['DeploymentOrFqn']): DeploymentNodeModel<M> | null {
+  public parent(element: DeploymentOrFqn<A>): DeploymentNodeModel<A> | null {
     const id = getId(element)
     return this.#parents.get(id) || null
   }
@@ -221,7 +241,7 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
    * Get all children of the element (only direct children),
    * @see descendants
    */
-  public children(element: M['DeploymentOrFqn']): ReadonlySet<DeploymentElementModel<M>> {
+  public children(element: DeploymentOrFqn<A>): ReadonlySet<DeploymentElementModel<A>> {
     const id = getId(element)
     return this.#children.get(id)
   }
@@ -229,7 +249,7 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
   /**
    * Get all sibling (i.e. same parent)
    */
-  public *siblings(element: M['DeploymentOrFqn']): DeploymentElementsIterator<M> {
+  public *siblings(element: DeploymentOrFqn<A>): DeploymentElementsIterator<A> {
     const id = getId(element)
     const siblings = this.parent(element)?.children() ?? this.roots()
     for (const sibling of siblings) {
@@ -244,8 +264,8 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
    * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
    * (from closest to root)
    */
-  public *ancestors(element: M['DeploymentOrFqn']): DeploymentNodesIterator<M> {
-    let id = isString(element) ? element : element.id
+  public *ancestors(element: DeploymentOrFqn<A>): DeploymentNodesIterator<A> {
+    let id = getId(element)
     let parent
     while (parent = this.#parents.get(id)) {
       yield parent
@@ -257,7 +277,10 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
   /**
    * Get all descendant elements (i.e. children, children’s children, etc.)
    */
-  public *descendants(element: M['DeploymentOrFqn'], sort: 'asc' | 'desc' = 'desc'): DeploymentElementsIterator<M> {
+  public *descendants(
+    element: DeploymentOrFqn<A>,
+    sort: 'asc' | 'desc' = 'desc',
+  ): DeploymentElementsIterator<A> {
     for (const child of this.children(element)) {
       if (sort === 'asc') {
         yield child
@@ -275,9 +298,9 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
    * @see incomers
    */
   public *incoming(
-    element: M['DeploymentOrFqn'],
+    element: DeploymentOrFqn<A>,
     filter: IncomingFilter = 'all',
-  ): IteratorLike<DeploymentRelationModel<M>> {
+  ): IteratorLike<DeploymentRelationModel<A>> {
     const id = getId(element)
     for (const rel of this.#incoming.get(id)) {
       switch (true) {
@@ -296,9 +319,9 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
    * @see outgoers
    */
   public *outgoing(
-    element: M['DeploymentOrFqn'],
+    element: DeploymentOrFqn<A>,
     filter: OutgoingFilter = 'all',
-  ): IteratorLike<DeploymentRelationModel<M>> {
+  ): IteratorLike<DeploymentRelationModel<A>> {
     const id = getId(element)
     for (const rel of this.#outgoing.get(id)) {
       switch (true) {
@@ -312,11 +335,11 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  private addElement(element: DeploymentElement) {
+  private addElement(element: DeploymentElement<A>) {
     if (this.#elements.has(element.id)) {
       throw new Error(`Element ${element.id} already exists`)
     }
-    const el = DeploymentElement.isDeploymentNode(element)
+    const el = isDeploymentNode(element)
       ? new DeploymentNodeModel(this, Object.freeze(element))
       : new DeployedInstanceModel(this, Object.freeze(element), this.$model.element(element.element))
     this.#elements.set(el.id, el)
@@ -332,7 +355,7 @@ export class LikeC4DeploymentModel<M extends AnyAux = AnyAux> {
     return el
   }
 
-  private addRelation(relation: DeploymentRelation) {
+  private addRelation(relation: DeploymentRelationship<A>) {
     if (this.#relations.has(relation.id)) {
       throw new Error(`Relation ${relation.id} already exists`)
     }

package/src/model/ElementModel.ts

@@ -1,45 +1,41 @@
-import { isTruthy } from 'remeda'
+import { isTruthy, unique } from 'remeda'
 import type { SetRequired } from 'type-fest'
-import type { IteratorLike } from '../types/_common'
+import type { Any, AnyAux, Color, IteratorLike } from '../types'
 import {
   type Element as C4Element,
-  type ElementKind as C4ElementKind,
   type ElementShape as C4ElementShape,
   type ElementStyle,
+  type IconUrl,
   type Link,
+  type ProjectId,
   DefaultElementShape,
+  DefaultShapeSize,
   DefaultThemeColor,
-} from '../types/element'
-import { DefaultShapeSize } from '../types/element'
-import {
-  type IconUrl,
-  type ProjectId,
-  type Tag as C4Tag,
   splitGlobalFqn,
-} from '../types/scalars'
-import type { ThemeColor } from '../types/theme'
-import { commonAncestor, hierarchyLevel, isAncestor, sortNaturalByFqn } from '../utils'
+} from '../types'
+import * as aux from '../types/aux'
+import { commonAncestor, hierarchyLevel, ihead, isAncestor, memoizeProp, sortNaturalByFqn } from '../utils'
 import { type DeployedInstancesIterator } from './DeploymentElementModel'
 import type { LikeC4Model } from './LikeC4Model'
 import type { RelationshipModel, RelationshipsIterator } from './RelationModel'
-import type { AnyAux, IncomingFilter, OutgoingFilter } from './types'
-import type { LikeC4ViewModel, ViewsIterator } from './view/LikeC4ViewModel'
+import type { $ViewWithType, IncomingFilter, OutgoingFilter } from './types'
+import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
 
 export type ElementsIterator<M extends AnyAux> = IteratorLike<ElementModel<M>>
 
-export class ElementModel<M extends AnyAux = AnyAux> {
-  readonly id: M['Fqn']
-  readonly _literalId: M['Element']
+export class ElementModel<A extends AnyAux = Any> {
+  readonly id: aux.Fqn<A>
+  readonly _literalId: aux.ElementId<A>
   readonly hierarchyLevel: number
 
   readonly imported: null | {
     from: ProjectId
-    fqn: string
+    fqn: aux.Fqn<A>
   }
 
   constructor(
-    public readonly $model: LikeC4Model<M>,
-    public readonly $element: C4Element,
+    public readonly $model: LikeC4Model<A>,
+    public readonly $element: C4Element<A>,
   ) {
     this.id = this.$element.id
     this._literalId = this.$element.id
@@ -56,11 +52,11 @@ export class ElementModel<M extends AnyAux = AnyAux> {
     }
   }
 
-  get parent(): ElementModel<M> | null {
+  get parent(): ElementModel<A> | null {
     return this.$model.parent(this)
   }
 
-  get kind(): C4ElementKind {
+  get kind(): aux.ElementKind<A> {
     return this.$element.kind
   }
 
@@ -68,16 +64,25 @@ export class ElementModel<M extends AnyAux = AnyAux> {
     return this.$element.shape ?? DefaultElementShape
   }
 
-  get color(): ThemeColor {
-    return this.$element.color as ThemeColor ?? DefaultThemeColor
+  get color(): Color {
+    return this.$element.color as Color ?? DefaultThemeColor
   }
 
   get icon(): IconUrl | null {
     return this.$element.icon ?? null
   }
 
-  get tags(): ReadonlyArray<C4Tag> {
-    return this.$element.tags ?? []
+  /**
+   * Returns all tags of the element.
+   * It includes tags from the element and its kind.
+   */
+  get tags(): aux.Tags<A> {
+    return memoizeProp(this, Symbol.for('tags'), () => {
+      return unique([
+        ...(this.$element.tags ?? []),
+        ...(this.$model.specification.elements[this.$element.kind]?.tags ?? []),
+      ] as aux.Tags<A>)
+    })
   }
 
   get title(): string {
@@ -85,19 +90,19 @@ export class ElementModel<M extends AnyAux = AnyAux> {
   }
 
   get description(): string | null {
-    return this.$element.description
+    return this.$element.description ?? null
   }
 
   get technology(): string | null {
-    return this.$element.technology
+    return this.$element.technology ?? null
   }
 
   get links(): ReadonlyArray<Link> {
     return this.$element.links ?? []
   }
 
-  get defaultView(): LikeC4ViewModel<M> | null {
-    return this.scopedViews().next().value ?? null
+  get defaultView(): LikeC4ViewModel<A, $ViewWithType<A, 'element'> & { viewOf: aux.StrictFqn<A> }> | null {
+    return memoizeProp(this, Symbol.for('defaultView'), () => ihead(this.scopedViews()) ?? null)
   }
 
   get isRoot(): boolean {
@@ -111,11 +116,11 @@ export class ElementModel<M extends AnyAux = AnyAux> {
     }
   }
 
-  public isAncestorOf(another: ElementModel<M>): boolean {
+  public isAncestorOf(another: ElementModel<A>): boolean {
     return isAncestor(this, another)
   }
 
-  public isDescendantOf(another: ElementModel<M>): boolean {
+  public isDescendantOf(another: ElementModel<A>): boolean {
     return isAncestor(another, this)
   }
 
@@ -123,26 +128,26 @@ export class ElementModel<M extends AnyAux = AnyAux> {
    * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
    * (from closest to root)
    */
-  public ancestors(): ElementsIterator<M> {
+  public ancestors(): ElementsIterator<A> {
     return this.$model.ancestors(this)
   }
 
   /**
    * Returns the common ancestor of this element and another element.
    */
-  public commonAncestor(another: ElementModel<M>): ElementModel<M> | null {
+  public commonAncestor(another: ElementModel<A>): ElementModel<A> | null {
     const common = commonAncestor(this.id, another.id)
     return common ? this.$model.element(common) : null
   }
 
-  public children(): ReadonlySet<ElementModel<M>> {
+  public children(): ReadonlySet<ElementModel<A>> {
     return this.$model.children(this)
   }
 
   /**
    * Get all descendant elements (i.e. children, children’s children, etc.)
    */
-  public descendants(sort?: 'asc' | 'desc'): ElementsIterator<M> {
+  public descendants(sort?: 'asc' | 'desc'): ElementsIterator<A> {
     if (sort) {
       const sorted = sortNaturalByFqn([...this.$model.descendants(this)], sort)
       return sorted[Symbol.iterator]()
@@ -153,15 +158,15 @@ export class ElementModel<M extends AnyAux = AnyAux> {
   /**
    * Get all sibling (i.e. same parent)
    */
-  public siblings(): ElementsIterator<M> {
+  public siblings(): ElementsIterator<A> {
     return this.$model.siblings(this)
   }
 
   /**
    * Resolve siblings of the element and its ancestors
-   *  (from closest to root)
+   * (from closest parent to root)
    */
-  public *ascendingSiblings(): ElementsIterator<M> {
+  public *ascendingSiblings(): ElementsIterator<A> {
     yield* this.siblings()
     for (const ancestor of this.ancestors()) {
       yield* ancestor.siblings()
@@ -173,7 +178,7 @@ export class ElementModel<M extends AnyAux = AnyAux> {
    * Resolve siblings of the element and its ancestors
    *  (from root to closest)
    */
-  public *descendingSiblings(): ElementsIterator<M> {
+  public *descendingSiblings(): ElementsIterator<A> {
     for (const ancestor of [...this.ancestors()].reverse()) {
       yield* ancestor.siblings()
     }
@@ -181,11 +186,11 @@ export class ElementModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  public incoming(filter: IncomingFilter = 'all'): RelationshipsIterator<M> {
+  public incoming(filter: IncomingFilter = 'all'): RelationshipsIterator<A> {
     return this.$model.incoming(this, filter)
   }
-  public *incomers(filter: IncomingFilter = 'all'): ElementsIterator<M> {
-    const unique = new Set<M['Fqn']>()
+  public *incomers(filter: IncomingFilter = 'all'): ElementsIterator<A> {
+    const unique = new Set<aux.StrictFqn<A>>()
     for (const r of this.incoming(filter)) {
       if (unique.has(r.source.id)) {
         continue
@@ -195,11 +200,11 @@ export class ElementModel<M extends AnyAux = AnyAux> {
     }
     return
   }
-  public outgoing(filter: OutgoingFilter = 'all'): RelationshipsIterator<M> {
+  public outgoing(filter: OutgoingFilter = 'all'): RelationshipsIterator<A> {
     return this.$model.outgoing(this, filter)
   }
-  public *outgoers(filter: OutgoingFilter = 'all'): ElementsIterator<M> {
-    const unique = new Set<M['Fqn']>()
+  public *outgoers(filter: OutgoingFilter = 'all'): ElementsIterator<A> {
+    const unique = new Set<aux.StrictFqn<A>>()
     for (const r of this.outgoing(filter)) {
       if (unique.has(r.target.id)) {
         continue
@@ -210,56 +215,71 @@ export class ElementModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  protected cachedOutgoing: Set<RelationshipModel<M>> | null = null
-  protected cachedIncoming: Set<RelationshipModel<M>> | null = null
-
-  public get allOutgoing(): ReadonlySet<RelationshipModel<M>> {
-    this.cachedOutgoing ??= new Set(this.outgoing())
-    return this.cachedOutgoing
+  public get allOutgoing(): ReadonlySet<RelationshipModel<A>> {
+    return memoizeProp(this, Symbol.for('allOutgoing'), () => new Set(this.outgoing()))
   }
 
-  public get allIncoming(): ReadonlySet<RelationshipModel<M>> {
-    this.cachedIncoming ??= new Set(this.incoming())
-    return this.cachedIncoming
+  public get allIncoming(): ReadonlySet<RelationshipModel<A>> {
+    return memoizeProp(this, Symbol.for('allIncoming'), () => new Set(this.incoming()))
   }
 
   /**
    * Iterate over all views that include this element.
    */
-  public *views(): ViewsIterator<M> {
-    for (const view of this.$model.views()) {
-      if (view.includesElement(this.id)) {
-        yield view
+  public views(): ReadonlySet<LikeC4ViewModel<A>> {
+    return memoizeProp(this, Symbol.for('views'), () => {
+      const views = new Set<LikeC4ViewModel<A>>()
+      for (const view of this.$model.views()) {
+        if (view.includesElement(this.id)) {
+          views.add(view)
+        }
       }
-    }
-    return
+      return views
+    })
   }
 
   /**
    * Iterate over all views that scope this element.
    * It is possible that element is not included in the view.
    */
-  public *scopedViews(): ViewsIterator<M> {
-    for (const vm of this.$model.views()) {
-      if (vm.isElementView() && vm.$view.viewOf === this.id) {
-        yield vm
+  public scopedViews(): ReadonlySet<
+    LikeC4ViewModel<A, $ViewWithType<A, 'element'> & { viewOf: aux.StrictFqn<A> }>
+  > {
+    return memoizeProp(this, Symbol.for('scopedViews'), () => {
+      const views = new Set<LikeC4ViewModel<A, $ViewWithType<A, 'element'> & { viewOf: aux.StrictFqn<A> }>>()
+      for (const vm of this.$model.views()) {
+        if (vm.isScopedElementView() && vm.viewOf.id === this.id) {
+          views.add(vm)
+        }
       }
-    }
-    return
+      return views
+    })
   }
 
   /**
    * @returns true if the element is deployed
    */
   public isDeployed(): boolean {
-    return isTruthy(this.deployments().next().value)
+    return isTruthy(ihead(this.deployments()))
   }
 
-  public deployments(): DeployedInstancesIterator<M> {
+  public deployments(): DeployedInstancesIterator<A> {
     return this.$model.deployment.instancesOf(this)
   }
-}
 
-export function isElementModel<M extends AnyAux = AnyAux>(element: any): element is ElementModel<M> {
-  return element instanceof ElementModel
+  public getMetadata(): aux.Metadata<A>
+  public getMetadata(field: aux.MetadataKey<A>): string | undefined
+  public getMetadata(field?: aux.MetadataKey<A>) {
+    if (field) {
+      return this.$element.metadata?.[field]
+    }
+    return this.$element.metadata ?? {}
+  }
+
+  /**
+   * Checks if the element has the given tag.
+   */
+  public isTagged(tag: aux.LooseTag<A>): boolean {
+    return this.tags.includes(tag as aux.Tag<A>)
+  }
 }