@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/transform/forHanaNew.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { getUtils, cloneCsn,
-        forEachMemberRecursively, forEachRef, forAllQueries,
+const { getUtils, cloneCsnNonDict,
+        forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath,
       } = require('../model/csnUtils');
@@ -12,23 +12,24 @@ const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
 const { csnRefs, pathId } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
-const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
+const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
 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;
 const flattening = require('./db/flattening');
 const expansion = require('./db/expansion');
 const assertUnique = require('./db/assertUnique');
-const generateDrafts = require('./db/draft');
-const enrichUniversalCsn = require('./universalCsnEnricher');
+const generateDrafts = require('./draft/db');
+const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
 const { getViewTransformer } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
+const { ModelError } = require("../base/error");
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -105,7 +106,7 @@ 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);
 
 
 
@@ -113,16 +114,16 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
 
-  let error, warning, info; // message functions
+  let message, error, warning, info; // message functions
   /** @type {() => void} */
-  let throwWithError;
-  let artifactRef, inspectRef, effectiveType, // csnRefs
-    addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType, getFinalBaseType, // transformUtils
-    get$combined; // csnUtils
+  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);
@@ -136,7 +137,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forHana(csn, {
-    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, getFinalBaseType, isAspect
   });
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
@@ -145,13 +146,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;
@@ -166,7 +167,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();
   }
 
@@ -232,34 +233,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
-    type: (val, node, key, path) => {
-      // Resolve type-of chains
-      function fn() {
-        // val can be undefined: books as myBooks : redirected to Model.MyBooks
-        if (val && val.ref) {
-          const { art } = inspectRef(path);
-          if (art && art.type) {
-            val = art.type;
-            // This is somehow needed to update the ref so that inspectRef sees it
-            node[key] = val;
-            if (val.ref)
-              fn();
-          }
-          else {
-            // Doesn't seem to ever ocurr
-          }
-        }
-      }
-      fn();
+    type: (val, node, key) => {
       renamePrimitiveTypesAndUuid(val, node, key);
       addDefaultTypeFacets(node);
     },
-    cast: (val) => {
-      if (options.forHana.names === 'plain' || options.toSql )
-        toFinalBaseType(val);
-      renamePrimitiveTypesAndUuid(val.type, val, 'type');
-      addDefaultTypeFacets(val);
-    },
     // HANA/SQLite do not support array-of - turn into CLOB/Text
     items: (val, node) => {
       node.type = 'cds.LargeString';
@@ -270,24 +247,19 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // (040) Ignore entities and views that are abstract or implemented
   // or carry the annotation cds.persistence.skip/exists
   // These entities are not removed from the csn, but flagged as "to be ignored"
-  forEachDefinition(csn, cdsPersistence.getAnnoProcessor(csn, options, {warning}));
+  forEachDefinition(csn, cdsPersistence.getAnnoProcessor());
 
 
   // (050) Check @cds.valid.from/to only on entity
   //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
-  //       Temporal only in beta-mode
   forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
 
-  handleManagedAssociationsAndCreateForeignKeys();
+  // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, { allowArtifact: artifact => (artifact.kind === 'entity') });
 
-  function handleManagedAssociationsAndCreateForeignKeys() {
-    forEachDefinition(csn, associations.getForeignKeyFlattener(csn, options, pathDelimiter));
-    forEachDefinition(csn, associations.getForeignKeyElementCreator(csn, options, pathDelimiter, { error }));
-  }
-
-  forEachDefinition(csn, flattenIndexes);
-  // Basic handling of associations in views and entities
-  forEachDefinition(csn, associations.getManagedAssociationTransformer(csn, options, pathDelimiter));
+  doA2J && forEachDefinition(csn, flattenIndexes);
+  // Managed associations get an on-condition - in views and entities
+  doA2J && associations.attachOnConditions(csn, pathDelimiter);
 
   // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
   // and make them entities
@@ -296,10 +268,11 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
   // are part of the elements
-  forEachDefinition(csn, handleManagedAssocStepsInOnCondition);
+  if (doA2J)
+    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter));
 
   // Create convenience views for localized entities/views.
-  // To be done after handleManagedAssocStepsInOnCondition because associations are
+  // To be done after getManagedAssocStepsInOnConditionFinalizer because associations are
   // handled and before handleDBChecks which removes the localized attribute.
   // Association elements of localized convenience views do not have hidden properties
   // like $managed set, so we cannot do this earlier on.
