@sap/cds 6.6.1 → 6.7.0

package/lib/dbs/cds-deploy.js

@@ -1,12 +1,9 @@
-const cds = require('../index'), { local, inspect } = cds.utils, { UPSERT } = cds.ql
+const cds = require('../index'), { local } = cds.utils
+const COLORS = !!process.stdout.isTTY && !!process.stderr.isTTY
+const GREY = COLORS ? '\x1b[2m' : ''
+const RESET = COLORS ? '\x1b[0m' : ''
 const DEBUG = cds.debug('deploy')
-
-const colors = !!process.stdout.isTTY && !!process.stderr.isTTY
-const term = {
-  x1b2: colors ? '\x1b[2m' : '',
-  x1b0: colors ? '\x1b[0m' : '',
-  info: colors ? (s => term.x1b2 + s + term.x1b0) : (s => s)
-}
+const TRACE = cds.debug('trace')
 
 /**
  * Implementation of `cds.deploy` common to all databases.
@@ -18,18 +15,10 @@ exports = module.exports = function cds_deploy (model,options,csvs) { return {
 
   /** @param {cds.Service} db */
   async to (db, o = options || cds.options || {}) {
-    if (!model)  throw new Error('Must provide a model or a path to model, received: ' + model)
-    const LOG = o.silent || !cds.log('deploy')._info ? ()=>{} : console.log
+    TRACE?.time ('cds.deploy db  ')
 
-    if (model && !model.definitions) {
-      model = await cds.load (model) .then (cds.minify)
-      if (DEBUG) try {
-        DEBUG (`loaded model from ${model.$sources.length} file(s):\n${term.x1b2}`)
-        for (let each of model.$sources)  console.log (' ', local(each))
-      } finally {
-        console.log (term.x1b0)
-      }
-    }
+    if (!model)  throw new Error('Must provide a model or a path to model, received: ' + model)
+    if (model && !model.definitions) model = await cds.load(model).then(cds.minify)
 
     if (o.mocked) exports.include_external_entities_in (model)
     else exports.exclude_external_entities_in (model)
@@ -39,18 +28,18 @@ exports = module.exports = function cds_deploy (model,options,csvs) { return {
     if (!db.model) db.model = model
 
     // create tables & views...
+    const LOG = o.silent || !cds.log('deploy')._info ? ()=>{} : console.log
     const any = await exports.create (db,model,o)
     if (!any && !csvs) return db
 
     // fill in initial data...
-    await exports.init (db,model,o,csvs, file => LOG(
-      term.info(` > init from ${local(file)}`)
-    ))
+    await exports.init (db,model,o,csvs, file => LOG (GREY,` > init from ${local(file)}`, RESET))
 
     // done
-    const file = db.getDbUrl(cds.context?.tenant)
-    if (file !== ':memory:') LOG (`/> successfully deployed to ./${file}\n`)
-    else LOG (`/> successfully deployed to sqlite in-memory db\n`)
+    let url = db.url4 (cds.context?.tenant); if (url === ':memory:') url = 'in-memory database.'
+    LOG ('/> successfully deployed to', url, '\n')
+
+    TRACE?.timeEnd ('cds.deploy db  ')
     return db
   },
 
@@ -105,127 +94,104 @@ exports.exclude_external_entities_in = function (csn) { // NOSONAR
   }
 }
 
-function getSqls(db, csn, o, beforeCsn) {
-  const schemaEvo = (db.options?.schema_evolution === 'auto' || o.schema_evolution === 'auto')
-  if (schemaEvo) {
-    const { afterImage: afterCsn, drops, createsAndAlters: creas } = cds.compile.to.sql.delta (csn, o, beforeCsn);
-    if(beforeCsn === undefined) {
-      // If this is the first deployment done with automatic schema evolution, generate everything as if it was a drop create
-      // but set the afterCsn in the db so we can calculate a delta going forward
-      return { afterCsn, drops: creas.map (each => {
-        let [, kind, entity] = each.match(/^CREATE (TABLE|VIEW) "?([^\s"(]+)/im) || []
-        return `DROP ${kind} IF EXISTS ${entity};`
-      }).reverse(), creas };
-    }
-    return { afterCsn, drops, creas };
-  } else {
-    const creas = cds.compile.to.sql(csn, o);
-    const drops = creas.map (each => {
-      let [, kind, entity] = each.match(/^CREATE (TABLE|VIEW) "?([^\s"(]+)/im) || []
-      return `DROP ${kind} IF EXISTS ${entity};`
-    }).reverse();
-    return { afterCsn: {}, drops, creas };
-  }
-}
 
