@sap/cds 6.0.4 → 6.1.2

package/lib/srv/srv-models.js

@@ -0,0 +1,207 @@
+// REVISIT: all handler caches (incl. templates) need to go into cached models -> eviction
+// REVISIT: all edmx caches also have to be hooked in here
+
+const cds = require ('../index')
+const LOG = cds.log()
+
+const {normalizeError} = require('../../libx/_runtime/common/error/frontend')
+const getError = require('../../libx/_runtime/common/error')
+
+/**
+ * Implements a static cache for all tenant/features-specific models.
+ * Cache keys are strings of the form `<tenant>:<comma-separated-features>`.
+ * The base model `cds.model` is also in the cache with key `':'`, i.e.,
+ * with undefined tenant and no activated features.
+ */
+class ExtendedModels {
+
+  /**
+   * Returns an express middleware to be used with the given srv to set cds.context.model.
+   * Uses `this.model4(...)` to get the respective tenant/features-specific models.
+   * @returns {(req,res)=>{}}
+   */
+  static middleware4 (srv) {
+    if (!(srv instanceof cds.ApplicationService)) return [] //> no middleware to add // REVISIT: move to `srv.isExtensible`
+    if (!srv.isExtensible) return [] //> no middleware to add
+    else return async function cds_context_model (req,res,next) {
+      if (!req.user?.tenant) return next()
+      const ctx = cds.context = cds.EventContext.for({ http: { req, res } })
+      ctx.user = req.user // REVISIT: should move to auth middleware?
+      try {
+        ctx.model = req.__model = await ExtendedModels.model4 (ctx.tenant, ctx.features)
+      } catch (e) {
+        LOG.error (Object.assign(e, { message: 'Unable to get service from service map due to error: ' + e.message }))
+
+        // return 503 to client
+        // REVISIT: Error handling!
+        const { error } = normalizeError(getError(Object.assign(e, { statusCode: 503 })), req)
+
+        return res.status(503).json({ error })
+      }
+      next()
+    }
+  }
+
+
+  /**
+   * Returns the model to use for given tenant and features.
+   * Loaded models are cached, with eviction on inactivity of tenants,
+   * and automatically refreshed when new extensions are made.
+   * @returns a CSN compiled.for.nodejs and cds.linked
+   */
+  static async model4 (tenant, features) {
+
+    const {cache} = ExtendedModels, key = cache.key4 (tenant, features)
+    const cached = cache.at(key); if (cached) return cached
+    if (key === ':') return cache.add (':', cds.compile.for.nodejs(cds.model))
+    else return cache[key] = (async()=>{ // temporarily add promise to cache to avoid race conditions...
+
+      // If tenant doesn't have extensions check cache with tenant = undefined
+      const _has_extensions = tenant && extensibility && await _is_extended(tenant)
+      if (!_has_extensions) {
+        let k = cache.key4 (tenant = undefined, features)
+        let cached = cache.at(k); if (cached) return cached
+        else if (k === ':') return cache.add (':', cds.compile.for.nodejs(cds.model))
+      }
+
+      // None cached -> obtain and cache specific model from ModelProvider
+      return await _get_model4 (tenant, Object.keys(features))
+
+    })()
+    .then (m => cache.add(key,m)) // replace promise in cache by real model
+    .catch (e => { delete cache[key]; throw e })
+  }
+
+
+  /**
+   * Constructs and returns a cache key for given tenant and features.
+   * @param {string} tenant string or `undefined` as obtained from `cds.context.tenant`
+   * @param {object} features object as obtained from `cds.context.features`
+   * @returns {string} of the form `<tenant>:<comma-separated-features>`
+   */
+  key4 (tenant, features) {
+    return `${tenant||''}:${features.$hash}`
+  }
+
+
+  /**
+   * Returns the currently cached model, or a promised one.
+   * Promises are added to the cache to avoid race conditions with parallel requests.
+   * This implementation regularly checks for new extensions, and transparently
+   * refreshes cached models if so.
+   * This method is overridden with a simple `return this[key]` when extensibility
+   * is switched off.
+   * @param {string} key as obtained through `cache.key4(t,f)`
+   * @returns { LinkedCSN | Promise<LinkedCSN> }
+   */
+  at (key) {
+    const model = this[key]; if (!model) return
+    if (model.then) return model //> promised model to avoid race conditions
+
+    const {_cached} = model, interval = ExtendedModels.checkInterval
+    if (!_cached.touched)  return model
+    if (Date.now() - _cached.touched < interval) return model //> checked recently
+
+    else return this[key] = (async()=>{ // temporarily replace cache entry by promise to avoid race conditions...
+
+      const has_new_extensions = await cds.db.exists('cds.xt.Extensions') .where ({
+        timestamp: { '>': new Date(_cached.touched).toISOString() } // REVISIT: better store epoc time in db?
+        // REVISIT: GAP: CAP runtime should allow Date objects + Date.now() for all date+time types !
+      })
+      if (has_new_extensions) { // new extensions arrived -> refresh model in cache
+        let [ tenant = undefined, toggles ] = key.split(':')
+        return _get_model4 (tenant, toggles.split(','))
+      } else {                        // no new extensions...
+        _cached.touched = Date.now() // check again in 1 min or so
+        return model               // keep cached model in cache
+      }
+
+    })()
+    .then (m => this.add(key,m))  // replace promise in cache by real model
+    .catch (e => { delete this[key]; throw e })
+  }
+
+
+  /**
+   * Adds a model into the cache under the given key.
+   * Only use that method to add loaded models, while using direct assignment
+   * to add promises, e.g. `cache[key] = promised_model`.
+   * @param {string} key as obtained through `cache.key4(t,f)`
+   * @param {LinkedCSN} model the loaded and linked model
+   * @returns the given `model`
+   */
+  add (key, model, touched = Date.now()) {
+    if (model) {
+      if (!model._cached) Object.defineProperty (model,'_cached',{ value:{key,touched} })
+      return this[key] = model
+    }
+  }
+
+
+  /**
+   * When started, regularly evicts models for inactive tenants.
+   */
+  startSentinel(){
+    this.sentinel = setInterval (()=>{ for (let [key,m] of Object.entries(this)) {
+      if (!m._cached) continue // `m` can also be `this.sentinel`
+      if (Date.now() - m._cached.touched > ExtendedModels.sentinelInterval) {
+        delete this [key]
+      }
+    }}, ExtendedModels.sentinelInterval)
+    cds.on('shutdown', ()=> clearInterval(this.sentinel))
+  }
+
+
+  /** The cache instance used by `middleware4()` and `model4()`. */
+  static cache = new ExtendedModels
+
+  /** Time interval in ms to check for new extensions and refresh models, if so. */
+  static checkInterval = cds.requires.extensibility?.tenantCheckInterval || cds.mtx?.tenantCheckInterval || 1 * 60 * 1000
+
+  /** Time interval in ms after which to evict models for inactive tenants. */
+  static sentinelInterval = cds.requires.extensibility?.evictionInterval || 3600*1000
+
+}
+module.exports = ExtendedModels
+
+
+
+// ---------------------------------------------------------------------------
+// Support for old MTX
+
+const old_mtx = cds.mtx
+if (old_mtx) {
+  if (!cds.requires.extensibility) cds.requires.extensibility = true // REVISIT: extensibility was always true in old MTX?
+  ExtendedModels.prototype.at = function (key) { return this[key] }
+  old_mtx.eventEmitter.on (old_mtx.events.TENANT_UPDATED, async (tenant='') => {
+    delete ExtendedModels.cache [tenant+':']
+  })
+}
+
+
+// ---------------------------------------------------------------------------
+// Optimizations for single-tenancy modes
+
+const extensibility = cds.requires.extensibility
+if (!extensibility) {
+  ExtendedModels.prototype.at = function (key) { return this[key] }
+  if (!cds.requires.toggles) ExtendedModels.middleware4 = ()=> []
+}
+
+
+// helper to get model for tenant/features
+const _is_extended = old_mtx ? t => old_mtx.isExtended(t) : extensibility ? ()=> cds.db.exists('cds.xt.Extensions') : ()=> false
+const _get_model4 = old_mtx ? async (tenant) => {
+  const isExtended = tenant && await old_mtx.isExtended(tenant) // REVISIT: avoid await
+  if (isExtended) return old_mtx.getCsn(tenant) .then (cds.compile.for.nodejs)
+} : (tenant, toggles) => {
+  const { 'cds.xt.ModelProviderService':mps } = cds.services
+  return mps.getCsn (tenant, toggles) .then (cds.compile.for.nodejs)
+}
+
+
+// ---------------------------------------------------------------------------
+// Optimizations for single-tenancy modes
+
+if (cds.requires.multitenancy && typeof global.it === 'undefined') ExtendedModels.cache.startSentinel()
+// REVISIT: how to do ^that^ correctly with jest?

