@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/edm/annotations/preprocessAnnotations.js

@@ -10,12 +10,12 @@ const { forEachDefinition } = require('../../model/csnUtils.js');
  * options:
  *   v
  *
- * This module never produces errors. In case of "unexpected" situations we issue a warning and
+ * This module never produces errors. In case of "unexpected" situations we issue a message and
  * try to proceed with the processing as good as possible.
  *
  */
 function preprocessAnnotations(csn, serviceName, options) {
-  const { warning } = makeMessageFunction(csn, options);
+  const { message } = makeMessageFunction(csn, options);
   let fkSeparator = '_';
 
   resolveShortcuts();
@@ -32,7 +32,7 @@ function preprocessAnnotations(csn, serviceName, options) {
   }
 
   // return value can be null is target has no key
-  function getKeyOfTargetOfManagedAssoc(assoc) {
+  function getKeyOfTargetOfManagedAssoc(anno, assoc) {
     // assoc.target can be the name of the target or the object itself
     let targetName = (typeof assoc.target === 'object') ? assoc.target.name : assoc.target;
     let target     = (typeof assoc.target === 'object') ? assoc.target      : csn.definitions[assoc.target];
@@ -40,10 +40,11 @@ function preprocessAnnotations(csn, serviceName, options) {
     let keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
-      warning(null, null, `in annotation preprocessing: target ${targetName} has no key`);
+      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'nokey' },
+      'target $(NAME) has no key');
     }
     else if (keyNames.length > 1)
-      warning(null, null, `in annotation preprocessing: target ${targetName} has multiple key elements`);
+      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'multkeys' });
     
     return keyNames[0];
   }
@@ -58,32 +59,29 @@ function preprocessAnnotations(csn, serviceName, options) {
     let art = null;
 
     forEachDefinition(csn, (artifact, artifactName) => {
+      const location = [ 'definitions', artifactName ];
       if(artifactName === serviceName || artifactName.startsWith(serviceName + '.')) {
         art = artifactName;
-        handleAnnotations(artifactName, artifact);
+        handleAnnotations(artifactName, artifact, location);
         artifact.elements && Object.entries(artifact.elements).forEach(([elementName, element]) => {
-          handleAnnotations(elementName, element);
+          handleAnnotations(elementName, element, [ ...location, 'elements', elementName ]);
         });
         artifact.actions && Object.values(artifact.actions).forEach(action => {
           action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-            handleAnnotations(paramName, param);
+            handleAnnotations(paramName, param, [ ...location, 'actions', action, 'params', paramName ]);
           });
         });
       }
     });
 
