@sap/cds-dk 6.4.1 → 6.5.0

package/lib/bind/bindingUtil.js

@@ -1,4 +1,3 @@
-
 const os = require('os');
 const IS_WIN = os.platform() === 'win32';
 
@@ -22,128 +21,118 @@ const PreferredKinds = [
     'xsuaa'
 ];
 
-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;
+const PLATFORM_TYPES = {
+    'cf': 'Cloud Foundry',
+    'k8s': 'Kubernetes'
 }
 
-/**
- * Determine kind value for services based on VCAP binding
- * information in the configuration.
- */
-function determineKinds(services) {
-    const vcapServices = {}
-
-    // Build VCAP_SERVICES
-    for (const service of services) {
-        service.kindCandidates = [ ]
+class BindingUtil {
+    static 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;
+    }
 
-        const { vcap = {} } = service.binding || {};
-        let { label, type } = vcap;
-        type = type || label;
-        if (!type) continue;
+    /**
+     * Determine kind value for services based on VCAP binding
+     * information in the configuration.
+     */
+    static determineKinds(services) {
+        const vcapServices = {}
 
-        if (!vcapServices[type]) vcapServices[type] = [];
-        vcapServices[type].push({ credentials: { dummy: 'dummy' }, ...vcap, service });
-    }
+        // Build VCAP_SERVICES
+        for (const service of services) {
+            service.kindCandidates = []
 
-// Auto configure services based on VCAP_SERVICES
+            const { vcap = {} } = service.binding || {};
+            let { label, type } = vcap;
+            type = type || label;
+            if (!type) continue;
 
-    const cds = require('../cds');
-    const env = cds.env.for('cds', process.cwd());
+            if (!vcapServices[type]) vcapServices[type] = [];
+            vcapServices[type].push({ credentials: { dummy: 'dummy' }, ...vcap, service });
+        }
 
-    if (!env._find_credentials_for_required_service) {
-        throwError `Please provide a service kind or update @sap/cds version to use the kind detection.`;
-    }
+        // Auto configure services based on VCAP_SERVICES
 
-    function findKindFor(kind, service) {
-        const vcapService = env._find_credentials_for_required_service(kind, service, vcapServices);
-        if (!vcapService) return;
-        if (!Object.values(requires).find( require => require !== service && require.kind == kind ))
-            vcapService.service.kindCandidates.push(kind);
-    }
+        const cds = require('../cds');
+        const env = cds.env.for('cds', process.cwd());
 
-    const requires = env.requires.kinds || {};
-    for (const kind of Object.keys(requires)) {
-        const requireService = requires[kind];
-        findKindFor(kind, requireService);
-        findKindFor(kind, { kind });
-    }
+        if (!env._find_credentials_for_required_service) {
+            throw new Error(`Please provide a service kind or update @sap/cds version to use the kind detection.`);
+        }
 
-    // Check if one "kind" per service was found
-    for (const service of services) {
-        const preferredKind = service.kindCandidates.find( kind => PreferredKinds.indexOf(kind) >= 0);
-        if (preferredKind) {
-            service.kind = preferredKind;
-        } if (service.kindCandidates.length === 1) {
-            service.kind = service.kindCandidates[0];
+        function findKindFor(kind, service) {
+            const vcapService = env._find_credentials_for_required_service(kind, service, vcapServices);
+            if (!vcapService) return;
+            if (!Object.values(requires).find(require => require !== service && require.kind == kind))
+                vcapService.service.kindCandidates.push(kind);
         }
 
-        delete service.kindCandidates;
-    }
-}
+        const requires = env.requires.kinds || {};
+        for (const kind of Object.keys(requires)) {
+            const requireService = requires[kind];
+            findKindFor(kind, requireService);
+            findKindFor(kind, { kind });
+        }
 
-function execAndExit(options, command, ...args) {
-    const { spawnSync } = require('child_process');
-    // use shell with Windows only; without output is not visible and some commands cannot be run
-    const result = spawnSync(command, args, { stdio: 'inherit', shell: IS_WIN, ...options });
-    process.exit(result.status);
-}
+        // Check if one "kind" per service was found
+        for (const service of services) {
+            const preferredKind = service.kindCandidates.find(kind => PreferredKinds.indexOf(kind) >= 0);
+            if (preferredKind) {
+                service.kind = preferredKind;
+            } if (service.kindCandidates.length === 1) {
+                service.kind = service.kindCandidates[0];
+            }
 
-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;
+            delete service.kindCandidates;
+        }
     }
-}
-
-
-/**
- *
- * @param {string} msg
- * @returns {never}
- */
- function throwError(msg = 'Internal Error') {
-    throw new Error(msg);
-}
 
