@sap/cds-dk 6.8.3 → 7.0.0

package/bin/version.js

@@ -0,0 +1,124 @@
+/* eslint-disable no-console */
+const { join, resolve } = require ('path')
+const { execSync } = require('child_process')
+module.exports = Object.assign(list_versions, {
+  flags: [ '--info', '--markdown', '--all', '--npm-list', '--npm-tree', '--no-colors'],
+  shortcuts: [ '-i', '-m','-a', '-ls', '-ll' ],
+  info,
+  help: `
+# SYNOPSIS
+
+    *cds version* <options>
+    *cds -v* <option>
+
+    Prints the versions of all @sap/cds packages in your package dependencies.
+
+# OPTIONS
+
+    *-i  | --info*
+
+      Prints version information in a tabular markdown format, which you
+      can embed into your bug reports.
+
+    *-a  | --all*
+
+      Also lists sub-packages and optional dependencies.
+
+    *-ls | --npm-list* <pattern>
+    *-ll | --npm-tree* <pattern>
+
+      Prints an npm ls tree filtered to the specified pattern.
+      (default: '@sap/cds')
+
+`})
+
+const MISSING = '-- missing --'
+
+function list_versions(args, options) { //NOSONAR
+  if (options['npm-list'] || options['npm-tree']) {
+    let [pattern] = args, re = pattern ? RegExp(pattern) : /@sap\/cd[rs]|@sap\/eslint-plugin-cds/
+    let cmd = 'npm ls --depth ' + (options['npm-tree'] ? 11 : 0)
+    console.log (cmd,'| grep', pattern)
+    return require('child_process').exec(cmd, (e,stdout)=>{
+      // if (e) console.error(e)
+      const replacement = (options['no-colors'] ? '$1 $2$3$4' : '\x1b[91m$1 \x1b[32m$2\x1b[0m\x1b[2m$3\x1b[32m$4\x1b[0m');
+      for (let line of stdout.split(/\n/)) if (line.match(re)) console.log(
+        line.replace(/(@sap[^@]*)@([\S]+)( -> [\S]+)?(deduped)?/,replacement)
+      )
+    })
+  }
+  const versions = info ()
+  if (options.markdown)  return _markdown (versions)
+  if (options.info)  return _markdown (versions)
+  const mark = options['no-colors'] ? s => s : require('../lib/util/term').info
+  for (let each of Object.keys(versions).sort())  console.log(`${mark(each)}: ${versions[each]}`)
+}
+
+function info() {
+  const cwd = process.cwd()
+  const npmRoot = execSync('npm root -g').toString().trim()
+  return {
+    ..._versions_from(_pkg_path('@sap/cds-dk', __dirname), '@sap/cds-dk (global)'), // ... linked in cap/dev setup
+    ..._versions_from(_pkg_path('@sap/cds-dk', npmRoot),   '@sap/cds-dk (global)'), // ... or installed globally
+    ..._versions_from(_pkg_path('@sap/cds-dk', cwd)),    // local dk, important for Java projects
+    ..._versions_from(_pkg_path('@sap/cds', __dirname)), // @sap/cds from here
+    ..._versions_from(cwd),                              // ... or from local app dependencies
+    ..._versions_from(_pkg_path('@sap/cds-compiler', cwd, __dirname)), // compiler is no direct dependency, so list it explicitly
+    'Node.js': process.version,
+    'home': require('../lib/cds').home // effective (local) cds
+  }
+}
+
+function _versions_from(pkg_path, pkg_label) {
+  let pkg; try { pkg = require(join(pkg_path, 'package.json')) } catch { return {} }
+  let versions = {}
+  if (pkg.name)  versions[pkg_label || pkg.name] = pkg.version
+
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  for (let dep in deps) {
+    if (!dep.match(/@sap\/.*cds.*/) && !dep.startsWith('@cap-js/'))  continue
+    try {
+      const dep_path = require.resolve(join(dep, 'package.json'), {paths:[pkg_path]})
+      const dep_pkg = require(dep_path)
+      versions[dep_pkg.name] = dep_pkg.version
+    } catch (e) {
+      if (e.code !== 'MODULE_NOT_FOUND')  console.error(e)
+     }
+  }
+  return versions
+}
+
+function _markdown (versions) {
+  console.log()
+  const pkg = { name:'', repository:'', version:'' }; try {
+    Object.assign (pkg, require (resolve('package.json')))
+  } catch (e) {/* ignored */}
+  console.log ('|', pkg.name, '|', pkg.repository.url || pkg.repository, '|')
+  console.log ('|:---------------------- | ----------- |')
+  if (require('../lib').env['project-nature'] === 'nodejs') {
+    console.log ('|', v('Node.js'), '|')
+    console.log ('|', v('@sap/cds'), '|')
+  } else {
+    console.log ('|', v('CAP Java Runtime'), '|')
+  }
+  console.log ('|', v('@sap/cds-compiler'), '|')
+  console.log ('|', v('@sap/cds-dk'), '|')
+  console.log ('|', v('@sap/cds-dk (global)'), '|')
+  console.log ('|', v('@sap/eslint-plugin-cds'), '|')
+  console.log ('|', v('@sap/cds-mtxs'), '|')
+  function v (component) {
+    const version = versions [component] || MISSING
+    return (component + '               ').slice(0,22)
+    +' | '+ (version  + '           ').slice(0,11)
+  }
+  console.log()
+}
+
+function _pkg_path(id, ...paths) {
+  try {
+    const pk_path = require.resolve(join(id, 'package.json'), { paths })
+    return resolve(pk_path, '..')
+  } catch (e) {
+    if (e.code !== 'MODULE_NOT_FOUND')  throw e
+  }
+}

