@sap/cds 9.2.1 → 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/rest/middleware/parse.js

@@ -23,7 +23,7 @@ exports.parse = function (req, res, next) {
   if (typeof definition === 'string') {
     definition =
       service.model.definitions[definition] ||
-      service.model.definitions[definition.split(':$:')[0]].actions[definition.split(':$:')[1]]
+      service.model.definitions[definition.split(':$:')[0]].actions?.[definition.split(':$:')[1]]
   }
   delete query.__target
 
@@ -79,7 +79,14 @@ exports.parse = function (req, res, next) {
         }
         cds.error(errorMsg, { code: 400 })
       }
-      if (!one) throw { statusCode: 400, code: '400', message: `INVALID_${req.method}` }
+      if (!one) {
+      if (req.method === 'PATCH') throw cds.error ({ status: 405, code: `INVALID_${req.method}` })
+        const entity = definition, keys = {}, data = req.body || {}
+        for (let k in entity.keys) keys[k] = data[k]
+          || entity.keys[k]['@cds.on.insert']?.['='] === '$user' && cds.context?.user?.id
+          || cds.error ({ status: 405, code: `INVALID_${req.method}` })
+        from.ref[0] = { id: from.ref[0], where: cds.ql.predicate (keys) }
+      }
       query = UPDATE(_target)
       break
     case 'DELETE':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "9.2.1",
+  "version": "9.3.0",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -32,7 +32,7 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@sap/cds-compiler": "^6",
+    "@sap/cds-compiler": "^6.1",
     "@sap/cds-fiori": "^2",
     "js-yaml": "^4.1.0"
   },

package/server.js

@@ -36,6 +36,8 @@ module.exports = async function cds_server (options) {
   }
 
   const app = cds.app = o.app || express()
+  // disable x-powered-by on express instance created by us
+  if (process.env.NODE_ENV === 'production' && !o.app) app.disable('x-powered-by')
   cds.emit ('bootstrap', app)
 
   // mount static resources and cors middleware

package/srv/app-service.js

@@ -0,0 +1 @@
+module.exports = require('../libx/_runtime/common/Service')

package/srv/db-service.js

@@ -0,0 +1 @@
+module.exports = require('@cap-js/db-service').DatabaseService

package/srv/msg-service.js

@@ -0,0 +1 @@
+module.exports = require('../libx/_runtime/messaging/service')

package/srv/remote-service.js

@@ -0,0 +1 @@
+module.exports = require('../libx/_runtime/remote/Service')

package/srv/ucl-service.cds

@@ -0,0 +1,32 @@
+@rest
+@path    : '/ucl/spii/v1'
+@requires: 'any'
+@impl    : '@sap/cds/srv/ucl-service.js'
+service UCLService {
+  @open
+  @cds.persistence.skip
+  entity tenantMappings {
+    key tenantId       : String;
+        context        : Map;
+        receiverTenant : Map;
+        assignedTenant : Map;
+  }
+
+/*
+  action assign(tenantId: String, context: Map, receiverTenant: Map, assignedTenant: Map)   returns {
+    state         : String enum {
+      CONFIG_PENDING = 'CONFIG_PENDING';
+      READY = 'READY';
+    };
+    configuration : Map;
+  };
+*/
+
+/*
+  action unassign(tenantId: String, context: Map, receiverTenant: Map, assignedTenant: Map) returns {
+    state         : String enum {
+      READY = 'READY';
+    }
+  };
+*/
+}

package/srv/ucl-service.js

@@ -0,0 +1 @@
+module.exports = require('../libx/_runtime/ucl/Service')

package/lib/ql/resolve.js

