@sap/cds 5.8.2 → 5.9.0

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.basename(file) +'_')
-    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,