@sap/cds-compiler 6.4.6 → 6.5.0

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 {

package/lib/transform/db/temporal.js

@@ -11,8 +11,8 @@ const validToString = '@cds.valid.to';
 const validFromString = '@cds.valid.from';
 /**
  * Get the forEachDefinition callback function that adds a where condition to views that
- * - are annotated with @cds.valid.from and @cds.valid.to,
- * - have only one @cds.valid.from and @cds.valid.to,
+ * - are annotated with `@cds.valid.from` and `@cds.valid.to`,
+ * - have only one `@cds.valid.from` and `@cds.valid.to`,
  * - and both annotations come from the same entity
  *
  * If the view has one of the annotations but the other conditions are not met, an error will be raised.
@@ -30,8 +30,8 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
   return addTemporalWhereConditionToView;
   /**
    * Add a where condition to views that
-   * - are annotated with @cds.valid.from and @cds.valid.to,
-   * - have only one @cds.valid.from and @cds.valid.to,
+   * - are annotated with `@cds.valid.from` and `@cds.valid.to`,
+   * - have only one `@cds.valid.from` and `@cds.valid.to`,
    * - and both annotations come from the same entity
    *
    * If the view has one of the annotations but the other conditions are not met, an error will be raised.
@@ -97,10 +97,10 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
   }
 
   /**
-   * Get all elements tagged with @cds.valid.from/to from the union of all entities of the from-clause.
+   * Get all elements tagged with `@cds.valid.from/to` from the union of all entities of the from-clause.
    *
-   * @param {any} combined union of all entities of the from-clause
-   * @returns {Array[]} Array where first field is array of elements with @cds.valid.from, second field is array of elements with @cds.valid.to.
+   * @param {CSN.QueryFrom} combined union of all entities of the from-clause
+   * @returns {Array[]} Array where first field is array of elements with `@cds.valid.from`, second field is array of elements with `@cds.valid.to`.
    */
   function getFromToElements( combined ) {
     const from = [];
@@ -121,7 +121,7 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
   }
 
   /**
-   * Check if the given SELECT has a falsy @cds.valid.from and a falsy @cds.valid.to
+   * Check if the given SELECT has a falsy `@cds.valid.from` and a falsy `@cds.valid.to`
    *
    * @param {CSN.QuerySelect} SELECT
    * @param {CSN.Elements} elements
@@ -150,13 +150,13 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
 }
 
 /**
- * Get the forEachDefinition callback function that collects all usages of @cds.valid.from/to/key and checks that
+ * Get the forEachDefinition callback function that collects all usages of `@cds.valid.from/to/key` and checks that
  * - the assignment is on a valid element
  * - the annotation is only assigned once
  * - key is only used in conjunction with from and to
  *
- * Furthermore, @cds.valid.from and @cds.valid.key is processed - @cds.valid.from is marked as key or marked as unique if @cds.valid.key is used.
- * If @cds.valid.key is used, the real key-elements have their key-property removed (set non-enumerable as $key) and instead the @cds.valid.key-marked elements have it added.
+ * Furthermore, `@cds.valid.from` and `@cds.valid.key` is processed - `@cds.valid.from` is marked as key or marked as unique if `@cds.valid.key` is used.
+ * If `@cds.valid.key` is used, the real key-elements have their key-property removed (set non-enumerable as $key) and instead the `@cds.valid.key`-marked elements have it added.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options

package/lib/transform/draft/db.js

@@ -188,6 +188,8 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     // Copy all elements
     for (const elemName in artifact.elements) {
       const origElem = artifact.elements[elemName];
+      // elements with $calc are rendered as usual
+
       if (origElem.value?.stored) {
         calcOnWriteElements.push(elemName);
       }

package/lib/transform/draft/odata.js

@@ -27,11 +27,12 @@ const { makeMessageFunction } = require('../../base/messages');
  * @param {CSN.Options} options
  * @param {string[]|undefined} services Will be calculated JIT if not provided
  * @param {object} [messageFunctions]
+ * @param {function} [isExternalServiceMember]
  * @returns {CSN.Model} Returns the transformed input model
  * @todo should be done by the compiler - Check associations for valid foreign keys
  * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
  */
-function generateDrafts( csn, options, services, messageFunctions ) {
+function generateDrafts( csn, options, services, messageFunctions, isExternalServiceMember ) {
   // TEMP(2024-02-26): Temporary! Umbrella uses this file directly in cds/lib/compile/for/drafts.js#L1
   messageFunctions ??= makeMessageFunction(csn, options, 'odata-drafts');
 
@@ -53,14 +54,11 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     services = getServiceNames(csn);
 
   const visitedArtifacts = Object.create(null);
-  // @ts-ignore
-  const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
-  // @ts-ignore
-  const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
+
   const filterDict = Object.create(null);
 
   // validate the 'DRAFT.DraftAdministrativeData_DraftMessage' type if already present in the model
-  if (options.draftMessages) {
+  if (options.draftMessages && options.odataVersion === 'v4') {
     const draftAdminDataMessagesType = csn.definitions['DRAFT.DraftAdministrativeData_DraftMessage'];
     if (draftAdminDataMessagesType && !isValidDraftAdminDataMessagesType(draftAdminDataMessagesType)) {
       error(null, [ 'definitions', 'DRAFT.DraftAdministrativeData_DraftMessage' ], { name: 'DRAFT.DraftAdministrativeData_DraftMessage' },
@@ -181,7 +179,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
     siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
 
-    if (options.draftMessages) {
+    if (options.draftMessages && options.odataVersion === 'v4') {
       const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
       addElement(draftMessages, artifact, artifactName);
 

package/lib/transform/effective/flattening.js

@@ -62,13 +62,12 @@ function flattenRefs(csn, options, csnUtils, messageFunctions) {
 
     // explicit binding parameter of bound action
     if (def.actions) {
-      const special$self = !csn?.definitions?.$self && '$self';
       Object.entries(def.actions).forEach(([ an, a ]) => {
         if (a.params) {
           const params = Object.entries(a.params);
           const firstParam = params[0][1];
           const type = firstParam?.items?.type || firstParam?.type;
-          if (type === special$self) {
+          if (type === '$self') {
             const bindingParamName = params[0][0];
             const markBindingParam = {
               ref: (parent, prop, xpr) => {

package/lib/transform/forOdata.js

@@ -117,9 +117,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // use the array when there is a need to identify if an artifact is in a service or not
   const services = getServiceNames(csn);
   // @ts-ignore
-  const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
+  const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external'] && csn.definitions[serviceName]['@cds.external'] !== 2);
   // @ts-ignore
-  const isExternalServiceMember = (art, name) => !!(externalServices.includes(getServiceName(name)) || (art && art['@cds.external']));
+  const isExternalServiceMember = (art, name) => !!(externalServices.includes(getServiceName(name)) || (art && art['@cds.external'] && art['@cds.external'] !== 2));
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
@@ -127,7 +127,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
   //   expansion do their magic including foreign key generation and annotation propagation.
   //   Tenantenizer has to decorate the DraftAdministrativeData, so draft decoration must be done before.
-  generateDrafts(csn, options, services, messageFunctions);
+  generateDrafts(csn, options, services, messageFunctions, isExternalServiceMember);
 
   if (options.tenantDiscriminator)
     addTenantFields(csn, options);

package/lib/transform/forRelationalDB.js

@@ -49,7 +49,7 @@ function forEachDefinition(csn, cb) {
  * such as flattening, wildcard expansion, etc.
  *
  * @param {CSN.Model}      csn
- * @param {CSN.SqlOptions} options
+ * @param {SqlOptions} options
  * @param {object}         messageFunctions Message functions such as `error()`, `info()`, …
  */
 function transformForRelationalDBWithCsn(csn, options, messageFunctions) {

package/lib/transform/odata/createForeignKeys.js

@@ -76,7 +76,6 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
   }
 
   function createForeignKeysForElement(path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalKey = {} ) {
-    const special$self = !csn?.definitions?.$self && '$self';
     const isInspectRefResult = !Array.isArray(path);
 
     let fks = [];
@@ -87,7 +86,7 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
     let finalTypeName;
 
     // resolve derived type
-    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/odata/flattening.js

@@ -102,13 +102,12 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
       setProp(def, '$flatAnnotations', flatAnnos);
       // explicit binding parameter of bound action
       if (def.actions) {
-        const special$self = !csn?.definitions?.$self && '$self';
         Object.entries(def.actions).forEach(([ actionName, action ]) => {
           if (action.params) {
             const params = Object.entries(action.params);
             const firstParam = params[0][1];
             const type = firstParam?.items?.type || firstParam?.type;
-            if (type === special$self) {
+            if (type === '$self') {
               const bindingParamName = params[0][0];
               const markBindingParam = {
                 ref: (parent, prop, xpr) => {

package/lib/transform/odata/toFinalBaseType.js

@@ -13,7 +13,6 @@ const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
 
 function expandToFinalBaseType(csn, transformers, csnUtils, services, options, error) {
   const isV4 = options.odataVersion === 'v4';
-  const special$self = !csn?.definitions?.$self && '$self';
   forEachDefinition(csn, (def, defName) => {
     // Unravel derived type chains to final one for elements, actions, action parameters (propagating annotations)
     forEachMemberRecursively(def, (member, _memberName) => {
@@ -112,65 +111,63 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       else {
         if (isExpandable(finalBaseType) || node.kind === 'type') {
           // 1. Get the final type of the node (resolve derived type chain)
-          if (finalBaseType.type !== special$self) {
-            // The type replacement depends on whether 'node' is a definition or a member[element].
-            if (node.kind) {
-              /*
-                It is a definition and we expand to builtin type and to elements
-                type T: S; --> Integer;
-                type S: X; --> Integer;
-                type X: Integer;
+          // The type replacement depends on whether 'node' is a definition or a member[element].
+          if (node.kind) {
+            /*
+              It is a definition and we expand to builtin type and to elements
+              type T: S; --> Integer;
+              type S: X; --> Integer;
+              type X: Integer;
 
-                type A: B; -> {...}
-                type B: C; -> { ... }
-                type C { .... };
+              type A: B; -> {...}
+              type B: C; -> { ... }
+              type C { .... };
+            */
+            if (isBuiltinType(finalBaseType.type)) {
+              /*
+                use transformUtils::toFinalBaseType for the moment,
+                as it is collects along the chain of types
+                attributes that need to be propagated
+                enum, length, scale, etc.
               */
-              if (isBuiltinType(finalBaseType.type)) {
-                /*
-                  use transformUtils::toFinalBaseType for the moment,
-                  as it is collects along the chain of types
-                  attributes that need to be propagated
-                  enum, length, scale, etc.
-                */
-                transformers.toFinalBaseType(node);
-              }
-              else if (csnUtils.isStructured(finalBaseType)) {
-                cloneElements(node, finalBaseType);
-              }
-              else if (node.type && node.items) {
-                delete node.type;
-              }
+              transformers.toFinalBaseType(node);
             }
-            else {
-              /*
-                this is a member and we expand to final base only if builtin
-                  type T: S; --> Integer;
-                  type S: X; --> Integer;
-                  type X: Integer;
+            else if (csnUtils.isStructured(finalBaseType)) {
+              cloneElements(node, finalBaseType);
+            }
+            else if (node.type && node.items) {
+              delete node.type;
+            }
+          }
+          else {
+            /*
+              this is a member and we expand to final base only if builtin
+              type T: S; --> Integer;
+              type S: X; --> Integer;
+              type X: Integer;
 
-                  type {
-                    struct_elt: many A; ---> stays the same
-                    scalar_elt: T; ---> Integer;
-                    type_ref_elt: type of struct_elt;
-                  };
-                  type A: B; -> {...}
-                  type B: C; -> { ... }
-                  type C { .... };
+              type {
+              struct_elt: many A; ---> stays the same
+              scalar_elt: T; ---> Integer;
+              type_ref_elt: type of struct_elt;
+              };
+              type A: B; -> {...}
+              type B: C; -> { ... }
+              type C { .... };
+            */
+            // eslint-disable-next-line no-lonely-if
+            if (isBuiltinType(finalBaseType.type)) {
+              /*
+                use transformUtils::toFinalBaseType for the moment,
+                as it is collects along the chain of types
+                attributes that need to be propagated
+                enum, length, scale, etc.
               */
-              // eslint-disable-next-line no-lonely-if
-              if (isBuiltinType(finalBaseType.type)) {
-                /*
-                  use transformUtils::toFinalBaseType for the moment,
-                  as it is collects along the chain of types
-                  attributes that need to be propagated
-                  enum, length, scale, etc.
-                */
-                transformers.toFinalBaseType(node);
-                // node.type = finalType;
-              }
-              else if (node.type.ref) {
-                cloneElements(node, finalBaseType);
-              }
+              transformers.toFinalBaseType(node);
+              // node.type = finalType;
+            }
+            else if (node.type.ref) {
+              cloneElements(node, finalBaseType);
             }
           }
         }