@sap/cds-dk 4.6.3 → 4.7.3

package/lib/bind/cfKeyProvider.js

@@ -8,18 +8,6 @@ const { URL } = require('url');
 const execAsync = util.promisify(cp.exec);
 const IS_WIN = os.platform() === 'win32';
 
-const KindToRequiresNameMap = {
-    xsuaa: 'uaa',
-    hana: 'db',
-    destinations: 'destinations',
-    connectivity: 'connectivity',
-    'audit-log': 'audit-log',
-    'enterprise-messaging': 'messaging',
-    'enterprise-messaging-amqp': 'messaging',
-    'enterprise-messaging-http': 'messaging',
-    'enterprise-messaging-shared': 'messaging'
-}
-
 class CFKeyProvider {
 
     constructor() {
@@ -69,7 +57,6 @@ class CFKeyProvider {
 
     async getCfTargetFromCli() {
         const result = await this._cfRead('target');
-
         return {
             apiEndpoint: this.extract(result, /^api endpoint:\s+(.*)$/i),
             user: this.extract(result, /^user:\s+(.*)$/i),
@@ -142,7 +129,7 @@ class CFKeyProvider {
         name = name || `${instance}:${key}`;
 
         if (apiEndpoint && apiEndpoint !== target.apiEndpoint) {
-            throw new Error(`Current Cloud Foundry api endpoint "${target.apiEndpoint}" doesn't match with requested api endpoint "${apiEndpoint}" for service binding "${name}".`);
+            throw new Error(`Current Cloud Foundry api endpoint "${target.apiEndpoint}" different than api endpoint "${apiEndpoint}" for service binding "${name}".`);
         }
 
         let spaceGuid;
@@ -182,6 +169,7 @@ class CFKeyProvider {
                 vcap: {
                     label: offeringObj.name,
                     plan: planObj.name,
+                    tags: offeringObj.tags
                 },
                 resolved: true,
             },
@@ -190,72 +178,6 @@ class CFKeyProvider {
 
         return resolvedBinding;
     }
-
-    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;
-    }
-
-    /**
-     * Determine kind value for services based on VCAP binding
-     * information in the configuration.
-     */
-    determineKinds(services) {
-        const vcapServices = {}
-
-        const getIndex = service => {
-            const { credentials } = service;
-            return credentials && credentials.binding && credentials.binding.index;
-        }
-
-        // Build VCAP_SERVICES
-        for (let index = 0; index<services.length; index++) {
-            const service = services[index];
-            const { label, name, tags } = service.binding.vcap;
-            if (!vcapServices[label]) vcapServices[label] = [];
-            vcapServices[label].push({ credentials: { binding: { index } }, label, name, tags });
-
-            service.kindCandidates = [ ]
-            service.nameCandidates = [ ]
-        }
-
-        // Auto configure services based on VCAP_SERVICES
-        const cds = require('@sap/cds/lib');
-        const VCAP_SERVICES = process.env.VCAP_SERVICES;
-        try {
-            process.env.VCAP_SERVICES = JSON.stringify(vcapServices);
-            const env = cds.env.for('cds', '.');
-
-            // Extract "kind" from auto configured services
-            for (const kind of Object.keys(env.requires)) {
-                const requireService = env.requires[kind];
-                const superKind = requireService.kind;
-                const index = getIndex(requireService);
-                if (!Number.isInteger(index)) continue;
-
-                const superRequireService = env.requires[superKind];
-                if (superRequireService) {
-                    const superIndex = getIndex(superRequireService);
-                    if (index === superIndex) continue;
-                }
-
-                services[index].kindCandidates.push(kind);
-            }
-
-            // Check if one "kind" per service was found
-            for (const service of services) {
-                if (service.kindCandidates.length !== 1) {
-                    throw new Error(`Unknown kind for service "${service.binding.instance}". Please specify with "--kind" option.`);
-                }
-
-                service.kind = service.kindCandidates[0];
-                delete service.kindCandidates;
-            }
-        } finally {
-            process.env.VCAP_SERVICES = VCAP_SERVICES;
-        }
-    }
 }
 
 class BatchRequest {

package/lib/bind/kubernetesCredentialsProvider.js

@@ -0,0 +1,157 @@
+const cp = require('child_process');
+const os = require('os');
+const util = require('util');
+const yaml = require("@sap/cds-foss")("yaml");
+
+const axios = require('axios');
+const { URL } = require('url');
+
+const execFile = util.promisify(cp.execFile);
+const IS_WIN = os.platform() === 'win32';
+
+class KubernetesCredentialsProvider {
+
+    constructor() {
+        this.logger = console;
+    }
+
+    setLogger(logger) {
+        this.logger = logger;
+    }
+
+    async _kubectlRead(...args) {
+        this.logger.debug(`_kubectlRead: kubectl ${args.join(" ")}`);
+
+        const result = await execFile("kubectl", args, {
+            shell: IS_WIN,
+            stdio: ['inherit', 'pipe', 'inherit'],
+        });
+
+        return result.stdout.toString().trim();
+    }
+
+
+    async _kubectlConfig() {
+        const configString = await this._kubectlRead('config', 'view', '--raw');
+        const config = yaml.parse(configString);
+
+        const currentContextName = config["current-context"];
+        if (!currentContextName) throw new Error(`No current context in kubectl config.`);
+        const currentContextEntry = config.contexts && config.contexts.find( entry => entry.name === currentContextName && entry.context && entry.context.cluster && entry.context.user );
+        if (!currentContextEntry) throw new Error(`Current context not found in kubectl config.`);
+        const currentContext = currentContextEntry.context;
+        const clusterEntry = config.clusters && config.clusters.find( entry => entry.name === currentContext.cluster && entry.cluster && entry.cluster.server );
+        if (!currentContextEntry) throw new Error(`Cluster ${currentContext.cluster} not found in kubectl config.`);
+        const cluster = clusterEntry.cluster;
+        const userEntry = config.users && config.users.find( entry => entry.name === currentContext.user && entry.user && entry.user.token );
+        if (!userEntry) throw new Error(`User ${currentContext.user} not found in kubectl config.`);
+        const user = userEntry.user;
+
+        return {
+            url: cluster.server,
+            namespace: currentContext.namespace || 'default',
+            token: user.token
+        }
+    }
+
+    async init() {
+        this.config = await this._kubectlConfig();
+    }
+
+    async _req(urlPath) {
+
+        const url = new URL(urlPath, this.config.url);
+        this.logger.debug(`_req: ${url.toString()}`);
+
+        const result = await axios.get(url.toString(), {
+            validateStatus: status => status === 200 || status === 404,
+            headers: {
+                authorization: `Bearer ${this.config.token}`
+            }
+        });
+
+        if (result.status === 200) {
+            return result.data;
+        } else {
+            return null
+        }
+    }
+
+
+    async resolve(name, binding) {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        await this.initPromise;
+
+        let {cluster, namespace, name: bindingName, secret } = binding;
+        let instance;
+        let secretOrBindingResource = 'Secret';
+
+        if (!namespace) namespace = this.config.namespace;
+        if (cluster && cluster !== this.config.url) throw new Error(`Current Kubernetes cluster "${this.config.url}" different than Kubernetes cluster "${cluster}" for service binding "${name}".`);
+
+        if (bindingName) {
+            const bindingResource = await this._req(`/apis/servicecatalog.k8s.io/v1beta1/namespaces/${encodeURIComponent(namespace)}/servicebindings/${encodeURIComponent(bindingName)}`);
+            if (bindingResource === null) {
+                // Fallback to secret instead of service binding;
+                secret = bindingName;
+                bindingName = undefined;
+                secretOrBindingResource = 'Service Binding or Secret';
+            } else {
+                secret = bindingResource.spec.secretName || throwError();
+                instance = bindingResource.spec.instanceRef && bindingResource.spec.instanceRef.name || throwError();
+            }
+        }
+
+        const secretResource = await this._req(`/api/v1/namespaces/${encodeURIComponent(namespace)}/secrets/${encodeURIComponent(secret)}`);
+        if (secretResource === null) throwError(`${secretOrBindingResource} '${secret}' not found.`);
+
+        const credentials = {};
+        for (const name in secretResource.data) {
+            let value = secretResource.data[name];
+            value = Buffer.from(value, "base64").toString(); // secret values are base64 encoded
+            // TODO: TESTIT
+            if (value && value[0] === '{') try { value = JSON.parse(value); } catch(e) {/* ignored */} // secret values may contain JSON objects
+            credentials[name] = value;
+        }
+
+        const resolvedBinding = {
+            binding: {
+                type: "k8s",
+                name: bindingName,
+                cluster: this.config.url,
+                instance,
+                namespace,
+                secret: secret,
+                resolved: true,
+            },
+            credentials
+        };
+
+
+        if (instance) {
+            const serviceInstanceResource = await this._req(`/apis/servicecatalog.k8s.io/v1beta1/namespaces/${encodeURIComponent(namespace)}/serviceinstances/${encodeURIComponent(instance)}`);
+
+            resolvedBinding.binding.vcap = {
+                label: serviceInstanceResource.spec.clusterServiceClassExternalName,
+                plan: serviceInstanceResource.spec.clusterServicePlanExternalName
+            }
+        }
+
+        return resolvedBinding;
+    }
+
+}
+
+
+/**
+ *
+ * @param {string} msg
+ * @returns {never}
+ */
+function throwError(msg = 'Internal Error') {
+    throw new Error(msg);
+}
+
+module.exports = new KubernetesCredentialsProvider();

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -3,7 +3,7 @@ const path = require('path');
 const readline = require('readline');
 
 const { fse } = require('@sap/cds-foss');
-const { highlight, warn } = require('../util/term');
+const { highlight } = require('../util/term');
 
 const commandUtil = require('../init/util/commandUtil');
 
@@ -108,19 +108,19 @@ ${file}
         }
 
         for (const service of services) {
-            const { name, kind, binding, credentials } = service;
+            const { name, kind, binding, credentials, vcap } = service;
             const requireService = section[name] = section[name] || {};
 
-            Object.assign(requireService, { kind, binding, credentials });
-
-            options.logger.log(`Binding ${highlight(name)} to Cloud Foundry service ${highlight(binding.instance)} key ${highlight(binding.key)} with kind ${highlight(kind)}.`);
+            Object.assign(requireService, { binding, credentials });
+            if (kind) requireService.kind = kind;
+            if (vcap) requireService.vcap = vcap;
         }
 
         await this.writeJsonFile(jsonPath, jsonObject, options.logger);
         if (options.profile) {
-            options.logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.profile)} .`);
+            options.logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.profile)}`);
         } else {
-            options.logger.log(`Saving bindings to ${highlight(jsonPath)}.`);
+            options.logger.log(`Saving bindings to ${highlight(jsonPath)}`);
         }
     }
 

