@sap/cds-dk 4.6.0 → 4.7.1

package/CHANGELOG.md

@@ -6,6 +6,76 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## 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
+
+- `cds add lint` now correctly detects missing local `eslint`
+- `cds add lint` no longer removes parts of `package.json`
+- `cds add lint` no longer creates duplicate configuration entries
+
+## Version 4.6.1 - 2021-11-08
+
+### Changed
+
+- `cds init` uses latest `Maven Java archetype` version `1.20.0` for creating Java projects.
+- `cds watch` now resolves local node modules like `hdb` even though `@sap/cds` is not installed locally.  This is useful during development where `@sap/cds` shall only be installed in a 'central' location, while extra modules shall still be found in the app's dir.
+
+### Fixed
+
+- `cds repl` now finds modules like `hdb` that are installed locally in the app folder
+- `cds repl` now enables the `await` statement also on Windows
+- `cds lint` now limits all file extensions to those allowed by the @sap/eslint-plugin-cds ESLint configuration
+
 ## Version 4.6.0 - 2021-11-02
 ### Added
 

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/compile/index.js

@@ -38,6 +38,7 @@ module.exports = Object.assign ( compile, {
     - json, yml
     - edm, edmx, edmx-v2, edmx-v4, edmx-w4, edmx-x4
     - sql, hdbcds, hdbtable
+    - cdl [beta]
     - xsuaa
     - openapi
 
@@ -261,7 +262,7 @@ function compile (models, options={}) {
 
   function suffix4 (x) { return x && ({
     edmx: '.xml',
-    "edmx-v2": '.xml', 
+    "edmx-v2": '.xml',
     "edmx-v4": '.xml',
     openapi: '.openapi3.json', //'.yml',
     cdl: '.cds',

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

@@ -14,8 +14,12 @@ module.exports = Object.assign (repl, { options: [], help: `
 
 function repl (_, options={}) {
 
-  if (module.parent && module.parent.filename.endsWith('/bin/cds.js')) {
-    return require('child_process').spawn('node',['--experimental-repl-await', __filename ],{stdio:'inherit'})
+  // enable `await` statement for Node.js < 16
+  if (!process.env['CDS_REPL_SPAWNED'] && process.version.split('.')[0].slice(1) < '16') {
+    process.env['CDS_REPL_SPAWNED'] = true
+    return require('child_process').spawn('node',['--experimental-repl-await',
+      ...process.argv.slice(1) ], {stdio:'inherit'}
+    )
   }
 
   const cds = require('@sap/cds/lib')
@@ -27,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'}),
@@ -35,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
@@ -43,7 +43,7 @@ module.exports = Object.assign ( watch, {
 `})
 
 const DEBUG = /\bwatch\b/.test(process.env.DEBUG) && console.debug
-const path = require ('path')
+const {delimiter,dirname,relative,resolve,sep} = require ('path')
 const fs = require ('fs')
 const t = module.exports.codes = {
   reset: '\x1b[0m', // Default
@@ -55,24 +55,30 @@ 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, {
     _args: JSON.stringify(args),
     _options: JSON.stringify(options)
   })
+
+  // allow running w/o or partial local node_modules, also add cds-dk for its sqlite
+  env.NODE_PATH = [...paths(cwd||process.cwd()), ...paths(__dirname)].join(delimiter)
+
   if (typeof ext !== 'string')  ext = extDefaults
-  env.NODE_PATH = path.resolve (__dirname,'../node_modules') // allow global sqlite to be resolved
 
   let liveReload //= ...
   let firstTime = true
@@ -83,7 +89,7 @@ async function watch ([cwd], {
     env.CDS_LIVERELOAD_URL = await liveReload.start (options['livereload'])
       .catch(err => { console.log(`Error starting live reload: ${err.message}`); liveReload = null })
   } else {
-    ignore = RegExp(`app${path.sep}.*\\.(js|ts)|`+ignore.source) // exclude more frontend stuff
+    ignore = RegExp(`app${sep}.*\\.(js|ts)|`+ignore.source) // exclude more frontend stuff
   }
 
   const log = (first,...more) => console.log (t.yellow + (first||''), ...more, t.reset)
@@ -91,8 +97,8 @@ async function watch ([cwd], {
     const ocwd = process.env._original_cwd = process.cwd()
     if (fs.existsSync(cwd)) log (`cd ${cwd}`)
     else try {
-      const resolved = path.dirname (require.resolve(cwd+'/package.json', {paths:[ocwd]}))
-      log (`cd ${path.relative(ocwd,cwd = resolved)}`)
+      const resolved = dirname (require.resolve(cwd+'/package.json', {paths:[ocwd]}))
+      log (`cd ${relative(ocwd,cwd = resolved)}`)
     } catch(_){ throw new Error(`No such folder or package: '${ocwd}' -> '${cwd}'`) }
   }
   log ()
@@ -102,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 ({
@@ -118,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()
         }
       })
@@ -172,6 +178,12 @@ function removeArgsIn (toRemove) {
   }
 }
 
+// builds paths from dir + its parent node_modules
+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
 //
@@ -197,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)