@sap/cds-compiler 5.6.0 → 5.7.0

package/lib/transform/db/flattening.js

@@ -3,10 +3,8 @@
 const {
   applyTransformations,
   applyTransformationsOnNonDictionary,
-  cardinality2str,
   copyAnnotations,
   implicitAs,
-  isDeepEqual,
   findAnnotationExpression,
 } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
@@ -17,6 +15,7 @@ const { forEach } = require('../../utils/objectUtils');
 const { transformExpression } = require('./applyTransformations');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
+const adaptAnnotationsRefs = require('../odata/adaptAnnotationRefs');
 
 /**
  * Strip off leading $self from refs where applicable.
@@ -74,7 +73,6 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
     }
   }
   const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
-  const { getServiceName, getFinalTypeInfo } = csnUtils;
 
   // We don't want to iterate over actions
   if (iterateOptions.skipDict && !iterateOptions.skipDict.actions)
@@ -82,14 +80,11 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
   else
     iterateOptions.skipDict = { actions: true };
 
-  const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
   const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
   const stripItems = options.transformation === 'hdbcds' || options.transformation === 'sql';
   const removeItems = new Set();
   applyTransformations(csn, {
     type: (node, prop, type, path, parent, parentProp) => {
-      if (options.toOdata && node.kind && node.kind in ignoreOdataKinds)
-        return;
       if (parentProp === 'cast') {
         const e = csnUtils.getFinalTypeInfo(type, t => resolved.get(t)?.art || csnUtils.artifactRef(t));
         if (e.items && stripItems)
@@ -97,7 +92,7 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
         if (!e || e.items || e.elements)
           return;
       }
-      if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
+      if (!isBuiltinType(type)) {
         toFinalBaseType(node, resolved, true);
 
 
@@ -160,42 +155,6 @@ function resolveTypeReferences( csn, options, messageFunctions, resolved, pathDe
     delete node.items;
   }
   removeItems.clear();
-
-
-  /**
-   * OData V4 only:
-   * Do not replace a type ref if:
-   * The type definition is terminating on a scalar type (that can also be a derived type chain)
-   * AND the typeName (that is the start of that (derived) type chain is defined within the same
-   * service as the artifact from which the type reference has to be resolved.
-   *
-   * @param {string} typeName
-   * @param {CSN.Path} path
-   * @returns {boolean}
-   */
-  function isODataV4BuiltinFromService( typeName, path ) {
-    if (!options.toOdata || (options.odataVersion === 'v2') || typeof typeName !== 'string')
-      return false;
-
-    const typeServiceName = getServiceName(typeName);
-    const finalBaseType = getFinalTypeInfo(typeName)?.type;
-    // we need the service of the current definition
-    const currDefServiceName = getServiceName(path[1]);
-
-    return typeServiceName === currDefServiceName && isBuiltinType(finalBaseType);
-  }
-
-  /**
-   * OData stops replacing types @ 'items', if the type ref is a user defined type
-   * AND that type has items, don't do toFinalBaseType
-   *
-   * @param {string} typeName
-   * @returns {boolean}
-   */
-  function isODataItems( typeName ) {
-    const typeDef = csn.definitions[typeName];
-    return !!(options.toOdata && typeDef && typeDef?.items);
-  }
 }
 
 /**
@@ -334,9 +293,6 @@ function flattenElements( csn, options, messageFunctions, pathDelimiter, iterate
     elements: flatten,
   };
 
-  if (options.toOdata) // Odata needs to flatten the .params as if it was a .elements
-    transformers.params = flatten;
-
   applyTransformations(csn, transformers, [], iterateOptions);
 
   /**
@@ -474,7 +430,7 @@ function getBranches( element, elementName, effectiveType, pathDelimiter ) {
  * @param {object} iterateOptions
  */
 function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFunctions, pathDelimiter, flattenKeyRefs, csnUtils, iterateOptions = {} ) {
-  const { error, warning } = messageFunctions;
+  const { error } = messageFunctions;
   const { inspectRef, isStructured } = csnUtils;
   const { flattenStructStepsInRef, flattenStructuredElement } = transformUtils.getTransformers(csn, options, messageFunctions, pathDelimiter);
   if (flattenKeyRefs) {
@@ -572,10 +528,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
         }
         else if (assoc.keys[i].ref && !assoc.keys[i].as) {
           setProp(assoc.keys[i], inferredAlias, true);
-          if (!(options.toOdata && assoc.keys[i].ref.length === 1))
-          // In OData backend there are no aliases assigned when the same as the ref
-          // TODO: remove the if after the new flattening in OData has been completed
-            assoc.keys[i].as = assoc.keys[i].ref[assoc.keys[i].ref.length - 1];
+          assoc.keys[i].as = assoc.keys[i].ref[assoc.keys[i].ref.length - 1];
           collector.push(assoc.keys[i]);
         }
         else {
@@ -632,8 +585,6 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
     const transformers = {
       elements: createFks,
     };
-    if (options.toOdata)
-      transformers.params = createFks;
 
     applyTransformations(csn, transformers, [], Object.assign({ skipIgnore: false }, iterateOptions));
 
@@ -661,9 +612,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
             acc[fk[0]] = 1;
 
           // check for name clash with existing elements
-          if ((parent[prop][fk[0]]) &&
-          ((options.toOdata && isDeepEqual(element, parent[prop][fk[0]], true)) ||
-            !options.toOdata)) {
+          if (parent[prop][fk[0]]) {
             // error location is the colliding element
             error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
           }
@@ -690,29 +639,18 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
               key.$generatedFieldName = fks[i][0];
               key.ref = [ (key.$ref || key.ref).join(pathDelimiter) ];
               delete key.$ref;
-              // TODO: remove the if after the new flattening in OData has been completed
-              if (options.toOdata && key.as && key.as === key.ref[0])
-                delete key.as;
+              const fk = fks[i][1];
+              if (options.transformation === 'effective')
+                copyAnnotations(key, fk);
             }
           });
