@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/transform/forHanaNew.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { getUtils, cloneCsn,
+const { getUtils, cloneCsnNonDict,
         forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath,
@@ -16,7 +16,7 @@ const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../che
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
-const { createDict } = require('../utils/objectUtils');
+const { createDict, forEach } = require('../utils/objectUtils');
 const handleExists = require('./db/transformExists');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
@@ -41,9 +41,7 @@ function forEachDefinition(csn, cb) {
  * in HANA CDS style, used by 'toHana', toSql' and 'toRename'.
  * The behavior is controlled by the following options:
  * options = {
- *    forHana.names                               // See the behavior of 'names' in toHana, toSql and toRename
- *    forHana.alwaysResolveDerivedTypes           // Always resolve derived type chains (by default, this is only
- *                                                // done for 'quoted' names). FIXME: Should always be done in general.
+ *    sqlMapping // See the behavior of 'sqlMapping' in toHana, toSql and toRename
  * }
  * The result model will always have 'options.forHana' set, to indicate that these transformations have happened.
  * The following transformations are made:
@@ -69,9 +67,9 @@ function forEachDefinition(csn, cb) {
  * - (110) Actions and functions (bound or unbound) are ignored.
  * - (120) (a) Services become contexts.
  * - (130) (not for to.hdbcds with hdbcds names): Elements having structured types are flattened into
- *         multiple elements (using '_' or '.' as name separator, depending on 'forHana.names').
+ *         multiple elements (using '_' or '.' as name separator, depending on 'sqlMapping').
  * - (140) (not for to.hdbcds with hdbcds names): Managed associations get explicit ON-conditions, with
- *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'forHana.names').
+ *         generated foreign key elements (also using '_' or '.' as name separator, depending on 'sqlMapping').
  * - (150) (a) Elements from inherited (included) entities are copied into the receiving entity
  *         (b) The 'include' property is removed from entities.
  * - (160) Projections become views, with MIXINs for association elements (adding $projection where
@@ -94,7 +92,7 @@ function forEachDefinition(csn, cb) {
  *         (d) Managed association entries in ORDER BY
  * - (240) All artifacts (a), elements, foreign keys, parameters (b) that have a DB representation are annotated
  *         with their database name (as '@cds.persistence.name') according to the naming convention chosen
- *         in 'options.forHana.names'.
+ *         in 'options.sqlMapping'.
  * - (250) Remove name space definitions again (only in forHanaNew). Maybe we can omit inserting namespace definitions
  *         completely (TODO)
  *
@@ -106,38 +104,35 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
   /** @type {CSN.Model} */
-  let csn = cloneCsn(inputModel, options);
-
-
+  let csn = cloneCsnNonDict(inputModel, options);
 
   checkCSNVersion(csn, options);
 
-  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
 
   let message, error, warning, info; // message functions
   /** @type {() => void} */
-  let throwWithError;
+  let throwWithAnyError;
   let artifactRef, inspectRef, effectiveType, get$combined,
-    getFinalBaseType, // csnUtils (csnRefs)
     addDefaultTypeFacets, expandStructsInExpression; // transformUtils
 
   bindCsnReference();
 
-  throwWithError(); // reclassify and throw in case of non-configurable errors
+  throwWithAnyError(); // reclassify and throw in case of non-configurable errors
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn')) {
     enrichUniversalCsn(csn, options);
     bindCsnReference();
   }
 
-  const dialect = options.forHana && options.forHana.dialect || options.toSql && options.toSql.dialect;
+  const dialect = options.sqlDialect;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forHana(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, getFinalBaseType, isAspect
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, isAspect
   });
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
@@ -146,13 +141,13 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
-  // If errors are detected, throwWithError() will return from further processing
+  // If errors are detected, throwWithAnyError() will return from further processing
 
   // If this function is ever undefined, we have a bug in our logic.
   // @ts-ignore
   expandStructsInExpression(csn, { drillRef: true });
 
-  throwWithError();
+  throwWithAnyError();
 
   // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
@@ -167,7 +162,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
-    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithError});
+    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithAnyError});
     bindCsnReference();
   }
 
@@ -222,6 +217,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     flattenStructuredElement,
     flattenStructStepsInRef,
     isAssociationOperand, isDollarSelfOrProjectionOperand,
+    csnUtils,
   } = transformUtils.getTransformers(csn, options, pathDelimiter);
 
   const {
@@ -229,7 +225,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     isAssocOrComposition,
     addStringAnnotationTo,
     cloneWithTransformations,
-  } = getUtils(csn);
+  } = csnUtils;
 
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
@@ -353,7 +349,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   if(doA2J)
     flattening.removeLeadingSelf(csn);
 
