@sap/cds-compiler 5.7.4 → 5.8.0

package/lib/transform/odata/createForeignKeys.js

@@ -2,9 +2,9 @@
 
 const { isBuiltinType } = require('../../base/builtins');
 const { setProp } = require('../../base/model');
-const { applyTransformations, implicitAs, findAnnotationExpression, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
+const { applyTransformations, implicitAs, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
-const adaptAnnotationsRefs = require('./adaptAnnotationRefs');
+const { adaptAnnotationsRefs } = require('./adaptAnnotationRefs');
 
 function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
 
@@ -28,20 +28,20 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
         orderedElements.push([ elementName, element ]);
         if (!csnUtils.isManagedAssociation(element)) return;
         const elementPath = path.concat(prop, elementName);
-        const generatedForeignKeys = createForeignKeysForElement(csnUtils, elementPath, element, elementName, csn, options, '_');
+        const generatedForeignKeys = createForeignKeysForElement(elementPath, element, elementName, csn, options, '_');
 
         // Second, finalize the generated FK elements
         const refCount = generatedForeignKeys.reduce((acc, fk) => {
           // count duplicates
-          if (acc[fk[0]])
-            acc[fk[0]]++;
+          if (acc[fk.prefix])
+            acc[fk.prefix]++;
           else
-            acc[fk[0]] = 1;
+            acc[fk.prefix] = 1;
 
           // check for name clash with existing elements
-          if (parent[prop][fk[0]] && isDeepEqual(element, parent[prop][fk[0]], true)) {
+          if (parent[prop][fk.prefix] && isDeepEqual(element, parent[prop][fk.prefix], true)) {
             // error location is the colliding element
-            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
+            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk.prefix, art: elementName });
           }
           // attach a proper $path
           setProp(element, '$path', elementPath);
@@ -50,7 +50,7 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
 
         // set default for single foreign key from association (if available)
         if (element.default?.val !== undefined && generatedForeignKeys.length === 1)
-        generatedForeignKeys[0][1].default = element.default;
+        generatedForeignKeys[0].foreignKey.default = element.default;
 
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
@@ -63,8 +63,8 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
         }
 
         adaptAnnotationsRefs(generatedForeignKeys, csnUtils, messageFunctions);
-        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk[0]));
-        orderedElements.push(...generatedForeignKeys);
+        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk.prefix));
+        orderedElements.push(...generatedForeignKeys.map(gfk => [ gfk.prefix, gfk.foreignKey ]));
       
     });
 
@@ -74,123 +74,127 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
     }, Object.create(null));
   }
 
