@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/render/utils/common.js

@@ -242,6 +242,10 @@ const cdsToSqlTypes = {
     'cds.DecimalFloat': 'DECIMAL',
     'cds.Integer64': 'BIGINT',
     'cds.Integer': 'INTEGER',
+    'cds.Int64': 'BIGINT',
+    'cds.Int32': 'INTEGER',
+    'cds.Int16': 'SMALLINT',
+    'cds.UInt8': 'TINYINT',
     'cds.hana.SMALLINT': 'SMALLINT',
     'cds.hana.TINYINT': 'TINYINT', // not a Standard SQL type
     'cds.Double': 'DOUBLE',
@@ -279,20 +283,33 @@ const cdsToSqlTypes = {
     'cds.hana.BINARY': 'BINARY',
     'cds.hana.SMALLDECIMAL': 'DECIMAL',
   },
+  h2: {
+    'cds.Binary': 'VARBINARY', // same as for plain
+    'cds.LargeBinary': 'BINARY LARGE OBJECT', // BLOB would require a length!
+    'cds.DecimalFloat': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
+    'cds.DateTime': 'TIMESTAMP(0)',
+    'cds.Timestamp': 'TIMESTAMP(7)',
+  },
   postgres: {
-    // TODO: Type mapping for binary types is not correct, yet.
-    // We can't use text types for binary on PostgreSQL due to NUL!
+    // See <https://www.postgresql.org/docs/current/datatype.html>
     'cds.String': 'VARCHAR',
-    'cds.LargeString': 'text',
-    'cds.hana.CLOB': 'text',
-    'cds.LargeBinary': 'bytea',
-    'cds.Binary': 'bytea',
-    'cds.hana.BINARY': 'bytea',
-    'cds.Double': 'double precision',
-    'cds.hana.TINYINT': 'INTEGER',
+    'cds.LargeString': 'TEXT',
+    'cds.LargeBinary': 'BYTEA',
+    'cds.Binary': 'BYTEA',
+    'cds.Double': 'FLOAT8',
+    'cds.UInt8': 'INTEGER', // Not equivalent
   },
 };
 
+// Type mapping from cds type names to HDBCDS type names:
+// Only those types, that need mapping, are listed.
+const cdsToHdbcdsTypes = {
+  'cds.UInt8': 'cds.hana.TINYINT',
+  'cds.Int16': 'cds.hana.SMALLINT',
+  'cds.Int32': 'cds.Integer',
+  'cds.Int64': 'cds.Integer64',
+};
+
 /**
  * Get the element matching the column
  *
@@ -521,6 +538,7 @@ module.exports = {
   addIntermediateContexts,
   addContextMarkers,
   cdsToSqlTypes,
+  cdsToHdbcdsTypes,
   hasHanaComment,
   getHanaComment,
   findElement,

package/lib/render/utils/sql.js

@@ -43,8 +43,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
                                 options.src === 'hdi' ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 
-  const { sqlMapping } = options;
-  const forSqlite = options.sqlDialect === 'sqlite';
+  const { sqlMapping, sqlDialect } = options;
   let result = '';
   result += `${indent}CONSTRAINT ${quoteId(constraint.identifier)}\n`;
   if (renderAsHdbconstraint)
@@ -55,7 +54,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
 
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
-    if (forSqlite) {
+    if (sqlDialect === 'sqlite') {
       if (constraint.onDelete === 'CASCADE' )
         result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
@@ -65,13 +64,14 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
+  // constraint enforcement / validation not supported by postgres
   // Does not include HDBCDS.
-  if (options.toSql && !forSqlite) {
+  if (options.toSql && sqlDialect !== 'sqlite' && sqlDialect !== 'postgres') {
     result += `${indent}${!constraint.validated ? 'NOT ' : ''}VALIDATED\n`;
     result += `${indent}${!constraint.enforced ? 'NOT ' : ''}ENFORCED\n`;
   }
   // for sqlite, the DEFERRABLE keyword is required
-  result += `${indent}${forSqlite ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
+  result += `${indent}${sqlDialect === 'sqlite' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
   return result;
 }
 

package/lib/sql-identifier.js

@@ -39,6 +39,13 @@ const keywords = require( './base/keywords' );
 
 const sqlDialects = {
   plain: {},
+  h2: {
+    // See http://www.h2database.com/html/grammar.html#name
+    regularRegex: /^[A-Za-z_][A-Za-z_0-9]*$/,
+    reservedWords: keywords.h2,
+    effectiveName: name => name.toUpperCase(),
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
   sqlite: {
     regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
     reservedWords: keywords.sqlite,

package/lib/transform/db/applyTransformations.js

@@ -35,10 +35,16 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
   };
 
   const csnPath = [ ...path ];
-  if (prop === 'definitions')
+  if (prop === 'definitions') {
     definitions( parent, 'definitions', parent.definitions );
-  else
+  }
+  else if (options.directDict) {
+    for (const name of Object.getOwnPropertyNames( parent ))
+      standard( parent, name, parent[name] );
+  }
+  else {
     standard(parent, prop, parent[prop]);
+  }
   return parent;
 
   /**
@@ -84,7 +90,7 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
    * @param {object} dict The value of node[_prop]
    */
   function dictionary( node, _prop, dict ) {
-    // Allow skipping dicts like actions in forHanaNew
+    // Allow skipping dicts like actions in forRelationalDB
     if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
       return;
     csnPath.push( _prop );
@@ -194,9 +200,31 @@ function applyTransformationsOnNonDictionary(parent, prop, customTransformers =
   return applyTransformationsInternal(parent, prop, customTransformers, [], options, path)[prop];
 }
 
+/**
+ * Instead of looping through the whole model, start at a given thing (like .elements),
+ * as long as it is a dictionary.
+ *
+ * Each transformer gets:
+ * - the parent having the property
+ * - the name of the property
+ * - the value of the property
+ * - the path to the property
+ *
+ *
+ * @param {object} dictionary Dictionary to enrich in-place
+ * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {applyTransformationsOptions} [options={}]
+ * @param {CSN.Path} path Path pointing to parent
+ * @returns {object} dictionary with transformations applied
+ */
+function applyTransformationsOnDictionary(dictionary, customTransformers = {}, options = {}, path = []) {
+  return applyTransformationsInternal(dictionary, null, customTransformers, [], { directDict: true, ...options }, path);
+}
+
 module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
 };
 
 
