@sap/cds-dk 4.9.5 → 6.0.1

package/lib/import/common.js

@@ -1,6 +1,23 @@
 'use strict';
 
-let convert = require('xml-js')
+let convert = require('xml-js');
+let axios = require('axios');
+const messages = require("./message").getMessages();
+const cds = require('../cds');
+const { fs, path, write, mkdirp, exists, read } = cds.utils;
+const cdsCompiler = require('../compile').compile.to;
+const md5 = require('md5');
+
+let optionsMapping = {
+    'keep-namespace': 'keepNamespace',
+    'include-namespaces': 'includeNamespaces',
+    'no-copy': 'no_copy',
+    'no-save': 'no_save'
+};
+
+let apiOptions = ['includeNamespaces', 'keepNamespace'];
+let commonOptions = ['no_copy', 'no_save', 'out', 'dry', 'as', 'from', 'force'];
+
 function _isJson(edmx) {
     let isJson = false;
     try {
@@ -12,8 +29,7 @@ function _isJson(edmx) {
     return isJson;
 }
 
-async function _generateEDMX2JSON(edmx) {
-    // Reinitialize
+async function generateEDMX2JSON(edmx) {
     let cjson = convert.xml2json(edmx, {
         compact: true,
         spaces: 4
@@ -21,21 +37,15 @@ async function _generateEDMX2JSON(edmx) {
     return JSON.parse(cjson);
 }
 
-function checkForEmptyKeys(element, oDataVersion) {
-    if (oDataVersion === "V2") {
-        return (element.includes(["cds.Association"]) && !element.includes(['"on":']));
+async function _isValidXML(edmx) {
+    let isValid = false;
+    try {
+        generateEDMX2JSON(edmx);
+        isValid = true;
+    } catch (err) {
+        isValid = false;
     }
-    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);
+    return isValid;
 }
 
 async function _getODataVersion(edmx) {
@@ -47,7 +57,7 @@ async function _getODataVersion(edmx) {
     if (_isJson(edmx)) {
         return '';
     }
-    jsonObj = await _generateEDMX2JSON(edmx);
+    jsonObj = await generateEDMX2JSON(edmx);
     try {
         dataServices = jsonObj['edmx:Edmx']['edmx:DataServices'];
         dataServicesAttributes = dataServices._attributes;
@@ -84,11 +94,10 @@ async function _isOdataV4(fileInputStream) {
     if (_isJson(fileInputStream)) {
         edmj = JSON.parse(fileInputStream);
         version = edmj.$Version;
-        // read $Version from JSON
     } else {
         version = await _getODataVersion(fileInputStream);
     }
-    if (version === '4.0') {
+    if (version === '4.0' || version === "4.01") {
         isV4 = true;
     }
     return isV4;
@@ -108,21 +117,327 @@ 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" };
+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 getContentFromFile(path) {
+    let fileContent;
+    fileContent = await read(path, "utf-8");
+    return fileContent;
+}
+
+async function getContentFromURL(url) {
+    let edmx;
+    const response = await axios.get(url);
+    edmx = response["data"];
+    if (edmx && (await _isValidXML(edmx))) {
+        return edmx;
+    } else {
+        throw new Error(messages.INVALID_EDMX_METADATA);
+    }
+}
+
+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() {
+function _supportedAsFormats() {
     return ["cds", "csn", "json"];
 }
 
+function _supportedFileExtensions() {
+    return ["edmx", "xml", "json"];
+}
+
+function _getInputFileExtension(inputFile) {
+    let startIndex = inputFile.lastIndexOf(".");
+    return inputFile.substring(startIndex + 1);
+}
+
+async function isValidInputFile(inputFileLoc) {
+    const fileResolved = await fs.isfile(inputFileLoc);
+    if (!fileResolved) throw new Error(messages.SPECIFY_INPUT_FILE);
+    let fileExtension = _getInputFileExtension(inputFileLoc);
+    if (_supportedFileExtensions().includes(fileExtension)) return fileResolved;
+    else throw new Error(messages.INVALID_INPUT_FILE);
+}
+
+async function _copyToSrvExternal(file, dst, cwd) {
+    const dstDir = path.dirname(dst), srcDir = path.dirname(file)
+    if (!file.startsWith(dstDir + path.sep)) {
+        await mkdirp(dstDir);
+        const copyOrMove = srcDir === cwd || srcDir == process.cwd() ? fs.renameSync : fs.copyFileSync;
+        await copyOrMove(file, dst);
+        return dst;
+    }
+    return file;
+}
+
+async function preProcess(file, options, cwd) {
+    let srcFilePath = await isValidInputFile(path.resolve(cwd, file));
+    if (options.as && !_supportedAsFormats().includes(options.as))
+        throw new Error(messages.INVALID_AS_OPTION);
+
+    const external = path.resolve(cwd, 'srv/external');
+    const destFilePath = path.join(external, path.basename(srcFilePath));
+
+    if (!options.dry && !options.no_copy)
+        srcFilePath = await _copyToSrvExternal(srcFilePath, destFilePath, cwd);
+
+    return [srcFilePath, destFilePath];
+}
+
+async function processOptions(cliOptions, odataOptions) {
+    //maps to renaming of variables
+    for (let [key, value] of Object.entries(optionsMapping)) {
+        if (cliOptions[key]) {
+            cliOptions[value] = cliOptions[key];
+            delete cliOptions[key];
+        }
+    }
+    //segregating cli/odata options
+    apiOptions.forEach(function (item) {
+        odataOptions[item] = cliOptions[item];
+        delete cliOptions[item];
+    });
+    //reads cli options from environment
+    readEnvVariables(cliOptions, true);
+
+
+}
+
+function _getServiceName(csn) {
+    for (let each in csn.definitions) {
+        if (csn.definitions[each].kind === 'service') return each;
+    }
+}
+
+function _validateAndComputeOutputFilePath(outputFileLoc, as, destFilePath) {
+    let index, extension, expectedExtension, supportedExtension;
+    if (typeof (outputFileLoc) !== 'boolean') {
+        index = outputFileLoc.lastIndexOf(".");
+        extension = outputFileLoc.substring(index + 1);
+        expectedExtension = (as) ? _getSuffix(as) : "csn";
+        supportedExtension = (index > 0) ? _supportedAsFormats().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 (index > 0 && !supportedExtension) {
+        // extension not supported, eg., "test.abs", "./sv/external.test.abcs", "./a."
+        throw new Error(messages.INVALID_OUTPUT_FILE);
+    } 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\") 
+        return outputFileLoc + path.parse(destFilePath).name;
+    }
+}
+
+async function _generateChecksumValidate(dest, output, force) {
+    let fileExists = await exists(dest);
+
+    // force flag disabled and cds file already exists, then throw error
+    if (!force && fileExists) {
+        throw new Error(messages.FILE_MODIFIED);
+    }
+
+    const currentChecksum = md5(output);
+    let existingFileContent, existingFileContentWithoutChecksum;
+    let existingFileContentChecksum, existingChecksumValue;
+
+    if (fileExists) {
+        existingFileContent = await read(dest, "utf-8");
+        const checksumStartIndex = existingFileContent.indexOf(`/* checksum : `);
+        const checksumEndIndex = existingFileContent.indexOf(" */");
+
+        if (checksumStartIndex >= 0) {
+            existingFileContentWithoutChecksum = existingFileContent.substring(
+                checksumEndIndex + 4
+            );
+            existingChecksumValue = existingFileContent.substring(
+                checksumStartIndex + 14, checksumEndIndex
+            );
+            existingFileContentChecksum = md5(existingFileContentWithoutChecksum);
+        }
+    }
+
+    // if force flag enbabled
+    if (force) {
+        // current and existing file content are same, and the existing
+        // checksum is not modified, then return the existing file content
+        if (currentChecksum == existingFileContentChecksum &&
+            currentChecksum == existingChecksumValue) {
+            return existingFileContent;
+        }
+    }
+    /*
+     * 1. current and existing checksum are different.
+     * 2. checksum is missing in the existing file:
+     *     a. existing and current file content are same.
+     *     b. existing and current file content are different.
+     * 3. cds file doesn't exist.
+     * 4. checksum of the existing file is modified.
+     */
+    return "/* checksum : " + currentChecksum + " */\n" + output;
+}
+
+async function _getResult(output, as, dest, force, version) {
+    let extension = dest.substring(dest.lastIndexOf(".") + 1);
+    as = (as === "cds") ? "cdl" : as;
+
+    // output filepath should simply contain .csn as extension
+    if (version === 'rest' &&  ['swagger', 'openapi3'].includes(extension)) {
+        dest = dest.replace('.' + extension, '');
+    }
+
+    if (!_supportedAsFormats().includes(extension)) {
+        // dest doesn't have any file extension, so get it
+        extension = _getSuffix(as);
+        dest += '.' + extension;
+    }
+
+    if (as && as != "csn" && as != "json") {
+        // cdsCompiler[as] will convert the csn output into various output formats
+        output = cdsCompiler[as](output);
+    }
+
+    switch (as) {
+        case "cdl":
+            output = await _generateChecksumValidate(dest, output, force);
+            break;
+        case undefined:
+        case "csn":
+        case "json":
+            output = JSON.stringify(output, null, '  ');
+            break;
+        default:
+            break;
+    }
+
+    return [output, dest];
+}
+
+async function _write(result, service, cwd) {
+    let dest, output, using, message, extenstion;
+    output = result[0];
+    dest = result[1];
+    await write(dest, output, "utf-8");
+
+    extenstion = dest.substring(dest.lastIndexOf('.'));
+    dest = dest.replace(extenstion, '');
+    using = `using { ${service} as external } from './${path.relative('srv', dest).replace(/\\/g, '/')}'`;
+    using = require('../util/term').info(using);
+    message = `[cds] - imported API to ${path.relative(cwd, dest)}
+> use it in your CDS models through the like of:
+
+${using}
+`;
+
+    console.log(message);
+}
+
+async function _updatePackageJson(dest, service, version, cwd) {
+    const package_json = path.resolve(cwd, 'package.json');
+    const conf = await exists(package_json) ? require(package_json) : {};
+    const requires = ['cds', 'requires'].reduce((p, n) => p[n] || (p[n] = {}), conf);
+    if (version !== 'rest') {
+        version = (version === "V2") ? 'odata-v2' : 'odata';
+    }
+    if (!requires[service]) {
+        const model = path.relative(cwd, dest);
+        cds.env.requires[service] = requires[service] = { kind: version, model };
+        await write(package_json, JSON.stringify(conf, null, '  '));
+        console.log(`[cds] - updated ./package.json`);
+    }
+}
+
+async function postProcess(filePath, options, csn, cwd) {
+    const service = _getServiceName(csn);
+    if (options.out) options.out = _validateAndComputeOutputFilePath(options.out, options.as, filePath);
+    const version = options.inputFileVersion;
+    const result = await _getResult(csn, options.as, options.out || filePath.replace(/\.[^.]+$/, ''), options.force, version);
+    const written = options.dry || await _write(result, service, cwd);
+    const registered = options.dry || options.no_save || await _updatePackageJson(result[1].replace(/\.[^.]+$/, ''), service, version, cwd);
+    if (options.dry) return console.log(result[0]);
+    return Promise.all([written, registered]);
+}
+
+async function identifyFile(filepath) {
+    let extension = _getInputFileExtension(filepath);
+    if (["edmx", "xml"].includes(extension)) {
+        return "edmx";
+    } else if (["json", "yaml", "yml"].includes(extension)) {
+        // based on the file content determine if it is openapi or asyncapi file and return the correct type
+        filepath = await isValidInputFile(path.resolve(process.cwd(), filepath));
+        const src = await getContentFromFile(filepath);
+        //for openapi
+        let jsonSrc = JSON.parse(src);
+        // eslint-disable-next-line no-prototype-builtins
+        if (jsonSrc.hasOwnProperty('openapi') || jsonSrc.hasOwnProperty('swagger')) {
+            return "openapi";
+        }
+    } else
+        return extension;
+}
+
+function readEnvVariables(options, cliCheck) {
+    if (cds.env.import) {
+        if (cliCheck) {
+            for (let key of commonOptions) {
+                if (key !== 'force' && !options[key]) {
+                    options[key] = cds.env.import[key];
+                }
+            }
+            if (options.as && !options.force) options.force = cds.env.import.force;
+        }
+        else {
+            for (let [key, value] of Object.entries(options)) {
+                if (!value) options[key] = cds.env.import[key];
+            }
+        }
+    }
+}
+
 module.exports = {
+    generateEDMX2JSON,
     getVersion,
-    getSuffix,
-    supportedFormats,
     checkForEmptyKeys,
-    replaceAliasValue
+    replaceAliasValue,
+    getContentFromFile,
+    getContentFromURL,
+    isValidInputFile,
+    preProcess,
+    postProcess,
+    identifyFile,
+    readEnvVariables,
+    processOptions
 };

package/lib/import/importapi.js

@@ -1,21 +1,89 @@
-const edm2csn = require('.');
-let context={};
-context.oDataInfo = {};
-context.namespaces = [];
+let cds = require('../cds');
+let { path } = cds.utils;
+let common = require('./common');
+let odata = require('./odata');
+let openapi = require('./openapi');
+let messages = require('./message').getMessages();
+
+module.exports = Object.assign(cds_import, {
+    from: cds.lazified({
+        edmx: cds_import_from_edmx,
+        openapi: cds_import_from_openapi
+    })
+});
+
 /**
 * This is the import API function to generate CSN from XML/EDMX files.
 * @param {string} filepath
 * - a single valid filepath
-* @param {{} | {keepNamespace:_keepNamespace, ...}} options
-* - an options object specifying the keepNamespace option on how CSN is to be generated
-* - optional parameter
+* @param {{} | {keepNamespace:_keepNamespace, includeNamespaces:_includeNamespaces...}} options
+* - an options object for importing OData files specifying the keepNamespace, includeNamespaces options
+* - Default values for OData V2: {keepNamespace: false, includeNamespaces:"edmx,m,sap"}
+* - Default values for OData V4: {keepNamespace: false, includeNamespaces:"edmx"}
+* - optional parameters
 * - other import options not supported
 * @returns {object} CSN
 */
-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, context);
-        return csn;
+async function cds_import(filepath, options = { keepNamespace: false }) {
+    // identifies the file and calls the respective api
+    let fileType = await common.identifyFile(filepath);
+    let csn;
+    switch (fileType) {
+        case "edmx":
+            csn = await cds_import_from_edmx(filepath, options);
+            break;
+        case "openapi":
+            csn = await cds_import_from_openapi(filepath, options);
+            break;
+        default:
+            throw new Error(messages.INVALID_INPUT_FILE);
+    }
+    return csn;
+}
+
+/**
+* This is the import API function to generate CSN from XML/EDMX files.
+* @param {string} filepath
+* - a single valid filepath
+* @param {{} | {keepNamespace:_keepNamespace, includeNamespaces:_includeNamespaces...}} options
+* - an options object specifying the keepNamespace, includeNamespaces options on how CSN is to be generated
+* - Default values for OData V2: {keepNamespace: false, includeNamespaces:"edmx,m,sap"}
+* - Default values for OData V4: {keepNamespace: false, includeNamespaces:"edmx"}
+* - optional parameters
+* - other import options not supported
+* @returns {object} CSN
+*/
+async function cds_import_from_edmx(filepath, options = { keepNamespace: false }) {
+    // validates and reads the input file
+    filepath = await common.isValidInputFile(path.resolve(process.cwd(), filepath));
+    const src = await common.getContentFromFile(filepath);
+    // takes the api specific options and reads it from env
+    let odataOptions = { include_namespaces: options.includeNamespaces, keep_namespace: options.keepNamespace };
+    if (cds.env.import) {
+        common.readEnvVariables(odataOptions, false);
+    }
+    // generates csn
+    odataOptions.include_all_namespaces = false;
+    odataOptions.namespaces = [];
+    if (odataOptions.include_namespaces) odata.getNamespaces(odataOptions);
+    let csn = await odata.edmx2csn(src, !odataOptions.keep_namespace && filepath, odataOptions);
+    //reading the file version
+    options.inputFileVersion = odataOptions.inputFileVersion;
+    // return the csn
+    return csn;
+}
+
+/**
+* This is the import API function to generate CSN from openapi files.
+* @param {string} filepath
+* - a single valid filepath
+* @returns {object} CSN
+*/
+async function cds_import_from_openapi(filepath, options = {}) {
+    // validates the input file
+    filepath = await common.isValidInputFile(path.resolve(process.cwd(), filepath));
+    const src = await common.getContentFromFile(filepath);
+    let csn = openapi.openAPI2csn(src);
+    options.inputFileVersion = 'rest';
+    return csn;
 }

package/lib/import/message.js

@@ -3,19 +3,19 @@
 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 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 valid file with either .edmx, .xml extension for OData or .json extension for OpenAPI.',
 	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 "*"',
 	MISSING_ASSOCIATION_SETS: 'Input file provided has missing Association Sets. Please check the edmx file.',
-	COLLECTION_IN_KEY: 'Key Property of an Entity cannot be of the type Collection.'
+	COLLECTION_IN_KEY: 'Key Property of an Entity cannot be of the type Collection.',
+	INVALID_OPENAPI_FILE: 'The OpenAPI file is not valid. Specify the correct OpenAPI file.'
 };
 
 function getMessages() {
@@ -24,4 +24,4 @@ function getMessages() {
 
 module.exports = {
 	getMessages
-};
+};