-function createForeignKeysForElement(csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalkey = {} ) {
-  const special$self = !csn?.definitions?.$self && '$self';
-  const isInspectRefResult = !Array.isArray(path);
+  function createForeignKeysForElement(path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalKey = {} ) {
+    const special$self = !csn?.definitions?.$self && '$self';
+    const isInspectRefResult = !Array.isArray(path);
 
-  let fks = [];
-  if (!element)
-    return fks;
+    let fks = [];
+    if (!element)
+      return fks;
 
-  let finalElement = element;
-  let finalTypeName;
+    let finalElement = element;
+    let finalTypeName;
 
-  // resolve derived type
-  if (element.type && !isBuiltinType(element.type) && element.type !== special$self) {
-    const tmpElt = csnUtils.effectiveType(element);
-    // effective type resolves to structs and enums only but not scalars
-    if (Object.keys(tmpElt).length) {
-      finalElement = tmpElt;
-      finalTypeName = finalElement.$path[1];
-    }
-    else {
-      // unwind a derived type chain to a scalar type
-      while (finalElement?.type && !isBuiltinType(finalElement?.type)) {
-        finalTypeName = finalElement.type;
-        finalElement = csn.definitions[finalElement.type];
+    // resolve derived type
+    if (element.type && !isBuiltinType(element.type) && element.type !== special$self) {
+      const tmpElt = csnUtils.effectiveType(element);
+      // effective type resolves to structs and enums only but not scalars
+      if (Object.keys(tmpElt).length) {
+        finalElement = tmpElt;
+        finalTypeName = finalElement.$path[1];
+      }
+      else {
+        // unwind a derived type chain to a scalar type
+        while (finalElement?.type && !isBuiltinType(finalElement?.type)) {
+          finalTypeName = finalElement.type;
+          finalElement = csn.definitions[finalElement.type];
+        }
       }
     }
-  }
 
-  if (!finalElement)
-    return [];
-
-  // main if for this function
-  // the element is a managed association
-  if (csnUtils.isManagedAssociation(finalElement)) {
-    finalElement.keys.forEach((key, keyIndex) => {
-      const continuePath = getContinuePath([ 'keys', keyIndex ]);
-      const alias = key.as || implicitAs(key.ref);
-      const result = csnUtils.inspectRef(continuePath);
-      let gfks = createForeignKeysForElement(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1,
-        lvl === 0 ? { ref: key.ref, as: key.as, $path: key.$path, $originalKeyRef: key.$originalKeyRef } : originalkey);
+    if (!finalElement)
+      return [];
+
+    // main if for this function
+    // the element is a managed association
+    if (csnUtils.isManagedAssociation(finalElement)) {
+      finalElement.keys.forEach((key, keyIndex) => {
+        const continuePath = getContinuePath([ 'keys', keyIndex ]);
+        const alias = key.as || implicitAs(key.ref);
+        const result = csnUtils.inspectRef(continuePath);
+        let gfks = createForeignKeysForElement(result, result.art, alias, csn, options, pathDelimiter, lvl + 1,
+          lvl === 0 ? key : originalKey);
+        if (lvl === 0) {
+          gfks.forEach(gfk => gfk.keyAnnotations.push( ...copyAnnotations(key, gfk.foreignKey)));
+          Object.keys(key).forEach( prop => {
+            // once applied -> remove the annotations from the keys array, to keep the OData CSN size as small as possible
+            if (prop[0] === '@')
+              delete key[prop]
+          });
+        }
+        fks = fks.concat(gfks);
+      });
+    }
+    // the element is a structure
+    else if (finalElement.elements) {
+      Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
+        // Skip already produced foreign keys
+        if (!elem['@odata.foreignKey4']) {
+          const continuePath = getContinuePath([ 'elements', elemName ]);
+          fks = fks.concat(createForeignKeysForElement(continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1, originalKey));
+        }
+      });
+    }
+    // we have reached a leaf element, create a foreign key
+    else if ((finalElement.type == null || isBuiltinType(finalElement.type)) && !finalElement.on) {
+      const newFk = Object.create(null);
+      [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
+        // copy props from original element to preserve derived types!
+        if (element[prop] !== undefined)
+          newFk[prop] = element[prop];
+      });
+      return [ { prefix, foreignKey: newFk, originalKey, keyAnnotations: [] } ];
+    }
+
+    fks.forEach((fk) => {
+      // prepend current prefix
+      fk.prefix = `${prefix}${pathDelimiter}${fk.prefix}`;
+      // if this is the entry association, decorate the final foreign keys with the association props/annos
       if (lvl === 0) {
-        gfks.forEach(gfk => copyAnnotations(key, gfk[1]));
-        // once applied -> remove the annotations from the keys array, to keep the OData CSN size as small as possible
-        Object.keys(key).forEach( prop => {
-          if (prop[0] === '@') delete key[prop]
-        });
-      }
-      fks = fks.concat(gfks);
-    });
-  }
-  // the element is a structure
-  else if (finalElement.elements) {
-    Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
-      // Skip already produced foreign keys
-      if (!elem['@odata.foreignKey4']) {
-        const continuePath = getContinuePath([ 'elements', elemName ]);
-        fks = fks.concat(createForeignKeysForElement(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1, originalkey));
+        fk.foreignKey['@odata.foreignKey4'] = prefix;
+
+        const fkPath = path.slice(0, path.length - 1);
+        fkPath.push(fk.prefix);
+        setProp(fk.foreignKey, '$path', fkPath);
+
+        const allowedOverwriteAnnotationNames = ['@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`)];
+        const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !allowedOverwriteAnnotationNames.includes(pn));
+        copyAnnotations(element, fk.foreignKey, false, {}, validAnnoNames);
+        const overwriteAnnoNames = Object.keys(element).filter(pn => allowedOverwriteAnnotationNames.includes(pn));
+        copyAnnotations(element, fk.foreignKey, true, {}, overwriteAnnoNames);
+
+        // propagate not null to final foreign key
+        for (const prop of [ 'notNull', 'key' ]) {
+          if (element[prop] !== undefined)
+            fk.foreignKey[prop] = element[prop];
+        }
+        if (element.$location)
+          setProp(fk.foreignKey, '$location', element.$location);
       }
     });
-  }
-  // we have reached a leaf element, create a foreign key
-  else if ((finalElement.type == null || isBuiltinType(finalElement.type)) && !finalElement.on) {
-    const newFk = Object.create(null);
-    [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
-      // copy props from original element to preserve derived types!
-      if (element[prop] !== undefined)
-        newFk[prop] = element[prop];
-    });
-    return [ [ prefix, newFk, originalkey ] ];
-  }
+    return fks;
 
