@sap/cds-dk 4.6.2 → 4.7.2

package/CHANGELOG.md

@@ -6,6 +6,65 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 4.7.2 - 2021-12-15
+
+### Fixed
+
+- `cds add lint` uses JSONC parser to read ESLint config files of type `.eslintrc[.js,.cjs,.json]`.
+
+### Changed
+
+- `cds init` uses latest Maven Java archetype version `1.21.0` for creating Java projects.
+
+## Version 4.7.1 - 2021-12-06
+
+### Fixed
+
+- `cds activate` authentication no longer fails
+- `cds.compile.to.openapi` does no longer crash if `cds.compile` was already initialized
+
+## Version 4.7.0 - 2021-12-06
+
+### Added
+
+- `cds add data --for` can be passed a regular expression, allowing more flexible name filters.  For example `--for '^Supplier$'` would only match entity `Supplier`, but not `SupplierAddress`.  Note that as before, `--for Supplier` is interpreted as `--for '^Supplier.*'`, i.e. matches both entities.
+- `cds init --add hana` and `cds add hana` now add a `undeploy.json` file containing wildcards. This ensures that SAP HANA artefacts are automatically cleaned-up in case views, unique keys or constraint definitions of associations have been changed in CDS model.
+
+### Changed
+
+- `cds import` now adds annotations for missing ON conditions in associations instead of appending it in `doc`.
+- `cds import` has updated mapping for OData V2 and V4
+- `cds add lint` now configures `csv` files in `.vscode/settings.json`
+- `cds add hana` for Java projects now adds an `engines.node` version of `^16` to the generated `db/package.json`, to pin the Node.js version.  This will help in the future when runtime environments change their default to some version higher than the one supported by `@sap/hdi-deploy`.
+- `cds add mta` for Node.js projects now adds `npm ci` commands instead of `npm install`.  This makes use of `package-lock.json` to enforce reproducible builds.
+- `cds watch` now ignores folders named `target`, to avoid restarts when Maven's build output changes
+
+### Fixed
+
+- `cds import` throws warning messages for unsupported data types.
+- `cds watch` allows the explicit `--with-mocks` option, although this is anyways included by default
+- `cds watch` no longer runs into multiple restarts if many files are changed at once, like in git branch changes
+
+## Version 4.6.4 - 2021-11-24
+
+### Fixed
+
+- `cds import` fix for TypeError issue during OData V2 EDMX conversion to CSN.
+- `cds import <file_name>` fix now updates the service name in the `package.json` with only the file name. Earlier, the service name sometimes used to be of the form `A.B`, with `A` being file name and `B` being a part of the schema namespace value in the EDMX file
+
+### Changed
+
+- `cds init` uses latest Maven Java archetype version `1.20.3` for creating Java projects.
+
+## Version 4.6.3 - 2021-11-16
+
+### Fixed
+
+- `cds watch` recovers again from compilation errors and properly prints these
+- `cds import` fix for omitting empty `doc` components.
+- `cds add lint` no longer duplicates initial contents in `package.json`
+- `cds add data` no longer ignores imported services for which credentials are stored in the project
+
 ## Version 4.6.2 - 2021-11-09
 
 ### Fixed

package/bin/add.js