+    static execAndExit(options, command, ...args) {
+        const { spawnSync } = require('child_process');
+        // use shell with Windows only; without output is not visible and some commands cannot be run
+        const result = spawnSync(command, args, { stdio: 'inherit', shell: IS_WIN, ...options });
+        process.exit(result.status);
+    }
 
-const PLATFORM_TYPES = {
-    'cf': 'Cloud Foundry',
-    'k8s': 'Kubernetes'
-}
+    static async 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;
+        }
+    }
 
-function platformText(binding) {
-    return PLATFORM_TYPES[binding.type] || throwError(`Unexpected binding type "${binding.type}"`);
-}
+    static platformText(binding) {
+        if (!PLATFORM_TYPES[binding.type]) throw new Error(`Unexpected binding type "${binding.type}"`);
+        return PLATFORM_TYPES[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();
+    static bindingText(binding, highlight = t => t) {
+        switch (binding.type) {
+            case 'cf':
+                if (binding.key) {
+                    return `managed service ${highlight(binding.instance + ':' + binding.key)}`
+                } else {
+                    return `user provided service ${highlight(binding.instance)}`
+                }
+            case 'k8s':
+                if (binding.name) {
+                    return `service binding ${highlight(binding.name)}`
+                } else {
+                    return `secret ${highlight(binding.secret)}`
+                }
+            default:
+                throw new Error('Internal Error');
+        }
     }
-}
 
-module.exports = {
-    getRequiresNameFromKind,
-    determineKinds,
-    execAndExit,
-    checkIsJavaProject,
-    throwError,
-    platformText,
-    bindingText
+    static logger = { log: console.log }
 }
+
+module.exports = BindingUtil

package/lib/bind/cfKeyProvider.js

@@ -3,22 +3,20 @@ const fsp = require('fs').promises;
 const os = require('os');
 const util = require('util');
 
+const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) && console.debug
+
 const axios = require('axios');
 const { URL } = require('url');
 const path = require('path');
