@sap/cds 6.6.2 → 6.7.0

package/bin/deploy/to-hana/cfUtil.js

@@ -13,7 +13,7 @@ const cds = require('../../../lib');
 const LOG = cds.log ? cds.log('deploy') : console;
 const DEBUG = cds.debug('deploy');
 
-const { bold } = require('../../utils/term');
+const { bold, warn } = require('../../utils/term');
 
 const CF_COMMAND = 'cf';
 
@@ -25,6 +25,8 @@ const OPERATION_STATE_IN_PROGRESS = 'in progress';
 const OPERATION_STATE_FAILED = 'failed';
 const OPERATION_STATE_SUCCEEDED = 'succeeded';
 
+const CF_CLIENT_MINIMUM_VERSION = 8;
+
 
 class CfUtil {
 
@@ -135,10 +137,22 @@ class CfUtil {
     }
 
     async getCfTarget() {
+        await this.checkCliVersion();
         await this._cfRun('oauth-token'); // check if token is valid or expired / missing
         return await this.getCfTargetFromConfigFile() || await this.getCfTargetFromCli();
     }
 
+    async checkCliVersion() {
+        const result = await this._cfRun('-v');
+        const version = result?.stdout?.match(/version.*(\d+\.\d+\.\d+)/i)
+        if (parseInt(version?.[1]) < CF_CLIENT_MINIMUM_VERSION) {
+            console.log(warn(`
+[Warning] You are using Cloud Foundry client version ${version[1]}. We recommend version ${CF_CLIENT_MINIMUM_VERSION} or higher.
+Deployment will stop in the near future for Cloud Foundry client versions < ${CF_CLIENT_MINIMUM_VERSION}.
+`));
+        }
+    }
+
     async getCfSpaceInfo() {
         if (!this.spaceInfo) {
             LOG.debug('getting space info');

package/bin/mtx/in-cds.js

@@ -1,14 +1,6 @@
 const cds = require('../build/cds')
-const { _oldMtx } = cds.utils
 
-const _is_streamlined_mtx = ()=>{
-  if (_oldMtx()) return false
-  try { return !!require.resolve('@sap/cds-mtxs/srv/deployment-service') }
-  catch {/* ignored */}
-}
-
-if (!cds.requires.multitenancy || _is_streamlined_mtx()) module.exports = undefined
-else try {
+if (cds.requires.multitenancy && cds.utils._oldMtx()) try {
   // eslint-disable-next-line cds/no-missing-dependencies
   const mtx = module.exports = require ('@sap/cds-mtx')()
   mtx.inject (cds)
@@ -17,6 +9,7 @@ else try {
   if (e.code === 'MODULE_NOT_FOUND') throw new Error('Error serving MTX APIs: @sap/cds-mtx is not installed')
   else throw e
 }
+else module.exports = undefined
 
 /*
  cds.requires.multitenancy  --  use this to check whether mt is enabled (old or new)

package/bin/plugins.js

@@ -0,0 +1,31 @@
+const cds = require('../lib')
+const DEBUG = cds.debug('plugins')
+
+module.exports = async function load_plugins (log = console.log) {
+
+  if (DEBUG) console.time('[cds] - loaded plugins in')
+  const plugins = []
+  if (cds.env.plugins) {
+    for (let each of cds.env.plugins) {
+      let impl = typeof each === 'string' ? each : each.impl
+      if (impl.startsWith('.'))
+        impl = require.resolve(cds.root + '/' + impl)
+      plugins.push(_load_plugin(impl, each))
+    }
+  } else
+    try {
+      const { dependencies } = require(cds.root + '/package.json')
+      for (let each in dependencies) {
+        plugins.push(_load_plugin(each + '/cds-plugin'))
+      }
+    } catch { /* ignored */ }
+  try { await Promise.all(plugins); } catch { /* ignored */ }
+  if (DEBUG) console.timeEnd('[cds] - loaded plugins in')
+
+  async function _load_plugin (impl, conf) {
+    // TODO support ESM plugins.  But see cap/cds/pull/1838#issuecomment-1177200 !
+    const plugin = require(impl)
+    log('loaded plugin:', { impl })
+    if (plugin.activate) await plugin.activate(conf)
+  }
+}

package/bin/serve.js

@@ -154,12 +154,19 @@ async function serve (all=[], o={}) {
   if (o.watch)  return _watch.call(this, o.project,o)   // cds serve --watch <project>
   if (o.project) _chdir_to (o.project)      // cds run --project <project>
 
+  const TRACE = cds.debug('trace')
+  // if (TRACE) {
+  //   TRACE?.time('load express   '); require('express') // eslint-disable-line cds/no-missing-dependencies
+  //   TRACE?.timeEnd('load express   ')
+  // }
+  TRACE?.time('cds bootstrap  ')
+
   // Load local server.js early in order to allow setting custom cds.log.Loggers
   const cds_server = await _local_server_js() || cds.server
   if (!o.silent) _prepare_logging ()
 
   // The following things are meant for dev mode, which can be overruled by feature flagse...
-  const {features} = cds.env
+  const {features,fiori} = cds.env
   {
     // handle --with-mocks resp. --mocked
     if (features.with_mocks) o.mocked = _with_mocks(o)
@@ -174,23 +181,16 @@ async function serve (all=[], o={}) {
     if (features.live_reload) require('../app/etc/livereload')
 
     // add dev helper for Fiori URLs
-    if (features.fiori_routes) require('../app/fiori/routes')
+    if (fiori.routes) require('../app/fiori/routes')
 
     // add fiori preview links to default index.html
-    if (features.fiori_preview) require('../app/fiori/preview')
+    if (fiori.preview) require('../app/fiori/preview')
 
   }
 
   // activate plugins
-  if (cds.env.plugins) for (let each of cds.env.plugins) {
-    if (typeof each === 'string') each = {impl:each}
-    let impl = each.impl
-    if (impl.startsWith('.')) impl = require.resolve(cds.root+'/'+impl)
-    log ('loading plugin:', {impl})
-    // TODO support ESM plugins.  But see cap/cds/pull/1838#issuecomment-1177200 !
-    const plugin = require(impl)
-    if (plugin.activate) await plugin.activate(each)
-  }
+  await require("./plugins")(log)
+  TRACE?.timeEnd('cds bootstrap  ')
 
   // bootstrap server from project-local server.js or from @sap/cds/server.js
   const server = await cds_server(o)

package/lib/compile/etc/_localized.js

@@ -45,7 +45,7 @@ function unfold_csn (m) { // NOSONAR
 	const pass2 = []
 
 	const _conf = env.requires.db || env.requires.sql || env.requires.kinds && env.requires.kinds.sql
-	const _on_sqlite = _conf.kind === 'sqlite' || _conf.kind === 'better-sqlite' || _conf.dialect === 'sqlite'
+	const _on_sqlite = _conf.kind === 'sqlite' || _conf.dialect === 'sqlite'
 	const _locales = _on_sqlite && _locales_4sql.sqlite
 
 	// Pass 1 - add localized.<locale> entities and views

package/lib/compile/for/lean_drafts.js

@@ -19,7 +19,13 @@ function _isCompositionBacklink(e) {
   }
 }
 
-const IGNORED_ANNOTATIONS = [
+const IGNORED_ENTITY_ANNOTATIONS = new Set([
+  '@readonly',
+  '@insertonly',
+  '@restrict',
+])
+
+const IGNORED_ELEMENT_ANNOTATIONS = [
   '@assert.range',
   '@assert.enum',
   '@assert.format',
@@ -27,14 +33,21 @@ const IGNORED_ANNOTATIONS = [
   '@mandatory',
   '@Core.Immutable',
   '@readonly',
-  '@cds.on.update',
-  '@cds.on.insert',
   '@Core.Computed',
   '@Common.FieldControl.Readonly',
   '@Common.FieldControl.Mandatory',
   '@FieldControl.Mandatory',
   '@FieldControl.ReadOnly',
-  '@Common.FieldControl'
+  '@Common.FieldControl',
+  '@PersonalData.DataSubjectRole',
+  '@PersonalData.EntitySemantics',
+  '@PersonalData.IsPotentiallyPersonal',
+  '@PersonalData.IsPotentiallySensitive',
+  '@PersonalData.FieldSemantics'
+  // These are still needed:
+  // '@odata.etag',
+  // '@cds.on.update',
+  // '@cds.on.insert',
 ]
 
 module.exports = function cds_compile_for_lean_drafts(csn) {
@@ -96,7 +109,10 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
     Object.defineProperty(active, 'drafts', { value: draft })
     Object.defineProperty(draft, 'actives', { value: active })
     draft['@cds.persistence.table'] = _draftEntity
-    if (draft['@restrict']) draft['@restrict'] = undefined
+
+    for (const key in draft) {
+      if (IGNORED_ENTITY_ANNOTATIONS.has(key) || key.startsWith('@Capabilities') || key.startsWith('@PersonalData')) draft[key] = undefined
+    }
     // Recursively add drafts for compositions
     for (const each in draft.elements) {
       const e = draft.elements[each]
@@ -106,7 +122,7 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
         _redirect(newEl, draftEntity(e._target, model))
       }
       newEl.parent = draft
-      for (const ignoredAnno of IGNORED_ANNOTATIONS) {
+      for (const ignoredAnno of IGNORED_ELEMENT_ANNOTATIONS) {
         if (newEl[ignoredAnno]) newEl[ignoredAnno] = undefined
       }
       draft.elements[each] = newEl

package/lib/compile/for/nodejs.js

@@ -1,13 +1,16 @@
 const cds = require ('../../index')
+const TRACE = cds.debug('trace')
 
 module.exports = function cds_compile_for_nodejs (csn,o) {
   if ('_4nodejs' in csn) return csn._4nodejs
+  TRACE?.time('cds.compile 4n ')
   let dsn = csn // cds.minify (csn)
   dsn = cds.compile.for.drafts (csn,o) //> creates a partial copy -> avoid any cds.linked() before
   dsn = cds.compile._localized.unfold_csn (dsn)
   dsn = cds.linked (dsn)
-  if (cds.env.features.lean_draft) cds.compile.for.lean_drafts(dsn, o)
+  if (cds.env.fiori.lean_draft) cds.compile.for.lean_drafts(dsn, o)
   Object.defineProperty (csn, '_4nodejs', {value:dsn})
   Object.defineProperty (dsn, '_4nodejs', {value:dsn})
+  TRACE?.timeEnd('cds.compile 4n ')
   return dsn
 }

package/lib/compile/load.js

@@ -1,9 +1,9 @@
 const cds = require('..')
-
+const TRACE = cds.debug('trace')
 
 module.exports = exports = function cds_load (files, options) {
   const all = cds.resolve(files,options)
-  if (!all)  return Promise.reject (new cds.error ({
+  if (!all) return Promise.reject (new cds.error ({
     message: `Couldn't find a CDS model for '${files}' in ${cds.root}`,
     code: 'MODEL_NOT_FOUND', files,
   }))
@@ -13,6 +13,7 @@ module.exports = exports = function cds_load (files, options) {
 
 exports.parsed = function cds_get (files, options, _flavor) { // NOSONAR
 
+  TRACE?.time('cds.load model ')
   const o = typeof options === 'string' ? { flavor:options } : options || {}
   if (!files) files = ['*']; else if (!Array.isArray(files)) files = [files]
   if (o.files || o.flavor === 'files') return cds.resolve(files,o)
@@ -31,6 +32,7 @@ exports.parsed = function cds_get (files, options, _flavor) { // NOSONAR
 
 const _finalize = (csn,o) => {
   if (!o.silent) cds.emit ('loaded', csn)
+  TRACE?.timeEnd('cds.load model ')
   return csn
 }
 

package/lib/core/index.js

@@ -50,27 +50,21 @@ const roots = _roots ({
 /** Construct builtin.types as dictionary of all roots and common types */
 const types = _common ({ __proto__: roots,
 	UUID: {type:'string',length:36,isUUID:true},
+	String: {type:'string'}, LargeString: {type:'String'},
+	Binary: {type:'string'}, LargeBinary: {type:'Binary'},
 	Boolean: {type:'boolean'},
 	Integer: {type:'number'},
 		UInt8: {type:'Integer'},
-		Int16: {type:'Integer'},
-		Int32: {type:'Integer'},
-		Int64: {type:'Integer'},
-		Integer16: {type:'Int16'},
-		Integer32: {type:'Int32'},
-		Integer64: {type:'Int64'},
-	Decimal: {type:'number'},
-	DecimalFloat: {type:'number'},
+		Int16: {type:'Integer'}, Integer16: {type:'Int16'},
+		Int32: {type:'Integer'}, Integer32: {type:'Int32'},
+		Int64: {type:'Integer'}, Integer64: {type:'Int64'},
 	Float: {type:'number'},
-	Double: {type:'number'},
-	DateTime: {type:'date'},
+	Double: {type:'Float'},
+	Decimal: {type:'Float'}, DecimalFloat: {type:'Decimal'},
 	Date: {type:'date'},
 	Time: {type:'date'},
-	Timestamp: {type:'date'},
-	String: {type:'string'},
-	Binary: {type:'string'},
-	LargeString: {type:'string'},
-	LargeBinary: {type:'string'}
+	DateTime: {type:'date'},
+	Timestamp: {type:'DateTime'},
 })
 
 /**
@@ -90,5 +84,31 @@ function _common (defs) {
 	return prefixed
 }
 
+;(
+	/**
+	 * Adds convenience functions which can be used like that:
+	 * ```js
+	 * var { Date, Time, DateTime } = cds.builtin.types
+	 * DateTime.now()   //> 2023-02-10T14:41:36.218Z
+	 * Date.now()       //> 2023-02-10T14:41:36.218Z
+	 * Time.now()       //> 14:43:18
+	 * Date.today()     //> 2023-02-10
+	 * ```
+	 */
+	function _add_convenience_functions(){
+		Object.defineProperties (types.Date, {
+			today: { value: ()=> (new Date).toISOString().slice(0,10) },
+			now: { value: ()=> (new Date).toISOString() },
+		})
+
+		Object.defineProperties (types.Time, {
+			now: { value: ()=> (new Date).toISOString().slice(11,19) },
+		})
+
+		Object.defineProperties (types.DateTime, {
+			now: { value: ()=> (new Date).toISOString() },
+		})
+	}
+)()
 
 module.exports = { types, classes }

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 */