@sap/cds-compiler 4.3.2 → 4.4.2

package/lib/render/utils/common.js

@@ -333,6 +333,81 @@ function getDefaultTypeLengths( sqlDialect ) {
   return { ...sqlDefaultLengths.default, ...sqlDefaultLengths[sqlDialect] };
 }
 
+/**
+ * Maps $-variables per SQL dialect to a renderable expression.
+ * Callers can use `.fallback` in case the wanted dialect is not found.
+ *
+ * IMPORTANT: There is no sqlDialect better-sqlite. This "fake" dialect is
+ *            set in variableForDialect() below.
+ *
+ * @type {object}
+ */
+const variablesToSql = {
+  fallback: {
+    // no fallback for $user.id and $user.tenant -> warning in call-site
+    '$user.locale': '\'en\'',
+    // $at.* are handled in all dialects -> there is no need for a fallback
+  },
+  hana: {
+    '$user.id': "SESSION_CONTEXT('APPLICATIONUSER')",
+    '$user.locale': "SESSION_CONTEXT('LOCALE')",
+    '$user.tenant': "SESSION_CONTEXT('TENANT')",
+    '$at.from': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-FROM'))",
+    '$at.to': "TO_TIMESTAMP(SESSION_CONTEXT('VALID-TO'))",
+  },
+  postgres: {
+    '$user.id': "current_setting('cap.applicationuser')",
+    '$user.locale': "current_setting('cap.locale')",
+    '$user.tenant': "current_setting('cap.tenant')",
+    '$at.from': "current_setting('cap.valid_from')::timestamp",
+    '$at.to': "current_setting('cap.valid_to')::timestamp",
+  },
+  'better-sqlite': {
+    '$user.id': "session_context( '$user.id' )",
+    '$user.locale': "session_context( '$user.locale' )",
+    '$user.tenant': "session_context( '$user.tenant' )",
+    '$at.from': "session_context( '$valid.from' )",
+    '$at.to': "session_context( '$valid.to' )",
+  },
+  sqlite: {
+    // For sqlite, we render the string-format-time (strftime) function.
+    // Because the format of `current_timestamp` is like that: '2021-05-14 09:17:19' whereas
+    // the format for timestamps (at least in Node.js) is like that: '2021-01-01T00:00:00.000Z'
+    // --> Therefore the comparison in the temporal where clause doesn't work properly.
+    '$at.from': "strftime('%Y-%m-%dT%H:%M:%S.000Z', 'now')",
+    // + 1ms compared to $at.from
+    '$at.to': "strftime('%Y-%m-%dT%H:%M:%S.001Z', 'now')",
+  },
+  plain: {
+    '$at.from': 'current_timestamp',
+    '$at.to': 'current_timestamp',
+  },
+  h2: {
+    '$user.id': '@applicationuser',
+    '$user.locale': '@locale',
+    '$user.tenant': '@tenant',
+    '$at.from': '@valid_from',
+    '$at.to': '@valid_to',
+  },
+};
+
+/**
+ * Get a renderable string for given variable for the given options.sqlDialect.
+ * Note that this function does not handle `variableReplacements`.  Callers should
+ * first check if the user has specified them and use them instead.
+ *
+ * @param {SqlOptions} options Used for `sqlDialect` and better-sqlite option.
+ * @param {string} variable Variable to render, e.g. `$user.id`.
+ * @return {string|null} `null` if the variable could not be found for the given dialect and in the fallback values.
+ */
+function variableForDialect( options, variable ) {
+  const dialect = options.sqlDialect === 'sqlite' && options.betterSqliteSessionVariables
+    ? 'better-sqlite'
+    : options.sqlDialect;
+  return variablesToSql[dialect]?.[variable] || variablesToSql.fallback[variable] || null;
+}
+
+
 /**
  * Get the element matching the column
  *
@@ -614,6 +689,7 @@ module.exports = {
   addContextMarkers,
   cdsToSqlTypes,
   cdsToHdbcdsTypes,
+  variableForDialect,
   hasHanaComment,
   getHanaComment,
   findElement,

package/lib/render/utils/delta.js

@@ -71,7 +71,7 @@ class DeltaRenderer {
   /**
    * Render column modifications as SQL.
    */
