@sap/cds-dk 8.7.2 → 8.8.0

package/CHANGELOG.md

@@ -7,7 +7,43 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
-## Version 8.7.2 - 2024-02-14
+## Version 8.8.0 - 2025-03-03
+
+### Added
+
+- `cds add xsuaa` lets you pass a `--plan` option, e.g. for `cds add xsuaa --plan broker`.
+- `cds add workzone` and `cds add workzone-standard` support for Kyma.
+- `cds add typer` now adds a `before:cds-watch` script to run cds-typer before starting `cds watch`.
+- `cds watch` supports a `before:cds-watch` npm script in your `package.json`, executed once before the initial `cds watch` startup.
+
+### Changed
+
+- Running `cds deploy` in dry mode with an output file specified will now only produce a warning in stderr and will not exit with an error code.
+- `cds deploy --out …` will not generate the specified output file if it would end up empty.
+- `cds add workzone` adds a transpilation task for UI5 deployment descriptors in TypeScript projects.
+- `cds add workzone` does not use the deprecated `webide-extension-task-updateManifestJson` task any more.
+
+### Fixed
+
+- `cds add approuter` doesn't create entries for `app` and `appconfig` local directories any more.
+- `cds add telemetry` for Java doesn't erroneously add `cds` configuration or `dependencies` to the `package.json`.
+- `cds add sample` adds the workzone-specific configuration if `cds.requires.workzone` is `true`.
+- `cds compile -o` uses the correct file suffix if explicitly specified in the file name.
+- `cds bind` caches the promise of its `cf -v` call to prevent race conditions.
+- `cds import --out <folder>` does not fail if executed in a folder with a `.`.
+- `cds add workzone` has improved support for multitenancy.
+
+## Version 8.7.3 - 2025-02-19
+
+### Fixed
+
+- `cds compile -o` fixes the output file name in `-o <service>.json`.
+- `cds lint` won't stumble over scalar config objects anymore.
+- `cds init` uses latest Maven Java archetype version 3.7.2 for creating Java projects.
+- `cds deploy --to hana --dry` doesn't exit with a `TypeError` if there are no models.
+- `cds add ias` fixes a few scenarios in combination with multitenancy.
+
+## Version 8.7.2 - 2025-02-14
 
 ### Fixed
 
@@ -21,7 +57,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - `cds bind -a` doesn't concurrently try to check the Cloud Foundry version or OAuth token.
 - `cds import` now resolves target of association/composition correctly for multiple schema files.
 
-## Version 8.7.1 - 2024-02-04
+## Version 8.7.1 - 2025-02-04
 
 ### Fixed
 
@@ -1574,7 +1610,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - `cds init` uses latest Maven Java archetype version 1.22.2 for creating Java projects.
 - `cds import` modified documentation for namespace option.
 - `cds import` does not create bound function imports key parameters in CSN for OData V2.
-- `cds import` now when `--keep-namespace` option is not given validates the file name and then converts it to complier supported format as service name .
+- `cds import` now when `--keep-namespace` option is not given validates the file name and then converts it to compiler supported format as service name .
 - add new methods from `FsUtil` to typescript interface.
 
 ### Fixed

package/bin/bind.js

