@likec4/core 1.40.0 → 1.42.0

package/src/builder/_types.ts

@@ -1,320 +0,0 @@
-import type { IfNever, IsLiteral, IsNever, Tagged, TupleToUnion } from 'type-fest'
-import type {
-  AnyAux,
-  Aux,
-  BorderStyle,
-  ElementShape,
-  ElementSpecification as ElementKindSpecification,
-  Expression,
-  KeysOf,
-  NonEmptyArray,
-  RelationshipArrowType,
-  RelationshipLineType,
-  RelationshipSpecification as RelationshipKindSpecification,
-  ShapeSize,
-  SpacingSize,
-  SpecAux,
-  TagSpecification,
-  TextSize,
-  ThemeColor as Color,
-} from '../types'
-import type { Builder } from './Builder'
-import type { DeploymentRulesBuilderOp } from './Builder.view-deployment'
-
-type ElementSpecification = Omit<ElementKindSpecification, 'tags'> & {
-  tags?: string[]
-}
-
-export type BuilderSpecification = {
-  elements: {
-    [kind: string]: Partial<ElementSpecification>
-  }
-  relationships?: {
-    [kind: string]: Partial<RelationshipKindSpecification>
-  }
-  deployments?: {
-    [kind: string]: Partial<ElementSpecification>
-  }
-  tags?: {
-    [kind: string]: Partial<TagSpecification>
-  }
-  metadataKeys?: string[]
-}
-
-/**
- * We need with `id: string` to be able to derive the project id
- *
- * @see {@link LikeC4Project}
- */
-export type BuilderProjectSpecification = {
-  id: string
-  title?: string
-}
-
-export type Metadata<MetadataKey extends string> = IsNever<MetadataKey> extends true ? never :
-  IsLiteral<MetadataKey> extends true ? {
-      [key in MetadataKey]?: string
-    } :
-  Record<string, string>
-
-export type NewElementProps<Tag, Metadata> = {
-  title?: string
-  description?: string
-  technology?: string
-  tags?: IfNever<Tag, never, [Tag, ...Tag[]]>
-  metadata?: Metadata
-  icon?: string
-  shape?: ElementShape
-  color?: Color
-  links?: Array<string | { title?: string; url: string }>
-  style?: {
-    border?: BorderStyle
-    // 0-100
-    opacity?: number
-    size?: ShapeSize
-    padding?: SpacingSize
-    textSize?: TextSize
-  }
-}
-
-export type NewDeploymentNodeProps<Tag, Metadata> = {
-  title?: string
-  description?: string
-  technology?: string
-  tags?: IfNever<Tag, never, [Tag, ...Tag[]]>
-  metadata?: Metadata
-  icon?: string
-  shape?: ElementShape
-  color?: Color
-  links?: NonEmptyArray<string | { title?: string; url: string }>
-  style?: {
-    border?: BorderStyle
-    // 0-100
-    opacity?: number
-    size?: ShapeSize
-    padding?: SpacingSize
-    textSize?: TextSize
-  }
-}
-
-export type NewViewProps<Tag> = {
-  title?: string
-  description?: string
-  tags?: IfNever<Tag, never, [Tag, ...Tag[]]>
-  links?: Array<string | { title?: string; url: string }>
-}
-
-export type NewRelationProps<Kind, Tag, Metadata> = {
-  kind?: Kind
-  title?: string
-  description?: string
-  technology?: string
-  tags?: IfNever<Tag, never, [Tag, ...Tag[]]>
-  metadata?: Metadata
-  head?: RelationshipArrowType
-  tail?: RelationshipArrowType
-  line?: RelationshipLineType
-  color?: Color
-  links?: NonEmptyArray<string | { title?: string; url: string }>
-}
-
-export type Invalid<Message extends string> = Tagged<Message, 'Error'>
-export type Warn<Id, Existing> = IsLiteral<Existing> extends true ? Id extends Existing ? Invalid<'Already exists'> : Id
-  : Id
-
-export type ValidId<Id> =
-  // Id extends `${string}.${string}` ? Invalid<'Id must not contain dot'>
-  Id extends `${number}${string}` ? Invalid<'Id must not start with number'>
-    : IsLiteral<Id> extends true ? Id
-    : Invalid<'Id must be a literal'>
-
-/**
- * Auxilary type to keep track of the types in builder
- */
-export interface Types<
-  ElementKind extends string,
-  Fqn extends string,
-  ViewId extends string,
-  RelationshipKind extends string,
-  Tag extends string,
-  MetadataKey extends string,
-  DeploymentKind extends string,
-  DeploymentFqn extends string,
-> {
-  ElementKind: ElementKind
-  Fqn: Fqn
-  ViewId: ViewId
-  RelationshipKind: RelationshipKind
-  Tag: Tag
-  MetadataKey: MetadataKey
-  DeploymentKind: DeploymentKind
-  DeploymentFqn: DeploymentFqn
-
-  Tags: IfNever<Tag, never, [Tag, ...Tag[]]>
-  // Metadata: Metadata<MetadataKey>
-
-  NewElementProps: NewElementProps<Tag, Metadata<MetadataKey>>
-  NewRelationshipProps: NewRelationProps<RelationshipKind, Tag, Metadata<MetadataKey>>
-  NewViewProps: NewViewProps<Tag>
-
-  NewDeploymentNodeProps: NewDeploymentNodeProps<Tag, Metadata<MetadataKey>>
-}
-
-/**
- * When building nested objects
- */
-export interface TypesNested<
-  Parent extends string,
-  ElementKind extends string,
-  Fqn extends string,
-  ViewId extends string,
-  RelationshipKind extends string,
-  Tag extends string,
-  MetadataKey extends string,
-  DeploymentKind extends string,
-  DeploymentFqn extends string,
-> extends
-  Types<
-    ElementKind,
-    Fqn,
-    ViewId,
-    RelationshipKind,
-    Tag,
-    MetadataKey,
-    DeploymentKind,
-    DeploymentFqn
-  >
-{
-  Parent: Parent
-}
-
-export type AnyTypes = Types<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
->
-
-export type AnyTypesNested = TypesNested<
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any,
-  any
->
-
-export namespace Types {
-  export type FromSpecification<Spec> = Spec extends BuilderSpecification ? Types<
-      KeysOf<Spec['elements']>,
-      never,
-      never,
-      KeysOf<Spec['relationships']>,
-      KeysOf<Spec['tags']>,
-      TupleToUnion<Spec['metadataKeys']>,
-      KeysOf<Spec['deployments']>,
-      never
-    >
-    : never
-
-  export type AddFqn<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any>
-    ? TypesNested<
-      P,
-      T['ElementKind'],
-      `${P}.${Id}` | T['Fqn'],
-      T['ViewId'],
-      T['RelationshipKind'],
-      T['Tag'],
-      T['MetadataKey'],
-      T['DeploymentKind'],
-      T['DeploymentFqn']
-    >
-    : T extends AnyTypes ? Types<
-        T['ElementKind'],
-        Id | T['Fqn'],
-        T['ViewId'],
-        T['RelationshipKind'],
-        T['Tag'],
-        T['MetadataKey'],
-        T['DeploymentKind'],
-        T['DeploymentFqn']
-      >
-    : never
-
-  export type AddDeploymentFqn<T, Id extends string> = T extends
-    TypesNested<infer P, any, any, any, any, any, any, any, any> ? TypesNested<
-      P,
-      T['ElementKind'],
-      T['Fqn'],
-      T['ViewId'],
-      T['RelationshipKind'],
-      T['Tag'],
-      T['MetadataKey'],
-      T['DeploymentKind'],
-      `${P}.${Id}` | T['DeploymentFqn']
-    >
-    : T extends AnyTypes ? Types<
-        T['ElementKind'],
-        T['Fqn'],
-        T['ViewId'],
-        T['RelationshipKind'],
-        T['Tag'],
-        T['MetadataKey'],
-        T['DeploymentKind'],
-        Id | T['DeploymentFqn']
-      >
-    : never
-
-  export type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any>
-    ? TypesNested<
-      P,
-      T['ElementKind'],
-      T['Fqn'],
-      Id | T['ViewId'],
-      T['RelationshipKind'],
-      T['Tag'],
-      T['MetadataKey'],
-      T['DeploymentKind'],
-      T['DeploymentFqn']
-    >
-    : T extends AnyTypes ? Types<
-        T['ElementKind'],
-        T['Fqn'],
-        Id | T['ViewId'],
-        T['RelationshipKind'],
-        T['Tag'],
-        T['MetadataKey'],
-        T['DeploymentKind'],
-        T['DeploymentFqn']
-      >
-    : never
-
-  export type ToAux<T> = T extends AnyTypes ? Aux<
-      'parsed',
-      T['Fqn'],
-      T['DeploymentFqn'],
-      T['ViewId'],
-      'from-builder',
-      SpecAux<
-        T['ElementKind'],
-        T['DeploymentKind'],
-        T['RelationshipKind'],
-        T['Tag'],
-        T['MetadataKey']
-      >
-    >
-    : AnyAux
-
-  export type ToExpression<T> = T extends AnyTypes ? Expression<ToAux<T>> : never
-
-  export type From<B> = B extends Builder<infer T> ? B['Types'] extends AnyTypes ? T : AnyTypes : never
-
-  export type DeploymentRules<B> = DeploymentRulesBuilderOp<From<B>>
-}

