@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/transform/db/flattening.js

@@ -15,7 +15,7 @@ const { forEach } = require('../../utils/objectUtils');
 const { transformExpression } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
-const adaptAnnotationsRefs = require('../odata/adaptAnnotationRefs');
+const { adaptAnnotationsRefs } = require('../odata/adaptAnnotationRefs');
 
 /**
  * Strip off leading $self from refs where applicable.
@@ -220,7 +220,8 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
           //       full path into target, uncomment this line and
           //       comment/remove setProp in expansion.js
           // setProp(parent, '$structRef', parent.ref);
-          [ parent.ref, refChanged ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, suspend, suspendPos, parent.$bparam);
+          const flattenParameters = false; // structured parameters remain structured
+          [ parent.ref, refChanged ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes, suspend, suspendPos, parent.$bparam, flattenParameters);
           resolved.set(parent, { links, art, scope });
           // Explicitly set implicit alias for things that are now flattened - but only in columns
           // TODO: Can this be done elegantly during expand phase already?
@@ -649,8 +650,11 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
             delete element.default;
         }
 
-        if (options.transformation === 'effective')
+        if (options.transformation === 'effective') {
           adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath);
+          const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && findAnnotationExpression(element, pn));
+          fks.forEach(fk => copyAnnotations(element, fk[1], false, {}, validAnnoNames));
+        }
         orderedElements.push(...fks);
       });
 

package/lib/transform/db/killAnnotations.js

@@ -25,6 +25,7 @@ const requiredAnnos = {
   '@cds.redirection.target': true,
   '@Core.Computed': true,
   [sqlServiceAnnotation]: true,
+  '@cds.external': true, // for external ABAP SQL services and data products for now
 };
 
 /**

package/lib/transform/db/processSqlServices.js

@@ -1,23 +1,26 @@
 'use strict';
 
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 
 const sqlServiceAnnotation = '@protocol';
-// Problem: How can we clone a Symbol when sorting?
-// const sqlServiceEntities = Symbol.for('SQL Service enabled entities');
+
 /**
  * Find all entities in SQL services and mark them with an annotation and
  * remember them in a symbol property for easier processing in toSql-rendering.
  *
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @returns {Function}
  */
