@sap/cds-compiler 5.7.4 → 5.8.0

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

package/lib/transform/forRelationalDB.js

@@ -3,7 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const { forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
-        isAspect, walkCsnPath, isPersistedOnDatabase
+        walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const transformUtils = require('./transformUtils');
@@ -34,7 +34,7 @@ const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
 const { featureFlags } = require('./featureFlags');
 const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
-const { processSqlServices } = require('./db/processSqlServices');
+const { processSqlServices, createServiceDummy  } = require('./db/processSqlServices');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -157,7 +157,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   timetrace.start('Validate');
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   validate.forRelationalDB(csn, {
-    ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect
+    ...messageFunctions, csnUtils, ...csnUtils, csn, options,
   });
   timetrace.stop('Validate');
 
@@ -354,12 +354,18 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // some errors can't be handled in the subsequent processing steps for e.g. HDBCDS
   messageFunctions.throwWithError();
 
+  // TODO: Might have to do this earlier if we want special rendering for projections?
+  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && (csn.meta?.[featureFlags]?.$sqlService || csn.meta?.[featureFlags]?.$dummyService) ? processSqlServices(csn, options): () => {}
+
   // Apply view-specific transformations
   // (160) Projections now finally become views
   // Replace managed association in group/order by with foreign keys
   const transformEntityOrViewPass2 = getViewTransformer(csn, options, messageFunctions);
-  forEachDefinition(csn, transformViews);
-
+  forEachDefinition(csn, [(artifact, artifactName) => {
+    findAndMarkSqlServiceArtifacts(artifact, artifactName);
+    if(artifact.$dummyService)
+      createServiceDummy(artifact, artifactName, csn, messageFunctions);
+  },  transformViews]);
 
   if(!doA2J) {
     forEachDefinition(csn, [
@@ -381,9 +387,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     ]);
   }
 
-  // TODO: Might have to do this earlier if we want special rendering for projections?
-  const findAndMarkSqlServiceArtifacts = options.sqlDialect === 'hana' && options.src === 'hdi' && csn.meta?.[featureFlags]?.$sqlService ? processSqlServices(csn): () => {}
-
   // TODO: Could we maybe merge this with the final applyTransformations?
   applyTransformations(csn, {
     type: (parent, prop, type, path) => {
@@ -409,8 +412,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     // Attach @cds.persistence.name to artifacts
     if (!artifact.$ignore && artifact.kind !== 'service' && artifact.kind !== 'context')
       csnUtils.addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
-
-    findAndMarkSqlServiceArtifacts(artifact, artifactName);
   }], { allowArtifact: artifact => artifact.kind === 'entity'});
 
   throwWithAnyError();
@@ -636,9 +637,14 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   function handleAssocToJoins() {
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
-    forEachDefinition(csn,
-      art => art.technicalConfig && setProp(art, 'technicalConfig',
-      art.technicalConfig));
+    forEachDefinition(csn, (art) => {
+      if (art.technicalConfig)
+        setProp(art, 'technicalConfig', art.technicalConfig);
+      if (art.kind === 'type' && art.projection) {
+        // Missing 'elements' already reported by csnRefs.
+        delete art.projection;
+      }
+    });
 
     const newCsn = translateAssocsToJoinsCSN(csn, options);
 
@@ -712,9 +718,15 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   // If 'elem' has a default that is an enum constant, replace that by its value. Complain
   // if not found or not an enum type,
+  // usually done by the Core Compiler, but backend might be called directly
   function replaceEnumSymbolsByValues(elem, path) {
     // (190 a) Replace enum symbols by their value (if found)
-    if (elem.default && elem.default['#']) {
+    if (!elem.default?.['#'])
+      return;
+    if (elem.default.val !== undefined) {
+      delete elem.default['#'];
+    }
+    else {
       let Enum = elem.enum;
       if (!Enum && !isBuiltinType(elem.type)) {
         const typeDef = csnUtils.getCsnDef(elem.type);
@@ -755,10 +767,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   /**
    * Check that required actual parameters on 'node.type' are set, that their values are in the correct range etc.
 
-   * @param {*} node 
-   * @param {*} nodeName 
-   * @param {*} model 
-   * @param {*} path 
+   * @param {*} node
+   * @param {*} nodeName
+   * @param {*} model
+   * @param {*} path
    */
   function checkTypeParameters(node, artifact, path) {
     if (node.type && !node.virtual) {

package/lib/transform/odata/adaptAnnotationRefs.js

@@ -8,21 +8,31 @@ const { transformAnnotationExpression, implicitAs, } = require('../../model/csnU
  * key declared in the scope, we replace it with referencing the foreign key itself. If a reference is a $self reference,
  * we do nothing and if a ref points to a structure/managed association, an error is thrown
  *
- * @param {Array[]} generatedForeignKeys 
+ * @param {Array[object]||Array[]} generatedForeignKeys 
  * @param {object} csnUtils 
  * @param {object} messageFunctions 
- * @param {CSN.Path} elementPath 
  */
 function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath) {
-  const reportedErrorsForAnnoPath = {};
-  generatedForeignKeys.forEach((gfk, index) => {
-    Object.entries(gfk[1]).forEach(([key, value]) => {
-      if (key[0] !== '@') return;
-
-      transformAnnotationExpression(gfk[1], key, {
-        ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
-          if (ref[0] !== '$self') {
-            const { art } = csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)); // OData uses getOriginatingKeyPath - as it relies on $path
+  if(Array.isArray(generatedForeignKeys && generatedForeignKeys[0])) {
+    // ensure we are always called with an array of objects. TODO: Cleanup fk creation in for.effective to create array of objects
+    adaptAnnotationsRefs(remapToArrayOfObjects(generatedForeignKeys), csnUtils, { error }, elementPath); 
+  } else {
+    const reportedErrorsForAnnoPath = {};
+    generatedForeignKeys.forEach((gfk, index) => {
+      Object.entries(gfk.foreignKey).forEach(([key, value]) => {
+        if (key[0] !== '@') return;
+  
+        transformAnnotationExpression(gfk.foreignKey, key, {
+          ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
+            // if the reference is a $self reference, we do nothing,
+            // as this is the way to tell that we do not reference the foreign key
+            if (ref[0] === '$self') return;
+            // if annotation was not propagated from the keys array during foreign keys creation,
+            // means that it is not a candidate for foreign key substitution
+            if (gfk.keyAnnotations !== null && !gfk.keyAnnotations.includes(key)) return;
+  
+            const art = gfk.originalKey._art || 
+            csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)).art; // OData uses getOriginatingKeyPath - as it relies on $path
             if (csnUtils.isManagedAssociation(art)) {
               if (!reportedErrorsForAnnoPath[path]) {
                 error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
@@ -31,15 +41,15 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
             } else {
               const gfkForRef = findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref);
               if (gfkForRef.length === 1) {
-                ref[0] = gfkForRef[0][0];
-
+                ref[0] = gfkForRef[0].prefix;
+  
                 if (ctx?.annoExpr?.['=']) {
                   ctx.annoExpr['='] = true;
                 }
               } else {
                 // check if the annotation reference points to a structure that has been expanded,
                 // if so -> report an error
-                const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk[2].$originalKeyRef), ref);
+                const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk.originalKey.$originalKeyRef), ref);
                 // references to expanded structures in flat mode will be found in the $originalKeyRef
                 // and in structured mode more than one match will be found in the generated foreign keys
                 if ((foundInOriginalRef.length || gfkForRef.length > 1) && !reportedErrorsForAnnoPath[path]) {
@@ -49,15 +59,15 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
               }
             }
           }
-        }
-      }, elementPath ? elementPath.concat(['keys', index]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
+        }, elementPath ? elementPath.concat(['keys', index]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
+      });
     });
-  });
+  }
 
   // During tuple expansion, the key ref object looses the $path, therefore
   // it needs to be extracted from the anno path
   function getOriginatingKeyPath(gfk, path) {
-    return gfk[2].$path || path.slice(0, path.findIndex(ps => ps[0] === '@'));
+    return gfk.originalKey.$path || path.slice(0, path.findIndex(ps => ps[0] === '@'));
   }
 
   // Loops through the generated foreign keys for this entity
@@ -65,15 +75,21 @@ function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, element
   // key ref. In case there are more than one foreign keys found,
   // that means the key ref points to a structured element/managed assoc
   function findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref) {
-    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk[2].as || implicitAs(gfk[2].ref))));
+    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk.originalKey.as || implicitAs(gfk.originalKey.ref))));
   }
 
   // Tuple expansion is performed before the generation of the foreign keys and the original(unexpanded) key ref
   // is stored in the property $originalKeyRef. Here we try to evaluate whether the reference in the annotation
   // points to a structure that has been expanded.
   function findOriginalRef(generatedForeignKeys, ref) {
-    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk[2].$originalKeyRef.as || implicitAs(gfk[2].$originalKeyRef.ref))));
+    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk.originalKey.$originalKeyRef.as || implicitAs(gfk.originalKey.$originalKeyRef.ref))));
   }
 }
 
-module.exports = adaptAnnotationsRefs;
+function remapToArrayOfObjects(generatedForeignKeys) {
+  return generatedForeignKeys.map(([ prefix, foreignKey, originalKey ]) => {
+    return { prefix, foreignKey, originalKey, keyAnnotations: null };
+  });
+}
+
+module.exports = { adaptAnnotationsRefs };