@sap/cds-compiler 4.5.0 → 4.6.0

package/lib/transform/addTenantFields.js

@@ -0,0 +1,228 @@
+// Add tenant field MANDT to entities
+
+// Prerequisites:
+
+// - the input CSN is a `client` style CSN from the Core Compiler
+// - using structure types with unmanaged associations is not supported by the
+//   Core Compiler (due to missing ON-rewrite)
+
+// TODO entities without MANDT:
+
+// - cache whether structure type contains (managed) association to entity with MANDT
+// - disallow use of such a type in entity without MANDT
+
+// Implementation remark:
+
+// - the functions `forEachDefinition` & friends in csnUtils.js have become quite
+//   (too) general and are probably slow → not used here
+
+'use strict';
+
+const { createMessageFunctions } = require( '../base/messages' );
+const { traverseQuery } = require( '../model/csnRefs' );
+
+const fieldName = 'tenant';
+const fieldDef = {
+  key: true,
+  type: 'cds.String',
+  length: 36,
+  '@cds.api.ignore': true, // and/or $generated: 'tenant' for the full Universal CSN?
+};
+
+function addTenantFields( csn, options ) {
+  const { definitions } = csn;
+  if (!definitions)
+    return csn;
+  const { error, throwWithError } = createMessageFunctions( options, 'tenant', csn );
+
+  const csnPath = [ 'definitions', '' ];
+  let projection;
+
+  for (const name in definitions) {
+    const art = definitions[name];
+    if (art?.kind !== 'entity')
+      continue;
+    csnPath[1] = name;
+
+    if (art['@cds.tenant.independent'] != null) {
+      error( null, csnPath, { anno: '@cds.tenant.independent' },
+             'Can\'t yet add annotation $(ANNO) to an entity' );
+    }
+    if (!handleElements( art ))
+      continue;
+    projection = art.query || art.projection && art;
+    if (projection)
+      traverseQuery( projection, null, null, handleQuery );
+  }
+
+  (csn.extensions || []).forEach( (ext, idx) => {
+    const tenant = ext.elements?.[fieldName];
+    const name = ext.annotate || ext.extend; // extend should not happen
+    if (tenant && definitions[name]?.kind === 'entity') { // TODO: ok for tenant-independent
+      error( null, [ 'extensions', idx, 'elements', 'tenant' ],
+             { name: fieldName },
+             'Can\'t annotate element $(NAME) of a tenant-dependent entity' );
+    }
+  } );
+
+  throwWithError();
+  return csn;                   // input CSN changed by side effect
+
+  function handleElements( art ) {
+    const { elements } = art;
+    if (elements[fieldName]) {
+      error( null, [ ...csnPath, 'elements', fieldName ], { name: fieldName },
+             'Can\'t add tenant field to entity having an element $(NAME)' );
+      return false;
+    }
+    if (!Object.values( elements ).some( e => e.key )) {
+      error( null, csnPath, {},
+             'There must be a key in a tenant-dependent entity' );
+      return false;
+    }
+    handleAssociations( art );
+    art.elements = { [fieldName]: { ...fieldDef }, ...elements };
+    return true;
+  }
+
+  function handleQuery( query ) {
+    // TODO: errors are temporary: start with simple projections only = no better
+    // message $location necessary yet
+    if (!projection)            // error already reported
+      return;
+    if (query.ref) {
+      if ((query.as || implicitAs( query.ref )) === fieldName) {
+        error( null, csnPath, { name: fieldName },
+               'Can\'t have a table alias named $(NAME) in a tenant-dependent entity' );
+      }
+      return;
+    }
+
+    const select = query.SELECT || query.projection;
+    if (query.SET || query !== projection || !select?.from?.ref) {
+      error( null, csnPath, {},
+             'Can\'t add tenant columns to non-simple query entities' );
+      projection = null;
+      return;
+    }
+
+    if (query.projection)
+      csnPath.push( 'projection' );
+    else
+      csnPath.push( 'query', 'SELECT' );
+
+    if (select.mixin)
+      handleMixins( select.mixin );
+    if (select.excluding)
+      checkExcluding( select.excluding );
+    if (select.columns)
+      handleColumns( select.columns );
+    // TODO: for subqueries, we might need to adapt the inferred elements
+    // TODO: where exists ref -
+    // TODO: select and query clauses, especially with aggregation functions
+    handleGroupBy( select );
+    csnPath.length = 2;
+  }
+
+  function handleMixins( mixin ) {
+    csnPath.push( 'mixin', '' );
+    for (const name in mixin) {
+      csnPath[csnPath.length - 1] = name;
+      if (name !== fieldName) {
+        addToCondition( mixin[name], name );
+      }
+      else {
+        error( null, csnPath, { name },
+               'Can\'t define a mixin named $(NAME) in a tenant-dependent entity' );
+      }
+    }
+    csnPath.length -= 2;
+  }
+
+  function checkExcluding( excludeList ) {
+    if (excludeList.includes( fieldName )) {
+      error( null, csnPath, { name: fieldName },
+             'Can\'t exclude $(NAME) from query source' );
+    }
+  }
+
+  function handleGroupBy( select ) {
+    // TODO: in the future, we allow model-wise keyless views when using
+    // aggregation function, and add a GROUP BY for MANDT in this case.  Now, also
+    // views with agg functions need to have a key element → it very likely
+    // already contains a GROUP BY. And anyway: if we miss to add GROUP BY MANDT,
+    // the database will complain → no safetly risk.
+    if (select.groupBy)
+      select.groupBy.unshift( { ref: [ fieldName ] } );
+  }
+
+  function handleColumns( columns ) {
+    let specifiedKey = false;
+    csnPath.push( 'columns', -1 );
+    for (const col of columns) {
+      ++csnPath[csnPath.length - 1];
+      if (col.expand || col.inline) {
+        error( null, csnPath, {},
+               'Can\'t use expand/inline in a tenant-dependent entity' );
+      }
+      if (col.key != null)      // yes, also with key: false
+        specifiedKey = true;
+      if (col.cast?.on) // REDIRECTED TO with explicit ON - TODO (low prio): less $self
+        addToCondition( col.cast, col.as || implicitAs( col.ref ) );
+    }
+    csnPath.length -= 2;
+    columns.unshift( specifiedKey
+      ? { key: true, ref: [ fieldName ] }
+      : { ref: [ fieldName ] } );
+  }
+
+  function handleAssociations( elem ) {
+    const { elements } = elem;
+    if (elements) {
+      csnPath.push( 'elements', '' );
+      for (const name in elements) {
+        csnPath[csnPath.length - 1] = name;
+        handleAssociations( elements[name] );
+      }
+      csnPath.length -= 2;
+    }
+    else if (elem.target) {
+      if (elem.on) {
+        addToCondition( elem, csnPath[csnPath.length - 1] );
+      }
+      else {
+        error( null, csnPath, {},
+               'Can\'t yet use managed associations in a tenant-dependent entity' );
+      }
+    }
+    else if (elem.items) {
+      csnPath.push( 'items' );
+      handleAssociations( elem.items );
+      --csnPath.length;
+    }
+  }
+
+  function addToCondition( elem, assoc ) {
+    if (!elem.on)
+      return;
+    const withSelf = csnPath.length > 4;
+    elem.on = [
+      { ref: [ assoc, fieldName ] }, // TODO: consider assoc name starting with '$'
+      '=',
+      { ref: (withSelf) ? [ '$self', fieldName ] : [ fieldName ] },
+      'and',
+      // TODO: avoid (...) for standard AND-ed EQ-comparisons ?
+      { xpr: elem.on },
+    ];
+  }
+}
+
+function implicitAs( ref ) {
+  const item = ref[ref.length - 1];
+  const id = (typeof item === 'string') ? item : item.id;
+  return id.substring( id.lastIndexOf('.') + 1 );
+}
+
+module.exports = {
+  addTenantFields,
+};

