@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/transform/odata/foreignKeyRefsInXprAnnos.js

@@ -1,4 +1,4 @@
-'use strict'
+'use strict';
 
 const { applyTransformations, transformAnnotationExpression } = require('../../model/csnUtils');
 const { isBuiltinType } = require('../../base/builtins');
@@ -8,61 +8,62 @@ function replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunct
   const transformers = {
     elements: processRef,
     params: processRef,
-    actions: processRef
+    actions: processRef,
     // '@': processRef
   };
   applyTransformations(csn, transformers, [ processRef ], iterateOptions);
 
   function processRef(parent, prop, _dict, path) {
-    transformAnnotationExpression(parent, prop,
-      {
-        ref: (parent, _prop, ref, path, _p, _ppn, ctx) => {
-          const { art, links } = 
-            (parent._art && parent._links) ? 
-            { art: parent._art, links: parent._links } :
-            csnUtils.inspectRef(path);
-          // if a reference points to a structure(managed assoc or structured element), then we do not process
-          // as we can't guess which specific foreign key is targeted
-          if (!art || csnUtils.isManagedAssociation(art) || csnUtils.isStructured(art)) return;
+    transformAnnotationExpression(parent, prop, {
+      ref: (parent, _prop, ref, path, _p, _ppn, ctx) => {
+        const { art, links }
+            = (parent._art && parent._links)
+              ? { art: parent._art, links: parent._links }
+              : csnUtils.inspectRef(path);
+        // if a reference points to a structure(managed assoc or structured element), then we do not process
+        // as we can't guess which specific foreign key is targeted
+        if (!art || csnUtils.isManagedAssociation(art) || csnUtils.isStructured(art))
+          return;
 
-          const allMngAssocsInRef = links.filter(link => csnUtils.isManagedAssociation(link.art));
-          if (!allMngAssocsInRef.length) return;
-          let firstAssocToProcess = allMngAssocsInRef[0];
+        const allMngAssocsInRef = links.filter(link => csnUtils.isManagedAssociation(link.art));
+        if (!allMngAssocsInRef.length)
+          return;
+        let firstAssocToProcess = allMngAssocsInRef[0];
 
-          const mngAssocsWithFilter = allMngAssocsInRef.filter(assoc => typeof ref[assoc.idx] !== 'string');
-          if (mngAssocsWithFilter.length) {
-            const refTail = links.slice(mngAssocsWithFilter.at(-1).idx + 1);
-            firstAssocToProcess = refTail.find(link => csnUtils.isManagedAssociation(link.art));
-          }
+        const mngAssocsWithFilter = allMngAssocsInRef.filter(assoc => typeof ref[assoc.idx] !== 'string');
+        if (mngAssocsWithFilter.length) {
+          const refTail = links.slice(mngAssocsWithFilter.at(-1).idx + 1);
+          firstAssocToProcess = refTail.find(link => csnUtils.isManagedAssociation(link.art));
+        }
 
-          const match = findMatchingForeignKeyForAssoc(firstAssocToProcess, art, ref, links);
-          if (match) {
-            const refHead = ref.slice(0, match.idx);
-            parent.ref = [...refHead, match.fkName];
-            if (ctx?.annoExpr?.['=']) {
-              ctx.annoExpr['='] = true;
-            }
-          }
+        const match = findMatchingForeignKeyForAssoc(firstAssocToProcess, art, ref, links);
+        if (match) {
+          const refHead = ref.slice(0, match.idx);
+          parent.ref = [ ...refHead, match.fkName ];
+          if (ctx?.annoExpr?.['='])
+            ctx.annoExpr['='] = true;
         }
       },
-      path);
+    },
+                                  path);
   }
 
   function findMatchingForeignKeyForAssoc(assoc, refArt, ref, links) {
-    if (!assoc) return undefined;
+    if (!assoc)
+      return undefined;
 
     const expectedFkName = findExpectedFkName(assoc, ref, links);
     const gfks = assoc.art?.$generatedForeignKeys;
-    if (!gfks) return undefined;
+    if (!gfks)
+      return undefined;
     const matchedFk = gfks.find(fk => fk.source === refArt && fk.name === expectedFkName);
-    if (matchedFk) {
+    if (matchedFk)
       return { fkName: matchedFk.name, idx: assoc.idx };
-    } else {
-      // try to find FK substitution in the next assoc in the ref (if there is such assoc)
-      const refTail = links.slice(assoc.idx + 1);
-      const nextAssoc = refTail.find(link => csnUtils.isManagedAssociation(link.art));
-      return findMatchingForeignKeyForAssoc(nextAssoc, refArt, ref, links);
-    }
+
+    // try to find FK substitution in the next assoc in the ref (if there is such assoc)
+    const refTail = links.slice(assoc.idx + 1);
+    const nextAssoc = refTail.find(link => csnUtils.isManagedAssociation(link.art));
+    return findMatchingForeignKeyForAssoc(nextAssoc, refArt, ref, links);
 
 
     function findExpectedFkName(assoc, ref, links) {
@@ -77,16 +78,17 @@ function replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunct
         bufferRef.push(ref[i]);
         if (csnUtils.isManagedAssociation(link.art)) {
           const subFkName = findExpectedFkName(link, ref, links);
-          if (!subFkName) return undefined;
-          expectedFkName += bufferRef.length > 1 ? 
-          `_${bufferRef.slice(0, -1).join('_')}_${subFkName}` :
-          `_${subFkName}`;
+          if (!subFkName)
+            return undefined;
+          expectedFkName += bufferRef.length > 1
+            ? `_${ bufferRef.slice(0, -1).join('_') }_${ subFkName }`
+            : `_${ subFkName }`;
           break;
-        } else if (isBuiltinType(link.art.type)) {
-          expectedFkName += `_${refAliasMapping[bufferRef.join('_')] || ref[i]}`;
+        }
+        else if (isBuiltinType(link.art.type)) {
+          expectedFkName += `_${ refAliasMapping[bufferRef.join('_')] || ref[i] }`;
           bufferRef = [];
         }
-  
       }
       return expectedFkName;
     }

package/lib/transform/odata/toFinalBaseType.js

@@ -21,8 +21,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       expandToFinalBaseType(member.items, defName);
       expandToFinalBaseType(member.returns, defName);
       expandToFinalBaseType(member.returns && member.returns.items, defName);
-
-    }, ['definitions', defName]);
+    }, [ 'definitions', defName ]);
 
     expandToFinalBaseType(def, defName);
     expandToFinalBaseType(def.items, defName);