-function processSqlServices(csn) {
+function processSqlServices(csn, options) {
   setProp(csn, '$sqlServiceEntities', Object.create(null));
+  setProp(csn, '$dummyServiceEntities', Object.create(null));
   return function findAndMarkSqlServiceArtifacts(artifact, artifactName) {
-    const sqlServiceName = isEntityInSqlService(artifact, artifactName, csn);
+    const { sqlServiceName, dummyServiceName } = isEntityInSqlService(artifact, artifactName, csn, options);
     if (sqlServiceName?.length > 0)
       setProp(artifact, '$sqlService', sqlServiceName);
+    if (dummyServiceName?.length > 0)
+      setProp(artifact, '$dummyService', dummyServiceName);
   };
 }
 
@@ -29,35 +32,85 @@ function processSqlServices(csn) {
 function isSqlService(artifact) {
   return artifact.kind === 'service' && artifact[sqlServiceAnnotation] === 'sql';
 }
+
 /**
+ * Checks if the given artifact is an external ABAP SQL service.
  *
- * @param {CSN.Artifact} artifact
- * @param {string} artifactName
- * @param {CSN.Model} csn
- * @returns {string|null}
+ * @param {object} artifact - The artifact to check.
+ * @param {CSN.Options} options
+ * @returns {boolean} - Returns true if the artifact is an external ABAP SQL service, otherwise false.
+ */
+function isDummyService(artifact, options) {
+  return isBetaEnabled(options, 'sqlServiceDummies') && artifact.kind === 'service' && artifact['@cds.external'] && artifact[sqlServiceAnnotation] === 'dummy';
+}
+
+/**
+ * Determines if an artifact is part of a SQL service or an external ABAP SQL service.
+ *
+ * @param {object} artifact - The artifact to check.
+ * @param {string} artifactName - The name of the artifact.
+ * @param {object} csn - The CSN (Core Schema Notation) object containing definitions.
+ * @param {CSN.Options} options
+ * @returns {object} An object containing the names of the SQL service and external ABAP SQL service, if found.
  */
-function isEntityInSqlService(artifact, artifactName, csn) {
-  if (artifact.kind !== 'entity' || !artifactName.includes('.'))
-    return null;
+function isEntityInSqlService(artifact, artifactName, csn, options) {
+  const result = { sqlServiceName: undefined, dummyServiceName: undefined };
+  if (artifact.kind !== 'entity' || !artifactName.includes('.') || artifact['@cds.persistence.skip'] === true)
+    return result;
 
   const nameParts = artifactName.split('.');
-  for (let i = nameParts.length; i >= 0; i--) {
+  for (let i = nameParts.length - 1; i >= 0; i--) {
     const possibleServiceName = nameParts.slice(0, i).join('.');
     if (!csn.definitions[possibleServiceName])
       continue;
 
     const definition = csn.definitions[possibleServiceName];
     if (isSqlService(definition))
-      return possibleServiceName;
+      result.sqlServiceName = possibleServiceName;
+
+    if (isDummyService(definition, options))
+      result.dummyServiceName = possibleServiceName;
 
     // We don't allow nested services/contexts - if we find one, we don't need to keep searching
     if (definition.kind === 'service' || definition.kind === 'context')
-      return null;
+      return result;
   }
 
-  return null;
+  return result;
+}
+
+/**
+ * Creates a dummy ABAP SQL service for the given artifact if it is marked as an external ABAP SQL service.
+ * The dummy service is a copy of the original artifact with certain properties removed.
+ * The dummy service is then added to the CSN (Core Schema Notation) definitions.
+ *
+ * @param {object} artifact - The artifact to create a dummy service for.
+ * @param {string} artifactName - The name of the artifact.
+ * @param {object} csn - The Core Schema Notation (CSN) object where the dummy service will be added.
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ */
+function createServiceDummy(artifact, artifactName, csn, { error }) {
+  if (!artifact.$dummyService)
+    return;
+
+  artifact['@cds.persistence.exists'] = true;
+  artifact.$ignore = true;
+
+  const dummy = { ...artifact };
+  delete dummy['@cds.persistence.exists'];
+  delete dummy.$ignore;
+
+  if (csn.definitions[`dummy.${artifactName}`])
+    error(null, [ 'definitions', artifactName ], { name: `dummy.${artifactName}` }, 'Generated artifact name $(NAME) conflicts with existing entity');
+  else
+    csn.definitions[`dummy.${artifactName}`] = dummy;
 }
 
 module.exports = {
-  processSqlServices, isSqlService, sqlServiceAnnotation,
+  processSqlServices,
+  isSqlService,
+  isDummyService,
+  sqlServiceAnnotation,
+  createServiceDummy,
 };

package/lib/transform/draft/db.js

@@ -4,7 +4,7 @@ const {
   hasAnnotationValue, getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
-const { setProp, isDeprecatedEnabled } = require('../../base/model');
+const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
@@ -25,8 +25,8 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   const allServices = getServiceNames(csn);
   const draftRoots = new WeakMap();
   const {
-    createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
-    addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
+    createAndAddDraftAdminDataProjection, createScalarElement,
+    createAssociationElement, addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
   } = getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
@@ -231,6 +231,11 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     };
     draftAdministrativeData.DraftAdministrativeData.notNull = true;
     addElement(draftAdministrativeData, draftsArtifact, artifactName);
+
+    if (isBetaEnabled(options, 'draftMessages')) {
+      const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
+      addElement(draftMessages, draftsArtifact, artifactName);
+    }
     // Note that we may need to do the HANA transformation steps for managed associations
     // (foreign key field generation, generatedFieldName, creating ON-condition) by hand,
     // because the corresponding transformation steps have already been done on all artifacts

package/lib/transform/draft/odata.js

@@ -7,6 +7,7 @@ const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtils');
 const { makeMessageFunction } = require('../../base/messages');
+const { isBetaEnabled } = require('../../base/model');
 
 /**
  * - Generate artificial draft fields if requested
@@ -35,10 +36,11 @@ function generateDrafts( csn, options, services, messageFunctions ) {
 
   const { error, info } = messageFunctions;
   const {
-    createAndAddDraftAdminDataProjection, createScalarElement,
-    createAssociationElement, createAssociationPathComparison,
-    addElement, createAction, assignAction,
-    resetAnnotation,
+    createAndAddDraftAdminDataProjection, isValidDraftAdminDataMessagesType, 
+    createScalarElement, createAssociationElement,
+    createAssociationPathComparison, addElement,
+    createAction, assignAction,
+    resetAnnotation, setAnnotation,
     csnUtils,
   } = getTransformers(csn, options, messageFunctions);
   const {
@@ -56,6 +58,16 @@ function generateDrafts( csn, options, services, messageFunctions ) {
   // @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 (isBetaEnabled(options, 'draftMessages')) {
+    const draftAdminDataMessagesType = csn.definitions['DRAFT.DraftAdministrativeData_DraftMessage'];
+    if (draftAdminDataMessagesType && !isValidDraftAdminDataMessagesType(draftAdminDataMessagesType)) {
+      error(null, [ 'definitions', 'DRAFT.DraftAdministrativeData_DraftMessage' ], { name: 'DRAFT.DraftAdministrativeData_DraftMessage' },
+            'Generated type $(NAME) conflicts with existing artifact');
+    }
+  }
+
   forEachDefinition(csn, (def, defName) => {
     // Generate artificial draft fields for entities/views if requested, ignore if not part of a service
     if (def.kind === 'entity' && def['@odata.draft.enabled'] && isArtifactInSomeService(defName, services))
@@ -167,6 +179,17 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
     siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
 
+    if (isBetaEnabled(options, 'draftMessages')) {
+      const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
+      addElement(draftMessages, artifact, artifactName);
+
+      if (!artifact['@Common.SideEffects#alwaysFetchMessages'] && artifact['@Common.SideEffects#alwaysFetchMessages'] !== null) {
+        setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.SourceEntities', ['']);
+        setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.TargetProperties', ['DraftMessages'] );
+      }
+      setAnnotation(artifact, '@Common.Messages', { '=': 'DraftMessages', ref: ['DraftMessages'] });
+    }
+
     // Iterate elements
     // TODO: Iterative vs recursive? What is more likely: Super deep nesting or cycles via malicious CSN?
     if (artifact.elements) {

package/lib/transform/effective/main.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getUtils, isAspect, mergeTransformers, applyTransformations,
+  getUtils, mergeTransformers, applyTransformations,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const effectiveFlattening = require('./flattening');
@@ -18,6 +18,7 @@ const annotations = require('./annotations');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('../db/rewriteCalculatedElements');
 const { cloneFullCsn } = require('../../model/cloneCsn');
 const { featureFlags } = require('../featureFlags');
+const getServiceFilterFunction = require('./service');
 
 /**
  * This is just a PoC for now!
@@ -36,14 +37,15 @@ function effectiveCsn( model, options, messageFunctions ) {
   delete csn.vocabularies; // must not be set for effective CSN
   messageFunctions.setModel(csn);
 
-  const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
+  const transformerUtils = transformUtils.getTransformers(csn, options, messageFunctions, '_');
+  const { expandStructsInExpression } = transformerUtils;
   const redoProjections = queries.projectionToSELECTAndAddColumns(csn);
 
   let csnUtils = getUtils(csn, 'init-all');
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
-    ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect,
+    ...messageFunctions, csnUtils, ...csnUtils, csn, options,
   });
 
   if (csn.meta?.[featureFlags]?.$calculatedElements)
@@ -63,7 +65,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   // Expand a structured thing in: keys, columns, order by, group by
   expansion.expandStructureReferences(csn, options, '_', messageFunctions, csnUtils);
 
-  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils, options);
+  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils, transformerUtils, options);
 
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
@@ -72,30 +74,55 @@ function effectiveCsn( model, options, messageFunctions ) {
   effectiveFlattening.flattenRefs(csn, options, csnUtils, messageFunctions);
   flattening.flattenElements(csn, options, messageFunctions, '_', { skipDict: { actions: true } });
 
-  resolveTypesInActionsAfterFlattening();
-
-  // ensure getElement works on flattened struct_assoc columns
+  // ensure getElement works on flattened struct_assoc columns and getFinalTypeInfo refreshes the cache
   csnUtils = getUtils(csn, 'init-all');
 
+  resolveTypesInActionsAfterFlattening(csnUtils);
+
   processCalculatedElementsInEntities(csn, options);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
   const transformers = mergeTransformers([
-    options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {},
     options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
     misc.removeDefinitionsAndProperties(csn, options),
     options.deriveAnalyticalAnnotations ? annotations.sealAnnoMagic(csn) : {},
   ], null);
 
-  applyTransformations(csn, transformers, [], { skipIgnore: false, processAnnotations: true });
+  if (options.addCdsPersistenceName) {
+    applyTransformations(csn, misc.attachPersistenceName(csn, options, csnUtils), [], {
+      skipIgnore: false, skipArtifact: artifact => artifact.kind !== 'entity', skipDict: { actions: true }, skipStandard: { items: true },
+    });
+  }
+
+  const artifactTransformers = [];
+
+  const collector = {
+    service: null,
+    containedArtifacts: Object.create(null),
+  };
+
+  if (options.effectiveServiceName)
+    artifactTransformers.push(getServiceFilterFunction(options.effectiveServiceName, collector));
+
+  applyTransformations(csn, transformers, artifactTransformers, { skipIgnore: false, processAnnotations: true });
 
   if (!options.resolveProjections)
     redoProjections.forEach(fn => fn());
 
-
   // Remove unapplied extensions/annotations
   delete csn.extensions;
 
+  if (options.effectiveServiceName) {
+    if (collector.service) {
+      csn.definitions = collector.containedArtifacts;
+      csn.definitions[options.effectiveServiceName] = collector.service;
+    }
+    else {
+      messageFunctions.warning(null, null, { name: options.effectiveServiceName, option: 'effectiveServiceName' }, 'Could not find a service matching requested effective service $(NAME) (option $(OPTION))');
+      csn.definitions = Object.create(null);
+    }
+  }
+
   messageFunctions.throwWithError();
 
   return csn;

package/lib/transform/effective/misc.js

@@ -19,20 +19,15 @@ function attachPersistenceName( csn, options, csnUtils ) {
    * @param {object} parent
    * @param {string} prop
    * @param {object} dict
-   * @param {CSN.Path} path
    */
-  function addToEachMember( parent, prop, dict, path ) {
-    const artifact = csn.definitions[path[1]];
-    if (artifact?.kind === 'entity') {
-      for (const memberName in dict)
-        addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), dict[memberName]);
-    }
+  function addToEachMember( parent, prop, dict ) {
+    for (const memberName in dict)
+      addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), dict[memberName]);
   }
 
   return {
     kind: (parent, prop, kind, path) => {
-      if (kind === 'entity')
-        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(path[1], options.sqlMapping, csn, options.sqlDialect), parent);
+      addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(path[1], options.sqlMapping, csn, options.sqlDialect), parent);
     },
     elements: addToEachMember,
     params: addToEachMember,