@@ -308,11 +281,11 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   else
     addLocalizationViews(csn, options);
 
-  forEachDefinition(csn, (definition, artName, prop, path) => {
+  !doA2J && forEachDefinition(csn, (definition, artName, prop, path) => {
     if (definition.query) {
       // reject managed association and structure publishing for to-hdbcds.hdbcds
       const that = { csnUtils: getUtils(csn), options, error };
-      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
+      rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
     }
   });
 
@@ -336,18 +309,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // because otherwise we would produce wrong ON-conditions for the keys involved. Sigh ...
   forEachDefinition(csn, transformSelfInBacklinks);
 
-  if(options.forHana){
-    /**
-     * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
-     * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
-     * hence we do not generate the referential constraints for them.
-     */
-    const validOptionsForConstraint = () => {
-      return (options.forHana.dialect === 'sqlite' || options.forHana.dialect === 'hana') && doA2J;
-    }
-    if(validOptionsForConstraint())
-      createReferentialConstraints(csn, options);
-  }
+  /**
+   * Referential Constraints are only supported for sql-dialect "hana" and "sqlite".
+   * For to.hdbcds with naming mode "hdbcds", no foreign keys are calculated,
+   * hence we do not generate the referential constraints for them.
+   */
+  if((options.sqlDialect === 'hana' || options.sqlDialect === 'sqlite') && doA2J)
+    createReferentialConstraints(csn, options);
+
   // no constraints for drafts
   generateDrafts(csn, options, pathDelimiter, { info, warning, error });
 
@@ -370,30 +339,12 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   const checkConstraintIdentifiers = (artifact, artifactName, prop, path) => {
     assertConstraintIdentifierUniqueness(artifact, artifactName, path, error);
   };
-  const removeNamespaces = (artifact, artifactName) => {
-    if (artifact.kind === 'namespace')
-      delete csn.definitions[artifactName];
-  };
-  const ignoreNonPersistedArtifactsWithAnonymousAspectComposition = (artifact) => {
-    if(artifact.kind === 'type' || artifact.kind === 'aspect' || artifact.kind === 'entity' && artifact.abstract){
-      if(artifact.elements && Object.keys(artifact.elements).some((elementName) => {
-        const element = artifact.elements[elementName];
-        return !element.target && element.targetAspect && typeof element.targetAspect !== 'string';
-      })) {
-        artifact._ignore = true;
-      }
-    }
-  };
 
   forEachDefinition(csn, [
     /* assert that there will be no conflicting unique- and foreign key constraint identifiers */
     checkConstraintIdentifiers,
-    /* (250) Remove all namespaces from definitions */
-    removeNamespaces,
     /* Check Type Parameters (precision, scale, length ...) */
     checkTypeParameters,
-    /* Filter out aspects/types/abstract entities containing managed compositions of anonymous aspects */
-    ignoreNonPersistedArtifactsWithAnonymousAspectComposition,
     // (200) Strip 'key' property from type elements
     removeKeyPropInType,
   ]);
@@ -402,7 +353,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   if(doA2J)
     flattening.removeLeadingSelf(csn);
 
-  throwWithError();
+  throwWithAnyError();
 
   timetrace.stop();
 
@@ -430,10 +381,25 @@ 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, [], false);
+  applyTransformations(csn, killers, [], { skipIgnore: false});
 
   redoProjections.forEach(fn => fn());
 
@@ -442,10 +408,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    ({ error, warning, info, throwWithError } = makeMessageFunction(csn, options, moduleName));
-    ({ artifactRef, inspectRef, effectiveType } = csnRefs(csn));
-    ({ getFinalBaseType, get$combined } = getUtils(csn));
-    ({ addDefaultTypeFacets, expandStructsInExpression, toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter));
+    ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
+    ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
+    ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
   }
 
   function bindCsnReferenceOnly(){
@@ -472,8 +437,8 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
           }
         })
       }
-    }
-    , [ 'definitions', artifactName, 'query' ]);
+    }, [ 'definitions', artifactName, 'query' ]);
+
     function getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path){
       const { inspectRef } = csnRefs(csn);
       const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
@@ -498,7 +463,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)
@@ -508,7 +473,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;
               }
