@sap/cds-dk 7.8.2 → 7.9.1

package/lib/bind/cfKeyProvider.js

@@ -2,109 +2,102 @@ const cds = require('../cds');
 const DEBUG = cds.debug('cli')
 
 const cfUtil = require('../util/cf');
-
-const axios = require('axios');
-require('../util/axios').pruneErrors();
-const { URL } = require('url');
-const { bold, highlight } = require('../util/term');
+const { bold } = require('../util/term');
+const { mergeCredentials } = require('./index');
 
 module.exports = new class CFKeyProvider {
-    async getCfSpaceInfo() {
-        DEBUG?.('getting space info');
-
-        const target = await cfUtil.getCfTarget();
-        const authorization = await cfUtil.getCfAuthorization();
-        const targetWithAuth = Object.assign({}, target, { authorization });
-
-
-        const { org, space } = target;
-        const orgs = await BatchRequest.req(targetWithAuth, `/v3/organizations?names=${encodeURIComponent(encodeURIComponent(org))}`);
-        if (!(orgs && orgs.resources.length === 1)) {
-            throw `CF org ${org} not found!`;
+    async init() {
+        if (!this.target) {
+            this.target = await cfUtil.getCfSpaceInfo();
         }
+    }
 
-        const orgGuid = orgs.resources[0].guid;
-        const spaces = await BatchRequest.req(targetWithAuth, `/v3/spaces?names=${encodeURIComponent(encodeURIComponent(space))}&organization_guids=${encodeURIComponent(encodeURIComponent(orgGuid))}`)
-        if (!(spaces && spaces.resources.length === 1)) {
-            throw `CF space ${space} not found in org ${org}!`;
-        }
+    async getOrg(orgName) {
+        const result = await cfUtil.cfRequest('/v3/organizations', { names: orgName });
+        return result?.resources?.[0];
+    }
 
-        const spaceGuid = spaces.resources[0].guid;
+    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);
+    }
 
-        return Object.assign({}, target, { orgGuid, spaceGuid, authorization });
+    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);
     }
 
-    async init() {
-        const target = this.target = await this.getCfSpaceInfo();
-        this.getOrg = BatchRequest.create({ target, url: '/v3/organizations' });
-        this.getSpace = BatchRequest.create({
-            target, url: '/v3/spaces', extractors: {
-                organization_guids: resource => resource.relationships.organization.data.guid
-            }
-        });
-        this.getInstance = BatchRequest.create({
-            target, url: '/v3/service_instances', extractors: {
-                space_guids: resource => resource.relationships.space.data.guid
-            }
-        });
-        this.getKey = BatchRequest.create({
-            target, url: '/v3/service_credential_bindings', extractors: {
-                service_instance_guids: resource => resource.relationships.service_instance.data.guid
-            }
-        });
-        this.getPlans = BatchRequest.create({ target, url: '/v3/service_plans' });
-        this.getOfferings = BatchRequest.create({ target, url: '/v3/service_offerings' });
+    async getPlan(planGuid) {
+        const result = await cfUtil.cfRequest('/v3/service_plans', { guids: planGuid });
+        return result?.resources?.[0];
+    }
+
+    async getOffering(offeringGuid) {
+        const result = await cfUtil.cfRequest('/v3/service_offerings', { guids: offeringGuid });
+        return result?.resources?.[0];
     }
 
     async resolve(name, binding) {
-        if (!this.initPromise) {
-            this.initPromise = this.init();
-        }
-        await this.initPromise;
+        await this.init();
         this._checkApiEndpoint(name, binding)
 
         let { instance, org, space } = binding;
-        let spaceGuid;
+        let spaceGuid, orgGuid;
         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 });
+            const orgObj = await this.getOrg(org);
+            const spaceObj = await this.getSpace(orgObj.guid, space);
             spaceGuid = spaceObj.guid;
