@likec4/core 1.27.3 → 1.28.0

package/src/types/expression-v2-model.ts

@@ -0,0 +1,314 @@
+import type { ExclusiveUnion } from './_common'
+import type { PredicateSelector } from './deployments'
+import type { BorderStyle, ElementKind, ElementShape } from './element'
+import type { WhereOperator } from './operators'
+import type { RelationshipArrowType, RelationshipLineType } from './relation'
+import { type Fqn, type IconUrl, type ProjectId, type Tag, GlobalFqn } from './scalars'
+import type { Color, ShapeSize } from './theme'
+import type { ViewId } from './view'
+
+export namespace ModelLayer {
+  export namespace FqnRef {
+    /**
+     * Reference to logical model element
+     */
+    export type ModelRef<F = Fqn> = {
+      model: F
+    }
+    export const isModelRef = (ref: FqnRef): ref is ModelRef => {
+      return 'model' in ref && !('project' in ref)
+    }
+
+    /**
+     * Reference to imported logical model element
+     */
+    export type ImportRef<F = Fqn> = {
+      project: ProjectId
+      model: F
+    }
+    export const isImportRef = (ref: FqnRef): ref is ImportRef => {
+      return 'project' in ref && 'model' in ref
+    }
+
+    export const toFqn = (ref: FqnRef): Fqn => {
+      if (isImportRef(ref)) {
+        return GlobalFqn(ref.project, ref.model)
+      }
+      if (isModelRef(ref)) {
+        return ref.model
+      }
+      throw new Error('Expected FqnRef.ModelRef or FqnRef.ImportRef')
+    }
+  }
+
+  export type FqnRef<M = Fqn> = ExclusiveUnion<{
+    ModelRef: FqnRef.ModelRef<M>
+    ImportRef: FqnRef.ImportRef<M>
+  }>
+
+  export namespace FqnExpr {
+    export type Wildcard = {
+      wildcard: true
+    }
+    export const isWildcard = (expr: Expression): expr is FqnExpr.Wildcard => {
+      return 'wildcard' in expr && expr.wildcard === true
+    }
+
+    export type ModelRef<M = Fqn> = {
+      ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>
+      selector?: PredicateSelector
+    }
+    export const isModelRef = (ref: Expression): ref is FqnExpr.ModelRef => {
+      return 'ref' in ref
+    }
+
+    export type ElementKindExpr = {
+      elementKind: ElementKind
+      isEqual: boolean
+    }
+    export function isElementKindExpr(expr: Expression): expr is ElementKindExpr {
+      return 'elementKind' in expr && 'isEqual' in expr
+    }
+
+    export type ElementTagExpr = {
+      elementTag: Tag
+      isEqual: boolean
+    }
+    export function isElementTagExpr(expr: Expression): expr is ElementTagExpr {
+      return 'elementTag' in expr && 'isEqual' in expr
+    }
+
+    export type NonWildcard<M = Fqn> = ExclusiveUnion<{
+      ModelRef: ModelRef<M>
+      ElementKind: ElementKindExpr
+      ElementTag: ElementTagExpr
+    }>
+
+    export type Where<M = Fqn> = {
+      where: {
+        expr: ExclusiveUnion<{
+          Wildcard: Wildcard
+          ModelRef: ModelRef<M>
+          ElementKind: ElementKindExpr
+          ElementTag: ElementTagExpr
+        }>
+        condition: WhereOperator<string, string>
+      }
+    }
+
+    export const isWhere = (expr: Expression): expr is FqnExpr.Where => {
+      return 'where' in expr && is(expr.where.expr)
+    }
+
+    export type Custom<M = Fqn> = {
+      custom: {
+        expr: FqnExprOrWhere<M>
+        title?: string
+        description?: string
+        technology?: string
+        notation?: string
+        shape?: ElementShape
+        color?: Color
+        icon?: IconUrl
+        border?: BorderStyle
+        opacity?: number
+        navigateTo?: ViewId
+        multiple?: boolean
+        size?: ShapeSize
+        padding?: ShapeSize
+        textSize?: ShapeSize
+      }
+    }
+
+    export const isCustom = (expr: Expression): expr is FqnExpr.Custom => {
+      return 'custom' in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr))
+    }
+
+    export const is = (expr: Expression): expr is FqnExpr => {
+      return isWildcard(expr)
+        || isModelRef(expr)
+        || isElementKindExpr(expr)
+        || isElementTagExpr(expr)
+    }
+  }
+
+  export type FqnExpr<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+  }>
+
+  export type FqnExprOrWhere<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+    Where: FqnExpr.Where<M>
+  }>
+
+  export type AnyFqnExpr<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+    Where: FqnExpr.Where<M>
+    Custom: FqnExpr.Custom<M>
+  }>
+
+  export function isAnyFqnExpr(expr: Expression): expr is AnyFqnExpr {
+    return FqnExpr.is(expr)
+      || FqnExpr.isWhere(expr)
+      || FqnExpr.isCustom(expr)
+  }
+
+  export namespace RelationExpr {
+    export type Direct<M = Fqn> = {
+      source: FqnExpr<M>
+      target: FqnExpr<M>
+      isBidirectional?: boolean
+    }
+    export const isDirect = (expr: Expression): expr is RelationExpr.Direct => {
+      return 'source' in expr && 'target' in expr
+    }
+    export type Incoming<M = Fqn> = {
+      incoming: FqnExpr<M>
+    }
+    export const isIncoming = (expr: Expression): expr is RelationExpr.Incoming => {
+      return 'incoming' in expr
+    }
+    export type Outgoing<M = Fqn> = {
+      outgoing: FqnExpr<M>
+    }
+    export const isOutgoing = (expr: Expression): expr is RelationExpr.Outgoing => {
+      return 'outgoing' in expr
+    }
+    export type InOut<M = Fqn> = {
+      inout: FqnExpr<M>
+    }
+    export const isInOut = (expr: Expression): expr is RelationExpr.InOut => {
+      return 'inout' in expr
+    }
+    export type Where<M = Fqn> = {
+      where: {
+        expr: ExclusiveUnion<{
+          Direct: RelationExpr.Direct<M>
+          Incoming: RelationExpr.Incoming<M>
+          Outgoing: RelationExpr.Outgoing<M>
+          InOut: RelationExpr.InOut<M>
+        }>
+        condition: WhereOperator<string, string>
+      }
+    }
+    export const isWhere = (expr: Expression): expr is RelationExpr.Where => {
+      return 'where' in expr && is(expr.where.expr)
+    }
+
+    export type Custom<M = Fqn> = {
+      customRelation: {
+        expr: RelationExprOrWhere<M>
+        title?: string
+        description?: string
+        technology?: string
+        notation?: string
+        // Link to dynamic view
+        navigateTo?: ViewId
+        // Notes for walkthrough
+        notes?: string
+        color?: Color
+        line?: RelationshipLineType
+        head?: RelationshipArrowType
+        tail?: RelationshipArrowType
+      }
+    }
+
+    export const isCustom = (expr: Expression): expr is Custom => {
+      return 'customRelation' in expr
+    }
+
+    export const is = (expr: Expression): expr is RelationExpr => {
+      return isDirect(expr)
+        || isIncoming(expr)
+        || isOutgoing(expr)
+        || isInOut(expr)
+    }
+  }
+
+  export type RelationExpr<M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+  }>
+
+  export type RelationExprOrWhere<M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+    Where: RelationExpr.Where<M>
+  }>
+
+  export type AnyRelationExpr<M = Fqn> = ExclusiveUnion<{
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+    Where: RelationExpr.Where<M>
+    CustomRelation: RelationExpr.Custom<M>
+  }>
+
+  export function isAnyRelationExpr(expr: Expression): expr is AnyRelationExpr {
+    return RelationExpr.is(expr)
+      || RelationExpr.isWhere(expr)
+      || RelationExpr.isCustom(expr)
+  }
+
+  /**
+   * Represents a version 2 expression which can be one of several types.
+   *
+   * @template M - The type for the model FQN, defaults to `Fqn`.
+   */
+  export type Expression<M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    ElementKind: FqnExpr.ElementKindExpr
+    ElementTag: FqnExpr.ElementTagExpr
+    Custom: FqnExpr.Custom<M>
+    Direct: RelationExpr.Direct<M>
+    Incoming: RelationExpr.Incoming<M>
+    Outgoing: RelationExpr.Outgoing<M>
+    InOut: RelationExpr.InOut<M>
+    CustomRelation: RelationExpr.Custom<M>
+    Where: Expression.Where<M>
+  }>
+
+  export function isExpression(expr: any): expr is Expression {
+    return isAnyFqnExpr(expr)
+      || isAnyRelationExpr(expr)
+  }
+
+  export namespace Expression {
+    export type Where<M = Fqn> = FqnExpr.Where<M> | RelationExpr.Where<M>
+
+    export const isWhere = (expr: Expression): expr is Expression.Where => {
+      return 'where' in expr
+    }
+
+    export const isCustomFqnExpr = (expr: Expression): expr is FqnExpr.Custom => {
+      return FqnExpr.isCustom(expr)
+    }
+
+    export const isCustomRelationExpr = (expr: Expression): expr is RelationExpr.Custom => {
+      return RelationExpr.isCustom(expr)
+    }
+
+    export const isFqnExpr = (expr: Expression): expr is FqnExpr => {
+      return FqnExpr.is(expr)
+    }
+
+    export const isRelation = (expr: Expression): expr is RelationExpr => {
+      return RelationExpr.is(expr)
+    }
+  }
+}

