@likec4/core 1.17.1 → 1.18.0

package/src/builder/Builder.view.ts

@@ -1,10 +1,14 @@
 import { isArray, isString, map } from 'remeda'
-import type { LiteralUnion, Simplify, Tagged } from 'type-fest'
+import type { LiteralUnion, Simplify, Tagged, Writable } from 'type-fest'
 import {
   type AutoLayoutDirection,
   type CustomElementExpr,
   type CustomRelationExpr,
+  type DeploymentElementExpression,
+  type DeploymentExpression,
+  type DeploymentView,
   type ElementExpression as C4ElementExpression,
+  type ElementView,
   type Expression as C4Expression,
   type Fqn,
   isElementPredicateExpr,
@@ -15,25 +19,58 @@ import {
 import type { AnyTypes, Types } from './_types'
 import type { views, ViewsBuilder as Builder } from './Builder.views'
 
-export interface ViewBuilder<T extends AnyTypes> {
-  include(...exprs: C4Expression[]): ViewBuilder<T>
-  exclude(...exprs: C4Expression[]): ViewBuilder<T>
-  style(rule: ViewRuleStyle): ViewBuilder<T>
-  autoLayout(layout: AutoLayoutDirection): ViewBuilder<T>
+interface AViewBuilder<
+  Types extends AnyTypes,
+  Fqn extends string,
+  TypedExpr,
+  ElementExpr extends string = ViewPredicate.ElementExpr<Fqn>,
+  Expr extends string = ViewPredicate.AllExpression<ElementExpr>
+> {
+  Types: Types
+  ElementExpr: ElementExpr
+  Expr: Expr
+  TypedExpr: TypedExpr
+  $expr(expr: Expr | TypedExpr): TypedExpr
+  include(...exprs: Expr[]): this
+  exclude(...exprs: Expr[]): this
+  style(rule: ViewRuleStyle): this
+  autoLayout(layout: AutoLayoutDirection): this
+}
+
+export interface ViewBuilder<T extends AnyTypes> extends AViewBuilder<T, T['Fqn'], C4Expression> {
+  $expr(expr: ViewPredicate.Expression<T> | C4Expression): TypedC4Expression<T>
+  include(...exprs: C4Expression[]): this
+  exclude(...exprs: C4Expression[]): this
+  style(rule: ViewRuleStyle): this
+  autoLayout(layout: AutoLayoutDirection): this
+}
+
+export interface DeploymentViewBuilder<T extends AnyTypes>
+  extends AViewBuilder<T, T['DeploymentFqn'], DeploymentExpression>
+{
+  $expr(expr: ViewPredicate.DeploymentExpression<T> | DeploymentExpression): TypedDeploymentExpression<T>
+  include(...exprs: DeploymentExpression[]): this
+  exclude(...exprs: DeploymentExpression[]): this
+  style(rule: ViewRuleStyle): this
+  autoLayout(layout: AutoLayoutDirection): this
 }
 
 export namespace ViewPredicate {
-  export type ElementExpr<Fqn extends string> = '*' | Fqn | `${Fqn}.*` | `${Fqn}._`
+  export type ElementExpr<Fqn extends string> = '*' | Fqn | `${Fqn}.*` | `${Fqn}._` | `${Fqn}.**`
 
-  type AllExpression<ElementExpr extends string> =
+  export type AllExpression<ElementExpr extends string> =
     | ElementExpr
     | `-> ${ElementExpr} ->`
     | `-> ${ElementExpr}`
     | `${ElementExpr} ->`
     | `${ElementExpr} ${'->' | '<->'} ${ElementExpr}`
 
-  export type Expression<T extends AnyTypes> = T extends Types<any, infer F extends string, any, any, any, any>
-    ? AllExpression<ViewPredicate.ElementExpr<F>>
+  export type Expression<T extends AnyTypes> = T extends
+    Types<any, infer F extends string, any, any, any, any, any, any> ? AllExpression<ViewPredicate.ElementExpr<F>>
+    : never
+
+  export type DeploymentExpression<T extends AnyTypes> = T extends
+    Types<any, any, any, any, any, any, any, infer F extends string> ? AllExpression<ViewPredicate.ElementExpr<F>>
     : never
 
   export type WhereTag<Tag extends string> = `tag ${'is' | 'is not'} #${Tag}`
@@ -67,7 +104,11 @@ export namespace ViewPredicate {
   }
 }
 
+type Op<T> = (b: T) => T
 export type ViewRuleBuilderOp<Types extends AnyTypes> = (b: ViewBuilder<Types>) => ViewBuilder<Types>
+export type DeploymentViewRuleBuilderOp<Types extends AnyTypes> = (
+  b: DeploymentViewBuilder<Types>
+) => DeploymentViewBuilder<Types>
 
 export interface AddViewHelper<Props = unknown> {
   // <
@@ -145,8 +186,28 @@ export interface AddViewOfHelper<Props = unknown> {
   ): (builder: Builder<T>) => Builder<Types.AddView<T, Id>>
 }
 
+export interface AddDeploymentViewHelper<Props = unknown> {
+  <
+    const Id extends string,
+    T extends AnyTypes
+  >(
+    id: Id,
+    builder: DeploymentViewRuleBuilderOp<T>
+  ): (builder: Builder<T>) => Builder<Types.AddView<T, Id>>
+
+  <
+    const Id extends string,
+    T extends AnyTypes
+  >(
+    id: Id,
+    propsOrTitle: Props | string | undefined,
+    builder: DeploymentViewRuleBuilderOp<T>
+  ): (builder: Builder<T>) => Builder<Types.AddView<T, Id>>
+}
+
 // To hook types
 type TypedC4Expression<Types extends AnyTypes> = Tagged<C4Expression, 'typed', Types>
+type TypedDeploymentExpression<Types extends AnyTypes> = Tagged<DeploymentExpression, 'typed', Types>
 
 function parseWhere(where: ViewPredicate.WhereOperator<AnyTypes>): WhereOperator<any, any> {
   if (isString(where)) {
@@ -200,15 +261,13 @@ function parseWhere(where: ViewPredicate.WhereOperator<AnyTypes>): WhereOperator
   throw new Error(`Unknown where operator: ${where}`)
 }
 
-function $include<Types extends AnyTypes>(
+function $include<B extends AViewBuilder<AnyTypes, any, any>>(
   ...args:
-    | [ViewPredicate.Expression<Types>]
-    | [TypedC4Expression<Types>]
-    | [ViewPredicate.Expression<Types>, ViewPredicate.Custom<Types>]
-): (b: ViewBuilder<Types>) => ViewBuilder<Types> {
+    | [B['Expr']]
+    | [B['Expr'], ViewPredicate.Custom<B['Types']>]
+): (b: B) => B {
   return (b) => {
-    let expr = $expr(args[0]) as C4Expression
-    const isElement = isElementPredicateExpr(expr)
+    let expr = b.$expr(args[0])
     if (args.length === 2) {
       const condition = args[1].where ? parseWhere(args[1].where) : undefined
       if (condition) {
@@ -222,6 +281,7 @@ function $include<Types extends AnyTypes>(
 
       const custom = args[1].with
       if (custom) {
+        const isElement = isElementPredicateExpr(expr)
         if (isElement) {
           expr = {
             custom: {
@@ -239,19 +299,18 @@ function $include<Types extends AnyTypes>(
         }
       }
     }
-    b.include(expr)
+    b.include(expr as any)
     return b
   }
 }
 
-function $exclude<Types extends AnyTypes>(
+function $exclude<B extends AViewBuilder<AnyTypes, any, any>>(
   ...args:
-    | [ViewPredicate.Expression<Types>]
-    | [TypedC4Expression<Types>]
-    | [ViewPredicate.Expression<Types>, ViewPredicate.Custom<Types>]
-): (b: ViewBuilder<Types>) => ViewBuilder<Types> {
+    | [B['Expr']]
+    | [B['Expr'], ViewPredicate.Custom<B['Types']>]
+): (b: B) => B {
   return (b) => {
-    let expr = $expr(args[0]) as C4Expression
+    let expr = b.$expr(args[0]) as C4Expression
     if (args.length === 2 && args[1].where) {
       const condition = parseWhere(args[1].where)
       expr = {
@@ -266,93 +325,219 @@ function $exclude<Types extends AnyTypes>(
   }
 }
 
+const asTypedExpr = <Types extends AnyTypes>(expr: C4Expression): TypedC4Expression<Types> => {
+  return expr as TypedC4Expression<Types>
+}
 function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Types> | C4Expression): TypedC4Expression<Types> {
   if (!isString(expr)) {
     return expr as TypedC4Expression<Types>
   }
   if (expr === '*') {
-    return { wildcard: true } as TypedC4Expression<Types>
+    return asTypedExpr({ wildcard: true })
   }
   if (expr.startsWith('->')) {
     if (expr.endsWith('->')) {
-      return {
+      return asTypedExpr({
         inout: $expr(expr.replace(/->/g, '').trim()) as any
-      } as TypedC4Expression<Types>
+      })
     }
-    return {
+    return asTypedExpr({
       incoming: $expr(expr.replace('-> ', '')) as any
-    } as TypedC4Expression<Types>
+    })
   }
   if (expr.endsWith(' ->')) {
-    return {
+    return asTypedExpr({
       outgoing: $expr(expr.replace(' ->', '')) as any
-    } as TypedC4Expression<Types>
+    })
   }
   if (expr.includes(' <-> ')) {
     const [source, target] = expr.split(' <-> ')
-    return {
+    return asTypedExpr({
       source: $expr(source) as any,
       target: $expr(target) as any,
       isBidirectional: true
-    } as TypedC4Expression<Types>
+    })
   }
   if (expr.includes(' -> ')) {
     const [source, target] = expr.split(' -> ')
-    return {
+    return asTypedExpr({
       source: $expr(source) as any,
       target: $expr(target) as any
-    } as TypedC4Expression<Types>
+    })
   }
   if (expr.endsWith('._')) {
-    return {
+    return asTypedExpr({
       expanded: expr.replace('._', '') as Fqn
-    } as TypedC4Expression<Types>
+    })
   }
   if (expr.endsWith('.*')) {
-    return {
+    return asTypedExpr({
       element: expr.replace('.*', '') as Fqn,
-      isDescedants: true
-    } as TypedC4Expression<Types>
+      isChildren: true
+    })
+  }
+  if (expr.endsWith('.**')) {
+    return asTypedExpr({
+      element: expr.replace('.**', '') as Fqn,
+      isDescendants: true
+    })
   }
-  return {
-    element: expr as any as Fqn,
-    isDescedants: false
-  } as TypedC4Expression<Types>
+  return asTypedExpr({
+    element: expr as any as Fqn
+  })
 }
 
-function $style<Types extends AnyTypes>(
-  element: ViewPredicate.ElementExpr<Types['Fqn']> | NonEmptyArray<ViewPredicate.ElementExpr<Types['Fqn']>>,
+const asTypedDeploymentExpression = <Types extends AnyTypes>(
+  expr: DeploymentExpression
+): TypedDeploymentExpression<Types> => {
+  return expr as TypedDeploymentExpression<Types>
+}
+
+function $deploymentExpr<Types extends AnyTypes>(
+  expr: ViewPredicate.DeploymentExpression<Types> | DeploymentExpression
+): TypedDeploymentExpression<Types> {
+  if (!isString(expr)) {
+    return expr as TypedDeploymentExpression<Types>
+  }
+  if (expr === '*') {
+    return asTypedDeploymentExpression({ wildcard: true })
+  }
+  if (expr.startsWith('->')) {
+    if (expr.endsWith('->')) {
+      return asTypedDeploymentExpression({
+        inout: $deploymentExpr(expr.replace(/->/g, '').trim()) as any
+      })
+    }
+    return asTypedDeploymentExpression({
+      incoming: $deploymentExpr(expr.replace('-> ', '')) as any
+    })
+  }
+  if (expr.endsWith(' ->')) {
+    return asTypedDeploymentExpression({
+      outgoing: $deploymentExpr(expr.replace(' ->', '')) as any
+    })
+  }
+  if (expr.includes(' <-> ')) {
+    const [source, target] = expr.split(' <-> ')
+    return asTypedDeploymentExpression({
+      source: $deploymentExpr(source) as DeploymentElementExpression,
+      target: $deploymentExpr(target) as DeploymentElementExpression,
+      isBidirectional: true
+    })
+  }
+  if (expr.includes(' -> ')) {
+    const [source, target] = expr.split(' -> ')
+    return asTypedDeploymentExpression({
+      source: $deploymentExpr(source) as DeploymentElementExpression,
+      target: $deploymentExpr(target) as DeploymentElementExpression
+    })
+  }
+  if (expr.endsWith('._')) {
+    return asTypedDeploymentExpression({
+      ref: {
+        id: expr.replace('._', '') as Fqn
+      },
+      selector: 'expanded'
+    })
+  }
+  if (expr.endsWith('.**')) {
+    return asTypedDeploymentExpression({
+      ref: {
+        id: expr.replace('.**', '') as Fqn
+      },
+      selector: 'descendants'
+    })
+  }
+  if (expr.endsWith('.*')) {
+    return asTypedDeploymentExpression({
+      ref: {
+        id: expr.replace('.*', '') as Fqn
+      },
+      selector: 'children'
+    })
+  }
+  return asTypedDeploymentExpression({
+    ref: {
+      id: expr as any as Fqn
+    }
+  })
+}
+
+function $style<B extends AViewBuilder<AnyTypes, any, any>>(
+  element: B['ElementExpr'] | NonEmptyArray<B['ElementExpr']>,
   { notation, ...style }: ViewRuleStyle['style'] & { notation?: string }
-): (b: ViewBuilder<Types>) => ViewBuilder<Types> {
+): (b: B) => B {
   return (b) =>
     b.style({
-      targets: (isArray(element) ? element : [element]).map(e => $expr(e) as C4ElementExpression),
-      ...notation ? { notation } : {},
+      targets: (isArray(element) ? element : [element]).map(e => b.$expr(e as any) as C4ElementExpression),
+      ...(notation ? { notation } : {}),
       style: {
         ...style
       }
     })
 }
 
-function $autoLayout<Types extends AnyTypes>(
+function $autoLayout<B extends AViewBuilder<AnyTypes, any, any>>(
   layout: AutoLayoutDirection
-): (b: ViewBuilder<Types>) => ViewBuilder<Types> {
+): (b: B) => B {
   return (b) => b.autoLayout(layout)
 }
 
-function $rules<T extends AnyTypes>(...rules: ViewRuleBuilderOp<T>[]): (b: ViewBuilder<T>) => ViewBuilder<T> {
+function $rules<B extends AViewBuilder<AnyTypes, any, any>>(...rules: Op<B>[]): (b: B) => B {
   return (b) => rules.reduce((b, rule) => rule(b), b)
 }
 
-export { $autoLayout, $exclude, $expr, $include, $rules, $style }
+export { $autoLayout, $exclude, $include, $rules, $style }
 
 export type ViewHelpers<T = unknown> = {
   views: typeof views
   view: AddViewHelper<T>
   viewOf: AddViewOfHelper<T>
+  deploymentView: AddDeploymentViewHelper<T>
   $include: typeof $include
   $exclude: typeof $exclude
   $style: typeof $style
   $rules: typeof $rules
   $autoLayout: typeof $autoLayout
 }
+
+export function mkViewBuilder(view: Writable<DeploymentView>): DeploymentViewBuilder<AnyTypes>
+export function mkViewBuilder(view: Writable<ElementView>): ViewBuilder<AnyTypes>
+export function mkViewBuilder(
+  view: Writable<ElementView | DeploymentView>
+): DeploymentViewBuilder<AnyTypes> | ViewBuilder<AnyTypes> {
+  const viewBuilder = {
+    $expr: view.__ === 'deployment' ? $deploymentExpr : $expr,
+    autoLayout(autoLayout: unknown) {
+      view.rules.push({
+        direction: autoLayout
+      } as any)
+      return viewBuilder
+    },
+    exclude(expr: unknown) {
+      view.rules.push({
+        exclude: [expr]
+      } as any)
+      return viewBuilder
+    },
+    include(expr: unknown) {
+      view.rules.push({
+        include: [expr]
+      } as any)
+      return viewBuilder
+    },
+    style(rule: any) {
+      view.rules.push(rule)
+      return viewBuilder
+    }
+    // title(title: string) {
+    //   view.title = title
+    //   return viewBuilder
+    // },
+    // description(description: string) {
+    //   view.description = description
+    //   return viewBuilder
+    // }
+  }
+  return viewBuilder as any
+}

package/src/builder/_types.ts

@@ -2,26 +2,32 @@ import type { IfNever, IsLiteral, Tagged, TupleToUnion } from 'type-fest'
 import type {
   BorderStyle,
   Color,
+  DeploymentNodeKindSpecification,
   ElementKindSpecification,
   ElementShape,
+  KeysOf,
+  NonEmptyArray,
   ParsedLikeC4Model,
   RelationshipArrowType,
   RelationshipKindSpecification,
   RelationshipLineType
 } from '../types'
 
-type KeysOf<T> = keyof T extends infer K extends string ? K : never
-
 export type BuilderSpecification = {
   elements: {
     [kind: string]: Partial<ElementKindSpecification>
   }
-  relationships?: Record<string, Partial<RelationshipKindSpecification>>
+  relationships?: {
+    [kind: string]: Partial<RelationshipKindSpecification>
+  }
+  deployments?: {
+    [kind: string]: Partial<DeploymentNodeKindSpecification>
+  }
   tags?: [string, ...string[]]
   metadataKeys?: [string, ...string[]]
 }
 
-type Metadata<MetadataKey extends string> = IfNever<MetadataKey, never, Record<MetadataKey, string>>
+export type Metadata<MetadataKey extends string> = IfNever<MetadataKey, never, Record<MetadataKey, string>>
 
 export type NewElementProps<Tag, Metadata> = {
   title?: string
@@ -40,6 +46,23 @@ export type NewElementProps<Tag, Metadata> = {
   }
 }
 
+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
+  }
+}
+
 export type NewViewProps<Tag> = {
   title?: string
   description?: string
@@ -58,7 +81,7 @@ export type NewRelationProps<Kind, Tag, Metadata> = {
   tail?: RelationshipArrowType
   line?: RelationshipLineType
   color?: Color
-  links?: Array<string | { title?: string; url: string }>
+  links?: NonEmptyArray<string | { title?: string; url: string }>
 }
 
 export type Invalid<Message extends string> = Tagged<Message, 'Error'>
@@ -74,7 +97,9 @@ export interface Types<
   ViewId extends string,
   RelationshipKind extends string,
   Tag extends string,
-  MetadataKey extends string
+  MetadataKey extends string,
+  DeploymentKind extends string,
+  DeploymentFqn extends string
 > {
   ElementKind: ElementKind
   Fqn: Fqn
@@ -82,6 +107,8 @@ export interface Types<
   RelationshipKind: RelationshipKind
   Tag: Tag
   MetadataKey: MetadataKey
+  DeploymentKind: DeploymentKind
+  DeploymentFqn: DeploymentFqn
 
   Tags: IfNever<Tag, never, [Tag, ...Tag[]]>
   // Metadata: Metadata<MetadataKey>
@@ -89,6 +116,8 @@ export interface Types<
   NewElementProps: NewElementProps<Tag, Metadata<MetadataKey>>
   NewRelationshipProps: NewRelationProps<RelationshipKind, Tag, Metadata<MetadataKey>>
   NewViewProps: NewViewProps<Tag>
+
+  NewDeploymentNodeProps: NewDeploymentNodeProps<Tag, Metadata<MetadataKey>>
 }
 
 /**
@@ -101,7 +130,9 @@ export interface TypesNested<
   ViewId extends string,
   RelationshipKind extends string,
   Tag extends string,
-  MetadataKey extends string
+  MetadataKey extends string,
+  DeploymentKind extends string,
+  DeploymentFqn extends string
 > extends
   Types<
     ElementKind,
@@ -109,7 +140,9 @@ export interface TypesNested<
     ViewId,
     RelationshipKind,
     Tag,
-    MetadataKey
+    MetadataKey,
+    DeploymentKind,
+    DeploymentFqn
   >
 {
   Parent: Parent
@@ -121,6 +154,8 @@ export type AnyTypes = Types<
   any,
   any,
   any,
+  any,
+  any,
   any
 >
 
@@ -131,6 +166,8 @@ export type AnyTypesNested = TypesNested<
   any,
   any,
   any,
+  any,
+  any,
   any
 >
 
@@ -141,18 +178,23 @@ export namespace Types {
       never,
       KeysOf<Spec['relationships']>,
       TupleToUnion<Spec['tags']>,
-      TupleToUnion<Spec['metadataKeys']>
+      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> ? TypesNested<
+  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['MetadataKey'],
+      T['DeploymentKind'],
+      T['DeploymentFqn']
     >
     : T extends AnyTypes ? Types<
         T['ElementKind'],
@@ -160,11 +202,37 @@ export namespace Types {
         T['ViewId'],
         T['RelationshipKind'],
         T['Tag'],
-        T['MetadataKey']
+        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>
+  export type AddView<T, Id extends string> = T extends TypesNested<infer P, any, any, any, any, any, any, any, any>
     ? TypesNested<
       P,
       T['ElementKind'],
@@ -172,7 +240,9 @@ export namespace Types {
       Id | T['ViewId'],
       T['RelationshipKind'],
       T['Tag'],
-      T['MetadataKey']
+      T['MetadataKey'],
+      T['DeploymentKind'],
+      T['DeploymentFqn']
     >
     : T extends AnyTypes ? Types<
         T['ElementKind'],
@@ -180,7 +250,9 @@ export namespace Types {
         Id | T['ViewId'],
         T['RelationshipKind'],
         T['Tag'],
-        T['MetadataKey']
+        T['MetadataKey'],
+        T['DeploymentKind'],
+        T['DeploymentFqn']
       >
     : never