@sap/cds-compiler 2.13.6 → 2.15.4

package/lib/edm/csn2edm.js

@@ -7,12 +7,13 @@ const NAVPROP_TRENNER = '_';
 const VALUELIST_NAVPROP_PREFIX = '';
 
 const edmUtils = require('./edmUtils.js')
-const { initializeModel } = require('./edmPreprocessor.js');
+const { initializeModel, assignAnnotation } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp } = require('../base/model');
-const { cloneCsn, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
+const { EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm } = require('./edm.js');
 
 /*
 OData V2 spec 06/01/2017 PDF version is available from here:
@@ -25,11 +26,11 @@ function csn2edm(_csn, serviceName, _options) {
 
 function csn2edmAll(_csn, _options, serviceNames=undefined) {
   // get us a fresh model copy that we can work with
-  const csn = cloneCsn(_csn, _options);
+  const csn = cloneCsnNonDict(_csn, _options);
 
   // use original options for messages; cloned CSN for semantic location
   const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
-  const { info, warning, error, message, throwWithError } = messageFunctions;
+  const { info, warning, error, message, throwWithAnyError } = messageFunctions;
   checkCSNVersion(csn, _options);
 
   let rc = Object.create(null);
@@ -42,13 +43,14 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     setProp(csn.meta, 'options', _csn.meta.options);
   }
 
-  let [ allServices,
+  const [ allServices,
     allSchemas,
+    reqDefs,
     whatsMyServiceRootName,
-    autoexposeSchemaName,
-    options ] = initializeModel(csn, _options, messageFunctions);
+    fallBackSchemaName,
+    options ] = initializeModel(csn, _options, messageFunctions, serviceNames);
 
-  const Edm = require('./edm.js')(options, error);
+  const Edm = getEdm(options, messageFunctions);
 
   const v = options.v;
   if(Object.keys(allServices).length === 0) {
@@ -74,7 +76,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       services[serviceCsn.name] = createEdm(serviceCsn);
       return services; }, rc);
   }
-  throwWithError();
+  throwWithAnyError();
   return rc;
 
   //--------------------------------------------------------------------------------
@@ -189,9 +191,9 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       fqSchemaXRef.sort((a,b) => b.length-a.length);
 
       // Bring the schemas in alphabetical order, service first, root last
-      const sortedSchemaNames = Object.keys(subSchemaDictionary).filter(n => n !== autoexposeSchemaName && n !== serviceCsn.name).sort();
-      if(subSchemaDictionary[autoexposeSchemaName])
-        sortedSchemaNames.push(autoexposeSchemaName);
+      const sortedSchemaNames = Object.keys(subSchemaDictionary).filter(n => n !== fallBackSchemaName && n !== serviceCsn.name).sort();
+      if(subSchemaDictionary[fallBackSchemaName])
+        sortedSchemaNames.push(fallBackSchemaName);
 
       // Finally create the schemas and register them in the service.
       LeadSchema = createSchema(subSchemaDictionary[serviceCsn.name]);
@@ -221,7 +223,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     service._children.forEach(c => {
       c._ec && Object.entries(c._ec._registry).forEach((([setName, arr]) => {
         if(arr.length > 1) {
-          error(null, null, { name: c.Namespace, id: setName },
+          error(null, null, { name: c._edmAttributes.Namespace, id: setName },
           `Namespace $(NAME): Duplicate entries in EntityContainer with Name=$(ID) for ${arr.map(a =>a.getDuplicateMessage()).join(', ')} `);
         }
       }));
@@ -232,7 +234,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
     // Sort definitions into their schema container
     function populateSchemas(schemas) {
-      Object.entries(csn.definitions).forEach(([fqName, art]) => {
+      Object.entries(reqDefs.definitions).forEach(([fqName, art]) => {
         // Identify service members by their definition name only, this allows
         // to let the internal object.name have the sub-schema name.
         // With nested services we must do a longest path match and check whether
@@ -301,10 +303,18 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       // Same check for alias (if supported by us)
       const reservedNames = ['Edm', 'odata', 'System', 'Transient'];
-      if(reservedNames.includes(schema.name)) {
-        warning('odata-spec-violation-namespace',
-                [ 'definitions', schema.name ], { names: reservedNames });
+      const loc = ['definitions', schema.name];
+      if(reservedNames.includes(schema.name))
+        warning('odata-spec-violation-namespace', loc, { names: reservedNames });
+      if (schema.name.length > 511)
+        warning('odata-spec-violation-namespace', loc, { '#': 'length' });
+      else {
+        schema.name.split('.').forEach(id => {
+          if (!edmUtils.isODataSimpleIdentifier(id))
+            message('odata-spec-violation-id', loc, { id });
+        });
       }
+
       /** @type {any} */
       const Schema = new Edm.Schema(v, schema.name, undefined /* unset alias */, schema._csn, /* annotations */ [], schema.container);
       const EntityContainer = Schema._ec || (LeadSchema && LeadSchema._ec);
@@ -343,10 +353,11 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       // fetch all exising children names in a map
       const NamesInSchemaXRef = Schema._children.reduce((acc, cur) => {
-        if(acc[cur.Name] === undefined) {
-          acc[cur.Name] = [ cur ];
+        const name = cur._edmAttributes.Name;
+        if(acc[name] === undefined) {
+          acc[name] = [ cur ];
         } else {
-          acc[cur.Name].push(cur);
+          acc[name].push(cur);
         }
         return acc;
       }, Object.create(null) );
@@ -368,12 +379,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       }
       if(Schema._children.length === 0) {
         // FIXME: Location for sub schemas?
-        warning(null, ['definitions', Schema.Namespace], { name: Schema.Namespace }, 'Schema $(NAME) is empty');
+        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.Namespace}.${name}`], { name: Schema.Namespace },
+          error(null, ['definitions', `${Schema._edmAttributes.Namespace}.${name}`], { name: Schema._edmAttributes.Namespace },
           'Duplicate name in Schema $(NAME)');
         }
       });
@@ -389,21 +400,29 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
         const loc = ['definitions', entityCsn.name];
         const type = `${schema.name}.${EntityTypeName}`;
-        if(properties.length === 0) {
+        if(properties.length === 0)
           warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no properties');
-        } else if(entityCsn.$edmKeyPaths.length === 0) {
+        else if(entityCsn.$edmKeyPaths.length === 0)
           message('odata-spec-violation-no-key', loc);
-        }
+
+        if(!edmUtils.isODataSimpleIdentifier(EntityTypeName))
+          message('odata-spec-violation-id', loc, { id: EntityTypeName });
+
         properties.forEach(p => {
-          const pLoc = [...loc, 'elements', p.Name];
-          if(!p[p._typeName]) {
-            message('odata-spec-violation-type', pLoc);
-          }
-          if(p.Name === EntityTypeName) {
+          const pLoc = [...loc, 'elements', p._edmAttributes.Name];
+          edmTypeCompatibilityCheck(p, pLoc);
+          if(p._edmAttributes.Name === EntityTypeName)
             warning('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
-          }
-          if(options.isV2() && p._isCollection && !edmUtils.isAssociationOrComposition(p._csn)) {
-            warning('odata-spec-violation-array', pLoc, { api: 'OData V2' });
+
+          if(options.isV2() && p._isCollection && !edmUtils.isAssociationOrComposition(p._csn))
+            warning('odata-spec-violation-array', pLoc, { version: '2.0' });
+
+          if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
+            message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
+          else if (options.isV2() && /^(_|[0-9])/.test(p._edmAttributes.Name)) {
+            // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
+            message('odata-spec-violation-id', pLoc,
+            { prop: p._edmAttributes.Name[0], id: p._edmAttributes.Name, version: '2.0', '#': 'v2firstchar' });
           }
         });
 
@@ -411,8 +430,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const attributes = { Name : EntityTypeName };
 
         // CDXCORE-CDXCORE-173
-        if(options.isV2() && hasStream)
-          attributes['m:HasStream'] = hasStream;
+        if(options.isV2() && hasStream) {
+          attributes['m:HasStream'] = true;
+          assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
+        }
 
         Schema.append(new Edm.EntityType(v, attributes, properties, entityCsn));
 
@@ -424,7 +445,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           if(edmUtils.isSingleton(entityCsn) && options.isV4()) {
             containerEntry = new Edm.Singleton(v, { Name: EntitySetName, Type: fullQualified(EntityTypeName) }, entityCsn);
             if(entityCsn['@odata.singleton.nullable'])
-              containerEntry.Nullable= true;
+              containerEntry._edmAttributes.Nullable= true;
           }
           else {
             containerEntry = new Edm.EntitySet(v, { Name: EntitySetName, EntityType: fullQualified(EntityTypeName) }, entityCsn);
@@ -447,14 +468,19 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       }
 
       // add bound/unbound actions/functions for V4
-      function createActionV4(actionCsn, name, entityCsn=undefined)
+      function createActionV4(actionCsn, _name, entityCsn=undefined)
       {
         const iAmAnAction = actionCsn.kind === 'action';
-
         const actionName = edmUtils.getBaseName(actionCsn.name);
-
         const attributes = { Name: actionName, IsBound : false };
 
+        const loc = entityCsn
+            ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
+            : [ 'definitions', actionCsn.name ];
+
+        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', loc, { id: attributes.Name });
+
         if(!iAmAnAction)
           attributes.IsComposable = false;
 
@@ -468,7 +494,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
         if(entityCsn != undefined)
         {
-          actionNode.IsBound = true;
+          actionNode.setEdmAttribute('IsBound', true);
           const bpType = fullQualified(entityCsn.name);
           // Binding Parameter: 'in' at first position in sequence, this is decisive!
           if(actionCsn['@cds.odata.bindingparameter.collection'])
@@ -489,7 +515,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             const definition = schemaCsn.definitions[rt];
             if(definition && definition.kind === 'entity' && !definition.abstract)
             {
-              actionImport.EntitySet = edmUtils.getBaseName(rt);
+              actionImport.setEdmAttribute('EntitySet', edmUtils.getBaseName(rt));
             }
           }
           EntityContainer.register(actionImport);
@@ -497,15 +523,22 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
         // Parameter Nodes
         edmUtils.forAll(actionCsn.params, (parameterCsn, parameterName) => {
-          actionNode.append(new Edm.Parameter(v, { Name: parameterName }, parameterCsn ));
+          const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
+          const pLoc = [ ...loc, 'params', p._edmAttributes.Name ];
+          if(!edmUtils.isODataSimpleIdentifier(parameterName))
+            message('odata-spec-violation-id', pLoc, { id: parameterName });
+
+          edmTypeCompatibilityCheck(p, pLoc);
+          actionNode.append(p);
         });
 
         // return type if any
         if(actionCsn.returns) {
           actionNode._returnType = new Edm.ReturnType(v, actionCsn.returns);
+          edmTypeCompatibilityCheck(actionNode._returnType, [ ...loc, 'returns' ]);
           // if binding type matches return type add attribute EntitySetPath
           if(entityCsn != undefined && fullQualified(entityCsn.name) === actionNode._returnType._type) {
-            actionNode.EntitySetPath = bpName;
+            actionNode.setEdmAttribute('EntitySetPath', bpName);
           }
         }
         Schema.addAction(actionNode);
@@ -515,7 +548,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       function createActionV2(actionCsn, name, entityCsn=undefined)
       {
         /** @type {object} */
-        const functionImport = new Edm.FunctionImport(v, { Name: name.replace(schemaNamePrefix, '') } );
+        const attributes = { Name: name.replace(schemaNamePrefix, '') };
+        const functionImport = new Edm.FunctionImport(v, attributes );
 
         // inserted now to maintain attribute order with old odata generator...
         /*
@@ -528,19 +562,25 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           in the spec and advised mention it as in V4
         */
 
-        const actLoc = ['definitions', ...(entityCsn ? [entityCsn.name, 'actions', actionCsn.name] : [actionCsn.name])];
+        const loc = entityCsn
+          ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
+          : [ 'definitions', actionCsn.name ];
+
+        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', loc, { id: attributes.Name });
+
         const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
         if(rt) // add EntitySet attribute only if return type is an entity
         {
           const defintion = schemaCsn.definitions[rt];
           if(defintion && edmUtils.isEntity(defintion))
           {
-            functionImport.EntitySet = rt.replace(schemaNamePrefix, '');
+            functionImport.setEdmAttribute('EntitySet', rt.replace(schemaNamePrefix, ''));
           }
         }
 
         if(actionCsn.returns)
-          functionImport.ReturnType = getReturnType(actionCsn);
+          functionImport.setEdmAttribute('ReturnType', getReturnType(actionCsn));
 
         if(actionCsn.kind === 'function')
           functionImport.setXml( {'m:HttpMethod': 'GET' });
@@ -551,7 +591,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         {
           // Make bound function names always unique as per Ralf's recommendation
           functionImport.setXml( {'sap:action-for':  fullQualified(entityCsn.name) } );
-          functionImport.Name = entityCsn.name.replace(schemaNamePrefix, '') + '_' + functionImport.Name;
+          const name = entityCsn.name.replace(schemaNamePrefix, '') + '_' + functionImport._edmAttributes.Name;
+          functionImport.setEdmAttribute('Name', name);
 
           // Binding Parameter: Primary Keys at first position in sequence, this is decisive!
           // V2 XML: Nullable=false is set because we reuse the primary key property for the parameter
@@ -573,14 +614,22 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // V2 XML spec does only mention default Nullable=true for Properties not for Parameters so omitting Nullable=true let
         // the client assume that Nullable is false.... Correct Nullable Handling is done inside Parameter constructor
         edmUtils.forAll(actionCsn.params, (parameterCsn, parameterName) => {
-          const paramLoc = [...actLoc, 'params', parameterName];
+          const pLoc = [...loc, 'params', parameterName];
           const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
-          if(param._type && !param._type.startsWith('Edm.') && !edmUtils.isStructuredType(csn.definitions[param._type])) {
-            warning('odata-spec-violation-param', paramLoc, { api: 'OData V2' });
-          }
-          if(param._isCollection) {
-            warning('odata-spec-violation-array', paramLoc, { api: 'OData V2' });
-          }
+          edmTypeCompatibilityCheck(param, pLoc);
+          if(!edmUtils.isODataSimpleIdentifier(parameterName))
+            message('odata-spec-violation-id', pLoc, { id: parameterName });
+
+          // only scalar or structured type in V2 (not entity)
+          if(param._type &&
+            !param._type.startsWith('Edm.') &&
+            csn.definitions[param._type] &&
+            !edmUtils.isStructuredType(csn.definitions[param._type]))
+            warning('odata-spec-violation-param', pLoc, { version: '2.0' });
+
+          if(param._isCollection)
+            warning('odata-spec-violation-array', pLoc, { version: '2.0' });
+
           functionImport.append(param);
         });
 
@@ -590,19 +639,33 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         function getReturnType(action)
         {
           // it is safe to assume that either type or items.type are set
+          const returnsLoc = [ ...loc, 'returns'];
           const returns = action.returns.items || action.returns;
           let type = returns.type;
-          if (type){
+          if (type) {
             if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
-              const returnsLoc = [ ...actLoc, 'returns'];
-              warning('odata-spec-violation-returns', returnsLoc, { kind: action.kind, api: 'OData V2' });
+              warning('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
+            }
+            else if(isBuiltinType(type)) {
+              type = edmUtils.mapCdsToEdmType(returns, messageFunctions, true);
+              if(type) {
+                const td = EdmPrimitiveTypeMap[type];
+                if(td && !td.v2) {
+                  message('odata-spec-violation-type', returnsLoc,
+                    { type, version: '2.0', '#': 'incompatible' });
+                }
+              }
+              else {
+                message('odata-spec-violation-type-unknown', returnsLoc, { type });
+              }
             }
-            type = edmUtils.mapCdsToEdmType(returns, messageFunctions, options.isV2());
+            if(action.returns._isCollection)
+              type = `Collection(${type})`
+          }
+          else {
+            // type is missing
+            message('odata-spec-violation-type', returnsLoc);
           }
-
-          if(action.returns._isCollection)
-            type = `Collection(${type})`
-
           return type;
         }
       }
@@ -610,14 +673,16 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       /**
        * @param {object} elementsCsn
        * @param {object} edmParentCsn
-       * @returns {[object[], boolean]} Returns a [ [ Edm Properties ], boolean hasStream ]:
+       * @returns {[object[], any]} Returns a [ [ Edm Properties ], boolean hasStream ]:
        *                              array of Edm Properties
-       *                              boolean hasStream : true if at least one element has @Core.MediaType assignment
+       *                              hasStream : value of @Core.MediaType assignment
        */
       function createProperties(elementsCsn, edmParentCsn=elementsCsn)
       {
         const props = [];
         let hasStream = false;
+        const streamProps = [];
+
         edmUtils.forAll(elementsCsn.elements, (elementCsn, elementName) =>
         {
           if(elementCsn._edmParentCsn == undefined)
@@ -653,12 +718,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
               // CDXCORE-CDXCORE-173
               // V2: filter  @Core.MediaType
               if ( options.isV2() && elementCsn['@Core.MediaType']) {
+                hasStream = elementCsn['@Core.MediaType'];
+                delete elementCsn['@Core.MediaType'];
                 // CDXCORE-CDXCORE-177:
                 // V2: don't render element but add attribute 'm:HasStream="true' to EntityType
                 // V4: render property type 'Edm.Stream'
-                hasStream = true;
-                info(null, ['definitions', elementsCsn.name], { name: elementsCsn.name, id: elementName, anno: '@Core.MediaType' },
-                  '$(NAME): Property $(ID) annotated with $(ANNO) is removed from EDM in OData V2');
+                streamProps.push(elementName);
 
               } else {
                 props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
@@ -667,6 +732,16 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           }
 
         });
+        if(options.isV2()) {
+          if(streamProps.length > 1) {
+            error(null, ['definitions', elementsCsn.name], { names: streamProps, version: '2.0', anno: '@Core.MediaType' },
+                 `Expected only one element to be annotated with $(ANNO) for OData $(VERSION) but found $(NAMES)`);
+          }
+          else if(streamProps.length === 1) {
+            info(null, ['definitions', elementsCsn.name], { id: streamProps[0], version: '2.0', anno: '@Core.MediaType' },
+                  'Property $(ID) annotated with $(ANNO) is removed from EDM for OData $(VERSION)');
+          }
+        }
         return [ props, hasStream ];
       }
 
@@ -681,24 +756,27 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         const loc = ['definitions', structuredTypeCsn.name];
 
         if(properties.length === 0) {
-          warning(null, ['definitions', structuredTypeCsn.name], { name: structuredTypeCsn.name },
+          warning(null, loc, { name: structuredTypeCsn.name },
           'EDM ComplexType $(NAME) has no properties');
         }
+        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', loc, { id: attributes.Name });
+
         properties.forEach(p => {
-          const pLoc = [ ...loc, ...(structuredTypeCsn.items ? ['items', 'elements'] : [ 'elements' ]), p.Name ];
-          if(!p[p._typeName]) {
-            message('odata-spec-violation-type', pLoc);
-          }
-          if(p.Name === complexType.Name) {
+          const pLoc = [ ...loc, ...(structuredTypeCsn.items ? ['items', 'elements'] : [ 'elements' ]), p._edmAttributes.Name ];
+          edmTypeCompatibilityCheck(p, pLoc);
+          if(p._edmAttributes.Name === complexType._edmAttributes.Name)
             warning('odata-spec-violation-property-name', pLoc, { kind: structuredTypeCsn.kind });
-          }
+
+          if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
+            message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
+
           if(options.isV2()) {
-            if(p._isCollection && !edmUtils.isAssociationOrComposition(p._csn)) {
-              warning('odata-spec-violation-array', pLoc, { api: 'OData V2' });
-            }
-            if(edmUtils.isAssociationOrComposition(p._csn)) {
-              warning('odata-spec-violation-assoc', pLoc, { api: 'OData V2' });
-            }
+            if(p._isCollection && !edmUtils.isAssociationOrComposition(p._csn))
+              warning('odata-spec-violation-array', pLoc, { version: '2.0' });
+
+            if(edmUtils.isAssociationOrComposition(p._csn))
+              warning('odata-spec-violation-assoc', pLoc, { version: '2.0' });
           }
         });
 
@@ -712,8 +790,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       function createTypeDefinition(typeCsn)
       {
         // derived types are already resolved to base types
-        const props = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
-        const typeDef = new Edm.TypeDefinition(v, props, typeCsn );
+        const attributes = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
+        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', ['definitions', typeCsn.name], { id: attributes.Name });
+
+        const typeDef = new Edm.TypeDefinition(v, attributes, typeCsn );
+        edmTypeCompatibilityCheck(typeDef, [ 'definitions', typeCsn.name ]);
         Schema.append(typeDef);
       }
 
@@ -735,7 +817,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       {
         let constraints = navigationProperty._csn._constraints;
         let parentName = navigationProperty._csn._edmParentCsn.name.replace(schemaNamePrefix, '');
-        let plainAssocName = parentName + NAVPROP_TRENNER + navigationProperty.Name.replace(VALUELIST_NAVPROP_PREFIX, '');
+        let plainAssocName = parentName + NAVPROP_TRENNER + navigationProperty._edmAttributes.Name.replace(VALUELIST_NAVPROP_PREFIX, '');
         let assocName = plainAssocName;
         let i = 1;
         while(NamesInSchemaXRef[assocName] !== undefined) {
@@ -743,7 +825,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         let fromRole = parentName;
-        let toRole = navigationProperty.Type.replace(schemaAliasPrefix, ''); // <= navprops type should be prefixed with alias
+        let toRole = navigationProperty._edmAttributes.Type.replace(schemaAliasPrefix, ''); // <= navprops type should be prefixed with alias
 
         let fromEntityType = fromRole;
         let toEntityType = toRole;
@@ -763,17 +845,14 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // add V2 attributes to navigationProperty
-        navigationProperty.Relationship = fullQualified(assocName);
-        navigationProperty.FromRole = fromRole;
-        navigationProperty.ToRole = toRole;
+        navigationProperty.setEdmAttribute('Relationship', fullQualified(assocName));
+        navigationProperty.setEdmAttribute('FromRole', fromRole);
+        navigationProperty.setEdmAttribute('ToRole', toRole);
 
         // remove V4 attributes
-        if(navigationProperty.Type != undefined)
-          delete navigationProperty.Type;
-        if(navigationProperty.Partner != undefined)
-          delete navigationProperty.Partner;
-        if(navigationProperty.ContainsTarget != undefined)
-          delete navigationProperty.ContainsTarget;
+        navigationProperty.removeEdmAttribute('Type');
+        navigationProperty.removeEdmAttribute('Partner');
+        navigationProperty.removeEdmAttribute('ContainsTarget');
 
         /*
           If NavigationProperty is a backlink association (constraints._originAssocCsn is set), then there are two options:
@@ -799,7 +878,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             assocName = plainAssocName + '_' + i++;
           }
 
-          navigationProperty.Relationship = fullQualified(assocName)
+          navigationProperty.setEdmAttribute('Relationship', fullQualified(assocName));
 
           reuseAssoc = !!forwardAssocCsn._NavigationProperty;
           constraints = forwardAssocCsn._constraints;
@@ -854,17 +933,18 @@ 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(csn, serviceCsn.name, Edm, options, messageFunctions);
+      let { annos, usedVocabularies } = translate.csn2annotationEdm(reqDefs, serviceCsn.name, Edm, options, messageFunctions);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema
       annos.forEach(anno => {
-        let targetSchema = whatsMySchemaName(anno.Target);
+        let targetSchema = whatsMySchemaName(anno._edmAttributes.Target);
         // 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) {
-            anno.Target = anno.Target.replace(serviceCsn.name + '.', '');
+            const newTarget = anno._edmAttributes.Target.replace(serviceCsn.name + '.', '');
+            anno.setEdmAttribute('Target', newTarget);
           }
           edm._service._schemas[targetSchema]._annotations.push(anno);
         }
@@ -877,6 +957,44 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         edm._defaultRefs.push(r);
       })
     }
+
+    function edmTypeCompatibilityCheck(p, pLoc) {
+      const edmType = p._type;
+      if(!edmType) {
+        message('odata-spec-violation-type', pLoc);
+      }
+      else if(p._scalarType) {
+        const td = EdmPrimitiveTypeMap[edmType];
+        if(td) {
+          // The renderer/type mapper doesn't/shouldn't produce incompatible types and facets.
+          // Only the unknown type warning may be triggered by an unknown @odata.Type override.
+          if(td.v2 !== p.v2 && td.v4 !== p.v4)
+            message('odata-spec-violation-type', pLoc,
+            { type:edmType, version: (p.v4 ? '4.0' : '2.0'), '#': 'incompatible' });
+          EdmTypeFacetNames.forEach(name => {
+            const facet = EdmTypeFacetMap[name];
+            const optional =
+              (facet.optional !== undefined)
+                ? (Array.isArray(facet.optional)
+                  ? facet.optional.includes(edmType)
+                  : facet.optional)
+              : false;
+
+            // facet is not in attributes
+            // facet is member of type definition and mandatory
+            // node and facet version match
+            if(!p._edmAttributes[name] && td[name] && !optional && (p.v2 === facet.v2 || p.v4 === facet.v4)) {
+              message('odata-spec-violation-type', pLoc,
+                { type:edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet' });
+            }
+          });
+        }
+        else {
+          message('odata-spec-violation-type-unknown', pLoc,
+          { type:edmType });
+        }
+      }
+    }
   }
 }
 module.exports = { csn2edm, csn2edmAll };