@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/edm/csn2edm.js

@@ -3,8 +3,8 @@
 /* eslint max-lines:off */
 /* eslint max-statements-per-line:off */
 
-let NAVPROP_TRENNER = '_';
-let VALUELIST_NAVPROP_PREFIX = '';
+const NAVPROP_TRENNER = '_';
+const VALUELIST_NAVPROP_PREFIX = '';
 
 const edmUtils = require('./edmUtils.js')
 const { initializeModel } = require('./edmPreprocessor.js');
@@ -25,11 +25,11 @@ function csn2edm(_csn, serviceName, _options) {
 
 function csn2edmAll(_csn, _options, serviceNames=undefined) {
   // get us a fresh model copy that we can work with
-  let csn = cloneCsn(_csn, _options);
+  const csn = cloneCsn(_csn, _options);
 
   // use original options for messages; cloned CSN for semantic location
   const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
-  const { info, warning, error, throwWithError } = messageFunctions;
+  const { info, warning, error, message, throwWithError } = messageFunctions;
   checkCSNVersion(csn, _options);
 
   let rc = Object.create(null);
@@ -42,10 +42,14 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     setProp(csn.meta, 'options', _csn.meta.options);
   }
 
-  let [ allServices, allSchemas, whatsMyServiceRootName, options ] = initializeModel(csn, _options);
+  let [ allServices,
+    allSchemas,
+    whatsMyServiceRootName,
+    options ] = initializeModel(csn, _options, messageFunctions);
+
   const Edm = require('./edm.js')(options, error);
 
-  let v = options.v;
+  const v = options.v;
   if(Object.keys(allServices).length === 0) {
     info(null, null, `No Services in model`);
     return rc;
@@ -222,7 +226,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       }));
     });
     // Create annotations and distribute into Schemas
-    translate.csn2annotationEdm(csn, edm, serviceCsn.name, options);
+    addAnnotations();
     return edm
 
     // Sort definitions into their schema container
