@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/transform/db/groupByOrderBy.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { ModelError } = require('../../base/error');
+
 /**
  * Replace (formerly) managed association in a GROUP BY/ORDER BY with its foreign keys.
  *
@@ -89,7 +91,7 @@ function replaceAssociationsInGroupByOrderBy(inputQuery, options, inspectRef, er
 function getForeignKeyRefs(assoc) {
   return assoc.keys.map((fk) => {
     if (!fk.$generatedFieldName)
-      throw new Error(`Expecting generated field name for foreign key: ${JSON.stringify(fk)}`);
+      throw new ModelError(`Expecting generated field name for foreign key: ${JSON.stringify(fk)}`);
 
     return { ref: [ fk.$generatedFieldName ] };
   });

package/lib/transform/db/temporal.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const {
+  getUtils, getNormalizedQuery, hasAnnotationValue, forEachMember,
+} = require('../../model/csnUtils');
+const { implicitAs } = require('../../model/csnRefs');
+const { setProp } = require('../../base/model');
+const { getTransformers } = require('../transformUtilsNew');
+
+const validToString = '@cds.valid.to';
+const validFromString = '@cds.valid.from';
+/**
+ * Get the forEachDefinition callback function that adds a where condition to views that
+ * - are annotated with @cds.valid.from and @cds.valid.to,
+ * - have only one @cds.valid.from and @cds.valid.to,
+ * - and both annotations come from the same entity
+ *
+ * If the view has one of the annotations but the other conditions are not met, an error will be raised.
+ *
+ * @param {CSN.Model} csn
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.info
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition applying the where-condition to views.
+ */
+function getViewDecorator(csn, messageFunctions) {
+  const { info } = messageFunctions;
+  const { get$combined } = getUtils(csn);
+  return addTemporalWhereConditionToView;
+  /**
+   * Add a where condition to views that
+   * - are annotated with @cds.valid.from and @cds.valid.to,
+   * - have only one @cds.valid.from and @cds.valid.to,
+   * - and both annotations come from the same entity
+   *
+   * If the view has one of the annotations but the other conditions are not met, an error will be raised.
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   */
+  function addTemporalWhereConditionToView(artifact, artifactName) {
+    const normalizedQuery = getNormalizedQuery(artifact);
+    if (normalizedQuery && normalizedQuery.query && normalizedQuery.query.SELECT) {
+      // BLOCKER: We need information to handle $combined
+      // What we are trying to achieve by this:
+      // Forbid joining/selecting from two or more temporal entities
+      // Idea: Follow the query-tree and check each from
+      // Collect all source-entities and compute our own $combined
+      const $combined = get$combined(normalizedQuery.query);
+      const [ from, to ] = getFromToElements($combined);
+      // exactly one validFrom & validTo
+      if (from.length === 1 && to.length === 1) {
+        // and both are from the same origin
+        if (from[0].source === to[0].source && from[0].parent === to[0].parent) {
+          if (!hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0])) {
+            const fromPath = {
+              ref: [
+                from[0].parent,
+                from[0].name,
+              ],
+            };
+
+            const toPath = {
+              ref: [
+                to[0].parent,
+                to[0].name,
+              ],
+            };
+
+
+            const atFrom = { ref: [ '$at', 'from' ] };
+            const atTo = { ref: [ '$at', 'to' ] };
+
+            const cond = [ '(', fromPath, '<', atTo, 'and', toPath, '>', atFrom, ')' ];
+
+            if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
+              normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];
+            }
+            else {
+              normalizedQuery.query.SELECT.where = cond;
+            }
+          }
+        }
+        else {
+          info(null, [ 'definitions', artifactName ], `No temporal WHERE clause added as "${from[0].error_parent}"."${from[0].name}" and "${to[0].error_parent}"."${to[0].name}" are not of same origin`);
+        }
+      }
+      else if (from.length > 0 || to.length > 0) {
+        const missingAnnotation = from.length > to.length ? validToString : validFromString;
+        info(null, [ 'definitions', artifactName ],
+             { anno: missingAnnotation },
+             'No temporal WHERE clause added because $(ANNO) is missing');
+      }
+    }
+  }
+
+  /**
+   * Get all elements tagged with @cds.valid.from/to from the union of all entities of the from-clause.
+   *
+   * @param {any} combined union of all entities of the from-clause
+   * @returns {Array[]} Array where first field is array of elements with @cds.valid.from, second field is array of elements with @cds.valid.to.
+   */
+  function getFromToElements(combined) {
+    const from = [];
+    const to = [];
+    for (const name in combined) {
+      let elt = combined[name];
+      if (!Array.isArray(elt))
+        elt = [ elt ];
+      elt.forEach((e) => {
+        if (hasAnnotationValue(e.element, validFromString))
+          from.push(e);
+
+        if (hasAnnotationValue(e.element, validToString))
+          to.push(e);
+      });
+    }
+
+    return [ from, to ];
+  }
+
+  /**
+   * Check if the given SELECT has a falsy @cds.valid.from and a falsy @cds.valid.to
+   *
+   * @param {CSN.QuerySelect} SELECT
+   * @param {CSN.Elements} elements
+   * @param {object} from
+   * @param {object} to
+   * @returns {boolean} True if both are present and false.
+   */
+  function hasFalsyTemporalAnnotations(SELECT, elements, from, to) {
+    let fromElement = elements[from.name];
+    let toElement = elements[to.name];
+
+    if (SELECT.columns) {
+      for (const col of SELECT.columns) {
+        if (col.ref) {
+          const implicitAlias = implicitAs(col.ref);
+          if (implicitAlias === from.name)
+            fromElement = elements[col.as || implicitAlias];
+          else if (implicitAlias === to.name)
+            toElement = elements[col.as || implicitAlias];
+        }
+      }
+    }
+    return fromElement && toElement &&
+          hasAnnotationValue(fromElement, validFromString, false) &&
+          hasAnnotationValue(toElement, validToString, false);
+  }
+}
+
+/**
+ * Get the forEachDefinition callback function that collects all usages of @cds.valid.from/to/key and checks that
+ * - the assignment is on a valid element
+ * - the annotation is only assigned once
+ * - key is only used in conjunction with from and to
+ *
+ * Furthermore, @cds.valid.from and @cds.valid.key is processed - @cds.valid.from is marked as key or marked as unique if @cds.valid.key is used.
+ * If @cds.valid.key is used, the real key-elements have their key-property removed (set non-enumerable as $key) and instead the @cds.valid.key-marked elements have it added.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {string} pathDelimiter
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition processing the annotations.
+ */
+function getAnnotationHandler(csn, options, pathDelimiter, messageFunctions) {
+  const { error } = messageFunctions;
+  const {
+    extractValidFromToKeyElement, checkAssignment, checkMultipleAssignments, recurseElements,
+  } = getTransformers(csn, options, pathDelimiter);
+
+  return handleTemporalAnnotations;
+  /**
+   * @param {CSN.Artifact} artifact
+   * @param {string} artifactName
+   */
+  function handleTemporalAnnotations(artifact, artifactName) {
+    const validFrom = [];
+    const validTo = [];
+    const validKey = [];
+
+    recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
+      const [ f, t, k ] = extractValidFromToKeyElement(member, path);
+      validFrom.push(...f);
+      validTo.push(...t);
+      validKey.push(...k);
+    });
+
+    if (artifact.kind === 'entity' && !artifact.query) {
+      validFrom.forEach(obj => checkAssignment(validFromString, obj.element, obj.path, artifact));
+      validTo.forEach(obj => checkAssignment(validToString, obj.element, obj.path, artifact));
+      validKey.forEach(obj => checkAssignment('@cds.valid.key', obj.element, obj.path, artifact));
+      checkMultipleAssignments(validFrom, validFromString, artifact, artifactName);
+      checkMultipleAssignments(validTo, validToString, artifact, artifactName, true);
+      checkMultipleAssignments(validKey, '@cds.valid.key', artifact, artifactName);
+    }
+
+    // if there is an cds.valid.key, make this the only primary key
+    // otherwise add all cds.valid.from to primary key tuple
+    if (validKey.length) {
+      if (!validFrom.length || !validTo.length) {
+        error(null, [ 'definitions', artifactName ],
+              'Expecting “@cds.valid.from” and “@cds.valid.to” if “@cds.valid.key” is used');
+      }
+
+      forEachMember(artifact, (member) => {
+        if (member.key) {
+          member.unique = true;
+          delete member.key;
+          // Remember that this element was a key in the original artifact.
+          // This is needed for localized convenience view generation.
+          setProp(member, '$key', true);
+        }
+      });
+      validKey.forEach((member) => {
+        member.element.key = true;
+      });
+
+      validFrom.forEach((member) => {
+        member.element.unique = true;
+      });
+    }
+    else {
+      validFrom.forEach((member) => {
+        member.element.key = true;
+      });
+    }
+  }
+}
+
+
+module.exports = {
+  getViewDecorator,
+  getAnnotationHandler,
+};

