@sap/cds-dk 6.4.1 → 6.5.1

package/CHANGELOG.md

@@ -7,6 +7,34 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 6.5.1 - 2023-02-06
+
+### Changed
+
+- `cds init` uses latest Maven Java archetype version 1.31.0 for creating Java projects.
+
+### Fixed
+
+- `cds deploy` no longer fails to write to a `package.json` file that has no `cds` section
+
+## Version 6.5.0 - 2023-01-27
+
+### Added
+
+- `cds run/serve/migrate --resolve-bindings` now pulls required service credentials if bound via `cds bind`. (beta)
+- `cds add helm` now supports multitenancy.
+- `cds bind` now supports binding of `user-provided service instances` from Cloud Foundry.
+
+### Changed
+
+- `cds push` now runs a build of the extension project to update the pushed extension archive (unless custom archive given).
+- `cds init` and `cds bind` no longer use a spinner when performing long running operations.
+
+### Fixed
+
+- `cds import` now generates flattened value for `@Common.FieldControl` annotation in the CSN for OData V4 files.
+- `cds import` now treates `CollectionKind` property attribute in OData V2 similar to `Collection(<data_type>)` in OData V4.
+
 ## Version 6.4.1 - 2022-01-17
 
 ### Fixed
@@ -14,6 +42,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `cds deploy -2 sqlite` now preserves the `schema_evolution` setting in the `package.json`.
 - `cds import` bug fix for OData V4 import crash.
 
+### Changed
+
 ## Version 6.4.0 - 2022-12-15
 
 ### Added

package/bin/bind.js

@@ -46,19 +46,14 @@ module.exports = Object.assign(cds_bind, {
 `
 });
 
-const cds = require('../lib/cds');
-const LOG = cds.log('bind');
-// required for spinner
-LOG.isDebug = LOG._debug;
-LOG.isTTY = process.stdout.isTTY;
-const resolveBinding = require('../lib/bind/bindingResolver').resolver(LOG);
+
+const BindingResolver = require('../lib/bind/bindingResolver')
 
 const { highlight, bold, info } = require('../lib/util/term');
 
-const Spinner = require('../lib/init/util/spinner');
-const { determineKinds, getRequiresNameFromKind, execAndExit, checkIsJavaProject, throwError, platformText, bindingText } = require('../lib/bind/bindingUtil');
+const { determineKinds, getRequiresNameFromKind, execAndExit, checkIsJavaProject, platformText, bindingText, logger } = require('../lib/bind/bindingUtil');
 
-async function cds_bind(args, options, logger = LOG) {
+async function cds_bind(args, options) {
 
     options.profile = parseProfile(options.profile);
     setProfile(options.profile);
@@ -89,8 +84,6 @@ async function cds_bind(args, options, logger = LOG) {
         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.`);
     }
 
