@sap/cds-compiler 4.4.4 → 4.6.0

package/lib/transform/db/flattening.js

@@ -9,15 +9,15 @@ const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
-const { cardinality2str } = require('../../model/csnUtils');
-
+const { cardinality2str, isAnnotationExpression } = require('../../model/csnUtils');
+const { transformExpression } = require('./applyTransformations');
 /**
  * Strip off leading $self from refs where applicable
  *
  * @param {CSN.Model} csn
  */
 function removeLeadingSelf( csn ) {
-  const magicVars = [ '$now', '$self', '$projection', '$user', '$session', '$at' ];
+  const magicVars = [ '$now', '$self', '$projection', '$user', '$tenant', '$session', '$at' ];
   applyTransformations(csn, {
     elements: (parent, prop, elements) => {
       for (const [ elementName, element ] of Object.entries(elements)) {
@@ -42,11 +42,12 @@ function removeLeadingSelf( csn ) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {WeakMap} resolved Cache for resolved refs
  * @param {string} pathDelimiter
  * @param {object} iterateOptions
  */
-function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOptions = {} ) {
+function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDelimiter, iterateOptions = {} ) {
   /**
    * Remove .localized from the element and any sub-elements
    *
@@ -67,7 +68,7 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
         stack.push(...Object.values(current.elements));
     }
   }
-  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { getServiceName, getFinalTypeInfo } = csnUtils;
 
   // We don't want to iterate over actions
@@ -95,18 +96,17 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
 
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
-        let nextElements = node.elements || node.items?.elements;
-        if (nextElements) {
-          const stack = [ nextElements ];
-          while (stack.length > 0) {
-            const elements = stack.pop();
-            for (const e of Object.values(elements)) {
-              if (e.type && !isBuiltinType(e.type))
-                toFinalBaseType(e, resolved, true);
-              nextElements = e.elements || e.items?.elements;
-              if (nextElements)
-                stack.push(nextElements);
-            }
+        const nextElements = node.elements || node.items?.elements;
+        const stack = nextElements ? [ nextElements ] : [];
+        while (stack.length > 0) {
+          const elements = stack.pop();
+          for (const e of Object.values(elements)) {
+            toFinalBaseType(e, resolved, true);
+            if (!options.toOdata && e.items) // items could have unresolved types
+              toFinalBaseType(e.items, resolved, true);
+            const next = e.elements || e.items?.elements;
+            if (next)
+              stack.push(next);
           }
         }
 
@@ -164,27 +164,28 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
    */
   function isODataItems( typeName ) {
     const typeDef = csn.definitions[typeName];
-    return !!(options.toOdata && typeDef && typeDef.items);
+    return !!(options.toOdata && typeDef && typeDef?.items);
   }
 }
 
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {WeakMap} resolved Cache for resolved refs
  * @param {string} pathDelimiter
  * @param {object} iterateOptions
  */
-function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, iterateOptions = {} ) {
+function flattenAllStructStepsInRefs( csn, options, messageFunctions, resolved, pathDelimiter, iterateOptions = {} ) {
   const { inspectRef, effectiveType } = csnRefs(csn);
-  const { flattenStructStepsInRef } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { flattenStructStepsInRef } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   const adaptRefs = [];
 
   /**
    * 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
    */
@@ -258,12 +259,13 @@ function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, ite
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {string} pathDelimiter
- * @param {Function} error
  * @param {object} iterateOptions
  */
-function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {} ) {
-  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+function flattenElements( csn, options, messageFunctions, pathDelimiter, iterateOptions = {} ) {
+  const { error } = messageFunctions;
+  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { isAssocOrComposition, effectiveType } = csnUtils;
   const transformers = {
     elements: flatten,
@@ -309,33 +311,28 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
           if (flatElement.notNull !== false && !branch.some(s => !s.notNull))
             flatElement.notNull = true;
 
-
           if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
             // unmanaged relations can't be primary key
             delete flatElement.key;
-            // Make refs resolvable by fixing the first ref step
-            for (const onPart of flatElement.on) {
-              if (onPart.ref) {
-                const firstRef = onPart.ref[0];
-
-                /*
-                  when element is defined in the current name resolution scope, like
-                    entity E {
-                      key x: Integer;
-                          s : {
-                          y : Integer;
-                          a3 : association to E on a3.x = y;
-                          }
-                    }
-                  We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
-                */
+            transformExpression(flatElement, 'on', {
+              ref: (_parent, _prop, xpr) => {
                 const prefix = flatElement._flatElementNameWithDots.split('.').slice(0, -1).join(pathDelimiter);
-                const possibleFlatName = prefix + pathDelimiter + firstRef;
-
+                const possibleFlatName = prefix + pathDelimiter + xpr[0];
+                /*
+                    when element is defined in the current name resolution scope, like
+                      entity E {
+                        key x: Integer;
+                            s : {
+                            y : Integer;
+                            a3 : association to E on a3.x = y;
+                            }
+                      }
+                    We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
+                  */
                 if (flatElems[possibleFlatName])
-                  onPart.ref[0] = possibleFlatName;
-              }
-            }
+                  xpr[0] = possibleFlatName;
+              },
+            });
           }
           parent[prop].$orderedElements.push([ flatElemName, flatElement ]);
           // Still add them - otherwise we might not detect collisions between generated elements.
@@ -434,16 +431,16 @@ function linkForeignKeyAnnotationExtensionsToAssociation( csn, options ) {
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param {Function} error
- * @param {Function} warning
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {string} pathDelimiter
  * @param {boolean} flattenKeyRefs
  * @param {object} csnUtils
  * @param {object} iterateOptions
  */
-function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, warning, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
+function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFunctions, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
+  const { error, warning } = messageFunctions;
   const { isManagedAssociation, inspectRef, isStructured } = csnUtils;
-  const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   if (flattenKeyRefs) {
     applyTransformations(csn, {
       elements: (parent, prop, elements, path) => {
@@ -814,6 +811,29 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
     return [ [ prefix, newFk ] ];
   }
 
+  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
+    if (lvl === 0) {
+      if (options.transformation !== 'effective')
+        fk[1]['@odata.foreignKey4'] = prefix;
+      if (options.transformation === 'odata' || options.transformation === 'effective') {
+        const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !isAnnotationExpression(element[pn]));
+        copyAnnotations(element, fk[1], true, {}, validAnnoNames);
+      }
+      // 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);
+    }
+  });
+  return fks;
+
+
   /**
    * Get the path to continue resolving references
    *
@@ -834,27 +854,6 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       return [ path, ...additions ];
     return [ ...path, ...additions ];
   }
-
-  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
-    if (lvl === 0) {
-      if (options.transformation !== 'effective')
-        fk[1]['@odata.foreignKey4'] = prefix;
-      if (options.transformation === 'odata' || options.transformation === 'effective')
-        copyAnnotations(element, fk[1], true);
-
-      // 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);
-    }
-  });
-  return fks;
 }
 
 module.exports = {

package/lib/transform/db/killAnnotations.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const requiredAnnos = {
+  '@cds.persistence.skip': true,
+  '@cds.persistence.exists': true,
+  '@cds.persistence.table': true,
+  '@cds.persistence.journal': true, // Build checks on it
+  '@sql.append': true,
+  '@sql.prepend': true,
+  '@sql.replace': true, // We do a check on this, no real function
+  '@assert.unique': true, // We do a check on this, no real function
+  '@assert.integrity': true,
+  '@cds.valid.from': true,
+  '@cds.valid.to': true,
+  '@cds.valid.key': true,
+  '@odata.draft.enabled': true,
+  '@fiori.draft.enabled': true,
+  '@cds.persistence.calcview': true,
+  '@cds.persistence.udf': true,
+  '@cds.autoexpose': true,
+  '@cds.autoexposed': true,
+  '@cds.redirection.target': true,
+  '@Core.Computed': true,
+};
+
+/**
+ *
+ * @param {object} carrier
+ * @param {string} annoKey
+ */
+function killNonrequiredAnno( carrier, annoKey ) {
+  if (!requiredAnnos[annoKey] && !annoKey.startsWith('@assert.unique.'))
+    delete carrier[annoKey];
+}
+
+
+module.exports = { killNonrequiredAnno };

package/lib/transform/db/rewriteCalculatedElements.js

@@ -149,8 +149,11 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
             art, env, links, scope,
           } = getRefInfo(parent, p);
 
+          // calc element publishes association, treat as regular
+          // unmanaged association
+          const calcElementIsAssoc = art?.value && art.target;
           // TODO: Calculated elements on-write
-          if (art?.value && !art.value.stored) {
+          if (art?.value && !art.value.stored && !calcElementIsAssoc) {
             const alias = parent.as || implicitAs(parent.ref);
             // TODO: What about other scopes? expand/inline?
             const value = (scope !== 'ref-target') ? absolutifyPaths(env, art, ref, links, name).value : keepAssocStepsInRef(ref, links, art).value;
@@ -446,11 +449,15 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
             unfoldingMap[name] = [ true, [ ...columns ] ];
           }
         }
-        else if (!columnMap[name] && hasStar) { // Via * - just append
-          unfoldingMap[name] = [ true, [ { ref: [ name ] } ] ];
-        }
-        else { // just a random column - keep
-          unfoldingMap[name] = [ false, [ columnMap[name] ] ];
+        else {
+          if (usesCalcOnRead(branches))
+            containsCalcOnRead = true;
+          if (!columnMap[name] && hasStar) { // Via * - just append
+            unfoldingMap[name] = [ true, [ { ref: [ name ] } ] ];
+          }
+          else { // just a random column - keep
+            unfoldingMap[name] = [ false, [ columnMap[name] ] ];
+          }
         }
       }
     }
@@ -491,6 +498,39 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
     return false;
   }
 
+  /**
+   * Returns true if the branch/column uses a calc-on-read,
+   * for example in a filter.
+   *
+   * TODO: Enable calculated elements next to nested projections
+   *
+   * @param {object} branches
+   * @returns {boolean}
+   */
+  function usesCalcOnRead( branches ) {
+    let returnValue = false;
+    for (const branchName in branches) {
+      const column = branches[branchName]?.steps[0]?._column;
+      if (column) {
+        applyTransformationsOnNonDictionary({ column }, 'column', {
+          // eslint-disable-next-line no-loop-func
+          ref: (parent) => {
+            if (hasOnReadValue(parent))
+              returnValue = true;
+          },
+        }, {
+          drillRef: true,
+          // skip subqueries and nested projections
+          // calculated elements and nested projections
+          // only conflict on same level
+          skipStandard: [ 'SELECT', 'expand', 'inline' ],
+        });
+      }
+    }
+
+    return returnValue;
+  }
+
   /**
    * A leaf can reference a column which in turn references a real element - that might have a .value.
    * Find such cases.

package/lib/transform/db/temporal.js

@@ -171,7 +171,7 @@ function getAnnotationHandler( csn, options, pathDelimiter, messageFunctions ) {
   const { error } = messageFunctions;
   const {
     extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments, recurseElements,
-  } = getTransformers(csn, options, pathDelimiter);
+  } = getTransformers(csn, options, messageFunctions, pathDelimiter);
 
   return handleTemporalAnnotations;
   /**

package/lib/transform/draft/db.js

@@ -26,7 +26,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   const {
     createForeignKeyElement, createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
     addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
-  } = getTransformers(csn, options, pathDelimiter);
+  } = getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
   const generatedArtifacts = Object.create(null);
@@ -122,26 +122,12 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
 
     generatedArtifacts[draftsArtifactName] = true;
 
-    // extract keys for UUID inspection
-    const keys = [];
+    // TODO: Do we really need this? Is this possibly done by a validator earlier?
     forEachMemberRecursively(artifact, (elt, name, prop, path) => {
       if (!elt.elements && !elt.type && !elt.virtual) // only check leafs
         error(null, path, 'Expecting element to have a type when used in a draft-enabled artifact');
-      if (elt.key && elt.key === true && !elt.virtual)
-        keys.push(elt);
     }, [ 'definitions', artifactName ], false, { elementsOnly: true });
 
-    // In contrast to EDM, the DB entity may have more than one technical keys but should have ideally exactly one key of type cds.UUID
-    if (keys.length !== 1) {
-      warning(null, [ 'definitions', artifactName ], { count: keys.length },
-              'Entity annotated with “@odata.draft.enabled” should have exactly one key element, but found $(COUNT)');
-    }
-    else {
-      const uuidCount = keys.reduce((acc, k) => ((k.type === 'cds.UUID' || k.type === 'cds.String' && k.$renamed === 'cds.UUID' && k.length === 36) ? acc + 1 : acc), 0);
-      if (uuidCount === 0)
-        warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
-    }
-
     // Ignore boolean return value. We know that we're inside a service or else we wouldn't have reached this code.
     const matchingService = getMatchingService(artifactName) || '';
     // Generate the DraftAdministrativeData projection into the service, unless there is already one

package/lib/transform/draft/odata.js

@@ -27,21 +27,21 @@ const { makeMessageFunction } = require('../../base/messages');
  * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
  */
 function generateDrafts( csn, options, services ) {
+  const messageFunctions = makeMessageFunction(csn, options, 'for.odata');
+  const { error, info } = messageFunctions;
   const {
     createAndAddDraftAdminDataProjection, createScalarElement,
     createAssociationElement, createAssociationPathComparison,
     addElement, createAction, assignAction,
     resetAnnotation,
     csnUtils,
-  } = getTransformers(csn, options);
+  } = getTransformers(csn, options, messageFunctions);
   const {
     getServiceName,
     hasAnnotationValue,
     getFinalTypeInfo,
   } = csnUtils;
 
-  const { error, info } = makeMessageFunction(csn, options, 'for.odata');
-
   if (!services)
     services = getServiceNames(csn);
 

package/lib/transform/effective/associations.js

@@ -17,14 +17,12 @@ const backlinks = require('../db/backlinks');
  * @param {CSN.Model} csn Input CSN - will not be transformed
  * @param {CSN.Options} options
  * @param {object} csnUtils
- * @param {object} messageFunctions
- * @param {Function} messageFunctions.error
- * @param {Function} messageFunctions.warning
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @todo Remove .keys afterwards
  * @todo Add created foreign keys into .columns in case of a query?
  * @returns {CSN.Model}
  */
-function turnAssociationsIntoUnmanaged( csn, options, csnUtils, { error, warning } ) {
+function turnAssociationsIntoUnmanaged( csn, options, csnUtils, messageFunctions ) {
   // TODO: Do we really need this?
   forEachDefinition(csn, (artifact, artifactName) => {
     setProp(artifact, '$path', [ 'definitions', artifactName ]);
@@ -33,7 +31,7 @@ function turnAssociationsIntoUnmanaged( csn, options, csnUtils, { error, warning
     }, [ 'definitions', artifactName ]);
   });
   // Flatten out the fks and create the corresponding elements
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', true, csnUtils, { allowArtifact: () => true, skipDict: {} });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_', true, csnUtils, { allowArtifact: () => true, skipDict: {} });
 
   // Add the foreign keys also to the columns if the association itself was explicitly selected
   // TODO: Extend the expansion to also expand managed to their foreign

package/lib/transform/effective/main.js

@@ -2,7 +2,6 @@
 
 const { isBetaEnabled } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
-const { makeMessageFunction } = require('../../base/messages');
 const { cloneCsnNonDict, getUtils, isAspect } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const flattening = require('../db/flattening');
@@ -26,21 +25,21 @@ const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities }
  * @private
  * @param {CSN.Model} model Input CSN - will not be transformed
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  * @returns {CSN.Model}
  */
-function effectiveCsn( model, options ) {
+function effectiveCsn( model, options, messageFunctions ) {
   if (!isBetaEnabled(options, 'effectiveCsn'))
     throw new CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
 
   const csn = cloneCsnNonDict(model, options);
-
   delete csn.vocabularies; // must not be set for effective CSN
+  messageFunctions.setModel(csn);
 
-  const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, '_');
+  const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
   queries.projectionToSELECTAndAddColumns(csn);
 
   let csnUtils = getUtils(csn, 'init-all');
-  const messageFunctions = makeMessageFunction(csn, options, 'for.effective');
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
@@ -65,13 +64,11 @@ function effectiveCsn( model, options ) {
 
   const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
 
-  csnUtils = getUtils(csn, 'init-all');
-
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
 
-  flattening.flattenAllStructStepsInRefs(csn, options, new WeakMap(), '_');
-  flattening.flattenElements(csn, options, '_', messageFunctions.error);
+  flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, new WeakMap(), '_');
+  flattening.flattenElements(csn, options, messageFunctions, '_');
 
   resolveTypesInActionsAfterFlattening();