@sap/cds-dk 7.8.2 → 7.9.2

package/bin/completion/index.js

@@ -0,0 +1,212 @@
+const path = require('node:path');
+
+const cds = require('../../bin/cds');
+const { bold } = require('../../lib/util/term');
+
+const SUPPORTED_SHELLS = ['bash', 'gitbash', 'zsh', 'ps']
+
+module.exports = Object.assign(completion, {
+    handleCompletion,
+    options: ['--shell', '--curr', '--line', '--prev'],
+    shortcuts: ['-s'],
+    flags: ['--add', '--profile', '--remove'],
+    help: `
+# SYNOPSIS
+
+    -- beta feature --
+
+    *cds completion* <options>
+
+    Adds or removes shell completion for cds commands. Currently supported shells:
+        bash, Git Bash, zsh, and PowerShell.
+
+    Depending on the operating system and the shell type, the following files will be changed:
+        Linux, WSL
+            bash: ~/.bashrc
+            zsh: ~/.zshrc
+        macOS
+            bash: ~/.bash_profile
+            zsh: ~/.zshrc
+        Windows
+            PowerShell: $PROFILE
+            Git Bash: ~/.bash_profile
+
+    This command also acts as an internal completion handler for the shell completion scripts.
+
+# OPTIONS
+
+     *--add*
+        Add shell completion for cds commands (see examples).
+
+    *--remove*
+        Remove shell completion for cds commands (see examples).
+
+    *--shell* <bash | gitbash | ps | zsh>
+        Force the shell completion code to be added to the correct shell profile file.
+            bash: macOS, Linux, WSL
+            zsh: macOS, Linux, WSL
+            gitbash: Git Bash for Windows
+            ps: PowerShell
+
+# EXAMPLES
+
+   *cds* completion --add                   # Add shell completion for cds commands
+   *cds* completion --remove                # Remove shell completion for cds commands
+   *cds* completion --add --shell bash      # Add shell completion for cds commands and enforce using bash shell
+
+# ALIASES
+
+   *cds* add completion                     # Add shell completion for cds commands
+   *cds* add completion --shell bash        # Add shell completion for cds commands and enforce using bash shell
+
+`});
+
+function getScriptFile(shell) {
+    switch (shell) {
+        case 'bash':
+        case 'gitbash':
+            return 'cds-bash.sh'
+        case 'ps':
+            return 'cds-ps.ps1'
+        case 'zsh':
+            return 'cds-zsh.sh'
+        case '':
+        case undefined:
+        case null:
+            throw 'Internal error: option --shell is missing';
+        default:
+            throw `Internal error: unsupported shell: ${shell}`;
+    }
+}
+
+async function completion(_argv, options) {
+    if (options.profile) {
+        const scriptFile = getScriptFile(options.shell);
+        return console.log(path.join(__dirname, 'scripts', scriptFile));
+    }
+
+    if (options.add || options.remove) {
+        const completionSetup = require('../../lib/init/template/completion/completionSetup');
+        await completionSetup.setup(options.add, options);
+        return;
+    }
+
+    // workaround to parse complex clis containing -- as part of value,
+    // e.g. cds completion --line "cds add --"
+    const localArgv = process.argv.slice(3);
+    const localOptions = {}
+    for (let i = 0; i < localArgv.length; i++) {
+        localOptions[localArgv[i].replaceAll('-', '')] = localArgv[++i];
+    }
+
+    if (localOptions.curr === undefined || localOptions.prev === undefined || localOptions.line === undefined) {
+        throw `Some information is missing. Please run ${bold('cds help completion')} for details on how to call this command.`;
+    }
+
+    const shell = localOptions.shell;
+    if (!SUPPORTED_SHELLS.includes(shell)) {
+        throw `internal Error: no completion handler found for type: ${shell}`;
+    }
+
+    const currentWord = localOptions.curr;
+    const previousWord = localOptions.prev;
+    const line = localOptions.line;
+    const segments = getSegments(line);
+    const cdsCmd = segments[1] || '';
+
+    let completions = await getCompletions(cdsCmd, previousWord, currentWord, segments);
+    if (currentWord && shell === 'ps') {
+        completions = completions.filter(v => v?.startsWith(currentWord));
+    }
+
+    reply(completions);
+}
+
+async function handleCompletion(currentWord, previousWord, argv, _util) {
+    const allOptionsFlags = ['--add', '--remove', '--shell']
+        .filter(e => !argv.includes(e));
+
+    if (currentWord?.startsWith('-')) {
+        return allOptionsFlags;
+    }
+
+    if (previousWord === '--shell') {
+        return ['bash', 'gitbash', 'ps', 'zsh'];
+    }
+
+    return allOptionsFlags;
+}
+
+function reply(values) {
+    if (!Array.isArray(values) || values.length === 0) {
+        return;
+    }
+
+    values = values.filter(e => !!(typeof e === 'string' && e.trim()));
+    values = [...new Set(values)];
+    values.sort((a, b) => {
+        if (a.startsWith('-') && !b.startsWith('-')) { return 1; }
+        if (!a.startsWith('-') && b.startsWith('-')) { return -1; }
+        return a.localeCompare(b);
+    });
+
+    console.log(values.join('\n'));
+}
+
+function getSegments(line) {
+    const cliSplit = /'(.*?)'|"(.*?)"|(\\,|\\ |[^, ])+/gs;
+    const result = line.match(cliSplit);
+    return result.map(s =>
+        s.trim()
+            .replace(/(\\ )/g, ' ')
+            .replace(/^["']|["']$/g, '')
+    );
+}
+
+function getCdsCmd(cdsCmd) {
+    cdsCmd = cds.Shortcuts?.[cdsCmd] ?? cdsCmd;
+    return cds.load(cdsCmd);
+}
+
+function getAllOptions(cdsCmdObj, segments) {
+    return [
+        ...cdsCmdObj.options ?? [],
+        ...cdsCmdObj.flags?.filter(o => !segments.includes(o)) ?? []
+    ];
+}
+
+function getUtil() {
+    const completionFs = require('./completionFs');
+    return {
+        cds,
+        completionFs
+    }
+}
+
+async function getCompletions(cdsCmd, previousWord, currentWord, segments) {
+    if (cdsCmd === currentWord) {
+        return cds.cmds;
+    }
+
+    try {
+        const cdsCmdObj = getCdsCmd(cdsCmd);
+        if (typeof cdsCmdObj.handleCompletion === 'function') {
+            return await cdsCmdObj.handleCompletion(currentWord, previousWord, segments, getUtil());
+        }
+
+        if (currentWord?.startsWith('-')) {
+            return getAllOptions(cdsCmdObj, segments);
+        }
+
+        const completionFs = require('./completionFs');
+        const all = await completionFs.readdir(currentWord);
+        if (!(cdsCmdObj.options?.includes(previousWord) || cdsCmdObj.shortcuts?.includes(previousWord))) {
+            const allOptions = getAllOptions(cdsCmdObj, segments);
+            all.push(...allOptions);
+        }
+
+        return all;
+    } catch (err) {
+        return [];
+    }
+}

package/bin/completion/scripts/cds-bash.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+CDS_COMMAND="cds"
+
+_completeCds()
+{
+    local current options previous
+    COMPREPLY=()
+    current="${COMP_WORDS[COMP_CWORD]}"
+    previous="${COMP_WORDS[COMP_CWORD - 1]}"
+    options=$($CDS_COMMAND completion --shell bash --prev "$previous" --curr "$current" --line "${COMP_WORDS[*]}")
+    COMPREPLY=( $(compgen -W "${options}" -- ${current}) )
+    compopt -o nosort -o nospace
+    return 0
+}
+
+complete -F _completeCds $CDS_COMMAND

package/bin/completion/scripts/cds-ps.ps1

@@ -0,0 +1,18 @@
+$COMMAND = "cds"
+
+Register-ArgumentCompleter -Native -CommandName $COMMAND -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $cmdSegments = $commandAst.CommandElements
+    $idx = $cmdSegments.IndexOf(($cmdSegments | Where-Object { $_.Extent.Text -eq $wordToComplete }))
+    if ($idx -gt 0) {
+        $previousWord = $cmdSegments[$idx - 1].Extent.Text
+    } else {
+        $previousWord = $cmdSegments[$cmdSegments.Count - 1].Extent.Text
+    }
+
+    $options = & $COMMAND completion --shell ps --prev "$previousWord" --curr "$wordToComplete" --line "$commandAst"
+    foreach ($option in $options) {
+        [System.Management.Automation.CompletionResult]::new($option, $option, 'ParameterValue', $option)
+    }
+}

package/bin/completion/scripts/cds-zsh.sh

@@ -0,0 +1,12 @@
+#!/bin/zsh
+
+# compinit is required but added to ~/.zshrc so user can remove it if it is already loaded
+# autoload -Uz compinit && compinit
+
+CDS_COMMAND="cds"
+
+_completeCds() {
+    compadd -S '' -V 'force no sort' -- `${CDS_COMMAND} completion --shell zsh --prev "${words[CURRENT-1]}" --curr "${words[CURRENT]}" --line "${words}"`
+}
+
+compdef _completeCds ${CDS_COMMAND}

package/bin/help.js

@@ -1,7 +1,7 @@
 const cds = require('../lib/cds')
 
 /* eslint-disable no-console */
-module.exports = exports = Object.assign (help, {formatHelp, help:`
+module.exports = exports = Object.assign (help, {formatHelp, handleCompletion, help:`
 # USAGE
 
     *cds* <command> [<args>]
@@ -32,13 +32,19 @@ module.exports = exports = Object.assign (help, {formatHelp, help:`
     * * | *push*        push extension to extensible SaaS app
     *t* | *lint*        run linter for env or model checks [beta]
     *v* | *version*     get detailed version information
+    * * | *completion*  add/remove cli completion for cds commands
     *?* | *help*        get detailed usage information
 
   Learn more about each command using:
   *cds help* <command> or
   *cds* <command> *--help*
 
-`})
+`});
+
+async function handleCompletion(_currentWord, _previousWord, _argv, _util) {
+  const cds = require('./cds');
+  return Object.values(cds.cmds);
+}
 
 async function help (topic) {
   await cds.plugins

package/bin/init.js

@@ -1,10 +1,13 @@
-const { URLS } = require('../lib/init/constants')
+const { URLS } = require('../lib/init/constants');
+
+const currentOptions = ['--add', '--java:mvn', '--java:package', '--lint:custom', '--lint:custom:example'];
 const legacyOptions = ['--db-technology', '--insecure', '--java-package', '--modules',
     '--mta', '--odata-version', '--pipeline', '--skip-install', '--skip-sample-models',
     '--srv-memory', '--srv-technology']
 
 module.exports = Object.assign(init, {
-    options: ['--add', '--java:mvn', '--java:package', '--lint:custom', '--lint:custom:example', ...legacyOptions],
+    handleCompletion,
+    options: [...currentOptions, ...legacyOptions],
     shortcuts: [],
     flags: ['--force', '--verbose'],
     help: `
@@ -96,7 +99,34 @@ module.exports = Object.assign(init, {
 
 `})
 
-async function init (args) {
+async function handleCompletion(currentWord, previousWord, argv, util) {
+    const allOptionsFlags = [
+        ...currentOptions ?? [],
+        ...init.flags ?? []
+    ].filter(e => !argv.includes(e));
+
+    if (currentWord?.startsWith('-')) {
+        return allOptionsFlags;
+    }
+
+    if (previousWord === '--add') {
+        return util.completionFs.readTemplates(argv);
+    }
+
+    if (previousWord === '--java:package') {
+        const excludes = ['_merging'];
+        return (await util.completionFs.readdir(currentWord, { files: false }))
+            .filter(e => !excludes.includes(e));
+    }
+
+    if (!currentWord && init.options?.includes(previousWord)) {
+        return [];
+    }
+
+    return allOptionsFlags;
+}
+
+async function init(args) {
     if (process.argv.some(a => legacyOptions.includes(a))) return _showWarningMessage()
     const CDSGenerator = require('../lib/init')
     const generator = new CDSGenerator()
@@ -104,7 +134,7 @@ async function init (args) {
 }
 
 
-function _showWarningMessage () {
+function _showWarningMessage() {
 
     const message = `
   ************************************************

package/bin/subscribe.js

@@ -1,6 +1,6 @@
 module.exports = Object.assign(subscribe, {
     init: cmd => new (require('../lib/mtx/tenant_action'))(cmd),
-    options: ['--to', '--user'],
+    options: ['--to', '--user', '--body'],
     flags: ['--local', '--resolve-bindings'],
     shortcuts: ['-2', '-u', '-l', '-b'],
     help: `
@@ -39,6 +39,10 @@ module.exports = Object.assign(subscribe, {
 
         Resolve remote service bindings configured via *cds bind*.
 
+    --body
+
+        JSON object to be sent as the body of the subscription request.
+
 
 # SEE ALSO
 

package/bin/watch.js

@@ -70,7 +70,9 @@ const ignore = RegExp(
     `(webapp|dist|target)\\${sep}|` +
     `tsconfig\\.json$|` +
     `.*\\.tsbuildinfo$` +
-  ')'
+  ')' +
+  `|package-lock\\.json$` +
+  `|\\${sep}gen\\${sep}`
 )
 
 async function watch ([cwd], {
@@ -138,7 +140,7 @@ async function watch ([cwd], {
 
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
-    script: resolve(__dirname,'watched'), cwd, env, ext, ignore,
+    script: resolve(__dirname,'../lib/watch/watched'), cwd, env, ext, ignore,
     delay,
     options
   }).on('restart', (files)=>{

package/lib/bind/KubernetesApiAccessor.js

@@ -1,5 +1,6 @@
 const yaml = require('@sap/cds-foss')('yaml');
 const { exec } = require('../util/exec');
+const { bold } = require('../util/term');
 
 class KubernetesApiAccessor {
 
@@ -15,7 +16,7 @@ class KubernetesApiAccessor {
             if (!currentContextEntry) throw new Error(`Current context not found in kubectl config.`);
             const currentContext = currentContextEntry.context;
             const clusterEntry = config.clusters && config.clusters.find( entry => entry.name === currentContext.cluster && entry.cluster && entry.cluster.server );
-            if (!currentContextEntry) throw new Error(`Cluster ${currentContext.cluster} not found in kubectl config.`);
+            if (!currentContextEntry) throw new Error(`Cluster ${bold(currentContext.cluster)} not found in kubectl config.`);
             const { cluster } = clusterEntry;
 
             const serverToContext = {};
@@ -41,7 +42,7 @@ class KubernetesApiAccessor {
         let contextEntry;
 
         if (cluster && cluster !== config.cluster.server) {
-            contextEntry = config.serverToContext[cluster] || throwError(`Cluster ${cluster} not found in kubectl configuration`);
+            contextEntry = config.serverToContext[cluster] || throwError(`Cluster ${bold(cluster)} not found in kubectl configuration`);
         } else {
             contextEntry = config.context;
         }

package/lib/bind/bindingResolver.js

@@ -1,6 +1,7 @@
 const cds = require('../cds');
 const path = require('path');
 const { platformText, bindingText, logger } = require('./bindingUtil');
+const { bold } = require('../util/term');
 
 class BindingResolver {
     getUnresolvedBindings({ cwd = process.cwd(), env } = {}) {
@@ -25,18 +26,21 @@ class BindingResolver {
 
         const resolvedBindings = {}
 
-        await Promise.all(Object.keys(bindings).map(async name => {
+        // Serialized because of parallelization issues in the cf CLI,
+        // see https://github.com/cloudfoundry/cli/issues/2232
+        // await Promise.all(Object.keys(bindings).map(async name => {
+        for (const name of Object.keys(bindings)) {
             const binding = bindings[name]
             const cacheKey = JSON.stringify(binding)
             let resolvedBinding
             if (!cache[cacheKey]) {
                 resolvedBinding = cache[cacheKey] = await this.resolveBinding(name, binding)
-                logger.log(`bound ${name} to ${platformText(binding)} ${bindingText(binding)}`)
+                logger.log(`bound ${bold(name)} to ${platformText(binding)} ${bindingText(binding)}`)
             } else {
                 resolvedBinding = cache[cacheKey]
             }
             resolvedBindings[name] = resolvedBinding
-        }))
+        }
         return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
     }
 
@@ -44,7 +48,7 @@ class BindingResolver {
         switch (binding.type) {
             case 'cf': return require('./cfKeyProvider').resolve(name, binding)
             case 'k8s': return require('./kubernetesCredentialsProvider').resolve(name, binding)
-            default: throw new Error(`Unsupported binding type "${binding.type}" for service "${name}".`)
+            default: throw new Error(`Unsupported binding type ${bold(binding.type)} for service ${bold(name)}.`)
         }
     }
 }

package/lib/bind/bindingUtil.js

@@ -1,3 +1,4 @@
+const { bold } = require('../util/term');
 
 const KindToRequiresNameMap = {
     xsuaa: 'auth', // REVISIT: remove with ^8
@@ -15,11 +16,12 @@ const KindToRequiresNameMap = {
     'enterprise-messaging-amqp': 'messaging',
     'enterprise-messaging-http': 'messaging',
     'enterprise-messaging-shared': 'messaging',
+    'redis-messaging': 'messaging',
     'multitenancy': 'multitenancy'
 }
 
 const PreferredKinds = {
-    multitenancy:1, 'hana-cloud':1, xsuaa:1, 'xsuaa-auth':1, 'ias-auth':1, 'saas-registry':1
+    multitenancy: 1, 'hana-cloud': 1, xsuaa: 1, 'xsuaa-auth': 1, 'ias-auth': 1, 'saas-registry': 1
 };
 
 const PLATFORM_TYPES = {
@@ -30,7 +32,7 @@ const PLATFORM_TYPES = {
 class BindingUtil {
     static getRequiresNameFromKind(service, kind) {
         const requiresName = KindToRequiresNameMap[kind];
-        if (!requiresName) throw new Error(`Unknown CDS service name for service "${service}". Please specify as argument for "cds bind".`)
+        if (!requiresName) throw new Error(`Unknown CDS service name for service ${bold(service)}. Please specify as argument for ${bold('cds bind')}.`)
         return requiresName;
     }
 
@@ -98,23 +100,23 @@ class BindingUtil {
     }
 
     static platformText(binding) {
-        if (!PLATFORM_TYPES[binding.type]) throw new Error(`Unexpected binding type "${binding.type}"`);
+        if (!PLATFORM_TYPES[binding.type]) throw new Error(`Unexpected binding type ${bold(binding.type)}.`);
         return PLATFORM_TYPES[binding.type]
     }
 
-    static bindingText(binding, highlight = t => t) {
+    static bindingText(binding) {
         switch (binding.type) {
             case 'cf':
                 if (binding.key) {
-                    return `managed service ${highlight(binding.instance + ':' + binding.key)}`
+                    return `managed service ${bold(binding.instance + ':' + binding.key)}`
                 } else {
-                    return `user provided service ${highlight(binding.instance)}`
+                    return `user provided service ${bold(binding.instance)}`
                 }
             case 'k8s':
                 if (binding.name) {
-                    return `service binding ${highlight(binding.name)}`
+                    return `service binding ${bold(binding.name)}`
                 } else {
-                    return `secret ${highlight(binding.secret)}`
+                    return `secret ${bold(binding.secret)}`
                 }
             default:
                 throw new Error('Internal Error');