@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/transform/odata/referenceFlattener.js

@@ -1,4 +1,4 @@
-const { forEachRef } = require('../../model/csnUtils');
+const { applyTransformations } = require('../../model/csnUtils');
 const { setProp } = require('../../base/model');
 const { implicitAs } = require('../../model/csnRefs');
 const { structuralPath } = require('./structuralPath');
@@ -52,32 +52,34 @@ class ReferenceFlattener {
    * @param {*} isStructured Callback function checking of an artifact is a structured element.
    */
   resolveAllReferences(csn, inspectRef, isStructured) {
-    forEachRef(csn, (_ref, node, path) => {
-      if (!path) return;
-      let resolved;
-      try {
-        resolved = inspectRef(path);
-      } catch (ex) {
-        return;  // TODO: fix tests: throw Error("Could not inspectRef: " + path.join("/"));
-      }
-      if (!resolved)
-        return; // TODO: fix tests: throw Error("Could not resolve: " + path.join("/"));
-      if (!resolved.links)
-        return; // TODO: fix tests:  throw Error("Could not resolve links: " + path.join("/"));
-      let paths = [];
-      resolved.links.forEach((element) => {
-        if (!element.art)
-          paths = undefined; // not resolved -> no paths
-        if (paths) {
-          paths.push(element.art.$path);
+    applyTransformations(csn, {
+      ref: (node, prop, _ref, path) => {
+        if (!path) return;
+        let resolved;
+        try {
+          resolved = inspectRef(path);
+        } catch (ex) {
+          return;  // TODO: fix tests: throw Error("Could not inspectRef: " + path.join("/"));
         }
-      });
-      if (paths)
-        setProp(node, '$paths', paths);
-      // cache if structured or not
-      let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
-      this.structuredReference[path.join('/')] = structured;
-    });
+        if (!resolved)
+          return; // TODO: fix tests: throw Error("Could not resolve: " + path.join("/"));
+        if (!resolved.links)
+          return; // TODO: fix tests:  throw Error("Could not resolve links: " + path.join("/"));
+        let paths = [];
+        resolved.links.forEach((element) => {
+          if (!element.art)
+            paths = undefined; // not resolved -> no paths
+          if (paths) {
+            paths.push(element.art.$path);
+          }
+        });
+        if (paths)
+          setProp(node, '$paths', paths);
+        // cache if structured or not
+        let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
+        this.structuredReference[path.join('/')] = structured;
+      }
+    })
   }
 
   /**
@@ -172,80 +174,84 @@ class ReferenceFlattener {
    * @param {*} csn
    */
   flattenAllReferences(csn) {
-    forEachRef(csn, (ref, node, path) => {
-      if (node.$paths) {
-        let newRef = []; // flattened reference
-        let flattenWithPrevious = false;
-        let lastFlattenedID = null; // The variable will be set to the index of the last flattened path
-        node.$paths.forEach((path, i) => {
-          if (path === undefined || !ref[i]) return;
-          let spath = path.join('/');
-          let movedTo = this.elementTransitions[spath]; // detect element transition
-          let flattened = this.flattenedElementPaths[spath];
-          if (flattenWithPrevious) {
-            newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + (ref[i].id || ref[i]);
-            // if we have a filter or args in an assoc, it needs to be kept, therefore
-            // the id of the ref is updated with the flattened version
-            if (ref[i].id) {
-              ref[i].id = newRef[newRef.length - 1];
-              newRef[newRef.length - 1] = ref[i];
+    applyTransformations(csn, {
+      ref: (node, prop, ref, path) => {
+        if (node.$paths) {
+          let newRef = []; // flattened reference
+          let flattenWithPrevious = false;
+          let lastFlattenedID = null; // The variable will be set to the index of the last flattened path
+          node.$paths.forEach((path, i) => {
+            if (path === undefined || !ref[i]) return;
+            let spath = path.join('/');
+            let movedTo = this.elementTransitions[spath]; // detect element transition
+            let flattened = this.flattenedElementPaths[spath];
+            if (flattenWithPrevious) {
+              newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + (ref[i].id || ref[i]);
+              // if we have a filter or args in an assoc, it needs to be kept, therefore
+              // the id of the ref is updated with the flattened version
+              if (ref[i].id) {
+                ref[i].id = newRef[newRef.length - 1];
+                newRef[newRef.length - 1] = ref[i];
+              }
+              lastFlattenedID = i;
+            } else if(movedTo && i===0) { // handle local scope reference which is transitioned - replace first item in reference
+              let movedToElementName = movedTo[movedTo.length-1];
+              newRef.push(movedToElementName);
+              lastFlattenedID = i;
+            } else {
+              newRef.push(ref[i]);
             }
-            lastFlattenedID = i;
-          } else if(movedTo && i===0) { // handle local scope reference which is transitioned - replace first item in reference
-            let movedToElementName = movedTo[movedTo.length-1];
-            newRef.push(movedToElementName);
-            lastFlattenedID = i;
-          } else {
-            newRef.push(ref[i]);
-          }
-          flattenWithPrevious = flattened;
-        });
-        if (newRef !== undefined && lastFlattenedID !== null) { // make sure the reference changed and only then replace it with the new one
-          // check if this is a column and add alias if missing
-          let structural = structuralPath(csn, path);
-          if (isColumnInSelectOrProjection(structural)) {
-            if (!node.as && lastFlattenedID === ref.length-1) // attach alias only if there is none and it is the last item in the reference that was flattened
-              node.as = node.ref[node.ref.length - 1];
-          }
-          setProp(newRef, '$path', path.concat('ref'));
-          if (!node.as) {
-            if (isPartOfKeysStructure(structural))
-              node.as = implicitAs(node.ref);
-            else
-              setProp(node, 'as', implicitAs(node.ref))
+            flattenWithPrevious = flattened;
+          });
+          if (newRef !== undefined && lastFlattenedID !== null) { // make sure the reference changed and only then replace it with the new one
+            // check if this is a column and add alias if missing
+            let structural = structuralPath(csn, path);
+            if (isColumnInSelectOrProjection(structural)) {
+              if (!node.as && lastFlattenedID === ref.length-1) // attach alias only if there is none and it is the last item in the reference that was flattened
+                node.as = node.ref[node.ref.length - 1];
+            }
+            setProp(newRef, '$path', path.concat('ref'));
+            if (!node.as) {
+              if (isPartOfKeysStructure(structural))
+                node.as = implicitAs(node.ref);
+              else
+                setProp(node, 'as', implicitAs(node.ref))
+            }
+            node.ref = newRef;
           }
-          node.ref = newRef;
         }
       }
     })
   }
 
   applyAliasesInOnCond(csn, inspectRef) {
-    forEachRef(csn, (ref, node, path) => {
-      // Process only on-conditions of associations
-      let structural = structuralPath(csn, path);
-      if(!isOnCondition(structural)) return;
-      let { links } = inspectRef(path);
-      if(!links) return; // $user not resolvable
-      let keysOfPreviousStepWhenManagedAssoc = undefined;
-
-      let aliasedRef = [...ref];
-
-      for (let idx = 0; idx < ref.length; idx++) {
-        const currArt = links[idx].art;
-        if (keysOfPreviousStepWhenManagedAssoc) {
-          const usedKey = keysOfPreviousStepWhenManagedAssoc.find(key => key.ref[0] === ref[idx]);
-          if (usedKey && usedKey.as) {
-            aliasedRef.splice(idx, usedKey.ref.length, usedKey.as);
-            idx += usedKey.ref.length - 1;
-            keysOfPreviousStepWhenManagedAssoc = undefined;
+    applyTransformations(csn, {
+      ref: (node, prop, ref, path) => {
+        // Process only on-conditions of associations
+        let structural = structuralPath(csn, path);
+        if(!isOnCondition(structural)) return;
+        let { links } = inspectRef(path);
+        if(!links) return; // $user not resolvable
+        let keysOfPreviousStepWhenManagedAssoc = undefined;
+  
+        let aliasedRef = [...ref];
+  
+        for (let idx = 0; idx < ref.length; idx++) {
+          const currArt = links[idx].art;
+          if (keysOfPreviousStepWhenManagedAssoc) {
+            const usedKey = keysOfPreviousStepWhenManagedAssoc.find(key => key.ref[0] === ref[idx]);
+            if (usedKey && usedKey.as) {
+              aliasedRef.splice(idx, usedKey.ref.length, usedKey.as);
+              idx += usedKey.ref.length - 1;
+              keysOfPreviousStepWhenManagedAssoc = undefined;
+            }
+          } else {
+            keysOfPreviousStepWhenManagedAssoc =
+              (currArt.type === 'cds.Association' || currArt.type === 'cds.Composition') && currArt.keys;
           }
-        } else {
-          keysOfPreviousStepWhenManagedAssoc =
-            (currArt.type === 'cds.Association' || currArt.type === 'cds.Composition') && currArt.keys;
         }
+        node.ref = aliasedRef;
       }
-      node.ref = aliasedRef;
     })
   }
 }

package/lib/transform/odata/structureFlattener.js

@@ -71,7 +71,7 @@ function flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExterna
  * @param {Function} error
  */
 function flattenDefinition(definition, definitionPath, csnUtils, options, referenceFlattener, error) {
-  if (definition.kind !== 'entity' && definition.kind !== 'view')
+  if (definition.kind !== 'entity')
     return;
 
   let { newFlatElements } = flattenStructure(definition.elements, definitionPath, csnUtils, options, error, referenceFlattener);

package/lib/transform/odata/toFinalBaseType.js

@@ -2,7 +2,7 @@
 
 const {
   forEachDefinition, forEachMemberRecursively,
-  isBuiltinType, cloneCsnDictionary,
+  isBuiltinType, cloneCsnDictionary, cloneCsn,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
@@ -86,21 +86,95 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     // EDMX at the moment and the reference in the OData CSN is fulfilled.
     if (node.kind === 'event') return;
 
-    if (isExpandable(node, defName) || node.kind === 'type') {
-      transformers.toFinalBaseType(node);
-      if (node.type && !isBuiltinType(node.type)) {
-        // handle array of defined via a named type
-        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
-        const currService = csnUtils.getServiceName(defName);
-        const finalType = csnUtils.getFinalTypeDef(node.type);
-        if (finalType.items && isBuiltinType(finalType.items.type)) {
-          if (!isArtifactInService(node.type, currService) || !isV4) {
-            node.items = finalType.items;
+    // elements have precedence over type
+    if (node.type && (!isBuiltinType(node.type) &&isExpandable(node, defName) || node.kind === 'type')) {
+      // 1. Get the final type of the node (resolve derived type chain)
+      const finalType = csnUtils.getFinalBaseType(node.type);
+      if (finalType) {
+        // The type replacement depends on whether 'node' is a definition or a member[element].
+        if (node.kind) {
+          // It is a definition and we expand to builtin type and to elements
+          // type T: S; --> Integer;
+          // type S: X; --> Integer;
+          // type X: Integer;
+          // 
+          // type A: B; -> {...}
+          // type B: C; -> { ... }
+          // type C { .... };
+          if (isBuiltinType(finalType)) {
+            // use transformUrilsNew::toFinalBaseType for the moment,
+            // as it is collects along the chain of types
+            // attributes that need to be propagated
+            // enum, length, scale, etc.
+            transformers.toFinalBaseType(node);
+            // node.type = finalType;
+          }
+          else if (csnUtils.isStructured(finalType)) {
+            cloneElements(finalType);
+          }
+          else if (node.type && node.items)
             delete node.type;
+        }
+        else {
+          // this is a member and we expand to final base only if builtin
+          //  type T: S; --> Integer;
+          //  type S: X; --> Integer;
+          //  type X: Integer;
+          //  
+          //  type {
+          //    struct_elt: many A; ---> stays the same
+          //    scalar_elt: T; ---> Integer;
+          //    type_ref_elt: type of struct_elt;
+          //  };
+          //  type A: B; -> {...}
+          //  type B: C; -> { ... }
+          //  type C { .... };
+          if (isBuiltinType(finalType)) {
+            // use transformUrilsNew::toFinalBaseType for the moment,
+            // as it is collects along the chain of types
+            // attributes that need to be propagated
+            // enum, length, scale, etc.
+            transformers.toFinalBaseType(node);
+            // node.type = finalType;
+          }
+          else if (node.type && node.type.ref) {
+            cloneElements(finalType);
           }
         }
       }
     }
+    if (node.type && !isBuiltinType(node.type)) {
+        // handle array of defined via a named type
+        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
+      const currService = csnUtils.getServiceName(defName);
+      const finalType = csnUtils.getFinalTypeDef(node.type);
+      if (finalType.items && isBuiltinType(finalType.items.type)) {
+        if (!isArtifactInService(node.type, currService) || !isV4) {
+          node.items = finalType.items;
+          delete node.type;
+        }
+      }
+    }
+
+    function cloneElements(finalType) {
+      // cloneCsn only works correctly if we start "from the top"
+      let clone;
+      // do the clone only if really needed
+      if((finalType.items && !node.items) ||
+         (finalType.elements && !node.elements))
+        clone = cloneCsn({ definitions: { 'TypeDef': finalType } }, options);
+      if (finalType.items) {
+        delete node.type;
+        if(!node.items)
+          Object.assign(node, { items: clone.definitions.TypeDef.items });
+      }
+      if (finalType.elements) {
+        if(!finalType.items)
+          delete node.type;
+        if(!node.elements)
+          Object.assign(node, { elements: clone.definitions.TypeDef.elements });
+      }
+    }
   }
 
   function isExpandable(node, defName) {
@@ -119,4 +193,4 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   }
 }
 
-module.exports = expandToFinalBaseType;
+module.exports = expandToFinalBaseType;

package/lib/transform/odata/typesExposure.js

@@ -18,7 +18,7 @@ const { copyAnnotations } = require('../../model/csnUtils');
  * @param {*} csnUtils
  * @param {object} message message object with { error } function
  */
-function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
+function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, csnUtils, message) {
   const { error } = message;
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.toOdata.version === 'v4' && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs);
@@ -30,9 +30,9 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     // we do expose types only for definition from inside services
     const serviceName = whatsMyServiceName(defName, false);
     if (serviceName) {
-      if (['type', 'entity', 'view'].includes(def.kind)) {
+      if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (['elements', 'params'].includes(propertyName)) {
+          if (propertyName === 'elements' || propertyName === 'params') {
             const artificialtName = `${isMultiSchema ?
               defNameWithoutServiceOrContextName(defName, serviceName)
               : defNameWithoutServiceOrContextName(defName, serviceName).replace(/\./g, '_')}_${elementName}`;
@@ -190,7 +190,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
       } else {
         const typeContext = csnUtils.getContextOfArtifact(typeName);
         const typeNamespace = csnUtils.getNamespaceOfArtifact(typeName);
-        const newSchemaName = `${service}.${typeContext || typeNamespace || 'root'}`;
+        const newSchemaName = `${service}.${typeContext || typeNamespace || autoexposeSchemaName}`;
         // new type name without any prefixes
         const typePlainName = typeContext ? defNameWithoutServiceOrContextName(typeName, typeContext)
           : typeName.replace(`${typeNamespace}.`, '');
@@ -209,7 +209,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
      */
     function getAnonymousTypeNameInMultiSchema(typeName, parentName) {
       let currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
-      const newSchemaName = currPrefix || 'root';
+      const newSchemaName = currPrefix || autoexposeSchemaName;
       // new type name without any prefixes
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
 

package/lib/transform/odata/utils.js

@@ -18,7 +18,7 @@ function isAssociationOrComposition(artifact) {
   return isAssociation(artifact) || isComposition(artifact);
 }
 
-function isManagedAssociationElement(artifact) {
+function isManagedAssociation(artifact) {
   return artifact.target !== undefined && artifact.on === undefined;
 }
 
@@ -94,5 +94,5 @@ module.exports = {
   isArtifactInSomeService,
   isAssociationOrComposition,
   isLocalizedArtifactInService,
-  isManagedAssociationElement,
+  isManagedAssociation,
 }