@sap/cds-compiler 4.7.6 → 4.8.0

package/lib/transform/odata/toFinalBaseType.js

@@ -6,9 +6,9 @@ const {
   forEachDefinition,
   forEachGeneric,
   forEachMemberRecursively,
-  isBuiltinType,
-  findAnnotationExpression, 
+  findAnnotationExpression,
 } = require('../../model/csnUtils');
+const { isBuiltinType } = require('../../base/builtins');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
 
@@ -98,12 +98,6 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
 
   function expandToFinalBaseType(node, defName) {
     if (!node) return;
-    // TODO: Clarify how should events be handled?
-    // They are not treated by the transformUtils::toFinalBaseType function
-    // in the same manner as named types, because the elements of structured events are not
-    // propagated as it is with types.
-    // It is ok to skip the expansion to the final base type for now as events are not rendered in
-    // EDMX at the moment and the reference in the OData CSN is fulfilled.
     if (node.kind === 'event') return;
 
     if(node.type && !isBuiltinType(node.type)) {
@@ -199,7 +193,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       // do the clone only if really needed
       if((finalBaseType.items && !node.items) ||
          (finalBaseType.elements && !node.elements)) {
-        // use the 'real' type, don't clone a clone
+        // clone the definition not another clone
         let _type = node._type;
         while(_type._type && !_type.items && !_type.elements)
           _type = _type._type;
@@ -227,15 +221,10 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       const typeRefStr = f(node.type.ref);
       const typeRefRootPath = $path2path(typeRefCsnPath);
       forEachMemberRecursively(clone, (elt, eltName, prop, location) => {
-        const [ xprANames /*nxprANames */ ] = Object.keys(elt).reduce((acc, pn) => {
-          if (pn[0] === '@')
-            acc[findAnnotationExpression(elt, pn) ? 0 : 1].push(pn);
-          return acc;
-        }, [ [], [] ]);
         const usingPositionStr = f($path2path(location));
         const eltRootPath = $path2path(elt.$path);
-        xprANames.forEach(xprAName => {
-          //let isSubTreeSpan = true;
+
+        Object.keys(elt).filter(pn => pn[0] === '@' && findAnnotationExpression(elt, pn)).forEach(xprAName => {
           transformExpression(elt, xprAName, {
             ref: (parent, prop, xpr, csnPath) => {
               let prefixMatch = true;
@@ -245,23 +234,18 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
                   prefixMatch = (xpr[i].id || xpr[i]) === typeRefRootPath[i];
                 }
                 if(prefixMatch && xpr.length > typeRefRootPath.length) {
-                  parent[prop] = [ ...xpr.slice(eltRootPath.length-1)];
+                  if(xpr.length >= eltRootPath.length)
+                    parent[prop] = [ ...xpr.slice(eltRootPath.length-1)];
+                  else
+                    parent[prop] = [ '$self', ...xpr.slice(typeRefRootPath.length)];
                 }
                 else {
                   error('odata-anno-xpr-ref', csnPath,
                   { anno: xprAName, elemref: xpr.join('.'), name: usingPositionStr, code: typeRefStr });
-                  //isSubTreeSpan = false;
                 }              
               }
             },
           }, elt.$path);
-          // if(!isSubTreeSpan) {
-          //   // remove annotation and sub annotations from cloned element
-          //   delete elt[xprAName];
-          //   nxprANames.filter(an => an.startsWith(`${xprAName}.`)).forEach((nxprAName) => {
-          //     delete elt[nxprAName];
-          //   });
-          // }
         });
         setProp(elt, '$path', location);
       }, node.$path);

package/lib/transform/odata/typesExposure.js

@@ -8,8 +8,9 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations, isBuiltinType, findAnnotationExpression,
+const { getNamespace, copyAnnotations, findAnnotationExpression, 
   forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
+const { isBuiltinType } = require('../../base/builtins');
 const { CompilerAssertion } = require('../../base/error');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
@@ -78,7 +79,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         forEachMember(def, (element, elementName, propertyName, path) => {
           if (propertyName === 'elements' || propertyName === 'params') {
             const newTypeName = getNewTypeName(element, elementName, defName, serviceName);
-            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, newTypeName, path);
+            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, newTypeName, defName, path);
           }
         }, path);
       }
@@ -105,7 +106,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           csn.definitions[defName] = def;
           const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;
           const newTypeName = getNewTypeName(undefined, undefined, artificialName, serviceName);
-          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, path.concat(['vocabularies', defName]), undefined, true);
+          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, defName, path.concat(['vocabularies', defName]), undefined, true);
         }
       }
     });