-          // OData specific:
-          // Not Null sets min cardinality to 1
-          if (options.toOdata && element.notNull) {
-            if (element.cardinality === undefined)
-              element.cardinality = {};
-              // min=0 is falsy => check for undefined
-            if (element.cardinality.min === undefined) {
-              element.cardinality.min = 1;
-            }
-            else if (element.cardinality.min === 0) {
-              warning(null, element.$path, { value: cardinality2str(element, false), code: 'not null' },
-                      'Expected target cardinality $(VALUE) and $(CODE) to match');
-            }
-          }
 
           if (options.transformation === 'effective')
             delete element.default;
         }
+
+        if (options.transformation === 'effective')
+          adaptAnnotationsRefs(fks, csnUtils, messageFunctions, eltPath);
         orderedElements.push(...fks);
       });
 
@@ -737,9 +675,10 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
  * @param {object} options
  * @param {string} pathDelimiter
  * @param {number} lvl
+ * @param {object} originalKey
  * @returns {Array[]} First element of every sub-array is the foreign key name, second is the foreign key definition
  */
-function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
+function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalKey = { }) {
   const special$self = !csn?.definitions?.$self && '$self';
   const isInspectRefResult = !Array.isArray(path);
 
@@ -785,7 +724,9 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
       const result = csnUtils.inspectRef(continuePath);
-      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
+      fks = fks.concat(createForeignKeys(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1, lvl === 0 ? {
+        ref: key.ref, as: key.as, $path: key.$path, $originalKeyRef: key.$originalKeyRef,
+      } : originalKey));
     });
     if (!hasKeys)
       delete finalElement.keys;
@@ -799,7 +740,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       // Skip already produced foreign keys
       if (!elem['@odata.foreignKey4']) {
         const continuePath = getContinuePath([ 'elements', elemName ]);
-        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
+        fks = fks.concat(createForeignKeys(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1, originalKey));
       }
     });
   }
