@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/transform/forHanaNew.js

@@ -2,7 +2,7 @@
 
 const { setProp, isBetaEnabled } = require('../base/model');
 const { getUtils, cloneCsn,
-        forEachMemberRecursively, forEachRef, forAllQueries,
+        forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath,
       } = require('../model/csnUtils');
@@ -12,7 +12,7 @@ const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const { csnRefs, pathId } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
-const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
+const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
@@ -23,12 +23,13 @@ const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
 const flattening = require('./db/flattening');
 const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
-const generateDrafts = require('./db/draft');
-const enrichUniversalCsn = require('./universalCsnEnricher');
+const generateDrafts = require('./draft/db');
+const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const { getViewTransformer } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
+const { ModelError } = require("../base/error");
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -113,12 +114,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
 
-  let error, warning, info; // message functions
+  let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithError;
-  let artifactRef, inspectRef, effectiveType, // csnRefs
-    addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType, getFinalBaseType, // transformUtils
-    get$combined; // csnUtils
+  let artifactRef, inspectRef, effectiveType, get$combined,
+    getFinalBaseType, // csnUtils (csnRefs)
+    addDefaultTypeFacets, expandStructsInExpression; // transformUtils
 
   bindCsnReference();
 
@@ -136,7 +137,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forHana(csn, {
-    error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
   });
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
@@ -232,34 +233,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
-    type: (val, node, key, path) => {
-      // Resolve type-of chains
-      function fn() {
-        // val can be undefined: books as myBooks : redirected to Model.MyBooks
-        if (val && val.ref) {
-          const { art } = inspectRef(path);
-          if (art && art.type) {
-            val = art.type;
-            // This is somehow needed to update the ref so that inspectRef sees it
-            node[key] = val;
-            if (val.ref)
-              fn();
-          }
-          else {
-            // Doesn't seem to ever ocurr
-          }
-        }
-      }
-      fn();
+    type: (val, node, key) => {
       renamePrimitiveTypesAndUuid(val, node, key);
       addDefaultTypeFacets(node);
     },
-    cast: (val) => {
-      if (options.forHana.names === 'plain' || options.toSql )
-        toFinalBaseType(val);
-      renamePrimitiveTypesAndUuid(val.type, val, 'type');
-      addDefaultTypeFacets(val);
-    },
     // HANA/SQLite do not support array-of - turn into CLOB/Text
     items: (val, node) => {
       node.type = 'cds.LargeString';
@@ -270,24 +247,19 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // (040) Ignore entities and views that are abstract or implemented
   // or carry the annotation cds.persistence.skip/exists
   // These entities are not removed from the csn, but flagged as "to be ignored"
-  forEachDefinition(csn, cdsPersistence.getAnnoProcessor(csn, options, {warning}));
+  forEachDefinition(csn, cdsPersistence.getAnnoProcessor());
 
 
   // (050) Check @cds.valid.from/to only on entity
   //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
-  //       Temporal only in beta-mode
   forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
 
-  handleManagedAssociationsAndCreateForeignKeys();
+  // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, { allowArtifact: artifact => (artifact.kind === 'entity') });
 
-  function handleManagedAssociationsAndCreateForeignKeys() {
-    forEachDefinition(csn, associations.getForeignKeyFlattener(csn, options, pathDelimiter));
-    forEachDefinition(csn, associations.getForeignKeyElementCreator(csn, options, pathDelimiter, { error }));
-  }
-
-  forEachDefinition(csn, flattenIndexes);
-  // Basic handling of associations in views and entities
-  forEachDefinition(csn, associations.getManagedAssociationTransformer(csn, options, pathDelimiter));
+  doA2J && forEachDefinition(csn, flattenIndexes);
+  // Managed associations get an on-condition - in views and entities
+  doA2J && associations.attachOnConditions(csn, pathDelimiter);
 
   // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
   // and make them entities
@@ -296,10 +268,11 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
   // are part of the elements
-  forEachDefinition(csn, handleManagedAssocStepsInOnCondition);
+  if (doA2J)
+    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter));
 
   // Create convenience views for localized entities/views.
-  // To be done after handleManagedAssocStepsInOnCondition because associations are
+  // To be done after getManagedAssocStepsInOnConditionFinalizer because associations are
   // handled and before handleDBChecks which removes the localized attribute.
   // Association elements of localized convenience views do not have hidden properties
   // like $managed set, so we cannot do this earlier on.
@@ -308,11 +281,11 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   else
     addLocalizationViews(csn, options);
 