@@ -125,13 +126,13 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
       const newTypeName = getNewTypeName(action.returns, undefined, artificialName, serviceName);
-      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, path.concat(['returns']));
+      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['returns']));
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
       const artificialName = `param_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
       const newTypeName = getNewTypeName(param, paramName, artificialName, serviceName);
-      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, path.concat(['params', paramName]));
+      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['params', paramName]));
     });
   }
 
@@ -144,7 +145,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=false, ignoreInAPI=false) {
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, lastNonAnonymousFQDefName, path, parentName, isTermDef=false, ignoreInAPI=false) {
     const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable();
     if (isExposable) {
       // this is the name used to register the new type in csn.definitions
@@ -164,6 +165,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         // expose the type as a new one not changing the original definition.
         if(elements && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
+        lastNonAnonymousFQDefName = fullQualifiedNewTypeName;
       }
       // check if that type is already defined
       let newType = csn.definitions[fullQualifiedNewTypeName];
@@ -197,10 +199,12 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
             if (node.elements && node.elements[elemName].$location)
               setProp(newElem, '$location', node.elements[elemName].$location);
+            if (newElem.$path)
+              newElem.$path[1] = lastNonAnonymousFQDefName;
             defName = typeDef.kind === 'type' ? typeName : defName;
             {
               const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                            getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI);
+                            getNewTypeName(newElem, elemName, newTypeName, serviceName), lastNonAnonymousFQDefName, path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI);
               // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
               // been caught by expandToFinalBaseType() (forODataNew must not modify external imported services)
               if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
@@ -222,14 +226,23 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
             }
           });
 
-          // expression annos and their sub annotations are not propagated to type
-          let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
-            if (pn[0] === '@')
-              acc[findAnnotationExpression(typeDef, pn) ? 0 : 1].push(pn);
-            return acc;
-          }, [ [], [] ]);
-          nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
-          copyAnnotations(typeDef, newType, false, {}, nxprANames);
+          // TODO: remove the this if and the else clause for the V5 release
+          if (isBetaEnabled(options, 'v5preview')) {
+            // We need this check, as we only need to copy the annotions if the type
+            // is user defined structured type outside of the service
+            if (!isAnonymous) {
+              copyAnnotations(typeDef, newType);
+            }
+          } else {
+            // expression annos and their sub annotations are not propagated to type
+            let [ xprANames, nxprANames ] = Object.keys(typeDef).reduce((acc, pn) => {
+              if (pn[0] === '@')
+                acc[findAnnotationExpression(typeDef, pn) ? 0 : 1].push(pn);
+              return acc;
+            }, [ [], [] ]);
+            nxprANames = nxprANames.filter(an => !xprANames.some(ean => an.startsWith(`${ean}.`)));
+            copyAnnotations(typeDef, newType, false, {}, nxprANames);
+          }
 
           // if the origin type had items, add items to exposed type
           if(typeDef.kind === 'type') {

package/lib/transform/parseExpr.js

@@ -2,9 +2,6 @@
 
 'use strict'
 
-// const funkyfuncs = Object.keys(require('../compiler/builtins.js').
-//   specialFunctions).filter(n => n.length).map(n=>n.toLowerCase());
-
 /**
  * parseExpr() accepts any JSON object and tries to convert a token stream expression
  * array into an AST like expression with CDL operator precedence.

package/lib/transform/transformUtils.js

@@ -8,10 +8,12 @@ const { setProp } = require('../base/model');
 
 const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand } = require('../model/csnUtils');
 const { getUtils } = require('../model/csnUtils');
-const { typeParameters, isBuiltinType } = require('../compiler/builtins');
+const { typeParameters } = require('../compiler/builtins');
+const { isBuiltinType } = require('../base/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
 const { cloneCsnNonDict, cloneCsnDict } = require('../model/cloneCsn');
+const { addTenantFieldToArt } = require('./addTenantFields');
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
 const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
@@ -321,10 +323,10 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
    * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
-   * @param {bool} [refParentIsItems] relative ref has an items root (suspend flattening by caller)
+   * @param {bool} [suspend] suspend flattening by caller until association path step
    * @returns {string[]}
    */
-  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), refParentIsItems=false) {
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
       return ref;
@@ -350,10 +352,10 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
      (resolvedLinkTypes.get(links[i])||{})[propName]);
 
     let flattenStep = false;
-    let nextIsItems = !!art('items') || (refParentIsItems && i === 0);
+    suspend = !!art('items') || (suspend && i <= suspendPos);
     for(; i < links.length; i++) {
 
-      if (flattenStep && !nextIsItems) {
+      if (flattenStep && !suspend) {
         result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
         // if we had a filter or args, we had an assoc so this step is done
         // we then keep along the filter/args by updating the id of the current ref
@@ -362,14 +364,14 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
           result[result.length-1] = ref[i];
         }
         // suspend flattening if the next path step has some 'items'
-        nextIsItems = !!art('items');
+        suspend = !!art('items');
       }
       else {
         result.push(ref[i]);
       }
       // revoke items suspension for next assoc step
-      if(nextIsItems && art('target'))
-        nextIsItems = false;
+      if(suspend && art('target'))
+        suspend = false;
 
       flattenStep = !links[i].art?.kind &&
         !links[i].art?.SELECT &&
@@ -522,6 +524,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!draftAdminDataEntity) {
       draftAdminDataEntity = createAndAddDraftAdminDataEntity();
       model.definitions['DRAFT.DraftAdministrativeData'] = draftAdminDataEntity;
+      if(options.tenantDiscriminator && options.transformation !== 'odata')
+        addTenantFieldToArt(model.definitions['DRAFT.DraftAdministrativeData'], options);
     }
 
     // Create a projection within this service

package/lib/transform/translateAssocsToJoins.js

@@ -600,7 +600,7 @@ function translateAssocsToJoins(model, inputOptions = {})
           Put all src/tgt path siblings into the EQ term and create the proper path objects
           with the src/tgt table alias path steps in front.
         */
-        let args = compareTenants ? [ addTenantComparison(assoc) ] : [];
+        let args = compareTenants && addTenantComparison(assoc) || [];
         for(let i = 0; i < assoc.$flatSrcFKs.length; i++)
         {
           args.push({op: {val: '=' },
@@ -678,7 +678,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         args[1].path.push({ id: 'tenant' }); // no need for _artifact
         const comparison = { op: {val: '=' }, args };
         if (!cond)              // for managed assoc
-          return comparison;
+          return [ comparison ];
         return { op: { val: 'and' }, args: [ comparison, parenthesise(cond) ] };
       }
 

package/lib/transform/universalCsn/coreComputed.js

@@ -5,6 +5,7 @@ const {
 } = require('../../model/csnUtils');
 const { setAnnotationIfNotDefined } = require('./utils');
 const { CompilerAssertion } = require('../../base/error');
+const { isMagicVariable } = require('../../base/builtins');
 
 /**
  * Set @Core.Computed on the elements of views (and projections) as well
@@ -157,7 +158,7 @@ function setCoreComputedOnViewsAndCalculatedElements( csn, csnUtils ) {
         (
           column.xpr || column.list || column.func || column.val !== undefined || column['#'] !== undefined || column.param ||
           column.SELECT || column.SET ||
-          column.ref && [ '$at', '$valid', '$now', '$user', '$tenant', '$session', '$parameters' ].includes(column.ref[0])
+          column.ref && (isMagicVariable(column.ref[0]) || column.ref[0] === '$parameters')
         );
     }
 

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -8,8 +8,8 @@ const {
   getUtils,
   applyTransformations,
   implicitAs,
-  isBuiltinType,
 } = require('../../model/csnUtils');
+const { isBuiltinType } = require('../../base/builtins');
 const {
   forEachValue, forEach,
 } = require('../../utils/objectUtils');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "4.7.6",
+  "version": "4.8.0",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -28,7 +28,7 @@
     "gentest3": "cross-env MAKEREFS=${MAKEREFS:-'true'} mocha --reporter-option maxDiffSize=0 test3/testRefFiles.js",
     "coverage": "cross-env nyc mocha --reporter-option maxDiffSize=0 test/ test3/testRefFiles.js && nyc report --reporter=lcov",
     "coverage:piper": "cross-env nyc mocha --reporter test/TestMochaReporter.js --reporter-options mochaFile=./coverage/TEST-results.xml --reporter-option maxDiffSize=0 --timeout 10000 test/ test3/ && nyc report --reporter=cobertura && nyc report --reporter=lcov",
-    "lint": "eslint bin/ benchmark/ lib/ test/ test3/ scripts/ types/ && node scripts/linter/lintGrammar.js && node scripts/linter/lintTests.js test3/ && node scripts/linter/lintMessages.js && node scripts/linter/lintMessageIdCoverage.js lib/ && markdownlint README.md CHANGELOG.md doc/ internalDoc/ && cd share/messages && markdownlint .",
+    "lint": "eslint bin/ benchmark/ lib/ test/ test3/ scripts/ types/ && node scripts/linter/lintGrammar.js && node scripts/linter/lintTests.js test3/ && node scripts/linter/lintMessages.js && node scripts/linter/lintMessageIdCoverage.js lib/ && markdownlint README.md CHANGELOG.md doc/ internalDoc/ && cd share/messages && markdownlint . && cd ../../ && node scripts/check-changelog.js",
     "tslint": "tsc --pretty -p .",
     "updateVocs": "node scripts/odataAnnotations/generateDictMain.js && npm run generateAllRefs",
     "updateTocs": "node scripts/update-toc.js",

package/share/messages/README.md

@@ -41,8 +41,12 @@ Usually mentions the severity.
 
 ## Example
 
+Erroneous code example:
+
+```
 Code which also lead to the current message,
 with an explanation why it is problematic.