@@ -811,7 +752,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
       if (element[prop] !== undefined)
         newFk[prop] = element[prop];
     });
-    return [ [ prefix, newFk ] ];
+    return [ [ prefix, newFk, originalKey ] ];
   }
 
   fks.forEach((fk) => {

package/lib/transform/db/groupByOrderBy.js

@@ -61,8 +61,8 @@ function replaceAssociationsInGroupByOrderBy( inputQuery, options, inspectRef, e
             // (230 d) If we keep associations as they are (hdbcds naming convention), we can't have associations in ORDER BY
             if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
               error(null, orderByPath,
-                    { $reviewed: true },
-                    'Unexpected managed association in ORDER BY for naming mode “hdbcds”');
+                    { $reviewed: true, keyword: 'ORDER BY', value: 'hdbcds' },
+                    'Unexpected managed association in $(KEYWORD) for naming mode $(VALUE)');
               continue;
             }
             const pathPrefix = query.orderBy[i].ref.slice(0, -1);

package/lib/transform/db/rewriteCalculatedElements.js

@@ -311,25 +311,20 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
 
     const refPrefix = refBase.slice(0, -1);
     const linksPrefix = linksBase.slice(0, -1);
-    if (newValue.xpr) {
-      // We need to adapt the scope of all refs in the new .xpr, as it might have been at a different "root"
-      applyTransformationsOnNonDictionary(clone, 'value', {
-        ref: (p, prop, ref) => {
-          if (ref[0] !== '$self' && ref[0] !== '$projection') {
-            p.ref = [ ...refPrefix, ...ref ];
-            if (p._links)
-              p._links = [ ...linksPrefix, ...p._links ]; // TODO: Make non-enum, increment idx
-          }
-        },
-      }, {
-        // Do not rewrite refs inside an association-where; avoids endless loop
-        skipStandard: { where: true },
-      });
-    }
-    else if (clone.value.ref && clone.value.ref[0] !== '$self' && clone.value.ref[0] !== '$projection' ) {
-      clone.value.ref = [ ...refPrefix, ...clone.value.ref ];
-      clone.value._links = [ ...linksPrefix, ...clone.value._links ]; // TODO: Make non-enum, increment idx
-    }
+
+    // We need to adapt the scope of all refs in the new .xpr, as it might have been at a different "root"
+    applyTransformationsOnNonDictionary(clone, 'value', {
+      ref: (p, prop, ref) => {
+        if (ref[0] !== '$self' && ref[0] !== '$projection') {
+          p.ref = [ ...refPrefix, ...ref ];
+          if (p._links)
+            p._links = [ ...linksPrefix, ...p._links ]; // TODO: Make non-enum, increment idx
+        }
+      },
+    }, {
+      // Do not rewrite refs inside an association-where; avoids endless loop
+      skipStandard: { where: true },
+    });
     return clone.value;
   }
 

package/lib/transform/db/temporal.js

