@sap/cds-dk 4.5.0 → 4.6.0

package/CHANGELOG.md

@@ -6,11 +6,65 @@ 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
+
+- `cds watch` no longer fails if started with `--ext`, `--livereload`, or `--open` arguments
+
+## Version 4.5.3 - 2021-10-05
+
+### Fixed
+
+- `cds import` fix for `--dry` shortcut `-`
+- `cds import` fix for missing type properties in csn for unbounded action and function in OData V4.
+- A  bug with `cds init` when called in BAS project wizard
+
+## Version 4.5.2 - 2021-09-30
+
+### Changed
+
+- `cds init` uses latest `Maven Java archetype` version `1.19.0` for creating Java projects.
+
+### Fixed
+
+- `cds deploy --to sqlite` now writes `credentials.database` again to `package.json`
+
+## Version 4.5.1 - 2021-09-29
+
+### Added
+
+- `cds import` introduced option `--as` which converts EDMX file to different file formats such as cds, csn and json.
+- `cds import` introduced flag `--f` which forcefully overwrite the content of existing cds file when specified with `--as` option.
+
+### Changed
+
+- Marked `cds lint` as beta again to further investigate issues from 'extends' via prettier plugin.
+
 ## Version 4.5.0 - 2021-09-23
 
 ### Added
 
-- `cds import` supports import of functions, action, functionimport and actionimport from both OData v2 and v4 edmx files.
+- `cds import` supports import of functions, action, functionimport and actionimport from both OData V2 and V4 EDMX files.
 
 ### Changed
 
@@ -18,16 +72,18 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Fixed
 
-- `cds watch` additional CLI args were not passed to launched process, e.g. `--odata x4`.
-- `cds import` fix for TypeError issue during OData v4 edmx conversion to csn.
-- `cds import` fix for multi-line documentation text in OData v2 edmx file.
-- `cds import` fix for v4 csn generation when non standard OData vocabularies are referred.
+- `cds watch` additional CLI args were not passed to launched process, for example, `--odata x4`.
+- `cds import` fix for TypeError issue during OData V4 EDMX conversion to CSN.
+- `cds import` fix for multi-line documentation text in OData V2 EDMX file.
+- `cds import` fix for V4 CSN generation when non standard OData vocabularies are referred.
 - `cds add data`
-    - no longer fails for entities without keys
-    - no longer creates csv files for synthetic draft entities
-    - no longer creates entries for virtual fields
-    - no longer skips over entities marked with `@cds.persistence.skip`, which is true for 'external' entities created by `cds import`.
+    + no longer fails for entities without keys
+    + no longer creates csv files for synthetic draft entities
+    + no longer creates entries for virtual fields
+    + 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/deploy/index.js

@@ -94,7 +94,7 @@ async function deploy (_model, options) { // NOSONAR
 }
 
 
