@sap/cds-compiler 3.9.8 → 3.9.12

package/CHANGELOG.md

@@ -7,6 +7,31 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+
+## Version 3.9.12 - 2023-12-06
+
+### Fixed
+
+- compiler:
+  + SQL function `STDDEV(*)` was not parsable.
+  + Numbers in scientific notation `-1e1` were sometimes not recognized via CSN input.
+- for.odata: Fix crash when using a projection with associations as action parameter type.
+- for.hana: Fix a bug in association to join translation, expect ON condition operand to be a function without arguments.
+- to.edm(x):
+  + Omit `EntitySet` attribute on `Edm.FunctionImport` and `Edm.ActionImport` that return a singleton.
+  + Don't render `Scale: variable` for `cds.Decimal(scale:0)`.
+- to.sql/hdi/hdbcds: consider `having` predicate for `exists` expansion
+
+## Version 3.9.10 - 2023-08-25
+
+### Fixed
+
+- to.edm(x): Error reporting for incorrect handling of "Collection()" has been improved.
+- to.sql/hdi/hdbcds: Views on views with parameters did not have localized convenience views based on
+  other localized views (missing `localized.` prefix in FROM clause)
+- to.sql: Casting expressions to a structured type yields a proper error instead of strange compiler error.
+- to.sql.migration: Don't drop-create views marked with `@cds.persistence.exists` or `@cds.persistence.skip`
+
 ## Version 3.9.8 - 2023-08-03
 
 ### Fixed

package/lib/api/main.js

@@ -48,7 +48,7 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
  * @param {string} transformation Name of the transformation - odata or hana
  * @param {NestedOptions} options Options used for the transformation
  * @param {string[]} relevantOptionNames Option names that are defining characteristics