@@ -206,7 +206,8 @@ function getAnnotationHandler( csn, options, pathDelimiter, messageFunctions ) {
     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');
+              { name: '@cds.valid.from', id: '@cds.valid.to', anno: '@cds.valid.key' },
+              'Expecting $(NAME) and $(ID) if $(ANNO) is used');
       }
 
       forEachMember(artifact, (member) => {

package/lib/transform/odata/adaptAnnotationRefs.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { transformAnnotationExpression, implicitAs, } = require('../../model/csnUtils');
+
+/**
+ * Used during annotating of foreign keys.
+ * Expression annotations which are assigned to a foreign key are examined. If some ref point to another foreign
+ * key declared in the scope, we replace it with referencing the foreign key itself. If a reference is a $self reference,
+ * we do nothing and if a ref points to a structure/managed association, an error is thrown
+ *
+ * @param {Array[]} generatedForeignKeys 
+ * @param {object} csnUtils 
+ * @param {object} messageFunctions 
+ * @param {CSN.Path} elementPath 
+ */
+function adaptAnnotationsRefs(generatedForeignKeys, csnUtils, { error }, elementPath) {
+  const reportedErrorsForAnnoPath = {};
+  generatedForeignKeys.forEach((gfk, index) => {
+    Object.entries(gfk[1]).forEach(([key, value]) => {
+      if (key[0] !== '@') return;
+
+      transformAnnotationExpression(gfk[1], key, {
+        ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
+          if (ref[0] !== '$self') {
+            const { art } = csnUtils.inspectRef(elementPath ? path : getOriginatingKeyPath(gfk, path)); // OData uses getOriginatingKeyPath - as it relies on $path
+            if (csnUtils.isManagedAssociation(art)) {
+              if (!reportedErrorsForAnnoPath[path]) {
+                error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
+                reportedErrorsForAnnoPath[path] = true;
+              }
+            } else {
+              const gfkForRef = findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref);
+              if (gfkForRef.length === 1) {
+                ref[0] = gfkForRef[0][0];
+
+                if (ctx?.annoExpr?.['=']) {
+                  ctx.annoExpr['='] = true;
+                }
+              } else {
+                // check if the annotation reference points to a structure that has been expanded,
+                // if so -> report an error
+                const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk[2].$originalKeyRef), ref);
+                // references to expanded structures in flat mode will be found in the $originalKeyRef
+                // and in structured mode more than one match will be found in the generated foreign keys
+                if ((foundInOriginalRef.length || gfkForRef.length > 1) && !reportedErrorsForAnnoPath[path]) {
+                  error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
+                  reportedErrorsForAnnoPath[path] = true;
+                }
+              }
+            }
+          }
+        }
+      }, elementPath ? elementPath.concat(['keys', index]) : value?.$path?.slice(0, value.$path.length - 1)); // OData uses $path
+    });
+  });
+
+  // During tuple expansion, the key ref object looses the $path, therefore
+  // it needs to be extracted from the anno path
+  function getOriginatingKeyPath(gfk, path) {
+    return gfk[2].$path || path.slice(0, path.findIndex(ps => ps[0] === '@'));
+  }
+
+  // Loops through the generated foreign keys for this entity
+  // and filters the ones, which were created for this specific
+  // key ref. In case there are more than one foreign keys found,
+  // that means the key ref points to a structured element/managed assoc
+  function findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref) {
+    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk[2].as || implicitAs(gfk[2].ref))));
+  }
+
+  // Tuple expansion is performed before the generation of the foreign keys and the original(unexpanded) key ref
+  // is stored in the property $originalKeyRef. Here we try to evaluate whether the reference in the annotation
+  // points to a structure that has been expanded.
+  function findOriginalRef(generatedForeignKeys, ref) {
+    return generatedForeignKeys.filter(gfk => (ref.join() === (gfk[2].$originalKeyRef.as || implicitAs(gfk[2].$originalKeyRef.ref))));
+  }
+}
+
+module.exports = adaptAnnotationsRefs;

package/lib/transform/odata/createForeignKeys.js

@@ -2,15 +2,16 @@
 
 const { isBuiltinType } = require('../../base/builtins');
 const { setProp } = require('../../base/model');