package/lib/transform/db/transformExists.js

@@ -4,6 +4,7 @@ const { forAllQueries, forEachDefinition, walkCsnPath } = require('../../model/c
 const { setProp } = require('../../base/model');
 const { getRealName } = require('../../render/utils/common');
 const { csnRefs } = require('../../model/csnRefs');
+const { ModelError } = require('../../base/error');
 
 /**
  * Turn a `exists assoc[filter = 100]` into a `exists (select 1 as dummy from assoc.target where <assoc on condition> and assoc.target.filter = 100)`.
@@ -48,7 +49,7 @@ const { csnRefs } = require('../../model/csnRefs');
  * @param {Function} error
  */
 function handleExists(csn, options, error) {
-  const { inspectRef } = csnRefs(csn);
+  let { inspectRef } = csnRefs(csn);
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.projection) // do the same hack we do for the other stuff...
@@ -81,6 +82,8 @@ function handleExists(csn, options, error) {
             // to check for further exists
             const { result, leftovers } = processExists(queryPath, exprPath);
             walkCsnPath(csn, exprPath.slice(0, -1))[exprPath[exprPath.length - 1]] = result;
+            if (leftovers.length > 0)
+              inspectRef = csnRefs(csn).inspectRef; // Refresh caches - we need to resolve stuff in the newly created subquery
             toProcess.push(...leftovers.reverse()); // any leftovers - schedule for further processing
           }
         }