-    function handleAnnotations(carrierName, carrier) {
+    function handleAnnotations(carrierName, carrier, location) {
 
       // collect the names of the carrier's annotation properties
-      let annoNames = Object.keys(carrier).filter( x => x.substr(0,1) === '@')
+      let annoNames = Object.keys(carrier).filter( x => x[0] === '@')
 
       for (let aName of annoNames) {
         let aNameWithoutQualifier = aName.split('#')[0];
 
-        //for warning messages
-        let ctx = 'target: ' + art + '/' + carrierName;
-
-
         // Always - draft annotations, value is action name
         //   - v2: prefix with entity name
         //   - prefix with service name
@@ -91,11 +89,11 @@ function preprocessAnnotations(csn, serviceName, options) {
 
         // Always - FixedValueListShortcut
         //   expand shortcut form of ValueList annotation
-        fixedValueListShortCut(carrier, aNameWithoutQualifier, ctx);
+        fixedValueListShortCut(carrier, aNameWithoutQualifier);
 
         // Always - TextArrangementReordering
         //   convert @Common.TextArrangement annotation that is on same level as Text annotation into a nested annotation
-        textArrangementReordering(carrier, aName, aNameWithoutQualifier, ctx);
+        textArrangementReordering(carrier, aName, aNameWithoutQualifier);
       }
 
       // inner functions
@@ -121,9 +119,9 @@ function preprocessAnnotations(csn, serviceName, options) {
         }
       }
 
-      function fixedValueListShortCut(carrier, aNameWithoutQualifier, ctx) {
-        if (aNameWithoutQualifier === '@Common.ValueList.entity' ||
-            aNameWithoutQualifier === '@Common.ValueList.viaAssociation') {
+      function fixedValueListShortCut(carrier, anno) {
+        if (anno === '@Common.ValueList.entity' ||
+            anno === '@Common.ValueList.viaAssociation') {
 
           const _fixedValueListShortCut = () => {
             // note: we loop over all annotations that were originally present, even if they are
@@ -136,7 +134,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             }
 
             if (carrier.kind === 'entity') {
-              warning(null, null, `annotation preprocessing/${aNameWithoutQualifier}: annotation must not be used for an entity, ${ctx}`);
+              message('odata-anno-preproc', [...location, anno], { anno, '#': 'notforentity' });
               return false;
             }
 
@@ -146,32 +144,37 @@ function preprocessAnnotations(csn, serviceName, options) {
             let enameShort = null;  // (string) name of value list entity, short (i.e. name within service)
             let enameFull = null;   // (string) name of value list entity, fully qualified name
 
-            if (aNameWithoutQualifier === '@Common.ValueList.viaAssociation') {
+            if (anno === '@Common.ValueList.viaAssociation') {
               // value is expected to be an expression, namely the path to an association of the carrier entity
               let assocName = carrier['@Common.ValueList.viaAssociation']['='];
               if (!assocName) {
-                warning(null, null, `in annotation preprocessing/${aNameWithoutQualifier}: value of 'viaAssociation' must be a path, ${ctx}`);
+                message('odata-anno-preproc', [...location, anno], { anno, '#': 'viaassoc' });
                 return false;
               }
               let assoc = csn.definitions[art].elements[assocName];
               if (!assoc || !assoc.target) {
-                warning(null, null, `in annotation preprocessing/${aNameWithoutQualifier}: there is no association "${assocName}", ${ctx}`);
+                message('odata-anno-preproc', [...location, anno], { anno, id: assocName, '#': 'noassoc' });
                 return false;
               }
 
               enameFull = assoc.target.name || assoc.target; // full name
               enameShort = enameFull.split('.').pop();
             }
-            else if (aNameWithoutQualifier === '@Common.ValueList.entity') {
+            else if (anno === '@Common.ValueList.entity') {
               // if both annotations are present, ignore 'entity' and raise a message
               if (annoNames.map(x=>x.split('#')[0]).find(x=>(x==='@Common.ValueList.viaAssociation'))) {
-                warning(null, null, `in annotation preprocessing/@Common.ValueList: 'entity' is ignored, as 'viaAssociation' is present, ${ctx}`);
+                message('odata-anno-preproc', [...location, anno],
+                  { 
+                    name: '@Common.ValueList.entity', anno: '@Common.ValueList', 
+                    value: 'entity', code: 'viaAssociation', '#': 'vallistignored'
+                  });
                 return false;
               }
 
               let annoVal = carrier['@Common.ValueList.entity']; // name of value list entity
               if (annoVal['=']) {
-                warning(null, null, `in annotation preprocessing/${aNameWithoutQualifier}: annotation value must be a string, ${ctx}`);
+                message('odata-anno-preproc', [...location, anno], { anno, '#': 'notastring' },
+                );
               }
 
               let nameprefix = art.replace(/.[^.]+$/, ''); // better way of getting the service name?
@@ -182,7 +185,7 @@ function preprocessAnnotations(csn, serviceName, options) {
 
             let vlEntity = csn.definitions[enameFull]; // (object) value list entity
             if (!vlEntity) {
-              warning(null, null, `in annotation preprocessing/${aNameWithoutQualifier}: entity "${enameFull}" does not exist, ${ctx}`);
+              message('odata-anno-preproc', [...location, anno ], { anno, id: enameFull, '#': 'notexist' });
               return false;
             }
 
@@ -196,7 +199,8 @@ function preprocessAnnotations(csn, serviceName, options) {
             //   if this is a managed assoc, use fk field instead (if there is a single one)
             let localDataProp = carrierName.split('/').pop();
             if (carrier.target && carrier.on === undefined) {
-              localDataProp = localDataProp + fkSeparator + getKeyOfTargetOfManagedAssoc(carrier);
+              localDataProp = localDataProp + fkSeparator + 
+                getKeyOfTargetOfManagedAssoc(anno, carrier);
             }
 
             // if this carrier is a generated foreign key field and the association is marked @cds.api.ignore
@@ -209,15 +213,15 @@ function preprocessAnnotations(csn, serviceName, options) {
             }
 
             // valueListProp: the (single) key field of the value list entity
-            //   if no key or multiple keys -> warning
+            //   if no key or multiple keys -> message
             let valueListProp = null;
             let keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target );
             if (keys.length === 0) {
-              warning(null, null, `in annotation preprocessing/value help shortcut: entity "${enameFull}" has no key, ${ctx}`);
+              message('odata-anno-preproc', [...location, anno], { anno, name: enameFull, '#': 'vhlnokey' });
               return false;
             }
             else if (keys.length > 1)
-              warning(null, null, `in annotation preprocessing/value help shortcut: entity "${enameFull}" has more than one key, ${ctx}`);
+              message('odata-anno-preproc', [...location, anno], { anno, name: enameFull, '#': 'vhlmultkeys' });
             valueListProp = keys[0];
 
             // textField:
@@ -278,20 +282,20 @@ function preprocessAnnotations(csn, serviceName, options) {
 
           const success = _fixedValueListShortCut();
           if (!success) {
-            // In case of failure, avoid subsequent warnings
-            delete carrier[aNameWithoutQualifier];
+            // In case of failure, avoid subsequent messages
+            delete carrier[anno];
             delete carrier['@Common.ValueList.type'];
           }
         }
       }
 
-      function textArrangementReordering(carrier, aName, aNameWithoutQualifier, ctx) {
+      function textArrangementReordering(carrier, aName, aNameWithoutQualifier) {
         if (aNameWithoutQualifier === '@Common.TextArrangement') {
           let value = carrier[aName];
           let textAnno = carrier['@Common.Text'];
           // can only occur if there is a @Common.Text annotation at the same target
           if (!textAnno) {
-            warning(null, null, `in annotation preprocessing: TextArrangement shortcut without Text annotation, ${ctx}`);
+            message('odata-anno-preproc', [...location, '@Common.TextArrangement'], { anno: '@Common.TextArrangement', name: '@Common.Text', '#': 'txtarr' });
           }
 
           //change the scalar anno into a "pseudo-structured" one

package/lib/edm/csn2edm.js

@@ -9,7 +9,7 @@ const VALUELIST_NAVPROP_PREFIX = '';
 const edmUtils = require('./edmUtils.js')
 const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
-const { setProp } = require('../base/model');
+const { setProp, isBetaEnabled } = require('../base/model');
 const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
@@ -43,7 +43,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     setProp(csn.meta, 'options', _csn.meta.options);
   }
 
-  const [ allServices,
+  const [
+    allServices,
     allSchemas,
     reqDefs,
     whatsMyServiceRootName,
@@ -133,11 +134,18 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       -----------------------------------------------*/
     let LeadSchema;
     const fqSchemaXRef = [serviceCsn.name];
-    const whatsMySchemaName = function(n, arr=fqSchemaXRef) {
-      return arr.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') ? sn : rc, undefined);
+    const whatsMySchemaName = function(n) {
+      return fqSchemaXRef.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') ? sn : rc, undefined);
     }
 
-    let xServiceRefs = [];
+    // tunnel schema xref and servicename in options to edm.Typebase to rectify
+    // type references that are eventually also prefixed with the service schema name.
+    options.serviceName = serviceCsn.name;
+      // List of all schema names in this service, including the service itself
+    options.whatsMySchemaName = whatsMySchemaName;
+    options.whatsMyServiceRootName = whatsMyServiceRootName;
+
+    let xServiceRefs = {};
     const UsedTypes = {};
     function collectUsedType(csn, typeName = (csn.items?.type || csn.type)) {
       if(typeName) {
@@ -160,26 +168,24 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     };
 
     if(options.isV4()) {
-      // tunnel schema xref and servicename in options to edm.Typebase to rectify
-      // type references that are eventually also prefixed with the service schema name.
-      options.serviceName = serviceCsn.name;
-      // List of all schema names in this service, including the service itself
-      options.whatsMySchemaName = whatsMySchemaName;
-
       // Add additional schema containers as sub contexts to the service
       Object.entries(allSchemas).forEach(([fqName, art]) => {
         if(serviceCsn.name === whatsMyServiceRootName(fqName) &&
-          fqName.startsWith(serviceCsn.name + '.') && art.kind === 'schema') {
-          fqSchemaXRef.push(fqName);
-          // Strip the toplevel service schema name (see comment above)
-          const name = fqName.replace(serviceCsn.name + '.', '');
-          subSchemaDictionary[name] = {
-            name,
-            fqName,
-            _csn: art,
-            container: false,
-            definitions: Object.create(null)
-          };
+          fqName.startsWith(serviceCsn.name + '.')) {
+          if(art.kind === 'reference')
+            fqSchemaXRef.push(fqName);
+          if(art.kind === 'schema') {
+            fqSchemaXRef.push(fqName);
+            // Strip the toplevel service schema name (see comment above)
+            const name = fqName.replace(serviceCsn.name + '.', '');
+            subSchemaDictionary[name] = {
+              name,
+              fqName,
+              _csn: art,
+              container: false,
+              definitions: Object.create(null)
+            };
+          }
         }
       }, subSchemaDictionary);
 
@@ -203,13 +209,6 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const schema = subSchemaDictionary[name];
         service.registerSchema(schema.fqName, createSchema(schema));
       });
-
-      // Add cross service references to the EDM
-      xServiceRefs.forEach(ref => {
-        let r = new Edm.Reference(v, ref.ref);
-        r.append(new Edm.Include(v, ref.inc))
-        edm._defaultRefs.push(r);
-      });
     }
     else {
       populateSchemas(subSchemaDictionary);
@@ -231,40 +230,43 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
       }));
     });
-    // Create annotations and distribute into Schemas
-    addAnnotations();
+    // Create annotations and distribute into Schemas, merge vocabulary cross refs into xServiceRefs
+    addAnnotations(xServiceRefs);
+
+    // Finally add cross service references into the EDM and extract the targetSchemaNames
+    // for the type cross check
+    Object.values(xServiceRefs).forEach(ref => {
+      let r = new Edm.Reference(v, ref.ref);
+      r.append(new Edm.Include(v, ref.inc))
+      edm._defaultRefs.push(r);
+    });
 
-     // type cross check
-    const xServiceRefNames = xServiceRefs.map(r => r.name).sort((a,b)=>b.length-a.length);
     for(let typeName in UsedTypes) {
       if(!isBuiltinType(typeName)) {
         let iTypeName = typeName;
         /*
           Report type ref, if the type is
             - not a builtin,
-            - not included in required definitions (for this service)
+            - not included in required definitions
             - not a type clash (reported in type exposure),
             - a @cds.external service member but can't be rendered
-            - and not a cross referenced type
         */
         if(!typeName.startsWith(serviceCsn.name + '.'))
           iTypeName = serviceCsn.name + '.' + typeName;
         const def = reqDefs.definitions[iTypeName];
 
         const usages = UsedTypes[typeName].filter(u => !u.$NameClashReported);
-        if(usages.length > 0) {
-          if(def && !def.$isRendered && def['@cds.external'])
-            message('odata-spec-violation-type', usages[0].$location, 
-              { 
-                type: typeName,
-                anno: '@cds.external',
-                name: serviceCsn.name,
-                code: def.elements ? 'Edm.ComplexType' : 'Edm.TypeDefinition',
-                version: options.isV4() ? '4.0' : '2.0',
-                '#': 'external' } );
-          else if(!def && !whatsMySchemaName(typeName, xServiceRefNames))
-            message('odata-spec-violation-type', usages[0].$location, 
-          { type: typeName, name: serviceCsn.name, '#': 'missing' } );
+        if(usages.length > 0 && def && !def.$isRendered && def['@cds.external']) {
+          message('odata-spec-violation-type', usages[0].$location,
+            {
+              type: typeName,
+              anno: '@cds.external',
+              name: serviceCsn.name,
+              code: def.elements ? 'Edm.ComplexType' : 'Edm.TypeDefinition',
+              version: options.isV4() ? '4.0' : '2.0',
+              '#': 'external'
+            }
+          );
         }
       }
     }
@@ -328,11 +330,13 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       return Object.entries(allSchemas).reduce((references, [fqName, art]) => {
         // add references
-        if(art.kind === 'reference' && whatsMySchemaName(fqName) && serviceCsn.name === whatsMyServiceRootName(fqName, false)) {
-          references.push(art);
+        if(art.kind === 'reference' &&
+           whatsMySchemaName(fqName) &&
+           serviceCsn.name === whatsMyServiceRootName(fqName, false)) {
+          references[art.inc.Namespace] = art;
         }
         return references;
-      }, []);
+      }, {});
     }
 
     // Main schema creator function
@@ -385,12 +389,18 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       {
         edmUtils.foreach(schemaCsn.definitions,
         artifact => edmUtils.isDerivedType(artifact) &&
-        !artifact.target &&
+        !artifact.target&&
         artifact.name.startsWith(schemaNamePrefix),
           [createTypeDefinitionV4, markRendered]);
       }
 
-      // fetch all existing child names in a map
+      if(isBetaEnabled(options, 'odataTerms')) {
+        edmUtils.foreach(schemaCsn.definitions,
+      a => a.kind === 'annotation' && a.name.startsWith(schemaNamePrefix),
+      createTerm);
+      }
+
+      // fetch all exising children names in a map
       const NamesInSchemaXRef = Schema._children.reduce((acc, cur) => {
         const name = cur._edmAttributes.Name;
         if(acc[name] === undefined) {
@@ -412,12 +422,6 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
       });
 
-      if(Schema._children.length === 0 || 
-        (Schema._children.length === 1 && Schema._children[0].kind === 'EntityContainer')) {
-        // FIXME: Location for sub schemas?
-        warning(null, ['definitions', Schema._edmAttributes.Namespace], { name: Schema._edmAttributes.Namespace }, 'Schema $(NAME) is empty');
-      }
-
       Object.entries(NamesInSchemaXRef).forEach(([name, refs]) => {
         if(refs.length > 1) {
           error(null, ['definitions', `${Schema._edmAttributes.Namespace}.${name}`], { name: Schema._edmAttributes.Namespace },
@@ -448,7 +452,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const pLoc = [...loc, 'elements', p._edmAttributes.Name];
           edmTypeCompatibilityCheck(p, pLoc);
           if(p._edmAttributes.Name === EntityTypeName)
-            message('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
+            message('odata-spec-violation-property-name', pLoc, { meta: entityCsn.kind });
 
           if(options.isV2() && p._isCollection && !p._csn.target)
             message('odata-spec-violation-array', pLoc, { version: '2.0' });
@@ -524,7 +528,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const pLoc = [ ...loc, ...(structuredTypeCsn.items ? ['items', 'elements'] : [ 'elements' ]), p._edmAttributes.Name ];
           edmTypeCompatibilityCheck(p, pLoc);
           if(p._edmAttributes.Name === complexType._edmAttributes.Name)
-            message('odata-spec-violation-property-name', pLoc, { kind: structuredTypeCsn.kind });
+            message('odata-spec-violation-property-name', pLoc, { meta: structuredTypeCsn.kind });
 
           if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
@@ -618,6 +622,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         return [ props, hasStream ];
       }
 
+      function createTerm(termCsn) {
+        const attributes = { Name: termCsn.name.replace(schemaNamePrefix, '') };
+        const term = new Edm.Term(v, attributes, termCsn);
+        Schema.append(term);
+      }
+
       // V4 <TypeDefintion>
       function createTypeDefinitionV4(typeCsn)
       {
@@ -970,8 +980,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     }
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
-    function addAnnotations() {
-      let { annos, usedVocabularies } = translate.csn2annotationEdm(reqDefs, serviceCsn.name, Edm, options, messageFunctions);
+    function addAnnotations(xServiceRefs) {
+      let { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema
       annos.forEach(anno => {
@@ -979,21 +989,24 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // if no target schema has been found, it's a service annotation that applies to the service schema
         if(targetSchema === undefined)
           targetSchema = serviceCsn.name;
-        if(targetSchema) {
-          if(targetSchema !== serviceCsn.name) {
-            const newTarget = anno._edmAttributes.Target.replace(serviceCsn.name + '.', '');
-            anno.setEdmAttribute('Target', newTarget);
-          }
-          edm._service._schemas[targetSchema]._annotations.push(anno);
+        if(targetSchema !== serviceCsn.name) {
+          const newTarget = anno._edmAttributes.Target.replace(serviceCsn.name + '.', '');
+          anno.setEdmAttribute('Target', newTarget);
         }
+        edm._service._schemas[targetSchema]._annotations.push(anno);
       });
       annos = [];
-      // add references for the used vocabularies
-      usedVocabularies.forEach(voc => {
-        let r = new Edm.Reference(v, voc.ref);
-        r.append(new Edm.Include(v, voc.inc))
-        edm._defaultRefs.push(r);
-      })
+
+      // create service cross reference and merge it into xServiceRefs
+      xrefs.forEach(xr => {
+        if(xr !== serviceCsn.name) {
+          const art = edmUtils.createSchemaRef(allServices, xr);
+          if(xServiceRefs[art.inc.Namespace] === undefined)
+            xServiceRefs[art.inc.Namespace] = art;
+        }
+      });
+      // merge vocabulary cross references into xServiceRefs
+      usedVocabularies.forEach(art => xServiceRefs[art.inc.Namespace] = art);
     }
 
     function edmTypeCompatibilityCheck(p, pLoc) {

package/lib/edm/edm.js

@@ -2,7 +2,7 @@
 
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
-const { forEach } = require("../utils/objectUtils");
+const { forEach } = require('../utils/objectUtils');
 const { isBetaEnabled } = require('../base/model.js');
 
 // facet definitions, optional could either be true or array of edm types
@@ -722,8 +722,8 @@ function getEdm(options, messageFunctions) {
         }
       }
 
-      // Set the collection property if this is either an element or a parameter
-      this._isCollection = (csn.kind === undefined) ? csn._isCollection : false;
+      // Set the collection property if this is either an element, parameter or a term def
+      this._isCollection = (csn.kind === undefined || csn.kind === 'annotation') ? csn._isCollection : false;
 
       if(options.whatsMySchemaName && this._edmAttributes[typeName]) {
         let schemaName = options.whatsMySchemaName(this._edmAttributes[typeName]);
@@ -834,6 +834,18 @@ function getEdm(options, messageFunctions) {
     }
   }
 
+  class Term extends TypeBase
+    {
+    constructor(v, attributes, csn)
+      {
+      super(v, attributes, csn);
+      const appliesTo = csn['@odata.term.AppliesTo'];
+      if(appliesTo) {
+        this.setEdmAttribute('AppliesTo', Array.isArray(appliesTo) ? appliesTo.map(v=>v['=']||v).join(' ') : appliesTo['='] || appliesTo);
+      }
+    }
+    }
+
   class TypeDefinition extends TypeBase
   {
     constructor(v, attributes, csn)
@@ -1639,6 +1651,8 @@ function getEdm(options, messageFunctions) {
     EntityContainer,
     EntitySet,
     Singleton,
+    TypeBase,
+    Term,
     TypeDefinition,
     EnumType,
     ComplexType,

package/lib/edm/edmAnnoPreprocessor.js

@@ -108,8 +108,8 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
       let CommonAttributes = element[prop];
       if(!Array.isArray(CommonAttributes)) {
         error(null, ['definitions', struct.name, 'elements', element.name],
-          { anno: '@Common.attribute', code: JSON.stringify(CommonAttributes) },
-          'Expect array value for $(ANNOTATION): $(CODE)');
+          { anno: '@Common.Attributes', code: JSON.stringify(CommonAttributes) },
+          'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
 
@@ -125,7 +125,7 @@ function applyAppSpecificLateCsnTransformationOnElement(options, element, struct
       if(!Array.isArray(ContextDefiningProperties)) {
         error(null, ['definitions', struct.name, 'elements', element.name],
           { anno: '@Aggregation.ContextDefiningProperties', code: JSON.stringify(ContextDefiningProperties) },
-          'Expect array value for $(ANNOTATION): $(CODE)');
+          'Expecting array value for $(ANNO): $(CODE)');
         return;
       }
       if(ContextDefiningProperties.length > 0)
@@ -198,7 +198,7 @@ function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error
         error(null, ['definitions', struct.name ],
           { anno: '@Capabilities.FilterRestrictions.FilterExpressionRestrictions',
             code: JSON.stringify(filterRestrictions) },
-          'Expect array value for $(ANNOTATION): $(CODE)');
+          'Expected array value for $(ANNO): $(CODE)');
         return;
       }
       filterRestrictions.forEach(v => {
@@ -215,7 +215,7 @@ function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error
         error(null, ['definitions', struct.name],
           { anno: '@Capabilities.FilterRestrictions.RequiredProperties',
             code: JSON.stringify(requiredProperties) },
-          'Expect array value for $(ANNOTATION): $(CODE)');
+          'Expecting array value for $(ANNO): $(CODE)');
         return;
       }