@sap/cds-compiler 3.4.2 → 3.5.0

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');
@@ -30,7 +30,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
   // use original options for messages; cloned CSN for semantic location
   const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
-  const { info, warning, error, message, throwWithAnyError } = messageFunctions;
+  const { info, warning, error, message, throwWithError } = messageFunctions;
   checkCSNVersion(csn, _options);
 
   let rc = Object.create(null);
@@ -43,7 +43,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     setProp(csn.meta, 'options', _csn.meta.options);
   }
 
-  const [ allServices,
+  const [
+    allServices,
     allSchemas,
     reqDefs,
     whatsMyServiceRootName,
@@ -54,7 +55,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
   const v = options.v;
   if(Object.keys(allServices).length === 0) {
-    info(null, null, `No Services in model`);
+    info(null, null, 'No Services in model');
     return rc;
   }
 
@@ -76,7 +77,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       services[serviceCsn.name] = createEdm(serviceCsn);
       return services; }, rc);
   }
-  throwWithAnyError();
+  throwWithError();
   return rc;
 
   //--------------------------------------------------------------------------------
@@ -91,6 +92,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     // let alias = serviceCsn.alias || baseName(baseName(serviceCsn.name, '::'), '.');
     // FIXME: UI5 cannot deal with spec conforming simpleid alias names
 
+    function markRendered(def) { setProp(def, '$isRendered', true); }
+
     const service = new Edm.DataServices(v);
     /** @type {object} */
     const edm = new Edm.Edm(v, service);
@@ -135,6 +138,24 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       return fqSchemaXRef.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') ? sn : rc, undefined);
     }
 
+    // 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) {
+        if(UsedTypes[typeName])
+          UsedTypes[typeName].push(csn)
+        else
+          UsedTypes[typeName] = [ csn ];
+      }
+    }
+
     // create schema containers
     const subSchemaDictionary = {
       [serviceCsn.name]: {
@@ -147,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);
 
@@ -175,20 +194,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       // Fill the schemas and references, fqSchemaXRef must be complete
       populateSchemas(subSchemaDictionary);
-      const xServiceRefs = populateXserviceRefs();
-      /* TODO:
-      const references = Object.entries(allSchemas).reduce((references, [fqName, art]) => {
-        // add references
-        if(fqName.startsWith(serviceCsn.name + '.') && art.kind === 'reference') {
-          fqSchemaXRef.push(fqName);
-          references.push(art);
-        }
-        return references;
-      }, []);
-      */
-      // Add xrefs to full schema cross ref list for further usage
-      fqSchemaXRef.push(...xServiceRefs);
-      fqSchemaXRef.sort((a,b) => b.length-a.length);
+      xServiceRefs = populateXserviceRefs();
 
       // Bring the schemas in alphabetical order, service first, root last
       const sortedSchemaNames = Object.keys(subSchemaDictionary).filter(n => n !== fallBackSchemaName && n !== serviceCsn.name).sort();
@@ -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);
@@ -223,13 +222,55 @@ 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._edmAttributes.Namespace, id: setName },
-          `Namespace $(NAME): Duplicate entries in EntityContainer with Name=$(ID) for ${arr.map(a =>a.getDuplicateMessage()).join(', ')} `);
+          error(null, null, {
+            name: c._edmAttributes.Namespace,
+            id: setName,
+            names: arr.map(a => a.getDuplicateMessage())
+          }, 'Namespace $(NAME): Duplicate entries in EntityContainer with Name=$(ID) for $(NAMES)');
         }
       }));
     });
-    // 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);
+    });
+
+    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
+            - not a type clash (reported in type exposure),
+            - a @cds.external service member but can't be rendered
+        */
+        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 && 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'
+            }
+          );
+        }
+      }
+    }
+
     return edm
 
     // Sort definitions into their schema container
@@ -289,12 +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)) {
-          fqSchemaXRef.push(fqName);
-          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
@@ -331,25 +373,31 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       */
       edmUtils.foreach(schemaCsn.definitions,
         a => a.kind === 'entity' && !a.abstract && a.name.startsWith(schemaNamePrefix),
-        createEntityTypeAndSet
+        [createEntityTypeAndSet, markRendered]
       );
       // create unbound actions/functions
-      edmUtils.foreach(schemaCsn.definitions, 
+      edmUtils.foreach(schemaCsn.definitions,
         a => (a.kind === 'action' || a.kind === 'function') && a.name.startsWith(schemaNamePrefix),
-        (options.isV4()) ? createActionV4 : createActionV2);
+        [(options.isV4()) ? createActionV4 : createActionV2, markRendered]);
 
     // create the complex types
       edmUtils.foreach(schemaCsn.definitions,
       a => edmUtils.isStructuredType(a) && a.name.startsWith(schemaNamePrefix),
-      createComplexType);
+      [createComplexType, markRendered]);
 
       if(options.isV4())
       {
         edmUtils.foreach(schemaCsn.definitions,
         artifact => edmUtils.isDerivedType(artifact) &&
-        !artifact.target &&
+        !artifact.target&&
         artifact.name.startsWith(schemaNamePrefix),
-          createTypeDefinition);
+          [createTypeDefinitionV4, markRendered]);
+      }
+
+      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
@@ -370,19 +418,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             np.addReferentialConstraintNodes();
         }
         else {
-          addAssociation(np);
+          addAssociationV2(np);
         }
       });
 
