@sap/cds-compiler 3.0.0 → 3.0.2

package/lib/base/messages.js

@@ -435,7 +435,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
       // CSN.Location (with line/endLine, col/endCol)
       return [ location, location.home || null, null ]
 
-    const isCsnPath = (typeof location[0] === 'string');
+    const isCsnPath = (typeof location[0] === 'string'); // could be `definitions`, `extensions`, ....
     if (isCsnPath) {
       return [
         searchForLocation( model, location ),
@@ -1174,7 +1174,7 @@ function homeName( art, absoluteOnly ) {
     return null;
   else if (art.kind === 'using')
     return 'using:' + quoted( art.name.id );
-  else if (art.kind === 'extend')
+  else if (art.kind === 'extend' || art.kind === 'annotate')
     return !absoluteOnly && homeNameForExtend ( art );
   else if (art.name._artifact)             // block, extend, annotate
     return homeName( art.name._artifact, absoluteOnly ); // use corresponding definition
@@ -1189,35 +1189,41 @@ function homeName( art, absoluteOnly ) {
 // The "home" for extensions is handled differently because `_artifact` is not
 // set for unknown extensions and we could have nested extensions.
 function homeNameForExtend( art ) {
+  const kind = art.kind || 'extend';
   // TODO: fix the following - do like in collectArtifactExtensions() or
-  // basically resolveUncheckedPath()
-  const absoluteName = (art.name.id ? art.name.id :
-      art.name.path.map(s => s && s.id).join('.'));
+  //       basically resolveUncheckedPath()
+  const absoluteName = art.name.id ? art.name.id :
+    (!art.name.element && art.name.absolute ||  art.name.path.map(s => s && s.id).join('.'));
 
   // Surrounding parent may be another extension.
   const parent = art._parent;
   if (!parent)
-    return 'extend:' + quoted(absoluteName);
-
-  // And that extension's artifact could have been found.
-  const parentArt = parent.name && parent.name._artifact;
-  if (!parentArt)
-    return artName(parent) + '/' + quoted(absoluteName);
-
-  let extensionName;
-  if (parentArt.enum || parentArt.elements) {
-    const fakeArt = {
-      kind: parentArt.enum ? 'enum' : 'element',
-      name: { element: absoluteName }
-    };
-    extensionName = artName(fakeArt);
+    return kind + ':' + quoted(absoluteName);
+
+  if (art.name.param && parent.params) {
+    const fakeArt = { kind: 'param', name: { param: absoluteName } };
+    return homeNameForExtend(parent) + '/' + artName(fakeArt);
   }
-  else {
-    extensionName = 'extend:' + quoted(absoluteName);
+  else if (art.name.action && parent.actions) {
+    const type = art.name._artifact?.kind || 'action';
+    const fakeArt = { kind: type, name: { action: absoluteName }, _main: art.name._artifact?._main };
+    return homeNameForExtend(parent) + '/' + artName(fakeArt);
+  }
+  else if (parent.enum || parent.elements || parent.returns?.elements) {
+    // For enum, extensions may store them in `elements`, i.e. don't differ between enum/elements,
+    // so we need to look at the parent artifact.
+    // For `extend <art> with enum`, there is `enum`.
+    const parentArt = parent.name?._artifact;
+    const fakeKind = (parent.enum || parentArt?.enum) ? 'enum' : 'element';
+    const fakeArt = { kind: fakeKind, name: { element: art.name.element } };
+    let parentOfElementChain = parent;
+    while (parentOfElementChain.name?.element && parentOfElementChain._parent)
+      parentOfElementChain = parentOfElementChain._parent;
+
+    return homeNameForExtend(parentOfElementChain) + '/' + artName(fakeArt);
   }
-  // Even though the parent artifact was found, we use kind 'extend'
-  // to make it clear that we are inside an (element) extension.
-  return 'extend:' + artName(parentArt) + '/' + extensionName;
+  // This case should not happen, but just in case
+  return kind + ':' + artName(parent);
 }
 
 function constructSemanticLocationFromCsnPath(csnPath, model) {
@@ -1230,10 +1236,14 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
   ];
   const queryProps = [ 'from', 'where', 'groupBy', 'having', 'orderBy', 'limit', 'offset' ];
 
-  let { query } = analyseCsnPath(
-    csnPath,
-    model
-  );
+  if (csnPath[0] === 'extensions') {
+    const ext = model.extensions && model.extensions[csnPath[1]] || {};
+    if (ext.annotate)
+      return 'annotate:' + quoted(ext.annotate);
+    return 'extend:' + quoted(ext.extend);
+  }
+
+  let { query } = analyseCsnPath(csnPath, model, false);
 
   // remove definitions
   csnPath.shift();

package/lib/base/optionProcessorHelper.js

@@ -153,36 +153,67 @@ function createOptionProcessor() {
    * Internal: Define a general or command option.
    * Throws if the option is already registered in the given command context.
    * or in the given command.
+   *
    * @private
    * @see option()
    */
   function _addOption(cmd, optString, validValues, options) {
-    const opt = _parseOptionString(optString, validValues);
-    Object.assign(opt, options);
+    const cliOpt = _parseOptionString(optString, validValues);
+    Object.assign(cliOpt, options);
+    _addLongOption(cmd, cliOpt.longName, cliOpt);
+    _addShortOption(cmd, cliOpt.shortName, cliOpt);
+
+    for (const alias of cliOpt.aliases || []) {
+      const aliasOpt = Object.assign({ }, cliOpt, { isAlias: true });
+      _addLongOption(cmd, alias, aliasOpt); // use same camelName, etc. for alias
+    }
+
+    return cmd;
+  }
 
-    if (cmd.options[opt.longName]) {
-      throw new Error(`Duplicate assignment for long option ${opt.longName}`);
-    } else if (optionProcessor.options[opt.longName]) {
+  /**
+   * Internal: Add longName to the list of options.
+   * Throws if the option is already registered in the given command context.
+   * or in the given command.
+   * `longName` may differ from `opt.longName`, e.g. for aliases.
+   *
+   * @private
+   * @see _addOption()
+   */
+  function _addLongOption(cmd, longName, opt) {
+    if (cmd.options[longName]) {
+      throw new Error(`Duplicate assignment for long option ${longName}`);
+    } else if (optionProcessor.options[longName]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
-        option: opt.longName,
-        description: `Command '${cmd.longName}' has option clash with general options for: ${opt.longName}`
+        option: longName,
+        description: `Command '${cmd.longName}' has option clash with general options for: ${longName}`
       });
     }
-    cmd.options[opt.longName] = opt;
-    if (opt.shortName) {
-      if (cmd.options[opt.shortName]) {
-        throw new Error(`Duplicate assignment for short option ${opt.shortName}`);
-      } else if (optionProcessor.options[opt.shortName]) {
-        // This path is only taken if optString is for commands
-        optionProcessor.optionClashes.push({
-          option: opt.shortName,
-          description: `Command '${cmd.longName}' has option clash with general options for: ${opt.shortName}`
-        });
-      }
-      cmd.options[opt.shortName] = opt;
+    cmd.options[longName] = opt;
+  }
+  /**
+   * Internal: Add shortName to the list of options.
+   * Throws if the option is already registered in the given command context.
+   * or in the given command.
+   * `longName` may differ from `opt.longName`, e.g. for aliases.
+   *
+   * @private
+   * @see _addOption()
+   */
+  function _addShortOption(cmd, shortName, opt) {
+    if (!shortName)
+      return;
+    if (cmd.options[shortName]) {
+      throw new Error(`Duplicate assignment for short option ${shortName}`);
+    } else if (optionProcessor.options[shortName]) {
+      // This path is only taken if optString is for commands
+      optionProcessor.optionClashes.push({
+        option: shortName,
+        description: `Command '${cmd.longName}' has option clash with general options for: ${shortName}`
+      });
     }
-    return cmd;
+    cmd.options[shortName] = opt;
   }
 
   // Internal: Parse one command string like "F, toFoo". Return an object like this
@@ -275,7 +306,8 @@ function createOptionProcessor() {
       shortName,
       camelName: camelifyLongOption(longName),
       param,
-      validValues
+      validValues,
+      isAlias: false, // default
     }
   }
 

package/lib/compiler/assert-consistency.js

@@ -585,7 +585,7 @@ function assertConsistency( model, stage ) {
     // (it can contain the artifact itself with no/failed autoexposure):
     _descendants: { kind: [ 'entity' ], test: isDictionary( isArray( TODO ) ) },
 
-    $errorReported: { parser: true, test: isBoolean },     // to avoid duplicate messages
+    $errorReported: { parser: true, kind: true, test: isString },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
     $inferred: { parser: true, kind: true, test: isString },

package/lib/compiler/builtins.js

@@ -1,7 +1,7 @@
 // The builtin artifacts of CDS
 
 // TODO: split this file
-// - in base/: common definitions
+// - in base/: common definitions, datetime formats
 // - in compiler/: XSN-specific
 // - in ?: CSN-specific
 
@@ -193,6 +193,44 @@ const magicVariables = {
 
 // see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP Cds via function
 
+/**
+ * Patterns for literal token tests and creation.  The value is a map from the
+ * `prefix` argument of function `quotedliteral` to the following properties:
+ *  - `test_msg`: error message which is issued if `test_fn` or `test_re` fail.
+ *  - `test_fn`: function called with argument `value`, fails falsy return value
+ *  - `test_re`: regular expression, fails if it does not match argument `value`
+ *  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
+ *  - `unexpected_char`: regular expression matching an illegal character in `value`,
+ *    the error location is only correct for a literal <prefix>'<value>'
+ *  - `literal`: the value which is used instead of `prefix` in the AST
+ * TODO: we might do a range check (consider leap seconds, i.e. max value 60),
+ *       but always allow Feb 29 (no leap year computation)
+ */
+const quotedLiteralPatterns = {
+  x: {
+    test_variant: 'uneven-hex',
+    test_fn: (str => Number.isInteger(str.length / 2)),
+    unexpected_variant: 'invalid-hex',
+    unexpected_char: /[^0-9a-f]/i,
+    json_type: 'string',
+  },
+  time: {
+    test_variant: 'time',
+    test_re: /^[0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?$/,
+    json_type: 'string',
+  },
+  date: {
+    test_variant: 'date',
+    test_re: /^[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}$/,
+    json_type: 'string',
+  },
+  timestamp: {
+    test_variant: 'timestamp',
+    test_re: /^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}(:[0-9]{2}(\.[0-9]{1,7})?)?$/,
+    json_type: 'string',
+  },
+};
+
 /** All types belong to one category. */
 const typeCategories = {
   string: [],
@@ -403,6 +441,7 @@ module.exports = {
   typeParameters,
   functionsWithoutParens,
   specialFunctions,
+  quotedLiteralPatterns,
   initBuiltins,
   isInReservedNamespace,
   isBuiltinType,

package/lib/compiler/define.js

@@ -390,14 +390,14 @@ function define( model ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
     if (!name.absolute)
-      name.absolute = prefix + name.path.map( id => id.id ).join('.');
+      name.absolute = prefix + pathName( name.path );
     dictAdd( model.vocabularies, name.absolute, vocab );
   }
 
   // Phase 2 ("init") --------------------------------------------------------
 
   function checkRedefinition( art ) {
-    if (!art.$duplicates)
+    if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend')
       return;
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
@@ -670,6 +670,8 @@ function define( model ) {
    * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
    */
   function approveExistsInChildren(exprOrPathElement) {
+    if (!exprOrPathElement) // may be null in case of parse error
+      return;
     if (exprOrPathElement.$expected === 'exists')
       exprOrPathElement.$expected = 'approved-exists';
     // Drill down

package/lib/compiler/extend.js

@@ -389,7 +389,10 @@ function extend( model ) {
         for (const ext of exts) {
           delete ext.name.path[0]._artifact;      // get message for root
           // TODO: make resolvePath('extend'/'annotate') ignore namespaces
-          if (resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
+          // Don't try to apply annotations in the `localized.` namespace.
+          // That's done in `localized.js`.
+          if (!name.startsWith('localized.') &&
+            resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
             // should issue error for cds extensions (annotate ok)
             if (art.kind === 'namespace') {
               info( 'anno-namespace', [ ext.name.location, ext ], {},

package/lib/compiler/populate.js

@@ -246,7 +246,9 @@ function populate( model ) {
       let struct = user;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select') {
+      if (struct.kind === 'select' || struct.kind === 'annotation') {
+        // `type of` in annotation definitions can't work, because csn type refs
+        // always refer to definitions.
         message( 'type-unexpected-typeof', [ ref.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         // we actually refer to an element in _combined; TODO: return null if

package/lib/compiler/resolve.js

@@ -481,10 +481,7 @@ function resolve( model ) {
     if (ext.$extension) // extension for known artifact -> already applied
       return;
     annotateMembers( ext );
-    for (const prop in ext) {
-      if (prop.charAt(0) === '@')
-        chooseAssignment( prop, ext );
-    }
+    chooseAnnotationsInArtifact( ext );
   }
 
   /**

package/lib/compiler/shared.js

@@ -881,9 +881,18 @@ function fns( model ) {
         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)');
+      }
     }
     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/utils.js

@@ -188,8 +188,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('.') : '';
 }
 
 /**

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) => {
+    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;
               }
@@ -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;

package/lib/edm/csn2edm.js

@@ -330,11 +330,12 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             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))
@@ -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

@@ -239,7 +239,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 +332,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 +350,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 +371,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 +737,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))
@@ -840,8 +840,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 +1177,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 +1503,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 +1607,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)));
       });