@sap/cds-dk 4.5.0 → 4.6.0

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

@@ -21,6 +21,23 @@ async function _generateEDMX2JSON(edmx) {
     return JSON.parse(cjson);
 }
 
+function checkForEmptyKeys(element, oDataVersion) {
+    if (oDataVersion === "V2") {
+        return (element.includes(["cds.Association"]) && !element.includes(['"on":']));
+    }
+    else {
+        return (['cds.Association'].includes(element.type)) && !element.on && !element.keys;
+    }    
+}
+
+//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;
@@ -91,6 +108,21 @@ async function getVersion(fileInputStream) {
     return oDataVersion;
 }
 
+function getSuffix(outputFormat) {
+    const suffix = { edmx: 'xml', "edmx-v2": 'xml', "edmx-v4": 'xml', "edmx-w4": 'xml',
+        "edmx-x4": 'xml', openapi: 'openapi3.json', sql: 'sql', edm: 'json', "cdl": "cds" };
+    // find the output file extension based on the target conversion selected
+    return (outputFormat) ? (suffix[outputFormat] || outputFormat) : 'csn';
+}
+
+function supportedFormats() {
+    return ["cds", "csn", "json"];
+}
+
 module.exports = {
-    getVersion
+    getVersion,
+    getSuffix,
+    supportedFormats,
+    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,oDataInfo);
+        let csn = await edm2csn.edmx2csn(edmx, !options.keepNamespace && filepath, context);
         return csn;
 }

package/lib/import/index.js

@@ -42,36 +42,35 @@ async function isValidInputFile(inputFileLoc) {
 	return file;
 }
 
-function validateAndComputeOutputFilePath(outputFileLoc) {
-	let filePath, index, extension;
+function validateAndComputeOutputFilePath(outputFileLoc, as) {
+	let index, extension, expectedExtension, supportedExtension;
 	if (typeof(outputFileLoc) !== 'boolean') {
 		index = outputFileLoc.lastIndexOf(".");
 		extension = outputFileLoc.substring(index + 1);
+		expectedExtension = (as) ? common.getSuffix(as) : "csn";
+		supportedExtension = (index > 0) ? common.supportedFormats().includes(extension) : false;
 	}
+
 	if (outputFileLoc === true || // if output file is not mentioned
+		outputFileLoc[0] === "-" || // if output file is missing and "--as" is considered as output file
 		outputFileLoc.trim() === "") {
 		throw new Error(messages.SPECIFY_OUTPUT_FILE);
-	} else if (outputFileLoc.endsWith(".json") || outputFileLoc.endsWith(".csn")) {
-		filePath = outputFileLoc;
-	} else if (index > 0 &&
-		!extension.endsWith("/") && // to ignore "../test/lib/import/output/tempOutput/"
-		!extension.endsWith("\\") && // to ignore "c:\windows\output\test\"
-		extension !== 'json' &&
-		extension !== 'csn') {
-		// Output file extension is not either .json or .csn ("test.abcde", "./srv/external/test.abcde")
+	} else if (index > 0 && !supportedExtension) { 
+		// extension not supported, eg., "test.abs", "./sv/external.test.abcs", "./a."
 		throw new Error(messages.INVALID_OUTPUT_FILE);
-	} else if (!outputFileLoc.endsWith(".json") &&
-		!outputFileLoc.endsWith(".csn") &&
-		!outputFileLoc.endsWith("\\") &&
-		!outputFileLoc.endsWith("/")) {
-		// Output file extension is not mentioned ("./srv/external/test", "test", "c:\windows\output\test")
-		filePath = outputFileLoc + ".csn";
+	} else if (index > 0 && !as && extension != "json" && extension != "csn") {
+		// --as option is not provided but output file is like: "test.cds", "./srv/external/test.cds"
+		throw new Error(messages.INCORRECT_EXTENSION);
+	} else if (index > 0 && as && extension != expectedExtension){ 
+		// extension not supported by --as option, e.g., "cds import <file> --out test.yml --as cds"
+		throw new Error(messages.OUTPUT_FILE_MISMATCH);
+	} else if (supportedExtension || (!outputFileLoc.endsWith("\\") && !outputFileLoc.endsWith("/"))) {
+		// eg., "./a.csn", "tst.cds", "./srv/external/test", "test", "c:\windows\output\test"
+		return outputFileLoc;
 	} else if (outputFileLoc.endsWith("/") || outputFileLoc.endsWith("\\")){ 
 		// File name not specified ("./srv/external/", "c:\windows\output\test\") 
-		filePath = outputFileLoc + path.parse(defaultFileName).name + ".csn";
+		return outputFileLoc + path.parse(defaultFileName).name;
 	}
-
-	return filePath;
 }
 
 async function getMetadataFromFile(path) {
@@ -117,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;
 }
@@ -156,17 +163,29 @@ 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,
 				ignorePersistenceSkip,
-				mockServerUc
+				mockServerUc,
+				context
 			);
 			if (csn) {
 				resolve(csn);
@@ -179,13 +198,20 @@ async function generateCSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
 		if(context){
 			context.oDataVersion = "V4";
 		}
-		return edmxv4CSN.getEdmxv4CSN(edmx, ignorePersistenceSkip, 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));
 	});
 }
-
 async function saveCSNModel(csnDataModel, fileLoc) {
 	await fs.write(fileLoc, csnDataModel, "utf-8");
 }

package/lib/import/message.js

