@sap/cds 5.8.3 → 5.9.1

package/lib/compile/resolve.js

@@ -2,6 +2,7 @@ const { resolve, join, sep } = require('path')
 const { readdirSync } = require('fs')
 const suffixes = [ '.csn', '.cds', sep+'index.csn', sep+'index.cds', sep+'csn.json' ]
 
+
 /**
 * Resolves given model references to an array of absolute filenames.
 * For the model references, all these are accepted:
@@ -16,18 +17,20 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
 
   if (!model || model === '--') return
   if (model._resolved) return model
-  if (model === '*') return exports.cache['*'] || _resolve_all(this,o)
-  if (Array.isArray(model)) return _resolved (
-    [... new Set(model)] .reduce ((prev,next) => prev.concat (this.resolve(next,o)||[]), [])
-  )
+  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 ? resolved : _resolved (resolved)
+  }
+  if (model.endsWith('/*')) return _resolve_subdirs_in(model,o,this)
 
-  const cwd = o.root || global.cds && global.cds.root, local = resolve (cwd,model)
+  const cwd = o.root || this.root, local = resolve (cwd,model)
   const context = _paths(cwd), {cached} = context
   let id = model.startsWith('.') ? local : model
-  if (id in cached && !o.skipModelCache)  return cached[id]
+  if (id in cached)  return cached[id]
 
   // expand @sap/cds by cds.home
-  if (id.startsWith('@sap/cds/')) id = global.cds.home + id.slice(8)
+  if (id.startsWith('@sap/cds/')) id = this.home + id.slice(8)
 
   // fetch file with .cds/.csn suffix as is
   if (/\.(csn|cds)$/.test(id)) try {
@@ -58,27 +61,41 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
 
 }
 
+
 exports.cache = {}
 
 
+const _required = cds => Object.values(cds.env.requires) .map (r => r.model) .filter(x=>x)
 const _resolve = require('module')._resolveFilename
 
-function _resolve_all (cds,o) {
-  const {roots,requires} = cds.env, {cache} = exports
-  const required = Object.values(requires) .map (r => r.model) .filter(x=>x)
-  if (o.dry || o === false)  return [ ...roots, ...required ]
-  cache['*'] = [] // important to avoid endless recursion on '*'
-  const resolved = cds.resolve (roots,o) || []
-  if (!(resolved.length === 1 && resolved[0].endsWith('csn.json')))
-  resolved.push (...cds.resolve (required,o)||[])
-  return cache['*'] = _resolved ([ ...new Set (resolved) ])
+function _resolve_all (o,cds) {
+  const {roots} = cds.env; if (o.dry || o === false)  return [ ...roots, ..._required(cds) ]
+  const cached = exports.cache['*']; if (cached) return cached
+  exports.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)||[])
+  return exports.cache['*'] = _resolved (sources)
+}
+
+function _resolve_subdirs_in (pattern='fts/*',o,cds) {
+  const cached = exports.cache[pattern]; if (cached && !o.dry && o !== false)  return cached
+  const folder = pattern.slice(0,-2), dir = resolve (cds.root, folder)
+  try {
+    const dirs = readdirSync(dir) .map (e => folder+'/'+e+'/') .filter (cds.utils.isdir)
+    if (o.dry || o === false)  return dirs
+    return exports.cache[pattern] = cds.resolve (dirs,o) || undefined
+  } catch(e) {
+    if (e.code === 'ENOENT')
+    return exports.cache[pattern] = undefined
+  }
 }
 
 function _paths (dir) {
-  const {cache} = exports; if (dir in cache)  return cache[dir]
+  const cached = exports.cache[dir]; if (cached)  return cached
   const a = dir.split(sep), n = a.length, nm = sep+'node_modules'
   const paths = [ dir, ...a.map ((_,i,a)=> a.slice(0,n-i).join(sep)+nm) ]
-  return cache[dir] = { paths, cached:{} }
+  return exports.cache[dir] = { paths, cached:{} }
 }
 
 function _resolved (array) {

package/lib/compile/to/json.js

@@ -8,12 +8,14 @@ module.exports = (csn,o={}) => JSON.stringify (csn, (_,v) => {
 
   else if (v.grant && v.where) try {
     // Add a parsed _where clause for @restrict.{grant,where} annotations
+    // Note: This has moved to cds.compile.for.java meanwhile, but is kept
+    // here for compatibility, at least temporarily.
     return {...v, _where: JSON.stringify (cds.parse.xpr(v.where)) }
   } catch(e){/* ignored */}
 
   else if (v.kind === "service" && !v['@source'] && v.$location && v.$location.file) {
     // Preserve original sources for services so we can use them for finding
-    // sibling implementation filed when reloaded from csn.json.
+    // sibling implementation files when reloaded from csn.json.
     const file = (o.cwd !== o.src) ? path.relative(o.src, path.join(o.cwd, v.$location.file)) : v.$location.file
     return { '@source': file.replace(/\\/g,'/'), ...v }
   }

