@sap/cds-compiler 5.3.2 → 5.4.2

package/lib/transform/odata/createForeignKeys.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const { isBuiltinType } = require('../../base/builtins');
+const { setProp } = require('../../base/model');
+const { applyTransformations, implicitAs, findAnnotationExpression, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
+const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
+
+function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
+
+    const { error } = messageFunctions;
+
+    applyTransformations(csn, { elements: createForeignKeysInCsn, params: createForeignKeysInCsn},
+                         [], Object.assign(iterateOptions, { skip: ['aspect', 'event'], skipStandard: { targetAspect: true } }));
+
+    /**
+     * Process a given elements or params dictionary and create foreign key elements.
+     *
+     * @param {object} parent The thing HAVING params or elements
+     * @param {string} prop
+     * @param {object} dict The params or elements thing
+     * @param {CSN.Path} path
+     */
+    function createForeignKeysInCsn( parent, prop, dict, path ) {
+      const orderedElements = [];
+      // First, generate the FK elements for given element
+      Object.entries(dict).forEach(([elementName, element]) => {
+        orderedElements.push([ elementName, element ]);
+        if (!csnUtils.isManagedAssociation(element)) return;
+        const elementPath = path.concat(prop, elementName);
+        const generatedForeignKeys = createForeignKeysForElement(csnUtils, elementPath, element, elementName, csn, options, '_');
+
+        // Second, finalize the generated FK elements
+        const refCount = generatedForeignKeys.reduce((acc, fk) => {
+          // count duplicates
+          if (acc[fk[0]])
+            acc[fk[0]]++;
+          else
+            acc[fk[0]] = 1;
+
+          // check for name clash with existing elements
+          if (parent[prop][fk[0]] && isDeepEqual(element, parent[prop][fk[0]], true)) {
+            // error location is the colliding element
+            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
+          }
+          // attach a proper $path
+          setProp(element, '$path', elementPath);
+          return acc;
+        }, Object.create(null));
+
+        // set default for single foreign key from association (if available)
+        if (element.default?.val !== undefined && generatedForeignKeys.length === 1)
+        generatedForeignKeys[0][1].default = element.default;
+
+        // check for duplicate foreign keys
+        Object.entries(refCount).forEach(([ name, occ ]) => {
+          if (occ > 1)
+            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-gen', name, art: elementName });
+        });
+        if (element.keys) {
+          if (options.transformation === 'effective')
+            delete element.default;
+        }
+        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => gfk[0]));
+        orderedElements.push(...generatedForeignKeys);
+      
+    });
+
+    parent[prop] = orderedElements.reduce((elementsAccumulator, [ name, element ]) => {
+      elementsAccumulator[name] = element;
+      return elementsAccumulator;
+    }, Object.create(null));
+}
+
+function createForeignKeysForElement(csnUtils, path, element, prefix, csn, options, pathDelimiter, lvl = 0 ) {
+  const special$self = !csn?.definitions?.$self && '$self';
+  const isInspectRefResult = !Array.isArray(path);
+
+  let fks = [];
+  if (!element)
+    return fks;
+
+  let finalElement = element;
+  let finalTypeName;
+
+  // resolve derived type
+  if (element.type && !isBuiltinType(element.type) && element.type !== special$self) {
+    const tmpElt = csnUtils.effectiveType(element);
+    // effective type resolves to structs and enums only but not scalars
+    if (Object.keys(tmpElt).length) {
+      finalElement = tmpElt;
+      finalTypeName = finalElement.$path[1];
+    }
+    else {
+      // unwind a derived type chain to a scalar type
+      while (finalElement?.type && !isBuiltinType(finalElement?.type)) {
+        finalTypeName = finalElement.type;
+        finalElement = csn.definitions[finalElement.type];
+      }
+    }
+  }
+
+  if (!finalElement)
+    return [];
+
+  // main if for this function
+  // the element is a managed association
+  if (csnUtils.isManagedAssociation(finalElement)) {
+    finalElement.keys.forEach((key, keyIndex) => {
+      const continuePath = getContinuePath([ 'keys', keyIndex ]);
+      const alias = key.as || implicitAs(key.ref);
+      const result = csnUtils.inspectRef(continuePath);
+      fks = fks.concat(createForeignKeysForElement(csnUtils, result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
+    });
+  }
+  // the element is a structure
+  else if (finalElement.elements) {
+    Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
+      // Skip already produced foreign keys
+      if (!elem['@odata.foreignKey4']) {
+        const continuePath = getContinuePath([ 'elements', elemName ]);
+        fks = fks.concat(createForeignKeysForElement(csnUtils, continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
+      }
+    });
+  }
+  // we have reached a leaf element, create a foreign key
+  else if ((finalElement.type == null || isBuiltinType(finalElement.type)) && !finalElement.on) {
+    const newFk = Object.create(null);
+    [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
+      // copy props from original element to preserve derived types!
+      if (element[prop] !== undefined)
+        newFk[prop] = element[prop];
+    });
+    return [ [ prefix, newFk ] ];
+  }
+
+  fks.forEach((fk) => {
+    // prepend current prefix
+    fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
+    // if this is the entry association, decorate the final foreign keys with the association props/annos
+    if (lvl === 0) {
+      if (options.transformation !== 'effective')
+        fk[1]['@odata.foreignKey4'] = prefix;
+      
+      const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !findAnnotationExpression(element, pn));
+      copyAnnotations(element, fk[1], true, {}, validAnnoNames);
+      // propagate not null to final foreign key
+      for (const prop of [ 'notNull', 'key' ]) {
+        if (element[prop] !== undefined)
+          fk[1][prop] = element[prop];
+      }
+      if (element.$location)
+        setProp(fk[1], '$location', element.$location);
+    }
+  });
+  return fks;
+
+  /**
+   * Get the path to continue resolving references
+   *
+   * If we are currently inside of a type, we need to start our path fresh from that given type.
+   * Otherwise, we would try to resolve .elements on a thing that does not exist.
+   *
+   * We also respect if we have a previous inspectRef result as our base.
+   *
+   * @param {Array} additions
+   * @returns {CSN.Path}
+   */
+  function getContinuePath( additions ) {
+    if (csn.definitions[finalElement.type])
+      return [ 'definitions', finalElement.type, ...additions ];
+    else if (finalTypeName)
+      return [ 'definitions', finalTypeName, ...additions ];
+    else if (isInspectRefResult)
+      return [ path, ...additions ];
+    return [ ...path, ...additions ];
+  }
+}
+}
+
+module.exports = createForeignKeyElements;