package/lib/{serve/Transaction.js → srv/srv-tx.js}

@@ -1,42 +1,47 @@
 const cds = require('../index'), { cds_tx_protection } = cds.env.features
 const EventContext = require('../req/context')
-class RootContext extends EventContext {}
+class RootContext extends EventContext {
+  static for(_) {
+    if (_ instanceof EventContext) return _
+    else return super.for(_,'as root')
+  }
+}
+class NestedContext extends EventContext {
+  static for(_) {
+    if (_ instanceof EventContext) return _
+    else return super.for(_)
+  }
+}
+
 
 /**
  * This is the implementation of the `srv.tx(req)` method. It constructs
  * a new Transaction as a derivate of the `srv` (i.e. {__proto__:srv})
- * @returns { Transaction & import('./Service-api') }
+ * @returns { Transaction & import('./srv-api') }
  * @param { EventContext } ctx
  */
-module.exports = function tx (ctx,fn) { const srv = this
+function srv_tx (ctx,fn) { const srv = this
 
   if (srv.context) return srv // srv.tx().tx() -> idempotent
+  if (!ctx) return RootTransaction.for (srv)
+
+  // Creating root or nested txes for existing contexts
+  if (ctx instanceof EventContext) {
+    if (ctx.tx) return NestedTransaction.for (srv, ctx)
+    else return RootTransaction.for (srv, ctx)
+  }
 
   // Last arg may be a function -> srv.tx (tx => { ... })
   if (typeof ctx === 'function') [ ctx, fn ] = [ undefined, ctx ]
   if (typeof fn === 'function') {
-    const tx = srv.tx(ctx), fx = ()=> Promise.resolve(fn(tx)).then(tx.commit,tx.rollback)
-    const gc = cds.context, _has_tx = gc && gc.tx && !gc.tx._done
-    return _has_tx ? fx() : cds._context.run(tx,fx)
-  }
-
-  if (ctx) {
-    if (ctx.context) ctx = ctx.context
-
-    // REVISIT: This is for compatibility with former srv.tx(req) usages
-    if (ctx instanceof EventContext) {
-      if (ctx.tx) return NestedTransaction.for (srv, ctx)
-      else return RootTransaction.for (srv, ctx)
-    }
-
-    // REVISIT: This is for compatibility with AFC only
-    if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
-    else Object.defineProperty(ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
-    return RootTransaction.for (srv, ctx)
+    const tx = RootTransaction.for (srv, ctx)
+    return cds._context.run (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
   }
 
-  // `ctx` is a plain context object or undefined
-  return RootTransaction.for (srv, RootContext.for(ctx))
+  // REVISIT: following is for compatibility with AFC only -> we should get rid of that
+  if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
+  else Object.defineProperty (ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
+  return RootTransaction.for (srv, ctx)
 }
 
 
@@ -45,19 +50,23 @@ class Transaction {
   /**
    * Returns an already started tx for given srv, or creates a new instance
    */
-  static for (srv,root) {
-    let txs = root.transactions
-    if (!txs) Object.defineProperty(root, 'transactions', {value: txs = new Map})
+  static for (srv, ctx) {
+    const txs = ctx.context.transactions || ctx.context._set ('transactions', new Map)
+    if (srv._real_srv) srv = srv._real_srv // REVISIT: srv._real_srv is a dirty hack for current Okra Adapters
     let tx = txs.get (srv)
-    if (!tx) txs.set (srv, tx = new this (srv,root))
+    if (!tx) txs.set (srv, tx = new this (srv,ctx))
     return tx
   }
 
-  constructor (srv,root) {
-    const tx = { __proto__:srv, context:root }
+  constructor (srv, ctx) {
+    const tx = { __proto__:srv, _kind: new.target.name, context: ctx }
     const proto = new.target.prototype
     tx.commit   = proto.commit.bind(tx)
     tx.rollback = proto.rollback.bind(tx)
+    if (srv.isExtensible) {
+      const m = cds.context?.model
+      if (m) tx.model = m
+    }
     return _init(tx)
   }
 
@@ -102,11 +111,12 @@ class Transaction {
 class RootTransaction extends Transaction {
 
   /**
-   * Register the new transaction with the root context.
-   * @param {EventContext} root
+   * Register the new transaction with the given context.
+   * @param {EventContext} ctx
    */
-  static for (srv,root) {
-    return root.tx = super.for (srv,root)
+  static for (srv, ctx) {
+    ctx = RootContext.for (ctx?.tx?._done ? {} : ctx)
+    return ctx.tx = super.for (srv, ctx)
   }
 
   /**
@@ -148,16 +158,21 @@ class RootTransaction extends Transaction {
 
 class NestedTransaction extends Transaction {
 
+  static for (srv,ctx) {
+    ctx = NestedContext.for (ctx)
+    return super.for (srv, ctx)
+  }
+
   /**
-   * Registers event listeners with the root context, to commit or rollback
+   * Registers event listeners with the given context, to commit or rollback
    * when the root tx is about to commit or rollback.
-   * @param {import ('../req/context')} root
+   * @param {EventContext} ctx
    */
-  constructor (srv,root) {
-    super (srv,root)
-    root.before ('succeeded', ()=> this.commit())
-    root.before ('failed', ()=> this.rollback())
-    if ('end' in srv) root.once ('done', ()=> srv.end())
+  constructor (srv,ctx) {
+    super (srv,ctx)
+    ctx.before ('succeeded', ()=> this.commit())
+    ctx.before ('failed', ()=> this.rollback())
+    if ('end' in srv) ctx.once ('done', ()=> srv.end())
   }
 
 }
@@ -188,3 +203,5 @@ const _begin = async function (req) {
   delete this.dispatch
   return this.dispatch (req)
 }
+
+module.exports = srv_tx

package/lib/utils/{tests.js → cds-test.js}

@@ -25,7 +25,7 @@ class Test extends require('./axios') {
         this.server = server
         this.url = url
       })
-      try { return cds.exec (cmd, ...args, '--port','0') }
+      try { return cds.exec (cmd, ...args, ...(args.includes('--port') ? [] : ['--port', '0'])) }
       catch (e) { if (is_mocha) console.error(e) } // eslint-disable-line no-console
     })
 
@@ -97,7 +97,7 @@ function support_jest_and_mocha() {
     }
     after(()=>{
       delete global.cds
-      for (let k in require.cache) delete require.cache[k]
+      for (let k in require.cache) delete require.cache[k] // REVISIT: Whay are we doing that?
     })
   } else if (is_jest) { // it's jest
     global.before = (msg,fn) => global.beforeAll(fn||msg)

package/lib/utils/cds-utils.js

@@ -0,0 +1,146 @@
+const cwd = process.env._original_cwd || process.cwd()
+const path = require ('path'), { dirname, extname, join, resolve, relative } = path
+const fs = require('fs')
+const cds = require('../index')
+
+const all = module.exports = exports = { ...fs,
+  get inspect() { return $set (this, 'inspect', require('util').inspect) },
+  get uuid() { return $set (this, 'uuid', require('@sap/cds-foss').uuid) },
+}
+
+exports.fs = all
+exports.path = path
+
+exports.local = (file) => relative(cwd,file)
+
+exports.readdir = async function (x) {
+  const d = resolve (cds.root,x)
+  return fs.promises.readdir(d)
+}
+
+exports.stat = async function (x) {
+  const d = resolve (cds.root,x)
+  return fs.promises.stat(d)
+}
+
+exports.exists = function exists (x) {
+  if (x) {
+    const y = resolve (cds.root,x)
+    return fs.existsSync(y)
+  }
+}
+
+exports.isdir = function isdir (x) {
+  if (x) try {
+    const y = resolve (cds.root,x)
+    const ls = fs.lstatSync(y)
+    if (ls.isDirectory()) return y
+    if (ls.isSymbolicLink()) return isdir (join (dirname(y), fs.readlinkSync(y)))
+  } catch(e){/* ignore */}
+}
+
+exports.isfile = function isfile (x) {
+  if (x) try {
+    const y = resolve (cds.root,x)
+    const ls = fs.lstatSync(y)
+    if (ls.isFile()) return y
+    if (ls.isSymbolicLink()) return isfile (join (dirname(y), fs.readlinkSync(y)))
+  } catch(e){/* ignore */}
+}
+
+exports.read = async function read (file, _encoding) {
+  const f = resolve (cds.root,file)
+  const src = await fs.promises.readFile (f, _encoding !== 'json' && _encoding || 'utf8')
+  return _encoding === 'json' || !_encoding && f.endsWith('.json') ? JSON.parse(src) : src
+}
+
+exports.write = function write (file, data, o) {
+  if (arguments.length === 1) return {to:(...path) => write(join(...path),file)}
+  if (typeof data === 'object' && !Buffer.isBuffer(data))
+    data = JSON.stringify(data, null, ' '.repeat(o && o.spaces))
+  const f = resolve (cds.root,file)
+  return mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data,o))
+}
+
+exports.mkdirp = async function (...path) {
+  const d = resolve (cds.root,...path)
+  await fs.promises.mkdir (d,{recursive:true})
+  return d
+}
+
+exports.rmdir = (...path) => {
+  const d = resolve (cds.root,...path)
+  return fs.promises.rm (d, {recursive:true})
+}
+
+exports.rimraf = (...path) => {
+  const d = resolve (cds.root,...path)
+  return fs.promises.rm (d, {recursive:true,force:true})
+}
+
+exports.rm = async function rm (x) {
+  const y = resolve (cds.root,x)
+  return fs.promises.rm(y)
+}
+
+exports.copy = async function copy (x,y) {
+  const src = resolve (cds.root,x)
+  const dst = resolve (cds.root,y)
+  if (fs.promises.cp) return fs.promises.cp (src,dst,{recursive:true})
+  await mkdirp (dirname(dst))
+  if (isdir(src)) {
+    const entries = await fs.promises.readdir(src)
+    return Promise.all (entries.map (async each => {
+      const e = join (src,each)
+      const f = join (dst,each)
+      return copy (e,f)
+    }))
+  } else {
+    return fs.promises.copyFile (src,dst)
+  }
+}
+
+exports.find = function find (base, patterns='*', filter=()=>true) {
+  const files=[];  base = resolve (cds.root,base)
+  if (typeof patterns === 'string')  patterns = patterns.split(',')
+  if (typeof filter === 'string')  filter = this[filter]
+  patterns.forEach (pattern => {
+    const star = pattern.indexOf('*')
+    if (star >= 0) {
+      const head = pattern.slice(0,star).replace(/[^/\\]*$/,'')
+      const dir = join (base,head)
+      try {
+        const ls = fs.lstatSync(dir)
+        if (ls.isDirectory()) {
+          const [,suffix,tail] = /([^/\\]*)?(?:.(.*))?/.exec (pattern.slice(star+1))
+          const prefix = pattern.slice(head.length,star)
+          let entries = fs.readdirSync(dir) //.filter (_filter)
+          if (prefix)  entries = entries.filter (e => e.startsWith(prefix));  if (!entries.length) return
+          if (suffix)  entries = entries.filter (e => e.endsWith(suffix));  if (!entries.length) return
+          let paths = entries.map (e=>join(dir,e))
+          if (filter)  paths = paths.filter (filter);  if (!paths.length) return
+          if (tail)  for (let _files of paths.map (e=>find (e,tail,filter)))  files.push (..._files)
+          else  files.push (...paths)
+        }
+      } catch(e) {/* ignore */}
+    } else {
+      const file = join (base, pattern)
+      if (fs.existsSync(file))  files.push (file)
+    }
+  })
+  return files
+}
+
+
+// internal utility to load a file through ESM or CommonJs.  TODO find a better place.
+const { pathToFileURL } = require('url')
+exports._import = async function(filePath) {
+  return typeof jest !== 'undefined' || extname(filePath) === '.ts' // ts-node w/ ESM not working (cap/issues#11980)
+    ? require(filePath)
+    : import (pathToFileURL(filePath).href) // must use a file: URL, esp. on Windows for C:\... paths
+}
+
+
+/** @type <T>(o,p,v:T) => T */
+const $set = (o,p,v) => { Object.defineProperty(o,p,{value:v}); return v }
+const { mkdirp, isdir } = exports

package/lib/utils/index.js

@@ -1,145 +1,2 @@
-const cwd = process.env._original_cwd || process.cwd()
-const path = require ('path'), { dirname, extname, join, resolve, sep, relative } = path
-const fs = require('fs')
-const cds = require('../index')
-
-const all = module.exports = exports = { ...fs,
-  get inspect() { return $set (this, 'inspect', require('util').inspect) },
-  get uuid() { return $set (this, 'uuid', require('@sap/cds-foss').uuid) },
-}
-
-exports.fs = all
-exports.path = path
-
-exports.local = (file) => relative(cwd,file)
-
-exports.readdir = async function (x) {
-  const d = resolve (cds.root,x)
-  return fs.promises.readdir(d)
-}
-
-exports.stat = async function (x) {
-  const d = resolve (cds.root,x)
-  return fs.promises.stat(d)
-}
-
-exports.exists = function exists (x) {
-  if (x) {
-    const y = resolve (cds.root,x)
-    return fs.existsSync(y)
-  }
-}
-
-exports.isdir = function isdir (x) {
-  if (x) try {
-    const y = resolve (cds.root,x)
-    const ls = fs.lstatSync(y)
-    if (ls.isDirectory()) return y
-    if (ls.isSymbolicLink()) return isdir (join (dirname(y), fs.readlinkSync(y)))
-  } catch(e){/* ignore */}
-}
-
-exports.isfile = function isfile (x) {
-  if (x) try {
-    const y = resolve (cds.root,x)
-    const ls = fs.lstatSync(y)
-    if (ls.isFile()) return y
-    if (ls.isSymbolicLink()) return isfile (join (dirname(y), fs.readlinkSync(y)))
-  } catch(e){/* ignore */}
-}
-
-exports.read = async function read (file, _encoding) {
-  const f = resolve (cds.root,file)
-  const src = await fs.promises.readFile (f, _encoding !== 'json' && _encoding || 'utf8')
-  return _encoding === 'json' || !_encoding && f.endsWith('.json') ? JSON.parse(src) : src
-}
-
-exports.write = function write (file, data, o) {
-  if (arguments.length === 1) return {to:(...path) => write(join(...path),file)}
-  if (typeof data === 'object' && !Buffer.isBuffer(data))
-    data = JSON.stringify(data, null, ' '.repeat(o && o.spaces))
-  const f = resolve (cds.root,file)
-  return mkdirp (dirname(f)).then (()=> fs.promises.writeFile (f,data,o))
-}
-
-exports.mkdirp = async function (...path) {
-  const d = resolve (cds.root,...path)
-  await fs.promises.mkdir (d,{recursive:true})
-  return d
-}
-
-exports.rmdir = (...path) => {
-  const d = resolve (cds.root,...path)
-  return (fs.promises.rm || fs.promises.rmdir) (d, {recursive:true})
-}
-
-exports.rimraf = (...path) => {
-  const d = resolve (cds.root,...path)
-  return (fs.promises.rm || fs.promises.rmdir) (d, {recursive:true,force:true})
-}
-
-exports.rm = async function rm (x) {
-  const y = resolve (cds.root,x)
-  return (fs.promises.rm || fs.promises.unlink)(y)
-}
-
-exports.copy = async function copy (x,y) {
-  const src = resolve (cds.root,x)
-  const dst = resolve (cds.root,y)
-  if (fs.promises.cp) return fs.promises.cp (src,dst,{recursive:true})
-  await mkdirp (dirname(dst))
-  if (isdir(src)) {
-    const entries = await fs.promises.readdir(src)
-    return Promise.all (entries.map (async each => {
-      const e = join (src,each)
-      const f = join (dst,each)
-      return copy (e,f)
-    }))
-  } else {
-    return fs.promises.copyFile (src,dst)
-  }
-}
-
-exports.find = function find (base, patterns='*', filter=()=>true) {
-  const files=[];  base = resolve (cds.root,base)
-  if (typeof patterns === 'string')  patterns = patterns.split(',')
-  if (typeof filter === 'string')  filter = this[filter]
-  patterns.forEach (pattern => {
-    const star = pattern.indexOf('*')
-    if (star >= 0) {
-      const head = pattern.slice(0,star).replace(/[^/\\]*$/,'')
-      const dir = join (base,head)
-      try {
-        const ls = fs.lstatSync(dir)
-        if (ls.isDirectory()) {
-          const [,suffix,tail] = /([^/\\]*)?(?:.(.*))?/.exec (pattern.slice(star+1))
-          const prefix = pattern.slice(head.length,star)
-          let entries = fs.readdirSync(dir) //.filter (_filter)
-          if (prefix)  entries = entries.filter (e => e.startsWith(prefix));  if (!entries.length) return
-          if (suffix)  entries = entries.filter (e => e.endsWith(suffix));  if (!entries.length) return
-          let paths = entries.map (e=>join(dir,e))
-          if (filter)  paths = paths.filter (filter);  if (!paths.length) return
-          if (tail)  for (let _files of paths.map (e=>find (e,tail,filter)))  files.push (..._files)
-          else  files.push (...paths)
-        }
-      } catch(e) {/* ignore */}
-    } else {
-      const file = join (base, pattern)
-      if (fs.existsSync(file))  files.push (file)
-    }
-  })
-  return files
-}
-
-// internal utility to load a file through ESM or CommonJs.  TODO find a better place.
-const { pathToFileURL } = require('url')
-exports._import = async function(filePath) {
-  return typeof jest !== 'undefined' || extname(filePath) === '.ts' // ts-node w/ ESM not working (cap/issues#11980)
-    ? require(filePath)
-    : import (pathToFileURL(filePath).href) // on Windows, must use a file: URL for ESM import
-}
-
-
-/** @type <T>(o,p,v:T) => T */
-const $set = (o,p,v) => { Object.defineProperty(o,p,{value:v}); return v }
-const { mkdirp, isdir } = exports
+// for compatibility with old releases of cds-lint
+module.exports = require('./cds-utils')