@sap/cds-dk 10.0.7 → 10.1.1

package/node_modules/@sap/cds-compiler/lib/gen/Dictionary.json

@@ -1112,14 +1112,12 @@
       "Type": "Core.Tag"
     },
     "Common.WebSocketBaseURL": {
-      "$experimental": true,
       "AppliesTo": [
         "EntityContainer"
       ],
       "Type": "Edm.String"
     },
     "Common.WebSocketChannel": {
-      "$experimental": true,
       "AppliesTo": [
         "EntityContainer"
       ],
@@ -1795,6 +1793,13 @@
       ],
       "Type": "UI.BadgeType"
     },
+    "UI.CardItem": {
+      "$experimental": true,
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "Type": "UI.CardItemType"
+    },
     "UI.Chart": {
       "AppliesTo": [
         "EntityType"
@@ -1897,7 +1902,6 @@
       "Type": "Edm.Boolean"
     },
     "UI.Emphasized": {
-      "$experimental": true,
       "AppliesTo": [
         "Record"
       ],
@@ -3443,6 +3447,9 @@
       "Properties": {
         "Discretionary": "Edm.Boolean",
         "SourceEntities": "Collection(Edm.NavigationPropertyPath)",
+        "SourceEntitiesDeleted": "Collection(Edm.NavigationPropertyPath)",
+        "SourceEntitiesInserted": "Collection(Edm.NavigationPropertyPath)",
+        "SourceEntitiesUpdated": "Collection(Edm.NavigationPropertyPath)",
         "SourceEvents": "Collection(Edm.String)",
         "SourceProperties": "Collection(Edm.PropertyPath)",
         "TargetEntities": "Collection(Edm.NavigationPropertyPath)",
@@ -4312,6 +4319,15 @@
         "TypeImageUrl": "Edm.String"
       }
     },
+    "UI.CardItemType": {
+      "$experimental": true,
+      "$kind": "ComplexType",
+      "Properties": {
+        "Actions": "Collection(UI.DataFieldAbstract)",
+        "Details": "Collection(UI.Facet)",
+        "Header": "Edm.AnnotationPath"
+      }
+    },
     "UI.ChartAxisAutoScaleBehaviorType": {
       "$kind": "ComplexType",
       "Properties": {

package/node_modules/@sap/cds-compiler/lib/json/from-csn.js

@@ -596,6 +596,7 @@ const schema = compileSchema( {
   any: { type: asQuantifier },  // probably just CSN v0.1.0
   distinct: { type: asQuantifier },
   all: { type: asQuantifier },
+  one: { type: boolOrNull },
   // further query properties: -----------------------------------------------
   excluding: {
     inKind: [ '$column' ],
@@ -1661,16 +1662,11 @@ function args( exprs, spec ) {
 
 function expr( e, spec ) {
   if (Array.isArray( e )) {
-    if (e.length > 1) {         // struct-xpr
+    if (e.length > 1)           // parse CSN produced with option 'structXpr'
+      return condition( e, spec );
+    if (e.length === 1) {       // CSN v.0.1.0 way for parentheses
       const loc = location();
-      const xsn = exprArgs( e, spec );
-      return (e.length < 3)     // optimization
-        ? { op: { val: 'ixpr', location: loc }, args: xsn, location: loc }
-        : xsnAsTree( e, xsn, loc );
-    }
-    else if (e.length === 1) { // CSN v.0.1.0 way for parentheses
-      const loc = location();
-      if (e[0] && !e[0].op)       // do not complain with 'op' (for which we complain)
+      if (e[0] && !e[0].op)     // do not complain with 'op' (for which we complain)
         replaceZeroValue( spec, 'zero-parens' );
       ++virtualLine;
       const r = expr( e[0], spec );
@@ -1714,13 +1710,9 @@ function exprArgs( cond, spec ) {
 function condition( cond, spec ) {
   const loc = location();
   const xsn = exprArgs( cond, spec );
-  // TODO sql-like backends: with the commented `return`, test3 generated sql
-  // files will not have the unnecessary `(…)` around `on` anymore → extra PR
-  const tree = (cond.length < 3) ? xsn : xsnAsTree( cond, xsn, loc ).args;
-  return { op: { val: 'xpr', location: loc }, args: tree, location: loc };
-  // return (cond.length < 3)      // optimization
-  //   ? { op: { val: 'ixpr', location: loc }, args: xsn, location: loc }
-  //   : xsnAsTree( cond, xsn, loc );
+  return (cond.length < 3)      // nothing to structurize with 1 or 2 nodes
+    ? { op: { val: 'ixpr', location: loc }, args: xsn, location: loc }
+    : xsnAsTree( cond, xsn, loc );
 }
 
 // Queries (std signature) ---------------------------------------------------
@@ -1892,6 +1884,8 @@ function calculateKind( def, spec, xsn ) {
   }
   if (spec.prop === 'extensions') {
     inExtensions = (def.extend) ? '' : 'annotate';
+    if (def.extend && Object.keys( def ).length === 1)
+      xsn.$syntax = 'empty';    // for Warning instead Error with undefined ref
     return (def.extend) ? 'extend' : 'annotate';
   }
   const kind = (def.kind === 'view') ? 'entity' : def.kind; // 'view' is CSN v0.1.0

package/node_modules/@sap/cds-compiler/lib/json/to-csn.js

@@ -13,7 +13,8 @@
 
 const { locationString } = require('../base/messages');
 const { isBetaEnabled } = require('../base/specialOptions');
-const { pathName, hasSpecialPathItemProp } = require('../compiler/utils');
+const { pathName, hasSpecialPathItemProp, isLeadingQuery } = require('../compiler/utils');
+const { dictFirst } = require('../compiler/dictionaries');
 const { CompilerAssertion } = require('../base/error');
 
 const compilerVersion = require('../../package.json').version;
@@ -70,6 +71,7 @@ const transformers = {
     csn[q.val] = true;
   },
   all: ignore,                  // XSN TODO use quantifier
+  one: value,
   // type properties (without 'elements') ------------------------------------
   localized: value,
   type,
@@ -114,6 +116,7 @@ const transformers = {
   rows: expression,
   offset: expression,
   on: onCondition,
+  $backlink: backlink,
   // definitions, extensions, members ----------------------------------------
   notNull: value,
   default: expression,
@@ -248,10 +251,10 @@ function compactModel( model, options = model.options || {} ) {
   set( 'i18n', csn, model );
   set( 'sources', csn, model );
   // Set $location, use $extra properties of first source as resulting $extra properties
-  const firstSourceName = Object.keys( srcDict )[0];
-  if (firstSourceName) {
-    const firstSource = srcDict[firstSourceName];
+  const firstSource = dictFirst( srcDict );
+  if (firstSource) {
     const loc = firstSource.location;
+
     if (loc && loc.file) {
       Object.defineProperty( csn, '$location', {
         value: { file: loc.file }, configurable: true, writable: true, enumerable: withLocations,
@@ -545,7 +548,7 @@ function enumDict( dict, csn, node ) {
 }
 
 function enumerableQueryElements( select ) {
-  return (universalCsn && select !== select._main._leadingQuery);
+  return (universalCsn && !isLeadingQuery( select ));
 }
 
 // Should we render the elements?  (and enum, items?)
@@ -688,16 +691,17 @@ function dictionary( dict, keys, prop ) {
 function foreignKeys( dict, csn, node ) {
   if (!dict ||              // `Association to many Target` without specified keys
       universalCsn && dict[$inferred] === 'keys' ||
-      !target( node.target, csn, node ) )
+      !target( node.target, csn, node ) ||
+      gensrcFlavor && dict[$inferred])
     return;
+  fkeys( dict, csn );
+}
 
-  if (gensrcFlavor) {
-    if (dict[$inferred])
-      return;
-  }
+function fkeys( dict, csn = {} ) {
   csn.keys = [];
   for (const n in dict)
     csn.keys.push( definition( dict[n] ) );
+  return csn;
 }
 
 function returns( art, csn, node, prop ) {
@@ -733,21 +737,6 @@ function definition( art, csn, _node, prop ) {
   return c;
 }
 
-/**
- * Create $origin specification for query/projection.
- */
-function queryOrigin( xsn ) {
-  const source = xsn._from[0]._origin;
-  let $origin;
-  if (xsn.includes)
-    // includesOrigin() does originRef() on the first include.
-    // Use it to behave the same as entity includes.
-    $origin = includesOrigin( [ { _artifact: source }, ...xsn.includes ], xsn );
-  else
-    $origin = originRef( source );
-  return $origin;
-}
-
 /**
  * Create $origin specification for `includes` of `art`.
  */
@@ -807,9 +796,16 @@ function addOrigin( csn, xsn, node ) {
       csn.$source = null;
     return;
   }
-  if (xsn._from) {
-    const source = xsn._from[0]._origin;
-    csn.$origin = queryOrigin( xsn );
+  if (xsn.query) {
+    let source = xsn._origin;   // table alias of leading query
+    while (source?._main)       // source is still a query
+      source = source._origin;
+    if (!source)
+      return;
+    csn.$origin = (xsn.includes)
+      ? includesOrigin( [ { _artifact: source }, ...xsn.includes ], xsn )
+      : originRef( source );
+
     if (source.params && !xsn.params)
       csn.params = null;        // discontinue `params` inheritance
     if (source.actions && !xsn.actions)
@@ -843,7 +839,7 @@ function addOrigin( csn, xsn, node ) {
   // console.log( 'X:',xsn, origin, parent, parentOrigin, getParent( origin ) );
   if (!origin) {
     if (parent && parentOrigin &&
-        (parent.kind !== 'select' || parent === parent._main._leadingQuery) &&
+        (parent.kind !== 'select' || isLeadingQuery( parent )) &&
         !(parent.enum && !parent.$origin && parent.type))
       csn.$origin = null;
     return;
@@ -937,7 +933,7 @@ function inferredPropertiesForOrigin( csn, node ) {
 function getParent( art ) {
   const parent = art._parent;
   const main = parent._main;
-  return (main && parent === main._leadingQuery) ? main : parent;
+  return (main && isLeadingQuery( parent )) ? main : parent;
 }
 
 function isMember( art ) {
@@ -952,15 +948,18 @@ function isMember( art ) {
 //   return main;
 // }
 
-// XSN `_origin` is (currently?) not the same as _origin in Universal CSN...
+// XSN `_origin` is not the same as _origin in Universal CSN...
 // TODO: at least with expand, set it correctly (alias: keep, assoc: to entity, $builtin: no)
 function getOrigin( art ) {
   if (art.$noOrigin)
     return undefined;
   const { _origin } = art;
-  if (_origin)                  // also for query entities
-    return (_origin.kind === 'builtin') ? undefined : _origin;
-
+  if (_origin) {                // also for query entities
+    // eslint-disable-next-line no-nested-ternary
+    return (_origin.kind === 'builtin')
+      ? undefined
+      : (_origin.kind === '$tableAlias') ? _origin._origin : _origin;
+  }
   if (hasExplicitProp( art.type, 'cast' ))
     return art.type._artifact;
   // must come after checking _origin, since entities can have both queries and
@@ -994,7 +993,7 @@ function originRef( art, user ) {
       r.push( !nkind ? name.id : name.id ? { [nkind]: name.id } : { returns: true } );
     parent = parent._parent;
   }
-  if (user && parent._main && parent._main === user._main && parent !== user._main._leadingQuery)
+  if (user && parent._main && parent._main === user._main && !isLeadingQuery( parent ))
     // well, an element of an query in FROM (TODO: try with sub elem), but not the leading query
     return false;               // do not write, probably use $origin: {...}
   // for sub query in FROM in sub query in FROM, we could condense the info
@@ -1239,6 +1238,12 @@ function onCondition( cond ) {
   return condition( cond );
 }
 
+function backlink( back, _csn, xsn ) {
+  if (back._redirected?.length && !gensrcFlavor && xsn?._main?.kind === 'entity')
+    return (back.on) ? condition( back.on ) : fkeys( back.foreignKeys );
+  return undefined;
+}
+
 function condition( node ) {
   const expr = exprInternal( node, 'no' );
   return (Array.isArray( expr ))
@@ -1309,9 +1314,17 @@ function exprInternal( node, xprParens ) {
       return cast( expression( node.args[0] ), node );
     case 'list':
       return extra( { list: node.args.map( expression ) }, node, 0 );
+    case 'and':
+      for (const arg of node.args) {
+        if (arg.$parens?.length)
+          continue;
+        if ((arg.op?.val === 'nary' || arg.op?.val === 'ixpr') &&
+            arg.args[1]?.val === 'or' &&
+            arg.args[1]?.literal === 'token')
+          arg.$parens = [ arg.location ];
+      }
+      // FALLTHROUGH
     default: {   // CSN v0 input (A2J: '='/'and'): binary (n-ary) and unary prefix
-      if (!node.args.length)
-        return { xpr: [] };
       const nary = [];
       for (const item of node.args)
         nary.push( { val, literal: 'token' }, item );
@@ -1323,10 +1336,16 @@ function exprInternal( node, xprParens ) {
       };
     }
   }
+  if (!node.args?.length)
+    return { xpr: [] };
   const rargs = node.args.map( exprInternal );
   if (val === 'xpr' || node.$parens)
     return extra( { xpr: flattenInternalXpr( rargs, val ) }, node, (xprParens === 'no' ? 0 : 1) );
-  return rargs.length === 1 ? rargs[0] : flattenInternalXpr( rargs, val );
+  // An 1-item 'ixpr' or 'nary' can (in general) be replaced by that one item.
+  // For lower *.sql diffs, not for 'xpr' in 'ixpr', produced before A2J recompilation.
+  return rargs.length === 1 && !rargs[0].xpr
+    ? rargs[0]
+    : flattenInternalXpr( rargs, val );
 }
 
 
@@ -1391,7 +1410,7 @@ function query( node, csn, xsn, _prop, expectedParens = 0 ) {
     const select = { SELECT: extra( standard( node ), node, expectedParens ) };
     // one paren pair is not put into XSN - TODO: change that?
     const elems = node.elements;
-    if (elems && node._main && node !== node._main._leadingQuery && gensrcFlavor !== true) {
+    if (elems && node._main && !isLeadingQuery( node ) && gensrcFlavor !== true) {
       // Set hidden 'elements' for csnRefs.js.  In select-item subqueries,
       // gensrcFlavor might have been set to 'column' and must be set to the
       // original value 'false' - otherwise no element appears.

package/node_modules/@sap/cds-compiler/lib/main.d.ts

@@ -345,6 +345,14 @@ declare namespace compiler {
      * @default true
      */
     resolveProjections?: boolean
+    /**
+     * If true, stringify annotation expression nodes as CDL-like text.
+     *
+     * Only expression-shaped nodes are stringified. Other annotation values stay unchanged.
+     *
+     * @default false
+     */
+    stringifyAnnoXpr?: boolean
     /**
      * If true, remap OData annotations to ABAP annotations.
      *

package/node_modules/@sap/cds-compiler/lib/main.js

@@ -200,6 +200,7 @@ module.exports = {
     compile: (...args) => compiler.compileX(...args),
     compileSync: (...args) => compiler.compileSyncX(...args),
     getArtifactName: art => base.getArtifactName(art),
+    getOrigin: art => (art._origin?.kind === '$tableAlias' ? art._origin._origin : art._origin),
     traverseSemanticTokens: (xsn, options) => lsp.traverseSemanticTokens(xsn, options),
     getSemanticTokenOrigin: obj => lsp.getSemanticTokenOrigin(obj),
     xsnToCsn: ( xsn, options ) => toCsn.compactModel( xsn, options ),

package/node_modules/@sap/cds-compiler/lib/model/csnUtils.js

@@ -8,6 +8,7 @@ const {
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
   mergeTransformers,
+  isSimpleAnnoExprRef,
 } = require('../transform/db/applyTransformations');
 const { isBuiltinType, isAnnotationExpression, primaryExprProperties } = require('../base/builtins');
 const { ModelError, CompilerAssertion } = require('../base/error');
@@ -926,6 +927,8 @@ function setDependencies( csn ) {
   const cleanup = [];
 
   forEachDefinition(csn, (artifact, artifactName) => {
+    if (!isPersistedOnDatabase(artifact))
+      return;
     const queries = getNormalizedQuery(artifact).query;
     if (queries) {
       initDependencies(artifact);
@@ -1510,6 +1513,7 @@ module.exports = {
   applyTransformationsOnNonDictionary,
   applyTransformationsOnDictionary,
   mergeTransformers,
+  isSimpleAnnoExprRef,
   setDependencies,
   isPersistedOnDatabase,
   isPersistedAsView,

package/node_modules/@sap/cds-compiler/lib/parsers/AstBuildingParser.js

@@ -1193,7 +1193,8 @@ class AstBuildingParser extends BaseParser {
     // see also isAnnotationExpression()
     if (!dict['=']) {
       const prop = dict['#'] && '#' ||
-        dict.xpr && Object.keys( dict ).length === 1 && 'xpr';
+        dict.xpr && Object.keys( dict ).length === 1 && 'xpr' ||
+        dict['...'] && Object.keys( dict ).length === 1 && '...';
       if (!prop)
         return;
       this.error( 'syntax-invalid-anno-struct', dict[prop].name.location,

package/node_modules/@sap/cds-compiler/lib/parsers/XprTree.js

@@ -262,8 +262,16 @@ function splitClauses( tree, isCsn ) {
   return (new XprTree( null, tree, !!isCsn || tree.location )).splitClauses();
 }
 
+// Operators that make an expression a predicate (condition) rather than a value.
+const MAX_PREDICATE_PRECEDENCE = 13;
+const predicateOperators = new Set( [
+  ...Object.keys( binaryOperators ).filter( op => binaryOperators[op] <= MAX_PREDICATE_PRECEDENCE ),
+  'exists', 'not',
+] );
+
 module.exports = {
   xsnAsTree: xprAsTree,
   csnAsTree: nodes => xprAsTree( nodes, nodes, true ),
   splitClauses,
+  predicateOperators,
 };

package/node_modules/@sap/cds-compiler/lib/render/toCdl.js

@@ -22,6 +22,7 @@ const { normalizeTypeRef, forEachDefinition } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/specialOptions');
 const { ModelError, CompilerAssertion } = require('../base/error');
+const { makeMessageFunction } = require('../base/messages');
 const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { isAnnotationExpression } = require('../base/builtins');
 const { forEach } = require('../utils/objectUtils');
@@ -2032,7 +2033,7 @@ class CsnToCdl {
         : this.quotePathIfRequired(annoValue['='], env);
     }
     // Ellipsis: `... up to <val>`
-    if (annoValue['...'] !== undefined) {
+    if (annoValue['...'] !== undefined && Object.keys( annoValue ).length === 1) {
       return (annoValue['...'] === true)
         ? '...'
         : `... up to ${ this.renderAnnotationValue(annoValue['...'], env) }`;
@@ -2714,7 +2715,10 @@ class CsnToCdl {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
+  // TODO: not quite sure why we split at '.' when quoting is needed
   quoteAnnotationPathIfRequired( anno, env ) {
+    if (anno === '...')
+      return this.quoteNonIdentifier(anno, env);
     return anno.split('.').map((segment) => {
       if (segment.startsWith('@'))
         return `@${ this.quoteNonIdentifier(segment.slice(1), env) }`;
@@ -3075,9 +3079,26 @@ function csnToCdl( csn, options, msg ) {
   return renderer.render();
 }
 
+/**
+ * Render a CSN expression object to CDL-like text.
+ *
+ * @param {object} expr CSN expression node
+ * @param {CdlOptions} [options]
+ * @param {object} [msg] Message functions
+ * @returns {string}
+ */
+function expressionToCdlString( expr, options = {}, msg = null ) {
+  const model = { $version: '2.0', definitions: Object.create(null) };
+  const messageFunctions = msg || makeMessageFunction(model, options, 'to-cdl');
+  const renderer = new CsnToCdl(model, options, messageFunctions);
+  const env = createEnv({ path: [] });
+  env.nameEnvStack.setRootScope(new DefinitionPathTree(), model);
+  return renderer.exprRenderer.renderExpr(expr, env);
+}
 
 module.exports = {
   csnToCdl,
+  expressionToCdlString,
   smartId: apiSmartId,
   smartFunctionId: apiSmartFunctionId,
   delimitedId: apiDelimitedId,

package/node_modules/@sap/cds-compiler/lib/render/toSql.js

@@ -31,7 +31,7 @@ const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
 const { pathId } = require('../base/csnRefs');
-const { transformExprOperators } = require('./utils/operators');
+const { transformExprOperators, isTopLevelPredicate } = require('./utils/operators');
 const { exprAsTree, condAsTree } = require('../base/xprAsTree');
 
 class SqlRenderEnvironment {
@@ -1183,7 +1183,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
       if (!col.as && col.ref?.[0] && isMagicVariable(pathId(col.ref?.[0])))
         col.as = implicitAs(col.ref);
 
-      result = env.indent + renderExpr(withoutCast(col), env);
+      // HANA rejects bare predicates in the select list; wrap them in CASE … WHEN.
+      result = env.indent + ((options.sqlDialect === 'hana' && isTopLevelPredicate(col))
+        ? wrapPredicateInCase(renderExpr({ xpr: col.xpr }, env))
+        : renderExpr(withoutCast(col), env));
       if (col.as)
         result += ` AS ${ quoteSqlId(col.as) }`;
       else if (col.func && !col.args) // e.g. CURRENT_TIMESTAMP
@@ -1728,6 +1731,18 @@ function toSqlDdl( csn, options, messageFunctions ) {
   }
 }
 
+/**
+ * Wrap a rendered predicate in `CASE WHEN <p> THEN TRUE WHEN NOT (<p>) THEN FALSE
+ * END`, as HANA requires for a predicate in the select list. The negated `WHEN`
+ * (not an `ELSE`) keeps a NULL predicate result as NULL rather than FALSE.
+ *
+ * @param {string} predicate Rendered predicate SQL
+ * @return {string}
+ */
+function wrapPredicateInCase( predicate ) {
+  return `CASE WHEN (${ predicate }) THEN TRUE WHEN NOT (${ predicate }) THEN FALSE END`;
+}
+
 /**
  * Render the given string for SQL databases.
  *

package/node_modules/@sap/cds-compiler/lib/render/utils/common.js

@@ -41,7 +41,12 @@ function renderFunc( funcName, node, renderArgs, utils ) {
   if (rewriteStandardFunctions) {
     // we check function arguments for correctness
     const { error } = messageFunctions;
-    const that = { renderArgs, error, path };
+    const that = {
+      renderArgs,
+      error,
+      path,
+      vector: { embeddingDefaultModel: options.vectorEmbeddingDefaultModel ?? 'SAP_GXY.20250407', embeddingHanaDefaultRemoteSource: options.vectorEmbeddingHanaDefaultRemoteSource ?? 'AI_CORE' },
+    };
     if (standardDatabaseFunctions[sqlDialect]?.[funcName])
       return standardDatabaseFunctions[sqlDialect][funcName].call(that, node);
     else if (standardDatabaseFunctions.common[funcName])

package/node_modules/@sap/cds-compiler/lib/render/utils/operators.js

@@ -2,6 +2,8 @@
 
 // Utilities to transform operators in expressions for SQL rendering.
 
+const { csnAsTree, predicateOperators } = require('../../parsers/XprTree');
+
 const operatorsPerDialect = {
   __proto__: null,
   plain: {
@@ -155,6 +157,31 @@ function transformExprOperators( xpr, options, messageFunctions, env ) {
   }
 }
 
+/**
+ * Whether the outermost operator of a column expression is a predicate (condition).
+ * Clones first because csnAsTree() restructures its input in place, and the column
+ * is structurized again for real when it is rendered.
+ *
+ * @param {object} col CSN column
+ * @returns {boolean}
+ */
+function isTopLevelPredicate( col ) {
+  if (!Array.isArray(col.xpr))
+    return false;
+  return isPredicateTree(csnAsTree(structuredClone(col.xpr)));
+}
+
+function isPredicateTree( tree ) {
+  const [ top ] = tree;
+  if (top && !Array.isArray(top) && top.xpr) // fully parenthesized: `( … )`
+    return isPredicateTree(csnAsTree(top.xpr));
+  if (!Array.isArray(top))
+    return false;
+  const op = typeof top[0] === 'string' ? top[0] : top[1];
+  return predicateOperators.has(op);
+}
+
 module.exports = {
   transformExprOperators,
+  isTopLevelPredicate,
 };