@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/transform/db/applyTransformations.js

@@ -1,6 +1,6 @@
 'use strict';
 
-/**
+/*
  * Module for general (partial) CSN looper functions, respecting dictionaries and allowing
  * to pass custom callbacks for certain properties like "ref".
  *
@@ -10,6 +10,8 @@
  *
  * @module lib/transform/db/applyTransformations
  */
+
+
 const { setProp } = require('../../base/model');
 
 
@@ -18,11 +20,17 @@ const { setProp } = require('../../base/model');
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {applyTransformationsOptions} [options={}]
+ * @param {applyTransformationsOptions} [_options={}]
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
-function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, options, path = [] ) {
+function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, _options, path = [] ) {
+  const options = { ..._options };
+  if (!options.skipStandard)
+    options.skipStandard = { $tableConstraints: true };
+  else if (options.skipStandard.$tableConstraints === undefined)
+    options.skipStandard = { ...options.skipStandard, ...{ $tableConstraints: true } };
+
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -43,23 +51,24 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       standard( parent, name, parent[name] );
   }
   else {
-    standard(parent, prop, parent[prop]);
+    standard( parent, prop, parent[prop] );
   }
   return parent;
 
   /**
-   * Default transformer for things that are not dictionaries, like "type" or "keys".
+   * Default transformer for things that are not dictionaries or dictionary entries,
+   * such as "type" or "keys".
    * The customTransformers are applied here (and only here).
    *
    * @param {object | Array} _parent the thing that has _prop
-   * @param {string|number} _prop the name of the current property
+   * @param {string|number} _prop the name of the current property or index
    * @param {object} node The value of node[_prop]
    */
   function standard( _parent, _prop, node ) {
     if (!node || typeof node !== 'object' ||
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
         (typeof _prop === 'string' && _prop.startsWith('@')) ||
-        (options.skipIgnore && node._ignore) ||
+        (options.skipIgnore && node.$ignore) ||
         options.skipStandard?.[_prop]
     )
       return;
@@ -75,13 +84,35 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
         const trans = transformers[name] || standard;
         if (customTransformers[name])
           customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
-
         trans( node, name, node[name], csnPath );
       }
     }
     csnPath.pop();
   }
 
+  /**
+   * Transformer for dictionary entries.  Similar to standard(), but does not filter
+   * based on the given name.  Otherwise, `options.skipStandards` could accidentally skip
+   * dictionary entries (e.g. entity called `@Name`).
+   *
+   * @param {object | Array} dict the thing that has _prop
+   * @param {string|number} entryName the name of the current property
+   * @param {object} node The value of node[_prop]
+   */
+  function dictEntry( dict, entryName, node ) {
+    if (!node || typeof node !== 'object' || (options.skipIgnore && node.$ignore))
+      return;
+
+    csnPath.push( entryName );
+    for (const name of Object.getOwnPropertyNames( node )) {
+      const trans = transformers[name] || standard;
+      if (customTransformers[name])
+        customTransformers[name](node, name, node[name], csnPath, dict);
+      trans( node, name, node[name], csnPath );
+    }
+    csnPath.pop();
+  }
+
   /**
    * Transformer for things that are dictionaries - like "elements".
    *
@@ -90,12 +121,12 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    * @param {object} dict The value of node[_prop]
    */
   function dictionary( node, _prop, dict ) {
-    // Allow skipping dicts like actions in forRelationalDB
-    if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
+    // Allow skipping dictionaries like actions in forRelationalDB
+    if (options.skipDict?.[_prop] || dict == null) // with universal CSN, dictionaries might be null
       return;
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict ))
-      standard( dict, name, dict[name] );
+      dictEntry( dict, name, dict[name] );
 
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
       setProp(node, `$${_prop}`, dict);