@@ -1,14 +1,19 @@
 "use strict";
 
 const messages = {
-	INVALID_EDMX_METADATA: "The OData model is not valid. Specify the correct OData model.",
-	INVALID_OUTPUT_FILE: "Please provide an output file with either .json or .csn extension.",
-	MISSING_ENTITIES: "There are no entities in the OData model. Specify the correct OData model in the provided file.",
-	SPECIFY_INPUT_FILE: "Specify an input file that exists.",
-	SPECIFY_OUTPUT_FILE: "Specify an output file.",
+	INVALID_EDMX_METADATA: 'The OData model is not valid. Specify the correct OData model.',
+	INVALID_OUTPUT_FILE: 'Please provide an output file with one of these [cds, csn, json] file extension.',
+	MISSING_ENTITIES: 'There are no entities in the OData model. Specify the correct OData model in the provided file.',
+	SPECIFY_INPUT_FILE: 'Specify an input file that exists.',
+	SPECIFY_OUTPUT_FILE: 'Specify an output file or correct the output file path provided.',
 	MISSING_ENTITY_CONTAINER: 'There is no entity container in the OData model. Specify the correct OData model.',
 	MISSING_ENTITY_SETS: 'There are no entity sets in the OData model. Specify the correct OData model.',
-	INVALID_INPUT_FILE: 'Input file provided is not valid. Please provide a file with either .edmx or .xml extension.'
+	INVALID_INPUT_FILE: 'Input file provided is not valid. Please provide a file with either .edmx or .xml extension.',
+	FILE_MODIFIED: 'The file with the same name exists and is been modified. Use --force flag to forcefully overwrite the file.',
+	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() {

package/lib/import/utils/MetadataConverter.js

@@ -396,7 +396,7 @@ class Expression {
         const target = this.getTarget();
         const element = this.getElement();
         const attribs = element.attributes;
-
+        let custom_namespace = MetadataConverter.custom_namespace;
         if (attribs == null) return;
         let realType = attribs.Type || attribs.EntityType || attribs.UnderlyingType;
         const propertyName = attribs.UnderlyingType == null ? '$Type' : '$UnderlyingType';
@@ -574,9 +574,29 @@ class Expression {
             !(target.$Kind === 'NavigationProperty' && target.$Collection === true)) {
             target.$Nullable = true;
         }
+        const nonStdAttributes = this.getNonStdAttributes(element.attributes);
+        for (let i = 0; i < nonStdAttributes.length; i++) {
+            let attr = nonStdAttributes[i];
+            let [prefix, attrName] = attr.split(':');
+            if(attrName)
+                attrName = attrName.replace(/-/g,'.');
+            let attribute;
+            if ((custom_namespace.includes(prefix) && attrName !== undefined) || custom_namespace.includes(true))
+                attribute = "@" + prefix + "." + attrName;
+            else if (attrName === undefined)
+                attribute = "$" + prefix;
+            if (attribute !== undefined)
+                target[attribute] = element.attributes[attr];
+        }
+    }
+    getNonStdAttributes(attributes) {
+        const attributeList = [];
+        const standardArrtibutes = ['MaxLength', 'Precision', 'Scale', 'Nullable', 'DefaultValue', 
+            'Name', 'Type', 'HasStream', 'IsFlags', 'Alias', 'Namespace', 'BaseType', 'Partner', 
+            'IsComposable', 'ContainsTarget', 'IsBound', 'EntitySet', 'EntitySetPath', 'EntityType'];
+        attributeList.push(...Object.keys(attributes).filter(attribute => standardArrtibutes.indexOf(attribute) === -1));
+        return attributeList;
     }
-
-
 }
 
 class EdmPrimitiveType {
@@ -2361,7 +2381,8 @@ class OnDeleteExpression extends Expression {
 }
 
 
-MetadataConverter.createOdataV4MetadataXmlToOdataV4CsdlStrategy = () => {
+MetadataConverter.createOdataV4MetadataXmlToOdataV4CsdlStrategy = (name_space) => {
+    MetadataConverter.custom_namespace = name_space;
     return new MetadataConverter.DefaultXmlStrategy()
         .use('http://docs.oasis-open.org/odata/ns/edmx:Edmx', (element, parentExpression, context) => {
             return new EdmxRootExpression(element, null, context);

package/lib/import/utils/MetadataConverterFactory.js

@@ -1,5 +1,4 @@
 'use strict';
-
 const xmljs = require('xml-js');
 const MetadataConverterV4 = require('../utils/MetadataConverter');
 
@@ -61,7 +60,7 @@ class MetadataConverterFactory {
      *
      */
     static createEdmxV40XmlToV40Json(options = {}) {
-        const defaultStrategy = MetadataConverterV4.createOdataV4MetadataXmlToOdataV4CsdlStrategy();
+        const defaultStrategy = MetadataConverterV4.createOdataV4MetadataXmlToOdataV4CsdlStrategy(options);
 
         if (options.astFactory) {
             defaultStrategy.setASTFactory(options.astFactory);

package/lib/import/utils/MultiMap.js

@@ -67,6 +67,32 @@ var Multimap = (function () {
         return this;
     };
 
+    /**
+   * @return {Array} all the keys in the map
+   */
+    Multimap.prototype.keys = function () {
+        if (this._map)
+            return makeIterator(this._.keys());
+
+        return makeIterator(Object.keys(this._));
+    };
+
+    function makeIterator(iterator) {
+        if (Array.isArray(iterator)) {
+            var nextIndex = 0;
+
+            return {
+                next: function () {
+                    return nextIndex < iterator.length ?
+                        { value: iterator[nextIndex++], done: false } :
+                        { done: true };
+                }
+            };
+        }
+
+        return iterator;
+    }
+
     return Multimap;
 })();