@sap/cds-dk 6.8.2 → 7.0.0

package/lib/import/asyncapi/parserContext.js

@@ -1,4 +1,4 @@
-const { typeRegex } = require('./utils');
+const { getRegExpGroups } = require('./utils');
 const messages = require("../message").getMessages();
 
 module.exports = class ParserContext {
@@ -6,9 +6,41 @@ module.exports = class ParserContext {
      * @constructor
      */
     constructor(content) {
+        this.topics = this.getTopics(content);
         this.services = this.getServicesFromContent(content);
     }
 
+    getTopicName(channelName) {
+        return channelName.startsWith('ce/') ? channelName.substring(3) : channelName;
+    }
+
+    getEventName(messageRefString) {
+        const lastSlashIndex = messageRefString.lastIndexOf('/');
+        return lastSlashIndex == -1 ? '' : messageRefString.substring(lastSlashIndex + 1);
+    }
+
+    /**
+     * Return an obect with topic annotations for messages
+     */
+    getTopics(content) {
+        const topics = {};
+
+        Object.entries(content.channels).forEach(([key, value]) => {
+            const topic = this.getTopicName(key);
+            if (value.subscribe && value.subscribe.message && value.subscribe.message.$ref) {
+                const event = this.getEventName(value.subscribe.message.$ref);
+                topics[event] = topic;
+            }
+
+            if (value.publish && value.publish.message && value.publish.message.$ref) {
+                const event = this.getEventName(value.publish.message.$ref);
+                topics[event] = topic;
+            }
+        });
+
+        return topics;
+    }
+
     /**
      * Returns services from the asyncapi json object along with the events and annotations.
      * @returns an object with all the services.
@@ -18,23 +50,31 @@ module.exports = class ParserContext {
         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);
+            let eventName;
+            // Message name should be used to capture the event name
+            if (value.name) {
+                eventName = value.name;
+            } else {
+                throw new Error(messages.INVALID_ASYNCAPI_FILE);
             }
-
-            const service = regexGroups[1] + "." + regexGroups[2];
-            const event = regexGroups[0];
+            // uses regex to break event name in different components
+            const regExpGroups = getRegExpGroups(eventName);
+            const service = regExpGroups[1] + "." + regExpGroups[2];
+            const event = regExpGroups[0];
 
             // add service to services entry if not present
             if (!(service in services)) {
-                services[service] = { 'kind': 'service', ...serviceAnnotations, 'events': {}, 'types': {} };
+                services[service] = { 'kind': 'service', '@cds.external': 'true', ...serviceAnnotations, 'events': {}, 'types': {} };
             }
 
             // add event entry to service
             const eventAnnotations = this.getEventAnnotations(value);
 
+            // add topic annotation
+            if (this.topics[event]) {
+                eventAnnotations['@topic'] = this.topics[event];
+            }
+
             let properties = {};
             let types = {};
 
@@ -44,7 +84,7 @@ module.exports = class ParserContext {
                 [properties, types] = this.getPropertiesAndTypes(event, eventSchema);
             }
             services[service].types = types;
-            services[service].events[event] = { 'kind': 'event', ...eventAnnotations, elements: properties };
+            services[service].events[event] = { 'kind': 'event', '@cds.external': 'true', ...eventAnnotations, elements: properties };
         });
 
         return services;
@@ -56,14 +96,14 @@ module.exports = class ParserContext {
      */
     getServiceAnnotations(content) {
         const serviceAnnotationsMapping = {
-            'x-sap-stateInfo': 'StateInfo', //expected: object
-            'x-sap-shortText': 'ShortText' //expected: string
+            '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
+            'title': 'Title', // expected: string
+            'version': 'SchemaVersion', // expected: string
+            'description': 'Description' // expected: string
         };
 
         const annotations = this.getAnnotations(content, serviceAnnotationsMapping);
@@ -86,12 +126,12 @@ module.exports = class ParserContext {
      */
     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
+            'x-sap-event-spec-version': 'EventSpecVersion', // expected: string
+            'x-sap-event-source': 'EventSource', // expected: string
+            'x-sap-event-version': 'EventSchemaVersion', // expected: string
+            'x-sap-event-source-parameters': 'EventSourceParams', // expected: object
+            'x-sap-event-characteristics': 'EventCharacteristics', // expected: object
+            'x-sap-stateInfo': 'EventStateInfo' // expected: object
         };
 
         const annotations = this.getAnnotations(content, eventLevelAnnotationsMapping);
@@ -100,7 +140,7 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns validity of the annotation value. Here the parameter 
+     * 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.
      */
@@ -120,7 +160,7 @@ module.exports = class ParserContext {
     }
 
     /**
-     * Returns annotations for an event/service. Here the parameter content 
+     * 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.
      */
@@ -131,13 +171,14 @@ module.exports = class ParserContext {
             // case: known annotation
             if (annotationsMapping[key] && this.isValidAnnotationValue(annotationsMapping[key], value)) {
                 annotations['@AsyncAPI.' + annotationsMapping[key]] = value;
-            } 
+            }
             // case: unkown annotation
             else if (key.startsWith('x-')) {
                 if (!annotations['@AsyncAPI.Extensions']) {
                     annotations['@AsyncAPI.Extensions'] = {};
                 }
-                annotations['@AsyncAPI.Extensions'][key.substring(2)] = value; //removes x- from the element
+                // removes x- from the element
+                annotations['@AsyncAPI.Extensions'][key.substring(2)] = value;
             }
         }
 
@@ -217,7 +258,7 @@ module.exports = class ParserContext {
             let typeName = eventName + "." + propertyName;
             // generate object for the introduced type
             const elements = this.getTypeElements(propertyContent);
-            types[typeName] = { 'kind': 'type', ...elements };
+            types[typeName] = { 'kind': 'type', '@cds.external': 'true', ...elements };
             // referring to the generated type from the property
             propertyAttributes = { 'type': typeName };
         } else {

package/lib/import/asyncapi/utils.js

@@ -8,11 +8,42 @@ function validateAsyncAPI(content) {
     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]*)))?$'
