@likec4/core 1.17.1 → 1.18.0

package/src/model/connection/DeploymentConnectionModel.ts

@@ -0,0 +1,99 @@
+import { invariant } from '../../errors'
+import { stringHash } from '../../utils'
+import { equals } from '../../utils/set'
+import {
+  type DeploymentElementModel,
+  DeploymentNodeModel,
+  type DeploymentRelationModel,
+  RelationshipsAccum
+} from '../DeploymentElementModel'
+import type { RelationshipModel } from '../RelationModel'
+import type { AnyAux, IteratorLike } from '../types'
+import type { Connection } from './ConnectionModel'
+
+/**
+ * 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']>
+{
+  /**
+   * Common ancestor of the source and target elements.
+   * Represents the boundary of the connection.
+   */
+  readonly boundary: DeploymentNodeModel<M> | null
+
+  constructor(
+    public readonly source: DeploymentElementModel<M>,
+    public readonly target: DeploymentElementModel<M>,
+    public readonly relations: RelationshipsAccum<M>
+  ) {
+    this.id = stringHash(`deployment:${source.id}:${target.id}`) as M['EdgeId']
+    this.boundary = source.commonAncestor(target)
+  }
+
+  readonly id: M['EdgeId']
+
+  /**
+   * Human readable expression of the connection
+   * Mostly used for testing and debugging
+   */
+  get expression(): string {
+    return `${this.source.id} -> ${this.target.id}`
+  }
+
+  nonEmpty(): boolean {
+    return this.relations.nonEmpty
+  }
+
+  /**
+   * Check if connection contains deployment relation,
+   * that is directly connected to source or target.
+   */
+  public hasDirectDeploymentRelation(): boolean {
+    for (const relation of this.relations.deployment) {
+      if (relation.source.id === this.source.id || relation.target.id === this.target.id) {
+        return true
+      }
+    }
+    return false
+  }
+
+  public *values(): IteratorLike<RelationshipModel<M> | DeploymentRelationModel<M>> {
+    yield* this.relations.model
+    yield* this.relations.deployment
+  }
+
+  /**
+   * 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> {
+    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 DeploymentConnectionModel(
+      this.source,
+      this.target,
+      this.relations.union(other.relations)
+    )
+  }
+
+  public difference(other: DeploymentConnectionModel<M>): DeploymentConnectionModel<M> {
+    invariant(this.source.id === other.source.id, 'Cannot difference connection with different sources')
+    invariant(this.target.id === other.target.id, 'Cannot difference connection with different targets')
+    return new DeploymentConnectionModel(
+      this.source,
+      this.target,
+      this.relations.difference(other.relations)
+    )
+  }
+
+  public equals(other: DeploymentConnectionModel<M>): boolean {
+    return this.id === other.id
+      && this.source.id === other.source.id
+      && this.target.id === other.target.id
+      && equals(this.relations.model, other.relations.model)
+      && equals(this.relations.deployment, other.relations.deployment)
+  }
+}

package/src/model/connection/deployment.ts

@@ -0,0 +1,124 @@
+import { isSameHierarchy } from '../../utils/fqn'
+import { type DeploymentElementModel } from '../DeploymentElementModel'
+import type { AnyAux } from '../types'
+import { DeploymentConnectionModel } from './DeploymentConnectionModel'
+
+export { mergeConnections } from './model'
+
+export { DeploymentConnectionModel }
+
+/**
+ * Resolve connection from source to target
+ * If direction is `both`, also look for reverse connection
+ *
+ * @default direction directed
+ */
+export function findConnection<M extends AnyAux>(
+  source: DeploymentElementModel<M>,
+  target: DeploymentElementModel<NoInfer<M>>,
+  direction: 'directed'
+):
+  | readonly [DeploymentConnectionModel<M>]
+  | readonly []
+export function findConnection<M extends AnyAux>(
+  source: DeploymentElementModel<M>,
+  target: DeploymentElementModel<NoInfer<M>>,
+  direction: 'both'
+):
+  | readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>]
+  | readonly [DeploymentConnectionModel<M>]
+  | readonly []
+export function findConnection<M extends AnyAux>(
+  source: DeploymentElementModel<M>,
+  target: DeploymentElementModel<NoInfer<M>>,
+  direction?: 'directed' | 'both'
+):
+  | readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>]
+  | readonly [DeploymentConnectionModel<M>]
+  | readonly []
+export function findConnection<M extends AnyAux>(
+  source: DeploymentElementModel<M>,
+  target: DeploymentElementModel<NoInfer<M>>,
+  direction: 'directed' | 'both' = 'directed'
+) {
+  if (source === target) {
+    return []
+  }
+  if (isSameHierarchy(source, target)) {
+    return []
+  }
+  const directedIntersection = source.allOutgoing.intersect(target.allIncoming)
+
+  const directed = directedIntersection.nonEmpty
+    ? [
+      new DeploymentConnectionModel<M>(
+        source,
+        target,
+        directedIntersection
+      )
+    ] as const
+    : [] as const
+
+  if (direction === 'directed') {
+    return directed
+  }
+  return [
+    ...directed,
+    ...findConnection(target, source, 'directed')
+  ] as const
+}
+
+/**
+ * Resolve all connections between element and others
+ * By default, look for both directions.
+ *
+ * @default direction both
+ */
+export function findConnectionsBetween<M extends AnyAux>(
+  element: DeploymentElementModel<M>,
+  others: Iterable<DeploymentElementModel<NoInfer<M>>>,
+  direction: 'directed' | 'both' = 'both'
+): readonly DeploymentConnectionModel<M>[] {
+  if (element.allIncoming.isEmpty && element.allOutgoing.isEmpty) {
+    return []
+  }
+
+  // We separate resolved connection,
+  // because we want return outgoing first
+  const outgoing = [] as DeploymentConnectionModel<M>[]
+  const incoming = [] as DeploymentConnectionModel<M>[]
+  for (const _other of others) {
+    if (element === _other) {
+      continue
+    }
+    for (const found of findConnection(element, _other, direction)) {
+      if (found.source === element) {
+        outgoing.push(found)
+      } else {
+        incoming.push(found)
+      }
+    }
+  }
+  return [
+    ...outgoing,
+    ...incoming
+  ]
+}
+
+/**
+ * Resolve all connections within a given set of elements
+ */
+export function findConnectionsWithin<M extends AnyAux>(
+  elements: Iterable<DeploymentElementModel<M>>
+): readonly DeploymentConnectionModel<M>[] {
+  return [...elements].reduce((acc, el, index, array) => {
+    // skip for last element
+    if (index === array.length - 1) {
+      return acc
+    }
+    acc.push(
+      ...findConnectionsBetween(el, array.slice(index + 1), 'both')
+    )
+    return acc
+  }, [] as DeploymentConnectionModel<M>[])
+}

