@sap/cds 5.5.5 → 5.6.3

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,48 @@ 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
-    for (let each in requires)  requires[each] = _merged (each)
+    const { requires } = this, protos = requires && requires._prototypes || {}
+    for (let each in requires) {
+      requires[each] = _merged (each)
+      // if we got an invalid value, remove it (would anyways cause trouble down the road)
+      if (!requires[each])  delete requires[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 +269,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 +313,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 +326,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 +401,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 +411,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 +463,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

@@ -31,7 +31,16 @@ module.exports = {
   "xsuaa-auth": {
     strategy: 'xsuaa',
   },
-  destinations: undefined,
+  destinations: {
+    vcap: {
+      label: 'destination'
+    }
+  },
+  xsuaa: {
+    vcap: {
+      label: 'xsuaa'
+    }
+  },
   monitoring: undefined,
   logging: undefined,
   audit: undefined,
@@ -105,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

@@ -35,13 +35,18 @@ function localize (model, /*with:*/ locale, aString) {
 const TEXT_KEY_MARKER = 'i18n>'
 const TEXT_KEYS = /"([^"{]+)?{b?i18n>([^"}]+)}([^"]+)?"/g
 function localizeString (aString, bundle) {
-  if (!bundle)  return aString
+  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
-
-  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 +211,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

@@ -77,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'),
@@ -131,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/Query.js

@@ -77,6 +77,7 @@ module.exports = class Query {
 
 }
 
+
 const _target4 = (target, arg2) =>  target && (
   typeof target === 'string' ? { name: target } :
   target.name ? target : //> assumed to be a linked csn definition

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/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)
   }
 }

package/lib/req/context.js

@@ -199,22 +199,30 @@ class EventContext {
 
 
 function cds_spawn (o,fn) {
-  if (typeof o === 'function' && typeof fn === 'object') [ fn, o ] = [ o, fn ]
+  if (typeof o === 'function') [ fn, o ] = [ o, fn ]
+  if (!o) o = {}
+  const em = new EventEmitter()
   const fx = async ()=> {
     // create a new transaction for each run of the background job
     // which inherits from the current event context by default
     const tx = cds.context = cds.tx({...o})
     try {
-      await fn(tx)
+      const res = await fn(tx)
       await tx.commit()
+      for (const handler of em.listeners('succeeded')) await handler(res)
+      for (const handler of em.listeners('done')) await handler()
     } catch(e) {
       console.trace (`ERROR occured in background job:`, e) // eslint-disable-line no-console
       await tx.rollback()
+      for (const handler of em.listeners('failed')) await handler(e)
+      for (const handler of em.listeners('done')) await handler()
     }
   }
-  if (o && o.after) return setTimeout (fx, o.after)
-  if (o && o.every) return setInterval (fx, o.every)
-  else return setImmediate (fx)
+  const timer = (
+    (o && o.after) ? setTimeout (fx, o.after) :
+    (o && o.every) ? setInterval (fx, o.every) :
+    setImmediate (fx) )
+  return Object.assign(em, { timer })
 }
 
 

package/lib/serve/Service-dispatch.js

@@ -33,10 +33,17 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
   // Ensure target and fqns
   if (!req.target) _ensure_target (this,req)
   if (typeof req.query === 'object') {
-    if (req.query._target !== req._target) Object.defineProperty (req.query,'_target',{ value:req.target, configurable:true, writable:true })
+    if (req.query._target !== req.target) Object.defineProperty (req.query,'_target',{ value:req.target, configurable:true, writable:true })
     if (!req.query._srv) Object.defineProperty (req.query,'_srv',{ value:this, configurable:true, writable:true })
   }
 
+  // REVISIT: Ensure req._.req and req._.res in case of srv.run(query)?!
+  /*
+  if (this instanceof cds.ApplicationService && !req._.req) {
+    // TODO: add req and res to req._ from tx
+  }
+  */
+
   return this.handle(req)
 }
 

package/lib/utils/axios.js

@@ -36,6 +36,13 @@ const _args = (args) => {
 }
 
 const _error = (e) => {
+  if (e.code === 'ECONNREFUSED' && e.port === 80 /*unchanged default port*/) {
+    // retain original error properties (code,...)
+    e = Object.assign(new Error(e.message +
+      '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.'),e)
+    e.stack = null // stack is just clutter here
+    throw e
+  }
   if (!e.response)  throw e
   if (!e.response.data)  throw e
   if (!e.response.data.error)  throw new Error(e.message + '\n\n' + e.response.data)

package/lib/utils/data.js

@@ -6,7 +6,7 @@ class DataUtil {
     if (!db)  db = await cds.connect.to('db')
     if (!this._deletes) {
       this._deletes = []
-      for (const entity of db.model.minified().all('entity')) {
+      for (const entity of db.model.each('entity')) {
         if (!entity.query && entity['@cds.persistence.skip'] !== true) {
           this._deletes.push(cds.ql.DELETE.from(entity))
         }

package/lib/utils/tests.js

@@ -134,4 +134,4 @@ function initLogging() {
 /** @type Test.run & Test */
 module.exports = Object.setPrototypeOf (Test.run, Test.prototype)
 
-/* eslint no-console: off */
+/* eslint no-console: off */