@sap/cds-compiler 4.9.4 → 5.0.6

package/lib/transform/effective/types.js

@@ -18,18 +18,15 @@ const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
  * @param {CSN.Model} csn will be transformed
  * @param {object} csnUtils
  * @param {CSN.Options} options
- * @returns {Function} Callback to resolve things (actions and their returns) later - as for them, $self would lead to unresolvable constructs at this point
+ * @returns {Function} Callback to resolve types in action returns later - as for them, $self would lead to unresolvable constructs at this point
  * so we can call this callback after flattening is done - then we can safely resolve their types.
  */
 function resolveTypes( csn, csnUtils, options ) {
   const { getFinalTypeInfo } = csnUtils;
   const later = [];
   applyTransformations(csn, {
-    type: (parent, prop, type, path) => {
-      const artifact = csn.definitions[path[1]];
-      // TODO: What about events?
-      if (!(artifact.kind === 'action' || artifact.kind === 'function'))
-        resolveType(parent);
+    type: (parent) => {
+      resolveType(parent);
     },
   }, [ (definitions, artifactName, artifact) => {
     // In a non-flat model, replacing types with some $self inside causes issues for actions (bound or unbound)
@@ -38,12 +35,20 @@ function resolveTypes( csn, csnUtils, options ) {
       later.push({ [artifactName]: artifact });
     else if (artifact.actions)
       later.push(artifact.actions);
-  } ], { skipDict: { actions: true }, processAnnotations: true });
+  } ], { skipStandard: { returns: true }, processAnnotations: true });
 
+  // TODO: Directly push the .returns into the later so we have a more minimal looping
   return function resolveTypesInActions() {
-    later.forEach(action => applyTransformationsOnDictionary(action, { type: parent => resolveType(parent) }));
+    later.forEach((a) => {
+      applyTransformationsOnDictionary(a, {
+        type: (parent) => {
+          resolveType(parent);
+        },
+      });
+    });
   };
 
+
   /**
    * Resolve a type to its
    * - elements
@@ -123,7 +128,6 @@ function resolveTypes( csn, csnUtils, options ) {
   }
 }
 
-
 module.exports = {
   resolve: resolveTypes,
 };

package/lib/transform/forOdata.js

@@ -167,8 +167,6 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     { skipArtifact: isExternalServiceMember }
   );
 
-  flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
-
   // All type refs must be resolved, including external APIs.
   // OData has no 'type of' so 'real' imported OData APIs marked @cds.external are safe.
   // If in the future 'other' APIs that might support type refs are imported, these refs must be

package/lib/transform/forRelationalDB.js

@@ -169,8 +169,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
 
-  doA2J && flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
-
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
@@ -702,23 +700,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
 
     });
-    // restore $fkExtensions and $structRef for foreign key annotations
-    if (isBetaEnabled(options, 'annotateForeignKeys')) {
-      forEachDefinition(csn, (oldDef, artName) => {
-        const newDef = newCsn.definitions[artName];
-        if(oldDef?.elements) {
-          Object.entries(oldDef.elements).forEach(([eltName, oldElt]) => {
-            const newElt = newDef.elements[eltName];
-            if(oldElt.$fkExtensions)
-              setProp(newElt, '$fkExtensions', oldElt.$fkExtensions);
-            oldElt.keys?.forEach((fk, i) => {
-              if(fk.$structRef && newElt.keys?.[i])
-                setProp(newElt.keys[i], '$structRef', fk.$structRef);
-            })
-          })
-        }
-      });
-    }
     csn = newCsn;
   }
 

package/lib/transform/localized.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { setProp, isDeprecatedEnabled, isBetaEnabled} = require('../base/model');
+const { setProp } = require('../base/model');
 const { forEachKey } = require('../utils/objectUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
@@ -91,6 +91,7 @@ const annoPersistenceSkip = '@cds.persistence.skip';
  *     Deprecated version of localizedLanguageFallback. Do not use.
  *
  * @param {boolean} [options.fewerLocalizedViews]
+ *     Default: true
  *
  * @param {object} config
  *     Configuration for creating convenience views.  Non-user visible options.
@@ -114,7 +115,8 @@ function _addLocalizationViews(csn, options, config) {
   const { useJoins, acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
-  const ignoreAssocToLocalized = !!options.fewerLocalizedViews;
+  // default is true, hence only check for explicitly disabled option
+  const ignoreAssocToLocalized = options.fewerLocalizedViews !== false;
 
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
@@ -176,7 +178,7 @@ function _addLocalizationViews(csn, options, config) {
     else
       view = createLocalizedViewForEntity(art, artName, textElements);
 
-    copyPersistenceAnnotations(view, art, options);
+    copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
   }
 
@@ -752,18 +754,15 @@ function copyLocation(target, source) {
  *
  * @param {CSN.Artifact} target
  * @param {CSN.Artifact} source
- * @param {CSN.Options} options
  */
