@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/transform/db/associations.js

@@ -0,0 +1,187 @@
+'use strict';
+
+const {
+  applyTransformationsOnNonDictionary,
+  applyTransformations,
+  getUtils,
+} = require('../../model/csnUtils');
+
+
+/**
+ * In all .elements of entities and views (and their bound actions/functions), create the on-condition for
+ * a managed associations. This needs to happen after the .keys are expanded and the corresponding elements are created.
+ *
+ * @param {CSN.Model} csn
+ * @param {string} pathDelimiter
+ * @returns {CSN.Model} Return the input csn, with the transformations applied
+ */
+function attachOnConditions(csn, pathDelimiter) {
+  const {
+    isManagedAssociation,
+  } = getUtils(csn);
+
+  const alreadyHandled = new WeakMap();
+  applyTransformations(csn, {
+    elements: (parent, prop, elements) => {
+      for (const elemName in elements) {
+        const elem = elements[elemName];
+        // (140) Generate the ON-condition for managed associations
+        if (isManagedAssociation(elem))
+          transformManagedAssociation(elem, elemName);
+      }
+    },     /* only for views and entities */
+  }, [], { skipIgnore: false, allowArtifact: artifact => (artifact.kind === 'entity') });
+
+  return csn;
+
+  /**
+   * Create the foreign key elements for a managed association and build the on-condition
+   *
+   * @param {Object} elem The association to process
+   * @param {string} elemName
+   * @returns {void}
+   */
+  function transformManagedAssociation(elem, elemName) {
+    // No need to run over this - we already did, possibly because it was referenced in the ON-Condition
+    // of another association - see a few lines lower
+    if (alreadyHandled.has(elem))
+      return;
+    // 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;
+    }
+    else {
+      for (const foreignKey of elem.keys) {
+        // Assemble left hand side of 'assoc.key = fkey'
+        const assocKeyArg = {
+          ref: [
+            elemName,
+          ].concat(foreignKey.ref),
+        };
+        const fkName = `${elemName}${pathDelimiter}${foreignKey.as}`;
+        const fKeyArg = {
+          ref: [
+            fkName,
+          ],
+        };
+
+        if (joinWithAnd) { // more than one FK
+          onCondParts.push('and');
+        }
+
+        onCondParts.push(
+          assocKeyArg
+        );
+        onCondParts.push('=');
+        onCondParts.push(fKeyArg);
+
+        if (!joinWithAnd)
+          joinWithAnd = true;
+      }
+      elem.on = onCondParts;
+    }
+
+    // If the managed association has a 'key' property => remove it as unmanaged assocs cannot be keys
+    // TODO: Are there other modifiers (like 'key') that are valid for managed, but not valid for unmanaged assocs?
+    if (elem.key)
+      delete elem.key;
+
+    // If the managed association has a 'not null' property => remove it
+    if (elem.notNull)
+      delete elem.notNull;
+
+    // The association is now unmanaged, i.e. actually it should no longer have foreign keys
+    // at all. But the processing of backlink associations below expects to have them, so
+    // we don't delete them
+    // TODO: maybe make non-enumerable, so we become recompilable in the future?
+
+    // Remember that we already processed this
+    alreadyHandled.set(elem, true);
+  }
+}
+
+/**
+ * @param {CSN.Model} csn
+ * @param {string} pathDelimiter
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
+ */
+function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
+  const {
+    inspectRef,
+  } = getUtils(csn);
+
+  return handleManagedAssocStepsInOnCondition;
+
+  /**
+   * Loop over all elements and for all unmanaged associations translate
+   * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
+   *
+   * Or in other words: Allow using the foreign keys of managed associations in on-conditions
+   *
+   * @param {CSN.Artifact} artifact Artifact to check
+   * @param {string} artifactName Name of the artifact
+   */
+  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
+    for (const elemName in artifact.elements) {
+      const elem = artifact.elements[elemName];
+      // The association is an unmanaged on
+      if (!elem.keys && elem.target && elem.on) {
+        applyTransformationsOnNonDictionary(elem, 'on', {
+          ref: (refOwner, prop, ref, path) => {
+            // [<assoc base>.]<managed assoc>.<field>
+            if (ref.length > 1) {
+              const { links } = inspectRef(path);
+              if (links) {
+                // eslint-disable-next-line for-direction
+                for (let i = links.length - 1; i >= 0; i--) {
+                  const link = links[i];
+                  // We found the latest managed assoc path step
+                  if (link.art && link.art.target && link.art.keys &&
+                    // Doesn't work when ref-target (filter condition) or similar is used
+                    !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
+                    // We join the managed assoc with everything following it
+                    const sourceElementName = ref.slice(i).join(pathDelimiter);
+                    const source = findSource(links, i - 1) || artifact;
+                    // allow specifying managed assoc on the source side
+                    const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
+                    if (fks && fks.length >= 1) {
+                      const fk = fks[0];
+                      const managedAssocStepName = refOwner.ref[i];
+                      const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
+                      if (source && source.elements[fkName])
+                        refOwner.ref = [ ...ref.slice(0, i), fkName ];
+                    }
+                  }
+                }
+              }
+            }
+          },
+        }, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+      }
+    }
+
+    /**
+     * Find out where the managed association is
+     *
+     * @param {Array} links
+     * @param {number} startIndex
+     * @returns {Object| undefined} CSN definition of the source of the managed association
+     */
+    function findSource(links, startIndex) {
+      for (let i = startIndex; i >= 0; i--) {
+        const link = links[i];
+        // We found the latest assoc step - now check where that points to
+        if (link.art && link.art.target)
+          return csn.definitions[link.art.target];
+      }
+
+      return undefined;
+    }
+  }
+}
+module.exports = {
+  attachOnConditions,
+  getManagedAssocStepsInOnConditionFinalizer,
+};