-const term = require('../util/term');
+const { bold, highlight } = require('../util/term');
+const { CliError } = require('../client/helper/errors');
 
 const execAsync = util.promisify(cp.exec);
 const IS_WIN = os.platform() === 'win32';
 
 class CFKeyProvider {
-
-    constructor() {
-        this.logger = console;
-    }
-
     async _cfRead(...args) {
-        this.logger.debug(`_cfRead: cf ${args}`);
+        DEBUG && DEBUG(`_cfRead: cf ${args}`);
 
         const result = await execAsync(`cf ${args}`, {
             shell: IS_WIN,
@@ -28,20 +26,6 @@ class CFKeyProvider {
         return result.stdout.toString().trim();
     }
 
-    async _req(target, urlPath) {
-        const url = new URL(urlPath, target.apiEndpoint);
-
-        this.logger.debug(`_req: ${url.toString()}`);
-
-        const result = await axios.get(url.toString(), {
-            headers: {
-                authorization: target.authorization
-            }
-        });
-
-        return result.data;
-    }
-
     extract(string, pattern, errorMsg) {
         const match = string.match(pattern);
         if (!match || !match[1]) {
@@ -63,7 +47,7 @@ class CFKeyProvider {
                 }
             }
         } catch (err) {
-            this.logger.debug(`getCfTargetFromConfigFile: ${err}`);
+            DEBUG && DEBUG(`getCfTargetFromConfigFile: ${err}`);
         }
     }
 
@@ -82,7 +66,7 @@ class CFKeyProvider {
     }
 
     async getCfSpaceInfo() {
-        this.logger.debug('getting space info');
+        DEBUG && DEBUG('getting space info');
 
         const target = await this.getCfTarget();
         const authorization = await this.getCfAuthorization();
@@ -90,13 +74,13 @@ class CFKeyProvider {
 
 
         const { org, space } = target;
-        const orgs = await this._req(targetWithAuth, `/v3/organizations?names=${encodeURIComponent(encodeURIComponent(org))}`);
+        const orgs = await BatchRequest.req(targetWithAuth, `/v3/organizations?names=${encodeURIComponent(encodeURIComponent(org))}`);
         if (!(orgs && orgs.resources.length === 1)) {
             throw new Error(`CF org ${org} not found!`);
         }
 
         const orgGuid = orgs.resources[0].guid;
-        const spaces = await this._req(targetWithAuth, `/v3/spaces?names=${encodeURIComponent(encodeURIComponent(space))}&organization_guids=${encodeURIComponent(encodeURIComponent(orgGuid))}`)
+        const spaces = await BatchRequest.req(targetWithAuth, `/v3/spaces?names=${encodeURIComponent(encodeURIComponent(space))}&organization_guids=${encodeURIComponent(encodeURIComponent(orgGuid))}`)
         if (!(spaces && spaces.resources.length === 1)) {
             throw new Error(`CF space ${space} not found in org ${org}!`);
         }
@@ -107,35 +91,30 @@ class CFKeyProvider {
     }
 
     async getCfAuthorization() {
-        this.logger.debug('getting authorization');
+        DEBUG && DEBUG('getting authorization');
         return this._cfRead('oauth-token');
     }
 
-    setLogger(logger) {
-        this.logger = logger;
-    }
-
     async init() {
         const target = this.target = await this.getCfSpaceInfo();
-        const logger = this.logger;
-        this.getOrg = BatchRequest.create({ logger, target, url: '/v3/organizations' });
+        this.getOrg = BatchRequest.create({ target, url: '/v3/organizations' });
         this.getSpace = BatchRequest.create({
-            logger, target, url: '/v3/spaces', extractors: {
+            target, url: '/v3/spaces', extractors: {
                 organization_guids: resource => resource.relationships.organization.data.guid
             }
         });
         this.getInstance = BatchRequest.create({
-            logger, target, url: '/v3/service_instances', extractors: {
+            target, url: '/v3/service_instances', extractors: {
                 space_guids: resource => resource.relationships.space.data.guid
             }
         });
         this.getKey = BatchRequest.create({
-            logger, target, url: '/v3/service_credential_bindings', extractors: {
+            target, url: '/v3/service_credential_bindings', extractors: {
                 service_instance_guids: resource => resource.relationships.service_instance.data.guid
             }
         });
-        this.getPlans = BatchRequest.create({ logger, target, url: '/v3/service_plans' });
-        this.getOfferings = BatchRequest.create({ logger, target, url: '/v3/service_offerings' });
+        this.getPlans = BatchRequest.create({ target, url: '/v3/service_plans' });
+        this.getOfferings = BatchRequest.create({ target, url: '/v3/service_offerings' });
     }
 
     async resolve(name, binding) {
@@ -143,29 +122,19 @@ class CFKeyProvider {
             this.initPromise = this.init();
         }
         await this.initPromise;
+        this._checkApiEndpoint(name, binding)
 
-        const target = this.target;
-
-        let { instance, key, apiEndpoint, org, space } = binding;
-        key = key || `${instance}-key`;
-        name = name || `${instance}:${key}`;
-
-        if (apiEndpoint && apiEndpoint !== target.apiEndpoint) {
-            let message = `Current Cloud Foundry API endpoint "${target.apiEndpoint}" differs from API endpoint "${apiEndpoint}" for service binding "${name}".\n`;
-            message += `Use ${term.bold(`cf login -a ${apiEndpoint}`)} to log in to the target API endpoint.`;
-            console.log(message);
-            process.exit(1);
-        }
-
+        let { instance, org, space } = binding;
         let spaceGuid;
         if (org && space) {
+            // org and space can be overwritten by currently logged in org and space
             const orgObj = await this.getOrg({ names: org });
             const spaceObj = await this.getSpace({ names: space, organization_guids: orgObj.guid });
             spaceGuid = spaceObj.guid;
         } else {
-            org = target.org;
-            space = target.space;
-            spaceGuid = target.spaceGuid;
+            org = this.target.org;
+            space = this.target.space;
+            spaceGuid = this.target.spaceGuid;
         }
 
         let instanceObj;
@@ -174,19 +143,32 @@ class CFKeyProvider {
         } catch (error) {
             throw new Error(`Service instance "${instance}" not found.`);
         }
-        let keyObj;
+        switch (instanceObj.type) {
+            case 'managed':
+                return this._resolveManagedService(instanceObj, instance, binding.key || `${instance}-key`, org, space);
+            case 'user-provided':
+                return this._resolveUserProvidedService(instanceObj, instance, org, space);
+            default:
+                throw new Error(`Service type ${instanceObj.type} not supported`)
+        }
+    }
+
+    async _resolveManagedService(instanceObj, instance, key, org, space) {
+        let keyObj
         try {
             keyObj = await this.getKey({ names: key, service_instance_guids: instanceObj.guid });
         } catch (error) {
-            throw new Error(`No service key "${key}" found for service instance "${instance}".`);
+            let message = `No service key ${highlight(key)} found for service instance ${highlight(instance)}.\n\n`;
+            message += `Use ${bold(`cf create-service-key ${instanceObj.name} ${key} [-c ...]`)} to create the required service key.`;
+            throw new CliError(message);
         }
         const planObj = await this.getPlans({ guids: instanceObj.relationships.service_plan.data.guid });
         const offeringObj = await this.getOfferings({ guids: planObj.relationships.service_offering.data.guid });
-        const keyCredentialsObj = await req(this.logger, target, `/v3/service_credential_bindings/${encodeURIComponent(keyObj.guid)}/details`);
+        const keyCredentialsObj = await BatchRequest.req(this.target, `/v3/service_credential_bindings/${encodeURIComponent(keyObj.guid)}/details`);
         const resolvedBinding = {
             binding: {
                 type: "cf",
-                apiEndpoint: target.apiEndpoint,
+                apiEndpoint: this.target.apiEndpoint,
                 org: org,
                 space: space,
                 instance: instance,
@@ -203,11 +185,42 @@ class CFKeyProvider {
 
         return resolvedBinding;
     }
+
+    async _resolveUserProvidedService(instanceObj, instance, org, space) {
+        const credentialsObj = await BatchRequest.req(this.target, `/v3/service_instances/${encodeURIComponent(instanceObj.guid)}/credentials`);
+        const resolvedBinding = {
+            binding: {
+                type: "cf",
+                apiEndpoint: this.target.apiEndpoint,
+                org: org,
+                space: space,
+                instance: instance,
+                vcap: {
+                    label: instanceObj.type,
+                    tags: instanceObj.tags
+                },
+                resolved: true,
+            },
+            credentials: credentialsObj
+        };
+        return resolvedBinding;
+    }
+
+    _checkApiEndpoint(name, binding) {
+        const { apiEndpoint, key, instance } = binding
+
+        // if no api endpoint is configured the currently logged in endpoint will be used
+        if (apiEndpoint && apiEndpoint !== this.target.apiEndpoint) {
+            name = `${name || instance}:${key || instance + '-key'}`
+            let message = `Current Cloud Foundry API endpoint ${highlight(this.target.apiEndpoint)} differs from API endpoint ${highlight(apiEndpoint)} for service binding ${highlight(name)}.\n\n`;
+            message += `Use ${bold(`cf login -a ${apiEndpoint}`)} to log in to the target API endpoint.`;
+            throw new CliError(message)
+        }
+    }
 }
 
 class BatchRequest {
-    constructor({ logger, target, url, extractors = {} }) {
-        this.logger = logger;
+    constructor({ target, url, extractors = {} }) {
         this.target = target;
         this.url = url;
         this.filters = [];
@@ -247,7 +260,7 @@ class BatchRequest {
         }
 
         const params = Object.keys(filterParams).map(
-            name => `${name}=${encodeURIComponent(filterParams[name].map(value => encodeURIComponent(value)).join(','))}`
+            name => `${name}=${encodeURIComponent(filterParams[name].map(encodeURIComponent).join(','))}`
         ).join("&");
 
         const url = this.url + (this.url.match(/\?/) ? '&' : '?') + params;
@@ -279,22 +292,20 @@ class BatchRequest {
     }
 
     async httpRequest(urlPath) {
-        return req(this.logger, this.target, urlPath);
+        return BatchRequest.req(this.target, urlPath);
     }
-}
-
-async function req(logger, target, urlPath) {
-    const url = new URL(urlPath, target.apiEndpoint);
-
-    logger.debug(`_req: ${url.toString()}`);
 
-    const result = await axios.get(url.toString(), {
-        headers: {
-            authorization: target.authorization
-        }
-    });
+    static async req(target, urlPath) {
+        const url = new URL(urlPath, target.apiEndpoint);
+        DEBUG && DEBUG(`_req: ${url.toString()}`);
 
-    return result.data;
+        const result = await axios.get(url.toString(), {
+            headers: {
+                authorization: target.authorization
+            }
+        });
+        return result.data;
+    }
 }
 
-module.exports = new CFKeyProvider();
+module.exports = new CFKeyProvider()