+/**
+ * Accepted scenarios:
+ * * with version info : <namespace>.<businessObject>.<operation>.<version>
+ * * without version info : <namespace>.<businessObject>.<operation>
+ *
+ * ? Is it mandatory for <namespace> to always follow small case notation?
+ * ? Is it mandatory for <businessObject> to follow Camel Case or Upper Came Case notation?
+ * 
+ * ToDo: Can we support `-` in operations?
+ */
+const regExp = 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]*))?$'
 );
 
+/**
+ * Validates the messages' `key` with the regExp and returns the regEx groups.
+ * @returns regexGroups
+ */
+function getRegExpGroups(key) {
+    /**
+     * Result format:
+     * index 0: key
+     * index 1: <namespace> value
+     * index 2: <businessObject> value
+     * index 3: <operation> value
+     * index 4: <version> value; undefined if <version> is optional
+     */
+    const regExpGroups = regExp.exec(key);
+
+    if (regExpGroups == null) {
+        throw new Error(messages.INVALID_MESSAGE_NAME);
+    }
+    return regExpGroups;
+}
+
 module.exports = {
     validateAsyncAPI,
-    typeRegex
+    getRegExpGroups
 }

package/lib/import/common.js

@@ -6,7 +6,7 @@ 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 cdsCompiler = require('..').compile.to;
 const md5 = require('md5');
 
 let optionsMapping = {
@@ -66,7 +66,7 @@ async function getVersion(fileInputStream){
     } else if (version === '4.0' || version === "4.01") {
         oDataVersion = 'V4';
     }
-    
+
     return oDataVersion;
 }
 