package/bin/watch.js

@@ -125,7 +125,7 @@ async function watch ([cwd], {
 
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
-    script:__filename, cwd, env, ext, includes, ignore,
+    script: resolve(__dirname,'watched'), cwd, env, ext, includes, ignore,
     delay: parseInt(process.env.CDS_WATCH_DELAY) || 200,
     options
   }).on('restart', (files)=>{
@@ -193,37 +193,3 @@ 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
-//
-
-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.watched = true
-
-  cds.once('listening', ({server}) => {
-    process.send ({ code:'listening', port: server.address().port })
-  })
-
-  try {
-    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: if (!e.messages) { // compiler messages have been written by cli already
-      console.error('\n❗️ ERROR on server start: ❗️\n\n', e)
-    }
-  }}
-  function _no_models_found(e) { console.log (`
-    No models found in ${cds.resolve(e.model||'*',false)}.
-    Waiting for some to arrive...
-  `)}
-  function _no_services_found() { console.log (`
-    No service definitions found in loaded models.
-    Waiting for some to arrive...
-  `)}
-})()

package/bin/watched.js

@@ -0,0 +1,39 @@
+//
+// Child process impl launched by cds watch
+// Extracted from watch.js to avoid cds.env loaded too eagerly
+//
+
+(async()=>{
+
+  // run through cli in order to use its error handling
+  const args = JSON.parse(process.env._args)
+  const bootstrap = require('./cds')(...args)
+  const {cds} = global; cds.watched = true
+
+  cds.once('listening', ({server}) => {
+    process.send ({ code:'listening', port: server.address().port })
+  })
+
+  try {
+    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: if (!e.messages) { // compiler messages have been written by cli already
+      console.error('\n❗️ ERROR on server start: ❗️\n\n', e)
+    }
+  }}
+
+  function _no_models_found(e) { console.log (`
+    No models found in ${cds.resolve(e.model||'*',false)}.
+    Waiting for some to arrive...
+  `)}
+
+  function _no_services_found() { console.log (`
+    No service definitions found in loaded models.
+    Waiting for some to arrive...
+  `)}
+
+})()

package/lib/bind/KubernetesApiAccessor.js

