@sap/cds-compiler 3.3.2 → 3.4.2

package/lib/transform/db/assertUnique.js

@@ -3,6 +3,7 @@
 const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
 const { getTransformers } = require('../transformUtilsNew');
 const { setProp } = require('../../base/model');
+const { pathName } = require('../../compiler/utils');
 
 
 /**
@@ -38,13 +39,14 @@ function processAssertUnique(csn, options, error, info) {
     // filter unique constraints from annotations
     for (const propName in artifact) {
       if (propName.startsWith('@assert.unique') && artifact[propName] !== null) {
+        const anno = propName;
         // Constraint Name check
         const constraintName = propName.split('.').splice(2);
         if (constraintName.length === 0)
-          err(propName, 'Table constraint cannot be anonymous');
+          error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Table constraint can\'t be anonymous');
         if (constraintName.length > 1)
         // Neither HANA CDS nor HANA SQL allow dots in index names
-          err(propName, "Illegal character '.' in constraint name");
+          error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Illegal character \'.\' in constraint name');
 
         const propValue = artifact[propName];
         // Constraint value check, returns array of path values
@@ -79,10 +81,12 @@ function processAssertUnique(csn, options, error, info) {
             pathxrefs[pstr]++;
         });
         Object.keys(pathxrefs).forEach((k) => {
-          if (pathxrefs[k] > 1)
-            err(propName, `Final path "${k}" can only be specified once`);
+          if (pathxrefs[k] > 1) {
+            error(null, [ 'definitions', artifactName ], { anno, id: k },
+                  '$(ANNO): Final path $(ID) can only be specified once');
+          }
         });
-        // 9) Add into constraint cross reference
+        // 9) Add into constraint cross-reference
         if (constraintKey.length) {
           if (constraintXrefs[constraintKey])
             constraintXrefs[constraintKey].push(propName);
@@ -99,7 +103,7 @@ function processAssertUnique(csn, options, error, info) {
     for (const key in constraintXrefs) {
       const val = constraintXrefs[key];
       if (val.length > 1)
-        err(val.join(', '), 'Constraint can only be specified once');
+        error(null, [ 'definitions', artifactName ], { annos: val }, '$(ANNOS): Constraint can only be specified once');
     }
     // preserve dictionary in '$tableConstraints' on the artifact for path rewriting and rendering
     if (Object.keys(constraintDict).length) {
@@ -119,17 +123,18 @@ function processAssertUnique(csn, options, error, info) {
      */
     function checkVal(val, propName) {
       const paths = [];
+      const loc = [ 'definitions', artifactName ];
       if (!Array.isArray(val)) {
-        err(propName, `Value '${JSON.stringify(unref(val))}' is not an array`);
+        error(null, loc, { anno: propName, value: JSON.stringify(unref(val)) }, '$(ANNO): Value $(VALUE) is not an array');
       }
       else {
         if (val.length === 0)
-          inf(propName, 'Empty annotation is ignored');
+          info(null, loc, { anno: propName }, '$(ANNO): Empty annotation is ignored');
 
         val.forEach((v) => {
           const p = v['='];
           if (!p)
-            err(propName, `Value '${JSON.stringify(unref(v))}' is not a path`);
+            error(null, loc, { anno: propName, value: JSON.stringify(unref(v)) }, '$(ANNO): Value $(VALUE) is not a path');
           else
             paths.push(p);
         });
@@ -185,61 +190,45 @@ function processAssertUnique(csn, options, error, info) {
         return;
       path.isChecked = true;
       let foundErr = false;
+      const name = pathName(path.ref);
+      const loc = [ 'definitions', artifactName ];
       for (let i = 0; i < path.ref.length && !foundErr; i++) {
         const art = path.ref[i]._art;
+        const elemref = path.ref[i].id;
         if (art) {
           if (art.items) {
-            msg(`'Array of/many' element "${path.ref[i].id}" is not allowed`);
+            error(null, loc, { elemref, name, anno: constraintName },
+                  '$(ANNO): \'Array of/many\' element $(ELEMREF) is not allowed in $(NAME)');
             delete path._art;
             foundErr = true;
           }
           if (art.target) {
             if (art.on) {
-              msg(`Unmanaged association "${path.ref[i].id}" is not allowed`);
+              error(null, loc, { elemref, name, anno: constraintName },
+                    '$(ANNO): Unmanaged association $(ELEMREF) is not allowed in $(NAME)');
               delete path._art;
               foundErr = true;
             }
             if (art.keys && i < path.ref.length - 1) {
-              msg(`Element access via managed association "${path.ref[i].id}" is not allowed`);
+              error(null, loc, { elemref, name, anno: constraintName },
+                    '$(ANNO): Element access via managed association $(ELEMREF) is not allowed in $(NAME)');
               delete path._art;
               foundErr = true;
             }
           }
         }
         else {
-          err(constraintName, `"${path.ref[i].id}" has not been found`);
+          error(null, loc, { elemref, anno: constraintName }, '$(ANNO): $(ELEMREF) has not been found');
           foundErr = true;
         }
       }
 
       if (!foundErr && path._art && [ 'cds.LargeBinary', 'cds.LargeString',
-        'cds.hana.CLOB', 'cds.hana.ST_POINT', 'cds.hana.ST_GEOMETRY' ].includes(path._art.type))
-        msg(`"Type ${path._art.type}" not allowed`);
-
-
-      /**
-       * @param {string} message
-       */
-      function msg(message) {
-        err(constraintName, `${message} in "${path.ref.map(p => p.id).join('.')}"`);
+        'cds.hana.CLOB', 'cds.hana.ST_POINT', 'cds.hana.ST_GEOMETRY' ].includes(path._art.type)) {
+        error(null, loc, { type: path._art.type, name, anno: constraintName },
+              '$(ANNO): Type $(TYPE) not allowed in $(NAME)');
       }
     }
-
-    // message macros for unified messaging
-    /**
-     * @param {string} propName
-     * @param {string} message
-     */
-    function err(propName, message) {
-      error(null, [ 'definitions', artifactName ], `${propName}: ${message}`);
-    }
-    /**
-     * @param {string} propName
-     * @param {string} message
-     */
-    function inf(propName, message) {
-      info(null, [ 'definitions', artifactName ], `${propName}: ${message}`);
-    }
   }
 }
 