-function copyPersistenceAnnotations(target, source, options) {
-  const copyExists = !isBetaEnabled(options, 'v5preview') &&
-    !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+function copyPersistenceAnnotations(target, source) {
   forEachKey(source, anno => {
     // Note:
     //   v3/v4: Because `.exists` is copied to the convenience view, it could
     //   lead to some localization views referencing non-existing ones.
     //   But that is the contract: User says that it already exists!
     //   v2/>=v5, `.exists` is never copied.
-    if (anno === annoPersistenceSkip || (copyExists && anno === '@cds.persistence.exists'))
+    if (anno === annoPersistenceSkip)
       target[anno] = source[anno];
   });
 }

package/lib/transform/odata/flattening.js

@@ -8,8 +8,7 @@ const transformUtils = require('../transformUtils');
 const { setProp } = require('../../base/model');
 const { applyTransformationsOnDictionary,
   applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
-const { linkForeignKeyAnnotationExtensionsToAssociation,
-  handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
+const { handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { forEach } = require('../../utils/objectUtils');
 
@@ -293,17 +292,27 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
 
     const refCheck = {
       ref: (elemref, prop, xpr, path) => {
-        const { art, scope } = inspectRef(path);
+        const { links, art, scope } = inspectRef(path);
         if (scope !== '$magic' && art) {
-          const ft = csnUtils.getFinalTypeInfo(art.type);
-          if (!isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-            error('odata-anno-xpr-ref', path,
-              {
-                anno: refCheck.anno,
-                elemref,
-                name: refCheck.eltLocationStr,
-                '#': 'flatten_builtin'
-              });
+          // try to find rightmost 'items', terminate if association comes first.
+          let i = links.length-1;
+          const getProp = (propName) => links[i].art?.[propName];
+  
+          let hasItems = false;
+          for(; i >= 0 && !getProp('target') && !hasItems; i--) {
+            hasItems = !!getProp('items')
+          }
+          if(!hasItems) {
+            const ft = csnUtils.getFinalTypeInfo(art.type);
+            if (!isBuiltinType(ft?.items?.type || ft?.type) && refCheck.anno !== 'value') {
+              error('odata-anno-xpr-ref', path,
+                {
+                  anno: refCheck.anno,
+                  elemref,
+                  name: refCheck.eltLocationStr,
+                  '#': 'flatten_builtin'
+                });
+            }  
           }
         }
       }
@@ -421,24 +430,24 @@ function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef,
 
   const refCheck = {
     ref: (elemref, prop, xpr, path) => {
-      const { links, art } = (elemref._links && elemref._art
-        ? { links: elemref._links, art: elemref._art }
-        : inspectRef(path) );
-
-      let i = links.length-2;
-      const getProp = (propName) =>
-        (links[i].art?.[propName] ||
-        effectiveType(links[i].art)[propName]);
-
-      const ft = csnUtils.getFinalTypeInfo(art?.type);
-      let target = undefined;
-      for(; i >= 0 && !getProp('items') && !target; i--) {
-        target = getProp('target');
-      }
-      if (target && csn.definitions[target].$flatelements
-          && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
-        error('odata-anno-xpr-ref', path,
-        { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+      const { links, art, scope } = inspectRef(path);
+
+      if (scope !== '$magic' && art) {
+        let i = links.length-2;
+        const getProp = (propName) =>
+          (links[i].art?.[propName] ||
+          effectiveType(links[i].art)[propName]);
+
+        let target = undefined;
+        for(; i >= 0 && !getProp('items') && !target; i--) {
+          target = getProp('target');
+        }
+        const ft = csnUtils.getFinalTypeInfo(art.type);
+        if (target && csn.definitions[target].$flatelements
+            && !isBuiltinType(ft?.type) && refCheck.anno !== 'value') {
+          error('odata-anno-xpr-ref', path,
+          { anno: refCheck.anno, elemref, '#': 'flatten_builtin_type' });
+        }
       }
     }
   }
@@ -548,7 +557,6 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
 module.exports = {
   allInOneFlattening,
   flattenAllStructStepsInRefs,
-  linkForeignKeyAnnotationExtensionsToAssociation,
   handleManagedAssociationsAndCreateForeignKeys,
   getStructRefFlatteningTransformer
 };

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations, findAnnotationExpression,
+const { getNamespace, copyAnnotations,
   forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
 const { isBuiltinType } = require('../../base/builtins');
 const { CompilerAssertion } = require('../../base/error');
@@ -229,22 +229,10 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
             }
           });
 
-          // 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);
+          // Annotations are propagated only from user defined structured
+          // types that need to be added to a service
+          if (!isAnonymous) {
+            copyAnnotations(typeDef, newType);
           }
 
           // if the origin type had items, add items to exposed type

package/lib/transform/transformUtils.js

@@ -266,7 +266,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         const flatElemName = elemName + pathDelimiter + childName;
-        const flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
+        const flatElem = cloneCsnNonDict(childElem, options);
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));

package/lib/transform/translateAssocsToJoins.js

@@ -1110,8 +1110,27 @@ function translateAssocsToJoins(model, inputOptions = {})
             }
             else {
               const [ tableAlias, path ] = getTableAliasAndPathSteps(pathNode);
-              const pathStr = path.map(ps => ps.id).join(pathDelimiter);
-              replaceNodeContent(pathNode, constructPathNode([ tableAlias, { id: pathStr, _artifact: pathNode._artifact } ]));
+              const rewrittenPath = [];
+              const leafArtifact = path.at(-1)._artifact;
+              // Walk from left to right and search for first assoc. If assocs in filters become join relevant in the future,
+              // i.e. not only fk-access, we need to revisit this
+              for(let i = 0; i < path.length; i++) {
+                const pathStep = path[i];
+                if(pathStep._artifact?.foreignKeys) {
+                  const possibleNonAliasedFkName = path.slice(i).map(ps => ps.id).join(pathDelimiter);
+                  if(!pathStep._artifact.$flatSrcFKs)
+                      setProp(pathStep._artifact, '$flatSrcFKs', flattenElement(pathStep._artifact, true, pathStep._artifact.name.id, pathStep._artifact.name.id));
+                  const fk = pathStep._artifact.$flatSrcFKs.find(f => f._artifact === leafArtifact && f.acc.startsWith(possibleNonAliasedFkName));
+                  if(fk) {
+                    rewrittenPath.push(fk);
+                    i = path.length;
+                    continue;
+                  }
+                }
+
+                rewrittenPath.push(pathStep);
+              }
+              replaceNodeContent(pathNode, constructPathNode([ tableAlias, { id: rewrittenPath.map(ps => ps.id).join(pathDelimiter), _artifact: pathNode._artifact } ]));
             }
           }
         } ]
@@ -1691,7 +1710,6 @@ function translateAssocsToJoins(model, inputOptions = {})
     const path = pathDict.path;
     const s = pathAsStr(path, '"');
     const me = env.lead && (env.lead.name.id || env.lead.op);
-    // eslint-disable-next-line no-console
     console.log(me + ': ' + env.location + ': ' + s + ' alias: ' + alias);
   }
 