package/src/model/connection/model.ts

@@ -0,0 +1,123 @@
+import { isSameHierarchy } from '../../utils/fqn'
+import { intersection } from '../../utils/set'
+import type { ElementModel } from '../ElementModel'
+import type { AnyAux } from '../types'
+import { type Connection, ConnectionModel } from './ConnectionModel'
+
+export function mergeConnections<C extends Connection<any, any>>(
+  connections: readonly C[]
+): C[] {
+  const map = new Map<C['id'], C>()
+  for (const conn of connections) {
+    const existing = map.get(conn.id)
+    if (existing) {
+      map.set(conn.id, existing.mergeWith(conn) as any)
+    } else {
+      map.set(conn.id, conn)
+    }
+  }
+  return [...map.values()]
+}
+
+/**
+ * Resolve connection from source to target
+ * If direction is `both`, also look for reverse connection
+ */
+export function findConnection<M extends AnyAux>(
+  source: ElementModel<M>,
+  target: ElementModel<NoInfer<M>>,
+  direction: 'directed' | 'both' = 'directed'
+):
+  | readonly [ConnectionModel<M>, ConnectionModel<M>]
+  | readonly [ConnectionModel<M>]
+  | readonly []
+{
+  if (source === target) {
+    return []
+  }
+  if (isSameHierarchy(source, target)) {
+    return []
+  }
+
+  const directedIntersection = intersection(source.allOutgoing, target.allIncoming)
+
+  const directed = directedIntersection.size > 0
+    ? [
+      new ConnectionModel(
+        source,
+        target,
+        directedIntersection
+      )
+    ] as const
+    : [] as const
+
+  if (direction === 'directed') {
+    return directed
+  }
+
+  const reverseIntersection = intersection(source.allIncoming, target.allOutgoing)
+  const reverse = reverseIntersection.size > 0
+    ? [
+      new ConnectionModel(
+        target,
+        source,
+        reverseIntersection
+      )
+    ] as const
+    : [] as const
+
+  return [...directed, ...reverse] as const
+}
+
+/**
+ * Resolve all connections between element and others
+ * By default, look for both directions.
+ */
+export function findConnectionsBetween<M extends AnyAux>(
+  element: ElementModel<M>,
+  others: Iterable<ElementModel<NoInfer<M>>>,
+  direction: 'directed' | 'both' = 'both'
+): readonly ConnectionModel<M>[] {
+  if (element.allIncoming.size === 0 && element.allOutgoing.size === 0) {
+    return []
+  }
+
+  // We separate resolved connection,
+  // because we want return outgoing first
+  const outgoing = [] as ConnectionModel<M>[]
+  const incoming = [] as ConnectionModel<M>[]
+  for (const _other of others) {
+    if (element === _other) {
+      continue
+    }
+    for (const found of findConnection(element, _other, direction)) {
+      if (found.source === element) {
+        outgoing.push(found)
+      } else {
+        incoming.push(found)
+      }
+    }
+  }
+  return [
+    ...outgoing,
+    ...incoming
+  ]
+}
+
+/**
+ * Resolve all connections within a given set of elements
+ */
+export function findConnectionsWithin<M extends AnyAux>(
+  elements: Iterable<ElementModel<M>>
+): readonly ConnectionModel<M>[] {
+  return [...elements].reduce((acc, el, index, array) => {
+    // skip for last element
+    if (index === array.length - 1) {
+      return acc
+    }
+    acc.push(
+      ...findConnectionsBetween(el, array.slice(index + 1), 'both')
+    )
+    return acc
+  }, [] as ConnectionModel<M>[])
+}

