@sap/cds-compiler 3.5.4 → 3.6.2

package/lib/render/toHdbcds.js

@@ -47,14 +47,7 @@ function renderStringForHdbcds( str ) {
 }
 
 /**
- * Render the CSN model 'model' to CDS source text. One source is created per
- * top-level artifact. Return a dictionary of top-level artifacts
- * by their names, like this:
- * { "foo" : "using XY; context foo {...};",
- *   "bar::wiz" : "namespace bar::; entity wiz {...};"
- * }
- *
- * FIXME: This comment no longer tells the whole truth
+ * Render the CSN model 'model' to CDS source text.
  *
  * @param {CSN.Model} csn HANA transformed CSN
  * @param {CSN.Options} [options] Transformation options
@@ -141,12 +134,11 @@ function toHdbcdsSource( csn, options ) {
   const hdbconstraint = Object.create(null);
   forEachDefinition(csn, (art) => {
     if (art.$tableConstraints && art.$tableConstraints.referential) {
-      const renderToUppercase = plainNames;
       const referentialConstraints = {};
       Object.entries(art.$tableConstraints.referential)
         .forEach(([ fileName, referentialConstraint ]) => {
           referentialConstraints[fileName] = renderReferentialConstraint(
-            referentialConstraint, increaseIndent(createEnv()).indent, renderToUppercase, csn, options
+            referentialConstraint, increaseIndent(createEnv()).indent, false, csn, options
           );
         });
       Object.entries(referentialConstraints)
@@ -176,8 +168,8 @@ function toHdbcdsSource( csn, options ) {
   function sort( obj ) {
     const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
     const sortedResult = Object.create(null);
-    for (let i = 0; i < keys.length; i++)
-      sortedResult[keys[i]] = obj[keys[i]];
+    for (const key of keys)
+      sortedResult[key] = obj[key];
 
     return sortedResult;
   }
@@ -191,7 +183,7 @@ function toHdbcdsSource( csn, options ) {
    * @returns {string} The rendered artifact
    */
   function renderArtifact( artifactName, art, env ) {
-    // FIXME: Correctly build the paths during runtime to give better locations
+    // We're always a top-level artifact.
     env.path = [ 'definitions', artifactName ];
     // Ignore whole artifacts if toHana says so
     if (art.abstract || hasValidSkipOrExists(art))
@@ -691,8 +683,10 @@ function toHdbcdsSource( csn, options ) {
     if (path.ref[0].args)
       result += `(${renderArgs(path.ref[0], ':', env)})`;
 
-    if (path.ref[0].where)
-      result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env)}]`;
+    if (path.ref[0].where) {
+      const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
+      result += `[${cardinality}${renderExpr(path.ref[0].where, env)}]`;
+    }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
@@ -959,8 +953,10 @@ function toHdbcdsSource( csn, options ) {
     if (limit.rows !== undefined)
       result += `limit ${renderExpr(limit.rows, env)}`;
 
-    if (limit.offset !== undefined)
-      result += `${result !== '' ? `\n${increaseIndent(env).indent}` : ''}offset ${renderExpr(limit.offset, env)}`;
+    if (limit.offset !== undefined) {
+      const indent = result !== '' ? `\n${increaseIndent(env).indent}` : '';
+      result += `${indent}offset ${renderExpr(limit.offset, env)}`;
+    }
 
     return result;
   }
@@ -1214,7 +1210,8 @@ function toHdbcdsSource( csn, options ) {
       }
       if (s.where) {
         // Filter, possibly with cardinality
-        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env)}]`;
+        const cardinality = s.cardinality ? `${s.cardinality.max}: ` : '';
+        result += `[${cardinality}${renderExpr(s.where, env)}]`;
       }
       return result;
     }