-async function updata_package_json (kind, model='*', database) {
+async function updata_package_json (kind, model, database) {
   const { fs, path, isfile } = cds.utils
   const { readFile, writeFile } = fs.promises
   const package_json = path.resolve ('package.json'), exists = isfile (package_json)
@@ -102,6 +102,7 @@ async function updata_package_json (kind, model='*', database) {
   const requires = ['cds','requires'] .reduce ((p,n)=>p[n] || (p[n]={}), conf)
   requires.db = cds.env.requires.db = { kind, model }
   if (database)  requires.db.credentials = { database }
+  else if (kind === 'sqlite') requires.db.credentials = { database:'sqlite.db' }
   await writeFile (package_json, JSON.stringify(conf,null,'  '))
   console.log (`/> ${ exists ? 'updated' : 'created' } ./package.json`)
 }

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
@@ -20,7 +21,7 @@ module.exports = exports = Object.assign (help, {help:`
     *d* | *deploy*     deploy to databases or cloud
     *l* | *login*      login to extendable SaaS application
     *x* | *extend*     create extension project from SaaS application
-    *t* | *lint*       run linter for env or model checks
+    *t* | *lint*       [beta] run linter for env or model checks
     *v* | *version*    get detailed version information
     *?* | *help*       get detailed usage information
 

package/bin/import.js

@@ -1,9 +1,9 @@
 
 module.exports = Object.assign(_import, {
     _name: 'import',
-    options: ['--out', '--into'],
-    flags: ['--dry', '--no-copy', '--no-save', '--keep-namespace'],
-    shortcuts: ['-o', '-in', '-'],
+    options: ['--out', '--into', '--as', '--include-namespaces'],
+    flags: ['--dry', '--force', '--no-copy', '--no-save', '--keep-namespace'],
+    shortcuts: ['-o', '-in', '-as', '-ns', '-', '-f'],
     help: `
 # SYNOPSIS
 
@@ -38,23 +38,51 @@ module.exports = Object.assign(_import, {
     *- | --dry*
         Writes the converted csn to stdout only.
 
+    *-as | --as <output_file_format>*
+        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
+        
+    *-ns | --include-namespaces <string_of_namespaces> or* * 
+        Imports only entities matching to the given list of namespaces.
+
+       
+       
 
 # EXAMPLES
 
     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')
-const { fs, path, write, mkdirp, exists } = cds.utils
+const { fs, path, write, mkdirp, exists, read} = cds.utils
 const edm2csn = require('../lib/import')
+const messages = require('../lib/import/message').getMessages();
+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,
+async function _import(file, { out, dry, into, as, 
+    'include-namespaces': include_namespaces,
     'no-save': no_save,
     'no-copy': no_copy,
-    'keep-namespace': keep_namespace
+    '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);
     if (Array.isArray(file)) file = file[0]
     if (!file) return this.help('import')
     file = await edm2csn.isValidInputFile(path.resolve(cwd, file))
@@ -62,25 +90,102 @@ async function _import(file, { out, dry, into,
     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)
-    const csn = await edm2csn.edmx2csn(src, !keep_namespace && file, this)
-    if (out) out = edm2csn.validateAndComputeOutputFilePath(out);
-    const written = dry || await _write(csn, out = out || dst.replace(/\.[^.]+$/, '.csn'))
-    const registered = dry || no_save || await _update_package_json(out, csn, this.oDataVersion)
-    if (dry) return console.log(JSON.stringify(csn, 0, '  '))
+    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);
+    const result = await _getResult(csn, service, as, out || dst.replace(/\.[^.]+$/, ''), force);
+    const written = dry || await _write(result[0], result[1], result[2]);
+    const registered = dry || no_save || await _update_package_json(result[1].replace(/\.[^.]+$/, ''), service, this.oDataVersion);
+    if (dry) return console.log(result[0]);
     return Promise.all([written, registered])
 }
 
-async function _write(csn, dest) {
-    await edm2csn.saveCSNModel(JSON.stringify(csn, null, '  '), dest);
-    const service = _service_name_from(csn)
-    let using = `using { ${service} as external } from './${path.relative('srv', dest).replace(/\\/g, '/')}';`
-    using = require('../lib/util/term').info(using)
-    console.log(
-        `[cds] - imported API to ${path.relative(cwd, dest)}
+async function _generateChecksumValidate(dest, output, force) {
+    let fileResolved = await exists(dest);
+    if (fileResolved === false) {
+        let checksum = md5(output);
+        output = "/* checksum : " + checksum + " */\n" + output;
+        return output;
+    }
+    else {
+        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 = 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" + existingFileContent;
+            return output;
+        }
+        else {
+            if (force) {
+                output = "/* checksum : " + md5(output) + " */\n" + output;
+                return output;
+            }
+            else {
+                throw new Error(messages.FILE_MODIFIED);
+            }
+        }
+    }
+}
+
+async function _getResult(output, service, as, dest, force) {
+    let using, message, extension;
+    as = (as === "cds") ? "cdl" : as;
+
+    if (!common.supportedFormats().includes(extension = dest.substring(dest.lastIndexOf(".") + 1))) {
+        // dest doesn't have any file extension, so get it
+        extension = common.getSuffix(as);
+    } 
+
+    dest = dest.replace('.' + extension, '');
+    using = `using { ${service} as external } from './${path.relative('srv', dest).replace(/\\/g, '/')}'`;
+    using = require('../lib/util/term').info(using);    
+    message = `[cds] - imported API to ${path.relative(cwd, dest)}
 > use it in your CDS models through the like of:
 
 ${using}
-`) // Please keep the newline above! -> it's intentional
+`;
+
+    dest += '.' + extension;
+
+    if (as && as != "csn" && as != "json") {
+        // cdsCompiler[as] will convert the csn output into various output formats
+        output = cdsCompiler[as](output);
+    }
+
+    switch(as) {
+        case "cdl":
+            output = await _generateChecksumValidate(dest, output, force);
+            break;
+        case undefined:
+        case "csn":
+        case "json":
+            output = JSON.stringify(output, null, '  ');
+            break;
+        default:
+            break;
+    }
+
+    return [output, dest, message];
+}
+
+async function _write(output, dest, message) {
+    await edm2csn.saveCSNModel(output, dest);
+    console.log(message);
 }
 
 async function _copy_to_srv_external(file, dst) {
@@ -100,17 +205,14 @@ function _service_name_from(csn) {
     }
 }
 
-async function _update_package_json(dest, csn, version) {
+async function _update_package_json(dest, service, version) {
     const package_json = path.resolve(cwd, 'package.json')
     const conf = await exists(package_json) ? require(package_json) : {}
-    const service = _service_name_from(csn)
     const requires = ['cds', 'requires'].reduce((p, n) => p[n] || (p[n] = {}), conf)
     if (!requires[service]) {
-        if (dest.endsWith(".json")) dest = dest.replace(/\.json$/, '').replace(/\\/g, '/');
-        else dest = dest.replace(/\.csn$/, '').replace(/\\/g, '/');
         const model = path.relative(cwd, dest)
         cds.env.requires[service] = requires[service] = { kind: (version === "V2") ? 'odata-v2' : 'odata', model }
         await write(package_json, JSON.stringify(conf, null, '  '))
         console.log(`[cds] - updated ./package.json`)
     }
-}
+}