package/lib/transform/effective/service.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { forEach } = require('../../utils/objectUtils');
+
+/**
+ * Creates a filter function for a specific service that processes and strips artifacts.
+ *
+ * @param {string} serviceName - The name of the service to filter for.
+ * @param {Object} collector - An object to collect the service and its contained artifacts.
+ * @param {Object} collector.service - The main service artifact.
+ * @param {Object} collector.containedArtifacts - The contained artifacts of the service.
+ * @returns {Function} A filter function that processes definitions and artifacts.
+ */
+function getServiceFilterFunction(serviceName, collector) {
+  return function filterAndStripForService(definitions, artifactName, artifact) {
+    if (artifactName === serviceName && artifact.kind === 'service') {
+      collector.service = artifact;
+    }
+    else if (definitions[serviceName]?.kind === 'service' && artifactName.startsWith(`${serviceName }.`)) {
+      collector.containedArtifacts[artifactName] = artifact;
+      delete artifact.query;
+      delete artifact.projection;
+      if (artifact.elements) {
+        forEach(artifact.elements, (elementName, element) => {
+          if (element.target && !element.target.startsWith(`${serviceName }.`))
+            delete artifact.elements[elementName];
+        });
+      }
+    }
+  };
+}
+
+
+module.exports = getServiceFilterFunction;

