@sap/cds-compiler 3.4.0 → 3.4.4

package/lib/compiler/propagator.js

@@ -33,6 +33,7 @@ function propagate( model ) {
     '@Analytics.visible': never,
     '@cds.autoexpose': onlyViaArtifact,
     '@cds.autoexposed': never,  // in case people set it themselves
+    '@cds.external': never,
     '@cds.redirection.target': never,
     '@fiori.draft.enabled': onlyViaArtifact,
     '@': annotation,            // always except in 'returns' and 'items'
@@ -84,42 +85,34 @@ function propagate( model ) {
       return;
     }
     // console.log('RUN:', art.name, art.elements ? Object.keys(art.elements) : 0)
+
     const chain = [];
-    let target = art;
-    let source = getOrigin( target );
-    while (source && checkAndSetStatus( source )) {
-      chain.push({ target, source });
-      target = source;
-      source = getOrigin( target );
-    }
-    if (source) {               // the source has fully propagated properties
-      chain.push({ target, source });
-    }
-    else if (target._main) {    // source is element, which has not inherited props yet
-      run( target._main );       // run on main artifact first
-    }
+    let targets = [ art ];
+    while (targets.length) {
+      const news = [];
+      for (const target of targets) {
+        const origin = getOrigin( target );
+        if (origin) {
+          chain.push( { target, source: origin } );
+          if (checkAndSetStatus( origin ))
+            news.push( origin );
+        }
 
-    // Even with a query source, go through `includes`. `source` is propagated first, i.e. wins.
-    if (target.includes) {
-      let targets = [ target ];
-      while (targets.length) {
-        const news = [];
-        for (const t of targets) {
-          for (const ref of t.includes || []) {
-            const s = ref._artifact;
-            if (!s)          // ref error
-              continue;
-            chain.push( { target: t, source: s } );
-            if (checkAndSetStatus( s ))
-              news.push( s );
-          }
+        for (const ref of target.includes || []) {
+          const include = ref._artifact;
+          if (!include)
+            continue;
+          chain.push( { target, source: include } );
+          if (checkAndSetStatus( include ))
+            news.push( include );
         }
-        targets = news;
       }
+      targets = news;
     }
+
     chain.reverse().forEach( step );
     runMembers( art );
-    // console.log('DONE:', art.name, art.elements ? Object.keys(art.elements) : 0)
+    // console.log('DONE:', art.name, art.elements ? Object.keys(art.elements) : 0);
   }
 
   function runMembers( art ) {

package/lib/compiler/resolve.js

@@ -63,6 +63,7 @@ const {
   storeExtension,
   dependsOn,
   dependsOnSilent,
+  setExpandStatusAnnotate,
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
@@ -618,20 +619,6 @@ function resolve( model ) {
     }
   }
 
-  function setExpandStatusAnnotate( elem, status ) {
-    for (;;) {
-      if (elem.$expand === status)
-        return;                 // already set
-      elem.$expand = status;    // meaning: expanded, containing annos
-      for (let line = elem.items; line; line = line.items)
-        line.$expand = status; // to-csn just uses the innermost $expand
-      if (!elem._main)
-        return;
-      elem = elem._parent;
-    }
-  }
-
-
   function expandParameters( action ) {
     // see also expandElements()
     if (!effectiveType( action ))
@@ -1291,7 +1278,7 @@ function resolve( model ) {
     }
   }
 
-  function resolveExpr( expr, expected, user, extDict, expandOrInline) {
+  function resolveExpr( expr, expected, user, extDict, expandOrInline ) {
     // TODO: when we have rewritten the resolvePath functions,
     // define a traverseExpr() in ./utils.js
     // TODO: extra "expected" 'expand'/'inline' instead o param `expandOrInline`

package/lib/compiler/shared.js

@@ -528,7 +528,7 @@ function fns( model ) {
    * @param {object} typeArtifact
    * @param {CSN.Artifact} user
    */
-  function resolveTypeArgumentsUnchecked(artifact, typeArtifact, user) {
+  function resolveTypeArgumentsUnchecked( artifact, typeArtifact, user ) {
     let args = artifact.$typeArgs || [];
     const parameters = typeArtifact.parameters || [];
 
@@ -873,7 +873,7 @@ function fns( model ) {
    * @param {object[]} valid
    * @param  {object} [textParams]
    */
-  function signalNotFound(msgId, location, valid, textParams ) {
+  function signalNotFound( msgId, location, valid, textParams ) {
     if (location.$notFound)
       return;
     location.$notFound = true;
@@ -891,7 +891,7 @@ function fns( model ) {
    * @param {object} art
    * @param {any} location
    */
-  function signalMissingElementAccess(art, location) {
+  function signalMissingElementAccess( art, location ) {
     const err = message( 'ref-expected-element', location,
                          { '#': 'magicVar', id: art.name.id } );
     // Mapping for better valid names: from -> $at.from
@@ -909,7 +909,7 @@ function fns( model ) {
    * @param {CompileMessage} msg CDS Compiler message
    * @param  {...object} validDicts One ore more artifact dictionaries such as in `_block`.
    */
-  function attachAndEmitValidNames(msg, ...validDicts) {
+  function attachAndEmitValidNames( msg, ...validDicts ) {
     if (!options.testMode && !options.attachValidNames)
       return;
 

package/lib/compiler/utils.js

@@ -400,6 +400,19 @@ function setExpandStatus( elem, status ) {
   }
 }
 
+function setExpandStatusAnnotate( elem, status ) {
+  for (;;) {
+    if (elem.$expand === status)
+      return;                 // already set
+    elem.$expand = status;    // meaning: expanded, containing annos
+    for (let line = elem.items; line; line = line.items)
+      line.$expand = status; // to-csn just uses the innermost $expand
+    if (!elem._main)
+      return;
+    elem = elem._parent;
+  }
+}
+
 module.exports = {
   pushLink,
   annotationVal,
@@ -424,4 +437,5 @@ module.exports = {
   traverseQueryPost,
   traverseQueryExtra,
   setExpandStatus,
+  setExpandStatusAnnotate,
 };

package/lib/edm/annotations/genericTranslation.js

@@ -6,6 +6,7 @@ const oDataDictionary = require('../../gen/Dictionary.json');
 const { forEachDefinition } = require('../../model/csnUtils');
 const { forEach } = require("../../utils/objectUtils");
 
+
 /*
    OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
    Aggregation (published)
@@ -171,6 +172,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     vocabularyDefinitions[n].used = false;
   });
 
+  // These vocabularies are always added for the runtimes
+  vocabularyDefinitions['Common'].used = true;
+  vocabularyDefinitions['Core'].used = true;
+
   // provide functions for dictionary lookup
   //   use closure to avoid making "dict" and "experimental" global variables
   let { getDictTerm, getDictType } = function(){
@@ -257,7 +262,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // this function is called in the translation code to issue an info/warning/error message
   // messages are reported via the severity function
   // context contains "semantic location"
-  function message(severity, context, message) {
+  function message(severity, context, message, args={}) {
     let fullMessage = 'In annotation translation: ' + message;
     if (context) {
       let loc = 'target: ' + context.target + ', annotation: ' + context.term;
@@ -266,7 +271,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       }
       fullMessage += ', ' + loc;
     }
-    severity(null, null, `${fullMessage}`);
+    severity(null, null, args, `${fullMessage}`);
   }
 
 /*
@@ -1016,119 +1021,126 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //      floating point type except Edm.Decimal -> Float
   //      Edm.Decimal -> Decimal
   //      integer tpye -> Int
-  function handleSimpleValue(val, dTypeName, context) {
+  function handleSimpleValue(value, dTypeName, context) {
     // these types must be represented as "String" values in XML:
     const castToXmlString = [ 'Edm.PrimitiveType', 'Edm.Stream', 'Edm.Untyped' ];
     // caller already made sure that val is neither object nor array
-    dTypeName = resolveType(dTypeName);
 
-    if (isEnumType(dTypeName)) {
-      const type = getDictType(dTypeName);
+    // check if type has allowed values
+    const typeDef = getDictType(dTypeName);
+    const Allowed = typeDef?.$Allowed;
+
+    let resolvedType = resolveTypeDefinition(dTypeName);
+
+    if (isEnumType(resolvedType)) {
+      const type = getDictType(resolvedType);
       const expected = type.Members.map(m => `"#${m}"`).join(', ');
-      message(warning, context, `found non-enum value "${val}", expected ${expected} for ${dTypeName}`);
+      message(warning, context, `found non-enum value "${value}", expected ${expected} for ${resolvedType}`);
     }
 
     let typeName = 'String';
+    if(Allowed && !Allowed.Values[value])
+      message(warning, context, 'Expected $(VALUE) to be one out of the allowed values $(VALUES)', { value, values: Object.keys(Allowed.Values) });
 
-    if (typeof val === 'string') {
-      if (dTypeName === 'Edm.Boolean') {
+    if (typeof value === 'string') {
+      if (resolvedType === 'Edm.Boolean') {
         typeName = 'Bool';
-        if (val !== 'true' && val !== 'false') {
-          message(warning, context, `found String, but expected type ${ dTypeName }`);
+        if (value !== 'true' && value !== 'false') {
+          message(warning, context, `found String, but expected type ${ resolvedType }`);
         }
       }
-      else if (dTypeName === 'Edm.Decimal') {
+      else if (resolvedType === 'Edm.Decimal') {
         typeName = 'Decimal';
-        if (isNaN(Number(val)) || isNaN(parseFloat(val))) {
-          message(warning, context, `found non-numeric string, but expected type ${ dTypeName }`);
+        if (isNaN(Number(value)) || isNaN(parseFloat(value))) {
+          message(warning, context, `found non-numeric string, but expected type ${ resolvedType }`);
         }
       }
-      else if (dTypeName === 'Edm.Double' || dTypeName === 'Edm.Single') {
+      else if (resolvedType === 'Edm.Double' || resolvedType === 'Edm.Single') {
         typeName = 'Float';
-        if (isNaN(Number(val)) || isNaN(parseFloat(val))) {
-          message(warning, context, `found non-numeric string, but expected type ${ dTypeName }`);
+        if (isNaN(Number(value)) || isNaN(parseFloat(value))) {
+          message(warning, context, `found non-numeric string, but expected type ${ resolvedType }`);
         }
       }
-      else if (isComplexType(dTypeName)) {
-        message(warning, context, `found String, but expected complex type ${ dTypeName }`);
+      else if (isComplexType(resolvedType)) {
+        message(warning, context, `found String, but expected complex type ${ resolvedType }`);
       }
-      else if (isEnumType(dTypeName)) {
-        message(warning, context, `found String, but expected enum type ${ dTypeName }`);
+      else if (isEnumType(resolvedType)) {
+        message(warning, context, `found String, but expected enum type ${ resolvedType }`);
         typeName = 'EnumMember';
       }
-      else if (dTypeName && dTypeName.startsWith('Edm.') && !castToXmlString.includes(dTypeName)) {
+      else if (resolvedType && resolvedType.startsWith('Edm.') && !castToXmlString.includes(resolvedType)) {
         // this covers also all paths
-        typeName = dTypeName.substring(4);
+        typeName = resolvedType.substring(4);
       }
       else {
-        if(dTypeName == undefined || castToXmlString.some(t => t === dTypeName))
-          dTypeName = 'Edm.String';
+        if(resolvedType == undefined || castToXmlString.some(t => t === resolvedType))
+          resolvedType = 'Edm.String';
         // TODO
         //message(warning, context, "type is not yet handled: found String, expected type: " + dTypeName);
       }
     }
-    else if (typeof val === 'boolean') {
-      if(dTypeName == undefined || dTypeName === 'Edm.Boolean' || dTypeName === 'Edm.PrimitiveType') {
+    else if (typeof value === 'boolean') {
+      if(resolvedType == undefined || resolvedType === 'Edm.Boolean' || resolvedType === 'Edm.PrimitiveType') {
         typeName = 'Bool';
-        dTypeName = 'Edm.Boolean';
+        resolvedType = 'Edm.Boolean';
       }
-      if (dTypeName === 'Edm.Boolean') {
-        val = val ? 'true' : 'false';
+      if (resolvedType === 'Edm.Boolean') {
+        value = value ? 'true' : 'false';
       }
-      else if (dTypeName === 'Edm.String') {
+      else if (resolvedType === 'Edm.String') {
         typeName = 'String';
       }
       else {
-        message(warning, context, `found Boolean, but expected type ${ dTypeName }`);
+        message(warning, context, `found Boolean, but expected type ${ resolvedType }`);
       }
     }
-    else if (typeof val === 'number') {
-      if (isComplexType(dTypeName)) {
-        message(warning, context, `found number, but expected complex type ${ dTypeName }`);
+    else if (typeof value === 'number') {
+      if (isComplexType(resolvedType)) {
+        message(warning, context, `found number, but expected complex type ${ resolvedType }`);
       }
-      else if (dTypeName === 'Edm.String') {
+      else if (resolvedType === 'Edm.String') {
         typeName = 'String';
       }
-      else if (dTypeName === 'Edm.PropertyPath') {
-        message(warning, context, `found number, but expected type ${ dTypeName }`);
+      else if (resolvedType === 'Edm.PropertyPath') {
+        message(warning, context, `found number, but expected type ${ resolvedType }`);
       }
-      else if (dTypeName === 'Edm.Boolean') {
-        message(warning, context, `found number, but expected type ${ dTypeName }`);
+      else if (resolvedType === 'Edm.Boolean') {
+        message(warning, context, `found number, but expected type ${ resolvedType }`);
       }
-      else if (dTypeName === 'Edm.Decimal') {
+      else if (resolvedType === 'Edm.Decimal') {
         typeName = 'Decimal';
       }
-      else if (dTypeName === 'Edm.Double') {
+      else if (resolvedType === 'Edm.Double') {
         typeName = 'Float';
       }
       else {
         //typeName = Number.isInteger(val) ? 'Int' : 'Float';
-        if(Number.isInteger(val)) {
+        if(Number.isInteger(value)) {
           typeName = 'Int';
-          if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType' || !dTypeName.startsWith('Edm.'))
-            dTypeName = 'Edm.Int64';
+          if(resolvedType == undefined || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
+            resolvedType = 'Edm.Int64';
         }
         else {
           typeName = 'Float';
-          if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType'|| !dTypeName.startsWith('Edm.'))
-            dTypeName = 'Edm.Double';
+          if(resolvedType == undefined || resolvedType === 'Edm.PrimitiveType'|| !resolvedType.startsWith('Edm.'))
+            resolvedType = 'Edm.Double';
         }
       }
     }
-    else if (val === null && dTypeName == null && typeName === 'String') {
-      dTypeName = 'Edm.String';
+    else if (value === null && resolvedType == null && typeName === 'String') {
+      resolvedType = 'Edm.String';
     }
     else {
-      message(warning, context, `expected simple value, but found value '${ val }' with type '${ typeof val }'`);
+      message(warning, context, `expected simple value, but found value '${ value }' with type '${ typeof value }'`);
     }
 
-    if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(dTypeName) )
-      dTypeName = dTypeName.split('.')[1];
+    if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(resolvedType) )
+      resolvedType = resolvedType.split('.')[1];
 
     return {
       name : typeName,
-      jsonName: dTypeName,
-      value : val
+      jsonName: resolvedType,
+      value : value
     };
   }
 
@@ -1506,8 +1518,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // resolve "derived types"
   // -> if dTypeName is a TypeDefinition, replace by
   //    underlying type
-  function resolveType(dTypeName) {
-    let type = getDictType(dTypeName);
+  function resolveTypeDefinition(dTypeName) {
+    const type = getDictType(dTypeName);
     if (type && type.UnderlyingType && type['$kind'] === 'TypeDefinition') {
       return type.UnderlyingType;
     }