-    const spinner = new Spinner();
-
     let on;
     if (options.on === 'k8s' || options.on === 'kubernetes') {
         on = 'k8s';
@@ -101,9 +94,11 @@ async function cds_bind(args, options, logger = LOG) {
     }
 
     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 => {
+    logger.log(`Retrieving data from ${onText}...`);
+    let resolvedServices
 
+    try {
+        resolvedServices = await Promise.all(targets.map(async target => {
             let binding;
             if (on === 'k8s') {
                 binding = { type: on, name: target };
@@ -111,21 +106,28 @@ async function cds_bind(args, options, logger = LOG) {
                 const [instance, key] = target.split(/:/);
                 binding = { type: on, instance, key };
             } else {
-                throwError();
+                throw new Error('Internal Error');
             }
-
-            const resolvedService = await resolveBinding(undefined, binding);
+            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, LOG);
+        determineKinds(resolvedServices);
     }
 
     for (const resolvedService of resolvedServices) {
@@ -135,37 +137,31 @@ async function cds_bind(args, options, logger = LOG) {
             resolvedService.name = getRequiresNameFromKind(resolvedService.binding.instance, resolvedService.kind);
         }
 
-        const { kind, name, binding } = resolvedService;
-        const kindText = kind && `with kind ${highlight(kind)}`;
-        const nameText = !isJavaProject && name && highlight(name);
+        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.info(['Binding', nameText, 'to', platformText(binding), bindingText(binding, highlight), kindText].filter(t => t).join(' '));
-
-        if (!resolvedService.name) {
-            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}`
-        }
+        logger.log(`Binding ${nameText} to ${platformText(binding)} ${bindingText(binding, highlight)}${kindText}`);
     }
 
     // prepare for different providers
     const userCdsrcJsonStorageProvider = require('../lib/bind/userCdsrcJsonStorageProvider');
 
     await userCdsrcJsonStorageProvider.storeServices(resolvedServices, {
-        ...options,
-        logger
+        ...options
     });
 
-    logger.info();
-    logger.info(`${info('TIP:')} Run with cloud bindings: ${bold(runCmd(options, isJavaProject))}`);
+    logger.log(`${info('TIP:')} Run with cloud bindings: ${bold(runCmd(options, isJavaProject))}`);
 }
 
 async function cds_bind_exec(command) { // eslint-disable-lint
     const cds = require('../lib/cds');
     const env = cds.env.for('cds', process.cwd());
 
-    const BindingManager = require('../lib/bind/BindingManager')
-    const bindingManager = new BindingManager({ env, output: 'info' })
+    const BindingManager = require('../lib/bind/bindingManager')
+    const bindingManager = new BindingManager({ env })
     const bindingEnv = await bindingManager.bindingEnv()
     const processEnv = Object.assign(process.env, bindingEnv)
 

package/bin/cds.js

@@ -37,7 +37,7 @@ 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
+      // REVISIT bind: '--' handling for cds bind --exec. Should be moved to cds_cli
       const endOfOptions = argv.indexOf('--')
       let appendArgs = []
       if (endOfOptions>=0) {
@@ -46,7 +46,9 @@ const cli = { //NOSONAR
       }
       const args = cds_cli.args(task,argv)
       args[0].push(...appendArgs)
-      return task.apply (this, args)
+      const resolveBindings = cmd in { run: 1, serve: 1, migrate: 1 } && argv.includes('--resolve-bindings')
+      if (resolveBindings) return _resolveBindings().then(() => task.apply(this, args))
+      else return task.apply(this, args)
     }
   },
 
@@ -62,7 +64,16 @@ const cli = { //NOSONAR
   help (cmd) { return this.exec ('help', cmd) }
 }
 
-const DEBUG = /\b(cli)\b/.test (process.env.DEBUG) && console.error
+const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) && console.debug
+
+async function _resolveBindings() {
+  const cds = require('../lib/cds')
+  const BindingManager = require('../lib/bind/bindingManager')
+  const bindingManager = new BindingManager()
+  const bindingEnv = await bindingManager.bindingEnv()
+  Object.assign(process.env, bindingEnv)
+  cds.env = cds.env.for('cds') // reload env
+}
 
 function _local (id, _else) {
   try { return require.resolve (id, {paths:[process.cwd(), __dirname]}) }

package/bin/deploy/index.js

@@ -110,16 +110,17 @@ async function deploy (_model, options) { // NOSONAR
 async function update_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)
+  const package_json = path.resolve (cds.root, 'package.json'), exists = isfile (package_json)
   const conf = exists ? JSON.parse (await readFile (package_json)) : {}
-  const requires = conf.cds?.requires
-  const { schema_evolution } = requires?.db ?? {}
+  conf.cds?.requires || (conf.cds = {requires: {}})
+  const requires = conf.cds.requires
+  const { schema_evolution } = requires.db ?? {}
   requires.db = cds.env.requires.db = { kind, model }
   if (database)  requires.db.credentials = { database }
   else if (kind === 'sqlite') requires.db.credentials = { database:'db.sqlite' }
   if (schema_evolution) requires.db.schema_evolution = schema_evolution
-  await writeFile (package_json, JSON.stringify(conf,null,'  '))
-  console.log (`/> ${ exists ? 'updated' : 'created' } ./package.json`)
+  await writeFile (package_json, JSON.stringify(conf,null,2))
+  console.log (`/> ${ exists ? 'updated' : 'created' } .${path.sep}package_json`)
 }
 
 /* eslint no-console: off */

package/bin/deploy/to-sqlite.js

@@ -1,6 +1,7 @@
 exports.deploy = function deploy_to_sqlite (_model, _db, options) {
 
-    if (options.dialect === 'postgres' && !options.dry)  console.error('\nDeploying to PostgreSQL is not yet supported\n')
+    if (options.dialect === 'postgres' && !options.dry)  console.error('\nDeploying into a PostgreSQL database is not yet supported\n')
+    if (options.dialect === 'h2' && !options.dry)  console.error('\nDeploying into a H2 database is not yet supported\n')
 
     const cds = require('../../lib/cds')
     const conf = cds.env.requires.db ?? {}

package/bin/env.js

@@ -53,8 +53,8 @@ async function env ([cmd, key, value], options={}) {
   let env = options.for ? cds.env.for(options.for) : cds.env
 
   if (options["resolve-bindings"]) {
-    const BindingManager = require('../lib/bind/BindingManager')
-    const bindingManager = new BindingManager({env, output: "debug"})
+    const BindingManager = require('../lib/bind/bindingManager')
+    const bindingManager = new BindingManager({ env, silent: true })
     const bindingEnv = await bindingManager.bindingEnv()
     Object.assign(process.env, bindingEnv)
     env = cds.env.for(options.for || 'cds') // reload env
@@ -97,14 +97,14 @@ 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}).replace(/\s+use:.*\[Getter\].*/g,''))
+    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)
     const str = JSON.stringify(obj, null, 2)
-    return console.log (str ? str.replace(/\s+use:.*\[Getter\].*/g,'') : str)
+    return console.log (str ? str.replace(/\s+use:.*\[Getter\][^,]+,?/g,'') : str)
   },
 
   set () {

package/bin/migrate.js

@@ -1,11 +1,11 @@
 module.exports = Object.assign(migrate, {
-    options: ['--directory'],
+    options: ['--directory', '--tag', '--tagRule'],
     shortcuts: ['-d'],
-    flags: ['--dry'],
+    flags: ['--dry', '--force', '--cleanup', '--resolve-bindings'],
     help: `
 # SYNOPSIS
 
-    *cds migrate* <tenant1|"*">[,<tenant2>] -d <directory> --dry
+    *cds migrate* <tenant1|"*">[,<tenant2>] [-d <directory>] [--tag <tag>] [--tagRule <tag rule>] [--dry] [--force]
 
     Migrate extensions created with @sap/cds-mtx to extensions for @sap/cds-mtxs
 
@@ -17,10 +17,30 @@ module.exports = Object.assign(migrate, {
 
         Specify the target directory of your migrated extension projects. By default, the migrated extension projects will not be stored.
 
+    *--tag* <tag>
+
+        Specify a default tag that is to be used to store the extension. If not specified "migrated" will be used.
+
+    *--tagRule* <tag rule>
+
+        Specify a regular expression that describes the mapping from file names to tags, e. g. "extension-(.*)\.cds" to map from "extension-123.cds" to tag "123". If the expression does not match, the default tag will be used.
+
+    *--force*
+
+        Force the re-migration of already migrated tenants.
+
     *--dry*
 
         Do a dry-run only. Only run a verification of the extension migration.
 
+    *--cleanup* (beta)
+
+        Removes all metadata containers created by @sap/cds-mtx.
+
+    *--resolve-bindings* (beta)
+
+        Resolve remote service bindings configured via *cds bind*.
+
 # SEE ALSO
 `})
 
@@ -30,4 +50,5 @@ async function migrate (param, options = {}) {
     await require('@sap/cds-mtxs/bin/cds-mtx-migrate').run(param[0], options)
 }
 
-/* eslint no-console: off */
+/* eslint no-console: off */
+/* eslint no-useless-escape: off */

package/bin/push.js

@@ -14,6 +14,10 @@ module.exports = Object.assign(push, {
     A download URL may contain Basic-Auth credentials as in 'https://user:pass@host'.
     
     By default, the current working directory is used as project directory.
+    
+    Unless a custom archive is given, the extension project will be automatically built
+    in order to update the generated extension archive. This ensures the most recent
+    extension model is pushed.
 
     Any authentication data will not be saved.
 

package/bin/watch.js

@@ -43,7 +43,7 @@ module.exports = Object.assign ( watch, {
 
 `})
 
-const DEBUG = /\bwatch\b/.test(process.env.DEBUG) && console.debug
+const DEBUG = /\b(y|all|cli|watch)\b/.test(process.env.DEBUG) && console.debug
 const {delimiter,dirname,relative,resolve,sep} = require ('path')
 const fs = require ('fs')
 
@@ -91,7 +91,7 @@ async function watch ([cwd], {
     ext += ',css,gif,html,jpg,png,svg'
     includes = fioriIncludes
     liveReload = new (require ('../lib/watch/livereload-server'))
-    env.CDS_LIVERELOAD_PATH = require.resolve ('connect-livereload')
+    env.CDS_LIVERELOAD_PATH = require.resolve ('../lib/watch/livereload-connect')
     env.CDS_LIVERELOAD_URL = await liveReload.start (options['livereload'])
       .catch(err => { console.log(`Error starting live reload: ${err.message}`); liveReload = null })
   } else {
@@ -113,7 +113,7 @@ async function watch ([cwd], {
   DEBUG && log (`also watching: ${includes.source}`)
   if (liveReload) log (`live reload enabled for browsers`)
 
-  const BindingManager = require('../lib/bind/BindingManager')
+  const BindingManager = require('../lib/bind/bindingManager')
   const bindingManager = new BindingManager({cwd})
   const bindingEnv = await bindingManager.bindingEnv()
   if (bindingEnv) env = {...env, ...bindingEnv}

package/lib/bind/KubernetesApiAccessor.js

@@ -0,0 +1,79 @@
+const yaml = require("@sap/cds-foss")("yaml");
+const { exec } = require('../util/exec');
+
+class KubernetesApiAccessor {
+
+    constructor() {
+
+        this.config = once( async() => {
+            const configString = await exec({result: 'stdout'}) `kubectl config view --raw`;
+            const config = yaml.parse(configString);
+
+            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.`);
+            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.`);
+            const { cluster } = clusterEntry;
+
+            const serverToContext = {};
+            for (const clusterEntry of config.clusters) {
+                const contextEntries = config.contexts.filter( contextEntry => contextEntry.context.cluster === clusterEntry.name );
+                // Collect only cluster servers that are used in exactly one context, to clearly identify the context to be used
+                if (contextEntries.length === 1) {
+                    serverToContext[clusterEntry.cluster.server] = contextEntries[0];
+                }
+            }
+
+            return {
+                namespace: currentContext.namespace || 'default',
+                context: currentContextEntry,
+                cluster,
+                serverToContext
+            }
+        });
+    }
+
+    async context({cluster, namespace}) {
+        const config = await this.config();
+        let contextEntry;
+
+        if (cluster && cluster !== config.cluster.server) {
+            contextEntry = config.serverToContext[cluster] || throwError(`Cluster ${cluster} not found in kubectl configuration`);
+        } else {
+            contextEntry = config.context;
+        }
+
+        return {
+            context: contextEntry.name,
+            cluster: cluster || config.cluster.server,
+            namespace: namespace || contextEntry.context.namespace || 'default'
+        };
+    }
+
+    async get(options) {
+        const {context, namespace, kind, name} = options;
+
+        const result = await exec({stdio: ['ignore', 'pipe', 'ignore'], acceptStatuses: [0, 1]}) `kubectl --output json --context ${context} --namespace ${namespace} get ${kind} ${name}`;
+        if (result.status === 0)
+            return JSON.parse(result.stdout);
+        else
+            return null;
+    }
+}
+
+function once(func) {
+    let result;
+    return function(...args) {
+        if (!result) result = func(...args);
+        return result;
+    }
+}
+
+function throwError(msg = 'Internal Error') {
+    throw new Error(msg);
+}
+
+module.exports = KubernetesApiAccessor;

package/lib/bind/{BindingManager.js → bindingManager.js}

@@ -1,32 +1,33 @@
-const cds = require('../cds')
-const LOG = cds.log('bind');
-const { resolveBindings, getUnresolvedBindings } = require('./bindingResolver')
+const bindingResolver = require('./bindingResolver')
+const { logger } = require('./bindingUtil')
+const DEBUG = /\b(all|cli)\b/.test(process.env.DEBUG)
 
 class BindingManager {
-    constructor(options) {
+    constructor(options = {}) {
         this.cache = {}
         this.bindingsStr = ''
         this.options = options
+        logger.log = DEBUG || !options.silent ? console.log : () => { }
     }
 
     getBindings() {
-        const bindings = getUnresolvedBindings(this.options)
+        const bindings = bindingResolver.getUnresolvedBindings(this.options)
         return bindings
     }
 
     async resolve(bindings) {
         if (!bindings) {
-            bindings = this.getBindings(this.options)
+            bindings = this.getBindings()
             this.bindingsStr = JSON.stringify(bindings)
         }
 
-        return await resolveBindings({...this.options, bindings, cache: this.cache})
+        return await bindingResolver.resolveBindings({ ...this.options, bindings, cache: this.cache })
     }
 
     async bindingEnv(bindings) {
         if (!bindings) bindings = await this.resolve()
         if (bindings) {
-            const VCAP_SERVICES = JSON.stringify(this.toVcapServices(bindings))
+            const VCAP_SERVICES = JSON.stringify(BindingManager.toVcapServices(bindings))
             return { VCAP_SERVICES }
         } else {
             return undefined
@@ -44,7 +45,7 @@ class BindingManager {
 
         try {
             if (this.pendingUpdate) await this.pendingUpdate
-        } catch(error) {
+        } catch (error) {
             // ignore
         }
         this.pendingUpdate = undefined
@@ -55,18 +56,18 @@ class BindingManager {
         try {
             this.pendingUpdate = this.resolve(bindings)
             resolvedBindings = await this.pendingUpdate
-        } catch(error) {
-            LOG.error(error.message)
+        } catch (error) {
+            console.error(error.message)
             return
         }
 
         if (this.bindingsStr !== bindingsStr) return // Next update in progress
 
         const env = Object.assign({ VCAP_SERVICES: '{}' }, await this.bindingEnv(resolvedBindings));
-        if (onAfterUpdate) onAfterUpdate({bindings: resolvedBindings, env})
+        if (onAfterUpdate) onAfterUpdate({ bindings: resolvedBindings, env })
     }
 
-    toVcapServices(bindings) {
+    static toVcapServices(bindings) {
         const services = {}
 
         for (const name in bindings) {
@@ -77,11 +78,11 @@ class BindingManager {
 
             // setting the 'name' property is important to make CAP match the CDS service to the VCAP service
             // it is also added to the 'vcap' property by 'cds bind'
-            serviceEntries.push({ ...vcap, name, credentials: binding.credentials})
+            serviceEntries.push({ ...vcap, name, credentials: binding.credentials })
         }
 
         return services
-    }
+        }
 }
 
 module.exports = BindingManager

package/lib/bind/bindingResolver.js

@@ -1,78 +1,51 @@
-const cds = require('../cds')
-const LOG = cds.log('bind');
-const resolveBinding = resolver(LOG);
-const { platformText, bindingText } = require('./bindingUtil');
+const cds = require('../cds');
+const { platformText, bindingText, logger } = require('./bindingUtil');
 
-function getUnresolvedBindings({cwd = process.cwd(), env}) {
-    if (!env) env = cds.env.for('cds', cwd)
-    if (feature(env) === false || feature(env) === "false") return {}
-
-    const bindings = {}
-    const requires = env.requires || {}
-    for (const name in requires) {
-        const service = requires[name]
-        if (service && service.binding && !service.binding.resolved) {
-            bindings[name] = {...service.binding, kind: service.kind }
+class BindingResolver {
+    getUnresolvedBindings({ cwd = process.cwd(), env } = {}) {
+        if (!env) {
+            env = cds.env.for('cds', cwd)
         }
-    }
-
-    return bindings
-}
-
-async function resolveBindings({bindings, cwd = process.cwd(), env, output = 'info', cache = {} }) {
-    bindings = bindings || getUnresolvedBindings({cwd, env})
-    if (Object.keys(bindings).length===0) return undefined
-    LOG[output](`resolving cloud service bindings...`)
-
-    const resolvedBindings = {}
-
-    await Promise.all( Object.keys(bindings).map( async name => {
-        const binding = bindings[name]
-        const cacheKey = JSON.stringify(binding)
-        let resolvedBinding
-        if (!cache[cacheKey]) {
-            resolvedBinding = cache[cacheKey] = await resolveBinding(name, binding)
-            LOG[output](`bound ${name} to ${platformText(binding)} ${bindingText(binding)}`)
-        } else {
-            resolvedBinding = cache[cacheKey]
+        const bindings = {}
+        const requires = env.requires || {}
+        for (const name in requires) {
+            const service = requires[name]
+            if (service && service.binding && !service.binding.resolved) {
+                bindings[name] = { ...service.binding, kind: service.kind }
+            }
         }
+        return bindings
+    }
 
-        resolvedBindings[name] = resolvedBinding
-    } ))
-
-    return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
-}
-
-let cfKeyProvider
-let kubernetesCredentialsProvider
+    async resolveBindings({ bindings, cwd = process.cwd(), env, cache = {} }) {
+        bindings = bindings || this.getUnresolvedBindings({ cwd, env })
+        if (Object.keys(bindings).length === 0) return undefined
+        logger.log(`resolving cloud service bindings...`)
+
+        const resolvedBindings = {}
+
+        await Promise.all(Object.keys(bindings).map(async name => {
+            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)}`)
+            } else {
+                resolvedBinding = cache[cacheKey]
+            }
+            resolvedBindings[name] = resolvedBinding
+        }))
+        return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
+    }
 
-function resolver(log) {
-    return function resolveBinding(name, binding) {
+    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}".`)
+            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}".`)
         }
     }
 }
 
-function feature(env) {
-    return env.features && env.features.dk && env.features.dk.resolveBindingsForTesting
-}
-
-module.exports = {
-    resolver,
-    resolveBindings,
-    getUnresolvedBindings
-}
+module.exports = new BindingResolver()