package/lib/transform/odata/flattening.js

@@ -5,14 +5,16 @@ const { forEachDefinition,
   transformExpression, transformAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const transformUtils = require('../transformUtils');
-const { setProp } = require('../../base/model');
+const { setProp, forEachGeneric } = require('../../base/model');
 const { applyTransformationsOnDictionary,
   applyTransformationsOnNonDictionary } = require('../db/applyTransformations.js');
 const { handleManagedAssociationsAndCreateForeignKeys } = require('../db/flattening');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 const { forEach } = require('../../utils/objectUtils');
+const { assignAnnotation } = require('../../edm/edmUtils');
 
-function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options) {
+function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, getFinalTypeInfo, isExternalServiceMember, error, csnUtils, options) {
+  const allMgdAssocDefs = []; 
   forEachDefinition(csn, (def, defName) => {
     if (def.kind === 'entity' && !isExternalServiceMember(def, defName)) {
       ['elements', 'params'].forEach(dictName => {
@@ -27,7 +29,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
             let resolvedElt = child;
             let typeIdx = 0;
             if (child.type && !child.elements) {
-              resolvedElt = csnUtils.getFinalTypeInfo(child.type);
+              resolvedElt = getFinalTypeInfo(child.type);
               if (resolvedElt.elements)
                 typeIdx = rootPrefix.length + 1;
             }
@@ -41,10 +43,12 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
                         { '#': 'flatten-element-exist', name: flatEltName });
                 propagateToFlatElem(child, flatElt);
                 rewriteOnCondition(flatElt, flattenedSubTree);
+                adaptManagedAssociationSpecialFields(flatElt, flatEltName, flattenedSubTree);
                 orderedElementList.push([flatEltName, flatElt]);
               });
             }
             else {
+              // TODO: run adaptManagedAssociationSpecialFields here as well
               const flatElt = cloneElt(dictName, child, location, [ defName, childName ]);
               orderedElementList.push([childName, flatElt]);
             }
@@ -53,16 +57,26 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
           const flatDict = orderedElementList.reduce((elements, [ flatEltName, flatElt ]) => {
             if (flatElt.items) {
               // rewrite annotation paths inside items.elements
-              forEachMemberRecursively(flatElt.items, (elt, _eltName, _prop, path) => {
+              forEachMemberRecursively(flatElt.items, (elt, eltName, _prop, path) => {
                 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 ]);
             elements[flatEltName] = flatElt;
             return elements;
           }, Object.create(null));
           setProp(def, `$flat${dictName}`, flatDict);
+          orderedElementList.reduce(
+            (mgdAssocs, [ _flatEltName, flatElt ]) => {
+              if(csnUtils.isManagedAssociation(flatElt))
+                mgdAssocs.push(flatElt);
+              return mgdAssocs;
+            }, allMgdAssocDefs);
         }
       });
       // entity annotations
@@ -126,7 +140,30 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
         });
       }
     }
