@sap/cds-compiler 4.6.0 → 4.7.4

package/lib/edm/edm.js

@@ -664,7 +664,7 @@ function getEdm( options, messageFunctions ) {
       }
 
       // Set the collection property if this is either an element, parameter or a term def
-      this._isCollection = (csn.kind === undefined || csn.kind === 'annotation') ? csn._isCollection : false;
+      this.$isCollection = (csn.kind === undefined || csn.kind === 'annotation') ? csn.$isCollection : false;
 
       if (options.whatsMySchemaName && this._edmAttributes[typeName]) {
         const schemaName = options.whatsMySchemaName(this._edmAttributes[typeName]);
@@ -675,7 +675,7 @@ function getEdm( options, messageFunctions ) {
       // store undecorated type for JSON
       this._type = this._edmAttributes[typeName];
       // decorate for XML (not for Complex/EntityType)
-      if (this._isCollection && this._edmAttributes[typeName])
+      if (this.$isCollection && this._edmAttributes[typeName])
         this._edmAttributes[typeName] = `Collection(${this._edmAttributes[typeName]})`;
     }
 
@@ -694,8 +694,8 @@ function getEdm( options, messageFunctions ) {
         });
       }
 
-      if (this._isCollection)
-        json.$Collection = this._isCollection;
+      if (this.$isCollection)
+        json.$Collection = this.$isCollection;
 
       return json;
     }
