@sap/cds-compiler 4.4.4 → 4.5.0

package/lib/edm/csn2edm.js

@@ -477,7 +477,10 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
         const type = `${schema.name}.${EntityTypeName}`;
         if (properties.length === 0)
           warning(null, location, { type }, 'EDM EntityType $(TYPE) has no properties');
-        else if (entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
+        // only if this entity has an entity set, it is required to have a key
+        // this especially covers: 'items: composition of one { data : String; }'
+        // "keyless" composition targets in structured containment mode
+        else if (entityCsn.$hasEntitySet && entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
           message('odata-spec-violation-no-key', location);
 
         if (!edmUtils.isODataSimpleIdentifier(EntityTypeName))

package/lib/edm/edmInboundChecks.js

@@ -2,8 +2,9 @@
 
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  forEachDefinition, forEachMemberRecursively,
+  forEachDefinition, forEachMemberRecursively, isBuiltinType, getUtils,
 } = require('../model/csnUtils');
+const { assignAnnotation } = require('./edmUtils.js');
 
 // eslint-disable-next-line no-unused-vars
 function resolveForeignKeyRefs( csn, csnUtils ) {
@@ -22,9 +23,11 @@ function resolveForeignKeyRefs( csn, csnUtils ) {
 
 function inboundQualificationChecks( csn, options, messageFunctions,
                                      serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils ) {
-  const { message, throwWithError } = messageFunctions;
+  const { message, warning, throwWithError } = messageFunctions;
 
-  forEachDefinition(csn, [ attach$path, checkProperArrayUsage ]);
+  const { getFinalTypeInfo } = getUtils(csn);
+
+  forEachDefinition(csn, [ attach$path, onServiceMember ]);
   checkNestedContextsAndServices();
   throwWithError();
 
@@ -37,27 +40,68 @@ function inboundQualificationChecks( csn, options, messageFunctions,
                              }, [ 'definitions', defName ]);
   }
 
-  function checkProperArrayUsage( def, defName ) {
+  // code that should be run only on service members
+  function onServiceMember( def, defName ) {
     if (!isMyServiceRequested(defName))
       return;
-    const currPath = [ 'definitions', defName ];
-    checkIfItemsOfItems(def, undefined, undefined, currPath);
-    forEachMemberRecursively(def, checkIfItemsOfItems, currPath);
-
-    function checkIfItemsOfItems( construct, _constructName, _prop, path ) {
-      const constructType = csnUtils.effectiveType(construct);
-      if (constructType.items) {
-        if (constructType.items.target) {
-          const isComp = constructType.items.type === 'cds.Composition';
+
+    const location = [ 'definitions', defName ];
+    // check items.items
+    checkIfItemsOfItems(def, undefined, undefined, location);
+    forEachMemberRecursively(def, checkIfItemsOfItems, location);
+
+    // decorate UUID keys with @Core.ComputedDefaultValue and complain
+    // on named type UUID elements that have no such annotation
+    const anno = '@Core.ComputedDefaultValue';
+    if (def.kind === 'entity' && def.elements) {
+      Object.entries(def.elements).forEach(([ eltName, elt ]) => {
+        if (elt.key)
+          addCoreComputedDefaultValueOnUUIDKeys(elt, [ eltName ], location);
+      });
+    }
+
+    function addCoreComputedDefaultValueOnUUIDKeys( elt, eltPath, path ) {
+      let type = elt.items?.type || elt.type;
+      if (type && !isBuiltinType(type)) {
+        type = getFinalTypeInfo(type);
+        if (!isBuiltinType(type.type))
+          path = [ 'definitions', type.type ];
+      }
+      else {
+        type = elt;
+      }
+
+      if (type.type === 'cds.UUID') {
+        if (path[1] === defName)
+          assignAnnotation(elt, anno, true);
+
+        else if (elt[anno] == null)
+          warning('odata-key-uuid-default-anno', path, { type: type.type, anno, id: `${defName}:${eltPath.join('.')}` });
+      }
+      else {
+        const elements = type.items?.elements || type.elements;
+        if (elements) {
+          Object.entries(elements).forEach(([ eltName, subelt ]) => {
+            addCoreComputedDefaultValueOnUUIDKeys(subelt, [ ...eltPath, eltName ], [ ...path, 'elements', eltName ]);
+          });
+        }
+      }
+    }
+
+    function checkIfItemsOfItems( member, _memberName, _prop, path ) {
+      const memberType = csnUtils.effectiveType(member);
+      if (memberType.items) {
+        if (memberType.items.target) {
+          const isComp = memberType.items.type === 'cds.Composition';
           message('type-invalid-items', path, { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
           return;
         }
-        if (constructType.items.items) {
+        if (memberType.items.items) {
           message('chained-array-of', path);
           return;
         }
 
-        const itemsType = csnUtils.effectiveType(constructType.items);
+        const itemsType = csnUtils.effectiveType(memberType.items);
         if (itemsType.items)
           message('chained-array-of', path);
       }

package/lib/edm/edmPreprocessor.js

@@ -168,7 +168,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         initEdmNavPropBindingTargets,
         pullupCapabilitiesAnnotations,
         annotateOptionalActFuncParams,
-        openService,
       ]);
     }
 
@@ -2125,7 +2124,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             optPns.forEach((op) => {
               const type = op.items?.type || op.type;
               if (type !== special$self)
-                warning('odata-parameter-order', location.concat(op.name));
+                error('odata-parameter-order', location.concat(op.name));
             });
             optPns = [];
           }
@@ -2134,11 +2133,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     }
   }
 
-  function openService( def ) {
-    if (options.odataOpenType && !def.$isParamEntity && !def.$proxy)
-      edmUtils.assignAnnotation(def, '@open', true);
-  }
-
   // ////////////////////////////////////////////////////////////////////
   //
   // Helper section starts here

package/lib/gen/Dictionary.json

@@ -801,6 +801,13 @@
         "Parameter"
       ]
     },
+    "Common.ValueListShowValuesImmediately": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "Annotation"
+      ],
+      "$experimental": true
+    },
     "Common.ValueListForValidation": {
       "Type": "Edm.String",
       "AppliesTo": [
@@ -2956,6 +2963,7 @@
     "Common.IntervalType": {
       "$kind": "ComplexType",
       "Properties": {
+        "Label": "Edm.String",
         "LowerBoundary": "Edm.PropertyPath",
         "LowerBoundaryIncluded": "Edm.Boolean",
         "UpperBoundary": "Edm.PropertyPath",

package/lib/gen/language.checksum

@@ -1 +1 @@
-582fa96ad61075beb0b9f9f8c46f11f3
+942cce045e6fb6ecaf7cbf3039001aa9