@sap/cds-dk 4.5.4 → 4.6.0

package/CHANGELOG.md

@@ -6,6 +6,25 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## 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 +83,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/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/watch.js

@@ -67,7 +67,7 @@ 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)
   })
@@ -100,8 +100,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 +115,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 +137,8 @@ async function watch ([cwd], {
     case 'EADDRINUSE': env.PORT = 0; _addr_in_use(msg); break
     default: console.error (msg)
   }})
+
+  return watcher
 }
 
 
@@ -168,8 +180,17 @@ 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) {

package/lib/bind/bindingResolver.js

@@ -0,0 +1,138 @@
+const Config = require('@sap/cds/lib/env')
+const cds = require('@sap/cds/lib');
+const LOG = cds.log('bind');
+
+function getUnresolvedBindings({cwd = process.cwd(), env}) {
+    if (!env) env = Config.for('cds', cwd)
+    if (feature(env) === false || feature(env) === "false") return {}
+
+    const requires = env.requires || {}
+    let bindings = {}
+    for (const name in requires) {
+        const service = requires[name]
+        if (service && service.binding && !service.binding.resolved) {
+            bindings[name] = {...service.binding, kind: service.kind }
+        }
+    }
+
+    return bindings
+}
+
+async function resolveBindings({bindings, cwd = process.cwd(), env, output = 'info', cache = {} }) {
+    const config = { requires: { } }
+    bindings = bindings || getUnresolvedBindings({cwd, env})
+    if (Object.keys(bindings).length===0) return config;
+    LOG[output](`resolving cloud service bindings...`)
+    await Promise.all( Object.keys(bindings).map( async name => {
+        const binding = bindings[name]
+        const cacheKey = JSON.stringify(binding)
+        if (!cache[cacheKey]) {
+            cache[cacheKey] = config.requires[name] = await resolveBinding(name, binding)
+            LOG[output](`bound ${name} to Cloud Foundry service instance ${binding.instance}`)
+        } else {
+            config.requires[name] = cache[cacheKey]
+        }
+    } ));
+
+    // Add kind to result, so that it can be applied to old @sap/cds versions that do not read `.cdsrc-private.json`
+    for (const name in config.requires) {
+        if (bindings[name].kind) config.requires[name].kind = bindings[name].kind
+    }
+
+    return config
+}
+
+let cfKeyProvider
+
+async function resolveBinding(name, binding) {
+    switch (binding.type) {
+        case 'cf':
+            if (!cfKeyProvider) {
+                cfKeyProvider = require('./cfKeyProvider');
+                cfKeyProvider.setLogger(LOG);
+            }
+            return cfKeyProvider.resolve(name, binding);
+        default:
+            throw new Error(`Unsupported binding type "${binding.type}" for service "${name}".`)
+    }
+}
+
+async function applyTo(options) {
+    const config = await resolveBindings(options)
+    if (!config) return
+    const {env} = options
+    for (const name in config.requires) {
+        const service = config.requires[name]
+        const { binding, credentials } = service
+        Object.assign(env.requires[name], { binding, credentials })
+    }
+
+    if (Config._emulate_vcap_services) {
+        Config._emulate_vcap_services()
+    }
+}
+
+class BindingManager {
+    constructor(options) {
+        this.cache = {}
+        this.bindingsStr = ''
+        this.options = options
+    }
+
+    getBindings() {
+        const bindings = getUnresolvedBindings(this.options)
+        return bindings
+    }
+
+    async resolve(bindings) {
+        if (!bindings) {
+            bindings = this.getBindings(this.options)
+            this.bindingsStr = JSON.stringify(bindings)
+        }
+
+        const config = await resolveBindings({...this.options, bindings, cache: this.cache})
+        if (config && Object.keys(config.requires || {}).length > 0) return config;
+    }
+
+    async update({ onBeforeUpdate, onAfterUpdate } = {}) {
+        const oldBindingsStr = this.bindingsStr
+        const bindings = this.getBindings()
+        const bindingsStr = JSON.stringify(bindings)
+        this.bindingsStr = bindingsStr
+
+        if (this.bindingsStr === oldBindingsStr) return // No change
+        if (onBeforeUpdate) await onBeforeUpdate()
+
+        try {
+            if (this.pendingUpdate) await this.pendingUpdate
+        } catch(error) {
+            // ignore
+        }
+        this.pendingUpdate = undefined
+
+        if (this.bindingsStr !== bindingsStr) return // Next update in progress
+
+        let resolvedBindings
+        try {
+            this.pendingUpdate = this.resolve(bindings)
+            resolvedBindings = await this.pendingUpdate
+        } catch(error) {
+            LOG.error(error.message)
+            return
+        }
+
+        if (this.bindingsStr !== bindingsStr) return // Next update in progress
+        if (onAfterUpdate) onAfterUpdate(resolvedBindings)
+    }
+}
+
+function feature(env) {
+    return env.features && env.features.dk && env.features.dk.resolveBindingsForTesting
+}
+
+module.exports = {
+    applyTo,
+    bindingManager: function(options) {
+        return new BindingManager(options)
+    }
+}