-  alterColumns(artifactName, columnName, delta, definitionsStr) {
+  alterColumns(artifactName, columnName, delta, definitionsStr, _eltName, _env) {
     return [ `ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER (${definitionsStr});` ];
   }
 
@@ -177,14 +177,28 @@ class DeltaRendererPostgres extends DeltaRenderer {
   /**
    * Render column modifications as Postgres SQL - no ( ), special NOT NULL.
    */
-  alterColumns(artifactName, columnName, delta, definitionsStr) {
+  alterColumns(artifactName, columnName, delta, definitionsStr, eltName, env) {
     const sqls = [];
     if (delta.new.notNull === true || delta.new.key === true)
       definitionsStr = definitionsStr.replace(' NOT NULL', ''); // TODO: Is this robust enough?
     else if (delta.new.notNull === false || delta.new.$notNull === false)
       definitionsStr = definitionsStr.replace(' NULL', ''); // TODO: Is this robust enough?
 
-    sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};`);
+    if (delta.old.default && !delta.old.value) // Drop old default if any exists
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER COLUMN ${columnName} DROP DEFAULT;`);
+
+    if (delta.new.default && !delta.new.value ) { // Alter column with default
+      const df = delta.new.default;
+      delete delta.new.default;
+      const eltStrNoDefault = this.scopedFunctions.renderElement(eltName, delta.new, null, null, env);
+      delta.new.default = df;
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${eltStrNoDefault};`);
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER COLUMN ${columnName} SET DEFAULT ${this.scopedFunctions.renderExpr(delta.new.default, env.withSubPath('default'))};`);
+    }
+    else { // Alter column without default
+      sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${definitionsStr};`);
+    }
+
     if (delta.new.notNull && !delta.old.notNull)
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${columnName} SET NOT NULL;`);
     else if (delta.old.notNull && !delta.new.notNull)

package/lib/sql-identifier.js

@@ -18,7 +18,7 @@
 //
 // Using the provided function smartId() instead of an identity function avoids
 // this situation: it constructs delimited identifiers for the reserved names.
-// Other names are returned directly to to avoid that people think that they
+// Other names are returned directly to avoid that people think that they
 // had to use all-upper names in CDS.
 
 // Please note that `.` to `_` replacements (and similar replacements for the

package/lib/transform/db/.eslintrc.json

@@ -3,6 +3,7 @@
   "plugins": ["sonarjs", "jsdoc"],
   "extends": ["plugin:jsdoc/recommended", "../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
+    "cds-compiler/message-no-quotes": "off",
     "prefer-const": "error",
     "quotes": ["error", "single", "avoid-escape"],
     "prefer-template": "error",

package/lib/transform/db/applyTransformations.js

@@ -13,6 +13,7 @@
 
 
 const { setProp } = require('../../base/model');
+const { xprInAnnoProperties } = require('../../compiler/builtins');
 
 
 /**
@@ -40,6 +41,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     mixin: dictionary,
     ref: pathRef,
     $origin: () => {}, // no-op
+    '@': annotation,
   };
 
   const csnPath = [ ...path ];
@@ -48,7 +50,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   }
   else if (options.directDict) {
     for (const name of Object.getOwnPropertyNames( parent ))
-      standard( parent, name, parent[name] );
+      dictEntry( parent, name, parent[name] );
   }
   else {
     standard( parent, prop, parent[prop] );
@@ -67,7 +69,6 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   function standard( _parent, _prop, node ) {
     if (!node || typeof node !== 'object' ||
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
-        (typeof _prop === 'string' && _prop.startsWith('@')) ||
         (options.skipIgnore && node.$ignore) ||
         options.skipStandard?.[_prop]
     )
@@ -81,7 +82,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
 
     else {
       for (const name of Object.getOwnPropertyNames( node )) {
-        const trans = transformers[name] || standard;
+        const trans = transformers[name] || transformers[name.charAt(0)] || standard;
         if (customTransformers[name])
           customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
         trans( node, name, node[name], csnPath );
@@ -105,7 +106,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
 
     csnPath.push( entryName );
     for (const name of Object.getOwnPropertyNames( node )) {
-      const trans = transformers[name] || standard;
+      const trans = transformers[name] || transformers[name.charAt(0)] || standard;
       if (customTransformers[name])
         customTransformers[name](node, name, node[name], csnPath, dict);
       trans( node, name, node[name], csnPath );
@@ -133,6 +134,30 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     csnPath.pop();
   }
 
+  /**
+   * Transformer for things that are annotations. When we have a "=" plus an expression of some sorts,
+   * we treat it like a "standard" thing.
+   *
+   * @param {object | Array} _parent the thing that has _prop
+   * @param {string|number} _prop the name of the current property or index
+   * @param {object} node The value of node[_prop]
+   */
+  function annotation( _parent, _prop, node ) {
+    if (options.processAnnotations) {
+      if (node?.['='] !== undefined && xprInAnnoProperties.some(xProp => node[xProp] !== undefined)) {
+        standard(_parent, _prop, node);
+      }
+      else if (node && typeof node === 'object') {
+        csnPath.push(_prop);
+
+        for (const name of Object.getOwnPropertyNames( node ))
+          annotation( node, name, node[name] );
+
+        csnPath.pop();
+      }
+    }
+  }
+
   /**
    * Special version of "dictionary" to apply artifactTransformers.
    *
@@ -279,4 +304,5 @@ module.exports = {
  * @property {object} [skipDict] stop drill-down on certain "dictionary" props
  * @property {boolean} [skipIgnore=true] Whether to skip $ignore elements or not
  * @property {boolean} [directDict=false] Implicitly set via applyTransformationsOnDictionary
+ * @property {boolean} [processAnnotations=false] Wether to process annotations and call custom transformers on them
  */

package/lib/transform/db/associations.js

@@ -13,9 +13,11 @@ const {
  * @param {CSN.Model} csn
  * @param {object} csnUtils
  * @param {string} pathDelimiter
+ * @param {object} [iterateOptions={}]
+ * @param {CSN.Options} [options={}]
  * @returns {CSN.Model} Return the input csn, with the transformations applied
  */
-function attachOnConditions( csn, csnUtils, pathDelimiter ) {
+function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {}, options = {} ) {
   const { isManagedAssociation } = csnUtils;
 
   const alreadyHandled = new WeakMap();
@@ -27,8 +29,8 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
         if (isManagedAssociation(elem))
           transformManagedAssociation(elem, elemName);
       }
-    },     /* only for views and entities */
-  }, [], { skipIgnore: false, allowArtifact: artifact => (artifact.kind === 'entity') });
+    },                                      /* only for views and entities */
+  }, [], Object.assign({ skipIgnore: false, allowArtifact: artifact => (artifact.kind === 'entity') }, iterateOptions));
 
   return csn;
 
