@sap/cds-compiler 3.7.2 → 3.8.2

package/lib/render/toRename.js

@@ -3,10 +3,11 @@
 
 const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { getNamespace, forEachDefinition } = require('../model/csnUtils');
+const { forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
 const { isBetaEnabled } = require('../base/model');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
+const { getIdentifierUtils } = require('./utils/sql');
 
 
 /**
@@ -46,6 +47,9 @@ function toRename( inputCsn, options ) {
 
   // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
   const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
+  const hdbcdsOrQuotedIdentifiers = getIdentifierUtils(csn, options);
+  const plainIdentifiers = getIdentifierUtils(csn, { sqlDialect: 'hana', sqlMapping: 'plain' });
+
   // forRelationalDB looses empty contexts and services, add them again so that toRename can calculate the namespaces
   forEachDefinition(csn, (artifact, artifactName) => {
     if ((artifact.kind === 'context' || artifact.kind === 'service') && csn.definitions[artifactName] === undefined)
@@ -82,10 +86,12 @@ function toRename( inputCsn, options ) {
   function renameTableAndColumns( artifactName, art ) {
     let resultStr = '';
     if (art.kind === 'entity' && !art.query) {
-      const beforeTableName = quoteSqlId(absoluteCdsName(artifactName));
-      const afterTableName = plainSqlId(artifactName);
+      const beforeTableName = hdbcdsOrQuotedIdentifiers.renderArtifactName(artifactName);
+      const afterTableName = plainIdentifiers.renderArtifactName(artifactName);
 
-      if (beforeTableName !== afterTableName)
+      if (beforeTableName.toUpperCase() === `"${afterTableName}"`)
+        resultStr += `  --EXEC 'RENAME TABLE ${beforeTableName} TO ${afterTableName}';\n`;
+      else if (beforeTableName !== afterTableName)
         resultStr += `  EXEC 'RENAME TABLE ${beforeTableName} TO ${afterTableName}';\n`;
 
 
@@ -93,13 +99,14 @@ function toRename( inputCsn, options ) {
         const e = art.elements[name];
         let str = '';
 
-        const beforeColumnName = quoteSqlId(name);
-        const afterColumnName = plainSqlId(name);
+        const beforeColumnName = hdbcdsOrQuotedIdentifiers.quoteSqlId(name);
+        const afterColumnName = plainIdentifiers.quoteSqlId(name);
 
         if (!e._ignore) {
           if (e.target)
             str = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
-
+          else if (beforeColumnName.toUpperCase() === `"${afterColumnName}"` ) // Basically a no-op - render commented out
+            str = `    --EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
           else if (beforeColumnName !== afterColumnName)
             str = `    EXEC 'RENAME COLUMN ${afterTableName}.${beforeColumnName} TO ${afterColumnName}';\n`;
         }
@@ -108,50 +115,6 @@ function toRename( inputCsn, options ) {
     }
     return resultStr;
   }
-
-  /**
-   * Return 'name' in the form of an absolute CDS name - for the 'hdbcds' naming convention,
-   * this means converting '.' to '::' on the border between namespace and top-level artifact.
-   * For all other naming conventions, this is a no-op.
-   *
-   * @param {string} name Name to absolutify
-   * @returns {string} Absolute name
-   */
-  function absoluteCdsName( name ) {
-    if (options.sqlMapping !== 'hdbcds')
-      return name;
-
-    const namespaceName = getNamespace(inputCsn, name);
-    if (namespaceName)
-      return `${namespaceName}::${name.substring(namespaceName.length + 1)}`;
-
-    return name;
-  }
-
-  /**
-   * Return 'name' with appropriate "-quotes, also replacing '::' by '.' if 'options.sqlMapping'
-   * is 'quoted'
-   *
-   * @param {string} name Name to quote
-   * @returns {string} Quoted string
-   */
-  function quoteSqlId( name ) {
-    if (options.sqlMapping === 'quoted')
-      name = name.replace(/::/g, '.');
-
-    return `"${name.replace(/"/g, '""')}"`;
-  }
-
-  /**
-   * Return 'name' with uppercasing and appropriate "-quotes, also replacing '::' and '.' by '_'
-   * (to be used by 'plain' naming convention).
-   *
-   * @param {string} name Name to turn into a plain identifier
-   * @returns {string} A plain SQL identifier
-   */
-  function plainSqlId( name ) {
-    return `"${name.toUpperCase().replace(/(::|\.)/g, '_').replace(/"/g, '""')}"`;
-  }
 }
 
 module.exports = {

package/lib/transform/braceExpression.js

@@ -1,3 +1,9 @@
+// Currently unused, but may become useful again if HDBCDS -> HDBTABLE
+// handover becomes more prominent.  Historically used with the no longer
+// existent option `--compatibility`.
+// If necessary, more complex expressions could be parsed with parseExpr.js
+// and then stringified with parentheses again.
+
 'use strict';
 
 function isAlreadyBraced(expression, start, end){

package/lib/transform/db/rewriteCalculatedElements.js

@@ -1,12 +1,13 @@
 'use strict';
 
-const { isBetaEnabled, setProp } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
 const {
   forEachDefinition, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary, implicitAs, cloneCsnNonDict, getUtils,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
+
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 /**
  * Rewrite usage of calculated Elements into the expression itself.
@@ -18,9 +19,6 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  * @param {Function} error
  */
 function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error ) {
-  if (!isBetaEnabled(options, 'calculatedElements'))
-    return;
-
   const { inspectRef, effectiveType } = getUtils(csn, 'init-all');
 
   const views = [];
@@ -107,7 +105,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     else
       makeAllCalculatedElementsExplicitColumns(elements, SELECT, containsExpandInline);
 
-    const name = SELECT.from.args ? undefined : SELECT.from.as || implicitAs(SELECT.from.ref);
+    const name = SELECT.from.args ? undefined : SELECT.from.as || (SELECT.from.ref && implicitAs(SELECT.from.ref));
 
     if (!containsExpandInline) {
       applyTransformationsOnNonDictionary({ SELECT }, 'SELECT', {
@@ -119,7 +117,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           if (art?.value) {
             const alias = parent.as || implicitAs(parent.ref);
             // TODO: What about other scopes? expand/inline?
-            const value = (scope !== 'ref-target') ? absolutifyPaths(env, art, ref, links, name).value : art.value;
+            const value = (scope !== 'ref-target') ? absolutifyPaths(env, art, ref, links, name).value : keepAssocStepsInRef(ref, links, art).value;
 
             // Is a shallow copy enough?
             if (art.value.cast)
@@ -146,8 +144,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     if (!SELECT.columns)
       return false;
 
-    for (let i = 0; i < SELECT.columns.length; i++) {
-      const column = SELECT.columns[i];
+    for (const column of SELECT.columns) {
       if (column.expand || column.inline)
         return true;
     }
@@ -307,7 +304,9 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
       return from.SELECT.elements;
     }
     else if (from.SET) {
-      return from.SET.elements || getDirectlyAdressableElements(from.SET.args[0].SELECT);
+      // FIXME: Check if this is correct
+      // args[0] could be SELECT or UNION
+      return getDirectlyAdressableElements({ from: from.SET.args[0] });
     }
     else if (from.args) {
       const mergedElements = Object.create(null);
@@ -316,10 +315,21 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           for (const elementName in arg._art.elements)
             mergedElements[elementName] = arg._art.elements[elementName];
         }
+        else if (arg.SET) {
+          // FIXME: Check if this is correct
+          return getDirectlyAdressableElements({ from: arg.SET.args[0] });
+        }
         else if (arg.SELECT) { // TODO: UNION
           for (const elementName in arg.SELECT.elements)
             mergedElements[elementName] = arg.SELECT.elements[elementName];
         }
+        else if (arg.args) { // TODO: Is it safe to do recursion here?
+          for (const subarg of arg.args) {
+            const elements = getDirectlyAdressableElements({ from: subarg });
+            for (const elementName in elements)
+              mergedElements[elementName] = elements[elementName];
+          }
+        }
         else {
           throw new CompilerAssertion(`Unhandled arg type: ${JSON.stringify(arg, null, 2)}`);
         }
@@ -441,6 +451,40 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     return false;
   }
 
+  /**
+   * We need to keep association steps in front of the paths - else they would lead into nothing
+   *
+   * @param {Array} artRef
+   * @param {Array} links
+   * @param {object} art
+   * @returns {object}
+   */
+  function keepAssocStepsInRef( artRef, links, art ) {
+    let lastAssocIndex = -1;
+    for (let i = links.length - 1; i > -1; i--) {
+      if (links[i].art.target) {
+        lastAssocIndex = i;
+        break;
+      }
+    }
+
+    if (lastAssocIndex > -1) {
+      const clone = { value: cloneCsnNonDict(art.value, cloneCsnOptions) };
+      applyTransformationsOnNonDictionary(clone, 'value', {
+        ref: (parent, prop, ref) => {
+          parent.ref = [ ...artRef.slice(0, lastAssocIndex + 1), ...ref ];
+          if (parent._links)
+            parent._links = [ ...links.slice(0, lastAssocIndex + 1), ...parent._links ];
+        },
+      }, {
+        skipStandard: { where: true }, // Do not rewrite refs inside of an association-where
+      });
+
+      return clone;
+    }
+
+    return art;
+  }
 
   /**
    * In order to just replace them in views, our calculated elements need to reference absolute things, i.e. have a table alias in front!
@@ -508,13 +552,10 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
 }
 
 /**
- *
  * @param {CSN.Model} csn
- * @param {CSN.Options} options
+ * @param {CSN.Options} _options
  */
-function processCalculatedElementsInEntities( csn, options ) {
-  if (!isBetaEnabled(options, 'calculatedElements'))
-    return;
+function processCalculatedElementsInEntities( csn, _options ) {
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.kind === 'entity' && !(artifact.query || artifact.projection))
       killInEntity(artifact, [ 'definitions', artifactName ]);

package/lib/transform/forOdataNew.js

@@ -60,7 +60,7 @@ const { addLocalizationViews } = require('./localized');
 //   - Mark fields with @odata.on.insert/update as @Core.Computed
 //     (EdmPreproc candidate, check with RT if @Core.Computed required by them)
 //   - Rename shorthand annotations according to a builtin list (EdmPreproc Candidate)
-//       e.g. @label -> @Common.Label or @important: [true|false] -> @UI.Importance: [#High|#Low]
+//       e.g. @label -> @Common.Label
 //   - If the association target is annotated with @cds.odata.valuelist, annotate the
 //        association with @Common.ValueList.viaAssociation (EdmPreproc Candidate)
 //   - Check for @Analytics.Measure and @Aggregation.default (Linter check candidate, remove)
@@ -315,31 +315,36 @@ function transform4odataWithCsn(inputModel, options) {
   // list.
   function renameShorthandAnnotations(node) {
     // FIXME: Verify this list - are they all still required? Do we need any more?
-    const mappings = {
+    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',
-    }
+    };
 
-    const shortCuts = Object.keys(mappings);
+    const setShortCuts = Object.keys(setMappings);
+    const renameShortCuts = Object.keys(renameMappings);
     Object.keys(node).forEach( name => {
+      if (!name.startsWith('@'))
+        return;
       // Rename according to map above
-      const prefix = shortCuts.find(p => name.startsWith(p + '.') || name === p);
-      if(prefix) {
-        renameAnnotation(node, name, name.replace(prefix, mappings[prefix]));
-      }
-      // Special case: '@important: [true|false]' becomes '@UI.Importance: [#High|#Low]'
-      if (name === '@important') {
-        renameAnnotation(node, name, '@UI.Importance');
-        let annotation = node['@UI.Importance'];
-        if (annotation !== null)
-          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' };
+      const renamePrefix = (name in renameMappings) ? name : renameShortCuts.find(p => name.startsWith(p + '.'));
+      if(renamePrefix) {
+        renameAnnotation(node, name, name.replace(renamePrefix, renameMappings[renamePrefix]));
+      } 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 + '.'));
+        if(setPrefix) {
+          setAnnotation(node, name.replace(setPrefix, setMappings[setPrefix]), node[name]);
+        }
       }
 
       // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
@@ -351,7 +356,7 @@ function transform4odataWithCsn(inputModel, options) {
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
           } else {
-            renameAnnotation(node, name, '@Core.Computed');
+            setAnnotation(node, '@Core.Computed', true);
           }
         }
         // @insertonly is effective on entities/queries only

package/lib/transform/forRelationalDB.js

@@ -9,7 +9,7 @@ const { cloneCsnNonDict,
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
-const { csnRefs, pathId } = require('../model/csnRefs');
+const { csnRefs, pathId, traverseQuery } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
@@ -127,8 +127,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     get$combined,
     getCsnDef,
     isAssocOrComposition,
-    addStringAnnotationTo,
-    cloneWithTransformations;
+    addStringAnnotationTo;
   // transformUtils
   let addDefaultTypeFacets,
     expandStructsInExpression,
@@ -175,11 +174,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   throwWithAnyError();
 
-  // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
 
-
-  forEachDefinition(csn, [ 
+  forEachDefinition(csn, [
     // (001) Add a temporal where condition to views where applicable before assoc2join
     //       assoc2join eventually rewrites the table aliases
     temporal.getViewDecorator(csn, {info}, csnUtils),
@@ -459,7 +456,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       getCsnDef,
       isAssocOrComposition,
       addStringAnnotationTo,
-      cloneWithTransformations
     } = csnUtils);
   }
 
@@ -540,6 +536,20 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
+
+        // First pass: Set alias name for SELECTs without table alias. Required for setting proper table aliases
+        // for HDBCDS in naming mode HDBCDS.  We use the same schema as the core-compiler, so duplicates should
+        // have already been reported.
+        let selectDepth = 0;
+        traverseQuery(artifact.query, null, null, (query, fromSelect) => {
+          if (!query.ref && !query.as && fromSelect) {
+            // Use +1; for UNION, it's the next select, for SELECT, it's increased later.
+            query.as = `$_select_${selectDepth + 1}__`;
+          }
+          if (query.SELECT)
+            ++selectDepth;
+        });
+
         const process = (parent, prop, query, path) => {
           transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
           replaceAssociationsInGroupByOrderBy(parent, options, inspectRef, error, path.concat(prop));
@@ -987,25 +997,22 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
       elemName = elemName.replace(/\./g, pathDelimiter);
       const assocName = originalAssocName.replace(/\./g, pathDelimiter);
-      // clone the onCond for later use in the path transformation,
-      // also assign the _artifact elements of the path elements to the copy
-      const newOnCond = cloneWithTransformations(assoc.on, {
-        ref: (value) => cloneWithTransformations(value, {}),
-      });
+      // clone the onCond for later use in the path transformation
+      const newOnCond = cloneCsnNonDict(assoc.on, options);
       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
+            // We could also have a $self in front 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
+            // we do not need it anymore, as we prepended in the previous step the back association's id
             if (ref[1] === '$self')
               ref.splice(1, 1);
           }

package/lib/transform/parseExpr.js

@@ -346,6 +346,8 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
 
 function isSimpleAnnoValue(val) {
   // Expressions as annotation values always have a `=` and another property.
+  // TODO: There must be at least one known expression property, otherwise
+  //       it could be `type: 'unchecked'`.
   return !val?.['='] || Object.keys(val) < 2;
 }
 

package/lib/transform/transformUtilsNew.js

@@ -12,7 +12,6 @@ const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnU
 const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
-const { pathName } = require('../compiler/utils');
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
 const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
@@ -1160,26 +1159,41 @@ function getTransformers(model, options, pathDelimiter = '_') {
             const xrefvalues = Object.values(xref);
             let cont = true;
 
+            const prefix = (lhs, op, rhs) => {
+              return `${lhsIsVal ? lhs.val : lhs.ref.join('.')} ${op} ${rhsIsVal ? rhs : rhs.ref.join('.')}`
+            }
             if(op === 'like' && xrefvalues.reduce((a, v) => {
               return (v.lhs && v.rhs) ? a + 1: a;
             }, 0) === 0) {
               // error if intersection of paths is zero
-              error(null, location, { lhs: pathName(lhs.ref), op, rhs: pathName(rhs.ref) },
-                'Expected compatible types for $(LHS) $(OP) $(RHS)');
+              error(null, location,
+                {
+                  prefix: prefix(lhs, op, rhs)
+                },
+                'Expected compatible types for $(PREFIX)');
               cont = false;
             }
 
             cont && xrefkeys.forEach(xn => {
               const x = xref[xn];
-              const prefix = `${pathName(lhs.ref)} ${op} ${pathName(rhs.ref)}`;
               // do the paths match?
               if(op !== 'like' && !(x.lhs && x.rhs)) {
                 if(xn.length) {
-                  error(null, location, { prefix, name: xn, alias: pathName((x.lhs ? rhs : lhs).ref) },
+                  error(null, location,
+                    {
+                      prefix: prefix(lhs, op, rhs),
+                      name: xn,
+                      alias: (x.lhs ? rhs : lhs).ref.join('.')
+                    },
                     '$(PREFIX): Sub path $(NAME) not found in $(ALIAS)');
                 }
                 else {
-                  error(null, location, { prefix, name: pathName((x.lhs ? lhs : rhs).ref), alias: pathName((x.lhs ? rhs : lhs).ref) },
+                  error(null, location, 
+                    {
+                      prefix: prefix(lhs, op, rhs), 
+                      name: (x.lhs ? lhs : rhs).ref.join('.'),
+                      alias: (x.lhs ? rhs : lhs).ref.join('.')
+                    },
                     '$(PREFIX): Path $(NAME) does not match $(ALIAS)');
                 }
                 cont = false;
@@ -1189,13 +1203,21 @@ function getTransformers(model, options, pathDelimiter = '_') {
                 // is lhs scalar?
                 // eslint-disable-next-line sonarjs/no-gratuitous-expressions
                 if(!lhsIsVal && x.lhs && !isScalarOrNoType(x.lhs._art)) {
-                  error(null, location, { prefix, name: `${pathName(x.lhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                  error(null, location,
+                    {
+                      prefix: prefix(lhs, op, rhs),
+                      name: `${x.lhs.ref.join('.')}${(xn.length ? '.' + xn : '')}`
+                    },
                     '$(PREFIX): Path $(NAME) must end on a scalar type')
                   cont = false;
                 }
                 // is rhs scalar?
                 if(!rhsIsVal && x.rhs && !isScalarOrNoType(x.rhs._art)) {
-                  error(null, location, { prefix, name: `${pathName(x.rhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                  error(null, location,
+                    {
+                      prefix: prefix(lhs, op, rhs),
+                      name: `${x.rhs.ref.join('.')}${(xn.length ? '.' + xn : '')}`
+                    },
                     '$(PREFIX): Path $(NAME) must end on a scalar type');
                   cont = false;
                 }
@@ -1205,7 +1227,12 @@ function getTransformers(model, options, pathDelimiter = '_') {
                   const lhst = getType(x.lhs._art);
                   const rhst = getType(x.rhs._art);
                   if(lhst !== rhst) {
-                    info(null, location, { prefix, name: xn },'$(PREFIX): Types for sub path $(NAME) don\'t match');
+                    info(null, location,
+                      {
+                        prefix: prefix(lhs, op, rhs),
+                        name: xn
+                      },
+                      '$(PREFIX): Types for sub path $(NAME) don\'t match');
                   }
                 }
               }

package/lib/transform/translateAssocsToJoins.js

@@ -196,7 +196,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     'leaf' QAT and to the respective $tableAlias which is used to link paths to the correct
     table alias. Subqueries are not considered in the mergePathIntoQat(), so a subquery QA
     must be created and added separately to the lead query $tableAlias'es.
-    Also the name of the subquery (the alias) needs to be set to the final QA alias name.
+    Also, the name of the subquery (the alias) needs to be set to the final QA alias name.
   */
   function createQAForFromClauseSubQuery(query, env)
   {
@@ -204,7 +204,14 @@ function translateAssocsToJoins(model, inputOptions = {})
       if (query.$tableAliases[taName].kind !== '$self') {
         let ta = query.$tableAliases[taName];
         if(!ta.$QA) {
-          ta.$QA = createQA(env, ta._origin, taName, undefined);
+          let alias = taName;
+          if (ta.name.$inferred === '$internal') {
+            // query has no explicit table alias, i.e. is internal: make it visible and remove `$`
+            alias = ta.name.alias.replace(/^[$]/, '_');
+            ta.$inferred = undefined;
+            ta.name.$inferred = undefined;
+          }
+          ta.$QA = createQA(env, ta._origin, alias, undefined);
           incAliasCount(env, ta.$QA);
           if(ta.name && ta.name.id) {
             ta.name.id = ta.$QA.name.id;
@@ -307,7 +314,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       // pop ta ps
       if(head._navigation.kind !== '$tableAlias')
         tail = pathNode.path;
-      // if tail.lenth > 1, search bottom up for QA
+      // if tail.length > 1, search bottom up for QA
       // default to rootQA, _parent.$QA has precedence
       let [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
       if(!QA) {
@@ -1005,7 +1012,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     A QA (QueryArtifact) is a representative for a table/view that must appear
     in the FROM clause either named directly or indirectly through an association.
    */
-  function createQA(env, artifact, alias=undefined, namedArgs=undefined)
+  function createQA(env, artifact, alias, namedArgs=undefined)
   {
     if(alias === undefined) {
       throw new CompilerAssertion('no alias provided');

package/lib/transform/universalCsn/coreComputed.js

@@ -1,18 +1,19 @@
 'use strict';
 
 const {
-  forEachDefinition, forAllQueries, getNormalizedQuery,
+  forEachDefinition, forAllQueries, getNormalizedQuery, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setAnnotationIfNotDefined } = require('./utils');
 const { CompilerAssertion } = require('../../base/error');
 
 /**
- * Set @Core.Computed on the elements of views (and projections).
+ * Set @Core.Computed on the elements of views (and projections) as well
+ * as on calculated elements of entities and aspects.
  *
  * @param {CSN.Model} csn
  * @param {object} csnUtils
  */
-function setCoreComputedOnViews( csn, csnUtils ) {
+function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
   const {
     artifactRef, getColumn, getElement, getOrigin,
   } = csnUtils;
@@ -24,6 +25,12 @@ function setCoreComputedOnViews( csn, csnUtils ) {
           traverseQueryAndAttachCoreComputed(query, query.SELECT.elements || artifact.elements);
       }, path);
     }
+    else if (artifact.kind === 'entity' || artifact.kind === 'aspect') {
+      forEachMemberRecursively(artifact, (element) => {
+        if (element.value && !element.value?.ref) // calculated elements, but simple references are ignored
+          setAnnotationIfNotDefined(element, '@Core.Computed', true);
+      }, path);
+    }
   });
   /**
    * Attach @Core.Computed to elements resulting from calculated fields
@@ -84,7 +91,7 @@ function setCoreComputedOnViews( csn, csnUtils ) {
      * @todo cleanup throw(s) - but leave in during dev
      */
     function getElementFromFrom( name, base ) {
-      if (base.SELECT && base.SELECT.elements) {
+      if (base.SELECT?.elements?.[name]) {
         return getAncestor(base.SELECT.elements[name], name, base.SELECT);
       }
       else if (base.ref) {
@@ -100,7 +107,7 @@ function setCoreComputedOnViews( csn, csnUtils ) {
         return checkJoinSources(base.args, name);
       }
 
-      throw new CompilerAssertion(JSON.stringify(base));
+      throw new CompilerAssertion(`Element “${name}” not found in: ${JSON.stringify(base)}`);
     }
 
     /**
@@ -146,7 +153,8 @@ function setCoreComputedOnViews( csn, csnUtils ) {
     function needsCoreComputed( column ) {
       return column &&
         (
-          column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET ||
+          column.xpr || column.list || column.func || column.val !== undefined || column.param ||
+          column.SELECT || column.SET ||
           column.ref && [ '$at', '$now', '$user', '$session' ].includes(column.ref[0])
         );
     }
@@ -175,5 +183,5 @@ function setCoreComputedOnViews( csn, csnUtils ) {
 }
 
 module.exports = {
-  setCoreComputedOnViews,
+  setCoreComputedOnViewsAndCalculatedElements,
 };