@likec4/core 1.31.0 → 1.32.0

package/src/model/RelationModel.ts

@@ -1,44 +1,67 @@
-import { isEmpty } from 'remeda'
-import type { IteratorLike } from '../types/_common'
-import type { Link } from '../types/element'
+import { isTruthy } from 'remeda'
+import type { AnyAux, Color, IteratorLike, Link, scalar } from '../types'
 import {
-  type ModelRelation,
+  type Relationship,
   type RelationshipLineType,
   DefaultLineStyle,
   DefaultRelationshipColor,
-} from '../types/relation'
-import type { Tag } from '../types/scalars'
-import type { Color } from '../types/theme'
+  FqnRef,
+} from '../types'
+import type * as aux from '../types/aux'
 import { commonAncestor } from '../utils/fqn'
 import type { DeploymentRelationModel } from './DeploymentElementModel'
 import type { ElementModel } from './ElementModel'
+import type { isDeploymentRelationModel } from './guards'
 import type { LikeC4Model } from './LikeC4Model'
-import type { AnyAux } from './types'
 import type { LikeC4ViewModel, ViewsIterator } from './view/LikeC4ViewModel'
 
-export type RelationshipsIterator<M extends AnyAux> = IteratorLike<RelationshipModel<M>>
+export type RelationshipsIterator<A extends AnyAux> = IteratorLike<RelationshipModel<A>>
+
+/**
+ * A relationship between two elements (in logical or deployment model)
+ * use {@link isDeploymentRelationModel} guard to check if the relationship is a deployment relationship
+ */
+export interface AnyRelationshipModel<A extends AnyAux> {
+  get id(): scalar.RelationId
+  get expression(): string
+  get title(): string | null
+  get technology(): string | null
+  get description(): string | null
+  get navigateTo(): LikeC4ViewModel<A> | null
+  get tags(): aux.Tags<A>
+  get kind(): aux.RelationKind<A> | null
+  get links(): ReadonlyArray<Link>
+  get color(): Color
+  get line(): RelationshipLineType
+  isDeploymentRelation(): this is DeploymentRelationModel<A>
+  isModelRelation(): this is RelationshipModel<A>
+  getMetadata(): aux.Metadata<A>
+  getMetadata(field: aux.MetadataKey<A>): string | undefined
+  views(): ViewsIterator<A>
+  isTagged(tag: aux.LooseTag<A>): boolean
+}
 
