@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/transform/db/rewriteCalculatedElements.js

@@ -3,12 +3,16 @@
 const { setProp } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
 const {
-  forEachDefinition, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary, implicitAs, cloneCsnNonDict, getUtils,
+  forEachDefinition,
+  applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
+  implicitAs,
+  cloneCsnNonDict,
   forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
-const { checkForeignKeyAccess } = require('../../checks/onConditions');
+const { requireForeignKeyAccess } = require('../../checks/onConditions');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 
@@ -19,11 +23,13 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} csnUtils
  * @param {string} pathDelimiter
- * @param {Function} error
+ * @param {object} messageFunctions
  */
-function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error ) {
-  const { inspectRef, effectiveType } = getUtils(csn, 'init-all');
+function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, messageFunctions ) {
+  const { inspectRef, effectiveType } = csnUtils;
+  const { error } = messageFunctions;
 
   const views = [];
   const entities = [];
@@ -121,7 +127,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         }
         else {
           // It's a managed association - access of the foreign keys is allowed
-          checkForeignKeyAccess(parent, i, csnPath, (errorIndex) => {
+          requireForeignKeyAccess(parent, i, (errorIndex) => {
             error('ref-unexpected-navigation', csnPath, {
               '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
             });
@@ -412,7 +418,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {CSN.QuerySelect} SELECT
    * @returns {object}
    */
-  function getDirectlyAdressableElements( SELECT ) {
+  function getDirectlyAddressableElements( SELECT ) {
     const { from } = SELECT;
     if (from.ref) {
       return from._art.elements;
@@ -422,7 +428,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     }
     else if (from.SET) {
       // args[0] could be SELECT or UNION
-      return getDirectlyAdressableElements({ from: from.SET.args[0] });
+      return getDirectlyAddressableElements({ from: from.SET.args[0] });
     }
     else if (from.args) {
       const mergedElements = Object.create(null);
@@ -432,7 +438,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
             mergedElements[elementName] = arg._art.elements[elementName];
         }
         else if (arg.SET) {
-          return getDirectlyAdressableElements({ from: arg.SET.args[0] });
+          return getDirectlyAddressableElements({ from: arg.SET.args[0] });
         }
         else if (arg.SELECT) { // TODO: UNION
           for (const elementName in arg.SELECT.elements)
@@ -440,7 +446,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         }
         else if (arg.args) { // TODO: Is it safe to do recursion here?
           for (const subarg of arg.args) {
-            const elements = getDirectlyAdressableElements({ from: subarg });
+            const elements = getDirectlyAddressableElements({ from: subarg });
             for (const elementName in elements)
               mergedElements[elementName] = elements[elementName];
           }
@@ -465,8 +471,8 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    */
   function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
     const cleanupCallbacks = [];
-    const root = getDirectlyAdressableElements(SELECT);
-    const columnMap = getColumnMap( { SELECT });
+    const root = getDirectlyAddressableElements(SELECT);
+    const columnMap = getColumnMap( { SELECT }, csnUtils );
     const hasStar = SELECT.columns.includes('*');
     const unfoldingMap = {};
     let starContainsCalculated = false;
@@ -699,9 +705,9 @@ function processCalculatedElementsInEntities( csn ) {
  */
 function removeDummyValueInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
-    value: (parent, prop, value, p, root) => {
+    value: (parent, prop, value, p, elements) => {
       if (!value.stored)
-        delete root[p[p.length - 1]];
+        delete elements[p[p.length - 1]];
     },
   }, {}, path.concat( 'elements' ));
 }

package/lib/transform/db/temporal.js

@@ -5,7 +5,7 @@ const {
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 
 const validToString = '@cds.valid.to';
 const validFromString = '@cds.valid.from';

package/lib/transform/db/transformExists.js

@@ -53,22 +53,23 @@ const { ModelError } = require('../../base/error');
 function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
+    // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
+    // thinks that the artifact was already initialized (including all queries).
+    dropDefinitionCache(artifact);
     if (artifact.projection) // do the same hack we do for the other stuff...
       artifact.query = { SELECT: artifact.projection };
 
     if (artifact.query) {
-      forAllQueries(artifact.query, (query, path) => {
+      forAllQueries(artifact.query, function handleExistsQuery(query, path) {
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
-          if (query.SELECT && query.SELECT.where && query.SELECT.where.length > 1)
+          if (query.SELECT?.where?.length > 1)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
 
-
-          if (query.SELECT && query.SELECT.columns)
+          if (query.SELECT?.columns)
             toProcess.push([ path.slice(0, -1), path.concat('columns') ]);
 
-
-          if (query.SELECT && query.SELECT.from.on )
+          if (query.SELECT?.from.on)
             toProcess.push([ path.slice(0, -1), path.concat([ 'from', 'on' ]) ]);
 
           for (const [ , exprPath ] of toProcess) {
@@ -268,7 +269,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
 
         const { links } = inspectRef(exprPath.concat(i));
 
-        const assocs = links.filter(link => link.art && link.art.target).map(link => current.ref[link.idx]);
+        const assocs = links.filter(link => link.art?.target).map(link => current.ref[link.idx]);
 
         checkForInvalidAssoc(assocs);
       }

package/lib/transform/db/views.js

@@ -1,10 +1,11 @@
 'use strict';
 
 const {
-  getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary,
+  getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary, forEachDefinition,
 } = require('../../model/csnUtils');
-const { implicitAs } = require('../../model/csnRefs');
+const { implicitAs, columnAlias } = require('../../model/csnRefs');
 const { ModelError } = require('../../base/error');
+const { setProp } = require('../../base/model');
 
 /**
  * If a mixin association is published, return the mixin association.
@@ -66,10 +67,11 @@ function usesMixinAssociation( query, association, associationName ) {
  * @returns {(query: CSN.Query, artifact: CSN.Artifact, artName: string, path: CSN.Path) => void} Transformer function for views
  */
 function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
+  const csnUtils = getUtils(csn);
   const {
     get$combined, isAssocOrComposition,
     inspectRef, queryOrMain, // csnRefs
-  } = getUtils(csn);
+  } = csnUtils;
   const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
@@ -213,7 +215,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
         else
           info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': 'std' });
 
-        elem._ignore = true;
+        elem.$ignore = true;
       }
       else {
         error(null, queryPath, { name: elemName }, 'Association $(NAME) can\'t be published in a SAP HANA CDS UNION');
@@ -270,7 +272,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
           }, {}, elementsPath.concat(elemName));
         }
 
-        if (!mixinElem._ignore)
+        if (!mixinElem.$ignore)
           columnMap[elemName] = { ref: [ mixinElemName ], as: elemName };
 
         if (query.SELECT) {
@@ -311,7 +313,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
 
 
   /**
-   * Loop over the columns and call all of the given functions with the column and the path
+   * Loop over the columns and call all the given functions with the column and the path
    *
    * @param {Function[]} functions
    * @param {CSN.Column[]} columns
@@ -332,6 +334,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
    */
   // eslint-disable-next-line complexity
   function transformViewOrEntity( query, artifact, artName, path ) {
+    csnUtils.initDefinition(artifact);
     const { elements } = queryOrMain(query, artifact);
     // We use the elements from the leading query/main artifact - adapt the path
     const elementsPath = elements === artifact.elements ? path.slice(0, 2).concat('elements') : path.concat('elements');
@@ -340,7 +343,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
     let hasNonAssocElements = false;
     const isSelect = query && query.SELECT;
     const isProjection = !!artifact.projection || query && query.SELECT && !query.SELECT.columns;
-    const columnMap = getColumnMap(query);
+    const columnMap = getColumnMap(query, csnUtils);
     const isSelectStar = query && query.SELECT && query.SELECT.columns && query.SELECT.columns.indexOf('*') !== -1;
 
     // check all queries/subqueries for mixin publishing inside of unions -> forbidden in hdbcds
@@ -365,7 +368,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
           addForeignKeysToColumns(columnMap, elem, elemName);
       }
       // Views must have at least one element that is not an unmanaged assoc
-      if (!elem.on && !elem._ignore)
+      if (!elem.on && !elem.$ignore)
         hasNonAssocElements = true;
 
       // (180 b) Create MIXINs for association elements in projections or views (those that are not mixins by themselves)
@@ -383,7 +386,7 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
 
     if (isSelect) {
       // Build new columns from the column map - bring elements and columns back in sync basically
-      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem]._ignore).map(key => stripLeadingSelf(columnMap[key]));
+      query.SELECT.columns = Object.keys(elements).filter(elem => !elements[elem].$ignore).map(key => stripLeadingSelf(columnMap[key]));
       // If following an association, explicitly set the implicit alias
       // due to an issue with HANA - this seems to only have an effect on ref files with hdbcds-hdbcds, so only run then
       const columnProcessors = [];
@@ -476,45 +479,82 @@ function getLastRefStepString( ref ) {
 }
 
 /**
- * Build a map of the resulting names (i.e. the element name of the column) and references to the respective columns
+ * This function is similar to csnRefs()' `columnName()`, but does not split the
+ * last `col.ref` segment on `.`.
  *
+ * TODO: The HDBCDS backend relies on this. Also the HDI backend relies
+ *       on this for virtual elements somehow.  That can probably be fixed
+ *       by using csnRefs()'s `getElement()`.
+ * TODO: Remove this function; update HDBCDS/HDI
+ *
+ * @param {CSN.Column} col
+ * @returns {string}
+ */
+function columnNameForMap( col ) {
+  return col.as || (!col.args && col.func) || (col.ref && getLastRefStepString( col.ref ));
+}
+
+/**
+ * Build a map of the resulting names (i.e. the element name of the column) and references
+ * to the respective columns.
  * This can later be used to match from elements to columns.
  *
  * @param {CSN.Query} query
+ * @param {object} csnUtils
  * @returns {object}
  */
-function getColumnMap( query ) {
+function getColumnMap( query, csnUtils ) {
   const map = Object.create(null);
-  if (query && query.SELECT && query.SELECT.columns) {
+  if (query?.SELECT?.columns) {
     query.SELECT.columns.forEach((col) => {
-      if (col === '*') {
-        // do nothing
-      }
-      else if (col.as) {
-        if (!map[col.as])
-          map[col.as] = col;
-      }
-      else if (col.ref) {
-        // .id on last path step can happen with hdbcds.hdbcds and malicious CSN input - maybe also with params?
-        // We made things right in the end with the second add of missing stuff, but why not do it
-        // right from the getgo
-        const last = getLastRefStepString(col.ref);
-        if (!map[last])
-          map[last] = col;
-      }
-      else if (col.func) {
-        map[col.func] = col;
-      }
-      else if (!map[col]) {
-        map[col] = col;
+      if (col !== '*') {
+        // Fallback to csnUtils for columns without any alias (internal one is created)
+        const as = columnNameForMap(col) || csnUtils.getColumnName( col );
+        if (as && !map[as])
+          map[as] = col;
       }
     });
   }
-
   return map;
 }
 
+
+/**
+ * Ensure that each column in the CSN has a name.  A column does not have
+ * a name if the column is an expression and there is no explicit alias.
+ * In that case an internal alias (from csnRefs()) is used and made explicit
+ * via non-enumerable `as`.
+ *
+ * For HDBCDS, the alias is made explicit as an enumerable property, because
+ * HDBCDS does not support expressions as columns without aliases.
+ *
+ * Notes:
+ *  - The alias is removed after A2J: we rely on the compiler ignoring non-enumerable CSN properties.
+ *  - We can't use e.g. `$as`, as csnRefs() does not use that property, and it must not
+ *    invent another name for the column (could happen after flattening).
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} csnUtils
+ */
+function ensureColumnNames( csn, options, csnUtils ) {
+  forEachDefinition(csn, (def) => {
+    csnUtils.initDefinition(def);
+    for (const query of csnUtils.$getQueries(def) || []) {
+      for (const col of query._select.columns || []) {
+        if (col !== '*' && !columnAlias(col)) {
+          if (options.transformation === 'hdbcds')
+            col.as = csnUtils.getColumnName(col);
+          else
+            setProp(col, 'as', csnUtils.getColumnName(col));
+        }
+      }
+    }
+  });
+}
+
 module.exports = {
   getViewTransformer,
   getColumnMap,
+  ensureColumnNames,
 };

package/lib/transform/draft/db.js

@@ -5,7 +5,7 @@ const {
   getResultingName, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const draftAnnotation = '@odata.draft.enabled';
 const booleanBuiltin = 'cds.Boolean';
@@ -124,16 +124,18 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
         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 ], true, { elementsOnly: true });
+    }, [ '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 ], 'Entity annotated with “@odata.draft.enabled” should have exactly one key element');
-
-    const uuidCount = keys.reduce((acc, k) => ((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”');
-
+    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.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) || '';

package/lib/transform/draft/odata.js

@@ -3,7 +3,7 @@
 const { forEachDefinition, getServiceNames } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { makeMessageFunction } = require('../../base/messages');
 

package/lib/transform/{forOdataNew.js → forOdata.js}

@@ -2,7 +2,7 @@
 
 const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
-const transformUtils = require('./transformUtilsNew');
+const transformUtils = require('./transformUtils');
 const { cloneCsnNonDict,
         forEachDefinition,
         forEachMemberRecursively,
@@ -152,6 +152,8 @@ function transform4odataWithCsn(inputModel, options) {
     { skipArtifact: isExternalServiceMember }
   );
 
+  flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
+
   // All type refs must be resolved, including external APIs.
   // OData has no 'type of' so 'real' imported OData APIs marked @cds.external are safe.
   // If in the future 'other' APIs that might support type refs are imported, these refs must be
@@ -169,6 +171,7 @@ function transform4odataWithCsn(inputModel, options) {
     expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
+
     flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
     // No type references exist anymore
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
@@ -389,14 +392,14 @@ function transform4odataWithCsn(inputModel, options) {
 
     // Only on element level
     if(node.kind == null) {
-      if (node['@mandatory']&& node['@Common.FieldControl'] === undefined) {
+      if (node['@mandatory'] && !Object.entries(node).some(([k,v]) => k === '@Common.FieldControl' || k.startsWith('@Common.FieldControl.') && v != null)) {
         setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
       }
-      if (node['@assert.range'] != null) {
-        if (Array.isArray(node['@assert.range']) && node['@assert.range'].length === 2) {
-          setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
-          setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
-        }
+      if (node['@assert.range'] != null &&
+          (Array.isArray(node['@assert.range']) &&
+           node['@assert.range'].length === 2)) {
+        setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
+        setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
       }
     }
   }