@likec4/language-server 1.6.1 → 1.7.0

package/src/model-graph/dynamic-view/compute.ts

@@ -1,31 +1,44 @@
-import type { ComputedDynamicView, ComputedEdge, DynamicView, EdgeId, Element, RelationID } from '@likec4/core'
+import type {
+  ComputedDynamicView,
+  ComputedEdge,
+  DynamicView,
+  Element,
+  RelationID,
+  RelationshipArrowType,
+  RelationshipLineType,
+  ThemeColor
+} from '@likec4/core'
 import {
   ancestorsFqn,
   commonAncestor,
   DefaultArrowType,
   DefaultLineStyle,
   DefaultRelationshipColor,
-  invariant,
-  isCustomElement,
   isDynamicViewIncludeRule,
-  isElementRef,
-  isExpandedElementExpr,
   isViewRuleAutoLayout,
   nonNullable,
   parentFqn,
   StepEdgeId
 } from '@likec4/core'
 import { isTruthy, unique } from 'remeda'
+import { calcViewLayoutHash } from '../../view-utils/view-hash'
 import type { LikeC4ModelGraph } from '../LikeC4ModelGraph'
 import { applyCustomElementProperties } from '../utils/applyCustomElementProperties'
 import { applyViewRuleStyles } from '../utils/applyViewRuleStyles'
 import { buildComputeNodes } from '../utils/buildComputeNodes'
