@sap/cds 9.2.0 → 9.3.0

package/libx/odata/parse/afterburner.js

@@ -8,6 +8,9 @@ const normalizeTimestamp = require('../../_runtime/common/utils/normalizeTimesta
 const { rewriteExpandAsterisk } = require('../../_runtime/common/utils/rewriteAsterisks')
 const resolveStructured = require('../../_runtime/common/utils/resolveStructured')
 
+// Same regex as peggy parser
+const RELAXED_UUID_REGEX = /^[0-9a-z]{8}-?[0-9a-z]{4}-?[0-9a-z]{4}-?[0-9a-z]{4}-?[0-9a-z]{12}$/i
+
 function _getDefinition(definition, name, namespace) {
   return (
     definition?.definitions?.[name] ||
@@ -185,6 +188,13 @@ function _convertVal(value, element) {
     case 'cds.Timestamp':
       return normalizeTimestamp(value)
 
+    case 'cds.UUID':
+      if (!RELAXED_UUID_REGEX.test(value)) {
+        const msg = `Element "${element.name}" does not contain a valid UUID`
+        throw Object.assign(new Error(msg), { statusCode: 400 })
+      }
+      return value
+
     default:
       return value
   }
@@ -528,6 +538,10 @@ function _processSegments(from, model, namespace, cqn, protocol) {
 
 const AGGR_DFLT = '@Aggregation.default'
 const CSTM_AGGR = '@Aggregation.CustomAggregate'
+const SMTCS_CC = '@Semantics.currencyCode'
+const SMTCS_UOM = '@Semantics.unitOfMeasure'
+const SMTCS_AMT_CC = '@Semantics.amount.currencyCode'
+const SMTCS_AMT_UOM = '@Semantics.amount.unitOfMeasure'
 
 function _addKeys(columns, target) {
   let hasAggregatedColumn = false,
@@ -586,17 +600,20 @@ const _structProperty = (ref, target) => {
 }
 
 function _processColumns(cqn, target, protocol) {
+  // Recursively process columns for nested SELECTs
   if (cqn.SELECT.from.SELECT) _processColumns(cqn.SELECT.from, target)
 
   let columns = cqn.SELECT.columns
 
+  // Error if groupBy is present but no columns are selected
   if (columns && !columns.length && cqn.SELECT.groupBy) {
-    cds.error('Explicit select must include at least one column available in the result set of groupby!', {
+    throw cds.error('Explicit select must include at least one column available in the result set of groupby', {
       code: '400',
       statusCode: 400
     })
   }
 
+  // If columns exist and no groupBy, handle asterisk and expand logic
   if (columns && !cqn.SELECT.groupBy) {
     let entity
     if (target.kind === 'entity') entity = target
@@ -606,32 +623,108 @@ function _processColumns(cqn, target, protocol) {
     _removeUnneededColumnsIfHasAsterisk(columns)
     rewriteExpandAsterisk(columns, entity)
 
-    // in case of odata, add all missing key fields (i.e., not in $select)
+    // For OData, add missing key fields to columns
     if (protocol?.match(/odata/i)) _addKeys(columns, entity)
   }
 
   if (!Array.isArray(columns)) return
 
-  let aggrProp, aggrElem, defaultAggregation
+  // Iterate columns to set default aggregation function if needed
   for (let i = 0; i < columns.length; i++) {
-    if (
-      columns[i].func === null &&
-      columns[i].args &&
-      columns[i].args.length &&
-      columns[i].args[0].ref &&
-      columns[i].args[0].ref.length
-    ) {
-      // REVISIT: also support aggregate(Sales/Amount)?
-      aggrProp = columns[i].args[0].ref[0]
-      aggrElem = target.elements[aggrProp]
-      if (aggrElem && target[`${CSTM_AGGR}#${aggrProp}`] && aggrElem[AGGR_DFLT] && aggrElem[AGGR_DFLT]['#']) {
-        defaultAggregation = aggrElem[AGGR_DFLT]['#'].toLowerCase()
-        if (defaultAggregation === 'count_distinct') defaultAggregation = 'countdistinct'
-        columns[i].func = defaultAggregation
-        columns[i].as = columns[i].as || aggrProp
-      } else {
-        throw new Error(`Default aggregation for property "${aggrProp}" not found`)
+    const processedColumn = columns[i]
+
+    // Skip if column is not an object or has a ref (not an aggregation)
+    if (typeof processedColumn !== 'object' || processedColumn.ref) continue
+
+    if (!processedColumn.args?.length) continue
+    if (!processedColumn.args[0].ref?.length) continue
+    const processedColumnRef = processedColumn.args[0].ref
+
+    // Extract relevant element characteristics
+    let aggregatedPropertyName, aggregatedElement
+    for (let refIdx = 0; refIdx < processedColumnRef.length; refIdx++) {
+      aggregatedPropertyName = processedColumnRef[refIdx]
+      if (aggregatedPropertyName.id) aggregatedPropertyName = aggregatedPropertyName.id
+      if (aggregatedElement && aggregatedElement.isAssociation) target = aggregatedElement._target
+      aggregatedElement = target.elements[aggregatedPropertyName]
+    }
+    const prefixRef = processedColumnRef.slice(0, processedColumnRef.length - 1)
+    const aggregatedElementRef = [...prefixRef, aggregatedPropertyName]
+    const isCurrencyCodeOrUnitOfMeasure = !!(aggregatedElement[SMTCS_CC] || aggregatedElement[SMTCS_UOM])
+    processedColumn.as = processedColumn.as || aggregatedPropertyName
+
+    // Specifically handle aggregating semantic amounts
+    if (isCurrencyCodeOrUnitOfMeasure) {
+      columns[i] = {
+        xpr: [
+          'case',
+          'when',
+          { xpr: [{ func: 'max', args: [{ ref: aggregatedElementRef }] }, '=', { val: null }] },
+          'then',
+          { val: '' },
+          'else',
+          {
+            xpr: [
+              'case',
+              'when',
+              {
+                xpr: [
+                  { func: 'min', args: [{ ref: aggregatedElementRef }] },
+                  '=',
+                  { func: 'max', args: [{ ref: aggregatedElementRef }] }
+                ]
+              },
+              'then',
+              { func: 'min', args: [{ ref: aggregatedElementRef }] },
+              'else',
+              { val: null },
+              'end'
+            ]
+          },
+          'end'
+        ],
+        as: processedColumn.as
       }
+
+      continue
+    }
+
+    // Determine default aggregation function if necessary
+    const customAggregate = target[`${CSTM_AGGR}#${aggregatedPropertyName}`]
+    if (processedColumn.func === null) {
+      processedColumn.func = aggregatedElement?.[AGGR_DFLT]?.['#']?.toLowerCase()
+      if (!customAggregate)
+        throw cds.error(`Result type for custom aggregation of property "${aggregatedPropertyName}" not found`)
+      if (!processedColumn.func)
+        throw cds.error(`Default aggregation for property "${aggregatedPropertyName}" not found`)
+      if (processedColumn.func === 'count_distinct') processedColumn.func = 'countdistinct'
+    }
+
+    // Process Semantics Amount - Currency Code / Unit of Measure - if present
+    const semanticsAmountElementName = aggregatedElement?.[SMTCS_AMT_CC] ?? aggregatedElement?.[SMTCS_AMT_UOM]
+    if (!semanticsAmountElementName) continue
+    if (!target.elements[semanticsAmountElementName])
+      throw cds.error(`Referenced semantics amount element not found: ${semanticsAmountElementName}`)
+    const semanticsAmountElementRef = [...prefixRef, semanticsAmountElementName]
+
+    columns[i] = {
+      xpr: [
+        'case',
+        'when',
+        {
+          xpr: [
+            { func: 'min', args: [{ ref: semanticsAmountElementRef }] },
+            '=',
+            { func: 'max', args: [{ ref: semanticsAmountElementRef }] }
+          ]
+        },
+        'then',
+        { func: processedColumn.func, args: [{ ref: aggregatedElementRef }] },
+        'else',
+        { val: null },
+        'end'
+      ],
+      as: processedColumn.as
     }
   }
 }

package/libx/odata/parse/cqn2odata.js

@@ -598,7 +598,7 @@ const _delete = (cqn, kind, model) => {
   return { method: 'DELETE', path: `${url}${keys}` }
 }
 
-function cqn2odata(cqn, { kind, model, method }) {
+module.exports.cqn2odata = (cqn, { kind, model, method }) => {
   if (cqn.SELECT) return _select(cqn, kind, model)
   if (cqn.INSERT) return _insert(cqn, kind, model)
   if (cqn.UPDATE) return _update(cqn, kind, model, method)
@@ -606,5 +606,3 @@ function cqn2odata(cqn, { kind, model, method }) {
 
   throw new Error('Unknown CQN object cannot be translated to URL: ' + JSON.stringify(cqn))
 }
-
-module.exports = cqn2odata

package/libx/odata/parse/grammar.peggy

@@ -208,7 +208,7 @@
       if (
         (topCqn.columns && topCqn.columns[0].as === '$count') ||
         //In QUERY_WITH_AGGREGATION topCqn.where is a having and thus no further nesting needed
-        (!QUERY_WITH_AGGREGATION && topCqn.where && (cqn.SELECT.where || cqn.SELECT.limit)) ||
+        (!QUERY_WITH_AGGREGATION && topCqn.where && (cqn.SELECT.where || cqn.SELECT.limit)) ||
         (cqn.SELECT.limit && topCqn.limit) ||
         (cqn.SELECT.orderBy && topCqn.orderBy) ||
         (cqn.SELECT.search && topCqn.search)
@@ -712,6 +712,8 @@
   = (
       c:('*' / ref) {
         const col = c === '*' ? {} : c
+        if (col.ref?.length > 1) throw Object.assign(new Error(`navigation "${col.ref.join('/')}" in "$expand" is not supported`), { statusCode: 400 })
+
         col.expand = ['*']
         if (!Array.isArray(SELECT.expand)) SELECT.expand = []
         if (!SELECT.expand.find(_compareRefs(col))) SELECT.expand.push(col)
@@ -986,7 +988,7 @@
       // Loop through each element, add it to current level, if element is already part of result, increase level
       for(let trafos of additionalTransformation) {
         for(const transformation in trafos) {
-          if (transformation === 'where' && (mainTransformation.groupBy || mainTransformation.aggregate) && !mainTransformation.having) {
+          if (transformation === 'where' && (mainTransformation.groupBy || mainTransformation.aggregate) && !mainTransformation.having) {
             //When a group by or aggregate preceed a where, the where is a having
             mainTransformation.having = trafos[transformation]
           }