+            orgGuid = orgObj.guid;
         } else {
             org = this.target.org;
             space = this.target.space;
             spaceGuid = this.target.spaceGuid;
+            orgGuid = this.target.orgGuid;
         }
 
         let instanceObj;
         try {
-            instanceObj = await this.getInstance({ names: instance, space_guids: spaceGuid });
+            instanceObj = await this.getInstance(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));
+                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));
+                    org = sharedFromOrgObj.name;
+                    orgGuid = sharedFromOrgObj.guid;
+                }
+            }
         } catch (error) {
-            throw `Service instance "${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);
+                return this._resolveManagedService(instanceObj, instance, binding.key || `${instance}-key`, org, space, binding.credentials);
             case 'user-provided':
-                return this._resolveUserProvidedService(instanceObj, instance, org, space);
+                return this._resolveUserProvidedService(instanceObj, instance, org, space, binding.credentials);
             default:
-                throw `Service type ${instanceObj.type} not supported`;
+                throw `Service type ${bold(instanceObj.type)} not supported`;
         }
     }
 
-    async _resolveManagedService(instanceObj, instance, key, org, space) {
+    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 credentials = await cfUtil.getOrCreateServiceKey(instanceObj, key, {}, { create, silent });
 
         if (!credentials) {
-            let message = `No service key ${highlight(key)} found for service instance ${highlight(instance)}.\n\n`;
+            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.`;
             throw 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 planObj = await this.getPlan(instanceObj.relationships.service_plan.data.guid);
+        const offeringObj = await this.getOffering(planObj.relationships.service_offering.data.guid);
         const resolvedBinding = {
             binding: {
                 type: "cf",
@@ -120,14 +113,14 @@ module.exports = new class CFKeyProvider {
                 },
                 resolved: true,
             },
-            credentials
+            credentials: mergeCredentials(credentials, customCredentials)
         };
 
         return resolvedBinding;
     }
 
-    async _resolveUserProvidedService(instanceObj, instance, org, space) {
-        const credentialsObj = await BatchRequest.req(this.target, `/v3/service_instances/${encodeURIComponent(instanceObj.guid)}/credentials`);
+    async _resolveUserProvidedService(instanceObj, instance, org, space, customCredentials) {
+        const credentials = await cfUtil.cfRequest(`/v3/service_instances/${encodeURIComponent(instanceObj.guid)}/credentials`);
         const resolvedBinding = {
             binding: {
                 type: "cf",
@@ -141,7 +134,7 @@ module.exports = new class CFKeyProvider {
                 },
                 resolved: true,
             },
-            credentials: credentialsObj
+            credentials: mergeCredentials(credentials, customCredentials)
         };
         return resolvedBinding;
     }
@@ -152,97 +145,9 @@ module.exports = new class CFKeyProvider {
         // 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`;
+            let message = `Current Cloud Foundry API endpoint ${bold(this.target.apiEndpoint)} differs from API endpoint ${bold(apiEndpoint)} for service binding ${bold(name)}.\n\n`;
             message += `Use ${bold(`cf login -a ${apiEndpoint}`)} to log in to the target API endpoint.`;
             throw message;
         }
     }
 }