-export class RelationshipModel<M extends AnyAux = AnyAux> {
-  public readonly source: ElementModel<M>
-  public readonly target: ElementModel<M>
+export class RelationshipModel<A extends AnyAux = AnyAux> implements AnyRelationshipModel<A> {
+  public readonly source: ElementModel<A>
+  public readonly target: ElementModel<A>
 
   /**
    * Common ancestor of the source and target elements.
    * Represents the boundary of the Relation.
    */
-  public readonly boundary: ElementModel<M> | null
+  public readonly boundary: ElementModel<A> | null
 
   constructor(
-    public readonly model: LikeC4Model<M>,
-    public readonly $relationship: ModelRelation,
+    public readonly model: LikeC4Model<A>,
+    public readonly $relationship: Relationship<A>,
   ) {
-    this.source = model.element($relationship.source)
-    this.target = model.element($relationship.target)
+    this.source = model.element(FqnRef.flatten($relationship.source))
+    this.target = model.element(FqnRef.flatten($relationship.target))
     const parent = commonAncestor(this.source.id, this.target.id)
     this.boundary = parent ? this.model.element(parent) : null
   }
 
-  get id(): M['RelationId'] {
+  get id(): scalar.RelationId {
     return this.$relationship.id
   }
 
@@ -47,35 +70,35 @@ export class RelationshipModel<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 navigateTo(): LikeC4ViewModel<M> | null {
+  get navigateTo(): LikeC4ViewModel<A> | null {
     return this.$relationship.navigateTo ? this.model.view(this.$relationship.navigateTo) : null
   }
 
-  get tags(): ReadonlyArray<Tag> {
+  get tags(): aux.Tags<A> {
     return this.$relationship.tags ?? []
   }
 
-  get kind(): string | null {
+  get kind(): aux.RelationKind<A> | null {
     return this.$relationship.kind ?? null
   }
 
@@ -94,7 +117,7 @@ export class RelationshipModel<M extends AnyAux = AnyAux> {
   /**
    * Iterate over all views that include this relationship.
    */
-  public *views(): ViewsIterator<M> {
+  public *views(): ViewsIterator<A> {
     for (const view of this.model.views()) {
       if (view.includesRelation(this.id)) {
         yield view
@@ -103,16 +126,27 @@ export class RelationshipModel<M extends AnyAux = AnyAux> {
     return
   }
 
-  public isDeploymentRelation(): this is DeploymentRelationModel<M> {
+  public isDeploymentRelation(): this is DeploymentRelationModel<A> {
     return false
   }
 
-  public getMetadata(): Record<string, string>
-  public getMetadata(field: string): string | undefined
-  public getMetadata(field?: string) {
+  public isModelRelation(): this is RelationshipModel<A> {
+    return true
+  }
+
+  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>)
+  }
 }

package/src/model/__test__/fixture.ts

@@ -1,5 +1,5 @@
 import { Builder } from '../../builder/Builder'
-import { computeViews } from '../../compute-view/compute-view'
+import { computeParsedModelData } from '../../compute-view/compute-view'
 import { LikeC4Model } from '../LikeC4Model'
 
 const {
@@ -26,33 +26,40 @@ const {
     viewOf,
     deploymentView,
     $rules,
-    $include
-  }
+    $include,
+  },
 } = Builder.forSpecification({
   elements: {
     person: {
       style: {
-        shape: 'person'
-      }
+        shape: 'person',
+      },
     },
     system: {},
     component: {},
     webapp: {
+      tags: ['internal'],
       style: {
-        shape: 'browser'
-      }
+        shape: 'browser',
+      },
     },
     mobile: {
       style: {
-        shape: 'mobile'
-      }
-    }
+        shape: 'mobile',
+      },
+    },
+  },
+  tags: {
+    internal: {},
+    external: {},
+    tag1: {},
+    tag2: {},
   },
   deployments: {
     env: {},
     zone: {},
-    node: {}
-  }
+    node: {},
+  },
 })
 
 const local = b
@@ -61,27 +68,34 @@ const local = b
       person('customer'),
       system('cloud').with(
         component('frontend').with(
-          webapp('dashboard'),
-          mobile('mobile')
+          webapp('dashboard', {
+            tags: ['tag1'],
+          }),
+          mobile('mobile'),
         ),
         component('auth'),
         component('backend').with(
           component('api'),
-          component('graphql')
+          component('graphql'),
         ),
         component('media', {
-          shape: 'storage'
-        })
+          tags: ['tag2'],
+          shape: 'storage',
+        }),
       ),
       system('aws').with(
         component('rds', {
-          shape: 'storage'
+          tags: ['tag2'],
+          shape: 'storage',
         }),
         component('s3', {
-          shape: 'storage'
-        })
+          tags: ['tag2'],
+          shape: 'storage',
+        }),
       ),