-  throwWithError();
+  throwWithAnyError();
 
   timetrace.stop();
 
@@ -381,7 +377,22 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     // Set when we turn UUID into String, checked during generateDraftForHana
     '$renamed': killProp,
     // Set when we remove .key from temporal things, used in localized.js
-    '$key': killProp
+    '$key': killProp,
+    // We need .elements easily for rendering - otherwise we have to compute it then
+    // Does not fit in the "killers" theme - TODO: Find a better place
+    SET: (parent, prop, SET) => {
+      if(!SET.elements) {
+        const stack = [parent];
+        while(stack.length > 0) {
+          const query = stack.pop();
+
+          if(query.SET)
+            stack.push(query.SET.args[0]);
+          else if(query.SELECT)
+            setProp(SET, 'elements', query.SELECT.elements);
+        }
+      }
+    }
   }
 
   applyTransformations(csn, killers, [], { skipIgnore: false});
@@ -393,9 +404,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    ({ error, warning, info, message, throwWithError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
+    ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
     ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    // TODO: Can we use csnUtils of the call above (transformUtils.getTransformers)?
+    ({ artifactRef, inspectRef, effectiveType, get$combined } = getUtils(csn));
   }
 
   function bindCsnReferenceOnly(){
@@ -448,7 +460,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
                 // get$combined also includes elements which are part of "excluding {}"
                 // this shouldn't be an issue here, as such references get rejected
                 const elementsOfQuerySources = get$combined(query);
-                Object.entries(elementsOfQuerySources).forEach(([id, element]) => {
+                forEach(elementsOfQuerySources, (id, element) => {
                   // if the ref points to an element which is not explicitly exposed in the column list,
                   // but through the '*' operator -> replace the $projection / $self with the correct source entity
                   if(id === columnToReplace)
@@ -458,7 +470,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
               // No implicit CAST in on-condition
               if(replaceWith && replaceWith.cast) {
-                const clone = cloneCsn(replaceWith, options);
+                const clone = cloneCsnNonDict(replaceWith, options);
                 delete clone.cast;
                 return clone;
               }
@@ -475,10 +487,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
-        forAllQueries(artifact.query, (q, p) => {
-          transformEntityOrViewPass2(q, artifact, artifactName, p)
-          replaceAssociationsInGroupByOrderBy(q, options, inspectRef, error, p);
-        }, [ 'definitions', artifactName, 'query' ]);
+        const process = (parent, prop, query, path) => {
+          transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
+          replaceAssociationsInGroupByOrderBy(parent, options, inspectRef, error, path.concat(prop));
+          return query;
+        }
+        applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
+          SELECT: process
+        }, {}, [ 'definitions']);
       }
     }
   }
@@ -490,7 +506,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function recursivelyApplyCommon(artifact, artifactName) {
     if (!artifact._ignore) {
       if (artifact.kind !== 'service' && artifact.kind !== 'context')
-        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.forHana.names, csn), artifact);
+        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
         transformCommon(member, memberName, path);
@@ -498,7 +514,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         // Virtual elements in entities and types are not annotated, as they have no DB representation.
         // In views they are, as we generate a null expression for them (null as <colname>)
         if ((!member.virtual || artifact.query))
-          addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.forHana.names), member);
+          addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member);
       }, [ 'definitions', artifactName ]);
     }
   }
