@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/compiler/shared.js

@@ -5,6 +5,7 @@
 
 const { searchName } = require('../base/messages');
 const { dictAddArray } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/model');
 
 const {
   setLink,
@@ -144,6 +145,13 @@ function fns( model ) {
     rewrite: {
       next: '_$next', dollar: true, escape: 'param', noDep: true, rewrite: true,
     }, // TODO: assertion that there is no next/escape used
+    'order-by': {
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      assoc: 'nav',
+      deprecatedSourceRefs: true,
+    },
     'order-by-union': {
       next: '_$next', dollar: true, escape: 'param', noDep: true, noExt: true,
     },
@@ -160,6 +168,7 @@ function fns( model ) {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
     resolvePath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
   } );
@@ -602,6 +611,21 @@ function fns( model ) {
       else if (r) {
         return setArtifactLink( head, r );
       }
+      else if (spec.deprecatedSourceRefs && env._combined &&
+               isDeprecatedEnabled( options, 'autoCorrectOrderBySourceRefs' )) {
+        // User has provided a source element without table alias where a query
+        // element is expected.  Possible on many DBs (and compiler v1), in CAP
+        // only with table alias.  Auto-correct it if no duplicate.
+        // TODO: we could use that info also in messages when the deprecated flag is not set
+        const s = env._combined[head.id];
+        if (s && !Array.isArray(s)) {
+          path.$prefix = s.name.alias; // pushing it to path directly could be problematic
+          warning( null, [ head.location, user ],
+                   { id: head.id, newcode: `${ s.name.alias }.${ head.id }` },
+                   'Replace source element reference $(ID) by $(NEWCODE); auto-corrected' );
+          return setArtifactLink( head, s );
+        }
+      }
     }
     if (spec.noMessage || msgArt === true && extDict === model.definitions)
       return null;
@@ -861,29 +885,41 @@ function fns( model ) {
     }
   }
 
+  // Issue messages for annotations on namespaces and builtins
+  // (TODO: really here?, probably split main artifacts vs returns)
+  // see also lateExtensions() where similar messages are reported
+  function checkAnnotate( construct, art ) {
+    // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
+    // they can still be applied. Namespace annotations are extracted in to-csn.js
+    // In parseCdl mode USINGs and other unknown references are generated as
+    // namespaces which would lead to false positives.
+    // TODO: should this really be different to annotate-unknown?
+    if (art.kind === 'namespace') {
+      info( 'anno-namespace', [ construct.name.location, construct ], {},
+            'Namespaces can\'t be annotated' );
+    }
+    // Builtin annotations would also get lost. Same as for namespaces:
+    // extracted in to-csn.js
+    else if (art.builtin === true) {
+      info( 'anno-builtin', [ construct.name.location, construct ], {},
+            'Builtin types should not be annotated. Use custom type instead' );
+    }
+    else if (construct.$syntax === 'returns' && art._block && art.kind !== 'action' &&
+             art.kind !== 'function' ) {
+      // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
+      // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
+      // `art._block` ensures that `art` is a defined def.
+      warning('anno-unexpected-returns', [ construct.name.location, construct ],
+              { keyword: 'returns', kind: art.kind }, 'Unexpected $(KEYWORD) for $(KIND)');
+    }
+  }
+
   // Set _block links for annotations (necessary for layering).