package/src/builder/index.ts

@@ -1,11 +0,0 @@
-export type * from './_types'
-export { Builder } from './Builder'
-export type * from './Builder.deployment'
-export type * from './Builder.deploymentModel'
-export type * from './Builder.element'
-export type * from './Builder.model'
-export type * from './Builder.view-common'
-export type * from './Builder.view-deployment'
-export type * from './Builder.view-element'
-export type * from './Builder.views'
-export type * from './Builder.with'

package/src/compute-view/compute-view.ts

@@ -1,80 +0,0 @@
-import { indexBy, values } from 'remeda'
-import { LikeC4Model } from '../model'
-import {
-  type AnyAux,
-  type ComputedLikeC4ModelData,
-  type ComputedView,
-  type ParsedLikeC4ModelData,
-  type ParsedView,
-  _stage,
-  isDeploymentView,
-  isDynamicView,
-  isElementView,
-} from '../types'
-import { nonexhaustive } from '../utils'
-import { computeDeploymentView } from './deployment-view/compute'
-import { computeDynamicView } from './dynamic-view/compute'
-import { computeElementView } from './element-view/compute'
-
-export type ComputeViewResult<V> =
-  | {
-    isSuccess: true
-    error?: undefined
-    view: V
-  }
-  | {
-    isSuccess: false
-    error: Error
-    view: undefined
-  }
-
-export function unsafeComputeView<A extends AnyAux>(
-  viewsource: ParsedView<A>,
-  likec4model: LikeC4Model<any>,
-): ComputedView<A> {
-  switch (true) {
-    case isElementView(viewsource):
-      return computeElementView(likec4model, viewsource)
-    case isDeploymentView(viewsource):
-      return computeDeploymentView(likec4model, viewsource)
-    case isDynamicView(viewsource):
-      return computeDynamicView(likec4model, viewsource)
-    default:
-      nonexhaustive(viewsource)
-  }
-}
-
-export function computeView<A extends AnyAux>(
-  viewsource: ParsedView<A>,
-  likec4model: LikeC4Model<A>,
-): ComputeViewResult<ComputedView<A>> {
-  try {
-    return {
-      isSuccess: true,
-      view: unsafeComputeView(viewsource, likec4model),
-    }
-  } catch (e) {
-    return {
-      isSuccess: false,
-      error: e instanceof Error ? e : new Error(`Unknown error: ${e}`),
-      view: undefined,
-    }
-  }
-}
-
-export function computeParsedModelData<A extends AnyAux>(
-  parsed: ParsedLikeC4ModelData<A>,
-): ComputedLikeC4ModelData<A> {
-  const likec4model = LikeC4Model.create(parsed)
-  const views = values(parsed.views as Record<string, ParsedView<A>>)
-    .map(v => unsafeComputeView(v, likec4model))
-  return {
-    ...parsed,
-    [_stage]: 'computed',
-    views: indexBy(views, v => v.id),
-  } as ComputedLikeC4ModelData<A>
-}
-
-export function computeLikeC4Model<A extends AnyAux>(parsed: ParsedLikeC4ModelData<A>): LikeC4Model.Computed<A> {
-  return LikeC4Model.create(computeParsedModelData(parsed))
-}

