@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/transform/db/rewriteCalculatedElements.js

@@ -4,17 +4,19 @@ const { setProp } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
 const {
   forEachDefinition, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary, implicitAs, cloneCsnNonDict, getUtils,
+  forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
+const { checkForeignKeyAccess } = require('../../checks/onConditions');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
+
+
 /**
  * Rewrite usage of calculated Elements into the expression itself.
  * Delete calculated elements in entities after processing so they don't materialize on the db.
  *
- * TODO: Calculated elements on-write (`stored: true`)
- *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
@@ -32,7 +34,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
       if (artifact.query || artifact.projection) {
         views.push({ artifact, artifactName });
       }
-      else {
+      else if (artifact.elements) { // can happen with CSN input
         rewriteInEntity(artifact);
         entities.push({ artifact, artifactName });
       }
@@ -44,8 +46,17 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
   entities.forEach(({ artifactName }) => {
     applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
       ref: (_parent, _prop, ref, _path, root, index) => {
-        if (_parent._art && _parent._art.value) {
-          root[index] = _parent._art.value;
+        if (_parent._art?.value && !_parent._art.value.stored) {
+          if (_parent._art.value.ref) {
+            // Ensure that we don't break any navigation by only replacing the real element at the end
+            const leafLength = getLeafLength(_parent._links);
+            root[index].ref = [ ...root[index].ref.slice(0, -1 * leafLength), ..._parent._art.value.ref ];
+            setProp(root[index], '_links', [ ...root[index]._links.slice(0, leafLength), ..._parent._art.value._links ]);
+            setProp(root[index], '_art', _parent._art);
+          }
+          else {
+            root[index] = _parent._art.value;
+          }
           // Note: Depends on A2J rejecting deeply nested filters
           applyTransformationsOnNonDictionary(root, index, {
             ref: (__parent, _, _ref) => {
@@ -55,7 +66,11 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           });
         }
       },
-    }, { drillRef: true }, [ 'definitions' ]);
+    }, {
+      drillRef: true,
+      // skip "type" to avoid going into type.ref
+      skipStandard: { type: 1 },
+    }, [ 'definitions' ]);
   });
 
 
@@ -75,11 +90,91 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     }, {}, [ 'definitions' ]);
   });
 
-  // Last pass, turn .value in tables into a simple val: 1 so we don't need to rewrite/flatten properly - will kill them later
+  /**
+   * Check that all paths in calculated elements-on write either access normal fields
+   * (structures are already rejected by the compiler) or access the foreign keys of
+   * associations. Non-fk fields must be rejected.
+   * Filters and parameters are not allowed.
+   *
+   * Note: This coding is similar to checks/onConditions.js, but does not check $self or other
+   *       ON-condition related stuff.
+   *
+   * @param {object} parent
+   * @param {(string|object)[]} value
+   * @param {CSN.Path} csnPath
+   */
+  function checkPathsInStoredCalcElement( parent, value, csnPath ) {
+    const { _links } = parent;
+
+    // If there is only one path step, it's been checked before.
+    for (let i = 0; i < value.length - 1; ++i) {
+      let hasPathError = false;
+      const step = value[i];
+      const stepArt = _links[i].art;
+
+      if (stepArt.target) {
+        const id = step.id || step;
+        if (stepArt.on) {
+          // It's an unmanaged association - traversal is always forbidden
+          error('ref-unexpected-navigation', csnPath, { '#': 'calc-unmanaged', id, elemref: parent });
+          hasPathError = true;
+        }
+        else {
+          // It's a managed association - access of the foreign keys is allowed
+          checkForeignKeyAccess(parent, i, csnPath, (errorIndex) => {
+            error('ref-unexpected-navigation', csnPath, {
+              '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
+            });
+            hasPathError = true;
+          });
+        }
+      }
+      if (typeof step === 'object') {
+        if (step.where) {
+          error('ref-unexpected-filter', csnPath, { '#': 'calc', elemref: parent });
+          hasPathError = true;
+        }
+        if (step.args) {
+          error('ref-unexpected-args', csnPath, { '#': 'calc', elemref: parent });
+          hasPathError = true;
+        }
+      }
+      if (hasPathError)
+        break; // avoid too many consequent errors
+    }
+  }
+
+  // Last pass, turn .value in tables into a simple 'val' so we don't need to rewrite/flatten properly - will kill them later
   entities.forEach(({ artifact, artifactName }) => {
     dummifyInEntity(artifact, [ 'definitions', artifactName ]);
+
+    forEachMemberRecursively({ elements: artifact.elements }, (element, elementName, _prop, path) => {
+      if (element.value?.stored) {
+        applyTransformationsOnNonDictionary(element, 'value', {
+          ref(parent, prop, value, csnPath) {
+            checkPathsInStoredCalcElement(parent, value, csnPath);
+          },
+        }, {}, path);
+      }
+    }, [ 'definitions', artifactName ]);
   });
 
+  /**
+   * Get the length of the effective leaf - since structures are not flat yet it might be more than 1.
+   * Walk from the back until we find the first association/composition.
+   *
+   * @param {object[]} links
+   * @returns {number}
+   */
+  function getLeafLength( links ) {
+    for (let i = links.length - 1; i >= 0; i--) {
+      const { art } = links[i];
+      if (art.target)
+        return links.length - i - 1;
+    }
+    return links.length;
+  }
+
   /**
    * Rewrite calculated-elements-columns in views/projections and replace them
    * with their "root"-expression.
@@ -173,11 +268,33 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {CSN.Artifact} artifact The artifact currently being processed
    */
   function rewriteInEntity( artifact ) {
+    let reorderElements = false;
     applyTransformationsOnDictionary(artifact.elements, {
       value: (parent, prop, value) => {
-        replaceValuesWithBaseValue(parent, value);
+        if (value.stored)
+          reorderElements = true;
+        replaceValuesWithBaseValue(parent);
       },
     });
+    // on-write must appear at the end of the elements. Order of the on-write between themselves
+    // should be as written.
+    if (reorderElements) {
+      const newElements = Object.create(null);
+      const onWrite = [];
+      for (const name in artifact.elements) {
+        const element = artifact.elements[name];
+        if (element.value?.stored)
+          onWrite.push(name);
+        else
+          newElements[name] = element;
+      }
+      // Add the on-write to the end
+      onWrite.forEach((name) => {
+        newElements[name] = artifact.elements[name];
+      });
+
+      artifact.elements = newElements;
+    }
   }
 
   /**
@@ -185,14 +302,13 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * - a .val thing
    * - a .ref to a non-value thing
    *
-   * @param {object | Array} parent
-   * @param {object} value
+   * @param {object} parent
    */
-  function replaceValuesWithBaseValue( parent, value ) {
-    if (value.val && parent.value === value)
-      return;
+  function replaceValuesWithBaseValue( parent ) {
+    if (parent.value.val !== undefined)
+      return; // literal; no need to traverse
 
-    const stack = [ { parent, value } ];
+    const stack = [ { parent, value: parent.value } ];
     while (stack.length > 0) {
       const current = stack.pop();
 
@@ -209,25 +325,20 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           },
         });
       }