-  forEachDefinition(csn, (definition, artName, prop, path) => {
+  !doA2J && forEachDefinition(csn, (definition, artName, prop, path) => {
     if (definition.query) {
       // reject managed association and structure publishing for to-hdbcds.hdbcds
       const that = { csnUtils: getUtils(csn), options, error };
-      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
+      rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
     }
   });
 
@@ -336,18 +309,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
   forEachDefinition(csn, transformSelfInBacklinks);
 
-  if(options.forHana){
-    /**
-     * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
-     * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
-     * hence we do not generate the referential constraints for them.
-     */
-    const validOptionsForConstraint = () => {
-      return (options.forHana.dialect === 'sqlite' || options.forHana.dialect === 'hana') && doA2J;
-    }
-    if(validOptionsForConstraint())
-      createReferentialConstraints(csn, options);
-  }
+  /**
+   * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
+   * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
+   * hence we do not generate the referential constraints for them.
+   */
+  if((options.sqlDialect === 'hana' || options.sqlDialect === 'sqlite') && doA2J)
+    createReferentialConstraints(csn, options);
+
   // no constraints for drafts
   generateDrafts(csn, options, pathDelimiter, { info, warning, error });
 
@@ -370,30 +339,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   const checkConstraintIdentifiers = (artifact, artifactName, prop, path) => {
     assertConstraintIdentifierUniqueness(artifact, artifactName, path, error);
   };
-  const removeNamespaces = (artifact, artifactName) => {
-    if (artifact.kind === 'namespace')
-      delete csn.definitions[artifactName];
-  };
-  const ignoreNonPersistedArtifactsWithAnonymousAspectComposition = (artifact) => {
-    if(artifact.kind === 'type' || artifact.kind === 'aspect' || artifact.kind === 'entity' && artifact.abstract){
-      if(artifact.elements && Object.keys(artifact.elements).some((elementName) => {
-        const element = artifact.elements[elementName];
-        return !element.target && element.targetAspect && typeof element.targetAspect !== 'string';
-      })) {
-        artifact._ignore = true;
-      }
-    }
-  };
 
   forEachDefinition(csn, [
     /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
     checkConstraintIdentifiers,
-    /* (250) Remove all namespaces from definitions */
-    removeNamespaces,
     /* Check Type Parameters (precision, scale, length ...) */
     checkTypeParameters,
-    /* Filter out aspects/types/abstract entities containing managed compositions of anonymous aspects */
-    ignoreNonPersistedArtifactsWithAnonymousAspectComposition,
     // (200) Strip 'key' property from type elements
     removeKeyPropInType,
   ]);
@@ -433,7 +384,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     '$key': killProp
   }
 
-  applyTransformations(csn, killers, [], false);
+  applyTransformations(csn, killers, [], { skipIgnore: false});
 
   redoProjections.forEach(fn => fn());
 
@@ -442,10 +393,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    ({ error, warning, info, throwWithError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, effectiveType } = csnRefs(csn));
-    ({ getFinalBaseType, get$combined } = getUtils(csn));
-    ({ addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    ({ error, warning, info, message, throwWithError } = makeMessageFunction(csn, options, moduleName));
+    ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
+    ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
   }
 
   function bindCsnReferenceOnly(){
@@ -472,8 +422,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           }
         })
       }