@@ -47,7 +49,7 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
     // Assemble an ON-condition with the foreign keys created in earlier steps
     const onCondParts = [];
     let joinWithAnd = false;
-    if (elem.keys.length === 0) { // TODO: really kill instead of $ignore?
+    if (elem.keys.length === 0 && options.transformation !== 'effective') { // TODO: really kill instead of $ignore?
       elem.$ignore = true;
     }
     else {
@@ -55,12 +57,15 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
         // Assemble left hand side of 'assoc.key = fkey'
         const assocKeyArg = {
           ref: [
+            ...elemName.startsWith('$') ? [ '$self' ] : [],
             elemName,
-          ].concat(foreignKey.ref),
+            ...foreignKey.ref,
+          ],
         };
         const fkName = `${elemName}${pathDelimiter}${foreignKey.as || implicitAs(foreignKey.ref)}`;
         const fKeyArg = {
           ref: [
+            ...fkName.startsWith('$') ? [ '$self' ] : [],
             fkName,
           ],
         };
@@ -104,9 +109,10 @@ function attachOnConditions( csn, csnUtils, pathDelimiter ) {
  * @param {CSN.Model} csn
  * @param {object} csnUtils
  * @param {string} pathDelimiter
+ * @param {boolean} [processOnInQueries=false] Wether to process on-conditions in queries (joins and mixins)
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
+function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries = false ) {
   const {
     inspectRef,
   } = csnUtils;
@@ -174,10 +180,16 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter ) {
     }
 
     if (artifact.query || artifact.projection) {
-      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', {
-        orderBy: (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path),
-        groupBy: (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path),
-      }, {}, [ 'definitions', artifactName ]);
+      const transform = (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path);
+      const queryTransformers = {
+        orderBy: transform,
+        groupBy: transform,
+        where: transform,
+        having: transform,
+      };
+      if (processOnInQueries)
+        queryTransformers.on = transform;
+      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, {}, [ 'definitions', artifactName ]);
     }
 
 

