@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/transform/odata/typesExposure.js

@@ -8,8 +8,10 @@
 
 const { setProp, isBetaEnabled } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { getNamespace, copyAnnotations,
-  forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered } = require('../../model/csnUtils');
+const {
+  getNamespace, copyAnnotations,
+  forEachDefinition, forEachMember, forEachGeneric, isEdmPropertyRendered,
+} = require('../../model/csnUtils');
 const { isBuiltinType } = require('../../base/builtins');
 const { CompilerAssertion } = require('../../base/error');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
@@ -81,23 +83,24 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           if (propertyName === 'elements') {
             const newTypeName = getNewTypeName(element, elementName, defName, serviceName);
             exposeTypeOf(element, element.key, elementName, defName, serviceName, newTypeName, defName, path);
-          } else if (propertyName === 'params') {
-            const newTypeName = getNewTypeName(element, elementName, `ep_${defName.replace(/\./g, '_')}`, serviceName);
+          }
+          else if (propertyName === 'params') {
+            const newTypeName = getNewTypeName(element, elementName, `ep_${ defName.replace(/\./g, '_') }`, serviceName);
             exposeTypeOf(element, true, elementName, defName, serviceName, newTypeName, defName, path);
           }
         }, path);
       }
 
-      if (def.kind === 'action' || def.kind === 'function') {
+      if (def.kind === 'action' || def.kind === 'function')
         exposeTypesOfAction(def, defName, defName, serviceName, path, false);
-      }
-      def.actions && Object.entries(def.actions).forEach(([actionName, action]) => {
-        exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]), true);
+
+      Object.entries(def.actions || {}).forEach(([ actionName, action ]) => {
+        exposeTypesOfAction(action, `${ defName }_${ actionName }`, defName, serviceName, path.concat([ 'actions', actionName ]), true);
       });
     }
   });
 
-  if(isBetaEnabled(options, 'odataTerms')) {
+  if (isBetaEnabled(options, 'odataTerms')) {
     forEachGeneric(csn, 'vocabularies', (def, defName, _propertyName, path) => {
       const serviceName = whatsMyServiceName(defName, false);
       if (serviceName && requestedServiceNames.includes(serviceName)) {
@@ -108,9 +111,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           // link def into definitions for later use
           def.kind = 'annotation';
           csn.definitions[defName] = def;
-          const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;
+          const artificialName = `term_${ defName.replace(/\./g, '_') }`;// _${paramName}`;
           const newTypeName = getNewTypeName(undefined, undefined, artificialName, serviceName);
-          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, defName, path.concat(['vocabularies', defName]), undefined, true);
+          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, defName, path.concat([ 'vocabularies', defName ]), undefined, true);
         }
       }
     });
@@ -118,7 +121,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
 
   return schemas;
 
-/**
+  /**
    * If an 'action' uses structured types as parameters or return values that are not exposed in 'service'
    * (because the types are anonymous or have a definition outside of 'service'),
    * create equivalent types in 'service' and make 'action' use them instead,
@@ -128,15 +131,15 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    */
   function exposeTypesOfAction(action, actionName, defName, serviceName, path, isBound) {
     if (action.returns) {
-      const artificialName = `return_${actionName.replace(/\./g, '_')}`;
+      const artificialName = `return_${ actionName.replace(/\./g, '_') }`;
       const newTypeName = getNewTypeName(action.returns, undefined, artificialName, serviceName);
-      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['returns']));
+      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, defName, path.concat([ 'returns' ]));
     }
 
-    action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-      const artificialName = `${isBound ? 'bap' : 'ap'}_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
+    Object.entries(action.params || {}).forEach(([ paramName, param ]) => {
+      const artificialName = `${ isBound ? 'bap' : 'ap' }_${ actionName.replace(/\./g, '_') }`;// _${paramName}`;
       const newTypeName = getNewTypeName(param, paramName, artificialName, serviceName);
-      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, defName, path.concat(['params', paramName]));
+      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, defName, path.concat([ 'params', paramName ]));
     });
   }
 