- * @param {string[]} [optionalOptionNames=[]] Option names that should be attached as a fyi
+ * @param {string[]} [optionalOptionNames] Option names that should be attached as a fyi
  */
 function attachTransformerCharacteristics( csn, transformation, options,
                                            relevantOptionNames, optionalOptionNames = [] ) {
@@ -141,7 +141,7 @@ function odataInternal( csn, internalOptions ) {
  * Return a odata-transformed CSN
  *
  * @param {CSN.Model} csn Clean input CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} [options] Options
  * @returns {oDataCSN} Return an oData-pre-processed CSN
  */
 function odata( csn, options = {} ) {
@@ -154,7 +154,7 @@ function odata( csn, options = {} ) {
  * Process the given csn back to cdl.
  *
  * @param {object} csn CSN to process
- * @param {object} [options={}] Options
+ * @param {object} [options] Options
  * @returns {object} { model: string, namespace: string }
  */
 function cdl( csn, options = {} ) {
@@ -167,7 +167,7 @@ function cdl( csn, options = {} ) {
  * Transform a CSN like to.sql
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {SqlOptions} [options={}] Options
+ * @param {SqlOptions} [options] Options
  * @returns {CSN.Model} CSN transformed like to.sql
  * @private
  */
@@ -182,7 +182,7 @@ function forSql( csn, options = {} ) {
  * Transform a CSN like to.hdi
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {HdiOptions} [options={}] Options
+ * @param {HdiOptions} [options] Options
  * @returns {CSN.Model} CSN transformed like to.hdi
  * @private
  */
@@ -197,7 +197,7 @@ function forHdi( csn, options = {} ) {
  * Transform a CSN like to.hdbcds
  *
  * @param {CSN.Model} csn Plain input CSN
- * @param {HdbcdsOptions} [options={}] Options
+ * @param {HdbcdsOptions} [options] Options
  * @returns {CSN.Model} CSN transformed like to.hdbcds
  * @private
  */
@@ -214,7 +214,7 @@ function forHdbcds( csn, options = {} ) {
  * Process the given CSN into SQL.
  *
  * @param {CSN.Model} csn A clean input CSN
- * @param {SqlOptions} [options={}] Options
+ * @param {SqlOptions} [options] Options
  * @returns {SQL[]} Array of SQL statements, tables first, views second
  */
 function sql( csn, options = {} ) {
@@ -235,7 +235,7 @@ function sql( csn, options = {} ) {
  * Process the given CSN into HDI artifacts.
  *
  * @param {CSN.Model} csn A clean input CSN
- * @param {HdiOptions} [options={}] Options
+ * @param {HdiOptions} [options] Options
  * @returns {HDIArtifacts} { <filename>:<content>, ...}
  */
 function hdi( csn, options = {} ) {
@@ -375,8 +375,7 @@ function sqlMigration( csn, options, beforeImage ) {
       const beforeArtifact = beforeImage.definitions[artifactName];
       const diffArtifact = diff.definitions[artifactName];
       // TODO: exists, abstract? isPersistedOnDb?
-      if (diffArtifact && diffArtifact['@cds.persistence.name'] && !diffArtifact['@cds.persistence.skip'] &&
-        (diffArtifact.query || diffArtifact.projection) &&
+      if (diffArtifact && diffArtifact['@cds.persistence.name'] && csnUtils.isPersistedAsView(diffArtifact) &&
         (diffArtifact[modelCompare.isChanged] === true || // we know it changed because we compared two views
           diffArtifact[modelCompare.isChanged] === undefined)) { // if it was removed in the after, then we don't have the flag
         drops.creates[artifactName] = `DROP VIEW ${ identifierUtils.renderArtifactName(artifactName) };`;
@@ -384,6 +383,7 @@ function sqlMigration( csn, options, beforeImage ) {
       else if (diffArtifact &&
         diffArtifact['@cds.persistence.skip'] !== true &&
         diffArtifact.kind === beforeArtifact.kind && // detect action -> entity
+        csnUtils.isPersistedAsTable(diffArtifact) === csnUtils.isPersistedAsTable(beforeArtifact) && // detect removal of @cds.persistence.exists
         csnUtils.isPersistedAsView(diffArtifact) === csnUtils.isPersistedAsView(beforeArtifact) // detect view -> entity
       ) { // don't render again, but need info for primary key extension
         diffArtifact['@cds.persistence.skip'] = true;
@@ -529,7 +529,7 @@ sql.migration = sqlMigration;
  * Process the given CSN into HDBCDS artifacts.
  *
  * @param {any} csn A clean input CSN
- * @param {HdbcdsOptions} [options={}] Options
+ * @param {HdbcdsOptions} [options] Options
  * @returns {HDBCDS} { <filename>:<content>, ...}
  */
 function hdbcds( csn, options = {} ) {
@@ -546,7 +546,7 @@ function hdbcds( csn, options = {} ) {
  * Generate a edm document for the given service
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} [options] Options
  * @returns {edm} The JSON representation of the service
  */
 function edm( csn, options = {} ) {
@@ -577,7 +577,7 @@ edm.all = edmall;
  * Generate edm documents for all services
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} [options] Options
  * @returns {edms} { <service>:<JSON representation>, ...}
  */
 function edmall( csn, options = {} ) {
@@ -608,7 +608,7 @@ function edmall( csn, options = {} ) {
  * Generate a edmx document for the given service
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} [options] Options
  * @returns {edmx} The XML representation of the service
  */
 function edmx( csn, options = {} ) {
@@ -640,7 +640,7 @@ edmx.all = edmxall;
  * Generate edmx documents for all services
  *
  * @param {CSN|oDataCSN} csn Clean input CSN or a pre-transformed CSN
- * @param {ODataOptions} [options={}] Options
+ * @param {ODataOptions} [options] Options
  * @returns {edmxs} { <service>:<XML representation>, ...}
  */
 function edmxall( csn, options = {} ) {

package/lib/api/options.js

@@ -74,9 +74,9 @@ const overallOptions = publicOptionsNewAPI.concat(privateOptions);
  * Apply defaults and make sure that the "hard requirements" are met,
  * i.e. src: sql if to.sql() was called.
  *
- * @param {FlatOptions} [input={}] Input options
- * @param {FlatOptions} [defaults={}] Default options to apply
- * @param {FlatOptions} [hardRequire={}] Hard requirements to enforce
+ * @param {FlatOptions} [input] Input options
+ * @param {FlatOptions} [defaults] Default options to apply
+ * @param {FlatOptions} [hardRequire] Hard requirements to enforce
  * @param {object} [customValidators] Custom validations to run instead of defaults
  * @param {string[]} [combinationValidators] Option combinations to validate
  * @param {string} moduleName The called module, e.g. 'for.odata', 'to.hdi'. Needed to initialize the message functions

package/lib/base/message-registry.js

@@ -742,6 +742,14 @@ const centralMessageTexts = {
     entity: 'Entity $(ART) with managed compositions can\'t be used in types', // yet
   },
 
+  'type-invalid-cast': {
+    std: 'Invalid cast to $(TYPE)', // unused
+    'to-structure': 'Can\'t cast to a structured type',
+    'from-structure':  'Structured elements can\'t be cast to a different type',
+    'expr-to-structure': 'Can\'t cast an expression to a structured type',
+    'val-to-structure': 'Can\'t cast $(VALUE) to a structured type'
+  },
+
   // -----------------------------------------------------------------------------------
   // Expressions
   // -----------------------------------------------------------------------------------
@@ -784,6 +792,7 @@ const centralMessageTexts = {
     incompatible: 'Unexpected EDM Type $(TYPE) for OData $(VERSION)',
     facet: 'Unexpected EDM Type facet $(NAME) of type $(TYPE) for OData $(VERSION)',
     external: 'Referenced type $(TYPE) marked as $(ANNO) can\'t be rendered as $(CODE) in service $(NAME) for OData $(VERSION)',
+    scale: 'Expected scale $(NUMBER) to be less than or equal to precision $(RAWVALUE)'
   },
   'odata-spec-violation-property-name': 'Expected element name to be different from declaring $(META)',
   'odata-spec-violation-namespace': {
@@ -811,7 +820,7 @@ const centralMessageTexts = {
   'odata-anno-preproc': {
     'std': 'unused message text',
     'nokey': 'Expected target $(NAME) to have a key element for $(ANNO)',
-    'multkeys': 'Expected target $(NAME) to have only one key element',
+    'multkeys': 'Expected target $(NAME) to have only one key element for $(ANNO)',
     'vhlnokey': 'Expected value help list entity $(NAME) to have a key element for $(ANNO)',
     'vhlmultkeys': 'Expected value help list entity $(NAME) to have only one key element for $(ANNO)',
     'notforentity': 'Unexpected usage of $(ANNO) for an entity',
@@ -819,8 +828,8 @@ const centralMessageTexts = {
     'noassoc': 'Expected association $(ID) to exist for $(ANNO)',
     'vallistignored': '$(NAME) is ignored for $(ANNO) as $(CODE) is present',
     'notastring': 'Expected value to be a string for $(ANNO)',
-    'notexist': 'Expect entity $(ID) to exist for $(ANNO)',
-    'txtarr': 'Expect $(ANNO) shortcut to have a $(NAME) annotation'
+    'notexist': 'Expected entity $(ID) to exist for $(ANNO)',
+    'txtarr': 'Expected $(ANNO) shortcut to have a $(NAME) annotation'
   },
   // -----------------------------------------------------------------------------------
   // GenericTranslation:
@@ -849,7 +858,7 @@ const centralMessageTexts = {
     // -----------------------------------------------------------------------------------
     'enum': 'Value $(VALUE) is not one out of $(RAWVALUES) for $(ANNO) of type $(TYPE)',
     'std': 'Unexpected value $(VALUE) for $(ANNO) of type $(TYPE)',
-    'struct': 'Unexpected $(STR) value for $(ANNO) of type $(TYPE)',
+    'incompval': 'Unexpected $(STR) value for $(ANNO) of type $(TYPE)',
     'nestedcollection': 'Nested collections are not supported for $(ANNO)',
     'enumincollection': 'Enum inside collection is not supported for $(ANNO)',
     'multexpr': 'EDM JSON code contains more than one dynamic expression: $(RAWVALUES) for $(ANNO)',

package/lib/checks/validator.js

@@ -127,10 +127,10 @@ const commonQueryValidators = [ validateMixinOnCondition ];
  *
  * @param {CSN.Model} csn CSN to check
  * @param {object} that Will be provided to the validators via "this"
- * @param {object[]} [csnValidators=[]] Validations on whole CSN using applyTransformations
- * @param {Function[]} [memberValidators=[]] Validations on member-level
- * @param {Function[]} [artifactValidators=[]] Validations on artifact-level
- * @param {Function[]} [queryValidators=[]] Validations on query-level
+ * @param {object[]} [csnValidators] Validations on whole CSN using applyTransformations
+ * @param {Function[]} [memberValidators] Validations on member-level
+ * @param {Function[]} [artifactValidators] Validations on artifact-level
+ * @param {Function[]} [queryValidators] Validations on query-level
  * @param {object} iterateOptions can be used to skip certain kinds from being iterated e.g. 'action' and 'function' for hana
  * @returns {Function} Function taking no parameters, that cleans up the attached helpers
  */

package/lib/compiler/builtins.js

@@ -119,7 +119,7 @@ const specialFunctions = compileFunctions( {
   MAX: 'COUNT',
   SUM: 'COUNT',
   AVG: 'COUNT',
-  STDDDEV: 'COUNT',
+  STDDEV: 'COUNT',
   VAR: 'COUNT',
   LOCATE_REGEXPR: [
     {
@@ -216,7 +216,7 @@ const timeRegEx = /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?(?:Z|[+-]\d{2}(?::\d{2})
 // eslint-disable-next-line max-len
 const timestampRegEx = /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?(?:Z|[+-]\d{2}(?::\d{2})?)?$/;
 //                          YYYY  -  MM   -  dd    T    HH   :   mm     :  ss     . fraction     TZD
-const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]\d+)?[ \t]*$/i;
+const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?[ \t]*$/i;
 
 /**
  * Patterns for literal token tests and creation.  The value is a map from the

package/lib/compiler/resolve.js

@@ -516,14 +516,10 @@ function resolve( model ) {
       ? art.value.args[0]?._artifact
       : art.value._artifact;
     if (elem && art.type) { // has explicit type
-      if (art.type._artifact?.elements) {
-        error('type-cast-to-structured', [ art.type.location, art ], {},
-              'Can\'t cast to structured element');
-      }
-      else if (elem.elements) { // TODO: calc elements
-        error('type-cast-structured', [ art.type.location, art ], {},
-              'Structured elements can\'t be cast to a different type');
-      }
+      if (art.type._artifact?.elements)
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
+      else if (elem.elements) // TODO: calc elements
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
     }
   }
 

package/lib/edm/annotations/genericTranslation.js

@@ -921,30 +921,33 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   //   cAnnoValue: the annotation value (c : csn)
   //   oTarget: the result object (o: odata)
   //   oTermName: current term
-  //   dTypeName: expected type of cAnnoValue according to dictionary, may be null (d: dictionary)
-  function handleValue(cAnnoValue, oTarget, oTermName, dTypeName, msg) {
+  //   dTypeNameArg: expected type of cAnnoValue according to dictionary, may be null (d: dictionary)
+  function handleValue( cAnnoValue, oTarget, oTermName, dTypeNameArg, msg ) {
     // this function basically only figures out what kind of annotation value we have
     //   (can be: array, expression, enum, pseudo-record, record, simple value),
     //   then calls a more specific function to deal with it and puts
     //   the result into the oTarget object
 
-    if (Array.isArray(cAnnoValue))
-    {
-      if (isEnumType(dTypeName))
-      {
+    const [ dTypeName, dTypeIsACollection ] = stripCollection(dTypeNameArg);
+
+    if (Array.isArray(cAnnoValue)) {
+      if (isEnumType(dTypeName)) {
         // if we find an array although we expect an enum, this may be a "flag enum"
-        checkMultiEnumValue(cAnnoValue);
+        checkMultiEnumValue();
         oTarget.setJSON({ 'EnumMember': generateMultiEnumValue(cAnnoValue, false), 'EnumMember@odata.type' : '#'+dTypeName });
         oTarget.setXml( { 'EnumMember': generateMultiEnumValue(cAnnoValue, true) });
       }
-      else
-      {
-        oTarget.append(generateCollection(cAnnoValue, oTermName, dTypeName, msg));
+      else {
+        oTarget.append(generateCollection(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
     }
     else if (cAnnoValue && typeof cAnnoValue === 'object') {
       // an empty record is rendered as <Record/>
       if ('=' in cAnnoValue) {
+        if (dTypeIsACollection) {
+          message('odata-anno-value', msg.location,
+                  { anno: msg.anno(), str: 'path', '#': 'incompval' });
+        }
         // expression
         const res = handleExpression(cAnnoValue['='], dTypeName);
         oTarget.setXml( { [res.name] : res.value });
@@ -954,8 +957,8 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
         const enumSymbol = cAnnoValue['#'];
         // enum
         if (dTypeName) {
-          const typeDef = getDictType(stripCollection(dTypeName));
-          if(typeDef && typeDef.$Allowed && !typeDef.Members) {
+          const typeDef = getDictType(dTypeName);
+          if (typeDef && typeDef.$Allowed && !typeDef.Members) {
             const allowedValue = typeDef.$Allowed.Symbols[enumSymbol];
             if(!allowedValue) {
               message('odata-anno-value', msg.location,
@@ -982,7 +985,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       }
       else if (cAnnoValue['$value'] !== undefined) {
         // "pseudo-structure" used for annotating scalar annotations
-        handleValue(cAnnoValue['$value'], oTarget, oTermName, dTypeName, msg);
+        handleValue(cAnnoValue.$value, oTarget, oTermName, dTypeNameArg, msg);
 
         const k = Object.keys(cAnnoValue).filter( x => x[0] === '@');
         if (!k || k.length === 0) {
@@ -1005,7 +1008,12 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       }
       else {
         // regular record
-        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, msg));
+        if (dTypeIsACollection) {
+          message('odata-anno-value', msg.location, {
+            anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'incompval',
+          });
+        }
+        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
     }
     else {
@@ -1021,7 +1029,6 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       }
       oTarget.setJSON( { [res.jsonName] : res.value });
     }
-
     // found an enum value ("#"), check whether this fits
     //  the expected type "dTypeName"
     function checkEnumValue(value) {
@@ -1053,15 +1060,17 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     // cAnnoValue: array
     // dTypeName: expected type, already identified as enum type
     //   array is expected to contain enum values
-    function checkMultiEnumValue(cAnnoValue) {
-    // we know that dTypeName is not null
+    function checkMultiEnumValue( ) {
+      // we know that dTypeName is not null
       const type = getDictType(dTypeName);
-      if (!type || type['IsFlags'] !== 'true') {
+      if (!type || type.IsFlags !== 'true') {
         message('odata-anno-value', msg.location,
-          { anno: msg.anno(),
+          {
+            anno: msg.anno(),
             str: 'collection',
             type: dTypeName,
-            '#': 'struct' });
+            '#': 'incompval',
+          });
       }
 
       let index = 0;
@@ -1092,8 +1101,6 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     }
   }
 
-
-
   // found an expression value ("=") "expr"
   //   expected type is dTypeName
   // note: expr can also be provided if an enum/complex type/collection is expected
@@ -1264,18 +1271,20 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // dTypeName : name of the expected record type according to vocabulary, may be null
   //
   // can be called for a record directly below a term, or at a deeper level
-  function generateRecord(obj, termName, dTypeName, msg) {
+  function generateRecord( obj, termName, dTypeName, dTypeIsACollection, msg ) {
     /** @type {object} */
     const newRecord = new Edm.Record(v);
 
     // first determine what is the actual type to be used for the record
     if (dTypeName && !isComplexType(dTypeName)) {
-      if (!getDictType(dTypeName) && !isPrimitiveType(dTypeName) && !isCollection(dTypeName))
-        message('odata-anno-dict', msg.location,
-        { anno: msg.anno(), type: dTypeName });
-      else
+      if (!getDictType(dTypeName) && !isPrimitiveType(dTypeName) && !dTypeIsACollection) {
+        message('odata-anno-dict', msg.location, { anno: msg.anno(), type: dTypeName });
+      } else {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'struct' });
+          {
+            anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'incompval',
+          });
+      }
       return newRecord;
     }
 
@@ -1383,19 +1392,14 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
   // annoValue is an array
   // dTypeName : Collection(...) according to dictionary
-  function generateCollection(annoValue, termName, dTypeName, msg) {
+  function generateCollection( annoValue, termName, dTypeName, dTypeIsACollection, msg ) {
     const newCollection = new Edm.Collection(v);
 
-    let innerTypeName = null;
-    if (dTypeName) {
-      const match = dTypeName.match(/^Collection\((.+)\)/);
-      if (match) {
-        innerTypeName = match[1];
-      }
-      else {
-        message('odata-anno-value', msg.location,
-        { anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'struct' });
-      }
+    if (dTypeName && !dTypeIsACollection) {
+      message('odata-anno-value', msg.location,
+        {
+          anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'incompval',
+        });
     }
 
     let index = 0;
@@ -1412,7 +1416,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       }
       else if (value && typeof value === 'object') {
         if (value['=']) {
-          const res = handleExpression(value['='], innerTypeName);
+          const res = handleExpression(value['='], dTypeName);
           const newPropertyPath = new Edm.ValueThing(v, res.name, res.value );
           newPropertyPath.setJSON( { [res.name] : res.value } );
           newCollection.append(newPropertyPath);
@@ -1425,13 +1429,13 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
           newCollection.append(handleEdmJson(value['$edmJson'], msg));
         }
         else {
-          newCollection.append(generateRecord(value, termName, innerTypeName, msg));
+          newCollection.append(generateRecord(value, termName, dTypeName, dTypeIsACollection, msg));
         }
       }
       else {
-        const res = handleSimpleValue(value, innerTypeName, msg);
-        const newThing = (value === null) ?new Edm.ValueThing(v, 'Null') : new Edm.ValueThing(v, res.name, value );
-        newThing.setJSON( { [res.jsonName] : res.value });
+        const res = handleSimpleValue(value, dTypeName, msg);
+        const newThing = (value === null) ? new Edm.ValueThing(v, 'Null') : new Edm.ValueThing(v, res.name, value );
+        newThing.setJSON( { [res.jsonName]: res.value });
         newCollection.append(newThing);
       }
 
@@ -1783,23 +1787,21 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     return dTypeName;
   }
 
-  function stripCollection(typeName) {
-    const match = typeName.match(/^Collection\((.+)\)/);
-    if (match) {
-      typeName = match[1];
+  function stripCollection( typeName ) {
+    if (typeName) {
+      const match = typeName.match(/^Collection\((.+)\)/);
+      if (match)
+        return [ match[1], true ];
     }
-    return typeName;
+
+    return [ typeName, false ];
   }
 
   function isPrimitiveType(typeName) {
     return typeName.split('.')[0] === 'Edm';
   }
 
-  function isCollection(typeName) {
-    return typeName.match(/^Collection\((.+)\)/) !== null;
-  }
-
-  function isEnumType(dTypeName) {
+  function isEnumType( dTypeName ) {
     const type = getDictType(dTypeName);
     return type && type['$kind'] === 'EnumType';
   }

package/lib/edm/annotations/preprocessAnnotations.js

@@ -40,11 +40,11 @@ function preprocessAnnotations(csn, serviceName, options) {
     const keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
     if (keyNames.length === 0) {
       keyNames.push('MISSING');
-      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'nokey' },
-      'target $(NAME) has no key');
+      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'nokey' } );
+    }
+    else if (keyNames.length > 1) {
+      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'multkeys' });
     }
-    else if (keyNames.length > 1)
-      message('odata-anno-preproc', null, { anno, name: targetName, '#': 'multkeys' });
 
     return keyNames[0];
   }

package/lib/edm/csn2edm.js

@@ -745,7 +745,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           if(rt) // add EntitySet attribute only if return type is a non abstract entity
           {
             const definition = schemaCsn.definitions[rt];
-            if(definition && definition.kind === 'entity' && !definition.abstract)
+            if (definition && definition.kind === 'entity' && !definition.abstract && !edmUtils.isSingleton(definition))
             {
               actionImport.setEdmAttribute('EntitySet', edmUtils.getBaseName(rt));
             }
@@ -1104,6 +1104,16 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
                 { type:edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet' });
             }
           });
+          if (edmType === 'Edm.Decimal') {
+            const precision = Number.parseInt(p._edmAttributes.Precision, 10);
+            const scale = Number.parseInt(p._edmAttributes.Scale, 10);
+            if (!Number.isNaN(precision) && !Number.isNaN(scale) && scale > precision) {
+              message('odata-spec-violation-type', pLoc,
+                {
+                  type: edmType, number: scale, rawvalue: precision, ersion: (p.v4 ? '4.0' : '2.0'), '#': 'scale',
+                });
+            }
+          }
         }
         else {
           message('odata-spec-violation-type-unknown', pLoc,

package/lib/edm/edmUtils.js

@@ -610,7 +610,7 @@ function addTypeFacets(node, csn)
       // map both floating and variable to => variable
       if(node._edmAttributes.Scale === 'floating')
         node.setEdmAttribute('Scale', 'variable');
-      if(!csn.precision && !csn.scale)
+      if (csn.precision == null && csn.scale == null)
         // if Decimal has no p, s set scale 'variable'
         node.setXml( { Scale: 'variable' } ); // floating is V4.01
     }

package/lib/transform/db/applyTransformations.js

@@ -17,8 +17,8 @@ const { setProp } = require('../../base/model');
  * @param {object} parent The "parent" of which we transform a property of
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {applyTransformationsOptions} [options={}]
+ * @param {Function[]} [artifactTransformers] Transformations to run on the artifacts, like forEachDefinition
+ * @param {applyTransformationsOptions} [options]
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
@@ -165,8 +165,8 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
  *
  * @param {object} csn CSN to enrich in-place
  * @param {object} customTransformers Map of _prop to transform and function to apply
- * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {applyTransformationsOptions} [options={}]
+ * @param {Function[]} [artifactTransformers] Transformations to run on the artifacts, like forEachDefinition
+ * @param {applyTransformationsOptions} [options]
  * @returns {object} CSN with transformations applied
  */
 function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], options = { } ) {
@@ -192,7 +192,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
  * @param {object} parent The "parent" of which we transform a property of
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {applyTransformationsOptions} [options={}]
+ * @param {applyTransformationsOptions} [options]
  * @param {CSN.Path} path Path pointing to parent
  * @returns {object} parent[prop] with transformations applied
  */
@@ -213,7 +213,7 @@ function applyTransformationsOnNonDictionary( parent, prop, customTransformers =
  *
  * @param {object} dictionary Dictionary to enrich in-place
  * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {applyTransformationsOptions} [options={}]
+ * @param {applyTransformationsOptions} [options]
  * @param {CSN.Path} path Path pointing to parent
  * @returns {object} dictionary with transformations applied
  */

package/lib/transform/db/expansion.js

@@ -18,13 +18,11 @@ const { forEach } = require('../../utils/objectUtils');
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
  * @param {object} messageFunctions
- * @param {Function} messageFunctions.error
- * @param {Function} messageFunctions.info
- * @param {Function} messageFunctions.throwWithAnyError
  * @param {object} csnUtils
  * @param {object} [iterateOptions]
  */
-function expandStructureReferences( csn, options, pathDelimiter, { error, info, throwWithAnyError }, csnUtils, iterateOptions = {} ) {
+function expandStructureReferences( csn, options, pathDelimiter, messageFunctions, csnUtils, iterateOptions = {} ) {
+  const { error, info, throwWithAnyError } = messageFunctions;
   const {
     isStructured, get$combined, getFinalTypeInfo,
   } = csnUtils;
@@ -32,7 +30,6 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
 
   rewriteExpandInline();
 
-
   applyTransformations(csn, {
     keys: (parent, name, keys, path) => {
       parent.keys = expand(keys, path.concat('keys'), true);
@@ -519,7 +516,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
    *
    * @param {Array} thing
    * @param {CSN.Path} path
-   * @param {boolean} [withAlias=false] Whether to "expand" the (implicit) alias aswell.
+   * @param {boolean} [withAlias] Whether to "expand" the (implicit) alias aswell.
    * @returns {Array} New array - with all structured things expanded
    */
   function expand( thing, path, withAlias = false ) {
@@ -538,6 +535,18 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         col.as = implicitAs(col.ref);
         newThing.push(col);
       }
+      else if (col.cast?.type) {
+        // TODO: Support expanding `null as field : StructuredT`
+        const _art = col.cast._type || inspectRef(path.concat(i, 'cast', 'type')).art;
+        if (_art && isStructured(_art)) {
+          error('type-invalid-cast', path.concat(i, 'cast', 'type'), {
+            '#': col.val !== undefined ? 'val-to-structure' : 'expr-to-structure', value: col.val,
+          });
+        }
+        else {
+          newThing.push(col);
+        }
+      }
       else {
         newThing.push(col);
       }
@@ -608,7 +617,7 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
    *
    * @param {object} base The raw set of things a * can expand to
    * @param {Array} subs Things - the .expand/.inline or .columns
-   * @param {string[]} [excluding=[]]
+   * @param {string[]} [excluding]
    * @returns {Array} If there was a star, expand it and handle shadowing/excluding, else just return subs
    */
   function replaceStar( base, subs, excluding = [] ) {

package/lib/transform/db/flattening.js

@@ -192,7 +192,7 @@ function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, ite
    * For each step of the links, check if there is a type reference.
    * If there is, resolve it and store the result in a WeakMap.
    *
-   * @param {Array} [links=[]]
+   * @param {Array} [links]
    * @todo seems too hacky
    * @returns {WeakMap} A WeakMap where a link is the key and the type is the value
    */

package/lib/transform/db/transformExists.js

@@ -63,6 +63,8 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           if (query.SELECT && query.SELECT.where && query.SELECT.where.length > 1)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
 
+          if (query.SELECT && query.SELECT.having?.length > 1)
+            toProcess.push([ path.slice(0, -1), path.concat('having') ]);
 
           if (query.SELECT && query.SELECT.columns)
             toProcess.push([ path.slice(0, -1), path.concat('columns') ]);

package/lib/transform/forOdataNew.js

@@ -98,7 +98,9 @@ function transform4odataWithCsn(inputModel, options) {
     inspectRef,
     artifactRef,
     effectiveType,
-    getFinalTypeInfo
+    getFinalTypeInfo,
+    dropDefinitionCache,
+    initDefinition,
   } = csnUtils;
 
   // are we working with structured OData or not
@@ -147,6 +149,8 @@ function transform4odataWithCsn(inputModel, options) {
       // TODO: handle artifact.projection instead of artifact.query correctly in future V2
       if (def.kind === 'entity' && def.projection) {
         def.query = { SELECT: def.projection };
+        dropDefinitionCache(def);
+        initDefinition(def);
       }
     }],
     { skipArtifact: isExternalServiceMember }

package/lib/transform/localized.js

@@ -13,6 +13,7 @@ const {
   forAllQueries,
   sortCsnDefinitionsForTests,
 } = require('../model/csnUtils');
+const {CompilerAssertion} = require('../base/error');
 
 /**
  * Indicator that a definition is localized and has a convenience view.
@@ -577,14 +578,22 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     if (!obj || !obj.ref)
       return;
     const ref = Array.isArray(obj.ref) ? obj.ref[0] : obj.ref;
-    if (typeof ref !== 'string')
-      return;
-    const def = csn.definitions[ref];
-    if (def && def[_hasLocalizedView]) {
-      if (Array.isArray(obj.ref))
-        obj.ref[0] = def[_hasLocalizedView];
-      else
+    if (typeof ref === 'string') {
+      const def = csn.definitions[ref];
+      if (def && def[_hasLocalizedView]) {
+        if (Array.isArray(obj.ref))
+          obj.ref[0] = def[_hasLocalizedView];
+        else
         obj.ref = def[_hasLocalizedView];
+      }
+
+    } else if (ref.id) {
+      const def = csn.definitions[ref.id];
+      if (def && def[_hasLocalizedView])
+        obj.ref[0].id = def[_hasLocalizedView];
+
+    } else if (options.testMode) {
+      throw new CompilerAssertion('Debug me: Unhandled reference during localized-rewrite!');
     }
   }
 

package/lib/transform/translateAssocsToJoins.js

@@ -730,7 +730,8 @@ function translateAssocsToJoins(model, inputOptions = {})
         // this will substitute multiple backlink conditions ($self = ... AND $self = ...AND ...)
         if(expr.op) {
           let x = clone(expr);
-          x.args = expr.args.map(cloneOnCondition);
+          if(expr.args)
+            x.args = expr.args.map(cloneOnCondition);
           return x;
         }
 

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -328,9 +328,9 @@ module.exports = (csn, options) => {
      * passed to this function.
      *
      * @param {CSN.Element}  member
-     * @param {object}       [except=null] List of properties which should not be propagated along the origin chain
+     * @param {object}       [except] List of properties which should not be propagated along the origin chain
      *                                     of the `member`
-     * @param {object}       [force=null]  Overwrite any member propagation rules or any except and always propagate the corresponding keys
+     * @param {object}       [force]  Overwrite any member propagation rules or any except and always propagate the corresponding keys
      */
     function propagateMemberPropsFromOrigin( member, except = null, force = null ) {
       const memberChain = getOriginChain(member);
@@ -613,8 +613,8 @@ module.exports = (csn, options) => {
  * @param {object} to
  * @param {Function} getCustomRule getter for the `memberProps` or `defProps`
  *                                 which shall be used for retrieving custom rules
- * @param {object} [except=null] array of properties which should not be propagated
- * @param {object} [force=null] Force propagation of the contained keys via a custom rule.
+ * @param {object} [except] array of properties which should not be propagated
+ * @param {object} [force] Force propagation of the contained keys via a custom rule.
  */
 function copyProperties( from, to, getCustomRule, except = null, force = null ) {
   const keys = Object.keys(from);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "3.9.8",
+  "version": "3.9.12",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",