-      // remove EntityContainer if empty
-      if(Schema._ec && Schema._ec._children.length === 0) {
-        Schema._children.splice(Schema._children.indexOf(Schema._ec), 1);
-      }
-      if(Schema._children.length === 0) {
-        // 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 },
@@ -413,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' });
@@ -468,6 +507,140 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         });
       }
 
+      function createComplexType(structuredTypeCsn)
+      {
+        // V4 attributes: Name, BaseType, Abstract, OpenType
+        const attributes = { Name: structuredTypeCsn.name.replace(schemaNamePrefix, '') };
+
+        const complexType = new Edm.ComplexType(v, attributes, structuredTypeCsn);
+        const elementsCsn = structuredTypeCsn.items || structuredTypeCsn;
+        const properties = createProperties(elementsCsn, structuredTypeCsn)[0];
+        const loc = ['definitions', structuredTypeCsn.name];
+
+        if(properties.length === 0) {
+          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._edmAttributes.Name ];
+          edmTypeCompatibilityCheck(p, pLoc);
+          if(p._edmAttributes.Name === complexType._edmAttributes.Name)
+            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 });
+
+          if(options.isV2()) {
+            if(p._isCollection && !p._csn.target)
+              message('odata-spec-violation-array', pLoc, { version: '2.0' });
+
+            if(p._csn.target)
+              message('odata-spec-violation-assoc', pLoc, { version: '2.0' });
+          }
+        });
+
+
+        complexType.append(...(properties));
+
+        Schema.append(complexType);
+      }
+
+      /**
+       * @param {object} elementsCsn
+       * @param {object} edmParentCsn
+       * @returns {[object[], any]} Returns a [ [ Edm Properties ], boolean hasStream ]:
+       *                              array of Edm Properties
+       *                              hasStream : value of @Core.MediaType assignment
+       */
+      function createProperties(elementsCsn, edmParentCsn=elementsCsn)
+      {
+        const props = [];
+        let hasStream = false;
+        const streamProps = [];
+
+        elementsCsn.elements && Object.entries(elementsCsn.elements).forEach(([elementName, elementCsn]) =>
+        {
+          if(elementCsn._edmParentCsn == undefined)
+            setProp(elementCsn, '_edmParentCsn', edmParentCsn);
+
+          if(elementCsn.target) {
+              // Foreign keys are part of the generic elementCsn.elements property creation
+
+              // This is the V4 edmx:NavigationProperty
+              // gets rewritten for V2 in addAssociations()
+
+              // suppress navprop creation only if @odata.navigable:false is not annotated.
+              // (undefined !== false) still evaluates to true
+            if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false)
+              {
+              const navProp = new Edm.NavigationProperty(v, {
+                Name: elementName,
+                Type: elementCsn._target.name
+              }, elementCsn);
+              collectUsedType(elementCsn, elementCsn._target.name);
+              props.push(navProp);
+                // save the navProp in the global array for late constraint building
+              navigationProperties.push(navProp);
+            }
+          }
+            // render ordinary property if element is NOT ...
+            // 1) ... annotated @cds.api.ignore
+            // 2) ... annotated @odata.foreignKey4 and odataFormat: structured
+
+          else if(isEdmPropertyRendered(elementCsn, options))
+            {
+              // 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'
+              streamProps.push(elementName);
+
+            } else {
+              collectUsedType(elementCsn);
+              props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
+            }
+          }
+
+        });
+        if(options.isV2()) {
+          if(streamProps.length > 1) { // TODO: why not mention 2.0 in text?
+            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 ];
+      }
+
+      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)
+      {
+        // derived types are already resolved to base types
+        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);
+      }
+
       // add bound/unbound actions/functions for V4
       function createActionV4(actionCsn, _name, entityCsn=undefined)
       {
@@ -528,7 +701,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const pLoc = [ ...loc, 'params', p._edmAttributes.Name ];
           if(!edmUtils.isODataSimpleIdentifier(parameterName))
             message('odata-spec-violation-id', pLoc, { id: parameterName });
-
+          collectUsedType(parameterCsn);
           edmTypeCompatibilityCheck(p, pLoc);
           actionNode.append(p);
         });
