@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/transform/forOdataNew.js

@@ -51,7 +51,7 @@ const { addLocalizationViews } = require('./localized');
 //        -- exposed associations do not point to non-exposed targets
 //        -- structured types must not contain associations for OData V2
 //   - Element must not be an 'array of' for OData V2 TODO: move to the validator
-//     (Linter Candiate, move as hard error into EdmPreproc on V2 generation)
+//     (Linter Candidate, move as hard error into EdmPreproc on V2 generation)
 //   - Perform checks for exposed non-abstract entities and views - check media type and
 //        key-ness (requires that containers have been identified) (Linter candidate, scenario check)
 //   Annotations related:
@@ -201,7 +201,7 @@ function transform4odataWithCsn(inputModel, options) {
   // Flatten on-conditions in unmanaged associations
   /* FIXME (HJB): Is this comment still correct? processOnCond only strips $self
                   We should not remove $self prefixes in structured OData to not
-                  interfer with path resolution
+                  interfere with path resolution
   */
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
@@ -230,12 +230,13 @@ function transform4odataWithCsn(inputModel, options) {
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
     forEachMemberRecursively(def, (member, memberName, propertyName) => {
-      if (memberName === '' && propertyName === 'params')
-        return; // ignore "returns" type
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)
-      if (options.sqlMapping && typeof member === 'object' && !(member.kind === 'action' || member.kind === 'function') && propertyName !== 'enum' && (!member.virtual || def.query)) {
+      if (options.sqlMapping && typeof member === 'object' &&
+          !(member.kind === 'action' || member.kind === 'function') &&
+          !(propertyName === 'enum' || propertyName === 'returns') &&
+          (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
         member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
@@ -311,88 +312,102 @@ 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) {
+    // 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) {
         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]);
         }
       }
-    });
+    }
   }
 
   // Apply default type facets to each type definition and every member
-  // But do not apply default string length 5000 (as in DB)
+  // But do not apply default string length (as in DB)
   function setDefaultTypeFacets(def) {
-    addDefaultTypeFacets(def.items || def, false)
-    forEachMemberRecursively(def,  m=>addDefaultTypeFacets(m.items || m, false));
+    addDefaultTypeFacets(def.items || def, null)
+    forEachMemberRecursively(def,  m=>addDefaultTypeFacets(m.items || m, null));
     if(def.returns)
-      addDefaultTypeFacets(def.returns.items || def.returns, false);
+      addDefaultTypeFacets(def.returns.items || def.returns, null);
   }
 
   // Handles on-conditions in unmanaged associations
@@ -409,7 +424,7 @@ function transform4odataWithCsn(inputModel, options) {
       // TODO: Shouldn't this only run on the on-condition and not the whole assoc-node?
       applyTransformationsOnNonDictionary({ assoc }, 'assoc', {
         ref: (node, prop, ref) => {
-          // remove leading $self when at the begining of a ref
+          // remove leading $self when at the beginning of a ref
           if (ref.length > 1 && ref[0] === '$self')
             node.ref.splice(0, 1);
         }

package/lib/transform/forRelationalDB.js

@@ -31,6 +31,7 @@ const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
 const { ModelError } = require('../base/error');
+const { getDefaultTypeLengths } = require('../render/utils/common');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -61,7 +62,7 @@ function forEachDefinition(csn, cb) {
  * - (045) The query is stripped from entities that are annotated with '@cds.persistence.table',
  *         essentially converting views to entities.
  * - (060) Users of primitive type 'UUID' (which is renamed to 'String' in 000) get length 36'.
- * - (070) Default length 5000 is supplied for strings if not specified.
+ * - (070) Default length N is supplied for strings if not specified.
  * - (080) Annotation definitions are ignored (note that annotation assignments are filtered out by toCdl).
  * - (090) Compositions become associations.
  * - (100) 'masked' is ignored (a), and attribute 'localized' is removed (b)
@@ -113,6 +114,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   checkCSNVersion(csn, options);
 
   const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
+  // There is also an explicit default length via options.defaultStringLength
+  const implicitDefaultLengths = getDefaultTypeLengths(options.sqlDialect);
 
   let csnUtils;
   let message, error, warning, info; // message functions
@@ -160,6 +163,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   });
   timetrace.stop('Validate');
 
+  rewriteCalculatedElementsInViews(csn, options, pathDelimiter, error);
+
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error, inspectRef, initDefinition, dropDefinitionCache);
 
@@ -184,8 +189,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     assertUnique.prepare(csn, options, error, info)
   ]);
 
