@sap/cds 6.0.4 → 6.1.2

package/libx/_runtime/hana/search2cqn4sql.js

@@ -58,6 +58,7 @@ const search2cqn4sql = (query, entity, options) => {
 
   if (useContains) {
     expression = search2Contains(cqnSearchPhrase, columns2Search)
+    Object.defineProperty(query.SELECT, '_$searchUsingContains', { value: true, enumerable: true })
   } else {
     // No CONTAINS optimization possible. The search implementation for localized
     // texts falls back to the LIKE predicate.

package/libx/_runtime/messaging/common-utils/authorizedRequest.js

@@ -19,7 +19,7 @@ const authorizedRequest = ({ method, uri, path, oa2, tenant, dataObj, headers, t
         if (dataObj) {
           data = JSON.stringify(dataObj)
           httpOptions.headers['Content-Type'] = 'application/json'
-          httpOptions.headers['Content-Length'] = data.length
+          httpOptions.headers['Content-Length'] = Buffer.byteLength(data)
         }
 
         if (headers) {

package/libx/_runtime/messaging/enterprise-messaging-utils/EMManagement.js

@@ -34,7 +34,6 @@ class EMManagement {
     this.namespace = namespace
     this.LOG = LOG
   }
-
   async getQueue(queueName = this.queueName) {
     this.LOG._info &&
       this.LOG.info(
@@ -303,7 +302,7 @@ class EMManagement {
         grantType: 'client_credentials',
         clientId: this.optionsMessagingREST.oa2.client,
         clientSecret: this.optionsMessagingREST.oa2.secret,
-        tokenUrl: this.optionsMessagingREST.oa2.endpoint
+        tokenUrl: this.optionsMessagingREST.oa2.endpoint // this is the changed tokenUrl
       }
     }
 

package/libx/_runtime/messaging/outbox/utils.js

@@ -191,7 +191,7 @@ const _createMessage = (name, msg, context) => {
 const writeInOutbox = async (name, msg, context) => {
   const outboxMsg = _createMessage(name, msg, context)
   const messagesEntity = _getMessagesEntity()
-  return INSERT.into(messagesEntity).entries(outboxMsg)
+  return cds.tx(context).run(INSERT.into(messagesEntity).entries(outboxMsg))
 }
 
 module.exports = { processMessages, registerMessageProcessor, writeInOutbox, hasPersistentOutbox, isUnrecoverable }

package/libx/_runtime/messaging/service.js

@@ -1,6 +1,7 @@
 const cds = require('../cds')
 const queued = require('./common-utils/queued')
 const OutboxService = require('./Outbox')
+const ExtendedModels = require('../../../lib/srv/srv-models')
 
 const appId = require('./common-utils/appId')
 
@@ -76,9 +77,17 @@ class MessagingService extends OutboxService {
     return super.init()
   }
 
-  emit(event, data, headers) {
+  async emit(event, data, headers) {
     const _msg = typeof event === 'object' ? event : { event, data, headers }
-    const msg = _msg instanceof cds.Event ? _msg : new cds.Event(this.message4(_msg))
+    if (_msg instanceof cds.Event) return super.emit(_msg)
+    if (_msg.inbound && !cds.context) {
+      cds.context = { tenant: _msg.tenant, user: cds.User.privileged }
+      if (cds.model) {
+        const ctx = cds.context
+        ctx.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
+      }
+    }
+    const msg = new cds.Event(this.message4(_msg))
     return super.emit(msg)
   }
 
@@ -112,10 +121,6 @@ class MessagingService extends OutboxService {
 
   message4(msg) {
     const _msg = { ...msg }
-    if (msg.inbound && !cds.context) {
-      // REVISIT: why are all inbound messages executed with privileged user?
-      cds.context = { tenant: msg.tenant, user: cds.User.privileged }
-    }
     _msg.event = _warnAndStripTopicPrefix(_msg.event, this.LOG)
     if (!_msg.headers) _msg.headers = {}
     if (!_msg.inbound) {

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

@@ -114,6 +114,7 @@ const _convertValue = (ieee754Compatible, exponentialDecimals) => (value, elemen
 
   return value
 }
+const _PT = ([hh, mm, ss]) => `PT${hh}H${mm}M${ss}S`
 
 const _convertPayloadValue = (value, element) => {
   const type = _elementType(element)
@@ -121,6 +122,10 @@ const _convertPayloadValue = (value, element) => {
   // see https://www.odata.org/documentation/odata-version-2-0/json-format/
   if (value == null) return value
   switch (type) {
+    case 'cds.Time':
+      return value.match(/^(PT)([H,M,S,0-9])*$/) ? value : _PT(value.split(':'))
+    case 'cds.Decimal':
+      return typeof value === 'string' ? value : new String(value)
     case 'cds.Date':
     case 'cds.DateTime':
       return `/Date(${new Date(value).getTime()})/`

package/libx/_runtime/sqlite/Service.js

@@ -70,7 +70,6 @@ module.exports = class SQLiteDatabase extends DatabaseService {
   }
 
   _registerBeforeHandlers() {
-    this._ensureModel && this.before('*', this._ensureModel)
     this.before(['CREATE', 'UPDATE'], '*', this._input) // > has to run before rewrite
     this.before(['CREATE', 'READ', 'UPDATE', 'DELETE'], '*', this._rewrite)
 
@@ -188,11 +187,13 @@ module.exports = class SQLiteDatabase extends DatabaseService {
       return
     }
 
-    const tx = this.transaction()
-    await tx.run(dropViews)
-    await tx.run(dropTables)
-    await tx.run(createEntities)
-    await tx.commit()
+    await this.run(async tx => {
+      // This starts a new transaction if called from CLI, while joining
+      // existing root tx, e.g. when called from DeploymenrService
+      await tx.run(dropViews)
+      await tx.run(dropTables)
+      await tx.run(createEntities)
+    })
 
     return true
   }

package/libx/_runtime/sqlite/execute.js

@@ -19,31 +19,47 @@ const SANITIZE_VALUES = process.env.NODE_ENV === 'production' && cds.env.log.san
  * -> only if DEBUG (which should not be used in production)
  */
 const DEBUG = cds.debug('sqlite')
-const _captureStack = DEBUG
-  ? () => {
-      const o = {}
-      Error.captureStackTrace(o, _captureStack)
-      return o
+const _exec = DEBUG
+  ? (dbc, op, ...args) => {
+      const callback = args[args.length - 1]
+      const captured = {}
+      Error.captureStackTrace(captured, _exec)
+      args[args.length - 1] = function (err) {
+        if (err) {
+          err.message += ' in: \n' + args[0]
+          err.query = args[0]
+          if (args.length > 2) err.values = SANITIZE_VALUES ? ['***'] : args[1]
+          err.stack =
+            err.message +
+            captured.stack
+              .slice(5)
+              .replace(/at( _exec)? /, 'at SQLite.' + op + ' ')
+              .replace(/\s+at new Promise .*\n.*/, '')
+        }
+        callback.apply(this, arguments)
+      }
+      return dbc[op](...args)
+    }
+  : (dbc, op, ...args) => {
+      const callback = args[args.length - 1]
+      args[args.length - 1] = function (err) {
+        if (err) {
+          err.message += ' in: \n' + args[0]
+          err.query = args[0]
+          if (args.length > 2) err.values = SANITIZE_VALUES ? ['***'] : args[1]
+        }
+        callback.apply(this, arguments)
+      }
+      return dbc[op](...args)
     }
-  : () => undefined
-
-const _augmented = (err, sql, values, o) => {
-  err.query = sql
-  if (values) err.values = SANITIZE_VALUES ? ['***'] : values
-  err.message += ' in: \n' + sql
-  if (o) err.stack = err.message + o.stack.slice(5)
-  return err
-}
 
 function _executeSimpleSQL(dbc, sql, values) {
   LOG._debug &&
     LOG.debug(coloredTxCommands[sql] || sql, Array.isArray(values) ? (SANITIZE_VALUES ? ['***'] : values) : '')
 
   return new Promise((resolve, reject) => {
-    const o = _captureStack()
-    dbc.run(sql, values, function (err) {
-      if (err) return reject(_augmented(err, sql, values, o))
-
+    _exec(dbc, 'run', sql, values, function (err) {
+      if (err) return reject(err)
       resolve(this.changes)
     })
   })
@@ -53,9 +69,8 @@ function executeSelectSQL(dbc, sql, values, isOne, postMapper) {
   LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
 
   return new Promise((resolve, reject) => {
-    const o = _captureStack()
-    dbc[isOne ? 'get' : 'all'](sql, values, (err, result) => {
-      if (err) return reject(_augmented(err, sql, values, o))
+    _exec(dbc, isOne ? 'get' : 'all', sql, values, (err, result) => {
+      if (err) return reject(err)
 
       // REVISIT
       // .get returns undefined if nothing in db
@@ -140,9 +155,8 @@ const _executeBulkInsertSQL = (dbc, sql, values) =>
     }
 
     LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
-    const o = _captureStack()
-    const stmt = dbc.prepare(sql, err => {
-      if (err) return reject(_augmented(err, sql, values, o))
+    const stmt = _exec(dbc, 'prepare', sql, err => {
+      if (err) return reject(err)
 
       if (!Array.isArray(values[0])) values = [values]
 
@@ -159,7 +173,7 @@ const _executeBulkInsertSQL = (dbc, sql, values) =>
             if (!isFinalized) {
               isFinalized = true
               stmt.finalize()
-              return reject(_augmented(err, sql, each, o))
+              return reject(err)
             }
           }
 
@@ -212,9 +226,8 @@ function executeInsertSQL(dbc, sql, values, query) {
   LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
 
   return new Promise((resolve, reject) => {
-    const o = _captureStack()
-    dbc.run(sql, values, function (err) {
-      if (err) return reject(_augmented(err, sql, values, o))
+    _exec(dbc, 'run', sql, values, function (err) {
+      if (err) return reject(err)
 
       // InsertResult needs an object per row with its values
       if (query && values.length > 0) {

package/libx/odata/afterburner.js

@@ -111,6 +111,77 @@ function addRefToWhereIfNecessary(where, entity) {
   return 1
 }
 
+function getResolvedElement(entity, { ref }) {
+  const element = entity.elements[ref[0]]
+  if (element && element.isAssociation && ref.length > 1) {
+    return getResolvedElement(element._target, { ref: ref.slice(1) })
+  } else if (element && element._isStructured) {
+    return getResolvedElement(element, { ref: ref.slice(1) })
+  }
+
+  return element
+}
+
+function _processWhere(where, entity) {
+  for (let i = 0; i < where.length; i++) {
+    const ref = where[i]
+    const val = where[i + 2]
+
+    if (ref === '(' || ref === ')' || ref === 'and' || ref === 'or' || ref === 'not' || val === 'not' || ref.func) {
+      continue
+    }
+    if (ref.xpr) {
+      _processWhere(ref.xpr, entity)
+      continue
+    }
+
+    let valIndex = -1
+    let refIndex = -1
+    if (typeof val === 'object') {
+      if (val.val !== undefined) valIndex = i + 2
+      if (val.ref != undefined) refIndex = i + 2
+    }
+    if (typeof ref === 'object') {
+      if (ref.val !== undefined) valIndex = i
+      if (ref.ref != undefined) refIndex = i
+    }
+
+    // no need to check ref = ref or val = val, if no ref or no val exists we can't do anything
+    if (valIndex === refIndex || valIndex === -1 || refIndex == -1) continue
+
+    const realRef = where[refIndex]
+    const element = getResolvedElement(entity, realRef)
+
+    if (element) {
+      i += 2
+      where[valIndex].val = _convertVal(element, where[valIndex].val)
+    }
+  }
+}
+
+function _convertVal(element, value) {
+  if (value === null) return value
+  switch (element._type) {
+    case 'cds.Integer':
+      // eslint-disable-next-line no-case-declarations
+      const n = Number(value)
+      if (Number.isSafeInteger(n)) return n
+      throw new Error('Not a valid integer') // TODO
+    case 'cds.String':
+    case 'cds.LargeString':
+    case 'cds.Decimal':
+    case 'cds.DecimalFloat':
+    case 'cds.Double':
+    case 'cds.Integer64':
+      if (typeof value === 'string') return value
+      return String(value)
+    case 'cds.Boolean':
+      return typeof value === 'string' ? value === 'true' : value
+    default:
+      return value
+  }
+}
+
 function _processSegments(from, model, namespace) {
   const { ref } = from
 
@@ -142,8 +213,7 @@ function _processSegments(from, model, namespace) {
           .join(',')})`
         base.where.push({ ref: [key] }, '=', { val })
       } else {
-        const val =
-          element._type === 'cds.Integer' ? Number(seg) : element._type === 'cds.Boolean' ? seg === 'true' : seg
+        const val = _convertVal(element, seg)
         base.where.push({ ref: [key] }, '=', { val })
       }
       ref[i] = null
@@ -168,6 +238,7 @@ function _processSegments(from, model, namespace) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
           _resolveAliasesInXpr(ref[i].where, current)
           _resolveAliasInParams(params, current)
+          _processWhere(ref[i].where, current)
         }
 
         _addDefaultParams(ref[i], current)
@@ -201,6 +272,7 @@ function _processSegments(from, model, namespace) {
           _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)
+          _processWhere(ref[i].where, current)
           _checkAllKeysProvided(params, current)
         }
       } else if ({ action: 1, function: 1 }[current.kind]) {
@@ -221,6 +293,7 @@ function _processSegments(from, model, namespace) {
         if (ref[i].where) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
           _resolveAliasesInXpr(ref[i].where, current)
+          _processWhere(ref[i].where, current)
         }
       } else if (current._isStructured) {
         // > nested property
@@ -349,6 +422,10 @@ function _4service(service) {
      */
     const { one, current, target } = _processSegments(from, model, namespace)
 
+    if (cqn.SELECT.where) {
+      _processWhere(cqn.SELECT.where, root)
+    }
+
     // one?
     if (one) cqn.SELECT.one = true
 

package/libx/odata/cqn2odata.js

@@ -114,11 +114,11 @@ const _odataV2Func = (func, args) => {
   }
 }
 
-const _format = (cur, element, target, kind, isLambda) => {
-  if (typeof cur !== 'object') return encodeURIComponent(formatVal(cur, element, target, kind))
+const _format = (cur, elementName, target, kind, isLambda) => {
+  if (typeof cur !== 'object') return encodeURIComponent(formatVal(cur, elementName, target, kind))
   if (hasValidProps(cur, 'ref'))
     return encodeURIComponent(isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref[0].id || cur.ref.join('/'))
-  if (hasValidProps(cur, 'val')) return encodeURIComponent(formatVal(cur.val, element, target, kind))
+  if (hasValidProps(cur, 'val')) return encodeURIComponent(formatVal(cur.val, elementName, target, kind))
   if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
   // REVISIT: How to detect the types for all functions?
   if (hasValidProps(cur, 'func', 'args')) {
@@ -180,7 +180,8 @@ function _xpr(expr, target, kind, isLambda) {
         res.push(OPERATORS[cur] || cur.toLowerCase())
       }
     } else {
-      const formatted = _format(cur, res[res.length - 2], target, kind, isLambda)
+      const ref = expr[i - 2]
+      const formatted = _format(cur, ref?.ref && (ref.ref.length ? ref.ref : ref.ref[0]), target, kind, isLambda)
       if (formatted !== undefined) res.push(formatted)
     }
   }
@@ -199,8 +200,12 @@ const _keysOfWhere = (where, kind, target) => {
   if (where.length === 3) {
     const [left, op, right] = where
     if (op === '=' && (('val' in left && right.ref) || (left.ref && 'val' in right))) {
-      if ('val' in left) return `(${formatVal(left.val, right.ref.join('/'), target, kind)})`
-      return `(${formatVal(right.val, left.ref.join('/'), target, kind)})`
+      const formattedValue =
+        'val' in left
+          ? formatVal(left.val, right.ref.join('/'), target, kind)
+          : formatVal(right.val, left.ref.join('/'), target, kind)
+
+      return `(${encodeURIComponent(formattedValue)})`
     }
   }
 
@@ -406,7 +411,7 @@ function $orderBy(orderBy) {
   return '$orderby=' + res.join(',')
 }
 
-function parseSearch(search) {
+function parseSearch(search, kind) {
   const res = []
 
   for (const cur of search) {
@@ -417,7 +422,8 @@ function parseSearch(search) {
 
     if (hasValidProps(cur, 'val')) {
       // search term must not be formatted
-      res.push(`"${encodeURIComponent(cur.val)}"`)
+      if (kind === 'odata-v2') res.push(`${encodeURIComponent(cur.val)}`)
+      else res.push(`"${encodeURIComponent(cur.val)}"`)
     }
 
     if (typeof cur === 'string') {
@@ -433,7 +439,7 @@ function parseSearch(search) {
 }
 
 function $search(search, kind) {
-  const expr = parseSearch(search).join('%20').replace('(%20', '(').replace('%20)', ')')
+  const expr = parseSearch(search, kind).join('%20').replace('(%20', '(').replace('%20)', ')')
 
   if (expr) {
     // odata-v2 may support custom query option "search"