@likec4/core 1.18.0 → 1.19.0

package/src/compute-view/element-view/__test__/fixture.ts

@@ -1,19 +1,19 @@
-import { forEach, indexBy, isString, map, mapToObj, prop, values } from 'remeda'
+import { indexBy, isString, map, prop } from 'remeda'
+import { LikeC4Model } from '../../../model'
 import {
   type BorderStyle,
   type Color,
   type ComputedView,
   type CustomElementExpr as C4CustomElementExpr,
   type CustomRelationExpr as C4CustomRelationExpr,
-  type EdgeId,
   type Element,
   type ElementExpression as C4ElementExpression,
   type ElementKind,
   type ElementShape,
-  type ElementView,
   type ElementWhereExpr,
   type Expression as C4Expression,
   type Fqn,
+  type GlobalPredicateId,
   type GlobalStyleID,
   type IconUrl,
   type IncomingExpr as C4IncomingExpr,
@@ -22,10 +22,9 @@ import {
   isElementWhere,
   isRelationExpression,
   isRelationWhere,
+  type ModelRelation,
   type NonEmptyArray,
   type OutgoingExpr as C4OutgoingExpr,
-  type Relation,
-  type RelationExpr as C4RelationExpr,
   type RelationId,
   type RelationshipArrowType,
   type RelationshipLineType,
@@ -33,19 +32,16 @@ import {
   type Tag,
   type ViewId,
   type ViewRule,
+  type ViewRuleGlobalPredicateRef,
   type ViewRuleGlobalStyle,
   type ViewRuleGroup,
   type ViewRulePredicate,
   type ViewRuleStyle,
-  type WhereOperator
+  type WhereOperator,
 } from '../../../types'
-import { LikeC4ModelGraph } from '../../LikeC4ModelGraph'
+import { type DirectRelationExpr as C4RelationExpr } from '../../../types/expression'
 import { withReadableEdges } from '../../utils/with-readable-edges'
-import { ComputeCtx } from '../compute'
-
-function computeElementView(view: ElementView, graph: LikeC4ModelGraph) {
-  return ComputeCtx.elementView(view, graph)
-}
+import { computeElementView } from '../compute'
 
 /**
               ┌──────────────────────────────────────────────────┐
@@ -149,9 +145,9 @@ const el = ({
   tags: tags as NonEmptyArray<Tag> ?? null,
   links: null,
   style: {
-    ...style
+    ...style,
   },
-  ...props
+  ...props,
 })
 
 export const fakeElements = {
@@ -159,68 +155,68 @@ export const fakeElements = {
     id: 'customer',
     kind: 'actor',
     title: 'customer',
-    shape: 'person'
+    shape: 'person',
   }),
   'support': el({
     id: 'support',
     kind: 'actor',
     title: 'support',
-    shape: 'person'
+    shape: 'person',
   }),
   'cloud': el({
     id: 'cloud',
     kind: 'system',
     title: 'cloud',
     icon: 'none',
-    tags: ['next', 'old']
+    tags: ['next', 'old'],
   }),
   'cloud.backend': el({
     id: 'cloud.backend',
     kind: 'container',
-    title: 'backend'
+    title: 'backend',
   }),
   'cloud.frontend': el({
     id: 'cloud.frontend',
     kind: 'container',
     title: 'frontend',
-    shape: 'browser'
+    shape: 'browser',
   }),
   'cloud.backend.graphql': el({
     id: 'cloud.backend.graphql',
     kind: 'component',
     icon: 'tech:graphql' as IconUrl,
-    title: 'graphql'
+    title: 'graphql',
   }),
   'email': el({
     id: 'email',
     kind: 'system',
-    title: 'email'
+    title: 'email',
   }),
   'cloud.backend.storage': el({
     id: 'cloud.backend.storage',
     kind: 'component',
     title: 'storage',
-    tags: ['storage', 'old']
-  }),
-  'cloud.frontend.adminPanel': el({
-    id: 'cloud.frontend.adminPanel',
-    kind: 'component',
-    title: 'adminPanel',
-    tags: ['old']
+    tags: ['storage', 'old'],
   }),
   'cloud.frontend.dashboard': el({
     id: 'cloud.frontend.dashboard',
     kind: 'component',
     title: 'dashboard',
     icon: 'tech:react' as IconUrl,
-    tags: ['next']
+    tags: ['next'],
+  }),
+  'cloud.frontend.supportPanel': el({
+    id: 'cloud.frontend.supportPanel',
+    kind: 'component',
+    title: 'adminPanel',
+    tags: ['old'],
   }),
   'amazon': el({
     id: 'amazon',
     kind: 'system',
     title: 'amazon',
     icon: 'tech:aws' as IconUrl,
-    tags: ['aws']
+    tags: ['aws'],
   }),
   'amazon.s3': el({
     id: 'amazon.s3',
@@ -228,8 +224,8 @@ export const fakeElements = {
     title: 's3',
     shape: 'storage',
     icon: 'aws:s3' as IconUrl,
-    tags: ['aws', 'storage']
-  })
+    tags: ['aws', 'storage'],
+  }),
 } satisfies Record<string, Element>
 
 export type FakeElementIds = keyof typeof fakeElements
@@ -255,51 +251,41 @@ const rel = <Source extends FakeElementIds, Target extends FakeElementIds>({
     title: title ?? '',
     source: source as Fqn,
     target: target as Fqn,
-    ...(props as any)
-  }) as Omit<Relation, 'id'> & { id: `${Source}:${Target}` }
+    ...(props as any),
+  }) as Omit<ModelRelation, 'id'> & { id: `${Source}:${Target}` }
 
 export const fakeRelations = [
   rel({
     source: 'customer',
     target: 'cloud.frontend.dashboard',
-    title: 'opens in browser'
+    title: 'opens in browser',
   }),
   rel({
     source: 'support',
-    target: 'cloud.frontend.adminPanel',
-    title: 'manages'
+    target: 'cloud.frontend.supportPanel',
+    title: 'manages',
   }),
   rel({
     source: 'cloud.backend.storage',
     target: 'amazon.s3',
     title: 'uploads',
-    tags: ['aws', 'storage', 'legacy']
+    tags: ['aws', 'storage', 'legacy'],
   }),
   rel({
     source: 'customer',
     target: 'cloud',
-    title: 'uses'
+    title: 'uses',
   }),
   rel({
     source: 'cloud.backend.graphql',
     target: 'cloud.backend.storage',
     title: 'stores',
-    tags: ['old', 'storage']
+    tags: ['old', 'storage'],
   }),
-  // rel({
-  //   source: 'cloud.backend',
-  //   target: 'cloud.email',
-  //   title: 'schedule emails'
-  // }),
-  // rel({
-  //   source: 'cloud.email',
-  //   target: 'customer',
-  //   title: 'send emails'
-  // }),
   rel({
     source: 'cloud.frontend',
     target: 'cloud.backend',
-    title: 'requests'
+    title: 'requests',
   }),
   rel({
     source: 'cloud.frontend.dashboard',
@@ -307,16 +293,16 @@ export const fakeRelations = [
     kind: 'graphlql',
     title: 'requests',
     line: 'solid',
-    tags: ['next']
+    tags: ['next'],
   }),
   rel({
-    source: 'cloud.frontend.adminPanel',
+    source: 'cloud.frontend.supportPanel',
     target: 'cloud.backend.graphql',
     kind: 'graphlql',
     title: 'fetches',
     line: 'dashed',
     tail: 'odiamond',
-    tags: ['old']
+    tags: ['old'],
   }),
   rel({
     source: 'cloud',
@@ -324,60 +310,92 @@ export const fakeRelations = [
     title: 'uses',
     head: 'diamond',
     tail: 'odiamond',
-    tags: ['aws']
+    tags: ['aws'],
   }),
   rel({
     source: 'cloud.backend',
     target: 'email',
     title: 'schedule',
-    tags: ['communication']
+    tags: ['communication'],
   }),
   rel({
     source: 'cloud',
     target: 'email',
     title: 'uses',
-    tags: ['communication']
+    tags: ['communication'],
   }),
   rel({
     source: 'email',
     target: 'cloud',
     title: 'notifies',
-    tags: ['communication']
-  })
+    tags: ['communication'],
+  }),
 ]
 
 export const globalStyles = {
   'mute_old': [{
     targets: [$expr({
       elementTag: 'old' as Tag,
-      isEqual: true
+      isEqual: true,
     })],
     style: {
-      color: 'muted'
-    }
+      color: 'muted',
+    },
   }],
   'red_next': [{
     targets: [$expr({
       elementTag: 'next' as Tag,
-      isEqual: true
+      isEqual: true,
     })],
     style: {
-      color: 'red'
-    }
-  }]
+      color: 'red',
+    },
+  }],
 } as const
 
 export type FakeRelationIds = (typeof fakeRelations)[number]['id']
-
-export const fakeModel = new LikeC4ModelGraph({
+const fakeParsedModel = {
   elements: fakeElements,
   relations: indexBy(fakeRelations, r => r.id),
+  deployments: {
+    elements: {},
+    relations: {},
+  },
+  views: {},
   globals: {
-    predicates: {},
+    predicates: {
+      'remove_tag_old': [
+        $exclude('*', {
+          tag: { eq: 'old' },
+        }),
+      ],
+      'remove_not_tag_old': [
+        $exclude('*', {
+          tag: { neq: 'old' },
+        }),
+      ],
+      'include_next': [
+        $include('* -> *', {
+          where: {
+            and: [
+              {
+                or: [
+                  { tag: { eq: 'communication' } },
+                  { tag: { eq: 'next' } },
+                  { tag: { eq: 'old' } },
+                ],
+              },
+              { tag: { neq: 'storage' } },
+            ],
+          },
+        }),
+      ],
+    } satisfies Record<string, NonEmptyArray<ViewRulePredicate>>,
     dynamicPredicates: {},
-    styles: globalStyles
-  }
-})
+    styles: globalStyles,
+  },
+} as const
+export const fakeModel = LikeC4Model.fromDump(fakeParsedModel)
 
 const emptyView = {
   __: 'element' as const,
@@ -387,18 +405,23 @@ const emptyView = {
   tags: null,
   links: null,
   customColorDefinitions: {},
-  rules: []
+  rules: [],
 }
 
 export const includeWildcard = {
   include: [
     {
-      wildcard: true
-    }
-  ]
+      wildcard: true,
+    },
+  ],
 } satisfies ViewRule
 
-export type ElementRefExpr = '*' | FakeElementIds | `${FakeElementIds}.*` | `${FakeElementIds}._`
+export type ElementRefExpr =
+  | '*'
+  | FakeElementIds
+  | `${FakeElementIds}.*`
+  | `${FakeElementIds}.**`
+  | `${FakeElementIds}._`
 
 type InOutExpr = `-> ${ElementRefExpr} ->`
 type IncomingExpr = `-> ${ElementRefExpr}`
@@ -425,42 +448,42 @@ export function $custom(
     icon?: string
     opacity?: number
     navigateTo?: string
-  }
+  },
 ): C4CustomElementExpr {
   return {
     custom: {
       expr: $expr(expr) as any,
-      ...props as any
-    }
+      ...props as any,
+    },
   }
 }
 
 export function $customRelation(
   relation: RelationExpr,
-  props: Omit<C4CustomRelationExpr['customRelation'], 'relation'>
+  props: Omit<C4CustomRelationExpr['customRelation'], 'relation'>,
 ): C4CustomRelationExpr {
   return {
     customRelation: {
       relation: $expr(relation) as any,
-      ...props
-    }
+      ...props,
+    },
   }
 }
 
 export function $where(
   expr: Expression | C4Expression,
-  operator: WhereOperator<TestTag, string>
+  operator: WhereOperator<TestTag, string>,
 ): ElementWhereExpr | RelationWhereExpr {
   return {
     where: {
       expr: $expr(expr) as any,
-      condition: operator
-    }
+      condition: operator,
+    },
   }
 }
 
 export function $inout(
-  expr: InOutExpr | C4ElementExpression
+  expr: InOutExpr | C4ElementExpression,
 ): C4InOutExpr {
   const innerExpression = !isString(expr)
     ? expr as C4Expression
@@ -470,7 +493,7 @@ export function $inout(
 }
 
 export function $incoming(
-  expr: IncomingExpr | C4ElementExpression
+  expr: IncomingExpr | C4ElementExpression,
 ): C4IncomingExpr {
   const innerExpression = !isString(expr)
     ? expr as C4Expression
@@ -480,7 +503,7 @@ export function $incoming(
 }
 
 export function $outgoing(
-  expr: OutgoingExpr | C4ElementExpression
+  expr: OutgoingExpr | C4ElementExpression,
 ): C4OutgoingExpr {
   const innerExpression = !isString(expr)
     ? expr as C4Expression
@@ -490,7 +513,7 @@ export function $outgoing(
 }
 
 export function $relation(
-  expr: RelationExpr
+  expr: RelationExpr,
 ): C4RelationExpr {
   const [source, target] = expr.split(/ -> | <-> /)
   const isBidirectional = expr.includes(' <-> ')
@@ -498,7 +521,7 @@ export function $relation(
   return {
     source: $expr(source as ElementRefExpr) as any,
     target: $expr(target as ElementRefExpr) as any,
-    ...(isBidirectional && { isBidirectional })
+    ...(isBidirectional && { isBidirectional }),
   }
 }
 
@@ -520,23 +543,23 @@ export function $expr(expr: Expression | C4Expression): C4Expression {
   }
   if (expr.endsWith('._')) {
     return {
-      expanded: expr.replace('._', '') as Fqn
+      expanded: expr.replace('._', '') as Fqn,
     }
   }
   if (expr.endsWith('.*')) {
     return {
       element: expr.replace('.*', '') as Fqn,
-      isChildren: true
+      isChildren: true,
     }
   }
   if (expr.endsWith('.**')) {
     return {
-      element: expr.replace('.*', '') as Fqn,
-      isDescendants: true
+      element: expr.replace('.**', '') as Fqn,
+      isDescendants: true,
     }
   }
   return {
-    element: expr as Fqn
+    element: expr as Fqn,
   }
 }
 
@@ -558,7 +581,7 @@ export function $include(expr: Expression | C4Expression, props?: CustomProps):
   let _expr = props?.where ? $where(expr, props.where) : $expr(expr)
   _expr = props?.with ? $with(_expr, props.with) : _expr
   return {
-    include: [_expr]
+    include: [_expr],
   }
 }
 export function $with(expr: C4Expression, props?: CustomProps['with']): C4CustomRelationExpr | C4CustomElementExpr {
@@ -566,15 +589,15 @@ export function $with(expr: C4Expression, props?: CustomProps['with']): C4Custom
     return {
       customRelation: {
         relation: expr,
-        ...props as any
-      }
+        ...props as any,
+      },
     }
   } else if (isElementRef(expr) || isElementWhere(expr)) {
     return {
       custom: {
         expr: expr,
-        ...props as any
-      }
+        ...props as any,
+      },
     }
   }
 
@@ -583,33 +606,40 @@ export function $with(expr: C4Expression, props?: CustomProps['with']): C4Custom
 export function $exclude(expr: Expression | C4Expression, where?: WhereOperator<TestTag, string>): ViewRulePredicate {
   let _expr = where ? $where(expr, where) : $expr(expr)
   return {
-    exclude: [_expr]
+    exclude: [_expr],
   }
 }
 export function $group(groupRules: ViewRuleGroup['groupRules']): ViewRuleGroup {
   return {
     title: null,
-    groupRules
+    groupRules,
   }
 }
 
 export function $style(element: ElementRefExpr, style: ViewRuleStyle['style']): ViewRuleStyle {
   return {
     targets: [$expr(element) as C4ElementExpression],
-    style: Object.assign({}, style)
+    style: Object.assign({}, style),
   }
 }
 
-type GlobalStyles = keyof typeof globalStyles
-type GlobalExpr = `style ${GlobalStyles}`
-export function $global(expr: GlobalExpr): ViewRuleGlobalStyle {
+type GlobalStyles = `style ${keyof typeof globalStyles}`
+type GlobalPredicate = `predicate ${keyof typeof fakeParsedModel.globals.predicates}`
+type GlobalExpr = GlobalStyles | GlobalPredicate
+export function $global(expr: GlobalExpr): ViewRuleGlobalStyle | ViewRuleGlobalPredicateRef {
   const [_t, id] = expr.split(' ') as [string, string]
-  if (_t === 'style') {
-    return {
-      styleId: id as GlobalStyleID
-    }
+  switch (_t) {
+    case 'predicate':
+      return {
+        predicateId: id as GlobalPredicateId,
+      }
+    case 'style':
+      return {
+        styleId: id as GlobalStyleID,
+      }
+    default:
+      throw new Error(`Invalid global expression: ${expr}`)
   }
-  throw new Error('Invalid global expression')
 }
 
 export function computeView(
@@ -618,21 +648,21 @@ export function computeView(
   let result: ComputedView
   if (args.length === 1) {
     result = computeElementView(
+      fakeModel,
       {
         ...emptyView,
-        rules: [args[0]].flat()
+        rules: [args[0]].flat(),
       },
-      fakeModel
     )
   } else {
     result = computeElementView(
+      fakeModel,
       {
         ...emptyView,
         id: 'index' as ViewId,
         viewOf: args[0] as Fqn,
-        rules: [args[1]].flat()
+        rules: [args[1]].flat(),
       },
-      fakeModel
     )
   }
 
@@ -640,6 +670,6 @@ export function computeView(
 
   return Object.assign(result, {
     nodeIds: map(result.nodes, prop('id')) as string[],
-    edgeIds: map(result.edges, prop('id')) as string[]
+    edgeIds: map(result.edges, prop('id')) as string[],
   })
 }

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

@@ -0,0 +1,48 @@
+import { type LikeC4Model } from '../../model'
+import type { ConnectionModel } from '../../model/connection/model'
+import type { RelationshipModel } from '../../model/RelationModel'
+import type { AnyAux } from '../../model/types'
+import type { ElementExpression, Expression, RelationExpression } from '../../types/expression'
+
+import type { Ctx, Memory, Stage, StageExclude, StageInclude } 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>
+export type ConnectionWhereFilter = (connections: readonly Connection[]) => Connection[]
+
+export { Memory } from './memory'
+
+export type Connections = ReadonlyArray<ConnectionModel<AnyAux>>
+
+export interface PredicateCtx<Expr extends Expression = Expression> {
+  expr: Expr
+  stage: Stage
+  // View scope
+  scope: Elem | null
+  model: LikeC4Model<AnyAux>
+  memory: Memory
+  where: Expr extends RelationExpression ? RelationshipWhere
+    : Expr extends ElementExpression ? ElementWhere
+    : never
+  filterWhere: Expr extends RelationExpression ? ConnectionWhereFilter
+    : Expr extends ElementExpression ? ElementWhereFilter
+    : never
+}
+export interface IncludePredicateCtx<Expr extends Expression = Expression> extends PredicateCtx<Expr> {
+  stage: StageInclude
+}
+export interface ExcludePredicateCtx<Expr extends Expression = Expression> extends PredicateCtx<Expr> {
+  stage: StageExclude
+}
+
+export interface PredicateExecutor<Expr extends Expression> {
+  include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
+  exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
+}