@@ -365,16 +368,23 @@ function handleExists(csn, options, error) {
         const subselect = getSubselect(root.target, ref, sources);
 
         const target = subselect.SELECT.from.as; // use subquery alias as target - prevent shadowing
-        if (root.keys) { // managed assoc
-          translateManagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current);
-        }
-        else { // unmanaged assoc
-          translateUnmanagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current);
-        }
+        const extension = root.keys ? translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) : translateUnmanagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current);
+        if (extension.length > 3)
+          subselect.SELECT.where.push('('); // add braces around the on-condition part to ensure precedence is kept
+
+        subselect.SELECT.where.push(...extension);
+
+        if (extension.length > 3)
+          subselect.SELECT.where.push(')');
 
         newExpr.push('exists');
-        if (ref && ref.where)
-          subselect.SELECT.where.push(...[ 'and', ...remapExistingWhere(target, ref.where) ]);
+        if (ref && ref.where) {
+          const remappedWhere = remapExistingWhere(target, ref.where);
+          if (remappedWhere.length > 3)
+            subselect.SELECT.where.push(...[ 'and', '(', ...remappedWhere, ')' ]);
+          else
+            subselect.SELECT.where.push(...[ 'and', ...remappedWhere ]);
+        }
 
         newExpr.push(subselect);
         toContinue.push([ exprPath.concat(newExpr.length - 1), exprPath.concat([ newExpr.length - 1, 'SELECT', 'where' ]) ]);
