@sap/cds-compiler 5.9.4 → 6.0.12

package/lib/render/utils/unique.js

@@ -14,9 +14,9 @@ function renderUniqueConstraintString( constraint, constraintName, tableName, qu
   const c = constraint.paths;
   const refs = c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ');
   if (options.src === 'hdi')
-    return `UNIQUE INVERTED INDEX ${constraintName} ON ${tableName} (${refs})`;
+    return `UNIQUE INVERTED INDEX ${ constraintName } ON ${ tableName } (${ refs })`;
 
-  return `CONSTRAINT ${constraintName} UNIQUE (${refs})`;
+  return `CONSTRAINT ${ constraintName } UNIQUE (${ refs })`;
 }
 /**
  * Render the "ALTER TABLE XY DROP CONSTRAINT <Z>;"
@@ -28,7 +28,7 @@ function renderUniqueConstraintString( constraint, constraintName, tableName, qu
  * @returns {string}
  */
 function renderUniqueConstraintDrop( constraint, constraintName, tableName, quoteSqlId ) {
-  return `ALTER TABLE ${tableName} DROP CONSTRAINT ${quoteSqlId(constraintName)};`;
+  return `ALTER TABLE ${ tableName } DROP CONSTRAINT ${ quoteSqlId(constraintName) };`;
 }
 
 /**
@@ -42,7 +42,7 @@ function renderUniqueConstraintDrop( constraint, constraintName, tableName, quot
  * @returns {string}
  */
 function renderUniqueConstraintAdd( constraint, constraintName, tableName, quoteSqlId, options ) {
-  return `ALTER TABLE ${tableName} ADD ${renderUniqueConstraintString(constraint, constraintName, tableName, quoteSqlId, options)};`;
+  return `ALTER TABLE ${ tableName } ADD ${ renderUniqueConstraintString(constraint, constraintName, tableName, quoteSqlId, options) };`;
 }
 
 module.exports = {

package/lib/transform/db/applyTransformations.js

@@ -183,7 +183,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict )) {
       if (!isArtifactSkipped( dict, name )) {
-        artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
+        artifactTransformers.forEach(fn => fn(dict, name, dict[name], [ 'definitions' ]));
         dictEntry( dict, name, dict[name] );
       }
     }

package/lib/transform/db/assertUnique.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { forEachDefinition, hasAnnotationValue } = require('../../model/csnUtils');
+const { forEachDefinition } = require('../../model/csnUtils');
 const { getTransformers } = require('../transformUtils');
 const { pathName } = require('../../compiler/utils');
 
