@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/edm/edmPreprocessor.js

@@ -43,19 +43,23 @@ function initializeModel(csn, _options, messageFunctions)
 
   const csnUtils = getUtils(csn);
   const {
+      inspectRef,
       getCsnDef,
       getFinalTypeDef,
       isStructured,
       isAssocOrComposition,
     } = getUtils(csn);
 
+  // proxies are merged into the final model after all proxy elements are collected
+  const proxyCache = [];
 
   // make sure options are complete
   let options = validateOptions(_options);
 
   // Fetch service definitions
-  const serviceRoots = Object.keys(csn.definitions || {}).reduce((serviceRoots, artName) => {
-    const art = csn.definitions[artName];
+  const allDefs = Object.entries(csn.definitions||{});
+
+  const serviceRoots = allDefs.reduce((serviceRoots, [artName, art]) => {
     if(art.kind === 'service') {
       serviceRoots[artName] = Object.assign(art, { name: artName });
     }
@@ -64,11 +68,24 @@ function initializeModel(csn, _options, messageFunctions)
 
   // first of all we need to know about all 'real' user defined services
   const serviceRootNames = Object.keys(serviceRoots).sort((a,b)=>b.length-a.length);
+
   function whatsMyServiceRootName(n, self=true) {
     return serviceRootNames.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') || (n === sn && self) ? sn : rc, undefined);
   }
+
+  // find a globally unambiguous schema name to collect all top level 'root' types
+  // TODO: work on service basis (this requires post exposure renaming)
+  let autoexposeSchemaName = 'root';
+  let i = 1;
+  while (allDefs.some(([artName, _art]) => {
+    const p = artName.split('.');
+    return p.length === 2 && p[0] === autoexposeSchemaName;
+  })) {
+    autoexposeSchemaName = 'root' + i++;
+  }
+
   if(serviceRootNames.length === 0) {
-    return [serviceRoots, Object.create(null), whatsMyServiceRootName, options];
+    return [serviceRoots, Object.create(null), whatsMyServiceRootName, autoexposeSchemaName, options];
   }
 
   // Structural CSN inbound QA checks
@@ -103,7 +120,7 @@ function initializeModel(csn, _options, messageFunctions)
     service), the namespace (including (sub-)contexts) or as last resort (if the type name
      has no prefix path) a 'root' namespace.
   */
-  const schemas = typesExposure(csn, whatsMyServiceRootName, options, csnUtils, { error });
+  const schemas = typesExposure(csn, whatsMyServiceRootName, autoexposeSchemaName, options, csnUtils, { error });
 
   // First attach names to all definitions (and actions/params) in the model
   // elements are done in initializeStruct
@@ -145,6 +162,9 @@ function initializeModel(csn, _options, messageFunctions)
     // create association target proxies
     // Decide if an entity set needs to be constructed or not
     forEachDefinition(csn, [ exposeTargetsAsProxiesOrSchemaRefs, determineEntitySet ]);
+    // finalize proxy creation
+    mergeProxiesIntoModel();
+
     if(options.isV4())
       forEachDefinition(csn, initializeEdmNavPropBindingTargets);
 
@@ -156,7 +176,7 @@ function initializeModel(csn, _options, messageFunctions)
     forEachDefinition(csn, [ initializeEdmKeyRefPaths, initializeEdmNavPropBindingPaths,
       initializeEdmTypesAndDescription, checkArtifactIdentifierAndBoundActions ]);
   }
-  return [serviceRoots, schemas, whatsMyServiceRootName, options];
+  return [serviceRoots, schemas, whatsMyServiceRootName, autoexposeSchemaName, options];
 
   //////////////////////////////////////////////////////////////////////
   //
@@ -186,16 +206,16 @@ function initializeModel(csn, _options, messageFunctions)
     const dotEntityNameMap = Object.create(null);
     const dotTypeNameMap = Object.create(null);
     forEachDefinition(csn, (def, defName) => {
-      if(['entity', 'view', 'type', 'action', 'function'].includes(def.kind)) {
+      if(['entity', 'type', 'action', 'function'].includes(def.kind)) {
         const rootDef = getRootDef(defName);
         // if this definition has a root def and the root def is not the service/schema name
         // => service C { type D.E }, replace the prefix dots with underscores
         if(rootDef && defName !== rootDef && rootDef !== getSchemaPrefix(defName)) {
           let newDefName = rootDef + '.' + defName.replace(rootDef + '.', '').replace(/\./g, '_');
           // store renamed types in correlation maps for later renaming
-          if(['entity', 'view'].includes(def.kind))
+          if(def.kind === 'entity')
             dotEntityNameMap[defName] = newDefName;
-          if(['type'].includes(def.kind))
+          if(def.kind === 'type')
             dotTypeNameMap[defName] = newDefName;
           // rename in csn.definitions
           const art = csn.definitions[newDefName];
@@ -252,7 +272,7 @@ function initializeModel(csn, _options, messageFunctions)
   */
   function splitDottedDefinitionsIntoSeparateServices() {
     forEachDefinition(csn, (def, defName) => {
-      if(![ 'service' ].includes(def.kind)) {
+      if(def.kind !== 'service') {
         const myServiceRoot = whatsMyServiceRootName(defName);
         const mySchemaPrefix = getSchemaPrefix(defName);
         if(myServiceRoot && options.isV4() &&
@@ -342,7 +362,7 @@ function initializeModel(csn, _options, messageFunctions)
   //   entity set. Instead try to rewrite the annotation in such a way that it is effective
   //   on the containment navigation property.
   function initializeContainments(container) {
-    if(['entity', 'view'].includes(container.kind)) {
+    if(container.kind === 'entity') {
       forEachMemberRecursively(container, initContainments,
         [], true, { elementsOnly: true });
     }
@@ -466,6 +486,17 @@ function initializeModel(csn, _options, messageFunctions)
       elt.name = n;
       delete elt.kind;
       elt.key = true; // params become primary key in parameter entity
+      /*
+        Spec meeting decision 28.02.22:
+        Annotation @sap.parameter allows two values "mandatory"/"optional".
+        Question was how to deal with incompatible "optional".
+        Only "mandatory" is allowed because in RAP all parameters are NOT NULL
+        and so they are in CAP (all view parameters become primary keys which are not null).
+      */
+      if(options.isV2())
+        assignAnnotation(elt, '@sap.parameter', 'mandatory');
+      else
+        assignAnnotation(elt, '@Common.FieldControl', { '#': 'Mandatory' });
       parameterCsn.elements[n] = elt;
     });
     linkAssociationTarget(parameterCsn);
@@ -581,16 +612,16 @@ function initializeModel(csn, _options, messageFunctions)
 
     // Iterate all struct elements
     forEachMemberRecursively(def.items || def, (element, elementName, prop, path = [], construct) => {
-      if(!['elements'].includes(prop))
+      if(prop !== 'elements')
         return;
 
       initElement(element, elementName, construct);
 
-      if(!['event', 'aspect'].includes(def.kind)) {
+      if(def.kind !== 'event' && def.kind !== 'aspect') {
         if(element._parent && element._parent.$mySchemaName) {
           if(!isODataSimpleIdentifier(elementName)) {
             signalIllegalIdentifier(elementName, ['definitions', def.name].concat(path));
-          } else if (options.isV2() && /^(_|[0-9])/.test(elementName) && ['view', 'entity'].includes(element._parent.kind)) {
+          } else if (options.isV2() && /^(_|[0-9])/.test(elementName) && element._parent.kind === 'entity') {
             // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
             error(null, ['definitions', def.name, 'elements', elementName], { prop: elementName[0] },
             'Element names must not start with $(PROP) for OData V2');
@@ -845,7 +876,7 @@ function initializeModel(csn, _options, messageFunctions)
       proxies.
   */
   function exposeTargetsAsProxiesOrSchemaRefs(struct) {
-    if([ 'context', 'service' ].includes(struct.kind) || struct.$proxy)
+    if(struct.kind === 'context' || struct.kind === 'service' || struct.$proxy)
       return;
 
     // globalSchemaPrefix is the prefix for all proxy registrations and must not change
@@ -880,6 +911,7 @@ function initializeModel(csn, _options, messageFunctions)
         // If the target is in another schema, check if both the source and the target share the same service name.
         // If they share the same service name, then it is just a cross schema navigation within the same EDM, no
         // proxy required.
+        // association must be managed and not unmanaged
 
         // odataProxies (P) and odataXServiceRefs (X) are evalutated as follows:
         // P | X | Action
@@ -890,7 +922,10 @@ function initializeModel(csn, _options, messageFunctions)
 
         const targetSchemaName = element._target.$mySchemaName;
         if(isProxyRequired(element)) {
-          if(options.isV4() && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs)) {
+          if(options.isV4() &&
+            (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs)
+             // must be a managed association with keys and no ON condition
+             /* && element.keys && !element.on */) {
             // reuse proxy if available
             let proxy = getProxyForTargetOf(element);
             if(!proxy) {
@@ -909,6 +944,7 @@ function initializeModel(csn, _options, messageFunctions)
               element._constraints.constraints = Object.create(null);
               if(proxy.kind === 'entity') {
                 element._target = proxy;
+                populateProxyElements(element, proxy, getForeignKeyDefinitions(element, ['definitions', struct.name, 'elements', element.name]));
               }
               else {
                 // fake the target to be proxy
@@ -933,7 +969,7 @@ function initializeModel(csn, _options, messageFunctions)
 
     function noNavPropMsg(elt) {
       warning(null, ['definitions', struct.name, 'elements', elt.name],
-            { target: elt._target.name }, 'No OData navigation property generated, target $(TARGET) is outside any service');
+            { target: elt._target.name, service: globalSchemaPrefix }, 'No OData navigation property generated, target $(TARGET) is outside of service $(SERVICE)');
     }
 
     function createSchemaRefFor(assoc, targetSchemaName) {
@@ -954,10 +990,10 @@ function initializeModel(csn, _options, messageFunctions)
         // 1) construct the proxy definition
         // proxyShortName: strip the serviceName and replace '.' with '_'
       const proxyShortName = assoc._target.name.replace(proxySchemaName + '.', '').replace(/\./g, '_');
-        // fullName: Prepend serviceName and if in same service add '_proxy'
-      const fullName = proxySchemaName + '.' + proxyShortName;
-      const proxy = { name: fullName, kind: 'entity', $proxy: true, elements: Object.create(null) };
+      // fullName: Prepend serviceName and if in same service add '_proxy'
+      const proxy = { name: proxySchemaName + '.' + proxyShortName, kind: 'entity', $proxy: true, elements: Object.create(null) };
       setProp(proxy, '$mySchemaName', proxySchemaName);
+      setProp(proxy, '$proxyShortName', proxyShortName);
       setProp(proxy, '$keys', Object.create(null));
       setProp(proxy, '$hasEntitySet', false);
       setProp(proxy, '$exposedTypes', Object.create(null));
@@ -968,59 +1004,67 @@ function initializeModel(csn, _options, messageFunctions)
       });
 
       // 2) create the elements and $keys
-      populateProxyElements(proxy, assoc._target.$keys);
-      // 3) sort the exposed types so that they appear lexicographically ordered in the EDM
-      proxy.$exposedTypes = Object.keys(proxy.$exposedTypes).sort().reduce((dict, tn) => {
-        dict[tn] = proxy.$exposedTypes[tn];
-        return dict
-      }, Object.create(null));
-
+      populateProxyElements(assoc, proxy, assoc._target.$keys);
       return proxy;
 
+    }
+
+    // return array of foreign key defs in the target
+    function getForeignKeyDefinitions(e, path=undefined) {
+        // populate foreign keys, if a key can't be resolved -> parametertype redirects, ignore them
+      return e.keys ? e.keys.map((_fk, i) => {
+        return inspectRef([...(path || e.$path), 'keys', i]).art;
+      }).filter(fk=>fk) : [];
+    }
       // copy over the primary keys of the target and trigger the type exposure
-      function populateProxyElements(proxy, keys) {
-        forAll(keys, e => {
-          if (isEdmPropertyRendered(e, options)) {
-            let newElt = undefined;
-            if(isAssocOrComposition(e.type)) {
-              if(!e.on && e.keys) {
-                if(options.toOdata.odataNoTransitiveProxies)
-                  newElt = convertManagedAssocIntoStruct(e);
-                else
+    function populateProxyElements(assoc, proxy, elements) {
+      forAll(elements, e => {
+        if (isEdmPropertyRendered(e, options) && !proxy.elements[e.name]) {
+          let newElt = undefined;
+          if(isAssocOrComposition(e.type)) {
+            if(!e.on && e.keys) {
+              if(options.toOdata.odataNoTransitiveProxies)
+                newElt = convertManagedAssocIntoStruct(e);
+              else
                   newElt = createProxyOrSchemaRefForManagedAssoc(e);
-              }
-              else {
-                info(null, ['definitions', struct.name, 'elements', assoc.name],
-                { name: fullName, target: assoc._target.name },
-                'Unmanaged associations are not supported as primary keys for proxy entity type $(NAME) of unexposed association target $(TARGET)');
-              }
             }
             else {
-              newElt = cloneCsn(e, options);
+              info(null, ['definitions', struct.name, 'elements', assoc.name],
+                { name: proxy.nname, target: assoc._target.name },
+                'Unmanaged associations are not supported as primary keys for proxy entity type $(NAME) of unexposed association target $(TARGET)');
             }
-            if(newElt) {
-              initElement(newElt, e.name, proxy);
-              if(isStructured(newElt)) {
+          }
+          else {
+            newElt = cloneCsn(e, options);
+          }
+          if(newElt) {
+            initElement(newElt, e.name, proxy);
+            if(isStructured(newElt)) {
                 // argument proxySchemaName forces an anonymous type definition for newElt into the
                 // proxy schema. If omitted, this exposure defaults to 'root', in case API flavor of the day
                 // changes...
-                exposeStructTypeForProxyOf(proxy, newElt, proxyShortName + '_' + newElt.name, proxySchemaName);
+              exposeStructTypeForProxyOf(proxy, newElt, proxy.$proxyShortName + '_' + newElt.name, proxy.$mySchemaName);
               // elements of newElt are required for key ref paths
-              }
-              // all elements must become primary key
-              proxy.$keys[e.name] = proxy.elements[newElt.name] = newElt;
             }
+            proxy.elements[newElt.name] = newElt;
+            if(newElt.key)
+              proxy.$keys[newElt.name] = newElt;
           }
-        });
-      }
+        }
+      });
+      // 3) sort the exposed types so that they appear lexicographically ordered in the EDM
+      proxy.$exposedTypes = Object.keys(proxy.$exposedTypes).sort().reduce((dict, tn) => {
+        dict[tn] = proxy.$exposedTypes[tn];
+        return dict
+      }, Object.create(null));
 
       // If 'node' exists and has a structured type that is not exposed in 'service', (because the type is
       // anonymous or has a definition outside of 'service'), create an equivalent type in 'service', either
       // using the type's name or (if anonymous) 'artificialName', and make 'node' use that type instead.
       // Complain if there is an error.
-      function exposeStructTypeForProxyOf(proxy, node, artificialName, typeSchemaName='root') {
+      function exposeStructTypeForProxyOf(proxy, node, artificialName, typeSchemaName=autoexposeSchemaName) {
         const isNotInProtNS = node.type ? !isBuiltinType(node.type) : true;
-        // Always expose types referred to by a proxy, never reuse an eventually exisiting type
+        // Always expose types referred to by a proxy, never reuse an eventually existing type
         // as the nested elements must all be not nullable
         if (isNotInProtNS) {
           let typeDef = node.type ? csn.definitions[node.type] : /* anonymous type */ node;
@@ -1052,7 +1096,7 @@ function initializeModel(csn, _options, messageFunctions)
                 if(typeClone) {
                   // Recurse into elements of 'type' (if any)
                   typeClone.elements && Object.entries(typeClone.elements).forEach( ([elemName, elem]) => {
-                    // if this is a foreign key elment, we must check wether or not the association
+                    // if this is a foreign key elment, we must check whether or not the association
                     // has been exposed as proxy. If it has not been exposed, no further structured
                     // types must be exposed as 'Proxy_' types.
 
@@ -1109,7 +1153,8 @@ function initializeModel(csn, _options, messageFunctions)
               Object.keys(elem).forEach(prop => type.elements[elemName][prop] = elem[prop])
               type.elements[elemName].notNull = true;
             }
-            else {
+            else if(elem.keys && !elem.on) {
+                // a primary key can never be an unmanaged association
               type.elements[elemName] = createProxyOrSchemaRefForManagedAssoc(elem);
             }
             setProp(type.elements[elemName], 'name', elem.name);
@@ -1166,6 +1211,7 @@ function initializeModel(csn, _options, messageFunctions)
             }
             else if(options.toOdata.odataProxies) {
               proxy = createProxyFor(e, e._target.$mySchemaName);
+              populateProxyElements(e, proxy, getForeignKeyDefinitions(e));
             }
             proxy = registerProxy(proxy, e);
           }
@@ -1229,8 +1275,11 @@ function initializeModel(csn, _options, messageFunctions)
     function registerProxy(proxy, element) {
       if(proxy === undefined)
         return undefined;
-      const fqProxyName = globalSchemaPrefix + '.' + proxy.name;
-      const fqSchemaName = globalSchemaPrefix + '.' + proxy.$mySchemaName;
+
+      setProp(proxy, '$globalSchemaPrefix', globalSchemaPrefix);
+      setProp(proxy, '$origin', element);
+
+      const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
 
       if(!element._target.$cachedProxy)
         assignProp(element._target, '$cachedProxy', Object.create(null));
@@ -1238,8 +1287,19 @@ function initializeModel(csn, _options, messageFunctions)
         info(null, ['definitions', struct.name, 'elements', element.name],
           { name: fqProxyName }, 'Proxy EDM entity type $(NAME) has already been registered');
       }
-      else
+      else {
+        determineEntitySet(proxy);
+        proxyCache.push(proxy);
         element._target.$cachedProxy[globalSchemaPrefix] = proxy;
+      }
+      return proxy;
+    }
+  }
+
+  function mergeProxiesIntoModel() {
+    proxyCache.forEach(proxy => {
+      const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
+      const fqSchemaName = proxy.$globalSchemaPrefix + '.' + proxy.$mySchemaName;
 
       if(proxy.kind === 'entity') {
         // collect all schemas even for newly exposed types
@@ -1251,7 +1311,7 @@ function initializeModel(csn, _options, messageFunctions)
         // don't forget to prepend the global namespace prefix
         // schemas are ordered in csn2edm.js for each service
         Object.keys(proxy.$exposedTypes).forEach(t =>
-          schemaSet.add(globalSchemaPrefix + '.' + getSchemaPrefix(t)));
+          schemaSet.add(proxy.$globalSchemaPrefix + '.' + getSchemaPrefix(t)));
         schemaSet.forEach(schemaName => {
           if(!schemas[schemaName]) {
             schemas[schemaName] = { kind: 'schema', name: schemaName };
@@ -1259,25 +1319,29 @@ function initializeModel(csn, _options, messageFunctions)
           }
         });
         /** @type {object} */
-        const alreadyRegistered = csn.definitions[fqProxyName]
+        const alreadyRegistered = csn.definitions[fqProxyName];
         if(!alreadyRegistered) {
           csn.definitions[fqProxyName] = proxy;
           setProp(proxy, '$path', ['definitions', fqProxyName]);
           Object.entries(proxy.$exposedTypes).forEach(([tn, v]) => {
-            const fqtn = globalSchemaPrefix + '.' + tn;
+            const fqtn = proxy.$globalSchemaPrefix + '.' + tn;
             if(csn.definitions[fqtn] === undefined) {
               csn.definitions[fqtn] = v;
               setProp(v, '$path', ['definitions', fqtn]);
             }
           });
-          info(null, ['definitions', element._parent.name, 'elements', element.name],
+          // default location is not always correct in case proxy has been created by a nested assoc
+          // as foreign key targeting another proxy association
+          let loc = ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name];
+          if(proxy.$origin._parent.$path)
+            loc = [...proxy.$origin._parent.$path, 'elements', proxy.$origin.name]
+          info(null, loc,
             { name: proxy.name }, 'Created proxy EDM entity type $(NAME)');
         }
         else if(alreadyRegistered && !alreadyRegistered.$proxy &&
-          !['entity', 'view'].includes(alreadyRegistered.kind)) {
-          warning('odata-definition-exists', ['definitions', element._parent.name, 'elements', element.name],
+          alreadyRegistered.kind !== 'entity') {
+          warning('odata-definition-exists', ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name],
             { '#': 'proxy', name: fqProxyName, kind: alreadyRegistered.kind });
-          return undefined;
         }
       }
       else {
@@ -1285,15 +1349,14 @@ function initializeModel(csn, _options, messageFunctions)
         if(!schemas[fqSchemaName]) {
           schemas[fqSchemaName] = proxy;
           schemaNames.push(fqSchemaName);
-          info(null, ['definitions', struct.name, 'elements', element.name],
+          info(null, ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name],
             { name: proxy.name }, 'Created EDM namespace reference $(NAME)');
         }
         // don't error on duplicate schemas, if it's already present then all is good....
       }
+    });
       // sort the global schemaNames array
-      schemaNames.sort((a,b) => b.length-a.length);
-      return proxy;
-    }
+    schemaNames.sort((a,b) => b.length-a.length);
   }
 
   /*
@@ -1737,12 +1800,13 @@ function initializeModel(csn, _options, messageFunctions)
     //   serviceRef.push('');
     if(serviceRef[serviceRef.length-1] !== '$metadata')
       serviceRef.push('$metadata');
-    return { kind: 'reference',
+    let sc = { kind: 'reference',
       name: targetSchemaName,
       ref: { Uri: serviceRef.join('/') },
-      inc: { Namespace: targetSchemaName },
-      $mySchemaName: targetSchemaName,
+      inc: { Namespace: targetSchemaName }
     };
+    setProp(sc, '$mySchemaName', targetSchemaName);
+    return sc;
 
     /**
      * Resolve a service endpoint path to mount it to as follows...
@@ -2158,7 +2222,7 @@ function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
   }
 
   function checkSemantics(struct, propName, propValue) {
-    if(['timeseries', 'aggregate'].includes(propValue)) {
+    if(propValue === 'timeseries' || propValue === 'aggregate') {
       // aggregate is forwarded to Set and must remain on Type
       addToSetAttr(struct, propName, propValue, propValue !== 'aggregate');
     }