-
-class BatchRequest {
-    constructor({ target, url, extractors = {} }) {
-        this.target = target;
-        this.url = url;
-        this.filters = [];
-        this.timeout = undefined;
-        this.extractors = Object.assign({ names: resource => resource.name, guids: resource => resource.guid }, extractors);
-    }
-
-    static create(options) {
-        const obj = new BatchRequest(options);
-        return (...args) => obj.request(...args);
-    }
-
-    async request(filter) {
-        let resolve;
-        let reject;
-        const promise = new Promise((_resolve, _reject) => {
-            resolve = _resolve;
-            reject = _reject;
-        });
-        this.filters.push({ filter, resolve, reject });
-
-        if (this.timeout) clearTimeout(this.timeout);
-        this.timeout = setTimeout(() => this.executeRequest(), 0);
-
-        return promise;
-    }
-
-    async executeRequest() {
-        const filters = this.filters;
-        this.filters = [];
-        const filterParams = {};
-        for (const filter of filters) {
-            for (const name of Object.keys(filter.filter)) {
-                if (!filterParams[name]) filterParams[name] = [];
-                filterParams[name].push(filter.filter[name]);
-            }
-        }
-
-        const params = Object.keys(filterParams).map(
-            name => `${name}=${encodeURIComponent(filterParams[name].map(encodeURIComponent).join(','))}`
-        ).join("&");
-
-        const url = this.url + (this.url.match(/\?/) ? '&' : '?') + params;
-
-        let data;
-        try {
-            data = await this.httpRequest(url);
-        } catch (error) {
-            for (const filter of filters) {
-                filter.reject(error);
-            }
-            return;
-        }
-        const fmt = filter => Object.keys(filter).map(key => `${key}: ${filter[key]}`).join(', ');
-        const resources = data.resources;
-        for (const filter of filters) {
-            let filteredResources = resources;
-            for (const name of Object.keys(filter.filter)) {
-                filteredResources = filteredResources.filter(resource => this.extractors[name](resource) === filter.filter[name]);
-            }
-            if (filteredResources.length === 1) {
-                filter.resolve(filteredResources[0]);
-            } else if (filteredResources.length === 0) {
-                filter.reject(`Couldn't find resource for url "${this.url}" with filter "${fmt(filter.filter)}"`);
-            } else {
-                filter.reject(`Found more than one resources for url "${this.url}" with filter "${fmt(filter.filter)}"`);
-            }
-        }
-    }
-
-    async httpRequest(urlPath) {
-        return BatchRequest.req(this.target, urlPath);
-    }
-
-    static async req(target, urlPath) {
-        const url = new URL(urlPath, target.apiEndpoint);
-        DEBUG?.(`_req: ${url.toString()}`);
-        const result = await axios.get(url.toString(), {
-            headers: {
-                authorization: target.authorization
-            }
-        });
-        return result.data;
-    }
-}

package/lib/bind/index.js

@@ -2,10 +2,10 @@ const cds = require('../cds');
 
 const BindingResolver = require('./bindingResolver');
 const { determineKinds, getRequiresNameFromKind, checkIsJavaProject, platformText, bindingText, logger } = require('./bindingUtil');
