@likec4/core 1.17.1 → 1.19.0

package/src/model/connection/ops.ts

@@ -0,0 +1,274 @@
+import { map, pipe, prop } from 'remeda'
+import { isString } from '../../utils'
+import {
+  type IterableContainer,
+  type ReorderedArray,
+  isAncestor,
+  isDescendantOf,
+  sortNaturalByFqn,
+} from '../../utils/fqn'
+import type { Connection } from './Connection'
+
+/**
+ * Check if connection is nested inside another connection
+ * (i.e. between descendants)
+ */
+export function isNestedConnection<T extends { id: string }>(
+  parent: WithSourceTarget<NoInfer<T>>,
+): (nested: WithSourceTarget<T>) => boolean
+export function isNestedConnection<T extends { id: string }>(
+  nested: WithSourceTarget<T>,
+  parent: WithSourceTarget<T>,
+): boolean
+export function isNestedConnection<T extends { id: string }>(
+  nested: WithSourceTarget<T>,
+  parent?: WithSourceTarget<T>,
+) {
+  if (!parent) {
+    const p = nested
+    return (n: WithSourceTarget<T>) => isNestedConnection(n, p)
+  }
+  const isSameSource = nested.source === parent.source
+  const isSameTarget = nested.target === parent.target
+  if (isSameSource && isSameTarget) {
+    return false
+  }
+  const isSourceNested = isAncestor(parent.source.id, nested.source.id)
+  const isTargetNested = isAncestor(parent.target.id, nested.target.id)
+  return (
+    (isSourceNested && isTargetNested)
+    || (isSameSource && isTargetNested)
+    || (isSameTarget && isSourceNested)
+  )
+}
+
+type ConnectionElemId = Connection<{ readonly id: string }, any>
+
+export function findDeepestNestedConnection<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+  connection: C,
+): C | null {
+  let deepest = connection
+  for (const c of connections) {
+    if (isNestedConnection(c, deepest)) {
+      deepest = c
+    }
+  }
+  return deepest !== connection ? deepest : null
+}
+
+export function sortDeepestFirst<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+): C[] {
+  const sorted = [] as C[]
+  const unsorted = connections.slice()
+  let next
+  while (next = unsorted.shift()) {
+    let deepest
+    while (deepest = findDeepestNestedConnection(unsorted, next)) {
+      const index = unsorted.indexOf(deepest)
+      sorted.push(unsorted.splice(index, 1)[0]!)
+    }
+    sorted.push(next)
+  }
+  return sorted
+}
+
+/**
+ * To make {@link sortConnectionsByBoundaryHierarchy} work correctly we add '.' to boundary
+ * Othwerwise connection without boundary will be considered same level as connection with top-level boundary
+ */
+export const boundaryHierarchy = <C extends WithBoundary>(conn: C) => conn.boundary?.id ? `.${conn.boundary.id}` : ''
+
+type WithBoundary = {
+  boundary: null | { id: string }
+}
+export function sortConnectionsByBoundaryHierarchy(
+  sort?: 'asc' | 'desc',
+): <T extends WithBoundary, A extends IterableContainer<T>>(array: A) => ReorderedArray<A>
+export function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(
+  array: A,
+  sort?: 'asc' | 'desc',
+): ReorderedArray<A>
+export function sortConnectionsByBoundaryHierarchy<T extends WithBoundary, A extends IterableContainer<T>>(
+  connections?: A | 'asc' | 'desc',
+  sort?: 'asc' | 'desc',
+) {
+  if (!connections || isString(connections)) {
+    const dir = connections ?? 'asc'
+    return (arr: A) => _sortByBoundary(arr, dir)
+  }
+  return _sortByBoundary(connections, sort ?? 'asc')
+}
+
+function _sortByBoundary<C extends WithBoundary>(
+  connections: ReadonlyArray<C>,
+  order: 'asc' | 'desc',
+): C[] {
+  return pipe(
+    connections,
+    map(conn => ({
+      id: boundaryHierarchy(conn),
+      conn,
+    })),
+    sortNaturalByFqn(order),
+    map(prop('conn')),
+  )
+}
+
+/**
+ * Find connections that includes given connection (i.e between it's ancestors)
+ */
+export function findAscendingConnections<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+  connection: C,
+): Array<C> {
+  return connections.filter(c => isNestedConnection(connection, c))
+}
+
+/**
+ * Find connections that includes given connection (i.e between it's descendants)
+ */
+export function findDescendantConnections<C extends ConnectionElemId>(
+  connections: ReadonlyArray<C>,
+  connection: C,
+): Array<C> {
+  return connections.filter(isNestedConnection(connection))
+}
+
+export function mergeConnections<C extends Connection>(
+  connections: ReadonlyArray<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, conn.mergeWith(existing) as C)
+    } else {
+      map.set(conn.id, conn)
+    }
+  }
+  return [...map.values()]
+}
+
+/**
+ * Excludes the values existing in `other` array.
+ * The output maintains the same order as the input.
+ */
+export function differenceConnections<C extends Connection>(
+  source: Iterable<C>,
+  exclude: Iterable<C>,
+): C[] {
+  const minus = new Map([...exclude].map(c => [c.id, c]))
+  return [...source].reduce((acc, c) => {
+    const other = minus.get(c.id)
+    if (!other) {
+      acc.push(c)
+      return acc
+    }
+    const updated = c.difference(other) as C
+    if (updated.nonEmpty()) {
+      acc.push(updated)
+    }
+    return acc
+  }, [] as C[])
+}
+
+type WithSourceTarget<T = unknown> = {
+  source: T
+  target: T
+}
+
+export function hasSameSourceTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
+export function hasSameSourceTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
+export function hasSameSourceTarget(a: WithSourceTarget, b?: WithSourceTarget) {
+  if (b) {
+    return a.source === b.source && a.target === b.target
+  }
+  return (b: WithSourceTarget) => a.source === b.source && a.target === b.target
+}
+
+export function hasSameSource<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
+export function hasSameSource<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
+export function hasSameSource(a: WithSourceTarget, b?: WithSourceTarget) {
+  if (b) {
+    return a.source === b.source
+  }
+  return (b: WithSourceTarget) => a.source === b.source
+}
+
+export function hasSameTarget<T>(a: WithSourceTarget<NoInfer<T>>): (b: WithSourceTarget<T>) => boolean
+export function hasSameTarget<T>(a: WithSourceTarget<T>, b: WithSourceTarget<T>): boolean
+export function hasSameTarget(a: WithSourceTarget, b?: WithSourceTarget) {
+  if (b) {
+    return a.target === b.target
+  }
+  return (b: WithSourceTarget) => a.target === b.target
+}
+
+type WithId<T> = {
+  id: T
+}
+export function isOutgoing<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
+export function isOutgoing<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
+  if (!source) {
+    const _source = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isOutgoing(b, _source)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.source, source) && !isDescendantOf(at.target, source)
+}
+
+export function isIncoming<T extends string>(target: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>>, target: WithId<T>): boolean
+export function isIncoming<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, target?: WithId<T>) {
+  if (!target) {
+    const _target = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isIncoming(b, _target)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.target, target) && !isDescendantOf(at.source, target)
+}
+
+export function isAnyInOut<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
+export function isAnyInOut<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
+  if (!source) {
+    const _source = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isAnyInOut(b, _source)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.source, source) !== isDescendantOf(at.target, source)
+}
+
+export function isInside<T extends string>(source: WithId<NoInfer<T>>): (a: WithSourceTarget<WithId<T>>) => boolean
+export function isInside<T extends string>(a: WithSourceTarget<WithId<T>>, source: WithId<T>): boolean
+export function isInside<T extends string>(a: WithSourceTarget<WithId<T>> | WithId<T>, source?: WithId<T>) {
+  if (!source) {
+    const _source = a as WithId<T>
+    return (b: WithSourceTarget<WithId<T>>) => isInside(b, _source)
+  }
+  const at = a as WithSourceTarget<WithId<T>>
+  return isDescendantOf(at.source, source) && isDescendantOf(at.target, source)
+}
+
+// export function isIncoming<T>(target: NoInfer<T>): (a: WithSourceTarget<T>) => boolean
+// export function isIncoming<T>(a: WithSourceTarget<T>, target: T): boolean
+// export function isIncoming<T = unknown>(a: WithSourceTarget<T> | T, target?: T) {
+//   if (target) {
+//     return (a as WithSourceTarget<T>).target === target
+//   }
+//   const _target = a as T
+//   return (b: WithSourceTarget) => b.target === _target
+// }
+
+// export function isAnyInOut<T>(source: NoInfer<T>): (a: WithSourceTarget<T>) => boolean
+// export function isAnyInOut<T>(a: WithSourceTarget<T>, source: T): boolean
+// export function isAnyInOut<T = unknown>(a: WithSourceTarget<T> | T, source?: T) {
+//   if (source) {
+//     return hasSameSource(a as WithSourceTarget<T>, source) || hasSameTarget(a as WithSourceTarget<T>, source)
+//   }
+//   const _source = a as T
+//   return (b: WithSourceTarget) => hasSameSource(b, _source) || hasSameTarget(b, _source)
+// }