@@ -112,13 +143,9 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   function definitions( node, _prop, dict ) {
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict )) {
-      const skip = (options && options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
-                   (options && options.skipArtifact && options.skipArtifact(dict[name], name)) ||
-                   (options && options.skip && options.skip.includes(dict[name].kind)) ||
-                   false;
-      if (!skip) {
+      if (!isArtifactSkipped( dict, name )) {
         artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-        standard( dict, name, dict[name] );
+        dictEntry( dict, name, dict[name] );
       }
     }
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
@@ -126,6 +153,20 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     csnPath.pop();
   }
 
+  /**
+   * Whether the given artifact `dict[name]` is skipped via options.
+   *
+   * @param {object} dict
+   * @param {string} name
+   * @returns {boolean}
+   */
+  function isArtifactSkipped( dict, name ) {
+    return options && ((options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
+        (options.skipArtifact && options.skipArtifact(dict[name], name)) ||
+        (options.skip?.includes(dict[name].kind))) ||
+      false;
+  }
+
   /**
    * Keep looping through the pathRef - because in a .ref we can have .args and .where
    *
@@ -173,7 +214,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
   if (options.skipIgnore === undefined)
     options.skipIgnore = true;
 
-  if (csn && csn.definitions)
+  if (csn?.definitions)
     return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, options);
   return csn;
 }
@@ -230,12 +271,12 @@ module.exports = {
 
 /**
  * @typedef {object} applyTransformationsOptions
- * @property {(artifact, name) => boolean} [allowArtifact] to only allow certain artifacts
- * @property {(artifact, name) => boolean} [skipArtifact] to skip certain artifacts
+ * @property {(artifact: CSN.Artifact, name: string) => boolean} [allowArtifact] to only allow certain artifacts
+ * @property {(artifact: CSN.Artifact, name: string) => boolean} [skipArtifact] to skip certain artifacts
  * @property {boolean} [drillRef] whether to drill into infix/args
  * @property {string[]} [skip] skip definitions from certain kind
  * @property {object} [skipStandard] stop drill-down on certain "standard" props
  * @property {object} [skipDict] stop drill-down on certain "dictionary" props
- * @property {boolean} [skipIgnore=true] Whether to skip _ignore elements or not
+ * @property {boolean} [skipIgnore=true] Whether to skip $ignore elements or not
  * @property {boolean} [directDict=false] Implicitly set via applyTransformationsOnDictionary
  */

package/lib/transform/db/assertUnique.js

@@ -1,8 +1,7 @@
 'use strict';
 
 const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
-const { getTransformers } = require('../transformUtilsNew');
-const { setProp } = require('../../base/model');
+const { getTransformers } = require('../transformUtils');
 const { pathName } = require('../../compiler/utils');
 
 
@@ -97,7 +96,7 @@ function processAssertUnique( csn, options, error, info ) {
         }
         // 10) Store remaining paths (if any) in constraint dictionary
         if (flattenedPathObjects.length)
-          constraintDict[constraintName.join('.')] = flattenedPathObjects;
+          constraintDict[constraintName.join('.')] = { paths: flattenedPathObjects, parentTable: artifactName };
       }
     }
 
