@sap/cds-compiler 4.0.0 → 4.1.2

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,
@@ -312,79 +312,93 @@ function transform4odataWithCsn(inputModel, options) {
       node['@Core.Computed'] = true;
   }
 
-  // Rename shorthand annotations within artifact or element 'node' according to a builtin
-  // list.
+  // Rename shorthand annotations within artifact or element 'node' according to a builtin list
   function renameShorthandAnnotations(node) {
-    // FIXME: Verify this list - are they all still required? Do we need any more?
     const setMappings = {
       '@label': '@Common.Label',
       '@title': '@Common.Label',
       '@description': '@Core.Description',
     };
     const renameMappings = {
-      '@ValueList.entity': '@Common.ValueList.entity',
-      '@ValueList.type': '@Common.ValueList.type',
-      '@Capabilities.Deletable': '@Capabilities.DeleteRestrictions.Deletable',
-      '@Capabilities.Insertable': '@Capabilities.InsertRestrictions.Insertable',
-      '@Capabilities.Updatable': '@Capabilities.UpdateRestrictions.Updatable',
-      '@Capabilities.Readable': '@Capabilities.ReadRestrictions.Readable',
+      '@ValueList.entity': { val: '@Common.ValueList', op: 'entity' },
+      '@ValueList.type':  { val: '@Common.ValueList', op: 'type' },
+      '@Capabilities.Deletable': { val: '@Capabilities.DeleteRestrictions', op: 'Deletable' },
+      '@Capabilities.Insertable': { val: '@Capabilities.InsertRestrictions', op: 'Insertable' },
+      '@Capabilities.Updatable': { val: '@Capabilities.UpdateRestrictions', op: 'Updatable' },
+      '@Capabilities.Readable': { val: '@Capabilities.ReadRestrictions', op: 'Readable' }
     };
 
     const setShortCuts = Object.keys(setMappings);
     const renameShortCuts = Object.keys(renameMappings);
+
+    // Capabilities shortcuts have precedence over @readonly/@insertonly
     Object.keys(node).forEach( name => {
       if (!name.startsWith('@'))
         return;
       // Rename according to map above
-      const renamePrefix = (name in renameMappings) ? name : renameShortCuts.find(p => name.startsWith(p + '.'));
+      const renamePrefix = (name in renameMappings)
+        ? name 
+        : renameShortCuts.find(p => name.startsWith(p + '.'));
       if(renamePrefix) {
-        renameAnnotation(node, name, name.replace(renamePrefix, renameMappings[renamePrefix]));
-      } else {
+        const mapping = renameMappings[renamePrefix];
+        renameAnnotation(node, name, name.replace(renamePrefix, `${mapping.val}.${mapping.op}`));
+      }
+      else {
         // The two mappings have no overlap, so no need to check for second map if first matched.
         // Rename according to map above
-        const setPrefix = (name in setMappings) ? name : setShortCuts.find(p => name.startsWith(p + '.'));
+        const setPrefix = (name in setMappings)
+          ? name
+          : setShortCuts.find(p => name.startsWith(p + '.') || name.startsWith(p + '#'));
         if(setPrefix) {
           setAnnotation(node, name.replace(setPrefix, setMappings[setPrefix]), node[name]);
         }
       }
+    });
+
+    // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
+    // but '@Core.Computed' for everything else.
 
-      // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
-      // but '@Core.Immutable' for everything else.
-      if (!(node['@readonly'] && node['@insertonly'])) {
-        if (name === '@readonly' && node[name]) {
+    // only if not both readonly/insertonly are true do the mapping
+    if(!(node['@readonly'] && node['@insertonly'])) {
+      if(node['@readonly']) {
+        const setRO = (qualifier) => {
           if (node.kind === 'entity' || node.kind === 'aspect') {
-            setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
-            setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
-            setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
+            setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifier ? '#' + qualifier : ''}.Deletable`, false);
+            setAnnotation(node, `@Capabilities.InsertRestrictions${ qualifier ? '#' + qualifier : ''}.Insertable`, false);
+            setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifier ? '#' + qualifier : ''}.Updatable`, false);
           } else {
             setAnnotation(node, '@Core.Computed', true);
           }
-        }
-        // @insertonly is effective on entities/queries only
-        else if (name === '@insertonly' && node[name]) {
-          if (node.kind === 'entity' || node.kind === 'aspect') {
-            setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
-            setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
-            setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
-          }
-        }
+        };
+        setRO(undefined);
       }
-      // Only on element level: translate @mandatory
-      if (name === '@mandatory' && node[name] &&
-        node.kind === undefined && node['@Common.FieldControl'] === undefined) {
-        setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
+      // @insertonly is effective on entities/queries only
+      if (node['@insertonly'] && (node.kind === 'entity' || node.kind === 'aspect')) {
+        const setIO = (qualifier) => {
+          setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifier ? '#' + qualifier : ''}.Deletable`, false);
+          setAnnotation(node, `@Capabilities.ReadRestrictions${ qualifier ? '#' + qualifier : ''}.Readable`, false);
+          setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifier ? '#' + qualifier : ''}.Updatable`, false);
+        }
+        setIO(undefined);
       }
+    }
 
-      if (name === '@assert.format' && node[name] !== null)
-        setAnnotation(node, '@Validation.Pattern', node['@assert.format']);
+    // @Validation.Pattern is applicable to "Term" => node.kind === annotation
+    if (node['@assert.format'] != null)
+      setAnnotation(node, '@Validation.Pattern', node['@assert.format']);
 
-      if (name === '@assert.range' && node[name] !== 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]);
-        }
+    // Only on element level
+    if(node.kind == null) {
+      if (node['@mandatory']&& node['@Common.FieldControl'] === undefined) {
+        setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
       }
-    });
+      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]);
+      }
+    }
   }
 
   // Apply default type facets to each type definition and every member