package/src/model/guards.ts

@@ -0,0 +1,9 @@
+import type { DeployedInstanceModel, DeploymentElementModel, DeploymentNodeModel } from './DeploymentElementModel'
+
+export function isDeploymentNode(model: DeploymentElementModel): model is DeploymentNodeModel {
+  return model.isDeploymentNode()
+}
+
+export function isDeployedInstance(model: DeploymentElementModel): model is DeployedInstanceModel {
+  return model.isInstance()
+}

package/src/model/index.ts

@@ -1,3 +1,47 @@
-export { LikeC4DiagramModel } from './LikeC4DiagramModel'
+export { ElementModel } from './ElementModel'
 export { LikeC4Model } from './LikeC4Model'
-export { LikeC4ViewModel } from './LikeC4ViewModel'
+export { RelationshipModel } from './RelationModel'
+
+export {
+  Connection,
+  ConnectionModel,
+  deployment as deploymentConnection,
+  DeploymentConnectionModel,
+  differenceConnections,
+  findAscendingConnections,
+  findDeepestNestedConnection,
+  findDescendantConnections,
+  hasSameSource,
+  hasSameSourceTarget,
+  hasSameTarget,
+  isAnyInOut,
+  isIncoming,
+  isNestedConnection,
+  isOutgoing,
+  mergeConnections,
+  model as modelConnection,
+  sortConnectionsByBoundaryHierarchy,
+  sortDeepestFirst,
+} from './connection'
+
+export {
+  DeployedInstanceModel,
+  type DeploymentElementModel,
+  DeploymentNodeModel,
+  DeploymentRelationModel,
+} from './DeploymentElementModel'
+export { LikeC4DeploymentModel } from './DeploymentModel'
+
+export { EdgeModel } from './view/EdgeModel'
+export { LikeC4ViewModel } from './view/LikeC4ViewModel'
+export { NodeModel } from './view/NodeModel'
+
+export type {
+  AnyAux,
+  Aux,
+} from './types'
+
+export {
+  isDeployedInstance,
+  isDeploymentNode,
+} from './guards'

