@sap/cds 5.9.7 → 6.0.2

package/lib/i18n/localize.js

@@ -2,12 +2,7 @@ const cds = require ('..')
 const {existsSync, readdirSync} = require ('fs')
 const {join,dirname,resolve,parse} = require ('path')
 
-const DEBUG = process.env.DEBUG_I18N && console.warn
-const conf = cds.env && cds.env.i18n || {}
-const DefaultLanguage = conf.default_language || 'en'
-const FallbackBundle = conf.fallback_bundle || ''
-const I18nFolders = conf.folders || [ '_i18n', 'i18n' ]
-const I18nFile = conf.file || 'i18n'
+const DEBUG = cds.debug('i18n')
 
 
 module.exports = Object.assign (localize, {
@@ -38,7 +33,7 @@ function localizeString (aString, bundle) {
   if (!bundle || !aString)  return aString
   if (typeof aString === 'object')  aString = JSON.stringify(aString, null, 2)
   // quick check for presence of any text key, to avoid expensive operation below
-  if (aString.indexOf(TEXT_KEY_MARKER) < 0)  return aString
+  if (!aString.includes(TEXT_KEY_MARKER))  return aString
   const escape = aString.startsWith('<?xml') ? escapeXmlAttr : /^[{[]/.test(aString) ? escapeJson : v=>v
   return aString.replace (TEXT_KEYS, (_, key) => {
     const val = bundle[key]
@@ -62,7 +57,7 @@ function bundles4 (model, locales) { // NOSONAR
   if (locales.length === 1 && (locales[0] === '*' || locales[0] === 'all')) {
     locales = allLocales4 (folders)
     if (!locales)  return {}
-    if (!locales.includes(FallbackBundle))  locales.push (FallbackBundle)
+    if (!locales.includes(cds.env.i18n.fallback_bundle))  locales.push (cds.env.i18n.fallback_bundle)
   }
   DEBUG && DEBUG ('Languages:', locales)
 
@@ -70,7 +65,7 @@ function bundles4 (model, locales) { // NOSONAR
     for (let each of locales) {
       let bundle = bundle4 (model, each)
       if (bundle) {
-        DEBUG && DEBUG (bundle.toString())
+        DEBUG && DEBUG (bundle)
         yield [ each, bundle ]
       }
     }
@@ -85,14 +80,16 @@ function bundles4 (model, locales) { // NOSONAR
 function allLocales4 (folders) {
   // find all languages in all folders
   const files = folders
-    .map (folder => readdirSync(folder).filter (e => e.startsWith(I18nFile)).map(i18nFile => join (folder, i18nFile)))
-    .reduce ((files, file) => files.concat(file)) // flatten
+    .map (folder => readdirSync(folder)
+      .filter (e => e.startsWith(cds.env.i18n.file))
+      .map(i18nFile => join (folder, i18nFile))
+    ).reduce ((files, file) => files.concat(file)) // flatten
   if (files.length === 0) {
     DEBUG && DEBUG ('No languages for folders:', folders)
     return null
   }
 
-   if (files[0].endsWith('.csv')) {
+  if (files[0].endsWith('.csv')) {
     return cds.load.csv (files[0])[0].slice(1)
   } else {
     const locales = new Set()
@@ -100,8 +97,10 @@ function allLocales4 (folders) {
       const parsed = parse(file)
       if (parsed.ext === '.json') {
         Object.keys(require(file)).forEach(locale => locales.add(locale))
-      } else if (parsed.ext === '.properties') {
-        locales.add(parsed.name.slice(5))
+      }
+      else if (parsed.ext === '.properties') {
+        const match = /_(\w+)$/.exec(parsed.name)
+        if (match)  locales.add(match[1])
       }
     })
     return Array.from(locales)
@@ -121,11 +120,11 @@ function bundle4 (model, locale) {
   const folders = folders4 (model); if (!folders.length)  return //> no folders, hence no bundles found at all
   const bundle = {}
 
-  add (FallbackBundle)  // e.g. i18n.properties
-  if (locale === FallbackBundle)  return bundle
+  add (cds.env.i18n.fallback_bundle)  // e.g. i18n.properties
+  if (locale === cds.env.i18n.fallback_bundle)  return bundle
 
-  add (DefaultLanguage)  // e.g. i18n_en.properties
-  if (locale === DefaultLanguage)  return bundle
+  add (cds.env.i18n.default_language)  // e.g. i18n_en.properties
+  if (locale === cds.env.i18n.default_language)  return bundle
 
   add (locale)  // e.g. i18n_de.properties
   return bundle
@@ -133,7 +132,7 @@ function bundle4 (model, locale) {
   function add (lang) {
     for (let each of folders) {
       const suffix = lang === '' ? '' : '_' + lang
-      const file = join (each, I18nFile),  key = file+suffix
+      const file = join (each, cds.env.i18n.file),  key = file+suffix
       const next = bundle4[key] || (bundle4[key] = (
         loadFromJSON (file, lang)  ||
         cds.load.properties (file + suffix.replace('-','_')) ||  // e.g. en-UK --> en_UK
@@ -158,7 +157,7 @@ function folders4 (model) {
   if (!model.$sources)  return []
   const folders=[];  for (let src of model.$sources) {
     let folder = folder4 (src)
-    if (!folder || folders.indexOf(folder) >= 0)  continue
+    if (!folder || folders.includes(folder)) continue
     folders.push(folder)  // use an array here to not screw up the folder order
   }
 
@@ -174,7 +173,7 @@ function folder4 (loc) {
   // already cached from a former lookup?
   if (loc in folder4)  return folder4[loc]
   // check whether a <loc>/_i18n extists
-  for (let i18n of I18nFolders) {
+  for (let i18n of cds.env.i18n.folders) {
     const f = join (loc, i18n)
     if (existsSync(f)) return folder4[loc] = f
   }
@@ -184,7 +183,7 @@ function folder4 (loc) {
 }
 
 
-function loadFromJSON (res, lang=DefaultLanguage) {
+function loadFromJSON (res, lang=cds.env.i18n.default_language) {
   try {
     const bundles = require (resolve (cds.root,res+'.json'))
     return bundles[lang] || bundles [(lang.match(/\w+/)||[])[0]]
@@ -193,7 +192,7 @@ function loadFromJSON (res, lang=DefaultLanguage) {
   }
 }
 
-function loadFromCSV (res, lang=DefaultLanguage) {
+function loadFromCSV (res, lang=cds.env.i18n.default_language) {
   let csv = cds.load.csv(res+'.csv'); if (!csv) return
   let [header, ...rows] = csv
   if (lang === '*') return header.slice(1).reduce ((all,lang,i) => {

package/lib/index.js

@@ -1,149 +1,153 @@
 /** @typedef {import './serve/Service-api'} Service */
-if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
-
-  const facade = class cds extends require('events') {
-
-    get env()      { return super.env = require('./env') }
-    get requires() { return super.requires = this.env.required_services_or_defs }
-    get version()  { return super.version = require('../package.json').version }
-    get builtin()  { return super.builtin = require ('./core') }
-    get service()  { return super.service = extend (this.builtin.classes.service) .with ({
-      /** @param x {(this:Service, srv:Service) => any} */ impl: x=>x,
-      /** @type {{ [path:string] : Service }} */ paths: {},
-      /** @type Service[] */ providers: [],
-      factory: require ('./serve/factory'),
-      adapters: require ('./serve/adapters'),
-      bindings: require ('./connect/bindings'),
-    })}
-    /** @type {import './req/context'} */
-    get context() { return require('./req/cds-context').for(this) }
-    set context(_){ require('./req/cds-context').for(this,_) }
-    get spawn() { return super.spawn = require('./req/cds-context').spawn }
-
-    emit (eve, ...args) {
-      if (eve === 'served') return Promise.all (this.listeners(eve).map (l => l.call(this,...args)))
-      else return super.emit (eve, ...args)
-    }
-  }
 
-  const { extend, lazify, lazified } = require ('./lazy')
-  const _class = lazy => cds.builtin.classes [lazy]
-  const _require = require; require = lazified (module)  // eslint-disable-line
-
-  /** cds is the central facade to all cds functions */
-  const cds = module.exports = global.cds = extend (new facade) .with ({
-
-    // Builtin types and classes
-    Association:_class,
-    Composition:_class,
-    entity:_class,
-    event:_class,
-    type:_class,
-    array:_class,
-    struct:_class,
-
-    // Model Reflection
-    reflect: require ('./core/reflect'),
-    linked: require ('./core/reflect'),
-    infer: require ('./core/infer'),
-
-    // Loading and Compiling Models
-    model: undefined,
-    compiler: require ('./compile/cdsc'),
-    compile: require ('./compile'),
-    resolve: require ('./compile/resolve'),
-    load: require ('./compile/load'), get: lazy => cds.load.parsed,
-    parse: require ('./compile/parse'),
-    minify: require ('./compile/minify'),
-    extend: require ('./compile/extend'),
-    deploy: require ('./deploy'),
-
-    // Providing and Consuming Services
-    services: new class IterableServices {
-      *[Symbol.iterator]() {for (let e in this) yield this[e]}
-      get _pending(){ return super._pending = {}}
-    },
-    serve: require ('./serve'),
-    server: require ('../server'),
-    connect: require ('./connect'),
-
-    // Core Services API
-    Service: require ('./serve/Service-api'),
-    EventContext: require ('./req/context'),
-    Request: require ('./req/request'),
-    Event: require ('./req/event'),
-    User: require ('./req/user'),
-    ql: require ('./ql'),
-    tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
-    /** @type Service */ db: undefined,
-
-    // Protocols and Periphery
-    ApplicationService: lazy => require('../libx/_runtime/cds-services/services/Service.js'),
-    MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
-    DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
-    RemoteService: lazy => require('../libx/_runtime/remote/Service.js'),
-    AuditLogService: lazy => require('../libx/_runtime/audit/Service.js'),
-    odata: require('../libx/odata'),
-
-    // Helpers
-    localize: require ('./i18n/localize'),
-    error: require ('./log/errors'),
-    utils: require ('./utils'),
-    test: require ('./utils/tests'),
-    log: require ('./log'), debug: lazy => cds.log.debug,
-    exec: require ('../bin/cds'),
-    clone: m => JSON.parse (JSON.stringify(m)),
-    lazified, lazify,
-
-    // Configuration & Information
-    home: __dirname.slice(0,-4),
-    root: lazy => process.cwd(),
-
-  })
-
-
-  // cds as shortcut to cds.db -> for compatibility only
-  extend (cds.__proto__) .with ({
-    get entities(){ return (cds.db||_missing).entities },
-    transaction: (..._) => (cds.db||_missing).transaction(..._),
-    run:         (..._) => (cds.db||_missing).run(..._),
-    foreach:     (..._) => (cds.db||_missing).foreach(..._),
-    stream:      (..._) => (cds.db||_missing).stream(..._),
-    read:        (..._) => (cds.db||_missing).read(..._),
-    create:      (..._) => (cds.db||_missing).create(..._),
-    insert:      (..._) => (cds.db||_missing).insert(..._),
-    update:      (..._) => (cds.db||_missing).update(..._),
-    delete:      (..._) => (cds.db||_missing).delete(..._),
-    disconnect:  (..._) => (cds.db||_missing).disconnect(..._),
-  })
-  /** @type Service */ const _missing = new Proxy ({},{
-    get:function fn(_,p){ cds.error.no_primary_db(p,fn) }
-  })
-
-  // legacy and to be moved stuff -> hidden for tools in cds.__proto__
-  extend (cds.__proto__) .with (lazified ({
-    /** @deprecated */ in: (cwd) => !cwd ? cds : {__proto__:cds, cwd, env: cds.env.for('cds',cwd) },
-    mtx: lazy => require('../bin/mtx/in-cds'),
-    build: lazy => require('../bin/build'),
-  }))
-
-  // Add global forwards to cds.ql and cds.parse
-  const odp = Object.defineProperty, _global = (_,...pp) => pp.forEach (p => odp(global,p,{
-    configurable:true, get:()=>{ let v=cds[_][p]; odp(this,p,{value:v}); return v }
-  }))
-  _global ('ql','SELECT','INSERT','UPDATE','DELETE','CREATE','DROP')
-  _global ('parse','CDL','CQL','CXL')
-
-  // 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[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.
-    Current v${given.version} does not satisfy this.
-    \n`) || 1)
+const facade = class cds extends require('events') {
+
+  get env()      { return super.env = require('./env').for('cds',cds.root) }
+  get requires() { return super.requires = this.env.required_services_or_defs }
+  get version()  { return super.version = require('../package.json').version }
+  get builtin()  { return super.builtin = require('./core') }
+  get service()  { return super.service = extend(this.builtin.classes.service) .with (_service) }
+  get _context() { return super._context = require('./req/cds-context') }
+  get context() { return this._context._for(this) }
+  set context(_){ this._context._for(this,_) }
+  get spawn() { return super.spawn = this._context.spawn }
+
+  emit (eve, ...args) {
+    if (eve === 'served') return Promise.all (this.listeners(eve).map (l => l.call(this,...args)))
+    else return super.emit (eve, ...args)
   }
+}
 
-  // restore require for subsequent uses in lazy getters
-  require = _require  // eslint-disable-line
+const { extend, lazify, lazified } = require ('./lazy')
+const _class = lazy => cds.builtin.classes [lazy]
+const _require = require; require = lazified (module)  // eslint-disable-line
+const _service = lazified ({ // nested facade for service-related modules
+  /** @param x {(this:Service, srv:Service, ...etc) => any} */ impl: x=>x,
+  /** @type {{ [path:string] : Service }} */ paths: {},
+  /** @type Service[] */ providers: [],
+  factory: require ('./serve/factory'),
+  adapters: require ('./serve/adapters'),
+  bindings: require ('./connect/bindings'),
+})
+
+/** cds is the central facade to all cds functions */
+const cds = module.exports = extend (new facade) .with ({
+
+  // Builtin types and classes
+  Association:_class,
+  Composition:_class,
+  entity:_class,
+  event:_class,
+  type:_class,
+  array:_class,
+  struct:_class,
+
+  // Model Reflection
+  reflect: require ('./core/reflect'),
+  linked: require ('./core/reflect'),
+  infer: require ('./core/infer'),
+
+  // Loading and Compiling Models
+  model: undefined,
+  compiler: require ('./compile/cdsc'),
+  compile: require ('./compile'),
+  resolve: require ('./compile/resolve'),
+  load: require ('./compile/load'), get: lazy => cds.load.parsed,
+  parse: require ('./compile/parse'),
+  minify: require ('./compile/minify'),
+  extend: require ('./compile/extend'),
+  deploy: require ('./deploy'),
+
+  // Providing and Consuming Services
+  services: new class IterableServices {
+    *[Symbol.iterator]() {for (let e in this) yield this[e]}
+    get _pending(){ let p={}; Object.defineProperty(this,'_pending',{value:p}); return p  }
+  },
+  serve: require ('./serve'),
+  server: require ('../server'),
+  connect: require ('./connect'),
+
+  // Core Services API
+  Service: require ('./serve/Service-api'),
+  EventContext: require ('./req/context'),
+  Request: require ('./req/request'),
+  Event: require ('./req/event'),
+  User: require ('./req/user'),
+  ql: require ('./ql'),
+  tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
+  /** @type Service */ db: undefined,
+
+  // Protocols and Periphery
+  ApplicationService: lazy => require('../libx/_runtime/cds-services/services/Service.js'),
+  MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
+  DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
+  RemoteService: lazy => require('../libx/_runtime/remote/Service.js'),
+  AuditLogService: lazy => require('../libx/_runtime/audit/Service.js'),
+  odata: require('../libx/odata'),
+
+  // Helpers
+  localize: require ('./i18n/localize'),
+  error: require ('./log/errors'),
+  utils: require ('./utils'),
+  test: require ('./utils/tests'),
+  log: require ('./log'), debug: lazy => cds.log.debug,
+  exec: require ('../bin/cds'),
+  clone: m => JSON.parse (JSON.stringify(m)),
+  lazified, lazify,
+
+  // Configuration & Information
+  home: __dirname.slice(0,-4),
+  root: lazy => process.cwd(),
+
+})
+
+
+// cds as shortcut to cds.db -> for compatibility only
+extend (cds.__proto__) .with ({
+  get entities(){ return (cds.db||_missing).entities },
+  transaction: (..._) => (cds.db||_missing).transaction(..._),
+  run:         (..._) => (cds.db||_missing).run(..._),
+  foreach:     (..._) => (cds.db||_missing).foreach(..._),
+  stream:      (..._) => (cds.db||_missing).stream(..._),
+  read:        (..._) => (cds.db||_missing).read(..._),
+  create:      (..._) => (cds.db||_missing).create(..._),
+  insert:      (..._) => (cds.db||_missing).insert(..._),
+  update:      (..._) => (cds.db||_missing).update(..._),
+  delete:      (..._) => (cds.db||_missing).delete(..._),
+  disconnect:  (..._) => (cds.db||_missing).disconnect(..._),
+})
+/** @type Service */ const _missing = new Proxy ({},{
+  get:function fn(_,p){ cds.error._no_primary_db(p,fn) }
+})
+
+// legacy and to be moved stuff -> hidden for tools in cds.__proto__
+extend (cds.__proto__) .with (lazified ({
+  /** @deprecated */ in: (cwd) => !cwd ? cds : {__proto__:cds, cwd, env: cds.env.for('cds',cwd) },
+  mtx: lazy => require('../bin/mtx/in-cds'),
+  build: lazy => require('../bin/build'),
+}))
+
+// Add global forwards to cds.ql and cds.parse
+const odp = Object.defineProperty, _global = (_,...pp) => pp.forEach (p => odp(global,p,{
+  configurable:true, get:()=>{ let v=cds[_][p]; odp(this,p,{value:v}); return v }
+}))
+_global ('ql','SELECT','INSERT','UPDATE','DELETE','CREATE','DROP')
+_global ('parse','CDL','CQL','CXL')
+
+// 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[1] }}
+  const required = v('14.15'), 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.
+  Current v${given.version} does not satisfy this.
+  \n`) || 1)
 }
+
+// restore require for subsequent uses in lazy getters
+require = _require  // eslint-disable-line
+
+if (process.env.CDS_GLOBAL) // TODO for stakeholder-tests only. Remove after cds 6.
+  Object.assign(module,{ exports: global.cds || (global.cds = cds)})
+else
+  global.cds = cds

package/lib/log/errors.js

@@ -1,22 +1,65 @@
-const error = exports = module.exports = (..._) => { throw _error(..._) }
-const _error = (msg, _details, _base = error, ...etc) => {
-  if (msg.raw) return _error (String.raw (msg,_details,_base,...etc))
-  const e = msg instanceof Error ? msg : new Error (msg)
-  if (_base) Error.captureStackTrace (e,_base)
-  if (_details) Object.assign (e,_details)
-  return e
-}
+const { format } = require('util'), _formatted = v => format(v)
+
 
-exports.reject = function (msg, _details, _base) {
-  return Promise.reject(_error(msg, _details, _base))
+/**
+ * This is the implementation of cds.error().
+ * Usage variants:
+ *
+ *       cds.error `Message with formatted: ${{foo:'bar'}}`
+ *       cds.error ({ message, code, ... })
+ *       cds.error (message, { code, ... })
+ *       let e = new cds.error(...) //> will not throw
+ *
+ * Calling `cds.error()` with `new` returns the newly created Error,
+ * while calling it without `new` it throws immediately. The latter is
+ * useful for usages like that:
+ *
+ *     let x = y || cds.error `Argument 'y' must not be null`
+ */
+const error = exports = module.exports = function cds_error (msg, _details, _base) {
+  let e; if (msg.raw) e = new error (error.message(...arguments))
+  else {
+    e = msg.stack ? msg : typeof msg === 'string' ? new Error(msg) : Object.assign(new Error,msg)
+    Error.captureStackTrace (e,_base||error)
+    if (_details) Object.assign (e,_details)
+  }
+  if (new.target) return e; else throw e
 }
 
+
+/**
+ * Constructs a message from a tagged template string. In contrast to usual
+ * template strings embedded values are formatted using `util.format`
+ * not just `toString()`.
+ *
+ *     let x = `A sample message with ${'a string'}, ${{an:'object'}}, and ${[1,2,3]}`
+ *     let y = cds.error.message`with ${'a string'}, ${{an:'object'}}, and ${[1,2,3]}`
+ *     //> x = A sample message with a string and [object Object], and 1,2,3
+ *     //> y = with a string, { an: 'object' }, and [ 1, 2, 3 ]
+ */
+exports.message = (strings,...values) => String.raw(strings,...values.map(_formatted))
+
+
+/**
+ * Use that to construct and throw errors from a tagged template string
+ * in validations of function arguments.
+ * Use it like that:
+ *
+ *     let x = {foo:'bar'}
+ *     typeof x === 'string' || cds.error.expected `${{x}} to be a string`
+ *     //> Error: Expected argument 'x' to be a string, but got: { foo: 'bar' }
+ */
 exports.expected = ([,type], arg) => {
   const [ name, value ] = Object.entries(arg)[0]
   return error `Expected argument '${name}'${type}, but got: ${require('util').inspect(value,{depth:11})}`
 }
 
-exports.duplicate_cds = (...locations) => {
+
+//
+// Private helpers ...
+//
+
+exports._duplicate_cds = (...locations) => {
   const { local } = require('../utils')
   throw error `Duplicate @sap/cds/common!
 
@@ -29,7 +72,7 @@ exports.duplicate_cds = (...locations) => {
   `
 }
 
-exports.no_primary_db = (p,_base) => error (`Not connected to primary datasource!
+exports._no_primary_db = (p,_base) => error (`Not connected to primary datasource!
 
   Attempt to use 'cds.${p}' without prior connect to primary datasource,
   i.e. cds.connect.to('db').

package/lib/log/format/kibana.js

@@ -57,5 +57,5 @@ module.exports = (module, level, ...args) => {
   }
 
   // return array with the stringified toLog (to avoid multiple log lines) as the sole element
-  return [JSON.stringify(toLog)]
+  return [util.inspect(toLog, { compact: true, breakLength: Infinity, depth: null })]
 }

package/lib/log/index.js

@@ -122,6 +122,10 @@ exports.Logger = (module, level) => {
  */
 exports.format = (
   process.env.NODE_ENV === 'production' && cds.env.features.kibana_formatter ? require('./format/kibana')
+  : cds.requires.multitenancy ? (module, level, ...args) => {
+    const t = cds.context?.tenant
+    return [ t ? `[${module}|${t}]` : `[${module}]`, '-', ...args ]
+  }
   : (module, level, ...args) => [ `[${module}] -`, ...args ]
 )
 

package/lib/ql/SELECT.js

@@ -1,5 +1,5 @@
 const Whereable = require('./Whereable'), { parse, predicate4 } = Whereable
-const defaults = global.cds.env.sql
+const cds = require('../index')
 
 
 module.exports = class SELECT extends Whereable {
@@ -120,13 +120,18 @@ module.exports = class SELECT extends Whereable {
     return this
   }
 
-  forUpdate ({ of, wait = defaults.lock_acquire_timeout || -1 } = {}) {
+  forUpdate ({ of, wait = cds.env.sql.lock_acquire_timeout || -1 } = {}) {
     const sfu = this.SELECT.forUpdate = {}
     if (of) sfu.of = of.map (c => ({ref:c.split('.')}))
     if (wait >= 0) sfu.wait = wait
     return this
   }
 
+  forShareLock () {
+    this.SELECT.forShareLock = true
+    return this
+  }
+
   foreach (callback) {
     return this.then(rows => rows.map(callback))
   }

package/lib/ql/Whereable.js

@@ -2,6 +2,11 @@ const { error } = require ('../index')
 const cds = require('../index')
 const parse = require('./parse')
 
+const _setIncludesOr = where => {
+  if (where.includes('or')) Object.defineProperty(where,'_includes_or__',{value:1}) 
+  else Object.defineProperty(where,'_includes_or__',{value:0})
+}
+
 class Whereable extends require('./Query') {
 
   where(...x) { return this._where (x,'and','where') }
@@ -20,11 +25,12 @@ class Whereable extends require('./Query') {
       if (_clause === 'on') _ = _.from
       let left = this._own(_clause,_)
       if (!left) {
-        if (pred.includes('or')) Object.defineProperty(pred,'_includes_or__',{value:1})
+        _setIncludesOr(pred)
         _[_clause] = pred
       } else {
         if (and_or === 'and') {
-          if (left._includes_or__) left = [{xpr:left}]
+          if (left._includes_or__ === undefined) _setIncludesOr(left) // information might be lost while copying
+          if (left._includes_or__ === 1) left = [{xpr:left}]
           if (pred.includes('or')) pred = [{xpr:pred}]
         }
         _[_clause] = [ ...left, and_or, ...pred ]

package/lib/ql/index.js

@@ -23,9 +23,9 @@ function _deprecated_srv_ql() { // eslint-disable-next-line no-console
 }
 
 if (cds.env.features.cls && cds.env.features.debug_queries) {
-  const Query = module.exports, { then } = Query.prototype
+  const Query = require('./Query'), { then } = Query.prototype
   const { AsyncResource } = require('async_hooks')
-  Object.defineProperty (Query,'then',{ get(){
+  Object.defineProperty (Query.prototype,'then',{ get(){
     const q = new AsyncResource('cds.Query')
     return (r,e) => q.runInAsyncScope (then,this,r,e)
   }})