@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/transform/db/expansion.js

@@ -446,11 +446,15 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       if (col.ref && col.$scope !== '$magic') {
         const _art = col._art || inspectRef(path.concat(i)).art;
         if (_art && isStructured(_art))
-          newThing.push(...expandRef(_art, col.ref, [ col.as || col.ref[col.ref.length - 1] ], col.key || false, withAlias));
+          newThing.push(...expandRef(_art, col.ref, col.as, col.key || false, withAlias));
 
         else
           newThing.push(col);
       }
+      else if (col.ref && col.$scope === '$magic' && ( col.ref[0] === '$user' || col.ref[0] === '$session' ) && !col.as) {
+        col.as = implicitAs(col.ref);
+        newThing.push(col);
+      }
       else {
         newThing.push(col);
       }
@@ -473,7 +477,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    */
   function expandRef(art, ref, alias, isKey, withAlias) {
     const expanded = [];
-    const stack = [ [ art, ref, alias ] ];
+    const stack = [ [ art, ref, [ alias || ref[ref.length - 1] ] ] ];
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
       if (isStructured(current)) {
@@ -482,8 +486,14 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       }
       else {
         const obj = { ref: currentRef };
-        if (withAlias)
-          obj.as = currentAlias.join(pathDelimiter);
+        if (withAlias) {
+          const newAlias = currentAlias.join(pathDelimiter);
+          // if (alias !== undefined) // explicit alias
+          obj.as = newAlias;
+          // alias was implicit - to later distinguish expanded s -> s.a from explicitly written s.a
+          if (alias === undefined)
+            setProp(obj, '$implicitAlias', true);
+        }
         if (isKey)
           obj.key = true;
         expanded.push(obj);
@@ -542,9 +552,11 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       for (const part of Object.keys(base)) {
         if (excluding.indexOf(part) === -1) {
           // The thing is shadowed - ignore names present because of .inline, as those "disappear"
-          if (names[part] && !subs[names[part]].inline) {
-            replaced[part] = true;
-            star.push(subs[names[part]]);
+          if (names[part] !== undefined && !subs[names[part]].inline) { // Only works for a single * - but a second is forbidden anyway
+            if (names[part] > stars[0]) { // explicit definitions BEFORE the star should stay "infront" of the star
+              replaced[part] = true;
+              star.push(subs[names[part]]);
+            }
           }
           else { // the thing is not shadowed - use the name from the base
             star.push({ ref: [ part ] });

package/lib/transform/db/flattening.js

@@ -69,12 +69,32 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter) {
     }
   }
   const { toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  // (030) - For all elements, replace derived types by final base type
   applyTransformations(csn, {
+    cast: (parent) => {
+      // Resolve cast already - we otherwise lose .localized
+      if (parent.cast.type && !isBuiltinType(parent.cast.type))
+        toFinalBaseType(parent.cast, resolved, true);
+    },
     type: (parent, prop, type) => {
       if (!isBuiltinType(type)) {
         const directLocalized = parent.localized || false;
         toFinalBaseType(parent, resolved);
+        // structured types might not have the child-types replaced.
+        // Drill down to ensure this.
+        if (parent.elements) {
+          const stack = [ parent.elements ];
+          while (stack.length > 0) {
+            const elements = stack.pop();
+            for (const e of Object.values(elements)) {
+              if (e.type && !isBuiltinType(e.type))
+                toFinalBaseType(e, resolved);
+
+              if (e.elements)
+                stack.push(e.elements);
+            }
+          }
+        }
+
         if (!directLocalized)
           removeLocalized(parent);
       }
@@ -99,7 +119,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter) {
 
       definitions[artifactName] = dummy;
     }
-  } ]);
+  } ], true, { skipDict: { actions: true } });
 }
 
 /**
@@ -143,13 +163,17 @@ function flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter) {
 
         parent.ref = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes );
         resolved.set(parent, { links, art, scope });
-        // Because of expansion we added alias to everything - strip off superflous alias
-        if (parent.as && parent.as === parent.ref[parent.ref.length - 1] && scope !== '$magic')
-          delete parent.as;
         // Explicitly set implicit alias for things that are now flattened - but only in columns
         // TODO: Can this be done elegantly during expand phase already?
-        else if (parent.ref[ref.length - 1] !== lastRef && (insideColumns(scopedPath) || insideKeys(scopedPath)) && !parent.as)
+        if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
+          if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+            delete parent.as;
+          delete parent.$implicitAlias;
+        }
+        // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
+        else if (parent.ref[parent.ref.length - 1] !== lastRef && (insideColumns(scopedPath) || insideKeys(scopedPath)) && !parent.as) {
           parent.as = lastRef;
+        }
       };
       // adapt queries later
       adaptRefs.push(fn);
@@ -263,7 +287,7 @@ function flattenElements(csn, options, pathDelimiter, error) {
         previous[name] = element;
         return previous;
       }, Object.create(null));
-    });
+    }, true);
   }
 
   /**