@sap/cds-compiler 4.7.6 → 4.8.0

package/lib/transform/addTenantFields.js

@@ -29,8 +29,9 @@ const tenantDef = {
   '@cds.api.ignore': true, // and/or $generated: 'tenant' for the full Universal CSN?
 };
 
-function addTenantFields( csn, options ) {
-  const { error, throwWithError } = createMessageFunctions( options, 'tenant', csn );
+function addTenantFields( csn, options, messageFunctions ) {
+  const { error, throwWithError }
+    = messageFunctions ?? createMessageFunctions( options, 'tenant', csn );
   const { tenantDiscriminator } = options;
   const tenantName = tenantDiscriminator === true ? 'tenant' : tenantDiscriminator;
   if (tenantName !== 'tenant') {
@@ -47,17 +48,21 @@ function addTenantFields( csn, options ) {
   const { definitions } = csn;
   if (!definitions)
     return csn;
-  const { initDefinition, artifactRef, effectiveType } = csnRefs( csn );
+  const {
+    initDefinition,
+    artifactRef,
+    effectiveType,
+    msgLocations,
+  } = csnRefs( csn, true );
 
   const typeCache = new WeakMap();
-  const csnPath = [ 'definitions', '' ];
+  const csnPath = [ null ];
   let independent;
   let projection;
 
   for (const name in definitions) {
-    const art = definitions[name];
-    initDefinition( art );
-    csnPath[1] = name;
+    const art = initDefinition( name );
+    csnPath[0] = art;
     independent = art[annoTenantIndep];
     projection = art.query || art.projection && art;
 
@@ -68,9 +73,11 @@ function addTenantFields( csn, options ) {
       handleElements( art );
       if (projection)
         traverseQuery( projection, null, null, handleQuery );
+      // Note: handleQuery sets csnPath[0]; store if needed afterwards
     }
     else if (!independent && independent != null) {
-      error( 'tenant-invalid-anno-value', csnPath, { anno: annoTenantIndep, value: independent },
+      error( 'tenant-invalid-anno-value', msgLocations( csnPath ),
+             { anno: annoTenantIndep, value: independent },
              // eslint-disable-next-line max-len
              'Can\'t add $(ANNO) with value $(VALUE) to a non-entity, which is always tenant-independent' );
     }
@@ -88,16 +95,15 @@ function addTenantFields( csn, options ) {
   // the cache of csnRefs):
   for (const name in definitions) {
     const art = definitions[name];
-    if (isTenantDepEntity( art ))
-      art.elements = { [tenantName]: { ...tenantDef }, ...art.elements };
-    // consider non-enumerable `elements` of subqueries if that is supported
+    addTenantFieldToArt(art, options);
   }
 
   (csn.extensions || []).forEach( ( ext, idx ) => {
     const tenant = ext.elements?.[tenantName];
     const name = ext.annotate || ext.extend; // extend should not happen
     if (tenant && isTenantDepEntity( definitions[name] )) {
-      error( 'tenant-unexpected-ext', [ 'extensions', idx, 'elements', 'tenant' ],
+      error( 'tenant-unexpected-ext',
+             msgLocations( [ 'extensions', idx, 'elements', 'tenant' ] ),
              { name: tenantName },
              'Can\'t annotate element $(NAME) of a tenant-dependent entity' );
     }
@@ -112,7 +118,7 @@ function addTenantFields( csn, options ) {
     const names = art.includes
       .filter( name => isTenantDepEntity( csn.definitions[name] ) );
     if (names.length) {
-      error( 'tenant-invalid-include', csnPath, { names }, {
+      error( 'tenant-invalid-include', msgLocations( csnPath ), { names }, {
         // eslint-disable-next-line max-len
         std: 'Can\'t include the tenant-dependent entities $(NAMES) into a tenant-independent definition',
         // eslint-disable-next-line max-len
@@ -125,12 +131,13 @@ function addTenantFields( csn, options ) {
   function handleElements( art ) {
     const { elements } = art;
     if (elements[tenantName]) {
-      error( 'tenant-unexpected-element', [ ...csnPath, 'elements', tenantName ],
+      error( 'tenant-unexpected-element',
+             msgLocations( [ ...csnPath, 'elements', tenantName ] ),
              { name: tenantName, option: 'tenantDiscriminator' },
              'Can\'t have entity with element $(NAME) when using option $(OPTION)' );
     }
     else if (!independent && !Object.values( elements ).some( e => e.key )) {
-      error( 'tenant-expecting-key', csnPath, {},
+      error( 'tenant-expecting-key', msgLocations( csnPath ), {},
              'There must be a key in a tenant-dependent entity' );
     }
     else {
@@ -147,18 +154,16 @@ function addTenantFields( csn, options ) {
       return;
 
     if (query !== projection && !independent) {
-      error( 'tenant-unsupported-query', csnPath, {},
+      error( 'tenant-unsupported-query', msgLocations( csnPath ), {},
              'Can\'t yet have tenant-dependent non-simple query entities' );
       projection = null;
       return;
     }
 
-    if (query.projection)
-      csnPath.push( 'projection' );
-    else if (query.SELECT)
-      csnPath.push( 'query', 'SELECT' );
-    else
+    if (!query.projection && !query.SELECT)
       return;                   // query.SET or query.join
+    csnPath[0] = query;
+    csnPath.push( query.SELECT ? 'SELECT' : 'projection' );
 
     const select = query.SELECT || query.projection;
     if (select.mixin)
@@ -177,7 +182,7 @@ function addTenantFields( csn, options ) {
     else if (query !== projection && select.columns) {
       checkColumnCasts( select.columns );
     }
-    csnPath.length = 2;
+    csnPath.length = 1;
   }
 
   function handleQuerySource( query ) {
@@ -185,7 +190,7 @@ function addTenantFields( csn, options ) {
       const art = query.ref[0]; // yes, the base
       if (csn.definitions[art][annoTenantIndep])
         return true;
-      error( 'tenant-invalid-query-source', csnPath, { art, '#': independent }, {
+      error( 'tenant-invalid-query-source', msgLocations( csnPath ), { art, '#': independent }, {
         std: 'Can\'t use a tenant-dependent query source $(ART) in a tenant-independent entity',
         event: 'Can\'t use a tenant-dependent query source $(ART) in an event',
       } );
@@ -194,12 +199,12 @@ function addTenantFields( csn, options ) {
     if (query !== (projection.SELECT || projection.projection)?.from) // with `join`
       return false;
     if ((query.as || implicitAs( query.ref )) === tenantName) {
-      error( 'tenant-invalid-alias-name', csnPath,
+      error( 'tenant-invalid-alias-name', msgLocations( csnPath ),
              { name: tenantName, '#': (query.as ? 'std' : 'implicit') } );
     }
     const art = artifactRef.from( query );
     if (art[annoTenantIndep]) {
-      error( 'tenant-expecting-tenant-source', csnPath, { art: query },
+      error( 'tenant-expecting-tenant-source', msgLocations( csnPath ), { art: query },
              // TODO: better the final entity name of assoc navigation in FROM
              // eslint-disable-next-line max-len
              'Expecting the query source $(ART) to be tenant-dependent for a tenant-dependent query entity' );
@@ -212,7 +217,7 @@ function addTenantFields( csn, options ) {
     for (const name in mixin) {
       csnPath[csnPath.length - 1] = name;
       if (name === tenantName && !independent)
-        error( 'tenant-invalid-alias-name', csnPath, { name, '#': 'mixin' } );
+        error( 'tenant-invalid-alias-name', msgLocations( csnPath ), { name, '#': 'mixin' } );
       handleAssociations( mixin[name], null );
     }
     csnPath.length -= 2;
@@ -220,7 +225,7 @@ function addTenantFields( csn, options ) {
 
   function checkExcluding( excludeList ) {
     if (excludeList.includes( tenantName )) {
-      error( 'tenant-invalid-excluding', csnPath, { name: tenantName },
+      error( 'tenant-invalid-excluding', msgLocations( csnPath ), { name: tenantName },
              'Can\'t exclude $(NAME) from the query source of a tenant-dependent entity' );
     }
   }
@@ -241,7 +246,7 @@ function addTenantFields( csn, options ) {
     for (const col of columns) {
       ++csnPath[csnPath.length - 1];
       if (col.expand || col.inline) {
-        error( 'tenant-unsupported-expand-inline', csnPath, {},
+        error( 'tenant-unsupported-expand-inline', msgLocations( csnPath ), {},
                'Can\'t use expand/inline in a tenant-dependent entity' );
       }
       if (col.key != null)      // yes, also with key: false
@@ -275,12 +280,20 @@ function addTenantFields( csn, options ) {
       return null;
 
     if (elem.target) {
-      if (!csn.definitions[elem.target][annoTenantIndep]) {
-        if (independent)
-          error( 'tenant-invalid-target', csnPath, { target: elem.target } );
+      const { target } = elem;
+      if (csn.definitions[target][annoTenantIndep]) {
+        if (!independent && isComposition( elem ))
+          error( 'tenant-invalid-composition', msgLocations( csnPath ), { target } );
       }
-      else if (!independent && isComposition( elem )) {
-        error( 'tenant-invalid-composition', csnPath, { target: elem.target } );
+      else if (independent) {
+        if (target.endsWith( '.DraftAdministrativeData' ) && csnPath.length === 3 &&
+            csnPath[1] === 'elements' && csnPath[2] === 'DraftAdministrativeData') {
+          error( 'tenant-invalid-draft', msgLocations( csnPath ), {},
+                 'A tenant-independent entity can\'t be draft-enabled' );
+        }
+        else {
+          error( 'tenant-invalid-target', msgLocations( csnPath ), { target } );
+        }
       }
     }
     else if (elem.type && (independent || !elem.elements && !elem.items)) {
@@ -290,10 +303,11 @@ function addTenantFields( csn, options ) {
       if (independent) {
         if (!dep || dep === 'Composition')
           return true;          // check elements (assocs could be redirected)
-        error( 'tenant-invalid-target', csnPath, { type: elem.type, '#': 'type' } );
+        error( 'tenant-invalid-target', msgLocations( csnPath ), { type: elem.type, '#': 'type' } );
       }
       else if (dep && dep !== 'dependent') {
-        error( 'tenant-invalid-composition', csnPath, { type: elem.type, '#': 'type' } );
+        error( 'tenant-invalid-composition', msgLocations( csnPath ),
+               { type: elem.type, '#': 'type' } );
       }
     }
     else {
@@ -398,6 +412,15 @@ function isTenantDepEntity( art ) {
   return art?.kind === 'entity' && !art[annoTenantIndep];
 }
 
+function addTenantFieldToArt( art, options ) {
+  const tenantName = options.tenantDiscriminator === true ? 'tenant' : options.tenantDiscriminator;
+
+  if (isTenantDepEntity( art ))
+    art.elements = { [tenantName]: { ...tenantDef }, ...art.elements };
+    // consider non-enumerable `elements` of subqueries if that is supported
+}
+
 module.exports = {
   addTenantFields,
+  addTenantFieldToArt,
 };

package/lib/transform/db/applyTransformations.js

@@ -13,7 +13,7 @@
 
 
 const { setProp } = require('../../base/model');
-const { isAnnotationExpression } = require('../../compiler/builtins');
+const { isAnnotationExpression } = require('../../base/builtins');
 
 
 /**

package/lib/transform/db/expansion.js

@@ -58,6 +58,9 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     orderBy: (parent, name, orderBy, path) => {
       parent.orderBy = expand(orderBy, path.concat('orderBy'));
     },
+    list: (parent, name, list, path) => {
+      parent.list = expand(list, path.concat('list'));
+    },
   };
 
   // To not have a whole model loop for such a "small" thing, we kill all non-sql-backend relevant annotations here

package/lib/transform/db/flattening.js

@@ -1,38 +1,42 @@
 'use strict';
 
 const {
-  applyTransformations, applyTransformationsOnNonDictionary,
-  isBuiltinType, cardinality2str,
-  copyAnnotations, implicitAs, isDeepEqual, findAnnotationExpression,
+  applyTransformations,
+  applyTransformationsOnNonDictionary,
+  cardinality2str,
+  copyAnnotations,
+  implicitAs,
+  isDeepEqual,
+  findAnnotationExpression,
 } = require('../../model/csnUtils');
+const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 const { transformExpression } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
+
 /**
- * Strip off leading $self from refs where applicable
+ * Strip off leading $self from refs where applicable.
+ * Only relevant for HDBCDS, because handling of `$self` is not implemented there.
  *
- * @param {CSN.Model} csn
+ * @param {object} parent
+ * @param {string} prop
+ * @param {CSN.Elements} elements
  */
-function removeLeadingSelf( csn ) {
-  const magicVars = [ '$now', '$self', '$projection', '$user', '$tenant', '$session', '$at' ];
-  applyTransformations(csn, {
-    elements: (parent, prop, elements) => {
-      for (const [ elementName, element ] of Object.entries(elements)) {
-        if (element.on) {
-          applyTransformationsOnNonDictionary(elements, elementName, {
-            ref: (root, name, ref) => {
-              // Renderers seem to expect it to not be there...
-              if (ref[0] === '$self' && ref.length > 1 && !magicVars.includes(ref[1]))
-                root.ref = ref.slice(1);
-            },
-          });
-        }
-      }
-    }, /* only for kind entity and view */                                                /* do not go into .actions */
-  }, [], { skipIgnore: false, allowArtifact: artifact => (artifact.kind === 'entity'), skipDict: { actions: true } });
+function removeLeadingSelf( parent, prop, elements ) {
+  for (const [ elementName, element ] of Object.entries(elements)) {
+    if (element.on) {
+      applyTransformationsOnNonDictionary(elements, elementName, {
+        ref: (root, name, ref) => {
+          // HDBCDS renderers seem to expect it to not be there...
+          if (ref[0] === '$self' && ref.length > 1 && !isMagicVariable(ref[1]) && ref[1] !== '$projection' && ref[1] !== '$self')
+            root.ref.shift();
+        },
+      });
+    }
+  }
 }
 
 /**
@@ -79,34 +83,49 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
 
   const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
   const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
+  const stripItems = options.transformation === 'hdbcds' || options.transformation === 'sql';
+  const removeItems = new Set();
   applyTransformations(csn, {
     type: (node, prop, type, path, parent, parentProp) => {
       if (options.toOdata && node.kind && node.kind in ignoreOdataKinds)
         return;
       if (parentProp === 'cast') {
         const e = csnUtils.getFinalTypeInfo(type, t => resolved.get(t)?.art || csnUtils.artifactRef(t));
+        if (e.items && stripItems)
+          removeItems.add(node);
         if (!e || e.items || e.elements)
           return;
       }
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
         toFinalBaseType(node, resolved, true);
 
-        if (node.items) // items could have unresolved types
-          toFinalBaseType(node.items, resolved, true);
-
-        // structured types might not have the child-types replaced.
-        // Drill down to ensure this.
-        const nextElements = node.elements || node.items?.elements;
-        const stack = nextElements ? [ nextElements ] : [];
-        while (stack.length > 0) {
-          const elements = stack.pop();
-          for (const e of Object.values(elements)) {
-            toFinalBaseType(e, resolved, true);
-            if (!options.toOdata && e.items) // items could have unresolved types
-              toFinalBaseType(e.items, resolved, true);
-            const next = e.elements || e.items?.elements;
-            if (next)
-              stack.push(next);
+
+        if (node.items && stripItems) {
+          removeItems.add(node);
+        }
+        else {
+          if (node.items) // items could have unresolved types
+            toFinalBaseType(node.items, resolved, true);
+
+          // structured types might not have the child-types replaced.
+          // Drill down to ensure this.
+          const nextElements = node.elements || node.items?.elements;
+          const stack = nextElements ? [ nextElements ] : [];
+          while (stack.length > 0) {
+            const elements = stack.pop();
+            for (const e of Object.values(elements)) {
+              toFinalBaseType(e, resolved, true);
+              if (stripItems && e.items) {
+                removeItems.add(e);
+              }
+              else {
+                if (!options.toOdata && e.items) // items could have unresolved types
+                  toFinalBaseType(e.items, resolved, true);
+                const next = e.elements || e.items?.elements;
+                if (next)
+                  stack.push(next);
+              }
+            }
           }
         }
 
@@ -115,6 +134,7 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
           removeLocalized(node);
       }
     },
+    items: node => removeItems.add(node),
   }, [ (definitions, artifactName, artifact) => {
     // Replace events, actions and functions with simple dummies - they don't have effect on forRelationalDB stuff
     // and that way they contain no references and don't hurt.
@@ -123,6 +143,8 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
     // TODO:factor out somewhere else
     if (!options.toOdata && artifact.kind in replaceWithDummyKinds) {
       const dummy = { kind: artifact.kind };
+      if (artifact.kind === 'event')
+        dummy.elements = {}; // events must be structured for recompilation
       if (artifact.$location)
         setProp(dummy, '$location', artifact.$location);
 
@@ -131,6 +153,13 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
     // TODO: skipDict options as default function arguments not via Object.assign
   } ], iterateOptions);
 
+  // no support for array-of - turn into CLOB/Text
+  for (const node of removeItems) {
+    node.type = 'cds.LargeString';
+    delete node.items;
+  }
+  removeItems.clear();
+
 
   /**
    * OData V4 only:
@@ -439,17 +468,13 @@ function linkForeignKeyAnnotationExtensionsToAssociation( csn, options ) {
  */
 function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFunctions, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
   const { error, warning } = messageFunctions;
-  const { isManagedAssociation, inspectRef, isStructured } = csnUtils;
+  const { inspectRef, isStructured } = csnUtils;
   const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   if (flattenKeyRefs) {
     applyTransformations(csn, {
-      elements: (parent, prop, elements, path) => {
-        Object.entries(elements).forEach(([ elementName, element ]) => {
-          if (isManagedAssociation(element)) {
-          // replace foreign keys that are managed associations by their respective foreign keys
-            flattenFKs(element, elementName, [ ...path, 'elements', elementName ]);
-          }
-        });
+      keys: (element, prop, keys, path) => {
+        // replace foreign keys that are managed associations by their respective foreign keys
+        flattenFKs(element, path.at(-1), path);
       },
     }, [], Object.assign({
       skipIgnore: false,

package/lib/transform/db/views.js

@@ -62,10 +62,9 @@ function usesMixinAssociation( query, association, associationName ) {
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {{error: Function, info: Function}} messageFunctions
- * @param {Function} transformCommon For the time being: Pass from outside
  * @returns {(query: CSN.Query, artifact: CSN.Artifact, artName: string, path: CSN.Path) => void} Transformer function for views
  */
-function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
+function getViewTransformer( csn, options, messageFunctions ) {
   const csnUtils = getUtils(csn);
   const {
     get$combined, isAssocOrComposition,
@@ -237,8 +236,6 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
         // Copy the association element to the MIXIN clause under its alias name
         // Needs to be a deep copy, as we transform the on-condition
         const mixinElem = cloneCsnNonDict(elem, options);
-        // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
-        transformCommon(mixinElem, mixinElemName);
 
         if (query.SELECT && !query.SELECT.mixin)
           query.SELECT.mixin = Object.create(null);

package/lib/transform/effective/main.js

@@ -38,7 +38,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   messageFunctions.setModel(csn);
 
   const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
-  queries.projectionToSELECTAndAddColumns(csn);
+  const redoProjections = queries.projectionToSELECTAndAddColumns(csn);
 
   let csnUtils = getUtils(csn, 'init-all');
 
@@ -63,7 +63,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   // Expand a structured thing in: keys, columns, order by, group by
   expansion.expandStructureReferences(csn, options, '_', messageFunctions, csnUtils);
 
-  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
+  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils, options);
 
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
@@ -81,7 +81,10 @@ function effectiveCsn( model, options, messageFunctions ) {
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
   generateDrafts(csn, options, '_', messageFunctions);
   misc.attachPersistenceName(csn, options, csnUtils);
-  misc.removeDefinitionsAndProperties(csn);
+  misc.removeDefinitionsAndProperties(csn, options);
+
+  if (!options.resolveProjections)
+    redoProjections.forEach(fn => fn());
 
   messageFunctions.throwWithError();
 

package/lib/transform/effective/misc.js

@@ -14,9 +14,11 @@ function attachPersistenceName( csn, options, csnUtils ) {
   const { addStringAnnotationTo } = csnUtils;
 
   forEachDefinition(csn, (artifact, artifactName) => {
-    addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+    if (artifact.kind === 'entity') {
+      addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
-    forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
+      forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
+    }
   });
 }
 
@@ -39,20 +41,28 @@ function killProp( parent, prop ) {
  * - includes
  * - localized
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @todo Callback-like architecture and merge with persistence name?
  */
-function _removeDefinitionsAndProperties( csn ) {
+function _removeDefinitionsAndProperties( csn, options ) {
   const killers = {
     $ignore: (a, b, c, path, parentParent) => {
       const tail = path[path.length - 1];
       delete parentParent[tail];
     },
     kind: (artifact, a, b, path) => {
-      if (artifact.kind === 'aspect' || artifact.kind === 'type')
-        delete csn.definitions[path[1]];
-
-      else if (artifact['@cds.persistence.skip'] === 'if-unused')
-        artifact['@cds.persistence.skip'] = false;
+      if (artifact.kind === 'aspect' || artifact.kind === 'type') {
+        if (artifact.elements || artifact.items || options.resolveSimpleTypes)
+          delete csn.definitions[path[1]];
+      }
+      else {
+        if (artifact.kind === 'event') {
+          delete artifact.projection;
+          delete artifact.query;
+        }
+        if (artifact['@cds.persistence.skip'] === 'if-unused')
+          artifact['@cds.persistence.skip'] = false;
+      }
     },
     // Still used in flattenStructuredElements - in db/flattening.js
     _flatElementNameWithDots: killProp,

package/lib/transform/effective/types.js

@@ -17,10 +17,11 @@ const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
  * @todo What about annotations on the type?
  * @param {CSN.Model} csn will be transformed
  * @param {object} csnUtils
+ * @param {CSN.Options} options
  * @returns {Function} Callback to resolve things (actions and their returns) later - as for them, $self would lead to unresolvable constructs at this point
  * so we can call this callback after flattening is done - then we can safely resolve their types.
  */
-function resolveTypes( csn, csnUtils ) {
+function resolveTypes( csn, csnUtils, options ) {
   const { getFinalTypeInfo } = csnUtils;
   const later = [];
   applyTransformations(csn, {
@@ -51,7 +52,7 @@ function resolveTypes( csn, csnUtils ) {
    *
    * Drill down into .elements and .items
    *
-   * @param {object} parent Object with a .type propertie
+   * @param {object} parent Object with a .type property
    */
   function resolveType( parent ) {
     // TODO: I assume there can be cases with a type ref but still having .elements already? Subelement anno?
@@ -67,7 +68,7 @@ function resolveTypes( csn, csnUtils ) {
         parent.items = cloneCsnNonDict(final.items);
       delete parent.type;
     }
-    else if (final?.type) {
+    else if (final?.type && (options.resolveSimpleTypes || parent.type.ref?.length > 1)) {
       forEachKey(final, (key) => { // copy `type` + properties (default, etc.)
         if (parent[key] === undefined || key === 'type')
           parent[key] = final[key];

package/lib/transform/forOdata.js

@@ -119,6 +119,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
+  // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
+  //   expansion do their magic including foreign key generation and annotation propagation.
+  //   Tenantenizer has to decorate the DraftAdministrativeData, so draft decoration must be done before.
+  generateDrafts(csn, options, services, messageFunctions);
+
   if (options.tenantDiscriminator)
     addTenantFields(csn, options);
 
@@ -171,9 +176,6 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // rendering which may has to publish external definitions
   expandToFinalBaseType(csn, transformers, csnUtils, services, options, error);
 
-  // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
-  //   expansion do their magic including foreign key generation and annotation propagation.
-  generateDrafts(csn, options, services, messageFunctions);
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
@@ -189,8 +191,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     const { adaptRefs, transformer: refFlattener } = flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
 
     flattening.allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options);
-
-    flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
+    flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs, inspectRef, effectiveType, csnUtils, error, options,
       { //skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
       });
@@ -199,8 +200,8 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // rewritten path expressions
     forEachDefinition(csn, (def) => {
       ['elements', 'params'].forEach(dictName => {
-        if(def[`$${dictName}`])
-          def[dictName] = def[`$${dictName}`];
+        if(def[`$flat${dictName}`])
+          def[dictName] = def[`$flat${dictName}`];
       })
       if(def.$flatAnnotations) {
         Object.entries(def.$flatAnnotations).forEach(([an, av]) => {