@likec4/core 1.30.0 → 1.32.0

package/src/model/DeploymentElementModel.ts

@@ -1,54 +1,48 @@
-import { isEmpty, only } from 'remeda'
+import { isTruthy, only, unique } from 'remeda'
 import type { SetRequired } from 'type-fest'
-import { nonNullable } from '../errors'
 import {
+  type Any,
   type Color,
-  type ComputedDeploymentView,
   type DeployedInstance,
+  type DeploymentElement,
   type DeploymentElementStyle,
   type DeploymentNode,
-  type DeploymentNodeKind,
-  type DeploymentRelation,
-  type ElementKind,
+  type DeploymentRelationship,
   type ElementShape as C4ElementShape,
   type IteratorLike,
   type Link,
-  type RelationshipKind,
   type RelationshipLineType,
-  type Tag,
-  type Tag as C4Tag,
-  type ThemeColor,
+  type scalar,
   DefaultElementShape,
   DefaultLineStyle,
-  DefaultRelationshipColor,
+  DefaultShapeSize,
   DefaultThemeColor,
 } from '../types'
-import { DefaultShapeSize } from '../types/element'
-import { commonAncestor, hierarchyLevel } from '../utils'
+import * as aux from '../types/aux'
+import { commonAncestor, hierarchyLevel, memoizeProp, nonNullable } from '../utils'
 import { difference, intersection, union } from '../utils/set'
 import type { LikeC4DeploymentModel } from './DeploymentModel'
 import type { ElementModel } from './ElementModel'
-import type { RelationshipModel, RelationshipsIterator } from './RelationModel'
-import type { AnyAux, IncomingFilter, OutgoingFilter } from './types'
+import type { AnyRelationshipModel, RelationshipModel, RelationshipsIterator } from './RelationModel'
+import type { IncomingFilter, OutgoingFilter } from './types'
 import type { LikeC4ViewModel } from './view/LikeC4ViewModel'
 
-export type DeploymentElementsIterator<M extends AnyAux> = IteratorLike<
-  DeploymentNodeModel<M> | DeployedInstanceModel<M>
->
-export type DeployedInstancesIterator<M extends AnyAux> = IteratorLike<DeployedInstanceModel<M>>
-export type DeploymentNodesIterator<M extends AnyAux> = IteratorLike<DeploymentNodeModel<M>>
+export type DeploymentElementsIterator<A extends Any> = IteratorLike<DeploymentElementModel<A>>
+export type DeployedInstancesIterator<A extends Any> = IteratorLike<DeployedInstanceModel<A>>
+export type DeploymentNodesIterator<A extends Any> = IteratorLike<DeploymentNodeModel<A>>
 
-export type DeploymentElementModel<M extends AnyAux = AnyAux> = DeploymentNodeModel<M> | DeployedInstanceModel<M>
+export type DeploymentElementModel<A extends Any = Any> = DeploymentNodeModel<A> | DeployedInstanceModel<A>
 
-abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
-  abstract readonly id: M['DeploymentFqn']
-  abstract readonly parent: DeploymentNodeModel<M> | null
+abstract class AbstractDeploymentElementModel<A extends Any> {
+  abstract readonly id: aux.DeploymentFqn<A>
+  abstract readonly _literalId: aux.DeploymentId<A>
+  abstract readonly parent: DeploymentNodeModel<A> | null
   abstract readonly title: string
   abstract readonly hierarchyLevel: number
 
-  abstract readonly $model: LikeC4DeploymentModel<M>
-  abstract readonly $node: DeploymentNode | DeployedInstance
-  abstract readonly kind: DeploymentNodeKind | ElementKind
+  abstract readonly $model: LikeC4DeploymentModel<A>
+  abstract readonly $node: DeploymentElement<A>
+  abstract readonly tags: aux.Tags<A>
 
   get style(): SetRequired<DeploymentElementStyle, 'shape' | 'color' | 'size'> {
     return {
@@ -63,12 +57,8 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
     return this.$node.style?.shape ?? DefaultElementShape
   }
 
-  get color(): ThemeColor {
-    return this.$node.style?.color as ThemeColor ?? DefaultThemeColor
-  }
-
-  get tags(): ReadonlyArray<C4Tag> {
-    return this.$node.tags ?? []
+  get color(): Color {
+    return this.$node.style?.color as Color ?? DefaultThemeColor
   }
 
   get description(): string | null {
@@ -87,14 +77,14 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
    * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
    * (from closest to root)
    */
-  public ancestors(): DeploymentNodesIterator<M> {
+  public ancestors(): DeploymentNodesIterator<A> {
     return this.$model.ancestors(this)
   }
 
   /**
    * Returns the common ancestor of this element and another element.
    */
-  public commonAncestor(another: DeploymentElementModel<M>): DeploymentNodeModel<M> | null {
+  public commonAncestor(another: DeploymentElementModel<A>): DeploymentNodeModel<A> | null {
     const common = commonAncestor(this.id, another.id)
     return common ? this.$model.node(common) : null
   }
@@ -102,14 +92,14 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
   /**
    * Get all sibling (i.e. same parent)
    */
-  public siblings(): DeploymentElementsIterator<M> {
+  public siblings(): DeploymentElementsIterator<A> {
     return this.$model.siblings(this)
   }
 
   /**
    * Check if the element is a sibling of another element
    */
-  public isSibling(other: DeploymentElementModel<M>): boolean {
+  public isSibling(other: DeploymentElementModel<A>): boolean {
     return this.parent === other.parent
   }
 
@@ -117,7 +107,7 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
    * Resolve siblings of the element and its ancestors
    *  (from closest to root)
    */
-  public *ascendingSiblings(): DeploymentElementsIterator<M> {
+  public *ascendingSiblings(): DeploymentElementsIterator<A> {
     yield* this.siblings()
     for (const ancestor of this.ancestors()) {
       yield* ancestor.siblings()
@@ -129,7 +119,7 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
    * Resolve siblings of the element and its ancestors
    *  (from root to closest)
    */
-  public *descendingSiblings(): DeploymentElementsIterator<M> {
+  public *descendingSiblings(): DeploymentElementsIterator<A> {
     for (const ancestor of [...this.ancestors()].reverse()) {
       yield* ancestor.siblings()
     }
@@ -137,15 +127,15 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  public incoming(filter: IncomingFilter = 'all'): IteratorLike<DeploymentRelationModel<M>> {
+  public incoming(filter: IncomingFilter = 'all'): IteratorLike<DeploymentRelationModel<A>> {
     return this.$model.incoming(this, filter)
   }
-  public outgoing(filter: OutgoingFilter = 'all'): IteratorLike<DeploymentRelationModel<M>> {
+  public outgoing(filter: OutgoingFilter = 'all'): IteratorLike<DeploymentRelationModel<A>> {
     return this.$model.outgoing(this, filter)
   }
 
-  public *incomers(filter: IncomingFilter = 'all'): IteratorLike<DeploymentRelationEndpoint<M>> {
-    const unique = new Set<M['Deployment']>()
+  public *incomers(filter: IncomingFilter = 'all'): IteratorLike<DeploymentRelationEndpoint<A>> {
+    const unique = new Set<aux.DeploymentFqn<A>>()
     for (const r of this.incoming(filter)) {
       if (unique.has(r.source.id)) {
         continue
@@ -155,8 +145,8 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
     }
     return
   }
-  public *outgoers(filter: OutgoingFilter = 'all'): IteratorLike<DeploymentRelationEndpoint<M>> {
-    const unique = new Set<M['Deployment']>()
+  public *outgoers(filter: OutgoingFilter = 'all'): IteratorLike<DeploymentRelationEndpoint<A>> {
+    const unique = new Set<aux.DeploymentFqn<A>>()
     for (const r of this.outgoing(filter)) {
       if (unique.has(r.target.id)) {
         continue
@@ -170,9 +160,9 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
   /**
    * Iterate over all views that include this deployment element.
    */
-  public *views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>> {
+  public *views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>> {
     for (const view of this.$model.views()) {
-      if (!view.isDeploymentView()) {
+      if (view._type !== 'deployment') {
         continue
       }
       if (view.includesDeployment(this.id)) {
@@ -182,76 +172,100 @@ abstract class AbstractDeploymentElementModel<M extends AnyAux = AnyAux> {
   }
 
   // type guard
-  public isDeploymentNode(): this is DeploymentNodeModel<M> {
+  public isDeploymentNode(): this is DeploymentNodeModel<A> {
     return false
   }
   // type guard
-  public isInstance(): this is DeployedInstanceModel<M> {
+  public isInstance(): this is DeployedInstanceModel<A> {
     return false
   }
 
-  public abstract outgoingModelRelationships(): RelationshipsIterator<M>
-  public abstract incomingModelRelationships(): RelationshipsIterator<M>
+  public abstract outgoingModelRelationships(): RelationshipsIterator<A>
+  public abstract incomingModelRelationships(): RelationshipsIterator<A>
 
-  protected cachedOutgoing: RelationshipsAccum<M> | null = null
-  protected cachedIncoming: RelationshipsAccum<M> | null = null
+  public get allOutgoing(): RelationshipsAccum<A> {
+    return memoizeProp(this, Symbol.for('allOutgoing'), () =>
+      RelationshipsAccum.from(
+        new Set(this.outgoingModelRelationships()),
+        new Set(this.outgoing()),
+      ))
+  }
 
-  public get allOutgoing(): RelationshipsAccum<M> {
-    this.cachedOutgoing ??= RelationshipsAccum.from(
-      new Set(this.outgoingModelRelationships()),
-      new Set(this.outgoing()),
-    )
-    return this.cachedOutgoing
+  public get allIncoming(): RelationshipsAccum<A> {
+    return memoizeProp(this, Symbol.for('allIncoming'), () =>
+      RelationshipsAccum.from(
+        new Set(this.incomingModelRelationships()),
+        new Set(this.incoming()),
+      ))
   }
 
-  public get allIncoming(): RelationshipsAccum<M> {
-    this.cachedIncoming ??= RelationshipsAccum.from(
-      new Set(this.incomingModelRelationships()),
-      new Set(this.incoming()),
-    )
-    return this.cachedIncoming
+  public getMetadata(): aux.Metadata<A>
+  public getMetadata(field: aux.MetadataKey<A>): string | undefined
+  public getMetadata(field?: aux.MetadataKey<A>) {
+    if (field) {
+      return this.$node.metadata?.[field]
+    }
+    return this.$node.metadata ?? {}
+  }
+
+  /**
+   * Checks if the deployment element has the given tag.
+   */
+  public isTagged(tag: aux.LooseTag<A>): boolean {
+    return this.tags.includes(tag as aux.Tag<A>)
   }
 }
 
-export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDeploymentElementModel<M> {
-  override id: M['DeploymentFqn']
+export class DeploymentNodeModel<A extends Any = Any> extends AbstractDeploymentElementModel<A> {
+  override id: aux.DeploymentFqn<A>
+  override _literalId: aux.DeploymentId<A>
   override title: string
   override hierarchyLevel: number
 
   constructor(
-    public readonly $model: LikeC4DeploymentModel<M>,
-    public readonly $node: DeploymentNode,
+    public readonly $model: LikeC4DeploymentModel<A>,
+    public readonly $node: DeploymentNode<A>,
   ) {
     super()
     this.id = $node.id
+    this._literalId = $node.id
     this.title = $node.title
     this.hierarchyLevel = hierarchyLevel($node.id)
   }
 
-  get parent(): DeploymentNodeModel<M> | null {
+  get parent(): DeploymentNodeModel<A> | null {
     return this.$model.parent(this)
   }
 
-  override get kind(): DeploymentNodeKind {
+  get kind(): aux.DeploymentKind<A> {
     return this.$node.kind
   }
 
-  public children(): ReadonlySet<DeploymentElementModel<M>> {
+  override get tags(): aux.Tags<A> {
+    return memoizeProp(this, Symbol.for('tags'), () => {
+      return unique([
+        ...(this.$node.tags ?? []),
+        ...(this.$model.$model.specification.deployments[this.kind]?.tags ?? []),
+      ] as aux.Tags<A>)
+    })
+  }
+
+  public children(): ReadonlySet<DeploymentElementModel<A>> {
     return this.$model.children(this)
   }
 
-  public descendants(sort: 'asc' | 'desc' = 'desc'): DeploymentElementsIterator<M> {
+  public descendants(sort: 'asc' | 'desc' = 'desc'): DeploymentElementsIterator<A> {
     return this.$model.descendants(this, sort)
   }
 
-  public override isDeploymentNode(): this is DeploymentNodeModel<M> {
+  public override isDeploymentNode(): this is DeploymentNodeModel<A> {
     return true
   }
 
   /**
    * Iterate over all instances nested in this deployment node.
    */
-  public *instances(): DeployedInstancesIterator<M> {
+  public *instances(): DeployedInstancesIterator<A> {
     for (const nested of this.descendants('desc')) {
       if (nested.isInstance()) {
         yield nested
@@ -264,7 +278,7 @@ export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDepl
    * Returns deployed instance inside this deployment node
    * if only there are no more instances
    */
-  public onlyOneInstance(): DeployedInstanceModel<M> | null {
+  public onlyOneInstance(): DeployedInstanceModel<A> | null {
     const children = this.children()
     if (children.size !== 1) {
       return null
@@ -277,8 +291,8 @@ export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDepl
    * Cached result of relationships from instances
    */
   private _relationshipsFromInstances: {
-    outgoing: ReadonlySet<RelationshipModel<M>>
-    incoming: ReadonlySet<RelationshipModel<M>>
+    outgoing: ReadonlySet<RelationshipModel<A>>
+    incoming: ReadonlySet<RelationshipModel<A>>
   } | null = null
 
   private relationshipsFromInstances() {
@@ -289,8 +303,8 @@ export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDepl
       outgoing,
       incoming,
     } = (this._relationshipsFromInstances = {
-      outgoing: new Set<RelationshipModel<M>>(),
-      incoming: new Set<RelationshipModel<M>>(),
+      outgoing: new Set<RelationshipModel<A>>(),
+      incoming: new Set<RelationshipModel<A>>(),
     })
     for (const instance of this.instances()) {
       for (const r of instance.element.outgoing()) {
@@ -306,21 +320,21 @@ export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDepl
   /**
    * We return only relationships that are not already present in nested instances
    */
-  public override outgoingModelRelationships(): RelationshipsIterator<M> {
+  public override outgoingModelRelationships(): RelationshipsIterator<A> {
     return this.relationshipsFromInstances().outgoing.values()
   }
 
   /**
    * We return only relationships that are not already present in nested instances
    */
-  public override incomingModelRelationships(): RelationshipsIterator<M> {
+  public override incomingModelRelationships(): RelationshipsIterator<A> {
     return this.relationshipsFromInstances().incoming.values()
   }
 
   /**
    * Returns an iterator of relationships between nested instances
    */
-  public internalModelRelationships(): ReadonlySet<RelationshipModel<M>> {
+  public internalModelRelationships(): ReadonlySet<RelationshipModel<A>> {
     const {
       outgoing,
       incoming,
@@ -329,27 +343,29 @@ export class DeploymentNodeModel<M extends AnyAux = AnyAux> extends AbstractDepl
   }
 }
 
-export class DeployedInstanceModel<M extends AnyAux = AnyAux> extends AbstractDeploymentElementModel<M> {
-  override readonly id: M['DeploymentFqn']
+export class DeployedInstanceModel<A extends Any = Any> extends AbstractDeploymentElementModel<A> {
+  override readonly id: aux.DeploymentFqn<A>
+  override readonly _literalId: aux.DeploymentId<A>
   override readonly title: string
   override readonly hierarchyLevel: number
 
   constructor(
-    public readonly $model: LikeC4DeploymentModel<M>,
-    public readonly $instance: DeployedInstance,
-    public readonly element: ElementModel<M>,
+    public readonly $model: LikeC4DeploymentModel<A>,
+    public readonly $instance: DeployedInstance<A>,
+    public readonly element: ElementModel<A>,
   ) {
     super()
     this.id = $instance.id
+    this._literalId = $instance.id
     this.title = $instance.title ?? element.title
     this.hierarchyLevel = hierarchyLevel($instance.id)
   }
 
-  get $node(): DeployedInstance {
+  get $node(): DeployedInstance<A> {
     return this.$instance
   }
 
-  get parent(): DeploymentNodeModel<M> {
+  get parent(): DeploymentNodeModel<A> {
     return nonNullable(this.$model.parent(this), `Parent of ${this.id} not found`)
   }
 
@@ -369,15 +385,20 @@ export class DeployedInstanceModel<M extends AnyAux = AnyAux> extends AbstractDe
     return this.$instance.style?.shape ?? this.element.shape
   }
 
-  override get color(): ThemeColor {
-    return this.$instance.style?.color as ThemeColor ?? this.element.color
+  override get color(): Color {
+    return this.$instance.style?.color as Color ?? this.element.color
   }
 
-  override get tags(): ReadonlyArray<C4Tag> {
-    return this.$instance.tags ?? []
+  override get tags(): aux.Tags<A> {
+    return memoizeProp(this, Symbol.for('tags'), () => {
+      return unique([
+        ...(this.$instance.tags ?? []),
+        ...this.element.tags,
+      ] as aux.Tags<A>)
+    })
   }
 
-  override get kind(): ElementKind {
+  get kind(): aux.ElementKind<A> {
     return this.element.kind
   }
 
@@ -393,14 +414,14 @@ export class DeployedInstanceModel<M extends AnyAux = AnyAux> extends AbstractDe
     return this.$instance.links ?? this.element.links
   }
 
-  public override isInstance(): this is DeployedInstanceModel<M> {
+  public override isInstance(): this is DeployedInstanceModel<A> {
     return true
   }
 
-  public override outgoingModelRelationships(): RelationshipsIterator<M> {
+  public override outgoingModelRelationships(): RelationshipsIterator<A> {
     return this.element.outgoing()
   }
-  public override incomingModelRelationships(): RelationshipsIterator<M> {
+  public override incomingModelRelationships(): RelationshipsIterator<A> {
     return this.element.incoming()
   }
 
@@ -408,9 +429,9 @@ export class DeployedInstanceModel<M extends AnyAux = AnyAux> extends AbstractDe
    * Iterate over all views that include this instance.
    * (Some views may include the parent deployment node instead of the instance.)
    */
-  public override *views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>> {
+  public override *views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>> {
     for (const view of this.$model.views()) {
-      if (!view.isDeploymentView()) {
+      if (view._type !== 'deployment') {
         continue
       }
       if (view.includesDeployment(this.id)) {
@@ -428,14 +449,18 @@ export class DeployedInstanceModel<M extends AnyAux = AnyAux> extends AbstractDe
   }
 }
 
-export class NestedElementOfDeployedInstanceModel<M extends AnyAux> {
+export class NestedElementOfDeployedInstanceModel<A extends Any = Any> {
   constructor(
-    public readonly instance: DeployedInstanceModel<M>,
-    public readonly element: ElementModel<M>,
+    public readonly instance: DeployedInstanceModel<A>,
+    public readonly element: ElementModel<A>,
   ) {
   }
 
-  get id(): M['DeploymentFqn'] {
+  get id(): aux.DeploymentFqn<A> {
+    return this.instance.id
+  }
+
+  get _literalId(): aux.DeploymentId<A> {
     return this.instance.id
   }
 
@@ -453,7 +478,7 @@ export class NestedElementOfDeployedInstanceModel<M extends AnyAux> {
     return this.element.shape
   }
 
-  get color(): ThemeColor {
+  get color(): Color {
     return this.element.color
   }
 
@@ -469,33 +494,33 @@ export class NestedElementOfDeployedInstanceModel<M extends AnyAux> {
     return this.element.technology
   }
 
-  public isDeploymentNode(): this is DeploymentNodeModel<M> {
+  public isDeploymentNode(): this is DeploymentNodeModel<A> {
     return false
   }
-  public isInstance(): this is DeployedInstanceModel<M> {
+  public isInstance(): this is DeployedInstanceModel<A> {
     return false
   }
 }
 
-export type DeploymentRelationEndpoint<M extends AnyAux> =
-  | DeploymentElementModel<M>
-  | NestedElementOfDeployedInstanceModel<M>
+export type DeploymentRelationEndpoint<A extends Any = Any> =
+  | DeploymentElementModel<A>
+  | NestedElementOfDeployedInstanceModel<A>
 
-export class DeploymentRelationModel<M extends AnyAux = AnyAux> {
-  public boundary: DeploymentNodeModel<M> | null
-  public source: DeploymentRelationEndpoint<M>
-  public target: DeploymentRelationEndpoint<M>
+export class DeploymentRelationModel<A extends Any = Any> implements AnyRelationshipModel<A> {
+  public boundary: DeploymentNodeModel<A> | null
+  public source: DeploymentRelationEndpoint<A>
+  public target: DeploymentRelationEndpoint<A>
 
   constructor(
-    public readonly $model: LikeC4DeploymentModel<M>,
-    public readonly $relationship: DeploymentRelation,
+    public readonly $model: LikeC4DeploymentModel<A>,
+    public readonly $relationship: DeploymentRelationship<A>,
   ) {
     this.source = $model.deploymentRef($relationship.source)
     this.target = $model.deploymentRef($relationship.target)
     const parent = commonAncestor(this.source.id, this.target.id)
     this.boundary = parent ? this.$model.node(parent) : null
   }
-  get id(): M['RelationId'] {
+  get id(): scalar.RelationId {
     return this.$relationship.id
   }
 
@@ -504,35 +529,35 @@ export class DeploymentRelationModel<M extends AnyAux = AnyAux> {
   }
 
   get title(): string | null {
-    if (isEmpty(this.$relationship.title)) {
+    if (!isTruthy(this.$relationship.title)) {
       return null
     }
     return this.$relationship.title
   }
 
   get technology(): string | null {
-    if (isEmpty(this.$relationship.technology)) {
+    if (!isTruthy(this.$relationship.technology)) {
       return null
     }
     return this.$relationship.technology
   }
 
   get description(): string | null {
-    if (isEmpty(this.$relationship.description)) {
+    if (!isTruthy(this.$relationship.description)) {
       return null
     }
     return this.$relationship.description
   }
 
-  get tags(): ReadonlyArray<Tag> {
+  get tags(): aux.Tags<A> {
     return this.$relationship.tags ?? []
   }
 
-  get kind(): RelationshipKind | null {
+  get kind(): aux.RelationKind<A> | null {
     return this.$relationship.kind ?? null
   }
 
-  get navigateTo(): LikeC4ViewModel<M> | null {
+  get navigateTo(): LikeC4ViewModel<A> | null {
     return this.$relationship.navigateTo ? this.$model.$model.view(this.$relationship.navigateTo) : null
   }
 
@@ -541,14 +566,14 @@ export class DeploymentRelationModel<M extends AnyAux = AnyAux> {
   }
 
   get color(): Color {
-    return this.$relationship.color ?? DefaultRelationshipColor
+    return this.$relationship.color ?? DefaultThemeColor
   }
 
   get line(): RelationshipLineType {
     return this.$relationship.line ?? DefaultLineStyle
   }
 
-  public *views(): IteratorLike<LikeC4ViewModel<M, ComputedDeploymentView>> {
+  public *views(): IteratorLike<LikeC4ViewModel.DeploymentView<A>> {
     for (const view of this.$model.views()) {
       if (view.includesRelation(this.id)) {
         yield view
@@ -557,19 +582,39 @@ export class DeploymentRelationModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  public isDeploymentRelation(): this is DeploymentRelationModel<M> {
+  public isDeploymentRelation(): this is DeploymentRelationModel<A> {
     return true
   }
+
+  public isModelRelation(): this is RelationshipModel<A> {
+    return false
+  }
+
+  public getMetadata(): aux.Metadata<A>
+  public getMetadata(field: aux.MetadataKey<A>): string | undefined
+  public getMetadata(field?: aux.MetadataKey<A>) {
+    if (field) {
+      return this.$relationship.metadata?.[field]
+    }
+    return this.$relationship.metadata ?? {}
+  }
+
+  /**
+   * Checks if the relationship has the given tag.
+   */
+  public isTagged(tag: aux.LooseTag<A>): boolean {
+    return this.tags.includes(tag as aux.Tag<A>)
+  }
 }
 
-export class RelationshipsAccum<M extends AnyAux> {
-  static empty<M extends AnyAux>(): RelationshipsAccum<M> {
+export class RelationshipsAccum<A extends Any = Any> {
+  static empty<A extends Any>(): RelationshipsAccum<A> {
     return new RelationshipsAccum()
   }
-  static from<M extends AnyAux>(
-    model: Iterable<RelationshipModel<M>> | undefined,
-    deployment?: Iterable<DeploymentRelationModel<M>>,
-  ): RelationshipsAccum<M> {
+  static from<A extends Any>(
+    model: Iterable<RelationshipModel<A>> | undefined,
+    deployment?: Iterable<DeploymentRelationModel<A>>,
+  ): RelationshipsAccum<A> {
     return new RelationshipsAccum(
       new Set(model),
       new Set(deployment),
@@ -580,8 +625,8 @@ export class RelationshipsAccum<M extends AnyAux> {
    * @param deployment relationships from deployment model
    */
   constructor(
-    public readonly model: ReadonlySet<RelationshipModel<M>> = new Set(),
-    public readonly deployment: ReadonlySet<DeploymentRelationModel<M>> = new Set(),
+    public readonly model: ReadonlySet<RelationshipModel<A>> = new Set(),
+    public readonly deployment: ReadonlySet<DeploymentRelationModel<A>> = new Set(),
   ) {
   }
 
@@ -600,7 +645,7 @@ export class RelationshipsAccum<M extends AnyAux> {
   /**
    * Returns new Accum containing all the elements which are both in this and otherAccum
    */
-  public intersect(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M> {
+  public intersect(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A> {
     return RelationshipsAccum.from(
       intersection(this.model, otherAccum.model),
       intersection(this.deployment, otherAccum.deployment),
@@ -610,7 +655,7 @@ export class RelationshipsAccum<M extends AnyAux> {
   /**
    * Returns new Accum containing all the elements which are both in this and otherAccum
    */
-  public difference(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M> {
+  public difference(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A> {
     return RelationshipsAccum.from(
       difference(this.model, otherAccum.model),
       difference(this.deployment, otherAccum.deployment),
@@ -620,7 +665,7 @@ export class RelationshipsAccum<M extends AnyAux> {
   /**
    * Returns new Accum containing all the elements from both
    */
-  public union(otherAccum: RelationshipsAccum<M>): RelationshipsAccum<M> {
+  public union(otherAccum: RelationshipsAccum<A>): RelationshipsAccum<A> {
     return RelationshipsAccum.from(
       union(this.model, otherAccum.model),
       union(this.deployment, otherAccum.deployment),