-const { transformAnnotationExpression, applyTransformations, implicitAs, findAnnotationExpression, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
+const { applyTransformations, implicitAs, findAnnotationExpression, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
+const adaptAnnotationsRefs = require('./adaptAnnotationRefs');
 
 function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
 
     const { error } = messageFunctions;
 
     applyTransformations(csn, { elements: createForeignKeysInCsn, params: createForeignKeysInCsn},
-                         [], Object.assign(iterateOptions, { skip: ['event'], skipStandard: { targetAspect: true } }));
+                         [], Object.assign(iterateOptions, { skip: ['event'] }));
 
     /**
      * Process a given elements or params dictionary and create foreign key elements.
@@ -61,7 +62,7 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
             delete element.default;
         }
 
-        adaptAnnotationsRefs(generatedForeignKeys, csnUtils);
+        adaptAnnotationsRefs(generatedForeignKeys, csnUtils, messageFunctions);
         setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk[0]));
         orderedElements.push(...generatedForeignKeys);
       
@@ -190,74 +191,6 @@ function createForeignKeysForElement(csnUtils, path, element, prefix, csn, optio
     return [ ...path, ...additions ];
   }
 }
-
-  function adaptAnnotationsRefs(generatedForeignKeys, csnUtils) {
-    let reportedErrorsForAnnoPath = {};
-    generatedForeignKeys.forEach(gfk => {
-      Object.entries(gfk[1]).forEach(([key, value]) => {
-        if (key[0] !== '@') return;
-
-        transformAnnotationExpression(gfk[1], key, {
-          ref: (_parent, _prop, ref, path, _p, _ppn, ctx) => {
-            if (ref[0] !== '$self') {
-
-              const { art } = csnUtils.inspectRef(getOriginatingKeyPath(gfk, path));
-              if (csnUtils.isManagedAssociation(art)) {
-                if (!reportedErrorsForAnnoPath[path]) {
-                  error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
-                  reportedErrorsForAnnoPath[path] = true;
-                }
-              } else {
-                const gfkForRef = findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref);
-                if (gfkForRef.length === 1) {
-                  ref[0] = gfkForRef[0][0];
-
-                  if (ctx?.annoExpr?.['=']) {
-                    ctx.annoExpr['='] = true;
-                  }
-                } else {
-                  // check if the annotation reference points to a structure that has been expanded,
-                  // if so -> report an error
-                  const foundInOriginalRef = findOriginalRef(generatedForeignKeys.filter(gfk => gfk[2].$originalKeyRef), ref);
-                  // references to expanded structures in flat mode will be found in the $originalKeyRef
-                  // and in strucred mode more than one match will be found in the generated foreign keys
-                  if ((foundInOriginalRef.length || gfkForRef.length > 1) && !reportedErrorsForAnnoPath[path]) {
-                    error('odata-anno-xpr-ref', path, { elemref: { ref }, anno: key, '#': 'fk_substitution' });
-                    reportedErrorsForAnnoPath[path] = true;
-                  }
-                }
-              }
-            }
-          }
-        }, value?.$path?.slice(0, value.$path.length - 1));
-      });
-    });
-
-    // During tuple expansion, the key ref object looses the $path, therefore
-    // it needs to be extracted from the anno path
-    function getOriginatingKeyPath(gfk, path) {
-      return gfk[2].$path || path.slice(0, path.findIndex(ps => ps[0] === '@'));
-    }
-
-    // Loops through the generated foreign keys for this entity
-    // and filters the ones, which were created for this specific
-    // key ref. In case there are more than one foreign keys found,
-    // that means the key ref points to a structured element/managed assoc
-    function findGeneratedForeignKeyForKeyRef(generatedForeignKeys, ref) {
-      return generatedForeignKeys.filter(gfk => {
-        return (ref.join() === (gfk[2].as || implicitAs(gfk[2].ref)));
-      });
-    }
-
-    // Tuple expansion is performed before the generation of the foreign keys and the original(unexpanded) key ref
-    // is stored in the property $originalKeyRef. Here we try to evaluate whether the reference in the annotation
-    // points to a structure that has been expanded.
-    function findOriginalRef(generatedForeignKeys, ref) {
-      return generatedForeignKeys.filter(gfk => {
-        return (ref.join() === (gfk[2].$originalKeyRef.as || implicitAs(gfk[2].$originalKeyRef.ref)));
-      });
-    }
-  }
 }
 
 module.exports = createForeignKeyElements;

package/lib/transform/odata/flattening.js

@@ -64,6 +64,15 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
                   allMgdAssocDefs.push(elt);
                 }
               }, [ flatEltName ], true, { pathWithoutProp: true } );
+            } else if (flatElt.targetAspect) {
+              forEachMemberRecursively(flatElt.targetAspect, (elt, _eltName, _prop, _path) => {
+                // TODO: check whether that needs to be done for targetAspects as well
+                // const exprAnnos = Object.keys(elt).filter(pn => pn[0] === '@');
+                // flattenAndPrefixExprPaths(elt, exprAnnos, elt.$path, path, 0, true);
+                if (csnUtils.isManagedAssociation(elt)) {
+                  allMgdAssocDefs.push(elt);
+                }
+              }, [ flatEltName ], true, { pathWithoutProp: true } );
             }
             setProp(flatElt, '$pathInStructuredModel', flatElt.$path);
             setProp(flatElt, '$path', [ ...csnPath, flatEltName ]);
@@ -339,7 +348,8 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTy
   
           let hasItems = false;
           for(; i >= 0 && !getProp('target') && !hasItems; i--) {
-            hasItems = !!getProp('items')
+            const art = links[i].art;
+            hasItems = !!getProp('items') || (art.type && !!csnUtils.getFinalTypeInfo(art.type)?.items)
           }
           if(!hasItems) {
             const ft = csnUtils.getFinalTypeInfo(art.type);

package/lib/transform/transformUtils.js

@@ -6,10 +6,10 @@
 
 const { setProp } = require('../base/model');
 
-const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand } = require('../model/csnUtils');
+const { copyAnnotations, applyTransformations, isDollarSelfOrProjectionOperand, transformAnnotationExpression } = require('../model/csnUtils');
 const { getUtils } = require('../model/csnUtils');
 const { typeParameters } = require('../compiler/builtins');
-const { isBuiltinType } = require('../base/builtins');
+const { isBuiltinType, isAnnotationExpression } = require('../base/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
 const { cloneCsnNonDict, cloneCsnDict } = require('../model/cloneCsn');
@@ -39,11 +39,9 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     resolvePath,
     flattenPath,
     addDefaultTypeFacets,
-    getForeignKeyArtifact,
     flattenStructuredElement,
     flattenStructStepsInRef,
     toFinalBaseType,
-    copyTypeProperties,
     createExposingProjection,
     createAndAddDraftAdminDataProjection,
     createScalarElement,
@@ -105,53 +103,6 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   */
   }
 