+    // loop through types as well in order to collect the managaed associations
+    // that reside in types definitions
+    if ((def.kind === 'action' || def.kind === 'function' || def.kind === 'type') && !isExternalServiceMember(def, defName)) {
+      if (def.kind === 'type' && csnUtils.isManagedAssociation(def))
+        allMgdAssocDefs.push(def);
+      else
+        forEachMemberRecursively(def, (elt, _eltName, _prop, _path) => {
+          if (csnUtils.isManagedAssociation(elt)) {
+            allMgdAssocDefs.push(elt);
+          }
+        });
+    }
+    // loop through actions/functions and action/function parameters as well
+    if (def.kind === 'entity' && def.actions && !isExternalServiceMember(def, defName)) {
+      forEachGeneric(def, 'actions', (act) => {
+        forEachMemberRecursively(act, (elt, _eltName, _prop, _path) => {
+          if (csnUtils.isManagedAssociation(elt)) {
+            allMgdAssocDefs.push(elt);
+          }
+        });
+      });
+    }
   });
+  return allMgdAssocDefs;
 
   function recurseIntoElement(scope, elt, resolvedElt, rootPathIsNotNull, location, rootPrefix = [], typeIdx = 0) {
     const eltName = rootPrefix[rootPrefix.length-1];
@@ -143,7 +180,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       forEach(resolvedElt.elements, (childName, child) => {
         resolvedElt = child;
         if (child.type && !child.elements) {
-          resolvedElt = csnUtils.getFinalTypeInfo(child.type);
+          resolvedElt = getFinalTypeInfo(child.type);
           if (resolvedElt.elements)
             typeIdx = rootPrefix.length + 1;
         }
@@ -206,14 +243,16 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   function cloneElt(scope, elt, location, rootPrefix = [], typeIdx = 0) {
     const flatElt = cloneCsnNonDict(elt,
       { ...options,
-        hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ]
+        hiddenPropertiesToClone: [ '$structRef', '$fkExtensions', '$generatedForeignKeys' ]
       } );
 
     // needed for @cds.persistence.name
     setProp(flatElt, '$defPath', rootPrefix);
     setProp(flatElt, '$scope', scope);
     retypeCloneWithFinalBaseType(flatElt, location);
-
+    if((elt._type || elt).type === 'cds.Map') {
+      assignAnnotation(flatElt, '@open', elt['@open'] || true);
+    }
     const [ nonAnnoProps, exprAnnoProps ] = Object.keys(flatElt).reduce((acc, pn) => {
       if (pn[0] !== '@' && pn !== 'value')
         acc[0].push(pn);
@@ -405,6 +444,25 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
       });
     }
   }
+
+  // update the @odata.foreignKey4 and the $generatedForeignKeys array of
+  // an association that have been flattened
+  function adaptManagedAssociationSpecialFields(flatElt, flatEltName, flattenedSubTree) {
+    if (!(flatElt.target || flatElt.keys) && !flatElt.on )
+      return;
+    const structuredAssocName = flatElt.$defPath[flatElt.$defPath.length - 1];
+    const generatedForeignKeysForAssoc = flattenedSubTree
+      .filter(se => {
+        // compare $defPath without the last element
+        let comeFromSameDef = flatElt.$defPath.slice(0, flatElt.$defPath.length - 1).join('.') === se[1].$defPath.slice(0, se[1].$defPath.length - 1).join('.');
+        return (comeFromSameDef && (se[1]['@odata.foreignKey4'] && se[1]['@odata.foreignKey4'] === structuredAssocName) && se[0].startsWith(flatEltName))
+      });
+    
+    generatedForeignKeysForAssoc.forEach(gfk => gfk[1]['@odata.foreignKey4'] = flatEltName);
+    // reassign the generated foreign keys for current assoc in order to assign
+    // correct values for $generatedFieldName later on during flattenManagedAssocsAsKeys();
+    setProp(flatElt, '$generatedForeignKeys', generatedForeignKeysForAssoc.map(gfk => gfk[0]));
+  }
 }
 
 function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef, effectiveType,