@@ -524,11 +489,15 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function transformViews(artifact, artifactName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
-      if ((artifact.kind === 'entity' || artifact.kind === 'view') && artifact.query) {
-        forAllQueries(artifact.query, (q, p) => {
-          transformEntityOrViewPass2(q, artifact, artifactName, p)
-          replaceAssociationsInGroupByOrderBy(q, options, inspectRef, error, p);
-        }, [ 'definitions', artifactName, 'query' ]);
+      if ((artifact.kind === 'entity') && artifact.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']);
       }
     }
   }
@@ -539,7 +508,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    */
   function recursivelyApplyCommon(artifact, artifactName) {
     if (!artifact._ignore) {
-      if (![ 'service', 'context', 'namespace', 'annotation', 'action', 'function' ].includes(artifact.kind))
+      if (artifact.kind !== 'service' && artifact.kind !== 'context')
         addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.forHana.names, csn), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
@@ -558,9 +527,9 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function removeKeyPropInType(artifact, artifactName) {
-    if (!artifact._ignore) {
+    if (!artifact._ignore && artifact.kind === 'type') {
       forEachMemberRecursively(artifact, (member) => {
-        if (artifact.kind === 'type' && member.key)
+        if (member.key)
           delete member.key;
       }, [ 'definitions', artifactName ]);
     }
@@ -609,25 +578,27 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         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)
-          error(null, path, 'Unexpected association in parameterized view');
+          message('def-unexpected-paramview-assoc', path, { '#': 'view' });
         }
         else if(artifact['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
           // UDF/CVs w/o params don't support 'WITH ASSOCIATIONS'
-          error(null, path, `Associations are not allowed in entities annotated with @cds.persistence { udf, calcview }`);
+          const anno = artifact['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+          message('def-unexpected-calcview-assoc', path, { '#': 'entity-persistence', anno });
         }
         if (csn.definitions[member.target].params) {
           // HANA does not allow association targets with parameters or to UDFs/CVs w/o parameters:
           // SAP DBTech JDBC: [7]: feature not supported: cannot support create association to a parameterized view
-          error(null, path, 'Unexpected parameterized association target');
+          message('def-unexpected-paramview-assoc', path, { '#': 'target' });
         }
-        else if(csn.definitions[member.target]['@cds.persistence.udf'] || artifact['@cds.persistence.calcview']) {
+        else if(csn.definitions[member.target]['@cds.persistence.udf'] || csn.definitions[member.target]['@cds.persistence.calcview']) {
           // HANA won't check the assoc target but when querying an association with target UDF, this is the error:
           // SAP DBTech JDBC: [259]: invalid table name: target object SYSTEM.UDF does not exist: line 3 col 6 (at pos 43)
           // CREATE TABLE F (id INTEGER NOT NULL);
           // CREATE FUNCTION UDF RETURNS TABLE (ID INTEGER) LANGUAGE SQLSCRIPT SQL SECURITY DEFINER AS BEGIN RETURN SELECT ID FROM F; END;
           // CREATE TABLE Y (  id INTEGER NOT NULL,  toUDF_id INTEGER) WITH ASSOCIATIONS (MANY TO ONE JOIN UDF AS toUDF ON (toUDF.id = toUDF_id));
           // CREATE VIEW U AS SELECT  id, toUDF.a FROM Y;
-          error(null, path, `Associations can't point to entities annotated with @cds.persistence { udf, calcview }`);
+          const anno = csn.definitions[member.target]['@cds.persistence.udf'] ? '@cds.persistence.udf' : '@cds.persistence.calcview';
+          message('def-unexpected-calcview-assoc', path, { '#': 'target-persistence', anno });
         }
       }
     }, [ 'definitions', artifactName ]);
@@ -638,7 +609,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
    * @param {string} artifactName
    */
   function handleChecksForWithParameters(artifact, artifactName) {
-    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity' || artifact.kind === 'view')) {
+    if (!artifact._ignore && artifact.params && (artifact.kind === 'entity')) {
       if (!artifact.query) { // table entity with params
         // Allow with plain
         error(null, [ 'definitions', artifactName ], { '#': options.toSql ? 'sql' : 'std' }, {
@@ -666,7 +637,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));
@@ -908,7 +879,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       else if (assoc.on)
         return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName);
 
-      throw new Error(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
+      throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
     }
 
     // For a condition `<elemName>.<assoc> = $self` in the ON-condition of element <elemName>,
@@ -963,22 +934,23 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       const newOnCond = cloneWithTransformations(assoc.on, {
         ref: (value) => cloneWithTransformations(value, {}),
       });
-      // goes through the the newOnCond and transform all the 'path' elements
-      forEachRef(newOnCond, (ref) => {
-        if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
-        {
-          ref.shift();
-        } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
-          // We could also have a $self infront of the assoc name - so we would need to shift twice
-          ref.shift();
-          ref.shift();
-        }
-        else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
-          ref.unshift(elemName);
-          // if there was a $self identifier in the forwarding association onCond
-          // we do not need it any more, as we prepended in the previous step the back association's id
-          if (ref[1] === '$self')
-            ref.splice(1, 1);
+      applyTransformationsOnNonDictionary({on: newOnCond}, 'on', {
+        ref: (parent, prop, ref) => {
+          if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
+          {
+            ref.shift();
+          } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
+            // We could also have a $self infront of the assoc name - so we would need to shift twice
+            ref.shift();
+            ref.shift();
+          }
+          else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
+            ref.unshift(elemName);
+            // if there was a $self identifier in the forwarding association onCond
+            // we do not need it any more, as we prepended in the previous step the back association's id
+            if (ref[1] === '$self')
+              ref.splice(1, 1);
+          }
         }
       });
       return newOnCond;
@@ -1045,24 +1017,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;
           }
         }