package/src/compute-view/deployment-view/_types.ts

@@ -1,38 +0,0 @@
-import type { RelationshipModel } from '../../model'
-import { LikeC4DeploymentModel } from '../../model'
-import type { AnyAux, Expression, OperatorPredicate } from '../../types'
-import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
-
-export { Memory, type Stage } from './memory'
-
-export type Where<T extends {}> = (x: T) => boolean
-
-export type Elem = Ctx['Element']
-export type Connection = Ctx['Connection']
-
-export type ElementWhere = Where<Elem>
-export type ElementWhereFilter = (elements: readonly Elem[]) => Elem[]
-export type ConnectionWhere = Where<Connection>
-export type RelationshipWhere = Where<RelationshipModel<any>>
-export type ConnectionWhereFilter = (connections: readonly Connection[]) => Connection[]
-
-export type Connections = ReadonlyArray<Connection>
-
-export interface PredicateCtx<Expr = Expression<AnyAux>> {
-  expr: Expr
-  stage: Stage
-  model: LikeC4DeploymentModel<AnyAux>
-  memory: Memory
-  where: OperatorPredicate<AnyAux> | null
-}
-export interface IncludePredicateCtx<Expr = Expression<AnyAux>> extends PredicateCtx<Expr> {
-  stage: StageInclude
-}
-export interface ExcludePredicateCtx<Expr = Expression<AnyAux>> extends PredicateCtx<Expr> {
-  stage: StageExclude
-}
-
-export interface PredicateExecutor<Expr extends Expression<AnyAux> = Expression<AnyAux>> {
-  include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
-  exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
-}