@@ -494,6 +552,8 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
+      if (insideKeys(path))
+        setProp(parent, '_art', art);
       const lastRef = ref[ref.length - 1];
       const fn = (suspend = false, suspendPos = 0, 
                     refFilter = (_parent) => true) => {
@@ -536,18 +596,19 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
             || path[path.length - 3] === 'projection')
             && path[path.length - 2] === 'columns';
         }
-        /**
-         * Return true if the path points inside keys
-         *
-         * @param {CSN.Path} path
-         * @returns {boolean}
-         */
-        function insideKeys( path ) {
-          return path.length >= 3
-            && path[path.length - 2] === 'keys'
-            && typeof path[path.length - 1] === 'number';
-        }
       };
+      /**
+       * Return true if the path points inside keys
+       *
+       * @param {CSN.Path} path
+       * @returns {boolean}
+       */
+      function insideKeys( path ) {
+        return path.length >= 3
+          && path[path.length - 2] === 'keys'
+          && typeof path[path.length - 1] === 'number';
+      }
+
 
       // adapt queries later
       if(ctx?.annoExpr?.['=']) {
@@ -565,9 +626,64 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
   return { adaptRefs, transformer, inspectRef, effectiveType };
 }
 
+// replace managed associations in key refs with their respective foreing keys
+function replaceManagedAssocsAsKeys(allFlatManagedAssocDefinitions, csnUtils) {
+  allFlatManagedAssocDefinitions.forEach( assoc => {
+    let finished = false;
+
+    while (!finished) {
+      const newKeys = [];
+      finished = processKeys(newKeys);
+      assoc.keys = newKeys;
+    }
+
+    function processKeys(collector) {
+      let done = true;
+      assoc.keys.forEach( key => {
+        const art = key._art;
+        if (art && csnUtils.isManagedAssociation(art)) {
+          done = false;
+          // key._art is the artifact from the structured model, because of that we need to look
+          // for the flat representation in the allFlatManagedAssocDefinitions
+          allFlatManagedAssocDefinitions.find(fa => (fa.$pathInStructuredModel || fa.$path).join() === art.$path.join())
+            .keys.forEach( keyAssocKey => {
+            collector.push(cloneAndExtendRef(keyAssocKey, key));
+          });
+        }
+        else if (art && !art.on){
+          if (!key.$generatedFieldName) {
+            const flatAssocName = assoc.$path[assoc.$path.length - 1];
+            // When we have a definition like type "<type_name>: Association to <target_name>",
+            // we do not generate foreign keys in the definition, therefore no $generatedForeignKeys,
+            // respectively we do not assign $generatedFieldName
+            if (assoc.$generatedForeignKeys) {
+              const generatedForeignKey = assoc.$generatedForeignKeys.find(gfk => gfk === `${flatAssocName}_${key.as || key.ref.join('_')}`);
+              key.$generatedFieldName = generatedForeignKey;
+            }
+          }
+          if (key.as && key.as === key.ref[0]) delete key.as;
+          collector.push(key);
+        }
+      })
+
+      return done;
+    }
+  });
+  
+  function cloneAndExtendRef(keyAssocKey, key) {
+    let newKey = { ref:  [`${key.ref.join('_')}_${keyAssocKey.as || keyAssocKey.ref.join('_')}`] };
+    setProp(newKey, '_art', keyAssocKey._art);
+    if (key.as) {
+      newKey.as = `${key.as}_${keyAssocKey.as || keyAssocKey.ref.join('_')}`;
+    }
+    return newKey;
+  }
+}
+
 module.exports = {
   allInOneFlattening,
   flattenAllStructStepsInRefs,
   handleManagedAssociationsAndCreateForeignKeys,
-  getStructRefFlatteningTransformer
+  getStructRefFlatteningTransformer,
+  replaceManagedAssocsAsKeys
 };