-  // createRealFK 'really' creates the new foreign key element and is used by the two
-  // main FK generators getForeignKeyArtifact & createForeignKeyElement
-  //      and (not yet) generateForeignKeyElements.js::generateForeignKeysForRef()
-  // TODO/FIXME: Can they be combined?
-  function createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName) {
-    const foreignKeyElement = Object.create(null);
-
-    // Transfer selected type properties from target key element
-    // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
-    for (const prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-      if (fkArtifact[prop] !== undefined) {
-        foreignKeyElement[prop] = fkArtifact[prop];
-      }
-    }
-
-    if (options.transformation === 'odata' || options.transformation === 'effective')
-      copyAnnotations(assoc, foreignKeyElement, true);
-
-    // If the association is non-fkArtifact resp. key, so should be the foreign key field
-    for (const prop of ['notNull', 'key']) {
-      if (assoc[prop] !== undefined) {
-        foreignKeyElement[prop] = assoc[prop];
-      }
-    }
-
-    // Establish the relationship between generated field and association:
-    // - generated field has annotation '@odata.foreignKey4'.
-    // - foreign key info has 'generatedFieldName'
-    if(options.transformation !== 'effective')
-      foreignKeyElement['@odata.foreignKey4'] = assocName;
-    foreignKey.$generatedFieldName = foreignKeyElementName;
-    // attach $path to the newly created element - used for inspectRef in processAssociationOrComposition
-    setProp(foreignKeyElement, '$path', path);
-    if (assoc.$location) {
-      setProp(foreignKeyElement, '$location', assoc.$location);
-    }
-    return foreignKeyElement;
-  }
-
-  function getForeignKeyArtifact(assoc, assocName, foreignKey, path) {
-    const fkArtifact = inspectRef(path).art;
-    // FIXME: Duplicate code
-    // Assemble foreign key element name from assoc name, '_' and foreign key name/alias
-    const foreignKeyElementName = `${assocName.replace(/\./g, pathDelimiter)}${pathDelimiter}${foreignKey.as || foreignKey.ref.join(pathDelimiter)}`;
-    return [ foreignKeyElementName, createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName) ];
-  }
-
   // For a structured element 'elem', return a dictionary of flattened elements to
   // replace it, flattening names with pathDelimiter's value and propagating all annotations and the
   // type properties 'key', 'notNull', 'virtual', 'masked' to the flattened elements.