package/lib/compile/to/sql.js

@@ -1,4 +1,4 @@
-const cds = require ('../..'), { unfold_ddl: cds_localized } = cds.compile._localized
+const cds = require ('../..')
 const cdsc = require ('../cdsc')
 
 
@@ -6,7 +6,7 @@ function cds_compile_to_sql (csn,_o) {
   csn = _extended(cds.minify(csn))
   const o = cdsc._options.for.sql(_o) //> used twice below...
   const all = cdsc.to.sql(csn,o) .map (each => each.replace(/^-- .+\n/,''))  //> strip comments
-  const sql = cds_localized(all, csn, o)
+  const sql = cds.compile._localized.unfold_ddl(all, csn, o)
   if (o.as === 'str') return `\n${sql.join('\n\n')}\n`
   return sql
 }

package/lib/compile/to/srvinfo.js

@@ -74,8 +74,10 @@ module.exports = (model, options={}) => {
       if (file) {
         const yaml = cds.load.yaml(file)
         for (let {cds} of Array.isArray(yaml) ? yaml : [yaml]) {
-          if (cds && cds['odata-v4.endpoint.path'])  return cds['odata-v4.endpoint.path']
-          if (cds && cds['odata-v2.endpoint.path'])  return cds['odata-v2.endpoint.path']
+          if (!cds)   continue
+          return cds['odataV4.endpoint.path']  || cds['odataV2.endpoint.path'] // https://cap.cloud.sap/docs/java/application-services#configure-base-path
+              || cds['odata-v4.endpoint.path'] || cds['odata-v2.endpoint.path'] // older/intermediate config, keep for backward compatibility
+
         }
         return 'odata/v4/'
       }

package/lib/connect/index.js

@@ -38,7 +38,7 @@ connect.to = async (datasource, options) => {
   // check if required service definition exists
   const required = cds.requires[datasource]
   if (required && required.model && datasource !== 'db' && !m.definitions[required.service||datasource]) {
-    LOG._error && LOG.error(`No service definition found for '${required.service || datasource}', as required by 'cds.requires.${datasource}':`, required)
+    LOG.error(`No service definition found for '${required.service || datasource}', as required by 'cds.requires.${datasource}':`, required)
     throw new Error (`No service definition found for '${required.service || datasource}'`)
   }
   // construct new service instance

package/lib/core/entities.js

@@ -34,23 +34,24 @@ class Association extends type {
     return !c || c.max === 1 || (!c.max && !c.targetMax) || c.targetMax === 1
   }
 
-  set _elements(k) { this.set('_elements', k) }
-  get _elements() {
-    const { keys } = this
-    if (!keys) return (this._elements = undefined)
-    const fks = {},{ elements } = this._target
-    for (let k of keys) fks[k.as || k.ref[0]] = elements[k.ref[0]]
-    return (this._elements = fks)
+  set foreignKeys(k) { this.set('foreignKeys', k) }
+  get foreignKeys() {
+    const keys = this.keys; if (!keys) return this.foreignKeys = undefined
+    const foreignKeys = {}
+    for (const k of keys) {
+      const el = k.ref.reduce((target,n)=> target.elements[n], this._target)
+      const as = k.as || k.ref[k.ref.length-1]
+      foreignKeys [as] = el
+    }
+    return this.foreignKeys = foreignKeys
   }
 
-  set _keys(k) { this.set('keys', k) }
-  get _keys() {
-    if (this.keys) return (this._keys = this.keys)
-    if (this.on || this.is2many || !this._target) return (this._keys = undefined)
-    const keys = [],
-      tks = this._target.keys
+  set keys(k) { super.keys = k }
+  get keys() {
+    if (this.on || this.is2many || !this._target) return this._keys = undefined
+    const keys=[], tks = this._target.keys
     for (let k in tks) keys.push({ ref: [tks[k].name] })
-    return (this._keys = keys)
+    return this.keys = keys
   }
 }
 

package/lib/core/index.js

@@ -8,8 +8,9 @@ const classes = Object.assign (
 	require('./entities'),
 )
 
-// Type system roots -> can be used with instanceof
-const roots = _bootstrap ({
+
+/** Type system roots -> can be used with instanceof */
+const roots = _roots ({
 	context: {},
 	type: {},
 		scalar: {type:'type'},
@@ -27,9 +28,28 @@ const roots = _bootstrap ({
 	service: {type:'context'},
 })
 
-// Adding common recommended types
-const common = { __proto__:roots,
-	UUID: {type:'string',length:36},
+/**
+ * Turns the given CSN definitions into linked definitions with classes.
+ * @type <T>(csn:T) => T
+ */
+ function _roots (defs) {
+	const linked = { any: classes.any.prototype }
+	for (const t in defs) {
+		if (t in classes) {
+			linked[t] = classes[t].prototype
+			continue
+		}
+		const c = class extends classes[defs[t].type || 'any'] {}
+		linked[t] = Object.defineProperty (c.prototype, 'name', {value:t})
+		classes[t] = Object.defineProperty (c, 'name', {value:t})
+	}
+	return linked
+}
+
+
+/** Construct builtin.types as dictionary of all roots and common types */
+const types = _common ({ __proto__: roots,
+	UUID: {type:'string',length:36,isUUID:true},
 	Boolean: {type:'boolean'},
 	Integer: {type:'number'},
 		Integer16: {type:'Integer'},
@@ -47,41 +67,24 @@ const common = { __proto__:roots,
 	Binary: {type:'string'},
 	LargeString: {type:'string'},
 	LargeBinary: {type:'string'},
-}
+})
 
 /**
- * Construct builtin.types as dictionary of all roots and common types
- * @type { typeof roots & typeof common }
+ * Link all definitions, essentially by: d.__proto__ = resolved (d.type),
+ * and prefixes all common types with a namespace 'cds'.
+ * @type <T>(csn:T) => T & roots
  */
-const types = { __proto__:common }
-
-// Link all definitions, essentially by: d.__proto__ = resolved (d.type)
-for (let [name,d] of Object.entries(common)) {
-	common[name] = Object.defineProperty({ ...d, __proto__: types[d.type] }, 'name', {value:name})
+function _common (defs) {
+	const prefixed = {__proto__:defs}
+	for (let [name,d] of Object.entries(defs)) {
+		defs[name] = Object.defineProperty({ ...d, __proto__: defs[d.type] }, 'name', {value:name})
+		Object.defineProperty (prefixed['cds.'+name] = defs[name], '_type', {value:'cds.'+name})
+	}
+	for (let name of ['Association','Composition']) {
+		Object.defineProperty (prefixed['cds.'+name] = defs[name], '_type', {value:'cds.'+name})
+	}
+	return prefixed
 }
 
-// Prefix all common types with a namespace 'cds'
-for (let t of Object.keys(common))  types['cds.'+t] = types[t]
-types['cds.Association'] = types.Association
-types['cds.Composition'] = types.Composition
 
 module.exports = { types, classes }
-
-
-/**
- * Turns the given CSN definitions into linked definitions.
- * @type <T>(csn:T) => T
- */
-function _bootstrap (csn) {
-	const defs = { any: classes.any.prototype }
-	for (const t in csn) {
-		if (t in classes) {
-			defs[t] = classes[t].prototype
-			continue
-		}
-		const c = class extends classes[csn[t].type || 'any'] {}
-		defs[t] = Object.defineProperty(c.prototype, 'name', { value: t })
-		classes[t] = Object.defineProperty(c, 'name', { value: t })
-	}
-	return defs
-}

package/lib/core/reflect.js

@@ -95,7 +95,7 @@ class LinkedCSN extends any {
 }
 
 
-const _unresolved = (x,unknown=any) => ({name:x, __proto__:unknown.prototype, _unresolved:true})
+const _unresolved = (x,unknown=any) => ({ name:x, __proto__:unknown.prototype, _unresolved:true })
 const _builtin = x => types[x] || typeof x === 'string' && x.startsWith('cds.hana.') && any.prototype
 const _infer = require('./infer'), _not_inferred = _unresolved('<query>',entity)
 const _set = (o,p,v) => Object.defineProperty (o,p,{value:v,enumerable:false,configurable:1,writable:1})
@@ -107,4 +107,6 @@ const _is = x => {
 }
 
 /** @returns {LinkedCSN} */
-module.exports = x => x instanceof any ? x : new LinkedCSN(x)
+module.exports = x => x instanceof any ? x : new LinkedCSN (
+  typeof x === 'string' ? global.cds.parse(x) : x
+)

package/lib/deploy.js

@@ -1,6 +1,6 @@
-const cds = require('./index'), { local } = cds.utils
+const cds = require('./index'), { local, inspect } = cds.utils
 const DEBUG = cds.debug('deploy')
-let LOG
+/* eslint-disable no-console */
 
 /**
  * Implementation of `cds.deploy` common to all databases.
@@ -11,8 +11,8 @@ let LOG
 exports = module.exports = function cds_deploy (model,options) { return {
 
   /** @param {cds.Service} db */
-  async to (db, o=options||{}) { // NOSONAR
-    LOG = cds.log('deploy')
+  async to (db, o = options || cds.options || {}) {
+    const LOG = o.silent || !cds.log('deploy')._info ? ()=>{} : console.log
 
     if (model && !model.definitions) {
       model = await cds.load (model) .then (cds.minify)
@@ -31,25 +31,22 @@ exports = module.exports = function cds_deploy (model,options) { return {
     if (!cds.db) cds.db = cds.services.db = db
     if (!db.model) db.model = model
 
-    if (o.ddl !== false) {
-      const any = await db.deploy (model,o) //> CREATE TABLE, ...
-      if (!any)  return
-    }
+    // create tables & views...
+    const any = await exports.create (db,model,o)
+    if (!any) return db
 
     // fill in initial data...
-    const SILENT = o.silent || !LOG._info
-    await init_from_code (db,model,SILENT)
-    await init_from_csv (db,model,SILENT)
-    await init_from_json (db,model,SILENT)
-
-    const {credentials} = db.options, file = credentials && (credentials.database || credentials.url)
-    if (!SILENT) {
-      if (file !== ':memory:')  console.log (`/> successfully deployed to ./${file}\n`)
-      else console.log (`/> successfully deployed to sqlite in-memory db\n`)
-    }
-
+    await exports.init (db,model, file => LOG(
+      `\x1b[2m > init from ${local(file)} \x1b[0m`
+    ))
+
+    // done
+    const {credentials:c} = db.options, file = c && (c.database || c.url)
+    if (file !== ':memory:') LOG (`/> successfully deployed to ./${file}\n`)
+    else LOG (`/> successfully deployed to sqlite in-memory db\n`)
     return db
   },
+
   // continue to support cds.deploy() as well...
   then(n,e) { return this.to (cds.db||'db') .then (n,e) },
   catch(e) { return this.to (cds.db||'db') .catch (e) },
@@ -57,9 +54,10 @@ exports = module.exports = function cds_deploy (model,options) { return {
 
 
 
-
-const { fs, path, isdir, isfile, read } = cds.utils
+const { fs, path, read } = cds.utils
 const { readdir } = fs.promises
+const isdir = (..._) => fs.isdir(path.join(..._))
+const isfile = (..._) => fs.isfile(path.join(..._))
 
 exports.include_external_entities_in = function (model) {
   if (model._mocked) return model; else Object.defineProperty(model,'_mocked',{value:true})
@@ -101,125 +99,114 @@ exports.exclude_external_entities_in = function (csn) { // NOSONAR
 }
 
 
-function init_from_code (db, csn, SILENT) {
-
-  if (!csn.$sources)  return
-  const folders = new Set([ path.resolve(cds.root,'db'), ...csn.$sources.map (path.dirname)])
-  const inits = []
-
-  for (let each of folders) {
-    let file;
-    if (process.env.CDS_TYPESCRIPT === 'true') file = isfile (path.resolve(each,'init.ts'));
-    if (!file) file = isfile (path.resolve(each,'init.js'));
-    if (!file)  continue
-    SILENT || console.log (` > initializing database from ${local(file)}`)  // eslint-disable-line
-    let init = require(file);  if (!init)  continue
-    if (!init.then && typeof init === 'function')  inits.push (init(db))
-    else  inits.push (init)
-  }
-
-  return Promise.all (inits)
+exports.create = async function (db, csn=db.model, o) {
+  if (!db.deploy || o.lean) {
+    const creates = cds.compile.to.sql (csn,o); if (!creates || creates.length === 0) return
+    const drops = creates.map (each => {
+      let [, kind, entity] = each.match(/^CREATE (TABLE|VIEW) "?([^\s"(]+)/im) || []
+      return `DROP ${kind} IF EXISTS ${entity};`
+    }).reverse()
+    if (o.dry) {
+      console.log(); for (let each of drops) console.log(each)
+      console.log(); for (let each of creates) console.log(each,'\n')
+      return
+    } else await db.tx (async tx => {
+      await tx.run(drops)
+      await tx.run(creates)
+      return true
+    })
+  } else return db.deploy (csn,o)
 }
 
-function init_from_csv (db, csn, SILENT) {
-  return init_from_ (['data','csv'], _csvs, db, csn, SILENT, (entity, src) => {
-    let [ cols, ...rows ] = cds.parse.csv (src)
-    return rows && rows[0] && INSERT.into (entity) .columns (cols) .rows (rows)
-  });
 
-  function _csvs (filename,_,allFiles) {
-    if (filename[0] === '-' || !filename.endsWith ('.csv'))  return false
-    if (prefer_translated_texts(filename, allFiles)) return false
-    return true
+exports.init = (db, csn=db.model, log=()=>{}) => db.tx (async tx => {
+  cds.context = tx //> registers tx as root transaction
+  const resources = await exports.resources(csn), inits=[], err = new Error
+  for (let [file,e] of Object.entries(resources)) {
+    if (e === '*') { // init.js/ts
+      const x = require(file); if (!x) continue
+      log (file)
+      inits.push (!x.then && typeof x === 'function' ? x(db) : x)
+    } 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); if (!q) continue
+      log (file,e)
+      inits.push (tx.run(q) .catch (e => { throw Object.assign (e,{
+        message: 'in cds.deploy(): ' + e.message +'\n'+ inspect(q),
+      })}))
+    }
   }
-}
-
-function init_from_json (db, csn, SILENT) {
-  return init_from_ (['data'], _jsons, db, csn, SILENT, (entity, src) => {
-    let json = JSON.parse (src)
-    return json[0] && INSERT.into (entity) .entries (json)
-  });
-
-  function _jsons (filename,_,allFiles) {
-    if (filename[0] === '-' || !filename.endsWith ('.json'))  return false
-    if (prefer_translated_texts(filename, allFiles)) return false
-    return true
+  await Promise.all (inits)
+})
+
+
+exports.resources = async function (csn) {
+  if (!csn || !csn.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
+  const folders = await exports.resources.folders(csn)
+  const found={}, ts = process.env.CDS_TYPESCRIPT
+  for (let folder of folders) {
+    // fetching init.js files
+    const init_js = ts && isfile(folder,'init.ts') || isfile(folder,'init.js')
+    if (init_js) found[init_js] = '*'
+    // fetching .csv and .json files
+    for (let each of ['data','csv']) {
+      const subdir = isdir(folder,each); if (!subdir) continue
+      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 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 && DEBUG (`ignoring '${fx}' in favor of translated ones`); continue
+          }
+          const e = _entity4(f,csn); if (_skip(e)) continue
+          found[path.join(subdir,fx)] = e.name
+        }
+      }
+    }
   }
+  return found
 }
 
-/**
- * ignores 'Books_texts.csv/json' if there is any 'Books_texts_LANG.csv/json'
- */
-function prefer_translated_texts (file, all) {
-  if (/[._]texts\.(json|csv)$/.test (file)) {
-    const pattern = new RegExp('^'+ path.parse(file).name +'_')
-    const translated = all.filter (f => pattern.test(f))
-    if (translated.length > 0) {
-      DEBUG && DEBUG (`ignoring '${file}' in favor of [${translated}]`)  // eslint-disable-line
-      return true
-    }
-  }
+
+exports.resources.folders = async function (csn) {
+  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 (cds.env.features.test_data) folders.add (path.resolve(cds.root,'test/'))
+  return folders
 }
 
-async function init_from_ (locations, filter, db, csn, SILENT, INSERT_into) { // NOSONAR
 
-  const folders = new Set
-  let roots = Object.values(cds.env.folders); if (cds.env.features.test_data) roots.push('test/')
-  for (let root of roots) {
-    for (let data of locations) {
-      let each = path.resolve(root,data)
-      if (isdir (each))  folders.add(each)
+const _entity4 = (file,csn) => {
+  const name = file.replace(/-/g,'.')
+  const entity = csn.definitions [name]
+  if (!entity) {
+    if (/(.+)[._]texts_?/.test(name)) { // 'Books.texts', 'Books.texts_de'
+      const base = csn.definitions [RegExp.$1]
+      return base && _entity4 (base.elements.texts.target,csn)
     }
+    else return DEBUG && DEBUG (`warning: ${name} not in model`)
   }
-  if (csn.$sources) for (let model of csn.$sources) {
-    for (let data of locations) {
-      let each = path.resolve(model,'..',data)
-      if (isdir (each))  folders.add(each)
-    }
+  // We also support insert into simple views if they have no projection
+  const p = entity.query && entity.query.SELECT || entity.projection
+  if (p && !p.columns && p.from.ref && p.from.ref.length === 1) {
+    if (csn.definitions [p.from.ref[0]])  return entity
   }
+  return entity.name ? entity : { name, __proto__:entity }
+}
 
-  if (folders.size === 0) return
-
-  const {local} = cds.utils, inits = [], err = new Error
-  await db.tx (async tx => {
-    for (let folder of folders) {
-      const files = await readdir (folder)
-      for (let each of files.filter (filter)) {
-        let name = each.replace(/-/g,'.').slice(0, -path.extname(each).length)
-        let entity = _entity4 (name)
-        if (!entity) { DEBUG && DEBUG (`warning: ${name} not in model`); continue }
-        if (entity['@cds.persistence.skip'] === true) continue
-        const file = path.join(folder,each)
-        const src = await read (file,'utf8'); if (!src) continue
-        const q = INSERT_into (entity,src)
-        if (!q)  { DEBUG && DEBUG (`skipping empty ${local(file)}`); continue }
-        SILENT || console.log (`\x1b[2m > filling ${entity.name} from ${local(file)} \x1b[0m`) // eslint-disable-line
-        inits.push (tx.run(q).catch(e=>{ const ex = new Error
-          e.stack = e.message +'\n'+ require('util').inspect(q) + err.stack.slice(5)
-            .replace (/deploy\.js:\d+:/, ex.stack.slice(5).match(/deploy\.js:\d+:/)[0])
-          throw e
-        }))
-      }
-    }
-    await Promise.all(inits)
-  })
-
-  function _entity4 (name) {
-    let entity = csn.definitions [name]
-    if (!entity) {
-      if (/(.+)[._]texts_?/.test (name)) { // 'Books.texts', 'Books.texts_de'
-        const base = csn.definitions [RegExp.$1]
-        return base && _entity4 (base.elements.texts.target)
-      }
-      else return
-    }
-    // We also support insert into simple views if they have no projection
-    const p = entity.query && entity.query.SELECT || entity.projection
-    if (p && !p.columns && p.from.ref && p.from.ref.length === 1) {
-      if (csn.definitions [p.from.ref[0]])  return entity
-    }
-    return entity.name ? entity : { name, __proto__:entity }
-  }
+const INSERT_from_csv = (entity, csv) => {
+  let [ cols, ...rows ] = cds.parse.csv (csv)
+  if (rows.length > 0) return INSERT.into (entity) .columns (cols) .rows (rows)
+}
 
+const INSERT_from_json = (entity, json) => {
+  let records = JSON.parse (json)
+  if (records.length > 0) return INSERT.into (entity) .entries (records)
 }
-/* eslint no-console: off */
+
+const _from_csv_or_json = { '.json': INSERT_from_json, '.csv': INSERT_from_csv, }
+const _skip = e => !e || e['@cds.persistence.skip'] === true

package/lib/env/defaults.js

@@ -6,6 +6,7 @@ module.exports = {
   requires: require('./requires'),
 
   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,