@@ -1,4 +1,4 @@
-const yaml = require("@sap/cds-foss")("yaml");
+const yaml = require('@sap/cds-foss')('yaml');
 const { exec } = require('../util/exec');
 
 class KubernetesApiAccessor {
@@ -9,7 +9,7 @@ class KubernetesApiAccessor {
             const configString = await exec({result: 'stdout'}) `kubectl config view --raw`;
             const config = yaml.parse(configString);
 
-            const currentContextName = config["current-context"];
+            const currentContextName = config['current-context'];
             if (!currentContextName) throw new Error(`No current context in kubectl config.`);
             const currentContextEntry = config.contexts && config.contexts.find( entry => entry.name === currentContextName && entry.context && entry.context.cluster && entry.context.user );
             if (!currentContextEntry) throw new Error(`Current context not found in kubectl config.`);

package/lib/bind/bindingManager.js

@@ -83,7 +83,7 @@ class BindingManager {
         }
 
         return services
-        }
+    }
 }
 
 module.exports = BindingManager

package/lib/bind/bindingUtil.js

@@ -1,5 +1,3 @@
-const os = require('os');
-const IS_WIN = os.platform() === 'win32';
 
 const KindToRequiresNameMap = {
     xsuaa: 'auth',
@@ -89,13 +87,6 @@ class BindingUtil {
         }
     }
 