package/src/compute-view/deployment-view/clean-connections.ts

@@ -1,236 +0,0 @@
-import {
-  dropWhile,
-  filter,
-  flatMap,
-  forEach,
-  groupBy,
-  hasAtLeast,
-  map,
-  pipe,
-  piped,
-  prop,
-  reduce,
-  values,
-} from 'remeda'
-import type { RelationshipModel } from '../../model'
-import {
-  DeploymentConnectionModel,
-  differenceConnections,
-  isNestedConnection,
-  mergeConnections,
-  RelationshipsAccum,
-  sortConnectionsByBoundaryHierarchy,
-} from '../../model'
-import { invariant } from '../../utils'
-import { imap, toArray } from '../../utils/iterable'
-import { DefaultMap } from '../../utils/mnemonist'
-import { intersection, union } from '../../utils/set'
-import type { Connection, Connections } from './_types'
-import { findConnection } from './utils'
-
-type MapOfExcludesFromConnection = DefaultMap<DeploymentConnectionModel, Set<RelationshipModel>>
-function findCrossBoundarySameSourceOrTarget(connections: Connections): MapOfExcludesFromConnection {
-  // Also find connections based on same relation
-  const groupedByRelation = new DefaultMap<RelationshipModel, Array<DeploymentConnectionModel>>(() => [])
-  for (const conn of connections) {
-    for (const relation of conn.relations.model) {
-      groupedByRelation.get(relation).push(conn)
-    }
-  }
-
-  // Aggreate excluded relations for each connection
-  const excludedRelations = new DefaultMap<
-    DeploymentConnectionModel,
-    Set<RelationshipModel>
-  >(() => new Set())
-
-  // In each group, find connected to same leaf
-  for (const [relation, sameRelationGroup] of groupedByRelation) {
-    if (!hasAtLeast(sameRelationGroup, 2)) {
-      continue
-    }
-
-    // Outgoing from same source
-    pipe(
-      sameRelationGroup,
-      flatMap(conn => [
-        { group: `$source-${conn.source.id}`, conn },
-        { group: `$target-${conn.target.id}`, conn },
-      ]),
-      groupBy(prop('group')),
-      values(),
-      filter(hasAtLeast(2)),
-      forEach(
-        // In each group, sort by hierarchy, first are deepest
-        piped(
-          map(prop('conn')),
-          sortConnectionsByBoundaryHierarchy('desc'),
-          // Drop first, as it is the deepest
-          // Drop if boundary is same as previous
-          dropWhile((conn, i, all) => i === 0 || conn.boundary === all[i - 1]!.boundary),
-          // Drop relations from boundaries above
-          forEach((conn) => {
-            excludedRelations.get(conn).add(relation)
-          }),
-        ),
-      ),
-    )
-  }
-
-  return excludedRelations
-}
-
-/**
- * Identifies and processes cross-boundary connections in a deployment diagram.
- * This function analyzes connections between nodes and removes redundant relations
- * when multiple connections exist between the same elements across different boundaries.
- *
- * The function performs the following:
- * 1. Groups connections by their relationship type
- * 2. For each relationship group, identifies connections that:
- *    - Share the same source
- *    - Share the same target
- * 3. When multiple connections are found in the same group, keeps only the most specific
- *    (deepest in hierarchy) connection and removes the relationship from others
- *
- * @param connections - The input collection of deployment connections to analyze
- * @returns connections with redundant cross-boundary relationships
- */
-export function findCrossBoundaryConnections(connections: Connections): Array<Connection> {
-  // Ensure connections are merged
-  connections = mergeConnections(connections)
-
-  const excludedRelations = findCrossBoundarySameSourceOrTarget(connections)
-
-  for (const c of connections) {
-    const { source, target } = c
-    const connectionModelRelations = c.relations.model
-    // Connections between node and instance
-    // Exclude internal relations of the node (otherwise they are cross-boundary)
-    if (source.isDeploymentNode() !== target.isDeploymentNode()) {
-      const node = source.isDeploymentNode() ? source : c.target
-      invariant(node.isDeploymentNode())
-      const nodeInternals = node.internalModelRelationships()
-      const toExclude = intersection(
-        connectionModelRelations,
-        nodeInternals,
-      )
-      for (const relation of toExclude) {
-        excludedRelations.get(c).add(relation)
-      }
-
-      continue
-    }
-
-    // Connection between nodes
-    if (source.isDeploymentNode() && target.isDeploymentNode()) {
-      const toExclude = union(
-        // Exclude node internals (otherwise thay are cross-boundary)
-        intersection(
-          c.relations.model,
-          source.internalModelRelationships(),
-        ),
-        intersection(
-          c.relations.model,
-          target.internalModelRelationships(),
-        ),
-      )
-      for (const relation of toExclude) {
-        excludedRelations.get(c).add(relation)
-      }
-    }
-  }
-
-  return pipe(
-    excludedRelations.entries(),
-    imap(([c, excluded]) =>
-      c.update({
-        model: excluded,
-        deployment: null,
-      })
-    ),
-    toArray(),
-  )
-}
-
-/**
- * Cleans connections that cross boundaries by removing overlapping parts.
- * @example
- * ```ts
- * const connections = getConnections();
- * const cleanedConnections = cleanCrossBoundary(connections);
- * ```
- */
-export function cleanCrossBoundary(connections: Connections): Array<Connection> {
-  return differenceConnections(
-    connections,
-    findCrossBoundaryConnections(connections),
-  )
-}
-
-/**
- * Identifies and returns redundant connections in a deployment view.
- * A connection is considered redundant if its relationships are already implied
- * through other connections
- *
- * @returns Array of redundant connections that can be safely removed
- */
-export function findRedundantConnections(connections: Connections): Array<Connection> {
-  return pipe(
-    connections,
-    mergeConnections,
-    reduce((redundants, connection) => {
-      const { source, target, relations } = connection
-
-      // Connection between instances is always explicit
-      if (source.isInstance() && target.isInstance()) {
-        return redundants
-      }
-
-      let redundantAccum = RelationshipsAccum.empty()
-
-      if (source.isDeploymentNode() && target.isDeploymentNode()) {
-        const [reversed] = findConnection(target, source, 'directed')
-        if (reversed) {
-          redundantAccum = relations.intersect(reversed.relations)
-        }
-      }
-
-      for (const c of connections) {
-        if (isNestedConnection(c, connection)) {
-          redundantAccum = redundantAccum.union(
-            relations.intersect(c.relations),
-          )
-        }
-      }
-
-      if (redundantAccum.nonEmpty) {
-        redundants.push(
-          new DeploymentConnectionModel(
-            source,
-            target,
-            redundantAccum,
-          ),
-        )
-      }
-
-      return redundants
-    }, [] as DeploymentConnectionModel[]),
-  )
-}
-
-/**
- * Remove relationships from connection model, that are already included in the connections between descendants.
- * In other words - if there is same connection down the hierarchy.
- *
- * @returns New connection without redundant relationships
- *          Connection may be empty if all relationships are redundant, in this case it should be removed
- */
-export function cleanRedundantRelationships(
-  connections: Connections,
-): Array<Connection> {
-  return differenceConnections(
-    connections,
-    findRedundantConnections(connections),
-  )
-}