-  fks.forEach((fk) => {
-    // prepend current prefix
-    fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
-    // if this is the entry association, decorate the final foreign keys with the association props/annos
-    if (lvl === 0) {
-      if (options.transformation !== 'effective')
-        fk[1]['@odata.foreignKey4'] = prefix;
-
-      const allowedOverwriteAnnotationNames = ['@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`)];
-      const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !allowedOverwriteAnnotationNames.includes(pn) && !findAnnotationExpression(element, pn));
-      copyAnnotations(element, fk[1], false, {}, validAnnoNames);
-      const overwriteAnnoNames = Object.keys(element).filter(pn => allowedOverwriteAnnotationNames.includes(pn) && !findAnnotationExpression(element, pn));
-      copyAnnotations(element, fk[1], true, {}, overwriteAnnoNames);
-
-      // propagate not null to final foreign key
-      for (const prop of [ 'notNull', 'key' ]) {
-        if (element[prop] !== undefined)
-          fk[1][prop] = element[prop];
-      }
-      if (element.$location)
-        setProp(fk[1], '$location', element.$location);
+    /**
+     * Get the path to continue resolving references
+     *
+     * If we are currently inside of a type, we need to start our path fresh from that given type.
+     * Otherwise, we would try to resolve .elements on a thing that does not exist.
+     *
+     * We also respect if we have a previous inspectRef result as our base.
+     *
+     * @param {Array} additions
+     * @returns {CSN.Path}
+     */
+    function getContinuePath( additions ) {
+      if (csn.definitions[finalElement.type])
+        return [ 'definitions', finalElement.type, ...additions ];
+      else if (finalTypeName)
+        return [ 'definitions', finalTypeName, ...additions ];
+      else if (isInspectRefResult)
+        return [ path, ...additions ];
+      return [ ...path, ...additions ];
     }
-  });
-  return fks;
-
-  /**
-   * Get the path to continue resolving references
-   *
-   * If we are currently inside of a type, we need to start our path fresh from that given type.
-   * Otherwise, we would try to resolve .elements on a thing that does not exist.
-   *
-   * We also respect if we have a previous inspectRef result as our base.
-   *
-   * @param {Array} additions
-   * @returns {CSN.Path}
-   */
-  function getContinuePath( additions ) {
-    if (csn.definitions[finalElement.type])
-      return [ 'definitions', finalElement.type, ...additions ];
-    else if (finalTypeName)
-      return [ 'definitions', finalTypeName, ...additions ];
-    else if (isInspectRefResult)
-      return [ path, ...additions ];
-    return [ ...path, ...additions ];
   }
 }
-}
 
 module.exports = createForeignKeyElements;

package/lib/transform/odata/flattening.js

@@ -14,7 +14,7 @@ const { forEach } = require('../../utils/objectUtils');
 const { assignAnnotation } = require('../../edm/edmUtils');
 
 function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options) {
-  const allMgdAssocDefs = []; 
+  const allMgdAssocDefs = [];
   forEachDefinition(csn, (def, defName) => {
     if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
       ['elements', 'params'].forEach(dictName => {
@@ -345,7 +345,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
           // try to find rightmost 'items', terminate if association comes first.
           let i = links.length-1;
           const getProp = (propName) => links[i].art?.[propName];
-  
+
           let hasItems = false;
           for(; i >= 0 && !getProp('target') && !hasItems; i--) {
             const art = links[i].art;
@@ -361,7 +361,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
                   name: refCheck.eltLocationStr,
                   '#': 'flatten_builtin'
                 });
-            }  
+            }
           }
         }
       }
@@ -467,7 +467,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
         let comeFromSameDef = flatElt.$defPath.slice(0, flatElt.$defPath.length - 1).join('.') === se[1].$defPath.slice(0, se[1].$defPath.length - 1).join('.');
         return (comeFromSameDef && (se[1]['@odata.foreignKey4'] && se[1]['@odata.foreignKey4'] === structuredAssocName) && se[0].startsWith(flatEltName))
       });