-    static execAndExit(options, command, ...args) {
-        const { spawnSync } = require('child_process');
-        // use shell with Windows only; without output is not visible and some commands cannot be run
-        const result = spawnSync(command, args, { stdio: 'inherit', shell: IS_WIN, ...options });
-        process.exit(result.status);
-    }
-
     static async checkIsJavaProject(projectPath) {
         const { constants, promises: fsp } = require('fs');
         const path = require('path');

package/lib/bind/cfKeyProvider.js

@@ -1,89 +1,32 @@
-const cp = require('child_process');
-const fsp = require('fs').promises;
-const os = require('os');
-const util = require('util');
-
 const cds = require('../cds');
 const DEBUG = cds.debug('cli')
 
+const cfUtil = require('../util/cfUtil');
+
 const axios = require('axios');
 const { URL } = require('url');
-const path = require('path');
 const { bold, highlight } = require('../util/term');
 const { CliError } = require('../client/helper/errors');
 
-const execAsync = util.promisify(cp.exec);
-const IS_WIN = os.platform() === 'win32';
-
 class CFKeyProvider {
-    async _cfRead(...args) {
-        DEBUG?.(`_cfRead: cf ${args}`);
-
-        const result = await execAsync(`cf ${args}`, {
-            shell: IS_WIN,
-            stdio: ['inherit', 'pipe', 'inherit'],
-        });
-
-        return result.stdout.toString().trim();
-    }
-
-    extract(string, pattern, errorMsg) {
-        const match = string.match(pattern);
-        if (!match || !match[1]) {
-            throw new Error(errorMsg);
-        }
-        return match[1];
-    }
-
-    async getCfTargetFromConfigFile() {
-        const cfHome = process.env.CF_HOME || process.env.cf_home || path.join(os.homedir(), '.cf');
-        try {
-            const fileContent = await fsp.readFile(path.join(cfHome, 'config.json'));
-            const config = JSON.parse(fileContent);
-            if (config) {
-                return {
-                    apiEndpoint: this.extract(config.Target, /\s*(.+)\s*/, `CF API endpoint is missing. Use 'cf login' to login.`),
-                    org: this.extract(config.OrganizationFields.Name, /\s*(.+)\s*/, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
-                    space: this.extract(config.SpaceFields.Name, /\s*(.+)\s*/, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`)
-                }
-            }
-        } catch (err) {
-            DEBUG?.(`getCfTargetFromConfigFile: ${err}`);
-        }
-    }
-
-    async getCfTargetFromCli() {
-        const result = await this._cfRead('target');
-        return {
-            apiEndpoint: this.extract(result, /api endpoint\s*:\s*([^\s]+)/i, `CF API endpoint is missing. Use 'cf login' to login.`),
-            user: this.extract(result, /user\s*:\s*(.+)/i, `CF user is missing. Use 'cf login' to login.`),
-            org: this.extract(result, /org\s*:\s*(.+)/i, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
-            space: this.extract(result, /space\s*:\s*(.+)/i, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`),
-        };
-    }
-
-    async getCfTarget() {
-        return await this.getCfTargetFromConfigFile() || await this.getCfTargetFromCli();
-    }
-
     async getCfSpaceInfo() {
         DEBUG?.('getting space info');
 
-        const target = await this.getCfTarget();
-        const authorization = await this.getCfAuthorization();
+        const target = await cfUtil.getCfTarget();
+        const authorization = await cfUtil.getCfAuthorization();
         const targetWithAuth = Object.assign({}, target, { authorization });
 
 
         const { org, space } = target;
         const orgs = await BatchRequest.req(targetWithAuth, `/v3/organizations?names=${encodeURIComponent(encodeURIComponent(org))}`);
         if (!(orgs && orgs.resources.length === 1)) {
-            throw new Error(`CF org ${org} not found!`);
+            throw new CliError(`CF org ${org} not found!`);
         }
 
         const orgGuid = orgs.resources[0].guid;
         const spaces = await BatchRequest.req(targetWithAuth, `/v3/spaces?names=${encodeURIComponent(encodeURIComponent(space))}&organization_guids=${encodeURIComponent(encodeURIComponent(orgGuid))}`)
         if (!(spaces && spaces.resources.length === 1)) {
-            throw new Error(`CF space ${space} not found in org ${org}!`);
+            throw new CliError(`CF space ${space} not found in org ${org}!`);
         }
 
         const spaceGuid = spaces.resources[0].guid;
@@ -91,11 +34,6 @@ class CFKeyProvider {
         return Object.assign({}, target, { orgGuid, spaceGuid, authorization });
     }
 
-    async getCfAuthorization() {
-        DEBUG?.('getting authorization');
-        return this._cfRead('oauth-token');
-    }
-
     async init() {
         const target = this.target = await this.getCfSpaceInfo();
         this.getOrg = BatchRequest.create({ target, url: '/v3/organizations' });
@@ -142,7 +80,7 @@ class CFKeyProvider {
         try {
             instanceObj = await this.getInstance({ names: instance, space_guids: spaceGuid });
         } catch (error) {
-            throw new Error(`Service instance "${instance}" not found.`);
+            throw new CliError(`Service instance "${instance}" not found.`);
         }
         switch (instanceObj.type) {
             case 'managed':
@@ -150,7 +88,7 @@ class CFKeyProvider {
             case 'user-provided':
                 return this._resolveUserProvidedService(instanceObj, instance, org, space);
             default:
-                throw new Error(`Service type ${instanceObj.type} not supported`)
+                throw new CliError(`Service type ${instanceObj.type} not supported`)
         }
     }
 
@@ -285,9 +223,9 @@ class BatchRequest {
             if (filteredResources.length === 1) {
                 filter.resolve(filteredResources[0]);
             } else if (filteredResources.length === 0) {
-                filter.reject(new Error(`Couldn't find resource for url "${this.url}" with filter "${fmt(filter.filter)}"`));
+                filter.reject(new CliError(`Couldn't find resource for url "${this.url}" with filter "${fmt(filter.filter)}"`));
             } else {
-                filter.reject(new Error(`Found more than one resources for url "${this.url}" with filter "${fmt(filter.filter)}"`));
+                filter.reject(new CliError(`Found more than one resources for url "${this.url}" with filter "${fmt(filter.filter)}"`));
             }
         }
     }

package/lib/bind/index.js

@@ -0,0 +1,114 @@
+const cds = require('../cds');
+
+const { CliError } = require('../client/helper/errors');
+
+const BindingResolver = require('./bindingResolver');
+const { determineKinds, getRequiresNameFromKind, checkIsJavaProject, platformText, bindingText, logger } = require('./bindingUtil');
+const { highlight, bold, info } = require('../util/term');
+
+
+module.exports = { bind, parseProfile }
+
+/**
+ * Executes cds build in the directory defined by cds.root.
+ *
+ * @param {object} options - command options as defined by build command.
+ */
+async function bind(options) {
+    let on;
+    switch(options.on) {
+        case 'k8s':
+        case 'kubernetes':
+            on = 'k8s';
+            break;
+        case undefined:
+        case null:
+        case 'cf':
+        case 'cloudfoundry':
+            on = 'cf';
+            break;
+        default:
+            throw new CliError(`Invalid value '${options.on}' for option --on.`);
+    }
+
+    const onText = { 'cf': 'Cloud Foundry', 'k8s': 'Kubernetes' }[on];
+    logger.log(`Retrieving data from ${onText}...`);
+    let resolvedServices
+
+    const targets = options.to.split(/,/g);
+    try {
+        resolvedServices = await Promise.all(targets.map(async target => {
+            let binding;
+            if (on === 'k8s') {
+                binding = { type: on, name: target };
+            } else if (on === 'cf') {
+                const [instance, key] = target.split(/:/);
+                binding = { type: on, instance, key };
+            } else {
+                throw new Error('Internal Error');
+            }
+            const resolvedService = await BindingResolver.resolveBinding(undefined, binding);
+            resolvedService._target = target;
+            delete resolvedService.credentials;
+            resolvedService.binding.resolved = false;
+            return resolvedService;
+        }));
+    } catch (error) {
+        if (error.name === 'AxiosError') {
+            const errors = error.response?.data?.errors ?? []
+            const responseInfo = errors.map(e => `${e.title}: ${e.detail} (${e.code})`).join('  \n')
+            const requestInfo = error.request?.path
+            throw new Error(`${error.toString()}\nResponse: ${responseInfo}\nRequest:${requestInfo}}`)
+        }
+        throw error
+    }
+
+    if (options.kind) {
+        resolvedServices.forEach(service => service.kind = options.kind);
+    } else {
+        determineKinds(resolvedServices);
+    }
+
+    for (const resolvedService of resolvedServices) {
+        if (options.serviceArg) {
+            resolvedService.name = options.serviceArg;
+        } else if (resolvedService.kind) {
+            resolvedService.name = getRequiresNameFromKind(resolvedService.binding.instance, resolvedService.kind);
+        }
+
+        let { kind, name, binding } = resolvedService;
+        name = name ?? `custom-service:${binding.instance || binding.secret}`
+        resolvedService.name = resolvedService.name ?? name
+        const kindText = kind ? ` with kind ${highlight(kind)}` : ''
+        const nameText = highlight(name)
+
+        logger.log(`Binding ${nameText} to ${platformText(binding)} ${bindingText(binding, highlight)}${kindText}`);
+    }
+
+    // prepare for different providers
+    const userCdsrcJsonStorageProvider = require('./userCdsrcJsonStorageProvider');
+
+    await userCdsrcJsonStorageProvider.storeServices(resolvedServices, {
+        ...options
+    });
+
+    const isJavaProject = await checkIsJavaProject(cds.root);
+    logger.log(`${info('TIP:')} Run with cloud bindings: ${bold(runCmd(options.for, isJavaProject))}`);
+}
+
+function runCmd(profile, isJavaProject) {
+    profile = parseProfile(profile);
+    if (isJavaProject) {
+        const p = profile === 'hybrid' ? '' : ` --profile ${profile}`;
+        return `cds bind exec${p} mvn spring-boot:run`;
+    } else {
+        const p = profile === 'development' ? '' : ` --profile ${profile}`;
+        return `cds watch${p}`;
+    }
+}
+
+function parseProfile(profile) {
+    if (!profile) return 'hybrid';
+    else if (profile === '-') return 'development';
+    else return profile;
+}

package/lib/bind/kubernetesCredentialsProvider.js

@@ -44,7 +44,7 @@ class KubernetesCredentialsProvider {
 
         const resolvedBinding = {
             binding: {
-                type: "k8s",
+                type: 'k8s',
                 name: bindingName,
                 cluster,
                 instance,
@@ -63,7 +63,7 @@ class KubernetesCredentialsProvider {
         const { data } = secret;
         const properties = {};
         for (const name in data) {
-            const value = Buffer.from(data[name], "base64").toString()
+            const value = Buffer.from(data[name], 'base64').toString()
             properties[name] = value;
         }
 

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -2,17 +2,13 @@ const os = require('os');
 const path = require('path');
 const readline = require('readline');
 
-const cds = require('../cds');
-const DEBUG = cds.debug('cli');
-
 const fs = require('fs').promises;
 const { highlight } = require('../util/term');
 const { logger } = require('./bindingUtil');
 
-const commandUtil = require('../util/command');
+const gitUtil = require('../util/gitUtil');
 
 const CDSRC_FILENAME = '.cdsrc-private.json';
-const GIT_IGNORE_FILE = '.gitignore';
 
 class UserCdsrcJsonStorageProvider {
     async askBooleanQuestion(question) {
@@ -34,44 +30,11 @@ class UserCdsrcJsonStorageProvider {
         });
     }
 
-    async ensureFileIsGitignored(file) {
-        try {
-            await commandUtil.spawnCommand('git', ['check-ignore', '-n', '-v', file], {}, undefined, true);
-            return; // file is git ignored
-        } catch (err) {
-            if (err.code === 'ENOENT') {   // git command not found
-                DEBUG?.('git command not found');
-                return;
-            }
-
-            if (!err.stdLog.match(/::/)) {   // included or not a git repo
-                DEBUG?.(err);
-                return;
-            }
-        }
-
-        logger.log(`adding entry '${file}' to ${GIT_IGNORE_FILE}.`);
-        let gitignore = await this.readFileSafely(GIT_IGNORE_FILE);
-        gitignore = gitignore + `
-# added by cds bind
-${file}
-`;
-        await fs.writeFile(GIT_IGNORE_FILE, gitignore, 'utf8');
-    }
-
-    async readFileSafely(file) {
-        try {
-            return await fs.readFile(file, 'utf8');
-        } catch (err) {
-            return '';
-        }
-    }
-
     async storeServices(services, options = {}) {
-        let jsonPath = options['output-file'] || CDSRC_FILENAME;
+        let jsonPath = options.outputFile || CDSRC_FILENAME;
 
         if (jsonPath === CDSRC_FILENAME) {
-            await this.ensureFileIsGitignored(CDSRC_FILENAME);
+            await gitUtil.ensureFileIsGitignored(CDSRC_FILENAME);
         }
 
         jsonPath = jsonPath.replace(/~/g, os.homedir());
@@ -89,13 +52,13 @@ ${file}
             cdsRoot = jsonObject;
         }
 
-        const profileKey = `[${options.profile}]`;
+        const profileKey = `[${options.for}]`;
         const features = cdsRoot.features && cdsRoot.features[profileKey];
         if (features) delete features.emulate_vcap_services;
 
         cdsRoot.requires = cdsRoot.requires || {};
         let section;
-        if (options.profile) {
+        if (options.for) {
             section = cdsRoot.requires[profileKey] = cdsRoot.requires[profileKey] || {};
         } else {
             section = cdsRoot.requires;
@@ -109,8 +72,8 @@ ${file}
         }
 
         await this.writeJsonFile(jsonPath, jsonObject);
-        if (options.profile) {
-            logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.profile)}`);
+        if (options.for) {
+            logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.for)}`);
         } else {
             logger.log(`Saving bindings to ${highlight(jsonPath)}`);
         }