package/lib/transform/db/backlinks.js

@@ -28,7 +28,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
   function transformSelfInBacklinks( artifact, artifactName, dummy, path ) {
     // Fixme: For toHana mixins must be transformed, for toSql -d hana
     // mixin elements must be transformed, why can't toSql also use mixins?
-    if (artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
+    if (options.transformation === 'effective' && artifact.elements || artifact.kind === 'entity' || artifact.query || (options.forHana && options.sqlMapping === 'hdbcds' && artifact.kind === 'type'))
       processDict(artifact.elements, path.concat([ 'elements' ]));
     if (artifact.query?.SELECT?.mixin)
       processDict(artifact.query.SELECT.mixin, path.concat([ 'query', 'SELECT', 'mixin' ]));
@@ -66,6 +66,9 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
     // Don't add braces if it is a single expression (ignoring superfluous braces)
     const multipleExprs = elem.on.filter(x => x !== '(' && x !== ')' ).length > 3;
     elem.on = processExpressionArgs(elem.on, pathToOn);
+    const column = csnUtils.getColumn(elem);
+    if (column?.cast?.on) // avoid difference between column and element
+      column.cast.on = elem.on;
 
     /**
      * Process the args
@@ -187,7 +190,8 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
       if (assoc.keys.length)
         return transformDollarSelfComparisonWithManagedAssoc(assocOp, assoc, assocName, elemName);
 
-      elem.$ignore = true;
+      if (options.transformation !== 'effective')
+        elem.$ignore = true;
       return [];
     }
 

package/lib/transform/db/expansion.js

@@ -33,7 +33,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     },
     columns: (parent, name, columns, path) => {
       const artifact = csn.definitions[path[1]];
-      csnUtils.initDefinition(artifact); // potentially no initialized, yet
+      csnUtils.initDefinition(artifact); // potentially not initialized, yet
       if (!hasAnnotationValue(artifact, '@cds.persistence.table')) {
         const root = csnUtils.get$combined({ SELECT: parent });
         // TODO: replace with the correct options.transformation?
@@ -719,7 +719,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
             }
           }
           else { // the thing is not shadowed - use the name from the base
-            const col = { ref: [ part ] };
+            const col = part.startsWith('$') ? { ref: [ base[part][0].parent, part ] } : { ref: [ part ] };
             if (isComplexQuery) // $env: tableAlias
               setProp(col, '$env', base[part][0].parent);
 

package/lib/transform/db/transformExists.js

@@ -273,14 +273,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           ref, head, tail,
         } = getFirstAssoc(current, exprPath.concat(i));
 
-        const lastAssoc = getLastAssoc(current, exprPath.concat(i));
-        // toE.toF.id -> we must not end on a non-assoc - this will also be caught downstream by
-        // '“EXISTS” can only be used with associations/compositions, found $(TYPE)'
-        // But the error might not be clear, since it could be because of our rewritten stuff. The later check
-        // checks for exists id -> our rewrite turns toE.toF.id into toE[exists toF[exists id]], leading to the same error
-        if (lastAssoc.tail.length > 0)
-          error(null, current.$path, { id: lastAssoc.tail[0].id ? lastAssoc.tail[0].id : lastAssoc.tail[0], name: lastAssoc.ref.id ? lastAssoc.ref.id : lastAssoc.ref }, 'Unexpected path step $(ID) after association $(NAME) in "EXISTS"');
-
         const newThing = [ ...head, nestFilters(head.length + 1, ref, tail, exprPath.concat([ i ])) ];
         expr[i].ref = newThing;
       }
@@ -312,11 +304,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
         const base = getBase(queryBase, isPrefixedWithTableAlias, current, exprPath.concat(i));
         const { root, ref } = getFirstAssoc(current, exprPath.concat(i));
 
-        if (!root.target) {
-          error(null, exprPath.concat(i), { type: root.type }, '“EXISTS” can only be used with associations/compositions, found $(TYPE)');
-          return { result: [], leftovers: [] };
-        }
-
         const subselect = getSubselect(root.target, ref, sources);
 
         const target = subselect.SELECT.from.as; // use subquery alias as target - prevent shadowing
@@ -331,7 +318,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
 
         newExpr.push('exists');
         if (ref && ref.where) {
-          const remappedWhere = remapExistingWhere(target, ref.where);
+          const remappedWhere = remapExistingWhere(target, ref.where, exprPath, current);
           if (remappedWhere.length > 3)
             subselect.SELECT.where.push(...[ 'and', '(', ...remappedWhere, ')' ]);
           else
@@ -381,7 +368,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
    */
   function translateManagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
     if (current.$scope === '$self') {
-      error('ref-unexpected-exists-self', current.$path, { id: current.ref[0], name: 'exists' }, 'With $(NAME), path steps must not start with $(ID)');
+      error('ref-unexpected-self', current.$path, { '#': 'exists', id: current.ref[0], name: 'exists' });
       return [];
     }
 
@@ -572,27 +559,6 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     };
   }
 
