@sap/cds-dk 4.5.4 → 4.6.4

package/CHANGELOG.md

@@ -6,6 +6,66 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 4.6.4 - 2021-11-24
+
+### Fixed
+
+- `cds import` fix for TypeError issue during OData V2 EDMX conversion to CSN.
+- `cds import <file_name>` fix now updates the service name in the `package.json` with only the file name. Earlier, the service name sometimes used to be of the form `A.B`, with `A` being file name and `B` being a part of the schema namespace value in the EDMX file
+
+### Changed
+
+- `cds init` uses latest `Maven Java archetype` version `1.20.3` for creating Java projects.
+
+## Version 4.6.3 - 2021-11-16
+
+### Fixed
+
+- `cds watch` recovers again from compilation errors and properly prints these
+- `cds import` fix for omitting empty `doc` components.
+- `cds add lint` no longer duplicates initial contents in `package.json`
+- `cds add data` no longer ignores imported services for which credentials are stored in the project
+
+## Version 4.6.2 - 2021-11-09
+
+### Fixed
+
+- `cds add lint` now correctly detects missing local `eslint`
+- `cds add lint` no longer removes parts of `package.json`
+- `cds add lint` no longer creates duplicate configuration entries
+
+## Version 4.6.1 - 2021-11-08
+
+### Changed
+
+- `cds init` uses latest `Maven Java archetype` version `1.20.0` for creating Java projects.
+- `cds watch` now resolves local node modules like `hdb` even though `@sap/cds` is not installed locally.  This is useful during development where `@sap/cds` shall only be installed in a 'central' location, while extra modules shall still be found in the app's dir.
+
+### Fixed
+
+- `cds repl` now finds modules like `hdb` that are installed locally in the app folder
+- `cds repl` now enables the `await` statement also on Windows
+- `cds lint` now limits all file extensions to those allowed by the @sap/eslint-plugin-cds ESLint configuration
+
+## Version 4.6.0 - 2021-11-02
+### Added
+
+- `cds bind` binds the given service to a hana instance by storing the credentials in `.cdsrc.json` in your user home directory [beta].
+- `cds import` introduced option `--include-namespaces` which imports the custom defined namespaces.
+- `cds import` preserve documentation in CSN file for actions and functions from OData V4 EDMX file.
+- `cds import` now supports reading values of the `as` option from cds.env
+
+### Fixed
+
+- `cds import` fix for reflecting only supported datatypes in csn for actions and functions for OData V4.
+- `cds import` fix for TypeError issue (#9868) during OData V4 EDMX conversion to CSN.
+- `cds watch` no longer omits starting some services every other time it is restarting the process
+- `cds-ts watch` now honors a local `tsconfig.json` file
+- `cds import` fix for TypeError issue (#9950) during OData V2 EDMX conversion to CSN.
+- `cds import` fix to generate the csn (#9950) during OData V2 EDMX conversion to CSN.
+- `cds import` fix to replace the aliases with original schema namespace value.
+- `cds import` adds `@cds.persistence.skip` back to imported models.  Its accidental removal in 4.5.0 caused wrong DB deployments of imported entities.
+
 ## Version 4.5.4 - 2021-10-07
 
 ### Fixed
@@ -64,6 +124,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
     + no longer skips over entities marked with `@cds.persistence.skip`, which is true for 'external' entities created by `cds import`.
 - `cds init --add` handles comma list correctly.
 - `cds import` fix for multi-line documentation text in OData V4 EDMX file.
+- `cds import` fix preserves the missing entities in csn for OData V2 EDMX file.
 
 
 ## Version 4.4.2 - 2021-09-03

package/bin/bind.js

@@ -1,17 +1,133 @@
-module.exports = Object.assign (
-    cds_bind, {help: `
+
+
+module.exports = Object.assign(cds_bind, {
+    options: ['--to', '--profile', '--kind', '--output-file'],
+    flags: [],
+    shortcuts: ['-2', '-p', '-k', '-o'],
+    help: `
 # SYNOPSIS
 
-    *cds bind* <service> [<options>]
+    *cds bind* <service> [<options>]  --  beta feature
 
-    Binds the given service to
+    Binds the given service to a service instance by storing connection information in *.cdsrc-private.json*
+    in your project directory. Credentials are not stored in the file but rather retrieved dynamically during *cds watch*.
+    Use option *--output-file* to specify a different path or file.
+
+    Currently *cds bind* only supports Node.js projects.
 
 # OPTIONS
 
-    *-2|--to* <credentials>
+    *-2 | --to* <instance>[:<key>]
+        bind to a given instance
+
+    *-p | --profile* <profile>
+        add the given profile, defaults to *hybrid*
+
+    *-k | --kind* <kind>
+        the kind of service
+
+    *-o | --output-file <path>*
+        save bindings to the given *.cdsrc.json* or *package.json* file. Default is *.cdsrc-private.json*.
+        If *path* is a directory, then it will save it to the *.cdsrc.json* file in that directory.
+
+# EXAMPLE
+
+    cds bind --to my-hdi-container
+    cds bind --to my-hdi-container,my-xsuaa
+    cds bind uaa --to my-xsuaa:my-xsuaa-key --kind xsuaa --profile myprofile
+
+    cds bind --to my-hdi-container --output-file ~
+    cds bind --to my-hdi-container --output-file package.json
+
+`});
+
+const { constants, promises: fsp } = require('fs');
+const path = require('path');
+
+const cds = require('@sap/cds/lib');
+const LOG = cds.log('bind');
+// required for spinner
+LOG.isDebug = LOG._debug;
+LOG.isTTY = process.stdout.isTTY;
+
+const { bold, info } = require('../lib/util/term');
+
+const Spinner = require('../lib/init/util/spinner');
+
 
-`})
+async function cds_bind(args, options) { // eslint-disable-line
+
+    options.profile = options.profile || 'hybrid';
+
+    if (await isJavaProject('.')) {
+        throw new Error(`Found a 'pom.xml' file in your project root folder indicating a Java project. Currently, 'cds bind' only supports Node.js projects.`);
+    }
+
+    if (!options.to) {
+        throw new Error(`use option --to or -2 to specify the target instance, e.g. cds bind --to myInstance:myService`);
+    }
+
+    if (args.length > 1) {
+        throw new Error(`Too many arguments: Please specify only one or no service.`);
+    }
+
+    let serviceArg = args[0]
+    const targets = options.to.split(/,/g);
+
+    if (targets.length >= 2 && serviceArg) {
+        throw new Error(`Service argument cannot be specified together with multiple targets ('--to') services. Use one service per call or omit the service argument.`);
+    }
+
+    if (targets.length >= 2 && options.kind) {
+        throw new Error(`The option '--kind' cannot be specified together with multiple targets ('--to') services. Use one service per call or omit the '--kind' option.`);
+    }
+
+    // prepare for different providers
+    const keyProvider = require('../lib/bind/cfKeyProvider');
+    keyProvider.setLogger(LOG);
+    const spinner = new Spinner(LOG);
+    const resolvedServices = await spinner.run(`Retrieving data from Cloud Foundry...`, async () => { // NOSONAR
+        const resolvedServices = [];
+        await Promise.all( targets.map( async target => {
+            const [instance, key] = target.split(/:/);
+            const resolvedService = await keyProvider.resolve(undefined, { instance, key });
+            // if (!options["save-credentials"]) {
+                delete resolvedService.credentials;
+                resolvedService.binding.resolved = false;
+            // }
+            resolvedServices.push(resolvedService);
+        }));
+        return resolvedServices;
+    });
+
+    if (!options.kind) {
+        keyProvider.determineKinds(resolvedServices);
+    }
+
+    for (const resolvedService of resolvedServices) {
+        resolvedService.kind = options.kind || resolvedService.kind;
+        resolvedService.name = serviceArg || keyProvider.getRequiresNameFromKind(resolvedService.binding.instance, resolvedService.kind);
+    }
+
+    // prepare for different providers
+    const userCdsrcJsonStorageProvider = require('../lib/bind/userCdsrcJsonStorageProvider');
+
+    await userCdsrcJsonStorageProvider.storeServices(resolvedServices, {
+        ...options,
+        logger: LOG
+    });
+
+    LOG.log();
+    LOG.log(`${info("TIP:")} Run with cloud bindings: ${bold(`cds watch --profile ${options.profile}`)}`);
+    // LOG.log();
+}
 
-function cds_bind (projects, options) { // eslint-disable-line
-  console.log (`cds bind is not yet released`)
+async function isJavaProject(projectPath) {
+    const pomXmlPath = path.join(projectPath, 'pom.xml');
+    try {
+        await fsp.access(pomXmlPath, constants.F_OK);
+        return true;
+    } catch (err) {
+        return false;
+    }
 }

package/bin/cds-ts.js

@@ -1,2 +1,2 @@
-#!/usr/bin/env ts-node
+#!/usr/bin/env ts-node-cwd
 require('./cds').apply(process.argv)

package/bin/cds.js

@@ -5,6 +5,7 @@ const cli = { //NOSONAR
   Shortcuts: {
     i: 'init',
     a: 'add',
+    y: 'bind',
     m: 'import',
     c: 'compile',
     s: 'serve',

package/bin/compile/index.js

@@ -38,6 +38,7 @@ module.exports = Object.assign ( compile, {
     - json, yml
     - edm, edmx, edmx-v2, edmx-v4, edmx-w4, edmx-x4
     - sql, hdbcds, hdbtable
+    - cdl [beta]
     - xsuaa
     - openapi
 
@@ -261,7 +262,7 @@ function compile (models, options={}) {
 
   function suffix4 (x) { return x && ({
     edmx: '.xml',
-    "edmx-v2": '.xml', 
+    "edmx-v2": '.xml',
     "edmx-v4": '.xml',
     openapi: '.openapi3.json', //'.yml',
     cdl: '.cds',

package/bin/env.js

@@ -1,5 +1,5 @@
 module.exports = Object.assign (env, {
-  options: ['--for', '--mocked'], flags: [], shortcuts: ['-4'],
+  options: ['--for', '--mocked'], flags: ['--process-env', '--resolve-bindings'], shortcuts: ['-4', undefined, '-P', '-b'],
   help: `
 # SYNOPSIS
 
@@ -11,13 +11,29 @@ module.exports = Object.assign (env, {
 
 # EXPLANATION
 
-    Without any arguments, this will display the effective configuration in
-    the current environment in JavaScript object format. <ls | list> displays
-    it in _.properties_ format.
+    Lists the effective configuration of the current environment in
+    _.properties_ format if no command, *ls*, or *list* is given.
 
-    The other variants either get or set a single option or display the sources
-    from which the effective configuration has been loaded.
+    The other commands either get or set a single property or display
+    the sources from which the effective configuration has been loaded.
 
+# OPTIONS
+
+    *-4* | *--for* <path>
+
+       Load configuration from path instead of the current working directory.
+
+    *--profile* <profile,...>
+
+       Load configuration for the specified profile(s).
+
+    *-P* | *--process-env*
+
+       Show properties from Node.js _process.env_.
+
+    *-b* | *--resolve-bindings*
+
+       Resolve _cds bind_ bindings.
 `})
 
 const path = require('path')
@@ -29,15 +45,20 @@ const info = (s) => process.stdout.isTTY ? term.info (s) : s
 async function env ([cmd, key, value], options={}) {
 
   const cds = require('@sap/cds/lib')
-  const fn = commands[cmd] || (()=>{
+  const fn = (options["process-env"] ? processEnvCommands[cmd] : commands[cmd]) || (()=>{
     this.help ('env')
     throw new Error (`Don't understand '${cmd}' here...`)
   })
 
+  if (options.profile) process.env.CDS_ENV = options.profile
+
   const env = options.for ? cds.env.for (options.for) : cds.env
   env['_home_cds-dk'] = path.resolve(__dirname, '..')  // to help tools find the DK
 
+  if (options["resolve-bindings"]) await require('../lib/bind/bindingResolver').applyTo({env, output: "debug"})
+
   if (!options.for && options.mocked)  await cds.service.bindings
+
   fn (env, key, value)
 }
 
@@ -69,19 +90,39 @@ const commands = {
     if (!process.stdout.isTTY)  return commands.json (conf, key, val)
     // tty: display formatted object
     const obj = (key ? conf.get(key) : conf)
-    console.log (inspect (obj, {depth:22,colors:true}))
+    console.log (inspect (obj, {depth:22,colors:true}).replace(/\s+use:.*\[Getter\].*/g,''))
   },
 
   // eslint-disable-next-line no-unused-vars
   json (conf, key, val) {
     const obj = (key ? conf.get(key) : conf)
-    return console.log (JSON.stringify(obj, null, 2))
+    const str = JSON.stringify(obj, null, 2)
+    return console.log (str ? str.replace(/\s+use:.*\[Getter\].*/g,'') : str)
   },
 
   set () {
     throw new Error ('cds config set is not yet implemented, sorry')
+  }
+}
+
+const processEnvCommands = {
+  get [undefined]() { return processEnvCommands.list },
+  get ''() { return processEnvCommands.list },
+  get ls()   { return process.list },
+
+  list (_, key) {
+    if (key) {
+      processEnvCommands.get(undefined, key)
+    } else {
+      for (const name in process.env) {
+        console.log(`${name}=${process.env[name]}`)
+      }
+    }
   },
 
+  get (_, key) {
+    console.log (process.env[key] || "")
+  }
 }
 
 /* eslint no-console:0 */

package/bin/help.js

@@ -10,6 +10,7 @@ module.exports = exports = Object.assign (help, {help:`
 
     *i* | *init*       jump-start cds-based projects
     *a* | *add*        add a feature to an existing project
+    *y* | *bind*       [beta] bind a service to a hana instance
     *m* | *import*     add models from external sources
     *c* | *compile*    compile cds models to different outputs
     *s* | *serve*      run your services in local server

package/bin/import.js

@@ -1,9 +1,9 @@
 
 module.exports = Object.assign(_import, {
     _name: 'import',
-    options: ['--out', '--into', '--as'],
+    options: ['--out', '--into', '--as', '--include-namespaces'],
     flags: ['--dry', '--force', '--no-copy', '--no-save', '--keep-namespace'],
-    shortcuts: ['-o', '-in', '-as', '-', '-f'],
+    shortcuts: ['-o', '-in', '-as', '-ns', '-', '-f'],
     help: `
 # SYNOPSIS
 
@@ -42,7 +42,10 @@ module.exports = Object.assign(_import, {
         Converts the input edmx or xml file into one of these supported formats "cds", "csn", "json"
 
     *-f | --force*
-        Forcefully overwrites the contents in the CDS file and updates the checksum 
+        Forcefully overwrites the contents in the CDS file and updates the checksum
+        
+    *-ns | --include-namespaces <string_of_namespaces> or* * 
+        Imports only entities matching to the given list of namespaces.
 
        
        
@@ -52,6 +55,8 @@ module.exports = Object.assign(_import, {
     cds import ~/Downloads/API_BUSINESS_PARTNER.edmx
     cds import - ~/Downloads/API_BUSINESS_PARTNER.edmx
     cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --as cds
+    cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --include-namespaces "sap,c4c"
+    cds import ~/Downloads/API_BUSINESS_PARTNER.edmx --include-namespaces "*"
 
 `})
 const cds = require('@sap/cds/lib')
@@ -62,12 +67,19 @@ const common = require('../lib/import/common');
 const cdsCompiler = require('../lib/compile').compile.to;
 const md5 = require('md5');
 let cwd;
-async function _import(file, { out, dry, into, as,
+async function _import(file, { out, dry, into, as, 
+    'include-namespaces': include_namespaces,
     'no-save': no_save,
     'no-copy': no_copy,
     'keep-namespace': keep_namespace,
     force
 } = {}) {
+    if (!as) {
+        if (cds.env.import) as = cds.env.import.as;
+    }
+    if (!include_namespaces) {
+        if(cds.env.import) include_namespaces = cds.env.import.include_namespaces;
+    }
     cwd = into || process.cwd();
     if (as && !common.supportedFormats().includes(as)) 
         throw new Error(messages.INVALID_AS_OPTION);
@@ -78,6 +90,14 @@ async function _import(file, { out, dry, into, as,
     const dst = path.join(external, path.basename(file))
     if (!dry && !no_copy) file = await _copy_to_srv_external(file, dst)
     const src = await edm2csn.getMetadataFromFile(file)
+    this.include_all_namespaces = false;
+    let namespaces = [];
+    if(include_namespaces) {
+        if(include_namespaces === "*") this.include_all_namespaces = true;
+        else if(typeof include_namespaces === 'string' && !include_namespaces.startsWith('-')) namespaces = include_namespaces.replace(/ /g, "").split(',');
+        else throw new Error(messages.INCORRECT_INPUT_NAMESPACES);
+    }
+    this.namespaces = namespaces;
     let csn = await edm2csn.edmx2csn(src, !keep_namespace && file, this)
     const service = _service_name_from(csn);
     if (out) out = edm2csn.validateAndComputeOutputFilePath(out, as);
@@ -96,23 +116,23 @@ async function _generateChecksumValidate(dest, output, force) {
         return output;
     }
     else {
-        let fileContent = await read(dest, "utf-8");
-        fileContent = String(fileContent);
-        if (fileContent.indexOf("checksum") === -1){
-            let checksum = md5(fileContent);
+        let existingFileContent = await read(dest, "utf-8");
+        existingFileContent = String(existingFileContent);
+        if (existingFileContent.indexOf("checksum") === -1){
+            let checksum = md5(existingFileContent);
             output = "/* checksum : " + checksum + " */\n" + output;
             return output;
         }      
-        let fileChecksum = fileContent.substring(fileContent.indexOf("checksum") + 11, fileContent.indexOf(" */"));
-        let newFile = fileContent.substring(fileContent.indexOf('*/') + 3);
-        let checksum = md5(newFile);
+        let fileChecksum = existingFileContent.substring(existingFileContent.indexOf("checksum") + 11, existingFileContent.indexOf(" */"));
+        existingFileContent = existingFileContent.substring(existingFileContent.indexOf('*/') + 3);
+        let checksum = md5(existingFileContent);
         if (fileChecksum === checksum) {
-            output = "/* checksum : " + checksum + " */\n" + output;
+            output = "/* checksum : " + checksum + " */\n" + existingFileContent;
             return output;
         }
         else {
             if (force) {
-                output = "/* checksum : " + checksum + " */\n" + newFile;
+                output = "/* checksum : " + md5(output) + " */\n" + output;
                 return output;
             }
             else {
@@ -195,4 +215,4 @@ async function _update_package_json(dest, service, version) {
         await write(package_json, JSON.stringify(conf, null, '  '))
         console.log(`[cds] - updated ./package.json`)
     }
-}
+}

package/bin/repl.js

@@ -14,8 +14,12 @@ module.exports = Object.assign (repl, { options: [], help: `
 
 function repl (_, options={}) {
 
-  if (module.parent && module.parent.filename.endsWith('/bin/cds.js')) {
-    return require('child_process').spawn('node',['--experimental-repl-await', __filename ],{stdio:'inherit'})
+  // enable `await` statement for Node.js < 16
+  if (!process.env['CDS_REPL_SPAWNED'] && process.version.split('.')[0].slice(1) < '16') {
+    process.env['CDS_REPL_SPAWNED'] = true
+    return require('child_process').spawn('node',['--experimental-repl-await',
+      ...process.argv.slice(1) ], {stdio:'inherit'}
+    )
   }
 
   const cds = require('@sap/cds/lib')

package/bin/watch.js

@@ -43,7 +43,7 @@ module.exports = Object.assign ( watch, {
 `})
 
 const DEBUG = /\bwatch\b/.test(process.env.DEBUG) && console.debug
-const path = require ('path')
+const {delimiter,dirname,relative,resolve,sep} = require ('path')
 const fs = require ('fs')
 const t = module.exports.codes = {
   reset: '\x1b[0m', // Default
@@ -67,12 +67,15 @@ async function watch ([cwd], {
     .filter(removeArgsIn(watchOnlyOptions))  // remove all watch-only options, as `cds serve` would not accept them
     .filter(a => a !== cwd))
 
-  const env = Object.assign (process.env, {
+  let env = Object.assign (process.env, {
     _args: JSON.stringify(args),
     _options: JSON.stringify(options)
   })
+
+  // allow running w/o or partial local node_modules, also add cds-dk for its sqlite
+  env.NODE_PATH = [...paths(cwd||process.cwd()), ...paths(__dirname)].join(delimiter)
+
   if (typeof ext !== 'string')  ext = extDefaults
-  env.NODE_PATH = path.resolve (__dirname,'../node_modules') // allow global sqlite to be resolved
 
   let liveReload //= ...
   let firstTime = true
@@ -83,7 +86,7 @@ async function watch ([cwd], {
     env.CDS_LIVERELOAD_URL = await liveReload.start (options['livereload'])
       .catch(err => { console.log(`Error starting live reload: ${err.message}`); liveReload = null })
   } else {
-    ignore = RegExp(`app${path.sep}.*\\.(js|ts)|`+ignore.source) // exclude more frontend stuff
+    ignore = RegExp(`app${sep}.*\\.(js|ts)|`+ignore.source) // exclude more frontend stuff
   }
 
   const log = (first,...more) => console.log (t.yellow + (first||''), ...more, t.reset)
@@ -91,8 +94,8 @@ async function watch ([cwd], {
     const ocwd = process.env._original_cwd = process.cwd()
     if (fs.existsSync(cwd)) log (`cd ${cwd}`)
     else try {
-      const resolved = path.dirname (require.resolve(cwd+'/package.json', {paths:[ocwd]}))
-      log (`cd ${path.relative(ocwd,cwd = resolved)}`)
+      const resolved = dirname (require.resolve(cwd+'/package.json', {paths:[ocwd]}))
+      log (`cd ${relative(ocwd,cwd = resolved)}`)
     } catch(_){ throw new Error(`No such folder or package: '${ocwd}' -> '${cwd}'`) }
   }
   log ()
@@ -100,8 +103,12 @@ async function watch ([cwd], {
   log (`watching: ${ext}...`)
   if (liveReload) log (`live reload enabled for browsers`)
 
+  const bindingManager = new require('../lib/bind/bindingResolver').bindingManager({cwd})
+  const bindings = await bindingManager.resolve()
+  if (bindings) env = {...env, CDS_CONFIG: JSON.stringify(bindings)}
+
   const nodemon = require('../lib/watch/node-watch')
-  return nodemon ({
+  const watcher = nodemon ({
     watch: ['*','.env','.cdsrc.json'],
     script:__filename, cwd, env, ext, ignore,
     delay: parseInt(process.env.CDS_WATCH_DELAY) || 200,
@@ -111,12 +118,18 @@ async function watch ([cwd], {
     if (liveReload) liveReload.markPending(files)
     if (this.delayed) clearTimeout (this.delayed)
     this.delayed = setTimeout(()=>{
+      bindingManager.update({
+        onBeforeUpdate: () => watcher.stop(),
+        onAfterUpdate: bindings => {
+          watcher.setEnv('CDS_CONFIG', bindings && JSON.stringify(bindings))
+          watcher.restart()
+        }
+      })
       log (`${t.bold}        _______________________\n`)
       FileHandlers.changed (files,cwd)
     }, 111)
   }).on('quit', ()=>{
     log (`${t.bold+t.green}\n[cds] - my watch has ended.\n`)
-    process.exit()
   }).on('message', async (msg) => { switch (msg.code) { // messages from child process
     case 'listening':
       env.PORT = (msg.address && msg.address.port) || msg.port
@@ -127,6 +140,8 @@ async function watch ([cwd], {
     case 'EADDRINUSE': env.PORT = 0; _addr_in_use(msg); break
     default: console.error (msg)
   }})
+
+  return watcher
 }
 
 
@@ -160,6 +175,12 @@ function removeArgsIn (toRemove) {
   }
 }
 
+// builds paths from dir + its parent node_modules
+function paths (dir) {
+  const parts = resolve(dir).split(sep), n = parts.length, nm = sep+'node_modules'
+  return parts.map ((_,i,a)=> a.slice(0,n-i).join(sep)+nm).filter(p => fs.existsSync(p))
+}
+
 //
 // Child process impl launched by watch
 //
@@ -168,15 +189,24 @@ if (!module.parent) (async()=>{ // launched by nodemon
   // run through cli in order to use its error handling
   const bootstrap = require('./cds')(...JSON.parse(process.env._args))
   const {cds} = global
+
+  cds.once('listening', ({server, url}) => {
+    process.send ({ code:'listening', port: server.address().port })
+    // Need to give bindings an explicit call to purge,
+    // as its .exit handler has no chance to execute on Windows.
+    process.on ('message', (msg)=> { if (msg && msg.exit) { // see node-watch
+      (new cds.service.bindings(url)).purge()
+    }})
+  })
+
   try {
-    cds.once('listening', ({server}) => process.send ({ code:'listening', port: server.address().port }))
     await bootstrap
     if (!cds.service.providers.length) return _no_services_found()
   } catch (e) { switch (e.code) {
     case 'NO_SERVICES_FOUND': return _no_services_found(e)
     case 'MODEL_NOT_FOUND': return _no_models_found(e)
     case 'EADDRINUSE': return process.send(e)  //> tell cds watch
-    default: console.error(e)
+    default: { throw e } // cli error handling will catch and format
   }}
   function _no_models_found(e) { console.log (`
     No models found in ${cds.resolve(e.model||'*',false)}.