package/lib/transform/effective/types.js

@@ -17,32 +17,43 @@ const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
  * @todo What about annotations on the type?
  * @param {CSN.Model} csn will be transformed
  * @param {object} csnUtils
+ * @param {object} transformers
  * @param {CSN.Options} options
  * @returns {Function} Callback to resolve types in action returns later - as for them, $self would lead to unresolvable constructs at this point
  * so we can call this callback after flattening is done - then we can safely resolve their types.
  */
-function resolveTypes( csn, csnUtils, options ) {
-  const { getFinalTypeInfo } = csnUtils;
+function resolveTypes( csn, csnUtils, transformers, options ) {
+  const { flattenStructStepsInRef } = transformers;
   const later = [];
   applyTransformations(csn, {
     type: (parent) => {
-      resolveType(parent);
+      resolveType(csnUtils, parent);
     },
   }, [ (definitions, artifactName, artifact) => {
     // In a non-flat model, replacing types with some $self inside causes issues for actions (bound or unbound)
     // we remember them and replace them after flattening.
-    if (artifact.kind === 'action' || artifact.kind === 'function')
-      later.push({ [artifactName]: artifact });
+    if (artifact.kind === 'action' || artifact.kind === 'function') // TODO: We still process them, this does not abort that? I am pretty sure at least...
+      later.push([ { [artifactName]: artifact }, [ 'definitions' ] ]);
     else if (artifact.actions)
-      later.push(artifact.actions);
-  } ], { skipStandard: { returns: true }, processAnnotations: true });
+      later.push([ artifact.actions, [ 'definitions', artifactName, 'actions' ] ]);
+  } ], { skipStandard: { returns: true }, processAnnotations: true, skipDict: { actions: true } });
+
+  // Type refs like E:struct.sub can not be resolved later, as struct will be flattened. So we rewrite it to E:struct_sub here.
+  later.forEach(([ action, actionPath ]) => {
+    applyTransformationsOnDictionary(action, {
+      type: (parent, prop, type, path) => {
+        if (type.ref)
+          type.ref = flattenStructStepsInRef(type.ref, path.concat('type'))[0];
+      },
+    }, {}, actionPath);
+  });
 
   // TODO: Directly push the .returns into the later so we have a more minimal looping