-  /**
-   * Get the last association from the expression part - similar to getFirstAssoc
-   *
-   * @param {object} xprPart
-   * @param {CSN.Path} path
-   * @returns {{head: Array, root: CSN.Element, ref: string|object, tail: Array}} The last assoc (root), the corresponding ref (ref), anything before the ref (head) and the rest of the ref (tail).
-   */
-  function getLastAssoc( xprPart, path ) {
-    const { links, art } = inspectRef(path);
-    for (let i = xprPart.ref.length - 1; i > -1; i--) {
-      if (links[i].art && links[i].art.target) {
-        return {
-          head: (i === 0 ? [] : xprPart.ref.slice(0, i)), root: links[i].art, ref: xprPart.ref[i], tail: xprPart.ref.slice(i + 1),
-        };
-      }
-    }
-    return {
-      head: (xprPart.ref.length === 1 ? [] : xprPart.ref.slice(0, xprPart.ref.length - 1)), root: art, ref: xprPart.ref[xprPart.ref.length - 1], tail: [],
-    };
-  }
-
   /**
    * Check (using inspectRef -> links), whether the first path step is an entity or query source
    *
@@ -713,13 +679,21 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
    *
    * This function does this by adding the assoc target before all the refs so that the refs are resolvable in the WHERE.
    *
+   * This function also rejects $self paths in filter conditions.
+   *
    * @param {string} target
    * @param {TokenStream} where
-   * @returns {TokenStream} The input-where with the refs transformed to absolute ones
+   * @param {CSN.Path} path path to the part, used if error needs to be thrown
+   * @param {CSN.Artifact} parent the host of the `where`, used if error needs to be thrown
+   *
+   * @returns {TokenStream} where The input-where with the refs transformed to absolute ones
    */