-    
+
     generatedForeignKeysForAssoc.forEach(gfk => gfk[1]['@odata.foreignKey4'] = flatEltName);
     // reassign the generated foreign keys for current assoc in order to assign
     // correct values for $generatedFieldName later on during flattenManagedAssocsAsKeys();
@@ -565,7 +565,7 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
       if (insideKeys(path))
         setProp(parent, '_art', art);
       const lastRef = ref[ref.length - 1];
-      const fn = (suspend = false, suspendPos = 0, 
+      const fn = (suspend = false, suspendPos = 0,
                     refFilter = (_parent) => true) => {
         if (refFilter(parent)) {
           const scopedPath = [ ...parent.$path ];
@@ -573,9 +573,11 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
           //       full path into target, uncomment this line and
           //       comment/remove setProp in expansion.js
           // setProp(parent, '$structRef', parent.ref);
+          const flattenParameters = true; // structured parameters are flattened
           const [ newRef, refChanged ] = flattenStructStepsInRef(ref,
               scopedPath, links, scope, resolvedLinkTypes,
-              suspend, suspendPos, parent.$bparam);
+              suspend, suspendPos, parent.$bparam,
+              flattenParameters);
           parent.ref = newRef;
           resolved.set(parent, { links, art, scope });
           // Explicitly set implicit alias for things that are now flattened - but only in columns
@@ -628,7 +630,7 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
             annoExpr['='] = true;
         });
       }
-      else 
+      else
         adaptRefs.push(fn);
     },
   }
@@ -679,7 +681,7 @@ function replaceManagedAssocsAsKeys(allFlatManagedAssocDefinitions, csnUtils) {
       return done;
     }
   });
-  
+
   function cloneAndExtendRef(keyAssocKey, key) {
     let newKey = { ref:  [`${key.ref.join('_')}_${keyAssocKey.as || keyAssocKey.ref.join('_')}`] };
     setProp(newKey, '_art', keyAssocKey._art);

package/lib/transform/transformUtils.js

@@ -4,12 +4,12 @@
 // different backends.
 // The sibling of model/transform/TransformUtil.js which works with compacted new CSN.
 
-const { setProp } = require('../base/model');
+const { setProp, isBetaEnabled } = require('../base/model');
 
-const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand, transformAnnotationExpression } = require('../model/csnUtils');
+const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand, isDeepEqual } = require('../model/csnUtils');
 const { getUtils } = require('../model/csnUtils');
 const { typeParameters } = require('../compiler/builtins');
-const { isBuiltinType, isAnnotationExpression } = require('../base/builtins');
+const { isBuiltinType } = require('../base/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
 const { cloneCsnNonDict, cloneCsnDict } = require('../model/cloneCsn');
@@ -44,6 +44,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     toFinalBaseType,
     createExposingProjection,
     createAndAddDraftAdminDataProjection,
+    isValidDraftAdminDataMessagesType,
     createScalarElement,
     createAssociationElement,
     createAssociationPathComparison,
@@ -195,24 +196,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         '@odata.Collation': 1,
         '@odata.Unicode': 1,
       } : {};
-      const annoNames = copyAnnotations(elem, flatElem, false, excludes);
-      if(options.transformation === 'effective') {
-        for(const annoName of annoNames) {
-          if(flatElem.keys && isAnnotationExpression(elem[annoName])) {
-            flatElem.keys.forEach(key => {
-              if(!key[annoName]) {
-                key[annoName] = flatElem[annoName];
-                transformAnnotationExpression(key, annoName, {
-                  ref: (parent, prop, ref) => {
-                    if(ref[0] !== '$self')
-                      parent.ref = ['$self', ...parent.ref];
-                  }
-                })
-              }
-            })
-          }
-        }
-      }
+      
+      copyAnnotations(elem, flatElem, false, excludes);
 
       // Copy selected type properties
       const props = ['key', 'virtual', 'masked', 'viaAll'];
@@ -243,15 +228,20 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    * @param {bool} [suspend] suspend flattening by caller until association path step
    * @param {int} [suspendPos] suspend if starting pos is lower or equal to suspendPos and suspend is true
    * @param {bool} [revokeAtSuspendPos] revoke suspension after suspendPos (binding parameter path use case)