@@ -209,4 +237,5 @@ module.exports = {
  * @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} [directDict=false] Implicitly set via applyTransformationsOnDictionary
  */

package/lib/transform/db/assertUnique.js

@@ -3,6 +3,7 @@
 const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
 const { getTransformers } = require('../transformUtilsNew');
 const { setProp } = require('../../base/model');
+const { pathName } = require('../../compiler/utils');
 
 
 /**
@@ -38,13 +39,14 @@ function processAssertUnique(csn, options, error, info) {
     // filter unique constraints from annotations
     for (const propName in artifact) {
       if (propName.startsWith('@assert.unique') && artifact[propName] !== null) {
+        const anno = propName;
         // Constraint Name check
         const constraintName = propName.split('.').splice(2);
         if (constraintName.length === 0)
-          err(propName, 'Table constraint cannot be anonymous');
+          error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Table constraint can\'t be anonymous');
         if (constraintName.length > 1)
         // Neither HANA CDS nor HANA SQL allow dots in index names
-          err(propName, "Illegal character '.' in constraint name");
+          error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Illegal character \'.\' in constraint name');
 
         const propValue = artifact[propName];
         // Constraint value check, returns array of path values
@@ -79,10 +81,12 @@ function processAssertUnique(csn, options, error, info) {
             pathxrefs[pstr]++;
         });
         Object.keys(pathxrefs).forEach((k) => {
-          if (pathxrefs[k] > 1)
-            err(propName, `Final path "${k}" can only be specified once`);
+          if (pathxrefs[k] > 1) {
+            error(null, [ 'definitions', artifactName ], { anno, id: k },
+                  '$(ANNO): Final path $(ID) can only be specified once');
+          }
         });
-        // 9) Add into constraint cross reference
+        // 9) Add into constraint cross-reference
         if (constraintKey.length) {
           if (constraintXrefs[constraintKey])
             constraintXrefs[constraintKey].push(propName);
@@ -99,7 +103,7 @@ function processAssertUnique(csn, options, error, info) {
     for (const key in constraintXrefs) {
       const val = constraintXrefs[key];
       if (val.length > 1)
-        err(val.join(', '), 'Constraint can only be specified once');
+        error(null, [ 'definitions', artifactName ], { annos: val }, '$(ANNOS): Constraint can only be specified once');
     }
     // preserve dictionary in '$tableConstraints' on the artifact for path rewriting and rendering
     if (Object.keys(constraintDict).length) {
@@ -119,17 +123,18 @@ function processAssertUnique(csn, options, error, info) {
      */
     function checkVal(val, propName) {
       const paths = [];
+      const loc = [ 'definitions', artifactName ];
       if (!Array.isArray(val)) {
-        err(propName, `Value '${JSON.stringify(unref(val))}' is not an array`);
+        error(null, loc, { anno: propName, value: JSON.stringify(unref(val)) }, '$(ANNO): Value $(VALUE) is not an array');
       }
       else {
         if (val.length === 0)
-          inf(propName, 'Empty annotation is ignored');
+          info(null, loc, { anno: propName }, '$(ANNO): Empty annotation is ignored');
 
         val.forEach((v) => {
           const p = v['='];
           if (!p)
-            err(propName, `Value '${JSON.stringify(unref(v))}' is not a path`);
+            error(null, loc, { anno: propName, value: JSON.stringify(unref(v)) }, '$(ANNO): Value $(VALUE) is not a path');
           else
             paths.push(p);
         });
@@ -185,61 +190,45 @@ function processAssertUnique(csn, options, error, info) {
         return;
       path.isChecked = true;
       let foundErr = false;
+      const name = pathName(path.ref);
+      const loc = [ 'definitions', artifactName ];
       for (let i = 0; i < path.ref.length && !foundErr; i++) {
         const art = path.ref[i]._art;
+        const elemref = path.ref[i].id;
         if (art) {
           if (art.items) {
-            msg(`'Array of/many' element "${path.ref[i].id}" is not allowed`);
+            error(null, loc, { elemref, name, anno: constraintName },
+                  '$(ANNO): \'Array of/many\' element $(ELEMREF) is not allowed in $(NAME)');
             delete path._art;
             foundErr = true;
           }
           if (art.target) {
             if (art.on) {
-              msg(`Unmanaged association "${path.ref[i].id}" is not allowed`);
+              error(null, loc, { elemref, name, anno: constraintName },
+                    '$(ANNO): Unmanaged association $(ELEMREF) is not allowed in $(NAME)');
               delete path._art;
               foundErr = true;
             }
             if (art.keys && i < path.ref.length - 1) {
-              msg(`Element access via managed association "${path.ref[i].id}" is not allowed`);
+              error(null, loc, { elemref, name, anno: constraintName },
+                    '$(ANNO): Element access via managed association $(ELEMREF) is not allowed in $(NAME)');
               delete path._art;
               foundErr = true;
             }
           }
         }
         else {
-          err(constraintName, `"${path.ref[i].id}" has not been found`);
+          error(null, loc, { elemref, anno: constraintName }, '$(ANNO): $(ELEMREF) has not been found');
           foundErr = true;
         }
       }
 
       if (!foundErr && path._art && [ 'cds.LargeBinary', 'cds.LargeString',
-        'cds.hana.CLOB', 'cds.hana.ST_POINT', 'cds.hana.ST_GEOMETRY' ].includes(path._art.type))
-        msg(`"Type ${path._art.type}" not allowed`);
-
-
-      /**
-       * @param {string} message
-       */
-      function msg(message) {
-        err(constraintName, `${message} in "${path.ref.map(p => p.id).join('.')}"`);
+        'cds.hana.CLOB', 'cds.hana.ST_POINT', 'cds.hana.ST_GEOMETRY' ].includes(path._art.type)) {
+        error(null, loc, { type: path._art.type, name, anno: constraintName },
+              '$(ANNO): Type $(TYPE) not allowed in $(NAME)');
       }
     }
-
-    // message macros for unified messaging
-    /**
-     * @param {string} propName
-     * @param {string} message
-     */
-    function err(propName, message) {
-      error(null, [ 'definitions', artifactName ], `${propName}: ${message}`);
-    }
-    /**
-     * @param {string} propName
-     * @param {string} message
-     */
-    function inf(propName, message) {
-      info(null, [ 'definitions', artifactName ], `${propName}: ${message}`);
-    }
   }
 }
 

