@sap/cds 5.5.5 → 5.6.3

package/libx/_runtime/fiori/uiflex/utils.js

@@ -0,0 +1,78 @@
+const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { ensureUnlocalized } = require('../../fiori/utils/handler')
+
+const EXT_BACK_PACK = 'extensions__'
+
+const getTargetRead = req => {
+  let name = ''
+  if (req.query.SELECT.from.join) {
+    // join
+    name = req.query.SELECT.from.args.find(arg => arg.ref && arg.ref[0] !== 'DRAFT.DraftAdministativeData').ref[0]
+  } else if (req.target.name.SET) {
+    // union
+    name = req.target.name.SET.args[0]._target.name
+  } else {
+    // simple select
+    name = req.target.name
+  }
+
+  return { name: ensureUnlocalized(ensureNoDraftsSuffix(name)) }
+}
+
+const getTargetWrite = (target, model) => {
+  return model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(target.name))]
+}
+
+const isExtendedEntity = (entityName, model) => {
+  // REVISIT: Dass alle unsere und auch custom handlers immer die ensureUnlocalized + ensureNoDraftsSuffix schleife drehen müssen, kann nicht sein
+  const entity = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))]
+  return entity.elements[EXT_BACK_PACK] || Object.values(entity.elements).some(el => el['@cds.extension'])
+}
+
+const _hasExtendedEntityArgs = (args, model) => {
+  return args.find(arg => {
+    if (arg.ref) {
+      return arg.ref[0] !== 'DRAFT.DraftAdministativeData' && isExtendedEntity(arg.ref[0], model)
+    }
+
+    if (arg.join) {
+      return _hasExtendedEntityArgs(arg.args, model)
+    }
+  })
+}
+
+const hasExtendedEntity = (req, model) => {
+  if (!req.query.SELECT) return false
+
+  if (req.query.SELECT.from.join) {
+    // join
+    return _hasExtendedEntityArgs(req.query.SELECT.from.args, model)
+  } else if (req.target.name.SET) {
+    // union
+    return isExtendedEntity(req.target.name.SET.args[0]._target.name, model)
+  } else {
+    // simple select
+    return isExtendedEntity(req.target.name, model)
+  }
+}
+
+const getExtendedFields = (entityName, model) => {
+  const elements = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))].elements
+
+  return Object.values(elements)
+    .filter(element => {
+      return element['@cds.extension']
+    })
+    .map(element => {
+      return element.name
+    })
+}
+
+module.exports = {
+  EXT_BACK_PACK,
+  getTargetRead,
+  getTargetWrite,
+  isExtendedEntity,
+  hasExtendedEntity,
+  getExtendedFields
+}

package/libx/_runtime/fiori/utils/handler.js