-exports.create = async function (db, csn=db.model, o) {
-  const schemaEvo = (db.options?.schema_evolution === 'auto' || o.schema_evolution === 'auto')
-  if(db.deploy && !schemaEvo) {
-    // reset CSN state saved in db - if there is any
-    if(!o.dry) await db.run('DROP table if exists cds_Model;');
-    return db.deploy(csn, o);
+exports.create = async function cds_deploy_create (db, csn=db.model, o) {
+
+  let drops, creas, schevo = db.options?.schema_evolution === 'auto' || o.schema_evolution === 'auto'
+  if (schevo) {
+    // REVISIT: replace by db-specific ways to read/updated recent deployed model
+    let before = await db.run (async tx => { try {
+      let [{ csn }] = await tx.run('SELECT csn from cds_Model')
+      return JSON.parse(csn)
+    } catch(e) { if (!e.message.includes('no such table')) throw e
+      await tx.run(`CREATE table cds_Model (csn CLOB)`)
+      await tx.run(`INSERT into cds_Model values ('null')`)
+    }})
+    const { afterImage, drops:_drops, createsAndAlters:_creas } = cds.compile.to.sql.delta (csn, o, before)
+    creas = _creas.concat (o.dry ? [] : UPDATE('cds.Model').with({ csn: JSON.stringify(afterImage) }))
+    drops = before ? _drops : _drops4(_creas)
+  } else {
+    creas = cds.compile.to.sql (csn, o)
+    drops = _drops4(creas) .concat ('DROP table if exists cds_Model;')
   }
+  if (!creas || creas.length === 0) return
 
-  let beforeCsn
-  if (schemaEvo) try {
-    const [{ csn }] = await db.read('cds.Model')
-    beforeCsn = JSON.parse(csn);
-  } catch(e) {
-    if (e.message.includes('no such table: cds_Model')) {
-      await db.run('CREATE table cds_Model ( csn CLOB )')
-      await db.insert({csn:''}).into('cds.Model')
-    }
+  function _drops4 (creas) {
+    return creas.map (each => {
+      let [, kind, entity] = each.match(/^CREATE (TABLE|VIEW) ("[^"]+"|[^\s(]+)/im) || []
+      return `DROP ${kind} IF EXISTS ${entity};`
+    }).reverse()
   }
 
-  const { afterCsn, drops, creas } = getSqls(db, csn, o, beforeCsn);
-
-  if (!creas || creas.length === 0) return
   if (o.dry) {
-    console.log(); for (let each of drops) console.log(each,'\n')
+    console.log(); for (let each of drops) console.log(each)
     console.log(); for (let each of creas) console.log(each,'\n')
-    return
-  } else return db.run (async tx => {
+  }
+  else return db.run (async tx => {
+    // This runs in a new transaction if called from CLI, while joining
+    // existing root tx, e.g. when called from DeploymentService.
+    if (!schevo && await tx.exists('sqlite.schema').where({name:'cds_xt_Extensions'})) {
+      // Poor man's schema evolution for extensions in drop-create deployments
+      drops = drops.filter(d => !d.includes('cds_xt_Extensions'))
+      creas = creas.filter(c => !c.includes('cds_xt_Extensions'))
+    }
+    // Set the context model while deploying for cqn42sql in new db layers
+    tx.model = cds.compile.for.nodejs(csn)
     await tx.run(drops)
     await tx.run(creas)
-    if (schemaEvo) {
-      await tx.update('cds.Model').with({ csn: JSON.stringify(afterCsn) })
-    }
     return true
   })
 }
 
 
-exports.init = (db, csn=db.model, o, csvs, log=()=>{}) => db.run (async tx => {
-
-  const {tenant} = cds.context; if (tenant && tenant === cds.requires.multitenancy?.t0) return
-  const schemaEvo = db.options?.schema_evolution === 'auto' || o?.schema_evolution === 'auto'
-  const resources = await exports.resources(csn, {testdata: cds.env.features.test_data})
-  const inits=[]
-
-  if (csvs) {
-    const ccsn = cds.compile.for['nodejs'](csn) // compile to calculate keys for newly added entities
-    for(let [file,src] of Object.entries(csvs)) {
-      const entity = _entity4(path.basename(file, '.csv'), csn)
-      if (entity?.name) {
-        const q = INSERT_from_csv (entity.name,src,schemaEvo); if (!q) continue
-        if (db.kind === 'better-sqlite') _add_missing_pks2(q)
-        q._target = ccsn.definitions[entity.name]
-        inits.push (tx.run(q) .catch (e => {
-          throw Object.assign (e, { message: 'in cds.deploy(): ' + e.message +'\n'+ inspect(q) })
-        }))
-      }
-    }
-  } else {
-    for (let [file,e] of Object.entries(resources)) {
-      if (e === '*') { // init.js/ts
-        let x = await cds.utils._import(file);  if (!x) continue
-        if (x.default)  x = x.default  // default ESM export
-        inits.push (!x.then && typeof x === 'function' ? x(tx,csn) : x)
-        log (file)
-      } else { // from .csv or .json
-        const INSERT_into = _from_csv_or_json [path.extname(file)]
-        const src = await read(file,'utf8'); if (!src) continue
-        const q = INSERT_into (e,src,schemaEvo); if (!q) continue
-        if (db.kind === 'better-sqlite') _add_missing_pks2(q)
-        if (cds.requires['cds.xt.ModelProviderService']?.kind === 'in-sidecar') q._target = csn.definitions[e]
-        log (file,e)
-        inits.push (tx.run(q) .catch (e => {
-          throw Object.assign (e, { message: 'in cds.deploy(): ' + e.message +'\n'+ inspect(q) })
-        }))
-      }
-    }
-  }
+exports.init = async function cds_deploy_init (db, csn=db.model, o, srces, log=()=>{}) {
+  const t = cds.context?.tenant; if (t && t === cds.requires.multitenancy?.t0) return
+  return db.run (async tx => {
 
-  await Promise.all (inits)
+    const m = tx.model = cds.compile.for.nodejs(csn) //> use correct model while deploying
+    const data = await exports.data (m,srces)
+    const query = _queries4 (db,m)
+    const INSERT_from = INSERT_from4 (db,o)
 
-  function _add_missing_pks2 (q) {
-    const {columns,rows} =  q.UPSERT || q.INSERT // REVISIT: .entries are covered by current runtime. Should eventually also be handled here, as we likely don't do so in new db services
-    if (columns) {
-      const entity = csn.definitions[q._target.name], {uuid} = cds.utils
-      for (let k in entity.keys) if (!columns.includes(k) && !entity.keys[k].isAssociation) {
-        columns.push(k)
-        const t = entity.keys[k]._type, pk = t === 'cds.UUID' ? uuid : index => index+1
-        rows.forEach ((row,index) => row.push(pk(index)))
+    for await (let [ file, entity, src ] of data) {
+      log (file)
+      if (entity) {
+        const q = INSERT_from (file) .into (entity, src)
+        if (q) try { await tx.run (query(q)) } catch(e) {
+          throw Object.assign (e, { message: 'in cds.deploy(): ' + e.message +'\n'+ cds.utils.inspect(q) })
+        }
+      } else {  //> init.js/ts case
+        if (typeof src === 'function') src(tx,csn)
       }
     }
-  }
+  })
+}
 
-})
+
+/** Prepare input from .csv, .json, init.js, ... */
+exports.data = async function cds_deploy_prepare_data (csn, srces) {
+  // In case of extension deployment .csv or .json input are provided through argument `srces`.
+  if (srces) return Object.entries(srces) .map (([file, src]) => {
+    let e = _entity4 (path.basename(file,'.csv'), csn)
+    return [ file, e, src ]
+  })
+  // If not, we load them from cds.deploy.resources(csn)
+  const resources = await exports.resources(csn, { testdata: cds.env.features.test_data })
+  return Object.entries(resources) .map (async ([file,e]) => {
+    if (e === '*') {
+      let init_js = await cds.utils._import (file)
+      return [ file, null, init_js.default || init_js ]
+    } else {
+      let src = await read (file, 'utf8')
+      return [ file, e, src ]
+    }
+  })
+}
 
 
-exports.resources = async function (csn, opts) {
+exports.resources = async function cds_deploy_resources (csn, opts) {
   if (!csn || !csn.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
-  const folders = await exports.resources.folders(csn, opts)
+  const folders = await cds_deploy_resources.folders(csn, opts)
   const found={}, ts = process.env.CDS_TYPESCRIPT
   for (let folder of folders) {
     // fetching init.js files
@@ -237,7 +203,7 @@ exports.resources = async function (csn, opts) {
       const files = await readdir (subdir)
       for (let fx of files) {
         if (fx[0] === '-') continue
-        const ext = path.extname(fx); if (ext in _from_csv_or_json) {
+        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'
@@ -287,17 +253,47 @@ const _entity4 = (file,csn) => {
   return entity.name ? entity : { name, __proto__:entity }
 }
 
-const INSERT_from_csv = (entity, csv, schemaEvo) => {
-  let [ cols, ...rows ] = cds.parse.csv (csv)
-  if (rows.length > 0) return (schemaEvo ? UPSERT : INSERT).into (entity) .columns (cols) .rows (rows)
+
+/** Prepare special handling for new db services */
+const _queries4 = (db,csn) => !db.cqn2sql ? q => q : q => {
+  const { columns, rows } =  q.INSERT || q.UPSERT; if (!columns) return q // REVISIT: .entries are covered by current runtime -> should eventually also be handled here
+  const entity = csn.definitions[q._target.name]
+
+  // Fill in missing primary keys...
+  const { uuid } = cds.utils
+  for (let k in entity.keys) if (entity.keys[k].isUUID && !columns.includes(k)) {
+    columns.push(k)
+    rows.forEach(row => row.push(uuid()))
+  }
+
+  // Fill in missing managed data...
+  const pseudos = { $user: 'anonymous', $now: (new Date).toISOString() }
+  for (let k in entity.elements) {
+    const managed = entity.elements[k]['@cds.on.insert']?.['=']
+    if (managed && !columns.includes(k)) {
+      columns.push(k)
+      rows.forEach(row => row.push(pseudos[managed]))
+    }
+  }
+
+  return q
 }
 
-const INSERT_from_json = (entity, json, schemaEvo) => {
-  let records = JSON.parse (json)
-  if (records.length > 0) return (schemaEvo ? UPSERT : INSERT).into (entity) .entries (records)
+
+const INSERT_from4 = (db,o) => {
+  const schevo = db.options?.schema_evolution === 'auto' || o?.schema_evolution === 'auto'
+  const INSERT_into = (schevo ? UPSERT : INSERT).into
+  return (file) => ({
+    '.json': { into (entity, json) {
+      let records = JSON.parse(json)
+      if (records.length > 0) return INSERT_into(entity).entries(records)
+    }},
+    '.csv': { into (entity, csv) {
+      let [cols, ...rows] = cds.parse.csv(csv)
+      if (rows.length > 0) return INSERT_into(entity).columns(cols).rows(rows)
+    }},
+  }) [path.extname(file)]
 }
 
-const _from_csv_or_json = { '.json': INSERT_from_json, '.csv': INSERT_from_csv, }
 const _skip = e => !e || e['@cds.persistence.skip'] === true
-
 /* eslint-disable no-console */

package/lib/env/cds-env.js

@@ -32,6 +32,11 @@ class Config {
     const { NODE_ENV, CDS_ENV } = process.env, profiles = []
     if (NODE_ENV) profiles.push (NODE_ENV)
     if (CDS_ENV) profiles.push (...CDS_ENV.split(/\s*,\s*/))
+    if (_home) try {
+      const { cds } = require(path.join(_home,'package.json'))
+      if (cds?.profiles) profiles.push(...cds.profiles)
+      if (cds?.profile) profiles.push(cds.profile)
+    } catch {/* ignore */}
     if (!profiles.includes('production')) profiles.push('development')
     this._profiles = new Set (profiles)
     this._profiles._defined = new Set()
@@ -127,8 +132,9 @@ class Config {
    * Retrieves the value for a config option, specified as a property path.
    */
   get (option) {
-    if (!option)  return
-    return option.split('.').reduce ((p,n)=> p && p[n], this)
+    if (!option) return
+    let path = option.includes('/') ? option.split('/') : option.split('.')
+    return path.reduce ((p,n)=> p && p[n], this)
   }
 
   get profiles() {
@@ -244,7 +250,7 @@ class Config {
   }
 
   _link_required_services () {
-    const { requires } = this; if (!requires) return
+    const { requires, _profiles } = this; if (!requires) return
     const kinds = requires.kinds || {}
     Object.defineProperty (requires, 'kinds', { value:kinds, enumerable:false }) // for cds env
     // Object.setPrototypeOf (requires, kinds)
@@ -254,27 +260,28 @@ class Config {
       if (!val || val._is_linked) return val
       if (val === true) {
         let x = kinds[key]
-        if (!x) return val
-        else val = x
+        if (x) val = x; else return val
       }
       if (typeof val === 'string') {
         let x = kinds[val] || kinds[val+'-'+key] || kinds[key+'-'+val]
-        if (!x) return val
-        else val = { kind: val }
+        if (x) val = {kind:val}; else return val
       }
-      const preset1 = kinds[key]
-      if (typeof preset1 === 'object' && preset1 !== val) {
-        const top = val, base = _merge ({},_linked(key,preset1)), {kind} = base
-        val = _merge (base, top, false, false)  // apply/override with top-level data
-        if (kind) val.kind = kind              // but inherited kind wins
+      let k = val.kind, p, preset = kinds[p=k] || kinds[p=k+'-'+key] || kinds[p=key+'-'+k]
+      if (!preset?.$root) {
+        const preset1 = kinds[key]
+        if (typeof preset1 === 'object' && preset1 !== val) {
+          const top = val, base = _merge ({},_linked(key,preset1)), {kind} = base
+          val = _merge (base, top, false, false)  // apply/override with top-level data
+          if (kind) val.kind = kind              // but inherited kind wins
+        }
       }
-      let k = val.kind, p, preset = k && kinds[p=k] || kinds[p=k+'-'+key] || kinds[p=key+'-'+k]
       if (typeof preset === 'object' && preset !== val) {
-        const top = val, base = _merge ({},_linked(p,preset)), {kind} = base
-        val = _merge (base, top, false, false)  // apply/override with top-level data
+        const top = val, base = _merge ({},_linked(p,preset), _profiles), {kind} = base
+        val = _merge (base, top, _profiles, false)  // apply/override with top-level data
         if (kind) val.kind = kind              // but inherited kind wins
       }
-      return Object.defineProperty (val, '_is_linked', {value:true})
+      if (typeof val === 'object') Object.defineProperty (val, '_is_linked', {value:true})
+      return val
     }
   }
 
@@ -435,7 +442,8 @@ function _merge (dst, src, _profiles, _cloned, _profiles_only = false) {
       const profile = p.slice(1,-1)
       if (_profiles._defined)  _profiles._defined.add (profile)
       if (_profiles.has(profile)) {
-        profiled.push ({ profile, merge: () => _merge (dst, src[p], _profiles, _cloned, false)})
+        let o = src[p]; if (typeof o === 'string') o = {kind:o}
+        profiled.push ({ profile, merge: () => _merge (dst, o, _profiles, _cloned, false)})
       }
       continue
     }

package/lib/env/cds-requires.js

@@ -2,16 +2,8 @@ const _runtime = '@sap/cds/libx/_runtime'
 
 exports = module.exports = {
 
-  middlewares: false,
-  "[middlewares]": {
-    middlewares: true
-  },
-
-  "[schevo]": {
-    db: { schema_evolution: 'auto' },
-  },
-
-  db: undefined,
+  middlewares: undefined,   "[middlewares]": { middlewares: true },
+  db: undefined,            "[schevo]": { db: { schema_evolution: 'auto' }, },
   messaging: undefined,
   multitenancy: undefined,
   extensibility: undefined,
@@ -127,19 +119,20 @@ const _databases = {
   "sql": {
     '[development]': { kind: 'sqlite', credentials: { url: ':memory:' } },
     '[production]': { kind: 'hana' },
-    '[better-sqlite]': { kind: 'better-sqlite' },
   },
-  "better-sqlite": _compat_to_use({
+  "better-sqlite": {
     credentials: { url: ":memory:" },
     impl: "@cap-js/sqlite",
-  }),
-  "sql-mt": {
+    kind: 'sqlite'
+  },
+  "sql-mt": { // For compatibility only
     '[development]': { kind: 'sqlite' },
     '[production]': { kind: 'hana-mt' },
   },
   "sqlite": _compat_to_use({
-    credentials: { url: 'db.sqlite' },
+    '[better-sqlite]': { impl: '@cap-js/sqlite' },
     impl: `${_runtime}/sqlite/Service.js`,
+    credentials: { url: 'db.sqlite' },
   }),
   "hana": _compat_to_use ({
     impl: `${_runtime}/hana/Service.js`,
@@ -246,37 +239,12 @@ const _platform_services = {
 
 }
 
-require = (id) => { // eslint-disable-line no-global-assign
-  try {
-    return module.require(id)
-  } catch(e) {
-    if (e.code !== 'MODULE_NOT_FOUND') throw e
-  }
-}
-
-// REVISIT: we should have a real modular plugin technique for cds.env
-const utils = require ('../utils/cds-utils')
-const _mtxs = !utils._oldMtx()
-  // eslint-disable-next-line cds/no-missing-dependencies
-  && require('@sap/cds-mtxs/lib/env-requires') || {
-  "toggles": {
-    model: "@sap/cds/srv/mtx"
-  },
-  "multitenancy": {
-    model: "@sap/cds/srv/mtx",
-    kind: "saas-registry",
-  },
-  "extensibility": {
-    model: "@sap/cds/srv/mtx",
-  },
-}
 
 exports.kinds = {
   ..._authentication_strategies,
   ..._databases,
   ..._services,
   ..._messaging,
-  ..._mtxs,
   ..._platform_services,
 }
 
@@ -285,3 +253,5 @@ function _compat_to_use(o) { return Object.defineProperties (o,{
   // NOTE: Property .use is for compatibility only -> use .dialect instead!
   use: { get(){ return this.dialect || this.kind }, configurable:true, enumerable:true },
 })}
+
+Object.defineProperty(exports,'_resolved',{value:exports._resolved,enumerable:false}) // hide it in outputs

package/lib/env/compat.js

@@ -89,4 +89,16 @@ module.exports = function (conf) {
       }
     }
   })
+
+  Object.defineProperties (conf.features, {
+    fiori_preview: {
+      get: ()=> _.fiori.preview,
+      set: (v) => { _.fiori.preview = v },
+    },
+    fiori_routes: {
+      get: ()=> _.fiori.routes,
+      set: (v) => { _.fiori.routes = v },
+    },
+  })
+
 }

package/lib/env/defaults.js

@@ -1,8 +1,7 @@
-const path = require('path')
-const [,major,minor] = /v(\d+)\.(\d+)/.exec(process.version)
 const production = process.env.NODE_ENV === 'production'
+const path = require('path')
 
-module.exports = {
+const defaults = module.exports = {
 
   requires: require('./cds-requires'),
 
@@ -13,10 +12,7 @@ module.exports = {
 
   features: {
     folders: 'fts/*', // where to find feature toggles -> switch on by default when released
-    cls: major > 12 || major == 12 && minor >= 18,
     live_reload: !production,
-    fiori_preview: !production,
-    fiori_routes: !production,
     in_memory_db: !production,
     test_data: !production,
     test_mocks: !production,
@@ -30,10 +26,20 @@ module.exports = {
     assert_integrity: false,
     cds_tx_protection: true,
     cds_tx_inheritance: true,
+  },
+
+  fiori: {
+    preview: !production,
+    routes: !production,
     lean_draft: false,
-    '[lean-draft]': {
-      lean_draft: true,
-    }
+    draft_compat: false,
+    '[better-sqlite]': { lean_draft: true },
+    '[lean-draft]': { lean_draft: true },
+    '[draft-compat]': { draft_compat: true },
+  },
+
+  ql: {
+    quirks_mode: true, // IMPORTANT: Remove that for cds7 !!
   },
 
   log: {
@@ -162,3 +168,5 @@ module.exports = {
   },
 
 }
+
+require('./plugins')(defaults)

package/lib/env/plugins.js

@@ -0,0 +1,29 @@
+// REVISIT: we should have a real modular plugin technique for cds.env
+module.exports = function add_mtx_env (env) {
+
+  const mtx_env = old_mtx_env() || require('@sap/cds-mtxs/env') // eslint-disable-line cds/no-missing-dependencies
+  if (mtx_env) {
+    const {requires} = env, {kinds} = requires
+    Object.assign (env, mtx_env, {requires})
+    Object.assign (requires, mtx_env.requires, {kinds})
+    Object.assign (kinds, mtx_env.requires?.kinds)
+  }
+
+  function require (id) {
+    try { return module.require(id) }
+    catch(e) { if (e.code !== 'MODULE_NOT_FOUND') throw e }
+  }
+
+  function old_mtx_env() {
+    const {_oldMtx} = require('../utils/cds-utils')
+    if (_oldMtx()) return {
+      requires: { kinds: {
+        "multitenancy": { model: "@sap/cds/srv/mtx", kind: "saas-registry" },
+        "extensibility": { model: "@sap/cds/srv/mtx" },
+        // "toggles": { model: "@sap/cds/srv/mtx" },
+      }
+    }
+  }}
+
+  return env
+}

package/lib/env/schemas/cds-rc.json

@@ -5,6 +5,20 @@
   "type": "object",
   "additionalProperties": true,
   "properties": {
+    "[development]": { "type": "object" },
+    "[production]": { "type": "object" },
+    "[hybrid]": { "type": "object" },
+    "profile": {
+      "description": "A single static profile",
+      "anyOf": [
+        { "enum": [ "mtx-sidecar", "with-mtx-sidecar" ] },
+        { "type": "string" }
+      ]
+    },
+    "profiles": {
+      "description": "An array of profiles",
+      "type": "array", "items": { "$ref": "#/properties/profile" }
+    },
     "folders": {
       "type": "object",
       "description": "Only set folders if you don't want to use the defaults 'app/', 'db/', 'srv/'.",

package/lib/index.js

@@ -77,6 +77,9 @@ const cds = module.exports = extend (new facade) .with ({
   User: require ('./req/user'),
   ql: lazy => require ('./ql/cds-ql'),
   tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
+  inferred: lazy => require('@cap-js/sqlite/lib/ql/cds.infer'), // eslint-disable-line cds/no-missing-dependencies
+  cqn2sql: lazy => require('@cap-js/sqlite/lib/db/sql/cqn2sql'), // eslint-disable-line cds/no-missing-dependencies
+  cqn4sql: lazy => require('@cap-js/sqlite/lib/db/sql/cqn4sql'), // eslint-disable-line cds/no-missing-dependencies
   /** @type Service */ db: undefined,
 
   // Protocols and Periphery

package/lib/log/cds-log.js

@@ -65,9 +65,12 @@ function cds_log (module, options) { // NOSONAR
  * Shortcut to `cds.log(...).debug`, returning undefined if `cds.log(...)._debug` is false.
  * @param {string} [module] the module for which a logger is requested
  */
-exports.debug = function cds_debug (module) {
-  const L = this.log (module)
-  if (L._debug) return L.debug
+exports.debug = function cds_debug (id, options) {
+  const L = cds_log (id, options)
+  if (L._debug) return Object.assign(L.debug, {
+    time:    label => console.time    (`[${id}] - ${label}`),
+    timeEnd: label => console.timeEnd (`[${id}] - ${label}`),
+  })
 }
 
 
@@ -87,7 +90,7 @@ exports.Logger = (label, level) => {
   const fmt = (level,args) => logger.format (label,level,...args)
   const logger = {
     format: exports.format, // use logger.format as this could be changed dynamically
-    trace:  level < TRACE ? ()=>{} : (...args) => console.trace (...fmt(TRACE,args)),
+    trace:  level < DEBUG ? ()=>{} : (...args) => console.trace (...fmt(TRACE,args)),
     debug:  level < DEBUG ? ()=>{} : (...args) => console.debug (...fmt(DEBUG,args)),
     log:    level < INFO  ? ()=>{} : (...args) => console.log (...fmt(INFO,args)),
     info:   level < INFO  ? ()=>{} : (...args) => console.info (...fmt(INFO,args)),