@sap/cds-compiler 5.7.2 → 5.8.0

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.2",
+  "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`

package/share/messages/rewrite-undefined-key.md

@@ -0,0 +1,94 @@
+# rewrite-undefined-key
+
+The compiler isn’t able to rewrite an association's foreign keys,
+because the redirected target is missing elements to match them.
+
+The message's severity is `Error`.
+
+## Example
+
+Erroneous code example:
+
+```cds
+entity model.Base {
+  key ID : UUID;
+  toTarget : Association to model.Target; // (1)
+}
+entity model.Target {
+  key ID : UUID; // (2)
+  field : String;
+}
+
+service S {
+  entity Base as projection on model.Base; // ❌ (3) Can't redirect 'toTarget'
+
+  entity Target as projection on model.Target {
+    field, // (4) No 'ID'
+  };
+}
+```
+
+In the example, the projected association `toTarget` at (3) in entity
+`S.Base` can't be redirected to `S.Target`, because `S.Target` does not
+project element `ID` (4).
+
+`toTarget` (1) is a managed association and hence foreign keys are inferred
+for it.  The compiler generates a foreign key `ID`, which corresponds to
+element `ID` of `model.Target` (2).
+
+As both entities are exposed in service `S`, the compiler tries to redirect
+`S.Base:toTarget` to an entity inside the same service, to create
+a “self-contained” service.  It notices, however, that `S.Target` does not
+have element `ID`, and therefore can't match the foreign key to a target
+element and emits this error message.
+
+## How to Fix
+
+If you don't need to expose association `toTarget` in `S.Target`, you can
+exclude it in the projection via an `excluding` clause.
+
+```cds
+service S {
+  entity Base as projection on model.Base
+    excluding { toTarget };
+  // ...
+}
+```
+
+If the association is required in the service, you need to either project
+element `ID` in `S.Target`, or redirect the association explicitly.
+
+The easiest fix is to select `ID` explicitly:
+```cds
+service S {
+  // ...
+  entity Target as projection on model.Target {
+    field, ID, // Explicitly select element ID
+  };
+}
+```
+
+However, if you don't want to expose `ID`, redirect association `toTarget`
+explicitly, matching the foreign key to another element:
+
+```cds
+service S {
+  entity Base as projection on model.Base {
+    ID,
+    toTarget : redirected to Target { fakeID as ID }, // (1)
+  };
+  entity Target as projection on model.Target {
+    calculateKey() as fakeID : UUID,                  // (2)
+    field,
+  };
+}
+```
+
+Note that at (1), we use element `fakeID` of `S.Target` as foreign key `ID`.
+That changes its semantic meaning and may not be feasible in all cases!
+In the example, we assume at (2) that a key can be calculated.
+
+
+## Related Messages
+
+- `rewrite-not-supported`