@@ -536,6 +709,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // return type if any
         if(actionCsn.returns) {
           actionNode._returnType = new Edm.ReturnType(v, actionCsn.returns);
+          collectUsedType(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) {
@@ -617,6 +791,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
           const pLoc = [...loc, 'params', parameterName];
           const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
+          collectUsedType(parameterCsn);
           edmTypeCompatibilityCheck(param, pLoc);
           if(!edmUtils.isODataSimpleIdentifier(parameterName))
             message('odata-spec-violation-id', pLoc, { id: parameterName });
@@ -644,6 +819,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const returns = action.returns.items || action.returns;
           let type = returns.type;
           if (type) {
+            collectUsedType(action.returns);
             if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
               message('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
             }
@@ -671,147 +847,21 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
       }
 
-      /**
-       * @param {object} elementsCsn
-       * @param {object} edmParentCsn
-       * @returns {[object[], any]} Returns a [ [ Edm Properties ], boolean hasStream ]:
-       *                              array of Edm Properties
-       *                              hasStream : value of @Core.MediaType assignment
-       */
-      function createProperties(elementsCsn, edmParentCsn=elementsCsn)
-      {
-        const props = [];
-        let hasStream = false;
-        const streamProps = [];
-
-        elementsCsn.elements && Object.entries(elementsCsn.elements).forEach(([elementName, elementCsn]) =>
-        {
-          if(elementCsn._edmParentCsn == undefined)
-            setProp(elementCsn, '_edmParentCsn', edmParentCsn);
-
-          if(elementCsn.target) {
-              // Foreign keys are part of the generic elementCsn.elements property creation
-
-              // This is the V4 edmx:NavigationProperty
-              // gets rewritten for V2 in addAssociations()
-
-              // suppress navprop creation only if @odata.navigable:false is not annotated.
-              // (undefined !== false) still evaluates to true
-            if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false)
-              {
-              const navProp = new Edm.NavigationProperty(v, {
-                Name: elementName,
-                Type: elementCsn._target.name
-              }, elementCsn);
-              props.push(navProp);
-                // save the navProp in the global array for late constraint building
-              navigationProperties.push(navProp);
-            }
-          }
-            // render ordinary property if element is NOT ...
-            // 1) ... annotated @cds.api.ignore
-            // 2) ... annotated @odata.foreignKey4 and odataFormat: structured
-
-          else if(isEdmPropertyRendered(elementCsn, options))
-            {
-              // 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'
-              streamProps.push(elementName);
-
-            } else {
-              props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
-            }
-          }
-
-        });
-        if(options.isV2()) {
-          if(streamProps.length > 1) { // TODO: why not mention 2.0 in text?
-            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 ];
-      }
-
-      function createComplexType(structuredTypeCsn)
-      {
-        // V4 attributes: Name, BaseType, Abstract, OpenType
-        const attributes = { Name: structuredTypeCsn.name.replace(schemaNamePrefix, '') };
-
-        const complexType = new Edm.ComplexType(v, attributes, structuredTypeCsn);
-        const elementsCsn = structuredTypeCsn.items || structuredTypeCsn;
-        const properties = createProperties(elementsCsn, structuredTypeCsn)[0];
-        const loc = ['definitions', structuredTypeCsn.name];
-
-        if(properties.length === 0) {
-          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._edmAttributes.Name ];
-          edmTypeCompatibilityCheck(p, pLoc);
-          if(p._edmAttributes.Name === complexType._edmAttributes.Name)
-            message('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 && !p._csn.target)
-              message('odata-spec-violation-array', pLoc, { version: '2.0' });
-
-            if(p._csn.target)
-              message('odata-spec-violation-assoc', pLoc, { version: '2.0' });
-          }
-        });
-
-
-        complexType.append(...(properties));
-
-        Schema.append(complexType);
-      }
-
-      // V4 <TypeDefintion>
-      function createTypeDefinition(typeCsn)
-      {
-        // derived types are already resolved to base types
-        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);
-      }
-
       /*
-      * addAssociation() constructs a V2 association.
-      * In V4 all this has been simplified very much, the only thing actually left over is
-      * <ReferentialConstriant> that is then a sub element to <NavigationProperty>.
-      * However, referential constraints are substantially different to its V2 counterpart,
-      * so it is better to reimplement proper V4 construction of<NavigationProperty> in a separate
-      * function.
-      *
-      * This method does:
-      * rewrite <NavigationProperty> attributes to be V2 compliant
-      * add <Association> elements to the schema
-      * add <End>, <ReferentialConstraint>, <Dependent> and <Principal> sub elements to <Association>
-      * add <AssociationSet> to the EntityContainer for each <Association>
+        addAssociation() constructs a V2 association.
+        In V4 all this has been simplified very much, the only thing actually left over is
+        <ReferentialConstriant> that is then a sub element to <NavigationProperty>.
+        However, referential constraints are substantially different to its V2 counterpart,
+        so it is better to reimplement proper V4 construction of<NavigationProperty> in a separate
+        function.
+
+        This method does:
+        rewrite <NavigationProperty> attributes to be V2 compliant
+        add <Association> elements to the schema
+        add <End>, <ReferentialConstraint>, <Dependent> and <Principal> sub elements to <Association>
+        add <AssociationSet> to the EntityContainer for each <Association>
       */
-      function addAssociation(navigationProperty)
+      function addAssociationV2(navigationProperty)
       {
         let constraints = navigationProperty._csn._constraints;
         let parentName = navigationProperty._csn._edmParentCsn.name.replace(schemaNamePrefix, '');
@@ -930,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 => {
@@ -939,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) {