package/lib/transform/db/cdsPersistence.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const {
+  forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
+  getUtils,
+} = require('../../model/csnUtils');
+const transformUtils = require('../transformUtilsNew');
+
+const exists = '@cds.persistence.exists';
+
+/**
+ * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
+ * with _ignore.
+ *
+ * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
+ */
+function getAnnoProcessor() {
+  return handleCdsPersistence;
+  /**
+   * @param {CSN.Artifact} artifact
+   */
+  function handleCdsPersistence(artifact) {
+    const ignoreArtifact = (artifact.kind === 'entity') &&
+                           (artifact.abstract ||
+                            hasAnnotationValue(artifact, '@cds.persistence.skip') ||
+                            hasAnnotationValue(artifact, exists));
+    if (ignoreArtifact)
+      artifact._ignore = true;
+  }
+}
+
+/**
+ * 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
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.info
+ * @returns {(artifact: CSN.Artifact, artifactName: string, prop: string, path: CSN.Path) => void} Callback function for forEachDefinition
+ */
+function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
+  const { info } = messageFunctions;
+  const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
+
+  const { isAssocOrComposition } = getUtils(csn);
+
+  return ignoreAssociationToSkippedTarget;
+  /**
+   * Associations that target a @cds.persistence.skip artifact must be removed
+   * from the persistence model
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   * @param {string} prop
+   * @param {CSN.Path} path
+   */
+  function ignoreAssociationToSkippedTarget(artifact, artifactName, prop, path) {
+    if (isPersistedOnDatabase(artifact)) {
+      // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
+      if (artifact.query) {
+        // If we do A2J, we don't need to check the mixin. Either it is used -> a join
+        // or published -> handled via elements/members. Unused mixins are removed anyway.
+        if (!doA2J && artifact.query.SELECT && artifact.query.SELECT.mixin)
+          forEachGeneric(artifact.query.SELECT, 'mixin', ignore, path.concat([ 'query', 'SELECT' ]));
+
+        else if (!doA2J && artifact.query.SET && artifact.query.SET.mixin)
+          forEachGeneric(artifact.query.SET, 'mixin', ignore, path.concat([ 'query', 'SET' ]));
+      }
+      forEachMemberRecursively(artifact, ignore, [ 'definitions', artifactName ]);
+    }
+  }
+
+  /**
+   * Mark the given member with _ignore if it is an association/composition and it's target is unreachable.
+   *
+   * @param {CSN.Element} member
+   * @param {string} memberName
+   * @param {string} prop
+   * @param {CSN.Path} path
+   * @todo Why do we check for @cds.persistence.exists here if the parent-function only calls this for skip/abstract?
+   */
+  function ignore(member, memberName, prop, path) {
+    if (options.sqlDialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
+      const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], exists) ? exists : '@cds.persistence.skip';
+      info(null, path,
+           { target: member.target, anno: targetAnnotation },
+           'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
+      member._ignore = true;
+    }
+  }
+
+  /**
+   * Check whether the given artifact is an unreachable association target because it will not "realy" hit the database:
+   * - @cds.persistence.skip/exists
+   * - abstract
+   *
+   * @param {CSN.Artifact} art
+   * @returns {boolean}
+   */
+  function isUnreachableAssociationTarget(art) {
+    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, exists);
+  }
+}
+
+/**
+ * Return a callback function for forEachDefinition that handles artifacts marked with @cds.persistence.table.
+ * If a .query artifact has this annotation, the .query will be deleted and it will be treated like a table.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
+ */
+function getPersistenceTableProcessor(csn, options, messageFunctions ) {
+  const { error } = messageFunctions;
+  const {
+    recurseElements,
+  } = transformUtils.getTransformers(csn, options, '_');
+
+  return handleQueryish;
+
+
+  /**
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   */
+  function handleQueryish(artifact, artifactName) {
+    const stripQueryish = artifact.query && hasAnnotationValue(artifact, '@cds.persistence.table');
+
+    if (stripQueryish) {
+      artifact.kind = 'entity';
+      delete artifact.query;
+
+      recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
+        // All elements must have a type for this to work
+        if (!member._ignore && !member.kind && !member.type)
+          error(null, path, 'Expecting element to have a type if view is annotated with “@cds.persistence.table“');
+      });
+    }
+  }
+}
+
+
+module.exports = {
+  getAnnoProcessor,
+  getAssocToSkippedIgnorer,
+  getPersistenceTableProcessor,
+};

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 };