@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
+const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
 const { isBetaEnabled } = require('../../base/model.js');
 
@@ -49,6 +49,31 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     }
   });
 
+  if(isBetaEnabled(options, 'odataTerms')) {
+    forEachGeneric(csn, 'vocabularies', (def, defName, _propertyName, path) => {
+    // we do expose types only for definition from inside services
+      const serviceName = whatsMyServiceName(defName, false);
+    // run type exposure only on requested services if not in multi schema mode
+    // multi schema mode requires a proper type exposure for all services as a prerequisite
+    // for the proxy exposure
+      if (serviceName && requestedServiceNames.includes(serviceName)) {
+        if(csn.definitions[defName]) {
+        // error, duplicate definitions not allowed!
+        // TODO: Use path as error location as soon as refs outside definitions are supported
+          error('odata-definition-exists', ['vocabularies', defName], { anno: defName, '#':'anno' });
+        }
+        else {
+        // link def into definitions for later use
+          def.kind = 'annotation';
+          csn.definitions[defName] = def;
+          const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;
+          const newTypeName = getNewTypeName(undefined, undefined, artificialName, serviceName);
+          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, path.concat(['vocabularies', defName]), undefined, true);
+        }
+      }
+    });
+  }
+
   return schemas;
 
 /**
@@ -82,14 +107,14 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName) {
-    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable(node);
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=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 && node.items.type)
-              ? getTypeNameInMultiSchema(node.type|| (node.items && node.items.type), serviceName)
+          ? (node.type || (node.items?.type)
+              ? getTypeNameInMultiSchema(node.type|| (node.items?.type), serviceName)
               : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
           : `${serviceName}.${newTypeName}`;
 
@@ -100,7 +125,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           isKey = false;
         // in case this was a named type and if the openess does not match the type definition
         // expose the type as a new one not changing the original definition.
-        if((!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
+        if(elements && (!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
       }
       // check if that type is already defined
@@ -108,41 +133,73 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       if (newType) {
         // error, if it was not exposed by us
         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;
+          return { isExposable, typeDef, typeName, isAnonymous };
         }
       }
       else {
         /* Expose new structured type
          * Treat items.elements as ordinary elements for now.
          */
-        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);
+        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);
 
-        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);
-          defName = typeDef.kind === 'type' ? typeName : defName;
-          exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                       getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName);
-        });
-        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;
+          // 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);
+            defName = typeDef.kind === 'type' ? typeName : defName;
+            {
+              const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
+                            getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef);
+              // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
+              // been catched 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;
+                }
+              }
+            }
+          });
+          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(let 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) {
@@ -155,6 +212,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         node.type = fullQualifiedNewTypeName;
       }
     }
+    return { isExposable, typeDef, typeName, isAnonymous };
 
      /**
      * Check if the node's type can be exposed:
@@ -166,38 +224,46 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      *  - the elements dictionary that needs to be cloned
      *  - the typeDef, either the resolved type def or the node itself
      *  - if structured type was anonymously defined
-     * @param {object} node
      * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
-    function isTypeExposable(node) {
+    function isTypeExposable() {
       let typeName = undefined;
       let typeDef = node;
-      let elements = (node.items && node.items.elements || node.elements)
+      let elements = (node.items?.elements || node.elements)
       // anonymous structured type
       if(elements)
         return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
       // named type, resolve the type to inspect it
-      let type = node.items && node.items.type || node.type;
+      let type = node.items?.type || node.type;
       if(type) {
         typeName = (type.ref && csnUtils.getFinalType(type)) || type;
-        typeDef = csnUtils.getFinalTypeDef(typeName);
         const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if(!isBuiltinType(typeName) && !isArtifactInService(typeName, serviceName)) {
-          while(!isBuiltinType(typeName)) {
-            typeDef = csnUtils.getFinalTypeDef(typeName);
-            if(typeDef) {
-              if((rc.elements = (typeDef.items && typeDef.items.elements || typeDef.elements)) !== undefined)
-                return rc;
-              type = typeDef.items && typeDef.items.type || typeDef.type;
-              typeName = (type.ref && csnUtils.getFinalType(type)) || type;
-            }
-            else {
-              throw Error(`Please debug me: ${typeName} not found`);
+        if(!isBuiltinType(typeName)) {
+          rc.typeDef = typeDef = csnUtils.getFinalTypeDef(typeName);
+          if(!isArtifactInService(typeName, serviceName)) {
+            while(!isBuiltinType(typeName)) {
+              typeDef = csnUtils.getFinalTypeDef(typeName);
+              if(typeDef) {
+                if((isTermDef && typeDef.enum) || (rc.elements = (typeDef.items?.elements || typeDef.elements)) !== undefined)
+                  return rc;
+                type = typeDef.items?.type || typeDef.type;
+                typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+              }
+              else {
+                throw Error(`Please debug me: ${typeName} not found`);
+              }
             }
           }
+          else {
+            rc.isExposable = false;
+            return rc;
+          }
         }
+        // else if(isTermDef && typeDef.enum) {
+        //   return rc;
+        // }
       }
-      return { isExposable: false };
+      return { isExposable: false, typeDef, typeName, isAnonymous: false };
     }
 
 
@@ -286,7 +352,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
   */
   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 && !element.items.elements && element.items.type);
+    const typeName = (!element?.elements && element?.type || !element?.items?.elements && element?.items?.type);
     return typeName
         ? `${isMultiSchema
               ? typeName.split('.').pop() // use leaf element