@@ -36,7 +36,8 @@ module.exports = Object.assign(add, {
 
     *-4* | *--for* <entity name or prefix>
 
-      Filters the CSN model with the given name or prefix
+      Filters entity names with the given string. If it contains meta characters like ^ or *
+      it is treated like a regular expression, otherwise as a prefix.
 
     *-o* | *--out* <target folder>
 

package/bin/bind.js

@@ -1,24 +1,27 @@
-
-
 module.exports = Object.assign(cds_bind, {
-    options: ['--to', '--profile', '--kind', '--output-file'],
-    flags: [],
-    shortcuts: ['-2', '-p', '-k', '-o'],
+    options: ['--to', '--on', '--profile', '--kind', '--output-file'],
+    flags: ['--exec'],
+    shortcuts: ['-2', '-n', '-p', '-k', '-o'],
     help: `
 # SYNOPSIS
 
-    *cds bind* <service> [<options>]  --  beta feature
+    *cds bind* <service> [<options>]
+    *cds bind --exec* [--profile <profile>] [--] <command> <args ...>
 
     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.
+    With *--exec* you can execute arbitrary commands with your service bindings. The service bindings are provided
+    in the *VCAP_SERVICES* env variable to the command.
 
 # OPTIONS
 
-    *-2 | --to* <instance>[:<key>]
-        bind to a given instance
+    *-2 | --to* <instance>[:<key>] | <service-binding> | <secret>
+        bind to a given Cloud Foundry instance, Kubernetes service binding or Kubernetes secret.
+
+    *-n | --on* cf | k8s
+        bind to service on Cloud Foundry or Kubernetes, defaults to Cloud Foundry
 
     *-p | --profile* <profile>
         add the given profile, defaults to *hybrid*
@@ -26,7 +29,7 @@ module.exports = Object.assign(cds_bind, {
     *-k | --kind* <kind>
         the kind of service
 
-    *-o | --output-file <path>*
+    *-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.
 
@@ -36,13 +39,12 @@ module.exports = Object.assign(cds_bind, {
     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 .
     cds bind --to my-hdi-container --output-file package.json
 
-`});
-
-const { constants, promises: fsp } = require('fs');
-const path = require('path');
+    cds bind --to my-hdi-container --on k8s
+`
+});
 
 const cds = require('@sap/cds/lib');
 const LOG = cds.log('bind');
@@ -50,19 +52,25 @@ const LOG = cds.log('bind');
 LOG.isDebug = LOG._debug;
 LOG.isTTY = process.stdout.isTTY;
 
-const { bold, info } = require('../lib/util/term');
+const { highlight, bold, info } = require('../lib/util/term');
 
 const Spinner = require('../lib/init/util/spinner');
+const resolveBinding = require('../lib/bind/bindingResolver').resolver(LOG);
+const { determineKinds, getRequiresNameFromKind, execAndExit, checkIsJavaProject, throwError, platformText, bindingText } = require('../lib/bind/bindingUtil');
 
+const VCAP_LABEL_PLACEHOLDER = '<replace with service label>';
 
-async function cds_bind(args, options) { // eslint-disable-line
-
-    options.profile = options.profile || 'hybrid';
+async function cds_bind(args, options) {
+    options.profile = parseProfile(options.profile);
+    setProfile(options.profile);
 
-    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.exec) {
+        cds_bind_exec(args, options)
+        return;
     }
 
+    const env = cds.env.for('cds', process.cwd());
+
     if (!options.to) {
         throw new Error(`use option --to or -2 to specify the target instance, e.g. cds bind --to myInstance:myService`);
     }
@@ -71,6 +79,8 @@ async function cds_bind(args, options) { // eslint-disable-line
         throw new Error(`Too many arguments: Please specify only one or no service.`);
     }
 
+    const isJavaProject = await checkIsJavaProject(process.cwd());
+
     let serviceArg = args[0]
     const targets = options.to.split(/,/g);
 
@@ -82,31 +92,72 @@ async function cds_bind(args, options) { // eslint-disable-line
         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);
+
+    let on;
+    if (options.on === 'k8s' || options.on === 'kubernetes') {
+        on = 'k8s';
+    } else if (!options.on || options.on === 'cf' || options.on === 'cloudfoundry') {
+        on = 'cf';
+    } else {
+        throw new Error(`Invalid value '${options.on}' for option --on.`);
+    }
+
+    const onText = { 'cf': 'Cloud Foundry', 'k8s': 'Kubernetes' }[on];
+    const resolvedServices = await spinner.run(`Retrieving data from ${onText}...`, async () => { // NOSONAR
+        return 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 {
+                throwError();
+            }
+
+            const resolvedService = await resolveBinding(undefined, binding);
+            resolvedService._target = target;
+            delete resolvedService.credentials;
+            resolvedService.binding.resolved = false;
+            return resolvedService;
         }));
-        return resolvedServices;
     });
 
-    if (!options.kind) {
-        keyProvider.determineKinds(resolvedServices);
+    if (options.kind) {
+        resolvedServices.forEach( service => service.kind = options.kind );
+    } else {
+        determineKinds(resolvedServices);
     }
 
     for (const resolvedService of resolvedServices) {
-        resolvedService.kind = options.kind || resolvedService.kind;
-        resolvedService.name = serviceArg || keyProvider.getRequiresNameFromKind(resolvedService.binding.instance, resolvedService.kind);
+        if (serviceArg) {
+            resolvedService.name = serviceArg;
+        } else if (resolvedService.kind) {
+            resolvedService.name = getRequiresNameFromKind(resolvedService.binding.instance, resolvedService.kind);
+        }
+
+        if (!resolvedService.name) {
+            if (isJavaProject) {
+                const { binding } = resolvedService;
+                // Generate a custom service entry for Java projects w/o the need to specify a name manually
+                resolvedService.name = `custom-service:${binding.instance || binding.secret}`
+            } else {
+                throw new Error(`Unknown CDS service name for service "${resolvedService._target}". Please specify as argument for "cds bind".`)
+            }
+        }
+
+        const { kind, name, binding } = resolvedService;
+        const kindText = kind && `with kind ${highlight(kind)}`;
+        const nameText = !isJavaProject && highlight(name);
+
+        LOG.log(['Binding', nameText, 'to', platformText(binding), bindingText(binding, highlight), kindText].filter( t => t ).join(' '));
+
+        if (isJavaProject && !hasVcapLabel(binding) && !hasVcapLabel(env.requires[resolvedService.name]) && !(kind && hasVcapLabel(env.requires[kind]))) {
+            resolvedService.vcap = { label: VCAP_LABEL_PLACEHOLDER };
+            LOG.log(`${info('INFO:')} Please add a "vcap.label" property to the binding for consumption in CAP Java projects`);
+        }
     }
 
     // prepare for different providers
@@ -118,16 +169,38 @@ async function cds_bind(args, options) { // eslint-disable-line
     });
 
     LOG.log();
-    LOG.log(`${info("TIP:")} Run with cloud bindings: ${bold(`cds watch --profile ${options.profile}`)}`);
-    // LOG.log();
+    LOG.log(`${info('TIP:')} Run with cloud bindings: ${bold(runCmd(options, isJavaProject))}`);
+}
+
+async function cds_bind_exec(command) { // eslint-disable-lint
+    const cds = require('@sap/cds/lib');
+    const env = cds.env.for('cds', process.cwd());
+    env._emulate_vcap_services();
+    await require('../lib/bind/bindingResolver').applyTo({env, output: 'info'});
+    execAndExit(...command);
+}
+
+function hasVcapLabel(service) {
+    return service && service.vcap && service.vcap.label && service.vcap.label != VCAP_LABEL_PLACEHOLDER;
 }
 
-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;
+function runCmd({profile}, isJavaProject) {
+    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 setProfile(profile) {
+    profile = parseProfile(profile);
+    if (profile) process.env.CDS_ENV = profile;
+}
+
+function parseProfile(profile) {
+    if (!profile) return 'hybrid';
+    else if (profile === '-') return 'development';
+    else return profile;
+}

package/bin/cds.js

@@ -39,7 +39,15 @@ const cli = { //NOSONAR
 
     const task = this.load (cmd, /*else*/ (f)=> argv.unshift(cmd) && _defaultCompile (argv,f))
     if (task) {
+      // REVISIT: '--' handling for cds bind --exec. Should be moved to cds_cli
+      const endOfOptions = argv.indexOf('--')
+      let appendArgs = []
+      if (endOfOptions>=0) {
+        appendArgs = argv.slice(endOfOptions+1)
+        argv = argv.slice(0, endOfOptions)
+      }
       const args = cds_cli.args(task,argv)
+      args[0].push(...appendArgs)
       return task.apply (this, args)
     }
   },

package/bin/env.js

@@ -50,8 +50,6 @@ async function env ([cmd, key, value], options={}) {
     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
 

package/bin/repl.js

@@ -31,7 +31,8 @@ function repl (_, options={}) {
   const info = colors ? require('../lib/util/term').info : s => s
   log(info('Welcome to cds repl v'+ cds.version))
 
-  const cdsr = cds.repl = require('repl').start ({...options, writer:_writer, ignoreUndefined:true })
+  const cdsr = require('repl').start ({...options, writer:_writer, ignoreUndefined:true })
+  Object.defineProperty (cds,'repl',{value:cdsr})
 
   cds.lazify (Object.assign (cdsr.context,{ cds,
     Foo: lazy => new cds.entity ({name:'Foo'}),
@@ -39,7 +40,9 @@ function repl (_, options={}) {
   }))
 
   // cosmetics: don't show cds.env when inspecting cds
-  cds.env && Reflect.defineProperty (cds,'env',{ value:cds.env, enumerable:false })
+  if (Reflect.getOwnPropertyDescriptor(cds,'env')) {
+    Reflect.defineProperty (cds,'env',{ value:cds.env, enumerable:false })
+  }
 
   inspect.defaultOptions.depth = 11
   function _writer (o) {

package/bin/watch.js

@@ -1,6 +1,6 @@
 const watchOnlyOptions = ['--ext', '--livereload', '--open']
 module.exports = Object.assign ( watch, {
-  flags: [ '--debug', '--in-memory', '--in-memory?' ],
+  flags: [ '--debug', '--in-memory', '--in-memory?', '--with-mocks' ],
   options: [ '--port', ...watchOnlyOptions ],
   help: `
 # SYNOPSIS
@@ -55,16 +55,19 @@ const t = module.exports.codes = {
   orange: '\x1b[38;2;255;140;0m' // darker orange, works with bright and dark background
 }
 const extDefaults = 'cds,csn,csv,ts,mjs,cjs,js,json,properties,edmx,xml,env'
-let ignore = /node_modules|\.cds-services\.json$/
+let ignore = /node_modules|target|\.cds-services\.json$/
 
 async function watch ([cwd], {
-  args = ['serve', 'all', '--with-mocks'],
+  args = ['serve', 'all'],
   ext = extDefaults,
   ...options
 }={}) {
-  args.push (`--${Object.keys(options).find(a => /^in-memory\??$/.test(a)) || 'in-memory?'}`)
-  args.push (...process.argv.slice(3)
+  if (!Object.keys(options).includes('with-mocks'))               args.push ('--with-mocks')
+  if (!Object.keys(options).find(a => /^in-memory\??$/.test(a)))  args.push ('--in-memory?')
+  args
+    .push (...(process.argv.slice(3).filter(a => !args.includes(a)))  // add deduped command line args
     .filter(removeArgsIn(watchOnlyOptions))  // remove all watch-only options, as `cds serve` would not accept them
+    .filter(a => a !== '--watch')            // from `cds serve --watch`
     .filter(a => a !== cwd))
 
   let env = Object.assign (process.env, {
@@ -105,7 +108,7 @@ async function watch ([cwd], {
 
   const bindingManager = new require('../lib/bind/bindingResolver').bindingManager({cwd})
   const bindings = await bindingManager.resolve()
-  if (bindings) env = {...env, CDS_CONFIG: JSON.stringify(bindings)}
+  if (bindings) env = {...env, 'CDS_REQUIRES': JSON.stringify(bindings.requires)}
 
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
@@ -121,7 +124,7 @@ async function watch ([cwd], {
       bindingManager.update({
         onBeforeUpdate: () => watcher.stop(),
         onAfterUpdate: bindings => {
-          watcher.setEnv('CDS_CONFIG', bindings && JSON.stringify(bindings))
+          watcher.setEnv('CDS_REQUIRES', bindings && JSON.stringify(bindings.requires))
           watcher.restart()
         }
       })
@@ -206,7 +209,7 @@ if (!module.parent) (async()=>{ // launched by nodemon
     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: console.error(e)
+    default: { throw e } // cli error handling will catch and format
   }}
   function _no_models_found(e) { console.log (`
     No models found in ${cds.resolve(e.model||'*',false)}.

package/lib/bind/bindingResolver.js

@@ -1,6 +1,8 @@
 const Config = require('@sap/cds/lib/env')
 const cds = require('@sap/cds/lib');
 const LOG = cds.log('bind');
+const resolveBinding = resolver(LOG);
+const { platformText, bindingText } = require('./bindingUtil');
 
 function getUnresolvedBindings({cwd = process.cwd(), env}) {
     if (!env) env = Config.for('cds', cwd)
@@ -28,7 +30,7 @@ async function resolveBindings({bindings, cwd = process.cwd(), env, output = 'in
         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}`)
+            LOG[output](`bound ${name} to ${platformText(binding)} ${bindingText(binding)}`)
         } else {
             config.requires[name] = cache[cacheKey]
         }
@@ -43,17 +45,26 @@ async function resolveBindings({bindings, cwd = process.cwd(), env, output = 'in
 }
 
 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}".`)
+let kubernetesCredentialsProvider
+
+function resolver(log) {
+    return function resolveBinding(name, binding) {
+        switch (binding.type) {
+            case 'cf':
+                if (!cfKeyProvider) {
+                    cfKeyProvider = require('./cfKeyProvider');
+                    cfKeyProvider.setLogger(log);
+                }
+                return cfKeyProvider.resolve(name, binding)
+            case 'k8s':
+                if (!kubernetesCredentialsProvider) {
+                    kubernetesCredentialsProvider = require('./kubernetesCredentialsProvider')
+                    kubernetesCredentialsProvider.setLogger(log)
+                }
+                return kubernetesCredentialsProvider.resolve(name, binding)
+            default:
+                throw new Error(`Unsupported binding type "${binding.type}" for service "${name}".`)
+        }
     }
 }
 
@@ -67,8 +78,8 @@ async function applyTo(options) {
         Object.assign(env.requires[name], { binding, credentials })
     }
 
-    if (Config._emulate_vcap_services) {
-        Config._emulate_vcap_services()
+    if (env._emulate_vcap_services) {
+        env._emulate_vcap_services()
     }
 }
 
@@ -131,6 +142,7 @@ function feature(env) {
 }
 
 module.exports = {
+    resolver,
     applyTo,
     bindingManager: function(options) {
         return new BindingManager(options)

package/lib/bind/bindingUtil.js

@@ -0,0 +1,144 @@
+const KindToRequiresNameMap = {
+    xsuaa: 'uaa',
+    hana: 'db',
+    destinations: 'destinations',
+    connectivity: 'connectivity',
+    'audit-log': 'audit-log',
+    'enterprise-messaging': 'messaging',
+    'enterprise-messaging-amqp': 'messaging',
+    'enterprise-messaging-http': 'messaging',
+    'enterprise-messaging-shared': 'messaging'
+}
+
+function 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".`)
+    return requiresName;
+}
+
+/**
+ * Determine kind value for services based on VCAP binding
+ * information in the configuration.
+ */
+function determineKinds(services) {
+        const vcapServices = {}
+
+        const getIndex = service => {
+            const { credentials } = service;
+            return credentials && credentials.binding && credentials.binding.index;
+        }
+
+        // Build VCAP_SERVICES
+        for (let index = 0; index<services.length; index++) {
+            const service = services[index];
+            service.kindCandidates = [ ]
+            service.nameCandidates = [ ]
+
+            const { label, name, tags } = service.binding && service.binding.vcap || {};
+            if (!label) continue;
+
+            if (!vcapServices[label]) vcapServices[label] = [];
+            vcapServices[label].push({ credentials: { binding: { index } }, label, name, tags });
+        }
+
+        // Auto configure services based on VCAP_SERVICES
+        const cds = require('@sap/cds/lib');
+        const VCAP_SERVICES = process.env.VCAP_SERVICES;
+        try {
+            process.env.VCAP_SERVICES = JSON.stringify(vcapServices);
+            const env = cds.env.for('cds', '.');
+
+            // Extract "kind" from auto configured services
+            for (const kind of Object.keys(env.requires)) {
+                const requireService = env.requires[kind];
+                const superKind = requireService.kind;
+                const index = getIndex(requireService);
+                if (!Number.isInteger(index)) continue;
+
+                const superRequireService = env.requires[superKind];
+                if (superRequireService) {
+                    const superIndex = getIndex(superRequireService);
+                    if (index === superIndex) continue;
+                }
+
+                services[index].kindCandidates.push(kind);
+            }
+
+            // Check if one "kind" per service was found
+            for (const service of services) {
+                if (service.kindCandidates.length === 1) {
+                    service.kind = service.kindCandidates[0];
+                }
+
+                delete service.kindCandidates;
+            }
+        } finally {
+            if (VCAP_SERVICES)
+                process.env.VCAP_SERVICES = VCAP_SERVICES;
+            else
+                delete process.env.VCAP_SERVICES;
+        }
+    }
+
+function execAndExit(command, ...args) {
+    const { spawnSync } = require('child_process');
+    const result = spawnSync(command, args, { stdio: 'inherit', shell: false });
+    process.exit(result.status);
+}
+
+async function checkIsJavaProject(projectPath) {
+    const { constants, promises: fsp } = require('fs');
+    const path = require('path');
+    const pomXmlPath = path.join(projectPath, 'pom.xml');
+    try {
+        await fsp.access(pomXmlPath, constants.F_OK);
+        return true;
+    } catch (err) {
+        return false;
+    }
+}
+
+
+/**
+ *
+ * @param {string} msg
+ * @returns {never}
+ */
+ function throwError(msg = 'Internal Error') {
+    throw new Error(msg);
+}
+
+
+const PLATFORM_TYPES = {
+    'cf': 'Cloud Foundry',
+    'k8s': 'Kubernetes'
+}
+
+function platformText(binding) {
+    return PLATFORM_TYPES[binding.type] || throwError(`Unexpected binding type "${binding.type}"`);
+}
+
+function bindingText(binding, highlight = t => t) {
+    switch (binding.type) {
+        case 'cf':
+            return `service ${highlight(binding.instance)} key ${highlight(binding.key)}`
+        case 'k8s':
+            if (binding.name) {
+                return `service binding ${highlight(binding.name)}`
+            } else {
+                return `secret ${highlight(binding.secret)}`
+            }
+        default:
+            throwError();
+    }
+}
+
+module.exports = {
+    getRequiresNameFromKind,
+    determineKinds,
+    execAndExit,
+    checkIsJavaProject,
+    throwError,
+    platformText,
+    bindingText
+}