@@ -1,45 +0,0 @@
-const { resolveView, getTransition } = require('../../libx/_runtime/common/utils/resolveView')
-const cds = require('..')
-
-const PERSISTENCE_TABLE = '@cds.persistence.table'
-const _isPersistenceTable = target =>
-  Object.prototype.hasOwnProperty.call(target, PERSISTENCE_TABLE) && target[PERSISTENCE_TABLE]
-
-// REVISIT revert after cds-dbs pr
-// REVISIT: Remove once we get rid of old db
-const _abortDB = resolve.abortDB = target => !!(_isPersistenceTable(target)|| !target.query?._target)
-// _service seems to be inherited in projections, so do not consider prototype chain
-const _defaultAbort = tx => e => e._service?.name === tx.definition?.name
-
-function resolve(query, tx, abortCondition) {
-  const ctx = cds.context
-  const abort = abortCondition ?? (typeof tx === 'function' ? tx : undefined)
-  const _tx = typeof tx === 'function' ? ctx?.tx : tx
-  const model = ctx?.model ?? _tx.model
-
-  return resolveView(query, model, _tx, abort || _defaultAbort(_tx))
-}
-
-resolve.resolve4db = (query, tx) => resolve(query, tx, _abortDB)
-
-// REVISIT: Remove once we get rid of composition tree
-resolve.table = target => {
-  if (target.query?._target && !_isPersistenceTable(target)) {
-    return resolve.table(target.query._target)
-  }
-  return target
-}
-
-// REVISIT: Remove argument `skipForbiddenViewCheck` once we get rid of composition tree
-resolve.transitions = (query, tx, abortCondition, skipForbiddenViewCheck) => {
-  const target = query && typeof query === 'object' ? cds.infer.target(query) || query?._target : undefined
-  const abort = abortCondition ?? (typeof tx === 'function' ? tx : undefined)
-  const _tx = typeof tx === 'function' ? cds.context?.tx : tx
-  return getTransition(target, _tx, skipForbiddenViewCheck, undefined, {
-    abort: abort ?? (tx.isDatabaseService ? _abortDB : _defaultAbort(tx))
-  })
-}
-
-resolve.transitions4db = (query, tx, skipForbiddenViewCheck) => resolve.transitions(query, tx, _abortDB, skipForbiddenViewCheck)
-
-module.exports = resolve

package/libx/common/assert/type-strict.js

@@ -1,109 +0,0 @@
-const { cds } = global
-
-const { Readable } = require('stream')
-
-const { getNormalizedDecimal, getTarget, isBase64String } = require('./utils')
-
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i //> "i" is acutally not OK, but we'll leave as is for now to avoid breaking changes
-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
-
-const ISO_DATE_PART1 =
-  '[1-9]\\d{3}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1\\d|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)'
-const ISO_DATE_PART2 = '(?:[1-9]\\d(?:0[48]|[2468][048]|[13579][26])|(?:[2468][048]|[13579][26])00)-02-29'
-const ISO_DATE = `(?:${ISO_DATE_PART1}|${ISO_DATE_PART2})`
-const ISO_TIME_NO_MILLIS = '(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d'
-const ISO_TIME = `${ISO_TIME_NO_MILLIS}(?:\\.\\d{1,9})?`
-const ISO_DATE_TIME = `${ISO_DATE}T${ISO_TIME_NO_MILLIS}(?:Z|[+-][01]\\d:?[0-5]\\d)`
-const ISO_TIMESTAMP = `${ISO_DATE}T${ISO_TIME}(?:Z|[+-][01]\\d:?[0-5]\\d)`
-const ISO_DATE_REGEX = new RegExp(`^${ISO_DATE}$`, 'i')
-const ISO_TIME_NO_MILLIS_REGEX = new RegExp(`^${ISO_TIME_NO_MILLIS}$`, 'i')
-const ISO_DATE_TIME_REGEX = new RegExp(`^${ISO_DATE_TIME}$`, 'i')
-const ISO_TIMESTAMP_REGEX = new RegExp(`^${ISO_TIMESTAMP}$`, 'i')
-
-const _checkString = value => typeof value === 'string'
-
-const _checkNumber = value => typeof value === 'number' && !Number.isNaN(value)
-
-const _oldCheckDecimal = (value, element) => {
-  const [left, right] = String(value).split('.')
-  return (
-    _checkNumber(value) &&
-    (!element.precision || left.length <= element.precision - (element.scale || 0)) &&
-    (!element.scale || ((right || '').length <= element.scale && parseFloat(right) !== 0))
-  )
-}
-
-// REVISIT: only use a cheaper check if not in strictDecimal mode?
-const _checkDecimal = (v, ele, errs, path, k) => {
-  if (!errs) return _oldCheckDecimal(v, ele)
-
-  const { precision, scale } = ele
-  let val = getNormalizedDecimal(v)
-  if (precision != null && scale != null) {
-    let isValid = true
-    if (!val.match(/\./)) val += '.0'
-    if (precision === scale) {
-      if (!val.match(new RegExp(`^-?0\\.\\d{0,${scale}}$`, 'g'))) isValid = false
-    } else if (scale === 0) {
-      if (!val.match(new RegExp(`^-?\\d{1,${precision - scale}}\\.0{0,1}$`, 'g'))) isValid = false
-    } else if (!val.match(new RegExp(`^-?\\d{1,${precision - scale}}\\.\\d{0,${scale}}$`, 'g'))) {
-      isValid = false
-    }
-    if (!isValid) {
-      const args = [v, `Decimal(${precision},${scale})`]
-      const target = getTarget(path, k)
-      errs.push(new cds.error('ASSERT_DATA_TYPE', { args, target, statusCode: 400, code: '400' }))
-    }
-  } else if (precision != null) {
-    if (!val.match(new RegExp(`^-?\\d{1,${precision}}$`, 'g'))) {
-      const args = [v, `Decimal(${precision})`]
-      const target = getTarget(path, k)
-      errs.push(new cds.error('ASSERT_DATA_TYPE', { args, target, statusCode: 400, code: '400' }))
-    }
-  }
-}
-
-const _checkInt = value => _checkNumber(value) && parseInt(value, 10) === value
-
-const _checkInt64 = value => typeof value === 'string' ? value.match(/^\d+$/) : _checkInt(value)
-
-const _checkBoolean = value => typeof value === 'boolean'
-
-const _checkBuffer = value => Buffer.isBuffer(value) || value.type === 'Buffer' || isBase64String(value)
-
-const _checkStreamOrBuffer = value => value instanceof Readable || _checkBuffer(value)
-
-const _checkUUID = value => _checkString(value) && UUID_REGEX.test(value)
-
-const _checkRelaxedUUID = value => _checkString(value) && RELAXED_UUID_REGEX.test(value)
-
-const _checkISODate = value => (_checkString(value) && ISO_DATE_REGEX.test(value)) || value instanceof Date
-
-const _checkISOTime = value => _checkString(value) && ISO_TIME_NO_MILLIS_REGEX.test(value)
-
-const _checkISODateTime = value => (_checkString(value) && ISO_DATE_TIME_REGEX.test(value)) || value instanceof Date
-
-const _checkISOTimestamp = value => (_checkString(value) && ISO_TIMESTAMP_REGEX.test(value)) || value instanceof Date
-
-module.exports = {
-  'cds.UUID': _checkUUID,
-  'relaxed.UUID': _checkRelaxedUUID,
-  'cds.Boolean': _checkBoolean,
-  'cds.Integer': _checkInt,
-  'cds.UInt8': _checkInt,
-  'cds.Int16': _checkInt,
-  'cds.Int32': _checkInt,
-  'cds.Integer64': _checkInt64,
-  'cds.Int64': _checkInt64,
-  'cds.Decimal': _checkDecimal,
-  'cds.DecimalFloat': _checkNumber,
-  'cds.Double': _checkNumber,
-  'cds.Date': _checkISODate,
-  'cds.Time': _checkISOTime,
-  'cds.DateTime': _checkISODateTime,
-  'cds.Timestamp': _checkISOTimestamp,
-  'cds.String': _checkString,
-  'cds.Binary': _checkBuffer,
-  'cds.LargeString': _checkString,
-  'cds.LargeBinary': _checkStreamOrBuffer
-}