@@ -244,7 +195,24 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         '@odata.Collation': 1,
         '@odata.Unicode': 1,
       } : {};
-      copyAnnotations(elem, flatElem, false, excludes);
+      const annoNames = copyAnnotations(elem, flatElem, false, excludes);
+      if(options.transformation === 'effective') {
+        for(const annoName of annoNames) {
+          if(flatElem.keys && isAnnotationExpression(elem[annoName])) {
+            flatElem.keys.forEach(key => {
+              if(!key[annoName]) {
+                key[annoName] = flatElem[annoName];
+                transformAnnotationExpression(key, annoName, {
+                  ref: (parent, prop, ref) => {
+                    if(ref[0] !== '$self')
+                      parent.ref = ['$self', ...parent.ref];
+                  }
+                })
+              }
+            })
+          }
+        }
+      }
 
       // Copy selected type properties
       const props = ['key', 'virtual', 'masked', 'viaAll'];
@@ -335,39 +303,6 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     return [ result, refChanged ];
   }
 
-  /**
-   * Copy properties of the referenced type, but don't resolve to the final base type.
-   *
-   * Do not copy the length if it was just set via the default-value.
-   *
-   * @param {any} node Node to copy to
-   * @returns {void}
-   */
-  function copyTypeProperties(node) {
-    // Nothing to do if no type (or if array/struct type)
-    if (!node || !node.type) return;
-    // ..  or if it is a ref
-    if (node.type && node.type.ref) return;
-    // ..  or builtin already
-    if (node.type && isBuiltinType(node.type)) return;
-
-    // The type might already be a full fledged type def (array of)
-    const typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
-    // Nothing to do if type is an array or a struct type
-    if (typeDef.items || typeDef.elements) return;
-    // if the declared element is an enum, these values are with priority
-    if (!node.enum && typeDef.enum)
-      Object.assign(node, { enum: typeDef.enum });
-    if (!node.length && typeDef.length && !typeDef.$default)
-      Object.assign(node, { length: typeDef.length });
-    if (!node.precision && typeDef.precision)
-      Object.assign(node, { precision: typeDef.precision });
-    if (!node.scale && typeDef.scale)
-      Object.assign(node, { scale: typeDef.scale });
-    if (!node.srid && typeDef.srid)
-      Object.assign(node, { srid: typeDef.srid });
-  }
-
   /**
    * Replace the type of 'nodeWithType' with its final base type, i.e. copy relevant type properties and
    * set the `type` property to the builtin if scalar or delete it if structured/arrayed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.6.0",
+  "version": "5.7.0",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -22,6 +22,7 @@
     "test:ci": "node scripts/verifyGrammarChecksum.js && mocha --timeout 10000 --reporter-option maxDiffSize=0 scripts/testLazyLoading.js && mocha --parallel --reporter-option maxDiffSize=0 test/ test3/",
     "test:piper": "node scripts/verifyGrammarChecksum.js && npm run coverage:piper",
     "test3": "node scripts/verifyGrammarChecksum.js && mocha --reporter-option maxDiffSize=0 test3/",
+    "testStandardDatabaseFunctions": "CDS_COMPILER_STANDARD_DB_FUNCTIONS=1 mocha --reporter-option maxDiffSize=0 test3/test.standard-database-functions.js",
     "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",