@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/transform/db/constraints.js

@@ -1,8 +1,9 @@
 'use strict';
 
 const { forEachDefinition } = require('../../base/model');
-const { forAllElements, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
+const { applyTransformations, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
 const { csnRefs } = require('../../model/csnRefs');
+const { forEach, forEachKey } = require('../../utils/objectUtils');
 
 const COMPOSITION = 'cds.Composition';
 const ASSOCIATION = 'cds.Association';
@@ -28,34 +29,36 @@ function createReferentialConstraints(csn, options) {
   // compositions must be processed first, as the <up_> links for them must result in `ON DELETE CASCADE`
   const compositions = [];
   const associations = [];
-  forEachDefinition(csn, (artifact, artifactName) => {
-    if (!artifact.query && artifact.kind === 'entity') {
-      forAllElements(artifact, artifactName, (parent, elements, path) => {
-        // Step I: iterate compositions, enrich dependent keys for <up_> association in target entity of composition
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (element.type === COMPOSITION && element.$selfOnCondition) {
-            compositions.push({
-              fn: () => {
-                foreignKeyConstraintForUpLinkOfComposition(element, parent, path.concat([ elementName ]));
-              },
-            });
-          }
+  applyTransformations(csn, {
+    elements: (parent, prop, elements, path) => {
+      // Step I: iterate compositions, enrich dependent keys for <up_> association in target entity of composition
+      for (const elementName in elements) {
+        const element = elements[elementName];
+        const ePath = path.concat([ 'elements', elementName ]); // Save a copy in this scope for the late callback
+        if (element.type === COMPOSITION && element.$selfOnCondition) {
+          compositions.push({
+            fn: () => {
+              foreignKeyConstraintForUpLinkOfComposition(element, parent, ePath);
+            },
+          });
         }
-        // Step II: iterate associations, enrich dependent keys (in entity containing the association)
-        for (const elementName in elements) {
-          const element = elements[elementName];
-          if (element.keys && isToOne(element) && element.type === ASSOCIATION || element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
-            associations.push({
-              fn: () => {
-                foreignKeyConstraintForAssociation(element, path.concat([ elementName ]));
-              },
-            });
-          }
+      }
+
+      // Step II: iterate associations, enrich dependent keys (in entity containing the association)
+      for (const elementName in elements) {
+        const element = elements[elementName];
+        const ePath = path.concat([ 'elements', elementName ]); // Save a copy in this scope for the late callback
+        if (element.keys && isToOne(element) && element.type === ASSOCIATION || element.type === COMPOSITION && treatCompositionLikeAssociation(element)) {
+          associations.push({
+            fn: () => {
+              foreignKeyConstraintForAssociation(element, ePath );
+            },
+          });
         }
-      });
-    }
-  });
+      }
+    },
+  }, [], { skipIgnore: false, skipArtifact: a => a.query || a.kind !== 'entity' });
+
   // create constraints on foreign keys
   // always process unmanaged first, up_ links must be flagged
   // before they are processed
@@ -215,8 +218,7 @@ function createReferentialConstraints(csn, options) {
    *  Skip referential constraint if the parent table (association target, or artifact where composition is defined)
    *  of the relation is:
    *    - a query
-   *    - TODO: Revisit -- annotated with '@cds.persistence.skip:true'
-   *    - TODO: Revisit -- annotated with '@cds.persistence.exists:true'
+   *    - annotated with '@cds.persistence.skip:true'
    *
    *  The following decision table reflects the current implementation:
    *
@@ -299,13 +301,15 @@ function createReferentialConstraints(csn, options) {
 
       return true;
     }
+    const runtimeChecks = options.assertIntegrityType && options.assertIntegrityType.toUpperCase() === RT;
+    const compilerChecks = options.assertIntegrityType && options.assertIntegrityType.toUpperCase() === DB;
 
     if ((!options.assertIntegrity || options.assertIntegrity === true || options.assertIntegrity === 'true') &&
-      (!options.assertIntegrityType || options.assertIntegrityType === RT))
+      (!options.assertIntegrityType || runtimeChecks))
       return assertForIntegrityTypeRT();
 
     if ((!options.assertIntegrity || options.assertIntegrity === true || options.assertIntegrity === 'true') &&
-      options.assertIntegrityType === DB)
+      compilerChecks)
       return assertForIntegrityTypeDB();
 
     if ((options.assertIntegrity === 'individual'))
@@ -313,7 +317,7 @@ function createReferentialConstraints(csn, options) {
 
     // The default for the assertIntegrityType is 'RT', no constraints in that case
     if ((!options.assertIntegrity || options.assertIntegrity === true) &&
-      (!options.assertIntegrityType || options.assertIntegrityType === RT))
+      (!options.assertIntegrityType || runtimeChecks))
       return true;
 
     if (!element.keys || !isToOne(element))
@@ -385,7 +389,7 @@ function createReferentialConstraints(csn, options) {
      * @returns {boolean}
      */
     function isAssertIntegrityAnnotationSetTo(value) {
-      return hasAnnotationValue(element, '@assert.integrity', value);
+      return hasAnnotationValue(element, '@assert.integrity', value, true);
     }
 
     /**
@@ -489,18 +493,20 @@ function createReferentialConstraints(csn, options) {
       const dependentKey = [ elementName ];
       const onDeleteRules = new Set();
       onDeleteRules.add($foreignKeyConstraint.onDelete);
-      // find all other $foreignKeyConstraint with same $sourceAssociation and same parentTable
-      Object.entries(artifact.elements)
-        .filter(([ , e ]) => e.$foreignKeyConstraint &&
-          e.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
-          e.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable)
-        .forEach(([ foreignKeyName, foreignKey ]) => {
-          const $foreignKeyConstraintCopy = Object.assign({}, foreignKey.$foreignKeyConstraint);
-          delete foreignKey.$foreignKeyConstraint;
-          parentKey.push($foreignKeyConstraintCopy.parentKey);
-          dependentKey.push(foreignKeyName);
-          onDeleteRules.add($foreignKeyConstraintCopy.onDelete);
-        });
+      forEach(artifact.elements, (foreignKeyName, foreignKey) => {
+        // find all other `$foreignKeyConstraint`s with same `$sourceAssociation` and same `parentTable`
+        const matchingForeignKeyFound = foreignKey.$foreignKeyConstraint &&
+        foreignKey.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
+        foreignKey.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable;
+        if (!matchingForeignKeyFound)
+          return;
+
+        const $foreignKeyConstraintCopy = Object.assign({}, foreignKey.$foreignKeyConstraint);
+        delete foreignKey.$foreignKeyConstraint;
+        parentKey.push($foreignKeyConstraintCopy.parentKey);
+        dependentKey.push(foreignKeyName);
+        onDeleteRules.add($foreignKeyConstraintCopy.onDelete);
+      });
       // onDelete Rule is the "weakest" rule applicable. Precedence: RESTRICT > SET NULL > CASCADE
       const onDelete = onDeleteRules.has('RESTRICT') ? 'RESTRICT' : 'CASCADE';
       let onDeleteRemark = null;
@@ -508,14 +514,14 @@ function createReferentialConstraints(csn, options) {
       if (options.testMode && onDelete === 'CASCADE')
         onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
       referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
-        identifier: `${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
+        // constraint identifier start with `c__` to avoid name clashes
+        identifier: `c__${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
         foreignKey: dependentKey,
         parentKey,
         dependentTable: artifactName,
         parentTable,
         onDelete,
         onDeleteRemark, // explain why this particular rule is chosen
-        // TODO: do we want to switch off validation / enforcement via annotation on association?
         validated: $foreignKeyConstraint.validated,
         enforced: $foreignKeyConstraint.enforced,
       };
@@ -543,15 +549,14 @@ function assertConstraintIdentifierUniqueness(artifact, artifactName, path, erro
   if (!(artifact.$tableConstraints && artifact.$tableConstraints.referential && artifact.$tableConstraints.unique))
     return;
 
-  Object.keys(artifact.$tableConstraints.unique)
-    .map(id => `${artifactName}_${id}`) // final unique constraint identifier will be generated in renderer likewise
-    .forEach((uniqueConstraintIdentifier) => {
-      if (artifact.$tableConstraints.referential[uniqueConstraintIdentifier]) {
-        error(null, path,
-              { name: uniqueConstraintIdentifier, art: artifactName },
-              'Duplicate constraint name $(NAME) in artifact $(ART)');
-      }
-    });
+  forEachKey(artifact.$tableConstraints.unique, (uniqueConstraintKey) => {
+    const uniqueConstraintIdentifier = `${artifactName}_${uniqueConstraintKey}`; // final unique constraint identifier will be generated in renderer likewise
+    if (artifact.$tableConstraints.referential[uniqueConstraintIdentifier]) {
+      error(null, path,
+            { name: uniqueConstraintIdentifier, art: artifactName },
+            'Duplicate constraint name $(NAME) in artifact $(ART)');
+    }
+  });
 }
 
 module.exports = { createReferentialConstraints, assertConstraintIdentifierUniqueness };

package/lib/transform/db/expansion.js

@@ -20,8 +20,9 @@ const { setProp, isBetaEnabled } = require('../../base/model');
  * @param {Function} messageFunctions.error
  * @param {Function} messageFunctions.info
  * @param {Function} messageFunctions.throwWithError
+ * @param {object} iterateOptions
  */
-function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithError }) {
+function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithError }, iterateOptions = {}) {
   const {
     isStructured, get$combined, getFinalBaseType, getServiceName,
   } = getUtils(csn);
@@ -39,7 +40,11 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       const artifact = csn.definitions[path[1]];
       if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
         const root = get$combined({ SELECT: parent });
-        parent.columns = replaceStar(root, columns, parent.excluding);
+        // TODO: replace with the correct options.transformation?
+        // Do not expand the * in OData for a moment, not to introduce changes
+        // while the OData CSN is still official
+        if (!options.toOdata)
+          parent.columns = replaceStar(root, columns, parent.excluding);
         parent.columns = expand(parent.columns, path.concat('columns'), true);
       }
     },