@@ -412,21 +422,24 @@ function handleExists(csn, options, error) {
    *
    * @param {CSN.Element} root
    * @param {string} target
-   * @param {CSN.Query} subselect This subselect will in the end replace <assoc> in EXISTS <assoc>
    * @param {boolean} isPrefixedWithTableAlias
    * @param {string} base
    * @param {Token} current
+   * @returns {object[]} The stuff to add to the where
    */
-  function translateManagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current) {
+  function translateManagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) {
+    const whereExtension = [];
     for (let j = 0; j < root.keys.length; j++) {
       const lop = { ref: [ target, ...root.keys[j].ref ] }; // target side
       const rop = { ref: (isPrefixedWithTableAlias ? [] : [ base ]).concat([ ...toRawRef(current.ref), ...root.keys[j].ref ]) }; // source side
 
       if (j > 0)
-        subselect.SELECT.where.push('and');
+        whereExtension.push('and');
 
-      subselect.SELECT.where.push(...[ lop, '=', rop ]);
+      whereExtension.push(...[ lop, '=', rop ]);
     }
+
+    return whereExtension;
   }
 
   /**
@@ -452,12 +465,13 @@ function handleExists(csn, options, error) {
    *
    * @param {CSN.Element} root
    * @param {string} target
-   * @param {CSN.Query} subselect This subselect will in the end replace <assoc> in EXISTS <assoc>
    * @param {boolean} isPrefixedWithTableAlias
    * @param {string} base
    * @param {Token} current
+   * @returns {object[]} The stuff to add to the where
    */