@@ -135,7 +135,7 @@ async function isValidInputFile(inputFileLoc) {
 }
 
 async function _copyToSrvExternal(file, dst, cwd) {
-    const dstDir = path.dirname(dst), srcDir = path.dirname(file)
+    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;
@@ -160,28 +160,28 @@ async function preProcess(file, options, cwd) {
 }
 
 async function processOptions(cliOptions, odataOptions) {
-    //maps to renaming of variables
+    // 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
+    // segregating cli/odata options
     apiOptions.forEach(function (item) {
         odataOptions[item] = cliOptions[item];
         delete cliOptions[item];
     });
-    //reads cli options from environment
+    // reads cli options from environment
     readEnvVariables(cliOptions, true);
-
-
 }
 
-function _getServiceName(csn) {
+function _getServiceNames(csn) {
+    let serviceList = [];
     for (let each in csn.definitions) {
-        if (csn.definitions[each].kind === 'service') return each;
+        if (csn.definitions[each].kind === 'service') serviceList.push(each);
     }
+    return serviceList;
 }
 
 function _validateAndComputeOutputFilePath(outputFileLoc, as, destFilePath) {
@@ -210,7 +210,7 @@ function _validateAndComputeOutputFilePath(outputFileLoc, as, destFilePath) {
         // 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\") 
+        // File name not specified ("./srv/external/", "c:\windows\output\test\")
         return outputFileLoc + path.parse(destFilePath).name;
     }
 }
@@ -252,7 +252,7 @@ async function _generateChecksumValidate(dest, output, force) {
             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.
@@ -290,7 +290,7 @@ async function _getResult(output, as, dest, force, version) {
         case undefined:
         case "csn":
         case "json":
-            output = JSON.stringify(output, null, '  ');
+            output = JSON.stringify(output, null, ' ');
             break;
         default:
             break;
@@ -304,10 +304,14 @@ async function _write(result, service, cwd) {
     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, '/')}'`;
+     if (service.length > 1){
+        using = `using { ${service.join(', ')}} from './${path.relative('srv', dest).replace(/\\/g, '/')}'`;
+     }
+     else{
+        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:
@@ -318,29 +322,35 @@ ${using}
     console.log(message);
 }
 
-async function _updatePackageJson(dest, service, version, cwd) {
+async function _updatePackageJson(dest, services, 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 initial_model = path.relative(cwd, dest);
-        const model = isLinux() ? initial_model.replace(/\\/g, '/') : initial_model;
-        cds.env.requires[service] = requires[service] = { kind: version, model };
-        await write(package_json, JSON.stringify(conf, null, '  '));
+    let package_json_updated = false;
+    for (let service of services) {
+        if (!requires[service]) {
+            const initial_model = path.relative(cwd, dest);
+            const model = isLinux() ? initial_model.replace(/\\/g, '/') : initial_model;
+            cds.env.requires[service] = requires[service] = { kind: version, model };
+            await write(package_json, JSON.stringify(conf, null, '  '));
+            package_json_updated = true;
+        }
+    }
+    if (package_json_updated) {
         console.log(`[cds] - updated ./package.json`);
     }
 }
 
 async function postProcess(filePath, options, csn, cwd) {
-    const service = _getServiceName(csn);
+    const services = _getServiceNames(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);
+    const written = options.dry || await _write(result, services, cwd);
+    const registered = options.dry || options.no_save || await _updatePackageJson(result[1].replace(/\.[^.]+$/, ''), services, version, cwd);
     if (options.dry) return console.log(result[0]);
     return Promise.all([written, registered]);
 }
@@ -353,20 +363,20 @@ async function identifyFile(filepath) {
         // 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
+        // for openapi
         let jsonSrc = JSON.parse(src);
         if (jsonSrc.hasOwnProperty('openapi') || jsonSrc.hasOwnProperty('swagger')) {
             return "openapi";
-        } else if (jsonSrc.hasOwnProperty('asyncapi')){
-            return "asyncapi";    
+        } else if (jsonSrc.hasOwnProperty('asyncapi')) {
+            return "asyncapi";
         }
     } else
         return extension;
 }
 
-function isLinux(){
-    let platform = process.platform
-    if (platform === 'linux' || platform === 'win32'){
+function isLinux() {
+    let platform = process.platform;
+    if (platform === 'linux' || platform === 'win32') {
         return true;
     }
 }

package/lib/import/importapi.js

@@ -15,20 +15,21 @@ module.exports = Object.assign(cds_import, {
 });
 
 /**
-* 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 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
-*/
+ * 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 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
+ */
 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":
@@ -47,17 +48,17 @@ async function cds_import(filepath, options = { keepNamespace: false }) {
 }
 
 /**
-* 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
-*/
+ * 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));
@@ -73,18 +74,18 @@ async function cds_import_from_edmx(filepath, options = { keepNamespace: 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
+    // reading the file version
     options.odataVersion = odataOptions.odataVersion;
     // 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
-*/
+ * 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));
@@ -94,12 +95,12 @@ async function cds_import_from_openapi(filepath, options = {}) {
     return csn;
 }
 
-/**
-* This is the import API function to generate CSN from asyncapi files.
-* @param {string} filepath
-* - a single valid filepath
-* @returns {object} 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));
@@ -107,4 +108,4 @@ async function cds_import_from_asyncapi(filepath, options = {}) {
     let csn = asyncapi.asyncapi2csn(src);
     options.inputFileVersion = 'odata';
     return csn;
-}
+}

package/lib/index.js

@@ -1,19 +1,14 @@
-const cds = require('./cds')
-const compile_desc = Reflect.getOwnPropertyDescriptor(cds,'compile')
-
-// extending cds to lazy-load additional submodules provided by cds-dk
-module.exports = Object.defineProperties (cds, {
-
-  import: {enumerable:true, get:()=> require('./import/importapi')},
+const cds = module.exports = require('./cds')
+cds.extend (cds.constructor) .with (class {
+  get import() { return super.import = require('./import/importapi') }
+})
 
-  compile: {enumerable:true, get:()=> {
-    // lazy-extending cds.compile.to only when cds.compile getter is invoked
-    // otherwise we might cause cds.env being invoked too early.
-    const compile = compile_desc.value || compile_desc.get.call(cds)
-    if (!Reflect.getOwnPropertyDescriptor(compile.to, 'openapi'))
-      Object.defineProperties (compile.to, {
-        openapi: {enumerable:true, get:()=> require('./compile/openapi')}
-      })
-    return compile
-  }},
+cds.extend (cds.compile.to.constructor) .with (class {
+  get asyncapi() { return super.asyncapi = require('./compile/asyncapi') }
+  get openapi() { return super.openapi = require('./compile/openapi') }
+  get xsuaa(){ return super.xsuaa = require('./compile/to-xsuaa') }
+  'edmx-v2'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'v2'}) }
+  'edmx-v4'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'v4'}) }
+  'edmx-w4'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'w4'}) }
+  'edmx-x4'(csn,o) { return cds.compile.to.edmx(csn,{...o,flavor:'x4'}) }
 })