-  rewriteCalculatedElementsInViews(csn, options, pathDelimiter, error);
-
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
     expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithAnyError}, csnUtils);
@@ -252,9 +255,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   transformCsn(csn, {
     type: (val, node, key) => {
       renamePrimitiveTypesAndUuid(val, node, key);
-      addDefaultTypeFacets(node);
+      addDefaultTypeFacets(node, implicitDefaultLengths);
     },
-    // HANA/SQLite do not support array-of - turn into CLOB/Text
+    // no support for array-of - turn into CLOB/Text
+    // must be done after A2J or compiler checks could change
+    // (e.g. annotation def checks for arrayed types)
     items: (val, node) => {
       node.type = 'cds.LargeString';
       delete node.items;
@@ -572,7 +577,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
-        if (memberName === '' && property === 'params')
+        if (property === 'returns')
           return; // ignore "returns" type
         transformCommon(member, memberName, path);
         // (240 b) Annotate elements, foreign keys, parameters etc with their DB names
@@ -1146,7 +1151,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
                     // if it's not the first entry, add a ',' ...
                     if (i)
                       flattenedIndex.push(',');
-                    // ... then add the flattend element name as a single ref
+                    // ... then add the flattened element name as a single ref
                     flattenedIndex.push({ ref: [ elem ] });
                     // ... then check if we have to propagate a 'asc'/'desc', omitting the last, which will be copied automatically
                     if ((idx + 1) < index.length && (index[idx + 1] === 'asc' || index[idx + 1] === 'desc') && i < elems.length - 1)

package/lib/transform/localized.js

@@ -610,8 +610,10 @@ function _addLocalizationViews(csn, options, useJoins, config) {
       override: true,
       filter: (name) => name.startsWith('localized.'),
       notFound(name, index) {
-        if (!ignoreUnknownExtensions)
-          messageFunctions.message('anno-undefined-art', [ 'extensions', index ], { name })
+        if (!ignoreUnknownExtensions) {
+          messageFunctions.message('anno-undefined-art', [ 'extensions', index ],
+                                   { art: name });
+        }
       },
     });
   }

package/lib/transform/odata/toFinalBaseType.js

@@ -103,14 +103,14 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
 
     if(node.type && !isBuiltinType(node.type)) {
       const finalBaseType = csnUtils.getFinalTypeInfo(node.type);
-      if(!finalBaseType) {
+      if(finalBaseType == null) {
         /*
-          type could not be resolved, set it to null
-          Today, all type refs must be resolvable,
-          input validations checkTypeDefinitionHasType, checkElementTypeDefinitionHasType
+          type could not be resolved, delete type property to be equal to a typeless element
+          definition. Today, all type refs must be resolvable, input validations
+          checkTypeDefinitionHasType, checkElementTypeDefinitionHasType
           guarantee this. In the future this may change.
         */
-        node.type = null;
+        delete node.type;
       }
       else {
         if (isExpandable(finalBaseType) || node.kind === 'type') {

package/lib/transform/odata/typesExposure.js

@@ -26,7 +26,7 @@ const { CompilerAssertion } = require('../../base/error');
  * and edges e(v_r, v_d) such that all v_r, v_d are elements of S (v_rs, v_ds) and with that
  * all edges are { e(v_rs, v_ds) }.
  *
- * The input CSN may contain edges e(v_rs, v_dns) with v_r element of S_i (v_rs) and v_d not element 
+ * The input CSN may contain edges e(v_rs, v_dns) with v_r element of S_i (v_rs) and v_d not element
  * of S_i (v_dns).
  *
  * The aim of this algorithm is to produce Tc's for all requested S_i by 'filling' up the missing
@@ -50,7 +50,7 @@ const { CompilerAssertion } = require('../../base/error');
  *
  * If name(v_dns) has no prefix segments, the fallback schema name is prepended instead:
  * name(v_ds) = name(v_s) + '.' + fallbackschema + name(v_dns);
- * 
+ *
  * @param {CSN.Model} csn
  * @param {function}  whatsMyServiceName
  * @param {string[]}     requestedServiceNames
@@ -160,7 +160,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         // we're no longer in a key def => don't set notNull:true on named types
         if(isKey)
           isKey = false;
-        // in case this was a named type and if the openess does not match the type definition
+        // in case this was a named type and if the openness does not match the type definition
         // expose the type as a new one not changing the original definition.
         if(elements && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';

package/lib/transform/parseExpr.js

@@ -282,6 +282,9 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
       // if(xpr?.func && funkyfuncs.includes(xpr?.func))
       //   return xpr;
       for(let n in xpr) {
+        // xpr could be an array with polluted prototype
+        if (!Object.hasOwnProperty.call(xpr, n))
+          continue;
         const x = xpr[n];
         const isAnno = n[0] === '@' && isSimpleAnnoValue(x);
         if(isAnno)

package/lib/transform/transformUtilsNew.js

@@ -66,28 +66,35 @@ function getTransformers(model, options, pathDelimiter = '_') {
     expandStructsInExpression,
   };
 
-  // Try to apply length, precision, scale from options if no type facet is set on the primitive types 'cds.String' or 'cds.Decimal'.
-  // If 'obj' has primitive type 'cds.String' and no length try to apply length from options if available or set to default 5000.
-  // if 'obj' has primitive type 'cds.Decimal' try to apply precision, scale from options if available.
-  function addDefaultTypeFacets(element, defStrLen5k=true) {
+  /**
+   * Try to apply length, precision, scale from options if no type facet is set on the primitive types 'cds.String' or 'cds.Decimal'.
+   * If 'obj' has primitive type 'cds.String' and no length try to apply length from options if available or set to default internalDefaultLengths[type].
+   * if 'obj' has primitive type 'cds.Decimal' try to apply precision, scale from options if available.
+   *
+   * @param {CSN.Element} element
+   * @param {null|object} [internalDefaultLengths] Either null (no implicit default) or an object `{ 'cds.String': N, 'cds.Binary': N }`.
+   * */
+  function addDefaultTypeFacets(element, internalDefaultLengths = null) {
     if (!element || !element.type)
       return;
 
     if (element.type === 'cds.String' && element.length === undefined) {
-      if(options.defaultStringLength) {
+      if (options.defaultStringLength) {
         element.length = options.defaultStringLength;
         setProp(element, '$default', true);
       }
-      else if(defStrLen5k)
-        element.length = 5000;
+      else if (internalDefaultLengths !== null) {
+        element.length = internalDefaultLengths[element.type];
+      }
     }
     if (element.type === 'cds.Binary' && element.length === undefined) {
-      if(options.defaultBinaryLength) {
+      if (options.defaultBinaryLength) {
         element.length = options.defaultBinaryLength;
         setProp(element, '$default', true);
       }
-      else if(defStrLen5k)
-        element.length = 5000;
+      else if(internalDefaultLengths !== null) {
+        element.length = internalDefaultLengths[element.type];
+      }
     }
   /*
     if (element.type === 'cds.Decimal' && element.precision === undefined && options.precision) {
@@ -273,7 +280,22 @@ function getTransformers(model, options, pathDelimiter = '_') {
       // This has historic reasons. We don't copy doc-comments because copying annotations
       // is questionable to begin with.  Only selected annotations should have been copied,
       // if at all.
-      copyAnnotations(elem, flatElem, false);
+      // When flattening structured elements for OData don't propagate the odata.Type annotations
+      // as these would falsify the flattened elements. Type facets must be aligned with
+      // EdmTypeFacetMap defined in edm.js
+      const excludes = options.toOdata ?
+      {
+        '@odata.Type': 1,
+        '@odata.Scale': 1,
+        '@odata.Precision': 1,
+        '@odata.MaxLength': 1,
+        '@odata.SRID': 1,
+        '@odata.FixedLength': 1,
+        '@odata.Collation': 1,
+        '@odata.Unicode': 1,
+      } : {};
+      copyAnnotations(elem, flatElem, false, excludes);
+
       // Copy selected type properties
       const props = ['key', 'virtual', 'masked', 'viaAll'];
       // 'localized' is needed for OData
@@ -413,14 +435,11 @@ function getTransformers(model, options, pathDelimiter = '_') {
       // Copy elements/items and we're finished. No need to look up actual base type,
       // since it must also be structured and must contain at least as many elements,
       // if not more (in client style CSN).
-      if (typeRef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
+      if (typeRef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds'))
         nodeWithType.elements = cloneCsnDictionary(typeRef.elements, options);
-        delete nodeWithType.type;
-      }
-      if (typeRef.items) {
+      else if (typeRef.items)
         nodeWithType.items = cloneCsnNonDict(typeRef.items, options);
-        delete nodeWithType.type;
-      }
+
       return;
     }
 
@@ -450,7 +469,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     art.elements && Object.entries(art.elements).forEach(([elemName, artElem]) => {
       let elem = Object.assign({}, artElem);
       // Transfer xrefs, that are redirected to the projection
-      // TODO: shall we remove the transfered elements from the original?
+      // TODO: shall we remove the transferred elements from the original?
       // if (artElem._xref) {
       //   setProp(elem, '_xref', artElem._xref.filter(xref => xref.user && xref.user._main && xref.user._main._service == service));
       // }
@@ -470,7 +489,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Assemble the projection itself and add it into the model
     let projection = {
       'kind': 'entity',
-      projection: query.SELECT, // it is important that projetion and query refer to the same object!
+      projection: query.SELECT, // it is important that projection and query refer to the same object!
       elements
     };
     // copy annotations from art to projection
@@ -749,6 +768,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       if (!isBuiltinType(returnTypeName) && !model.definitions[returnTypeName])
         throw new ModelError('Expecting valid return type name: ' + returnTypeName);
       action.returns = { type: returnTypeName };
+      // TODO: What about annotation propagation from return type to `returns`?
     }
 
     // Add parameter if provided
@@ -918,7 +938,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
   /**
    * Assigns unconditionally annotation to a node, which means it overwrites already existing annotation assignment.
-   * Overwritting is when the assignment differs from undefined and null, also when differs from the already set value.
+   * Overwriting is when the assignment differs from undefined and null, also when differs from the already set value.
    * Setting new assignment results false as return value and overwriting - true.
    *
    * @param {object} node Assignee
@@ -1114,7 +1134,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
           const lhsArt = lhs._art || lhs.ref && !lhs.$scope && inspectRef(location.concat(i)).art;
           const rhsArt = rhs._art || rhs.ref && !rhs.$scope && inspectRef(location.concat(i+2)).art;
           const lhsIsVal = (lhs.val !== undefined);
-          // if ever rhs should be alowed to be a value uncomment this
+          // if ever rhs should be allowed to be a value uncomment this
           const rhsIsVal = (rhs === 'null' /*|| rhs.val !== undefined*/);
 
           // lhs & rhs must be expandable types (structures or managed associations)
@@ -1300,8 +1320,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
 
       function getType(art) {
-        const effart = effectiveType(art);
-        return Object.keys(effart).length ? effart : art.type;
+        const effArt = effectiveType(art);
+        return Object.keys(effArt).length ? effArt : art.type;
       }
 
       function isExpandable(art) {

package/lib/transform/translateAssocsToJoins.js

@@ -230,7 +230,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   /*
     Add an artificial QA for each mixin definition. This QA completes the QAT
-    datastructure that requires a QA at the rootQat before starting the join generation.
+    data-structure that requires a QA at the rootQat before starting the join generation.
     This QA is marked as 'mixin' which indicates that the paths of the ON condition must
     not receive the usual source and target table alias (which is used for generic associations)
     but instead just use the rootQA of the individual ON condition paths. These paths are
@@ -684,7 +684,7 @@ function translateAssocsToJoins(model, inputOptions = {})
               //env.assocStack.includes(fwdAssoc) => recursion
               if(env.assocStack.length === 2) {
                 // reuse (ugly) error message from forHana
-                error(null, env.assocStack[0].location,
+                error(null, [env.assocStack[0].location,env.assocStack[0]],
                   { name: '$self', id: '$self' },
                   'An association that uses $(NAME) in its ON-condition can\'t be compared to $(ID)');
                 // don't check these paths again
@@ -706,6 +706,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       }
 
       function cloneOnCondExprTree(expr) {
+        // TODO: This function is not covered by an tests, only cloneOnCondExprStream is.
         // keep parentheses intact
         if(Array.isArray(expr))
           return expr.map(cloneOnCondition);
@@ -1126,7 +1127,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       for(let fkn in element.foreignKeys)
       {
         let fk = element.foreignKeys[fkn];
-        // once a fk is to be followed, treat all sub patsh as srcSide, this will add fk.name.id only
+        // once a fk is to be followed, treat all sub-paths as srcSide, this will add fk.name.id only
         if(srcSide)
           paths = paths.concat(flattenElement(fk.targetElement._artifact, true,  fk.name.id, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
         else
@@ -1199,7 +1200,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   /*
     Munch path steps and append them to a path string until an
     assoc step is found. The assoc path step is also appended
-    to the path string. If no assoc path step has occured, all
+    to the path string. If no assoc path step has occurred, all
     path steps are added to the path string and tail is empty.
 
     Return assocPathStep, the remaining tail path and the path string
@@ -1219,7 +1220,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   /*
     Substitute the n first path steps of a given path against a FK alias name.
-    Resolve a foreign key of a managaged association by following the n first
+    Resolve a foreign key of a managed association by following the n first
     path steps. Longest path matches:
     Example: fk tuple { a.b, a.b.c, a.b.e },
     path: a.b.c.d.e.f: FK a.b.c is found, even if FK a.b is one level higher in the prefix tree.
@@ -1866,7 +1867,7 @@ function walkPath(node, env)
     /*
       NOTE: As long as association path steps are not allowed in filters,
       it is not required to walk over filter expressions.
-      Simple filter paths are rewritten inin createJoinTree (first filter)
+      Simple filter paths are rewritten in createJoinTree (first filter)
       and createJoinQA (subsequent one that belong to the ON condition).
 
       If the filter becomes JOIN relevant, default FILTERS (part of the

package/lib/transform/universalCsn/.eslintrc.json

@@ -1,7 +1,7 @@
 {
   "root": true,
   "plugins": ["sonarjs", "jsdoc"],
-  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "extends": ["plugin:jsdoc/recommended", "../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
     "prefer-const": "error",
     "quotes": ["error", "single", "avoid-escape"],

package/lib/transform/universalCsn/coreComputed.js

@@ -27,7 +27,9 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
     }
     else if (artifact.kind === 'entity' || artifact.kind === 'aspect') {
       forEachMemberRecursively(artifact, (element) => {
-        if (element.value && !element.value?.ref) // calculated elements, but simple references are ignored
+        // Calculated elements, but simple references are ignored for on-read.
+        // casts() are also computed. In CSN, they appear next to a `.ref`.
+        if (element.value && (!element.value.ref || element.value.cast || element.value.stored))
           setAnnotationIfNotDefined(element, '@Core.Computed', true);
       }, path);
     }
@@ -95,7 +97,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
         return getAncestor(base.SELECT.elements[name], name, base.SELECT);
       }
       else if (base.ref) {
-        let artifact = artifactRef(base);
+        let artifact = artifactRef.from(base);
         if (artifact.target)
           artifact = artifactRef(artifact.target);
         return artifact.elements[name];
@@ -145,7 +147,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
     }
 
     /**
-     * Return whether the given columns element needs to be marked with @Core.Computed.
+     * Returns true, if the given columns element needs to be annotated with @Core.Computed.
      *
      * @param {CSN.Column} column
      * @returns {boolean}
@@ -153,9 +155,9 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
     function needsCoreComputed( column ) {
       return column &&
         (
-          column.xpr || column.list || column.func || column.val !== undefined || column.param ||
+          column.xpr || column.list || column.func || column.val !== undefined || column['#'] !== undefined || column.param ||
           column.SELECT || column.SET ||
-          column.ref && [ '$at', '$valid', '$now', '$user', '$session' ].includes(column.ref[0])
+          column.ref && [ '$at', '$valid', '$now', '$user', '$session', '$parameters' ].includes(column.ref[0])
         );
     }