@@ -32,7 +32,7 @@ function processAssertUnique( csn, options, messageFunctions ) {
    */
   function handleAssertUnique( artifact, artifactName ) {
     // operate only on real entities that are not abstract
-    if (artifact.abstract || (artifact.kind !== 'entity' || (artifact.query || artifact.projection) && !hasAnnotationValue(artifact, '@cds.persistence.table')))
+    if (artifact.abstract || (artifact.kind !== 'entity' || (artifact.query || artifact.projection) && !artifact['@cds.persistence.table']))
       return;
     const constraintXrefs = Object.create(null);
     const constraintDict = Object.create(null);

package/lib/transform/db/associations.js

@@ -46,14 +46,14 @@ function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {},
     // of another association - see a few lines lower
     if (alreadyHandled.has(elem))
       return;
-    // Assemble an ON-condition with the foreign keys created in earlier steps
-    const onCondParts = [];
-    let joinWithAnd = false;
-    if (elem.keys.length === 0 && options.transformation !== 'effective') { // TODO: really kill instead of $ignore?
+    if ((!elem.keys || elem.keys.length === 0) && options.transformation !== 'effective') { // TODO: really kill instead of $ignore?
       elem.$ignore = true;
     }
     else {
-      for (const foreignKey of elem.keys) {
+      // Assemble an ON-condition with the foreign keys created in earlier steps
+      const onCondParts = [];
+      let joinWithAnd = false;
+      for (const foreignKey of elem.keys || []) {
         // Assemble left hand side of 'assoc.key = fkey'
         const assocKeyArg = {
           ref: [
@@ -70,9 +70,8 @@ function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {},
           ],
         };
 
-        if (joinWithAnd) { // more than one FK
+        if (joinWithAnd) // more than one FK
           onCondParts.push('and');
-        }
 
         onCondParts.push(
           assocKeyArg

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

@@ -1,7 +1,7 @@
 'use strict';
 
 const { getRealName } = require('../../../render/utils/common');
-const { ModelError } = require('../../../base/error');
+const { ModelError, CompilerAssertion } = require('../../../base/error');
 
 /**
  * Some shared transformation utilities between exists rewriting and general assoc to subselect rewriting
@@ -74,10 +74,10 @@ function getHelpers( csn, inspectRef, error ) {
       else if (typeof xpr.$env === 'number') {
         if (xpr.$scope === 'mixin')
           return '';
-        return error(null, xpr.$path, '$env with number is not handled yet - report this error!');
+        throw new CompilerAssertion(`$env with number is not handled yet - report this error! in ${ JSON.stringify(xpr.$path) }`);
       }
 
-      return error(null, xpr.$path, 'Boolean $env is not handled yet - report this error!');
+      throw new CompilerAssertion(`Boolean $env is not handled yet - report this error! in ${ JSON.stringify(xpr.$path) }`);
     }
     else if (xpr.ref) {
       throw new ModelError('Missing $env and missing leading artifact ref - throwing to trigger recompilation!');
@@ -364,8 +364,7 @@ function getHelpers( csn, inspectRef, error ) {
         }
         else if (part.$scope === '$self') { // source side - "absolute" scope
           // Same message as in forRelationalDB/transformDollarSelfComparisonWithUnmanagedAssoc
-          error(null, part.$path, { name: '$self' },
-                'An association that uses $(NAME) in its ON-condition can\'t be compared to "$self"');
+          error('type-invalid-self', part.$path, { name: '$self' });
         }
         else if (partInspect.art) { // source side - with local scope
           where.push({ ref: [ target, ...assoc.ref.slice(1, -1), ...part.ref ] });

package/lib/transform/db/backlinks.js

@@ -5,9 +5,9 @@ const {
 } = require('../../model/csnUtils');
 
 const { setProp } = require('../../base/model');
-const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
+const { ModelError } = require('../../base/error');
 
 /**
  * Get a function that transforms $self backlinks
@@ -188,25 +188,28 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
     // Check: The forward link <assocOp> must not contain '$self' in its own ON-condition
     if (assoc.on) {
       const containsDollarSelf = assoc.on.some(isDollarSelfOrProjectionOperand);
+      if (containsDollarSelf)
+        messageFunctions.error('type-invalid-self', path, { name: '$self' });
+    }
 
-      if (containsDollarSelf) {
-        messageFunctions.error(null, path, { name: '$self' },
-                               'An association that uses $(NAME) in its ON-condition can\'t be compared to $(NAME)');
-      }
+    if (!assoc.keys && !assoc.on) {
+      // Interpret no ON-condition/no keys like empty 'keys'.
+      if (options.transformation !== 'effective')
+        elem.$ignore = true;
+      return [];
     }
 
-    // Transform comparison of $self to managed association into AND-combined foreign key comparisons
     if (assoc.keys) {
-      if (assoc.keys.length)
+      // Transform comparison of $self to managed association into AND-combined foreign key comparisons
+      if (assoc.keys.length > 0)
         return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName, art, path);
 
       if (options.transformation !== 'effective')
         elem.$ignore = true;
       return [];
     }
-
-    // Transform comparison of $self to unmanaged association into "reversed" ON-condition
     else if (assoc.on) {
+      // Transform comparison of $self to unmanaged association into "reversed" ON-condition
       return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName, art, path);
     }
 

package/lib/transform/db/cdsPersistence.js

@@ -1,17 +1,18 @@
 'use strict';
 
 const {
-  forEachGeneric, forEachMemberRecursively, hasAnnotationValue, isPersistedOnDatabase,
+  forEachGeneric,
+  forEachMemberRecursively,
+  isPersistedOnDatabase,
+  hasPersistenceSkipAnnotation,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 
-const exists = '@cds.persistence.exists';
-
 /**
  * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
  * with $ignore.
  *
- * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback function for forEachDefinition
  */
 function getAnnoProcessor() {
   return handleCdsPersistence;
@@ -21,8 +22,8 @@ function getAnnoProcessor() {
   function handleCdsPersistence( artifact ) {
     const ignoreArtifact = (artifact.kind === 'entity') &&
                            (artifact.abstract ||
-                            hasAnnotationValue(artifact, '@cds.persistence.skip') ||
-                            hasAnnotationValue(artifact, exists));
+                            hasPersistenceSkipAnnotation(artifact) ||
+                            artifact['@cds.persistence.exists']);
     if (ignoreArtifact)
       artifact.$ignore = true;
   }
@@ -116,7 +117,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
    * @param {string} artifactName
    */
   function handleQueryish( artifact, artifactName ) {
-    const stripQueryish = artifact.query && hasAnnotationValue(artifact, '@cds.persistence.table');
+    const stripQueryish = artifact.query && artifact['@cds.persistence.table'];
 
     if (stripQueryish) {
       artifact.kind = 'entity';

package/lib/transform/db/constraints.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { forEachDefinition } = require('../../base/model');
-const { applyTransformations, hasAnnotationValue, getResultingName } = require('../../model/csnUtils');
+const { applyTransformations, getResultingName, hasPersistenceSkipAnnotation } = require('../../model/csnUtils');
 const { forEach, forEachKey } = require('../../utils/objectUtils');
 const { CompilerAssertion } = require('../../base/error');
 
@@ -292,10 +292,10 @@ function createReferentialConstraints( csn, options ) {
 
     // no constraint if either dependent or parent is not persisted
     if (
-      hasAnnotationValue(parent, '@cds.persistence.skip') ||
-      hasAnnotationValue(dependent, '@cds.persistence.skip') ||
-      hasAnnotationValue(parent, '@cds.persistence.exists') ||
-      hasAnnotationValue(dependent, '@cds.persistence.exists')
+      hasPersistenceSkipAnnotation(parent) ||
+      hasPersistenceSkipAnnotation(dependent) ||
+      parent['@cds.persistence.exists'] ||
+      dependent['@cds.persistence.exists']
     )
       return true;
 
@@ -351,12 +351,12 @@ function createReferentialConstraints( csn, options ) {
      */
     function assertForIndividual() {
       if (isAssertIntegrityAnnotationSetTo(DB) || element[CREATE_FOR_UP]) {
-        // if this is has a $self comparison, the up_ link should then result in a constraint
+        // if this is a $self comparison, the up_ link should then result in a constraint
         assignPropOnBacklinkIfPossible(CREATE_FOR_UP, true);
         return false;
       }
       if (options.assertIntegrityType === DB && isAssertIntegrityAnnotationSetTo(true)) {
-        // if this is has a $self comparison, the up_ link should then result in a constraint
+        // if this is a $self comparison, the up_ link should then result in a constraint
         assignPropOnBacklinkIfPossible(CREATE_FOR_UP, true);
         return false;
       }
@@ -397,14 +397,17 @@ function createReferentialConstraints( csn, options ) {
     }
 
     /**
-     * convenience to check if value of element's @assert.integrity annotation
-     * is the same as a given value
+     * 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.
      *
      * @param {string|boolean} value
      * @returns {boolean}
      */
     function isAssertIntegrityAnnotationSetTo( value ) {
-      return hasAnnotationValue(element, '@assert.integrity', value, true);
+      if (typeof element['@assert.integrity'] === 'string' && typeof value === 'string')
+        return element['@assert.integrity'].toUpperCase() === value.toUpperCase();
+      return element['@assert.integrity'] === value;
     }
 
     /**

package/lib/transform/db/expansion.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const {
-  hasAnnotationValue,
   applyTransformations,
   setDependencies,
   walkCsnPath,
@@ -39,7 +38,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     columns: (parent, name, columns, path) => {
       const artifact = csn.definitions[path[1]];
       csnUtils.initDefinition(artifact); // potentially not initialized, yet
-      if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
+      if (!artifact['@cds.persistence.table']) {
         const root = csnUtils.get$combined({ SELECT: parent });
         // TODO: replace with the correct options.transformation?
         // Do not expand the * in OData for a moment, not to introduce changes
@@ -87,7 +86,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         // (which is the thing inside SET/SELECT)
         // We can directly use SELECT here, as only projections and SELECT can have .columns
         const root = csnUtils.get$combined({ SELECT: parent });
-        if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
+        if (!artifact['@cds.persistence.table']) {
           // Make root look like normal .elements - we never cared about conflict afaik anyway
           Object.keys(root).forEach((key) => {
             root[key] = root[key][0].element;
@@ -395,6 +394,11 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
       const stack = [ [ parent, ref ] ];
       while (stack.length > 0) {
         const [ current, currentRef ] = stack.pop();
+
+        // '*' can't be used in function inside expand/inline, as it's not rewritten.
+        if (current.func && current.args?.[0] === '*')
+          error('query-unsupported-asterisk', current.$path, { code: `${ current.func }(*)` });
+
         if (current.xpr)
           rewriteSingleExpressionArray(current.xpr, currentRef, stack);
         if (current.args)

package/lib/transform/db/flattening.js

@@ -462,6 +462,9 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
    * @param {*} path
    */
   function flattenFKs( assoc, assocName, path ) {
+    if (!assoc.keys)
+      return; // managed to-many assoc
+
     // TODO Depth first search and not iterate mark and sweep approach
     let finished = false;
     while (!finished) {
@@ -713,18 +716,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
     return [];
 
   if (finalElement.target && !finalElement.on) {
-    const hasKeys = !!finalElement.keys;
-    if (!hasKeys) {
-      const target = csn.definitions[finalElement.target];
-
-      setProp(finalElement, 'keys', [ ] );
-      if (target && target.elements) {
-        finalElement.keys = Object.entries(target.elements).filter(([ _n, e ]) => e.key)
-          . map(([ n, _e ]) => ({ ref: [ n ], as: n }));
-      }
-    }
-    // TODO: has managed assoc keys?
-    finalElement.keys.forEach((key, keyIndex) => {
+    finalElement.keys?.forEach((key, keyIndex) => {
       const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
       const result = csnUtils.inspectRef(continuePath);
@@ -732,8 +724,6 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
         ref: key.ref, as: key.as, $path: key.$path, $originalKeyRef: key.$originalKeyRef,
       } : originalKey));
     });
-    if (!hasKeys)
-      delete finalElement.keys;
   }
   // return if the toplevel element is not a managed association
   else if (lvl === 0) {

package/lib/transform/db/processSqlServices.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../../base/model');
+const { hasPersistenceSkipAnnotation } = require('../../model/csnUtils');
 
 const sqlServiceAnnotation = '@protocol';
 
@@ -55,7 +56,7 @@ function isDummyService(artifact, options) {
  */
 function isEntityInSqlService(artifact, artifactName, csn, options) {
   const result = { sqlServiceName: undefined, dummyServiceName: undefined };
-  if (artifact.kind !== 'entity' || !artifactName.includes('.') || artifact['@cds.persistence.skip'] === true)
+  if (artifact.kind !== 'entity' || !artifactName.includes('.') || hasPersistenceSkipAnnotation(artifact))
     return result;
 
   const nameParts = artifactName.split('.');

package/lib/transform/db/temporal.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getNormalizedQuery, hasAnnotationValue, forEachMember,
+  getNormalizedQuery, forEachMember,
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
@@ -110,10 +110,9 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
       if (!Array.isArray(elt))
         elt = [ elt ];
       elt.forEach((e) => {
-        if (hasAnnotationValue(e.element, validFromString))
+        if (e.element[validFromString])
           from.push(e);
-
-        if (hasAnnotationValue(e.element, validToString))
+        if (e.element[validToString])
           to.push(e);
       });
     }
@@ -145,9 +144,8 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
         }
       }
     }
-    return fromElement && toElement &&
-          hasAnnotationValue(fromElement, validFromString, false) &&
-          hasAnnotationValue(toElement, validToString, false);
+    return fromElement && !fromElement[validFromString] &&
+           toElement && !toElement[validToString];
   }
 }
 

package/lib/transform/db/views.js

@@ -371,10 +371,8 @@ function getViewTransformer( csn, options, messageFunctions ) {
     }
 
     if (query && !hasNonAssocElements) {
-      // Complain if there are no elements other than unmanaged associations
-      // Allow with plain
-      error(null, [ 'definitions', artName ], { $reviewed: true },
-            'Expecting view or projection to have at least one element that is not an unmanaged association');
+      // Complain if there are no elements other than unmanaged associations or associations without keys.
+      error('def-missing-element', [ 'definitions', artName ], { '#': 'view' });
     }
 
     if (isSelect) {

package/lib/transform/draft/db.js

@@ -1,10 +1,10 @@
 'use strict';
 
 const {
-  hasAnnotationValue, getServiceNames, forEachDefinition,
+  getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
-const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
@@ -34,7 +34,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
 
   forEachDefinition(csn, generateDraft);
 
-  applyAnnotationsFromExtensions(csn, { filter: name => generatedArtifacts[name], applyToElements: false });
+  applyAnnotationsFromExtensions(csn, { filter: name => generatedArtifacts[name], applyToElements: false }, error);
 
   /**
    * Generate the draft stuff for a given artifact
@@ -44,7 +44,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
    */
   function generateDraft( artifact, artifactName ) {
     if ((artifact.kind === 'entity') &&
-        hasAnnotationValue(artifact, draftAnnotation) &&
+        artifact[draftAnnotation] &&
         isPartOfService(artifactName)) {
       // Determine the set of target draft nodes belonging to this draft root (the draft root
       // itself plus all its transitively composition-reachable targets)
@@ -93,13 +93,13 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
           continue;
         }
         // Barf if a draft node other than the root has @odata.draft.enabled itself
-        if (draftNode !== rootArtifact && hasAnnotationValue(draftNode, draftAnnotation)) {
+        if (draftNode !== rootArtifact && draftNode[draftAnnotation]) {
           error('ref-unexpected-draft-enabled', [ 'definitions', artifactName, 'elements', elemName ], { anno: '@odata.draft.enabled' });
           delete draftNodes[draftNodeName];
           continue;
         }
-        // Recurse unless already known
-        if (!hasAnnotationValue(draftNode, draftAnnotation, false) && !draftNodes[draftNodeName])
+        // Recurse unless already known. Check for explicit `false` on purpose.
+        if (draftNode[draftAnnotation] !== false && !draftNodes[draftNodeName])
           collectDraftNodesInto(draftNode, draftNodeName, rootArtifact, draftNodes);
       }
     }
@@ -193,7 +193,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
       }
       else {
         let elem;
-        if ((isDeprecatedEnabled(options, '_renderVirtualElements') && origElem.virtual) || !origElem.virtual)
+        if (!origElem.virtual)
           elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
         if (elem) {
           // Remove "virtual" - cap/issues 4956

package/lib/transform/draft/odata.js

@@ -36,7 +36,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
 
   const { error, info } = messageFunctions;
   const {
-    createAndAddDraftAdminDataProjection, isValidDraftAdminDataMessagesType, 
+    createAndAddDraftAdminDataProjection, isValidDraftAdminDataMessagesType,
     createScalarElement, createAssociationElement,
     createAssociationPathComparison, addElement,
     createAction, assignAction,
@@ -45,7 +45,6 @@ function generateDrafts( csn, options, services, messageFunctions ) {
   } = getTransformers(csn, options, messageFunctions);
   const {
     getServiceName,
-    hasAnnotationValue,
     getFinalTypeInfo,
   } = csnUtils;
 
@@ -74,7 +73,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
       generateDraftForOdata(def, defName, def);
   }, { skipArtifact: isExternalServiceMember });
 
-  applyAnnotationsFromExtensions(csn, { override: true, filter: name => filterDict[name] });
+  applyAnnotationsFromExtensions(csn, { override: true, filter: name => filterDict[name] }, error);
   rewriteDollarDraft();
 
   return csn;
@@ -101,7 +100,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
 
     if(!visitedArtifacts[artifactName])
       visitedArtifacts[artifactName] = artifact;
-    
+
     const draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
     assignAction(draftPrepare, artifact);
     // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
@@ -124,6 +123,8 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     if (!draftAdminDataProjection) {
       // @ts-ignore
       draftAdminDataProjection = createAndAddDraftAdminDataProjection(getServiceOfArtifact(artifactName, services));
+      filterDict[draftAdminDataProjectionName] = true;
+      filterDict['DRAFT.DraftAdministrativeData'] = true;
     }
     // Report an error if it is not an entity or not what we expect
     if (draftAdminDataProjection.kind !== 'entity' || !draftAdminDataProjection.elements.DraftUUID) {
@@ -217,11 +218,13 @@ function generateDrafts( csn, options, services, messageFunctions ) {
             // Ignore if that is our own draft root
             if (draftNode !== rootArtifact) {
               // Report error when the draft node has @odata.draft.enabled itself
-              if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
+              const draftEnabled = draftNode['@odata.draft.enabled'];
+              if (draftEnabled) {
                 error('ref-unexpected-draft-enabled', [ 'definitions', artifactName, 'elements', elemName ], { anno: '@odata.draft.enabled' });
               }
               // Ignore composition if it's target is not part of a service or explicitly draft disabled
-              else if (!getServiceName(elem.target) || hasAnnotationValue(draftNode, '@odata.draft.enabled', false)) {
+              // Only for explicit `false` annotation value, not for `undefined` or `null`.
+              else if (!getServiceName(elem.target) || draftEnabled === false) {
                 return;
               }
               else {
@@ -247,7 +250,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
      * After draft decoration, all visited artifacts are supposed to have the draft state elements
      * Is/HasActiveEntity, HasDraftEntity. Now, $draft.<postfix> (with postfix defined as magic variable
      * in the core compiler builtins) needs to be translated into $self.<postfix>.
-     * 
+     *
      * It has to be processed after the late 'applyAnnotationsFromExtensions' which could also merge in
      * some $draft path expressions.
   */

package/lib/transform/forOdata.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
+const { isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtils');
 const { forEachDefinition,
         forEachMemberRecursively,
@@ -28,6 +28,7 @@ const { addTenantFields } = require('./addTenantFields');
 const { addLocalizationViews } = require('./localized');
 const { cloneFullCsn } = require('../model/cloneCsn');
 const { csnRefs } = require('../model/csnRefs');
+const replaceForeignKeyRefsInExpressionAnnotations = require('./odata/foreignKeyRefsInXprAnnos');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
 // The result should be suitable for consumption by EDMX processors (annotations and metadata)
@@ -129,11 +130,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   if (options.tenantDiscriminator)
     addTenantFields(csn, options);
 
-  const keepLocalizedViews = isDeprecatedEnabled(options, '_createLocalizedViews');
-
   function acceptLocalizedView(_name, parent) {
     csn.definitions[parent].$localized = true;
-    return keepLocalizedViews && !isExternalServiceMember(undefined, parent);
+    return false; // don't keep the views
   }
 
   addLocalizationViews(csn, options, { acceptLocalizedView, ignoreUnknownExtensions: true });
@@ -192,6 +191,12 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
 
   createForeignKeyElements(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
 
+  // needs to be performed after creating foreign keys for the entire model,
+  // because of multiple managed associations in refs
+  replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
+
+  bindCsnReferenceOnly();
+
   if (!structuredOData) {
     const resolved = new WeakMap();
     const { inspectRef, effectiveType } = csnRefs(csn);
@@ -465,7 +470,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // a cardinality property is set to the association member
   // with the value { "min": 1 };
   function setCardinalityToNotNullAssociations(member) {
-    if (member.target && member.keys && !member.on) {
+    if (member.target && !member.on) {
       if (member.notNull) {
         if (member.cardinality === undefined)
           member.cardinality = {};