package/lib/transform/db/expansion.js

@@ -62,7 +62,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * For such skipped things, error for usage of assoc pointing to them and and ignore publishing of assoc pointing to them.
    */
   function rewriteExpandInline() {
-    const { cleanup, _dependents } = setDependencies(csn);
+    let cleanup;
+    let _dependents;
 
     const entity = findAnEntity();
     const toDummyfy = [];
@@ -76,7 +77,6 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         const root = get$combined({ SELECT: parent });
         if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
           const rewritten = rewrite(root, parent.columns, parent.excluding);
-          parent.columns = rewritten.columns;
           /*
            * Do not remove unexpandable many columns in OData
           */
@@ -96,7 +96,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     if (!options.toOdata)
       dummyfy();
 
-    cleanup.forEach(fn => fn());
+    if (cleanup)
+      cleanup.forEach(fn => fn());
 
     ({ effectiveType, inspectRef } = csnRefs(csn));
 
@@ -104,7 +105,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     const publishing = [];
     // OData must allow navigations to @cds.persistence.skip targets
     // as valid navigations in the API
-    if (!options.toOdata) {
+    if (options.transformation !== 'odata') {
       applyTransformations(csn, {
         target: (parent, name, target, path) => {
           if (toDummyfy.indexOf(target) !== -1) {
@@ -207,6 +208,9 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {string} name
      */
     function markAsToDummyfy(artifact, name) {
+      if (!_dependents && !cleanup)
+        ({ cleanup, _dependents } = setDependencies(csn, csnUtils));
+
       const stack = [ [ artifact, name ] ];
       while (stack.length > 0) {
         const [ a, n ] = stack.pop();
@@ -355,6 +359,9 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         else if (current.val !== undefined || current.func !== undefined) {
           expanded.push(Object.assign(current, { as: currentAlias.join(pathDelimiter) }));
         }
+        else if (current.$scope === '$magic' || current.$scope === '$self') {
+          expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
+        }
         else { // preserve stuff like .cast for redirection
           expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }

package/lib/transform/db/temporal.js

@@ -81,7 +81,9 @@ function getViewDecorator(csn, messageFunctions) {
           }
         }
         else {
-          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${from[0].errorParent}"."${from[0].name}" and "${to[0].errorParent}"."${to[0].name}" are not of same origin`);
+          info(null, [ 'definitions', artifactName ],
+               { source: `${from[0].errorParent}.${from[0].name}`, target: `${to[0].errorParent}.${to[0].name}` },
+               'No temporal WHERE clause added as $(SOURCE) and $(TARGET) are not of same origin');
         }
       }
       else if (from.length > 0 || to.length > 0) {

package/lib/transform/db/transformExists.js

@@ -428,6 +428,11 @@ function handleExists(csn, options, error) {
    * @returns {object[]} The stuff to add to the where
    */
   function translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) {
+    if (current.$scope === '$self') {
+      error('ref-unexpected-exists-self', current.$path, { id: current.ref[0], name: 'exists' }, 'With $(NAME), path steps must not start with $(ID)');
+      return [];
+    }
+
     const whereExtension = [];
     for (let j = 0; j < root.keys.length; j++) {
       const lop = { ref: [ target, ...root.keys[j].ref ] }; // target side
@@ -800,7 +805,8 @@ function handleExists(csn, options, error) {
         }
         else if (part.$scope === '$self') { // source side - "absolute" scope
           // Same message as in forRelationalDB/transformDollarSelfComparisonWithUnmanagedAssoc
-          error(null, part.$path, 'An association that uses "$self" in its ON-condition can\'t be compared to "$self"');
+          error(null, part.$path, { name: '$self' },
+                'An association that uses $(NAME) in its ON-condition can\'t be compared to "$self"');
         }
         else if (partInspect.art) { // source side - with local scope
           where.push({ ref: [ target, ...assoc.ref.slice(1, -1), ...part.ref ] });

package/lib/transform/db/views.js

@@ -247,14 +247,14 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
     if (isUnion(queryPath) && options.transformation === 'hdbcds') {
       if (isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J) {
         if (elem.keys)
-          info(null, queryPath, `Managed association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, { name: elemName }, 'Managed association $(NAME), published in a UNION, will be ignored');
         else
-          info(null, queryPath, `Association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, { name: elemName }, 'Association $(NAME), published in a UNION, will be ignored');
 
         elem._ignore = true;
       }
       else {
-        error(null, queryPath, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
+        error(null, queryPath, { name: elemName }, 'Association $(NAME) can\'t be published in a SAP HANA CDS UNION');
       }
     }
     else if (queryPath.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
@@ -325,17 +325,40 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
    * due to an issue with HANA - only for hdbcds-hdbcds, I assume flattening
    * takes care of this for the other cases already
    *
-   * @param {CSN.Query} query
+   * @param {CSN.Column} col
    * @param {CSN.Path} path
    */
-  function addImplicitAliasWithAssoc(query, path) {
-    for (let i = 0; i < query.SELECT.columns.length; i++) {
-      const col = query.SELECT.columns[i];
-      if (!col.as && col.ref && col.ref.length > 1) {
-        const { links } = inspectRef(path.concat([ 'columns', i ]));
-        if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
-          col.as = getLastRefStepString(col.ref);
-      }
+  function addImplicitAliasWithAssoc(col, path) {
+    if (!col.as && col.ref && col.ref.length > 1) {
+      const { links } = inspectRef(path);
+      if (links && links.slice(0, -1).some(({ art }) => isAssocOrComposition(art && art.type || '')))
+        col.as = getLastRefStepString(col.ref);
+    }
+  }
+
+  /**
+   * If simply selecting from a param like `:param`, we need to add an implicit alias like `:param as param`
+   * due to an issue with HANA
+   *
+   * @param {CSN.Column} col
+   */
+  function addImplicitAliasWithLonelyParam(col) {
+    if (!col.as && col.param)
+      col.as = getLastRefStepString(col.ref);
+  }
+
+
+  /**
+   * Loop over the columns and call all of the given functions with the column and the path
+   *
+   * @param {Function[]} functions
+   * @param {CSN.Column[]} columns
+   * @param {CSN.Path} path
+   */
+  function processColumns(functions, columns, path) {
+    for (let i = 0; i < columns.length; i++) {
+      const col = columns[i];
+      functions.forEach(fn => fn(col, path.concat(i)));
     }
   }
 
@@ -401,8 +424,14 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
       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 = [];
+      if (options.transformation === 'hdbcds' || options.transformation === 'sql' && options.sqlDialect === 'hana')
+        columnProcessors.push(addImplicitAliasWithLonelyParam);
       if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')
-        addImplicitAliasWithAssoc(query, path);
+        columnProcessors.push(addImplicitAliasWithAssoc);
+
+      if (columnProcessors.length > 0)
+        processColumns(columnProcessors, query.SELECT.columns, path.concat('columns'));
 
       delete query.SELECT.excluding;  // just to make the output of the new transformer the same as the old
 

package/lib/transform/draft/db.js

@@ -165,8 +165,8 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
       }
 
       else {
-        error(null, [ 'definitions', draftRootName ], { name: persistenceName },
-              `Entity $(NAME) already generated by draft root "${definingDraftRoot}"`);
+        error(null, [ 'definitions', draftRootName ], { name: persistenceName, alias: definingDraftRoot },
+              'Entity $(NAME) already generated by draft root $(ALIAS)');
       }
 
       return;

package/lib/transform/forOdataNew.js

@@ -109,7 +109,9 @@ function transform4odataWithCsn(inputModel, options) {
   // @ts-ignore
   const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
   // @ts-ignore
-  const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
+  const isExternalServiceMember = (art, name) => {
+    return !!(externalServices.includes(getServiceName(name)) ||  (art && art['@cds.external']))
+  }
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
@@ -163,10 +165,12 @@ function transform4odataWithCsn(inputModel, options) {
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
     // OData doesn't resolve type chains after the first 'items'
     flattening.resolveTypeReferences(csn, options, resolved, '_',
-      { skip: [ 'action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
+      { skip: [ 'action', 'aspect', 'event', 'function', 'type'], 
+        skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
     // No structured elements exists anymore
     flattening.flattenElements(csn, options, '_', error,
-      { skip: ['action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember,
+      { skip: ['action', 'aspect', 'event', 'function', 'type'], 
+        skipArtifact: isExternalServiceMember,
         skipStandard: { items: true },  // don't drill further into .items
         skipDict: { actions: true } }); // don't drill further into .actions -> bound actions, action-artifacts are handled by skip
   }

package/lib/transform/forRelationalDB.js

@@ -310,7 +310,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
    * 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 !== 'plain' && doA2J)
+  if(options.sqlDialect !== 'plain' && options.sqlDialect !== 'h2' && doA2J)
     createReferentialConstraints(csn, options);
 
   // no constraints for drafts
@@ -625,12 +625,12 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       }
       else if (options.sqlDialect === 'sqlite') { // view with params
         // Allow with plain
-        error(null, [ 'definitions', artifactName ], `SQLite does not support entities with parameters`);
+        error(null, [ 'definitions', artifactName ], 'SQLite does not support entities with parameters');
       }
       else {
         for (const pname in artifact.params) {
           if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be regular SQL identifier
-            warning(null, [ 'definitions', artifactName, 'params', pname ], `Expecting regular SQL-Identifier`);
+            warning(null, [ 'definitions', artifactName, 'params', pname ], 'Expecting regular SQL-Identifier');
           }
           else if (options.sqlMapping !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
             warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.sqlMapping },
@@ -704,6 +704,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       node.length = 36;
       setProp(node, '$renamed', 'cds.UUID');
     }
+
+    if(options.sqlDialect === 'h2' && val === 'cds.Decimal' && node.scale === undefined) {
+      node[key] = 'cds.DecimalFloat'; // cds.Decimal and cds.Decimal(p) should map do DECFLOAT for h2
+    }
+
     // Length/Precision/Scale is done in addDefaultTypeFacets
   }
 
@@ -860,7 +865,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // not to the view).
       // FIXME: This also means that corresponding key fields should be in the select list etc ...
       if (!art.query && !art.projection && assoc.target && assoc.target != artifactName)
-        error(null, path, `Only an association that points back to this artifact can be compared to "$self"`);
+        error(null, path, { name: '$self' }, 'Only an association that points back to this artifact can be compared to $(NAME)');
 
 
       // Check: The forward link <assocOp> must not contain '$self' in its own ON-condition
@@ -868,7 +873,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         const containsDollarSelf = assoc.on.some(isDollarSelfOrProjectionOperand);
 
         if (containsDollarSelf)
-          error(null, path, `An association that uses "$self" in its ON-condition can't be compared to "$self"`);
+          error(null, path, { name: '$self' },
+            'An association that uses $(NAME) in its ON-condition can\'t be compared to $(NAME)');
       }
 
       // Transform comparison of $self to managed association into AND-combined foreign key comparisons
@@ -1086,7 +1092,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
                 else if (art.elements) {
                   // The reference is structured
                   if (isFulltextIndex)
-                    error(null, path, `"${ artName }": A fulltext index can't be defined on a structured element`);
+                    error(null, path, { name: artName }, 'A fulltext index can\'t be defined on a structured element $(NAME)');
                   // First, compute the name from the path, e.g ['s', 's1', 's2' ] will result in 'S_s1_s2' ...
                   const refPath = flattenStructStepsInRef(val.ref, path);
                   // ... and take this as the prefix for all elements

package/lib/transform/localized.js

@@ -73,7 +73,7 @@ const _targetFor = Symbol('_targetFor');
  */
 function _addLocalizationViews(csn, options, useJoins, config) {
   // Don't try to create convenience views with errors.
-  if (hasErrors(options.messages))
+  if (hasErrors(options.messages)) // TODO: this is actually wrong, consider --test-mode
     return csn;
 
   const messageFunctions = makeMessageFunction(csn, options);

package/lib/transform/odata/typesExposure.js

@@ -108,7 +108,8 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       if (newType) {
         // error, if it was not exposed by us
         if (!exposedTypes[fullQualifiedNewTypeName]) {
-          error(null, path, `Can't create artificial type "${fullQualifiedNewTypeName}" for "${memberName}" because the name is already used`);
+          error(null, path, { type: fullQualifiedNewTypeName, name: memberName },
+            'Can\'t create artificial type $(TYPE) for $(NAME) because the name is already used');
           return;
         }
       }