@likec4/core 1.27.2 → 1.28.0

package/src/builder/Builder.view-element.ts

@@ -1,11 +1,12 @@
 import { isString } from 'remeda'
 import type { IsStringLiteral } from 'type-fest/source/is-literal'
-import { type Expression as C4Expression, type Fqn } from '../types'
+import { type ExpressionV2 } from '../types/expression-v2'
+import { type Fqn } from '../types/scalars'
 import type { AnyTypes, Invalid, Types } from './_types'
 import type { LikeC4ViewBuilder, ViewPredicate } from './Builder.view-common'
 import type { ViewsBuilder } from './Builder.views'
 
-export interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], C4Expression> {
+export interface ElementViewBuilder<T extends AnyTypes> extends LikeC4ViewBuilder<T, T['Fqn'], Types.ToExpression<T>> {
 }
 
 export type ElementViewRulesBuilder<T extends AnyTypes> = (b: ElementViewBuilder<T>) => ElementViewBuilder<T>
@@ -125,13 +126,15 @@ export interface TypedAddViewOfHelper<A extends AnyTypes> {
   }
 }
 // To hook types
-const asTypedExpr = (expr: C4Expression): C4Expression => {
-  return expr as C4Expression
+const asTypedExpr = (expr: ExpressionV2): ExpressionV2 => {
+  return expr as ExpressionV2
 }
 
-export function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Types> | C4Expression): C4Expression {
+export function $expr<Types extends AnyTypes>(
+  expr: ViewPredicate.Expression<Types> | ExpressionV2,
+): ExpressionV2 {
   if (!isString(expr)) {
-    return expr as C4Expression
+    return expr as ExpressionV2
   }
   if (expr === '*') {
     return asTypedExpr({ wildcard: true })
@@ -168,22 +171,31 @@ export function $expr<Types extends AnyTypes>(expr: ViewPredicate.Expression<Typ
   }
   if (expr.endsWith('._')) {
     return asTypedExpr({
-      expanded: expr.replace('._', '') as Fqn,
+      ref: {
+        model: expr.replace('._', '') as Fqn,
+      },
+      selector: 'expanded',
     })
   }
-  if (expr.endsWith('.*')) {
+  if (expr.endsWith('.**')) {
     return asTypedExpr({
-      element: expr.replace('.*', '') as Fqn,
-      isChildren: true,
+      ref: {
+        model: expr.replace('.**', '') as Fqn,
+      },
+      selector: 'descendants',
     })
   }
-  if (expr.endsWith('.**')) {
+  if (expr.endsWith('.*')) {
     return asTypedExpr({
-      element: expr.replace('.**', '') as Fqn,
-      isDescendants: true,
+      ref: {
+        model: expr.replace('.*', '') as Fqn,
+      },
+      selector: 'children',
     })
   }
   return asTypedExpr({
-    element: expr as any as Fqn,
+    ref: {
+      model: expr as any as Fqn,
+    },
   })
 }

package/src/builder/__snapshots__/Builder-style1.spec.ts.snap

@@ -99,6 +99,7 @@ exports[`Builder (style1) > should build nested elements and relTo 1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {
     "rel1": {
       "id": "rel1",
@@ -192,6 +193,7 @@ exports[`Builder (style1) > should build view  1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {},
   "specification": {
     "deployments": {},
@@ -237,8 +239,10 @@ exports[`Builder (style1) > should build view  1`] = `
         {
           "include": [
             {
-              "element": "c2",
-              "isChildren": true,
+              "ref": {
+                "model": "c2",
+              },
+              "selector": "children",
             },
           ],
         },
@@ -256,7 +260,10 @@ exports[`Builder (style1) > should build view  1`] = `
         {
           "include": [
             {
-              "expanded": "c3",
+              "ref": {
+                "model": "c3",
+              },
+              "selector": "expanded",
             },
           ],
         },
@@ -329,6 +336,7 @@ exports[`Builder (style1) > should build viewOf  1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {},
   "specification": {
     "deployments": {},
@@ -357,8 +365,10 @@ exports[`Builder (style1) > should build viewOf  1`] = `
           "include": [
             {
               "inout": {
-                "element": "c2.c3",
-                "isChildren": true,
+                "ref": {
+                  "model": "c2.c3",
+                },
+                "selector": "children",
               },
             },
           ],
@@ -367,11 +377,16 @@ exports[`Builder (style1) > should build viewOf  1`] = `
           "exclude": [
             {
               "source": {
-                "expanded": "c1",
+                "ref": {
+                  "model": "c1",
+                },
+                "selector": "expanded",
               },
               "target": {
-                "element": "c2.c3",
-                "isChildren": true,
+                "ref": {
+                  "model": "c2.c3",
+                },
+                "selector": "children",
               },
             },
           ],

package/src/builder/__snapshots__/Builder-style2.spec.ts.snap

@@ -105,6 +105,7 @@ exports[`Builder (style 2) > should build  1`] = `
     "predicates": {},
     "styles": {},
   },
+  "imports": {},
   "relations": {},
   "specification": {
     "deployments": {
@@ -143,8 +144,10 @@ exports[`Builder (style 2) > should build  1`] = `
                 "wildcard": true,
               },
               "target": {
-                "element": "cloud",
-                "isDescendants": true,
+                "ref": {
+                  "model": "cloud",
+                },
+                "selector": "descendants",
               },
             },
           ],
@@ -185,8 +188,10 @@ exports[`Builder (style 2) > should build  1`] = `
         {
           "include": [
             {
-              "element": "cloud",
-              "isChildren": true,
+              "ref": {
+                "model": "cloud",
+              },
+              "selector": "children",
             },
           ],
         },

package/src/compute-view/deployment-view/predicates/deploymentRefs-where.ts

@@ -0,0 +1,18 @@
+import { type FqnExpr, type RelationExpr, whereOperatorAsPredicate } from '../../../types'
+import type { PredicateExecutor } from '../_types'
+import type { StageExclude, StageInclude } from '../memory'
+import { predicateToPatch } from './utils'
+
+// relation matches the condition
+export const WhereDeploymentRefPredicate: PredicateExecutor<FqnExpr.Where> = {
+  include: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition)
+
+    return predicateToPatch('include', { expr: expr.where.expr, model, stage, memory, where }) as StageInclude
+  },
+  exclude: ({ expr, model, memory, stage }) => {
+    const where = whereOperatorAsPredicate(expr.where.condition)
+
+    return predicateToPatch('exclude', { expr: expr.where.expr, model, stage, memory, where }) as StageExclude
+  },
+}

package/src/compute-view/deployment-view/predicates/relation-direct.ts

@@ -40,6 +40,12 @@ const resolveWildcard = (model: LikeC4DeploymentModel, nonWildcard: FqnExpr.Depl
 
 export const DirectRelationPredicate: PredicateExecutor<RelationExpr.Direct> = {
   include: ({ expr: { source, target, isBidirectional = false }, model, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(source) || FqnExpr.isElementKindExpr(source)) {
+      throw new Error('element kind and tag expressions are not supported in include')
+    }
+    if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) {
+      throw new Error('element kind and tag expressions are not supported in include')
+    }
     invariant(!FqnExpr.isModelRef(source), 'Invalid source model ref in direct relation')
     invariant(!FqnExpr.isModelRef(target), 'Invalid target model ref in direct relation')
     const sourceIsWildcard = FqnExpr.isWildcard(source)

package/src/compute-view/deployment-view/predicates/relation-in-out.ts

@@ -36,6 +36,9 @@ export const InOutRelationPredicate: PredicateExecutor<RelationExpr.InOut> = {
     return stage
   },
   exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(expr.inout) || FqnExpr.isElementKindExpr(expr.inout)) {
+      throw new Error('element kind and tag expressions are not supported in exclude')
+    }
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.inout)) {
       const elements = resolveModelElements(model, expr.inout)

package/src/compute-view/deployment-view/predicates/relation-incoming.ts

@@ -38,6 +38,9 @@ export const IncomingRelationPredicate: PredicateExecutor<RelationExpr.Incoming>
     return stage
   },
   exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(expr.incoming) || FqnExpr.isElementKindExpr(expr.incoming)) {
+      throw new Error('element kind and tag expressions are not supported in exclude')
+    }
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.incoming)) {
       const excludedRelations = resolveAllImcomingRelations(model, expr.incoming)

package/src/compute-view/deployment-view/predicates/relation-outgoing.ts

@@ -39,6 +39,9 @@ export const OutgoingRelationPredicate: PredicateExecutor<RelationExpr.Outgoing>
     return stage
   },
   exclude: ({ expr, model, memory, stage, where }) => {
+    if (FqnExpr.isElementTagExpr(expr.outgoing) || FqnExpr.isElementKindExpr(expr.outgoing)) {
+      throw new Error('element kind and tag expressions are not supported in exclude')
+    }
     // Exclude all connections that have model relationshps with the elements
     if (FqnExpr.isModelRef(expr.outgoing)) {
       const excludedRelations = resolveAllOutgoingRelations(model, expr.outgoing)

package/src/compute-view/deployment-view/predicates/utils.ts

@@ -15,6 +15,7 @@ import { hasIntersection, intersection } from '../../../utils/set'
 import type { ExcludePredicateCtx, PredicateCtx } from '../_types'
 import type { StageExclude, StageInclude } from '../memory'
 import { DeploymentRefPredicate } from './deploymentRefs'
+import { WhereDeploymentRefPredicate } from './deploymentRefs-where'
 import { DirectRelationPredicate } from './relation-direct'
 import { InOutRelationPredicate } from './relation-in-out'
 import { IncomingRelationPredicate } from './relation-incoming'
@@ -30,14 +31,22 @@ export function predicateToPatch(
   { expr, where, ...ctx }: PredicateCtx,
 ): StageExclude | StageInclude | undefined {
   switch (true) {
+    case FqnExpr.isElementTagExpr(expr):
+    case FqnExpr.isElementKindExpr(expr):
+      throw new Error('element kind and tag expressions are not supported in deployment view rules')
+    case RelationExpr.isCustom(expr):
+    case FqnExpr.isCustom(expr):
     case FqnExpr.isModelRef(expr):
       // Ignore model refs in deployment view
       return undefined
+    case FqnExpr.isWhere(expr):
+      return WhereDeploymentRefPredicate[op]({ ...ctx, expr, where } as any)
+    case RelationExpr.isWhere(expr):
+      return WhereRelationPredicate[op]({ ...ctx, expr, where } as any)
     case FqnExpr.isDeploymentRef(expr):
       return DeploymentRefPredicate[op]({ ...ctx, expr, where } as any)
     case FqnExpr.isWildcard(expr):
       return WildcardPredicate[op]({ ...ctx, expr, where } as any)
-
     case RelationExpr.isDirect(expr):
       return DirectRelationPredicate[op]({ ...ctx, expr, where } as any)
     case RelationExpr.isInOut(expr):
@@ -46,8 +55,6 @@ export function predicateToPatch(
       return OutgoingRelationPredicate[op]({ ...ctx, expr, where } as any)
     case RelationExpr.isIncoming(expr):
       return IncomingRelationPredicate[op]({ ...ctx, expr, where } as any)
-    case RelationExpr.isWhere(expr):
-      return WhereRelationPredicate[op]({ ...ctx, expr, where } as any)
     default:
       nonexhaustive(expr)
   }

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

@@ -7,18 +7,18 @@ import type { AnyAux } from '../../model/types'
 import {
   type ComputedEdge,
   type ComputedNode,
-  DefaultArrowType,
   type DeploymentNodeKind,
   type DeploymentViewRule,
   type Fqn,
-  FqnExpr,
-  isViewRuleStyle,
   type NonEmptyArray,
   type Tag,
+  DefaultArrowType,
+  FqnExpr,
+  isViewRuleStyle,
 } from '../../types'
 import { nameFromFqn, parentFqn } from '../../utils'
 import { applyViewRuleStyle } from '../utils/applyViewRuleStyles'
-import { buildComputedNodes, type ComputedNodeSource } from '../utils/buildComputedNodes'
+import { type ComputedNodeSource, buildComputedNodes } from '../utils/buildComputedNodes'
 import { mergePropsFromRelationships } from '../utils/merge-props-from-relationships'
 import { uniqueTags } from '../utils/uniqueTags'
 import type { Elem, Memory } from './_types'
@@ -67,6 +67,9 @@ export function deploymentExpressionToPredicate<T extends { id: string; modelRef
   if (FqnExpr.isWildcard(target)) {
     return () => true
   }
+  if (FqnExpr.isElementTagExpr(target) || FqnExpr.isElementKindExpr(target)) {
+    throw new Error('element kind and tag expressions are not supported in deployment view rules')
+  }
   if (FqnExpr.isDeploymentRef(target)) {
     const fqn = target.ref.deployment
     if (target.selector === 'expanded') {

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

@@ -4,28 +4,19 @@ import {
   type BorderStyle,
   type Color,
   type ComputedView,
-  type CustomElementExpr as C4CustomElementExpr,
-  type CustomRelationExpr as C4CustomRelationExpr,
   type Element,
-  type ElementExpression as C4ElementExpression,
   type ElementKind,
   type ElementShape,
-  type ElementWhereExpr,
-  type Expression as C4Expression,
   type Fqn,
   type GlobalPredicateId,
   type GlobalStyleID,
   type IconUrl,
-  type IncomingExpr as C4IncomingExpr,
-  type InOutExpr as C4InOutExpr,
   type KindEqual,
   type ModelRelation,
   type NonEmptyArray,
-  type OutgoingExpr as C4OutgoingExpr,
   type RelationId,
   type RelationshipArrowType,
   type RelationshipLineType,
-  type RelationWhereExpr,
   type Tag,
   type TagEqual,
   type ViewId,
@@ -36,12 +27,8 @@ import {
   type ViewRulePredicate,
   type ViewRuleStyle,
   type WhereOperator,
-  isElementRef,
-  isElementWhere,
-  isRelationExpression,
-  isRelationWhere,
+  ModelLayer,
 } from '../../../types'
-import { type DirectRelationExpr as C4RelationExpr } from '../../../types/expression'
 import type { Participant } from '../../../types/operators'
 import { withReadableEdges } from '../../utils/with-readable-edges'
 import { computeElementView } from '../compute'
@@ -365,6 +352,7 @@ const fakeParsedModel = {
     relations: {},
   },
   views: {},
+  imports: {},
   globals: {
     predicates: {
       'remove_tag_old': [
@@ -441,19 +429,8 @@ export type Expression =
 
 export function $custom(
   expr: ElementRefExpr,
-  props: {
-    title?: string
-    description?: string
-    technology?: string
-    shape?: ElementShape
-    color?: Color
-    border?: BorderStyle
-    icon?: string
-    opacity?: number
-    navigateTo?: string
-    multiple?: boolean
-  },
-): C4CustomElementExpr {
+  props: Omit<ModelLayer.FqnExpr.Custom['custom'], 'expr'>,
+): ModelLayer.FqnExpr.Custom {
   return {
     custom: {
       expr: $expr(expr) as any,
@@ -463,21 +440,33 @@ export function $custom(
 }
 
 export function $customRelation(
-  relation: RelationExpr,
-  props: Omit<C4CustomRelationExpr['customRelation'], 'relation'>,
-): C4CustomRelationExpr {
+  relation: ModelLayer.RelationExprOrWhere,
+  props: Omit<ModelLayer.RelationExpr.Custom['customRelation'], 'expr'>,
+): ModelLayer.RelationExpr.Custom {
   return {
     customRelation: {
-      relation: $expr(relation) as any,
+      expr: $expr(relation) as any,
       ...props,
     },
   }
 }
 
 export function $where(
-  expr: Expression | C4Expression,
+  expr: Expression,
   operator: WhereOperator<TestTag, string>,
-): ElementWhereExpr | RelationWhereExpr {
+): ModelLayer.Expression.Where
+export function $where(
+  expr: ModelLayer.RelationExpr,
+  operator: WhereOperator<TestTag, string>,
+): ModelLayer.RelationExpr.Where
+export function $where(
+  expr: ModelLayer.FqnExpr,
+  operator: WhereOperator<TestTag, string>,
+): ModelLayer.FqnExpr.Where
+export function $where(
+  expr: Expression | ModelLayer.Expression,
+  operator: WhereOperator<TestTag, string>,
+): ModelLayer.Expression {
   return {
     where: {
       expr: $expr(expr) as any,
@@ -497,38 +486,38 @@ export function $participant(
 }
 
 export function $inout(
-  expr: InOutExpr | C4ElementExpression,
-): C4InOutExpr {
+  expr: InOutExpr | ModelLayer.FqnExpr,
+): ModelLayer.RelationExpr.InOut {
   const innerExpression = !isString(expr)
-    ? expr as C4Expression
-    : $expr(expr.replace(/->/g, '').trim() as ElementRefExpr) as any
+    ? expr as ModelLayer.FqnExpr
+    : $expr(expr.replace(/->/g, '').trim() as any)
 
   return { inout: innerExpression }
 }
 
 export function $incoming(
-  expr: IncomingExpr | C4ElementExpression,
-): C4IncomingExpr {
+  expr: IncomingExpr | ModelLayer.FqnExpr,
+): ModelLayer.RelationExpr.Incoming {
   const innerExpression = !isString(expr)
-    ? expr as C4Expression
-    : $expr(expr.replace('-> ', '') as ElementRefExpr) as any
+    ? expr as ModelLayer.FqnExpr
+    : $expr(expr.replace('-> ', '') as any)
 
   return { incoming: innerExpression }
 }
 
 export function $outgoing(
-  expr: OutgoingExpr | C4ElementExpression,
-): C4OutgoingExpr {
+  expr: OutgoingExpr | ModelLayer.FqnExpr,
+): ModelLayer.RelationExpr.Outgoing {
   const innerExpression = !isString(expr)
-    ? expr as C4Expression
-    : $expr(expr.replace(' ->', '') as ElementRefExpr) as any
+    ? expr as ModelLayer.FqnExpr
+    : $expr(expr.replace(' ->', '') as any)
 
   return { outgoing: innerExpression }
 }
 
 export function $relation(
   expr: RelationExpr,
-): C4RelationExpr {
+): ModelLayer.RelationExpr {
   const [source, target] = expr.split(/ -> | <-> /)
   const isBidirectional = expr.includes(' <-> ')
 
@@ -539,9 +528,9 @@ export function $relation(
   }
 }
 
-export function $expr(expr: Expression | C4Expression): C4Expression {
+export function $expr(expr: Expression | ModelLayer.Expression): ModelLayer.Expression {
   if (!isString(expr)) {
-    return expr as C4Expression
+    return expr as ModelLayer.Expression
   }
   if (expr === '*') {
     return { wildcard: true }
@@ -557,23 +546,32 @@ export function $expr(expr: Expression | C4Expression): C4Expression {
   }
   if (expr.endsWith('._')) {
     return {
-      expanded: expr.replace('._', '') as Fqn,
+      ref: {
+        model: expr.replace('._', '') as Fqn,
+      },
+      selector: 'expanded',
     }
   }
   if (expr.endsWith('.*')) {
     return {
-      element: expr.replace('.*', '') as Fqn,
-      isChildren: true,
+      ref: {
+        model: expr.replace('.*', '') as Fqn,
+      },
+      selector: 'children',
     }
   }
   if (expr.endsWith('.**')) {
     return {
-      element: expr.replace('.**', '') as Fqn,
-      isDescendants: true,
+      ref: {
+        model: expr.replace('.**', '') as Fqn,
+      },
+      selector: 'descendants',
     }
   }
   return {
-    element: expr as Fqn,
+    ref: {
+      model: expr as Fqn,
+    },
   }
 }
 
@@ -590,27 +588,33 @@ type CustomProps = {
     opacity?: number
     navigateTo?: string
     multiple?: boolean
-  } & Omit<C4CustomRelationExpr['customRelation'], 'relation' | 'navigateTo'>
+  } & Omit<ModelLayer.RelationExpr.Custom['customRelation'], 'expr' | 'navigateTo'>
 }
-export function $include(expr: Expression | C4Expression, props?: CustomProps): ViewRulePredicate {
-  let _expr = props?.where ? $where(expr, props.where) : $expr(expr)
+export function $include(
+  expr: Expression | ModelLayer.Expression,
+  props?: CustomProps,
+): ViewRulePredicate {
+  let _expr = props?.where ? $where(expr as any, props.where) : $expr(expr)
   _expr = props?.with ? $with(_expr, props.with) : _expr
   return {
     include: [_expr],
   }
 }
-export function $with(expr: C4Expression, props?: CustomProps['with']): C4CustomRelationExpr | C4CustomElementExpr {
-  if (isRelationExpression(expr) || isRelationWhere(expr)) {
+export function $with(
+  expr: ModelLayer.Expression,
+  props?: CustomProps['with'],
+): ModelLayer.RelationExpr.Custom | ModelLayer.FqnExpr.Custom {
+  if (ModelLayer.RelationExpr.is(expr) || ModelLayer.RelationExpr.isWhere(expr)) {
     return {
       customRelation: {
-        relation: expr,
+        expr,
         ...props as any,
       },
     }
-  } else if (isElementRef(expr) || isElementWhere(expr)) {
+  } else if (ModelLayer.FqnExpr.is(expr) || ModelLayer.FqnExpr.isWhere(expr)) {
     return {
       custom: {
-        expr: expr,
+        expr,
         ...props as any,
       },
     }
@@ -618,8 +622,11 @@ export function $with(expr: C4Expression, props?: CustomProps['with']): C4Custom
 
   throw 'Unsupported type of internal expression'
 }
-export function $exclude(expr: Expression | C4Expression, where?: WhereOperator<TestTag, string>): ViewRulePredicate {
-  let _expr = where ? $where(expr, where) : $expr(expr)
+export function $exclude(
+  expr: Expression | ModelLayer.Expression,
+  where?: WhereOperator<TestTag, string>,
+): ViewRulePredicate {
+  let _expr = where ? $where(expr as any, where) : $expr(expr)
   return {
     exclude: [_expr],
   }
@@ -633,7 +640,7 @@ export function $group(groupRules: ViewRuleGroup['groupRules']): ViewRuleGroup {
 
 export function $style(element: ElementRefExpr, style: ViewRuleStyle['style']): ViewRuleStyle {
   return {
-    targets: [$expr(element) as C4ElementExpression],
+    targets: [$expr(element) as ModelLayer.FqnExpr],
     style: Object.assign({}, style),
   }
 }

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

@@ -2,7 +2,7 @@ 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 { ModelLayer } from '../../types/expression-v2-model'
 
 import type { Ctx, Memory, Stage, StageExclude, StageInclude } from './memory'
 
@@ -21,28 +21,32 @@ export { Memory } from './memory'
 
 export type Connections = ReadonlyArray<ConnectionModel<AnyAux>>
 
-export interface PredicateCtx<Expr extends Expression = Expression> {
+export interface PredicateCtx<Expr extends ModelLayer.Expression = ModelLayer.Expression> {
   expr: Expr
   stage: Stage
   // View scope
   scope: Elem | null
   model: LikeC4Model<AnyAux>
   memory: Memory
-  where: Expr extends RelationExpression ? RelationshipWhere
-    : Expr extends ElementExpression ? ElementWhere
+  where: Expr extends ModelLayer.RelationExpr ? RelationshipWhere
+    : Expr extends ModelLayer.FqnExpr ? ElementWhere
     : never
-  filterWhere: Expr extends RelationExpression ? ConnectionWhereFilter
-    : Expr extends ElementExpression ? ElementWhereFilter
+  filterWhere: Expr extends ModelLayer.RelationExpr ? ConnectionWhereFilter
+    : Expr extends ModelLayer.FqnExpr ? ElementWhereFilter
     : never
 }
-export interface IncludePredicateCtx<Expr extends Expression = Expression> extends PredicateCtx<Expr> {
+export interface IncludePredicateCtx<Expr extends ModelLayer.Expression = ModelLayer.Expression>
+  extends PredicateCtx<Expr>
+{
   stage: StageInclude
 }
-export interface ExcludePredicateCtx<Expr extends Expression = Expression> extends PredicateCtx<Expr> {
+export interface ExcludePredicateCtx<Expr extends ModelLayer.Expression = ModelLayer.Expression>
+  extends PredicateCtx<Expr>
+{
   stage: StageExclude
 }
 
-export interface PredicateExecutor<Expr extends Expression> {
+export interface PredicateExecutor<Expr extends ModelLayer.Expression = ModelLayer.Expression> {
   include(ctx: IncludePredicateCtx<Expr>): StageInclude | undefined
   exclude(ctx: ExcludePredicateCtx<Expr>): StageExclude | undefined
 }