@@ -110,9 +109,9 @@ function processAssertUnique( csn, options, error, info ) {
     // preserve dictionary in '$tableConstraints' on the artifact for path rewriting and rendering
     if (Object.keys(constraintDict).length) {
       if (!('$tableConstraints' in artifact))
-        setProp(artifact, '$tableConstraints', Object.create(null));
+        artifact.$tableConstraints = Object.create(null);
 
-      setProp(artifact.$tableConstraints, 'unique', constraintDict);
+      artifact.$tableConstraints.unique = constraintDict;
     }
 
     /**
@@ -286,7 +285,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
       }
       for (const uniqueConstraint in artifact.$tableConstraints.unique) {
         // iterate over each constraint
-        const c = uniqueConstraints[uniqueConstraint];
+        const c = uniqueConstraints[uniqueConstraint].paths;
         const rewrittenPaths = [];
         // and inspect each path of the constraint
         c.forEach((cpath) => {
@@ -319,7 +318,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
           }
         });
         // preserve the rewritten and filtered paths for toSql
-        uniqueConstraints[uniqueConstraint] = rewrittenPaths;
+        uniqueConstraints[uniqueConstraint] = { paths: rewrittenPaths, parentTable: uniqueConstraints[uniqueConstraint].parentTable };
 
         // now add the index for HANA CDS
         if (options.transformation === 'hdbcds') {
@@ -335,7 +334,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
           artifact.technicalConfig.hana.indexes[uniqueConstraint] = index;
         }
       }
-      setProp(artifact.$tableConstraints, 'unique', uniqueConstraints);
+      artifact.$tableConstraints.unique = uniqueConstraints;
     }
   }
 }

package/lib/transform/db/associations.js

@@ -48,8 +48,8 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
     // Assemble an ON-condition with the foreign keys created in earlier steps
     const onCondParts = [];
     let joinWithAnd = false;
-    if (elem.keys.length === 0) { // TODO: really kill instead of _ignore?
-      elem._ignore = true;
+    if (elem.keys.length === 0) { // TODO: really kill instead of $ignore?
+      elem.$ignore = true;
     }
     else {
       for (const foreignKey of elem.keys) {

package/lib/transform/db/cdsPersistence.js

@@ -3,13 +3,13 @@
 const {
   forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtilsNew');
+const transformUtils = require('../transformUtils');
 
 const exists = '@cds.persistence.exists';
 
 /**
  * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
- * with _ignore.
+ * with $ignore.
  *
  * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
  */
@@ -24,12 +24,12 @@ function getAnnoProcessor() {
                             hasAnnotationValue(artifact, '@cds.persistence.skip') ||
                             hasAnnotationValue(artifact, exists));
     if (ignoreArtifact)
-      artifact._ignore = true;
+      artifact.$ignore = true;
   }
 }
 
 /**
- * Return a callback function for forEachDefinition that marks associations with _ignore
+ * Return a callback function for forEachDefinition that marks associations with $ignore
  * if their target does not reach the database, i.e. marked with @cds.persistence.skip or is abstract
  *
  * @param {CSN.Model} csn
@@ -72,7 +72,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
   }
 
   /**
-   * Mark the given member with _ignore if it is an association/composition and it's target is unreachable.
+   * Mark the given member with $ignore if it is an association/composition and its target is unreachable.
    *
    * @param {CSN.Element} member
    * @param {string} memberName
@@ -81,13 +81,13 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
    */
   function ignore( member, memberName, prop, path ) {
     if (options.sqlDialect === 'hana' &&
-       !member._ignore && member.target &&
+       !member.$ignore && member.target &&
        isAssocOrComposition(member) &&
        !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
            { target: member.target, anno: '@cds.persistence.skip' },
-           'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
-      member._ignore = true;
+           'Association has been removed, as its target $(TARGET) is annotated with $(ANNO) and can\'t be rendered in SAP HANA SQL');
+      member.$ignore = true;
     }
   }
 }
@@ -124,7 +124,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member._ignore && !member.kind && !member.type) {
+        if (!member.$ignore && !member.kind && !member.type) {
           error(null, path, { anno: '@cds.persistence.table' },
                 'Expecting element to have a type if view is annotated with $(ANNO)');
         }

package/lib/transform/db/constraints.js

@@ -56,6 +56,25 @@ function createReferentialConstraints( csn, options ) {
             },
           });
         }
+        // for `texts` compositions, we may generate foreign key constraints even w/o `up_`
+        else if (elementName === 'texts' && element.target === `${path[path.length - 1]}.texts`) {
+          const { on } = element;
+          const target = csn.definitions[element.target];
+          // `texts` entities have a key named "locale"
+          const targetSideHasLocaleKey = target.elements.locale?.key;
+          if (targetSideHasLocaleKey && !skipConstraintGeneration(parent, target, { /* there is no assoc */ })) {
+            const sourceElements = Array.from(elementsOfSourceSide(on, elements));
+            const targetElements = Array.from(elementsOfTargetSide(on, target.elements));
+            // `texts` entities have all the keys the original entity has
+            const allElementsAreKeysAndHaveTheSameName = targetElements.length &&
+            targetElements.every(
+              ([ targetKey, e ]) => e.key &&
+              sourceElements.some(([ sourceKey, sourceElement ]) => sourceElement.key && targetKey === sourceKey )
+            );
+            if (allElementsAreKeysAndHaveTheSameName)
+              attachConstraintsToDependentKeys(targetElements, sourceElements, path[path.length - 1], 'texts', { texts: true });
+          }
+        }
       }
     },
   }, [], { skipIgnore: false, skipArtifact: a => a.query || a.kind !== 'entity' });