-  // Issue messages for annotations on namespaces and builtins (TODO: really here?)
   // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
   function defineAnnotations( construct, art, block, priority = false ) {
-    if (!options.parseCdl && construct.kind === 'annotate') {
-      // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
-      // they can still be applied. Namespace annotations are extracted in to-csn.js
-      // In parseCdl mode USINGs and other unknown references are generated as
-      // namespaces which would lead to false positives.
-      // TODO: should this really be different to annotate-unknown?
-      if (art.kind === 'namespace') {
-        info( 'anno-namespace', [ construct.name.location, construct ], {},
-              'Namespaces can\'t be annotated' );
-      }
-      // Builtin annotations would also get lost. Same as for namespaces:
-      // extracted in to-csn.js
-      else if (art.builtin === true) {
-        info( 'anno-builtin', [ construct.name.location, construct ], {},
-              'Builtin types should not be annotated. Use custom type instead' );
-      }
-    }
     if (construct.doc)
       art.doc = construct.doc; // e.g. through `extensions` array in CSN
+
     // set _block (for layering) and $priority, shallow-copy from extension
     // TODO: think of removing $priority, then
     // no _block: define, _block: annotate/extend/edmx

package/lib/compiler/tweak-assocs.js

@@ -3,7 +3,6 @@
 'use strict';
 
 const {
-  isDeprecatedEnabled,
   forEachDefinition,
   forEachGeneric,
   forEachInOrder,
@@ -26,7 +25,6 @@ const $location = Symbol.for('cds.$location');
 
 // Export function of this file.
 function tweakAssocs( model ) {
-  const { options } = model;
   // Get shared functionality and the message function:
   const {
     info, warning, error,
@@ -38,11 +36,6 @@ function tweakAssocs( model ) {
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
-
   // Phase 5: rewrite associations
   forEachDefinition( model, rewriteSimple );
   // TODO: sequence not good enough with derived type of structure with
@@ -113,7 +106,7 @@ function tweakAssocs( model ) {
 
   function rewriteAssociationCheck( element ) {
     const elem = element.items || element; // TODO v2: nested items
-    if (elem.elements && enableExpandElements)
+    if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
       return;
@@ -207,7 +200,7 @@ function tweakAssocs( model ) {
 
   function rewriteAssociation( element ) {
     let elem = element.items || element; // TODO v2: nested items
-    if (elem.elements && enableExpandElements)
+    if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
       return;
@@ -286,7 +279,7 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
-    if (enableExpandElements && elem._parent && elem._parent.kind === 'element') {
+    if (elem._parent && elem._parent.kind === 'element') {
       // managed association as sub element not supported yet
       error( null, [ elem.location, elem ], {},
         // eslint-disable-next-line max-len
@@ -369,7 +362,8 @@ function tweakAssocs( model ) {
       const item = expr.path[root.kind === '$self' ? 1 : 0];
       if (!item)
         return;                                   // just $self
-      const elem = assoc._main.elements[item.id]; // corresponding elem in including structure
+      // corresponding elem in including structure
+      const elem = (assoc._main.items || assoc._main).elements[item.id];
       if (!(Array.isArray(elem) ||              // no msg for redefs
             elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {

package/lib/compiler/utils.js

@@ -95,6 +95,14 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
+/**
+ * Set the member `elem` to have a _parent link to `parent` and a corresponding
+ * _main link.  Also set the member's name accordingly, where argument `name`
+ * is most often the property `elem.name.id`.
+ *
+ * If argument `prop` is provided, add `elem` to the dictionary of that name,
+ * e.g. `elements`.
+*/
 function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
     // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
@@ -107,9 +115,10 @@ function setMemberParent( elem, name, parent, prop ) {
     parent = parent._outer;
   setLink( elem, '_parent', parent );
   setLink( elem, '_main', parent._main || parent );
-  const parentName = parent.name || parent._outer.name;
-  elem.name.absolute = parentName.absolute;
-  if (name == null)
+  const parentName = parent.name || parent._outer?.name;
+  if (parentName) // may not be available in e.g. cast() - TODO recheck (#9503)
+    elem.name.absolute = parentName.absolute;
+  if (!parentName || name == null)
     return;
   const normalized = kindProperties[elem.kind].normalized || elem.kind;
   [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
@@ -188,8 +197,8 @@ function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = fa
  *
  * @param {XSN.Path} path
  */
-function pathName(path) {
-  return (path.broken) ? '' : path.map( id => id.id ).join('.');
+function pathName( path ) {
+  return (path && !path.broken) ? path.map( id => id.id ).join('.') : '';
 }
 
 /**
@@ -357,7 +366,7 @@ function traverseQueryExtra( main, callback ) {
 //             that value is only on elements, types, and params -> no other members
 //             when set, only on elem/art with expanded elements
 // - 'target': all expanded (sub) elements might only have new target/on, but
-//             no indivual annotations on any (sub) member
+//             no individual annotations on any (sub) member
 //             when set, traverse all parents where the value has been 'origin' before
 // - 'annotate': at least one inferred (sub) member has an individual annotation,
 //               not counting propagated ones; set up to the definition (main artifact)

package/lib/edm/annotations/genericTranslation.js

@@ -401,8 +401,6 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       params.push(action['@cds.odata.bindingparameter.collection'] ? 'Collection(' + bindingParam + ')' : bindingParam);
     }
     if (action.kind === 'function') {
-      let mapType = (p) => (isBuiltinType(p.type)) ?
-        edmUtils.mapCdsToEdmType(p, messageFunctions, false /*is only called for v4*/) : p.type;
       if(action.params) {
         action.params && Object.values(action.params).forEach(p => {
           let isArrayType = !p.type && p.items && p.items.type;
@@ -411,6 +409,18 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       }
     }
     return '(' + params.join(',') + ')';
+
+    function mapType(p) {
+      if(isBuiltinType(p.type))
+        return edmUtils.mapCdsToEdmType(p, messageFunctions, false /*is only called for v4*/)
+      else if(options.whatsMySchemaName) {
+        const schemaName = options.whatsMySchemaName(p.type);
+        // strip the service namespace of from a parameter type
+        if(schemaName && schemaName !== options.serviceName)
+          return p.type.replace(options.serviceName + '.', '');
+      }
+      return p.type;
+    }
   }
 
 

package/lib/edm/annotations/preprocessAnnotations.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const edmUtils = require('../edmUtils.js');
 const { makeMessageFunction } = require('../../base/messages.js');
+const { forEachDefinition } = require('../../model/csnUtils.js');
 
 
 /**************************************************************************************************
@@ -37,15 +37,14 @@ function preprocessAnnotations(csn, serviceName, options) {
     let targetName = (typeof assoc.target === 'object') ? assoc.target.name : assoc.target;
     let target     = (typeof assoc.target === 'object') ? assoc.target      : csn.definitions[assoc.target];
 
-    let keyNames = Object.keys(target.elements).filter(x => target.elements[x].key);
+    let keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
       warning(null, null, `in annotation preprocessing: target ${targetName} has no key`);
     }
     else if (keyNames.length > 1)
       warning(null, null, `in annotation preprocessing: target ${targetName} has multiple key elements`);
-
-    // TODO: what happens if key of target is itself a managed association?
+    
     return keyNames[0];
   }
 
@@ -58,15 +57,15 @@ function preprocessAnnotations(csn, serviceName, options) {
   function resolveShortcuts() {
     let art = null;
 
-    edmUtils.forAll(csn.definitions, (artifact, artifactName) => {
-      if(artifactName == serviceName || artifactName.startsWith(serviceName + '.')) {
+    forEachDefinition(csn, (artifact, artifactName) => {
+      if(artifactName === serviceName || artifactName.startsWith(serviceName + '.')) {
         art = artifactName;
         handleAnnotations(artifactName, artifact);
-        edmUtils.forAll(artifact.elements, (element, elementName) => {
+        artifact.elements && Object.entries(artifact.elements).forEach(([elementName, element]) => {
           handleAnnotations(elementName, element);
         });
-        edmUtils.forAll(artifact.actions, (action) => {
-          edmUtils.forAll(action.params, (param, paramName) => {
+        artifact.actions && Object.values(artifact.actions).forEach(action => {
+          action.params && Object.entries(action.params).forEach(([paramName, param]) => {
             handleAnnotations(paramName, param);
           });
         });
@@ -155,7 +154,7 @@ function preprocessAnnotations(csn, serviceName, options) {
                 return false;
               }
               let assoc = csn.definitions[art].elements[assocName];
-              if (!assoc || !(assoc.type === 'cds.Association' || assoc.type === 'cds.Composition')) {
+              if (!assoc || !assoc.target) {
                 warning(null, null, `in annotation preprocessing/${aNameWithoutQualifier}: there is no association "${assocName}", ${ctx}`);
                 return false;
               }
@@ -165,7 +164,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             }
             else if (aNameWithoutQualifier === '@Common.ValueList.entity') {
               // if both annotations are present, ignore 'entity' and raise a message
-              if (annoNames.map(x=>x.split('#')[0]).find(x=>(x=='@Common.ValueList.viaAssociation'))) {
+              if (annoNames.map(x=>x.split('#')[0]).find(x=>(x==='@Common.ValueList.viaAssociation'))) {
                 warning(null, null, `in annotation preprocessing/@Common.ValueList: 'entity' is ignored, as 'viaAssociation' is present, ${ctx}`);
                 return false;
               }
@@ -196,7 +195,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             //   name of the element carrying the value help annotation
             //   if this is a managed assoc, use fk field instead (if there is a single one)
             let localDataProp = carrierName.split('/').pop();
-            if (edmUtils.isManagedAssociation(carrier)) {
+            if (carrier.target && carrier.on === undefined) {
               localDataProp = localDataProp + fkSeparator + getKeyOfTargetOfManagedAssoc(carrier);
             }
 
@@ -212,7 +211,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             // valueListProp: the (single) key field of the value list entity
             //   if no key or multiple keys -> warning
             let valueListProp = null;
-            let keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key );
+            let keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target );
             if (keys.length === 0) {
               warning(null, null, `in annotation preprocessing/value help shortcut: entity "${enameFull}" has no key, ${ctx}`);
               return false;
@@ -297,8 +296,12 @@ function preprocessAnnotations(csn, serviceName, options) {
 
           //change the scalar anno into a "pseudo-structured" one
           // TODO should be flattened, but then alphabetical order is destroyed
-          let newTextAnno = { '$value': textAnno, '@UI.TextArrangement': value };
-          carrier['@Common.Text'] = newTextAnno;
+
+          // Do not overwrite existing nested annotation values, instead give existing
+          // nested annotation precedence and remove outer annotation (always)
+          if(!carrier['@Common.Text.@UI.TextArrangement'] && textAnno) {
+            carrier['@Common.Text'] = { '$value': textAnno, '@UI.TextArrangement': value };
+          }
           delete carrier[aName];
         }
       }

package/lib/edm/csn2edm.js

@@ -7,7 +7,7 @@ const NAVPROP_TRENNER = '_';
 const VALUELIST_NAVPROP_PREFIX = '';
 
 const edmUtils = require('./edmUtils.js')
-const { initializeModel, assignAnnotation } = require('./edmPreprocessor.js');
+const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp } = require('../base/model');
 const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
@@ -326,15 +326,16 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       /* create the entitytypes and sets
         Do not create an entity set if:
-            V4 containment: _containerEntity is set and not equal with the artifact name
+            V4 containment: $containerNames is set and not equal with the artifact name
             Entity starts with 'localserviceNameized.' or ends with '_localized'
       */
       edmUtils.foreach(schemaCsn.definitions,
-        a => edmUtils.isEntity(a) && !a.abstract && a.name.startsWith(schemaNamePrefix),
+        a => a.kind === 'entity' && !a.abstract && a.name.startsWith(schemaNamePrefix),
         createEntityTypeAndSet
       );
       // create unbound actions/functions
-      edmUtils.foreach(schemaCsn.definitions, a => edmUtils.isActionOrFunction(a) && a.name.startsWith(schemaNamePrefix),
+      edmUtils.foreach(schemaCsn.definitions, 
+        a => (a.kind === 'action' || a.kind === 'function') && a.name.startsWith(schemaNamePrefix),
         (options.isV4()) ? createActionV4 : createActionV2);
 
     // create the complex types
@@ -346,7 +347,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       {
         edmUtils.foreach(schemaCsn.definitions,
         artifact => edmUtils.isDerivedType(artifact) &&
-        !edmUtils.isAssociationOrComposition(artifact) &&
+        !artifact.target &&
         artifact.name.startsWith(schemaNamePrefix),
           createTypeDefinition);
       }
@@ -414,7 +415,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           if(p._edmAttributes.Name === EntityTypeName)
             warning('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
 
-          if(options.isV2() && p._isCollection && !edmUtils.isAssociationOrComposition(p._csn))
+          if(options.isV2() && p._isCollection && !p._csn.target)
             warning('odata-spec-violation-array', pLoc, { version: '2.0' });
 
           if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
@@ -432,7 +433,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // CDXCORE-CDXCORE-173
         if(options.isV2() && hasStream) {
           attributes['m:HasStream'] = true;
-          assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
+          edmUtils.assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
         }
 
         Schema.append(new Edm.EntityType(v, attributes, properties, entityCsn));
@@ -461,7 +462,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // put actions behind entity types in Schema/EntityContainer
-        edmUtils.forAll(entityCsn.actions, (a, n) => {
+        entityCsn.actions && Object.entries(entityCsn.actions).forEach(([ n, a ]) => {
           (options.isV4()) ? createActionV4(a, n, entityCsn)
                           : createActionV2(a, n, entityCsn)
         });
@@ -522,7 +523,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // Parameter Nodes
-        edmUtils.forAll(actionCsn.params, (parameterCsn, parameterName) => {
+        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
           const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
           const pLoc = [ ...loc, 'params', p._edmAttributes.Name ];
           if(!edmUtils.isODataSimpleIdentifier(parameterName))
@@ -573,7 +574,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         if(rt) // add EntitySet attribute only if return type is an entity
         {
           const defintion = schemaCsn.definitions[rt];
-          if(defintion && edmUtils.isEntity(defintion))
+          if(defintion && defintion.kind === 'entity')
           {
             functionImport.setEdmAttribute('EntitySet', rt.replace(schemaNamePrefix, ''));
           }
@@ -597,7 +598,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           // 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
           edmUtils.foreach(entityCsn.elements,
-            elementCsn => elementCsn.key && !edmUtils.isAssociationOrComposition(elementCsn),
+            elementCsn => elementCsn.key && !elementCsn.target,
             (elementCsn, elementName) => {
               functionImport.append(new Edm.Parameter(v, { Name: elementName }, elementCsn, 'In' ));
             }
@@ -605,7 +606,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         }
 
         // is this still required?
-        edmUtils.forAll(actionCsn, (v, p) => {
+        Object.entries(actionCsn).forEach(([p, v]) => {
           if (p.match(/^@sap\./))
             functionImport.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v });
         });
@@ -613,7 +614,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // V2 XML: Parameters that are not explicitly marked as Nullable or NotNullable in the CSN must become Nullable=true
         // 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) => {
+        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
           const pLoc = [...loc, 'params', parameterName];
           const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
           edmTypeCompatibilityCheck(param, pLoc);
@@ -683,12 +684,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         let hasStream = false;
         const streamProps = [];
 
-        edmUtils.forAll(elementsCsn.elements, (elementCsn, elementName) =>
+        elementsCsn.elements && Object.entries(elementsCsn.elements).forEach(([elementName, elementCsn]) =>
         {
           if(elementCsn._edmParentCsn == undefined)
             setProp(elementCsn, '_edmParentCsn', edmParentCsn);
 
-          if(edmUtils.isAssociationOrComposition(elementCsn)) {
+          if(elementCsn.target) {
               // Foreign keys are part of the generic elementCsn.elements property creation
 
               // This is the V4 edmx:NavigationProperty
@@ -769,10 +770,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
 
           if(options.isV2()) {
-            if(p._isCollection && !edmUtils.isAssociationOrComposition(p._csn))
+            if(p._isCollection && !p._csn.target)
               warning('odata-spec-violation-array', pLoc, { version: '2.0' });
 
-            if(edmUtils.isAssociationOrComposition(p._csn))
+            if(p._csn.target)
               warning('odata-spec-violation-assoc', pLoc, { version: '2.0' });
           }
         });

package/lib/edm/edm.js

@@ -3,6 +3,7 @@
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
 const { forEach } = require("../utils/objectUtils");
+const { isBetaEnabled } = require('../base/model.js');
 
 // facet definitions, optional could either be true or array of edm types
 // remove indicates wether or not the canonic facet shall be removed when applying @odata.Type
@@ -239,7 +240,7 @@ function getEdm(options, messageFunctions) {
       if(csn)
       {
         const attr = (useSetAttributes ? csn._SetAttributes : csn);
-        edmUtils.forAll(attr, (v, p) => {
+        attr && Object.entries(attr).forEach(([p, v]) => {
           if (p.match(/^@sap./))
             this.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v } );
         });
@@ -332,7 +333,7 @@ function getEdm(options, messageFunctions) {
       if(what==='metadata' || what==='all')
       {
         xml += super.innerXML(indent);
-        edmUtils.forAll(this._actions, actionArray => {
+        this._actions && Object.values(this._actions).forEach(actionArray => {
           actionArray.forEach(action => {
             xml += action.toXML(indent, what) + '\n'; });
         });
@@ -350,7 +351,7 @@ function getEdm(options, messageFunctions) {
     // no $Namespace
     toJSONattributes(json)
     {
-      edmUtils.forAll(this._edmAttributes, (v,p) => {
+      this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
         if (p !== 'Name' && p !== 'Namespace')
           json[p[0] === '@' ? p : '$' + p] = v;
       });
@@ -371,7 +372,7 @@ function getEdm(options, messageFunctions) {
         if(Object.keys(json_Annotations).length)
           json['$Annotations'] = json_Annotations;
       }
-      edmUtils.forAll(this._actions, (actionArray, actionName) => {
+      this._actions && Object.entries(this._actions).forEach(([actionName, actionArray]) => {
         json[actionName] = [];
         actionArray.forEach(action => {
           json[actionName].push(action.toJSON());
@@ -737,7 +738,7 @@ function getEdm(options, messageFunctions) {
       if(this._type !== 'Edm.String' && this._type)   // Edm.String is default)
         json['$'+this._typeName] = this._type;
 
-      edmUtils.forAll(this._edmAttributes, (v,p) => {
+      this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
         if (p !== 'Name' && p !== this._typeName
           // remove this line if Nullable=true becomes default
           && !(p === 'Nullable' && v == false))
@@ -754,7 +755,14 @@ function getEdm(options, messageFunctions) {
     }
   }
 
-  class ComplexType extends TypeBase { }
+  class ComplexType extends TypeBase { 
+    constructor(v, details, csn) {
+      super(v, details, csn);
+      if(this.v4 && !!csn['@open'] && isBetaEnabled(options, 'odataOpenType')) {
+        this._edmAttributes['OpenType'] = true;
+      }
+    }
+  }
   class EntityType extends ComplexType
   {
     constructor(v, details, properties, csn)
@@ -840,8 +848,8 @@ function getEdm(options, messageFunctions) {
       super(v, attributes, csn);
 
       // array of enum not yet allowed
-      let enumValues = /*(csn.items && csn.items.enum) ||*/ csn.enum;
-      edmUtils.forAll(enumValues, (e, en) =>  {
+      const enumValues = /*(csn.items && csn.items.enum) ||*/ csn.enum;
+      enumValues && Object.entries(enumValues).forEach(([en, e]) =>  {
         this.append(new Member(v, { Name: en, Value: e.val } ));
       });
     }
@@ -1177,9 +1185,10 @@ function getEdm(options, messageFunctions) {
         _constraints = this._csn._constraints._partnerCsn._constraints;
         [i,j] = [1,0];
       }
-      edmUtils.forAll(_constraints.constraints,
-        c => this.append(new ReferentialConstraint(this._v,
-        { Property: c[i].join(options.pathDelimiter), ReferencedProperty: c[j].join(options.pathDelimiter) } ) ) );
+      _constraints.constraints && Object.values(_constraints.constraints).forEach(c =>
+        this.append(new ReferentialConstraint(this._v,
+          { Property: c[i].join(options.pathDelimiter), ReferencedProperty: c[j].join(options.pathDelimiter) } ) )
+      );
     }
   }
 
@@ -1502,7 +1511,7 @@ function getEdm(options, messageFunctions) {
     }
     toJSONattributes(json) {
       super.toJSONattributes(json);
-      edmUtils.forAll(this._jsonOnlyAttributes, (v,p) => {
+      this._jsonOnlyAttributes && Object.entries(this._jsonOnlyAttributes).forEach(([p, v]) => {
         json[p[0] === '@' ? p : '$' + p] = v;
       });
       return json;
@@ -1606,7 +1615,7 @@ function getEdm(options, messageFunctions) {
       node._d = new Dependent(v, { Role: from } );
       node._p = new Principal(v, { Role: to } );
 
-      edmUtils.forAll(c, cv => {
+      c && Object.values(c).forEach(cv => {
         node._d.append(new PropertyRef(v, cv[0].join(options.pathDelimiter)));
         node._p.append(new PropertyRef(v, cv[1].join(options.pathDelimiter)));
       });