-  return function resolveTypesInActions() {
-    later.forEach((a) => {
-      applyTransformationsOnDictionary(a, {
+  return function resolveTypesInActions(refreshedCsnUtils) {
+    later.forEach(([ action ]) => {
+      applyTransformationsOnDictionary(action, {
         type: (parent) => {
-          resolveType(parent);
+          resolveType(refreshedCsnUtils, parent);
         },
       });
     });
@@ -59,9 +70,9 @@ function resolveTypes( csn, csnUtils, options ) {
    *
    * @param {object} parent Object with a .type property
    */
-  function resolveType( parent ) {
+  function resolveType( csnUtils, parent ) {
     // TODO: I assume there can be cases with a type ref but still having .elements already? Subelement anno?
-    const final = getFinalTypeInfo(parent.type);
+    const final = csnUtils.getFinalTypeInfo(parent.type);
     if (final?.elements) {
       // We do full clones so users don't get unexpected linkage later
       if (!parent.elements)
@@ -88,12 +99,12 @@ function resolveTypes( csn, csnUtils, options ) {
       const obj = stack.pop();
       if (obj.elements) {
         applyTransformationsOnDictionary(obj.elements, {
-          type: getTypeTransformer(stack),
+          type: getTypeTransformer(csnUtils, stack),
         }, { skipDict: { actions: true } });
       }
       else if (obj.items) {
         applyTransformationsOnNonDictionary(obj, 'items', {
-          type: getTypeTransformer(stack),
+          type: getTypeTransformer(csnUtils, stack),
         }, { skipDict: { actions: true } });
       }
     }
@@ -104,9 +115,9 @@ function resolveTypes( csn, csnUtils, options ) {
    * @param {object[]} stack
    * @returns {Function}
    */
-  function getTypeTransformer( stack ) {
+  function getTypeTransformer( csnUtils, stack ) {
     return function typeTransformer( _parent, _prop, _type ) {
-      const finalSub = getFinalTypeInfo(_type);
+      const finalSub = csnUtils.getFinalTypeInfo(_type);
 
       if (finalSub?.elements) {
         // We do full clones so users don't get unexpected linkage later

package/lib/transform/forOdata.js

@@ -7,7 +7,6 @@ const { forEachDefinition,
         applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf,
         getElementDatabaseNameOf,
-        isAspect,
         getServiceNames,
         forEachGeneric,
         cardinality2str,
@@ -147,7 +146,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   options.enrichAnnotations = true;
   const cleanup = validate.forOdata(csn, {
     message, error, warning, info, inspectRef, effectiveType, getFinalTypeInfo, artifactRef,
-    options, csnUtils, services, isAspect, isExternalServiceMember, recurseElements,
+    options, csnUtils, services, isExternalServiceMember, recurseElements,
     checkMultipleAssignments, csn,
   });
 
@@ -208,7 +207,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
         skipArtifact: isExternalServiceMember,
       });
     flattening.replaceManagedAssocsAsKeys(allMgdAssocDefs, csnUtils);
-      
+
     // replace structured with flat dictionaries that contain
     // rewritten path expressions
     forEachDefinition(csn, (def) => {
@@ -218,7 +217,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       })
       if(def.$flatAnnotations) {
         Object.entries(def.$flatAnnotations).forEach(([an, av]) => {
-          def[an] = av; 
+          def[an] = av;
         })
       }
       if(def.actions) {
@@ -425,15 +424,42 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
       if (node['@mandatory'] && !Object.entries(node).some(([k,v]) => k === '@Common.FieldControl' || k.startsWith('@Common.FieldControl.') && v != null)) {
         setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
       }
-      if (node['@assert.range'] != null &&
-          (Array.isArray(node['@assert.range']) &&
-           node['@assert.range'].length === 2)) {
-        setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
-        setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
-      }
+      if (node['@assert.range'] != null)
+        setAssertRangeAnnotation(node);
     }
   }
 
+
+  function setAssertRangeAnnotation(node) {
+    const range = node['@assert.range'];
+    if (!Array.isArray(range) || range.length !== 2)
+    return; // TODO: Warning for wrong format?
+
+    const min = range[0];
+    const max = range[1];
+    const minVal = min?.val ?? min;
+    const maxVal = max?.val ?? max;
+
+    // CAP Node 8.5 introduced "exclusive" ranges using the annotation expression
+    // syntax.  Hence, the compiler uses the same.  It also introduced "infinity"
+    // via `@assert.range: [ _, _ ]`.
+    // For `_`, minVal is an object and this function returns false, which is ok,
+    // since we don't render the annotation for "infinite" values.
+    const shouldSet = (val) => (typeof val !== 'object' && val !== undefined && val !== null);
+
+    if (shouldSet(minVal)) {
+      setAnnotation(node, '@Validation.Minimum', minVal);
+      if (min['='] !== undefined)
+        setAnnotation(node, '@Validation.Minimum.@Validation.Exclusive', true);
+    }
+    if (shouldSet(maxVal)) {
+      setAnnotation(node, '@Validation.Maximum', maxVal);
+      if (max['='] !== undefined)
+        setAnnotation(node, '@Validation.Maximum.@Validation.Exclusive', true);
+    }
+
+  }
+
   // If an association was modelled as not null, like so:
   // <associationName>: Association to <target> not null;
   // a cardinality property is set to the association member