@@ -134,7 +153,7 @@ function createReferentialConstraints( csn, options ) {
    * @param {Array} parentKeys array holding parent keys in the format [['key1', 'value1'], [...], ...]
    * @param {CSN.PathSegment} parentTable the sql-table where the foreign key constraints will be pointing to
    * @param {CSN.PathSegment} sourceAssociation the name of the association from which the constraint originates
-   * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
+   * @param {CSN.PathSegment | object} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    *                                    it is used for a comment in the constraint, which is only printed out in test-mode
    */
   function attachConstraintsToDependentKeys( dependentKeys, parentKeys, parentTable, sourceAssociation, upLinkFor = null ) {
@@ -440,13 +459,16 @@ function createReferentialConstraints( csn, options ) {
    */
   function elementsOfTargetSide( on, targetElements ) {
     const elements = new Map();
-    on.filter(element => typeof element === 'object' &&
-      element.ref.length > 1 &&
-      targetElements[element.ref[element.ref.length - 1]])
-      .forEach((element) => {
-        elements.set(element.ref[element.ref.length - 1], targetElements[element.ref[element.ref.length - 1]]);
-      });
-
+    const findElements = (tokenStream) => {
+      tokenStream
+        .forEach((element) => {
+          if (typeof element === 'object' && element.ref?.length > 1 && targetElements[element.ref[element.ref.length - 1]])
+            elements.set(element.ref[element.ref.length - 1], targetElements[element.ref[element.ref.length - 1]]);
+          else if (element.xpr)
+            findElements(element.xpr);
+        });
+    };
+    findElements(on);
     return elements;
   }
 
@@ -459,12 +481,16 @@ function createReferentialConstraints( csn, options ) {
    */
   function elementsOfSourceSide( on, sourceElements ) {
     const elements = new Map();
-    on.filter(element => typeof element === 'object' &&
-      element.ref.length === 1 &&
-      sourceElements[element.ref[0]])
-      .forEach((element) => {
-        elements.set(element.ref[0], sourceElements[element.ref[0]]);
-      });
+    const findElements = (tokenStream) => {
+      tokenStream
+        .forEach((element) => {
+          if (typeof element === 'object' && element.ref?.length === 1 && sourceElements[element.ref[0]])
+            elements.set(element.ref[0], sourceElements[element.ref[0]]);
+          else if (element.xpr)
+            findElements(element.xpr);
+        });
+    };
+    findElements(on);
     return elements;
   }
 
@@ -507,12 +533,16 @@ function createReferentialConstraints( csn, options ) {
         dependentKey.push(foreignKeyName);
         onDeleteRules.add($foreignKeyConstraintCopy.onDelete);
       });
-      // onDelete Rule is the "weakest" rule applicable. Precedence: RESTRICT > SET NULL > CASCADE
+      // onDelete Rule is the "weakest" rule applicable. Precedence: RESTRICT > CASCADE
       const onDelete = onDeleteRules.has('RESTRICT') ? 'RESTRICT' : 'CASCADE';
       let onDeleteRemark = null;
       // comments in sqlite files are causing the JDBC driver to throw an error on deployment
-      if (options.testMode && onDelete === 'CASCADE')
-        onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
+      if (options.testMode && onDelete === 'CASCADE') {
+        if ($foreignKeyConstraint.upLinkFor?.texts)
+          onDeleteRemark = `Constraint originates from localized composition ”${$foreignKeyConstraint.parentTable}:texts“`;
+        else
+          onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
+      }
       // constraint identifier usually start with `c__` to avoid name clashes
       let identifier = options.pre2134ReferentialConstraintNames ? '' : 'c__';
       identifier += `${getResultingName(csn, options.sqlMapping, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`;