@@ -282,8 +286,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       return Object.entries(allSchemas).reduce((references, [fqName, art]) => {
         // add references
-        let mySchemaName = whatsMySchemaName(fqName);
-        if(art.kind === 'reference' && mySchemaName && serviceCsn.name === whatsMyServiceRootName(fqName, false)) {
+        if(art.kind === 'reference' && whatsMySchemaName(fqName) && serviceCsn.name === whatsMyServiceRootName(fqName, false)) {
           fqSchemaXRef.push(fqName);
           references.push(art);
         }
@@ -298,16 +301,17 @@ 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-name', [ 'definitions', schema.name ], { name: schema.name, names: reservedNames },
-            'The EDM namespace $(NAME) must not be one of the reserved values $(NAMES)');
+        warning('odata-spec-violation-namespace',
+                [ 'definitions', schema.name ], { names: reservedNames });
       }
+      /** @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);
       // now namespace and alias are used to create the fullQualified(name)
       const schemaNamePrefix = schema.name + '.'
       const schemaAliasPrefix = schemaNamePrefix;
       const schemaCsn = schema;
-      let navigationProperties = [];
+      const navigationProperties = [];
 
       /* create the entitytypes and sets
         Do not create an entity set if:
@@ -337,7 +341,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       }
 
       // fetch all exising children names in a map
-      let NamesInSchemaXRef = Schema._children.reduce((acc, cur) => {
+      const NamesInSchemaXRef = Schema._children.reduce((acc, cur) => {
         if(acc[cur.Name] === undefined) {
           acc[cur.Name] = [ cur ];
         } else {
@@ -359,8 +363,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       // remove EntityContainer if empty
       if(Schema._ec && Schema._ec._children.length === 0) {
-        let pos = Schema._children.indexOf(Schema._ec);
-        Schema._children.splice(pos, 1);
+        Schema._children.splice(Schema._children.indexOf(Schema._ec), 1);
       }
       if(Schema._children.length === 0) {
         // FIXME: Location for sub schemas?
@@ -369,8 +372,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       Object.entries(NamesInSchemaXRef).forEach(([name, refs]) => {
         if(refs.length > 1) {
-          let artifactName = `${Schema.Namespace}.${name}`;
-          error(null, ['definitions', artifactName], { name: Schema.Namespace },
+          error(null, ['definitions', `${Schema.Namespace}.${name}`], { name: Schema.Namespace },
           'Duplicate name in Schema $(NAME)');
         }
       });
@@ -379,33 +381,33 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       function createEntityTypeAndSet(entityCsn)
       {
-        let EntityTypeName = entityCsn.name.replace(schemaNamePrefix, '');
-        let EntitySetName = edmUtils.getBaseName(entityCsn.$entitySetName || entityCsn.name);
+        const EntityTypeName = entityCsn.name.replace(schemaNamePrefix, '');
+        const EntitySetName = edmUtils.getBaseName(entityCsn.$entitySetName || entityCsn.name);
 
-        let [ properties, hasStream ] = createProperties(entityCsn);
+        const [ properties, hasStream ] = createProperties(entityCsn);
 
         const loc = ['definitions', entityCsn.name];
         const type = `${schema.name}.${EntityTypeName}`;
         if(properties.length === 0) {
           warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no properties');
         } else if(entityCsn.$edmKeyPaths.length === 0) {
-          warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no primary key');
+          message('odata-spec-violation-no-key', loc);
         }
         properties.forEach(p => {
           const pLoc = [...loc, 'elements', p.Name];
           if(!p[p._typeName]) {
-            warning('odata-spec-violation-attribute', pLoc, { name: p.Name, prop: p._typeName });
+            message('odata-spec-violation-type', pLoc);
           }
           if(p.Name === EntityTypeName) {
-            warning('odata-spec-violation-property-name', pLoc, { name: p.Name, type: 'EntityType' });
+            warning('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
           }
           if(options.isV2() && p._isCollection && !edmUtils.isAssociationOrComposition(p._csn)) {
-            warning('odata-spec-violation-array-of-v2', pLoc, { literal: 'Property', prop: 'Type', name: 'Collection' });
+            warning('odata-spec-violation-array', pLoc, { api: 'OData V2' });
           }
         });
 
         // construct EntityType attributes
-        let attributes = { Name : EntityTypeName };
+        const attributes = { Name : EntityTypeName };
 
         // CDXCORE-CDXCORE-173
         if(options.isV2() && hasStream)
@@ -418,7 +420,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           /** @type {object} */
           let containerEntry;
 
-          if(isSingleton(entityCsn)) {
+          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;
@@ -428,18 +430,11 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           }
 
           // V4: Create NavigationPropertyBinding in EntitySet
-          if(options.isV4())
-            properties.filter(np =>
-              np instanceof Edm.NavigationProperty &&
-              // @ts-ignore TypeScript does not recognize these properties on type NavigationProperty
-              !np.isContainment() &&
-              !edmUtils.isContainee(np._targetCsn) &&
-              !np._targetCsn.$proxy &&
-              !np._targetCsn.$externalRef &&
-              !(np._isCollection && isSingleton(np._targetCsn))
-            ). forEach(np =>
-                containerEntry.append(np.createNavigationPropertyBinding(schemaNamePrefix)));
-
+          if(options.isV4()) {
+            entityCsn.$edmNPBs.forEach(npb => {
+              containerEntry.append(new Edm.NavigationPropertyBinding(v, npb))
+            });
+          }
           EntityContainer.register(containerEntry);
         }
 
@@ -448,38 +443,32 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           (options.isV4()) ? createActionV4(a, n, entityCsn)
                           : createActionV2(a, n, entityCsn)
         });
-
-        function isSingleton(entityCsn) {
-          const singleton = entityCsn['@odata.singleton'];
-          const hasNullable = entityCsn['@odata.singleton.nullable'] !== undefined && entityCsn['@odata.singleton.nullable'] !== null;
-          return options.isV4() && singleton || ((singleton === undefined || singleton === null) && hasNullable);
-        }
       }
 
       // add bound/unbound actions/functions for V4
       function createActionV4(actionCsn, name, entityCsn=undefined)
       {
-        let iAmAnAction = actionCsn.kind === 'action';
+        const iAmAnAction = actionCsn.kind === 'action';
 
-        let actionName = edmUtils.getBaseName(actionCsn.name);
+        const actionName = edmUtils.getBaseName(actionCsn.name);
 
-        let attributes = { Name: actionName, IsBound : false };
+        const attributes = { Name: actionName, IsBound : false };
 
         if(!iAmAnAction)
           attributes.IsComposable = false;
 
         /** @type {object} */
-        let actionNode = (iAmAnAction) ? new Edm.Action(v, attributes)
+        const actionNode = (iAmAnAction) ? new Edm.Action(v, attributes)
                                       : new Edm.FunctionDefinition(v, attributes);
 
         // bpName is eventually used later for EntitySetPath
-        let bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
-        let bpName = bpNameAnno !== undefined ? (bpNameAnno['='] || bpNameAnno) : 'in';
+        const bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
+        const bpName = bpNameAnno !== undefined ? (bpNameAnno['='] || bpNameAnno) : 'in';
 
         if(entityCsn != undefined)
         {
           actionNode.IsBound = true;
-          let bpType = fullQualified(entityCsn.name);
+          const bpType = fullQualified(entityCsn.name);
           // Binding Parameter: 'in' at first position in sequence, this is decisive!
           if(actionCsn['@cds.odata.bindingparameter.collection'])
             actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection:true } ));