package/src/model/types.ts

@@ -1,23 +1,120 @@
-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 { IsStringLiteral, LiteralUnion, Simplify } from 'type-fest'
+import type {
+  ComputedView,
+  DiagramView,
+  EdgeId,
+  Fqn,
+  GenericLikeC4Model,
+  IteratorLike,
+  KeysOf,
+  LayoutedLikeC4Model,
+  LikeC4ModelDump,
+  NodeId,
+  ParsedLikeC4Model,
+  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
+}
+
+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,
+  View extends string,
+  ViewType,
+> {
+  Element: Element
+  Deployment: Deployment
+  View: View
+
+  // Wrapped Element
+  // If Fqn is just a string, then we use generic Fqn to have better hints in the editor
+  Fqn: IsStringLiteral<Element> extends true ? Fqn<Element> : Fqn
+  ElementOrFqn: Element | WithId<this['Fqn']>
+
+  // Wrapped Deployment
+  DeploymentFqn: IsStringLiteral<Deployment> extends true ? Fqn<Deployment> : Fqn
+  DeploymentOrFqn: Deployment | WithId<this['DeploymentFqn']>
+
+  // Wrapped View
+  ViewId: IsStringLiteral<View> extends true ? ViewId<View> : ViewId
+
+  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<GenericLikeC4Model, 'views'> & WithViews<this['ViewId'], ViewType>>
+}
+
+export type AnyAux = Aux<
+  string,
+  string,
+  string,
+  any
+>
+
+export namespace Strict {
+  export type Fqn<A extends AnyAux> = A['Element']
+  export type Deployment<A extends AnyAux> = A['Deployment']
+  export type ViewId<A extends AnyAux> = A['View']
+}
+
+export namespace Aux {
+  export type FromParsed<M> = M extends ParsedLikeC4Model ? Aux<
+      KeysOf<M['elements']>,
+      KeysOf<M['deployments']['elements']>,
+      KeysOf<M['views']>,
+      ComputedView<ViewId<KeysOf<M['views']>>, string>
+    >
+    : never
+
+  export type FromModel<M> = M extends GenericLikeC4Model ? 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 LikeC4ModelDump ? 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,
+  type IteratorLike,
+  type RelationId as C4RelationID,
+  type StepEdgeId,
+  type Tag as C4Tag,
+  extractStep,
+  isStepEdgeId,
+} from '../../types'
+import type { DeploymentRelationModel } from '../DeploymentElementModel'
+import type { LikeC4Model } from '../LikeC4Model'
+import type { RelationshipModel } from '../RelationModel'
+import type { AnyAux } 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) {
+        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>
+  }
+}