@sap/cds 9.6.3 → 9.7.0

package/lib/compile/minify.js

@@ -26,20 +26,20 @@ class Minifier {
       // If o.services is specified, only keep matching services and their children
       const rx = o.services == 'all' || o.services == '/all/i' ? {test:()=>true} : o.services
       for (let [s,d] of all) if (d.kind === 'service' && rx.test(s)) {
-        this.keep (s,d); children (s, (c,d) => this.keep (c,d))
+        this.keep(s,d); children (s, (c,d) => this.keep(c,d))
       }
     } else {
       // Otherwise first mark all external services and their children as initially skipped
       for (let [s,d] of all) if (d.kind === 'service' && _skip_service(s,d)) {
-        skipped[s] = 0; children (s, (c,d) => d.kind in events ? this.keep (c,d) : skipped[c] = s) // used later on in this.keep()
+        skipped[s] = 0; children (s, (c,d) => d.kind in events ? this.keep(c,d,s) : skipped[c] = s) // used later on in this.keep()
       }
       // Then keep all own services and their children
       for (let [s,d] of all) if (d.kind === 'service' && !(s in skipped)) {
-        this.keep (s,d); children (s, (c,d) => d.kind in keep ? this.keep (c,d) : skipped[c] = 0)
+        this.keep(s,d); children (s, (c,d) => d.kind in keep ? this.keep(c,d) : skipped[c] = 0)
       }
       // Also keep remaining non-service entities
       for (let [e,d] of all) if (d.kind === 'entity') {
-        e in kept || e in skipped || _skip_entity(e,d) || this.keep (e,d)
+        e in kept || e in skipped || _skip_entity(e,d) || this.keep(e,d)
       }
     }
 