-const { highlight, bold, info } = require('../util/term');
+const { bold } = require('../util/term');
 
 
-module.exports = { bind, parseProfile }
+module.exports = { bind, storeBindings, parseProfile, mergeCredentials }
 
 /**
  * Executes cds build in the directory defined by cds.root.
@@ -13,11 +13,8 @@ module.exports = { bind, parseProfile }
  * @param {object} options - command options as defined by build command.
  */
 async function bind(options) {
-
-    options.for = options.for || 'hybrid';
-
     let on;
-    switch(options.on) {
+    switch (options.on) {
         case 'k8s':
         case 'kubernetes':
             on = 'k8s';
@@ -33,36 +30,26 @@ async function bind(options) {
     }
 
     const onText = { 'cf': 'Cloud Foundry', 'k8s': 'Kubernetes' }[on];
-    if (!options['to-app-services']) logger.log(`Retrieving data from ${onText}...`);
+    if (!options['to-app-services']) logger.log(`Retrieving data from ${bold(onText)}...`);
     let resolvedServices
 
     const targets = options.to.split(/,/g);
-    try {
-        resolvedServices = 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 {
-                throw new Error('Internal Error');
-            }
-            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}}`)
+    resolvedServices = 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 {
+            throw new Error('Internal Error');
         }
-        throw error
-    }
+        const resolvedService = await BindingResolver.resolveBinding(undefined, binding);
+        resolvedService._target = target;
+        delete resolvedService.credentials;
+        resolvedService.binding.resolved = false;
+        return resolvedService;
+    }));
 
     if (options.kind) {
         resolvedServices.forEach(service => service.kind = options.kind);
@@ -80,12 +67,16 @@ async function bind(options) {
         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)
+        const kindText = kind ? ` with kind ${bold(kind)}` : ''
+        const nameText = bold(name)
 
-        logger.log(`Binding ${nameText} to ${platformText(binding)} ${bindingText(binding, highlight)}${kindText}`);
+        logger.log(`Binding ${nameText} to ${platformText(binding)} ${bindingText(binding)}${kindText}`);
     }
 
+    return resolvedServices;
+}
+
+async function storeBindings(resolvedServices, options) {
     // prepare for different providers
     const userCdsrcJsonStorageProvider = require('./userCdsrcJsonStorageProvider');
 
@@ -95,7 +86,7 @@ async function bind(options) {
 
     const isJavaProject = await checkIsJavaProject(cds.root);
     if (!cds.cli.options['to-app-services']) {
-        logger.log(`${info('TIP:')} Run with cloud bindings: ${bold(runCmd(options.for, isJavaProject))}`);
+        logger.log(`\nTo run with cloud bindings use ${bold(runCmd(options.for, isJavaProject))}`);
     }
 }
 
@@ -115,3 +106,22 @@ function parseProfile(profile) {
     else if (profile === '-') return 'development';
     else return profile;
 }
+
+function mergeCredentials(credentials, customCredentials) {
+    if (!customCredentials) return credentials;
+
+    for (const key in customCredentials) {
+        if (typeof customCredentials[key] === 'object') {
+            if (credentials[key] && typeof credentials[key] !== 'object') {
+                throw `Cannot merge credentials: '${key}' is not an object`;
+            }
+            if (!credentials[key]) {
+                credentials[key] = {};
+            }
+            credentials[key] = this._mergeCredentials(credentials[key], customCredentials[key]);
+        } else {
+            credentials[key] = customCredentials[key];
+        }
+    }
+    return credentials;
+}

package/lib/bind/kubernetesCredentialsProvider.js

@@ -1,4 +1,5 @@
 const KubernetesApiAccessor = require('./KubernetesApiAccessor');
+const { mergeCredentials } = require('./index');
 
 class KubernetesCredentialsProvider {
     async init() {
@@ -12,14 +13,14 @@ class KubernetesCredentialsProvider {
         await this.initPromise;
 
 
-        const {context, namespace, cluster} = await this.api.context({cluster: binding.cluster, namespace: binding.namespace});
-        let {name: bindingName, secret} = binding;
+        const { context, namespace, cluster } = await this.api.context({ cluster: binding.cluster, namespace: binding.namespace });
+        let { name: bindingName, secret, credentials: customCredentials } = binding;
 
         let instance;
         let secretOrBindingResource = 'Secret';
 
         if (bindingName) {
-            const bindingResource = await this.api.get({context, namespace, kind: 'servicebindings', name: bindingName});
+            const bindingResource = await this.api.get({ context, namespace, kind: 'servicebindings', name: bindingName });
             if (bindingResource === null) {
                 // Fallback to secret instead of service binding;
                 secret = bindingName;
@@ -35,7 +36,7 @@ class KubernetesCredentialsProvider {
             }
         }
 
-        const secretResource = await this.api.get({context, namespace, kind: 'secrets', name: secret});
+        const secretResource = await this.api.get({ context, namespace, kind: 'secrets', name: secret });
         if (secretResource === null) throw new Error(`${secretOrBindingResource} '${secret}' not found.`);
 
         const serviceBinding = this._readBinding(name, secretResource);
@@ -53,7 +54,7 @@ class KubernetesCredentialsProvider {
                 resolved: true,
                 vcap
             },
-            credentials
+            credentials: mergeCredentials(credentials, customCredentials)
         };
 
         return resolvedBinding;

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -3,7 +3,7 @@ const path = require('path');
 const readline = require('readline');
 
 const fs = require('fs').promises;
-const { highlight } = require('../util/term');
+const { bold } = require('../util/term');
 const { logger } = require('./bindingUtil');
 
 const gitUtil = require('../util/git');
@@ -38,7 +38,6 @@ class UserCdsrcJsonStorageProvider {
         }
 
         jsonPath = jsonPath.replace(/~/g, os.homedir());
-        // const stat = await .stat(jsonPath);
         if (path.extname(jsonPath) !== '.json') {
             jsonPath = path.join(jsonPath, '.cdsrc.json');
         }
@@ -63,12 +62,14 @@ class UserCdsrcJsonStorageProvider {
         for (const service of services) {
             const { name, kind, binding, credentials } = service;
             const requireService = section[name] = section[name] || {};
+            // store optional custom credentials
+            binding.credentials = this._getServiceCredentials(binding, services, options);
 
             Object.assign(requireService, { binding: { ...binding, vcap: undefined }, credentials, kind, vcap: { name } });
         }
 
         await this.writeJsonFile(jsonPath, jsonObject);
-        logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.for)}`);
+        logger.log(`Saving bindings to ${bold(jsonPath)} in profile ${bold(options.for)}`);
     }
 
     async readJsonSafely(filePath) {
@@ -84,6 +85,27 @@ class UserCdsrcJsonStorageProvider {
         await fs.writeFile(filePath, JSON.stringify(content, null, 2));
         await fs.chmod(filePath, 0o600); // -rw-------
     }
+
+    _getServiceCredentials(binding, services, options) {
+        const { to, 'to-app-services': app, credentials } = options;
+        if (!credentials) {
+            return
+        }
+        // toService has format <service-name>[:<key>]
+        const toServices = to ? to.split(',') : services.map(s => s.binding.instance);
+        const toService = toServices.find(toService => binding.type === 'cf' ?
+            toService === binding.instance || toService === binding.instance + ':' + binding.key :
+            toService === binding.secret);
+        if (!toService) {
+            // must never happen
+            throw new Error(`Internal error: Service ${binding.instance}:${binding.key} not found`);
+        }
+        // app based binding always requires service name as key in credentials
+        if (!app && toServices.length === 1) {
+            return credentials[toService] || credentials;
+        }
+        return credentials[toService];
+    }
 }
 
 module.exports = new UserCdsrcJsonStorageProvider();

