@sap/cds-dk 7.6.0 → 7.6.1

package/bin/import.js

@@ -87,7 +87,7 @@ async function _import(file, options = {}) {
     if (!file) return this.help('import');
     // process options
     await common.processOptions(options, apiOptions);
-    const [srcFilePath, destFilePath] = await common.preProcess(file, options, cwd);
+    const srcFilePath = await common.preProcess(file, options, cwd);
 
     // process - csn generation
     // if --from option is given, call api directly accordingly
@@ -102,5 +102,5 @@ async function _import(file, options = {}) {
     options.inputFileKind = apiOptions.odataVersion ? apiOptions.odataVersion : apiOptions.inputFileKind;
 
     // postprocess
-    return await common.postProcess(destFilePath, options, csn, cwd);
+    return await common.postProcess(file, options, csn, cwd);
 }

package/lib/deploy/to-hana/hana.js

@@ -1,15 +1,14 @@
-const cp = require('child_process');
 const path = require('path');
-const util = require('util');
 
 const fs = require('fs').promises;
 
 const cds = require('../../../lib/cds');
+const { exists, read } = cds.utils;
 
 const { build } = require('../../build');
 const buildConstants = require('../../build/constants');
 
-const hdiDeployUtil = require('./hdiDeployUtil');
+const hdi = require('./hdiDeployUtil');
 const cfUtil = require('../../util/cf');
 const gitUtil = require('../../util/git');
 const mtaUtil = require('./mtaUtil');
@@ -18,15 +17,9 @@ const { bold, info } = require('../../util/term');
 
 const { bind } = require('../../bind');
 
-const UTF_8 = 'utf-8';
+const DEBUG = cds.debug('deploy');
 
-
-class HanaDeployer {
-
-  constructor() {
-    this.execAsync = util.promisify(cp.exec);
-    this.spawnSync = cp.spawnSync;
-  }
+module.exports = new class HanaDeployer {
 
   getFromEnv(...varNames) {
     const result = {}
@@ -42,11 +35,8 @@ class HanaDeployer {
     return result;
   }
 
-  // arg object
-  // async deploy(model, serviceName, tunnelAddress, buildTaskOptions, vcapFile, undeployWhitelist, hdiOptions, bindCallback) { // NOSONAR
-  async deploy(options = {}) { // NOSONAR
-    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions, dry } = options;
-
+  async deploy(options = {}) {
+    let { model, serviceName, tunnelAddress, vcapFile, undeployWhitelist, hdiOptions = {}, dry, storeCredentials } = options;
     if (model) {
       throw `Specifying a CDS model for HANA deployment is not supported.
 'cds deploy --to hana' performs 'cds build --for hana' which in turn uses the configured HANA build task.
@@ -65,15 +55,16 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
     const buildResults = await this._build();
 
-    let globalVcapEnv = vcapFile ? await this._loadEnvFile(vcapFile) : {};
-    globalVcapEnv = { ...globalVcapEnv, ...this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS') };
+    const fromFile = vcapFile && exists(vcapFile) ? await read(vcapFile) : {};
+    const fromEnv = this.getFromEnv('VCAP_SERVICES', 'SERVICE_REPLACEMENTS');
+    let vcapEnv = { ...fromFile, ...fromEnv };
     if (process.env.TARGET_CONTAINER) {
-      globalVcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
+      vcapEnv.TARGET_CONTAINER = process.env.TARGET_CONTAINER;
     }
 
     if (dry) {
-      for (const buildResult of buildResults) {
-        const model = await cds.load(buildResult.task.src);
+      for (const { task } of buildResults) {
+        const model = await cds.load(task.src);
         const data = cds.compile.to.hdbtable(model);
         for (const [src, { file }] of data) {
           console.log(`-- ${file}`);
@@ -82,49 +73,47 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
         }
       }
     } else {
-      for (const buildResult of buildResults) {
-        let vcapEnv = globalVcapEnv;
-        let serviceKeyName;
-        const currentModelFolder = buildResult.task.dest;
+      for (const { task } of buildResults) {
+        const dest = task.dest;
 
         if (undeployWhitelist) {
           console.log('Writing undeploy.json');
-          await fs.write(path.join(currentModelFolder, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
+          await fs.write(path.join(dest, 'undeploy.json'), JSON.stringify(undeployWhitelist, null, 2));
         }
 
         const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
         if (!serviceName && hasVCAPEnv) {
-          await fs.mkdir(currentModelFolder, { recursive: true });
-        } else {
-          const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
-            await this._getOrCreateCFService(projectPath, currentModelFolder, serviceName, tunnelAddress);
-          serviceKeyName = cfServiceInstanceKeyName;
-          serviceName = serviceName || cfServiceInstanceName;
+          await fs.mkdir(dest, { recursive: true });
+        }
+        const { cfServiceInstanceName, cfServiceInstanceKeyName, serviceKey } =
+            await this._getOrCreateCFService(projectPath, dest, serviceName, tunnelAddress);
 
-          vcapEnv = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        serviceName ??= cfServiceInstanceName;
+        if (!vcapEnv.VCAP_SERVICES || serviceName) {
+          vcapEnv.VCAP_SERVICES = this._getVCAPServicesEntry(cfServiceInstanceName, serviceKey);
+        }
 
-          if (options.storeCredentials) {
-            await this._addInstanceToDefaultEnvJson([currentModelFolder, projectPath], cfServiceInstanceName, serviceKey);
-          }
+        if (storeCredentials) {
+          await this._addInstanceToDefaultEnvJson([dest, projectPath], cfServiceInstanceName, serviceKey);
         }
 
         console.log(`${bold('Starting deployment to SAP HANA ...')}`);
 
-        hdiOptions = hdiOptions || {}
-        await hdiDeployUtil.deploy(currentModelFolder, vcapEnv, hdiOptions);
+        DEBUG?.({ dest, vcapEnv, hdiOptions })
+        await hdi.deploy(dest, vcapEnv, hdiOptions);
 
         if (!hasVCAPEnv) {
           const bindOptions = {
             ...options,
-            to: `${serviceName}:${serviceKeyName}`,
+            to: `${serviceName}:${cfServiceInstanceKeyName}`,
             for: options.for,
-            kind: buildResult.task.for
+            kind: task.for
           }
           await bind(bindOptions);
         }
       }
 
-      if (options.storeCredentials) {
+      if (storeCredentials) {
         await gitUtil.ensureFileIsGitignored('default-env.json', projectPath);
       }
 
@@ -155,7 +144,7 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     this._validateServiceInstanceName(cfServiceInstanceName);
     console.log(`Using container ${bold(cfServiceInstanceName)}`);
 
-    let cfConfig = cfServiceInstanceMta && cfServiceInstanceMta.parameters && cfServiceInstanceMta.parameters.config;
+    const cfConfig = cfServiceInstanceMta?.parameters?.config;
     const serviceInstance = await this.createHanaService(cfServiceInstanceName, cfConfig);
 
     const cfServiceInstanceKeyName = `${cfServiceInstanceName}-key`;
@@ -191,13 +180,17 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _validateServiceKey(serviceKey, cfServiceInstanceKey) {
     if (!serviceKey) {
-      throw new Error(`Could not create service key ${bold(cfServiceInstanceKey)}.`);
+      throw `Could not create service key ${bold(cfServiceInstanceKey)}.`;
+    }
+
+    if (serviceKey['sm_url']) {
+      throw `Service key credentials are matching to a Service Manager instance of a multitenant environment. Make sure there is no conflict with ${cfServiceInstanceKey}.`;
     }
 
     const fields = ['schema', 'user', 'password', 'url'];
     for (const field of fields) {
       if (!serviceKey[field]) {
-        throw new Error(`Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`);
+        throw `Service key is missing mandatory field '${field}'. Make sure you are ${bold('not')} using a managed service.`;
       }
     }
   }
@@ -209,40 +202,21 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     }
 
     console.log(`Running build`);
-    const buildResults = await build(buildTaskOptions);
-    return buildResults;
+    return build(buildTaskOptions);
   }
 
-  async _loadEnvFile(defaultEnvFile) {
-    try {
-      const content = await fs.readFile(defaultEnvFile);
-      return JSON.parse(content);
-    } catch (err) {
-      throw new Error(`Error reading default env file: ${err.message}`);
-    }
-  }
-
-
   async _addInstanceToDefaultEnvJson(currentFolders, serviceInstanceName, serviceKey) {
     for (const currentFolder of currentFolders) {
-      let defaultEnvJson = {};
       const defaultEnvJsonPath = path.join(currentFolder, 'default-env.json');
+      const defaultEnvJson = exists(defaultEnvJsonPath) ? await read(defaultEnvJsonPath) : {};
 
-      try {
-        defaultEnvJson = JSON.parse(await fs.readFile(defaultEnvJsonPath, UTF_8));
-      } catch (err) {
-        // ignore any errors
-      }
-
-      defaultEnvJson.VCAP_SERVICES = defaultEnvJson.VCAP_SERVICES || {};
-      for (const serviceKey of Object.keys(defaultEnvJson.VCAP_SERVICES)) {
-        defaultEnvJson.VCAP_SERVICES[serviceKey] = defaultEnvJson.VCAP_SERVICES[serviceKey].filter((service) => {
-          return (service.name !== serviceInstanceName);
-        });
+      defaultEnvJson.VCAP_SERVICES ??= {};
+      for (const [serviceKey, services] of Object.entries(defaultEnvJson.VCAP_SERVICES)) {
+        defaultEnvJson.VCAP_SERVICES[serviceKey] = services.filter(service => service.name !== serviceInstanceName);
       }
 
       const hanaEntry = this._getVCAPServicesEntry(serviceInstanceName, serviceKey)
-      Object.assign(defaultEnvJson, hanaEntry);
+      Object.assign(defaultEnvJson.VCAP_SERVICES, hanaEntry);
 
       console.log(`Writing ${defaultEnvJsonPath}`);
       await fs.mkdir(path.dirname(defaultEnvJsonPath), { recursive: true })
@@ -253,15 +227,13 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
 
   _getVCAPServicesEntry(serviceInstanceName, serviceKey) {
     return {
-      VCAP_SERVICES: {
         hana: [
           {
             name: serviceInstanceName,
             tags: ['hana'],
             credentials: serviceKey
           }
-        ]
-      }
+      ]
     };
   }
 
@@ -269,14 +241,14 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
   _validateServiceInstanceName(serviceInstanceName) {
     // valid service name chars: alpha-numeric, hyphens, and underscores
     if (/[^\w-_]+/g.exec(serviceInstanceName)) {
-      throw new Error(`Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`);
+      throw `Service name ${serviceInstanceName} must only contain alpha-numeric, hyphens, and underscores.`;
     }
   }
 
 
   _injectTunnelAddress(serviceKey, tunnelAddress) {
     if (!/\w+:\d+/.test(tunnelAddress)) {
-      throw new Error(`Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`)
+      throw `Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`;
     }
     const [tunnelHost, tunnelPort] = tunnelAddress.split(':')
     const { host, port } = serviceKey
@@ -288,5 +260,3 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     return serviceKey
   }
 }
-
-module.exports = new HanaDeployer();

package/lib/deploy/to-hana/hdiDeployUtil.js

@@ -1,22 +1,21 @@
 const path = require('path');
 const util = require('util');
+const { bold } = require('../../util/term');
 
 const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
 
-class HdiDeployUtil {
+module.exports = new class HdiDeployUtil {
 
-    async deploy(dbDir, vcapEnv = {}, options = {}) {
+    async deploy(dbDir, vcapEnv = {}, { autoUndeploy } = {}) {
         console.log(`Deploying to HANA from ${dbDir}`);
 
-        const hdiDeployLib = await this._loadHdiDeployLib(dbDir);
+        const { clean_env, deploy } = this._loadHdiDeployLib(dbDir);
 
-        let deployerEnv = JSON.parse(JSON.stringify(process.env));
+        const deployerEnv = JSON.parse(JSON.stringify(process.env));
         const hdiDeployOptions = deployerEnv.HDI_DEPLOY_OPTIONS ? JSON.parse(deployerEnv.HDI_DEPLOY_OPTIONS) : {};
         delete hdiDeployOptions.root;
 
-        if (typeof hdiDeployLib.clean_env === 'function') {
-            deployerEnv = hdiDeployLib.clean_env(deployerEnv);
-        }
+        clean_env?.(deployerEnv);
 
         if (vcapEnv.VCAP_SERVICES) {
             deployerEnv.VCAP_SERVICES = JSON.stringify(vcapEnv.VCAP_SERVICES);
@@ -28,8 +27,8 @@ class HdiDeployUtil {
             deployerEnv.TARGET_CONTAINER = vcapEnv.TARGET_CONTAINER;
         }
 
-        if (options.autoUndeploy) {
-            console.log(`Hdi deployer automatically undeploys deleted resources using --auto-undeploy.`);
+        if (autoUndeploy) {
+            console.log(`HDI deployer automatically undeploys deleted resources using --auto-undeploy.`);
             hdiDeployOptions.auto_undeploy = true;
         }
 
@@ -37,12 +36,12 @@ class HdiDeployUtil {
             deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(hdiDeployOptions);
         }
 
-        const asyncDeploy = util.promisify(hdiDeployLib.deploy);
-        const response = await asyncDeploy(dbDir, deployerEnv);
-        if (response?.exitCode) {
-            let message = `HDI deployment failed with exit code ${response.exitCode}`;
-            if (response.signal) {
-                message += `. ${response.signal}`;
+        const asyncDeploy = util.promisify(deploy);
+        const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
+        if (exitCode) {
+            let message = `HDI deployment failed with exit code ${exitCode}`;
+            if (signal) {
+                message += `. ${signal}`;
             }
             throw new Error(message);
         }
@@ -55,7 +54,7 @@ class HdiDeployUtil {
         if (!libPath) {
             throw new Error(`Required library '${HDI_DEPLOY_LIB}' not found in
     ${searchPaths.join('\n    ')}
-Add it either as a devDependency using 'npm install -D ${HDI_DEPLOY_LIB}' or install it globally using 'npm install -g ${HDI_DEPLOY_LIB}'.`);
+    Add it either to ${bold('devDependencies')} using 'npm install -D ${HDI_DEPLOY_LIB}' or install it globally using 'npm install -g ${HDI_DEPLOY_LIB}'.`);
         }
 
         console.log(`Using HDI deployer from ${libPath}`)
@@ -64,5 +63,3 @@ Add it either as a devDependency using 'npm install -D ${HDI_DEPLOY_LIB}' or ins
         return require(libPath);
     }
 }
-
-module.exports = new HdiDeployUtil();

package/lib/deploy/to-hana/mtaUtil.js

@@ -98,7 +98,7 @@ async function _getProjectInfo(projectPath, mta) {
 }
 
 async function _getMta(projectPath) {
-    // yaml.parse  oesn't like null
+    // yaml.parse doesn't like null
     const mtaFilePath = path.join(projectPath, MTA_YAML)
 
     const existsMtaYaml = existsSync(mtaFilePath)

package/lib/import/common.js

@@ -148,30 +148,11 @@ async function _copyToSrvExternal(file, dst, cwd) {
     return file;
 }
 
-async function isValidJsonObject(options){
-    let config;
-    try {
-        if (options.config) {
-            config = JSON.parse(options.config);
-            return config;
-        }
-    } catch (error) {
-        throw new Error(messages.SPECIFY_CONFIG);
-    }
-} 
-
 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];
+    return srcFilePath;
 }
 
 async function processOptions(cliOptions, odataOptions) {
@@ -359,14 +340,28 @@ async function _updatePackageJson(dest, services, kind, cwd, config) {
     }
 }
 
+function _parseValidJsonConfig(config) {
+    try {
+        if (config) {
+            return JSON.parse(config);
+        }
+    } catch (error) {
+        throw new Error(messages.SPECIFY_CONFIG);
+    }
+}
+
 async function postProcess(filePath, options, csn, cwd) {
     const services = _getServiceNames(csn);
-    let config = await isValidJsonObject(options);
-    if (options.out) options.out = _validateAndComputeOutputFilePath(options.out, options.as, filePath);
+    let config = _parseValidJsonConfig(options.config);
+    const external = path.resolve(cwd, 'srv/external');
+    const destFilePath = path.join(external, path.basename(filePath));
+    if (options.out) options.out = _validateAndComputeOutputFilePath(options.out, options.as, destFilePath);
     const kind = options.inputFileKind;
-    const result = await _getResult(csn, options.as, options.out || filePath.replace(/\.[^.]+$/, ''), options.force, kind);
+    const result = await _getResult(csn, options.as, options.out || destFilePath.replace(/\.[^.]+$/, ''), options.force, kind);
     const written = options.dry || await _write(result, services, cwd);
     const registered = options.dry || options.no_save || await _updatePackageJson(result[1].replace(/\.[^.]+$/, ''), services, kind, cwd, config);
+    if (!options.dry && !options.no_copy)
+        await _copyToSrvExternal(filePath, destFilePath, cwd);
     if (options.dry) return console.log(result[0]);
     return Promise.all([written, registered]);
 }

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -1025,7 +1025,6 @@ MetadataConverter.Context = Context;
 * @param {Object} result The metadata abstract syntax tree of the depended metadata document
 */
 
-
 /**
 * This callback is displayed as part of the DefaultXmlStrategy class.
 * This factory is called when the converter can not find a needed type within the current metadata document.
@@ -1073,7 +1072,6 @@ The result must be returned via 'return' statement.
 * @returns {Expression} The expression to interpret the current element node
 */
 
-
 /**
 * This callback is displayed as part of the DefaultXmlStrategy class.
 * This callback is called on finishing a strategy.
@@ -1083,7 +1081,6 @@ The result must be returned via 'return' statement.
 * @param {Any} result The output of the Strategy
 */
 
-
 class DefaultXmlStrategy extends Strategy {
     constructor(options) {
         super(undefined, options);
@@ -1243,7 +1240,6 @@ class DefaultXmlStrategy extends Strategy {
 }
 MetadataConverter.DefaultXmlStrategy = DefaultXmlStrategy;
 
-
 class EdmxRootExpression extends Expression {
     constructor(element, expression, context) { super(element, expression, context); }
     interpret() {
@@ -1441,7 +1437,6 @@ class AbstractLogicalExpression extends Expression {
     }
 }
 
-
 class AndExpression extends AbstractLogicalExpression {
     constructor(element, expression, context) { super(element, expression, context, '$And'); }
 }
@@ -1671,8 +1666,18 @@ class PropertyValueExpression extends Expression {
         this.setTarget(target);
         this.buildTypeCollectionAndFacets('$Type');
 
+        /**
+         * We can have instances of EDMX where we see value for a particular attribute as:
+         * AnnotationPath="part/icipants/@UI.LineItem" or Path="SAP__Messages/random”, etc
+         * 
+         * In such cases we need to replace '/' with '.' and only then the CSN generated will
+         * be treated correctly in the later steps.
+         * * For now this is only done for AnnotationPath value in #1680 to resolve an issue
+         * * TODO: In future we might have to do it for many such value.
+         */
         if (element.attributes.Path) target[name] = { "=": element.attributes.Path };
         if (element.attributes.PropertyPath) target[name] = { "=": element.attributes.PropertyPath };
+        if (element.attributes.AnnotationPath) target[name] = { "=": (element.attributes.AnnotationPath).replaceAll('/', '.') };
         if (element.attributes.EnumMember) target[name] = { "#": element.attributes.EnumMember.substring(element.attributes.EnumMember.lastIndexOf('/') + 1) };
         if (element.attributes.NavigationPropertyPath) target[name] = { "=": element.attributes.NavigationPropertyPath };
         if (element.attributes.String) target[name] = element.attributes.String;
@@ -1684,8 +1689,8 @@ class PropertyValueExpression extends Expression {
         if (element.attributes.Bool) target[name] = element.attributes.Bool === 'true';
         /**
          * If the property valus is of type `Date`, import it as a string itself
-         * <PropertyValue Property="Date" Date="2021-08-24" />
-         * We might have to have a strict check in the futore.. 'YYYY-MM_DD`
+         * <PropertyValue Property="Date" Date="2021-08-24"/>
+         * We might have to have a strict check in the future.. 'YYYY-MM_DD`
          */
         if (element.attributes.Date) target[name] = element.attributes.Date;
 
@@ -2411,7 +2416,6 @@ class OnDeleteExpression extends Expression {
 
 }
 
-
 MetadataConverter.createOdataV4MetadataXmlToOdataV4CsdlStrategy = (name_space) => {
     MetadataConverter.custom_namespace = name_space;
     return new MetadataConverter.DefaultXmlStrategy()

package/lib/import/odata/v4parser.js

@@ -426,8 +426,8 @@ function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTarg
 function _resolveAnotationTerm(schemaDataAnnotation, parserContext) {
     // Case 1: We have the Namespace and Alias for the vocabulary
     for (const [alias, namespace] of Object.entries(parserContext.vocabAliasToNamespace)) {
-        if (schemaDataAnnotation.includes('@' + alias)) {
-            schemaDataAnnotation = schemaDataAnnotation.split('@' + alias).join('@' + known_vocabularies[namespace]);
+        if (schemaDataAnnotation.includes('@' + alias + '.')) {
+            schemaDataAnnotation = schemaDataAnnotation.split('@' + alias + '.').join('@' + known_vocabularies[namespace] + '.');
         }
     }
     /**
@@ -1225,6 +1225,15 @@ function _addSuffixForCollisionTypes(fqName, suffix) {
 function _parseEntityContainer(csnDefs, entityContainerElements, parserContext) {
     const entityContainerElementNames = Object.keys(entityContainerElements);
     const redundantElementNames = [];
+    let possibleAnnotations = {};
+
+    // filter entries starting with '@', they can be possible annotation
+    entityContainerElementNames.filter(
+        elementName => elementName.startsWith('@')
+    ).forEach(elementName => {
+        possibleAnnotations[elementName] = entityContainerElements[elementName];
+        delete entityContainerElements[elementName];
+    });
 
     entityContainerElementNames.forEach(ecElement => {
         if (entityContainerElements[ecElement] instanceof Object) {
@@ -1294,6 +1303,49 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
         delete csnDefs[name];
     });
 
+    // check for possible annotations present within the entity container
+    if (Object.keys(possibleAnnotations).length > 0) {
+        let entityContainerAnnotations = {};
+        let annotationTarget = parserContext.primarySchema + '.' + parserContext.entityContainerName;
+        possibleAnnotations = _resolveAnotationTerm(
+            JSON.stringify(possibleAnnotations), parserContext
+        );
+        /**
+         * If the same annotation target already exists because of the annotation present outside
+         * of the EntityContainer, then append the possible annotations to it and parse all of them.
+         * Few exact same annotation term if exists, will result in information being overwritten
+         * by the annotation term present within the EntityContainer.
+         */
+        if (Object.keys(parserContext.entityContainerAnnotations).length > 0) {
+            entityContainerAnnotations = parserContext.entityContainerAnnotations;
+            /**
+             * When the parserContext.entityContainerAnnotations contains the annotation target,
+             * and we have unique information present within EntityContainer as well as indipendent
+             * annotation, we have to merge them.
+             */
+            if (parserContext.entityContainerAnnotations[annotationTarget] &&
+                Object.keys(parserContext.entityContainerAnnotations[annotationTarget]).length > 0
+            ) {
+                entityContainerAnnotations[annotationTarget] = Object.assign(
+                    entityContainerAnnotations[annotationTarget], 
+                    possibleAnnotations
+                );
+            }
+            /**
+             * If the annotation target name is different, we can expand all of the information
+             * into a single object itself
+             */
+            else {
+                entityContainerAnnotations[annotationTarget] = possibleAnnotations;
+            }
+        }
+        // Simply add the possible annotations to the object with the target
+        else {
+            entityContainerAnnotations[annotationTarget] = possibleAnnotations;
+        }
+        parserContext.entityContainerAnnotations = entityContainerAnnotations;
+    }
+
     // parse all the entity container annotations
     if (parserContext.entityContainerAnnotations) {
         _parseAnnotations(parserContext.entityContainerAnnotations, csnDefs, parserContext);
@@ -1450,6 +1502,17 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
 
     _collectUnboundedActionFunction(schemaDataList, parserContext);
 
+    // capture all the references
+    if (edmxAsJson.$Reference) {
+        Object.entries(edmxAsJson.$Reference).forEach(ref => {
+            if (ref[1].$Include[0].$Alias &&
+                known_vocabularies.hasOwnProperty(ref[1].$Include[0].$Namespace)
+            ) {
+                parserContext.vocabAliasToNamespace[ref[1].$Include[0].$Alias] = ref[1].$Include[0].$Namespace;
+            }
+        });
+    }
+
     // collect entityType, enumType, complexType, typeDefinition, bounded action/function, annotations
     for (let schemaData of schemaDataList) {
         let currNamespace = schemaData.$SchemaNamespace;
@@ -1472,15 +1535,6 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
                 }
                 // annotations
                 else if (elementName === '$Annotations') {
-                    if (edmxAsJson.$Reference) {
-                        Object.entries(edmxAsJson.$Reference).forEach(ref => {
-                            if (ref[1].$Include[0].$Alias &&
-                                known_vocabularies.hasOwnProperty(ref[1].$Include[0].$Namespace)
-                            ) {
-                                parserContext.vocabAliasToNamespace[ref[1].$Include[0].$Alias] = ref[1].$Include[0].$Namespace;
-                            }
-                        });
-                    }
                     schemaData.$Annotations = _resolveAnotationTerm(JSON.stringify(schemaData.$Annotations), parserContext);
                     /**
                      * collect entity container annotations with the assumption that
@@ -1552,7 +1606,8 @@ function _preProcess(edmxAsJson, parserContext, importerContext) {
         parserContext.entityToEntitySetMap._.size === 0 &&
         parserContext.entityToSingletonMap._.size === 0 &&
         parserContext.actionToActionImportMap._.size === 0 &&
-        parserContext.functionToFunctionImportMap._.size === 0) {
+        parserContext.functionToFunctionImportMap._.size === 0)
+    {
         parserContext.mockServerUc = false;
     }
 

package/lib/init/constants.js

@@ -57,9 +57,7 @@ module.exports = {
         SAMPLES: 'https://github.com/SAP-samples/cloud-cap-samples',
         CAPIRE: 'https://cap.cloud.sap',
         MAVEN_ARCHETYPE_HELP: `https://cap.cloud.sap/docs/java/development/#the-maven-archetype`,
-        MAVEN_INSTALL_HELP: `https://maven.apache.org/install.html`,
-        VSCODE: 'https://code.visualstudio.com/',
-        VSCODE_ESLINT: 'https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint'
+        MAVEN_INSTALL_HELP: `https://maven.apache.org/install.html`
     }),
 
     PROJECT_FILES: ['package.json', 'pom.xml', '.cdsrc.json']

package/lib/lint/Linter.js

@@ -38,7 +38,7 @@ class Linter {
   /**
    * Initializes `cds lint` call and generates the required content
    * object for `cds` executable
-   * @returns object continaing help, options, flags and shortcuts
+   * @returns object containing help, options, flags and shortcuts
    */
   init(help = "", options = [], flags = [], shortcuts = []) {
     this.eslintCmd = checks.resolveEslint(this.cdsdkPath, this.globalPath);
@@ -56,7 +56,7 @@ class Linter {
 
   /**
    * Runner for 'cds lint' which is a wrapper for eslint cmd calls
-   * that detecs and adds the required cmd line arguments
+   * that detects and adds the required cmd line arguments
    * @param {*} args files/globs for eslint to lint
    * @param {*} options options/flag passed by user
    */