@sap/cds 5.8.2 → 5.9.0

package/libx/_runtime/messaging/message-queuing.js

@@ -1,18 +1,17 @@
-const cds = require('../cds.js')
 const AMQPWebhookMessaging = require('./AMQPWebhookMessaging')
 const AMQPClient = require('./common-utils/AMQPClient.js')
 
 const optionsMessaging = require('./message-queuing-utils/options-messaging.js')
 const optionsManagement = require('./message-queuing-utils/options-management.js')
 const authorizedRequest = require('./common-utils/authorizedRequest')
-const LOG = cds.log('messaging')
 
 class MQManagement {
-  constructor({ options, queueConfig, queueName, subscribedTopics }) {
+  constructor({ options, queueConfig, queueName, subscribedTopics, LOG }) {
     this.options = options
     this.queueConfig = queueConfig
     this.queueName = queueName
     this.subscribedTopics = subscribedTopics
+    this.LOG = LOG
   }
 
   async getQueue(queueName = this.queueName) {
@@ -21,7 +20,7 @@ class MQManagement {
       uri: this.options.url,
       path: `/v1/management/queues/${encodeURIComponent(queueName)}`,
       oa2: this.options.auth.oauth2,
-      attemptInfo: () => LOG._info && LOG.info('Get queue', { queue: queueName }),
+      attemptInfo: () => this.LOG._info && this.LOG.info('Get queue', { queue: queueName }),
       errMsg: `Queue "${queueName}" could not be retrieved`,
       target: { kind: 'QUEUE', queue: queueName },
       tokenStore: this
@@ -35,7 +34,7 @@ class MQManagement {
       uri: this.options.url,
       path: `/v1/management/queues`,
       oa2: this.options.auth.oauth2,
-      attemptInfo: () => LOG._info && LOG.info('Get queues'),
+      attemptInfo: () => this.LOG._info && this.LOG.info('Get queues'),
       errMsg: `Queues could not be retrieved`,
       target: { kind: 'QUEUE' },
       tokenStore: this
@@ -50,7 +49,7 @@ class MQManagement {
       path: `/v1/management/queues/${encodeURIComponent(queueName)}`,
       oa2: this.options.auth.oauth2,
       dataObj: this.queueConfig,
-      attemptInfo: () => LOG._info && LOG.info('Create queue', { queue: queueName }),
+      attemptInfo: () => this.LOG._info && this.LOG.info('Create queue', { queue: queueName }),
       errMsg: `Queue "${queueName}" could not be created`,
       target: { kind: 'QUEUE', queue: queueName },
       tokenStore: this
@@ -63,7 +62,7 @@ class MQManagement {
       uri: this.options.url,
       path: `/v1/management/queues/${encodeURIComponent(queueName)}`,
       oa2: this.options.auth.oauth2,
-      attemptInfo: () => LOG._info && LOG.info('Delete queue', { queue: queueName }),
+      attemptInfo: () => this.LOG._info && this.LOG.info('Delete queue', { queue: queueName }),
       errMsg: `Queue "${queueName}" could not be deleted`,
       target: { kind: 'QUEUE', queue: queueName },
       tokenStore: this
@@ -76,7 +75,7 @@ class MQManagement {
       uri: this.options.url,
       path: `/v1/management/queues/${encodeURIComponent(queueName)}/subscriptions/topics`,
       oa2: this.options.auth.oauth2,
-      attemptInfo: () => LOG._info && LOG.info('Get subscriptions', { queue: queueName }),
+      attemptInfo: () => this.LOG._info && this.LOG.info('Get subscriptions', { queue: queueName }),
       errMsg: `Subscriptions for "${queueName}" could not be retrieved`,
       target: { kind: 'SUBSCRIPTION', queue: queueName },
       tokenStore: this
@@ -92,7 +91,8 @@ class MQManagement {
         topicPattern
       )}`,
       oa2: this.options.auth.oauth2,
-      attemptInfo: () => LOG._info && LOG.info('Create subscription', { topic: topicPattern, queue: queueName }),
+      attemptInfo: () =>
+        this.LOG._info && this.LOG.info('Create subscription', { topic: topicPattern, queue: queueName }),
       errMsg: `Subscription "${topicPattern}" could not be added to queue "${queueName}"`,
       target: { kind: 'SUBSCRIPTION', queue: queueName, topic: topicPattern },
       tokenStore: this
@@ -107,7 +107,8 @@ class MQManagement {
         topicPattern
       )}`,
       oa2: this.options.auth.oauth2,
-      attemptInfo: () => LOG._info && LOG.info('Delete subscription', { topic: topicPattern, queue: queueName }),
+      attemptInfo: () =>
+        this.LOG._info && this.LOG.info('Delete subscription', { topic: topicPattern, queue: queueName }),
       errMsg: `Subscription "${topicPattern}" could not be deleted from queue "${queueName}"`,
       target: { kind: 'SUBSCRIPTION', queue: queueName, topic: topicPattern },
       tokenStore: this
@@ -115,7 +116,7 @@ class MQManagement {
   }
 
   async createQueueAndSubscriptions() {
-    LOG._info && LOG.info(`Create messaging artifacts`)
+    this.LOG._info && this.LOG.info(`Create messaging artifacts`)
     const created = await this.createQueue()
     if (created && created.statusCode === 200) {
       // We need to make sure to only keep our own subscriptions
@@ -171,7 +172,8 @@ class MessageQueuing extends AMQPWebhookMessaging {
       options: _optionsManagement,
       queueConfig,
       queueName,
-      subscribedTopics: this.subscribedTopics
+      subscribedTopics: this.subscribedTopics,
+      LOG: this.LOG
     })
     return this.management
   }

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

@@ -21,9 +21,10 @@ const _getMessagesEntity = () => {
   return messagesEntity
 }
 
-// REVISIT: Is there a better way?
+// REVISIT: Is this always a reliable way to identify the provider tenant?
+//          Are there scenarios where the credentials have a different format?
 const _isProviderTenant = tenant =>
-  cds.requires.uaa && cds.requires.uaa.credentials && cds.requires.uaa.credentials.identityzoneid === tenant
+  cds.requires.auth && cds.requires.auth.credentials && cds.requires.auth.credentials.identityzoneid === tenant
 
 const hasPersistentOutbox = (srv, tenant) => {
   if (!cds.requires.outbox || cds.requires.outbox.kind !== 'persistent-outbox') return false
@@ -86,16 +87,15 @@ const processMessages = async (service, tenant, _opts = {}) => {
       } catch (e) {
         // could potentially be a timeout
         const _waitingTime = waitingTime(opts.attempt)
-        LOG._error &&
-          LOG.error(
-            'Outbox SELECT FOR UPDATE failed',
-            opts.attempt > 0
-              ? ''
-              : {
-                  cause: e
-                },
-            `Retrying in ${Math.round(_waitingTime / 1000)} s`
-          )
+        LOG.error(
+          'Outbox SELECT FOR UPDATE failed',
+          opts.attempt > 0
+            ? ''
+            : {
+                cause: e
+              },
+          `Retrying in ${Math.round(_waitingTime / 1000)} s`
+        )
         outboxRunner.schedule(
           {
             name,
@@ -127,7 +127,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
           const _waitingTime = waitingTime(error.failedMessage.attempts)
           const info = { service: name, event: error.failedMessage.event }
           if (error.failedMessage.attempts > 0) info.cause = error.failedMessage.error
-          LOG._error && LOG.error('Emit failed', info, `Retrying in ${Math.round(_waitingTime / 1000)} s`)
+          LOG.error('Emit failed', info, `Retrying in ${Math.round(_waitingTime / 1000)} s`)
           await UPDATE(messagesEntity)
             .where({ ID: error.failedMessage.ID })
             .set({ attempts: { '+=': 1 } })
@@ -140,12 +140,11 @@ const processMessages = async (service, tenant, _opts = {}) => {
             () => processMessages(service, tenant, opts)
           )
         } else {
-          LOG._error &&
-            LOG.error(
-              'Emit failed',
-              { service: name, event: error.failedMessage.event, cause: error.failedMessage.error },
-              'Unrecoverable, outbox entry deleted'
-            )
+          LOG.error(
+            'Emit failed',
+            { service: name, event: error.failedMessage.event, cause: error.failedMessage.error },
+            'Unrecoverable, outbox entry deleted'
+          )
         }
       } else {
         outboxRunner.success({ name, tenant })

package/libx/_runtime/messaging/redis-messaging.js

@@ -0,0 +1,91 @@
+/* eslint-disable prettier/prettier */
+const redis = require('redis')
+const cds = require('../../../lib')
+const waitingTime = require('./common-utils/waitingTime')
+const normalizeIncomingMessage = require('./common-utils/normalizeIncomingMessage')
+const { hasPersistentOutbox } = require('./outbox/utils')
+
+const _handleReconnects = (client, LOG) => {
+  client.on('reconnecting', () => {
+    LOG.warn('Reconnecting')
+  })
+
+  client.on('error', error => {
+    LOG.warn('Failed to connect to Redis: ', error)
+  })
+}
+
+class RedisMessaging extends cds.MessagingService {
+  async init() {
+    await super.init()
+    const credentials = this.options && this.options.credentials
+    const config = {
+      socket: {
+        reconnectStrategy: attempts => {
+          const _waitingTime = waitingTime(attempts)
+          this.LOG.warn(`Connection to Redis lost: Reconnecting in ${Math.round(_waitingTime / 1000)} s`)
+          return _waitingTime
+        }
+      }
+    }
+    // rediss://someUserName:somePassword@hostName:port -> rediss://:somePassword@hostName:port
+    const url = credentials && credentials.uri && credentials.uri.replace(/\/\/.*?:/, '//:')
+    if (!url) this.LOG._warn && this.LOG.warn('No Redis credentials found, using default credentials')
+    else config.url = url
+    this.client = redis.createClient(config)
+    _handleReconnects(this.client, this.LOG)
+
+    try {
+      await this.client.connect()
+    } catch (e) {
+      throw new Error('Connection to Redis could not be established: ' + e)
+    }
+
+    this._ready = true
+    this.client.on('end', () => {
+      this._ready = false
+    })
+    this.client.on('error', () => {
+      this._ready = false
+    })
+    this.client.on('ready', () => {
+      this._ready = true
+    })
+
+    cds.once('listening', () => {
+      this.startListening()
+    })
+  }
+
+  async startListening() {
+    let subscriber
+    for (const topic of [...this.subscribedTopics].map(kv => kv[0])) {
+      if (!subscriber) {
+        // For subscriptions we need to duplicate the connection
+        subscriber = this.client.duplicate()
+        _handleReconnects(subscriber)
+        await subscriber.connect()
+      }
+      this.LOG._info && this.LOG('Create subscription', { topic })
+      await subscriber.subscribe(topic, async message => {
+        const msg = normalizeIncomingMessage(message)
+        msg.event = topic
+        try {
+          await super.emit(msg)
+        } catch (e) {
+          this.LOG.error('ERROR occured in asynchronous event processing:', e)
+        }
+      })
+    }
+  }
+
+  async emit(msg) {
+    const _msg = this.message4(msg)
+    this.LOG._info && this.LOG.info('Emit', { topic: _msg.event })
+    if (!this._ready && hasPersistentOutbox(this, cds.context && cds.context.tenant))
+      throw new Error('Redis connection not ready')
+    await this.client.publish(_msg.event, JSON.stringify({ data: _msg.data, ...(_msg.headers || {}) }))
+  }
+}
+
+module.exports = RedisMessaging

package/libx/_runtime/messaging/service.js

@@ -1,12 +1,11 @@
 const cds = require('../cds')
-const LOG = cds.log('messaging')
 const queued = require('./common-utils/queued')
 const OutboxService = require('./Outbox')
 
 const _topic = declared => declared['@topic'] || declared.name
 
 let usedTopicOnce = false
-const _warnAndStripTopicPrefix = event => {
+const _warnAndStripTopicPrefix = (event, LOG) => {
   if (event.startsWith('topic:')) {
     // backwards compatibility
     event = event.replace(/topic:/, '')
@@ -24,6 +23,7 @@ class MessagingService extends OutboxService {
     // enables queued async operations (without awaiting)
     this.queued = queued()
     this.subscribedTopics = new Map()
+    this.LOG = cds.log(this.kind ? `${this.kind}|messaging` : 'messaging')
     // Only for one central `messaging` service, otherwise all technical services would register themselves
     if (this.name === 'messaging') {
       this._registeredServices = new Map()
@@ -81,7 +81,7 @@ class MessagingService extends OutboxService {
   }
 
   on(event, cb) {
-    const _event = _warnAndStripTopicPrefix(event)
+    const _event = _warnAndStripTopicPrefix(event, this.LOG)
     // save all subscribed topics (not needed for local-messaging)
     this.subscribedTopics.set(this.prepareTopic(_event, true), _event)
     return super.on(_event, cb)
@@ -109,9 +109,11 @@ class MessagingService extends OutboxService {
 
   message4(msg) {
     const _msg = { ...msg }
-    if (msg.inbound && !cds.context)
-      _msg.user = msg.tenant ? new cds.User.Privileged({ tenant: msg.tenant }) : new cds.User.Privileged()
-    _msg.event = _warnAndStripTopicPrefix(_msg.event)
+    if (msg.inbound && !cds.context) {
+      // REVISIT: why are all inbound messages executed with privileged user?
+      cds.context = { tenant: msg.tenant, user: new cds.User.Privileged() }
+    }
+    _msg.event = _warnAndStripTopicPrefix(_msg.event, this.LOG)
     if (!_msg.headers) _msg.headers = {}
     if (!_msg.inbound) {
       _msg.headers = { ..._msg.headers } // don't change the original object

package/libx/_runtime/remote/Service.js

@@ -40,12 +40,13 @@ const _setCorrectValue = (el, data, params, kind) => {
 const _buildPartialUrlFunctions = (url, data, params, kind = 'odata-v4') => {
   const funcParams = []
   const queryOptions = []
-  for (const el in data) {
+  // REVISIT: take params from params after importer fix (the keys should not be part of params)
+  for (const param in data) {
     if (kind === 'odata-v2') {
-      funcParams.push(`${el}=${_setCorrectValue(el, data, params, kind)}`)
+      funcParams.push(`${param}=${_setCorrectValue(param, data, params, kind)}`)
     } else {
-      funcParams.push(`${el}=@${el}`)
-      queryOptions.push(`@${el}=${_setCorrectValue(el, data, params, kind)}`)
+      funcParams.push(`${param}=@${param}`)
+      queryOptions.push(`@${param}=${_setCorrectValue(param, data, params, kind)}`)
     }
   }
   return kind === 'odata-v2'
@@ -62,8 +63,17 @@ const _extractParamsFromData = (data, params) => {
 
 const _buildKeys = (req, kind) => {
   const keys = []
-  for (const key in req.target.keys) {
-    keys.push(`${key}=${formatVal(req.data[key], key, req.target, kind)}`)
+  if (req.params && req.params.length > 0) {
+    const p1 = req.params[0]
+    if (typeof p1 !== 'object') return [p1]
+    for (const key in req.target.keys) {
+      keys.push(`${key}=${formatVal(p1[key], key, req.target, kind)}`)
+    }
+  } else {
+    // REVISIT: shall we keep that or remove it?
+    for (const key in req.target.keys) {
+      keys.push(`${key}=${formatVal(req.data[key], key, req.target, kind)}`)
+    }
   }
   return keys
 }
@@ -83,7 +93,14 @@ const _handleBoundActionFunction = (srv, def, req, url) => {
 
 const _handleUnboundActionFunction = (srv, def, req, event) => {
   if (def.kind === 'action') {
-    return srv.post(`/${event}`, req.data)
+    // REVISIT: only for "rest" unbound actions/functions, we enforce axios to return a buffer
+    // required by cds-mt
+    const isBinary =
+      srv.kind === 'rest' &&
+      def &&
+      def.returns &&
+      (def.returns.type === 'cds.LargeBinary' || def.returns.type === 'cds.Binary')
+    return srv.send({ method: 'POST', path: `/${event}`, data: req.data, _binary: isBinary })
   }
 
   const url =
@@ -97,11 +114,30 @@ const _handleV2ActionFunction = (srv, def, req, event, kind) => {
   return def.kind === 'function' ? srv.get(url) : srv.post(url, {})
 }
 
+const _handleV2BoundActionFunction = (srv, def, req, event, kind) => {
+  const params = []
+  const data = req.data
+  // REVISIT: take params from def.params, after importer fix (the keys should not be part of params)
+  for (const param in req.data) {
+    params.push(`${param}=${formatVal(data[param], param, { elements: def.params }, kind)}`)
+  }
+  const keys = _buildKeys(req, this.kind)
+  if (keys.length === 1 && typeof req.params[0] !== 'object') {
+    params.push(`${Object.keys(req.target.keys)[0]}=${keys[0]}`)
+  } else {
+    params.push(...keys)
+  }
+  const url = `${`/${event}`}?${params.join('&')}`
+  return def.kind === 'function' ? srv.get(url) : srv.post(url, {})
+}
+
 const _addHandlerActionFunction = (srv, def, target) => {
   const event = def.name.match(/\w*$/)[0]
   if (target) {
     srv.on(event, target, async function (req) {
       const shortEntityName = req.target.name.replace(`${this.namespace}.`, '')
+      if (this.kind === 'odata-v2')
+        return _handleV2BoundActionFunction(srv, def, req, `${shortEntityName}_${event}`, this.kind)
       const url = `/${shortEntityName}(${_buildKeys(req, this.kind).join(',')})/${this.namespace}.${event}`
       return _handleBoundActionFunction(srv, def, req, url)
     })
@@ -208,7 +244,7 @@ class RemoteService extends cds.Service {
 
     if (req.target && req.target.name && this.definition && req.target.name.startsWith(this.definition.name + '.')) {
       const result = await super.handle(req)
-      // only post process if alias was explicitely set in query
+      // only post process if alias was explicitly set in query
       if (_selectOnlyWithAlias(req.query)) {
         return postProcess(req.query, result, this, true)
       }

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
@@ -67,6 +65,11 @@ const getDestination = (name, credentials) => {
     throw new Error(`"url" or "destination" property must be configured in "credentials" of "${name}".`)
   }
 
+  // Cloud SDK wants property "queryParameters" but we have documented "queries"
+  if (credentials.queries && !credentials.queryParameters) {
+    credentials.queryParameters = credentials.queries
+  }
+
   return { name, ...credentials }
 }
 
@@ -244,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
@@ -266,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
@@ -295,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
     }
   }
 
@@ -394,9 +403,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
   }
 
@@ -437,6 +444,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]
  */