package/src/model/index.ts

@@ -1,3 +1,5 @@
-export { LikeC4DiagramModel } from './LikeC4DiagramModel'
+export { LikeC4DeploymentModel } from './DeploymentModel'
 export { LikeC4Model } from './LikeC4Model'
-export { LikeC4ViewModel } from './LikeC4ViewModel'
+export type * from './LikeC4Model'
+export type { Aux as LikeC4ModelAux } from './types'
+export { LikeC4ViewModel } from './view/LikeC4ViewModel'

package/src/model/types.ts

@@ -1,23 +1,103 @@
-import type { Fqn as CoreFqn } from '../types/element'
-import type { RelationID as CoreRelationID } from '../types/relation'
-import type { EdgeId as CoreEdgeId, ViewID as CoreViewID } from '../types/view'
-
-import { isString } from 'remeda'
-import type { LiteralUnion } from 'type-fest'
-
-export type Fqn = LiteralUnion<CoreFqn, string>
-export type RelationID = LiteralUnion<CoreRelationID, string>
-export type ViewID = LiteralUnion<CoreViewID, string>
-export type EdgeId = LiteralUnion<CoreEdgeId, string>
+import type { IsLiteral, LiteralUnion, Simplify } from 'type-fest'
+import type {
+  AnyLikeC4Model,
+  ComputedView,
+  DiagramView,
+  EdgeId,
+  Fqn,
+  KeysOf,
+  LayoutedLikeC4Model,
+  NodeId,
+  ParsedLikeC4ModelDump,
+  RelationId,
+  ViewId
+} from '../types'
+import { isString } from '../utils/guards'
 
 export type IncomingFilter = 'all' | 'direct' | 'to-descendants'
 export type OutgoingFilter = 'all' | 'direct' | 'from-descendants'
 
-export type ElementOrFqn = Fqn | { id: Fqn }
-
 /**
  * Utility function to extract `id` from the given element.
  */