@@ -149,25 +152,27 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, lastNonAnonymousFQDefName, path, parentName, isTermDef=false, ignoreInAPI=false) {
-    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable();
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, lastNonAnonymousFQDefName, path, parentName, isTermDef = false, ignoreInAPI = false) {
+    const {
+      isExposable, typeDef, typeName, elements, isAnonymous,
+    } = isTypeExposable();
     if (isExposable) {
       // this is the name used to register the new type in csn.definitions
-      let fullQualifiedNewTypeName =
-        isMultiSchema
-          ? (node.type || (node.items?.type)
-              ? getTypeNameInMultiSchema(node.type|| (node.items?.type), serviceName)
-              : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
-          : `${serviceName}.${newTypeName}`;
+      // eslint-disable-next-line no-nested-ternary
+      let fullQualifiedNewTypeName = isMultiSchema
+        ? (node.type || (node.items?.type)
+          ? getTypeNameInMultiSchema(node.type || (node.items?.type), serviceName)
+          : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
+        : `${ serviceName }.${ newTypeName }`;
 
       if (!isAnonymous) {
         // as soon as we leave of the anonymous world,
         // we're no longer in a key def => don't set notNull:true on named types
-        if(isKey)
+        if (isKey)
           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'] != null && !!node['@open'] !== !!typeDef['@open'])
+        if (elements && node['@open'] != null && !!node['@open'] !== !!typeDef['@open'])
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
         lastNonAnonymousFQDefName = fullQualifiedNewTypeName;
       }
@@ -178,84 +183,86 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         if (!exposedTypes[fullQualifiedNewTypeName]) {
           setProp(node, '$NameClashReported', true);
           error(null, path, { type: fullQualifiedNewTypeName, name: memberName },
-            'Can\'t create artificial type $(TYPE) for $(NAME) because the name is already used');
-          return { isExposable, typeDef, typeName, isAnonymous };
+                'Can\'t create artificial type $(TYPE) for $(NAME) because the name is already used');
+          return {
+            isExposable, typeDef, typeName, isAnonymous,
+          };
         }
       }
-      else {
+      else if (elements) {
         /* Expose new structured type
          * Treat items.elements as ordinary elements for now.
          */
-        if(elements) {
-          newType = createNewStructType(elements);
-          // if using node enforces open/closed, set it on type
-          if (node['@open'] !== undefined)
-            newType['@open'] = node['@open']
-          if (node.$location)
-            setProp(newType, '$location', node.$location);
-          ignoreInAPI ||= !isEdmPropertyRendered(node, options);
-          setProp(newType, '$ignoreInAPI', ignoreInAPI);
+        newType = createNewStructType(elements);
+        // if using node enforces open/closed, set it on type
+        if (node['@open'] !== undefined)
+          newType['@open'] = node['@open'];
+        if (node.$location)
+          setProp(newType, '$location', node.$location);
+        ignoreInAPI ||= !isEdmPropertyRendered(node, options);
+        setProp(newType, '$ignoreInAPI', ignoreInAPI);
 
-          csn.definitions[fullQualifiedNewTypeName] = newType;
-          exposedTypes[fullQualifiedNewTypeName] = 1;
+        csn.definitions[fullQualifiedNewTypeName] = newType;
+        exposedTypes[fullQualifiedNewTypeName] = 1;
 
-          // Recurse into elements of 'type' (if any) and expose them as well (is needed)
-          newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
-            if (node.elements && node.elements[elemName].$location)
-              setProp(newElem, '$location', node.elements[elemName].$location);
-            if (newElem.$path)
-              newElem.$path[1] = lastNonAnonymousFQDefName;
-            defName = typeDef.kind === 'type' ? typeName : defName;
-            {
-              const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                            getNewTypeName(newElem, elemName, newTypeName, serviceName), lastNonAnonymousFQDefName, path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI);
+        // Recurse into elements of 'type' (if any) and expose them as well (is needed)
+        Object.entries(newType.elements || {}).forEach(([ elemName, newElem ]) => {
+          if (node.elements && node.elements[elemName].$location)
+            setProp(newElem, '$location', node.elements[elemName].$location);
+          if (newElem.$path)
+            newElem.$path[1] = lastNonAnonymousFQDefName;
+          defName = typeDef.kind === 'type' ? typeName : defName;
+          {
+            const { isExposable, typeDef, typeName } = exposeTypeOf(
+              newElem, isKey, elemName, defName, serviceName,
+              getNewTypeName(newElem, elemName, newTypeName, serviceName), lastNonAnonymousFQDefName, path, fullQualifiedNewTypeName, isTermDef, ignoreInAPI
+            );
               // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
               // been caught by expandToFinalBaseType() (forODataNew must not modify external imported services)
-              if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
-                if(typeDef.items) {
-                  newElem.items = typeDef.items;
-                  delete newElem.type;
-                }
-                else if(newElem.items) {
-                  newElem.items.type = typeName;
-                  if(typeDef.enum)
-                    newElem.items.enum = typeDef.enum;
-                }
-                else {
-                  newElem.type = typeName;
-                  if(typeDef.enum)
-                    newElem.enum = typeDef.enum;
-                }
+            if (!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
+              if (typeDef.items) {
+                newElem.items = typeDef.items;
+                delete newElem.type;
+              }
+              else if (newElem.items) {
+                newElem.items.type = typeName;
+                if (typeDef.enum)
+                  newElem.items.enum = typeDef.enum;
+              }
+              else {
+                newElem.type = typeName;
+                if (typeDef.enum)
+                  newElem.enum = typeDef.enum;
               }
             }
-          });
-
-          // Annotations are propagated only from user defined structured
-          // types that need to be added to a service
-          if (!isAnonymous) {
-            copyAnnotations(typeDef, newType);
           }
+        });
 
-          // if the origin type had items, add items to exposed type
-          if(typeDef.kind === 'type') {
-            if(typeDef.items) {
-              newType.items = { elements: newType.elements };
-              delete newType.elements;
-            }
-          }
-        }
-        else if(isTermDef) {
-          newType = Object.create(null);
-          for(const n in typeDef) {
-            newType[n] = typeDef[n];
+        // Annotations are propagated only from user defined structured
+        // types that need to be added to a service
+        if (!isAnonymous)
+          copyAnnotations(typeDef, newType);
+
+
+        // if the origin type had items, add items to exposed type
+        if (typeDef.kind === 'type') {
+          if (typeDef.items) {
+            newType.items = { elements: newType.elements };
+            delete newType.elements;
           }
-          newType.kind = 'type';
-          csn.definitions[fullQualifiedNewTypeName] = newType;
-          exposedTypes[fullQualifiedNewTypeName] = 1;
         }
       }
+      else if (isTermDef) {
+        newType = Object.create(null);
+        for (const n in typeDef)
+          newType[n] = typeDef[n];
+
+        newType.kind = 'type';
+        csn.definitions[fullQualifiedNewTypeName] = newType;
+        exposedTypes[fullQualifiedNewTypeName] = 1;
+      }
       // adjust current node to new type
-      if(node.items) {
+      if (node.items) {
         delete node.items.elements;
         delete node.type;
         node.items.type = fullQualifiedNewTypeName;
@@ -265,7 +272,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         node.type = fullQualifiedNewTypeName;
       }
     }
-    return { isExposable, typeDef, typeName, isAnonymous };
+    return {
+      isExposable, typeDef, typeName, isAnonymous,
+    };
 
     /**
      * Check if the node's type can be exposed:
@@ -283,31 +292,37 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
     function isTypeExposable() {
-      let typeName = undefined;
+      let typeName;
       let typeDef = node;
-      const elements = (node.items?.elements || node.elements)
+      const elements = (node.items?.elements || node.elements);
       // anonymous structured type
-      if(elements)
-        return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
+      if (elements) {
+        return {
+          isExposable: true, typeDef, typeName, elements, isAnonymous: true,
+        };
+      }
       // named type, resolve the type to inspect it
       let type = node.items?.type || node.type;
-      if(type) {
+      if (type) {
         typeName = (type.ref && csnUtils.artifactRef(type)) || type;
-        const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if((!isBuiltinType(typeName) || typeName === 'cds.Map') && typeName !== special$self) {
-          rc.typeDef = typeDef = csnUtils.artifactRef(typeName, typeName);
-          if(!isArtifactInService(typeName, serviceName)) {
-            while(!isBuiltinType(typeName) || typeDef.$emtpyMapType) {
+        const rc = {
+          isExposable: true, typeDef, typeName, isAnonymous: false,
+        };
+        if ((!isBuiltinType(typeName) || typeName === 'cds.Map') && typeName !== special$self) {
+          typeDef = csnUtils.artifactRef(typeName, typeName);
+          rc.typeDef = typeDef;
+          if (!isArtifactInService(typeName, serviceName)) {
+            while (!isBuiltinType(typeName) || typeDef.$emtpyMapType) {
               typeDef = csnUtils.artifactRef(typeName, typeName);
-              if(typeDef !== typeName) {
+              if (typeDef !== typeName) {
                 // Implementation note: For `type S: T:struct;`, elements from `T:struct` were already propagated to `S`.
-                if((isTermDef && typeDef.enum) || (rc.elements = (typeDef.items?.elements || typeDef.elements)) !== undefined)
+                if ((isTermDef && typeDef.enum) || (rc.elements = (typeDef.items?.elements || typeDef.elements)) !== undefined)
                   return rc;
                 type = typeDef.items?.type || typeDef.type;
                 typeName = (type.ref && csnUtils.artifactRef(type)) || type;
               }
               else {
-                throw new CompilerAssertion(`Debug me: ${typeName} not found`);
+                throw new CompilerAssertion(`Debug me: ${ typeName } not found`);
               }
             }
           }
@@ -320,7 +335,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         //   return rc;
         // }
       }
-      return { isExposable: false, typeDef, typeName, isAnonymous: false };
+      return {
+        isExposable: false, typeDef, typeName, isAnonymous: false,
+      };
     }
 
 
@@ -336,24 +353,24 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       if (typeService) {
         // new type name without any prefixes
         const typePlainName = defNameWithoutServiceOrContextName(typeName, typeService);
-        const newSchemaName = `${serviceName}.${typeService}`;
+        const newSchemaName = `${ serviceName }.${ typeService }`;
         createSchema(newSchemaName);
         // return the new type name
-        return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;
-      } else {
-        const typeContext = csnUtils.getContextOfArtifact(typeName);
-        const typeNamespace = getNamespace(csn, typeName);
-        const newSchemaName = `${serviceName}.${typeContext || typeNamespace || fallBackSchemaName}`;
-        // new type name without any prefixes
-        const typePlainName = typeContext
-          ? defNameWithoutServiceOrContextName(typeName, typeContext)
-          : (typeNamespace
-              ? typeName.replace(typeNamespace + '.', '')
-              : typeName);
-        createSchema(newSchemaName);
-        // return the new type name
-        return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;
+        return `${ newSchemaName }.${ typePlainName.replace(/\./g, '_') }`;
       }
+      const typeContext = csnUtils.getContextOfArtifact(typeName);
+      const typeNamespace = getNamespace(csn, typeName);
+      const newSchemaName = `${ serviceName }.${ typeContext || typeNamespace || fallBackSchemaName }`;
+      // new type name without any prefixes
+      // eslint-disable-next-line no-nested-ternary
+      const typePlainName = typeContext
+        ? defNameWithoutServiceOrContextName(typeName, typeContext)
+        : (typeNamespace
+          ? typeName.replace(`${ typeNamespace }.`, '')
+          : typeName);
+      createSchema(newSchemaName);
+      // return the new type name
+      return `${ newSchemaName }.${ typePlainName.replace(/\./g, '_') }`;
     }
 
     /**
@@ -370,7 +387,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
 
       createSchema(newSchemaName);
-      return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;
+      return `${ newSchemaName }.${ typePlainName.replace(/\./g, '_') }`;
     }
 
     /**
@@ -394,18 +411,18 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       setProp(type, '$exposedBy', 'typeExposure');
 
       // Duplicate elements
-      Object.entries(elements).forEach(([elemName, element]) => {
+      Object.entries(elements).forEach(([ elemName, element ]) => {
         const cloned = cloneCsnNonDict(element, options);
         // if this was an anonymous sub element of a key, mark it as not nullable
-        if(isAnonymous && isKey && !cloned.key) {
-          if(cloned.target) {
-            if(cloned.cardinality === undefined)
+        if (isAnonymous && isKey && !cloned.key) {
+          if (cloned.target) {
+            if (cloned.cardinality === undefined)
               cloned.cardinality = {};
             cloned.cardinality.min = 1;
           }
           // if odata-unexpected-nullable-key is checking on min>1, this can
           // be an else if
-          if(cloned.notNull === undefined)
+          if (cloned.notNull === undefined)
             cloned.notNull = true;
         }
         type.elements[elemName] = cloned;
@@ -418,18 +435,19 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * Calculate the name of the exposed type based on the information, the element can provide
    * If the element is typed, use the type name
    * else assume it's a de-anonymized type, concatenate the element name to the defName
-  */
+   */
   function getNewTypeName(element, elementName, typeNamePrefix, serviceName) {
     // for the new type name node.type has precedence over node.items.type
     const typeName = (!element?.elements && element?.type || !element?.items?.elements && element?.items?.type);
-    return typeName
-        ? `${isMultiSchema
-              ? typeName.split('.').pop() // use leaf element
-              : typeName.replace(/\./g, '_')}` // concatenate path
-        : ( elementName // returns has no elementName, return the precalculated prefix
-            ? `${defNameWithoutServiceOrContextName(typeNamePrefix, serviceName).replace(/\./g, '_')}_${elementName}`
-            : typeNamePrefix
-          );
+    if (typeName) {
+      return `${ isMultiSchema
+        ? typeName.split('.').pop() // use leaf element
+        : typeName.replace(/\./g, '_') }`; // concatenate path
+    }
+    return ( elementName // returns has no elementName, return the precalculated prefix
+      ? `${ defNameWithoutServiceOrContextName(typeNamePrefix, serviceName).replace(/\./g, '_') }_${ elementName }`
+      : typeNamePrefix
+    );
   }
 }
 

package/lib/transform/odata/utils.js

@@ -6,7 +6,7 @@
  * @param {string} srvOrCtx
  */
 function defNameWithoutServiceOrContextName(name, srvOrCtx) {
-  return name.replace(`${srvOrCtx}.`, '');
+  return name.replace(`${ srvOrCtx }.`, '');
 }
 
 /**
@@ -20,7 +20,7 @@ function defNameWithoutServiceOrContextName(name, srvOrCtx) {
  * @param {string[]} services
  */
 function getServiceOfArtifact(artName, services) {
-  return services.find(serviceName => artName.startsWith(`${serviceName}.`));
+  return services.find(serviceName => artName.startsWith(`${ serviceName }.`));
 }
 
 /**
@@ -29,7 +29,7 @@ function getServiceOfArtifact(artName, services) {
  * @param {string} service Name of the service
  */
 function isArtifactInService(artName, service) {
-  return typeof artName === 'string' ? artName.startsWith(`${service}.`) : false;
+  return typeof artName === 'string' ? artName.startsWith(`${ service }.`) : false;
 }
 
 /**
@@ -40,7 +40,7 @@ function isArtifactInService(artName, service) {
  * @param {string[]} services
  */
 function isArtifactInSomeService(artName, services) {
-  return services.some(serviceName => artName.startsWith(`${serviceName}.`));
+  return services.some(serviceName => artName.startsWith(`${ serviceName }.`));
 }
 
 /**
@@ -51,7 +51,8 @@ function isArtifactInSomeService(artName, services) {
  * @param {string[]} services
  */
 function isLocalizedArtifactInService(artName, services) {
-  if (!artName.startsWith('localized.')) return false;
+  if (!artName.startsWith('localized.'))
+    return false;
   return isArtifactInSomeService(artName.split('.').slice(1).join('.'), services);
 }
 
@@ -61,4 +62,4 @@ module.exports = {
   isArtifactInService,
   isArtifactInSomeService,
   isLocalizedArtifactInService,
-}
+};