@@ -69,6 +69,7 @@ module.exports = Object.assign(cds_bind, {
     cds bind --to bookshop-db --for my-profile
 
     cds bind --to-app-services bookshop-srv
+    cds bind -a bookshop-srv
 
     cds bind messaging --to redis-cache --credentials '{"host":"localhost","port":6379}'
     cds bind messaging --to redis-cache --credentials ./credentials.json
@@ -78,21 +79,21 @@ module.exports = Object.assign(cds_bind, {
 const os = require('os');
 const IS_WIN = os.platform() === 'win32';
 
-const { bind, storeBindings, parseProfile } = require('../lib/bind');
+const { bind, storeBindings } = require('../lib/bind/shared');
 
 
 async function cds_bind(args, options) {
     const { on, 'to-app-services': app, to, out, 'output-file': outputFile, exec, credentials } = options
 
     if (exec) {
-        process.env.CDS_ENV = parseProfile(process.env.CDS_ENV);
+        process.env.CDS_ENV ??= 'hybrid'
         if (options.for) {
             console.warn(term.warn(`Parameter --for is not supported in combination with --exec. Its value will be ignored.`));
         }
         return cds_bind_exec(args)
     }
 
-    // Check if cds command was bind. Don't abort in case of deploy
+    // Check if command was cds bind. Don't abort for cds deploy.
     if (process.env.CDS_ENV && process.argv[2] === 'bind') {
         throw `Option ${term.bold('--profile')} is no longer supported. Use ${term.bold('--for')} instead to specify the profile to use when storing connection settings.`;
     }
@@ -156,7 +157,7 @@ async function cds_bind(args, options) {
     if (app) {
         const cds = require('../lib/cds');
         const resolvedServices = [], unresolvedServices = {}
-        const services = (await require('../lib/util/cf').getServices(app)).filter(s => Object.keys(s.credentials).length > 0)
+        const services = (await require('../lib/util/cf').services(app)).filter(s => Object.keys(s.credentials).length > 0)
 
         services.forEach(service => {
             const type = service.label || service.type;
@@ -213,10 +214,8 @@ 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 })
-    const bindingEnv = await bindingManager.bindingEnv()
-    const processEnv = Object.assign(process.env, bindingEnv)
+    const { bindingEnv } = require('../lib/bind/shared')
+    const processEnv = Object.assign(process.env, await bindingEnv({env}))
 
     execAndExit({ env: processEnv }, ...command);
 }

package/bin/cds.js

@@ -171,10 +171,8 @@ const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) ? console.debug : undefi
 
 async function _resolveBindings(options) {
   const cds = require('../lib/cds')
-  const BindingManager = require('../lib/bind/bindingManager')
-  const bindingManager = new BindingManager(options)
-  const bindingEnv = await bindingManager.bindingEnv()
-  Object.assign(process.env, bindingEnv)
+  const { bindingEnv } = require('../lib/bind/shared')
+  Object.assign(process.env, await bindingEnv(options))
   cds.env = cds.env.for('cds') // reload env // FIXME: This is too early!
   cds.requires = cds.env.requires // REVISIT: We should clean this up!
 }

package/bin/compile/index.js

@@ -224,6 +224,7 @@ async function compile (models, options={}) {
     if (ext) {
       options.file ??= path.basename(dest, ext)
       options.dest = path.dirname(dest)
+      options.suffix ??= ext
     }
   }
   if (options.all)  return compile_all (models[0])
@@ -294,7 +295,7 @@ async function compile (models, options={}) {
   const write = require ('../../lib/util/write')
   chain = chain.then (write.to ({
     folder: options.dest,
-    file: options.file || options.service === 'all' ? path.basename(src) : options.service,
+    file: options.file || (options.service === 'all' ? path.basename(src) : options.service),
     suffix: options.suffix || suffix4(_suffix),
     [options.dest ? 'foreach' : 'log']: options.log || consoleLog
   }))

package/bin/deploy/index.js

@@ -159,14 +159,19 @@ async function deploy(_model, options) { // NOSONAR
     const log = this.log || _log
     if (options.messages.length) log (options.messages, options)
 
-    if (options.out) {
+    if (options.out && options.schema_log?.length) {
       await cds.utils.write (options.out, options.schema_log.join('\n'))
     }
   } catch (e) {
-    if (e.code === 'MODEL_NOT_FOUND') {
-      if (!_model) throw new Error('No .cds models found, please specify one as an argument')
-      throw new Error(`No cds models found at/in '${_model}'`)
-    } else throw e
+    if (e.code !== 'MODEL_NOT_FOUND') throw e
+    if (_model) throw `No cds models found at/in '${_model}'`
+    if (options.dry && options.out) {
+      // this is to allow project starts w/o a model with a watcher running
+      console.error('No .cds models found. Doing nothing in dry mode with specified output file.')
+    }
+    else {
+      throw 'No .cds models found, please specify one as an argument'
+    }
   }
 }
 

package/bin/lint.js

@@ -1,7 +1,13 @@
 const Linter = require('../lib/lint/Linter');
 const linter = new Linter();
 
-module.exports = Object.assign(
-    linter.lint,
-    linter.init()
-);
+// cds cli exec expects an executable object with various additional properties.
+// As most of the linting functionality is bound to a class instance, we need to wrap the instance
+// to not lose the this-context and attach the additional properties to the function.
+const lint = (...args) => linter.lint(...args)
+const additionalProperties = Object.entries(linter.init())
+    .map(([key, value]) => [key, { value }])
+
+Object.defineProperties(lint, Object.fromEntries(additionalProperties))
+
+module.exports = lint

package/bin/watch.js

@@ -1,3 +1,6 @@
+const path = require('node:path')
+const { execSync } = require('node:child_process')
+
 const watchOnlyOptions = ['--ext', '--livereload', '--open', '--debug', '--inspect', '--inspect-brk', '--include', '--exclude']
 
 module.exports = Object.assign ( watch, {
@@ -68,7 +71,7 @@ module.exports = Object.assign ( watch, {
 `})
 
 const cds = require('../lib/cds')
-const DEBUG = cds.log('cli|watch')._debug
+const DEBUG = cds.log('cli|watch')
 const {delimiter,dirname,relative,resolve,sep} = require ('path')
 const {codes} = require('../lib/util/term'), t = codes
 const fs = require ('fs')
@@ -161,17 +164,17 @@ async function watch ([cwd], {
     ? new RegExp(ignoreDefaults.map(d => d.source).concat(excludedPaths).join('|'))
     : new RegExp(ignoreDefaults.map(d => d.source).join('|'))
   const watched = [ _cwd, ...included.map(resolved) ]
-  if (DEBUG) {
+  if (DEBUG._debug) {
     console.log(`\nwatching (pid ${process.pid})`, {
       extensions:ext, roots:watched, ignoring: [...excludedPaths.map(s => new RegExp(s)), ...ignoreDefaults]
     })
   }
   if (liveReload) console.log (`live reload enabled for browsers`)
 
-  const BindingManager = require('../lib/bind/bindingManager')
-  const bindingManager = new BindingManager({cwd})
-  const bindingEnv = await bindingManager.bindingEnv()
-  if (bindingEnv) env = {...env, ...bindingEnv}
+  const { bindingEnv, updateBindings } = require('../lib/bind/shared')
+  Object.assign(env, await bindingEnv({cwd}))
+
+  runBeforeScript('watch', {cwd})
 
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
@@ -183,7 +186,7 @@ async function watch ([cwd], {
     if (liveReload) liveReload.markPending(files)
     if (this.delayed) clearTimeout (this.delayed)
     this.delayed = setTimeout(()=>{
-      bindingManager.update({
+      updateBindings({
         onBeforeUpdate: () => watcher.stop(),
         onAfterUpdate: ({env}) => {
           Object.keys(env).forEach( name => watcher.setEnv(name, env[name]) )
@@ -248,3 +251,41 @@ function installed(id, ...paths) {
   try { return require.resolve (id, { paths }) }
   catch(e) { if (e.code !== 'MODULE_NOT_FOUND')  throw e }
 }
+
+/**
+ * Runs a before-script for the given task.
+ * For now, this will only be used for cds watch,
+ * but could be used for other tasks in the future,
+ * therefore the generic name/ implementation.
+ * @param {string} task - The task to run the before-script for.
+ * @param {object} options - Options object containing the cwd.
+ * @param {[string]} options.cwd - The current working directory.
+ */
+function runBeforeScript(task, {cwd}) {
+  cwd ??= '.'
+  try {
+    const packageJson = getPackageJson(cwd)
+    const beforeScript = `before:cds-${task}`
+    if (packageJson.scripts?.[beforeScript]) {
+      DEBUG(`running before-script '${beforeScript}' for cds ${task}`)
+      const cmd = `npm run ${beforeScript} --prefix "${cwd}"`
+      execSync(cmd)
+    }
+  } catch (e) {
+    // ignore not finding package.json (happens during cds init)
+    if (!(e.code === 'MODULE_NOT_FOUND' && e.message.includes('package.json'))) throw e
+  }
+}
+
+/**
+ * @param {string} project - The project to get the package.json from.
+ * @returns {JSON} The package.json of the given project.
+ */
+function getPackageJson (project) {
+  try {
+    return require(path.join(project, 'package.json'))
+  } catch (e) {
+    if (e.code !== 'MODULE_NOT_FOUND') throw e
+    return require(path.join(cds.root, project, 'package.json'))
+  }
+}

package/lib/bind/{cfKeyProvider.js → cf.js}

@@ -1,52 +1,47 @@
 const cds = require('../cds');
 const DEBUG = cds.log('cli')._debug
-
-const cfUtil = require('../util/cf');
+const cf = require('../util/cf');
 const { bold } = require('../util/term');
-const { mergeCredentials } = require('./index');
+const { mergeCredentials } = require('./shared');
 
-module.exports = new class CFKeyProvider {
-    async init() {
-        if (!this.target) {
-            this.target = await cfUtil.getCfSpaceInfo();
-        }
-    }
+module.exports = new class CFBind extends require('./plugin') {
 
-    async getOrg(orgName) {
-        const result = await cfUtil.cfRequest('/v3/organizations', { names: orgName });
-        return result?.resources?.[0];
-    }
+    /* Public API */
 
-    async getSpace(orgGuid, spaceName) {
-        const result = await cfUtil.cfRequest('/v3/spaces', { names: spaceName, organization_guids: orgGuid });
-        return result?.resources?.find(r => r.relationships.organization.data.guid === orgGuid);
+    displayName() {
+        return 'Cloud Foundry'
     }
 
-    async getInstance(spaceGuid, instanceName) {
-        const result = await cfUtil.cfRequest('/v3/service_instances', { names: instanceName, space_guids: spaceGuid });
-        return result?.resources?.find(r => !!r.relationships.space.data.guid);
+    binding4(service) {
+        const [instance, key] = service.split(/:/)
+        return { instance, key }
     }
 
-    async getPlan(planGuid) {
-        const result = await cfUtil.cfRequest('/v3/service_plans', { guids: planGuid });
-        return result?.resources?.[0];
+    description4(binding) {
+        if (binding.key) {
+            return `managed service ${bold(binding.instance + ':' + binding.key)}`
+        } else {
+            return `user provided service ${bold(binding.instance)}`
+        }
     }
 
-    async getOffering(offeringGuid) {
-        const result = await cfUtil.cfRequest('/v3/service_offerings', { guids: offeringGuid });
-        return result?.resources?.[0];
+    service4({ instance, key }, services) {
+        const toServices = Array.isArray(services) ? services.map(s => s.binding.instance) : services.split(',')
+        const service = toServices.find(s => s === instance || s === instance + ':' + key)
+        if (!service) throw `service '${instance}:${key}' not found`
+        return service
     }
 
     async resolve(name, binding) {
-        await this.init();
-        this._checkApiEndpoint(name, binding)
+        this.target ??= await cf.target()
+        this.#checkApiEndpoint(name, binding)
 
         let { instance, org, space } = binding;
         let spaceGuid, orgGuid;
         if (org && space) {
             // org and space can be overwritten by currently logged in org and space
-            const orgObj = await this.getOrg(org);
-            const spaceObj = await this.getSpace(orgObj.guid, space);
+            const orgObj = await cf.org(org);
+            const spaceObj = await cf.space(orgObj.guid, space);
             spaceGuid = spaceObj.guid;
             orgGuid = orgObj.guid;
         } else {
@@ -58,41 +53,43 @@ module.exports = new class CFKeyProvider {
 
         let instanceObj;
         try {
-            instanceObj = await this.getInstance(spaceGuid, instance);
+            instanceObj = await cf.instance(spaceGuid, instance);
             const instanceSpaceGuid = instanceObj.relationships.space.data.guid;
             if (instanceSpaceGuid !== spaceGuid) {
                 // service instance is shared from another space, service key must be created in that space
-                const sharedFromSpaceObj = await cfUtil.cfRequest('/v3/spaces/' + encodeURIComponent(instanceSpaceGuid));
+                const sharedFromSpaceObj = await cf.curl('/v3/spaces/' + encodeURIComponent(instanceSpaceGuid));
                 space = sharedFromSpaceObj.name;
                 spaceGuid = sharedFromSpaceObj.guid;
                 const instanceOrgGuid = sharedFromSpaceObj.relationships.organization.data.guid;
                 if (instanceOrgGuid !== orgGuid) {
-                    const sharedFromOrgObj = await cfUtil.cfRequest('/v3/organizations/' + encodeURIComponent(instanceOrgGuid));
+                    const sharedFromOrgObj = await cf.curl('/v3/organizations/' + encodeURIComponent(instanceOrgGuid));
                     org = sharedFromOrgObj.name;
                     orgGuid = sharedFromOrgObj.guid;
                 }
             }
         } catch (error) {
-            throw `Service instance ${bold(instance)} not found.`;
+            throw `service instance ${bold(instance)} not found.`;
         }
         switch (instanceObj.type) {
             case 'managed':
-                return this._resolveManagedService(instanceObj, instance, binding.key || `${instance}-key`, org, space, binding.credentials);
+                return this.#resolveManagedService(instanceObj, instance, binding.key || `${instance}-key`, org, space, binding.credentials);
             case 'user-provided':
-                return this._resolveUserProvidedService(instanceObj, instance, org, space, binding.credentials);
+                return this.#resolveUserProvidedService(instanceObj, instance, org, space, binding.credentials);
             default:
                 throw `Service type ${bold(instanceObj.type)} not supported`;
         }
     }
 
-    async _resolveManagedService(instanceObj, instance, key, org, space, customCredentials) {
+    /* Private helpers */
+
+    async #resolveManagedService(instanceObj, instance, key, org, space, customCredentials) {
         const create = (cds.cli.command === 'bind' || cds.cli.command === 'deploy') && !cds.cli.options['no-create-service-key']
         const silent = (cds.cli.options.json || cds.cli.command === 'env') && !DEBUG
-        const planObj = await this.getPlan(instanceObj.relationships.service_plan.data.guid);
-        const offeringObj = await this.getOffering(planObj.relationships.service_offering.data.guid);
+        const planObj = await cf.plan(instanceObj.relationships.service_plan.data.guid);
+        const offeringObj = await cf.offering(planObj.relationships.service_offering.data.guid);
         const parameters = offeringObj.name === "identity" ? { "credential-type": "X509_GENERATED", "app-identifier" : "cds_bind" } : {};
 
-        const credentials = await cfUtil.getOrCreateServiceKey(instanceObj, key, parameters, { create, silent });
+        const credentials = await cf.getOrCreateServiceKey(instanceObj, key, parameters, { create, silent });
         if (!credentials) {
             let message = `No service key ${bold(key)} found for service instance ${bold(instance)}.\n\n`;
             message += `Use ${bold(`cf create-service-key ${instanceObj.name} ${key} [-c ...]`)} to create the required service key.`;
@@ -103,16 +100,12 @@ module.exports = new class CFKeyProvider {
             binding: {
                 type: "cf",
                 apiEndpoint: this.target.apiEndpoint,
-                org: org,
-                space: space,
-                instance: instance,
-                key: key,
+                org, space, instance, key,
                 vcap: {
                     label: offeringObj.name,
                     plan: planObj.name,
                     tags: offeringObj.tags
-                },
-                resolved: true,
+                }
             },
             credentials: mergeCredentials(credentials, customCredentials)
         };
@@ -120,27 +113,24 @@ module.exports = new class CFKeyProvider {
         return resolvedBinding;
     }
 
-    async _resolveUserProvidedService(instanceObj, instance, org, space, customCredentials) {
-        const credentials = await cfUtil.cfRequest(`/v3/service_instances/${encodeURIComponent(instanceObj.guid)}/credentials`);
+    async #resolveUserProvidedService(instanceObj, instance, org, space, customCredentials) {
+        const credentials = await cf.curl(`/v3/service_instances/${encodeURIComponent(instanceObj.guid)}/credentials`);
         const resolvedBinding = {
             binding: {
                 type: "cf",
                 apiEndpoint: this.target.apiEndpoint,
-                org: org,
-                space: space,
-                instance: instance,
+                org, space, instance,
                 vcap: {
                     label: instanceObj.type,
                     tags: instanceObj.tags
-                },
-                resolved: true,
+                }
             },
             credentials: mergeCredentials(credentials, customCredentials)
         };
         return resolvedBinding;
     }
 
-    _checkApiEndpoint(name, binding) {
+    #checkApiEndpoint(name, binding) {
         const { apiEndpoint, key, instance } = binding
 
         // if no api endpoint is configured the currently logged in endpoint will be used

package/lib/bind/k8s.js

@@ -0,0 +1,138 @@
+const { execSync } = require('node:child_process')
+const { yaml } = require('../cds').utils
+const { mergeCredentials } = require('./shared')
+const { bold } = require('../util/term')
+
+module.exports = new class K8SBind extends require('./plugin') {
+
+  /* Public API */
+
+  displayName() {
+    return 'Kubernetes'
+  }
+
+  description4(binding) {
+    if (binding.name) {
+        return `service binding ${bold(binding.name)}`
+    } else {
+        return `secret ${bold(binding.secret)}`
+    }
+  }
+
+  binding4(service) {
+    return { name: service }
+  }
+
+  service4({ secret, name }, services) {
+    const toServices = Array.isArray(services) ? services.map(s => s.binding.name || s.binding.secret) : services.split(',')
+    const service = toServices.find(s => s === secret || s === name)
+    if (!service) throw `secret or binding '${secret || name}' not found`
+    return service
+  }
+
+  async resolve(name, binding) {
+    const { context, namespace, cluster } = await this.#context4(binding)
+
+    let { name: bindingName, secret, credentials: customCredentials } = binding
+
+    let instance
+    let secretOrBindingResource = 'secret'
+
+    if (bindingName) {
+      const bindingResource = await this.#data4({ context, namespace, kind: 'servicebindings', name: bindingName })
+      if (bindingResource === null) {
+        secret = bindingName // Fallback to secret instead of service binding
+        bindingName = undefined
+        secretOrBindingResource = 'service binding or secret'
+      } else {
+        const { secretName, serviceInstanceName } = bindingResource.spec
+        if (!secretName || !serviceInstanceName) throw 'secret name or service instance name not found in service binding.'
+        secret = secretName
+        instance = serviceInstanceName
+      }
+    }
+
+    const secretResource = await this.#data4({ context, namespace, kind: 'secrets', name: secret })
+    if (!secretResource) throw `${secretOrBindingResource} '${secret}' not found.`
+
+    const properties = Object.fromEntries(
+      Object.entries(secretResource.data).map(([key, value]) => [key, Buffer.from(value, 'base64').toString()])
+    )
+
+    // REVISIT: Proper API
+    // eslint-disable-next-line cds-dk/use-relative-require, cds-dk/use-api-require
+    const serviceBinding = require('@sap/cds/lib/env/serviceBindings').parseBinding('/', name, properties)
+    const { credentials } = serviceBinding
+    const vcap = { ...serviceBinding, credentials: undefined }
+
+    const resolvedBinding = {
+      binding: {
+        type: 'k8s',
+        name: bindingName,
+        cluster, instance, namespace, secret,
+        vcap
+      },
+      credentials: mergeCredentials(credentials, customCredentials)
+    }
+    return resolvedBinding
+  }
+
+  /* Private helpers */
+
+  async #data4({ context, namespace, kind, name }) {
+    try {
+      return JSON.parse(execSync(`kubectl --output json --context ${context} --namespace ${namespace} get ${kind} ${name}`).toString())
+    }
+    catch (error) {
+      if (error.status === 1) return null
+      else throw error
+    }
+  }
+
+  #configPromise
+  async #context4({ cluster, namespace }) {
+    if (!this.#configPromise) {
+      this.#configPromise = (async () => {
+        const raw = execSync('kubectl config view --raw').toString()
+        const { clusters, contexts, 'current-context': current } = yaml.parse(raw)
+        if (!current) throw 'no current context in kubectl config.'
+        const entry = contexts?.find(entry => entry.name === current && entry.context?.cluster && entry.context?.user)
+        if (!entry) throw 'current context not found in kubectl config.'
+        const clusterEntry = clusters?.find(clusterItem => clusterItem.name === entry.context?.cluster && clusterItem.cluster?.server)
+        if (!clusterEntry) throw `cluster ${bold(entry.cluster)} not found in kubectl config.`
+        const { cluster } = clusterEntry
+
+        const serverToContext = {}
+        for (const { name, cluster } of clusters) {
+          const contextEntries = contexts.filter(entry => entry.context.cluster === 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[cluster.server] = contextEntries[0]
+          }
+        }
+
+        return {
+          namespace: current.namespace || 'default',
+          context: entry,
+          cluster,
+          serverToContext
+        }
+      })()
+    }
+    const config = await this.#configPromise
+    let contextEntry
+
+    if (cluster && cluster !== config.cluster.server) {
+      const context = config.serverToContext[cluster]
+      if (context) contextEntry = context
+      else throw `cluster ${bold(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'
+    }
+  }
+}

package/lib/bind/plugin.js

@@ -0,0 +1,48 @@
+module.exports = class BindPlugin {
+
+  /**
+   * Returns the display name of the binding plugin
+   * @returns {string} The display name
+   */
+  displayName() {
+    throw new Error('displayName not implemented')
+  }
+
+  /**
+   * Returns a description for the given binding
+   * @param {Object} binding - The binding configuration object
+   * @returns {string} A description of the binding
+   */
+  description4(_binding) {
+    throw new Error('description4 not implemented')
+  }
+
+  /**
+   * Parses the [service]:[key] string into a binding configuration object
+   * @param {string} service - The passed service instance name
+   * @returns {Object} The parsed binding configuration
+   */
+  binding4(_service) {
+    throw new Error('binding4 not implemented')
+  }
+
+  /**
+   * Returns a description for the given binding
+   * @param {Object} binding - The binding configuration object
+   * @param {Object} services – Service candidates
+   * @returns {string} The name of the service matching the binding
+   */
+  service4(_binding, _services) {
+    throw new Error('credentials4 not implemented')
+  }
+
+  /**
+   * Resolves the binding configuration for the given service name
+   * @param {string} name - The name of the service
+   * @param {Object} binding - The binding configuration object
+   * @returns {Promise<{binding: Object, credentials: Object}>} A promise that resolves to the resolved binding
+   */
+  async resolve(_name, _binding) {
+    throw new Error('resolve not implemented')
+  }
+}