package/lib/transform/db/expansion.js

@@ -7,7 +7,7 @@ const {
   walkCsnPath,
 } = require('../../model/csnUtils');
 const { csnRefs, implicitAs } = require('../../model/csnRefs');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 
 /**
@@ -26,12 +26,11 @@ const { forEach } = require('../../utils/objectUtils');
 function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
   const csnUtils = getUtils(csn);
   const {
-    isStructured, get$combined, getFinalBaseTypeWithProps, getServiceName,
+    isStructured, get$combined, getFinalBaseTypeWithProps,
   } = csnUtils;
   let { effectiveType, inspectRef } = csnUtils;
 
-  if (isBetaEnabled(options, 'nestedProjections'))
-    rewriteExpandInline();
+  rewriteExpandInline();
 
 
   applyTransformations(csn, {
@@ -63,7 +62,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * For such skipped things, error for usage of assoc pointing to them and and ignore publishing of assoc pointing to them.
    */
   function rewriteExpandInline() {
-    const { cleanup, _dependents } = setDependencies(csn);
+    let cleanup;
+    let _dependents;
 
     const entity = findAnEntity();
     const toDummyfy = [];
@@ -77,14 +77,12 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         const root = get$combined({ SELECT: parent });
         if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
           const rewritten = rewrite(root, parent.columns, parent.excluding);
-          parent.columns = rewritten.columns;
           /*
            * Do not remove unexpandable many columns in OData
           */
           if (rewritten.toMany.length > 0 && !options.toOdata) {
             markAsToDummyfy(artifact, path[1]);
-            if (getServiceName(path[1]) === null)
-              error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME), which is outside any service');
+            error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME)');
           }
           else {
             parent.columns = rewritten.columns;
@@ -98,7 +96,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     if (!options.toOdata)
       dummyfy();
 
-    cleanup.forEach(fn => fn());
+    if (cleanup)
+      cleanup.forEach(fn => fn());
 
     ({ effectiveType, inspectRef } = csnRefs(csn));
 
@@ -106,7 +105,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     const publishing = [];
     // OData must allow navigations to @cds.persistence.skip targets
     // as valid navigations in the API
-    if (!options.toOdata) {
+    if (options.transformation !== 'odata') {
       applyTransformations(csn, {
         target: (parent, name, target, path) => {
           if (toDummyfy.indexOf(target) !== -1) {
@@ -209,6 +208,9 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {string} name
      */
     function markAsToDummyfy(artifact, name) {
+      if (!_dependents && !cleanup)
+        ({ cleanup, _dependents } = setDependencies(csn, csnUtils));
+
       const stack = [ [ artifact, name ] ];
       while (stack.length > 0) {
         const [ a, n ] = stack.pop();
@@ -347,14 +349,21 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         }
         else if (current.xpr || current.args) {
           // We need to re-write refs in the .xpr/.args so they stay resolvable - we need to prepend the currentRef
-          rewriteXprArgs(current, currentRef);
+          rewriteExpressionArrays(current, currentRef);
           expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
         }
+        else if (current.on || current.cast?.on) {
+          rewriteOn(current, [ currentAlias.slice(0, -1).join(pathDelimiter) ]);
+          expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
+        }
         else if (current.val !== undefined || current.func !== undefined) {
           expanded.push(Object.assign(current, { as: currentAlias.join(pathDelimiter) }));
         }
-        else {
-          expanded.push({ ref: currentRef, as: currentAlias.join(pathDelimiter) });
+        else if (current.$scope === '$magic' || current.$scope === '$self') {
+          expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
+        }
+        else { // preserve stuff like .cast for redirection
+          expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }
       }
 
@@ -367,37 +376,79 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {object} parent Thing that has an .xpr/.args
      * @param {string[]} ref Ref so far
      */
-    function rewriteXprArgs(parent, ref) {
+    function rewriteExpressionArrays(parent, ref) {
       const stack = [ [ parent, ref ] ];
       while (stack.length > 0) {
         const [ current, currentRef ] = stack.pop();
-        if (current.xpr) {
-          for (let i = 0; i < current.xpr.length; i++) {
-            const part = current.xpr[i];
-            if (part.ref) {
-              part.ref = currentRef.concat(part.ref);
-              // part.as = currentAlias.concat(part.as || part.ref[ref.length - 1]).join(pathDelimiter);
-              current.xpr[i] = part;
-              stack.push([ part, part.ref ]);
-            }
-            else {
-              stack.push([ part, currentRef ]);
-            }
-          }
+        if (current.xpr)
+          rewriteSingleExpressionArray(current.xpr, currentRef, stack);
+        if (current.args)
+          rewriteSingleExpressionArray(current.args, currentRef, stack);
+      }
+    }
+
+    /**
+     * With a .cast.on  or .on in a .expand/.inline, we need to change the references,
+     * since we change the overall scope of things (by "heaving" them up into "normal refs").
+     *
+     * So anything that does not have a $self/$projection infron get's the so-far-traveled alias,
+     * since after the transformation it will basically be in "top-level".
+     *
+     * @param {object} parent
+     * @param {Array} ref The so-far effective name (basically the will-be alias), as an array to treat like a ref
+     */
+    function rewriteOn(parent, ref) {
+      const stack = [ [ parent, ref ] ];
+      while (stack.length > 0) {
+        const [ current, currentRef ] = stack.pop();
+        if (current.on)
+          rewriteOnCondition(current.on, currentRef, stack);
+        if (current.cast?.on)
+          rewriteOnCondition(current.cast.on, currentRef, stack);
+      }
+    }
+
+    /**
+     * Actually rewrite the given oncondition. Once we find something to rewrite,
+     * we preprend the currentRef.
+     *
+     * All stuff is pushed to the stack.
+     *
+     * @param {Array} on
+     * @param {Array} currentRef
+     * @param {Array} stack
+     */
+    function rewriteOnCondition(on, currentRef, stack) {
+      for (let i = 0; i < on.length; i++) {
+        const part = on[i];
+        if (part.ref && part.ref[0] !== '$self' && part.ref[0] !== '$projection') {
+          part.ref = currentRef[0] ? [ currentRef[0], ...part.ref ] : part.ref;
+          on[i] = part;
+          stack.push([ part, part.ref ]);
         }
-        if (current.args) {
-          for (let i = 0; i < current.args.length; i++) {
-            const part = current.args[i];
-            if (part.ref) {
-              part.ref = currentRef.concat(part.ref);
-              // part.as = currentAlias.concat(part.as || part.ref[ref.length - 1]).join(pathDelimiter);
-              current.args[i] = part;
-              stack.push([ part, part.ref ]);
-            }
-            else {
-              stack.push([ part, currentRef ]);
-            }
-          }
+        else {
+          stack.push([ part, currentRef ]);
+        }
+      }
+    }
+
+    /**
+     * Rewrite the given expressionArray, prefixing currentRef to all refs
+     *
+     * @param {Array} expressionArray
+     * @param {Array} currentRef
+     * @param {Array} stack
+     */
+    function rewriteSingleExpressionArray(expressionArray, currentRef, stack) {
+      for (let i = 0; i < expressionArray.length; i++) {
+        const part = expressionArray[i];
+        if (part.ref) {
+          part.ref = currentRef.concat(part.ref);
+          expressionArray[i] = part;
+          stack.push([ part, part.ref ]);
+        }
+        else {
+          stack.push([ part, currentRef ]);
         }
       }
     }
@@ -409,7 +460,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      */
     function findAnEntity() {
       for (const name in csn.definitions) {
-        if (Object.hasOwnProperty.call(csn.definitions, name) && csn.definitions[name].kind === 'entity' && !csn.definitions[name].query)
+        if (Object.prototype.hasOwnProperty.call(csn.definitions, name) && csn.definitions[name].kind === 'entity' && !csn.definitions[name].query)
           return name;
       }
       return null;

package/lib/transform/db/flattening.js

@@ -124,7 +124,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
       }
     },
   }, [ (definitions, artifactName, artifact) => {
-    // Replace events, actions and functions with simple dummies - they don't have effect on forHanaNew stuff
+    // 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.
 
     // Do not do for OData

package/lib/transform/db/temporal.js

@@ -81,7 +81,9 @@ function getViewDecorator(csn, messageFunctions) {
           }
         }
         else {
-          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${from[0].error_parent}"."${from[0].name}" and "${to[0].error_parent}"."${to[0].name}" are not of same origin`);
+          info(null, [ 'definitions', artifactName ],
+               { source: `${from[0].errorParent}.${from[0].name}`, target: `${to[0].errorParent}.${to[0].name}` },
+               'No temporal WHERE clause added as $(SOURCE) and $(TARGET) are not of same origin');
         }
       }
       else if (from.length > 0 || to.length > 0) {

package/lib/transform/db/transformExists.js

@@ -428,6 +428,11 @@ function handleExists(csn, options, error) {
    * @returns {object[]} The stuff to add to the where
    */
   function translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) {
+    if (current.$scope === '$self') {
+      error('ref-unexpected-exists-self', current.$path, { id: current.ref[0], name: 'exists' }, 'With $(NAME), path steps must not start with $(ID)');
+      return [];
+    }
+
     const whereExtension = [];
     for (let j = 0; j < root.keys.length; j++) {
       const lop = { ref: [ target, ...root.keys[j].ref ] }; // target side
@@ -799,8 +804,9 @@ function handleExists(csn, options, error) {
           where.push({ ref: [ base, ...part.ref.slice(1) ] });
         }
         else if (part.$scope === '$self') { // source side - "absolute" scope
-          // Same message as in forHanaNew/transformDollarSelfComparisonWithUnmanagedAssoc
-          error(null, part.$path, 'An association that uses "$self" in its ON-condition can\'t be compared to "$self"');
+          // Same message as in forRelationalDB/transformDollarSelfComparisonWithUnmanagedAssoc
+          error(null, part.$path, { name: '$self' },
+                'An association that uses $(NAME) in its ON-condition can\'t be compared to "$self"');
         }
         else if (partInspect.art) { // source side - with local scope
           where.push({ ref: [ target, ...assoc.ref.slice(1, -1), ...part.ref ] });