-  function remapExistingWhere( target, where ) {
+  function remapExistingWhere( target, where, path, parent ) {
     return where.map((part) => {
-      if (part.ref && part.$scope !== '$magic') {
+      if (part.$scope === '$self') {
+        error('ref-unexpected-self', path, { '#': 'exists-filter', elemref: parent, id: part.ref[0] });
+      }
+      else if (part.ref && part.$scope !== '$magic') {
         part.ref = [ target, ...part.ref ];
         return part;
       }

package/lib/transform/draft/db.js

@@ -2,7 +2,7 @@
 
 const {
   hasAnnotationValue, getServiceNames, forEachDefinition,
-  getResultingName, forEachMemberRecursively,
+  getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
@@ -29,9 +29,12 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   } = getTransformers(csn, options, pathDelimiter);
   const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
+  const generatedArtifacts = Object.create(null);
 
   forEachDefinition(csn, generateDraft);
 
+  applyAnnotationsFromExtensions(csn, { filter: name => generatedArtifacts[name], applyToElements: false });
+
   /**
    * Generate the draft stuff for a given artifact
    *
@@ -117,6 +120,8 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     // The name of the draft shadow entity we should generate
     const draftsArtifactName = `${artifactName}${draftSuffix}`;
 
+    generatedArtifacts[draftsArtifactName] = true;
+
     // extract keys for UUID inspection
     const keys = [];
     forEachMemberRecursively(artifact, (elt, name, prop, path) => {
@@ -132,7 +137,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
               '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.String' && k.$renamed === 'cds.UUID' && k.length === 36) ? acc + 1 : acc), 0);
+      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”');
     }
@@ -143,10 +148,16 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     const draftAdminDataProjectionName = `${matchingService}.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
     if (!draftAdminDataProjection) {
+      generatedArtifacts[draftAdminDataProjectionName] = true;
       draftAdminDataProjection = createAndAddDraftAdminDataProjection(matchingService, true);
 
       if (!draftAdminDataProjection.projection.columns && draftAdminDataProjection.elements.DraftUUID)
         draftAdminDataProjection.projection.columns = Object.keys(draftAdminDataProjection.elements).map(e => (e === 'DraftUUID' ? { key: true, ref: [ 'DraftAdministrativeData', e ] } : { ref: [ 'DraftAdministrativeData', e ] }));
+
+      if (options.transformation === 'effective' && draftAdminDataProjection.projection) {
+        draftAdminDataProjection.query = { SELECT: draftAdminDataProjection.projection };
+        delete draftAdminDataProjection.projection;
+      }
     }
 
     // Barf if it is not an entity or not what we expect
@@ -159,7 +170,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
 
     const persistenceName = getResultingName(csn, options.sqlMapping, draftsArtifactName);
     // Duplicate the artifact as a draft shadow entity
-    if (csn.definitions[persistenceName]) {
+    if (csn.definitions[persistenceName] && !(options.transformation === 'effective' && csn.definitions[persistenceName].kind === 'entity' && csn.definitions[persistenceName].elements.DraftAdministrativeData_DraftUUID)) {
       const definingDraftRoot = draftRoots.get(csn.definitions[persistenceName]);
       if (!definingDraftRoot) {
         error(null, [ 'definitions', artifactName ], { name: persistenceName },

package/lib/transform/draft/odata.js

@@ -1,10 +1,9 @@
 'use strict';
 
-const { forEachDefinition, getServiceNames } = require('../../model/csnUtils');
+const { forEachDefinition, getServiceNames, applyAnnotationsFromExtensions } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtils');
-const { ModelError } = require('../../base/error');
 const { makeMessageFunction } = require('../../base/messages');
 
 /**
@@ -29,7 +28,6 @@ const { makeMessageFunction } = require('../../base/messages');
  */
 function generateDrafts( csn, options, services ) {
   const {
-    createForeignKeyElement,
     createAndAddDraftAdminDataProjection, createScalarElement,
     createAssociationElement, createAssociationPathComparison,
     addElement, createAction, assignAction,
@@ -52,7 +50,7 @@ function generateDrafts( csn, options, services ) {
   const externalServices = services.filter(serviceName => csn.definitions[serviceName]['@cds.external']);
   // @ts-ignore
   const isExternalServiceMember = (_art, name) => externalServices.includes(getServiceName(name));
-
+  const filterDict = Object.create(null);
   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))
@@ -61,6 +59,7 @@ function generateDrafts( csn, options, services ) {
     visitedArtifacts[defName] = true;
   }, { skipArtifact: isExternalServiceMember });
 
+  applyAnnotationsFromExtensions(csn, { override: true, filter: name => filterDict[name] });
   return csn;
   /**
    * Generate all that is required in ODATA for draft enablement of 'artifact' into the artifact,
@@ -77,11 +76,6 @@ function generateDrafts( csn, options, services ) {
    * @param {CSN.Artifact} rootArtifact artifact where composition traversal started
    */
   function generateDraftForOdata( artifact, artifactName, rootArtifact ) {
-    // Sanity check
-    // @ts-ignore
-    if (!isArtifactInSomeService(artifactName, services))
-      throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
-
     // Nothing to do if already draft-enabled (composition traversal may have circles)
     if ((artifact['@Common.DraftRoot.PreparationAction'] || artifact['@Common.DraftNode.PreparationAction']) &&
         artifact.actions && artifact.actions.draftPrepare)
@@ -106,9 +100,11 @@ function generateDrafts( csn, options, services ) {
       resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, [ 'definitions', draftAdminDataProjectionName ]);
       resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, [ 'definitions', draftAdminDataProjectionName ]);
       resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, [ 'definitions', draftAdminDataProjectionName ]);
+      filterDict[artifactName] = true;
     }
     else {
       resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, [ 'definitions', draftAdminDataProjectionName ]);
+      filterDict[artifactName] = true;
     }
 
     Object.values(artifact.elements || {}).forEach( (elem) => {
@@ -141,15 +137,6 @@ function generateDrafts( csn, options, services ) {
     draftAdministrativeData.DraftAdministrativeData['@UI.Hidden'] = true;
     addElement(draftAdministrativeData, artifact, artifactName);
 
-    // Note that we need to do the ODATA transformation steps for managed associations
-    // (foreign key field generation, generatedFieldName) by hand, because the corresponding
-    // transformation steps have already been done on all artifacts when we come here)
-    let uuidDraftKey = draftAdministrativeData.DraftAdministrativeData.keys.filter(key => key.ref && key.ref.length === 1 && key.ref[0] === 'DraftUUID');
-    if (uuidDraftKey && uuidDraftKey[0]) {
-      uuidDraftKey = uuidDraftKey[0]; // filter returns an array, but it has only one element
-      const path = [ 'definitions', artifactName, 'elements', 'DraftAdministrativeData', 'keys', 0 ];
-      createForeignKeyElement(draftAdministrativeData.DraftAdministrativeData, 'DraftAdministrativeData', uuidDraftKey, artifact, artifactName, path);
-    }
     // SiblingEntity : Association to one <artifact> on (... IsActiveEntity unequal, all other key fields equal ...)
     const siblingEntity = createAssociationElement('SiblingEntity', artifactName, false);
     siblingEntity.SiblingEntity.cardinality = { max: 1 };