package/lib/client/activate.js

@@ -166,15 +166,14 @@ module.exports = class Activate extends BaseCommand {
 
             activationUrl = Activate.getMtxApiUrl(params.get('appUrl'), COMMAND_URL_SUFFIX);
             const requestOptions = Object.assign({
-                headers: {},
-                data: {
-                    extension: [...allFiles],
-                    undeployExtension: params.get('undeploy')
-                }
+                headers: {}
             }, params.get('reqAuth'));
             requestOptions.headers['Content-Type'] = 'application/json';
 
-            return axios.post(activationUrl, requestOptions);
+            return axios.post(activationUrl, {
+                extension: [...allFiles],
+                undeployExtension: params.get('undeploy')
+            }, requestOptions);
         })
         .then(response => {
             if (response === null) {
@@ -223,13 +222,12 @@ module.exports = class Activate extends BaseCommand {
         const customFileUrl = Activate.getMtxApiUrl(params.get('appUrl'), Activate.UPDATE_CUSTOM_FILE_URL_SUFFIX);
         const requestOptions = Object.assign({
             headers: {},
-            data: {
-                content: customFilesSerialized
-            }
         }, params.get('reqAuth'));
         requestOptions.headers['Content-Type'] = 'application/json';
 
-        await axios.post(customFileUrl, requestOptions);
+        await axios.post(customFileUrl, {
+            content: customFilesSerialized
+        }, requestOptions);
 
         Logger.log('Custom file upload finished');
     }

package/lib/import/index.js

@@ -130,12 +130,13 @@ function _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace) {
 }
 
 async function edmx2csn(edmx, filename, context) {
-    const result = edmx.match(/EntityType="([^.]+)/);
+    const result = edmx.match(/EntityType="([^"]+)/);
     const multipleSchemas = /(\s*<\/Schema>\s*<Schema [^>]*>)\s*/m;
     if (!result) {
         throw new Error(messages.MISSING_ENTITIES);
     }
-    const namespace = result[1];
+    const index = result[1].lastIndexOf(".");
+	const namespace = (index > 0 ) ? result[1].substring(0, index) : result[1];
 
     if (multipleSchemas.test(edmx)) {
         edmx = _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace);

package/lib/import/internalDoc/edm2cdsTypeMapping.md

@@ -0,0 +1,38 @@
+# OData V2 or V4 EDM Datatype mapping to CAP CDS 
+
+oData V2/V4 |  CAP CDS | Comments (if any) |
+------------|----------| ----------|
+Edm.Guid  |cds.UUID    |  |
+Edm.Boolean  |cds.Boolean| |
+Edm.Int16  |cds.Integer| |
+Edm.Int32 |cds.Integer| |
+Edm.Int64 | cds.Integer64| | 
+Edm.Decimal | cds.DecimalFloat| | 
+Edm.Decimal Precision > 0 | cds.Decimal| |
+Edm.Single  | cds.Double @odata.type: “Edm.Single”| |
+Edm.Double  | cds.Double| |
+Edm.Double Precision > 0 |cds.Double| |
+Edm.String  | cds.LargeString| |
+Edm.String MaxLength > 0 |cds.String| |
+Edm.Binary MaxLength > 0 |  cds.Binary | |
+Edm.Binary |  cds.LargeBinary | |
+Edm.Byte  |cds.Integer| |
+Edm.Byte MaxLength > 0 |cds.Binary| |
+Edm.SByte  |cds.Integer| |
+Edm.Stream |  cds.LargeBinary @odata.type: “Edm.Stream” | |
+Edm.DateTimeOffset Precision : Microsecond |  cds.Timestamp, @odata.type: “Edm.DateTimeOffset”, @odata.precision:<> | The value of precision from odata will be mapped to @odata.precision | 
+Edm.DateTimeOffset Precision : Second | cds.DateTime, @odata.type: “Edm.DateTimeOffset”, @odata.precision:0| |
+ | |
+**Below attributes are applicable to V2 only**   |
+| |
+Edm.DateTime Precision : Microsecond |  cds.Timestamp, @odata.type: “Edm.DateTime”, @odata.precision:<> | The value of precision from odata will be mapped to @odata.precision | |
+Edm.DateTime Precision : Second | cds.DateTime, @odata.type: “Edm.DateTime”, @odata.precision:0| |
+Edm.Time  |cds.Time| |
+Edm.DateTime sap:display-format="Date" |cds.Date| |
+Edm.DateTimeOffset sap:display-format="Date" |cds.Date||
+**Below attributes are applicable to V4 only** |  
+| |
+Edm.TimeOfDay |cds.Time||
+Edm.Date |cds.Date||
+
+

package/lib/import/utils/MultiMap.js

@@ -49,6 +49,7 @@ var Multimap = (function () {
      * @param {Object} key
      * @param {Object} val...
      */
+    // eslint-disable-next-line no-unused-vars
     Multimap.prototype.set = function (key, val) {
         var args = Array.prototype.slice.call(arguments);