@@ -1371,7 +1368,8 @@ function toHdbcdsSource( csn, options ) {
    * @returns {string} Rendered foreign key
    */
   function renderForeignKey( fKey, env ) {
-    return `${renderExpr(fKey, env)}${fKey.as ? (` as ${fKey.as}`) : ''}`;
+    const alias = fKey.as ? (` as ${formatIdentifier(fKey.as)}`) : '';
+    return `${renderExpr(fKey, env)}${alias}`;
   }
 
   /**
@@ -1585,7 +1583,7 @@ function toHdbcdsSource( csn, options ) {
       return '';
     }
     // The top-level artifact's parent would be the namespace (if any)
-    const namespace = getNamespace(csn, topLevelName) || '';
+    const namespace = getNamespace(csn, topLevelName);
     if (namespace)
       return `${env.indent}namespace ${quotePathString(namespace)};\n`;
 
@@ -1720,8 +1718,10 @@ function toHdbcdsSource( csn, options ) {
 
     if (hdbcdsNames) {
       const namespace = getNamespace(csn, absName);
-      if (namespace)
-        return `"${(`${namespace}::${resultingName.substring(namespace.length + 2)}`).replace(/"/g, '""')}"`;
+      if (namespace) {
+        const id = `${namespace}::${resultingName.substring(namespace.length + 2)}`;
+        return `"${id.replace(/"/g, '""')}"`;
+      }
     }
     return `"${resultingName.replace(/"/g, '""')}"`;
   }

package/lib/render/toRename.js

@@ -3,7 +3,7 @@
 
 const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { getUtils, forEachDefinition } = require('../model/csnUtils');
+const { getNamespace, forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
 const { isBetaEnabled } = require('../base/model');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
@@ -34,7 +34,7 @@ function toRename( inputCsn, options ) {
   const { error, warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
 
   // Merge options with defaults.
-  options = Object.assign({ sqlMapping: 'hdbcds' }, options);
+  options = Object.assign({ sqlMapping: 'hdbcds', sqlDialect: 'hana' }, options);
 
   // Verify options
   optionProcessor.verifyOptions(options, 'toRename').forEach(complaint => warning(null, null, `${complaint}`));
@@ -53,7 +53,6 @@ function toRename( inputCsn, options ) {
   });
 
   const result = Object.create(null);
-  const { getNamespaceOfArtifact } = getUtils(csn, false);
 
   // Render each artifact on its own
   for (const artifactName in csn.definitions) {
@@ -122,7 +121,7 @@ function toRename( inputCsn, options ) {
     if (options.sqlMapping !== 'hdbcds')
       return name;
 
-    const namespaceName = getNamespaceOfArtifact(name);
+    const namespaceName = getNamespace(inputCsn, name);
     if (namespaceName)
       return `${namespaceName}::${name.substring(namespaceName.length + 1)}`;
 

package/lib/render/toSql.js

@@ -6,6 +6,7 @@ const {
   hasValidSkipOrExists, isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
   forEachDefinition, getResultingName, getVariableReplacement,
 } = require('../model/csnUtils');
+const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
 const {
   renderFunc, cdsToSqlTypes, getHanaComment, hasHanaComment,
   getSqlSnippets, createExpressionRenderer, withoutCast,
@@ -24,7 +25,7 @@ const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
 const { sortCsn } = require('../json/to-csn');
 const { manageConstraints } = require('./manageConstraints');
-const { ModelError } = require('../base/error');
+const { ModelError, CompilerAssertion } = require('../base/error');
 
 
 /**
@@ -135,7 +136,7 @@ function toSqlDdl( csn, options ) {
 
   // FIXME: Currently requires 'options.forHana', because it can only render HANA-ish SQL dialect
   if (!options.forHana && !isBetaEnabled(options, 'sqlExtensions'))
-    throw new Error('toSql can currently only be used with HANA preprocessing');
+    throw new CompilerAssertion('toSql can currently only be used with HANA preprocessing');
 
   checkCSNVersion(csn, options);
 
@@ -229,7 +230,7 @@ function toSqlDdl( csn, options ) {
           sourceString = sourceString.slice('COLUMN '.length);
         sql[name] = `${options.testMode ? '' : sqlVersionLine}CREATE ${sourceString};`;
       }
-      else if (!options.testMode) {
+      else if (!options.testMode && options.generatedByComment) {
         mainResultObj[hdbKind][name] = sqlVersionLine + mainResultObj[hdbKind][name];
       }
     }
@@ -237,12 +238,14 @@ function toSqlDdl( csn, options ) {
       delete mainResultObj[hdbKind];
   }
 
-  // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana`
-  if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres')) {
+  // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana` / `postgres`
+  // TODO `ALTER TABLE ADD CONSTRAINT` statements also for sqlite constraints
+  if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres' /* || options.sqlDialect === 'sqlite' */)) {
     const alterStmts = manageConstraints(csn, options);
 
-    for ( const constraintName of Object.keys(alterStmts))
+    forEachKey(alterStmts, (constraintName) => {
       sql[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+    });
     mainResultObj.sql = sql;
   }
 
@@ -250,7 +253,7 @@ function toSqlDdl( csn, options ) {
     mainResultObj.sql = sql;
 
   for (const name in deletions)
-    deletions[name] = `${options.testMode ? '' : sqlVersionLine}${deletions[name]}`;
+    deletions[name] = `${options.testMode || !options.generatedByComment ? '' : sqlVersionLine}${deletions[name]}`;
 
   timetrace.stop('SQL rendering');
   return mainResultObj;
@@ -506,17 +509,16 @@ function toSqlDdl( csn, options ) {
     if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.src === 'hdi';
       const referentialConstraints = {};
-      Object.entries(art.$tableConstraints.referential)
-        .forEach(([ fileName, referentialConstraint ]) => {
-          referentialConstraints[fileName] = renderReferentialConstraint(referentialConstraint, childEnv.indent, false, csn, options);
-        });
+      forEach(art.$tableConstraints.referential, ( fileName, referentialConstraint ) => {
+        referentialConstraints[fileName] = renderReferentialConstraint(referentialConstraint, childEnv.indent, false, csn, options);
+      });
       if (renderReferentialConstraintsAsHdbconstraint) {
-        Object.entries(referentialConstraints).forEach(([ fileName, constraint ]) => {
+        forEach(referentialConstraints, (fileName, constraint ) => {
           resultObj.hdbconstraint[fileName] = constraint;
         });
       }
       else {
-        Object.values(referentialConstraints).forEach((constraint) => {
+        forEachValue(referentialConstraints, (constraint) => {
           result += `,\n${constraint}`;
         });
       }
@@ -527,12 +529,14 @@ function toSqlDdl( csn, options ) {
     const uniqueConstraints = art.$tableConstraints && art.$tableConstraints.unique;
     for (const cn in uniqueConstraints) {
       const c = uniqueConstraints[cn];
+      const cnName = renderArtifactName(`${artifactName}_${cn}`);
+      const refs = c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ');
       if (options.src === 'hdi') {
         resultObj.hdbindex[`${artifactName}.${cn}`]
-          = `UNIQUE INVERTED INDEX ${renderArtifactName(`${artifactName}_${cn}`)} ON ${tableName} (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
+          = `UNIQUE INVERTED INDEX ${cnName} ON ${tableName} (${refs})`;
       }
       else {
-        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
+        result += `,\n${childEnv.indent}CONSTRAINT ${cnName} UNIQUE (${refs})`;
       }
     }
     result += `${env.indent}\n)`;
@@ -962,8 +966,10 @@ function toSqlDdl( csn, options ) {
       // CV without parameters is called as simple view
       result += '()';
     }
-    if (path.ref[0].where)
-      result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env)}]`;
+    if (path.ref[0].where) {
+      const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
+      result += `[${cardinality}${renderExpr(path.ref[0].where, env)}]`;
+    }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
@@ -1193,10 +1199,10 @@ function toSqlDdl( csn, options ) {
   }
 
   /**
-   * Render a query's LIMIT clause, which may have also have OFFSET.
+   * Render a query's LIMIT clause, which may also have OFFSET.
    *
    * @param {CSN.QueryLimit} limit Limit clause
-   * @param {object} env Renderenvironment
+   * @param {object} env Render environment
    * @returns {string} Rendered LIMIT clause
    */
   function renderLimit( limit, env ) {
@@ -1204,8 +1210,10 @@ function toSqlDdl( csn, options ) {
     if (limit.rows !== undefined)
       result += `LIMIT ${renderExpr(limit.rows, env)}`;
 
-    if (limit.offset !== undefined)
-      result += `${result !== '' ? `\n${env.indent}` : ''}OFFSET ${renderExpr(limit.offset, env)}`;
+    if (limit.offset !== undefined) {
+      const indent = result !== '' ? `\n${env.indent}` : '';
+      result += `${indent}OFFSET ${renderExpr(limit.offset, env)}`;
+    }
 
     return result;
   }
@@ -1547,7 +1555,8 @@ function toSqlDdl( csn, options ) {
         if (s.where) {
           // Filter, possibly with cardinality
           // FIXME: Does SQL understand filter cardinalities?
-          result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env)}]`;
+          const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+          result += `[${cardinality}${renderExpr(s.where, env)}]`;
         }
         return result;
       }

package/lib/render/utils/delta.js

@@ -162,7 +162,9 @@ class DeltaRendererPostgres extends DeltaRenderer {
    * @todo tableName is escaped - we cannot simply add _pkey
    */
   dropKey(artifactName) {
-    return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} DROP CONSTRAINT ${this.scopedFunctions.renderArtifactName(`${artifactName}_pkey`)};` ];
+    const table = this.scopedFunctions.renderArtifactName(artifactName);
+    const pkey = this.scopedFunctions.renderArtifactName(`${artifactName}_pkey`);
+    return [ `ALTER TABLE ${table} DROP CONSTRAINT ${pkey};` ];
   }
 
   /**

package/lib/render/utils/sql.js

@@ -19,18 +19,7 @@ const { ModelError } = require('../../base/error');
  * @returns {string} SQL statement which can be used to create the referential constraint on the db.
  */
 function renderReferentialConstraint( constraint, indent, toUpperCase, csn, options, alterConstraint = false ) {
-  let quoteId;
-  // for to.hana we can't utilize the sql identifier utils
-  if (options.transformation === 'hdbcds') {
-    quoteId = (id) => {
-      if (options.sqlMapping === 'plain')
-        return id.replace(/\./g, '_');
-      return `"${id}"`;
-    };
-  }
-  else {
-    quoteId = getIdentifierUtils(csn, options).quoteSqlId;
-  }
+  const quoteId = getIdentifierUtils(csn, options).quoteSqlId;
   if (toUpperCase) {
     constraint.identifier = constraint.identifier.toUpperCase();
     constraint.foreignKey = constraint.foreignKey.map(fk => fk.toUpperCase());
@@ -40,8 +29,7 @@ function renderReferentialConstraint( constraint, indent, toUpperCase, csn, opti
   }
 
   const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
-                                options.src === 'hdi' ||
-                                (options.manageConstraints && options.manageConstraints.src === 'hdi');
+                                options.src === 'hdi';
 
   const { sqlMapping, sqlDialect } = options;
   let result = '';

package/lib/transform/db/associations.js

@@ -3,22 +3,21 @@
 const {
   applyTransformationsOnNonDictionary,
   applyTransformations,
-  getUtils,
 } = require('../../model/csnUtils');
 
-
 /**
  * In all .elements of entities and views (and their bound actions/functions), create the on-condition for
  * a managed associations. This needs to happen after the .keys are expanded and the corresponding elements are created.
  *
  * @param {CSN.Model} csn
+ * @param {object} csnUtils
  * @param {string} pathDelimiter
  * @returns {CSN.Model} Return the input csn, with the transformations applied
  */
-function attachOnConditions( csn, pathDelimiter ) {
+function attachOnConditions( csn, csnUtils, pathDelimiter ) {
   const {
     isManagedAssociation,
-  } = getUtils(csn);
+  } = csnUtils;
 
   const alreadyHandled = new WeakMap();
   applyTransformations(csn, {
@@ -104,13 +103,14 @@ function attachOnConditions( csn, pathDelimiter ) {
 
 /**
  * @param {CSN.Model} csn
+ * @param {object} csnUtils
  * @param {string} pathDelimiter
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getFKAccessFinalizer( csn, pathDelimiter ) {
+function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
   const {
     inspectRef,
-  } = getUtils(csn);
+  } = csnUtils;
 
   return handleManagedAssocSteps;
 

package/lib/transform/db/cdsPersistence.js

@@ -2,7 +2,6 @@
 
 const {
   forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
-  getUtils,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtilsNew');
 
@@ -37,13 +36,14 @@ function getAnnoProcessor() {
  * @param {CSN.Options} options
  * @param {object} messageFunctions
  * @param {Function} messageFunctions.info
+ * @param {object} csnUtils
  * @returns {(artifact: CSN.Artifact, artifactName: string, prop: string, path: CSN.Path) => void} Callback function for forEachDefinition
  */
-function getAssocToSkippedIgnorer( csn, options, messageFunctions ) {
+function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
   const { info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 
-  const { isAssocOrComposition } = getUtils(csn);
+  const { isAssocOrComposition } = csnUtils;
 
   return ignoreAssociationToSkippedTarget;
   /**

package/lib/transform/db/constraints.js

@@ -4,6 +4,7 @@ const { forEachDefinition } = require('../../base/model');
 const { applyTransformations, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { forEach, forEachKey } = require('../../utils/objectUtils');
+const { CompilerAssertion } = require('../../base/error');
 
 const COMPOSITION = 'cds.Composition';
 const ASSOCIATION = 'cds.Association';
@@ -90,7 +91,7 @@ function createReferentialConstraints( csn, options ) {
         foreignKeyConstraintForAssociation(up_, [ 'definitions', composition.target, 'elements', upLinkName ], path[path.length - 1]);
     }
     else if (!onCondition && composition.keys.length > 0) {
-      throw new Error('Please debug me, an on-condition was expected here, but only found keys');
+      throw new CompilerAssertion('Please debug me, an on-condition was expected here, but only found keys');
     }
   }
 
@@ -120,7 +121,7 @@ function createReferentialConstraints( csn, options ) {
         attachConstraintsToDependentKeys(dependentKeys, parentKeys, association.target, path[path.length - 1], upLinkFor);
     }
     else if (!onCondition && association.keys.length > 0) {
-      throw new Error('Please debug me, an on-condition was expected here, but only found keys');
+      throw new CompilerAssertion('Please debug me, an on-condition was expected here, but only found keys');
     }
   }
 
@@ -377,12 +378,9 @@ function createReferentialConstraints( csn, options ) {
      * @returns {boolean}
      */
     function assertForIntegrityTypeDB() {
-      if (isAssertIntegrityAnnotationSetTo(RT))
-        return true;
-      return false;
+      return isAssertIntegrityAnnotationSetTo(RT);
     }
 
-
     /**
      * convenience to check if value of element's @assert.integrity annotation
      * is the same as a given value

package/lib/transform/db/expansion.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  hasAnnotationValue, getUtils,
+  hasAnnotationValue,
   applyTransformations,
   setDependencies,
   walkCsnPath,
@@ -21,10 +21,10 @@ const { forEach } = require('../../utils/objectUtils');
  * @param {Function} messageFunctions.error
  * @param {Function} messageFunctions.info
  * @param {Function} messageFunctions.throwWithAnyError
- * @param {object} iterateOptions
+ * @param {object} csnUtils
+ * @param {object} [iterateOptions]
  */
-function expandStructureReferences( csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {} ) {
-  const csnUtils = getUtils(csn);
+function expandStructureReferences( csn, options, pathDelimiter, { error, info, throwWithAnyError }, csnUtils, iterateOptions = {} ) {
   const {
     isStructured, get$combined, getFinalBaseTypeWithProps,
   } = csnUtils;

package/lib/transform/db/flattening.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const {
-  getUtils,
   applyTransformations, applyTransformationsOnNonDictionary,
   isBuiltinType, cloneCsnNonDict,
   copyAnnotations, implicitAs, isDeepEqual,
@@ -409,10 +408,11 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
  * @param {Function} error
  * @param {string} pathDelimiter
  * @param {boolean} flattenKeyRefs
+ * @param {object} csnUtils
  * @param {object} iterateOptions
  */
-function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pathDelimiter, flattenKeyRefs, iterateOptions = {} ) {
-  const { isManagedAssociation, inspectRef, isStructured } = getUtils(csn);
+function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
+  const { isManagedAssociation, inspectRef, isStructured } = csnUtils;
   const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
   if (flattenKeyRefs) {
     applyTransformations(csn, {
@@ -595,7 +595,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pat
       Object.entries(dict).forEach(([ elementName, element ]) => {
         orderedElements.push([ elementName, element ]);
         const eltPath = path.concat(prop, elementName);
-        const fks = createForeignKeys(eltPath, element, elementName, csn, options, pathDelimiter);
+        const fks = createForeignKeys(csnUtils, eltPath, element, elementName, csn, options, pathDelimiter);
 
         // finalize the generated foreign keys
         const refCount = fks.reduce((acc, fk) => {
@@ -662,6 +662,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pat
  *
  * If element is not a managed association, an empty array is returned
  *
+ * @param {object} csnUtils
  * @param {Array|object} path CSN path pointing to element or the result of a previous call to inspectRef
  * @param {CSN.Element} element
  * @param {string} prefix Element name
@@ -671,12 +672,8 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, pat
  * @param {number} lvl
  * @returns {Array[]} First element of every sub-array is the foreign key name, second is the foreign key definition
  */
-function createForeignKeys( path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
-  const {
-    effectiveType,
-    inspectRef,
-  } = getUtils(csn);
-
+function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
+  const special$self = !csn?.definitions?.$self && '$self';
   const isInspectRefResult = !Array.isArray(path);
 
   let fks = [];
@@ -686,8 +683,8 @@ function createForeignKeys( path, element, prefix, csn, options, pathDelimiter,
   let finalElement = element;
   let finalTypeName; // TODO: Find a way to not rely on $path?
   // TODO: effectiveType's return value is 'path' for the next inspectRef
-  if (element.type && !isBuiltinType(element.type)) {
-    const tmpElt = effectiveType(element);
+  if (element.type && !isBuiltinType(element.type) && element.type !== special$self) {
+    const tmpElt = csnUtils.effectiveType(element);
     // effective type resolves to structs and enums only but not scalars
     if (Object.keys(tmpElt).length) {
       finalElement = tmpElt;
@@ -717,8 +714,8 @@ function createForeignKeys( path, element, prefix, csn, options, pathDelimiter,
     finalElement.keys.forEach((key, keyIndex) => {
       const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
-      const result = inspectRef(continuePath);
-      fks = fks.concat(createForeignKeys(result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
+      const result = csnUtils.inspectRef(continuePath);
+      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
     });
     if (!hasKeys)
       delete finalElement.keys;
@@ -742,7 +739,7 @@ function createForeignKeys( path, element, prefix, csn, options, pathDelimiter,
       // Skip already produced foreign keys
       if (!elem['@odata.foreignKey4']) {
         const continuePath = getContinuePath([ 'elements', elemName ]);
-        fks = fks.concat(createForeignKeys(continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
+        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
       }
     });
   }

package/lib/transform/db/temporal.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getUtils, getNormalizedQuery, hasAnnotationValue, forEachMember,
+  getNormalizedQuery, hasAnnotationValue, forEachMember,
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
@@ -20,11 +20,12 @@ const validFromString = '@cds.valid.from';
  * @param {CSN.Model} csn
  * @param {object} messageFunctions
  * @param {Function} messageFunctions.info
+ * @param {object} csnUtils
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition applying the where-condition to views.
  */
-function getViewDecorator( csn, messageFunctions ) {
+function getViewDecorator( csn, messageFunctions, csnUtils ) {
   const { info } = messageFunctions;
-  const { get$combined } = getUtils(csn);
+  const { get$combined } = csnUtils;
   return addTemporalWhereConditionToView;
   /**
    * Add a where condition to views that

package/lib/transform/db/transformExists.js

@@ -3,7 +3,6 @@
 const { forAllQueries, forEachDefinition, walkCsnPath } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { getRealName } = require('../../render/utils/common');
-const { csnRefs } = require('../../model/csnRefs');
 const { ModelError } = require('../../base/error');
 
 /**
@@ -47,9 +46,11 @@ const { ModelError } = require('../../base/error');
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {Function} error
+ * @param {Function} inspectRef
+ * @param {Function} initDefinition
+ * @param {Function} dropDefinitionCache
  */
-function handleExists( csn, options, error ) {
-  let { inspectRef } = csnRefs(csn);
+function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.projection) // do the same hack we do for the other stuff...
@@ -78,14 +79,19 @@ function handleExists( csn, options, error ) {
 
           while (toProcess.length > 0) {
             const [ queryPath, exprPath ] = toProcess.pop();
+            // Re-init caches for this artifact
+            dropDefinitionCache(artifact);
+            initDefinition(artifact);
             // leftovers can happen with nested exists - we then need to drill down into the created SELECT
             // to check for further exists
             const { result, leftovers } = processExists(queryPath, exprPath);
             walkCsnPath(csn, exprPath.slice(0, -1))[exprPath[exprPath.length - 1]] = result;
-            if (leftovers.length > 0)
-              inspectRef = csnRefs(csn).inspectRef; // Refresh caches - we need to resolve stuff in the newly created subquery
-            toProcess.push(...leftovers.reverse()); // any leftovers - schedule for further processing
+            leftovers.reverse();
+            toProcess.push(...leftovers); // any leftovers - schedule for further processing
           }
+          // Make sure we leave csnRefs usable
+          dropDefinitionCache(artifact);
+          initDefinition(artifact);
         }
       }, [ 'definitions', artifactName, 'query' ]);
     }
@@ -763,7 +769,7 @@ function handleExists( csn, options, error ) {
    */
   function remapExistingWhere( target, where ) {
     return where.map((part) => {
-      if (part.ref) {
+      if (part.ref && part.$scope !== '$magic') {
         part.ref = [ target, ...part.ref ];
         return part;
       }