@sap/cds 8.5.0 → 8.6.0

package/lib/ql/SELECT.js

@@ -1,89 +1,102 @@
-const Whereable = require('./Whereable'), { parse, predicate4 } = Whereable
+const Whereable = require('./Whereable')
+const is_number = x => !isNaN(x)
 const cds = require('../index')
-
-module.exports = class Query extends Whereable {
-
-  get kind() { return 'SELECT' }
-  static _api() {
-    const $ = Object.assign
-    return $((..._)       => new this()._select_or_from(..._), {
-      localized: $((...x) => new this({localized:true})._select_or_from(...x),{
-        columns: (..._)   => new this({localized:true}).columns(..._),
-        from: (..._)      => new this({localized:true}).from(..._),
-      }),
-      distinct: $((...x)  => new this({distinct:true})._select_or_from(...x),{
-        columns: (..._)   => new this({distinct:true}).columns(..._),
-        from: (..._)      => new this({distinct:true}).from(..._),
-      }),
-      one: $((...x)       => new this({one:true})._select_or_from(...x),{
-        columns: (..._)   => new this({one:true}).columns(..._),
-        from: (..._)      => new this({one:true}).from(..._),
-        localized: (..._) => new this({one:true,localized:true}).from(..._)
-      }),
-      from: $((..._)      => new this().from(..._), {
-        localized: (..._) => new this({localized:true}).from(..._)
-      }),
-      columns: (..._)     => new this().columns(..._),
-    })
-  }
-
-  _select_or_from (cols, ...more) { // srv.read`title`.from`Books` or srv.read`Books` ?
-    if (!cols) return this
-    else if (is_number(cols)) return this.columns(...arguments) //> numbers can't be from
-    else if (cols.name) return this.from (...arguments) //> clearly a from
-    else if (cols.raw) { // tagged template string
-      if (cols[0].startsWith('from ')) { // SELECT`from ...`, with an arbitrary long CQL tail...
-        Object.assign (this.SELECT, SELECT_(' ',arguments))
-        return this
-      } else if (cols[0][0] === '{') {  // SELECT`{a,b}`... -> it's columns
-        let {columns:c} = SELECT_('from X', arguments)
-        return this._add('columns',c)
-      } else {                          // SELECT`Foo` -> ambiguous -> try parsing as columns...
-        let {columns:c} = SELECT_('from X {', arguments, '}')
-        if (c.length > 1 || !c[0].ref) return this._add('columns',c)
-        // else cols = c[0] //> goes on below...
+const $ = Object.assign
+
+class SELECT extends Whereable {
+
+  /** @type import('./cqn').SELECT['SELECT'] */
+  SELECT = {}
+
+  static call = (..._) => (new this)._select_or_from(..._) // SELECT `x`...
+  static API = {
+    columns:      (..._) => (new this).columns(..._),
+    from:       $((..._) => (new this).from(..._), {
+      localized:  (..._) => (new this).localized.from(..._)
+    }),
+    localized:  $((..._) => (new this).localized._select_or_from(..._),{
+      columns:    (..._) => (new this).localized.columns(..._),
+      from:       (..._) => (new this).localized.from(..._),
+    }),
+    distinct:   $((..._) => (new this).distinct._select_or_from(..._),{
+      localized:  (..._) => (new this).distinct.localized.from(..._),
+      columns:    (..._) => (new this).distinct.columns(..._),
+      from:       (..._) => (new this).distinct.from(..._),
+    }),
+    one:        $((..._) => (new this).one._select_or_from(..._),{
+      localized:  (..._) => (new this).one.localized.from(..._),
+      columns:    (..._) => (new this).one.columns(..._),
+      from:       (..._) => (new this).one.from(..._),
+    }),
+    read:         (..._) => (new this)._select_or_from(..._),
+    class: this
+  }
+
+  get localized() { this.SELECT.localized = true; return this }
+  get distinct() { this.SELECT.distinct = true; return this }
+  get one() { this.SELECT.one = true; return this }
+
+  /** @private */ _select_or_from (x,...etc) {
+    if (!x) return this
+    else if (x == '*') return this.columns (x,...etc)
+    else switch (typeof x) {
+      case 'string': {
+        if (etc.length) return this._ambiguous (x,...etc)
+        else (x = [x]).raw = x // single arg -> resolve in case 'object' block below
       }
-    } else {                          // SELECT('Foo'|'*',[...]|(foo)=>{})
-      if (cols === '*') return this.columns(...arguments)
-      const c = _columns_or_not (cols)
-      if (c) return this._add('columns',c)
-      if (typeof cols === 'string') {
-        try { parse.path(cols) }
-        catch { //> it can't be a from
-          try { return this.columns(...arguments) }
-          catch(e) {
-            if (!e.message.startsWith('CDS compilation failed')) throw e
-            this._expected `Argument ${{cols}} to be a valid argument for SELECT.from or .columns`
-          }
+      case 'object': { // eslint-disable-line no-fallthrough
+        if (x.raw) { // TODO: We might add a cache and reuse parsed [cqn,params] ...
+          const SELECT = cds.parse._select('',[x,...etc]), {columns:cols} = SELECT
+          if (SELECT.from || cols.length > 1 || !cols[0].ref) // SELECT `from Foo` | `a,b` | `max(a)`
+            return this._assign (SELECT)
+          const { columns:[{ expand, ...from }], ...more_clauses } = SELECT
+          if (expand) more_clauses.columns = expand  // SELECT `Foo {a,b}`
+          if (0 in Object.keys(more_clauses))       // SELECT `Foo where x=1`
+            return this._assign ({from}, more_clauses)
+          else return this._ambiguous (x,...etc)
         }
+        else if (Array.isArray(x)) return this.columns(x)
+        else if (x.kind === 'element') return this.columns (x,...etc)
+        else if (x.name) return this.from (x,...etc)
+        else if (x.ref) return this._ambiguous (x,...etc)
+        else if (x.from) return this._assign(x)
+        else if (x.SELECT || x.SET) return this.from(x)
+        else break
       }
+      default: return this.columns(x)
     }
+    throw this._expected `Argument for SELECT(${{x}}) to be a valid argument for SELECT.from or .columns`
+  }
 
-    // return a proxy assuming it's a from and switching to
-    // columns on a subsequent call of .from, if any.
+  /** @private */ _ambiguous (...xy) {
     const {SELECT:_} = this, {one} = _
-    return Object.defineProperties (this.from (cols, ...more), {
-      from: { configurable:true, value:(...args) => { delete this.from
-        if (!one) delete _.one; delete _.columns; delete _.where
-        return this.from (...args) .columns (cols, ...more)
-      }}
+    return this.from(...xy)._set('from', (...the_real_target) => {
+      if (!one) delete _.one; delete _.columns; delete this.from
+      return this.from (...the_real_target) .columns (...xy)
     })
   }
 
   columns (...cols) {
-    if (cols[0]) this._add ('columns', _columns(cols))
+    if (cols[0]) this._add ('columns', cds.ql.columns(...cols))
     return this
   }
 
-  from (target, second, third) {
-    this.SELECT.from = target === '*' || this._target_ref4 (...arguments)
-    if (!target.raw && second !== undefined) {
+  from (...args) {
+    const [target] = args
+    if (target.raw) {
+      let { from, ...more } = cds.parse._select ('from',args)
+      this.SELECT.from = this._target4 (from)
+      return this._assign(more)
+    }
+    this.SELECT.from = this._target4 (target)
+    const [,second,third] = args
+    if (second !== undefined) {
       if (third) {
         this.byKey(second)
         this.columns(third)
       } else {
-        const cols = _columns_or_not (second)
-        cols ? this._add('columns',cols) : this.byKey(second)
+        if (Array.isArray(second) || typeof second === 'function') this.columns(second)
+        else this.byKey(second)
       }
     }
     return this
@@ -95,19 +108,22 @@ module.exports = class Query extends Whereable {
   innerJoin (other, as) { return this.join (other, as, 'inner') }
   join (other, as, kind='inner') {
     const [, target, alias = as] = /(\S+)(?:\s+(?:as)?\s+(\S+))?/i.exec(other)
-    const ref = { ref: [target] }
-    if (alias) ref.as = alias
+    const ref = { ref: [target] }; if (alias) ref.as = alias
     this.SELECT.from = { join:kind, args: [this.SELECT.from, ref] }
     return Object.defineProperty(this, '_where_or_having', { value: 'on', configurable: true })
   }
   on (...args) {
-    if (!this.SELECT.from || !this.SELECT.from.join || !this.SELECT.from.args) // `join` can also be a function, e.g. in SELECT.from(SELECT.from('foo'))
-      throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
-    return this._where (args,'and','on')
+    const {from} = this.SELECT
+    if (!from?.join) throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
+    // string values in on clause are interpreted as refs, not vals
+    const [o] = args; if (typeof o === 'object' && !o.raw && !Array.isArray(o)) {
+      for (let a in o) if (typeof o[a] === 'string') o[a] = {ref:o[a].split('.')}
+    }
+    return this._where (args,'on',from)
   }
 
   having(...args) {
-    return this._where (args,'and','having')
+    return this._where (args,'having')
   }
 
   search (...args) {
@@ -118,13 +134,13 @@ module.exports = class Query extends Whereable {
 
   groupBy (...args) {
     if (!args[0]) return this
-    const cqn = args[0].raw ? SELECT_('from X group by', args).groupBy : args.map(parse.expr)
+    const cqn = args[0].raw ? cds.parse._select('from X group by', args).groupBy : args.map(cds.parse.ref)
     return this._add('groupBy',cqn)
   }
 
   orderBy (...args) {
     if (!args[0]) return this
-    return this._add('orderBy',_order_by(args))
+    return this._add('orderBy', cds.ql.orders(...args))
   }
 
   limit (rows, offset) {
@@ -153,101 +169,12 @@ module.exports = class Query extends Whereable {
     return super.valueOf('SELECT * FROM')
   }
 
-  get _target_ref(){ return this.SELECT.from }
+  /** @private */ get _target_ref(){ return this.SELECT.from }
 
   get elements() { return this.elements = cds.infer.elements4 (this.SELECT.columns, this.source) }
   set elements(e) { this._set('elements',e) }
 }
 
 
-const _columns = (args) => {
-  const x = args[0]
-  if (x.raw) {
-    if (x[0][0] === '{') return SELECT_('from X ',args).columns
-    else                 return SELECT_('from X {',args,'}').columns
-  } else {
-    if (typeof x === 'string' && x[0] === '{') return parse.cql('SELECT from X '+ x).SELECT.columns
-    else return _columns_or_not(x) || args.map(_column_expr)
-  }
-}
-
-const _columns_or_not = (x) => {
-  if (typeof x === 'function') return _projection4(x)
-  if (Array.isArray(x)) return x.map(_column_expr)
-}
-
-const _column_expr = (x) => {
-  if (is_cqn(x)) return x
-  if (typeof x === 'string') return parse.column(x)
-  if (typeof x === 'object') for (let one in x) return Object.assign(parse.expr(one),{as:x[one]})
-  else return {val:x}
-}
-
-const _projection4 = (fn) => {
-  const columns=[]; fn (new Proxy (fn,{
-    apply: (_, __, args) => { // handle top-level projections such as (foo)=>{ foo('*') }
-      if (!args.length) return columns.push('*')
-      let [x] = Array.isArray(args[0]) ? args[0] : args
-      columns.push (x === '*' || x === '.*' ? '*' : is_cqn(x) ? x : {ref:[x]})
-      return { as: (alias) => (x.as = alias) }
-    },
-    get: (_, p) => { // handle top-level paths like (foo)=>{ foo.bar }
-      const col = {ref:[p]}; columns.push(col)
-      const nested = new Proxy(fn,{ // handle n-fold paths like (foo)=>{ foo.bar.car }
-        get: (_, p) => {
-          if (p === 'where') return (x) => ((col.where = predicate4([x])), nested)
-          if (p === 'as') return (alias) => ((col.as = alias), nested)
-          else return col.ref.push(p), nested
-        },
-        apply: (_, __, args) => { // handle nested projections e.g. (foo)=>{ foo.bar (b=>{ ... }) }
-          const [a, b] = args
-          if (!a) col.expand = ['*']
-          else if (a.raw) switch (a[0]) {
-            case  '*': col.expand = ['*']; break
-            case '.*': col.inline = ['*']; break
-            default: Object.assign (col, SELECT_(col.ref.at(-1)+' ', args, ' from X').columns[0])
-          }
-          else if (Array.isArray(a)) col.expand = _columns(a)
-          else if (a === '*') col.expand = ['*']
-          else if (a === '.*') col.inline = ['*']
-          else if (typeof a === 'string') col.ref.push(a)
-          else if (typeof a === 'function') {
-            let x = (col[/^\(?_\b/.test(a) ? 'inline' : 'expand'] = _projection4(a))
-            if (b?.levels) while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
-          } else if (typeof b === 'function') {
-            let x = (col[/^\(?_\b/.test(b) ? 'inline' : 'expand'] = _projection4(b))
-            if (a?.depth) while (--a.depth) x.push({ ...col, expand: (x = [...x]) })
-          }
-          return nested
-        },
-      })
-      return nested
-    },
-  }))
-  return columns
-}
-
-const _order_by = (args) => {
-  if (args[0].raw) return SELECT_('from X order by', args).orderBy
-  if (Array.isArray(args[0])) args = args[0]
-  const cqn=[], _add = (ref,ad) => {
-    const obx = parse.expr(ref); cqn.push(obx)
-    if (ad) obx.sort = ad == 1 ? 'asc' : ad == -1 ? 'desc' : ad
-  }
-  for (let each of args) {
-    if (each.ref) cqn.push(each)
-    else if (typeof each === 'string') _add (...each.split(' '))
-    else for (let ref in each) _add (ref, each[ref])
-  }
-  return cqn
-}
-
-const {CQL} = parse, SELECT_ = (prefix, [ strings, ...more ], suffix) => {
-  const tts = [...strings]; tts.raw = true
-  if (prefix) tts[0] = `SELECT ${prefix} ${tts[0]}`
-  if (suffix) tts[tts.length-1] += ` ${suffix}`
-  return CQL(tts,...more).SELECT
-}
-
-const is_cqn = x => x === undefined || x === '*' || x.val !== undefined || x.xpr || x.ref || x.list || x.func || x.SELECT
-const is_number = x => !isNaN(x)
+/** @type SELECT.API & (...columns:string[]) => SELECT */
+module.exports = SELECT.init()

package/lib/ql/UPDATE.js

@@ -1,18 +1,19 @@
 const Whereable = require('./Whereable')
-const { parse } = require('../index')
+const cds = require('../index')
 
-module.exports = class Query extends Whereable {
+class UPDATE extends Whereable {
 
-  get kind() { return 'UPDATE' }
-  static _api() {
-    return Object.assign ((..._) => (new this).entity(..._), {
-      entity: (..._) => (new this).entity(..._),
-    })
+  /** @type import('./cqn').UPDATE['UPDATE'] */
+  UPDATE = {}
+
+  static call = (..._) => (new this).entity(..._)
+  static API = { class:this,
+    entity: (..._) => (new this).entity(..._)
   }
 
-  entity (e, key) {
-    this.UPDATE.entity = this._target4 (...arguments) // supporting tts
-    if (key !== undefined) this.byKey(key)
+  entity (e, ...etc) {
+    this.UPDATE.entity = this._target4 (e, ...etc) // supporting tts
+    if (!e.raw && etc.length) this.byKey(etc[0])
     return this
   }
 
@@ -30,8 +31,7 @@ module.exports = class Query extends Whereable {
 
     // A tagged template string with a single expression, e.g. .with `my.stock -= 1`
     if (args[0].raw) {
-      let [lhs,op,...rhs] = parse.CXL(...args).xpr || this._expected `${{args}} to contain expressions of form 'column = <expr>'`
-      _add (this, lhs.ref.join('.'), op, ...rhs)
+      _add (this, ..._parse_set_expr (this, String.raw(...args)))
     }
 
     // Alternating expr fragment / values args, e.g. .with ('my.stock -=',1, 'lastOrder =', '$now')
@@ -45,8 +45,7 @@ module.exports = class Query extends Whereable {
     // A single string with comma-separated expressions, e.g. .with ('my.stock -= 1, lastOrder = $now')
     else if (typeof args[0] === 'string') {
       for (let each of _comma_separated_exprs(args[0])) {
-        let [lhs,op,...rhs] = parse.expr(each).xpr || this._expected `${{args}} to contain expressions of form 'column = <expr>'`
-        _add (this, lhs.ref.join('.'), op, ...rhs)
+        _add (this, ..._parse_set_expr (this, each))
       }
     }
 
@@ -97,4 +96,14 @@ const _comma_separated_exprs = (s) => {
   return all
 }
 
+const _parse_set_expr = (q,expr) => {
+  const [,lhs,rhs] = /^\s*(\w+)\s*=\s*(.*)/.exec(expr)
+    || q._expected `${{expr}} to contain expressions of form 'column = <expr>'`
+  return [ lhs, '=', cds.parse.expr(rhs) ]
+}
+
 const operators = { '=':1, '-=':2, '+=':2, '*=':2, '/=':2, '%=':2 }
+
+
+/** @type UPDATE.API & (...entries:[]) => UPDATE */
+module.exports = UPDATE.init()

package/lib/ql/UPSERT.js

@@ -1,3 +1,16 @@
-module.exports = class Query extends require('./INSERT') {
-  get kind() { return 'UPSERT' }
+const { class:INSERT } = require('./INSERT')
+class UPSERT extends INSERT {
+
+  /** @type import('./cqn').UPSERT['UPSERT'] */
+  UPSERT = {}
+
+  constructor() { delete super().INSERT }
+  static call = (..._) => (new this).entries(..._)
+  static API = { class:this,
+    into: (..._) => (new this).into(..._)
+  }
+
 }
+
+/** @type UPSERT.API & (...entries:[]) => UPSERT */
+module.exports = UPSERT.init()

package/lib/ql/Whereable.js

@@ -1,131 +1,57 @@
-const { error } = require ('../index')
 const cds = require('../index')
-const parse = require('./parse')
+const Query = require('./cds.ql-Query')
 
-class Query extends require('./Query') {
 
-  where(...x) { return this._where (x,'and','where') }
-  and(...x) {  return this._where (x,'and') }
-  or(...x) { return this._where (x,'or') }
-  _where (args, and_or, _where) {
-    if (!args[0]) return this
-    let pred = predicate4(args, _where)
-    if (pred && pred.length > 0) {
-      let {_} = this
-      const clause = _where ?? (
-        _.having ? 'having' :
-        _.where ? 'where' :
-        _.from?.on ? 'on' :
-        error (`Invalid attempt to call '${this.kind}.${and_or}()' before a prior call to '${this.kind}.where()'`)
-      )
-      if (clause === 'on') _ = _.from
-      let left = _[clause]
-      if (!left) { //> .where() called first time
-        // SELECT.from `X` .where `x or y` .and `z` -> SELECT from X where (x or y) and z
-        if (pred.includes('or')) this._left_has_or = true
-        _[clause] = pred
-      } else { //> .where(), .and(), .or() called successively
-        if (_where) {
-          // SELECT.from `X` .where `x` .or `y` .where `z` -> SELECT from X where (x or y) and z
-          if (left.includes('or')) left = [{xpr:left}]
-        } else if (and_or === 'and') {
-          // SELECT.from `X` .where `x` .or `y` .and `z` -> SELECT from X where x or y and z
-          if (this._left_has_or) { left = [{xpr:left}]; delete this._left_has_or }
-        }
-        // SELECT.from `X` .where `x` .and `y or z` -> SELECT from X where x and (y or z)
-        if (pred.includes('or')) pred = [{xpr:pred}]
-        _[clause] = [ ...left, and_or, ...pred ]
-      }
+class Whereable extends Query {
+
+  where (...args) { return this._where (args) }
+  and (...args) { return this._and_or ('and',args) }
+  or (...args) { return this._and_or ('or',args) }
+
+  /** @protected */
+  _where (args, clause='where', cqn=this._) {
+    let tail = cds.ql.predicate(...args); if (!tail?.length) return this
+    let head = cqn[clause]
+    if (!head) cqn[clause] = tail
+    else { //> always wrap ORs on subsequent .where() calls, as these happen somewhere else
+      if (head.includes('or')) head = [{xpr:head}]
+      if (tail.includes('or')) tail = [{xpr:tail}]
+      cqn[clause] = [ ...head, 'and', ...tail ]
     }
+    this._clause = this._direct = clause
     return this
   }
 
-  byKey(key) {
-    if (typeof key !== 'object' || key === null) key = { [Object.keys(this._target.keys||{ID:1})[0]]: key }
-    if (this.SELECT) this.SELECT.one = true
-    if (cds.env.features.keys_into_where) return this.where(key)
-    if (this.UPDATE) { this.UPDATE.entity = { ref: [{ id: this.UPDATE.entity.ref.at(-1), where: predicate4([key]) }] }; return this }
-    if (this.SELECT) { this.SELECT.from.ref[this.SELECT.from.ref.length-1] = { id: this.SELECT.from.ref.at(-1), where: predicate4([key]) }; return this }
-    if (this.DELETE) { this.DELETE.from = { ref: [{ id: this.DELETE.from.ref.at(-1), where: predicate4([key]) }] }; return this }
-    return this.where(key)
-  }
-}
-
-const predicate4 = (args, _clause) => {
-  if (args.length === 0) return; /* else */ const x = args[0]
-  if (x.raw) {
-    let cxn = parse.CXL(...args)
-    return cxn.xpr ?? [cxn] //> the fallback is for single-item exprs like `1` or `ref`
-  }
-  if (args.length === 1 && typeof x === 'object') {
-    if (is_array(x)) return x
-    if (is_cqn(x)) return args
-    else return _object_predicate(args,_clause)
+  /** @private */
+  _and_or (ao, args) {
+    let clause = this._clause ??= ( //> some projects use .and()/.or() with manually filled in .where
+      this._.having ? 'having' :
+      this._.where ? 'where' :
+      this._.from?.on ? 'on' :
+      cds.error `Unexpected use of .${ao}() without prior .where(), .having(), or .on()`
+    )
+    let tail = cds.ql.predicate(...args); if (!tail?.length) return this
+    let cqn = clause === 'on' ? this._.from : this._
+    let head = cqn[clause], direct = this._direct; delete this._direct
+    if (direct && ao === 'and') //> wrap ORs for .and() directly following .where()
+      if (head.includes('or')) head = [{xpr:head}]
+    if (tail.includes('or')) tail = [{xpr:tail}]
+    cqn[clause] = [ ...head, ao, ...tail ]
+    return this
   }
-  else return _fluid_predicate(args)
-}
 
-const _object_predicate = ([arg], _clause) => { // e.g. .where ({ID:4711, stock: {'>=':1})
-  const pred = []
-  for (const k in arg) {
-    const x = arg[k]
-    if (k === 'and') {
-      if (x.or) pred.push('and', {xpr:predicate4([x],_clause)})
-      else pred.push('and', ...predicate4([x],_clause))
-      continue
-    }
-    if (k === 'or') {
-      pred.push('or', ...predicate4([x],_clause))
-      continue
-    }
-    if (k === 'not') {
-      pred.push('not', {xpr:predicate4([x],_clause)})
-      continue
-    }
-    if (k === 'exists') {
-      pred.push('and', 'exists', typeof x === 'object' ? x : { ref: x.split('.') })
-      continue
-    }
-    if (k === 'not exists') {
-      pred.push('and', 'not', 'exists', typeof x === 'object' ? x : { ref: x.split('.') })
-      continue
-    }
-    if (k === 'in') {
-      pred.push('in', val(x))
-      continue
-    }
-    else pred.push('and', parse.expr(k))
-    if (!x || x==='*') pred.push('=', {val:x})
-    else if (x.SELECT || x.list) pred.push('in', x)
-    else if (is_array(x)) pred.push('in', {list:x.map(val)})
-    else if (is_cqn(x)) pred.push('=', x)
-    else if (x instanceof Buffer) pred.push('=', {val:x})
-    else if (x instanceof RegExp) pred.push('like', {val:x})
-    else if (x instanceof Date) pred.push('=', {val:x})
-    else if (typeof x === 'object') for (let op in x) x[op]?.in ? pred.push(op, ...predicate4([x[op]],_clause)) : pred.push(op, val(x[op])) // REVIST: Should always be proper recursion
-    else if (_clause === 'on' && typeof x === 'string') pred.push('=', { ref: x.split('.') })
-    else pred.push('=', {val:x})
+  byKey (key) {
+    if (typeof key !== 'object' || key === null)
+      key = cds.env.features.keys_as_val ? { val: key } : { [Object.keys(this._target.keys||{ID:1})[0]]: key }
+    if (this.SELECT) this.SELECT.one = true
+    if (cds.env.features.keys_into_where) return this.where(key)
+    const {ref} = this._target_ref
+    ref[ref.length-1] = { id: ref.at(-1), where: cds.ql.predicate(key) }
+    return this
   }
-  return pred[0] === 'and' ? pred.slice(1) : pred
-}
 
-const _fluid_predicate = (args) => { // e.g. .where ('ID=',4711, 'and stock >=',1)
-  if (args.length === 3 && args[1] in operators) return [ ref(args[0]), args[1], val(args[2]) ] // REVISIT: Legacy!
-  if (args.length % 2 === 0) args.push('')
-  const expr = args.filter((_, i) => i % 2 === 0).join(' ? ')
-  const vals = args.filter((_, i) => i % 2 === 1)
-  const {xpr} = parse.expr(expr)
-  ;(function _fill_in_vals_into (xpr) { xpr.forEach ((x,i) => {
-    if (x.xpr) _fill_in_vals_into (x.xpr)
-    if (x.param) xpr[i] = val(vals.shift())
-  })})(xpr)
-  return xpr
+  /** @private */ set _clause (clause) { this._set('_clause',clause) }
+  /** @private */ set _direct (clause) { this._set('_direct',clause) }
 }
 
-const ref = x => is_cqn(x) ? x : {ref:x.split('.')}
-const val = x => !x ? {val:x} : is_array(x) ? {list:x.map(val)} : is_cqn(x) ? x : {val:x}
-const is_cqn = x => x.val !== undefined || x.xpr || x.ref || x.list || x.func || x.SELECT
-const is_array = Array.isArray
-const operators = { '=':1, '<':2, '<=':2, '>':2, '>=':2, '!=':3, '<>':3, in:4, like:4, IN:4, LIKE:4 }
-
-module.exports = Object.assign (Query, { predicate4, parse })
+module.exports = Whereable