-      system('email')
+      system('email', {
+        tags: ['external'],
+      }),
     ),
     $m.model(
       $m.rel('customer', 'cloud', 'uses services'),
@@ -93,7 +107,7 @@ const local = b
       $m.rel('cloud.frontend.mobile', 'cloud.auth', 'authenticates'),
       $m.rel('cloud.frontend.mobile', 'cloud.backend.api', 'fetches data'),
       $m.rel('cloud.frontend.mobile', 'cloud.media', 'fetches media'),
-      $m.rel('cloud.frontend', 'cloud.backend')
+      $m.rel('cloud.frontend', 'cloud.backend'),
     ),
     $m.model(
       $m.rel('cloud.backend.api', 'cloud.auth', 'authorizes'),
@@ -102,30 +116,30 @@ const local = b
       $m.rel('cloud.backend.api', 'email', 'sends emails'),
       $m.rel('cloud', 'email', 'uses'),
       $m.rel('cloud.media', 'aws.s3', 'uploads'),
-      $m.rel('email', 'customer', 'sends emails')
+      $m.rel('email', 'customer', 'sends emails'),
     ),
     deployment(
       node('customer').with(
-        instanceOf('instance', 'customer')
+        instanceOf('instance', 'customer'),
       ),
       env('prod').with(
         zone('eu').with(
           zone('zone1').with(
             instanceOf('ui', 'cloud.frontend.dashboard'),
-            instanceOf('api', 'cloud.backend.api')
+            instanceOf('api', 'cloud.backend.api'),
           ),
           zone('zone2').with(
             instanceOf('ui', 'cloud.frontend.dashboard'),
-            instanceOf('api', 'cloud.backend.api')
+            instanceOf('api', 'cloud.backend.api'),
           ),
           instanceOf('media', 'cloud.media'),
-          instanceOf('db', 'aws.rds')
+          instanceOf('db', 'aws.rds'),
         ),
         zone('us').with(
-          instanceOf('db', 'aws.rds')
-        )
+          instanceOf('db', 'aws.rds'),
+        ),
       ),
-      $d.rel('prod.eu.db', 'prod.us.db', 'replicates')
+      $d.rel('prod.eu.db', 'prod.us.db', 'replicates'),
     ),
     views(
       view('index', $include('*')),
@@ -134,14 +148,14 @@ const local = b
         'cloud',
         $rules(
           $include('*'),
-          $include('cloud.frontend.dashboard')
-        )
+          $include('cloud.frontend.dashboard'),
+        ),
       ),
       deploymentView('prod').with(
         $include('customer.instance'),
-        $include('prod.eu.zone1.ui')
-      )
-    )
+        $include('prod.eu.zone1.ui'),
+      ),
+    ),
   )
 
 export const builder = local.clone()
@@ -149,6 +163,6 @@ export const builder = local.clone()
 export const parsed = local.build()
 export type TestFqn = typeof local.Types.Fqn
 
-export const computed = computeViews(parsed)
+export const computed = computeParsedModelData(parsed)
 
 export const model = LikeC4Model.create(computed)

package/src/model/connection/Connection.ts

@@ -1,9 +1,9 @@
-import type { Fqn } from '../../types'
+import type { AnyAux, Fqn } from '../../types'
 import { isAncestor } from '../../utils'
 import type { DeploymentElementModel } from '../DeploymentElementModel'
 import type { ElementModel } from '../ElementModel'
 