package/libx/common/assert/utils.js

@@ -1,60 +0,0 @@
-const getNormalizedDecimal = val => {
-  let v = `${val}`
-  const cgs = v.match(/^(\d*\.*\d*)e([+|-]*)(\d*)$/)
-  if (cgs) {
-    let [l, r = ''] = cgs[1].split('.')
-    const dir = cgs[2] || '+'
-    const exp = Number(cgs[3])
-    if (dir === '+') {
-      // move decimal point to the right
-      r = r.padEnd(exp, '0')
-      l += r.substring(0, exp)
-      r = r.slice(exp)
-      v = `${l}${r ? '.' + r : ''}`
-    } else {
-      // move decimal point to the left
-      l = l.padStart(exp, '0')
-      r = l.substring(0, exp) + r
-      l = l.slice(exp)
-      v = `${l ? l : '0'}.${r}`
-    }
-  }
-  return v
-}
-
-function getTarget(path, k) {
-  return path.length && path[path.length - 1].match(/\[\d+\]$/) ? path.join('/') : path.concat(k).join('/')
-}
-
-// non-strict mode also allows url-safe base64 strings
-function isBase64String(string, strict = false) {
-  if (typeof string !== 'string') return false
-
-  if (strict && string.length % 4 !== 0) return false
-
-  let length = string.length
-  if (string.endsWith('==')) length -= 2
-  else if (string.endsWith('=')) length -= 1
-
-  let char
-  for (let i = 0; i < length; i++) {
-    char = string[i]
-    if (char >= 'A' && char <= 'Z') continue
-    else if (char >= 'a' && char <= 'z') continue
-    else if (char >= '0' && char <= '9') continue
-    else if (char === '+' || char === '/') continue
-    else if (!strict && (char === '-' || char === '_')) continue
-    return false
-  }
-
-  return true
-}
-
-
-
-
-module.exports = {
-  getNormalizedDecimal,
-  getTarget,
-  isBase64String
-}