@sap/cds-dk 4.5.4 → 4.6.0

package/lib/bind/cfKeyProvider.js

@@ -0,0 +1,353 @@
+const cp = require('child_process');
+const os = require('os');
+const util = require('util');
+
+const axios = require('axios');
+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() {
+        this.logger = console;
+    }
+
+    async _cfRead(...args) {
+        this.logger.debug(`_cfRead: cf ${args}`);
+
+        const result = await execAsync(`cf ${args}`, {
+            shell: IS_WIN,
+            stdio: ['inherit', 'pipe', 'inherit'],
+        });
+
+        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, defaultValue) {
+        const array = string.split(/[\n\r]+/);
+        for (let line of array) {
+            const match = line.match(pattern);
+            if (match) {
+                return match[1];
+            }
+        }
+
+        if (typeof defaultValue === 'undefined') {
+            throw Error(`Pattern not found: ${pattern}`);
+        } else {
+            return defaultValue;
+        }
+    }
+
+    async getCfTargetFromCli() {
+        const result = await this._cfRead('target');
+
+        return {
+            apiEndpoint: this.extract(result, /^api endpoint:\s+(.*)$/i),
+            user: this.extract(result, /^user:\s+(.*)$/i),
+            org: this.extract(result, /^org:\s+(.*)$/i),
+            space: this.extract(result, /^space:\s+(.*)$/i),
+        };
+    }
+
+    async getCfSpaceInfo() {
+        this.logger.debug('getting space info');
+
+        const target = await this.getCfTargetFromCli();
+        const authorization = await this.getCfAuthorization();
+        const targetWithAuth = Object.assign({}, target, { authorization });
+
+
+        const { org, space } = target;
+        const orgs = await this._req(targetWithAuth, `/v3/organizations?names=${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=${space}&organization_guids=${orgGuid}`)
+        if (!(spaces && spaces.resources.length === 1)) {
+            throw new Error(`CF space ${space} not found in org ${org}!`);
+        }
+
+        const spaceGuid = spaces.resources[0].guid;
+
+        return Object.assign({}, target, { orgGuid, spaceGuid, authorization });
+    }
+
+    async getCfAuthorization() {
+        this.logger.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.getSpace = BatchRequest.create({logger, target, url: '/v3/spaces', extractors: {
+            organization_guids: resource => resource.relationships.organization.data.guid
+        }});
+        this.getInstance = BatchRequest.create({logger, 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: {
+            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' });
+    }
+
+    async resolve(name, binding) {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        await this.initPromise;
+
+        const target = this.target;
+
+        let {instance, key, apiEndpoint, org, space} = binding;
+        key = key || `${instance}-key`;
+        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}".`);
+        }
+
+        let spaceGuid;
+        if (org && 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;
+        }
+
+        let instanceObj;
+        try {
+            instanceObj = await this.getInstance({ names: instance, space_guids: spaceGuid });
+        } catch(error) {
+            throw new Error(`Service instance "${instance}" not found.`);
+        }
+        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}".`);
+        }
+        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 resolvedBinding = {
+            binding: {
+                type: "cf",
+                apiEndpoint: target.apiEndpoint,
+                org: org,
+                space: space,
+                instance: instance,
+                key: key,
+                vcap: {
+                    label: offeringObj.name,
+                    plan: planObj.name,
+                },
+                resolved: true,
+            },
+            credentials: keyCredentialsObj.credentials
+        };
+
+        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 {
+    constructor({logger, target, url, extractors = {}}) {
+        this.logger = logger;
+        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}=${filterParams[name].map( value => encodeURIComponent(value) ).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(new Error(`Couldn't find resource for url "${this.url}" with filter "${fmt(filter.filter)}"`));
+            } else {
+                filter.reject(new Error(`Found more than one resources for url "${this.url}" with filter "${fmt(filter.filter)}"`));
+            }
+        }
+    }
+
+    async httpRequest(urlPath) {
+        return req(this.logger, 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
+        }
+    });
+
+    return result.data;
+}
+
+module.exports = new CFKeyProvider();

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -0,0 +1,144 @@
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+
+const { fse } = require('@sap/cds-foss');
+const { highlight, warn } = require('../util/term');
+
+const commandUtil = require('../init/util/commandUtil');
+
+const CDSRC_FILENAME = '.cdsrc-private.json';
+const GIT_IGNORE_FILE = '.gitignore';
+
+class UserCdsrcJsonStorageProvider {
+
+    async askBooleanQuestion(question) {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        question = question.trim() + ' ';
+        return new Promise(resolve => {
+            rl.question(question, answer => {
+                if (answer === 'y' || answer === 'Y') {
+                    resolve(true);
+                } else {
+                    resolve(false);
+                }
+                rl.close();
+            });
+        });
+    }
+
+    async ensureFileIsGitignored(file, logger = console) {
+        try {
+            await commandUtil.spawnCommand('git', ['check-ignore', '-n', '-v', file], {}, undefined, true);
+            return; // file is git ignored
+        } catch (err) {
+            if (err.code === 'ENOENT') {   // git command not found
+                logger.debug('git command not found');
+                return;
+            }
+
+            if (!err.stdLog.match(/::/)) {   // included or not a git repo
+                logger.debug(err);
+                return;
+            }
+        }
+
+        logger.log(`adding entry '${file}' to ${GIT_IGNORE_FILE}.`);
+        let gitignore = await this.readFileSafely(GIT_IGNORE_FILE);
+        gitignore = gitignore + `
+# added by cds bind
+${file}
+`;
+        await fse.writeFile(GIT_IGNORE_FILE, gitignore, 'utf8');
+    }
+
+    async readFileSafely(file) {
+        try {
+            return await fse.readFile(file, 'utf8');
+        } catch (err) {
+            return '';
+        }
+    }
+
+    async storeServices(services, options = {}) {
+        let jsonPath = options['output-file'] || CDSRC_FILENAME;
+
+        if (jsonPath === CDSRC_FILENAME) {
+            await this.ensureFileIsGitignored(CDSRC_FILENAME, options.logger);
+        }
+
+        jsonPath = jsonPath.replace(/~/g, os.homedir());
+        // const stat = await fse.stat(jsonPath);
+        if (path.extname(jsonPath) !== '.json') {
+            jsonPath = path.join(jsonPath, '.cdsrc.json');
+        }
+
+        // if (options['save-credentials'] && services.find(service => service.credentials) && process.stdin.isTTY) {
+        //     const answer = await this.askBooleanQuestion(warn(`IF YOU CONTINUE, SENSITIVE DATA WILL BE WRITTEN TO AN UNENCRYPTED FILE [${jsonPath}]! Do you want to continue [y/N] ?`));
+        //     if (!answer) {
+        //         options.logger.log(`aborting cds bind; not writing any sensitive data to file [${jsonPath}]`);
+        //         return;
+        //     }
+        // }
+
+        const jsonObject = await this.readJsonSafely(jsonPath);
+        let cdsRoot;
+        if (path.basename(jsonPath) === 'package.json') {
+            jsonObject.cds = jsonObject.cds || {};
+            cdsRoot = jsonObject.cds;
+        } else {
+            cdsRoot = jsonObject;
+        }
+
+        const profileKey = `[${options.profile}]`;
+        cdsRoot.features = cdsRoot.features || {};
+        cdsRoot.features[profileKey] = cdsRoot.features[profileKey] || {};
+        cdsRoot.features[profileKey].emulate_vcap_services = true;
+
+        cdsRoot.requires = cdsRoot.requires || {};
+        let section;
+        if (options.profile) {
+            section = cdsRoot.requires[profileKey] = cdsRoot.requires[profileKey] || {};
+        } else {
+            section = cdsRoot.requires;
+        }
+
+        for (const service of services) {
+            const { name, kind, binding, credentials } = 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)}.`);
+        }
+
+        await this.writeJsonFile(jsonPath, jsonObject, options.logger);
+        if (options.profile) {
+            options.logger.log(`Saving bindings to ${highlight(jsonPath)} in profile ${highlight(options.profile)} .`);
+        } else {
+            options.logger.log(`Saving bindings to ${highlight(jsonPath)}.`);
+        }
+    }
+
+    async readJsonSafely(filePath) {
+        try {
+            return await fse.readJSON(filePath) || {};
+        } catch (err) {
+            return {};
+        }
+    }
+
+    async writeJsonFile(filePath, content) {
+        await fse.outputJSON(filePath, content, {
+            spaces: 2
+        });
+
+        await fse.chmod(filePath, 0o600); // -rw-------
+    }
+}
+
+module.exports = new UserCdsrcJsonStorageProvider();

package/lib/client/auth_manager.js

@@ -26,12 +26,12 @@ function getTokenUrl(params) {
     tokenUrl.search = `subdomain=${params.get('subdomain')}`;
 
     if (params.has('refreshToken')) {
-        tokenUrl.search += `&refresh_token=${params.get('refreshToken')}`;
+        tokenUrl.search += `&refresh_token=${encodeURIComponent(params.get('refreshToken'))}`;
     } else if (params.has('passcode')) {
-        tokenUrl.search += `&passcode=${params.get('passcode')}`;
+        tokenUrl.search += `&passcode=${encodeURIComponent(params.get('passcode'))}`;
     }
     if (params.has('clientid')) {
-        tokenUrl.search += `&clientid=${params.get('clientid')}&clientsecret=${params.get('clientsecret')}`;
+        tokenUrl.search += `&clientid=${encodeURIComponent(params.get('clientid'))}&clientsecret=${encodeURIComponent(params.get('clientsecret'))}`;
     }
     return tokenUrl.toString();
 }
@@ -58,7 +58,7 @@ async function retrieveTokenOrPasscodeUrl(params) {
 
         let response;
         try {
-            response = await axios(tokenUrl.toString(), { method: 'GET' });
+            response = await axios(tokenUrl, { method: 'GET' });
         } catch (error) {
             throw new Error(`Failed to get authentication token: ${error}.\nResponse body: ${util.inspect(response && response.data)}`);
         }

package/lib/client/settings_manager.js

@@ -55,7 +55,7 @@ function other(tokenStorage) {
 
 function getProjectFolder(params) {
     const relativePath = params.get('projectFolder') || params.get('directory') || (
-        params.has('subdomain') && fse.existsSync(path.resolve(params.get('subdomain')))
+        params.has('subdomain') && fse.existsSync(params.get('subdomain'))
             ? params.get('subdomain')
             : '.'
     );

package/lib/import/common.js

@@ -30,6 +30,14 @@ function checkForEmptyKeys(element, oDataVersion) {
     }    
 }
 
+//to replace the alias value with original schema namespace value
+function replaceAliasValue(schemaContent, schemaNamespaceValue, aliasValue){
+    const re = RegExp(`([("/])${aliasValue}([/").])`, 'g');
+    const val = `$1${schemaNamespaceValue}$2`;
+    schemaContent = schemaContent.replace(re, val);
+    return JSON.parse(schemaContent);
+}
+
 async function _getODataVersion(edmx) {
     let oDataVersion;
     let jsonObj;
@@ -115,5 +123,6 @@ module.exports = {
     getVersion,
     getSuffix,
     supportedFormats,
-    checkForEmptyKeys
+    checkForEmptyKeys,
+    replaceAliasValue
 };

package/lib/import/importapi.js

@@ -1,5 +1,7 @@
 const edm2csn = require('.');
-
+let context={};
+context.oDataInfo = {};
+context.namespaces = [];
 /**
 * This is the import API function to generate CSN from XML/EDMX files.
 * @param {string} filepath
@@ -10,11 +12,10 @@ const edm2csn = require('.');
 * - other import options not supported
 * @returns {object} CSN
 */
-const oDataInfo={};
 module.exports = async function cds_import(filepath, options = {keepNamespace : false}) //namespace will be taken as false in case it is not mentioned
 {
         filepath = await edm2csn.isValidInputFile(filepath);
         let edmx= await edm2csn.getMetadataFromFile(filepath);
-        let csn = await edm2csn.edmx2csn(edmx, !options.keepNamespace && filepath, false, oDataInfo);
+        let csn = await edm2csn.edmx2csn(edmx, !options.keepNamespace && filepath, context);
         return csn;
 }

package/lib/import/index.js

@@ -116,7 +116,15 @@ function _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace) {
 			</Schema>
 		</edmx:DataServices>
 	*/
-	edmx = edmx.replace(multipleSchemas, '').replace(/<Schema Namespace="[^"]+"/, `<Schema Namespace="${namespace}"`);
+
+	// Remove the ending and beginning of the first and second schema tag
+	edmx = edmx.replace(multipleSchemas, '');
+	// Now capture the schema tag details
+	let schemaDetails = edmx.match(/(<Schema [^>]*>)/);
+	// Replace the Namespace value with the correct one
+	schemaDetails = schemaDetails[0].replace(/Namespace="[^"]+"/, `Namespace="${namespace}"`);
+	// Place the above computed schema details in the edmx content
+	edmx = edmx.replace(/(<Schema [^>]*>)/, `${schemaDetails}`);
 
 	return edmx;
 }
@@ -132,7 +140,7 @@ async function edmx2csn(edmx, filename, context) {
     if (multipleSchemas.test(edmx)) {
         edmx = _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace);
     }
-	let csn = await generateCSN(edmx, true, context);
+	let csn = await generateCSN(edmx, false, true, context);
 	if (filename) {
 		// Replace namespace by given filename in the csn file instead of edmx file
         const re = RegExp(`([("/])${namespace}([/").])`, 'g');
@@ -151,20 +159,33 @@ async function _generateEDMX2JSON(edmx) {
 	return JSON.parse(cjson);
 }
 
-async function generateCSN(edmx, mockServerUc, context) {
+async function generateCSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
 	let csn;
 	let odataVersion;
 	let edmx2jsonModel;
+	let defaultNamespaces;
+	let namespaces = [];
+	if(context.namespaces) namespaces.push(...(context.namespaces));
 	odataVersion = await common.getVersion(edmx);
 	if (odataVersion === "V2") {
 		if(context){
 			context.oDataVersion = "V2";
 		}
+		//default namespaces to be present
+		if(!context.include_all_namespaces)
+		{
+			defaultNamespaces = ['edmx','sap','m'];
+			namespaces = namespaces.concat(defaultNamespaces);
+			namespaces = namespaces.filter((item,pos) => namespaces.indexOf(item) === pos); //removing duplicate values
+		}
+		context.namespaces = namespaces;
 		edmx2jsonModel = await _generateEDMX2JSON(edmx);
 		return new Promise(function getCsn(resolve, reject) {
 			csn = edmxv2CSN.getEdmxv2CSN(
 				edmx2jsonModel,
-				mockServerUc
+				ignorePersistenceSkip,
+				mockServerUc,
+				context
 			);
 			if (csn) {
 				resolve(csn);
@@ -177,7 +198,15 @@ async function generateCSN(edmx, mockServerUc, context) {
 		if(context){
 			context.oDataVersion = "V4";
 		}
-		return edmxv4CSN.getEdmxv4CSN(edmx, mockServerUc);
+		//default namespaces to be present
+		if(!context.include_all_namespaces)
+		{
+			defaultNamespaces = ['edmx'];
+			namespaces = namespaces.concat(defaultNamespaces);
+			namespaces = namespaces.filter((item,pos) => namespaces.indexOf(item) === pos); //removing duplicate values
+		}
+		context.namespaces = namespaces;
+		return edmxv4CSN.getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context);
 	}
 	return new Promise(function invalidFile(resolve, reject) {
 		reject(new Error(messages.INVALID_EDMX_METADATA));

package/lib/import/message.js

@@ -13,6 +13,7 @@ const messages = {
 	OUTPUT_FILE_MISMATCH: 'Specify the file extension that --as option supports.',
 	INVALID_AS_OPTION: 'For --as option, please specify one of these output file format [cds, csn, json].',
 	INCORRECT_EXTENSION: 'If --as option is not provided, then please provide either .json or .csn output file extension.',
+	INCORRECT_INPUT_NAMESPACES: 'Invalid value for --include-namespaces option. Specify namespaces as comma-separated list or "*"'
 };
 
 function getMessages() {