@sap/cds-dk 7.8.1 → 7.9.1

package/bin/add.js

@@ -23,6 +23,7 @@ const flags = ['--force', ...Object.values(conf).flatMap(p => p.flags).map(o =>
 DEBUG?.('cli config ', { options, shortcuts, flags })
 
 module.exports = Object.assign(add, {
+  handleCompletion,
   options,
   shortcuts,
   flags,
@@ -98,18 +99,18 @@ module.exports = Object.assign(add, {
 # FEATURE OPTIONS
 
 ${Object.entries(conf).sort(([a], [b]) => a.localeCompare(b)).flatMap(([pluginName, { options, flags }]) => {
-  const text4 = arr => arr.map(({ key, help, short }) => help && `      ${key}${short ? ' | '+short : ''}\n\n        ${help}`).join('\n\n')
-  const optionsText = text4(options), flagsText = text4(flags)
-  if (!optionsText && !flagsText) return []
-  return `    *cds add ${pluginName}*\n\n${optionsText}${flagsText}`
-}).join('\n\n\n')}
+    const text4 = arr => arr.map(({ key, help, short }) => help && `      ${key}${short ? ' | '+short : ''}\n\n        ${help}`).join('\n\n')
+    const optionsText = text4(options), flagsText = text4(flags)
+    if (!optionsText && !flagsText) return []
+    return `    *cds add ${pluginName}*\n\n${optionsText}${flagsText}`
+  }).join('\n\n\n')}
 
 
 # EXAMPLES
 
     *cds add* sample
     *cds add* multitenancy,hana,xsuaa --for production
-    *cds add* data --data:for my.namespace.MyEntity
+    *cds add* data --filter my.namespace.MyEntity
     *cds add* mta
     *cds add* helm
 
@@ -118,7 +119,27 @@ ${Object.entries(conf).sort(([a], [b]) => a.localeCompare(b)).flatMap(([pluginNa
 
   *cds init*
 
-`})
+`});
+
+async function handleCompletion(currentWord, previousWord, argv, util) {
+  const allOptionsFlags = [
+    ...options ?? [],
+    ...flags ?? []
+  ].filter(e => !argv.includes(e));
+
+  if (currentWord?.startsWith('-')) {
+    return allOptionsFlags;
+  }
+
+  if (!currentWord && options?.includes(previousWord)) {
+    return [];
+  }
+
+  const entries = await util.completionFs.readTemplates(argv);
+  entries.push(...allOptionsFlags);
+
+  return entries;
+}
 
 async function add(args) {
   // await cds.plugins

package/bin/bind.js

@@ -1,9 +1,9 @@
-const { warn } = require('../lib/util/term')
+const term = require('../lib/util/term')
 
 module.exports = Object.assign(cds_bind, {
-    options: ['--to', '--for', '--on', '--kind', '--out', '--to-app-services', '--no-create-service-key', '--output-file'],
-    flags: ['--exec'],
-    shortcuts: ['-2', '-4', '-n', '-k', '-o', '-a'],
+    options: ['--to', '--for', '--on', '--kind', '--out', '--to-app-services', '--credentials', '--output-file'],
+    flags: ['--exec', '--no-create-service-key'],
+    shortcuts: ['-2', '-4', '-n', '-k', '-o', '-a', '-c'],
     help: `
 # SYNOPSIS
 
@@ -52,6 +52,11 @@ module.exports = Object.assign(cds_bind, {
 
         Skip automatic creation of service keys.
 
+    *-c | --credentials* <JSON|{file path}> (Beta)
+
+        JSON or file path defining custom fields overwriting service credentials.
+        Custom credentials are merged with the credentials read from BTP when running your application in hybrid mode.
+
 # EXAMPLE
 
     cds bind --to bookshop-db
@@ -64,72 +69,110 @@ module.exports = Object.assign(cds_bind, {
     cds bind --to bookshop-db --for my-profile
 
     cds bind --to-app-services bookshop-srv
+
+    cds bind messaging --to redis-cache --credentials '{"host":"localhost","port":6379}'
+    cds bind messaging --to redis-cache --credentials ./credentials.json
 `
 });
 
 const os = require('os');
 const IS_WIN = os.platform() === 'win32';
 
-const { bind, parseProfile } = require('../lib/bind');
+const { bind, storeBindings, parseProfile } = require('../lib/bind');
 
 
 async function cds_bind(args, options) {
-
-    const { on, 'to-app-services': app, to, out, 'output-file': outputFile, exec } = options
+    const { on, 'to-app-services': app, to, out, 'output-file': outputFile, exec, credentials } = options
 
     if (exec) {
         process.env.CDS_ENV = parseProfile(process.env.CDS_ENV);
         if (options.for) {
-            console.warn('Parameter --for is not supported in combination with --exec. Its value will be ignored.');
+            console.warn(term.warn(`Parameter --for is not supported in combination with --exec. Its value will be ignored.`));
         }
         return cds_bind_exec(args)
     }
 
     // Check if cds command was bind. Don't abort in case of deploy
     if (process.env.CDS_ENV && process.argv[2] === 'bind') {
-        throw 'Option --profile is no longer supported. Use --for instead to specify the profile to use when storing connection settings.';
+        throw `Option ${term.bold('--profile')} is no longer supported. Use ${term.bold('--for')} instead to specify the profile to use when storing connection settings.`;
     }
 
     if (outputFile) {
-        console.warn(warn('Option --output-file is deprecated. Please use --out instead.'))
+        console.warn(term.warn(`Option --output-file is deprecated. Please use --out instead.`))
         options.out ??= outputFile
     }
 
     if (on === 'k8s' && app) {
-        throw 'Option --to-app-services is only supported for Cloud Foundry.';
+        throw `Option ${term.bold('--to-app-services')} is only supported for Cloud Foundry.`;
+    }
+
+    if (credentials === true) {
+        throw `Option ${term.bold('--credentials')} requires a JSON object or a file path.`;
+    }
+
+    // read credentials from file if it is a file, from JSON if it is JSON
+    if (credentials) {
+        let credentialsJson = options.credentials;
+        if (!credentials.trim().startsWith('{')) {
+            const fs = require('fs');
+            try {
+                credentialsJson = fs.readFileSync(credentials, 'utf8');
+            } catch (e) {
+                throw `Error reading credentials from file ${credentials}: ${e.message}`
+            }
+        }
+        try {
+            options.credentials = JSON.parse(credentialsJson);
+        } catch (e) {
+            throw `Invalid JSON format for option ${term.bold('--credentials')}: ${e.message}`;
+        }
+        if (options.to) {
+            //at least one service must match
+            const toServices = options.to.split(',');
+            if (toServices.length > 1) {
+                if (!toServices.some(toService => options.credentials[toService])) {
+                    throw `Option ${term.bold('--credentials')} cannot uniquely identify a matching service defined in ${term.bold('--to')}.\nWhen passing multiple services, include the service name in the credentials object.\nExample: cds bind --to bookshop-db,bookshop-redis --credentials '{ "bookshop-redis": {"host": "localhost", "port": 1234}}'`
+                }
+            }
+        }
     }
 
     if (!to && !app) {
-        throw `Use option --to or -2 to specify the target instance, e.g. cds bind --to myInstance:myService`;
+        throw `Use option ${term.bold('--to')} or ${term.bold('-2')} to specify the target instance, e.g. ${term.bold('cds bind --to myInstance:myService')}`;
     }
 
     if (app === true) {
-        throw `Option '--to-app-services' requires an app name, for example 'cds bind --to-app-services bookshop-srv'.`
+        throw `Option ${term.bold('--to-app-services')} requires an app name, for example ${term.bold('cds bind --to-app-services bookshop-srv')}.`
     }
 
+    options.for ??= 'hybrid';
+
     if (app) {
         const services = await require('../lib/util/cf').getServices(app)
-        // Later: optimize logging for parallelization, services.forEach(service => bind({ ...options, to: service.name, outputFile }))
-        for (const service of services.filter(s => Object.keys(s.credentials).length > 0)) {
-            await bind({ ...options, to: service.name, out })
-        }
+        const allServices = await Promise.all(
+            services
+                .filter(s => Object.keys(s.credentials).length > 0)
+                .map(s => bind({ ...options, to: s.name, out }))
+        )
+        await storeBindings(allServices.flat(), options);
     } else {
         if (args.length > 1) {
-            throw `Too many arguments: Please specify only one or no service.`;
+            throw 'Too many arguments: Please specify only one or no service.';
         }
 
         options.serviceArg = args[0]
         options.targets = options.to.split(/,/g);
 
         if (options.targets.length >= 2 && options.serviceArg) {
-            throw `Service argument cannot be specified together with multiple targets ('--to') services. Use one service per call or omit the service argument.`;
+            throw `Service argument cannot be specified together with multiple targets (${term.bold('--to')}) services. Use one service per call or omit the service argument.`;
         }
 
         if (options.targets.length >= 2 && options.kind) {
-            throw `The option '--kind' cannot be specified together with multiple targets ('--to') services. Use one service per call or omit the '--kind' option.`;
+            throw `The option '--kind' cannot be specified together with multiple targets (${term.bold('--to')}) services. Use one service per call or omit the ${term.bold('--kind')} option.`;
         }
 
-        await bind({ ...options, out });
+        const services = await bind({ ...options, out });
+        await storeBindings(services, options);
     }
 }
 

package/bin/build.js

@@ -1,4 +1,5 @@
 module.exports = Object.assign(build, {
+    handleCompletion,
     options: ['--project', '--src', '--dest', '--for', '--use', '--opts', '--log-level', '--options-model'],
     shortcuts: ['-in', '-s', '-o', '-4'],
     flags: ['--clean', '--no-clean', '--ws', '--ws-pack'], // REVISIT: --clean is deprecated, backward compatibility
@@ -67,7 +68,7 @@ module.exports = Object.assign(build, {
     *-in | --project* [<project>]
         Runs 'cds build' for the specified project, default is current working
         directory.
-        
+
     *--no-clean* (beta)
         Skips cleaning the build output folder before running the actual build
         operation. Clients need to clean the output folder upfront to ensure
@@ -92,7 +93,7 @@ module.exports = Object.assign(build, {
         folder of the project. This 'db' folder represents the single database shared by all workspaces.
         *Note:* Make sure to use consistent package versions in your workspace dependencies in order
         to avoid compilation errors caused by duplicate model definitions.
-        
+
 # EXAMPLES
 
    *cds* build
@@ -102,10 +103,41 @@ module.exports = Object.assign(build, {
    *cds* build --for java --dest ../srv/target --opts model=[db/model,srv,schema]
 `})
 
+async function handleCompletion(currentWord, previousWord, argv, util) {
+    const allOptionsFlags = [
+        ...build.options ?? [],
+        ...build.flags ?? []
+    ].filter(e => !argv.includes(e));
+
+    if (currentWord?.startsWith('-')) {
+        return allOptionsFlags;
+    }
+
+    switch (previousWord) {
+        case '--log-level':
+            return ['debug', 'info', 'warn', 'error'];
+        case '-4':
+        case '--for':
+            return ['hana', 'java', 'mtx', 'mtx-extension', 'mtx-sidecar', 'nodejs'];
+        case '--dest':
+        case '-o':
+        case '-s':
+        case '--src': {
+            return util.completionFs.readdir(currentWord, { files: false });
+        }
+    }
+
+    if (!currentWord && build.options?.includes(previousWord)) {
+        return [];
+    }
+
+    return allOptionsFlags;
+}
+
 async function build([project], options = {}) {
     const path = require('path')
 
-    // ensure that cds build plugins defined as devDependencies are loaded 
+    // ensure that cds build plugins defined as devDependencies are loaded
     if (process.env.NODE_ENV === 'production') delete process.env.NODE_ENV
 
     const cds = require('../lib/cds')

package/bin/cds.js

@@ -34,6 +34,14 @@ const cli = {
     DEBUG?.(`[cds] - @sap/cds ${cds.version} loaded: ${cds.home}`)
 
     try {
+      const allCmds = getCommands();
+
+      //TODO: make better; only POC for cds help
+      Object.assign(module.exports, { cmds: allCmds })
+
+      // const { handleCompletion } = require('./util/completion');
+      // await handleCompletion(process.argv, allCmds, this);
+
       const task = this.load(cmd, /*else*/(f) => argv.unshift(cmd) && (cmd = 'compile') && _defaultCompile(argv, f))
       if (task) {
         // REVISIT bind: '--' handling for cds bind --exec. Should be moved to cds_cli
@@ -46,7 +54,7 @@ const cli = {
         // REVISIT: Have to do it here to allow custom flags for plugins!
         if (cmd === 'add') {
           await cds.plugins
-          for (const [_, Plugin] of cds.add.registered) {
+          for (const [, Plugin] of cds.add.registered) {
             task.options.push(...Object.keys((new Plugin).options()).map(key => '--'+key))
           }
         }
@@ -130,6 +138,7 @@ async function _resolveBindings(options) {
   const bindingEnv = await bindingManager.bindingEnv()
   Object.assign(process.env, bindingEnv)
   cds.env = cds.env.for('cds') // reload env // FIXME: This is too early!
+  cds.requires = cds.env.requires // REVISIT: We should clean this up!
 }
 
 function _local (id, _else) {
@@ -160,15 +169,7 @@ function _dieForUnknownCommand(cmd) {
 
   let bestMatchText = '';
 
-  const excludeList = ['cds.js', 'cds-ts.js', 'fix-redirects.js', 'util'];
-  const { readdirSync } = require('fs');
-  const { resolve } = require('path');
-  let commands = readdirSync(__dirname, { withFileTypes: true })
-    .concat(readdirSync(resolve(_local('@sap/cds'), '..', '..', 'bin'), { withFileTypes: true }))
-    .filter((f) => !excludeList.includes(f.name))
-    .map((f) => f.name.split('.')[0])
-  commands = [...new Set(commands)] // make unique
-    .sort();
+  const commands = getCommands();
 
   const bestMatches = fuzzySearch(cmd, commands, DEBUG);
 
@@ -192,9 +193,7 @@ function _dieForUnknownCommand(cmd) {
 
   You can use ${term.bold("cds help [command]")} to get more information on the command.
 `
-  console.error(msg)
-
-  process.exit(1)
+  throw msg;
 }
 
 function _require (id,o) {
@@ -211,4 +210,24 @@ module.exports = Object.assign ((..._) => cli.exec(..._), cli)
 
 if (!module.parent)  module.exports()
 
+
+
+function getCommands() {
+  const fs = require('fs');
+  const path = require('path');
+
+  const excludeList = ['cds.js', 'cds-ts.js', 'fix-redirects.js'];
+
+  const files = fs.readdirSync(__dirname, { withFileTypes: true, encoding: 'utf8' })
+  const result = new Set()
+  for (const f of files) {
+    if (!excludeList.includes(f.name)) {
+      if (f.isDirectory() && fs.existsSync(path.join(__dirname, f.name, 'index.js')) || f.isFile() && f.name.endsWith('.js')) {
+        result.add(path.parse(f.name).name)
+      }
+    }
+  }
+  return Array.from(result).sort()
+}
+
 /* eslint no-console:off */

package/bin/compile/index.js

@@ -1,6 +1,7 @@
 const path = require("path");
 
 module.exports = Object.assign ( compile, {
+  handleCompletion,
   options: [
   '--from', '--service', '--lang', '--for', '--to', '--dest', '--log-level', '--flavor', '--dialect', '--sql-dialect', '--openapi:url', '--openapi:servers', '--odata-version'
   ],
@@ -53,13 +54,13 @@ module.exports = Object.assign ( compile, {
 
     - odata
     - sql
-    
+
   *--dialect* <dialect>
-    
+
     Needs option *--to*.
     Specify the dialect in combination with *--to sql*.
     Currently supported:
-    
+
     - sqlite
     - h2
     - postgres
@@ -147,6 +148,46 @@ module.exports = Object.assign ( compile, {
 
 `})
 
+async function handleCompletion(currentWord, previousWord, argv, util) {
+  const allOptionsFlags = [
+    ...compile.options ?? [],
+    ...compile.flags ?? []
+  ].filter(e => !argv.includes(e))
+
+  if (currentWord?.startsWith('-')) { return allOptionsFlags }
+
+  switch (previousWord) {
+    case '-2':
+    case '--to':
+      return ['json', 'yml', 'edm', 'edmx', 'edmx-v2', 'edmx-v4', 'sql', 'hdbcds', 'hdbtable', 'cdl', 'xsuaa', 'openapi', 'asyncapi'];
+    case '-4':
+    case '--for':
+      return ['odata', 'sql'];
+    case '--dialect':
+      return ['sqlite', 'h2', 'postgres', 'hana'];
+    case '--log-level':
+      return ['debug', 'info', 'warn', 'error'];
+    case '--odata-version':
+      return ['4.0', '4.01'];
+    case '-f':
+    case '--flavor':
+      return ['sources', 'files', 'parsed', 'xtended', 'inferred'];
+    case '-s':
+    case '--service':
+    case '-l':
+    case '--lang':
+      return ['all'];
+    case '-o':
+    case '--dest':
+      return util.completionFs.readdir(currentWord, { files: false })
+    default:
+  }
+
+  if (!currentWord && compile.options?.includes(previousWord)) { return [] }
+
+  return util.completionFs.readdir(currentWord, { fileRegex: /\.(cds|json)/ })
+}
+
 async function compile_all (root='.') {
 
   const {exec} = require ('child_process')

package/bin/completion/completionFs.js

@@ -0,0 +1,61 @@
+module.exports = new class CompletionFS {
+    async readdir(currentFolder, options) {
+        options = {
+            files: true,
+            folders: true,
+            fileRegex: /.*/,
+            folderRegex: /.*/,
+            ...options
+        }
+        const fsp = require('node:fs/promises');
+        const path = require('node:path');
+
+        const match = /\/|(\\)[^\s]/.exec(currentFolder);
+        const separationChar = match?.[1] || match?.[0] || '/';
+        let folder = currentFolder || process.cwd();
+
+        let entries;
+        try {
+            entries = await fsp.readdir(folder, { withFileTypes: true });
+        } catch (err) {
+            folder = path.dirname(folder);
+            entries = await fsp.readdir(folder, { withFileTypes: true });
+        }
+        const isCwd = folder === '.' || folder === process.cwd();
+
+        entries = entries
+            .filter(e =>
+                options.folders && e.isDirectory() && e.name.match(options.folderRegex)
+                || options.files && e.isFile() && e.name.match(options.fileRegex))
+            .map(e => {
+                let result = isCwd
+                    ? path.relative(folder, e.name)
+                    : (folder + separationChar + e.name).replace(/\\{2,}/g, '\\').replace(/\/{2,}/g, '/');
+
+                if (e.isDirectory()) {
+                    result += separationChar;
+                }
+
+                return result;
+            });
+
+        if (entries.length === 0) {
+            entries.push(folder);
+        }
+        return entries;
+    }
+
+    async readTemplates(argv) {
+        const fsp = require('node:fs/promises');
+        const path = require('node:path');
+
+        const excludes = ['nodejs', 'java', ...argv];
+
+        return (await fsp.readdir(path.join(__dirname, '../../lib/init/template'), { withFileTypes: true }))
+            .filter(e =>
+                e.isDirectory()
+                && !e.name.startsWith('_')
+                && !excludes.includes(e.name))
+            .map(e => e.name);
+    }
+}