@sap/cds-dk 6.7.1 → 6.8.0

package/lib/import/asyncapi/parserContext.js

@@ -0,0 +1,351 @@
+const { typeRegex } = require('./utils');
+const messages = require("../message").getMessages();
+
+module.exports = class ParserContext {
+    /**
+     * @constructor
+     */
+    constructor(content) {
+        this.services = this.getServicesFromContent(content);
+    }
+
+    /**
+     * Returns services from the asyncapi json object along with the events and annotations.
+     * @returns an object with all the services.
+     */
+    getServicesFromContent(content) {
+        const services = {};
+        const serviceAnnotations = this.getServiceAnnotations(content);
+
+        Object.entries(content.components.messages).forEach(([key, value]) => {
+            // uses regex to break event name in different components
+            const regexGroups = typeRegex.exec(key);
+            if (regexGroups == null) {
+                throw new Error(messages.INVALID_MESSAGE_NAME);
+            }
+
+            const service = regexGroups[1] + "." + regexGroups[2];
+            const event = regexGroups[0];
+
+            // add service to services entry if not present
+            if (!(service in services)) {
+                services[service] = { 'kind': 'service', ...serviceAnnotations, 'events': {}, 'types': {} };
+            }
+
+            // add event entry to service
+            const eventAnnotations = this.getEventAnnotations(value);
+
+            let properties = {};
+            let types = {};
+
+            if (value.payload) {
+                // gets the schema being referred to in the event
+                const eventSchema = this.resolveRef(content, value.payload);
+                [properties, types] = this.getPropertiesAndTypes(event, eventSchema);
+            }
+            services[service].types = types;
+            services[service].events[event] = { 'kind': 'event', ...eventAnnotations, elements: properties };
+        });
+
+        return services;
+    }
+
+    /**
+     * Returns annotations of a particular service.
+     * @returns an object with all the annotations as key value pairs.
+     */
+    getServiceAnnotations(content) {
+        const serviceAnnotationsMapping = {
+            'x-sap-stateInfo': 'StateInfo', //expected: object
+            'x-sap-shortText': 'ShortText' //expected: string
+        };
+
+        const infoAnnotationsMapping = {
+            'title': 'Title', //expected: string
+            'version': 'SchemaVersion', //expected: string
+            'description': 'Description' //expected: string
+        };
+
+        const annotations = this.getAnnotations(content, serviceAnnotationsMapping);
+
+        if (content.info) {
+            for (const [key, value] of Object.entries(infoAnnotationsMapping)) {
+                if (content.info[key] && !(content.info[key] instanceof Object)) {
+                    // info values will always be in string format
+                    annotations['@AsyncAPI.' + value] = content.info[key];
+                }
+            }
+        }
+
+        return annotations;
+    }
+
+    /**
+     * Returns annotations of a particular event. Here the parameter content is event content.
+     * @returns an object with all the annotations as key value pairs.
+     */
+    getEventAnnotations(content) {
+        const eventLevelAnnotationsMapping = {
+            'x-sap-event-spec-version': 'EventSpecVersion', //expected: string
+            'x-sap-event-source': 'EventSource', //expected: string
+            'x-sap-event-source-parameters': 'EventSourceParams', //expected: object
+            'x-sap-event-characteristics': 'EventCharacteristics', //expected: object
+            'x-sap-stateInfo': 'EventStateInfo', //expected: object
+            'x-sap-event-version': 'EventSchemaVersion' //expected: string
+        };
+
+        const annotations = this.getAnnotations(content, eventLevelAnnotationsMapping);
+
+        return annotations;
+    }
+
+    /**
+     * Returns validity of the annotation value. Here the parameter 
+     * content is the annotation name and value of the annotation.
+     * @returns true/false depending on the annotation value.
+     */
+    isValidAnnotationValue(annotation, value) {
+        const objectTypeAnnotations = ['StateInfo', 'EventSourceParams', 'EventCharacteristics', 'EventStateInfo'];
+        // if the value is an array or null
+        if (Array.isArray(value) || value === null) return false;
+
+        if (objectTypeAnnotations.includes(annotation) && (value instanceof Object)) {
+            return true;
+        } else if ((!objectTypeAnnotations.includes(annotation)) && (typeof value === 'string')) {
+            return true;
+        } else {
+            console.warn(`WARNING: Annotations which are not following the expected type are omitted.`);
+            return false;
+        }
+    }
+
+    /**
+     * Returns annotations for an event/service. Here the parameter content 
+     * is event/service content along with the corresponding mapping.
+     * @returns an object with the annotations as key value pairs.
+     */
+    getAnnotations(content, annotationsMapping) {
+        const annotations = {};
+
+        for (const [key, value] of Object.entries(content)) {
+            // case: known annotation
+            if (annotationsMapping[key] && this.isValidAnnotationValue(annotationsMapping[key], value)) {
+                annotations['@AsyncAPI.' + annotationsMapping[key]] = value;
+            } 
+            // case: unkown annotation
+            else if (key.startsWith('x-sap-')) {
+                if (!annotations['@AsyncAPI.Extensions']) {
+                    annotations['@AsyncAPI.Extensions'] = {};
+                }
+                annotations['@AsyncAPI.Extensions'][key] = value;
+            }
+        }
+
+        return annotations;
+    }
+
+    /**
+     * Returns the referred schema. Here the content is the asyncapi
+     * document and payloadObject is the reference path
+     * @returns an object with the referred schema.
+     */
+    resolveRef(content, payloadObject) {
+        let schema = {};
+
+        if (payloadObject['$ref']) {
+            const pathArray = payloadObject['$ref'].split('/');
+            pathArray.forEach((value) => {
+                if (value === '#') schema = content;
+                else if (schema[value]) schema = schema[value];
+                // in case path doesn't exist in the file
+                else schema = {};
+            });
+
+            if (!Object.keys(schema).length) {
+                console.warn(`WARNING: Unable to resolve ref path: ` + payloadObject['$ref']);
+            }
+        }
+        else if (payloadObject instanceof Object) {
+            // in case ref is not there and schema object is there
+            schema = payloadObject;
+        }
+
+        return schema;
+    }
+
+    /**
+     * Returns the properties and types generated, related to an event.
+     * @returns a properties object and a types object.
+     */
+    getPropertiesAndTypes(eventName, content) {
+        const properties = {};
+        let types = {};
+
+        if (content.properties) {
+            for (const [key, value] of Object.entries(content.properties)) {
+                // will contain type objects generated for a property
+                let referredTypes = {};
+                let isRequired = false;
+                if (content['required']?.includes(key)) isRequired = true;
+                [properties[key], referredTypes] = this.parseProperty(eventName, key, value, isRequired);
+                // collecting all the types
+                types = { ...types, ...referredTypes };
+            }
+        }
+        return [properties, types];
+    }
+
+    /**
+     * Returns the processed objects for property and type.
+     * @returns property object and type object.
+     */
+    parseProperty(eventName, propertyName, propertyContent, isRequired) {
+        let property = {};
+        let propertyAttributes = {};
+        let types = {};
+
+        if (isRequired === true) {
+            property['@mandatory'] = true;
+        }
+
+        let type = this.getTypeFromArray(propertyContent.type);
+
+        // case where type is defined
+        if (type && (type === 'object' || type === 'array')) {
+            // for generation of type: event name + property name
+            propertyName = propertyName[0].toUpperCase() + propertyName.substring(1);
+            let typeName = eventName + "." + propertyName;
+            // generate object for the introduced type
+            const elements = this.getTypeElements(propertyContent);
+            types[typeName] = { 'kind': 'type', ...elements };
+            // referring to the generated type from the property
+            propertyAttributes = { 'type': typeName };
+        } else {
+            propertyAttributes = this.getPropertyObject(propertyContent);
+        }
+        property = { ...property, ...propertyAttributes };
+
+        return [property, types];
+    }
+
+    /**
+     * Returns generated type for the property.
+     * @returns an object for a type.
+     */
+    getTypeElements(propertyContent) {
+        let properties = {};
+        let type = this.getTypeFromArray(propertyContent.type);
+
+        // for nested object
+        if (type === 'object') {
+            for (const [key, value] of Object.entries(propertyContent.properties)) {
+                properties[key] = this.getTypeElements(value);
+            }
+        }
+        // for nested array
+        else if (type === 'array') {
+            properties.items = this.getTypeElements(propertyContent.items);
+            return properties;
+        }
+        // base data type mapping
+        else {
+            return this.getPropertyObject(propertyContent);
+        }
+
+        return { elements: properties };
+    }
+
+    /**
+     * Returns type for the property from the AsyncAPI Document.
+     * @returns the value of type.
+     */
+    getTypeFromArray(typeValue) {
+        let type;
+        // if type is an array
+        if (Array.isArray(typeValue)) {
+            // one of the value will be null
+            type = typeValue[0] === 'null' ? typeValue[1] : typeValue[0];
+        } else {
+            type = typeValue;
+        }
+
+        return type;
+    }
+
+    /**
+     * Returns generated object for a single property.
+     * @returns an object for a property.
+     */
+    getPropertyObject(propertyContent) {
+        const property = {};
+        const inputType = this.getTypeFromArray(propertyContent.type);
+        const cdsType = this.getDataType(inputType, propertyContent.format);
+
+        property['type'] = cdsType;
+
+        // case: cds type is decimal
+        if (cdsType === 'cds.Decimal') {
+            if (propertyContent['x-sap-precision']) property.precision = propertyContent['x-sap-precision'];
+            if (propertyContent['x-sap-scale']) property.scale = propertyContent['x-sap-scale'];
+        }
+
+        if (propertyContent['default']) {
+            property['default'] = { 'val': propertyContent['default'] };
+        }
+
+        if (propertyContent['enum']) {
+            property['enum'] = this.getEnumObject(propertyContent['enum']);
+        }
+
+        return property;
+    }
+
+    /**
+     * Takes the enums from the AsyncAPI Document.
+     * @returns the property object of enums.
+     */
+    getEnumObject(enumArray) {
+        const enumProperty = {};
+
+        enumArray.forEach(val => {
+            enumProperty[val] = {};
+        });
+
+        return enumProperty;
+    }
+
+    /**
+     * Takes the type and format from the document and returns the corresponding cds type.
+     * @returns the corresponding cds type.
+     */
+    getDataType(type, format = null) {
+        const asyncapiToCdsMapping = {
+            'number': 'cds.Double',
+            'boolean': 'cds.Boolean',
+            'integer': 'cds.Integer'
+        };
+
+        if (type === 'string') {
+            switch (format) {
+                case 'int64':
+                    return 'cds.Integer64';
+                case 'decimal':
+                    return 'cds.Decimal';
+                case 'uuid':
+                    return 'cds.UUID';
+                case 'date':
+                    return 'cds.Date';
+                case 'partial-time':
+                    return 'cds.Time';
+                case 'date-time':
+                    return 'cds.Timestamp';
+                default:
+                    return 'cds.LargeString';
+            }
+        } else if (asyncapiToCdsMapping[type]) {
+            return asyncapiToCdsMapping[type];
+        } else {
+            throw new Error(messages.UNRESOLVED_TYPE + `'${type}'`);
+        }
+    }
+}