@@ -524,7 +540,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformSelfInBacklinks(artifact, artifactName, dummy, path) {
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
-    if(artifact.kind === 'entity' || artifact.query || (options.toHana && options.toHana.names === 'hdbcds' && artifact.kind == 'type'))
+    if(artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
       doit(artifact.elements, path.concat([ 'elements' ]));
     if (artifact.query && artifact.query.SELECT && artifact.query.SELECT.mixin)
       doit(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
@@ -555,7 +571,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       // For HANA: Report an error on
       // - view with parameters that has an element of type association/composition
       // - association that points to entity with parameters
-      if (options.forHana.dialect === 'hana' && member.target && isAssocOrComposition(member.type) && !isBetaEnabled(options, 'assocsWithParams')) {
+      if (options.sqlDialect === 'hana' && member.target && isAssocOrComposition(member.type) && !isBetaEnabled(options, 'assocsWithParams')) {
         if (artifact.params) {
           // HANA does not allow 'WITH ASSOCIATIONS' on something with parameters:
           // SAP DBTech JDBC: [7]: feature not supported: parameterized sql view cannot support association: line 1 col 1 (at pos 0)
@@ -598,7 +614,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           sql: 'Table-like entities with parameters are not supported for conversion to SQL',
         });
       }
-      else if (options.forHana.dialect === 'sqlite') { // view with params
+      else if (options.sqlDialect === 'sqlite') { // view with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], `SQLite does not support entities with parameters`);
       }
@@ -607,8 +623,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           if (pname.match(/\W/g) || pname.match(/^\d/) || pname.match(/^_/)) { // parameter name must be regular SQL identifier
             warning(null, [ 'definitions', artifactName, 'params', pname ], `Expecting regular SQL-Identifier`);
           }
-          else if (options.forHana.names !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
-            warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.forHana.names },
+          else if (options.sqlMapping !== 'plain' && pname.toUpperCase() !== pname) { // not plain mode: param name must be all upper
+            warning(null, [ 'definitions', artifactName, 'params', pname ], { name: options.sqlMapping },
                    'Expecting parameter to be uppercase in naming mode $(NAME)');
           }
         }
@@ -618,7 +634,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function handleAssocToJoins() {
     // With flattening errors, it makes little sense to continue.
-    throwWithError();
+    throwWithAnyError();
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
     forEachDefinition(csn, art => art.technicalConfig && setProp(art, 'technicalConfig', art.technicalConfig));
@@ -998,24 +1014,22 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
       function checkTypeParamValue(node, paramName, range = null, path = null) {
         const paramValue = node[paramName];
-        if (paramValue == undefined) {
+        if (paramValue === undefined || paramValue === null) {
           if(options.toSql || artifact.query || !['cds.Binary','cds.hana.BINARY', 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
             return true;
           } else {
-            return error('missing-type-parameter', path, { name: paramName, id: node.type, $reviewed: false });
+            return error('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
           }
         }
         if (range) {
           if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
-            error(null, path,
-              { prop: paramName, type: node.type, number: range.max, $reviewed: false },
-              'Expecting parameter $(PROP) for type $(TYPE) to not exceed $(NUMBER)');
+            error('type-unexpected-argument', path,
+              { '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false });
             return false;
           }
           if (range.min && paramValue < range.min) {
-            error(null, path,
-              { prop: paramName, type: node.type, number: range.min, $reviewed: false },
-              'Expecting parameter $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)');
+            error('type-unexpected-argument', path,
+              { '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false });
             return false;
           }
         }
@@ -1031,7 +1045,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   * @returns {boolean}
   */
   function isMaxParameterLengthRestricted(type) {
-    return !(options.toSql && type === 'cds.String' && (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain'));
+    return !(options.toSql && type === 'cds.String' && (options.sqlDialect === 'sqlite' || options.sqlDialect === 'plain'));
   }
 
   /**

package/lib/transform/forOdataNew.js

@@ -3,8 +3,7 @@
 const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
-const { getUtils,
-        cloneCsn,
+const { cloneCsnNonDict,
         forEachDefinition,
         forEachMemberRecursively,
         applyTransformationsOnNonDictionary,
@@ -17,14 +16,12 @@ const { getUtils,
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./odata/utils');
-const ReferenceFlattener = require('./odata/referenceFlattener');
-const { flattenCSN } = require('./odata/structureFlattener');
-const generateForeignKeys = require('./odata/generateForeignKeyElements');
-const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssociations');
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
-const { attachPath } = require('./odata/attachPath');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
+const flattening = require('./db/flattening');
+const associations = require('./db/associations')
+const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
 const { addLocalizationViews } = require('./localized');
@@ -74,10 +71,10 @@ module.exports = { transform4odataWithCsn };
 function transform4odataWithCsn(inputModel, options) {
   timetrace.start('OData transformation');
   // copy the model as we don't want to change the input model
-  let csn = cloneCsn(inputModel, options);
+  let csn = cloneCsnNonDict(inputModel, options);
 
-  const { message, error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
-  throwWithError();
+  const { message, error, warning, info, throwWithAnyError } = makeMessageFunction(csn, options, 'for.odata');
+  throwWithAnyError();
 
   // the new transformer works only with new CSN
   checkCSNVersion(csn, options);
@@ -88,24 +85,22 @@ function transform4odataWithCsn(inputModel, options) {
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
     recurseElements, setAnnotation, renameAnnotation,
-    expandStructsInExpression
+    expandStructsInExpression,
+    csnUtils,
   } = transformers;
 
-  const csnUtils = getUtils(csn);
   const {
     getCsnDef,
     getServiceName,
     isAssocOrComposition,
     isAssociation,
-    isStructured,
     inspectRef,
     artifactRef,
     effectiveType,
-    getFinalBaseType,
   } = csnUtils;
 
   // are we working with structured OData or not
-  const structuredOData = options.toOdata.odataFormat === 'structured' && options.toOdata.version === 'v4';
+  const structuredOData = options.odataFormat === 'structured' && options.odataVersion === 'v4';
 
   // collect all declared non-abstract services from the model
   // use the array when there is a need to identify if an artifact is in a service or not
@@ -118,7 +113,7 @@ function transform4odataWithCsn(inputModel, options) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
-  const keepLocalizedViews = isDeprecatedEnabled(options, 'createLocalizedViews');
+  const keepLocalizedViews = isDeprecatedEnabled(options, '_createLocalizedViews');
 
   function acceptLocalizedView(_name, parent) {
     csn.definitions[parent].$localized = true;
@@ -127,13 +122,13 @@ function transform4odataWithCsn(inputModel, options) {
 
   addLocalizationViews(csn, options, acceptLocalizedView);
 
-  validate.forOdata(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
+  const cleanup = validate.forOdata(csn, {
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
   });
 
 
   // Throw exception in case of errors
-  throwWithError();
+  throwWithAnyError();
 
   // Semantic checks before flattening regarding temporal data
   // TODO: Move in the validator
@@ -155,35 +150,38 @@ function transform4odataWithCsn(inputModel, options) {
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
-  // If errors are detected, throwWithError() will return from further processing
+  // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
-  // handles reference flattening
-  let referenceFlattener = new ReferenceFlattener();
-  referenceFlattener.resolveAllReferences(csn, inspectRef, isStructured);
-  attachPath(csn);
-
-  referenceFlattener.applyAliasesInOnCond(csn, inspectRef);
-
   if (!structuredOData) {
-    // flatten structures
-    // @ts-ignore
-    flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember);
-    // flatten references
-    referenceFlattener.flattenAllReferences(csn);
+    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, { skipArtifact: isExternalServiceMember });
+    const resolved = new WeakMap();
+    // No refs with struct-steps exist anymore
+    flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
+    // No type references exist anymore
+    // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
+    // OData doesn't resolve type chains after the first 'items'
+    flattening.resolveTypeReferences(csn, options, resolved, '_',
+      { skip: [ 'action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
+    // No structured elements exists anymore
+    flattening.flattenElements(csn, options, '_', error,
+      { skip: ['action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember,
+        skipStandard: { items: true },  // don't drill further into .items
+        skipDict: { actions: true } }); // don't drill further into .actions -> bound actions, action-artifacts are handled by skip
   }
 
-  // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
-  throwWithError();
+  // TODO: add the generated foreign keys to the columns when we are in a view
+  // see db/views.js::addForeignKeysToColumns
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, '_', !structuredOData, { skipArtifact: isExternalServiceMember });
 
-  // Process associations
-  // 1. In case we generate flat mode, expand the structured foreign keys.
-  // This logic rewrites the 'ref' for such keys with the corresponding flattened
-  // elements.
-  if (!structuredOData)
-    expandStructKeysInAssociations(csn, referenceFlattener, csnUtils, isExternalServiceMember);
-  // 2. generate foreign keys for managed associations
-  generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
+  // Allow using managed associations as steps in on-conditions to access their fks
+  // To be done after handleManagedAssociationsAndCreateForeignKeys,
+  // since then the foreign keys of the managed assocs are part of the elements
+  if(!structuredOData)
+    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, '_'));
+
+  // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
+  throwWithAnyError();
 
   // Apply default type facets as set by options
   // Flatten on-conditions in unmanaged associations
@@ -207,22 +205,23 @@ function transform4odataWithCsn(inputModel, options) {
   generateDrafts(csn, options, services)
 
   // Deal with all kind of annotations manipulations here
+  const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};
   forEachDefinition(csn, (def, defName) => {
     // Resolve annotation shorthands for entities, types, annotations, ...
     renameShorthandAnnotations(def);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
-    if (options.toOdata.names && !['service', 'context', 'namespace', 'annotation', 'action', 'function'].includes(def.kind))
-      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.toOdata.names, csn);
+    if (options.sqlMapping && !(def.kind in skipPersNameKinds))
+      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
-    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // 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.toOdata.names && typeof member === 'object' && !['action', 'function'].includes(member.kind) && propertyName !== 'enum' && (!member.virtual || def.query)) {
+      if (options.sqlMapping && typeof member === 'object' && !(member.kind === 'action' || member.kind === 'function') && propertyName !== 'enum' && (!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(referenceFlattener.getElementNameWithDots(path) || memberName, options.toOdata.names);
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -252,9 +251,9 @@ function transform4odataWithCsn(inputModel, options) {
   }, { skipArtifact: isExternalServiceMember })
 
   // Throw exception in case of errors
-  throwWithError();
-
-  if (options.testMode) csn = cloneCsn(csn, options);   // sort, keep hidden properties
+  throwWithAnyError();
+  cleanup();
+  if (options.testMode) csn = cloneCsnNonDict(csn, options);   // sort, keep hidden properties
   timetrace.stop();
   return csn;
 

package/lib/transform/localized.js

@@ -1,12 +1,14 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { setProp } = require('../base/model');
+const { setProp, isDeprecatedEnabled} = require('../base/model');
 const { hasErrors } = require('../base/messages');
-const { cloneCsnDictionary } = require('../model/csnUtils');
+const { forEachKey } = require('../utils/objectUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
-  cloneCsn,
+  cloneCsnDictionary,
+  cloneCsnNonDict,
+  applyAnnotationsFromExtensions,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
@@ -67,7 +69,8 @@ const _targetFor = Symbol('_targetFor');
  * @param {CSN.Options} options
  * @param {boolean} useJoins If true, rewrite the "localized" association to a
  *                           join in direct convenience views.
- * @param {acceptLocalizedView} [acceptLocalizedView] optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param {acceptLocalizedView} [acceptLocalizedView] optional callback function returning true if the localized view
+ *                                                    name and its parent name provided as parameter should be created
  */
 function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = null) {
   // Don't try to create convenience views with errors.
@@ -86,6 +89,12 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
   forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
+  // In case that the user tried to annotate `localized.*` artifacts, apply them.
+  applyAnnotationsFromExtensions(csn, {
+    overwrite: true,
+    filter: (name) => name.startsWith('localized.')
+  });
+
   sortCsnDefinitionsForTests(csn, options);
   return csn;
 
@@ -141,9 +150,8 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     else
       view = createLocalizedViewForEntity(art, artName, textElements);
 
+    copyPersistenceAnnotations(view, art, options);
     csn.definitions[viewName] = view;
-
-    copyPersistenceAnnotations(csn.definitions[viewName], art);
   }
 
   /**
@@ -245,9 +253,9 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     };
 
     if (view.query)
-      convenienceView.query = cloneCsn(view.query, options);
+      convenienceView.query = cloneCsnNonDict(view.query, options);
     else if (view.projection)
-      convenienceView.projection = cloneCsn(view.projection, options);
+      convenienceView.projection = cloneCsnNonDict(view.projection, options);
 
     convenienceView.elements = cloneCsnDictionary(view.elements, options);
     convenienceView[_isViewForView] = true;
@@ -549,7 +557,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     if (!obj || typeof obj !== 'object' || Array.isArray(obj))
       return;
 
-    for (const prop of [ 'ref', 'target', 'on' ]) {
+    for (const prop of [ 'ref', 'target' ]) {
       const val = obj[prop];
       if (prop === 'ref') {
         rewriteRefToLocalized(obj);
@@ -662,21 +670,24 @@ function copyLocation(target, source) {
 }
 
 /**
- * Copy some @cds.persistence.* annotations from the source to
- * the target.  Ignores existing annotations on the target.
+ * Copy @cds.persistence.exists/skip annotations from the source to
+ * the target.  Ignores existing annotations on the _target_.
  *
  * @param {CSN.Artifact} target
  * @param {CSN.Artifact} source
+ * @param {CSN.Options} options
  */
-function copyPersistenceAnnotations(target, source) {
-  Object.keys(source)
-    .forEach(anno => {
-      // Do NOT copy ".exists" at the moment.  ".exists" is not propagated
-      // and this would lead to some localization views referencing not-existing
-      // "localized.XYZ" views.
-      if (anno === '@cds.persistence.skip')
-        target[anno] = source[anno];
-    });
+function copyPersistenceAnnotations(target, source, options) {
+  const doNotCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  forEachKey(source, anno => {
+    // Note:
+    //   Because `.exists` is copied to the convenience view, it could
+    //   lead to some localization views referencing non-existing ones.
+    //   But that is the contract: User says that it already exists!
+    //   In v2, `.exists` was never copied.
+    if (anno === '@cds.persistence.skip' || (!doNotCopyExists && anno === '@cds.persistence.exists'))
+      target[anno] = source[anno];
+  });
 }
 
 /**