-export interface Connection<Elem = ElementModel | DeploymentElementModel, Id = string> {
+export interface Connection<Elem = ElementModel<AnyAux> | DeploymentElementModel<AnyAux>, Id = string> {
   readonly id: Id
   readonly source: Elem
   readonly target: Elem

package/src/model/connection/deployment/DeploymentConnectionModel.ts

@@ -1,36 +1,33 @@
-import { invariant } from '../../../errors'
-import type { IteratorLike } from '../../../types'
-import { stringHash } from '../../../utils'
+import type { AnyAux, aux, IteratorLike } from '../../../types'
+import { invariant, stringHash } from '../../../utils'
 import { customInspectSymbol } from '../../../utils/const'
 import { equals } from '../../../utils/set'
 import {
-  type DeployedInstanceModel,
   type DeploymentElementModel,
   type DeploymentRelationModel,
   DeploymentNodeModel,
   RelationshipsAccum,
 } from '../../DeploymentElementModel'
 import type { RelationshipModel } from '../../RelationModel'
-import type { AnyAux } from '../../types'
 import type { Connection } from '../Connection'
 
 /**
  * Connection is ephemeral entity, result of a resolving relationships between source and target.
  * Includes direct relationships and/or between their nested elements.
  */
-export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
-  implements Connection<DeploymentElementModel<M>, M['EdgeId']>
+export class DeploymentConnectionModel<A extends AnyAux = AnyAux>
+  implements Connection<DeploymentElementModel<A>, aux.EdgeId>
 {
+  readonly id: aux.EdgeId
+
   constructor(
-    public readonly source: DeploymentNodeModel<M> | DeployedInstanceModel<M>,
-    public readonly target: DeploymentNodeModel<M> | DeployedInstanceModel<M>,
-    public readonly relations: RelationshipsAccum<M>,
+    public readonly source: DeploymentElementModel<A>,
+    public readonly target: DeploymentElementModel<A>,
+    public readonly relations: RelationshipsAccum<A>,
   ) {
-    this.id = stringHash(`deployment:${source.id}:${target.id}`) as M['EdgeId']
+    this.id = stringHash(`deployment:${source.id}:${target.id}`) as aux.EdgeId
   }
 
-  readonly id: M['EdgeId']
-
   /**
    * Human readable expression of the connection
    * Mostly used for testing and debugging
@@ -39,12 +36,12 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
     return `${this.source.id} -> ${this.target.id}`
   }
 
-  private _boundary: DeploymentNodeModel<M> | null | undefined
+  private _boundary: DeploymentNodeModel<A> | null | undefined
   /**
    * Common ancestor of the source and target elements.
    * Represents the boundary of the connection.
    */
-  get boundary(): DeploymentNodeModel<M> | null {
+  get boundary(): DeploymentNodeModel<A> | null {
     this._boundary ??= this.source.commonAncestor(this.target)
     return this._boundary
   }
@@ -105,7 +102,7 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
     return false
   }
 
-  public *values(): IteratorLike<RelationshipModel<M> | DeploymentRelationModel<M>> {
+  public *values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>> {
     yield* this.relations.model
     yield* this.relations.deployment
   }
@@ -114,13 +111,13 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
    * Merge with another connections, if it has the same source and target.
    * Returns new connection with union of relationships.
    */
-  public mergeWith(others: DeploymentConnectionModel<M>[]): DeploymentConnectionModel<M>
+  public mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>
   /**
    * Merge with another connection, if it has the same source and target.
    * Returns new connection with union of relationships.
    */
-  public mergeWith(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M>
-  public mergeWith(other: DeploymentConnectionModel<M> | DeploymentConnectionModel<M>[]): DeploymentConnectionModel<M> {
+  public mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>
+  public mergeWith(other: DeploymentConnectionModel<A> | DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A> {
     if (Array.isArray(other)) {
       return other.reduce((acc, o) => acc.mergeWith(o), this)
     }
@@ -134,7 +131,7 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
     )
   }
 
-  public difference(other: DeploymentConnectionModel<M>) {
+  public difference(other: DeploymentConnectionModel<A>) {
     return new DeploymentConnectionModel(
       this.source,
       this.target,
@@ -142,7 +139,7 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
     )
   }
 
-  public intersect(other: DeploymentConnectionModel<M>) {
+  public intersect(other: DeploymentConnectionModel<A>) {
     return new DeploymentConnectionModel(
       this.source,
       this.target,
@@ -164,9 +161,9 @@ export class DeploymentConnectionModel<M extends AnyAux = AnyAux>
    * if `null` is provided in overrides, the corresponding relation set will be empty.
    */
   public update(overrides?: {
-    model?: ReadonlySet<RelationshipModel<M>> | null
-    deployment?: ReadonlySet<DeploymentRelationModel<M>> | null
-  }): DeploymentConnectionModel<M> {
+    model?: ReadonlySet<RelationshipModel<A>> | null
+    deployment?: ReadonlySet<DeploymentRelationModel<A>> | null
+  }): DeploymentConnectionModel<A> {
     if (overrides) {
       overrides = {
         model: this.relations.model,

package/src/model/connection/deployment/find.ts

@@ -1,6 +1,6 @@
+import type { AnyAux } from '../../../types'
 import { isSameHierarchy } from '../../../utils'
 import type { DeploymentElementModel } from '../../DeploymentElementModel'
-import type { AnyAux } from '../../types'
 import { DeploymentConnectionModel } from './DeploymentConnectionModel'
 
 /**

package/src/model/connection/model/ConnectionModel.ts

@@ -1,12 +1,12 @@
 import { isNot } from 'remeda'
-import { invariant } from '../../../errors'
+import type { AnyAux, aux, Unknown } from '../../../types'
+import { invariant } from '../../../utils'
 import { customInspectSymbol } from '../../../utils/const'
 import { ifilter, isome } from '../../../utils/iterable'
 import { difference, equals, intersection, union } from '../../../utils/set'
 import { stringHash } from '../../../utils/string-hash'
 import type { ElementModel } from '../../ElementModel'
 import type { RelationshipModel } from '../../RelationModel'
-import type { AnyAux } from '../../types'
 import type { Connection } from '../Connection'
 import { hasSameSourceTarget } from '../ops'
 import { findConnection } from './find'
@@ -17,23 +17,23 @@ import { findConnection } from './find'
  *
  * Merges relationships together to an single edge on the diagram.
  */
-export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<ElementModel<M>, M['EdgeId']> {
-  public readonly id: M['EdgeId']
+export class ConnectionModel<A extends AnyAux = Unknown> implements Connection<ElementModel<A>, aux.EdgeId> {
+  public readonly id: aux.EdgeId
 
   constructor(
-    public readonly source: ElementModel<M>,
-    public readonly target: ElementModel<M>,
-    public readonly relations: ReadonlySet<RelationshipModel<M>> = new Set(),
+    public readonly source: ElementModel<A>,
+    public readonly target: ElementModel<A>,
+    public readonly relations: ReadonlySet<RelationshipModel<A>> = new Set(),
   ) {
-    this.id = stringHash(`model:${source.id}:${target.id}`) as M['EdgeId']
+    this.id = stringHash(`model:${source.id}:${target.id}`) as aux.EdgeId
   }
 
-  private _boundary: ElementModel<M> | null | undefined
+  private _boundary: ElementModel<A> | null | undefined
   /**
    * Common ancestor of the source and target elements.
    * Represents the boundary of the connection.
    */
-  get boundary(): ElementModel<M> | null {
+  get boundary(): ElementModel<A> | null {
     return this._boundary ??= this.source.commonAncestor(this.target)
   }
 
@@ -59,7 +59,7 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
     return this.nonEmpty() && isome(this.relations, isNot(hasSameSourceTarget(this)))
   }
 
-  get directRelations(): ReadonlySet<RelationshipModel<M>> {
+  get directRelations(): ReadonlySet<RelationshipModel<A>> {
     return new Set(ifilter(this.relations, hasSameSourceTarget(this)))
   }
 
@@ -67,7 +67,7 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
     return this.relations.size > 0
   }
 
-  mergeWith(other: ConnectionModel<M>) {
+  mergeWith(other: ConnectionModel<A>) {
     invariant(this.source.id === other.source.id, 'Cannot merge connections with different sources')
     invariant(this.target.id === other.target.id, 'Cannot merge connections with different targets')
     return new ConnectionModel(
@@ -77,7 +77,7 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
     )
   }
 
-  difference(other: ConnectionModel<M>) {
+  difference(other: ConnectionModel<A>) {
     return new ConnectionModel(
       this.source,
       this.target,
@@ -85,7 +85,7 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
     )
   }
 
-  intersect(other: ConnectionModel<M>) {
+  intersect(other: ConnectionModel<A>) {
     invariant(other instanceof ConnectionModel, 'Cannot intersect connection with different type')
     return new ConnectionModel(
       this.source,
@@ -96,10 +96,11 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
 
   equals(other: Connection): boolean {
     invariant(other instanceof ConnectionModel, 'Cannot merge connection with different type')
-    return this.id === other.id
-      && this.source.id === other.source.id
-      && this.target.id === other.target.id
-      && equals(this.relations, other.relations)
+    const _other = other as ConnectionModel<A>
+    return this.id === _other.id
+      && this.source.id === _other.source.id
+      && this.target.id === _other.target.id
+      && equals(this.relations, _other.relations)
   }
 
   /**
@@ -108,7 +109,7 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
    * @param relations - A readonly set of `RelationshipModel` instances representing the new relations.
    * @returns A new `ConnectionModel` instance with the updated relations.
    */
-  update(relations: ReadonlySet<RelationshipModel<M>>): ConnectionModel<M> {
+  update(relations: ReadonlySet<RelationshipModel<A>>): ConnectionModel<A> {
     return new ConnectionModel(
       this.source,
       this.target,
@@ -147,7 +148,7 @@ export class ConnectionModel<M extends AnyAux = AnyAux> implements Connection<El
    * Creates a new connection with reversed direction (target becomes source and vice versa)
    * @param search - When true, attempts to find an existing connection between the reversed nodes
    */
-  reversed(search = false): ConnectionModel<M> {
+  reversed(search = false): ConnectionModel<A> {
     if (!search) {
       return new ConnectionModel(this.target, this.source)
     }

package/src/model/connection/model/find.ts

@@ -1,7 +1,7 @@
+import type { AnyAux } from '../../../types'
 import { isSameHierarchy } from '../../../utils/fqn'
 import { intersection } from '../../../utils/set'
 import type { ElementModel } from '../../ElementModel'
-import type { AnyAux } from '../../types'
 import { ConnectionModel } from './ConnectionModel'
 
 /**
@@ -10,13 +10,13 @@ import { ConnectionModel } from './ConnectionModel'
  * @param direction - if 'both', also returns connection from target to source
  * @default `directed`
  */
-export function findConnection<M extends AnyAux>(
-  source: ElementModel<M>,
-  target: ElementModel<M>,
+export function findConnection<A extends AnyAux>(
+  source: ElementModel<A>,
+  target: ElementModel<A>,
   direction: 'directed' | 'both' = 'directed',
 ):
-  | [ConnectionModel<M>, ConnectionModel<M>]
-  | [ConnectionModel<M>]
+  | [ConnectionModel<A>, ConnectionModel<A>]
+  | [ConnectionModel<A>]
   | []
 {
   if (source === target) {
@@ -69,7 +69,7 @@ export function findConnection<M extends AnyAux>(
  */
 export function findConnectionsBetween<M extends AnyAux>(
   element: ElementModel<M>,
-  others: Iterable<ElementModel<NoInfer<M>>>,
+  others: Iterable<ElementModel<M>>,
   direction: 'directed' | 'both' = 'both',
 ): readonly ConnectionModel<M>[] {
   if (element.allIncoming.size === 0 && element.allOutgoing.size === 0) {

package/src/model/connection/ops.ts

@@ -136,14 +136,14 @@ export function findDescendantConnections<C extends ConnectionElemId>(
   return connections.filter(isNestedConnection(connection))
 }
 
-export function mergeConnections<C extends Connection>(
-  connections: ReadonlyArray<C>,
-): C[] {
-  const map = new Map<C['id'], C>()
+export function mergeConnections<C extends IterableContainer<Connection<any, any>>>(
+  connections: C,
+): Array<C[number]> {
+  const map = new Map<C[number]['id'], C[number]>()
   for (const conn of connections) {
     const existing = map.get(conn.id)
     if (existing) {
-      map.set(conn.id, conn.mergeWith(existing) as C)
+      map.set(conn.id, conn.mergeWith(existing))
     } else {
       map.set(conn.id, conn)
     }
@@ -155,7 +155,7 @@ export function mergeConnections<C extends Connection>(
  * Excludes the values existing in `other` array.
  * The output maintains the same order as the input.
  */
-export function differenceConnections<C extends Connection>(
+export function differenceConnections<C extends Connection<any, any>>(
   source: Iterable<C>,
   exclude: Iterable<C>,
 ): C[] {