@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/render/toHdbcds.js

@@ -2,10 +2,11 @@
 
 const {
   getLastPartOf, getLastPartOfRef,
-  hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
+  hasValidSkipOrExists, generatedByCompilerVersion, getNormalizedQuery,
   getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement, hasAnnotationValue,
-  pathName, isMagicVariable,
+  pathName,
 } = require('../model/csnUtils');
+const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const keywords = require('../base/keywords');
 const {
   renderFunc, createExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
@@ -315,49 +316,6 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     return false;
   }
 
-  /* FIXME: Not yet required
-  // Returns the artifact or element that constitutes the final type of
-  // construct 'node', i.e. the object in which we would find type properties for
-  // 'node'. Note that this may well be 'node' itself.
-  function getFinalTypeOf(node) {
-    if (node && node.type) {
-      if (isBuiltinType(node.type)) {
-        return node;
-      }
-      return getFinalTypeOf(node.type);
-    }
-    return node;
-  }
-
-  // Resolve path array 'ref' against artifact 'base' (or against 'csn.definitions'
-  // if no 'base' given).
-  // Return the resulting artifact or element (or 'undefined' if not found).
-  function resolveRef(ref, base) {
-    let result = base;
-    for (let i = 0; i < ref.length; i++) {
-      let pathStep = ref[i].id || ref[i];
-      // Only first path step may be looked up in 'definitions'
-      if (i === 0 && !base) {
-        result = csn.definitions[pathStep];
-        continue;
-      }
-      // Structured type
-      else if (result && result.elements) {
-        result = getFinalTypeOf(result.elements[pathStep]);
-      }
-      // Association
-      else if (result && result.target) {
-        result = resolveRef([pathStep], csn.definitions[result.target]);
-      }
-      // Not resolvable
-      else {
-        return undefined;
-      }
-    }
-    return result;
-  }
-*/
-
   /**
    * Render a context or service. Return the resulting source string.
    *
@@ -1155,9 +1113,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    */
   function renderAssociationType( elm, env ) {
     // Type, cardinality and target
-    let result = 'association';
-
-    result += `${renderCardinality(elm.cardinality)} to `;
+    let result = `association${renderCardinality(elm.cardinality)} to `;
 
     // normal target or named aspect
     if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {

package/lib/render/toSql.js

@@ -3,10 +3,11 @@
 
 const {
   getLastPartOf, getLastPartOfRef,
-  hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
+  hasValidSkipOrExists, generatedByCompilerVersion, getNormalizedQuery,
   forEachDefinition, getResultingName,
-  getVariableReplacement, isMagicVariable, pathName,
+  getVariableReplacement, pathName,
 } = require('../model/csnUtils');
+const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
 const {
   renderFunc, cdsToSqlTypes, getHanaComment, hasHanaComment,
@@ -740,7 +741,9 @@ function toSqlDdl( csn, options, messageFunctions ) {
     let result = `${env.indent + quotedElementName}${isPostgresAlterColumn ? ' TYPE' : ''} ${renderTypeReference(elm, env)
     }${renderNullability(elm, true, env.alterMode)}`;
     // calculated elements (on write) can't have a default; ignore it
-    if (elm.default && !elm.value)
+    if (elm.$default && env.alterMode && !elm.value && options.sqlDialect !== 'postgres')
+      result += ` DEFAULT ${renderExpr(elm.$default, env.withSubPath([ '$default' ]))}`;
+    else if (elm.default && !elm.value)
       result += ` DEFAULT ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
 
     // Only SAP HANA has fuzzy indices

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');
 
 
 /**
@@ -344,7 +344,40 @@ function transformExpression( parent, propName, transformers, path = [] ) {
   return parent;
 }
 
+/**
+ * Merge an array of transformer-objects into a single one, set the this-value of every subfunction to "that"
+ *
+ * @param {object[]} transformers transformers
+ * @param {object} that Value for this
+ * @returns {object} Remapped transformers.
+ */
+function mergeTransformers( transformers, that ) {
+  const remapped = {};
+  for (const transformer of transformers) {
+    for (const [ n, fns ] of Object.entries(transformer)) {
+      if (!remapped[n])
+        remapped[n] = [];
+
+      if (Array.isArray(fns)) {
+        remapped[n].push((parent, name, prop, path, parentParent) => fns.forEach(
+          fn => fn.bind(that)(parent, name, prop, path, parentParent)
+        ));
+      }
+      else {
+        remapped[n].push((parent, name, prop, path, parentParent) => fns.bind(that)(parent, name, prop, path, parentParent));
+      }
+    }
+  }
+
+  for (const [ n, fns ] of Object.entries(remapped))
+    remapped[n] = (parent, name, prop, path, parentParent) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path, parentParent));
+
+
+  return remapped;
+}
+
 module.exports = {
+  mergeTransformers,
   transformExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,

package/lib/transform/db/constraints.js

@@ -116,7 +116,7 @@ function createReferentialConstraints( csn, options ) {
         foreignKeyConstraintForAssociation(up_, dependent, [ 'definitions', composition.target, 'elements', upLinkName ], path[path.length - 1] );
     }
     else if (!onCondition && composition.keys.length > 0) {
-      throw new CompilerAssertion('Please debug me, an on-condition was expected here, but only found keys');
+      throw new CompilerAssertion('Debug me, an on-condition was expected here, but only found keys');
     }
   }
 

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
@@ -95,7 +98,9 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           */
           if (rewritten.toMany.length > 0 && !options.toOdata) {
             markAsToDummify(artifact, path[1]);
-            error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME)');
+            rewritten.toMany.forEach(({ art }) => {
+              error( null, art.$path || [ 'definitions', path[1] ], { name: `${art.$env || path[1]}:${art.ref.map(r => r.id || r)}` }, 'Unexpected .expand with to-many association $(NAME)');
+            });
           }
           else {
             parent.columns = rewritten.columns;
@@ -172,8 +177,11 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           const target = art.target ? art.target : pathStep;
           if (toDummify.indexOf(target) !== -1) {
             error( null, obj.$path, {
-              id: pathStep, elemref: obj, name,
-            }, 'Unexpected “@cds.persistence.skip” annotation on Association target $(NAME) of $(ID) in path $(ELEMREF) was skipped because of .expand in conjunction with to-many');
+              id: pathStep,
+              elemref: obj,
+              name,
+              anno: '@cds.persistence.skip',
+            }, 'Unexpected $(ANNO) annotation on Association target $(NAME) of $(ID) in path $(ELEMREF) was skipped because of .expand in conjunction with to-many');
           }
         }
 

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/groupByOrderBy.js

@@ -28,8 +28,8 @@ function replaceAssociationsInGroupByOrderBy( inputQuery, options, inspectRef, e
             // (230 c) If we keep associations as they are (hdbcds naming convention), we can't have associations in GROUP BY
             if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
               error(null, groupByPath,
-                    { $reviewed: true },
-                    'Unexpected managed association in GROUP BY for naming mode “hdbcds”');
+                    { $reviewed: true, keyword: 'GROUP BY', value: 'hdbcds' },
+                    'Unexpected managed association in $(KEYWORD) for naming mode $(VALUE)');
               continue;
             }
             const pathPrefix = query.groupBy[i].ref.slice(0, -1);

package/lib/transform/db/temporal.js

@@ -4,7 +4,7 @@ const {
   getNormalizedQuery, hasAnnotationValue, forEachMember,
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 
 const validToString = '@cds.valid.to';
@@ -21,9 +21,10 @@ const validFromString = '@cds.valid.from';
  * @param {object} messageFunctions
  * @param {Function} messageFunctions.info
  * @param {object} csnUtils
+ * @param {object} options
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition applying the where-condition to views.
  */
-function getViewDecorator( csn, messageFunctions, csnUtils ) {
+function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
   const { info } = messageFunctions;
   const { get$combined } = csnUtils;
   return addTemporalWhereConditionToView;
@@ -52,7 +53,9 @@ function getViewDecorator( csn, messageFunctions, csnUtils ) {
       if (from.length === 1 && to.length === 1) {
         // and both are from the same origin
         if (from[0].source === to[0].source && from[0].parent === to[0].parent) {
-          if (!hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0])) {
+          const omitWhereClause = isBetaEnabled(options, 'temporalRawProjection') &&
+            hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0]);
+          if (!omitWhereClause) {
             const fromPath = {
               ref: [
                 from[0].parent,