-export function getId(element: ElementOrFqn): Fqn {
-  return isString(element) ? element : element.id
+export function getId<Id extends string>(element: string | { id: Id }): Id {
+  return isString(element) ? element as Id : element.id
 }
+
+export type IteratorLike<T> = IteratorObject<T, BuiltinIteratorReturn>
+
+type WithId<Id> = { id: Id }
+
+type WithViews<Id extends string, ViewType> = { views: Record<Id, ViewType> }
+
+/**
+ * Auxilary type to keep track
+ */
+export interface Aux<
+  Element extends string,
+  Deployment extends string,
+  Views extends string,
+  ViewType
+> {
+  // Model: Model
+
+  // If Fqn is just a string, then we use generic Fqn to have better hints in the editor
+  Fqn: IsLiteral<Element> extends true ? Fqn<Element> : Fqn
+  Element: Element
+  ElementOrFqn: Element | WithId<this['Fqn']>
+
+  DeploymentFqn: IsLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn
+  Deployment: Deployment
+  DeploymentOrFqn: Deployment | WithId<this['DeploymentFqn']>
+
+  ViewId: IsLiteral<Views> extends true ? ViewId<Views> : ViewId
+  ViewIdLiteral: Views
+  ViewType: ViewType
+
+  RelationId: RelationId
+  NodeId: NodeId
+  NodeIdLiteral: string
+  EdgeId: EdgeId
+  EdgeIdLiteral: string
+
+  NodeOrId: LiteralUnion<this['NodeIdLiteral'], string> | WithId<this['NodeId']>
+  EdgeOrId: LiteralUnion<this['EdgeIdLiteral'], string> | WithId<this['EdgeId']>
+
+  Model: Simplify<Omit<AnyLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>
+}
+
+export type AnyAux = Aux<
+  string,
+  string,
+  string,
+  any
+>
+
+export namespace Aux {
+  export type FromModel<M> = M extends AnyLikeC4Model ? Aux<
+      KeysOf<M['elements']>,
+      KeysOf<M['deployments']['elements']>,
+      KeysOf<M['views']>,
+      M extends LayoutedLikeC4Model ? DiagramView<ViewId<KeysOf<M['views']>>, string>
+        : ComputedView<ViewId<KeysOf<M['views']>>, string>
+    >
+    : never
+
+  export type FromDump<M> = M extends ParsedLikeC4ModelDump ? Aux<
+      KeysOf<M['elements']>,
+      KeysOf<M['deployments']['elements']>,
+      KeysOf<M['views']>,
+      DiagramView<ViewId<KeysOf<M['views']>>, string>
+    >
+    : never
+}
+
+// export type FromModel<M> = LikeC4Model<
+//   M extends AnyLikeC4Model<
+//     infer Fqn extends string,
+//     infer Deployment extends string,
+//     infer ViewId extends string,
+//     any
+//   > ? Aux<Fqn, Deployment, ViewId, M>
+//     : Aux<KeysOf<>, string, string, ComputedLikeC4Model | LayoutedLikeC4Model>
+// >

package/src/model/view/EdgeModel.ts

@@ -0,0 +1,103 @@
+import { isNonNullish } from 'remeda'
+import type { LiteralUnion } from 'type-fest'
+import {
+  type ComputedDynamicView,
+  type ComputedView,
+  type DiagramView,
+  extractStep,
+  isStepEdgeId,
+  type RelationId as C4RelationID,
+  type StepEdgeId,
+  type Tag as C4Tag
+} from '../../types'
+import type { DeploymentRelationModel } from '../DeploymentElementModel'
+import type { LikeC4Model } from '../LikeC4Model'
+import type { RelationshipModel } from '../RelationModel'
+import type { AnyAux, IteratorLike } from '../types'
+import type { LikeC4ViewModel } from './LikeC4ViewModel'
+import type { NodeModel } from './NodeModel'
+
+export type EdgesIterator<M extends AnyAux, V extends ComputedView | DiagramView> = IteratorLike<EdgeModel<M, V>>
+
+export class EdgeModel<M extends AnyAux, V extends ComputedView | DiagramView = M['ViewType']> {
+  constructor(
+    public readonly view: LikeC4ViewModel<M, V>,
+    public readonly $edge: V['edges'][number],
+    public readonly source: NodeModel<M, V>,
+    public readonly target: NodeModel<M, V>
+  ) {
+  }
+
+  get id(): M['EdgeId'] {
+    return this.$edge.id
+  }
+
+  get parent(): NodeModel<M, V> | null {
+    return this.$edge.parent ? this.view.node(this.$edge.parent) : null
+  }
+
+  get label(): string | null {
+    return this.$edge.label
+  }
+
+  get description(): string | null {
+    return this.$edge.description ?? null
+  }
+
+  get technology(): string | null {
+    return this.$edge.technology ?? null
+  }
+
+  public hasParent(): this is EdgeModel.WithParent<M, V> {
+    return this.$edge.parent !== null
+  }
+
+  get tags(): ReadonlyArray<C4Tag> {
+    return this.$edge.tags ?? []
+  }
+
+  get stepNumber(): number | null {
+    return this.isStep() ? extractStep(this.id) : null
+  }
+
+  get navigateTo(): LikeC4ViewModel<M> | null {
+    return this.$edge.navigateTo ? this.view.$model.view(this.$edge.navigateTo) : null
+  }
+
+  public isStep(): this is EdgeModel.StepEdge<M, ComputedDynamicView> {
+    return isStepEdgeId(this.id)
+  }
+
+  public relationships(type: 'model'): IteratorLike<RelationshipModel<M>>
+  public relationships(type: 'deployment'): IteratorLike<DeploymentRelationModel<M>>
+  public relationships(type?: 'model' | 'deployment'): IteratorLike<LikeC4Model.AnyRelation<M>>
+  public *relationships(type: 'model' | 'deployment' | undefined): IteratorLike<LikeC4Model.AnyRelation<M>> {
+    for (const id of this.$edge.relations) {
+      // if type is provided, then we need to filter relationships
+      if (type) {
+        yield this.view.$model.relationship(id, type)
+        const rel = this.view.$model.findRelationship(id, type)
+        if (rel) {
+          yield rel
+        }
+      } else {
+        yield this.view.$model.relationship(id)
+      }
+    }
+    return
+  }
+
+  public includesRelation(rel: M['RelationId']): boolean {
+    return this.$edge.relations.includes(rel as C4RelationID)
+  }
+}
+
+namespace EdgeModel {
+  export interface StepEdge<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+    id: StepEdgeId
+    stepNumber: number
+  }
+  export interface WithParent<M extends AnyAux, V extends ComputedView | DiagramView> extends EdgeModel<M, V> {
+    parent: NodeModel<M, V>
+  }
+}