package/lib/utils/file.js

@@ -49,22 +49,28 @@ function cdsFs( fileCache, enableTrace ) {
 
   return {
     /** @type {function(string, string)} */
-    readFileAsync: util.promisify(readFile),
+    readFileAsync: util.promisify( readFile ),
     readFile,
     readFileSync,
-    isFileAsync: util.promisify(isFile),
     isFile,
     isFileSync,
-    realpathAsync: util.promisify(realpath),
-    realpath,
+    realpath: fs.realpath,
+    realpathNative: fs.realpath.native,
     realpathSync,
+    realpathSyncNative,
   };
 
-  function realpath( path, cb ) {
-    return fs.realpath.native(path, cb);
-  }
 
   function realpathSync( path, cb ) {
+    try {
+      cb(null, fs.realpathSync(path));
+    }
+    catch (err) {
+      cb(err, null);
+    }
+  }
+
+  function realpathSyncNative( path, cb ) {
     try {
       cb(null, fs.realpathSync.native(path));
     }

package/lib/utils/moduleResolve.js

@@ -70,7 +70,7 @@ function makeModuleResolver( options, fileCache, messageFunctions ) {
     extensions,
     isFile: _fs.isFile,
     readFile: _fs.readFile,
-    realpath: _fs.realpath,
+    realpath: _fs.realpathNative,
     lookupDirs: _getLookupDirectories( options, messageFunctions ),
   };
 
@@ -90,7 +90,20 @@ function makeModuleResolver( options, fileCache, messageFunctions ) {
           const body = fileCache[res];
           if (body === undefined || body === true) { // use fs if no or just temp entry
             dep.absname = res;
-            _fs.realpath( res, cb );
+            _fs.realpath( res, function realPathResult(realpathErr, modulePath) {
+              if (realpathErr) {
+                cb(realpathErr, modulePath);
+              }
+              else {
+                _fs.realpathNative( res, function nativeRealPathResult(nativeErr, nativePath) {
+                  if (!nativeErr)
+                    checkFileCase( dep, modulePath, nativePath, messageFunctions );
+                  // Pass the _native_ path to ensure that we use the actual
+                  // file's path (include case-differences)
+                  cb(realpathErr, nativePath);
+                });
+              }
+            } );
           }
           else if (body && typeof body === 'object' && body.realname) {
             // dep.absname = body.realname;
@@ -138,7 +151,7 @@ function makeModuleResolverSync( options, fileCache, messageFunctions ) {
     extensions,
     isFile: _fs.isFileSync,
     readFile: _fs.readFileSync,
-    realpath: _fs.realpathSync,
+    realpath: _fs.realpathSyncNative,
     lookupDirs: _getLookupDirectories( options, messageFunctions ),
   };
 
@@ -166,11 +179,23 @@ function makeModuleResolverSync( options, fileCache, messageFunctions ) {
     const body = result ? fileCache[result] : undefined;
     if (body === undefined || body === true) { // use fs if no or just temp entry
       dep.absname = result;
-      _fs.realpathSync( result, (err, modulePath) => {
-        if (err)
-          error = err;
-        else
-          result = modulePath;
+      _fs.realpathSync( result, function realPathResult(realpathErr, modulePath) {
+        if (realpathErr) {
+          error = realpathErr;
+        }
+        else {
+          _fs.realpathSyncNative( result, function nativeRealPathResult(nativeErr, nativePath) {
+            if (nativeErr) {
+              error = nativeErr;
+            }
+            else {
+              checkFileCase(dep, modulePath, nativePath, messageFunctions);
+              // Use the _native_ path to ensure that we use the actual
+              // file's path (include case-differences)
+              result = nativePath;
+            }
+          });
+        }
       });
     }
     else if (body && typeof body === 'object' && body.realname) {
@@ -533,6 +558,32 @@ function packageCdsMain( pkg ) {
   return null;
 }
 
+/**
+ * Check if the given paths for case-differences.  If there are case differences
+ * emit a warning.  This can happen on systems with case-insensitive file
+ * systems.  As that is a hard-to-debug issue, we help the user by emitting
+ * a corresponding warning.
+ *
+ * @param {object} dep
+ * @param {string} realpath
+ * @param {string} nativeRealpath
+ * @param {Function} warning
+ */
+function checkFileCase( dep, realpath, nativeRealpath, { warning } ) {
+  if (realpath === nativeRealpath)
+    return;
+  if (realpath.toLowerCase() !== nativeRealpath.toLowerCase()) {
+    // safe-guard: in case realpath() resolved symlinks more deeply or sockets/pipes were used,
+    // which realpath.native() handles differently, don't report a possible false positive.
+    return;
+  }
+  for (const using of dep.usingFroms) {
+    warning('file-unexpected-case-mismatch', [ using.location, using ], {},
+            // eslint-disable-next-line max-len
+            'The imported filename differs on the filesystem; ensure that capitalization matches the actual file\'s name');
+  }
+}
+
 /**
  * @typedef {object} ResolveConfig
  * @property {string[]} lookupDirs

package/lib/utils/term.js

@@ -57,8 +57,9 @@ function term( useColor = 'auto' ) {
         //       > that, when present (regardless of its value), prevents the addition
         //       > of ANSI color.
         // Note: To be able to disable colors in tests, we check the environment
-        //       variable here again.
-        hasColor = hasColorShell && (process.env.NO_COLOR === undefined);
+        //       variables again.
+        hasColor = (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0') ||
+          (hasColorShell && process.env.NO_COLOR === undefined);
         break;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "4.9.4",
+  "version": "5.0.6",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -24,11 +24,15 @@
     "test3": "node scripts/verifyGrammarChecksum.js && mocha --reporter-option maxDiffSize=0 test3/",
     "deployHanaSql": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 test3/test.deploy.hana-sql.js",
     "deployHdiHdbcds": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 test3/test.deploy.hdi.hdbcds.js",
+    "deployHdi": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 --extensions .hdi test3/test.deploy.hdi.hdbcds.js",
+    "deployHdbcds": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 --extensions .hdbcds test3/test.deploy.hdi.hdbcds.js",
     "deployGitDiffs": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 test3/test.deploy.git-diffs.js",
+    "deployHdbcdsGitDiffs": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 --extensions .hdbcds test3/test.deploy.git-diffs.js",
+    "deployHdiGitDiffs": "CDS_COMPILER_DEPLOY_HANA=1 mocha --reporter-option maxDiffSize=0 --extensions .hdi test3/test.deploy.git-diffs.js",
     "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 . && cd ../../ && node scripts/check-changelog.js",
+    "lint": "eslint bin/ benchmark/ lib/ test/ test3/ scripts/ && 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",
@@ -60,6 +64,6 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   }
 }

package/share/messages/message-explanations.json

@@ -14,6 +14,8 @@
     "rewrite-not-supported",
     "syntax-expecting-unsigned-int",
     "type-missing-enum-value",
+    "type-unexpected-foreign-keys",
+    "type-unexpected-on-condition",
     "wildcard-excluding-one"
   ]
 }

package/share/messages/type-unexpected-foreign-keys.md

@@ -0,0 +1,52 @@
+# type-unexpected-foreign-keys
+
+Foreign keys were specified in a composition-of-aspect.
+
+Compositions of aspects are managed by the compiler.
+Specifying a foreign key list is not supported.
+If you need to specify foreign keys, use a composition
+of an entity instead.
+
+The message's severity is `Error`.
+
+## Example
+
+Erroneous code example:
+
+```cds
+aspect Item {
+  key ID : UUID;
+  field : String;
+};
+entity Model {
+  key ID : UUID;
+  Item : Composition of Item { ID }; // ❌
+};
+```
+
+`Item` is an aspect.  Because an explicit list of foreign keys is specified,
+the compiler rejects this CDS snippet.  With an explicit foreign key list,
+only entities can be used, but not aspects.
+
+## How to Fix
+
+Either remove the explicit list of foreign keys and let the compiler handle
+the composition, or use a composition of entity instead.
+
+```cds
+aspect Item {
+  key ID : UUID;
+  field : String;
+};
+entity Model {
+  key ID : UUID;
+  Item : Composition of Model.Item { ID }; // ok
+};
+entity Model.Item : Item { };
+```
+
+The snippet uses a user-defined entity, that includes the aspects.
+
+## Related Messages
+
+- `type-unexpected-on-condition`

package/share/messages/type-unexpected-on-condition.md

@@ -0,0 +1,52 @@
+# type-unexpected-on-condition
+
+An ON-condition was specified in a composition-of-aspect.
+
+Compositions of aspects are managed by the compiler.
+Specifying an ON-condition is not supported.
+If you need to specify an ON-condition, use a composition
+of an entity instead.
+
+The message's severity is `Error`.
+
+## Example
+
+Erroneous code example:
+
+```cds
+aspect Item {
+  key ID : UUID;
+  field : String;
+};
+entity Model {
+  key ID : UUID;
+  Item : Composition of Item on Item.ID = ID; // ❌
+};
+```
+
+`Item` is an aspect.  Because an ON-condition is specified, the compiler
+rejects this CDS snippet.  With an ON-condition, only entities can be used,
+but not aspects.
+
+## How to Fix
+
+Either remove the ON-condition and let the compiler handle
+the composition, or use a composition of entity instead.
+
+```cds
+aspect Item {
+  key ID : UUID;
+  field : String;
+};
+entity Model {
+  key ID : UUID;
+  Item : Composition of Model.Item on Item.ID = ID; // ok
+};
+entity Model.Item : Item { };
+```
+
+The snippet uses a user-defined entity, that includes the aspects.
+
+## Related Messages
+
+- `type-unexpected-foreign-keys`