@@ -49,7 +54,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     orderBy: (parent, name, orderBy, path) => {
       parent.orderBy = expand(orderBy, path.concat('orderBy'));
     },
-  });
+  }, [], iterateOptions);
 
   /**
    * Turn .expand/.inline into normal refs. @cds.persistence.skip .expand with to-many (and all transitive views).
@@ -71,16 +76,25 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
           const rewritten = rewrite(root, parent.columns, parent.excluding);
           parent.columns = rewritten.columns;
-          if (rewritten.toMany.length > 0) {
+          /*
+           * Do not remove unexpandable many columns in OData
+          */
+          if (rewritten.toMany.length > 0 && !options.toOdata) {
             markAsToDummyfy(artifact, path[1]);
             if (getServiceName(path[1]) === null)
               error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME), which is outside any service');
           }
+          else {
+            parent.columns = rewritten.columns;
+          }
         }
       },
     });
 
-    dummyfy();
+    // OData must keep @cds.persistence.skip definitions
+    // to present them in the API (and CSN)
+    if (!options.toOdata)
+      dummyfy();
 
     cleanup.forEach(fn => fn());
 
@@ -88,23 +102,26 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
 
 
     const publishing = [];
-
-    applyTransformations(csn, {
-      target: (parent, name, target, path) => {
-        if (toDummyfy.indexOf(target) !== -1) {
-          publishing.push({
-            parent, name, target, path: [ ...path ],
-          });
-        }
-      },
-      from: check,
-      columns: check,
-      where: check,
-      groupBy: check,
-      orderBy: check,
-      having: check,
-      limit: check,
-    });
+    // OData must allow navigations to @cds.persistence.skip targets
+    // as valid navigations in the API
+    if (!options.toOdata) {
+      applyTransformations(csn, {
+        target: (parent, name, target, path) => {
+          if (toDummyfy.indexOf(target) !== -1) {
+            publishing.push({
+              parent, name, target, path: [ ...path ],
+            });
+          }
+        },
+        from: check,
+        columns: check,
+        where: check,
+        groupBy: check,
+        orderBy: check,
+        having: check,
+        limit: check,
+      });
+    }
 
 
     /**
@@ -239,15 +256,14 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {CSN.Artifact} root All elements visible fromt he query source ($combined)
      * @param {CSN.Column[]} columns
      * @param {string[]} excluding
-     * @returns {{columns: Array, toManys: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
+     * @returns {{columns: Array, toMany: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
      */
     function rewrite(root, columns, excluding) {
       const allToMany = [];
       const newThing = [];
       // Replace stars - needs to happen here since the .expand/.inline first path step affects the root *
       columns = replaceStar(root, columns, excluding);
-      for (let i = 0; i < columns.length; i++) {
-        const col = columns[i];
+      for (const col of columns) {
         if (col.expand) {
           // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
           const { expanded, toManys } = expandInline(root, col, col.ref || [], [ dbName(col) ]);
@@ -270,7 +286,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     }
 
     /**
-     * Check wether the given object is a to-many association
+     * Check whether the given object is a to-many association
      *
      * @param {CSN.Element} obj
      * @returns {boolean}
@@ -302,6 +318,11 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       while (stack.length > 0) {
         const [ base, current, currentRef, currentAlias ] = stack.pop();
         if (isToMany(current) && current.expand) {
+          expanded.push({
+            expand: current.expand,
+            ref: currentRef,
+            as: currentAlias.join(pathDelimiter),
+          });
           toManys.push({ art: current, ref: currentRef, as: currentAlias.join(pathDelimiter) });
         }
         else if (current.expand) {
@@ -436,7 +457,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    *
    * @param {Array} thing
    * @param {CSN.Path} path
-   * @param {boolean} [withAlias=false] Wether to "expand" the (implicit) alias aswell.
+   * @param {boolean} [withAlias=false] Whether to "expand" the (implicit) alias aswell.
    * @returns {Array} New array - with all structured things expanded
    */
   function expand(thing, path, withAlias = false) {
@@ -477,6 +498,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    */
   function expandRef(art, ref, alias, isKey, withAlias) {
     const expanded = [];
+    /** @type {Array<[CSN.Element, any[], any[]]>} */
     const stack = [ [ art, ref, [ alias || ref[ref.length - 1] ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
@@ -564,8 +586,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         }
       }
       // Finally: Replace the stars and leave out the shadowed things
-      for (let i = 0; i < subs.length; i++) {
-        const sub = subs[i];
+      for (const sub of subs) {
         if (sub !== '*' && !replaced[dbName(sub)])
           final.push(sub);
         else if (sub === '*')