-      else if (current.value.ref && current.value._art?.value) {
-        // TODO: Check for calculated elements on-write
+      else if (current.value.ref && current.value._art?.value && !current.value._art?.value.stored) {
         const linksBase = current.value._links;
         const refBase = current.value.ref;
-        const parentIndex = Array.isArray(current.parent) ? current.parent.indexOf(current.value) : -1;
-
-        replaceInRef(current.parent, current.value._art.value, current.isInXpr, refBase, linksBase, parentIndex);
-
-        stack.push(Object.assign(current, {
-          value: parentIndex > -1 ? current.parent[parentIndex] : current.parent.value,
-          refBase,
-          linksBase,
-        }));
+        const newValue = replaceInRef(current.value, current.value._art.value, current.isInXpr, refBase, linksBase);
+        const prop = Array.isArray(current.parent) ? current.parent.indexOf(current.value) : 'value';
+        if (prop === -1)
+          throw new CompilerAssertion('Calculated Elements: Value not in parent; should never happen!');
+        current.parent[prop] = newValue;
+        stack.push(Object.assign(current, { value: newValue, refBase, linksBase }));
       }
-      // No need for cloning here, as we don't rewrite this further and will later on kill all the stuff anyway
-      else if (current.value.val) { // this is the base case - or a ref to a non-calculated element
+      else if (current.value.val) {
         if (current.isInXpr) { // inside of expressions we directly need the val
           current.parent.val = current.value.val;
-          delete current.parent.value;
+          delete current.parent.value; // TODO: current.parent could be an array!
         }
         else { // outside of expressions, i.e. as normal elements, we need it in a .value wrapper
           current.parent.value = current.value;
@@ -243,18 +354,18 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    *
    * We either "trick" it into the correct place in an .xpr or we simply overwrite the existing .ref
    *
-   * @param {object} parent
+   * @param {object} oldValue
    * @param {object} newValue
    * @param {boolean} isInXpr
    * @param {Array} refBase
    * @param {Array} linksBase
-   * @param {number} indexInParent
+   * @returns {object|Array}
    */
-  function replaceInRef( parent, newValue, isInXpr, refBase, linksBase, indexInParent ) {
-    delete parent.ref;
-    const clone = {
-      value: cloneCsnNonDict({ value: newValue }, cloneCsnOptions).value,
-    };
+  function replaceInRef( oldValue, newValue, isInXpr, refBase, linksBase ) {
+    const clone = { value: cloneCsnNonDict({ value: newValue }, cloneCsnOptions).value };
+    if (oldValue.stored)
+      clone.value.stored = oldValue.stored;
+
     const refPrefix = refBase.slice(0, -1);
     const linksPrefix = linksBase.slice(0, -1);
     if (newValue.xpr) {
@@ -268,24 +379,15 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           }
         },
       }, {
-        // Do not rewrite refs inside of an association-where; avoids endless loop
+        // Do not rewrite refs inside an association-where; avoids endless loop
         skipStandard: { where: true },
       });
-      if (indexInParent > -1) // a .xpr in a .xpr
-        parent[indexInParent] = clone.value;
-      else
-        parent.value = clone.value;
     }
-    else {
-      if (indexInParent > -1) // a .ref in a .xpr
-        parent[indexInParent] = clone.value;
-      else
-        parent.value = clone.value;
-      if (clone.value.ref && clone.value.ref[0] !== '$self' && clone.value.ref[0] !== '$projection' ) {
-        clone.value.ref = [ ...refPrefix, ...clone.value.ref ];
-        clone.value._links = [ ...linksPrefix, ...clone.value._links ]; // TODO: Make non-enum, increment idx
-      }
+    else if (clone.value.ref && clone.value.ref[0] !== '$self' && clone.value.ref[0] !== '$projection' ) {
+      clone.value.ref = [ ...refPrefix, ...clone.value.ref ];
+      clone.value._links = [ ...linksPrefix, ...clone.value._links ]; // TODO: Make non-enum, increment idx
     }
+    return clone.value;
   }
 
   /**
@@ -295,6 +397,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    *
    * @param {CSN.Elements} elements Artifact elements
    * @param {object} carrier The thing that will "carry" the columns - .SELECT or .projection
+   * @returns {Function[]} Cleanup callbacks that remove `_`-links.
    */
   function calculateColumns( elements, carrier ) {
     carrier.columns = [ '*' ];
@@ -358,6 +461,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {CSN.Elements} elements
    * @param {CSN.QuerySelect} SELECT
    * @param {boolean} containsExpandInline
+   * @returns {Function[]} Cleanup callbacks that remove `_`-links.
    */
   function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
     const cleanupCallbacks = [];
@@ -366,7 +470,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     const hasStar = SELECT.columns.includes('*');
     const unfoldingMap = {};
     let starContainsCalculated = false;
-    let containsCalculated = false;
+    let containsCalcOnRead = false;
     for (const name in elements) {
       const originalRef = columnMap[name] && columnMap[name].ref || [ name ];
 
@@ -377,17 +481,19 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         else
           element = columnMap[name]?._art || columnMap[name]?._element || root[name] || elements[name];
         const branches = getBranches(element, name, effectiveType, pathDelimiter); // TODO: is our elements[name] really the root[name]?
-        if (hasCalculatedLeaf(branches)) {
-          containsCalculated = true;
+        if (hasCalcOnReadLeaf(branches)) {
+          containsCalcOnRead = true;
           const columns = [];
           for (const branchName in branches) {
+            const branch = branches[branchName];
+            const leafElement = branch.steps[branch.steps.length - 1];
             if (columnMap[branchName]) { // Existing column - don't overwrite, we need $env!
               columns.push(columnMap[branchName]);
             }
             else {
               // TODO: Hm, will we have a $env in the leaf of the thing then?
               const column = { ref: [ ...originalRef, ...branches[branchName].ref.slice(1) ], as: branchName };
-              setProp(column, '_element', element);
+              setProp(column, '_element', leafElement);
               cleanupCallbacks.push(() => delete column._element);
               columns.push(column);
             }
@@ -409,10 +515,10 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
       }
     }
 
-    if (containsExpandInline && containsCalculated) {
+    if (containsExpandInline && containsCalcOnRead) {
       error('query-unsupported-calc', SELECT.$path, { '#': 'std' });
     }
-    else if (containsCalculated) {
+    else if (containsCalcOnRead) {
       const newColumns = [];
       if (hasStar && !starContainsCalculated)
         newColumns.push('*');
@@ -422,22 +528,23 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
           newColumns.push(...columns);
       }
 
-
       SELECT.columns = newColumns;
     }
     return cleanupCallbacks;
   }
 
   /**
+   * Returns true if any leaf node is a calculated element on-read.
+   * On-write behaves like regular elements, hence they do not count here.
    *
    * @param {object} branches
    * @returns {boolean}
    */
-  function hasCalculatedLeaf( branches ) {
+  function hasCalcOnReadLeaf( branches ) {
     for (const branchName in branches) {
       const branch = branches[branchName].steps;
       const leaf = branch[branch.length - 1];
-      if (hasValue(leaf))
+      if (hasOnReadValue(leaf))
         return true;
     }
 
@@ -451,13 +558,13 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {object} baseLeaf Leaf to start at
    * @returns {boolean}
    */
-  function hasValue( baseLeaf ) {
+  function hasOnReadValue( baseLeaf ) {
     const visited = new WeakSet();
     const stack = [ baseLeaf ];
     while (stack.length > 0) {
       const leaf = stack.pop();
       if (!visited.has(leaf)) { // Don't re-process things
-        if (leaf.value)
+        if (leaf.value && !leaf.value.stored)
           return true;
         else if (leaf._art)
           stack.push(leaf._art);
@@ -575,9 +682,9 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
  * @param {CSN.Model} csn
  */
 function processCalculatedElementsInEntities( csn ) {
-  forEachDefinition(csn, (artifact, artifactName) => {
+  forEachDefinition(csn, (artifact, definitionName) => {
     if (artifact.kind === 'entity' && !(artifact.query || artifact.projection))
-      killInEntity(artifact, [ 'definitions', artifactName ]);
+      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ]);
   });
 }
 
@@ -590,13 +697,13 @@ function processCalculatedElementsInEntities( csn ) {
  * @todo calculated elements that "live" on the database?
  * @todo error when artifact is empty afterwards? Probably better as a CSN check!
  */
-function killInEntity( artifact, path ) {
+function removeDummyValueInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
     value: (parent, prop, value, p, root) => {
       if (!value.stored)
         delete root[p[p.length - 1]];
     },
-  }, {}, path);
+  }, {}, path.concat( 'elements' ));
 }
 
 /**

package/lib/transform/db/views.js

@@ -4,7 +4,6 @@ const {
   getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
-const { isBetaEnabled } = require('../../base/model');
 const { ModelError } = require('../../base/error');
 
 /**
@@ -208,11 +207,11 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
    */
   function handleAssociationElement( query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath ) {
     if (isUnion(queryPath) && options.transformation === 'hdbcds') {
-      if (isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J) {
+      if (doA2J) {
         if (elem.keys)
-          info(null, queryPath, { name: elemName }, 'Managed association $(NAME), published in a UNION, will be ignored');
+          info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': 'managed' });
         else
-          info(null, queryPath, { name: elemName }, 'Association $(NAME), published in a UNION, will be ignored');
+          info('query-ignoring-assoc-in-union', queryPath, { name: elemName, '#': 'std' });
 
         elem._ignore = true;
       }

package/lib/transform/draft/db.js

@@ -126,7 +126,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
         keys.push(elt);
     }, [ 'definitions', artifactName ], true, { elementsOnly: true });
 
-    // In contrast to EDM, the DB entity may have more than one technical keys but should have idealy exactly one key of type cds.UUID
+    // 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');
 
@@ -183,20 +183,27 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     if (artifact.$location)
       setProp(draftsArtifact, '$location', artifact.$location);
 
+    const calcOnWriteElements = [];
+
     // Copy all elements
     for (const elemName in artifact.elements) {
       const origElem = artifact.elements[elemName];
-      let elem;
-      if ((isDeprecatedEnabled(options, '_renderVirtualElements') && origElem.virtual) || !origElem.virtual)
-        elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
-      if (elem) {
-        // Remove "virtual" - cap/issues 4956
-        if (elem.virtual)
-          delete elem.virtual;
-
-        // explicitly set nullable if not key and not unmanaged association
-        if (!elem.key && !elem.on)
-          elem.notNull = false;
+      if (origElem.value?.stored) {
+        calcOnWriteElements.push(elemName);
+      }
+      else {
+        let elem;
+        if ((isDeprecatedEnabled(options, '_renderVirtualElements') && origElem.virtual) || !origElem.virtual)
+          elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
+        if (elem) {
+          // Remove "virtual" - cap/issues 4956
+          if (elem.virtual)
+            delete elem.virtual;
+
+          // explicitly set nullable if not key and not unmanaged association
+          if (!elem.key && !elem.on)
+            elem.notNull = false;
+        }
       }
     }
 
@@ -276,6 +283,8 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
       // we don't delete them (but mark them as implicit so that toCdl does not render them)
       // draftAdministrativeData.DraftAdministrativeData.implicitForeignKeys = true;
     }
+
+    calcOnWriteElements.forEach(elemName => copyAndAddElement(artifact.elements[elemName], draftsArtifact, draftsArtifactName, elemName)[elemName]);
   }
 
   /**

package/lib/transform/draft/odata.js

@@ -16,6 +16,10 @@ const { makeMessageFunction } = require('../../base/messages');
  * - Element must not be an 'array of' for OData V2 TODO: move to the validator
  * - Perform checks for exposed non-abstract entities and views - check media type and key-ness
  *
+ * ATTENTION:  generateDrafts propagates annotations from the draft nodes to the
+ *             returns element of the draft actions. Shortcut/Convenience annotations
+ *             are NOT replaced/expanded (eg. @label => @Common.Label).
+ *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {Array} [services] Will be calculated JIT if not provided

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"
       }
@@ -387,12 +388,12 @@ function transform4odataWithCsn(inputModel, options) {
   }
 
   // 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 +410,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)