@@ -64,18 +63,16 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
     // type Foo: array of Bar; type Bar: { qux: Integer };
     // In the type Foo we expand the first level of elements of the items or
     // type Foo: array of { qux: Integer };
-    if (def.kind === 'type' && def.items && isArtifactInSomeService(defName, services)) {
+    if (def.kind === 'type' && def.items && isArtifactInSomeService(defName, services))
       expandFirstLevelOfArrayed(def);
-    }
   });
 
-  if(isBetaEnabled(options, 'odataTerms')) {
+  if (isBetaEnabled(options, 'odataTerms')) {
     forEachGeneric(csn, 'vocabularies', (def, defName) => {
       forEachMemberRecursively(def, (member) => {
         expandToFinalBaseType(member, defName);
         expandToFinalBaseType(member.items, defName);
-
-      }, ['vocabularies', defName]);
+      }, [ 'vocabularies', defName ]);
 
       expandToFinalBaseType(def, defName);
       expandToFinalBaseType(def.items, defName);
@@ -96,12 +93,14 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
   }
 
   function expandToFinalBaseType(node, defName) {
-    if (!node) return;
-    if (node.kind === 'event') return;
+    if (!node)
+      return;
+    if (node.kind === 'event')
+      return;
 
-    if(node.type && !isBuiltinType(node.type)) {
+    if (node.type && !isBuiltinType(node.type)) {
       const finalBaseType = csnUtils.getFinalTypeInfo(node.type);
-      if(finalBaseType == null) {
+      if (finalBaseType == null) {
         /*
           type could not be resolved, delete type property to be equal to a typeless element
           definition. Today, all type refs must be resolvable, input validations
@@ -138,8 +137,9 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
               else if (csnUtils.isStructured(finalBaseType)) {
                 cloneElements(node, finalBaseType);
               }
-              else if (node.type && node.items)
+              else if (node.type && node.items) {
                 delete node.type;
+              }
             }
             else {
               /*
@@ -157,6 +157,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
                   type B: C; -> { ... }
                   type C { .... };
               */
+              // eslint-disable-next-line no-lonely-if
               if (isBuiltinType(finalBaseType.type)) {
                 /*
                   use transformUtils::toFinalBaseType for the moment,
@@ -173,12 +174,12 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
             }
           }
         }
-        if (/*the resolved type is not built in*/ !isBuiltinType(node.type)) {
+        if (/* the resolved type is not built in */ !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 isArrayOfBuiltin = finalBaseType.items &&
-            isBuiltinType(csnUtils.getFinalTypeInfo(finalBaseType.items.type)?.type)
+            isBuiltinType(csnUtils.getFinalTypeInfo(finalBaseType.items.type)?.type);
           if (isArrayOfBuiltin && (!isArtifactInService(node.type, currService) || !isV4)) {
             node.items = finalBaseType.items;
             delete node.type;
@@ -190,60 +191,61 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
     function cloneElements(node, finalBaseType) {
       let clone;
       // do the clone only if really needed
-      if((finalBaseType.items && !node.items) ||
+      if ((finalBaseType.items && !node.items) ||
          (finalBaseType.elements && !node.elements)) {
         // clone the definition not another clone
-        let _type = node._type;
-        while(_type._type && !_type.items && !_type.elements)
+        let { _type } = node;
+        while (_type._type && !_type.items && !_type.elements)
           _type = _type._type;
         clone = cloneCsnNonDict(_type, { ...options, hiddenPropertiesToClone: [ '_type' ] });
         fitClonedElementsIntoParent(clone, node, _type.$path);
       }
       if (finalBaseType.items) {
         delete node.type;
-        if(!node.items)
+        if (!node.items)
           Object.assign(node, { items: clone.items });
       }
       if (finalBaseType.elements) {
-        if(!finalBaseType.items)
+        if (!finalBaseType.items)
           delete node.type;
-        if(!node.elements)
+        if (!node.elements)
           Object.assign(node, { elements: clone.elements });
       }
     }
 
     function fitClonedElementsIntoParent(clone, node, typeRefCsnPath) {
       const f = (p) => {
-        const [h, ...t ] = p;
-        return `${h}:${t.join('.')}`;
-      }
+        const [ h, ...t ] = p;
+        return `${ h }:${ t.join('.') }`;
+      };
       const typeRefStr = f(node.type.ref);
       const typeRefRootPath = $path2path(typeRefCsnPath);
       forEachMemberRecursively(clone, (elt, eltName, prop, location) => {
         const usingPositionStr = f($path2path(location));
         const eltRootPath = $path2path(elt.$path);
 
-        Object.keys(elt).filter(pn => pn[0] === '@').forEach(anno => {
+        Object.keys(elt).filter(pn => pn[0] === '@').forEach((anno) => {
           transformAnnotationExpression(elt, anno, {
             ref: (parent, prop, xpr, csnPath, _p, _ppn, ctx) => {
               let prefixMatch = true;
               const head = xpr[0].id || xpr[0];
               if (head === '$self') {
-                for (let i = 1; i < typeRefRootPath.length && prefixMatch; i++){
+                for (let i = 1; i < typeRefRootPath.length && prefixMatch; i++)
                   prefixMatch = (xpr[i].id || xpr[i]) === typeRefRootPath[i];
-                }
-                if(prefixMatch && xpr.length > typeRefRootPath.length) {
-                  if(xpr.length >= eltRootPath.length)
-                    parent[prop] = [ ...xpr.slice(eltRootPath.length-1)];
+
+                if (prefixMatch && xpr.length > typeRefRootPath.length) {
+                  if (xpr.length >= eltRootPath.length)
+                    parent[prop] = [ ...xpr.slice(eltRootPath.length - 1) ];
                   else
-                    parent[prop] = [ '$self', ...xpr.slice(typeRefRootPath.length)];
-                  if(ctx?.annoExpr?.['='])
+                    parent[prop] = [ '$self', ...xpr.slice(typeRefRootPath.length) ];
+                  if (ctx?.annoExpr?.['='])
                     ctx.annoExpr['='] = true;
                 }
                 else {
-                  error('odata-anno-xpr-ref', csnPath,
-                  { anno, elemref: xpr.join('.'), name: usingPositionStr, code: typeRefStr });
-                }              
+                  error('odata-anno-xpr-ref', csnPath, {
+                    anno, elemref: xpr.join('.'), name: usingPositionStr, code: typeRefStr,
+                  });
+                }
               }
             },
           }, elt.$path);
@@ -260,8 +262,8 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       - the referred type is defined in the service
     */
     function isExpandable(finalBaseType) {
-        // in V4 we should use TypeDefinitions whenever possible, thus in case the final type of a field is
-        // a builtin from the service - do not expand to the final base type
+      // in V4 we should use TypeDefinitions whenever possible, thus in case the final type of a field is
+      // a builtin from the service - do not expand to the final base type
 
       const currService = csnUtils.getServiceName(defName);
       const isBuiltin = isBuiltinType(finalBaseType.type);
@@ -270,7 +272,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       return !isV4 || !(isBuiltin && !isAssoc && isInCurServ);
     }
 
-// convert $path to path starting at main artifact
+    // convert $path to path starting at main artifact
     function $path2path( p ) {
       const path = [];
       let env = csn;
@@ -279,7 +281,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
         env = env[ps];
         if (env && env.constructor === Object) {
           path.push(ps);
-      // jump over many items but not if this is an element
+          // jump over many items but not if this is an element
           if (env.items) {
             env = env.items;
             if (p[i + 1] === 'items')
@@ -291,7 +293,6 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, e
       }
       return path;
     }
-
   }
 }