@sap/cds-compiler 4.0.0 → 4.1.2

package/lib/transform/db/applyTransformations.js

@@ -1,6 +1,6 @@
 'use strict';
 
-/**
+/*
  * Module for general (partial) CSN looper functions, respecting dictionaries and allowing
  * to pass custom callbacks for certain properties like "ref".
  *
@@ -10,6 +10,8 @@
  *
  * @module lib/transform/db/applyTransformations
  */
+
+
 const { setProp } = require('../../base/model');
 
 
@@ -18,11 +20,17 @@ const { setProp } = require('../../base/model');
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {applyTransformationsOptions} [options={}]
+ * @param {applyTransformationsOptions} [_options={}]
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
-function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, options, path = [] ) {
+function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, _options, path = [] ) {
+  const options = { ..._options };
+  if (!options.skipStandard)
+    options.skipStandard = { $tableConstraints: true };
+  else if (options.skipStandard.$tableConstraints === undefined)
+    options.skipStandard = { ...options.skipStandard, ...{ $tableConstraints: true } };
+
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -43,12 +51,13 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       standard( parent, name, parent[name] );
   }
   else {
-    standard(parent, prop, parent[prop]);
+    standard( parent, prop, parent[prop] );
   }
   return parent;
 
   /**
-   * Default transformer for things that are not dictionaries, like "type" or "keys".
+   * Default transformer for things that are not dictionaries or dictionary entries,
+   * such as "type" or "keys".
    * The customTransformers are applied here (and only here).
    *
    * @param {object | Array} _parent the thing that has _prop
@@ -59,7 +68,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     if (!node || typeof node !== 'object' ||
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
         (typeof _prop === 'string' && _prop.startsWith('@')) ||
-        (options.skipIgnore && node._ignore) ||
+        (options.skipIgnore && node.$ignore) ||
         options.skipStandard?.[_prop]
     )
       return;
@@ -75,13 +84,35 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
         const trans = transformers[name] || standard;
         if (customTransformers[name])
           customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
-
         trans( node, name, node[name], csnPath );
       }
     }
     csnPath.pop();
   }
 
+  /**
+   * Transformer for dictionary entries.  Similar to standard(), but does not filter
+   * based on the given name.  Otherwise, `options.skipStandards` could accidentally skip
+   * dictionary entries (e.g. entity called `@Name`).
+   *
+   * @param {object | Array} dict the thing that has _prop
+   * @param {string|number} entryName the name of the current property
+   * @param {object} node The value of node[_prop]
+   */
+  function dictEntry( dict, entryName, node ) {
+    if (!node || typeof node !== 'object' || (options.skipIgnore && node.$ignore))
+      return;
+
+    csnPath.push( entryName );
+    for (const name of Object.getOwnPropertyNames( node )) {
+      const trans = transformers[name] || standard;
+      if (customTransformers[name])
+        customTransformers[name](node, name, node[name], csnPath, dict);
+      trans( node, name, node[name], csnPath );
+    }
+    csnPath.pop();
+  }
+
   /**
    * Transformer for things that are dictionaries - like "elements".
    *
@@ -90,12 +121,12 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    * @param {object} dict The value of node[_prop]
    */
   function dictionary( node, _prop, dict ) {
-    // Allow skipping dicts like actions in forRelationalDB
-    if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
+    // Allow skipping dictionaries like actions in forRelationalDB
+    if (options.skipDict?.[_prop] || dict == null) // with universal CSN, dictionaries might be null
       return;
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict ))
-      standard( dict, name, dict[name] );
+      dictEntry( dict, name, dict[name] );
 
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
       setProp(node, `$${_prop}`, dict);
