@sap/cds 5.5.2 → 5.6.0

package/lib/env/index.js

@@ -1,10 +1,9 @@
 const { isfile, fs } = require('../utils')
 const DEFAULTS = require('./defaults'), defaults = require.resolve ('./defaults')
-const user_home = require('os').homedir()
+const os_user_home = require('os').homedir()
 const compat = require('./compat')
 const path = require('path')
 
-
 /**
  * Both a config inctance as well as factory for.
  */
@@ -30,38 +29,73 @@ class Config {
     this._profiles = _determineProfilesFrom (process.env)
     this._profiles._defined = new Set()
 
-    // compat requires default values
+    // 1. set compat requires default values
     if (_context === 'cds' && _defaults)  this.add (DEFAULTS, defaults)
     if (_context === 'cds' && _defaults)  compat (this)
     if (!_home)  return
 
-    // 1. fill-in defaults for process.env, unless already defined
+    // fill-in defaults to process.env, unless already defined => 4.
     this._add_to_process_env (_home, 'default-env.json')
-    // 1.5 additional env for dev
+
+    // additional env for dev => 4.
     if (process.env.NODE_ENV !== 'production') {
       this._add_to_process_env (_home, '.env')
     }
 
+    const sources = Config.sources(_home, _context)
+
     // 2. read config sources in defined order
-    if (_context === 'cds') {
-      this._load (user_home, '.cdsrc.json')
-      this._load (_home, '.cdsrc.json')
+    for (const source of sources) {
+      this._load(source.path, source.file, source.mapper, this._profiles, false)
+    }
+
+    // 3. read important (!) profiles from config sources in defined order
+    const overwriteProfiles = new Set(this.profiles.map( profile => `${profile}!` ).filter( profile => this._profiles._defined.has( profile ) ));
+    if (overwriteProfiles.size > 0) {
+      for (const source of sources) {
+        this._load(source.path, source.file, source.mapper, overwriteProfiles, true)
+      }
     }
-    this._load (_home, 'package.json', p => p[_context])
-    this.add (_process_env4(_context), '{process.env}')
 
-    // 3. link dependant services (through kind/use)
+    // 4. add process env
+    this._add_process_env(_context, _home)
+
+    // 6. link dependant services (through kind/use)
     this._link_required_services()
-    // 4. complete service configurations from VCAP
+    // 7. complete service configurations from VCAP
     this._add_vcap_services (process.env.VCAP_SERVICES)
 
-    // 5. Add compatibility for mtx
+    // 8. Add compatibility for mtx
     if (this.requires && this.requires.db) {
       if (this.requires.multitenancy !== undefined) {
         Object.defineProperty(this.requires.db, 'multiTenant', { value: !!this.requires.multitenancy })
       }
       else if (this.requires.db.multiTenant !== undefined) this.requires.multitenancy = this.requires.db.multiTenant
     }
+
+    // Only if feature is enabled
+    this._emulate_vcap_services()
+  }
+
+  /**
+   * Get configuration sources
+   *
+   * @param {string} home Project home
+   * @param {string} context configuration context literal
+   */
+  static sources(home, context = 'cds', ) {
+    if (!home) throw new Error('Missing parameter "home".')
+    const user_home = process.env.CDS_USER_HOME || os_user_home
+
+    let sources = [
+      { name: 'USER_HOME', path: user_home, file: '.cdsrc.json' },
+      { name: 'PROJECT', path: home, file: '.cdsrc.json' },
+      { name: 'PACKAGE', path: home, file: 'package.json', mapper: p => p[context] },
+      { name: 'PRIVATE', path: home, file: '.cdsrc-private.json' }
+    ]
+
+    if (context !== 'cds') sources = sources.filter( source => source.name === 'PACKAGE' )
+    return sources
   }
 
   /**
@@ -122,7 +156,7 @@ class Config {
    * For BAS only: get all defined profiles (could include some from the defaults)
    */
   get "defined-profiles" () {
-    return Array.from (this._profiles._defined)
+    return Array.from (new Set(Array.from(this._profiles._defined).map( profile => profile.endsWith("!") ? profile.slice(0, -1) : profile)))
   }
 
   get profiles() {
@@ -137,15 +171,26 @@ class Config {
 //
 
 
-  _load (cwd, file, _conf=o=>o) {
+/**
+ * Load from JSON file or directory
+ *
+ * No profile support!
+ */
+_loadFromPath (_path, _basePath) {
+    if (_basePath && !path.isAbsolute(_path)) _path = path.join(_basePath, _path)
+    const json = _readJson (_path) || _readFromDir (_path)
+    if (json) this.add (json, _path, new Set())
+  }
+
+  _load (cwd, file, _conf=o=>o, profiles, profiles_only) {
     const json = _readJson (file = path.join(cwd, file))  // only support JSON
-    if (json) this.add (_conf (json), file)
+    if (json) this.add (_conf (json), file, profiles, profiles_only)
   }
 
-  add (conf, /*from:*/ _src) {
+  add (conf, /*from:*/ _src, profiles = this._profiles, profiles_only = false) {
     if (!conf)  return this
     if (_src)  this._sources.push (_src)
-    _merge (this, conf, this._profiles)
+    _merge (this, conf, profiles, undefined, profiles_only)
     return this
   }
 
@@ -165,14 +210,44 @@ class Config {
     }
   }
 
+
+  _add_process_env (prefix, basePath) {
+    const {env} = process
+    const PREF = prefix.toUpperCase(), my = { CONFIG: PREF+'_CONFIG', ENV: PREF+'_ENV' }
+    const configEnvValue = env[my.CONFIG]
+    let config
+    try {
+      // CDS_CONFIG={ /* json */}
+      config = JSON.parse (configEnvValue)
+    } catch (e) {
+      // CDS_CONFIG=/path/to/config.json *OR* CDS_CONFIG=/path/to/config/dir
+      if (configEnvValue && typeof configEnvValue === "string") this._loadFromPath (configEnvValue, basePath)
+    }
+
+    if (!config) config = {}
+    const pref_ = RegExp('^'+prefix+'[._]','i')
+    for (let p in env) if (!(p in my) && pref_.test(p)) {
+      const key = /[a-z]/.test(p) ? p : p.toLowerCase() //> CDS_FOO_BAR -> cds_foo_bar
+      const path = key.slice(prefix.length+1) .split (key[prefix.length]) //> ['foo','bar']
+      for (var o=config,next;;) {
+        next = path.shift()
+        if (!path.length) break
+        o = o[next] || (o[next] = {})
+      }
+      o[next] = _value4(env[p])
+    }
+
+    this.add(config, '{process.env}')
+  }
+
   _link_required_services () {
-    const { requires } = this
+    const { requires } = this, protos = requires && requires._prototypes || {}
     for (let each in requires)  requires[each] = _merged (each)
     function _merged (key) {
-      const entry = requires[key]
-      if (entry._is_merged || entry.kind === key || !(entry.kind in requires)) return entry
+      const entry = requires[key] || protos[key]
+      if (!entry || entry._is_merged || entry.kind === key || !(entry.kind in requires) && !(entry.kind in protos)) return entry
       const clone = _merge ({}, _merged (entry.kind))        // first apply inherited data
-      _merge (clone, entry, false, false, o => _merge({},o)) // then apply overridden data
+      _merge (clone, entry, false, false) // then apply overridden data
       return Object.defineProperty (clone, '_is_merged', {value:true})
     }
   }
@@ -190,6 +265,14 @@ class Config {
     }
   }
 
+  /**
+   * Build VCAP_SERVICES for compatibility (for example for CloudSDK) or for running
+   * locally with credentials (hybrid mode).
+   */
+  _emulate_vcap_services() {
+    if (!(this.features && this.features.emulate_vcap_services)) return
+    process.env.VCAP_SERVICES = JSON.stringify(build_vcap_services(this))
+  }
 
 //////////////////////////////////////////////////////////////////////////
 //
@@ -226,7 +309,7 @@ class Config {
 /**
  * @returns {Config} dst
  */
-function _merge (dst, src, _profiles, _cloned) {
+function _merge (dst, src, _profiles, _cloned, _profiles_only = false) {
   const profiled = [], descr = Object.getOwnPropertyDescriptors(src)
   for (let p in descr) {
     const pd = descr[p]
@@ -239,39 +322,65 @@ function _merge (dst, src, _profiles, _cloned) {
     if (_profiles && p[0] === '[') {
       if (_profiles._defined)  _profiles._defined.add (p.slice(1,-1))
       if (_profiles.has(p.slice(1,-1)))
-        profiled.push (()=> _merge (dst, src[p], _profiles, _cloned))
+        profiled.push (()=> _merge (dst, src[p], _profiles, _cloned, false))
       continue
     }
 
     const v = pd.value
     if (typeof v === 'object' && !Array.isArray(v)) {
       if (!dst[p]) dst[p] = {}; else if (_cloned)  dst[p] = _cloned(dst[p])
-      _merge (dst[p], v, _profiles, _cloned)
+      _merge (dst[p], v, _profiles, _cloned, _profiles_only)
       continue
     }
 
-    if (v !== undefined) dst[p] = v
+    if (!_profiles_only && v !== undefined) dst[p] = v
   }
   for (let each of profiled) each()
   return dst
 }
 
-function _process_env4 (prefix) {
-  const {env} = process
-  const PREF = prefix.toUpperCase(), my = { CONFIG: PREF+'_CONFIG', ENV: PREF+'_ENV' }
-  const out = JSON.parse (env[my.CONFIG] || '{}')
-  const pref_ = RegExp('^'+prefix+'[._]','i')
-  for (let p in env) if (!(p in my) && pref_.test(p)) {
-    const key = /[a-z]/.test(p) ? p : p.toLowerCase() //> CDS_FOO_BAR -> cds_foo_bar
-    const path = key.slice(prefix.length+1) .split (key[prefix.length]) //> ['foo','bar']
-    for (var o=out,next;;) {
-      next = path.shift()
-      if (!path.length) break
-      o = o[next] || (o[next] = {})
+function _readFromDir (p, isDir) {
+  if (typeof isDir === "undefined") {
+    try {
+      const entry = fs.statSync(p)
+      if (entry.isDirectory()) {
+        isDir = true
+      } else if (isFile(p, entry)) {
+        isDir = false
+      } else {
+        return undefined
+      }
+    } catch (e) {
+      return undefined
+    }
+  }
+  if (isDir) {
+    const result = {}
+    const entries = fs.readdirSync(p, {withFileTypes: true})
+    for (let entry of entries) {
+      const entryPath = path.join(p, entry.name)
+      if (entry.isDirectory()) {
+        result[entry.name] = _readFromDir(entryPath, true)
+      } else if (isFile(entryPath, entry)) {
+        result[entry.name] = _readFromDir(entryPath, false)
+      }
     }
-    o[next] = _value4(env[p])
+    return result
+  } else {
+    return _value4(fs.readFileSync(p, "utf-8"))
+  }
+}
+
+function isFile(p, entry) {
+  if (entry.isFile()) return true
+  if (entry.isSymbolicLink()) {
+    // Kubernetes credentials use symlinks
+    const target = fs.realpathSync(p)
+    const targetStat = fs.statSync(target)
+
+    if (targetStat.isFile()) return true
   }
-  return out
+  return false
 }
 
 function _value4 (val) {
@@ -288,6 +397,7 @@ function _add_vcap_services_to (env, vcaps={}) {
   let any
   for (let service in env.requires) {
     const conf = env.requires [service]
+    if (!conf) continue
     const { credentials } = (
       conf.vcap && _fetch (conf.vcap) ||  //> alternatives, e.g. { name:'foo', tag:'foo' }
       _fetch ({ name: service })  ||
@@ -297,7 +407,9 @@ function _add_vcap_services_to (env, vcaps={}) {
       {/* not found */}
     )
     // Merge `credentials`.  Needed because some app-defined things like `credentials.destination` must survive.
-    if (credentials)  any = conf.credentials = Object.assign ({}, conf.credentials, credentials)
+    if (credentials)  {
+      any = conf.credentials = Object.assign ({}, conf.credentials, credentials)
+    }
   }
   return any
 
@@ -347,6 +459,28 @@ function set (o,p,value) {
   return value
 }
 
+function build_vcap_services(env) {
+  let v = {}
+  let names = new Set()
+
+  for (const service in env.requires) {
+    let { vcap, credentials, binding } = env.requires[service]
+    // "binding.vcap" is chosen over "vcap" because it is meta data resolved from the real service (-> cds bind)
+    if (binding && binding.vcap) vcap = binding.vcap
+    if (vcap && vcap.label && credentials && Object.keys(credentials).length > 0) {
+      // Only one entry for a (instance) name. Generate name from label and plan if not given.
+      const { label, plan } = vcap
+      const name = vcap.name || `instance:${label}:${plan || ""}`
+      if (names.has(name)) continue
+      names.add(name)
+
+      if (!v[label]) v[label] = []
+      v[label].push(Object.assign({ name }, vcap, { credentials }))
+    }
+  }
+
+  return v
+}
 
 /** @type Config & typeof DEFAULTS */
 module.exports = Config.prototype.for('cds')

package/lib/env/requires.js

@@ -9,11 +9,14 @@ module.exports = {
   },
   "auth": {
     '[development]': { kind: 'mocked-auth' },
-    '[production]': { kind: 'JWT-auth' }
+    '[production]': { kind: 'jwt-auth' }
   },
   "dummy-auth": {
     strategy: 'dummy',
   },
+  "basic-auth": {
+    kind: "mocked-auth"
+  },
   "mocked-auth": {
     strategy: 'mock',
     users: {
@@ -22,10 +25,22 @@ module.exports = {
       '*': true
     }
   },
-  "JWT-auth": {
+  "jwt-auth": {
     strategy: 'JWT',
   },
-  destinations: undefined,
+  "xsuaa-auth": {
+    strategy: 'xsuaa',
+  },
+  destinations: {
+    vcap: {
+      label: 'destination'
+    }
+  },
+  xsuaa: {
+    vcap: {
+      label: 'xsuaa'
+    }
+  },
   monitoring: undefined,
   logging: undefined,
   audit: undefined,
@@ -99,6 +114,12 @@ module.exports = {
     // model: 'AuditLogService.cds',
     outbox: true,
     vcap: { label: "auditlog" },
+  },
+
+  _prototypes: {
+    "uiflex": {
+      "model": "@sap/cds/libx/_runtime/fiori/uiflex/extensibility"
+    },
   }
 }
 

package/lib/i18n/localize.js

@@ -38,10 +38,14 @@ function localizeString (aString, bundle) {
   if (!bundle)  return aString
   // quick check for presence of any text key, to avoid expensive operation below
   if (aString.indexOf(TEXT_KEY_MARKER) < 0)  return aString
-
-  return aString.replace (TEXT_KEYS, // always creates a new loong string
-    (_, left='', key, right='') => `"${left}${bundle[key]||key}${right}"`
-  )
+  const isXml = aString.startsWith('<?xml')
+  const isJson = /^[{[]/.test(aString)
+  return aString.replace (TEXT_KEYS, (_, left='', key, right='') => {
+    let val = bundle[key] || key
+    if      (val && isXml)   val = escapeXmlAttr(val)
+    else if (val && isJson)  val = escapeJson(val)
+    return `"${left}${val}${right}"`
+  })
 }
 
 
@@ -206,4 +210,27 @@ function loadFromCSV (res, lang=DefaultLanguage) {
   }
 }
 
+// TODO use compiler API for XML escaping
+function escapeXmlAttr (str) {
+  // first regex: replace & if not followed by apos; or quot; or gt; or lt; or amp; or #
+  // Do not always escape > as it is a marker for {i18n>...} translated string values
+  let result = str;
+  if (typeof str === 'string') {
+    result = str.replace(/&(?!(?:apos|quot|[gl]t|amp);|#)/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/"/g, '&quot;')
+      .replace(/\r\n|\n/g, '&#xa;');
+    if (!result.startsWith('{i18n>') && !result.startsWith('{bi18n'))
+      result = result.replace(/>/g, '&gt;')
+  }
+  return result;
+}
+
+function escapeJson (str) { return str
+    .replace(/"/g, '\\"')
+    .replace(/\\t/g, '\\t')
+    .replace(/\\n/g, '\\n')
+}
+
+
 /* eslint no-console:off */

package/lib/index.js

@@ -15,6 +15,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
     })}
     get context() { return require('./req/context').for(this) }
     set context(_){ require('./req/context').for(this,_) }
+    get spawn() { return super.spawn = require('./req/context').spawn }
 
     emit (eve, ...args) {
       if (eve === 'served') return Promise.all (this.listeners(eve).map (l => l.call(this,...args)))
@@ -63,11 +64,12 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
 
     // Core Services API
     Service: require ('./serve/Service-api'),
-    Request: require ('./req/impl'),
+    EventContext: require ('./req/context'),
+    Request: require ('./req/request'),
     Event: require ('./req/event'),
     User: require ('./req/user'),
     ql: require ('./ql'),
-    spawn: lazy => cds.Event.spawn,
+    tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
     /** @type Service */ db: undefined,
 
     // Protocols and Periphery
@@ -75,7 +77,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
     MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
     DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
     RemoteService: lazy => require('../libx/_runtime/rest/service.js'),
-    odata: require('../libx/_runtime/odata'),
+    odata: require('../libx/odata'),
 
     // Helpers
     localize: require ('./i18n/localize'),
@@ -98,7 +100,6 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
   extend (cds.__proto__) .with ({
     get entities(){ return (cds.db||_missing).entities },
     transaction: (..._) => (cds.db||_missing).transaction(..._),
-    tx:          (..._) => (cds.db||_missing).tx(..._),
     run:         (..._) => (cds.db||_missing).run(..._),
     foreach:     (..._) => (cds.db||_missing).foreach(..._),
     stream:      (..._) => (cds.db||_missing).stream(..._),
@@ -130,10 +131,10 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
 
   // Check Node.js version
   if (process.env.CDS_STRICT_NODE_VERSION !== 'false' && !process.env['WORKSPACE_ID']) { // FIXME remove as soon as BAS is ready for the Node version check below
-    const v = version => { let vv = version.split('.'); return { version, major: +vv[0], minor: +vv[0] }}
+    const v = version => { let vv = version.split('.'); return { version, major: +vv[0], minor: +vv[1] }}
     const required = v('12.18'), given = v(process.version.match(/^v(\d+\.\d+)/)[1])
     if (given.major < required.major || given.major === required.major && given.minor < required.minor) process.exit (process.stderr.write (`
-    Node.js v${required.version} or higher is required for @sap/cds ${cds.version}.
+    Node.js v${required.version} or higher is required for @sap/cds.
     Current v${given.version} does not satisfy this.
     \n`) || 1)
   }

package/lib/log/format/kibana.js

@@ -7,6 +7,9 @@ const _l2l = { 1: 'error', 2: 'warn', 3: 'info', 4: 'debug', 5: 'trace' }
  * log formatter for kibana
  */
 module.exports = (module, level, ...args) => {
+  // config
+  const { user: log_user , kibana_custom_fields } = cds.env.log
+
   // build the object to log
   const toLog = {
     level: _l2l[level] || 'info',
@@ -16,9 +19,11 @@ module.exports = (module, level, ...args) => {
 
   // add correlation
   if (cds.context) {
-    const { id, tenant } = cds.context
+    const { id, tenant, user } = cds.context
     toLog.correlation_id = id
     if (tenant) toLog.tenant_id = tenant
+    // log user id, if configured (data privacy)
+    if (user && log_user) toLog.remote_user = user.id
     // add headers, if available, with _ instead of -
     const req = cds.context._ && cds.context._.req
     if (req && req.headers) for (const k in req.headers) toLog[k.replace(/-/g, '_')] = req.headers[k]
@@ -43,7 +48,6 @@ module.exports = (module, level, ...args) => {
   }
 
   // kibana custom fields
-  const { kibana_custom_fields } = cds.env.log
   if (kibana_custom_fields) {
     const cf = []
     for (const k in kibana_custom_fields) if (toLog[k]) cf.push({ k, v: toLog[k], i: kibana_custom_fields[k] })

package/lib/ql/DELETE.js

@@ -9,7 +9,7 @@ module.exports = class DELETE extends Whereable {
   }
 
   from(entity, key) {
-    this.DELETE.from = this._target_name4 (entity)
+    this.DELETE.from = this._target_name4 (...arguments) // supporting tts
     if (key) this.byKey(key)
     return this
   }

package/lib/ql/INSERT.js

@@ -9,7 +9,7 @@ module.exports = class INSERT extends Query {
   }
 
   into (entity, ...data) {
-    this.INSERT.into = this._target_name4 (entity)
+    this.INSERT.into = this._target_name4 (...arguments) // supporting tts
     if (data.length) this.entries(...data)
     return this
   }

package/lib/ql/Query.js

@@ -12,7 +12,7 @@ module.exports = class Query {
 
   /** Binds this query to be executed with the given service */
   bind (srv) {
-    return Object.defineProperty (this,'_srv',{value:srv})
+    return Object.defineProperty (this,'_srv',{ value:srv, configurable:true, writable:true })
   }
 
   /** Turns all queries into Thenables which execute with primary db by default */
@@ -34,15 +34,10 @@ module.exports = class Query {
     '}'
   }
 
-  _target_ref4 (target) {
+  _target_ref4 (target, arg2) {
 
     // Resolving this._target --> REVISIT: this is not reliable !!!
-    Object.defineProperty (this, '_target', { value: target && (
-      typeof target === 'string' ? { name: target } :
-      target.name ? target : //> assumed to be a linked csn definition
-      target.ref ? { name: target.ref[0] } :
-      target._target || { name: undefined }
-    ), configurable:true })
+    Object.defineProperty (this, '_target', { value: _target4 (target,arg2), configurable:true, writable:true })
 
     return target && (
       typeof target === 'string' ? cds.parse.path(target) :
@@ -56,8 +51,8 @@ module.exports = class Query {
   }
 
   //> REVISIT: should we rather have consistent .from/.entity/.into in CQN?
-  _target_name4 (target) {
-    const {ref} = this._target_ref4 (target)
+  _target_name4 (...args) {
+    const {ref} = this._target_ref4 (...args)
     return ref.length === 1 && typeof ref[0] === 'string' ? ref[0] : {ref}
   }
 
@@ -83,4 +78,12 @@ module.exports = class Query {
 }
 
 
+const _target4 = (target, arg2) =>  target && (
+  typeof target === 'string' ? { name: target } :
+  target.name ? target : //> assumed to be a linked csn definition
+  target.ref ? { name: target.ref[0] } :
+  target.raw ? _target4(arg2) :
+  target._target || { name: undefined }
+)
+
 const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')

package/lib/ql/SELECT.js

@@ -61,9 +61,13 @@ module.exports = class SELECT extends Whereable {
   from (target, second, third) {
     this.SELECT.from = target === '*' || this._target_ref4 (...arguments)
     if (!target.raw && second) {
-      const cols = _columns_or_not (second)
-      cols ? this._add('columns',cols) : this.byKey(second)
-      if (third) this.columns(third)
+      if (third) {
+        this.byKey(second)
+        this.columns(third)
+      } else {
+        const cols = _columns_or_not (second)
+        cols ? this._add('columns',cols) : this.byKey(second)
+      }
     }
     return this
   }
@@ -124,15 +128,18 @@ module.exports = class SELECT extends Whereable {
 
 
 const _columns = (args) => {
-  if (args[0].raw) {
-    if (args[0][0] === '{') return SELECT_('from X ',args).columns
-    else                    return SELECT_('from X {',args,'}').columns
-  } else return _columns_or_not(args[0]) || args.map(_column_expr)
+  const x = args[0]
+  if (x.raw) {
+    if (x[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 (typeof x === 'string' && x[0] === '{') return parse.cql('SELECT from X '+ x).SELECT.columns
   if (Array.isArray(x)) return x.map(_column_expr)
 }
 

package/lib/ql/UPDATE.js

@@ -10,7 +10,7 @@ module.exports = class UPDATE extends Whereable {
   }
 
   entity (e, key) {
-    this.UPDATE.entity = this._target_name4 (e)
+    this.UPDATE.entity = this._target_name4 (...arguments) // supporting tts
     if (key) this.byKey(key)
     return this
   }

package/lib/ql/Whereable.js

@@ -1,4 +1,5 @@
 const { error } = require ('../index')
+const cds = require('../index')
 const parse = require('./parse')
 
 class Whereable extends require('./Query') {
@@ -35,6 +36,10 @@ class Whereable extends require('./Query') {
   byKey(key) {
     if (typeof key !== 'object') 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, where: predicate4([key]) }] }; return this }
+    if (this.SELECT) { this.SELECT.from.ref[this.SELECT.from.ref.length-1] = { id: this.SELECT.from.ref[this.SELECT.from.ref.length-1], where: predicate4([key]) }; return this }
+    if (this.DELETE) { this.DELETE.from = { ref: [{ id: this.DELETE.from, where: predicate4([key]) }] }; return this }
     return this.where(key)
   }
 }