package/src/types/expression-v2.ts

@@ -1,8 +1,12 @@
 import { invariant } from '../errors'
 import type { ExclusiveUnion } from './_common'
 import type { DeploymentRef as DeploymentModelRef, PredicateSelector } from './deployments'
-import type { Fqn } from './element'
+import type { BorderStyle, ElementKind, ElementShape } from './element'
 import type { WhereOperator } from './operators'
+import type { RelationshipArrowType, RelationshipLineType } from './relation'
+import { type Fqn, type IconUrl, type ProjectId, type Tag, GlobalFqn } from './scalars'
+import type { Color, ShapeSize } from './theme'
+import type { ViewId } from './view'
 
 export namespace FqnRef {
   /**
@@ -37,7 +41,7 @@ export namespace FqnRef {
 
   export type DeploymentRef<D = Fqn, M = Fqn> = DeploymentElementRef<D> | InsideInstanceRef<D, M>
   export const isDeploymentRef = (ref: FqnRef): ref is DeploymentRef => {
-    return !isModelRef(ref)
+    return !isModelRef(ref) && !isImportRef(ref)
   }
 
   /**
@@ -47,7 +51,18 @@ export namespace FqnRef {
     model: F
   }
   export const isModelRef = (ref: FqnRef): ref is ModelRef => {
-    return 'model' in ref
+    return 'model' in ref && !('project' in ref)
+  }
+
+  /**
+   * Reference to imported logical model element
+   */
+  export type ImportRef<F = Fqn> = {
+    project: ProjectId
+    model: F
+  }
+  export const isImportRef = (ref: FqnRef): ref is ImportRef => {
+    return 'project' in ref && 'model' in ref
   }
 
   export const toDeploymentRef = (ref: FqnRef): DeploymentModelRef => {
@@ -61,28 +76,39 @@ export namespace FqnRef {
         id: ref.deployment,
       }
   }
+
+  export const toModelFqn = (ref: FqnRef): Fqn => {
+    if (isImportRef(ref)) {
+      return GlobalFqn(ref.project, ref.model)
+    }
+    if (isModelRef(ref)) {
+      return ref.model
+    }
+    throw new Error('Expected FqnRef.ModelRef or FqnRef.ImportRef')
+  }
 }
 
 export type FqnRef<D = Fqn, M = Fqn> = ExclusiveUnion<{
   InsideInstanceRef: FqnRef.InsideInstanceRef<D, M>
   DeploymentRef: FqnRef.DeploymentRef<D>
   ModelRef: FqnRef.ModelRef<M>
+  ImportRef: FqnRef.ImportRef<M>
 }>
 
 export namespace FqnExpr {
   export type Wildcard = {
     wildcard: true
   }
-  export const isWildcard = (expr: ExpressionV2): expr is Wildcard => {
+  export const isWildcard = (expr: ExpressionV2): expr is FqnExpr.Wildcard => {
     return 'wildcard' in expr && expr.wildcard === true
   }
 
   export type ModelRef<M = Fqn> = {
-    ref: FqnRef.ModelRef<M>
+    ref: FqnRef.ModelRef<M> | FqnRef.ImportRef<M>
     selector?: PredicateSelector
   }
-  export const isModelRef = (ref: ExpressionV2): ref is ModelRef => {
-    return 'ref' in ref && FqnRef.isModelRef(ref.ref)
+  export const isModelRef = (ref: ExpressionV2): ref is FqnExpr.ModelRef => {
+    return 'ref' in ref && (FqnRef.isModelRef(ref.ref) || FqnRef.isImportRef(ref.ref))
   }
 
   export type DeploymentRef<D = Fqn, M = Fqn> = {
@@ -93,53 +119,216 @@ export namespace FqnExpr {
     return 'ref' in ref && FqnRef.isDeploymentRef(ref.ref)
   }
 
+  export type ElementKindExpr = {
+    elementKind: ElementKind
+    isEqual: boolean
+  }
+  export function isElementKindExpr(expr: ExpressionV2): expr is ElementKindExpr {
+    return 'elementKind' in expr && 'isEqual' in expr
+  }
+
+  export type ElementTagExpr = {
+    elementTag: Tag
+    isEqual: boolean
+  }
+  export function isElementTagExpr(expr: ExpressionV2): expr is ElementTagExpr {
+    return 'elementTag' in expr && 'isEqual' in expr
+  }
+
   export type NonWildcard<D = Fqn, M = Fqn> = ExclusiveUnion<{
     ModelRef: ModelRef<M>
     DeploymentRef: DeploymentRef<D, M>
+    ElementKind: ElementKindExpr
+    ElementTag: ElementTagExpr
+  }>
+
+  export type Where<D = Fqn, M = Fqn> = {
+    where: {
+      expr: ExclusiveUnion<{
+        Wildcard: Wildcard
+        ModelRef: ModelRef<M>
+        DeploymentRef: DeploymentRef<D, M>
+        ElementKind: ElementKindExpr
+        ElementTag: ElementTagExpr
+      }>
+      condition: WhereOperator<string, string>
+    }
+  }
+
+  export const isWhere = (expr: ExpressionV2): expr is FqnExpr.Where => {
+    return 'where' in expr && is(expr.where.expr)
+  }
+
+  export type Custom<D = Fqn, M = Fqn> = {
+    custom: {
+      expr: OrWhere<D, M>
+      title?: string
+      description?: string
+      technology?: string
+      notation?: string
+      shape?: ElementShape
+      color?: Color
+      icon?: IconUrl
+      border?: BorderStyle
+      opacity?: number
+      navigateTo?: ViewId
+      multiple?: boolean
+      size?: ShapeSize
+      padding?: ShapeSize
+      textSize?: ShapeSize
+    }
+  }
+
+  export const isCustom = (expr: ExpressionV2): expr is Custom => {
+    return 'custom' in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr))
+  }
+
+  export const is = (expr: ExpressionV2): expr is FqnExpr => {
+    return isWildcard(expr)
+      || isModelRef(expr)
+      || isDeploymentRef(expr)
+      || isElementKindExpr(expr)
+      || isElementTagExpr(expr)
+  }
+
+  export type OrWhere<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: FqnExpr.Wildcard
+    ModelRef: FqnExpr.ModelRef<M>
+    DeploymentRef: FqnExpr.DeploymentRef<D, M>
+    ElementKind: ElementKindExpr
+    ElementTag: ElementTagExpr
+    Where: FqnExpr.Where<D, M>
+  }>
+
+  export type Any<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Wildcard: Wildcard
+    ModelRef: ModelRef<M>
+    DeploymentRef: DeploymentRef<D, M>
+    ElementKind: ElementKindExpr
+    ElementTag: ElementTagExpr
+    Where: Where<D, M>
+    Custom: Custom<D, M>
   }>