+import { elementExprToPredicate } from '../utils/elementExpressionToPredicate'
 
 export namespace DynamicViewComputeCtx {
   export interface Step {
     source: Element
     target: Element
     title: string | null
+    description?: string
+    technology?: string
+    color?: ThemeColor
+    line?: RelationshipLineType
+    head?: RelationshipArrowType
+    tail?: RelationshipArrowType
     relations: RelationID[]
     isBackward: boolean
   }
@@ -46,17 +59,24 @@ export class DynamicViewComputeCtx {
   ) {}
 
   protected compute(): ComputedDynamicView {
-    // reset ctx
-    const { rules, steps, ...view } = this.view
-
-    // const sources = new Set<Element>()
-    // const stepsStack = new Set<string>()
-
-    // const sourcesOf = new Map<Fqn, Set<Element>>()
-
-    for (let step of steps) {
-      const source = this.graph.element(step.source)
-      const target = this.graph.element(step.target)
+    const {
+      docUri: _docUri, // exclude docUri
+      rules,
+      steps: viewSteps,
+      ...view
+    } = this.view
+
+    for (
+      let {
+        source: stepSource,
+        target: stepTarget,
+        title: stepTitle,
+        isBackward,
+        ...step
+      } of viewSteps
+    ) {
+      const source = this.graph.element(stepSource)
+      const target = this.graph.element(stepTarget)
 
       this.explicits.add(source)
       this.explicits.add(target)
@@ -64,30 +84,20 @@ export class DynamicViewComputeCtx {
       const { title, relations } = this.findRelations(source, target)
 
       this.steps.push({
+        ...step,
         source,
         target,
-        title: step.title ?? title,
+        title: isTruthy(stepTitle) ? stepTitle : title,
         relations,
-        isBackward: step.isBackward ?? false
+        isBackward: isBackward ?? false
       })
     }
 
     for (const rule of rules) {
       if (isDynamicViewIncludeRule(rule)) {
         for (const expr of rule.include) {
-          if (isElementRef(expr)) {
-            this.explicits.add(this.graph.element(expr.element))
-            continue
-          }
-          if (isExpandedElementExpr(expr)) {
-            this.explicits.add(this.graph.element(expr.expanded))
-            continue
-          }
-          if (isCustomElement(expr)) {
-            this.explicits.add(this.graph.element(expr.custom.element))
-            continue
-          }
-          console.warn('Unsupported include expression: ', expr)
+          const predicate = elementExprToPredicate(expr)
+          this.graph.elements.filter(predicate).forEach(e => this.explicits.add(e))
         }
       }
     }
@@ -95,24 +105,23 @@ export class DynamicViewComputeCtx {
     const elements = [...this.explicits]
     const nodesMap = buildComputeNodes(elements)
 
-    const edges = this.steps.map(({ source, target, relations, ...step }, index) => {
-      const sourceNode = nodesMap.get(source.id)
-      const targetNode = nodesMap.get(target.id)
-      invariant(sourceNode, `Source node ${source.id} not found`)
-      invariant(targetNode, `Target node ${target.id} not found`)
+    const edges = this.steps.map(({ source, target, relations, title, isBackward, ...step }, index) => {
+      const sourceNode = nonNullable(nodesMap.get(source.id), `Source node ${source.id} not found`)
+      const targetNode = nonNullable(nodesMap.get(target.id), `Target node ${target.id} not found`)
       const stepNum = index + 1
       const edge: ComputedEdge = {
         id: StepEdgeId(stepNum),
         parent: commonAncestor(source.id, target.id),
         source: source.id,
         target: target.id,
-        label: step.title,
+        label: title,
         relations,
         color: DefaultRelationshipColor,
         line: DefaultLineStyle,
-        head: DefaultArrowType
+        head: DefaultArrowType,
+        ...step
       }
-      if (step.isBackward) {
+      if (isBackward) {
         edge.dir = 'back'
       }
 
@@ -149,12 +158,12 @@ export class DynamicViewComputeCtx {
 
     const autoLayoutRule = rules.findLast(isViewRuleAutoLayout)
 
-    return {
+    return calcViewLayoutHash({
       ...view,
       autoLayout: autoLayoutRule?.autoLayout ?? 'LR',
       nodes,
       edges
-    }
+    })
   }
 
   private findRelations(source: Element, target: Element): {

package/src/model-graph/utils/applyCustomElementProperties.ts

@@ -1,6 +1,7 @@
 import type { ComputedNode, ViewRule } from '@likec4/core'
 import { Expr, nonNullable } from '@likec4/core'
 import { isEmpty, isNonNullish, pickBy } from 'remeda'
+import { elementExprToPredicate } from './elementExpressionToPredicate'
 
 export function applyCustomElementProperties(_rules: ViewRule[], _nodes: ComputedNode[]) {
   const rules = _rules.flatMap(r => ('include' in r ? r.include.filter(Expr.isCustomElement) : []))
@@ -10,42 +11,43 @@ export function applyCustomElementProperties(_rules: ViewRule[], _nodes: Compute
   const nodes = [..._nodes]
   for (
     const {
-      custom: { element, ...props }
+      custom: { expr, ...props }
     } of rules
   ) {
-    const nodeIdx = nodes.findIndex(n => n.id === element)
-    if (nodeIdx === -1) {
-      continue
-    }
-    let node = nonNullable(nodes[nodeIdx])
-    const { border, opacity, ...rest } = pickBy(props, isNonNullish)
-    if (!isEmpty(rest)) {
-      node = {
-        ...node,
-        isCustomized: true,
-        ...rest
+    const satisfies = elementExprToPredicate(expr)
+    nodes.forEach((node, i) => {
+      if (!satisfies(node)) {
+        return
       }
-    }
 
-    let styleOverride: ComputedNode['style'] | undefined
-    if (border !== undefined) {
-      styleOverride = { border }
-    }
-    if (opacity !== undefined) {
-      styleOverride = { ...styleOverride, opacity }
-    }
-    if (styleOverride) {
-      node = {
-        ...node,
-        isCustomized: true,
-        style: {
-          ...node.style,
-          ...styleOverride
+      const { border, opacity, ...rest } = pickBy(props, isNonNullish)
+      if (!isEmpty(rest)) {
+        node = {
+          ...node,
+          isCustomized: true,
+          ...rest
         }
       }
-    }
 
-    nodes[nodeIdx] = node
+      let styleOverride: ComputedNode['style'] | undefined
+      if (border !== undefined) {
+        styleOverride = { border }
+      }
+      if (opacity !== undefined) {
+        styleOverride = { ...styleOverride, opacity }
+      }
+      if (styleOverride) {
+        node = {
+          ...node,
+          isCustomized: true,
+          style: {
+            ...node.style,
+            ...styleOverride
+          }
+        }
+      }
+      nodes[i] = node
+    })
   }
   return nodes
 }

package/src/model-graph/utils/applyCustomRelationProperties.ts

@@ -1,8 +1,39 @@
-import type { ComputedEdge, ComputedNode, ViewRule } from '@likec4/core'
-import { Expr } from '@likec4/core'
+import type { ComputedEdge, ComputedNode, Element, ViewRule } from '@likec4/core'
+import { Expr, nonexhaustive } from '@likec4/core'
 import { isEmpty } from 'remeda'
 import { elementExprToPredicate } from './elementExpressionToPredicate'
 
+function relationExpressionToPredicates(
+  expr: Expr.RelationExpression | Expr.RelationWhereExpr
+): (edge: { source: Element; target: Element }) => boolean {
+  switch (true) {
+    case Expr.isRelationWhere(expr):
+      return relationExpressionToPredicates(expr.where.expr)
+    case Expr.isRelation(expr): {
+      const isSource = elementExprToPredicate(expr.source)
+      const isTarget = elementExprToPredicate(expr.target)
+      return edge => {
+        return (isSource(edge.source) && isTarget(edge.target))
+          || (!!expr.isBidirectional && isSource(edge.target) && isTarget(edge.source))
+      }
+    }
+    case Expr.isInOut(expr): {
+      const isInOut = elementExprToPredicate(expr.inout)
+      return edge => isInOut(edge.source) || isInOut(edge.target)
+    }
+    case Expr.isIncoming(expr): {
+      const isTarget = elementExprToPredicate(expr.incoming)
+      return edge => isTarget(edge.target)
+    }
+    case Expr.isOutgoing(expr): {
+      const isSource = elementExprToPredicate(expr.outgoing)
+      return edge => isSource(edge.source)
+    }
+    default:
+      nonexhaustive(expr)
+  }
+}
+
 export function applyCustomRelationProperties(
   _rules: ViewRule[],
   nodes: ComputedNode[],
@@ -10,7 +41,7 @@ export function applyCustomRelationProperties(
 ): ComputedEdge[] {
   const rules = _rules.flatMap(r => ('include' in r ? r.include.filter(Expr.isCustomRelationExpr) : []))
   const edges = Array.from(_edges)
-  if (rules.length === 0) {
+  if (rules.length === 0 || edges.length === 0) {
     return edges
   }
   for (
@@ -21,22 +52,28 @@ export function applyCustomRelationProperties(
     if (isEmpty(props) && !title) {
       continue
     }
-    const isSource = elementExprToPredicate(relation.source)
-    const isTarget = elementExprToPredicate(relation.target)
-    const satisfies = (edge: ComputedEdge) => {
+    const satisfies = relationExpressionToPredicates(relation)
+    // const isSource = elementExprToPredicate(relation.source)
+    // const isTarget = elementExprToPredicate(relation.target)
+    // const satisfies = (edge: ComputedEdge) => {
+    //   const source = nodes.find(n => n.id === edge.source)
+    //   const target = nodes.find(n => n.id === edge.target)
+    //   if (!source || !target) {
+    //     return false
+    //   }
+    //   let result = isSource(source) && isTarget(target)
+    //   if (!result && relation.isBidirectional) {
+    //     result = isSource(target) && isTarget(source)
+    //   }
+    //   return result
+    // }
+    edges.forEach((edge, i) => {
       const source = nodes.find(n => n.id === edge.source)
       const target = nodes.find(n => n.id === edge.target)
       if (!source || !target) {
-        return false
+        return
       }
-      let result = isSource(source) && isTarget(target)
-      if (!result && relation.isBidirectional) {
-        result = isSource(target) && isTarget(source)
-      }
-      return result
-    }
-    edges.forEach((edge, i) => {
-      if (satisfies(edge)) {
+      if (satisfies({ source, target })) {
         edges[i] = {
           ...edge,
           label: title ?? edge.label,

package/src/model-graph/utils/elementExpressionToPredicate.ts

@@ -1,10 +1,15 @@
-import type { ComputedNode } from '@likec4/core'
 import { Expr, nonexhaustive, parentFqn } from '@likec4/core'
+import { type Element, whereOperatorAsPredicate } from '@likec4/core/types'
 import { isNullish } from 'remeda'
 
 type Predicate<T> = (x: T) => boolean
 
-export function elementExprToPredicate(target: Expr.ElementPredicateExpression): Predicate<ComputedNode> {
+export function elementExprToPredicate(target: Expr.ElementPredicateExpression): Predicate<Element> {
+  if (Expr.isElementWhere(target)) {
+    const predicate = elementExprToPredicate(target.where.expr)
+    const where = whereOperatorAsPredicate(target.where.condition)
+    return n => predicate(n) && where(n)
+  }
   if (Expr.isWildcard(target)) {
     return () => true
   }
@@ -26,7 +31,7 @@ export function elementExprToPredicate(target: Expr.ElementPredicateExpression):
       : n => (n.id as string) === element
   }
   if (Expr.isCustomElement(target)) {
-    return n => (n.id as string) === target.custom.element
+    return elementExprToPredicate(target.custom.expr)
   }
   nonexhaustive(target)
 }

package/src/module.ts

@@ -1,4 +1,3 @@
-import { normalizeError } from '@likec4/core'
 import { EmptyFileSystem, inject, type Module, WorkspaceCache } from 'langium'
 import {
   createDefaultModule,
@@ -10,7 +9,7 @@ import {
   type PartialLangiumSharedServices
 } from 'langium/lsp'
 import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module'
-import { logger } from './logger'
+import { logErrorToTelemetry } from './logger'
 import {
   LikeC4CodeLensProvider,
   LikeC4CompletionProvider,
@@ -142,26 +141,13 @@ export function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3
 }
 
 export function createSharedServices(context: LanguageServicesContext = {}): LikeC4SharedServices {
-  const connection = context.connection
-  if (connection) {
-    // eslint-disable-next-line @typescript-eslint/unbound-method
-    const original = logger.error.bind(logger)
-    logger.error = (arg: unknown) => {
-      if (typeof arg === 'string') {
-        original(arg)
-        connection.telemetry.logEvent({ eventName: 'error', error: arg })
-        return
-      }
-      const error = normalizeError(arg)
-      original(error)
-      connection.telemetry.logEvent({ eventName: 'error', error: error.stack ?? error.message })
-    }
-  }
-
   const moduleContext: DefaultSharedModuleContext = {
     ...EmptyFileSystem,
     ...context
   }
+  if (context.connection) {
+    logErrorToTelemetry(context.connection)
+  }
 
   return inject(
     createDefaultSharedModule(moduleContext),

package/src/{node/index.ts → node.ts}

@@ -1,7 +1,7 @@
 import { startLanguageServer as startLanguim } from 'langium/lsp'
 import { NodeFileSystem } from 'langium/node'
 import { createConnection, ProposedFeatures } from 'vscode-languageserver/node'
-import { createLanguageServices } from '../module'
+import { createLanguageServices } from './module'
 
 export function startLanguageServer() {
   /* browser specific setup code */

package/src/protocol.ts

@@ -8,8 +8,8 @@ import type {
   ViewChangeOp,
   ViewID
 } from '@likec4/core'
-import type { DocumentUri, Location } from 'vscode-languageserver-protocol'
-import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol'
+import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc'
+import type { DocumentUri, Location } from 'vscode-languageserver-types'
 
 // #region From server
 export const onDidChangeModel = new NotificationType<string>('likec4/onDidChangeModel')

package/src/shared/NodeKindProvider.ts

@@ -1,6 +1,6 @@
 import { type AstNode, type AstNodeDescription } from 'langium'
 import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp'
-import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-protocol'
+import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-types'
 import { ast } from '../ast'
 
 export class NodeKindProvider implements LspNodeKindProvider {
@@ -38,7 +38,7 @@ export class NodeKindProvider implements LspNodeKindProvider {
         return SymbolKind.TypeParameter
       }
     }
-    return SymbolKind.Constant
+    return SymbolKind.Field
   }
   /**
    * Returns a `CompletionItemKind` as used by the `CompletionProvider`.
@@ -61,6 +61,8 @@ export class NodeKindProvider implements LspNodeKindProvider {
         return CompletionItemKind.Interface
       case SymbolKind.Event:
         return CompletionItemKind.Event
+      case SymbolKind.Constant:
+        return CompletionItemKind.Constant
       default:
         return CompletionItemKind.Reference
     }

package/src/test/setup.ts

@@ -0,0 +1,13 @@
+import { beforeAll, beforeEach, vi } from 'vitest'
+import { logger } from '../logger'
+
+beforeAll(() => {
+  // Redirect std and console to consola too
+  // Calling this once is sufficient
+  logger.wrapAll()
+})
+
+beforeEach(() => {
+  // Vitest
+  logger.mockTypes(() => vi.fn())
+})

package/src/test/testServices.ts

@@ -1,7 +1,7 @@
 import { DocumentState, EmptyFileSystem } from 'langium'
 import * as assert from 'node:assert'
 import stripIndent from 'strip-indent'
-import { type Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-protocol'
+import { type Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types'
 import { URI, Utils } from 'vscode-uri'
 import type { LikeC4LangiumDocument } from '../ast'
 import { createLanguageServices } from '../module'

package/src/validation/dynamic-view-rule.ts

@@ -1,28 +1,28 @@
 import { nonexhaustive } from '@likec4/core'
 import type { ValidationCheck } from 'langium'
-import { ast } from '../ast'
+import { ast, elementExpressionFromPredicate } from '../ast'
 import type { LikeC4Services } from '../module'
 
 export const dynamicViewRulePredicate = (
   _services: LikeC4Services
-): ValidationCheck<ast.DynamicViewRulePredicateIterator> => {
-  return (expr, accept) => {
+): ValidationCheck<ast.DynamicViewPredicateIterator> => {
+  return (predicate, accept) => {
+    const expr = elementExpressionFromPredicate(predicate.value)
     switch (true) {
-      case ast.isElementRef(expr.value):
-      case ast.isElementDescedantsExpression(expr.value):
-      case ast.isCustomElementExpression(expr.value):
-      case ast.isExpandElementExpression(expr.value):
+      case ast.isElementRef(expr):
+      case ast.isElementDescedantsExpression(expr):
+      case ast.isExpandElementExpression(expr):
         return
-      case ast.isElementKindExpression(expr.value):
-      case ast.isElementTagExpression(expr.value):
-      case ast.isWildcardExpression(expr.value): {
+      case ast.isElementKindExpression(expr):
+      case ast.isElementTagExpression(expr):
+      case ast.isWildcardExpression(expr): {
         accept('warning', `Predicate is ignored, as not supported in dynamic views`, {
-          node: expr
+          node: predicate
         })
         return
       }
       default:
-        nonexhaustive(expr.value)
+        nonexhaustive(expr)
     }
   }
 }

package/src/validation/index.ts

@@ -16,11 +16,11 @@ import {
 } from './specification'
 import { viewChecks } from './view'
 import {
-  customElementExprChecks,
-  customRelationExprChecks,
+  elementPredicateWithChecks,
   expandElementExprChecks,
   incomingExpressionChecks,
-  outgoingExpressionChecks
+  outgoingExpressionChecks,
+  relationPredicateWithChecks
 } from './view-predicates'
 
 export function registerValidationChecks(services: LikeC4Services) {
@@ -38,9 +38,9 @@ export function registerValidationChecks(services: LikeC4Services) {
     ElementKind: elementKindChecks(services),
     Relation: relationChecks(services),
     Tag: tagChecks(services),
-    DynamicViewRulePredicateIterator: dynamicViewRulePredicate(services),
-    CustomElementExpression: customElementExprChecks(services),
-    CustomRelationExpression: customRelationExprChecks(services),
+    DynamicViewPredicateIterator: dynamicViewRulePredicate(services),
+    ElementPredicateWith: elementPredicateWithChecks(services),
+    RelationPredicateWith: relationPredicateWithChecks(services),
     ExpandElementExpression: expandElementExprChecks(services),
     RelationshipKind: relationshipChecks(services),
     IncomingRelationExpression: incomingExpressionChecks(services),

package/src/validation/relation.ts

@@ -44,7 +44,7 @@ export const relationChecks = (services: LikeC4Services): ValidationCheck<ast.Re
         })
       }
 
-      if (el.tags?.value && el.body?.tags?.value) {
+      if (el.tags?.values && el.body?.tags?.values) {
         accept('error', 'Relation cannot have tags in both header and body', {
           node: el,
           property: 'tags'

package/src/validation/view-predicates/{custom-element-expr.ts → element-with.ts}

@@ -4,9 +4,9 @@ import { AstUtils } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
-export const customElementExprChecks = (
+export const elementPredicateWithChecks = (
   _services: LikeC4Services
-): ValidationCheck<ast.CustomElementExpression> => {
+): ValidationCheck<ast.ElementPredicateWith> => {
   return (el, accept) => {
     const container = AstUtils.getContainerOfType(el, ast.isViewRulePredicate)
     if (ast.isExcludePredicate(container)) {
@@ -14,21 +14,22 @@ export const customElementExprChecks = (
         node: el
       })
     }
+    const subject = ast.isElementPredicateWhere(el.subject) ? el.subject.subject : el.subject
     switch (true) {
-      case ast.isElementRef(el.target):
-      case ast.isElementDescedantsExpression(el.target):
-      case ast.isExpandElementExpression(el.target):
+      case ast.isElementRef(subject):
+      case ast.isElementDescedantsExpression(subject):
+      case ast.isExpandElementExpression(subject):
+      case ast.isWildcardExpression(subject):
         return
-      case ast.isElementKindExpression(el.target):
-      case ast.isElementTagExpression(el.target):
-      case ast.isWildcardExpression(el.target):
+      case ast.isElementKindExpression(subject):
+      case ast.isElementTagExpression(subject):
         accept('error', 'Invalid target (expect reference to specific element)', {
           node: el,
-          property: 'target'
+          property: 'subject'
         })
         return
       default:
-        nonexhaustive(el.target)
+        nonexhaustive(subject)
     }
   }
 }

package/src/validation/view-predicates/expanded-element.ts

@@ -1,5 +1,4 @@
-import { nonexhaustive } from '@likec4/core'
-import { type AstNode, AstUtils, type ValidationCheck } from 'langium'
+import { AstUtils, type ValidationCheck } from 'langium'
 import { ast } from '../../ast'
 import type { LikeC4Services } from '../../module'
 
@@ -7,17 +6,10 @@ export const expandElementExprChecks = (
   _services: LikeC4Services
 ): ValidationCheck<ast.ExpandElementExpression> => {
   return (el, accept) => {
-    const isInside = <T extends AstNode>(typePredicate: (n: AstNode) => n is T): boolean =>
-      !!AstUtils.getContainerOfType(el, typePredicate)
-    if (isInside(ast.isRelationExpression)) {
+    if (AstUtils.hasContainerOfType(el, ast.isRelationExpression)) {
       accept('warning', `Redundant usage, expand predicate resolves parent element only when used in relations`, {
         node: el
       })
     }
-    if (isInside(ast.isExcludePredicate)) {
-      accept('warning', `Expand predicate is ignored in exclude`, {
-        node: el
-      })
-    }
   }
 }

package/src/validation/view-predicates/incoming.ts

@@ -7,7 +7,7 @@ export const incomingExpressionChecks = (
   _services: LikeC4Services
 ): ValidationCheck<ast.IncomingRelationExpression> => {
   return (el, accept) => {
-    if (ast.isWildcardExpression(el.to) && ast.isExpressions(el.$container)) {
+    if (ast.isWildcardExpression(el.to) && !ast.isInOutRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView)
       if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {

package/src/validation/view-predicates/index.ts

@@ -1,5 +1,5 @@
-export * from './custom-element-expr'
-export * from './custom-relation-expr'
+export * from './element-with'
 export * from './expanded-element'
 export * from './incoming'
 export * from './outgoing'
+export * from './relation-with'

package/src/validation/view-predicates/outgoing.ts

@@ -7,7 +7,7 @@ export const outgoingExpressionChecks = (
   _services: LikeC4Services
 ): ValidationCheck<ast.OutgoingRelationExpression> => {
   return (el, accept) => {
-    if (ast.isWildcardExpression(el.from) && ast.isExpressions(el.$container)) {
+    if (ast.isWildcardExpression(el.from) && !ast.isDirectedRelationExpression(el.$container)) {
       const view = AstUtils.getContainerOfType(el, ast.isElementView)
       if (isNullish(view?.viewOf)) {
         accept('warning', 'Predicate is ignored as it concerns all relationships', {