@sap/cds 5.8.4 → 5.9.2

package/libx/_runtime/remote/utils/client.js

@@ -3,8 +3,6 @@ const LOG = cds.log('remote')
 
 const SANITIZE_VALUES = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
 
-const cdsLocale = require('../../../../lib/req/locale')
-
 const { convertV2ResponseData, deepSanitize, convertV2PayloadData } = require('./data')
 
 let _cloudSdkCore
@@ -249,10 +247,11 @@ const run = async (
 
     const sanitizedError = _getSanitizedError(e, requestConfig, suppressRemoteResponseBody)
 
-    LOG._warn && LOG.warn(sanitizedError)
-
     // REVISIT: switch from innererror to reason in cds^6
-    throw Object.assign(new Error(e.message), { statusCode: 502, innererror: sanitizedError })
+    const err = Object.assign(new Error(e.message), { statusCode: 502, innererror: sanitizedError })
+    LOG._warn && LOG.warn(err)
+
+    throw err
   }
 
   // text/html indicates a redirect -> reject
@@ -271,13 +270,15 @@ const run = async (
 
     const sanitizedError = _getSanitizedError(e, requestConfig, suppressRemoteResponseBody)
 
-    LOG._warn && LOG.warn(sanitizedError)
-
     // REVISIT: switch from innererror to reason in cds^6
-    throw Object.assign(new Error(`Error during request to remote service: ${e.message}`), {
+    const err = Object.assign(new Error(`Error during request to remote service: ${e.message}`), {
       statusCode: 502,
       innererror: sanitizedError
     })
+
+    LOG._warn && LOG.warn(err)
+
+    throw err
   }
 
   // get result of $batch
@@ -300,10 +301,13 @@ const run = async (
         ? 'Error during request to remote service: ' + contentJSON.message
         : 'Request to remote service failed.'
       const sanitizedError = _getSanitizedError(contentJSON, requestConfig)
-      LOG._warn && LOG.warn(sanitizedError)
+
+      const err = Object.assign(new Error(contentJSON.message), { statusCode: 502, innererror: sanitizedError })
+
+      LOG._warn && LOG.warn(err)
 
       // REVISIT: switch from innererror to reason in cds^6
-      throw Object.assign(new Error(contentJSON.message), { statusCode: 502, innererror: sanitizedError })
+      throw err
     }
   }
 
@@ -335,12 +339,10 @@ const _cqnToReqOptions = (query, kind, model, target) => {
   const queryObject = cds.odata.urlify(query, { kind, model })
   const reqOptions = {
     method: queryObject.method,
-    url: encodeURI(
-      queryObject.path
-        // ugly workaround for Okra not allowing spaces in ( x eq 1 )
-        .replace(/\( /g, '(')
-        .replace(/ \)/g, ')')
-    )
+    url: queryObject.path
+      // ugly workaround for Okra not allowing spaces in ( x eq 1 )
+      .replace(/\( /g, '(')
+      .replace(/ \)/g, ')')
   }
   if (queryObject.method !== 'GET' && queryObject.method !== 'HEAD') {
     reqOptions.data = kind === 'odata-v2' ? convertV2PayloadData(queryObject.body, target) : queryObject.body
@@ -399,9 +401,7 @@ const getReqOptions = (req, query, service) => {
   if (!_hasHeader(req.headers, 'accept-language')) {
     // Forward the locale properties from the original request (including region variants or weight factors),
     // if not given, it's taken from the user's locale (normalized and simplified)
-    const locale =
-      (req.context && req.context._ && req.context._.req && cdsLocale.from_req(req.context._.req)) ||
-      (req.user && req.user.locale)
+    const locale = req._locale
     if (locale) reqOptions.headers['accept-language'] = locale
   }
 
@@ -442,6 +442,11 @@ const getReqOptions = (req, query, service) => {
 
   if (service.path) reqOptions.url = `${encodeURI(service.path)}${reqOptions.url}`
 
+  // set axios responseType to 'arraybuffer' if returning binary in rest
+  if (req._binary) {
+    reqOptions.responseType = 'arraybuffer'
+  }
+
   return reqOptions
 }
 

package/libx/_runtime/remote/utils/data.js

@@ -60,15 +60,15 @@ const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, elemen
 
   const type = _elementType(element)
 
-  if (['cds.Boolean'].includes(type)) {
+  if (type === 'cds.Boolean') {
     if (value === 'true') {
       value = true
     } else if (value === 'false') {
       value = false
     }
-  } else if (['cds.Integer'].includes(type)) {
+  } else if (type === 'cds.Integer') {
     value = parseInt(value, 10)
-  } else if (['cds.Decimal', 'cds.Integer64', 'cds.DecimalFloat'].includes(type)) {
+  } else if (type === 'cds.Decimal' || type === 'cds.DecimalFloat' || type === 'cds.Integer64') {
     const bigValue = big(value)
     if (ieee754Compatible) {
       // TODO test with arrayed => element.items.scale?
@@ -77,15 +77,15 @@ const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, elemen
       // OData V2 does not even mention ieee754Compatible, but V4 requires JSON number if ieee754Compatible=false
       value = bigValue.toNumber()
     }
-  } else if (['cds.Double'].includes(type)) {
+  } else if (type === 'cds.Double') {
     value = parseFloat(value)
-  } else if (['cds.Time'].includes(type)) {
+  } else if (type === 'cds.Time') {
     const match = value.match(DurationRegex)
 
     if (match) {
       value = `${match[4] || '00'}:${match[5] || '00'}:${match[6] || '00'}`
     }
-  } else if (['cds.Date', 'cds.DateTime', 'cds.Timestamp'].includes(type)) {
+  } else if (type === 'cds.Timestamp' || type === 'cds.DateTime' || type === 'cds.Date') {
     const match = value.match(/\/Date\((.*)\)\//)
     const ticksAndOffset = match && match.pop()
 
@@ -93,9 +93,9 @@ const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, elemen
       value = new Date(_calculateTicksOffsetSum(ticksAndOffset)).toISOString() // always UTC
     }
 
-    if (['cds.DateTime'].includes(type)) {
+    if (type === 'cds.DateTime') {
       value = value.slice(0, 19) + 'Z' // Cut millis
-    } else if (['cds.Date'].includes(type)) {
+    } else if (type === 'cds.Date') {
       value = value.slice(0, 10) // Cut time
     }
   }
@@ -136,15 +136,15 @@ const _elementType = element => {
   let type
 
   if (element) {
-    type = element.type
+    type = element._type
 
     if (element['@odata.Type']) {
       const odataType = element['@odata.Type'].match(/\w+$/)
       type = (odataType && DataTypeOData[odataType[0]]) || type
     }
 
-    if (!type && element.items && element.items.type) {
-      type = element.items.type
+    if (!type && element.items && element.items._type) {
+      type = element.items._type
     }
   }
 

package/libx/_runtime/sqlite/Service.js

@@ -91,17 +91,12 @@ module.exports = class SQLiteDatabase extends DatabaseService {
 
   _registerAfterHandlers() {
     // REVISIT: after phase runs in parallel -> side effects possible!
-    const { effective } = cds.env
+    const { effective, features } = cds.env
 
-    if (effective.odata.structs) {
+    if (effective.odata.structs && !features.ucsn_struct_conversion) {
       // REVISIT: only register for entities that contain structured or navigation to it
       this.after(['READ'], '*', this._structured)
     }
-
-    if (effective.odata.version !== 'v2') {
-      // REVISIT: only register for entities that contain arrayed or navigation to it
-      this.after(['READ'], '*', this._arrayed)
-    }
   }
 
   /*
@@ -110,7 +105,9 @@ module.exports = class SQLiteDatabase extends DatabaseService {
   async acquire(arg) {
     // in non-multi-tenant scenarios, the default db should be returned regardless of arg
     let tenant = 'anonymous'
-    if (this.options.multiTenant && arg) {
+    const isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
+    // REVISIT: there should already be compat for the multitenancy flag, why is it not working here?
+    if (isMultitenant && arg) {
       if (typeof arg === 'string') tenant = arg
       else tenant = arg.tenant || (arg.user && arg.user.tenant) || tenant // > REVISIT: remove fallback arg.user.tenant with cds^6
     }
@@ -120,7 +117,7 @@ module.exports = class SQLiteDatabase extends DatabaseService {
       const credentials = this.options.credentials || this.options || {}
       let dbUrl = credentials.database || credentials.url || credentials.host || ':memory:'
 
-      if (this.options.multiTenant && dbUrl.endsWith('.db')) {
+      if (isMultitenant && dbUrl.endsWith('.db')) {
         dbUrl = dbUrl.split('.db')[0] + '_' + tenant + '.db'
       }
 

package/libx/_runtime/sqlite/customBuilder/CustomFunctionBuilder.js

@@ -8,7 +8,10 @@ const dateTimeFunctions = new Map([
   ['hour', "'%H'"],
   ['minute', "'%M'"]
 ])
-const standadFunctions = ['locate', 'substring', 'to_date', 'to_time']
+const STANDAD_FUNCTIONS_MAP = ['locate', 'substring', 'to_date', 'to_time'].reduce((acc, cur) => {
+  acc[cur] = 1
+  return acc
+}, {})
 
 class CustomFunctionBuilder extends FunctionBuilder {
   get ExpressionBuilder() {
@@ -35,7 +38,7 @@ class CustomFunctionBuilder extends FunctionBuilder {
 
     if (dateTimeFunctions.has(functionName)) {
       this._timeFunction(functionName, args)
-    } else if (standadFunctions.includes(functionName)) {
+    } else if (functionName in STANDAD_FUNCTIONS_MAP) {
       this._standardFunction(functionName, args)
     } else if (functionName === 'seconds_between') {
       this._secondsBetweenFunction(args)

package/libx/_runtime/types/api.js

@@ -49,7 +49,7 @@
  * @typedef {object} TemplateProcessorPathOptions
  * @property {object} [extraKeys]
  * @property {function} [rowKeysGenerator]
- * @property {string[]} [segments=[]] - Path segments to relate the error message.
+ * @property {pathSegment[]} [path=[]] - Path segments to relate the error message.
  * @property {boolean} [includeKeyValues=false] Indicates whether the key values are included in the path segments
  * The path segments are used to build the error target (a relative resource path)
  */
@@ -70,7 +70,14 @@
  * @property {object} element
  * @property {boolean} plain
  * @property {boolean} isRoot
- * @property {Array<String>} [pathSegments]
+ * @property {Array<pathSegment>} [path]
+ */
+
+/**
+ * @typedef {object} pathSegment
+ * @property {string} key
+ * @property {number} idx
+ * @property {string} url
  */
 
 // Search
@@ -102,6 +109,7 @@
  * @typedef {object} cqn2cqn4sqlOptions
  * @property {boolean} [suppressSearch=false] Indicates whether the search handler is called.
  * @property {boolean} [_4fiori]
+ * @property {boolean} [_4db]
  * @property {import('../db/Service')} [service]
  */
 

package/libx/common/utils/ucsn.js

@@ -0,0 +1,109 @@
+const cds = require('../../_runtime/cds')
+const getTemplate = require('../../_runtime/common/utils/template')
+const templateProcessor = require('../../_runtime/common/utils/templateProcessor')
+const IS_PROXY = Symbol('flat2structProxy')
+
+const proxifyIfFlattened = (definition, payload) => {
+  if (!definition || !definition._flat2struct || payload == null || payload[IS_PROXY]) return payload
+  return Object.setPrototypeOf(
+    payload,
+    new Proxy(
+      {},
+      {
+        get: function (_, k, cur) {
+          if (k === IS_PROXY) return true
+          if (!definition._flat2struct[k]) return Reflect.get(...arguments)
+          const segments = definition._flat2struct[k]
+          for (let i = 0; i < segments.length - 1; i++) {
+            cur = cur[segments[i]]
+            if (!cur) return cur
+          }
+          return cur[segments[segments.length - 1]]
+        },
+        set: function (_, k, v, o) {
+          let cur = o
+          if (definition._flat2struct[k]) {
+            const segments = definition._flat2struct[k]
+            for (let i = 0; i < segments.length - 1; i++) {
+              if (!cur[segments[i]]) {
+                cur[segments[i]] = {}
+              }
+              cur = cur[segments[i]]
+            }
+            cur[segments[segments.length - 1]] = v
+          } else if (k === IS_PROXY) {
+            // do nothing
+          } else {
+            Reflect.set(...arguments)
+          }
+          return o
+        }
+      }
+    )
+  )
+}
+
+const _picker = element => {
+  if (Array.isArray(element)) return { category: 'flat leaf' }
+  if (element.isAssociation) return { category: 'node' }
+}
+
+const _processor = ({ row, key, plain: { category }, element }) => {
+  if (!(key in row)) return
+  if (category === 'node') {
+    row[key] = Array.isArray(row[key])
+      ? row[key].map(data => proxifyIfFlattened(element._target, data))
+      : proxifyIfFlattened(element._target, row[key])
+  } else if (category === 'flat leaf') {
+    const data = row[key]
+    delete row[key]
+    row[key] = data
+  }
+}
+
+const _cleanup = (row, definition, cleanupNull) => {
+  if (!row || !definition) return
+  const elements = definition.elements || definition.params
+  for (const key of Object.keys(row)) {
+    const element = elements[key]
+    if (!element) {
+      if (!definition['@open']) delete row[key]
+      continue
+    }
+    if (!row[key]) continue
+    if (element.isAssociation) {
+      if (element.is2many) {
+        for (const r of row[key]) {
+          _cleanup(r, element._target, cleanupNull)
+        }
+      } else {
+        _cleanup(row[key], element._target, cleanupNull)
+      }
+    } else if (element.elements) {
+      _cleanup(row[key], element, cleanupNull)
+      if (cleanupNull && Object.values(row[key]).every(v => v == null)) row[key] = null
+    }
+  }
+}
+
+function convertStructured(service, definition, data, { cleanupNull = false } = {}) {
+  if (!definition) return
+  // REVISIT check `structs` mode only for now as uCSN is not yet available
+  const flatAccess = cds.env.features.compat_flat_access
+  const template = getTemplate('universal-input', service, definition, { pick: _picker, flatAccess })
+  const arrayData = Array.isArray(data) ? data : [data]
+  if (template && template.elements.size) {
+    for (let i = 0; i < arrayData.length; i++) {
+      const row = proxifyIfFlattened(definition, arrayData[i])
+      templateProcessor({ processFn: _processor, row, template, pathOptions: { path: [] } })
+    }
+  }
+  for (const row of arrayData) {
+    _cleanup(row, definition, cleanupNull)
+  }
+}
+
+module.exports = {
+  convertStructured,
+  proxifyIfFlattened
+}

package/libx/gql/resolvers/crud/update.js

@@ -29,6 +29,11 @@ module.exports = async (service, entityFQN, selection) => {
     cds.context = tx
     // read needs to be done before the update, otherwise the where clause might become invalid (case that properties in where clause are updated by the mutation)
     resultBeforeUpdate = await tx.run(queryBeforeUpdate)
+
+    if (resultBeforeUpdate.length === 0) {
+      return []
+    }
+
     return tx.run(query)
   })
 

package/libx/gql/resolvers/parse/ast2cqn/columns.js

@@ -14,7 +14,9 @@ const astToColumns = selections => {
     }
 
     if (selection.selectionSet && selection.selectionSet.selections) {
-      column.expand = astToColumns(selection.selectionSet.selections)
+      const columns = astToColumns(selection.selectionSet.selections)
+      // columns is empty if only __typename was selected (which was filtered out in the enriched AST)
+      column.expand = columns.length > 0 ? columns : ['*']
     }
 
     const filter = getArgumentByName(selection.arguments, ARGUMENT.FILTER)

package/libx/gql/schema/typeDefMap.js

@@ -30,8 +30,8 @@ const servicesToTypeDefMap = services => {
           // TODO structured types
           continue
         } else {
-          if (CDS_TO_GRAPHQL_TYPES[ele.type]) {
-            def[ele.name] = CDS_TO_GRAPHQL_TYPES[ele.type]
+          if (CDS_TO_GRAPHQL_TYPES[ele._type]) {
+            def[ele.name] = CDS_TO_GRAPHQL_TYPES[ele._type]
           }
           // TODO aspects
         }

package/libx/odata/afterburner.js

@@ -3,10 +3,20 @@ const cds = require('../_runtime/cds')
 const { where2obj } = require('../_runtime/common/utils/cqn')
 const { findCsnTargetFor } = require('../_runtime/common/utils/csn')
 
-const _addKeysDeep = (keys, keysCollector) => {
+const _addKeysDeep = (keys, keysCollector, ignoreManagedBacklinks) => {
   for (const keyName in keys) {
     const key = keys[keyName]
-    if (key.type === 'cds.Association' || key['@odata.foreignKey4'] === 'up_') continue
+    const foreignKey = key._foreignKey4
+    if (key.isAssociation || foreignKey === 'up_' || key['@cds.api.ignore'] === true) continue
+
+    if (ignoreManagedBacklinks && foreignKey) {
+      const navigationElement = keys[foreignKey]
+      if (!navigationElement.on && navigationElement._isBacklink) {
+        // skip navigation elements that are backlinks
+        continue
+      }
+    }
+
     if ('elements' in key) {
       _addKeysDeep(key.elements, keysCollector)
       continue
@@ -15,10 +25,10 @@ const _addKeysDeep = (keys, keysCollector) => {
   }
 }
 
-function _keysOf(entity) {
+function _keysOf(entity, ignoreManagedBacklinks) {
   if (!entity || !entity.keys) return
   const keysCollector = []
-  _addKeysDeep(entity.keys, keysCollector)
+  _addKeysDeep(entity.keys, keysCollector, ignoreManagedBacklinks)
   return keysCollector
 }
 
@@ -31,18 +41,47 @@ function _getDefinition(definition, name, namespace) {
   )
 }
 
+function _resolveAliasInParams(params, entity) {
+  if (!entity._alias2ref) return
+  const paramKeys = Object.keys(params)
+  for (const paramKey of paramKeys) {
+    if (entity._alias2ref[paramKey]) {
+      params[entity._alias2ref[paramKey].join('_')] = params[paramKey]
+      params[paramKey] = undefined
+    }
+  }
+}
+
 function _resolveAliasInWhere(where, entity) {
   if (!entity._alias2ref) return
-  for (let i = 0; i < where.length; i++) {
-    if (!where[i].ref || where[i].ref.length > 1 || entity.keys[where[i].ref[0]]) continue
-    where[i].ref = entity._alias2ref[where[i].ref[0]] || where[i].ref
+  for (const w of where) {
+    if (!w.ref || w.ref.length > 1 || entity.keys[w.ref[0]]) continue
+    w.ref = entity._alias2ref[w.ref[0]] || w.ref
+  }
+}
+
+function _addDefaultParams(ref, view) {
+  const params = view.params
+  const defaults = params && Object.values(params).filter(p => p.default)
+  if (defaults && defaults.length > 0) {
+    if (!ref.where) ref.where = []
+    for (const def of defaults) {
+      if (ref.where.find(e => e.ref && e.ref[0] === def.name)) {
+        continue
+      }
+      if (ref.where.length > 0) ref.where.push('and')
+      ref.where.push({ ref: [def.name] }, '=', { val: def.default.val })
+    }
   }
 }
 
 // case: single key without name, e.g., Foo(1)
 function addRefToWhereIfNecessary(where, entity) {
   if (!where || where.length !== 1) return 0
-  const keys = _keysOf(entity)
+
+  const isView = !!entity.params
+
+  const keys = isView ? Object.keys(entity.params) : _keysOf(entity)
   if (keys.length !== 1) return 0
   where.unshift(...[{ ref: [keys[0]] }, '='])
   return 1
@@ -64,13 +103,14 @@ function _processSegments(cqn, model, namespace) {
 
     if (incompleteKeys) {
       // > key
-      keys = keys || _keysOf(current)
-      const key = keys[keyCount++]
+      keys = keys || _keysOf(current, !cds.env.features.rest_new_adapter && !cds.env.features.rest_new_parser) // if odata skip backlinks as key as they are used from structure
+      let key = keys[keyCount++]
       one = true
       const element = current.elements[key]
       let base = ref[i - keyCount]
       if (!base.id) base = { id: base, where: [] }
       if (base.where.length) base.where.push('and')
+
       if (ref[i].id) {
         // > fix case key value parsed to collection with filter
         const val = `${ref[i].id}(${Object.keys(params)
@@ -78,7 +118,7 @@ function _processSegments(cqn, model, namespace) {
           .join(',')})`
         base.where.push({ ref: [key] }, '=', { val })
       } else {
-        base.where.push({ ref: [key] }, '=', { val: element.type === 'cds.Integer' ? Number(seg) : seg })
+        base.where.push({ ref: [key] }, '=', { val: element._type === 'cds.Integer' ? Number(seg) : seg })
       }
       ref[i] = null
       ref[i - keyCount] = base
@@ -95,13 +135,40 @@ function _processSegments(cqn, model, namespace) {
       // REVISIT: 404 or 400?
       if (!current) cds.error(`Invalid resource path "${path}"`, { code: 404 })
 
-      if (current.kind === 'entity') {
+      if (current.params && current.kind === 'entity') {
+        // > View with params
+        if (ref[i].where) {
+          keyCount += addRefToWhereIfNecessary(ref[i].where, current)
+          _resolveAliasInWhere(ref[i].where, current)
+          _resolveAliasInParams(params, current)
+        }
+
+        _addDefaultParams(ref[i], current)
+        if ((!params || !Object.keys(params).length) && ref[i].where) params = where2obj(ref[i].where)
+
+        _checkAllKeysProvided(params, current)
+
+        ref[i].args = {}
+        for (let j = 0; j < ref[i].where.length; j++) {
+          const w = ref[i].where[j]
+          if (w === 'and' || !w.ref) continue
+          ref[i].args[w.ref[0]] = ref[i].where[j + 2]
+          j += 2
+        }
+        ref[i].where = undefined
+        if (ref[i + 1] !== 'Set') {
+          // /Set is missing
+          throw new Error(`Incorrect call to a view with parameter "${current.name}"`)
+        }
+        ref[++i] = null
+      } else if (current.kind === 'entity') {
         // > entity
         one = !!(ref[i].where || current._isSingleton)
         incompleteKeys = ref[i].where ? false : i === ref.length - 1 || one ? false : true
         if (ref[i].where) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
           _resolveAliasInWhere(ref[i].where, current)
+          _resolveAliasInParams(params, current)
           // in case of Foo(1), params will be {} (before addRefToWhereIfNecessary was called)
           if (!Object.keys(params).length) params = where2obj(ref[i].where)
           _checkAllKeysProvided(params, current)
@@ -114,7 +181,7 @@ function _processSegments(cqn, model, namespace) {
         }
         ref[i] = { operation: current.name }
         if (params) ref[i].args = params
-        if (current.returns && current.returns.type) one = true
+        if (current.returns && current.returns._type) one = true
       } else if (current.isAssociation) {
         // > navigation
         one = !!(current.is2one || ref[i].where)
@@ -161,11 +228,38 @@ function _processSegments(cqn, model, namespace) {
 const _resolveFrom = from => (from.SELECT ? _resolveFrom(from.SELECT.from) : from)
 
 const _checkAllKeysProvided = (params, entity) => {
-  const keysOfEntity = _keysOf(entity)
+  let keysOfEntity
+  const isView = !!entity.params
+  if (isView) {
+    // view with params
+    if (params === undefined) {
+      throw new Error(`Incorrect call to a view with parameter "${entity.name}"`)
+    } else if (Object.keys(params).length === 0) {
+      throw new Error('KEY_EXPECTED')
+    }
+
+    keysOfEntity = Object.keys(entity.params)
+  } else {
+    keysOfEntity = _keysOf(entity)
+  }
+
   if (!keysOfEntity) return
   for (const keyOfEntity of keysOfEntity) {
-    if (!(keyOfEntity in params))
-      throw Object.assign(new Error(`Key "${keyOfEntity}" is missing for entity "${entity.name}"`), { status: 400 })
+    if (!(keyOfEntity in params)) {
+      if (isView && entity.params[keyOfEntity].default) {
+        // will be added later?
+        continue
+      }
+
+      throw Object.assign(
+        new Error(
+          `${isView ? 'Parameter' : 'Key'} "${keyOfEntity}" is missing for ${isView ? 'view' : 'entity'} "${
+            entity.name
+          }"`
+        ),
+        { status: 400 }
+      )
+    }
   }
 }