+
+  export const unwrap = (expr: FqnExpr): Wildcard | ModelRef | DeploymentRef | ElementKindExpr | ElementTagExpr  => {
+    if (isCustom(expr)) {
+      expr = expr.custom.expr
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr
+    }
+    return expr
+  }
 }
 
 export type FqnExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Wildcard: FqnExpr.Wildcard
   ModelRef: FqnExpr.ModelRef<M>
   DeploymentRef: FqnExpr.DeploymentRef<D, M>
+  ElementKind: FqnExpr.ElementKindExpr
+  ElementTag: FqnExpr.ElementTagExpr
 }>
 
 export namespace RelationExpr {
+  export type Endpoint<D = Fqn, M = Fqn> = FqnExpr.Where<D, M>['where']['expr']
+
   export type Direct<D = Fqn, M = Fqn> = {
-    source: FqnExpr<D, M>
-    target: FqnExpr<D, M>
+    source: Endpoint<D, M>
+    target: Endpoint<D, M>
     isBidirectional?: boolean
   }
-  export const isDirect = (expr: ExpressionV2): expr is Direct => {
+  export const isDirect = (expr: ExpressionV2): expr is RelationExpr.Direct => {
     return 'source' in expr && 'target' in expr
   }
   export type Incoming<D = Fqn, M = Fqn> = {
-    incoming: FqnExpr<D, M>
+    incoming: Endpoint<D, M>
   }
-  export const isIncoming = (expr: ExpressionV2): expr is Incoming => {
+  export const isIncoming = (expr: ExpressionV2): expr is RelationExpr.Incoming => {
     return 'incoming' in expr
   }
   export type Outgoing<D = Fqn, M = Fqn> = {
-    outgoing: FqnExpr<D, M>
+    outgoing: Endpoint<D, M>
   }
-  export const isOutgoing = (expr: ExpressionV2): expr is Outgoing => {
+  export const isOutgoing = (expr: ExpressionV2): expr is RelationExpr.Outgoing => {
     return 'outgoing' in expr
   }
   export type InOut<D = Fqn, M = Fqn> = {
-    inout: FqnExpr<D, M>
+    inout: Endpoint<D, M>
   }
-  export const isInOut = (expr: ExpressionV2): expr is InOut => {
+  export const isInOut = (expr: ExpressionV2): expr is RelationExpr.InOut => {
     return 'inout' in expr
   }
   export type Where<D = Fqn, M = Fqn> = {
     where: {
-      expr: ExpressionV2<D, M>
+      expr: ExclusiveUnion<{
+        Direct: RelationExpr.Direct<D, M>
+        Incoming: RelationExpr.Incoming<D, M>
+        Outgoing: RelationExpr.Outgoing<D, M>
+        InOut: RelationExpr.InOut<D, M>
+      }>
       condition: WhereOperator<string, string>
     }
   }
-  export const isWhere = (expr: ExpressionV2): expr is Where => {
-    return 'where' in expr
+  export const isWhere = (expr: ExpressionV2): expr is RelationExpr.Where => {
+    return 'where' in expr &&
+      (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) ||
+        isInOut(expr.where.expr))
+  }
+
+  export type Custom<D = Fqn, M = Fqn> = {
+    customRelation: {
+      expr: OrWhere<D, M>
+      title?: string
+      description?: string
+      technology?: string
+      notation?: string
+      // Link to dynamic view
+      navigateTo?: ViewId
+      // Notes for walkthrough
+      notes?: string
+      color?: Color
+      line?: RelationshipLineType
+      head?: RelationshipArrowType
+      tail?: RelationshipArrowType
+    }
+  }
+
+  export const isCustom = (expr: ExpressionV2): expr is Custom => {
+    return 'customRelation' in expr
+  }
+
+  export const is = (expr: ExpressionV2): expr is RelationExpr => {
+    return isDirect(expr)
+      || isIncoming(expr)
+      || isOutgoing(expr)
+      || isInOut(expr)
+  }
+
+  export type OrWhere<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Direct: Direct<D, M>
+    Incoming: Incoming<D, M>
+    Outgoing: Outgoing<D, M>
+    InOut: InOut<D, M>
+    Where: Where<D, M>
+  }>
+
+  export type Any<D = Fqn, M = Fqn> = ExclusiveUnion<{
+    Direct: Direct<D, M>
+    Incoming: Incoming<D, M>
+    Outgoing: Outgoing<D, M>
+    InOut: InOut<D, M>
+    Where: Where<D, M>
+    Custom: Custom<D, M>
+  }>
+
+  export const unwrap = (expr: RelationExpr): Direct | Incoming | Outgoing | InOut => {
+    if (isCustom(expr)) {
+      expr = expr.customRelation.expr
+    }
+    if (isWhere(expr)) {
+      expr = expr.where.expr
+    }
+    return expr
   }
 }
 
@@ -148,7 +337,6 @@ export type RelationExpr<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
-  Where: RelationExpr.Where<D, M>
 }>
 
 /**
@@ -161,24 +349,44 @@ export type ExpressionV2<D = Fqn, M = Fqn> = ExclusiveUnion<{
   Wildcard: FqnExpr.Wildcard
   ModelRef: FqnExpr.ModelRef<M>
   DeploymentRef: FqnExpr.DeploymentRef<D, M>
+  ElementKind: FqnExpr.ElementKindExpr
+  ElementTag: FqnExpr.ElementTagExpr
+  Custom: FqnExpr.Custom<D, M>
   Direct: RelationExpr.Direct<D, M>
   Incoming: RelationExpr.Incoming<D, M>
   Outgoing: RelationExpr.Outgoing<D, M>
   InOut: RelationExpr.InOut<D, M>
-  RelationPredicateOrWhere: RelationExpr.Where<D, M>
+  Where: ExpressionV2.Where<D, M>
+  CustomRelation: RelationExpr.Custom<D, M>
 }>
 
 export namespace ExpressionV2 {
-  export const isFqnExpr = (expr: ExpressionV2): expr is FqnExpr => {
-    return FqnExpr.isWildcard(expr)
-      || FqnExpr.isModelRef(expr)
-      || FqnExpr.isDeploymentRef(expr)
+  export type Where<D = Fqn, M = Fqn> = FqnExpr.Where<D, M> | RelationExpr.Where<D, M>
+  // export type Where<D = Fqn, M = Fqn> = {
+  //   where: ExclusiveUnion<{
+  //     Fqn: FqnExpr.Where<D, M>['where']['expr']
+  //     Relation: RelationExpr.Where<D, M>['where']['expr']
+  //   }>
+  //   condition: WhereOperator<string, string>
+  // }
+
+  export const isWhere = (expr: ExpressionV2): expr is ExpressionV2.Where => {
+    return 'where' in expr
+  }
+
+  export const isRelationWhere = (expr: ExpressionV2): expr is RelationExpr.Where => {
+    return RelationExpr.isWhere(expr)
+  }
+
+  export const isFqnExprWhere = (expr: ExpressionV2): expr is FqnExpr.Where => {
+    return FqnExpr.isWhere(expr)
+  }
+
+  export const isFqnExpr = (expr: ExpressionV2): expr is FqnExpr.Any => {
+    return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr)
   }
 
-  export const isRelation = (expr: ExpressionV2): expr is RelationExpr => {
-    return RelationExpr.isDirect(expr)
-      || RelationExpr.isIncoming(expr)
-      || RelationExpr.isOutgoing(expr)
-      || RelationExpr.isInOut(expr)
+  export const isRelation = (expr: ExpressionV2): expr is RelationExpr.Any => {
+    return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr)
   }
 }