@sap/cds 6.8.4 → 7.0.0

package/lib/compile/load.js

@@ -1,7 +1,7 @@
 const cds = require('..')
 const TRACE = cds.debug('trace')
 
-module.exports = exports = function cds_load (files, options) {
+module.exports = exports = function load (files, options) {
   const all = cds.resolve(files,options)
   if (!all) return Promise.reject (new cds.error ({
     message: `Couldn't find a CDS model for '${files}' in ${cds.root}`,

package/lib/compile/minify.js

@@ -1,4 +1,5 @@
 const cds = require('../index')
+const DEBUG = cds.debug('minify')
 
 module.exports = function cds_minify (csn, _roots) { // IMPORTANT: don't add cds.env.features.skip_unused as default for _roots here, as that will break VSCode's IntelliSense
   const roots = _roots !== undefined ? _roots : cds.env.features.skip_unused
@@ -58,6 +59,7 @@ module.exports = function cds_minify (csn, _roots) { // IMPORTANT: don't add cds
   const minified = Object.create (csn.__proto__, Object.getOwnPropertyDescriptors(csn))
   const less = minified.definitions = {}
   for (let n in all) if (reached.has(all[n])) less[n] = all[n]
+  else DEBUG?.('skipping', all[n].kind, n)
   Object.defineProperty (minified,_minified,{value:true})
   return minified
 }

package/lib/compile/to/csn.js

@@ -0,0 +1,74 @@
+const cds = require ('../../index')
+
+/**
+ * This is the central function to compile sources to CSN.
+ * @param {string|string[]|{}} model one of:
+ * - a single filename starting with 'file:'
+ * - a single CDL source string
+ * - an object with multiple CDL or CSN sources
+ * - an array of one or more filenames
+ * @param { _flavor | {flavor:_flavor, ...}} options
+ * - an options object or a string specifying the flavor of CSN to generate
+ * @param { 'inferred'|'xtended'|'parsed' } _flavor - for internal use only(!)
+ * @returns {{ namespace?:string, definitions:{}, extensions?:[], meta:{ flavor:_flavor }}} CSN
+ */
+function cds_compile_to_csn (model, options, _flavor) {
+
+  if (!model) throw cds.error (`Argument 'model' must be specified`)
+  if (_is_csn(model) && _assert_flavor(model,_flavor,options)) return model   //> already parsed csn
+
+  const o = _options4 (options,_flavor)
+  const cwd = o.cwd || cds.root
+  const files = _is_files (model,cwd)
+  const cdsc = require ('../cdsc')
+  if (files && o.sync) return _finalize (cdsc.compileSync(files,cwd,o))  //> compile files synchroneously
+  if (files) return cdsc.compile(files,cwd,o) .then (_finalize)         //> compile files asynchroneously
+  else return _finalize (cdsc.compileSources(model,o))                 //> compile CDL sources
+
+  function _finalize (csn) {
+    if (o.min) csn = cds.minify(csn)
+    // REVISIT: experimental implementation to detect external APIs
+    for (let each in csn.definitions) {
+      const d = csn.definitions[each]
+      if (d.kind === 'service' && cds.requires[each]?.external && (!o.mocked || cds.requires[each].credentials)) {
+        Object.defineProperty (d,'@cds.external', { value: cds.requires[each].kind || true })
+      }
+    }
+    if (!csn.meta) csn.meta = {}
+    csn.meta.flavor = o.flavor
+    return csn
+  }
+}
+
+
+const _is_csn = (x) => (x.definitions || x.extensions) && !x.$builtins
+const _is_files = (m,root) => {
+  if (m === '*' || Array.isArray(m) || /^file:/.test(m) && (m = m.slice(5)))
+    return cds.resolve(m,{root}) || cds.error ( `Couldn't find a CDS model for '${m}' in ${root||cds.root}`,{ code:'MODEL_NOT_FOUND', model: m })
+}
+
+const _assert_flavor = (m,_flavor,options) => {
+  if (!m.meta) return true; const f = _flavor || _flavor4 (options)
+  return !f || f === m.meta.flavor || cds.error (`cds.compile(...,{flavor:'${f}'}) called on csn with different meta.flavor='${m.meta.flavor}'`)
+}
+const _flavors = {
+  'parsed':   { level:1, cdsc_options: { parseCdl:true } },
+  'xtended':  { level:2, cdsc_options: { csnFlavor:'gensrc' } },
+  'inferred': { level:3 },
+}
+const _flavor4 = (o) => {
+  const f = typeof o === 'string' ? o : o && o.flavor
+  return !f || f in _flavors ? f : cds.error (`Option 'flavor' must be one of ${Object.keys(_flavors)}; got: '${f}'`)
+}
+
+const _options4 = (_o, _flavor) => {
+  const flavor = _flavor ? _flavor4(_flavor) : _flavor4(_o) || 'inferred'
+  const spec = _flavors[flavor]
+  const o = { ..._o, flavor, ...spec.cdsc_options, ...cds.env.cdsc, cdsHome: cds.home } // cdsHome is for the compiler resolving @sap/cds/... files
+  if (o.docs) o.docComment = true
+  if (o.locations) o.withLocations = true
+  if (!o.messages) o.messages = []
+  return o
+}
+
+module.exports = cds_compile_to_csn

package/{bin/build/provider/hana/2tabledata.js → lib/compile/to/hdbtabledata.js}

@@ -1,10 +1,8 @@
-const cds = require('../../cds')
-const CSV = require('../../csv-reader')
+const cds = require('../../../lib')
 const { getElementCdsPersistenceName, getArtifactCdsPersistenceName } = require('@sap/cds-compiler')
-const { LOG_MODULE_NAMES } = require('../../constants')
-const { fs, path, isdir } = cds.utils
+const { fs, path, isdir, csv } = cds.utils
 const { readdir } = fs.promises
-let logger = cds.log(LOG_MODULE_NAMES)
+let logger = cds.log('cds')
 
 module.exports = async (model, options = {}) => {
   if (options.logger) {
@@ -52,7 +50,7 @@ async function _tabledata4(dir, csvFile, model, baseDir, naming) {
 
   const file = path.join(dir, csvFile)
   const reader = fs.createReadStream(file)
-  const { cols, delimiter } = await CSV.readHeader(reader)
+  const { cols, delimiter } = await csv.readHeader(reader)
   if (cols.length === 0) return  // no columns at all -> skip import
 
   cols.forEach(csvCol => {

package/lib/compile/to/json.js

@@ -34,7 +34,7 @@ module.exports = (csn,o={}) => {
     return v
 
   }
-  return JSON.stringify (csn, resolver, o && o.indents || 2)
+  return JSON.stringify (csn, resolver, o?.indents ?? 2)
 }
 
 // go upwards, find a package.json and try resolving with this module name

package/lib/compile/to/sql.js

@@ -1,12 +1,13 @@
 const cds = require ('../..')
 const cdsc = require ('../cdsc')
 const keywords = require("@sap/cds-compiler").to.sql.sqlite.keywords
+const { unfold_ddl } = require ('../etc/_localized')
 
 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.compile._localized.unfold_ddl(all, csn, o)
+  const sql = unfold_ddl(all, csn, o)
   if (o.as === 'str') return `\n${sql.join('\n\n')}\n`
   return sql
 }
@@ -18,12 +19,13 @@ function cds_compile_to_hdbtable (csn,o) {
 }
 
 function cds_compile_to_deltaSql (csn, o, beforeCsn) {
-  const options = cdsc._options.for.sql(o);
+  const options = cdsc._options.for.sql(o)
+  if (typeof beforeCsn === 'string') beforeCsn = JSON.parse(beforeCsn)
   const { afterImage, drops, createsAndAlters } = cdsc.to.deltaSql (csn, options, beforeCsn || {definitions: {}, $version: '2.0'} ); // FIXME: As default value in compiler API?
-  return { 
-    afterImage, 
-    drops: cds.compile._localized.unfold_ddl(drops.map (each => each.replace(/^-- .+\n/,'')), csn, options), 
-    createsAndAlters: cds.compile._localized.unfold_ddl(createsAndAlters.map (each => each.replace(/^-- .+\n/,'')), csn, options) 
+  return {
+    afterImage,
+    drops: unfold_ddl(drops.map (each => each.replace(/^-- .+\n/,'')), csn, options),
+    createsAndAlters: unfold_ddl(createsAndAlters.map (each => each.replace(/^-- .+\n/,'')), csn, options)
   };
 }
 

package/lib/dbs/cds-deploy.js

@@ -1,21 +1,9 @@
+#!/usr/bin/env node
 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 TRACE = cds.debug('trace')
-const nativeSchevoSqls = {
-  'postgres': {
-    create: `CREATE table cds_model (csn text)`,
-    insert: `INSERT into cds_model values ('null')`,
-    drop: `DROP table if exists cds_model;`
-  },
-  'sqlite': {
-    create: `CREATE table cds_Model (csn CLOB)`,
-    insert: `INSERT into cds_Model values ('null')`,
-    drop: `DROP table if exists cds_Model;`
-  }
-}
+let DEBUG // IMPORTANT: initialized later after await cds.plugins
 
 /**
  * Implementation of `cds.deploy` common to all databases.
@@ -23,43 +11,148 @@ const nativeSchevoSqls = {
  * deploy create tables and views in case of a SQL database, then fills
  * in initial data, if present.
  */
-exports = module.exports = function cds_deploy (model,options,csvs) { return {
+module.exports = exports = function cds_deploy (model,options,csvs) {
+  DEBUG = cds.debug('deploy')
+  return {
+    /** @param {import('@sap/cds/lib/srv/srv-api')} db */
+    async to(db, o = options || cds.options || {}) {
+
+      const TRACE = cds.debug('trace')
+      TRACE?.time('cds.deploy db  ')
+
+      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)
+
+      if (!db.run) db = await cds.connect.to(db)
+      if (!cds.db) cds.db = cds.services.db = db
+      if (!db.model) db.model = model
+
+      // eslint-disable-next-line no-console
+      const LOG = o.silent || o.dry || !cds.log('deploy')._info ? () => {} : console.log
+      const _deploy = async tx => {
+        // create / update schema
+        let any = await exports.create(tx, model, o)
+        if (!any && !csvs) return db
+        // fill in initial data
+        await exports.init(tx, model, o, csvs, file => LOG(GREY, ` > init from ${local(file)}`, RESET))
+      }
 
-  /** @param {cds.Service} db */
-  async to (db, o = options || cds.options || {}) {
-    TRACE?.time ('cds.deploy db  ')
+      let url = db.url4(cds.context?.tenant)
+      if (url === ':memory:') url = 'in-memory database.'
+      else if (!url.startsWith('http:')) url = local(url)
+      try {
+        await (o.dry ? _deploy(db) : db.run(_deploy))
+        LOG('/> successfully deployed to', url, '\n')
+      } catch (e) {
+        LOG('/> deployment to', url, 'failed\n')
+        throw e
+      }
 
-    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)
+      TRACE?.timeEnd('cds.deploy db  ')
+      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)
+    },
+  }
+}
 
-    if (o.mocked) exports.include_external_entities_in (model)
-    else exports.exclude_external_entities_in (model)
+exports.create = async function cds_deploy_create (db, csn=db.model, o) {
 
-    if (!db.run) db = await cds.connect.to(db)
-    if (!cds.db) cds.db = cds.services.db = db
-    if (!db.model) db.model = model
+  /* eslint-disable no-console */
 
-    // 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
+  if (!o.to || o.to === db.options.kind)  o = { ...db.options, ...o }
+  if (o.impl === '@cap-js/sqlite') {
+    // REVISIT: Move that to configuration or to cds.compile -> currently cds compile creates wrong output
+    o.betterSqliteSessionVariables = true
+    o.sqlDialect = 'sqlite'
+  }
 
-    // fill in initial data...
-    await exports.init (db,model,o,csvs, file => LOG (GREY,` > init from ${local(file)}`, RESET))
+  let drops, creas
+  let schevo = o.schema_evolution === 'auto' || o['with-auto-schema-evolution'] || o['model-only'] || o['delta-from'] || (o.kind === 'postgres' && o.schema_evolution !== false);
+  if (schevo) {
+    const { prior, table_exists } = await get_prior_model()
+    const { afterImage, drops: d, createsAndAlters } = cds.compile.to.sql.delta(csn, o, prior && JSON.parse(prior))
+    const after = JSON.stringify(afterImage)
+    if (!o.dry && after != prior) {
+      if (!table_exists) {
+        const CLOB = o.dialect === 'postgres' || o.kind === 'postgres' ? 'text' : 'CLOB'
+        await db.run(`CREATE table cds_model (csn ${CLOB})`)
+        await db.run(`INSERT into cds_model values (?)`, after)
+      } else {
+        await db.run(`UPDATE cds_model SET csn = ?`, after)
+      }
+      db.options.schema_evolution = 'auto' // for updating package.json
+    }
+    // cds deploy --model-only > fills in table cds_model above
+    if (o['model-only']) return o.dry && console.log(after)
+    // cds deploy -- with auto schema evolution > upgrade by applying delta to former model
+    creas = createsAndAlters
+    drops = d
+  } else {
+    // cds deploy -- w/o auto schema evoution > drop-create db
+    creas = cds.compile.to.sql(csn, o)
+  }
 
-    // done
-    let url = db.url4 (cds.context?.tenant); if (url === ':memory:') url = 'in-memory database.'
-    LOG ('/> successfully deployed to', url, '\n')
+  if (!drops)
+    drops = creas
+      .map(each => {
+        let [, kind, entity] = each.match(/^CREATE (TABLE|VIEW) ("[^"]+"|[^\s(]+)/im) || []
+        return `DROP ${kind} IF EXISTS ${entity};`
+      })
+      .reverse()
 
-    TRACE?.timeEnd ('cds.deploy db  ')
-    return db
-  },
+  if (!drops.length && !creas.length) return !o.dry
 
-  // 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) },
-}}
+  if (o.dry) {
+    console.log()
+    for (let each of drops) console.log(each)
+    console.log()
+    for (let each of creas) console.log(each, '\n')
+    return
+  }
 
+  // Set the context model while deploying for cqn42sql in new db layers
+  db.model = cds.compile.for.nodejs(csn)
+  await db.run(drops)
+  await db.run(creas)
+  return true
+
+  async function get_prior_model() {
+    let file = o['delta-from']
+    if (file) {
+      let prior = await cds.utils.read(file)
+      return { prior }
+    }
+    if (o.dry) return {}
+
+    let [table_exists] = await db.run(
+      // REVISIT: prettier forced this horrible, unreadable formatting:
+      db.kind === 'postgres'
+        ? `SELECT 1 from pg_tables WHERE tablename = 'cds_model' and schemaname = current_schema()`
+        : db.kind === 'sqlite'
+        ? `SELECT 1 from sqlite_schema WHERE name = 'cds_model'`
+        : cds.error`Schema evolution is not supported for ${db.kind} databases`,
+    )
+
+    if (o['model-only'])
+      return { table_exists };
+
+    if (table_exists) {
+      let [{ csn }] = await db.run('SELECT csn from cds_model')
+      return { prior: csn, table_exists }
+    }
+    return { table_exists } // no prior csn
+  }
+}
 
 
 const { fs, path, read } = cds.utils
@@ -73,7 +166,7 @@ exports.include_external_entities_in = function (model) {
     const def = model.definitions[each]
     if (def['@cds.persistence.mock'] === false) continue
     if (def['@cds.persistence.skip'] === true) {
-      DEBUG && DEBUG ('including mocked', each)
+      DEBUG?.('including mocked', each)
       delete def['@cds.persistence.skip']
     }
   }
@@ -86,7 +179,7 @@ exports.exclude_external_entities_in = function (csn) { // NOSONAR
   for (let [each,{service=each,model,credentials}] of Object.entries (cds.env.requires)) {
     if (!model) continue //> not for internal services like cds.requires.odata
     if (!credentials && csn._mocked) continue //> not for mocked unbound services
-    DEBUG && DEBUG ('excluding external entities for', service, '...')
+    DEBUG?.('excluding external entities for', service, '...')
     const prefix = service+'.'
     for (let each in csn.definitions) if (each.startsWith(prefix)) _exclude (each)
   }
@@ -95,7 +188,7 @@ exports.exclude_external_entities_in = function (csn) { // NOSONAR
   function _exclude (each) {
     const def = csn.definitions[each]; if (def.kind !== 'entity') return
     if (def['@cds.persistence.table'] === true) return // do not exclude replica table
-    DEBUG && DEBUG ('excluding external entity', each)
+    DEBUG?.('excluding external entity', each)
     def['@cds.persistence.skip'] = true
     // propagate to all views on top...
     for (let other in csn.definitions) {
@@ -107,66 +200,6 @@ exports.exclude_external_entities_in = function (csn) { // NOSONAR
 }
 
 
-exports.create = async function cds_deploy_create (db, csn=db.model, o) {
-  // REVISIT: How to find out if we use better-sqlite?
-  if (db._source === '@cap-js/sqlite') {
-    // it's required to set both properties
-    o.betterSqliteSessionVariables = true
-    o.sqlDialect = 'sqlite'
-  }
-
-  const sqls = nativeSchevoSqls[db.options?.dialect || db.options?.kind || 'sqlite'];
-  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;
-    try {
-      const [{csn}] = await db.read('cds.Model');
-      before = JSON.parse(csn);
-    } catch(e) {
-      if (!e.message.includes('no such table') && !e.message.includes('relation "cds_model" does not exist')) throw e
-      // TODO: Put both into one tx - read can not be part of it, as the transaction gets killed in PG once an error appears
-      await db.run(sqls.create)
-      await db.run(sqls.insert)
-      before = null;
-    }
-    const { afterImage, drops:_drops, createsAndAlters:_creas } = cds.compile.to.sql.delta (csn, {...o, ...db.options}, 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, ...db.options})
-    drops = _drops4(creas) .concat (sqls.drop)
-  }
-  if (!creas || creas.length === 0) return
-
-  function _drops4 (creas) {
-    return creas.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 creas) console.log(each,'\n')
-  }
-  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 && db.kind == 'sqlite' && 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)
-    return true
-  })
-}
-
-
 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 => {
@@ -184,7 +217,7 @@ exports.init = async function cds_deploy_init (db, csn=db.model, o, srces, log=(
           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)
+        if (typeof src === 'function') await src(tx,csn)
       }
     }
   })
@@ -199,16 +232,19 @@ exports.data = async function cds_deploy_prepare_data (csn, srces) {
     return [ file, e, src ]
   })
   // If not, we load them from cds.deploy.resources(csn)
+  const data = []
   const resources = await exports.resources(csn, { testdata: cds.env.features.test_data })
-  return Object.entries(resources) .map (async ([file,e]) => {
+  const resEntries = Object.entries(resources).reverse() // reversed $sources, relevant as UPSERT order
+  for (const [file,e] of resEntries) {
     if (e === '*') {
       let init_js = await cds.utils._import (file)
-      return [ file, null, init_js.default || init_js ]
+      data.push([ file, null, init_js.default || init_js ])
     } else {
       let src = await read (file, 'utf8')
-      return [ file, e, src ]
+      data.push([ file, e, src ])
     }
-  })
+  }
+  return data
 }
 
 
@@ -230,14 +266,14 @@ exports.resources = async function cds_deploy_resources (csn, opts) {
           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`)
+            DEBUG?.(`ignoring '${fx}' in favor of translated ones`)
             continue
           }
           const e = _entity4(f,csn); if (_skip(e)) continue
           if (cds.env.features.deploy_data_onconflict === 'replace' && !/[._]texts_/.test(f)) {
             const seenBefore = Object.entries(found).find(([_, entity]) => entity === e.name )
             if (seenBefore) {
-              DEBUG && DEBUG(`Conflict for '${e.name}': replacing '${local(seenBefore[0])}' with '${local(path.join(subdir,fx))}'`)
+              DEBUG?.(`Conflict for '${e.name}': replacing '${local(seenBefore[0])}' with '${local(path.join(subdir,fx))}'`)
               continue
             }
           }
@@ -267,7 +303,7 @@ const _entity4 = (file,csn) => {
       const base = csn.definitions [RegExp.$1]
       return base?.elements?.texts && _entity4 (base.elements.texts.target, csn)
     }
-    else return DEBUG && DEBUG (`warning: ${name} not in model`)
+    else return DEBUG?.(`warning: ${name} not in model`)
   }
   // We also support insert into simple views if they have no projection
   const p = entity.query && entity.query.SELECT || entity.projection
@@ -305,7 +341,7 @@ const _queries4 = (db,csn) => !db.cqn2sql ? q => q : q => {
 
 
 const INSERT_from4 = (db,o) => {
-  const schevo = db.options?.schema_evolution === 'auto' || o?.schema_evolution === 'auto'
+  const schevo = db.options?.schema_evolution === 'auto' || cds.env.requires.db?.schema_evolution === 'auto' || o?.schema_evolution === 'auto'
   const INSERT_into = (schevo ? UPSERT : INSERT).into
   return (file) => ({
     '.json': { into (entity, json) {
@@ -320,4 +356,28 @@ const INSERT_from4 = (db,o) => {
 }
 
 const _skip = e => !e || e['@cds.persistence.skip'] === true
-/* eslint-disable no-console */
+
+
+
+if (!module.parent) (async () => {
+  await cds.plugins // IMPORTANT: that has to go before any call to cds.env, like through cds.deploy or cds.requires below
+  let db = cds.requires.db
+  try {
+    let o={}, recent
+    for (let each of process.argv.slice(2)) {
+      if (each.startsWith('--')) o[(recent = each.slice(2))] = true
+      else o[recent] = each
+    }
+    if (o.to) {
+      db = { kind: o.to, dialect: o.to }
+      if (o.url) (db.credentials ??= {}).url = o.url
+      if (o.host) (db.credentials ??= {}).host = o.host
+      if (o.port) (db.credentials ??= {}).port = o.port
+      if (o.username) (db.credentials ??= {}).username = o.username
+      if (o.password) (db.credentials ??= {}).password = o.password
+    }
+    db = await cds.deploy('*',o).to(db)
+  } finally {
+    await db?.disconnect?.()
+  }
+})().catch(console.error)