@@ -112,13 +143,9 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   function definitions( node, _prop, dict ) {
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict )) {
-      const skip = (options && options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
-                   (options && options.skipArtifact && options.skipArtifact(dict[name], name)) ||
-                   (options && options.skip && options.skip.includes(dict[name].kind)) ||
-                   false;
-      if (!skip) {
+      if (!isArtifactSkipped( dict, name )) {
         artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-        standard( dict, name, dict[name] );
+        dictEntry( dict, name, dict[name] );
       }
     }
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
@@ -126,6 +153,20 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     csnPath.pop();
   }
 
+  /**
+   * Whether the given artifact `dict[name]` is skipped via options.
+   *
+   * @param {object} dict
+   * @param {string} name
+   * @returns {boolean}
+   */
+  function isArtifactSkipped( dict, name ) {
+    return options && ((options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
+        (options.skipArtifact && options.skipArtifact(dict[name], name)) ||
+        (options.skip?.includes(dict[name].kind))) ||
+      false;
+  }
+
   /**
    * Keep looping through the pathRef - because in a .ref we can have .args and .where
    *
@@ -173,7 +214,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
   if (options.skipIgnore === undefined)
     options.skipIgnore = true;
 
-  if (csn && csn.definitions)
+  if (csn?.definitions)
     return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, options);
   return csn;
 }
@@ -230,12 +271,12 @@ module.exports = {
 
 /**
  * @typedef {object} applyTransformationsOptions
- * @property {(artifact, name) => boolean} [allowArtifact] to only allow certain artifacts
- * @property {(artifact, name) => boolean} [skipArtifact] to skip certain artifacts
+ * @property {(artifact: CSN.Artifact, name: string) => boolean} [allowArtifact] to only allow certain artifacts
+ * @property {(artifact: CSN.Artifact, name: string) => boolean} [skipArtifact] to skip certain artifacts
  * @property {boolean} [drillRef] whether to drill into infix/args
  * @property {string[]} [skip] skip definitions from certain kind
  * @property {object} [skipStandard] stop drill-down on certain "standard" props
  * @property {object} [skipDict] stop drill-down on certain "dictionary" props
- * @property {boolean} [skipIgnore=true] Whether to skip _ignore elements or not
+ * @property {boolean} [skipIgnore=true] Whether to skip $ignore elements or not
  * @property {boolean} [directDict=false] Implicitly set via applyTransformationsOnDictionary
  */

package/lib/transform/db/assertUnique.js

@@ -1,8 +1,7 @@
 'use strict';
 
 const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
-const { getTransformers } = require('../transformUtilsNew');
-const { setProp } = require('../../base/model');
+const { getTransformers } = require('../transformUtils');
 const { pathName } = require('../../compiler/utils');
 
 
@@ -97,7 +96,7 @@ function processAssertUnique( csn, options, error, info ) {
         }
         // 10) Store remaining paths (if any) in constraint dictionary
         if (flattenedPathObjects.length)
-          constraintDict[constraintName.join('.')] = flattenedPathObjects;
+          constraintDict[constraintName.join('.')] = { paths: flattenedPathObjects, parentTable: artifactName };
       }
     }
 
@@ -110,9 +109,9 @@ function processAssertUnique( csn, options, error, info ) {
     // preserve dictionary in '$tableConstraints' on the artifact for path rewriting and rendering
     if (Object.keys(constraintDict).length) {
       if (!('$tableConstraints' in artifact))
-        setProp(artifact, '$tableConstraints', Object.create(null));
+        artifact.$tableConstraints = Object.create(null);
 
-      setProp(artifact.$tableConstraints, 'unique', constraintDict);
+      artifact.$tableConstraints.unique = constraintDict;
     }
 
     /**
@@ -286,7 +285,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
       }
       for (const uniqueConstraint in artifact.$tableConstraints.unique) {
         // iterate over each constraint
-        const c = uniqueConstraints[uniqueConstraint];
+        const c = uniqueConstraints[uniqueConstraint].paths;
         const rewrittenPaths = [];
         // and inspect each path of the constraint
         c.forEach((cpath) => {
@@ -319,7 +318,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
           }
         });
         // preserve the rewritten and filtered paths for toSql
-        uniqueConstraints[uniqueConstraint] = rewrittenPaths;
+        uniqueConstraints[uniqueConstraint] = { paths: rewrittenPaths, parentTable: uniqueConstraints[uniqueConstraint].parentTable };
 
         // now add the index for HANA CDS
         if (options.transformation === 'hdbcds') {
@@ -335,7 +334,7 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
           artifact.technicalConfig.hana.indexes[uniqueConstraint] = index;
         }
       }
-      setProp(artifact.$tableConstraints, 'unique', uniqueConstraints);
+      artifact.$tableConstraints.unique = uniqueConstraints;
     }
   }
 }

package/lib/transform/db/associations.js

@@ -48,8 +48,8 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
     // Assemble an ON-condition with the foreign keys created in earlier steps
     const onCondParts = [];
     let joinWithAnd = false;
-    if (elem.keys.length === 0) { // TODO: really kill instead of _ignore?
-      elem._ignore = true;
+    if (elem.keys.length === 0) { // TODO: really kill instead of $ignore?
+      elem.$ignore = true;
     }
     else {
       for (const foreignKey of elem.keys) {

package/lib/transform/db/cdsPersistence.js

@@ -3,13 +3,13 @@
 const {
   forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtilsNew');
+const transformUtils = require('../transformUtils');
 
 const exists = '@cds.persistence.exists';
 
 /**
  * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
- * with _ignore.
+ * with $ignore.
  *
  * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
  */
@@ -24,12 +24,12 @@ function getAnnoProcessor() {
                             hasAnnotationValue(artifact, '@cds.persistence.skip') ||
                             hasAnnotationValue(artifact, exists));
     if (ignoreArtifact)
-      artifact._ignore = true;
+      artifact.$ignore = true;
   }
 }
 
 /**
- * Return a callback function for forEachDefinition that marks associations with _ignore
+ * Return a callback function for forEachDefinition that marks associations with $ignore
  * if their target does not reach the database, i.e. marked with @cds.persistence.skip or is abstract
  *
  * @param {CSN.Model} csn
@@ -72,7 +72,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
   }
 
   /**
-   * Mark the given member with _ignore if it is an association/composition and it's target is unreachable.
+   * Mark the given member with $ignore if it is an association/composition and its target is unreachable.
    *
    * @param {CSN.Element} member
    * @param {string} memberName
@@ -81,13 +81,13 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
    */
   function ignore( member, memberName, prop, path ) {
     if (options.sqlDialect === 'hana' &&
-       !member._ignore && member.target &&
+       !member.$ignore && member.target &&
        isAssocOrComposition(member) &&
        !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
            { target: member.target, anno: '@cds.persistence.skip' },
            'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
-      member._ignore = true;
+      member.$ignore = true;
     }
   }
 }