-  function translateUnmanagedAssocToWhere(root, target, subselect, isPrefixedWithTableAlias, base, current) {
+  function translateUnmanagedAssocToWhere(root, target, isPrefixedWithTableAlias, base, current) {
+    const whereExtension = [];
     for (let j = 0; j < root.on.length; j++) {
       const part = root.on[j];
 
@@ -465,7 +479,7 @@ function handleExists(csn, options, error) {
       // but also keep along stuff like null and undefined, so compiler
       // can have a chance to complain/ we can fail later nicely maybe
       if (!(part && part.ref)) {
-        subselect.SELECT.where.push(part);
+        whereExtension.push(part);
         continue;
       }
 
@@ -475,30 +489,82 @@ function handleExists(csn, options, error) {
       // Dollar Self Backlink
       if (isValidDollarSelf(root.on[j], root.$path.concat([ 'on', j ]), root.on[j + 1], root.on[j + 2], root.$path.concat([ 'on', j + 2 ]))) {
         if (root.on[j].ref[0] === '$self' && root.on[j].ref.length === 1)
-          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
+          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
         else
-          subselect.SELECT.where.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
+          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
 
         j += 2;
       }
       else if (links && links[0].art === root) { // target side
-        subselect.SELECT.where.push({ ref: [ target, ...part.ref.slice(1) ] });
+        whereExtension.push({ ref: [ target, ...part.ref.slice(1) ] });
       }
       else if (part.$scope === '$self') { // source side - "absolute" scope
-        // cut off the $self, as we prefix the entity name now
-        subselect.SELECT.where.push({ ref: [ base, ...part.ref.slice(1) ] });
+        const column = part._art._column;
+        if (column && column.as) { // Replace with the "original" expression (the .ref, .xpr etc.)
+          whereExtension.push(translateToSourceSide(column));
+        }
+        else {
+          whereExtension.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
+        }
       }
       else if (art) { // source side - with local scope
-        if (isPrefixedWithTableAlias)
-          subselect.SELECT.where.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
+        if (isPrefixedWithTableAlias || part.$scope === 'alias')
+          whereExtension.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
         else
-          subselect.SELECT.where.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
+          whereExtension.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
       }
       else { // operator - or any other leftover
-        subselect.SELECT.where.push(part);
+        whereExtension.push(part);
       }
     }
 
+    return whereExtension;
+
+
+    /**
+     * Run Object.assign on all of the passed in parameters and delete a .as at the end
+     *
+     * @param {...any} args
+     * @returns {object} The merged args without an .as property
+     */
+    function assignAndDeleteAs(...args) {
+      const obj = Object.assign.apply(null, args);
+      delete obj.as;
+      return obj;
+    }
+    /**
+     * Translate the given obj (a column-like thing) into an expression that we can use in the WHERE.
+     * - Strip off $self/$projection and correctly replace with source expression
+     * - Drill further down into .xpr
+     * - Correctly set table alias in front of ref
+     *
+     * @param {object} obj
+     * @returns {object}
+     */
+    function translateToSourceSide(obj) {
+      if (obj.ref) {
+        if (obj.$scope === '$self') { // TODO: Check with this way down, do we keep the links?
+          const column = obj._art._column;
+          if (column && column.as)
+            return translateToSourceSide(column);
+          return assignAndDeleteAs({}, obj, { ref: [ base, ...obj.ref.slice(1) ] });
+        }
+        else if (typeof obj.$env === 'string') {
+          return assignAndDeleteAs({}, obj, { ref: [ obj.$env, ...obj.ref ] });
+        }
+
+        return assignAndDeleteAs({}, obj, { ref: [ ...obj.ref ] });
+      }
+      else if (obj.xpr) { // we need to drill further down into .xpr
+        return assignAndDeleteAs({}, obj, { xpr: obj.xpr.map(translateToSourceSide) });
+      }
+      else if (obj.args) {
+        return assignAndDeleteAs({}, obj, { args: obj.args.map(translateToSourceSide) });
+      }
+
+      return obj;
+    }
+
     /**
      * Check that an expression triple is a valid $self
      *
@@ -571,7 +637,7 @@ function handleExists(csn, options, error) {
   }
 
   /**
-   * Check (using inspectRef -> links), wether the first path step is an entity or query source
+   * Check (using inspectRef -> links), whether the first path step is an entity or query source
    *
    * @param {CSN.Path} path
    * @returns {boolean}
@@ -621,7 +687,7 @@ function handleExists(csn, options, error) {
       return error(null, xpr.$path, 'Boolean $env is not handled yet - please report this error!');
     }
     else if (xpr.ref) {
-      throw new Error('Missing $env and missing leading artifact ref - throwing to trigger recompilation!');
+      throw new ModelError('Missing $env and missing leading artifact ref - throwing to trigger recompilation!');
     }
   }
 
@@ -706,7 +772,7 @@ function handleExists(csn, options, error) {
    *
    * @param {string} base The source entity/query source name
    * @param {string} target The target entity/query source name
-   * @param {CSN.Element} assoc The association element - the "not-$self" side of the comparison
+   * @param {object} assoc The association element - the "not-$self" side of the comparison
    * @param {CSN.Path} path
    * @returns {TokenStream} The WHERE representing the $self comparison
    */

package/lib/transform/db/views.js

@@ -5,6 +5,7 @@ const {
 } = require('../../model/csnUtils');
 const { implicitAs, csnRefs } = require('../../model/csnRefs');
 const { isBetaEnabled } = require('../../base/model');
+const { ModelError } = require('../../base/error');
 
 /**
  * If a mixin association is published, return the mixin association.
@@ -38,7 +39,7 @@ function getMixinAssocOfQueryIfPublished(query, association, associationName) {
 }
 
 /**
- * Check wether the given artifact uses the given mixin association.
+ * Check whether the given artifact uses the given mixin association.
  *
  * We can rely on the fact that there can be no usage starting with $self/$projection,
  * since lib/checks/selectItems.js forbids that.
@@ -182,10 +183,10 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
       const matchingCombined = $combined[elemName];
       // Internal errors - this should never happen!
       if (matchingCombined.length > 1) { // should already be caught by compiler
-        throw new Error(`Ambiguous name - can't be resolved: ${elemName}. Found in: ${matchingCombined.map(o => o.parent)}`);
+        throw new ModelError(`Ambiguous name - can't be resolved: ${elemName}. Found in: ${matchingCombined.map(o => o.parent)}`);
       }
       else if (matchingCombined.length === 0) { // no clue how this could happen? Invalid CSN?
-        throw new Error(`No matching entry found in UNION of all elements for: ${elemName}`);
+        throw new ModelError(`No matching entry found in UNION of all elements for: ${elemName}`);
       }
       alias = matchingCombined[0].parent;
     }
@@ -304,7 +305,7 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
               parent.ref = ref;
               return ref;
             },
-          }, elementsPath.concat(elemName));
+          }, {}, elementsPath.concat(elemName));
         }
 
         if (!mixinElem._ignore)

package/lib/transform/draft/.eslintrc.json

@@ -0,0 +1,38 @@
+{
+  "root": true,
+  "plugins": ["sonarjs", "jsdoc"],
+  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "rules": {
+    "prefer-const": "error",
+    "quotes": ["error", "single", "avoid-escape"],
+    "prefer-template": "error",
+    "no-trailing-spaces": "error",
+    "template-curly-spacing":["error", "never"],
+    "complexity": ["warn", 30],
+    "max-len": "off",
+    // Don't enforce stupid descriptions
+    "jsdoc/require-param-description": "off",
+    "jsdoc/require-returns-description": "off",
+    // Sometimes if-else's are more specific
+    "sonarjs/prefer-single-boolean-return": "off",
+    // Very whiny and nitpicky
+    "sonarjs/cognitive-complexity": "off",
+    // Does not recognize TS types
+    "jsdoc/no-undefined-types": "off",
+    // Whiny and annoying
+    "sonarjs/no-duplicate-string": "off"
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "script"
+  },
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "settings": {
+    "jsdoc": {
+      "mode": "typescript"
+    }
+  }
+}

package/lib/transform/{db/draft.js → draft/db.js}

@@ -6,6 +6,7 @@ const {
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtilsNew');
+const { ModelError } = require('../../base/error');
 const draftAnnotation = '@odata.draft.enabled';
 const booleanBuiltin = 'cds.Boolean';
 
@@ -38,7 +39,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName
    */
   function generateDraft(artifact, artifactName) {
-    if ((artifact.kind === 'entity' || artifact.kind === 'view') &&
+    if ((artifact.kind === 'entity') &&
         hasAnnotationValue(artifact, draftAnnotation) &&
         isPartOfService(artifactName)) {
       // Determine the set of target draft nodes belonging to this draft root (the draft root
@@ -79,7 +80,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
         const draftNodeName = elem.target;
         // Sanity check
         if (!draftNode)
-          throw new Error(`Expecting target to be resolved: ${JSON.stringify(elem, null, 2)}`);
+          throw new ModelError(`Expecting target to be resolved: ${JSON.stringify(elem, null, 2)}`);
 
         // Ignore composition if not part of a service
         if (!isPartOfService(draftNodeName)) {
@@ -89,7 +90,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
         }
         // Barf if a draft node other than the root has @odata.draft.enabled itself
         if (draftNode !== rootArtifact && hasAnnotationValue(draftNode, draftAnnotation)) {
-          error(null, [ 'definitions', artifactName, 'elements', elemName ], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
+          error('ref-unexpected-draft-enabled', [ 'definitions', artifactName, 'elements', elemName ], { anno: '@odata.draft.enabled' });
           delete draftNodes[draftNodeName];
           continue;
         }
@@ -110,7 +111,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
   function generateDraftForHana(artifact, artifactName, draftRootName) {
     // Sanity check
     if (!isPartOfService(artifactName))
-      throw new Error(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
+      throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
 
 
     // The name of the draft shadow entity we should generate
@@ -134,7 +135,8 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
       warning(null, [ 'definitions', artifactName ], 'Entity annotated with “@odata.draft.enabled” should have one key element of type “cds.UUID”');
 
 
-    const matchingService = getMatchingService(artifactName);
+    // 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
     const draftAdminDataProjectionName = `${matchingService}.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
@@ -311,7 +313,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     function getDraftShadowEntityFor(draftNode, draftNodeName) {
       // Sanity check
       if (!draftNodes[draftNodeName])
-        throw new Error(`Not a draft node: ${draftNodeName}`);
+        throw new ModelError(`Not a draft node: ${draftNodeName}`);
 
       return { shadowTarget: csn.definitions[`${draftNodeName}${draftSuffix}`], shadowTargetName: `${draftNodeName}${draftSuffix}` };
     }
@@ -336,7 +338,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * Get the service name containing the artifact.
    *
    * @param {string} artifactName Absolute name of the artifact
-   * @returns {boolean|string} Name of the service or false if no match is found.
+   * @returns {false|string} Name of the service or false if no match is found.
    */
   function getMatchingService(artifactName) {
     const matches = [];