@sap/cds-compiler 6.4.6 → 6.5.2

package/lib/edm/edmPreprocessor.js

@@ -40,7 +40,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
   const {
     info, warning, error, message,
   } = messageFunctions;
-  const special$self = !csn?.definitions?.$self && '$self';
   const csnUtils = getUtils(csn);
 
   // proxies are merged into the final model after all proxy elements are collected
@@ -2077,7 +2076,8 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
 
     function iterateParams( action, location ) {
       let optPns = [];
-      const isBP = p => (p.items?.type || p.type) === special$self;
+      const isBP = p => (p.items?.type || p.type) === '$self' &&
+        p === Object.values( action.params )[0];
 
       if (action.params) {
         Object.entries(action.params).forEach(([ pn, p ]) => {
@@ -2126,7 +2126,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             }
             else if (action.kind === 'function') {
               // this is a mandatory parameter, warn about all previously collected optional parameters
-              if (optPns.filter(op => (op.items?.type || op.type) !== special$self).length)
+              if (optPns.length)
                 error('odata-parameter-order', location.concat(pn));
               optPns = [];
             }

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-8e38091fda3711e1d4d2b8b87fbdd328
+2af41f8c84ca1fa40a50b8c58903dadc

package/lib/gen/CdlParser.js

@@ -3827,7 +3827,7 @@ case 645:this.s=651;{ this.attachLocation( $.expr ); }continue
 case 646:if(this.valuePath(_={},651)){e=_.expr; this.valuePathAstWithNew( $.expr, e ); }continue
 case 647:switch(this.l()){
 case'(':if(this.c(648))open=this.lb();continue
-case'Id':if(this.valuePath(_={},651)){e=_.expr; e = this.valuePathAst( e ); e.$expected = 'exists';
+case'Id':if(this.valuePath(_={},651)){e=_.expr; e = this.valuePathAst( e ); e.$syntax = 'after-exists';
 $.expr.args.push( e ); this.attachLocation( $.expr ); }continue
 case'?':if(this.c(651)){ this.csnParseOnly( 'syntax-unsupported-param', -1, { '#': 'dynamic', code: '?' } );
 $.expr.args.push( { param: this.valueWithLocation(), scope: 'param' } ); this.attachLocation( $.expr ); }continue

package/lib/gen/Dictionary.json

@@ -596,7 +596,7 @@
         "Property",
         "Parameter"
       ],
-      "Type": "Edm.String"
+      "Type": "Edm.PrimitiveType"
     },
     "Common.FieldControl": {
       "AppliesTo": [
@@ -910,6 +910,13 @@
       "$deprecationText": "Use terms [Aggregation.RecursiveHierarchy](https://github.com/oasis-tcs/odata-vocabularies/blob/main/vocabularies/Org.OData.Aggregation.V1.md#RecursiveHierarchy) and [Hierarchy.RecursiveHierarchy](https://github.com/SAP/odata-vocabularies/blob/main/vocabularies/Hierarchy.md#RecursiveHierarchy) instead",
       "Type": "Common.RecursiveHierarchyType"
     },
+    "Common.ReferentialConstraint": {
+      "$experimental": true,
+      "AppliesTo": [
+        "NavigationProperty"
+      ],
+      "Type": "Collection(Common.ReferentialConstraintType)"
+    },
     "Common.RelatedRecursiveHierarchy": {
       "AppliesTo": [
         "Property"
@@ -3345,6 +3352,14 @@
         "NodeDrillStateProperty": "Edm.PropertyPath"
       }
     },
+    "Common.ReferentialConstraintType": {
+      "$experimental": true,
+      "$kind": "ComplexType",
+      "Properties": {
+        "Property": "Edm.PropertyPath",
+        "ReferencedProperty": "Edm.PropertyPath"
+      }
+    },
     "Common.SAPObjectNodeTypeType": {
       "$experimental": true,
       "$kind": "ComplexType",

package/lib/json/from-csn.js

@@ -1682,15 +1682,13 @@ function exprOrString( val, spec ) {
     : expr( val, spec );
 }
 
-// mark path argument of 'exists' predicate with $expected:'exists'
+// mark path argument of 'exists' predicate with $syntax:'after-exists'
 function exprArgs( cond, spec ) {
   const rxsn = arrayOf( exprOrString )( cond, spec );
-  // TODO: do that in definer.js, neither here nor in CDL parser
   if (Array.isArray( rxsn )) {
-    for (let i = 0; i < rxsn.length - 1; i++) {
-      // TODO: disallow param ref - write test
-      if (cond[i] === 'exists' && rxsn[i + 1].path)
-        rxsn[++i].$expected = 'exists';
+    for (let i = 0; i < rxsn.length - 1;) {
+      if (cond[i++] === 'exists' && rxsn[i].path)
+        rxsn[i].$syntax = 'after-exists';
     }
   }
   return rxsn;

package/lib/json/to-csn.js

@@ -1172,15 +1172,15 @@ function enumValueOrCalc( v, csn, node, prop ) {
   if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }
-  else if (v === true && prop === '$calc') {
-    return true;                // calculation has used non-projected elements
+  else if (prop === '$calc') {
+    return v === true || expression( v );
   }
   // In XSN, there are combined elem/column objects: do not represent column
   // expression when presented as element in CSN
 
   // node.$syntax set in define.el(!), but not inside an `extend`, a _parent might
   // not be set always for parse-only, especially with CSN input
-  else if (node.$syntax === 'calc' || prop === '$calc' ||
+  else if (node.$syntax === 'calc' ||
            !node._parent || node._parent.kind === 'extend') {
     const stored = v.stored ? { stored: value(v.stored) } : {};
     return Object.assign( stored, expression( v ) );

package/lib/model/csnRefs.js

@@ -245,9 +245,10 @@ const referenceSemantics = {
   inline: { lexical: justDollar, dynamic: 'inline' },   // ...using baseEnv
   ref_where: { lexical: justDollar, dynamic: 'ref-target' }, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
+  // there are also 'on_join' and 'on_mixin' with default semantics
+  $calc: { lexical: justDollar, dynamic: 'query' }, // calculation for draft
   annotation: { lexical: justDollar, dynamic: 'query' }, // anno top-level `ref`
   annotationExpr: { lexical: justDollar, dynamic: 'query' }, // annotation assignment
-  // there are also 'on_join' and 'on_mixin' with default semantics
   orderBy_ref: { lexical: query => query, dynamic: 'query' },
   orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
   orderBy_set_ref: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
@@ -519,6 +520,8 @@ function csnRefs( csn, universalReady ) {
    * Return the object pointing to by the artifact reference (in 'type',
    * 'includes', 'target').  For `from`, use artifactRefFrom()!
    *
+   * Warning: do not use it for the binding parameter if the ref is `$self`.
+   *
    * @param {CSN.ArtifactReferencePath|string} ref
    * @param {any} [notFound] Value that is returned in case the artifact reference
    *                         could not be found.
@@ -612,9 +615,16 @@ function csnRefs( csn, universalReady ) {
 
   function getOriginRaw( art ) {
     if (art.type) {               // TODO: make robust against "linked" = only direct
-      return (art.type !== '$self' || csn.definitions.$self)
-        ? artifactRef( art.type, BUILTIN_TYPE )
-        : getCache( boundActionOrMain( art ), '_parent' );
+      if (art.type !== '$self')
+        return artifactRef( art.type, BUILTIN_TYPE );
+      const action = boundActionOrMain( art );
+      const binding = action?.params && Object.values( action.params )[0];
+      // binding parameter must be typed with `$self` or `many $self`:
+      const entity = binding && (art === binding || art === binding.items) &&
+        getCache( action, '_parent' );
+      // if name-deprecated-$self is a non-config error, this could be simplified to:
+      // const entity = action?.params && getCache( action, '_parent' );
+      return entity || artifactRef( art.type, BUILTIN_TYPE );
     }
     if (typeof art.$origin === 'object') // null, […], {…}
       return getOriginExplicit( art.$origin );
@@ -798,7 +808,7 @@ function csnRefs( csn, universalReady ) {
       }
 
       if (!qcache)
-        throw new CompilerAssertion( `Query not in cache at: ${ locationString(query.$location) }` );
+        throw new CompilerAssertion( `For semantics '${ refCtx }', query not in cache at: ${ locationString(query.$location) }` );
 
       if (semantics.dynamic === 'query') {
         // TODO: for ON condition in expand, would need to use cached _element
@@ -1066,6 +1076,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     if (refCtx === 'annotation' && typeof obj === 'object') {
       // we do not know yet whether the annotation value is an expression or not →
       // loop over outer array and records (structure values):
+      // TODO: add test → `@(A: [{target: ($user)}])` on query column
       if (Array.isArray( obj ) || !isAnnotationExpression( obj )) {
         obj = obj[prop];
         continue;
@@ -1155,6 +1166,9 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     else if (prop[0] === '@') {
       refCtx = 'annotation';
     }
+    else if (prop === '$calc') {
+      refCtx = '$calc';
+    }
     else if (prop !== 'xpr' && prop !== 'list') {
       // 'xpr' and 'list' do not change the ref context, all other props do:
       refCtx = prop;

package/lib/model/enrichCsn.js

@@ -69,7 +69,6 @@ function enrichCsn( csn, options = {} ) {
   // options.enrichCsn = 'DEBUG';
   let $$cacheObjectNumber = 0;   // for debugging
   const debugLocationInfo = options.enrichCsn === 'DEBUG' && Object.create(null);
-  const special$self = !csn.definitions.$self && '$self';
 
   setLocations( csn, false, null );
   const {
@@ -180,7 +179,10 @@ function enrichCsn( csn, options = {} ) {
       parent[`_${ prop }`] = ref.map( r => refLocation( artifactRef( r, notFound ) ) );
     }
     else if (typeof ref === 'string') {
-      if (!ref.startsWith( 'cds.') && ref !== special$self)
+      // Don't use `artifactRef( 'self' )` for binding parameter. Because it is not
+      // easily recognizable here, always omit `_type` property for `$self` even if
+      // there is a type named `$self` (which would induce a configurable error):
+      if (!ref.startsWith( 'cds.') && ref !== '$self')
         parent[`_${ prop }`] = refLocation( artifactRef( ref, notFound ) );
     }
     else if (!ref.elements) {

package/lib/optionProcessor.js

@@ -2,11 +2,13 @@
 
 /* eslint @stylistic/max-len: 0 */
 
-// Remarks:
-// - The specification is client-tool centric (bin/cdsc.js):
+// Remarks (`git blame` on these remarks does not reveal the options designer)
+// - The specification is client-tool centric (../bin/cdsc.js):
 //   an option named `fooBar` is “produced” by `.option('  --foo-bar')`.
 // - Also list the option in the `help` text, used with `cdsc -h`.
-// - Specify valid values for non-boolean options in lib/api/validate.js.
+// - All options must also be added to ./api/options.js.
+// - Specify valid values for non-boolean options in ./api/validate.js.
+// - Beta and deprecated options are specified in ./base/model.js.
 
 'use strict';
 
@@ -54,7 +56,8 @@ optionProcessor
   .option('    --add-texts-language-assoc')
   .option('    --localized-without-coalesce')
   .option('    --tenant-discriminator')
-  .option('    --no-composition-includes')
+  .option('    --no-composition-includes') // TODO: missed to be removed in #13762
+  .option('    --no-dollar-calc')          // for grep: option `noDollarCalc`
   .option('    --default-binary-length <length>')
   .option('    --default-string-length <length>')
   .option('    --struct-xpr')
@@ -157,6 +160,7 @@ optionProcessor
                                     to "sap.common.Languages" if it exists
        --localized-without-coalesce Omit coalesce in localized convenience views
        --no-composition-includes  Do NOT add named aspects to 'includes' property of generated composition entity.
+       --no-dollar-calc     Don't set $calc property in CSN
        --no-recompile       Don't recompile in case of internal errors
        --struct-xpr         Write structured expressions to the compiler CSN output (possibly then
                             used as input for backends)

package/lib/render/toSql.js

@@ -1294,11 +1294,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
-      // If the whole SET has an ORDER BY/LIMIT, wrap the part before that in parentheses
-      // (otherwise some SQL implementations (e.g. sqlite) would interpret the ORDER BY/LIMIT as belonging
-      // to the last SET argument, not to the whole SET)
       if (query.SET.orderBy || query.SET.limit) {
-        result = `(${ result })`;
         if (query.SET.orderBy) {
           const orderBy = query.SET.orderBy.map(entry => renderOrderByEntry(entry, env.withSubPath([ 'orderBy' ]))).join(', ');
           result += `\n${ env.indent }ORDER BY ${ orderBy }`;

package/lib/render/utils/sql.js

@@ -198,10 +198,11 @@ function _artifactIsProjectionView( csn, artifact ) {
     referencedElements[column.ref.at(-1)] = true;
   }
 
-  // Full primary key needs to be projected according to HANA SQL spec
+  // Full primary key/not null chain needs to be projected according to HANA SQL spec
+  // https://help.sap.com/docs/hana-cloud-database/sap-hana-cloud-sap-hana-database-sql-reference-guide/create-projection-view-statement-data-definition
   for (const elementName in source.elements) {
     const element = source.elements[elementName];
-    if (element.key && !referencedElements[elementName])
+    if ((element.notNull || element.key) && !referencedElements[elementName])
       return false;
   }
 

package/lib/transform/db/applyTransformations.js

@@ -211,7 +211,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    *
    * @param {object | Array} node the thing that has _prop
    * @param {string|number} _prop the name of the current property
-   * @param {any} _path The value of node[_prop]
+   * @param {Array} _path The value of node[_prop]
    */
   function pathRef( node, _prop, _path ) {
     csnPath.push( _prop );

package/lib/transform/db/assertUnique.js

@@ -122,7 +122,7 @@ function processAssertUnique( csn, options, messageFunctions ) {
      * Check strictly that annotation value is an array
      * and that the individual array entries are references
      *
-     * @param {any} val Annotation value
+     * @param {object} val Annotation value
      * @param {string} propName
      * @returns {Array} Array of paths
      */
@@ -149,8 +149,8 @@ function processAssertUnique( csn, options, messageFunctions ) {
       /**
        * Convert a ref object to a path string
        *
-       * @param {any} v
-       * @returns {string|string[]|any}
+       * @param {CSN.Ref | object} v
+       * @returns {string|string[]|object}
        */
       function unref( v ) {
         if (Array.isArray(v))

package/lib/transform/db/assocsToQueries/normalizeFrom.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Normalize a queries `from` clause by moving the infix filters on the last step of a `SELECT.from.ref` path.
+ *
+ * For the given query/projection, if the terminal ref element is an object
+ * containing a `where` (syntactic sugar), its condition is moved into `SELECT.where`.
+ * - If `SELECT.where` already exists, both are combined as:  { xpr: [ oldWhere ] } AND { xpr: [ leafWhere ] }.
+ * - Otherwise the leaf `where` becomes the `SELECT.where`.
+ * The ref leaf object is then replaced by its plain `id`, removing the inline filter.
+ *
+ * Mutates the provided query in place.
+ *
+ * @param {CSN.Query} query - The query to normalize.
+ */
+function normalizeFromLeaf( query ) {
+  const where = query.SELECT?.from.ref?.at(-1).where;
+  if (!where || where.length === 0)
+    return;
+  if (query.SELECT.where)
+    query.SELECT.where = [ { xpr: [ ...query.SELECT.where ] }, 'AND', { xpr: [ ...where ] } ];
+  else
+    query.SELECT.where = where;
+
+  // preserve `args`
+  if (query.SELECT?.from.ref?.at(-1).args)
+    delete query.SELECT.from.ref[query.SELECT.from.ref.length - 1].where;
+  else
+    query.SELECT.from.ref[query.SELECT.from.ref.length - 1] = query.SELECT.from.ref.at(-1).id;
+}
+
+
+module.exports = normalizeFromLeaf;

package/lib/transform/db/assocsToQueries/transformExists.js

@@ -1,9 +1,13 @@
 'use strict';
 
-const { forAllQueries, forEachDefinition, walkCsnPath } = require('../../../model/csnUtils');
+const {
+  forAllQueries, forEachDefinition, walkCsnPath, transformExpression,
+} = require('../../../model/csnUtils');
 const { setProp } = require('../../../base/model');
 const { getHelpers } = require('./utils');
 
+const normalizeFromLeaf = require('./normalizeFrom');
+
 /**
  * Turn a `exists assoc[filter = 100]` into a `exists (select 1 as dummy from assoc.target where <assoc on condition> and assoc.target.filter = 100)`.
  *
@@ -62,6 +66,9 @@ function handleExists( csn, options, messageFunctions, csnUtils ) {
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.query || artifact.projection) {
       forAllQueries(artifact.query || { SELECT: artifact.projection }, function handleExistsQuery(query, path) {
+        // Normalize infix filters on the last step of a `SELECT.from.ref` path.
+        // By doing this before the exists transformation, we enable `SELECT * FROM Author:books[exists genre]`
+        normalizeFromLeaf(query);
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
           if (query.SELECT?.where?.length > 1)
@@ -77,8 +84,12 @@ function handleExists( csn, options, messageFunctions, csnUtils ) {
             toProcess.push([ path.slice(0, -1), path.concat([ 'from', 'on' ]) ]);
 
           for (const [ , exprPath ] of toProcess) {
-            const expr = nestExists(exprPath);
-            walkCsnPath(csn, exprPath.slice(0, -1))[exprPath[exprPath.length - 1]] = expr;
+            const token = walkCsnPath(csn, exprPath);
+            transformExpression(token, null, {
+              ref: (container, prop, ref, pathToRef) => {
+                nestExists(pathToRef.slice(0, -1));
+              },
+            }, exprPath);
           }
 
           while (toProcess.length > 0) {

package/lib/transform/db/assocsToQueries/utils.js

@@ -255,7 +255,7 @@ function getHelpers( csn, inspectRef, error ) {
     /**
      * Run Object.assign on all of the passed in parameters and delete a .as and .key at the end
      *
-     * @param {...any} args
+     * @param {...object} args
      * @returns {object} The merged args without an .as and .key property
      */
     function assignAndDeleteAsAndKey( ...args ) {

package/lib/transform/db/backlinks.js

@@ -24,7 +24,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
-   * @param {any} dummy unused Parameter
+   * @param {object} dummy unused Parameter
    * @param {CSN.Path} path
    */
   function transformSelfInBacklinks( artifact, artifactName, dummy, path ) {
@@ -164,7 +164,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * Return the condition to replace the comparison `<assocOp> = $self` in the ON-condition
    * of element <elem> of artifact 'art'. If there is anything to complain, use location <loc>
    *
-   * @param {any} assocOp
+   * @param {CSN.Ref} assocOp
    * @param {CSN.Element} assoc
    * @param {string} assocName
    * @param {CSN.Element} elem
@@ -224,7 +224,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * keys in this artifact.
    * For example, `ON elem.ass = $self` becomes `ON elem.ass_key1 = key1 AND elem.ass_key2 = key2`
    * (assuming that `ass` has the foreign keys `key1` and `key2`)
-   * @param {any} assocOp
+   * @param {CSN.Ref} assocOp
    * @param {CSN.Element} assoc
    * @param {string} originalAssocName
    * @param {string} elemName
@@ -276,7 +276,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    * For example, `ON elem.ass = $self` becomes `ON a = elem.x AND b = elem.y`
    * (assuming that `ass` has the ON-condition `ON ass.a = x AND ass.b = y`)
    *
-   * @param {any} assocOp
+   * @param {CSN.Ref} assocOp
    * @param {CSN.Element} assoc
    * @param {string} originalAssocName
    * @param {string} elemName

package/lib/transform/db/cdsPersistence.js

@@ -9,7 +9,7 @@ const {
 const { recurseElements } = require('../transformUtils');
 
 /**
- * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
+ * Return a callback function for forEachDefinition that marks artifacts that are abstract or `@cds.persistence.exists/skip`
  * with $ignore.
  *
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback function for forEachDefinition
@@ -31,7 +31,7 @@ function getAnnoProcessor() {
 
 /**
  * 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
+ * if their target does not reach the database, i.e. marked with `@cds.persistence.skip` or is abstract
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
@@ -48,7 +48,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
 
   return ignoreAssociationToSkippedTarget;
   /**
-   * Associations that target a @cds.persistence.skip artifact must be removed
+   * Associations that target a `@cds.persistence.skip` artifact must be removed
    * from the persistence model
    *
    * @param {CSN.Artifact} artifact
@@ -94,7 +94,7 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
 }
 
 /**
- * Return a callback function for forEachDefinition that handles artifacts marked with @cds.persistence.table.
+ * Return a callback function for forEachDefinition that handles artifacts marked with `@cds.persistence.table`.
  * If a .query artifact has this annotation, the .query will be deleted and it will be treated like a table.
  *
  * @param {CSN.Model} csn

package/lib/transform/db/constraints.js

@@ -239,7 +239,7 @@ function createReferentialConstraints( csn, options ) {
    *  The following decision table reflects the current implementation:
    *
    *   +-----------------+--------------------+-------------------+----------+
-   *   | Global Switch:  | Global Check Type:  | @assert.integrity | Generate  |
+   *   | Global Switch:  | Global Check Type:  | `@assert.integrity` | Generate  |
    *   |"assertIntegrity"| "assertIntegrityType"|                   | Constraint|
    *   +-----------------+--------------------+-------------------+----------+
    *   | on              | RT                 | false             | no       |
@@ -345,7 +345,7 @@ function createReferentialConstraints( csn, options ) {
 
     /**
      *  if global checks are 'individual' we evaluate every association,
-     *  we create db constraints if it is annotated with @assert.integrity: 'DB' (or true)
+     *  we create db constraints if it is annotated with `@assert.integrity`: 'DB' (or true)
      *
      * @returns {boolean}
      */
@@ -388,7 +388,7 @@ function createReferentialConstraints( csn, options ) {
     /**
      * if global checks are on and global integrity check type is 'DB'
      * we create db constraints in any case except if annotated
-     * with @assert.integrity: 'RT' (or false, but that is rejected earlier)
+     * with `@assert.integrity: 'RT'` (or false, but that is rejected earlier)
      *
      * @returns {boolean}
      */
@@ -397,7 +397,7 @@ function createReferentialConstraints( csn, options ) {
     }
 
     /**
-     * Convenience to check if value of element's @assert.integrity annotation
+     * Convenience to check if value of element's `@assert.integrity` annotation
      * is the same as a given value.  `@assert.integrity`-value checks do not use the "truthy"-semantics,
      * since string values _and_ booleans are allowed, but are treated differently.
      *

package/lib/transform/db/expansion.js

@@ -124,7 +124,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
   }
 
   /**
-   * Turn .expand/.inline into normal refs. @cds.persistence.skip .expand with to-many (and all transitive views).
+   * Turn .expand/.inline into normal refs. `@cds.persistence.skip` .expand with to-many (and all transitive views).
    * For such skipped things, error for usage of assoc pointing to them and ignore publishing of assoc pointing to them.
    */
   function rewriteExpandInline() {
@@ -269,7 +269,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
 
     /**
      * Mark the given artifact and all (transitively) dependent artifacts as `toDummify`.
-     * This means that they will be replaced with simple dummy views in @dummify
+     * This means that they will be replaced with simple dummy views in `@dummify`
      *
      * @param {CSN.Artifact} artifact
      * @param {string} name
@@ -544,7 +544,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     }
 
     /**
-     * Create a simple dummy view marked with @cds.persistence.skip
+     * Create a simple dummy view marked with `@cds.persistence.skip`
      *
      * @param {string} source
      * @returns {CSN.Artifact}
@@ -646,14 +646,14 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
    *     leafs `a_b` and `a_c`, if `art` has elements `b` and `c`.
    * @param {string[]} colTypeRef
    *     Expanded type for the column. Basically the path to the to-be-expanded `art`.
-   * @param {(currentRef: any[], currentAlias: string[]) => object} leafCallback
+   * @param {(currentRef: CSN.Ref, currentAlias: string[]) => object} leafCallback
    *    Callback when leaf nodes are reached. currentRef is the type reference for the expanded
    *    column.  currentAlias is the columns calculated alias.
    * @returns {object[]}
    */
   function _expandStructCol( art, colName, colTypeRef, leafCallback ) {
     const expanded = [];
-    /** @type {Array<[CSN.Element, any[], string[]]>} */
+    /** @type {Array<[CSN.Element, CSN.Column, string[]]>} */
     const stack = [ [ art, colTypeRef, [ colName ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();

package/lib/transform/db/flattening.js

@@ -468,9 +468,9 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
    *
    * If a structure contains an assoc, this will also be resolved and vice versa
    *
-   * @param {*} assoc
-   * @param {*} assocName
-   * @param {*} path
+   * @param {CSN.Association} assoc
+   * @param {string} assocName
+   * @param {CSN.Path} path
    */
   function flattenFKs( assoc, assocName, path ) {
     if (!assoc.keys)
@@ -697,7 +697,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
  * @returns {Array[]} First element of every sub-array is the foreign key name, second is the foreign key definition
  */
 function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalKey = { }) {
-  const special$self = !csn?.definitions?.$self && '$self';
   const isInspectRefResult = !Array.isArray(path);
 
   let fks = [];
@@ -707,7 +706,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
   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) && element.type !== special$self) {
+  if (element.type && !isBuiltinType(element.type)) {
     const tmpElt = csnUtils.effectiveType(element);
     // effective type resolves to structs and enums only but not scalars
     if (Object.keys(tmpElt).length) {

package/lib/transform/db/rewriteCalculatedElements.js

@@ -141,9 +141,9 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
     /**
      * @param {object} parent
      * @param {string} prop
-     * @param ref
-     * @param p
-     * @param root
+     * @param {CSN.Ref} ref
+     * @param {CSN.Path} p
+     * @param {CSN.Element} root
      */
     function transformRef(parent, prop, ref, p, root) {
       const {