@@ -124,7 +124,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member._ignore && !member.kind && !member.type) {
+        if (!member.$ignore && !member.kind && !member.type) {
           error(null, path, { anno: '@cds.persistence.table' },
                 'Expecting element to have a type if view is annotated with $(ANNO)');
         }

package/lib/transform/db/expansion.js

@@ -274,15 +274,8 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
         return { columns, toMany: [] };
 
       for (const col of columns) {
-        if (col.expand) {
-          // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
-          const { expanded, toManys } = expandInline(root, col, col.ref || [], [ dbName(col) ]);
-
-          allToMany.push(...toManys);
-          newThing.push(...expanded);
-        }
-        else if (col.inline) {
-          const { expanded, toManys } = expandInline(root, col, col.ref || [], []);
+        if (col.expand || col.inline) {
+          const { expanded, toManys } = expandInline(root, col, col.ref || [], col.expand ? [ dbName(col) ] : []);
 
           allToMany.push(...toManys);
           newThing.push(...expanded);
@@ -335,18 +328,21 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           });
           toManys.push({ art: current, ref: currentRef, as: currentAlias.join(pathDelimiter) });
         }
-        else if (current.expand) {
-          current.expand = replaceStar(nextBase(current, base), current.expand, current.excluding);
-          for (let i = current.expand.length - 1; i >= 0; i--) {
-            const sub = current.expand[i];
-            stack.push([ nextBase(current, base), sub, sub.ref ? currentRef.concat(sub.ref) : currentRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
-          }
-        }
-        else if (current.inline) {
-          current.inline = replaceStar(nextBase(current, base), current.inline, current.excluding);
-          for (let i = current.inline.length - 1; i >= 0; i--) {
-            const sub = current.inline[i];
-            stack.push([ nextBase(current, base), sub, sub.ref ? currentRef.concat(sub.ref) : currentRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
+        else if (current.expand || current.inline) {
+          const withoutStar = replaceStar(nextBase(current, base), current.expand || current.inline, current.excluding);
+          current[current.expand ? 'expand' : 'inline'] = withoutStar;
+          for (let i = withoutStar.length - 1; i >= 0; i--) {
+            const sub = withoutStar[i];
+            let subRef;
+            if (sub.ref) {
+              // Each expand/inline can introduce another layer of $self/$projection.  Since $self is
+              // a path-breakout, we can simply use the ref without outer expand/inline-references.
+              subRef = (sub.$scope === '$self') ? sub.ref : currentRef.concat(sub.ref);
+            }
+            else {
+              subRef = currentRef;
+            }
+            stack.push([ nextBase(current, base), sub, subRef, !sub.inline ? currentAlias.concat(dbName(sub)) : currentAlias ]);
           }
         }
         else if (current.xpr || current.args) {

package/lib/transform/db/flattening.js

@@ -5,7 +5,7 @@ const {
   isBuiltinType, cloneCsnNonDict,
   copyAnnotations, implicitAs, isDeepEqual,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtilsNew');
+const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
@@ -79,24 +79,23 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
   const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
   const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
   applyTransformations(csn, {
-    cast: (parent, prop, cast, path) => {
-      // Resolve cast already - we otherwise lose .localized
-      if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
-        toFinalBaseType(parent.cast, resolved, true);
-    },
-    // @ts-ignore
-    type: (parent, prop, type, path) => {
-      if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
+    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 || e.items || e.elements)
+          return;
+      }
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved, true);
+        toFinalBaseType(node, resolved, true);
 
-        if (parent.items) // items could have unresolved types
-          toFinalBaseType(parent.items, 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.
-        let nextElements = parent.elements || parent.items?.elements;
+        let nextElements = node.elements || node.items?.elements;
         if (nextElements) {
           const stack = [ nextElements ];
           while (stack.length > 0) {
@@ -111,9 +110,9 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
           }
         }
 
-        const directLocalized = parent.localized || false;
+        const directLocalized = node.localized || false;
         if (!directLocalized && !options.toOdata)
-          removeLocalized(parent);
+          removeLocalized(node);
       }
     },
   }, [ (definitions, artifactName, artifact) => {
@@ -284,8 +283,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
     forEach(dict, (elementName, element) => {
       if (element.elements) {
         // Ignore the structured element, replace it by its flattened form
-        // TODO: use $ignore - _ is for links
-        element._ignore = true;
+        element.$ignore = true;
 
         const branches = getBranches(element, elementName, effectiveType, pathDelimiter);
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
@@ -308,6 +306,8 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
 
 
           if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
+            // unmanaged relations can't be primary key
+            delete flatElement.key;
             // Make refs resolvable by fixing the first ref step
             for (const onPart of flatElement.on) {
               if (onPart.ref) {
@@ -441,6 +441,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
    * @param {*} path
    */
   function flattenFKs( assoc, assocName, path ) {
+    // TODO Depth first search and not iterate mark and sweep approach
     let finished = false;
     while (!finished) {
       const newKeys = [];
@@ -465,8 +466,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         const { ref } = assoc.keys[i];
         if (isStructured(art)) {
           done = false;
-          // Mark this element to filter it later - not needed after expansion
-          setProp(assoc.keys[i], '$toDelete', true);
           const flat = flattenStructuredElement(art, ref[ref.length - 1], [], pathToKey);
           Object.keys(flat).forEach((flatElemName) => {
             const key = assoc.keys[i];
@@ -502,12 +501,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
         }
         else if (art.target) {
           done = false;
-          // Mark this element to filter it later - not needed after expansion
-          setProp(assoc.keys[i], '$toDelete', true);
           // Directly work on csn.definitions - this way the changes take effect in csnRefs/inspectRef immediately
           // Add the newly generated foreign keys to the end - they will be picked up later on
           // Recursive solutions run into call stack issues
-          art.keys.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i], ref)));
+          art.keys?.forEach(key => collector.push(cloneAndExtendRef(key, assoc.keys[i], ref)));
         }
         else if (assoc.keys[i].ref && !assoc.keys[i].as) {
           setProp(assoc.keys[i], inferredAlias, true);
@@ -523,7 +520,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
       }
       return done;
     }
-    assoc.keys = assoc.keys.filter(o => !o.$toDelete);
 
     /**
      * Clone base and extend the .ref and .as of the clone with the .ref and .as of ref.
@@ -612,6 +608,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, war
           return acc;
         }, Object.create(null));
 
+        // set default for single foreign key from association (if available)
+        if (element.default?.val !== undefined && fks.length === 1)
+          fks[0][1].default = element.default;
+
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
           if (occ > 1)

package/lib/transform/db/rewriteCalculatedElements.js

@@ -3,12 +3,16 @@
 const { setProp } = require('../../base/model');
 const { CompilerAssertion } = require('../../base/error');
 const {
-  forEachDefinition, applyTransformationsOnNonDictionary, applyTransformationsOnDictionary, implicitAs, cloneCsnNonDict, getUtils,
+  forEachDefinition,
+  applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
+  implicitAs,
+  cloneCsnNonDict,
   forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
 const { getColumnMap } = require('./views');
-const { checkForeignKeyAccess } = require('../../checks/onConditions');
+const { requireForeignKeyAccess } = require('../../checks/onConditions');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
 
@@ -19,11 +23,13 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} csnUtils
  * @param {string} pathDelimiter
- * @param {Function} error
+ * @param {object} messageFunctions
  */
-function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error ) {
-  const { inspectRef, effectiveType } = getUtils(csn, 'init-all');
+function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, messageFunctions ) {
+  const { inspectRef, effectiveType } = csnUtils;
+  const { error } = messageFunctions;
 
   const views = [];
   const entities = [];
@@ -121,7 +127,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         }
         else {
           // It's a managed association - access of the foreign keys is allowed
-          checkForeignKeyAccess(parent, i, csnPath, (errorIndex) => {
+          requireForeignKeyAccess(parent, i, (errorIndex) => {
             error('ref-unexpected-navigation', csnPath, {
               '#': 'calc-non-fk', id, elemref: parent, name: value[errorIndex].id || value[errorIndex],
             });
@@ -412,7 +418,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    * @param {CSN.QuerySelect} SELECT
    * @returns {object}
    */
-  function getDirectlyAdressableElements( SELECT ) {
+  function getDirectlyAddressableElements( SELECT ) {
     const { from } = SELECT;
     if (from.ref) {
       return from._art.elements;
@@ -422,7 +428,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
     }
     else if (from.SET) {
       // args[0] could be SELECT or UNION
-      return getDirectlyAdressableElements({ from: from.SET.args[0] });
+      return getDirectlyAddressableElements({ from: from.SET.args[0] });
     }
     else if (from.args) {
       const mergedElements = Object.create(null);
@@ -432,7 +438,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
             mergedElements[elementName] = arg._art.elements[elementName];
         }
         else if (arg.SET) {
-          return getDirectlyAdressableElements({ from: arg.SET.args[0] });
+          return getDirectlyAddressableElements({ from: arg.SET.args[0] });
         }
         else if (arg.SELECT) { // TODO: UNION
           for (const elementName in arg.SELECT.elements)
@@ -440,7 +446,7 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
         }
         else if (arg.args) { // TODO: Is it safe to do recursion here?
           for (const subarg of arg.args) {
-            const elements = getDirectlyAdressableElements({ from: subarg });
+            const elements = getDirectlyAddressableElements({ from: subarg });
             for (const elementName in elements)
               mergedElements[elementName] = elements[elementName];
           }
@@ -465,8 +471,8 @@ function rewriteCalculatedElementsInViews( csn, options, pathDelimiter, error )
    */
   function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
     const cleanupCallbacks = [];
-    const root = getDirectlyAdressableElements(SELECT);
-    const columnMap = getColumnMap( { SELECT });
+    const root = getDirectlyAddressableElements(SELECT);
+    const columnMap = getColumnMap( { SELECT }, csnUtils );
     const hasStar = SELECT.columns.includes('*');
     const unfoldingMap = {};
     let starContainsCalculated = false;
@@ -699,9 +705,9 @@ function processCalculatedElementsInEntities( csn ) {
  */
 function removeDummyValueInEntity( artifact, path ) {
   applyTransformationsOnDictionary(artifact.elements, {
-    value: (parent, prop, value, p, root) => {
+    value: (parent, prop, value, p, elements) => {
       if (!value.stored)
-        delete root[p[p.length - 1]];
+        delete elements[p[p.length - 1]];
     },
   }, {}, path.concat( 'elements' ));
 }

package/lib/transform/db/temporal.js

@@ -5,7 +5,7 @@ const {
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
-const { getTransformers } = require('../transformUtilsNew');
+const { getTransformers } = require('../transformUtils');
 
 const validToString = '@cds.valid.to';
 const validFromString = '@cds.valid.from';

package/lib/transform/db/transformExists.js

@@ -53,22 +53,23 @@ const { ModelError } = require('../../base/error');
 function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
+    // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
+    // thinks that the artifact was already initialized (including all queries).
+    dropDefinitionCache(artifact);
     if (artifact.projection) // do the same hack we do for the other stuff...
       artifact.query = { SELECT: artifact.projection };
 
     if (artifact.query) {
-      forAllQueries(artifact.query, (query, path) => {
+      forAllQueries(artifact.query, function handleExistsQuery(query, path) {
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
-          if (query.SELECT && query.SELECT.where && query.SELECT.where.length > 1)
+          if (query.SELECT?.where?.length > 1)
             toProcess.push([ path.slice(0, -1), path.concat('where') ]);
 
-
-          if (query.SELECT && query.SELECT.columns)
+          if (query.SELECT?.columns)
             toProcess.push([ path.slice(0, -1), path.concat('columns') ]);
 
-
-          if (query.SELECT && query.SELECT.from.on )
+          if (query.SELECT?.from.on)
             toProcess.push([ path.slice(0, -1), path.concat([ 'from', 'on' ]) ]);
 
           for (const [ , exprPath ] of toProcess) {
@@ -268,7 +269,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
 
         const { links } = inspectRef(exprPath.concat(i));
 
-        const assocs = links.filter(link => link.art && link.art.target).map(link => current.ref[link.idx]);
+        const assocs = links.filter(link => link.art?.target).map(link => current.ref[link.idx]);
 
         checkForInvalidAssoc(assocs);
       }