+   * @param {bool} [flattenParameters] Whether to flatten references into structured parameters. OData flattens parameters, SQL/for.effective does not.
+   *
+   * @todo: Refactor to take config object instead of N boolean arguments.
    * @returns [string[], bool]
    */
-  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0, revokeAtSuspendPos=false) {
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0, revokeAtSuspendPos=false, flattenParameters = false) {
+    // A path is absolute if it starts with $self or a parameter. Then we must not flatten the first path step.
+    const pathIsAbsolute = scope === '$self' || (!flattenParameters && scope === 'param');
     // Refs of length 1 cannot contain steps - no need to check
-    if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
+    if (ref.length < 2 || (pathIsAbsolute && ref.length === 2)) {
       return [ ref, false ];
     }
 
-    const result = scope === '$self' ? [ref[0]] : [];
+    const result = pathIsAbsolute ? [ref[0]] : [];
     //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
     if(!links && !scope) { // calculate JIT if not supplied
       const res = inspectRef(path);
@@ -262,7 +252,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       return [ ref, false ];
 
     // Don't process a leading $self - it will a .art with .elements!
-    let i = scope === '$self' ? 1 : 0;
+    let i = pathIsAbsolute ? 1 : 0;
 
     // read property from resolved path link
     const art = (propName) =>
@@ -413,6 +403,11 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!draftAdminDataEntity) {
       draftAdminDataEntity = createAndAddDraftAdminDataEntity();
       model.definitions['DRAFT.DraftAdministrativeData'] = draftAdminDataEntity;
+      if (isBetaEnabled(options, 'draftMessages')
+          && options.transformation === 'odata'
+          && !model.definitions['DRAFT.DraftAdministrativeData_DraftMessage']) {
+        model.definitions['DRAFT.DraftAdministrativeData_DraftMessage'] = createDraftAdminDataMessagesType();
+      }
       if(options.tenantDiscriminator && options.transformation !== 'odata')
         addTenantFieldToArt(model.definitions['DRAFT.DraftAdministrativeData'], options);
     }
@@ -481,10 +476,48 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       draftIsProcessedByMe.DraftIsProcessedByMe['@Common.Label'] = '{i18n>Draft_DraftIsProcessedByMe}';
       addElement(draftIsProcessedByMe, artifact, artifactName);
 
+      if (isBetaEnabled(options, 'draftMessages')) {
+        const messages = { DraftMessages: { } };
+        if (options.transformation === 'odata') {
+          messages.DraftMessages = { items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } };
+        } else {
+          messages.DraftMessages = { type: 'cds.LargeString' };
+        }
+        messages.DraftMessages['@cds.api.ignore'] = true;
+        addElement(messages , artifact, artifactName);
+      }
+
       return artifact;
     }
   }
 