@@ -1090,7 +1060,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   function flattenIndexes(art, artName) {
     // Flatten structs in indexes (unless explicitly asked to keep structs)
     const tc = art.technicalConfig;
-    if ((art.kind === 'entity' || art.kind === 'view') && doA2J) {
+    if (art.kind === 'entity') {
       if (tc && tc[dialect]) {
         // Secondary and fulltext indexes
         for (const name in tc[dialect].indexes) {
@@ -1144,75 +1114,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       }
     }
   }
-
-  /**
-   * Loop over all elements and for all unmanaged associations translate
-   * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
-   *
-   * Or in other words: Allow using the foreign keys of managed associations in on-conditions
-   *
-   * @param {CSN.Artifact} artifact Artifact to check
-   * @param {string} artifactName Name of the artifact
-   */
-  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
-    for (const elemName in artifact.elements) {
-      const elem = artifact.elements[elemName];
-      if (doA2J) {
-        // The association is an unmanaged on
-        if (!elem.keys && elem.target && elem.on) {
-          forEachRef(elem.on, (ref, refOwner, path) => {
-            // [<assoc base>.]<managed assoc>.<field>
-            if (ref.length > 1) {
-              const { links } = inspectRef(path);
-              if (links) {
-                // eslint-disable-next-line for-direction
-                for (let i = links.length - 1; i >= 0; i--) {
-                  const link = links[i];
-                  // We found the latest managed assoc path step
-                  if (link.art && link.art.target && link.art.keys) {
-                    // Doesn't work when ref-target (filter condition) or similar is used
-                    if (!ref.slice(i).some(refElement => typeof refElement !== 'string')) {
-                      // We join the managed assoc with everything following it
-                      const sourceElementName = ref.slice(i).join(pathDelimiter);
-                      const source = findSource(links, i - 1) || artifact;
-                      // allow specifying managed assoc on the source side
-                      const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] ===  sourceElementName);
-                      if(fks && fks.length >= 1){
-                        const fk = fks[0];
-                        const managedAssocStepName = refOwner.ref[i];
-                        const fkName = `${ managedAssocStepName }${ pathDelimiter }${ fk.as }`;
-                        if(source && source.elements[fkName])
-                          refOwner.ref = [ ...ref.slice(0, i), fkName ];
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }, [ 'definitions', artifactName, 'elements', elemName, 'on' ]);
-        }
-      }
-    }
-
-    /**
-     * Find out where the managed association is
-     *
-     * @param {Array} links
-     * @param {Number} startIndex
-     * @returns {Object| undefined} CSN definition of the source of the managed association
-     *
-     */
-    function findSource(links, startIndex) {
-      for (let i = startIndex; i >= 0; i--) {
-        const link = links[i];
-        // We found the latest assoc step - now check where that points to
-        if (link.art && link.art.target)
-          return csn.definitions[link.art.target];
-      }
-
-      return undefined;
-    }
-  }
 }