-    }
-    , [ 'definitions', artifactName, 'query' ]);
+    }, [ 'definitions', artifactName, 'query' ]);
+
     function getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path){
       const { inspectRef } = csnRefs(csn);
       const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
@@ -524,7 +474,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformViews(artifact, artifactName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
-      if ((artifact.kind === 'entity' || artifact.kind === 'view') && artifact.query) {
+      if ((artifact.kind === 'entity') && artifact.query) {
         forAllQueries(artifact.query, (q, p) => {
           transformEntityOrViewPass2(q, artifact, artifactName, p)
           replaceAssociationsInGroupByOrderBy(q, options, inspectRef, error, p);
@@ -539,7 +489,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    */
   function recursivelyApplyCommon(artifact, artifactName) {
     if (!artifact._ignore) {
-      if (![ 'service', 'context', 'namespace', 'annotation', 'action', 'function' ].includes(artifact.kind))
+      if (artifact.kind !== 'service' && artifact.kind !== 'context')
         addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.forHana.names, csn), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
@@ -558,9 +508,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function removeKeyPropInType(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact._ignore && artifact.kind === 'type') {
       forEachMemberRecursively(artifact, (member) => {
-        if (artifact.kind === 'type' && member.key)
+        if (member.key)
           delete member.key;
       }, [ 'definitions', artifactName ]);
     }
@@ -609,25 +559,27 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         if (artifact.params) {
           // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
           // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
-          error(null, path, 'Unexpected association in parameterized view');
+          message('def-unexpected-paramview-assoc', path, { '#': 'view' });
         }
         else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
           // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
-          error(null, path, `Associations are not allowed in entities annotated with @cds.persistence { udf, calcview }`);
+          const anno = artifact['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+          message('def-unexpected-calcview-assoc', path, { '#': 'entity-persistence', anno });
         }
         if (csn.definitions[member.target].params) {
           // HANA does not allow association targets with parameters or to UDFs/CVs w/o parameters:
           // SAP DBTech JDBC: [7]: feature not supported: cannot support create association to a parameterized view
-          error(null, path, 'Unexpected parameterized association target');
+          message('def-unexpected-paramview-assoc', path, { '#': 'target' });
         }
-        else if(csn.definitions[member.target]['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
+        else if(csn.definitions[member.target]['@cds.persistence.udf'] || csn.definitions[member.target]['@cds.persistence.calcview']) {
           // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
           // SAP DBTech JDBC: [259]: invalid table name: target object SYSTEM.UDF does not exist: line 3 col 6 (at pos 43)
           // CREATE TABLE F (id INTEGER NOT NULL);
           // CREATE FUNCTION UDF RETURNS TABLE (ID INTEGER) LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS BEGIN RETURN SELECT ID FROM F; END;
           // CREATE TABLE Y (  id INTEGER NOT NULL,  toUDF_id INTEGER) WITH ASSOCIATIONS (MANY TO ONE JOIN UDF AS toUDF ON (toUDF.id = toUDF_id));
           // CREATE VIEW U AS SELECT  id, toUDF.a FROM Y;
-          error(null, path, `Associations can't point to entities annotated with @cds.persistence { udf, calcview }`);
+          const anno = csn.definitions[member.target]['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+          message('def-unexpected-calcview-assoc', path, { '#': 'target-persistence', anno });
         }
       }
     }, [ 'definitions', artifactName ]);
@@ -638,7 +590,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function handleChecksForWithParameters(artifact, artifactName) {
-    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity' || artifact.kind === 'view')) {
+    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity')) {
       if (!artifact.query) { // table entity with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], { '#': options.toSql ? 'sql' : 'std' }, {
@@ -908,7 +860,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       else if (assoc.on)
         return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName);
 
-      throw new Error(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
+      throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
     }
 
     // For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
@@ -963,22 +915,23 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       const newOnCond = cloneWithTransformations(assoc.on, {
         ref: (value) => cloneWithTransformations(value, {}),
       });
-      // goes through the the newOnCond and transform all the 'path' elements
-      forEachRef(newOnCond, (ref) => {
-        if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
-        {
-          ref.shift();
-        } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
-          // We could also have a $self infront of the assoc name - so we would need to shift twice
-          ref.shift();
-          ref.shift();
-        }
-        else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
-          ref.unshift(elemName);
-          // if there was a $self identifier in the forwarding association onCond
-          // we do not need it any more, as we prepended in the previous step the back association's id
-          if (ref[1] === '$self')
-            ref.splice(1, 1);
+      applyTransformationsOnNonDictionary({on: newOnCond}, 'on', {
+        ref: (parent, prop, ref) => {
+          if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
+          {
+            ref.shift();
+          } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
+            // We could also have a $self infront of the assoc name - so we would need to shift twice
+            ref.shift();
+            ref.shift();
+          }
+          else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
+            ref.unshift(elemName);
+            // if there was a $self identifier in the forwarding association onCond
+            // we do not need it any more, as we prepended in the previous step the back association's id
+            if (ref[1] === '$self')
+              ref.splice(1, 1);
+          }
         }
       });
       return newOnCond;
@@ -1090,7 +1043,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function flattenIndexes(art, artName) {
     // Flatten structs in indexes (unless explicitly asked to keep structs)
     const tc = art.technicalConfig;
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
+    if (art.kind === 'entity') {
       if (tc && tc[dialect]) {
         // Secondary and fulltext indexes
         for (const name in tc[dialect].indexes) {
@@ -1144,75 +1097,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       }
     }
   }
-
-  /**
-   * 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];
-      if (doA2J) {
-        // The association is an unmanaged on
-        if (!elem.keys && elem.target && elem.on) {
-          forEachRef(elem.on, (ref, refOwner, 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
-                    if (!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, 'on' ]);
-        }
-      }
-    }
-
-    /**
-     * 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;
-    }
-  }
 }