package/lib/build/buildTaskEngine.js

@@ -227,7 +227,7 @@ class BuildTaskEngine {
                 files.length = LOG_LIMIT
                 files.push(`... ${length - files.length} more. Run with DEBUG=build to show all files.`)
             }
-            console.log(`done > wrote output to:\n   ${term.secondary(files.join("\n   "))}\n`)
+            console.log(`done > wrote output to:\n   ${term.dim(files.join("\n   "))}\n`)
         }
     }
 

package/lib/build/provider/hana/index.js

@@ -398,7 +398,7 @@ class HanaBuildPlugin extends InternalBuildPlugin {
      * Create .hdiconfig file in <dest>src/gen folder of db module.
      */
     async _writeHdiConfig(compileHdiPlugins) {
-        const DEFAULT_HDI_PLUGINS = [FILE_EXT_CSV, FILE_EXT_HDBTABLEDATA, FILE_EXT_HDBTABLE, ".hdbview", ".hdbindex", ".hdbconstraint"]
+        const DEFAULT_HDI_PLUGINS = [FILE_EXT_CSV, FILE_EXT_HDBTABLEDATA, FILE_EXT_HDBTABLE, ".hdbview", ".hdbindex", ".hdbconstraint", ".hdbcalculationview"]
         const undeployHdiPlugins = await this._readTypesFromUndeployJson() // see CAP issue #6222
         const hdiPlugins = new Set([...DEFAULT_HDI_PLUGINS, ...undeployHdiPlugins, ...compileHdiPlugins])
         let hdiConfigPath

package/lib/build/provider/hana/template/undeploy.json

@@ -1,5 +1,7 @@
 [
     "src/gen/**/*.hdbview",
     "src/gen/**/*.hdbindex",
-    "src/gen/**/*.hdbconstraint"
+    "src/gen/**/*.hdbconstraint",
+    "src/gen/**/*_drafts.hdbtable",
+    "src/gen/**/*.hdbcalculationview"
 ]

package/lib/build/provider/nodejs/index.js

@@ -92,7 +92,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
      */
     async copySrvContent(src, destRoot, destSrv) {
         const srvRootBlockList = RegExp('package\\.json$|package-lock\\.json$|\\.npmrc$|\\.cdsrc\\.json$')
-        const srvBlockList = RegExp('\\.cds$|csn\\.json$|\\.csn$|manifest\\.y.?ml$|\\.env($|\\..*$)|default-env\\.json$')
+        const srvBlockList = RegExp('\\.cds$|csn\\.json$|\\.csn$|manifest\\.y.?ml$|\\.env($|\\..*$)|default-env\\.json$|\\.cdsrc-private.json$')
         const srvRootFileNames = []
 
         // 1. copy all files to 'destSrv' except those contained in the blocklist (including node_modules)

package/lib/compile/openapi/index.js

@@ -58,6 +58,11 @@ function servicePath(csdl, csn) {
     if (csdl.$EntityContainer) {
         const serviceName = csdl.$EntityContainer.replace(/\.[^.]+$/, '')
         const service = csn.definitions[serviceName]
+
+        // if @protocol is 'none' then throw an error
+        if (service['@protocol'] === 'none') {
+            throw new Error(`Service "${serviceName}" is annotated with @protocol:'none' which is not supported in openAPI generation.`)
+        }
         return cds.service.path4?.(service) || cds.serve.path4(service)
     }
 }

package/lib/deploy/to-hana/hana.js

@@ -13,9 +13,9 @@ const cfUtil = require('../../util/cf');
 const gitUtil = require('../../util/git');
 const mtaUtil = require('./mtaUtil');
 
-const { bold, info } = require('../../util/term');
+const { bold, info, warn } = require('../../util/term');
 
-const { bind } = require('../../bind');
+const { bind, storeBindings } = require('../../bind');
 
 const DEBUG = cds.debug('deploy');
 
@@ -37,6 +37,9 @@ module.exports = new class HanaDeployer {
 
   async deploy(options = {}) {
     let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
+
+    options.for = options.for || 'hybrid';
+
     if (model) {
       throw `Specifying a CDS model for HANA deployment is not supported.
 'cds deploy --to hana' performs 'cds build --for hana' which in turn uses the configured HANA build task.
@@ -51,13 +54,22 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
       console.log(`Using VCAP_SERVICES from file ${vcapFile} (beta feature).`);
     }
 
-    const projectPath = cds.root;
+    const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
+    const fromEnv = this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS');
+    const vcapEnv = { ...fromEnv, ...fromFile };
+
+    const warnings = [];
+    if (serviceName && vcapEnv.VCAP_SERVICES?.hana?.[0].name !== serviceName) {
+      if (vcapFile) {
+        warnings.push(`The specified service name '${serviceName}' was used; the information coming from --vcap-service file was ignored.`);
+      } else if (Object.keys(fromEnv).length > 0) {
+        warnings.push(`The specified service name '${serviceName}' was used; the information coming from environment variable VCAP_SERVICES was ignored.`);
+      }
+    }
 
+    const projectPath = cds.root;
     const buildResults = await this._build();
 
-    const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
-    const fromEnv = this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS');
-    let vcapEnv = { ...fromEnv, ...fromFile };
     if (process.env.TARGET_CONTAINER) {
       vcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
     }
@@ -111,7 +123,8 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
             for: options.for,
             kind: task.for
           }
-          await bind(bindOptions);
+          const services = await bind(bindOptions);
+          await storeBindings(services, bindOptions);
         }
       }
 
@@ -124,6 +137,11 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
     console.log(`Done.`);
 
+    if (warnings.length > 0) {
+      console.warn(warn('\nWARNING:'));
+      console.warn(warn(warnings.join('\n')));
+    }
+
     return { buildResults };
   }