package/lib/transform/odata/typesExposure.js

@@ -64,6 +64,7 @@ const { cloneCsnNonDict } = require('../../model/cloneCsn');
 function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   const special$self = !csn?.definitions?.$self && '$self';
+
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.odataVersion === 'v4' && (options.odataProxies || options.odataXServiceRefs);
   // service sub schemas as return value
@@ -166,7 +167,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           isKey = false;
         // in case this was a named type and if the openness does not match the type definition
         // expose the type as a new one not changing the original definition.
-        if(elements && !!node['@open'] !== !!typeDef['@open'])
+        if(elements && node['@open'] != null && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
         lastNonAnonymousFQDefName = fullQualifiedNewTypeName;
       }
@@ -293,10 +294,10 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       if(type) {
         typeName = (type.ref && csnUtils.artifactRef(type)) || type;
         const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if(!isBuiltinType(typeName) && typeName !== special$self) {
+        if((!isBuiltinType(typeName) || typeName === 'cds.Map') && typeName !== special$self) {
           rc.typeDef = typeDef = csnUtils.artifactRef(typeName, typeName);
           if(!isArtifactInService(typeName, serviceName)) {
-            while(!isBuiltinType(typeName)) {
+            while(!isBuiltinType(typeName) || typeDef.$emtpyMapType) {
               typeDef = csnUtils.artifactRef(typeName, typeName);
               if(typeDef !== typeName) {
                 // Implementation note: For `type S: T:struct;`, elements from `T:struct` were already propagated to `S`.

package/lib/transform/transformUtils.js

@@ -1332,14 +1332,14 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
 
       function isScalarOrNoType(art) {
         art = effectiveType(art);
-        if(art) {
-          const type = art.type || (art.items && art.items.type);
-          // items in ON conds are illegal but this should be checked elsewhere
+        if (art) {
+          const type = art.type || art.items?.type;
+          // items in ON-conditions are illegal but this should be checked elsewhere
           const elements = art.elements || (art.items && art.items.elements);
           // @Core.Computed has no type
-          return(!elements && !type ||
-          (type && isBuiltinType(type) &&
-           !['cds.Association', 'cds.Composition'].includes(type)))
+          return (!elements && !type ||
+            (type && isBuiltinType(type) &&
+              type !== 'cds.Association' && type !== 'cds.Composition' && type !== 'cds.Map'))
         }
         return false;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "5.3.2",
+  "version": "5.4.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",