@@ -489,14 +478,14 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         else if(EntityContainer)// unbound => produce Action/FunctionImport
         {
           /** @type {object} */
-          let actionImport = iAmAnAction
+          const actionImport = iAmAnAction
             ? new Edm.ActionImport(v, { Name: actionName, Action : fullQualified(actionName) })
             : new Edm.FunctionImport(v, { Name: actionName, Function : fullQualified(actionName) });
 
-          let rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
+          const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
           if(rt) // add EntitySet attribute only if return type is a non abstract entity
           {
-            let definition = schemaCsn.definitions[rt];
+            const definition = schemaCsn.definitions[rt];
             if(definition && definition.kind === 'entity' && !definition.abstract)
             {
               actionImport.EntitySet = edmUtils.getBaseName(rt);
@@ -525,7 +514,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       function createActionV2(actionCsn, name, entityCsn=undefined)
       {
         /** @type {object} */
-        let functionImport = new Edm.FunctionImport(v, { Name: name.replace(schemaNamePrefix, '') } );
+        const functionImport = new Edm.FunctionImport(v, { Name: name.replace(schemaNamePrefix, '') } );
 
         // inserted now to maintain attribute order with old odata generator...
         /*
@@ -539,10 +528,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         */
 
         const actLoc = ['definitions', ...(entityCsn ? [entityCsn.name, 'actions', actionCsn.name] : [actionCsn.name])];
-        let rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
+        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
         {
-          let defintion = schemaCsn.definitions[rt];
+          const defintion = schemaCsn.definitions[rt];
           if(defintion && edmUtils.isEntity(defintion))
           {
             functionImport.EntitySet = rt.replace(schemaNamePrefix, '');
@@ -586,10 +575,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const paramLoc = [...actLoc, 'params', parameterName];
           const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
           if(!param._type.startsWith('Edm.') && !edmUtils.isStructuredType(csn.definitions[param._type])) {
-            warning('odata-spec-violation-param-v2', paramLoc);
+            warning('odata-spec-violation-param', paramLoc, { api: 'OData V2' });
           }
           if(param._isCollection) {
-            warning('odata-spec-violation-array-of-v2', paramLoc, { literal: 'FunctionImport Parameter', prop: 'Type', name: 'Collection' });
+            warning('odata-spec-violation-array', paramLoc, { api: 'OData V2' });
           }
           functionImport.append(param);
         });
@@ -600,12 +589,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         function getReturnType(action)
         {
           // it is safe to assume that either type or items.type are set
-          let returns = action.returns.items || action.returns;
+          const returns = action.returns.items || action.returns;
           let type = returns.type;
           if(type){
             if(!isBuiltinType(type) && !['entity', 'view', 'type'].includes(csn.definitions[type].kind)){
               const returnsLoc = [ ...actLoc, 'returns'];
-              warning('odata-spec-violation-returns-v2', returnsLoc);
+              warning('odata-spec-violation-returns', returnsLoc, { kind: action.kind, api: 'OData V2' });
             }
             type = edmUtils.mapCdsToEdmType(returns, messageFunctions, options.isV2());
           }
@@ -618,19 +607,20 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       }
 
       /**
-       * @param {object} parentCsn
+       * @param {object} elementsCsn
+       * @param {object} edmParentCsn
        * @returns {[object[], boolean]} Returns a [ [ Edm Properties ], boolean hasStream ]:
        *                              array of Edm Properties
        *                              boolean hasStream : true if at least one element has @Core.MediaType assignment
        */
-      function createProperties(parentCsn)
+      function createProperties(elementsCsn, edmParentCsn=elementsCsn)
       {
-        let props = [];
+        const props = [];
         let hasStream = false;
-        edmUtils.forAll(parentCsn.elements, (elementCsn, elementName) =>
+        edmUtils.forAll(elementsCsn.elements, (elementCsn, elementName) =>
         {
-          if(elementCsn._parent == undefined)
-            setProp(elementCsn, '_parent', parentCsn);
+          if(elementCsn._edmParentCsn == undefined)
+            setProp(elementCsn, '_edmParentCsn', edmParentCsn);
 
           if(!elementCsn._ignore) {
             if(edmUtils.isAssociationOrComposition(elementCsn))
@@ -644,11 +634,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
               // (undefined !== false) still evaluates to true
               if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false)
               {
-                let navProp = new Edm.NavigationProperty(v, {
+                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);
@@ -667,7 +656,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
                 // V2: don't render element but add attribute 'm:HasStream="true' to EntityType
                 // V4: render property type 'Edm.Stream'
                 hasStream = true;
-                info(null, ['definitions', parentCsn.name], { name: parentCsn.name, id: elementName, anno: '@Core.MediaType' },
+                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');
 
               } else {
@@ -683,11 +672,11 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       function createComplexType(structuredTypeCsn)
       {
         // V4 attributes: Name, BaseType, Abstract, OpenType
-        let attributes = { Name: structuredTypeCsn.name.replace(schemaNamePrefix, '') };
+        const attributes = { Name: structuredTypeCsn.name.replace(schemaNamePrefix, '') };
 
-        let complexType = new Edm.ComplexType(v, attributes, structuredTypeCsn);
-        let elementsCsn = structuredTypeCsn.items || structuredTypeCsn;
-        let properties = createProperties(elementsCsn)[0];
+        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) {
@@ -697,17 +686,17 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         properties.forEach(p => {
           const pLoc = [ ...loc, ...(structuredTypeCsn.items ? ['items', 'elements'] : [ 'elements' ]), p.Name ];
           if(!p[p._typeName]) {
-            warning('odata-spec-violation-attribute', pLoc, { name: p.Name, prop: p._typeName });
+            message('odata-spec-violation-type', pLoc);
           }
           if(p.Name === complexType.Name) {
-            warning('odata-spec-violation-property-name', pLoc, { name: p.Name, type: complexType.kind });
+            warning('odata-spec-violation-property-name', pLoc, { kind: structuredTypeCsn.kind });
           }
           if(options.isV2()) {
             if(p._isCollection && !edmUtils.isAssociationOrComposition(p._csn)) {
-              warning('odata-spec-violation-array-of-v2', pLoc, { literal: 'Property' ,prop: 'Type', name: 'Collection' });
+              warning('odata-spec-violation-array', pLoc, { api: 'OData V2' });
             }
             if(edmUtils.isAssociationOrComposition(p._csn)) {
-              warning('odata-spec-violation-assoc-v2', pLoc, { name: structuredTypeCsn.name });
+              warning('odata-spec-violation-assoc', pLoc, { api: 'OData V2' });
             }
           }
         });
@@ -722,7 +711,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       function createTypeDefinition(typeCsn)
       {
         // derived types are already resolved to base types
-        let props = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
+        const props = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
         const typeDef = new Edm.TypeDefinition(v, props, typeCsn );
         Schema.append(typeDef);
       }
@@ -744,7 +733,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       function addAssociation(navigationProperty)
       {
         let constraints = navigationProperty._csn._constraints;
-        let parentName = navigationProperty._csn._parent.name.replace(schemaNamePrefix, '');
+        let parentName = navigationProperty._csn._edmParentCsn.name.replace(schemaNamePrefix, '');
         let plainAssocName = parentName + NAVPROP_TRENNER + navigationProperty.Name.replace(VALUELIST_NAVPROP_PREFIX, '');
         let assocName = plainAssocName;
         let i = 1;
@@ -760,7 +749,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
         // The entity set name may not be the same as the type name (parameterized entities have
         // differing set names (<T>Parameters => <T>, <T>Type => <T>Set)
-        let fromEntitySet = ( navigationProperty._csn._parent.$entitySetName || fromEntityType).replace(schemaNamePrefix, '');
+        let fromEntitySet = ( navigationProperty._csn._edmParentCsn.$entitySetName || fromEntityType).replace(schemaNamePrefix, '');
         let toEntitySet = (navigationProperty._targetCsn.$entitySetName || toEntityType).replace(schemaNamePrefix, '');
 
         // from and to roles must be distinguishable (in case of self association entity E { toE: association to E; ... })
@@ -802,7 +791,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           [ fromEntityType, toEntityType ] = [ toEntityType, fromEntityType ];
           [ fromEntitySet, toEntitySet ] = [ toEntitySet, fromEntitySet ];
 
-          parentName = forwardAssocCsn._parent.name.replace(schemaNamePrefix, '');
+          parentName = forwardAssocCsn._edmParentCsn.name.replace(schemaNamePrefix, '');
           assocName = plainAssocName = parentName + NAVPROP_TRENNER + forwardAssocCsn.name.replace(VALUELIST_NAVPROP_PREFIX, '');
           i = 1;
           while(NamesInSchemaXRef[assocName] !== undefined && !(NamesInSchemaXRef[assocName][0] instanceof Edm.Association)) {
@@ -817,56 +806,37 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         if(reuseAssoc)
-        {
-          // Example:
-          // entity E { key id: Integer; toF: association to F; };
-          // entity F { key id: Integer; toE: composition of E on toE.toF = $self; };
-          //
-          // Consider we're in NavigationProperty 'toE' which is the backlink to F.
-          // Then forwardAssocCsn is 'E_toF' with two Ends: E, F.
-          // Backlink F.toE is a composition, making E existentially dependant on F.
-          // So End E of Association E_toF (which is End[0]) receives Edm.OnDelete.
-          // Depending on the order of the navigation properties it might be that the
-          // forward Edm.Association has not yet been produced. In this case Edm.OnDelete
-          // is parked at the forward NavigationProperty.
-
-          if(!forwardAssocCsn._NavigationProperty._edmAssociation && navigationProperty._csn.type === 'cds.Composition')
-          {
-            // TODO: to be specified via @sap.on.delete
-            forwardAssocCsn._NavigationProperty.set( { _OnDelete: new Edm.OnDelete(v, { Action: 'Cascade' }) } );
-          }
           return;
-        }
 
         // Create Association and AssociationSet if this is not a backlink association.
         // Store association at navigation property because in case the Ends must be modified
         // later by the partner (backlink) association
-        navigationProperty._edmAssociation = new Edm.Association(v, { Name: assocName }, navigationProperty,
+        const edmAssociation = new Edm.Association(v, { Name: assocName }, navigationProperty,
                                         [ fromRole, fullQualified(fromEntityType) ],
                                         [ toRole, fullQualified(toEntityType) ],
                                         constraints._multiplicity );
         if(NamesInSchemaXRef[assocName] === undefined) {
-          NamesInSchemaXRef[assocName] = [ navigationProperty._edmAssociation ];
+          NamesInSchemaXRef[assocName] = [ edmAssociation ];
         }
         else {
-          navigationProperty._edmAssociation.push(navigationProperty._edmAssociation);
+          NamesInSchemaXRef[assocName].push(edmAssociation);
         }
         // Add ReferentialConstraints if any
         if(!navigationProperty._isCollection && Object.keys(constraints.constraints).length > 0) {
           // A managed composition is treated as association
           if(navigationProperty._csn.type === 'cds.Composition' && navigationProperty._csn.on) {
-            navigationProperty._edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
+            edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
               toRole, fromRole, constraints.constraints));
           }
           else {
-            navigationProperty._edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
+            edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
               fromRole, toRole, constraints.constraints));
           }
         }
 
-        Schema.append(navigationProperty._edmAssociation);
+        Schema.append(edmAssociation);
         if(EntityContainer && !navigationProperty._targetCsn.$proxy) {
-          let assocSet =  new Edm.AssociationSet(v, { Name: assocName, Association: fullQualified(assocName) },
+          const assocSet =  new Edm.AssociationSet(v, { Name: assocName, Association: fullQualified(assocName) },
             fromRole, toRole, fromEntitySet, toEntitySet);
           if(navigationProperty._csn._SetAttributes)
             assocSet.setSapVocabularyAsAttributes(navigationProperty._csn._SetAttributes);
@@ -880,6 +850,32 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         return schemaAliasPrefix + name.replace(schemaNamePrefix, '')
       }
     }
+
+    // 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);
+      // distribute edm:Annotations into the schemas
+      // Distribute each anno into Schema
+      annos.forEach(anno => {
+        let targetSchema = whatsMySchemaName(anno.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 + '.', '');
+          }
+          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);
+      })
+    }
   }
 }
 module.exports = { csn2edm, csn2edmAll };

package/lib/edm/edm.js

@@ -288,7 +288,8 @@ module.exports = function (options, error) {
         });
         let json_Annotations = Object.create(null);
         this._annotations.filter(a => a.Target).forEach(a => json_Annotations[a.Target] = a.toJSON());
-        json['$Annotations'] = json_Annotations;
+        if(Object.keys(json_Annotations).length)
+          json['$Annotations'] = json_Annotations;
       }
       edmUtils.forAll(this._actions, (actionArray, actionName) => {
         json[actionName] = [];
@@ -610,7 +611,12 @@ module.exports = function (options, error) {
           if(scalarType) {
             this[typeName] = csn._edmType;
             // CDXCORE-CDXCORE-173 ignore type facets for Edm.Stream
-            if(this[typeName] !== 'Edm.Stream')
+            // cds-compiler/issues/7835: Only set length for Binary as long as it is
+            // unclear how many bytes a string character represents.
+            // We can't calculate an unambiguous byte stream length for DB dependent
+            // multi-byte characters.
+            if(!(this[typeName] === 'Edm.Stream' &&
+               ![ /*'cds.String',*/ 'cds.Binary'].includes(scalarType.type)))
               edmUtils.addTypeFacets(this, scalarType);
           }
           else {
@@ -996,9 +1002,11 @@ module.exports = function (options, error) {
           // values are !null (with other words: a collection must never return [1,2,null,3])
           delete this.Nullable;
         }
-        let partner = (csn._selfReferences.length > 0) ? csn._selfReferences[0] : csn._constraints._partnerCsn;
+        // we have exactly one selfReference or the default partner
+        let partner = (!csn.$noPartner && csn._selfReferences.length === 1) ? csn._selfReferences[0] : csn._constraints._partnerCsn;
         if(partner && partner['@odata.navigable'] !== false) {
-          this.Partner = partner.name;
+          // $abspath[0] is main entity
+          this.Partner = partner.$abspath.slice(1).join(options.pathDelimiter);
         }
 
         /*
@@ -1084,13 +1092,6 @@ module.exports = function (options, error) {
       return json;
     }
 
-    createNavigationPropertyBinding(namespace)
-    {
-      return new NavigationPropertyBinding(this._v,
-        { Path: this.Name, Target: this._csn._target.name.replace(namespace, '') }
-      );
-    }
-
     // V4 referential constraints!
     addReferentialConstraintNodes()
     {
@@ -1486,17 +1487,13 @@ module.exports = function (options, error) {
         new End(v, { Role: fromRole[0], Type: fromRole[1], Multiplicity: multiplicity[0] } ),
         new End(v, { Role: toRole[0], Type: toRole[1], Multiplicity: multiplicity[1] } ) );
 
-      // if eventually a backlink is a composition and this (Forward-)Association has not yet been
-      // produced, add the OnDelete property now to the target end.
-      // undefined values are not appended
-      if(navProp._OnDelete)
-        this._end[1].append(navProp._OnDelete);
+      // set Delete:Cascade on composition end
+      if(navProp._csn.type === 'cds.Composition')
+        this._end[0].append(new OnDelete(v, { Action: 'Cascade' }));
 
-      // if the NavProp is a composition, add the OnDelete to the source end
-      if(navProp._csn.type === 'cds.Composition') {
-        // TODO: to be specified via @sap.on.delete
-        this._end[0].append(new OnDelete(v, { Action: 'Cascade' } ) );
-      }
+      if(navProp._csn._selfReferences && navProp._csn._selfReferences.length &&
+         navProp._csn._selfReferences[0].type === 'cds.Composition')
+        this._end[1].append(new OnDelete(v, { Action: 'Cascade' }));
     }
 
     innerXML(indent)