@@ -231,11 +231,12 @@ const addColumnAlias = (columns, alias) => {
 const getCompositionTargets = (entity, srv) => {
   if (!entity.own('_deepCompositionTargets')) {
     const _deepCompositionTargets = []
-    getTemplate('delete-drafts', srv, entity, {
+    getTemplate(undefined, srv, entity, {
       pick: element => {
         if (element.isAssociation && !element._isAssociationStrict && srv.model.definitions[element.target].drafts)
           _deepCompositionTargets.push(element.target)
-      }
+      },
+      ignore: element => !element.isAssociation || element._isAssociationStrict
     })
     entity.set('_deepCompositionTargets', new Set(_deepCompositionTargets))
   }
@@ -268,16 +269,6 @@ const getKeyProperty = keys => {
   })
 }
 
-const hasKeyInWhere = (where, target) => {
-  if (!where) {
-    return false
-  }
-
-  const key = getKeyProperty(target.keys)
-
-  return where.some(element => (element.ref ? key === element.ref[element.ref.length - 1] : false))
-}
-
 const filterKeys = keys => {
   return Object.keys(keys).filter(key => {
     return key !== 'IsActiveEntity' && !keys[key]._isAssociationStrict
@@ -301,7 +292,6 @@ module.exports = {
   adaptStreamCQN,
   replaceRefWithDraft,
   getKeyProperty,
-  hasKeyInWhere,
   filterKeys,
   getDeleteDraftAdminCqn,
   getCompositionTargets

package/libx/_runtime/fiori/utils/where.js

@@ -55,6 +55,9 @@ const _removeIsActiveEntityCondition = where => {
       i = i + 4
     } else if (where[i] === 'and' && where[i + 1] === '(' && _isActiveEntity(where[i + 2])) {
       i = i + 6
+    } else if (where[i].xpr) {
+      newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
+      i++
     } else {
       newWhere.push(where[i])
       i++
@@ -132,7 +135,7 @@ const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
 const removeIsActiveEntityRecursively = where => {
   for (const entry of where) {
     if (entry.SELECT && entry.SELECT.where && entry.SELECT.from.ref && !entry.SELECT.from.ref[0].endsWith('_drafts')) {
-      entry.SELECT.where = _removeIsActiveEntityCondition(entry.SELECT.where)
+      entry.SELECT.where = removeIsActiveEntityRecursively(entry.SELECT.where)
 
       if (entry.SELECT.where.length === 0) {
         delete entry.SELECT.where
@@ -144,6 +147,8 @@ const removeIsActiveEntityRecursively = where => {
 }
 
 const isActiveEntityRequested = where => {
+  if (!where) return true
+
   let i = 0
 
   while (where[i]) {

package/libx/_runtime/hana/pool.js

@@ -9,19 +9,20 @@ const _require = require('../common/utils/require')
 let im
 
 function multiTenantInstanceManager(db = cds.env.requires.db) {
-  let creds = db.credentials && (db.credentials.get_managed_instance_url || db.credentials.sm_url) && db.credentials
-  if (!creds) creds = _require('@sap/xsenv').serviceCredentials(db.vcap || { label: 'managed-hana' })
-  if (!creds) creds = _require('@sap/xsenv').serviceCredentials({ label: 'service-manager' })
-
-  if (!creds || typeof creds !== 'object' || !(creds.get_managed_instance_url || creds.sm_url)) {
-    throw Object.assign(new Error('No or malformed Managed HANA credentials'), { credentials: creds })
+  const credentials = db.credentials
+  if (
+    !credentials ||
+    typeof credentials !== 'object' ||
+    !(credentials.get_managed_instance_url || credentials.sm_url)
+  ) {
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
   }
 
   // new instance manager
   return new Promise((resolve, reject) => {
     // REVISIT: better cache settings? current copied from old cds-hana...
     // note: may need to be low for mtx tests -> configurable?
-    const opts = Object.assign(creds, {
+    const opts = Object.assign(credentials, {
       cache_max_items: 1,
       cache_item_expire_seconds: 1
     })
@@ -37,16 +38,16 @@ function multiTenantInstanceManager(db = cds.env.requires.db) {
 }
 
 function singleTenantInstanceManager(db = cds.env.requires.db) {
-  const creds = db.credentials || _require('@sap/xsenv').serviceCredentials(db.vcap || { label: 'hana' })
+  const credentials = db.credentials
 
-  if (!creds || typeof creds !== 'object' || !creds.host) {
-    throw Object.assign(new Error('No or malformed HANA credentials'), { credentials: creds })
+  if (!credentials || typeof credentials !== 'object' || !credentials.host) {
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
   }
 
   // mock instance manager
   return {
     get: (_, cb) => {
-      cb(null, { credentials: creds })
+      cb(null, { credentials: credentials })
     }
   }
 }

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,7 +1,6 @@
 const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, searchToContains } = require('./searchToContains')
-const { getOnCond } = require('../common/utils/generateOnCond')
 
 /**
  * Computes a CQN expression for a search query.
@@ -15,30 +14,27 @@ const { getOnCond } = require('../common/utils/generateOnCond')
  * But in contrast to the explicitly written `LIKE ?`, the parameter is already resolved to its concrete value, making
  * it better optimizable by the HANA optimizer.
  *
- * @param {object} cqn The CQN object
+ * @param {object} query The CQN object
  * @param {import('@sap/cds-compiler/lib/api/main').CSN} entity The target entity for the search query
  * @param {import('../types/api').search2cqnOptions} [options]
  * @returns {object} The modified CQN object
  */
-const search2cqn4sql = (cqn, entity, options) => {
-  const cqnSearchPhrase = cqn.SELECT.search
-  if (!cqnSearchPhrase) return cqn
+const search2cqn4sql = (query, entity, options) => {
+  const cqnSearchPhrase = query.SELECT.search
+  if (!cqnSearchPhrase) return query
 
-  let { columns = computeColumnsToBeSearched(cqn, entity), locale } = options
+  let { columns: columnsToBeSearched = computeColumnsToBeSearched(query, entity), locale } = options
   const localizedAssociation = _getLocalizedAssociation(entity)
 
   // If the localized association is defined for the target entity,
   // there should be at least one localized element.
   const resolveLocalizedTextsAtRuntime = !!localizedAssociation
 
-  if (resolveLocalizedTextsAtRuntime) {
-    // suppress the localize handler from modifying the from target
-    // The `_suppressLocalization` property is:
-    // enumerable: false (default), writable: false (default)
-    Object.defineProperty(cqn, '_suppressLocalization', { value: true })
+  // suppress the localize handler from redirecting the query's target to the localized view
+  Object.defineProperty(query, '_suppressLocalization', { value: true })
 
-    const onConditionOptions = _getOnConditionOptions(entity, localizedAssociation)
-    const onCondition = getOnCond(localizedAssociation, onConditionOptions)
+  if (resolveLocalizedTextsAtRuntime) {
+    const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
     onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
@@ -46,31 +42,26 @@ const search2cqn4sql = (cqn, entity, options) => {
     // inner join the target table with the _texts table (the _texts table contains
     // the translated texts)
     const localizedEntityName = localizedAssociation.target
-    cqn.join(localizedEntityName).on(onCondition)
-
-    // The inner join modifies the original SELECT ... FROM query and adds ambiguity,
-    // therefore add the table/entity name (as a preceding element) to the columns ref
-    // to prevent a SQL ambiguity error. E.g., SqlError message: column ambiguously
-    // defined.
-    cqn.SELECT.columns = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.columns)
-    columns = _unshiftEntityNameToColumnRef(entity, columns)
-    if (cqn.SELECT.groupBy) cqn.SELECT.groupBy = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.groupBy)
+    query.join(localizedEntityName).on(onCondition)
+
+    // prevent SQL ambiguity error for columns with the same name
+    columnsToBeSearched = _addAliasToColumns(query, entity, columnsToBeSearched)
   } // else --> resolve localized texts via localized view (default)
 
-  const useContains = resolveLocalizedTextsAtRuntime && isContainsPredicateSupported(cqn)
+  const useContains = isContainsPredicateSupported(query)
   let expression
 
   if (useContains) {
-    expression = searchToContains(cqnSearchPhrase, columns)
+    expression = searchToContains(cqnSearchPhrase, columnsToBeSearched)
   } else {
     // No CONTAINS optimization possible. The search implementation for localized
     // texts falls back to the LIKE predicate.
-    expression = searchToLike(cqnSearchPhrase, columns)
+    expression = searchToLike(cqnSearchPhrase, columnsToBeSearched)
   }
 
   // REVISIT: find out here if where or having must be used
-  cqn._aggregated ? cqn.having(expression) : cqn.where(expression)
-  return cqn
+  query._aggregated ? query.having(expression) : query.where(expression)
+  return query
 }
 
 const _getLocalizedAssociation = entity => {
@@ -78,28 +69,28 @@ const _getLocalizedAssociation = entity => {
   return associations && associations.localized
 }
 
-const _getOnConditionOptions = (entity, localizedAssociation) => {
-  return {
-    associationNames: [localizedAssociation.name],
-    aliases: {
-      select: localizedAssociation.target,
-      join: entity.name
-    }
-  }
-}
-
-const _unshiftEntityNameToColumnRef = (entity, columns) => {
+// The inner join modifies the original SELECT ... FROM query and adds ambiguity,
+// therefore add the table/entity name (as a preceding element) to the columns ref
+// to prevent a SQL ambiguity error.
+const _addAliasToColumns = (query, entity, columnsToBeSearched) => {
   const localizedEntityName = _getLocalizedAssociation(entity).target
   const elements = entity.elements
-
-  columns = columns.map(column => {
+  const entityName = entity.name
+  const _addAliasToColumn = (entityName, localizedEntityName, elements) => column => {
     const columnRef = column.ref
     if (!columnRef) return column
     const columnName = columnRef[0]
     const localizedElement = elements[columnName].localized
-    const entityName = localizedElement ? localizedEntityName : entity.name
-    return { ref: [entityName, columnName] }
-  })
+    const targetEntityName = localizedElement ? localizedEntityName : entityName
+    return { ref: [targetEntityName, columnName] }
+  }
+
+  query.SELECT.columns = query.SELECT.columns.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+  const columns = columnsToBeSearched.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+
+  if (query.SELECT.groupBy) {
+    query.SELECT.groupBy = query.SELECT.groupBy.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+  }
 
   return columns
 }

package/libx/_runtime/hana/searchToContains.js

@@ -64,12 +64,12 @@ const searchToContains = (cqnSearchPhrase, columns) => {
   return expression
 }
 
-const isContainsPredicateSupported = cqn => {
-  const cqnSearchPhrase = cqn.SELECT.search
+const isContainsPredicateSupported = query => {
+  const cqnSearchPhrase = query.SELECT.search
 
   // REVISIT: In the future, to further optimize search queries, you might
   // want to remove the following condition(s).
-  if (cqn._aggregated) return false
+  if (query._aggregated) return false
 
   // REVISIT: search terms starting with whitespace after a `NOT` operator does not
   // return the expected result on SAP HANA (BCP 2180256508). In addition, double

package/libx/_runtime/index.js

@@ -5,9 +5,12 @@ module.exports = {
       return this._odatav4 || (this._odatav4 = require('./cds-services/adapter/odata-v4/to'))
     },
 
-    /** @type {import('./cds-services/adapter/rest/to')} */
     get rest() {
-      return this._rest || (this._rest = require('./cds-services/adapter/rest/to'))
+      if (!this._rest) {
+        if (global.cds.env.features.rest_new_adapter) this._rest = require('../rest')
+        else this._rest = require('./cds-services/adapter/rest/to')
+      }
+      return this._rest
     }
   },
 

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -37,7 +37,7 @@ class AMQPWebhookMessaging extends MessagingService {
         // Some messaging systems don't adhere to the standard that the payload has a `data` property.
         // For these cases, we interpret the whole payload as `data`.
         let data, headers
-        if ('data' in _payload) {
+        if (typeof _payload === 'object' && 'data' in _payload) {
           data = _payload.data
           headers = { ..._payload }
           delete headers.data

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

@@ -3,6 +3,14 @@ const LOG = cds.log('messaging')
 const ClientAmqp = require('@sap/xb-msg-amqp-v100').Client
 const { connect, disconnect } = require('./connections')
 
+const _JSONorString = string => {
+  try {
+    return JSON.parse(string)
+  } catch (e) {
+    return string
+  }
+}
+
 const addDataListener = (client, queue, prefix, cb) =>
   new Promise((resolve, reject) => {
     const source = `${prefix}${queue}`
@@ -10,9 +18,14 @@ const addDataListener = (client, queue, prefix, cb) =>
       .receiver(queue)
       .attach(source)
       .on('data', async raw => {
-        const buffer = Buffer.concat(raw.payload.chunks)
-        const payload = JSON.parse(buffer.toString())
-        const topic = raw.source.properties.to.replace(/^topic:\/*/, '')
+        const buffer = raw.payload && Buffer.concat(raw.payload.chunks)
+        const payload = buffer && _JSONorString(buffer.toString())
+        const topic =
+          raw.source &&
+          raw.source.properties &&
+          raw.source.properties.to &&
+          raw.source.properties.to.replace(/^topic:\/*/, '')
+        if (!topic) return raw.done()
         await cb(topic, payload, null, { done: raw.done, failed: raw.failed })
       })
       .on('subscribed', () => {

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

@@ -1,17 +1,15 @@
 const cds = require('../../cds')
 const LOG = cds.log('messaging')
 
-const MAX_NUMBER_RECONNECTS = 1000
 const MAX_WAITING_TIME = 1480000
 
 const _waitingTime = x => (x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) + Math.random()) * 1000)
 
-const _periodicallyReconnect = (client, x, n) => {
+const _connectUntilConnected = (client, x) => {
   setTimeout(() => {
     connect(client, true).catch(e => {
-      LOG._warn && LOG.warn(`Connection to Enterprise Messaging Client lost: Unsuccessful attempt to reconnect (${n}).`)
-      /* istanbul ignore else */
-      if (n < MAX_NUMBER_RECONNECTS) _periodicallyReconnect(client, x + 1, n + 1)
+      LOG._warn && LOG.warn(`Connection to Enterprise Messaging Client lost: Unsuccessful attempt to reconnect (${x}).`)
+      _connectUntilConnected(client, x + 1)
     })
   }, _waitingTime(x))
 }
@@ -30,22 +28,21 @@ const connect = (client, keepAlive) => {
           client.disconnect()
         })
 
+        if (keepAlive) {
+          client.once('disconnected', () => {
+            client.removeAllListeners('error')
+            client.removeAllListeners('connected')
+            _connectUntilConnected(client, 0)
+          })
+        }
+
         resolve(this)
       })
       .once('error', err => {
-        client.removeAllListeners('disconnected')
         client.removeAllListeners('connected')
         reject(err)
       })
 
-    if (keepAlive) {
-      client.once('disconnected', () => {
-        client.removeAllListeners('error')
-        client.removeAllListeners('connected')
-        _periodicallyReconnect(client, 0, 0)
-      })
-    }
-
     client.connect()
   })
 }

package/libx/_runtime/messaging/common-utils/naming-conventions.js

@@ -6,7 +6,7 @@ const _queueName = ({ appName, appID, ownNamespace }) => {
 const queueName = (options, optionsApp = {}) => {
   const namespace = options.credentials && options.credentials.namespace
   if (options.queue && options.queue.name) {
-    if (options.credentials.namespace) return options.queue.name.replace(/\$namespace/g, options.credentials.namespace)
+    if (namespace) return options.queue.name.replace(/\$namespace/g, namespace)
     return options.queue.name
   }
   const ownNamespace = namespace

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

@@ -65,7 +65,8 @@ class EndpointRegistry {
         const other = authInfo
           ? {
               _: { req: { authInfo, headers: {}, query: {} } }, // for messaging to retrieve subdomain
-              user: new cds.User.Privileged({ tenant: tenantId }) // usual tenant identification
+              user: new cds.User.Privileged(),
+              tenant: tenantId
             }
           : {}
         if (!cb) return res.sendStatus(200)

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

@@ -29,6 +29,20 @@ class MQManagement {
     return res.body
   }
 
+  async getQueues() {
+    const res = await authorizedRequest({
+      method: 'GET',
+      uri: this.options.url,
+      path: `/v1/management/queues`,
+      oa2: this.options.auth.oauth2,
+      attemptInfo: () => LOG._info && LOG.info('Get queues'),
+      errMsg: `Queues could not be retrieved`,
+      target: { kind: 'QUEUE' },
+      tokenStore: this
+    })
+    return res.body && res.body.results
+  }
+
   createQueue(queueName = this.queueName) {
     return authorizedRequest({
       method: 'PUT',
@@ -121,6 +135,10 @@ class MQManagement {
     }
     await Promise.all([...this.subscribedTopics].map(kv => kv[0]).map(t => this.createSubscription(t)))
   }
+
+  waitUntilReady() {
+    return this
+  }
 }
 
 class MessageQueuing extends AMQPWebhookMessaging {

package/libx/_runtime/remote/Service.js

@@ -5,14 +5,18 @@ const LOG = cds.log('remote')
 
 // disable sdk logger if not in debug mode
 if (!LOG._debug) {
-  const sdkUtils = require('@sap-cloud-sdk/util')
-  sdkUtils.setGlobalLogLevel('error')
+  try {
+    const sdkUtils = require('@sap-cloud-sdk/util')
+    sdkUtils.setGlobalLogLevel('error')
+  } catch (err) {
+    /* might fail in cds repl due to winston's exception handler, see cap/issues#10134 */
+  }
 }
 
 const { resolveView, getTransition, restoreLink, findQueryTarget } = require('../common/utils/resolveView')
 const { postProcess } = require('../common/utils/postProcessing')
 const { getKind, run, getDestination, getAdditionalOptions, getReqOptions } = require('./utils/client')
-const { formatVal } = require('../odata/cqn2odata')
+const { formatVal } = require('../../odata/utils')
 
 const _isSimpleCqnQuery = q => typeof q === 'object' && q !== null && !Array.isArray(q) && Object.keys(q).length > 0
 
@@ -125,6 +129,7 @@ class RemoteService extends cds.Service {
     }
 
     this.datasource = this.options.datasource
+    this.destinationOptions = this.options.destinationOptions
     this.destination =
       this.options.credentials.destination ||
       getDestination((this.definition && this.definition.name) || this.datasource, this.options.credentials)
@@ -133,6 +138,11 @@ class RemoteService extends cds.Service {
     this.path = this.options.credentials.path
     this.kind = getKind(this.options) // TODO: Simplify
 
+    const clearKeysFromData = function (req) {
+      if (req.target && req.target.keys) for (const k of Object.keys(req.target.keys)) delete req.data[k]
+    }
+    this.before('UPDATE', '*', Object.assign(clearKeysFromData, { _initial: true }))
+
     for (const each of this.entities) {
       for (const a in each.actions) {
         _addHandlerActionFunction(this, each.actions[a], each)
@@ -153,7 +163,13 @@ class RemoteService extends cds.Service {
       const resolvedTarget = resolvedTargetOfQuery(query) || getTransition(req.target, this).target
       const reqOptions = getReqOptions(req, query, this)
       reqOptions.headers = _setHeaders(reqOptions.headers, req)
-      const additionalOptions = getAdditionalOptions(req, this.destination, this.kind, resolvedTarget)
+      const additionalOptions = getAdditionalOptions(
+        req,
+        this.destination,
+        this.kind,
+        resolvedTarget,
+        this.destinationOptions
+      )
 
       // hidden compat flag in order to suppress logging response body of failed request
       if (req._suppressRemoteResponseBody) {

package/libx/_runtime/remote/utils/client-types.d.ts

@@ -0,0 +1,7 @@
+import sdkCore from '@sap-cloud-sdk/core'
+export interface DestinationOptions extends Omit<sdkCore.DestinationOptions, 'selectionStrategy'> {
+  /*
+   * @see https://sap.github.io/cloud-sdk/api/1.50.0/modules/sap_cloud_sdk_core#DestinationSelectionStrategies
+   */
+  selectionStrategy?: 'alwaysProvider' | 'alwaysSubscriber' | 'subscriberFirst'
+}