package/lib/transform/db/applyTransformations.js

@@ -13,7 +13,7 @@
 
 
 const { setProp } = require('../../base/model');
-const { xprInAnnoProperties } = require('../../compiler/builtins');
+const { isAnnotationExpression } = require('../../compiler/builtins');
 
 
 /**
@@ -148,7 +148,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    */
   function annotation( _parent, _prop, node ) {
     if (options.processAnnotations) {
-      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+      if (isAnnotationExpression(node)) {
         standard(_parent, _prop, node);
       }
       else if (node && typeof node === 'object') {
@@ -299,47 +299,43 @@ function applyTransformationsOnDictionary( dictionary, customTransformers = {},
 /**
  * transformExpression is a lightweight version of applyTransformations
  * used primarily to transform annotation expressions.
+ * If propName is undefined, all properties of parent are transformed.
  * @param {object} parent Start node
- * @param {object} customTransformers Map of callback functions
+ * @param {string} propName Start at specific property of parent
+ * @param {object} transformers Map of callback functions
  * @param {CSN.Path} path Path to parent
- * @returns {object} transformed parent
+ * @returns {object} transformed node
  */
-function transformExpression( parent, customTransformers, path = [] ) {
-  const csnPath = [ ...path ];
-  /**
-   *
-   * @param {object} _parent
-   * @param {string} _prop
-   * @param {object} node
-   */
-  function standard( _parent, _prop, node ) {
-    if (!node || typeof node !== 'object' ||
-        !{}.propertyIsEnumerable.call( _parent, _prop ) ||
-        (typeof _prop === 'string' && _prop.startsWith('@')))
-      return;
-
-
-    csnPath.push(_prop);
-    if (Array.isArray(node)) {
-      node.forEach( (n, i) => standard( node, i, n ) );
+function transformExpression( parent, propName, transformers, path = [] ) {
+  if (propName != null) {
+    const child = parent[propName];
+    if (!child || typeof child !== 'object' ||
+        !{}.propertyIsEnumerable.call( parent, propName ))
+      return parent;
+
+    path = [ ...path, propName ];
+    if (Array.isArray(child)) {
+      child.forEach( (n, i) => transformExpression( child, i, transformers, path ) );
     }
     else {
-      for (const name of Object.getOwnPropertyNames( node )) {
-        const ct = customTransformers[name];
+      for (const cpn of Object.getOwnPropertyNames( child )) {
+        const ct = transformers[cpn];
         if (ct) {
+          const ppn = propName;
           if (Array.isArray(ct))
-            ct.forEach(cti => cti(node, name, node[name], csnPath, _parent, _prop));
+            ct.forEach(cti => cti(child, cpn, child[cpn], path, parent, ppn));
+
           else
-            ct(node, name, node[name], csnPath, _parent, _prop);
+            ct(child, cpn, child[cpn], path, parent, ppn);
         }
-        standard(node, name, node[name]);
+        transformExpression(child, cpn, transformers, path);
       }
     }
-    csnPath.pop();
   }
-
-  for (const name of Object.getOwnPropertyNames( parent ))
-    standard( parent, name, parent[name] );
+  else {
+    for (propName of Object.getOwnPropertyNames( parent ))
+      transformExpression( parent, propName, transformers, path );
+  }
   return parent;
 }
 

package/lib/transform/db/assertUnique.js

@@ -16,12 +16,12 @@ const { pathName } = require('../../compiler/utils');
  *
  * @param {CSN.Model} csn Overall CSN model
  * @param {CSN.Options} options Options
- * @param {Function} error Message function for errors
- * @param {Function} info Message function for info
+ * @param {object} messageFunctions Message functions (error(), info(), …)
  * @returns {Function} forEachDefinition callback
  */
-function processAssertUnique( csn, options, error, info ) {
-  const { resolvePath, flattenPath } = getTransformers(csn, options);
+function processAssertUnique( csn, options, messageFunctions ) {
+  const { resolvePath, flattenPath } = getTransformers(csn, options, messageFunctions);
+  const { error, info } = messageFunctions;
 
   return handleAssertUnique;
   /**

package/lib/transform/db/cdsPersistence.js

@@ -106,7 +106,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
   const { error } = messageFunctions;
   const {
     recurseElements,
-  } = transformUtils.getTransformers(csn, options, '_');
+  } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
 
   return handleQueryish;
 

package/lib/transform/db/flattening.js

@@ -9,8 +9,8 @@ const transformUtils = require('../transformUtils');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
-const { cardinality2str } = require('../../model/csnUtils');
-
+const { cardinality2str, isAnnotationExpression } = require('../../model/csnUtils');
+const { transformExpression } = require('./applyTransformations');
 /**
  * Strip off leading $self from refs where applicable
  *
@@ -42,11 +42,12 @@ function removeLeadingSelf( csn ) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {WeakMap} resolved Cache for resolved refs
  * @param {string} pathDelimiter
  * @param {object} iterateOptions
  */
-function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOptions = {} ) {
+function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDelimiter, iterateOptions = {} ) {
   /**
    * Remove .localized from the element and any sub-elements
    *
@@ -67,7 +68,7 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
         stack.push(...Object.values(current.elements));
     }
   }
-  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { getServiceName, getFinalTypeInfo } = csnUtils;
 
   // We don't want to iterate over actions
@@ -95,18 +96,17 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
 
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
-        let nextElements = node.elements || node.items?.elements;
-        if (nextElements) {
-          const stack = [ nextElements ];
-          while (stack.length > 0) {
-            const elements = stack.pop();
-            for (const e of Object.values(elements)) {
-              if (e.type && !isBuiltinType(e.type))
-                toFinalBaseType(e, resolved, true);
-              nextElements = e.elements || e.items?.elements;
-              if (nextElements)
-                stack.push(nextElements);
-            }
+        const nextElements = node.elements || node.items?.elements;
+        const stack = nextElements ? [ nextElements ] : [];
+        while (stack.length > 0) {
+          const elements = stack.pop();
+          for (const e of Object.values(elements)) {
+            toFinalBaseType(e, resolved, true);
+            if (!options.toOdata && e.items) // items could have unresolved types
+              toFinalBaseType(e.items, resolved, true);
+            const next = e.elements || e.items?.elements;
+            if (next)
+              stack.push(next);
           }
         }
 
@@ -164,20 +164,21 @@ function resolveTypeReferences( csn, options, resolved, pathDelimiter, iterateOp
    */
   function isODataItems( typeName ) {
     const typeDef = csn.definitions[typeName];
-    return !!(options.toOdata && typeDef && typeDef.items);
+    return !!(options.toOdata && typeDef && typeDef?.items);
   }
 }
 
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {WeakMap} resolved Cache for resolved refs
  * @param {string} pathDelimiter
  * @param {object} iterateOptions
  */
-function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, iterateOptions = {} ) {
+function flattenAllStructStepsInRefs( csn, options, messageFunctions, resolved, pathDelimiter, iterateOptions = {} ) {
   const { inspectRef, effectiveType } = csnRefs(csn);
-  const { flattenStructStepsInRef } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { flattenStructStepsInRef } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   const adaptRefs = [];
 
   /**
@@ -258,12 +259,13 @@ function flattenAllStructStepsInRefs( csn, options, resolved, pathDelimiter, ite
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {string} pathDelimiter
- * @param {Function} error
  * @param {object} iterateOptions
  */
-function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {} ) {
-  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+function flattenElements( csn, options, messageFunctions, pathDelimiter, iterateOptions = {} ) {
+  const { error } = messageFunctions;
+  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { isAssocOrComposition, effectiveType } = csnUtils;
   const transformers = {
     elements: flatten,
@@ -309,33 +311,28 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
           if (flatElement.notNull !== false && !branch.some(s => !s.notNull))
             flatElement.notNull = true;
 
-
           if (flatElement.type && isAssocOrComposition(flatElement) && flatElement.on) {
             // unmanaged relations can't be primary key
             delete flatElement.key;
-            // Make refs resolvable by fixing the first ref step
-            for (const onPart of flatElement.on) {
-              if (onPart.ref) {
-                const firstRef = onPart.ref[0];
-
-                /*
-                  when element is defined in the current name resolution scope, like
-                    entity E {
-                      key x: Integer;
-                          s : {
-                          y : Integer;
-                          a3 : association to E on a3.x = y;
-                          }
-                    }
-                  We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
-                */
+            transformExpression(flatElement, 'on', {
+              ref: (_parent, _prop, xpr) => {
                 const prefix = flatElement._flatElementNameWithDots.split('.').slice(0, -1).join(pathDelimiter);
-                const possibleFlatName = prefix + pathDelimiter + firstRef;
-
+                const possibleFlatName = prefix + pathDelimiter + xpr[0];
+                /*
+                    when element is defined in the current name resolution scope, like
+                      entity E {
+                        key x: Integer;
+                            s : {
+                            y : Integer;
+                            a3 : association to E on a3.x = y;
+                            }
+                      }
+                    We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
+                  */
                 if (flatElems[possibleFlatName])
-                  onPart.ref[0] = possibleFlatName;
-              }
-            }
+                  xpr[0] = possibleFlatName;
+              },
+            });
           }
           parent[prop].$orderedElements.push([ flatElemName, flatElement ]);
           // Still add them - otherwise we might not detect collisions between generated elements.
@@ -434,16 +431,16 @@ function linkForeignKeyAnnotationExtensionsToAssociation( csn, options ) {
 /**
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param {Function} error
- * @param {Function} warning
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @param {string} pathDelimiter
  * @param {boolean} flattenKeyRefs
  * @param {object} csnUtils
  * @param {object} iterateOptions
  */
-function handleManagedAssociationsAndCreateForeignKeys( csn, options, error, warning, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
+function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFunctions, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
+  const { error, warning } = messageFunctions;
   const { isManagedAssociation, inspectRef, isStructured } = csnUtils;
-  const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   if (flattenKeyRefs) {
     applyTransformations(csn, {
       elements: (parent, prop, elements, path) => {
@@ -814,6 +811,29 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
     return [ [ prefix, newFk ] ];
   }
 
+  fks.forEach((fk) => {
+    // prepend current prefix
+    fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
+    // if this is the entry association, decorate the final foreign keys with the association props
+    if (lvl === 0) {
+      if (options.transformation !== 'effective')
+        fk[1]['@odata.foreignKey4'] = prefix;
+      if (options.transformation === 'odata' || options.transformation === 'effective') {
+        const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !isAnnotationExpression(element[pn]));
+        copyAnnotations(element, fk[1], true, {}, validAnnoNames);
+      }
+      // propagate not null to final foreign key
+      for (const prop of [ 'notNull', 'key' ]) {
+        if (element[prop] !== undefined)
+          fk[1][prop] = element[prop];
+      }
+      if (element.$location)
+        setProp(fk[1], '$location', element.$location);
+    }
+  });
+  return fks;
+
+
   /**
    * Get the path to continue resolving references
    *
@@ -834,27 +854,6 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       return [ path, ...additions ];
     return [ ...path, ...additions ];
   }
-
-  fks.forEach((fk) => {
-    // prepend current prefix
-    fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
-    // if this is the entry association, decorate the final foreign keys with the association props
-    if (lvl === 0) {
-      if (options.transformation !== 'effective')
-        fk[1]['@odata.foreignKey4'] = prefix;
-      if (options.transformation === 'odata' || options.transformation === 'effective')
-        copyAnnotations(element, fk[1], true);
-
-      // propagate not null to final foreign key
-      for (const prop of [ 'notNull', 'key' ]) {
-        if (element[prop] !== undefined)
-          fk[1][prop] = element[prop];
-      }
-      if (element.$location)
-        setProp(fk[1], '$location', element.$location);
-    }
-  });
-  return fks;
 }
 
 module.exports = {

package/lib/transform/db/temporal.js

@@ -171,7 +171,7 @@ function getAnnotationHandler( csn, options, pathDelimiter, messageFunctions ) {
   const { error } = messageFunctions;
   const {
     extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments, recurseElements,
-  } = getTransformers(csn, options, pathDelimiter);
+  } = getTransformers(csn, options, messageFunctions, pathDelimiter);
 
   return handleTemporalAnnotations;
   /**

package/lib/transform/draft/db.js

@@ -26,7 +26,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   const {
     createForeignKeyElement, createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
     addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
-  } = getTransformers(csn, options, pathDelimiter);
+  } = getTransformers(csn, options, messageFunctions, pathDelimiter);
   const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
   const generatedArtifacts = Object.create(null);
@@ -122,26 +122,12 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
 
     generatedArtifacts[draftsArtifactName] = true;
 
-    // extract keys for UUID inspection
-    const keys = [];
+    // TODO: Do we really need this? Is this possibly done by a validator earlier?
     forEachMemberRecursively(artifact, (elt, name, prop, path) => {
       if (!elt.elements && !elt.type && !elt.virtual) // only check leafs
         error(null, path, 'Expecting element to have a type when used in a draft-enabled artifact');
-      if (elt.key && elt.key === true && !elt.virtual)
-        keys.push(elt);
     }, [ 'definitions', artifactName ], false, { elementsOnly: true });
 
-    // In contrast to EDM, the DB entity may have more than one technical keys but should have ideally exactly one key of type cds.UUID
-    if (keys.length !== 1) {
-      warning(null, [ 'definitions', artifactName ], { count: keys.length },
-              'Entity annotated with “@odata.draft.enabled” should have exactly one key element, but found $(COUNT)');
-    }
-    else {
-      const uuidCount = keys.reduce((acc, k) => ((k.type === 'cds.UUID' || k.type === 'cds.String' && k.$renamed === 'cds.UUID' && k.length === 36) ? acc + 1 : acc), 0);
-      if (uuidCount === 0)
-        warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
-    }
-
     // Ignore boolean return value. We know that we're inside a service or else we wouldn't have reached this code.
     const matchingService = getMatchingService(artifactName) || '';
     // Generate the DraftAdministrativeData projection into the service, unless there is already one

package/lib/transform/draft/odata.js

@@ -27,21 +27,21 @@ const { makeMessageFunction } = require('../../base/messages');
  * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
  */
 function generateDrafts( csn, options, services ) {
+  const messageFunctions = makeMessageFunction(csn, options, 'for.odata');
+  const { error, info } = messageFunctions;
   const {
     createAndAddDraftAdminDataProjection, createScalarElement,
     createAssociationElement, createAssociationPathComparison,
     addElement, createAction, assignAction,
     resetAnnotation,
     csnUtils,
-  } = getTransformers(csn, options);
+  } = getTransformers(csn, options, messageFunctions);
   const {
     getServiceName,
     hasAnnotationValue,
     getFinalTypeInfo,
   } = csnUtils;
 
-  const { error, info } = makeMessageFunction(csn, options, 'for.odata');
-
   if (!services)
     services = getServiceNames(csn);