@@ -58,8 +58,8 @@ class Minifier {
     if (d.target)             this.keep (d.target)              // has to go first w/o return for redirected targets
     if (d.type in this.defs)  return this.keep (d.type)         // return to avoid endless recursion
     if (d.type?.ref)          return this.keep (d.type.ref[0])  // return to avoid endless recursion
-    if (d.projection)         this.view (d.projection)
-    if (d.query)              this.view (d.query)
+    if (d.projection)         this.view (d.projection,d)
+    if (d.query)              this.view (d.query,d)
     if (d.items)              this.walk (d.items)
     if (d.returns)            this.walk (d.returns)
     for (let e in d.elements) this.walk (d.elements[e])
@@ -69,20 +69,38 @@ class Minifier {
   // Note: this ^^^^^^^^^^^^ is required for cdsc.recompile; with delete d.includes, redirects in AFC broke
   }
 
-  view (q) {
+  view (q,v) {
     if (q.SELECT) q = q.SELECT // i.e. entity as select from ...
     if (q.mixin) for (let e in q.mixin) this.walk (q.mixin[e])
-    if (q.from?.ref) return this.keep (_source(q.from.ref[0])) // keep sources of views
+    if (q.from?.ref) {
+      let r = q.from.ref[0]; if (r.id) r = r.id; if (r in this.kept) return
+      if (v?.['@cds.minify'] === 'unused-elements') return this.keep_columns (q)
+      else return this.keep (r) // keep sources of views
+    }
     if (q.from?.join) return q.from.args.forEach (from => this.view ({from}))
     if (q.SET) return q.SET.args.forEach (q => this.view (q.SELECT||q))
-    function _source (r) { return r.id || r }
   }
 
-  keep (n,d) {
+  keep_columns (q) {
+    let r = q.from.ref[0]; if (r.id) r = r.id; if (r in this.kept) return
+    let e = this.defs[r]; if (!e) return
+    let all = e.elements, kept = {}
+    if (q.columns) _keep (q.columns)
+    if (q.where) _keep (q.where)
+    e.elements = kept
+    return this.keep (r,e)
+    function _keep (xx) { for (let x of xx) {
+      if (x.func) { _keep (x.args); continue }
+      if (x.xpr) { _keep (x.xpr); continue }
+      if (x.ref) { let [r] = x.ref; if (r in all) kept[r] = all[r] }
+    }}
+  }
+
+  keep (n,d,parent) {
     if (n in this.kept) return; else d ??= this.defs[n]
     if (d) this.walk (this.kept[n] = d, n); else return
     let texts = this.defs[n+'.texts']; if (texts) this.keep (n+'.texts', texts)
-    let parent = this.skipped[n]; if (parent) this.keep(parent) // keep initially skipped services
+    let p = parent ?? this.skipped[n]; if (p) this.keep(p) // keep initially skipped services
   }
 
 }

package/lib/compile/parse.js

@@ -128,7 +128,7 @@ const native = {
   SESSION_USER         : { func: 'session_user' },
   SYSUUID              : { func: 'sysuuid' },
 }
-const is_cqn = x => typeof x === 'object' && (
+const is_cqn = x => x !== null && typeof x === 'object' && (
   'ref' in x ||
   'val' in x ||
   'xpr' in x ||

package/lib/compile/resolve.js

@@ -1,109 +1,166 @@
-const { resolve, join, sep } = require('path')
-const { readdirSync } = require('fs')
-const suffixes = [ '.csn', '.cds', sep+'index.csn', sep+'index.cds', sep+'csn.json' ]
-
+const resolve = module.exports = exports = cds_resolve
+const cds = require('..'), {fs,path} = cds.utils
 
 /**
-* Resolves given model references to an array of absolute filenames.
-* For the model references, all these are accepted:
-* - with suffix or without → will append `.csn|cds`, `/index.csn|cds`
-* - absolute refs like `@sap/cds/common`
-* - local refs with leading `.` or without, e.g. `srv/cat-service`
-* - directory names → will fetch all contained `.csn` and `.cds` files
-* - arrays of any of the above
-* @returns and array of absolute filenames
-*/
-module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
+ * Resolves given model references to an array of absolute filenames.
+ * For the model references, all these are accepted:
+ * - with suffix or without → will append `.csn|cds`, `/index.csn|cds`
+ * - absolute refs like `@sap/cds/common`
+ * - local refs with leading `.` or without, e.g. `srv/cat-service`
+ * - directory names → will fetch all contained `.csn` and `.cds` files
+ * - arrays of any of the above
+ * @returns and array of absolute filenames
+ */
+function cds_resolve (refs,o) {
+  if (refs?._resolved) return refs //> already resolved
+  let o2 = resolve.options(o)
+  if (Array.isArray(refs)) return resolve.many (refs.flat(),o2)
+  else return resolve.single (refs,o2)
+}
+
+resolve.locations = (model='*', o) => resolve(model, { dry:true, ...o })
+
+resolve.options = function (options) {
+
+  const o = options === false ? { dry:true } : {...options}
+  const cwd = o.root ??= cds.root
+
+  // return cached prior result, if any
+  const caches = o.cache || exports.cache
+  if (cwd in caches) return { ...caches[cwd], ...o }
+  else caches[cwd] = { paths: [ cwd ], cached:{} }
+
+  // prepare module lookup paths
+  const paths = [ cwd ]
+  const node_modules = (o.env||cds.env).cdsc.moduleLookupDirectories
+  const a = cwd.split(path.sep), n = a.length
+  for (let each of node_modules) paths.push (
+    ...a.map ((_,i,a)=> a.slice(0,n-i).join(path.sep) + path.sep + each)
+  )
+
+  // cache and return
+  const cache = caches[cwd] = { paths, cached:{} }
+  return { ...o, ...cache }
+}
+
+
+resolve.all = function (o) {
+  
+  const _required = env => Object.values(env.requires) .map (r => r.model) .filter(x=>x) .flat()
+  const env = o.env || cds.env
+
+  // resolve(...,false) => return cds.env.roots + all required models
+  if (o.dry) return [ ...env.roots, ...new Set(_required(env)) ]
+
+  // return cached prior result, if any
+  const {cached} = o; if ('*' in cached) return cached['*']
+  else cached['*'] = [] // important to avoid endless recursion on '*'
+  
+  // resolve all roots, plus all cds.required.models (unless csn.json already there)
+  const files = resolve.many (env.roots,o) || []
+  const is_csn_json = files.length === 1 && files[0].endsWith('csn.json')
+  if (!is_csn_json) files.push (...resolve.many (_required(env),o)||[])
+
+  // cache and return resolved files
+  return cached['*'] = _resolved (files)
+}
+
+
+resolve.many = function (models, o) {
+  const resolved = _distinct(models) .reduce ((p,n) => p.concat (resolve.single(n,o)||[]), [])
+  return o.dry ? _distinct(resolved.flat()) : _resolved (resolved)
+}
+
+
+resolve.single = function (model,o) { 
+  
   if (!model || model === '--') return
-  if (model._resolved) return model
-  if (model === '*') return _resolve_all(o,this)
-  if (Array.isArray(model)) {
-    const resolved = [... new Set(model)] .reduce ((prev,next) => prev.concat (this.resolve(next,o)||[]), [])
-    return o.dry || o === false ? [...new Set(resolved.flat())] : _resolved (resolved)
-  }
-  if (model.endsWith('/*')) return _resolve_subdirs_in(model,o,this)
+  if (model == '*') return resolve.all(o)
+
+  // handle subdirectory patterns like 'app/*', 'srv/*', 'fts/*'
+  if (model.endsWith('/*')) return resolve.nested (model,o)
 
-  const cwd = o.root || this.root, local = resolve (cwd,model)
-  const context = _paths(cwd,o,this), {cached} = context
+  // check cache, and return if already resolved
+  const {cached} = o, local = path.resolve (o.root, model)
   let id = model.startsWith('.') ? local : model
-  if (id in cached)  return cached[id]
+  if (id in cached) return cached[id]
 
   // expand @sap/cds by cds.home
-  if (id.startsWith('@sap/cds/')) id = this.home + id.slice(8)
+  if (id.startsWith('@sap/cds/')) id = cds.home + id.slice(8)
 
   // fetch file with .cds/.csn suffix as is
   if (/\.(csn|cds)$/.test(id)) try {
-    return cached[id] = _resolved ([ _resolve (id,context) ])
+    return cached[id] = _resolved ([ _resolve (id,o) ])
   } catch {/* ignored */}
 
   // try to resolve file with one of the suffixes
-  for (let tail of o.suffixes || suffixes) try {
-    return cached[id] = _resolved ([ _resolve (id+tail,context) ])
+  for (let tail of o.suffixes || exports.suffixes) try {
+    return cached[id] = _resolved ([ _resolve (id+tail,o) ])
   } catch {/* ignored */}
 
-  // fetch all in a directory
+  // fetch all in a folder
   if (o.all !== false) try {
-    const files = readdirSync(local), all=[], unique={}
-    for (let f of files) if (f.endsWith('.csn')) {
-      all.push (unique[f.slice(0,-4)] = join(local,f))
-    }
-    for (let f of files) if (f.endsWith('.cds')) {
-      unique[f.slice(0,-4)] || all.push (join(local,f))
-    }
-    return cached[id] = _resolved (all)
+    return cached[id] = _resolved (resolve.folder (local,o))
   } catch {/* ignored */}
 
   // fetch file without suffix
   if (o.any !== false && !id.endsWith('/')) try { // NOTE: this also finds .js files!
-    return cached[id] = _resolved ([ _resolve (id,context) ])
+    return cached[id] = _resolved ([ _resolve (id,o) ])
   } catch {/* ignored */}
 
+  // not found
+  return cached[id] = null
 }
 
 
-exports.cache = {}
+resolve.folder = function (folder) {
+  const files = fs.readdirSync(folder), all=[], unique={}
+  for (let f of files) if (f.endsWith('.csn')) {
+    all.push (unique[f.slice(0,-4)] = path.join(folder,f))
+  }
+  for (let f of files) if (f.endsWith('.cds')) {
+    unique[f.slice(0,-4)] || all.push (path.join(folder,f))
+  }
+  return all
+}
 
 
-const _required = (cds,env=cds.env) => Object.values(env.requires) .map (r => r.model) .filter(x=>x)
-const _resolve = require('module')._resolveFilename
+resolve.nested = function (pattern,o) {
 
-function _resolve_all (o,cds) {
-  const {roots} = o.env || cds.env; if (o.dry || o === false)  return [ ...roots, ...new Set(_required(cds).flat()) ]
-  const cache = o.cache || exports.cache
-  const cached = cache['*']; if (cached) return cached
-  cache['*'] = [] // important to avoid endless recursion on '*'
-  const sources = cds.resolve (roots,o) || []
-  if (!(sources.length === 1 && sources[0].endsWith('csn.json'))) // REVISIT: why is that? -> pre-compiled gen/csn.json?
-    sources.push (...cds.resolve (_required(cds,o.env),o)||[])
-  return cache['*'] = _resolved (sources)
-}
+  // return cached prior result, if any
+  const {cached} = o; if (!o.dry && pattern in cached) return cached[pattern]
 
-function _resolve_subdirs_in (pattern='fts/*',o,cds) {
-  const cache = o.cache || exports.cache
-  const cached = cache[pattern]; if (cached && !o.dry && o !== false)  return cached
-  const folder = pattern.slice(0,-2), dir = resolve (o.root || cds.root, folder)
-  try {
-    const dirs = readdirSync(dir) .filter (e => cds.utils.isdir(dir+sep+e)) .map (e => folder+sep+e+sep)
-    if (o.dry || o === false)  return dirs
-    return cache[pattern] = cds.resolve (dirs,o) || undefined
-  } catch(e) {
-    if (e.code === 'ENOENT')
-    return cache[pattern] = undefined
-  }
-}
+  // fetch all subdirectories matching the pattern
+  const folder = pattern.slice(0,-2), dir = path.resolve (o.root, folder)
+  try { var nested = fs.readdirSync(dir) .filter (d => is_dir(path.join(dir,d))) .map (d => path.join(folder,d,path.sep)) } 
+  catch(e) { if (e.code === 'ENOENT') return cached[pattern] = null }
 
-function _paths (dir,o,cds) {
-  const cache = o.cache || exports.cache
-  const cached = cache[dir]; if (cached)  return cached
-  const a = dir.split(sep), n = a.length, paths = [ dir ]
-  const { cdsc: { moduleLookupDirectories }} = o.env ?? cds.env
-  for (const mld of moduleLookupDirectories) { // node_modules/ usually, more for Java
-    paths.push(...a.map ((_,i,a)=> a.slice(0,n-i).join(sep)+sep+mld))
-  }
-  return cache[dir] = { paths, cached:{} }
+  // don't resolve, if resolve(...,false)
+  if (o.dry) return nested
+
+  // resolve files for those dirs
+  const files = nested?.map (d => resolve.single (d,o)).flat()
+  return cached[pattern] = _resolved (files.filter(x=>x))
 }
 
-function _resolved (array) {
-  if (!array || !array.length)  return
-  return Object.defineProperty ([...new Set (array)], '_resolved', {value:true})
+
+resolve.module = function (module_name, o = resolve.options()) {
+  try { return _resolve (module_name,o) } 
+  catch { return null }
 }
+
+
+exports.suffixes = [ // always .csn before .cds to prefer compiled files
+  '.csn', 
+  '.cds', 
+  path.sep+'index.csn', 
+  path.sep+'index.cds', 
+  path.sep+'csn.json' 
+]
+exports.cache = {}
+
+
+const _resolve = require('module')._resolveFilename
+const _resolved = files => !files?.length ? null : Object.defineProperty (_distinct(files), '_resolved', {value:true})
+const _distinct = files => [...new Set (files)]
+const is_dir = file => fs.statSync(file).isDirectory()

package/lib/compile/to/csn.js

@@ -36,8 +36,8 @@ function cds_compile_to_csn (model, options, _flavor) {
     // REVISIT: experimental implementation to detect external APIs
     for (let each in csn.definitions) {
       const d = csn.definitions[each]
-      if (d.kind === 'service' && cds.requires[each]?.external && (!o.mocked || cds.requires[each].credentials)) {
-        Object.defineProperty (d,'@cds.external', { value: cds.requires[each].kind || true })
+      if (d.kind === 'service' && !d['@cds.external'] && cds.requires[each]?.external && (!o.mocked || cds.requires[each].credentials)) {
+        Object.defineProperty (d,'@cds.external', { value: !!cds.requires[each].kind || true })
       }
     }
     if (!csn.meta) csn.meta = {}

package/lib/dbs/cds-deploy.js

@@ -275,53 +275,55 @@ deploy.prepare = async function (csn, srces) {
 }
 
 
-/** Resolve initial data resources for given model */
-deploy.resources = async function (csn, opts) {
-  if (!csn || !csn.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
-  const { fs, isdir, isfile } = cds.utils
-  const folders = await deploy.folders(csn, opts)
-  const found={}, ts = process.env.CDS_TYPESCRIPT
-  for (let folder of folders) {
-    // fetching .csv and .json files
-    for (let each of ['data','csv']) {
-      const subdir = isdir(folder,each); if (!subdir) continue
-      const files = await fs.promises.readdir (subdir)
-      for (let fx of files) {
-        if (fx[0] === '-') continue
-        const ext = path.extname(fx); if (ext in {'.csv':1,'.json':2}) {
-          const f = fx.slice(0,-ext.length)
-          if (/[._]texts$/.test(f) && files.some(g => g.startsWith(f+'_'))) {
-            // ignores 'Books_texts.csv/json' if there is any 'Books_texts_LANG.csv/json'
-            DEBUG?.(`ignoring '${fx}' in favor of translated ones`)
-            continue
-          }
-          const e = _entity4(f,csn); if (!e || e['@cds.persistence.skip'] === true) continue
-          if (cds.env.features.deploy_data_onconflict === 'replace' && !/[._]texts_/.test(f)) {
-            const seenBefore = Object.entries(found).find(([,entity]) => entity === e.name )
-            if (seenBefore) {
-              DEBUG?.(`Conflict for '${e.name}': replacing '${local(seenBefore[0])}' with '${local(path.join(subdir,fx))}'`)
-              continue
-            }
-          }
-          found[path.join(subdir,fx)] = e.name
-        }
-      }
-    }
-    // fetching init.js files -> Note: after .csv files to have that on top, when processing in .reverse order
+/** 
+ * Resolve initial data resources for given model.
+ * Found resources are executed in reverse order of discovery!
+ */
+deploy.resources = async function (csn,o) {
+
+  const { fs, isdir, isfile } = cds.utils, ts = process.env.CDS_TYPESCRIPT
+  const subfolders = ['data','csv']
+  const filetypes = ['.csv','.json']
+  const found={}, neighborhood = new Set
+  
+  // fetching csvs in models' neighborhood ...
+  if (!csn?.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
+  for (let each of csn.$sources) {
+    let d = path.dirname (each)
+    if (d === cds.home || neighborhood.has(d)) continue; else neighborhood.add (d)
+    for (let data of subfolders) await fetch_csvs_in (path.join (d,data))
+  }
+
+  // fetching csvs in db/data and test/data
+  let d = cds.env.requires.db?.data || (
+    // REVISIT: fallback for some very special cds build and mtxs tests with mocked cds.env?
+    o?.testdata ? ['db/data','test/data'] : ['db/data'] 
+  )
+  if (d) for (let each of d) await fetch_csvs_in (each)
+
+  // fetching init.js files in models' neighborhood ...
+  for (let folder of neighborhood) {
     const init_js = ts && isfile(folder,'init.ts') || isfile(folder,'init.js')
     if (init_js) found[init_js] = '*'
   }
   return found
-}
-
-
-/** Resolve folders to fetch for initial data resources for given model */
-deploy.folders = async function (csn, o={}) {
-  if (!csn || !csn.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
-  const folders = new Set (csn.$sources.map (path.dirname) .filter (f => f !== cds.home))
-  if (cds.env.folders.db) folders.add (path.resolve(cds.root, cds.env.folders.db))
-  if (o.testdata) folders.add (path.resolve(cds.root,'test/'))
-  return folders
+  
+  async function fetch_csvs_in (dir) {
+    const subdir = isdir(dir); if (!subdir) return
+    const files = await fs.promises.readdir (subdir) 
+    files.forEach (fx => { if (fx[0] !== '-') {
+      const ext = path.extname(fx); if (!filetypes.includes(ext)) return
+      const f = fx.slice(0,-ext.length)
+      // ignore '_texts.csv' if there is any '_texts_<lang>.csv'
+      if (/[._]texts$/.test(f) && files.some(g => g.startsWith(f+'_')))
+        return DEBUG?.(`ignoring '${fx}' in favor of translated ones`)
+      const e = _entity4(f,csn); if (!e || e['@cds.persistence.skip'] === true) return
+      if (cds.env.features.deploy_data_onconflict === 'replace' && !/[._]texts_/.test(f))
+        for (let any in found) if (found[any] === e.name)
+          return DEBUG?.(`Conflict for '${e.name}': replacing '${local(any)}' with '${local(path.join(subdir,fx))}'`)
+      found[path.join(subdir,fx)] = e.name
+    }})
+  }
 }
 
 
@@ -335,6 +337,9 @@ deploy.include_external_entities_in = function (csn) {
       DEBUG?.('including mocked', each)
       delete def['@cds.persistence.skip']
     }
+    // DON'T CLEANUP: Please keep these comments in for future reference!
+    // REVISIT: if (def['@cds.external'] === 2) delete def['@cds.external']
+    // REVISIT: if (def['@cds.external'] === 2) def['@cds.external'] = 1
   }
   deploy.exclude_external_entities_in (csn)
   return csn

package/lib/env/cds-env.js

@@ -395,6 +395,12 @@ class Config {
       _fetch ({ type: conf.dialect || conf.kind })
 
     function _fetch (predicate) {
+      if (Array.isArray(predicate)) {
+        for (const p of predicate) {
+          const found = _fetch(p)
+          if (found) return found
+        }
+      }
       const filters = []
       for (let k in predicate) {
         const v = predicate[k]; if (!v) continue

package/lib/env/cds-requires.js

@@ -119,21 +119,27 @@ const _services = {
 
 }
 
+const _db_data = {
+  '[development]': { data: [ 'db/data', 'db/csv', 'test/data' ] },
+  '[production]': { data: [ 'db/data', 'db/csv' ] },
+}
 
 const _databases = {
 
-  "db-defaults": { kind: 'sql' },
+  "db-defaults": { kind: 'sql', ..._db_data }, //> applied only for cds.requires.db: true 
+  
   "sql": {
     '[development]': { kind: 'sqlite', credentials: { url: ':memory:' } },
     '[production]': { kind: 'hana' },
   },
 
   "sqlite": {
-    impl: '@cap-js/sqlite',
-    credentials: { url: 'db.sqlite' },
+    impl: '@cap-js/sqlite', credentials: { url: 'db.sqlite' },
+    ..._db_data,
   },
   "hana": {
     impl: '@cap-js/hana',
+    ..._db_data,
   },
   "hana-cloud": {
     kind: 'hana', "deploy-format": "hdbtable",

package/lib/index.js

@@ -1,5 +1,4 @@
 if (process.env.CDS_STRICT_NODE_VERSION !== 'false') require('./utils/version').check()
-! (global.__cds_loaded_from ??= new Set).add(__filename.toLowerCase()) // track from where we loaded cds, lowercase to avoid path duplicates on Windows
 
 const { AsyncLocalStorage } = require ('async_hooks')
 const context = new AsyncLocalStorage
@@ -152,3 +151,6 @@ function G (p,v) { Object.defineProperty (global, p, { value:v, enumerable:1,con
 
 // Allow for `import cds from '@sap/cds'` without `esModuleInterop` in tsconfig.json
 Object.defineProperties (exports, { default: {value:cds}, __esModule: {value:true} })
+
+// track from where we loaded cds, lowercase to avoid path duplicates on Windows
+!(global.__cds_loaded_from ??= new Set).add(cds.home.toLowerCase()) 

package/lib/plugins.js

@@ -1,4 +1,4 @@
-const DEBUG = /plugins/.test(process.env.DEBUG) ? console : undefined // eslint-disable-line no-console
+const DEBUG = /\b(y|all|plugins)\b/.test(process.env.DEBUG) ? console : undefined // eslint-disable-line no-console
 const cds = require('.')
 const prio_plugins = {
   '@sap/cds-mtxs': true,    // plugins may register handlers for mtxs services

package/lib/req/request.js

@@ -1,5 +1,5 @@
 const cds = require('../index')
-const { Responses, Errors, prepareError } = require('./response')
+const { Responses, Errors } = require('./response')
 
 /**
  * Class Request represents requests received via synchronous protocols.
@@ -110,7 +110,7 @@ class Request extends require('./event') {
       delete err.stack
       throw err
     }
-    let e = prepareError(4, ...args)
+    let e = this._errors.add (4, ...args)
     if (!('stack' in e)) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
     if (!('message' in e)) e.message = String (e.code || e.status)
     throw e

package/lib/srv/bindings.js

@@ -11,25 +11,31 @@ class Bindings {
   #bound = {}
 
   then (r,e) {
+    const info = ()=> LOG.info ('using bindings from:', { registry })
+    if (cds.watched) cds.prependOnceListener ('connect',info); else info()
     delete Bindings.prototype.then // only once per process
-    cds.prependOnceListener ('connect', ()=> LOG.info ('connect using bindings from:', { registry }))
     cds.once('listening', server => this.export (cds.service.providers, server.url))
     return this.import() .then (r,e)
   }
 
   bind (service) {
     let required = cds.requires [service]
-    let binding = this.provides [required?.service || service]
-    if (binding?.endpoints) {
+    let binding = this.provides [service]
+
+    if (binding?.endpoints && !required?.credentials) {
+      // > Re-route requests to the mock service running locally
+
       const server = this.servers [binding.server]
       const kind = [ required?.kind, 'hcql', 'rest', 'odata' ].find (k => k in binding.endpoints)
       const path = binding.endpoints [kind]
+      
       // in case of cds.requires.Foo = { ... }
       if (typeof required === 'object') required.credentials = {
         ...required.credentials,
         ...binding.credentials,
         url: server.url + path
       }
+      
       // in case of cds.requires.Foo = true
       else required = cds.requires[service] = cds.env.requires[service] = {
         ...cds.requires.kinds [binding.kind],
@@ -38,12 +44,18 @@ class Bindings {
           url: server.url + path
         }
       }
+
       required.kind = kind
+
       // REVISIT: temporary fix to inherit kind as well for mocked odata services
       // otherwise mocking with two services does not work for kind:odata-v2
       if (kind === 'odata-v2' || kind === 'odata-v4') required.kind = 'odata'
+
+      // Finally, ensure the changes are mirrored in cds.requires overlays as well
+      if (required.service) cds.requires[required.service] = required
     }
-    return required
+    
+    return this.#bound [service] = required
   }
 
   // used by cds.connect
@@ -74,7 +86,7 @@ class Bindings {
 
   async import() {
     await this.load()
-    for (let each in cds.requires) this.bind (each)
+    for (let each in cds.env.requires) this.bind (each)
     return this
   }
 

package/lib/srv/middlewares/auth/index.js

@@ -29,14 +29,16 @@ module.exports = function auth_factory (o) {
   // from cds.requires.auth in the log or error output below.
 
   // try resolving the impl, throw if not found
-  const config = { kind, impl }
-  // use cds.resolve() to allow './srv/auth.js' and 'srv/auth.js' -> REVISIT: cds.resolve() is not needed here, and not meant for that !
-  try { impl = require.resolve (cds.resolve (impl)?.[0], {paths:[cds.root]}) } catch {
-    throw cds.error `Didn't find auth implementation for ${config}`
+  const config = { kind }
+  try { impl = require.resolve (impl, {paths:[cds.root]}) } catch {
+    try { impl = require.resolve ('./'+impl, {paths:[cds.root]}) } catch {
+      throw cds.error `Didn't find auth implementation for ${config}`
+    }
   }
 
   // load the auth middleware from the resolved path
-  config.impl = cds.utils.local(impl)
+  const builtin = cds.utils.path.join (cds.home,'lib')
+  if (!impl.match(builtin)) config.impl = cds.utils.local(impl)
   cds.log().info ('using auth strategy', config)
   let auth = require (impl)