+```
 
 ## How to Fix
 

package/share/messages/anno-duplicate-unrelated-layer.md

@@ -23,7 +23,7 @@ annotate FooBar with @Anno: 'Foo';
 using from './Base';
 annotate FooBar with @Anno: 'Bar';
 
-// (4) All.cds: Combine all files
+// (4) All.cds: Combine all files ❌
 using from './FooAnnotate';
 using from './BarAnnotate';
 ```

package/share/messages/check-proper-type-of.md

@@ -18,7 +18,7 @@ view ViewFoo as select from Foo {
   1+1 as calculatedField @(anno)
 };
 entity Bar {
-  // `e` has no proper type but has the annotation `@anno`.
+  // ❌ `e` has no proper type but has the annotation `@anno`.
   e : ViewFoo:calculatedField;
 };
 ```

package/share/messages/def-duplicate-autoexposed.md

@@ -31,7 +31,7 @@ entity ns.Base {
   to_second : Composition of many ns.second.Foo;
 }
 service ns.MyService {
-  // (4)
+  // (4) ❌
   entity BaseView as projection on ns.Base;
 };
 ```

package/share/messages/extend-repeated-intralayer.md

@@ -9,30 +9,17 @@ They form a cyclic connection through their dependencies
 
 ## Example
 
-Erroneous code example with a single CDL file:
-
-```cds
-entity FooBar { }
-
-extend FooBar { foo : Integer; }
-extend FooBar { bar : Integer; }
-```
-
-Due to multiple extensions in the example above, the order of `foo` and `bar`
-inside `FooBar` may not be stable.  You therefore can’t depend on it.
-
-It's also possible to trigger this warning with multiple files.
-Look at the following example:
+Erroneous code example with multiple CDL files:
 
 ```cds
 // (1) Definition.cds
 using from './Extension.cds';
 entity FooBar { };
-extend FooBar { foo: Integer; };
+extend FooBar { foo: Integer; }; // ❌
 
 // (2) Extension.cds
 using from './Definition.cds';
-extend FooBar { bar: Integer; }
+extend FooBar { bar: Integer; }; // ❌
 ```
 
 Here we have a cyclic dependency between (1) and (2).  Together they form one