package/lib/import/asyncapi/utils.js

@@ -0,0 +1,18 @@
+const messages = require("../message").getMessages();
+
+function validateAsyncAPI(content) {
+    if ('channels' in content && 'components' in content && 'messages' in content.components) {
+        return;
+    }
+
+    throw new Error(messages.INVALID_ASYNCAPI_FILE);
+}
+
+const typeRegex = new RegExp(
+    '^(?<namespace>(?:[a-z][a-z0-9]*)(?:[.][a-z][a-z0-9]*)+)[.](?<businessObject>[a-zA-Z0-9]+)[.](?<operation>[a-zA-Z0-9]+)([.](?<version>v(?:[0-9]|[1-9][0-9]*)))?$'
+);
+
+module.exports = {
+    validateAsyncAPI,
+    typeRegex
+}

package/lib/import/common.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-prototype-builtins */
 'use strict';
 
 let convert = require('xml-js');
@@ -18,17 +19,6 @@ let optionsMapping = {
 let apiOptions = ['includeNamespaces', 'keepNamespace'];
 let commonOptions = ['no_copy', 'no_save', 'out', 'dry', 'as', 'from', 'force'];
 
-function _isJson(edmx) {
-    let isJson = false;
-    try {
-        JSON.parse(edmx);
-        isJson = true;
-    } catch (err) {
-        isJson = false;
-    }
-    return isJson;
-}
-
 async function generateEDMX2JSON(edmx) {
     let cjson = convert.xml2json(edmx, {
         compact: true,
@@ -49,71 +39,34 @@ async function _isValidXML(edmx) {
 }
 
 async function _getODataVersion(edmx) {
-    let oDataVersion;
-    let jsonObj;
-    let dataServices;
-    let dataServicesAttributes;
-    // Check OData version
-    if (_isJson(edmx)) {
-        return '';
-    }
-    jsonObj = await generateEDMX2JSON(edmx);
-    try {
-        dataServices = jsonObj['edmx:Edmx']['edmx:DataServices'];
-        dataServicesAttributes = dataServices._attributes;
-    } catch (err) {
-        oDataVersion = '';
-    }
-    if (dataServicesAttributes) {
-        oDataVersion = dataServicesAttributes['m:DataServiceVersion'];
-    } else {
-        // V4 edmx
-        try {
-            oDataVersion = jsonObj['edmx:Edmx']._attributes.Version;
-        } catch (err) {
-            oDataVersion = '';
-        }
-    }
-    return oDataVersion;
-}
+    let oDataVersion = "";
 
-async function _isOdataV2(fileInputStream) {
-    let isV2 = false;
-    // existing logic
-    const version = await _getODataVersion(fileInputStream);
-    if (version === '1.0' || version === '2.0') {
-        isV2 = true;
+    let checkForV2 = edmx.match(/m:DataServiceVersion="[^"]+"/);
+    if (checkForV2) {
+        oDataVersion = checkForV2[0].split('"')[1];
+        return oDataVersion;
     }
-    return isV2;
-}
 
-async function _isOdataV4(fileInputStream) {
-    let isV4 = false;
-    let version;
-    let edmj;
-    if (_isJson(fileInputStream)) {
-        edmj = JSON.parse(fileInputStream);
-        version = edmj.$Version;
-    } else {
-        version = await _getODataVersion(fileInputStream);
+    let edmxMatching = edmx.match(/<edmx:Edmx[^>]+"/);
+    if (edmxMatching) {
+        let checkForV4 = edmxMatching[0].match(/Version="[^"]+"/);
+        oDataVersion = checkForV4[0].split('"')[1];
     }
-    if (version === '4.0' || version === "4.01") {
-        isV4 = true;
-    }
-    return isV4;
+
+    return oDataVersion;
 }
 
-async function getVersion(fileInputStream) {
-    // method to find the version
-    // input can be JSON or XML
-    // if xml, find the version
-    // if json, find the version
+// method to find the version, input is in XML format
+async function getVersion(fileInputStream){
     let oDataVersion;
-    if (await _isOdataV2(fileInputStream)) {
+    const version = await _getODataVersion(fileInputStream);
+
+    if (version === '1.0' || version === '2.0') {
         oDataVersion = 'V2';
-    } else if (await _isOdataV4(fileInputStream)) {
+    } else if (version === '4.0' || version === "4.01") {
         oDataVersion = 'V4';
     }
+    
     return oDataVersion;
 }
 
@@ -402,9 +355,10 @@ async function identifyFile(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 if (jsonSrc.hasOwnProperty('asyncapi')){
+            return "asyncapi";    
         }
     } else
         return extension;

package/lib/import/importapi.js

@@ -3,12 +3,14 @@ let { path } = cds.utils;
 let common = require('./common');
 let odata = require('./odata');
 let openapi = require('./openapi');
+let asyncapi = require('./asyncapi');
 let messages = require('./message').getMessages();
 
 module.exports = Object.assign(cds_import, {
     from: cds.lazified({
         edmx: cds_import_from_edmx,
-        openapi: cds_import_from_openapi
+        openapi: cds_import_from_openapi,
+        asyncapi: cds_import_from_asyncapi
     })
 });
 
@@ -35,6 +37,9 @@ async function cds_import(filepath, options = { keepNamespace: false }) {
         case "openapi":
             csn = await cds_import_from_openapi(filepath, options);
             break;
+        case "asyncapi":
+            csn = await cds_import_from_asyncapi(filepath, options);
+            break;
         default:
             throw new Error(messages.INVALID_INPUT_FILE);
     }
@@ -63,12 +68,13 @@ async function cds_import_from_edmx(filepath, options = { keepNamespace: false }
         common.readEnvVariables(odataOptions, false);
     }
     // generates csn
+    odataOptions.odataVersion = await common.getVersion(src);
     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;
+    options.odataVersion = odataOptions.odataVersion;
     // return the csn
     return csn;
 }
@@ -86,4 +92,19 @@ async function cds_import_from_openapi(filepath, options = {}) {
     let csn = openapi.openAPI2csn(src);
     options.inputFileVersion = 'rest';
     return csn;
+}
+
+/**
+* This is the import API function to generate CSN from asyncapi files.
+* @param {string} filepath
+* - a single valid filepath
+* @returns {object} CSN
+*/
+async function cds_import_from_asyncapi(filepath, options = {}) {
+    // validates the input file
+    filepath = await common.isValidInputFile(path.resolve(process.cwd(), filepath));
+    const src = await common.getContentFromFile(filepath);
+    let csn = asyncapi.asyncapi2csn(src);
+    options.inputFileVersion = 'odata';
+    return csn;
 }

package/lib/import/message.js

@@ -16,9 +16,19 @@ const messages = {
 	MISSING_ASSOCIATION: 'Association is missing in the input file provided. Please check the edmx file.',
 	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.',
+	INVALID_ASYNCAPI_FILE: 'The AsyncAPI file is not valid. Specify the correct AsyncAPI file.',
+	INVALID_MESSAGE_NAME: 'The message name is not valid.',
 	UNRESOLVED_TYPE: 'Could not resolve the type: ',
 	NO_RETURN_TYPE: 'No ReturnType found in Function: ',
-	INVALID_ENUM_TYPE: 'The Underlying type provided is not supported for the EnumType: '
+	INVALID_ENUM_TYPE: 'The Underlying type provided is not supported for the EnumType: ',
+	UNBOUNDED_ACTION_COLLISION: 'Unbounded Action does not support collision. Check the Action ',
+	INVALID_BOUNDED_PARAM_TYPE: 'Parameter Type of Bounded Action/Function should not refer to an Entity in another Schema.',
+	BOUNDED_ACTION_COLLISION: 'For Bounded Action, combination of action name and binding parameter type should be unique.',
+	STREAM_NO_COLLECTION: `'Edm.Stream' cannot be of Collection type.`,
+	UNSUPPORTED_PROPERTY_TYPE: 'Property cannot be of EntityType. Check the type: ',
+	UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
+	INVALID_DATATYPE: `Invalid Data Type `,
+	ELEMENT_NAME_COLLISION: 'Collision between EntityContainer Element Name and Schema Element Name is currenlty not supported. Please check the element name: '
 };
 
 function getMessages() {

package/lib/import/odata/index.js

@@ -53,6 +53,7 @@ function _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace) {
 
 async function edmx2csn(edmx, filename, context) {
 	let namespace;
+	// we might get aliased namespace value here
 	const result = edmx.match(/EntityType="([^"]+)/);
 	const multipleSchemas = /(\s*<\/Schema>\s*<Schema [^>]*>)\s*/m;
 	if (result) {
@@ -67,13 +68,23 @@ async function edmx2csn(edmx, filename, context) {
 		schema = schema[0].match(/Namespace="[^"]+"/);
 		namespace = schema[0].slice(schema[0].lastIndexOf('Namespace') + 11, schema[0].lastIndexOf('"'));
 	}
-	if (multipleSchemas.test(edmx)) {
+	// this hack is only used for OData V2, for V4 we support multiple schema scenario
+	if (context.odataVersion === 'V2' && multipleSchemas.test(edmx)) {
 		edmx = _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace);
 	}
 	let csn = await _generateCSN(edmx, false, true, context);
 	const regex = /^[\p{Letter}\p{Nl}_]{1}[_\p{Letter}\p{Nl}\p{Nd}\p{Mn}\p{Mc}\p{Pc}\p{Cf}]{0,127}$/gu
 	// Regex checks for this condition “A-B” must start with a letter or underscore, followed by at most 127 letters, underscores or digits in the fileName
 	if (filename) {
+		/**
+		 * V4: <Schema Namespace="Full.Schema.Name" xmlns="http://docs.oasis-open.org/odata/ns/edm" Alias="aliasedValue">
+		 * V2: <Schema Namespace="Full.Schema.Name" xmlns="http://schemas.microsoft.com/ado/2008/09/edm" Alias="aliasedValue">
+		 * 
+		 * context.schemaNamespace is set to correct namespace value by the respective parsers
+		 */
+		if (context.schemaNamespace) {
+			namespace = context.schemaNamespace;	
+		}
 		// Replace namespace by given filename in the csn file instead of edmx file
 		const re = RegExp(`([("/])${namespace}([/").])`, 'g');
 		let name = path.parse(filename).name;
@@ -89,16 +100,11 @@ async function edmx2csn(edmx, filename, 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.inputFileVersion = "V2";
-		}
+	if (context.odataVersion === "V2") {
 		// default namespaces to be present
 		if (!context.include_all_namespaces) {
 			defaultNamespaces = ['edmx', 'sap', 'm'];
@@ -113,10 +119,7 @@ async function _generateCSN(edmx, ignorePersistenceSkip, mockServerUc, context)
 			else reject("Error Occurred");
 		});
 	}
-	else if (odataVersion === 'V4') {
-		if (context) {
-			context.inputFileVersion = "V4";
-		}
+	else if (context.odataVersion === 'V4') {
 		// default namespaces to be present
 		if (!context.include_all_namespaces) {
 			defaultNamespaces = ['edmx'];