@@ -848,7 +848,7 @@ function getEdm( options, messageFunctions ) {
 
     setNullable() {
       // From the Spec: In OData 4.01 responses a collection-valued property MUST specify a value for the Nullable attribute.
-      if (this._isCollection)
+      if (this.$isCollection)
         this._edmAttributes.Nullable = !this.isNotNullable();
 
       // Nullable=true is default, mention Nullable=false only in XML
@@ -1000,7 +1000,7 @@ function getEdm( options, messageFunctions ) {
       const [ src, tgt ] = edmUtils.determineMultiplicity(csn._constraints._partnerCsn || csn);
       csn._constraints._multiplicity = csn._constraints._partnerCsn ? [ tgt, src ] : [ src, tgt ];
       this._type = attributes.Type;
-      this._isCollection = this.isToMany();
+      this.$isCollection = this.isToMany();
       this._targetCsn = csn._target;
 
       if (this.v4) {
@@ -1008,7 +1008,7 @@ function getEdm( options, messageFunctions ) {
           this._edmAttributes.Nullable = false;
 
         // either csn has multiplicity or we have to use the multiplicity of the backlink
-        if (this._isCollection) {
+        if (this.$isCollection) {
           this._edmAttributes.Type = `Collection(${attributes.Type})`;
           // attribute Nullable is not allowed in combination with Collection (see Spec)
           // Even if min cardinality is > 0, remove Nullable, because the implicit OData contract
@@ -1082,7 +1082,7 @@ function getEdm( options, messageFunctions ) {
       return (nodeCsn.notNull === true && !nodeCsn.target || tgtCard.min > 0);
     }
     isToMany() {
-      return (this._isCollection || this._csn._constraints._multiplicity[1] === '*');
+      return (this.$isCollection || this._csn._constraints._multiplicity[1] === '*');
     }
 
     toJSONattributes(json) {

package/lib/edm/edmPreprocessor.js

@@ -4,14 +4,17 @@
 const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
-  isEdmPropertyRendered, getUtils, cloneCsnNonDict,
-  isBuiltinType, applyTransformations, cloneAnnotationValue, cardinality2str, isAnnotationExpression,
+  isEdmPropertyRendered, getUtils,
+  isBuiltinType, applyTransformations, transformExpression, findAnnotationExpression,
+  cardinality2str, isMagicVariable,
 } = require('../model/csnUtils');
 const edmUtils = require('./edmUtils.js');
 const edmAnnoPreproc = require('./edmAnnoPreprocessor.js');
 const { inboundQualificationChecks } = require('./edmInboundChecks.js');
 const typesExposure = require('../transform/odata/typesExposure');
 const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
+const { cloneCsnNonDict, cloneAnnotationValue } = require('../model/cloneCsn');
+const { forEach, forEachKey } = require('../utils/objectUtils.js');
 
 const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 
@@ -504,16 +507,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     setProp(parameterCsn, '_origin', entityCsn);
     // create the Type Definition
     // modify the original parameter entity with backlink and new name
-    if (csn.definitions[typeEntityName]) {
+    if (csn.definitions[typeEntityName])
       error('odata-definition-exists', [ 'definitions', entityName ], { '#': 'std', name: typeEntityName });
-    }
-    else {
-      csn.definitions[typeEntityName] = entityCsn;
-      reqDefs.definitions[typeEntityName] = entityCsn;
-      delete csn.definitions[entityCsn.name];
-      delete reqDefs.definitions[entityCsn.name];
+    else
       entityCsn.name = typeEntityName;
-    }
     setProp(entityCsn, '$entitySetName', typeEntitySetName);
     // add backlink association
     if (hasBacklink) {
@@ -526,15 +523,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       setProp(entityCsn.elements[typeToParameterAssocName], '_selfReferences', []);
       setProp(entityCsn.elements[typeToParameterAssocName], '_target', parameterCsn);
       setProp(entityCsn.elements[typeToParameterAssocName], '$path',
-              [ 'definitions', typeEntityName, 'elements', typeToParameterAssocName ] );
-
-      // rewrite $path
-      if (entityCsn.$path)
-        entityCsn.$path[1] = typeEntityName;
-      forEachMemberRecursively(entityCsn, (member) => {
-        if (member.$path)
-          member.$path[1] = typeEntityName;
-      });
+              [ 'definitions', entityName, 'elements', typeToParameterAssocName ] );
     }
 
     /*
@@ -720,10 +709,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       // such that the VL annotations are distributed to the associations *before*
       // FK creation.
       // The FK creation already propagates the annotations from the association
-      const elements = construct.items && construct.items.elements || construct.elements;
+      const elements = construct.items?.elements || construct.elements;
       const assoc = elements[element['@odata.foreignKey4']];
       if (assoc) {
-        Object.keys(assoc).filter(pn => pn[0] === '@' && !isAnnotationExpression(assoc[pn])).forEach((pn) => {
+        Object.keys(assoc).filter(pn => pn[0] === '@' && !findAnnotationExpression(assoc, pn)).forEach((pn) => {
           edmUtils.assignAnnotation(element, pn, assoc[pn]);
         });
       }
@@ -731,15 +720,16 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       if (options.isV2())
         edmAnnoPreproc.setSAPSpecificV2AnnotationsToAssociation(element);
 
+      const absPath = $path2path(element.$path);
+
       // initialize an association
       if (element.target) {
         // in case this is a forward assoc, store the backlink partners here, _selfReferences.length > 1 => error
         edmUtils.assignProp(element, '_selfReferences', []);
         edmUtils.assignProp(element._target, '$proxies', []);
         // $abspath is used as partner path
-        edmUtils.assignProp(element, '$abspath', $path2path(element.$path));
+        edmUtils.assignProp(element, '$abspath', absPath);
       }
-
       // Collect keys
       if (element.key)
         keys[elementName] = element;
@@ -935,7 +925,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             const targetSchemaName = fqSchemaName.replace(`${srn}.`, '');
             if (serviceRootNames.includes(targetSchemaName)) {
               // remove all definitions starting with < fqSchemaName >. and add a schema reference
-              Object.keys(csn.definitions).forEach((dn) => {
+              forEachKey(csn.definitions, (dn) => {
                 if (dn.startsWith(fqSchemaName)) {
                   delete csn.definitions[dn];
                   delete reqDefs.definitions[dn];
@@ -1075,7 +1065,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     function muteNavProp( elt, msg = 'std' ) {
       edmUtils.assignAnnotation(elt, '@odata.navigable', false);
       if (elt._target['@cds.autoexpose'] !== false) {
-        warning('odata-navigation', [ 'definitions', struct.name, 'elements', elt.name ],
+        warning('odata-navigation', elt.$path,
                 { target: elt._target.name, service: globalSchemaPrefix, '#': msg });
       }
     }
@@ -1118,7 +1108,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       setProp(proxy, '$hasEntitySet', false);
       setProp(proxy, '$exposedTypes', Object.create(null));
       // copy all annotations of the target to the proxy
-      Object.entries(assoc._target).forEach(([ k, v ]) => {
+      forEach(assoc._target, ( k, v ) => {
         if (k[0] === '@' && k !== '@open')
           proxy[k] = v;
       });
@@ -1165,7 +1155,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             }
             else {
               newElt = Object.create(null);
-              Object.keys(e).forEach((prop) => {
+              forEachKey(e, (prop) => {
                 newElt[prop] = e[prop];
               });
             }
@@ -1241,7 +1231,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
               if (typeClone) {
                 // Recurse into elements of 'type' (if any)
                 if (typeClone.elements) {
-                  Object.entries(typeClone.elements).forEach(([ elemName, elem ]) => {
+                  forEach(typeClone.elements, ( elemName, elem ) => {
                   // if this is a foreign key element, we must check whether or not the association
                   // has been exposed as proxy. If it has not been exposed, no further structured
                   // types must be exposed as 'Proxy_' types.
@@ -1298,10 +1288,10 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             type['@open'] = typeDef['@open'];
 
           if (typeDef.elements) {
-            Object.entries(typeDef.elements).forEach( ([ elemName, elem ]) => {
+            forEach(typeDef.elements, ( elemName, elem ) => {
               if (!elem.target) {
                 type.elements[elemName] = Object.create(null);
-                Object.keys(elem).forEach((prop) => {
+                forEachKey(elem, (prop) => {
                   type.elements[elemName][prop] = elem[prop];
                 });
               }
@@ -1478,7 +1468,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         // followed by all namespaces that are potentially exposed by the exposed types
         // don't forget to prepend the global namespace prefix
         // schemas are ordered in csn2edm.js for each service
-        Object.keys(proxy.$exposedTypes).forEach(t => schemaSet.add(`${proxy.$globalSchemaPrefix}.${edmUtils.getSchemaPrefix(t)}`));
+        forEachKey(proxy.$exposedTypes, t => schemaSet.add(`${proxy.$globalSchemaPrefix}.${edmUtils.getSchemaPrefix(t)}`));
         schemaSet.forEach((schemaName) => {
           if (!schemas[schemaName]) {
             schemas[schemaName] = { kind: 'schema', name: schemaName };
@@ -1490,7 +1480,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
           csn.definitions[fqProxyName] = proxy;
           reqDefs.definitions[fqProxyName] = proxy;
           setProp(proxy, '$path', [ 'definitions', fqProxyName ]);
-          Object.entries(proxy.$exposedTypes).forEach(([ tn, v ]) => {
+          forEach(proxy.$exposedTypes, ( tn, v ) => {
             const fqtn = `${proxy.$globalSchemaPrefix}.${tn}`;
             if (csn.definitions[fqtn] === undefined) {
               csn.definitions[fqtn] = v;
@@ -1610,7 +1600,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         elements = finalType?.elements || finalType?.items?.elements;
       }
       if (elements) {
-        Object.entries(elements).forEach(([ eltName, elt ]) => {
+        forEach(elements, ( eltName, elt ) => {
           if (!elt.$visited) {
             setProp(elt, '$visited', true);
             let newRefs = [];
@@ -1711,7 +1701,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             'Edm.TimeOfDay': 1,
           };
           if (!(edmType in legalEdmTypes)) {
-            warning('odata-spec-violation-key-type', location,
+            message('odata-spec-violation-key-type', location,
                     {
                       name: pathSegment, type: type.type, id: edmType, '#': pathSegment ? 'std' : 'scalar',
                     });
@@ -1909,6 +1899,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       mapCdsToEdmProp(member);
       annotateAllowedValues(member, location);
       ComputedDefaultValue(member);
+      rewriteAnnotationExpressions(member);
       if (member.returns) {
         edmUtils.assignAnnotation(member.returns, '@Core.Description', member.returns.doc);
         markCollection(member.returns);
@@ -1921,7 +1912,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
       if (items) {
         edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : true);
-        edmUtils.assignProp(obj, '_isCollection', true);
+        edmUtils.assignProp(obj, '$isCollection', true);
       }
     }
 
@@ -2029,6 +2020,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
             if (npe.NavigationProperty &&
                npe.NavigationProperty['='] &&
                typeof npe.NavigationProperty['='] === 'string') {
+              // TODO: replace with transformExpression
               applyTransformations({ definitions: { npe } }, {
                 '=': (parent, prop, value) => {
                   parent[prop] = prefix.concat(value).join('.');
@@ -2146,12 +2138,12 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       const edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }
-    else if (obj._isCollection && (obj.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.type)?.type))) {
+    else if (obj.$isCollection && (obj.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.type)?.type))) {
       const edmType = edmUtils.mapCdsToEdmType(obj.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType'], obj.$path);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }
     // This is the special case when we have array of array, but will not be supported in the future
-    else if (obj._isCollection && obj.items && obj.items.type && obj.items.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.items.type)?.type)) {
+    else if (obj.$isCollection && obj.items && obj.items.type && obj.items.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.items.type)?.type)) {
       const edmType = edmUtils.mapCdsToEdmType(obj.items.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }
@@ -2175,6 +2167,112 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         edmUtils.assignAnnotation(member, '@Core.ComputedDefaultValue', true);
     }
   }
+
+  function rewriteAnnotationExpressions( carrier ) {
+    // rewrite annotation expression paths such that they are defined against the definition
+    const absPath = $path2path(carrier.$path);
+    let isSubTreeSpan = true;
+    const rootPrefix = absPath.slice(1, absPath.length - 1);
+
+    const isExprAnno = (obj, pn) => isBetaEnabled(options, 'odataPathsInAnnotationExpressions') && findAnnotationExpression(obj, pn);
+
+    const subTreeSpan = {
+      ref: (parent, _prop, xpr) => {
+        const head = xpr[0].id || xpr[0];
+        if (head === '$self' || parent.param) {
+          let j = parent.param ? 0 : 1;
+          for (let i = 1; i < absPath.length - 1 && isSubTreeSpan; i++, j++)
+            isSubTreeSpan = (xpr[j].id || xpr[j]) === absPath[i];
+        }
+      },
+    };
+      // this element was not a top level element before type exposure
+      // rectify all absolute annotation paths inside
+    const relativize = {
+      ref: (parent, _prop, xpr) => {
+        const head = xpr[0].id || xpr[0];
+        let absPathPrefixEqual = true;
+        if (head === '$self' || parent.param) {
+          let j = parent.param ? 0 : 1;
+          for (let i = 1; i < absPath.length - 1 && absPathPrefixEqual; i++, j++)
+            absPathPrefixEqual = (xpr[j].id || xpr[j]) === absPath[i];
+
+          if (absPathPrefixEqual)
+            // remove prefix between $self and leaf element name
+            // or starting with the parameter name
+            xpr.splice(parent.param ? 0 : 1, absPath.length - 2);
+        }
+      },
+    };
+
+    const absolutize = {
+      ref: (parent, prop, xpr) => {
+        const head = xpr[0].id || xpr[0];
+        if (head !== '$self' && !parent.param && !isMagicVariable(head)) {
+          parent[prop] = [ ...rootPrefix, ...xpr ];
+          if (absolutize.scope === 'params')
+            parent.param = true;
+          else
+            parent[prop].unshift('$self');
+        }
+      },
+    };
+
+    if (absPath.length > 2) {
+      const [ xprANames, nxprANames ] = Object.keys(carrier).reduce((acc, pn) => {
+        if (pn[0] === '@')
+          acc[isExprAnno(carrier, pn) ? 0 : 1].push(pn);
+        return acc;
+      }, [ [], [] ]);
+      xprANames.forEach((xprAName) => {
+        isSubTreeSpan = true;
+        transformExpression(carrier, xprAName, subTreeSpan);
+        if (isSubTreeSpan) {
+          transformExpression(carrier, xprAName, relativize);
+        }
+        else {
+          const scope = carrier.$path[2];
+          absolutize.scope = scope;
+          transformExpression(carrier, xprAName, absolutize);
+          const def = csn.definitions[absPath[0]];
+          const eltPath = absPath.slice(1).join('/');
+          const proxyDict = scope === 'elements' ? '$eltAnnoProxies' : '$paramAnnoProxies';
+
+          if (!def[proxyDict])
+            setProp(def, proxyDict, Object.create(null));
+          let eltProxy = def[proxyDict][eltPath];
+          if (!eltProxy) {
+            eltProxy = Object.create(null);
+            // these attributes are needed to test for
+            // Property, Parameter, NavigationProperty, Collection
+            // Applicability
+            [ 'target',
+              'cardinality',
+              'keys',
+              '$isCollection',
+              '$appliesToReturnType',
+              '$path',
+              '@cds.api.ignore',
+              '@odata.navigable' ].forEach((prop) => {
+              if (carrier[prop] != null)
+                setProp(eltProxy, prop, carrier[prop]);
+            });
+
+            Object.keys(carrier).filter(pn => pn[0] !== '@').forEach((pn) => {
+              eltProxy[pn] = carrier[pn];
+            });
+            def[proxyDict][eltPath] = eltProxy;
+          }
+          eltProxy[xprAName] = carrier[xprAName];
+          carrier[xprAName] = null;
+          nxprANames.filter(an => an.startsWith(`${xprAName}.`)).forEach((nxprAName) => {
+            eltProxy[nxprAName] = carrier[nxprAName];
+            carrier[nxprAName] = null;
+          });
+        }
+      });
+    }
+  }
 }
 
 module.exports = {

package/lib/edm/edmUtils.js

@@ -1,11 +1,12 @@
 'use strict';
 
-const { setProp } = require('../base/model');
+const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  isBuiltinType, isEdmPropertyRendered, applyTransformations, cloneAnnotationValue,
+  isBuiltinType, isEdmPropertyRendered, applyTransformations,
 } = require('../model/csnUtils');
 const { escapeString, hasControlCharacters, hasUnpairedUnicodeSurrogate } = require('../render/utils/stringEscapes');
 const { CompilerAssertion } = require('../base/error');
+const { cloneAnnotationValue } = require('../model/cloneCsn');
 
 /* eslint max-statements-per-line:off */
 function validateOptions( _options ) {
@@ -31,6 +32,19 @@ function validateOptions( _options ) {
 
     options.pathDelimiter = options.isStructFormat ? '/' : '_';
 
+    if (isBetaEnabled(options, 'v5preview')) {
+      if (!options.severities)
+        options.severities = {};
+      options.severities['odata-spec-violation-array'] ??= 'Error';
+      options.severities['odata-spec-violation-assoc'] ??= 'Error';
+      options.severities['odata-spec-violation-namespace'] ??= 'Error';
+      options.severities['odata-spec-violation-param'] ??= 'Error';
+      options.severities['odata-spec-violation-returns'] ??= 'Error';
+      options.severities['odata-spec-violation-type-unknown'] ??= 'Error';
+      options.severities['odata-spec-violation-no-key'] ??= 'Error';
+      options.severities['odata-spec-violation-key-type'] ??= 'Error';
+      options.severities['odata-spec-violation-property-name'] ??= 'Error';
+    }
     return options;
   }
   return _options;
@@ -575,15 +589,14 @@ function addTypeFacets( node, csn ) {
   const decimalTypes = { 'cds.Decimal': 1, 'cds.DecimalFloat': 1, 'cds.hana.SMALLDECIMAL': 1 };
   if (csn.length != null)
     node.setEdmAttribute('MaxLength', csn.length);
-  if (csn.scale !== undefined)
-    node.setEdmAttribute('Scale', csn.scale);
-  // else if (csn.type === 'cds.hana.SMALLDECIMAL' && !isV2)
-  //   node._edmAttributes.Scale = 'floating';
-
   if (csn.precision != null)
     node.setEdmAttribute('Precision', csn.precision);
   // else if (csn.type === 'cds.hana.SMALLDECIMAL' && !isV2)
   //   node.Precision = 16;
+  if (csn.scale !== undefined)
+    node.setEdmAttribute('Scale', csn.scale);
+  // else if (csn.type === 'cds.hana.SMALLDECIMAL' && !isV2)
+  //   node._edmAttributes.Scale = 'floating';
   else if (csn.type === 'cds.Timestamp' && node._edmAttributes.Type === 'Edm.DateTimeOffset')
     node.setEdmAttribute('Precision', 7);
   if (csn.type in decimalTypes) {

package/lib/gen/Dictionary.json

@@ -2690,7 +2690,7 @@
     "Capabilities.PermissionType": {
       "$kind": "ComplexType",
       "Properties": {
-        "SchemeName": "Auth.SchemeName",
+        "SchemeName": "Authorization.SchemeName",
         "Scopes": "Collection(Capabilities.ScopeType)"
       }
     },
@@ -3594,6 +3594,7 @@
       "$kind": "ComplexType",
       "Properties": {
         "ChangeNextSiblingAction": "Common.QualifiedName",
+        "ChangeSiblingForRootsSupported": "Edm.Boolean",
         "CopyAction": "Common.QualifiedName"
       }
     },

package/lib/gen/language.checksum

@@ -1 +1 @@
-99b88c455f59a02a22d3d2ee662b8136
+37b3697769a5035b6409cd959ebdf610