package/share/messages/extend-unrelated-layer.md

@@ -23,7 +23,7 @@ extend FooBar { foo : Integer; }
 using from './Base';
 extend FooBar { bar : Integer; }
 
-// (4) All.cds: Combine all files
+// (4) ❌ All.cds: Combine all files
 using from './FooExtend';
 using from './BarExtend';
 ```

package/share/messages/message-explanations.json

@@ -12,6 +12,7 @@
     "redirected-to-unrelated",
     "rewrite-not-supported",
     "syntax-expecting-unsigned-int",
+    "type-missing-enum-value",
     "wildcard-excluding-one"
   ]
 }

package/share/messages/redirected-to-ambiguous.md

@@ -26,7 +26,7 @@ view View as select from
     Target,
     Target as Duplicate
 {
-    // This redirection can’t be resolved:
+    // ❌ This redirection can’t be resolved:
     Main.toTarget : redirected to View
 };
 ```

package/share/messages/redirected-to-complex.md

@@ -21,7 +21,7 @@ entity Secondary {
 entity CrossJoin as SELECT from Main, Secondary;
 entity RedirectToComplex as projection on Main {
     id,
-    toMain: redirected to CrossJoin,
+    toMain: redirected to CrossJoin, // ❌
 };
 ```
 

package/share/messages/redirected-to-unrelated.md

@@ -21,7 +21,7 @@ entity Secondary {
 }
 entity InvalidRedirect as projection on Main {
     id,
-    // Invalid redirection
+    // ❌ Invalid redirection
     toMain: redirected to Secondary,
 };
 ```

package/share/messages/rewrite-not-supported.md

@@ -29,7 +29,7 @@ entity Secondary {
 
 entity View as select from Base {
   id,
-  primary.secondary // Error: The ON condition isn’t rewritten here
+  primary.secondary // ❌ The ON condition isn’t rewritten here
 };
 ```
 

package/share/messages/syntax-expecting-unsigned-int.md

@@ -17,8 +17,8 @@ Erroneous code example:
 
 <!-- cds-mode: ignore -->
 ```cds
-type LengthIsUnsafe : String(9007199254740992);
-type NotAnInteger : String(42.1);
+type LengthIsUnsafe : String(9007199254740992); // ❌
+type NotAnInteger : String(42.1);               // ❌
 ```
 
 In the erroneous example, the string length for the type `LengthIsUnsafe` is

package/share/messages/type-missing-enum-value.md

@@ -0,0 +1,59 @@
+# type-missing-enum-value
+
+An enum definition is missing explicit values for one or more of its entries.
+
+Enum definitions that aren't based on string-types do not get implicit values.
+They have therefore to be defined explicitly in the model.
+
+The message’s severity is `Warning` and is raised by the compiler.  You need
+to adapt your model to fix the warning.
+
+## Example
+
+Erroneous code example:
+
+```cds
+entity Books {
+  // …
+  category: Integer enum {
+    Fiction; // ❌
+    Action;  // ❌
+    // …
+  } default #Action;
+};
+```
+
+Both entries `#Fiction` and `#Action` of the enum `category` are missing an
+explicit value.  Because the base type `Integer` is not a string, no implicit
+values are defined for them.
+
+## How to Fix
+
+Explicitly assign a value or change the type to a string if the values are not
+important in your model.  The erroneous example above can be changed to:
+
+```cds
+entity Books {
+  // …
+  category: Integer enum {
+    Fiction = 1;
+    Action = 2;
+    // …
+  } default #Action;
+};
+```
+
+## Background
+
+Many languages support implicit values for integer-like enums.  However,
+CAP CDS does not have this feature, because otherwise, if values are persisted,
+adding a new entry in-between existing ones would lead to issues during
+deserialization later on.
+
+Assume that CAP would assign implicit values for integer enums.  If a new value
+were to be added between `Fiction` and `Action` in the erroneous example above,
+then the generated SQL statement for entity `Books` would change:  
+Instead of default value `2`, value `3` would be persisted.  Without data
+migration, existing action books would have changed their category.
+
+To avoid this scenario, always add explicit values to enums.

package/share/messages/wildcard-excluding-one.md

@@ -17,7 +17,7 @@ entity Book {
 };
 entity IsbnBook as projection on Book {
   *,
-  isbn as id,
+  isbn as id, // ❌
 };
 ```