+  // Create the artificial 'DRAFT.Draf tAdministrativeData_DraftMessage' type
+  // for the beta feature 'draftMessages'
+  function createDraftAdminDataMessagesType() {
+    const messagesType = {
+      kind: 'type',
+      elements: Object.create(null)
+    }
+
+    addElement(createScalarElement('code', 'cds.String'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    addElement(createScalarElement('message', 'cds.String'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    addElement(createScalarElement('target', 'cds.String'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    addElement({ 'additionalTargets': createScalarElement('items', 'cds.String') }, messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    addElement(createScalarElement('transition', 'cds.Boolean'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    addElement(createScalarElement('numericSeverity', 'cds.UInt8'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    addElement(createScalarElement('longtextUrl', 'cds.String'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    // the tag element not needed for now, but might be added later on
+    // addElement(createScalarElement('tag', 'cds.String'), messagesType, 'DRAFT.DraftAdministrativeData_DraftMessage');
+    // setAnnotation(messagesType.tag, '@cds.api.ignore', true);
+    return messagesType;
+  }
+
+  // Checks if the given definition is a valid 'DRAFT.DraftAdministrativeData_DraftMessage' type
+  function isValidDraftAdminDataMessagesType(def) {
+    const expectedType = createDraftAdminDataMessagesType();
+    return isDeepEqual(def, expectedType, false);
+  }
+
   // Create an artificial scalar element 'elemName' with final type 'typeName'.
   // Make the element a key element if 'isKey' is true.
   // Add a default value 'defaultVal' if supplied

package/lib/transform/translateAssocsToJoins.js

@@ -50,6 +50,7 @@ function translateAssocsToJoinsCSN(csn, options){
   // FIXME: Move this somewhere more appropriate
   const newCsn = compactModel(model, compileOptions);
   //require('fs').writeFileSync('./csnoutput_a2j.json', JSON.stringify(newCsn, null,2))
+  //console.log('CSN returned by A2J:',JSON.stringify(newCsn,null,2))
   return newCsn;
 }
 
@@ -607,6 +608,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             args: [ constructPathNode( [ srcAlias, prefixFK(assoc.$elementPrefix, assoc.$flatSrcFKs[i]) ] ),
                     constructPathNode( [ tgtAlias, assoc.$flatTgtFKs[i] ] ) ] });
         }
+        // TODO: why inner "parenthesise" - comparison in `and`?
         return parenthesise((args.length > 1 ? { op: { val: 'and' }, args: [ ...args.map(parenthesise) ] } : args[0] ));
       }
       else {
@@ -689,7 +691,8 @@ function translateAssocsToJoins(model, inputOptions = {})
       // clone ON condition with rewritten paths and substituted backlink conditions
       function cloneOnCondition(expr)
       {
-        if(expr.op?.val === 'xpr')
+        const op = expr.op?.val;
+        if(op === 'xpr' || op === 'ixpr' || op === 'nary')
           return cloneOnCondExprStream(expr);
         else
           return cloneOnCondExprTree(expr);
@@ -700,7 +703,8 @@ function translateAssocsToJoins(model, inputOptions = {})
         const result = { op: { val: expr.op.val }, args: [ ] };
         for(let i = 0; i < args.length; i++)
         {
-          if(args[i].op?.val === 'xpr')
+          const op = args[i].op?.val;
+          if(op === 'xpr' || op === 'ixpr' || op === 'nary')
           {
             result.args.push(cloneOnCondition(args[i]));
           }
@@ -1890,15 +1894,15 @@ function walk(node, env)
 function walkPath(node, env)
 {
   const path = node.path;
-  // Ignore paths that that have no artifact (function calls etc) or that are builtins ($now, $user)
+  // Ignore paths that have no artifact (function calls etc.) or that are builtins ($now, $user)
   // or that are parameters ($parameters or escaped paths (':')
   //path.length && path[ path.length-1 ]._artifact
-  const art = path && path.length && path[path.length-1]._artifact;
+  const art = path?.length && path[path.length-1]._artifact;
 
   // regardless of the position in the query, ignore paths that have virtual path steps
-  if(art && path.some(ps => ps._artifact && ps._artifact.virtual && ps._artifact.virtual.val))
+  if(art && path.some(ps => ps._artifact?.virtual?.val))
     return path;
-  if(art && !internalArtifactKinds.includes(art.kind))
+  if(art && !internalArtifactKinds.includes(art.kind) && node.scope !== 'param')
   {
     if(env.callback)
     {

package/lib/transform/universalCsn/coreComputed.js

@@ -21,8 +21,12 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
 
   forEachDefinition(csn, (artifact, name, prop, path) => {
     if (artifact.query || artifact.projection) {
+      // For events and types, the query is only used for inferring the element signature.
+      // There, we don't want to set `@Core.Computed`.
+      const queryForSignatureOnly = artifact.kind === 'type' || artifact.kind === 'event';
       forAllQueries(getNormalizedQuery(artifact).query, (query) => {
-        if (query.SELECT)
+        const isTopLevelQuery = query.SELECT === (artifact.query?.SELECT || artifact.projection);
+        if (query.SELECT && (!isTopLevelQuery || !queryForSignatureOnly))
           traverseQueryAndAttachCoreComputed(query, query.SELECT.elements || artifact.elements);
       }, path);
     }

package/package.json

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

package/share/messages/message-explanations.json

@@ -12,6 +12,7 @@
     "redirected-to-complex",
     "redirected-to-unrelated",
     "rewrite-not-supported",
+    "rewrite-undefined-key",
     "syntax-expecting-unsigned-int",
     "type-missing-enum-value",
     "type-unexpected-foreign-keys",

package/share/messages/rewrite-not-supported.md

@@ -54,3 +54,8 @@ entity View as select from Base {
 In the corrected view above, the association `secondary` gets an explicit ON
 condition.  For this to work it is necessary to add `secondary_id` to the
 selection list, that means, we have to explicitly use the foreign key.
+
+
+## Related Messages
+
+- `rewrite-undefined-key`