@sap/cds-compiler 3.9.8 → 3.9.10

package/CHANGELOG.md

@@ -7,6 +7,16 @@
 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.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

@@ -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;

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
   // -----------------------------------------------------------------------------------
@@ -849,7 +857,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/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,11 @@ 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', '#': 'incompval' });
+        }
+        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
     }
     else {
@@ -1021,7 +1028,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 +1059,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 +1100,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 +1270,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 +1391,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 +1415,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 +1428,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 +1786,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/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);
@@ -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);
       }

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/package.json

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