@sap/cds 7.7.3 → 7.8.1

package/libx/_runtime/common/utils/resolveView.js

@@ -625,7 +625,8 @@ const _getTransitionData = (target, columns, service, skipForbiddenViewCheck) =>
  * @param service
  * @param skipForbiddenViewCheck
  */
-const getTransition = (queryTarget, service, skipForbiddenViewCheck) => {
+const getTransition = (queryTarget, service, skipForbiddenViewCheck, event) => {
+  if (event) _event = event
   // Never resolve unknown targets (e.g. for drafts)
   if (!queryTarget) {
     return { target: queryTarget, queryTarget, mapping: new Map() }

package/libx/_runtime/common/utils/rewriteAsterisks.js

@@ -42,7 +42,7 @@ const _resolveTarget = (ref, target) => {
   const element = target.elements[_ref]
   if (element) return element._target
 
-  throw cds.error(`Navigation property '${_ref}' is not defined in type '${target.name}'`, { code: 400 })
+  throw cds.error(`Navigation property '${_ref}' is not defined in '${target.name}'`, { code: 400 })
 }
 
 const rewriteExpandAsterisk = (columns, target) => {

package/libx/_runtime/common/utils/stream.js

@@ -4,8 +4,6 @@ const { SELECT } = cds.ql
 const { deepCopyArray } = require('./copy')
 const { getTransition } = require('./resolveView')
 const { cqn2cqn4sql } = require('./cqn2cqn4sql')
-const getTemplate = require('./template')
-const templateProcessor = require('./templateProcessor')
 const { adaptStreamCQN } = require('../../fiori/utils/stream.js')
 const { isPathToDraft } = require('./cqn')
 
@@ -116,12 +114,4 @@ const enhanceStreamResult = async (req, query, result, model) => {
   }
 }
 
-const pick = element => {
-  return element['@Core.IsURL'] || element['@Core.MediaType']
-}
-
-const processFn = ({ row, key }) => {
-  delete row[key]
-}
-
 module.exports = { enhanceStreamResult }

package/libx/_runtime/common/utils/template.js

@@ -107,9 +107,14 @@ function _getTemplate(model, cache, targetEntity, callbacks, parent = null, _ent
     } else if (nextTarget) {
       // For associations and _typed_ structured elements, there's a (cacheable) target,
       // inline structures must be handled separately.
-      const subTemplate = _isInlineStructured(element)
-        ? _getTemplate(model, cache, nextTarget, callbacks, targetEntity, _entityMap, currentPath)
-        : cache.for(nextTarget, getTemplate(model, callbacks, targetEntity, _entityMap))
+      let subTemplate
+      if (_isInlineStructured(element))
+        subTemplate = _getTemplate(model, cache, nextTarget, callbacks, targetEntity, _entityMap, currentPath)
+      else if (cache.has(nextTarget)) subTemplate = cache.get(nextTarget)
+      else {
+        subTemplate = _getTemplate(model, cache, nextTarget, callbacks, targetEntity, _entityMap)
+        cache.set(nextTarget, subTemplate)
+      }
       _addSubTemplate(templateElements, elementName, subTemplate)
     }
   }
@@ -117,43 +122,23 @@ function _getTemplate(model, cache, targetEntity, callbacks, parent = null, _ent
   return template
 }
 
-const getTemplate =
-  (model, ...args) =>
-  (target, cache) =>
-    _getTemplate(model, cache, target, ...args)
-
-const getCache = (anything, cache, newCacheFn) => {
-  let _cached = cache.get(anything)
-  if (_cached) return _cached
-
-  _cached = (typeof newCacheFn === 'function' && newCacheFn(anything, cache)) || new Map()
-  _cached.for = (_usecase, _newCacheFn) => getCache(_usecase, _cached, _newCacheFn)
-  cache.set(anything, _cached)
-  return _cached
-}
-
 module.exports = (usecase, tx, target, ...args) => {
-  // get model first as it may be added to tx (cf. "_ensureModel") // REVISIT: _ensureModel is gone
+  if (!target) return
+
+  // REVISIT: tx.model === cds.context.model, but keep for usage stability
   const model = tx.model
   if (!model) return
 
-  // double-check with get target from model
-  // since target might come from anywhere like via cqn etc
-  if (!target) return
-  const root = (model && model.definitions[target.name]) || target
+  const root = model.definitions[target.name] || target
   if (!root) return
 
-  // tx could be the service itself -> prefer ApplicationService
-  // REVISIT: context._tx is not a stable API -> pls do not rely on that
-  const service = tx.context ? (tx.context.tx && Object.getPrototypeOf(tx.context.tx)) || Object.getPrototypeOf(tx) : tx
-  if (!service) return
+  if (!model._templateCache) Object.defineProperty(model, '_templateCache', { value: new Map() })
+  if (!model._templateCache.get(usecase)) model._templateCache.set(usecase, new WeakMap())
 
-  // cache templates at service for garbage collection
-  if (usecase && !service._templateCache) service._templateCache = new Map()
-  // model can be also a subset from tx
-
-  // if no usecase, don't save cache on the service object
-  return getCache(usecase, usecase ? service._templateCache : new Map())
-    .for(model)
-    .for(root, getTemplate(model, ...args))
+  let tmplt = model._templateCache.get(usecase).get(root)
+  if (!tmplt) {
+    tmplt = _getTemplate(model, model._templateCache.get(usecase), root, ...args)
+    model._templateCache.get(usecase).set(root, tmplt)
+  }
+  return tmplt
 }

package/libx/_runtime/db/Service.js

@@ -12,6 +12,10 @@ const queries = require('./query')
  */
 const generic = require('./generic')
 
+// not able to pass in stream method into cds.utils.deprecated for unknown reason
+// workaround: extract and deprecate helper function
+const _streamDeprecation = () => {}
+
 class DatabaseService extends cds.Service {
   constructor(...args) {
     super(...args)
@@ -91,7 +95,7 @@ class DatabaseService extends cds.Service {
   }
 
   stream(query) {
-    cds._logDeprecation('stream method is deprecated and will be removed in upcoming releases!')
+    cds.utils.deprecated(_streamDeprecation, { old: 'cds.stream' })()
     // aynchronous API: cds.stream(query)
     if (typeof query === 'object') {
       // eslint-disable-next-line no-async-promise-executor

package/libx/_runtime/db/utils/columns.js

@@ -22,7 +22,7 @@ const getColumns = (entity, { _4db, onlyKeys, omitStream } = { _4db: true, onlyK
   // REVISIT!!!
   const { structs = cds.env.features.ucsn_struct_conversion } = cds.env.effective.odata
   const { lean_draft } = cds.env.fiori
-  const elements = lean_draft ? entity.elements : Object.getPrototypeOf(entity.elements) || entity.elements
+  const elements = entity.elements
   for (const elementName in elements) {
     const element = elements[elementName]
     if (element['@cds.api.ignore']) continue

package/libx/_runtime/fiori/lean-draft.js

@@ -2,7 +2,10 @@ const cds = require('../cds'),
   { Object_keys } = cds.utils
 const { getTransition } = require('../common/utils/resolveView')
 const { getKeyData } = require('./utils/where')
-const { getPageSize } = require('../common/generic/paging')
+
+const { getPageSize, commonGenericPaging } = require('../common/generic/paging')
+const { handler: commonGenericSorting } = require('../common/generic/sorting')
+
 const LOG = cds.log('fiori|drafts')
 const original = Symbol('original')
 const DRAFT_PARAMS = Symbol('draftParams')
@@ -283,6 +286,10 @@ cds.ApplicationService.prototype.handle = async function (req) {
   }
 
   if (req.event === 'READ') {
+    // apply paging and sorting on original query for protocol adapters relying on it
+    commonGenericPaging(req)
+    commonGenericSorting(req)
+
     if (
       !Object.keys(draftParams).length &&
       !req.query._target.name?.endsWith('DraftAdministrativeData') &&
@@ -401,6 +408,10 @@ cds.ApplicationService.prototype.handle = async function (req) {
       req.reject(400, 'Action "draftActivate" can only be called on the root draft entity')
     }
 
+    if (req.target._etag && !req.headers['if-match'] && !req.headers['if-none-match']) {
+      req.reject(428)
+    }
+
     const targetDraft = req.target.drafts
     const cols = expandStarStar(targetDraft)
 
@@ -528,6 +539,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
   }
 
   req.query = query
+
   return handle(req)
 }
 
@@ -761,7 +773,7 @@ const Read = {
           : [...ownDrafts, ...actives]
 
     // runtime sort required
-    if (ownDrafts.length > 0 && actives.length > 0) {
+    if (orderByExpr && ownDrafts.length > 0 && actives.length > 0) {
       const locale = cds.context.locale.replaceAll('_', '-')
       const collatorMap = new Map()
       const elementNamesToSort = orderByExpr.map(orderByExp => orderByExp.ref.join('_'))

package/libx/_runtime/messaging/Outbox.js

@@ -1,13 +1,15 @@
 const cds = require('../cds')
 
-module.exports = class Outbox extends cds.Service {
+class Outbox extends cds.Service {
   constructor(...args) {
-    cds._logDeprecation(
-      'Internal class `OutboxService` is deprecated and will be removed. Services are outboxable via config or `cds.outboxed()`.'
-    )
-
     super(...args)
 
     if (this.options.outbox) return cds.outboxed(this)
   }
 }
+
+module.exports = cds.utils.deprecated(() => Outbox, {
+  kind: 'Class',
+  old: 'Outbox',
+  use: 'config or cds.outboxed() to outbox your service'
+})()

package/libx/_runtime/messaging/kafka.js

@@ -0,0 +1,266 @@
+const cds = require('../cds')
+// eslint-disable-next-line
+const { Kafka } = require('kafkajs')
+
+class KafkaService extends cds.MessagingService {
+  async init() {
+    await super.init()
+
+    // We might also support subscribeTopic and publishTopic in the future
+    // but we keep it as simple as possible for now.
+
+    this._topics_in_kafka = new Set()
+
+    this._cachedKeyFns = new Map()
+
+    // TODO: Make configurable
+    this.appId = appId()
+
+    if (!this.options.local && !this.options.credentials) {
+      throw new Error(
+        'No Kafka credentials found.\n\nHint: You need to bind your application to a Kafa service instance.'
+      )
+    }
+
+    const config = this.options.local ? await _getConfigLocal(this) : await _getConfig(this)
+    this.client = new Kafka(config)
+
+    // check for proper credentials
+    const producer = this.client.producer()
+    await producer.connect()
+    await producer.disconnect()
+
+    cds.once('listening', () => {
+      this.startListening()
+    })
+  }
+
+  async handle(msg) {
+    if (msg.inbound) return super.handle(msg)
+    const _msg = this.message4(msg)
+    this.LOG._info && this.LOG.info('Emit', { topic: _msg.event })
+    if (!this.producer) {
+      this.producer = this.client.producer()
+      await this.producer.connect()
+    }
+    // In the future, we might allow to set the topic manually:
+    // const topic = _msg.headers?.["@kafka.topic"] ?? this.options.topic;
+    const topic = this.options.topic
+    let key = _msg.headers['@kafka.key']
+
+    if (!key) {
+      let keyFn = this._cachedKeyFns.get(_msg.event)
+      if (keyFn === undefined) {
+        // `null` means there is no keyFn for that event
+        keyFn = _getKeyFn(_msg.event)
+        this._cachedKeyFns.set(_msg.event, keyFn)
+      }
+      key = keyFn?.(_msg.data)
+    }
+
+    const headers = { ...(_msg.headers || {}) }
+    headers['x-sap-cap-effective-topic'] = _msg.event
+    delete headers['@kafka.key']
+    // delete headers["@kafka.topic"];
+    const tenant = cds.context?.tenant
+    if (tenant) headers['x-sap-cap-tenant-id'] = tenant
+    const message = {
+      value: (typeof _msg.data === 'string' && _msg.data) || JSON.stringify(_msg.data),
+      headers
+    }
+    if (key) message.key = key
+    await this._ensureTopicsExist([topic])
+    const payload = {
+      topic,
+      messages: [message]
+    }
+    if (this.LOG._debug) this.LOG.debug('Sending', payload)
+    await this.producer.send(payload)
+  }
+
+  async _ensureTopicsExist(topics) {
+    const toBeCheckedTopics = topics.filter(t => !this._topics_in_kafka.has(t))
+    if (!toBeCheckedTopics.length) return
+    const admin = this.client.admin()
+    await admin.connect()
+
+    const existingTopics = await admin.listTopics()
+    const missingTopics = toBeCheckedTopics.filter(t => !existingTopics.includes(t))
+    if (missingTopics.length) {
+      this.LOG._info && this.LOG.info(`Creating topics: ${missingTopics}`)
+      await admin.createTopics({ topics: missingTopics.map(t => ({ topic: t })) })
+      // Let's just cache used ones
+      for (const missingTopic of missingTopics) this._topics_in_kafka.add(missingTopic)
+    }
+  }
+
+  async startListening() {
+    const consumer = this.client.consumer({ groupId: this.appId })
+    await consumer.connect()
+
+    // In the future, we might allow to support the annotation @kafka.topic
+    // but then, we'd need to collect them like this:
+    // const topics = []
+    // const messaging = cds.env.requires.messaging && await cds.connect.to('messaging')
+    // if (messaging) {
+    //   for (const [_, declared] of messaging._registeredEvents) {
+    //     for (const [_, event] of this.subscribedTopics) {
+    //       const kafkaTopic = declared['@kafka.topic']
+    //       // `this` only knows about the subscribed topics (from `@topic` of fully-qualified name)
+    //       if (kafkaTopic && (declared['@topic'] === event || declared.name === event)) {
+    //         topics.push(kafkaTopic)
+    //       }
+    //     }
+    //   }
+    // }
+    // this.subscribeTopics = this.subscribeTopics.concat(topics)
+
+    await this._ensureTopicsExist([this.options.topic])
+
+    this.LOG._info && this.LOG.info(`Subscribe to ${this.options.topic}`)
+    await consumer.subscribe({ topics: [this.options.topic] })
+    await consumer.run({
+      eachMessage: async raw => {
+        try {
+          const msg = _normalizeIncomingMessage(raw.message.value.toString())
+          msg.headers = {}
+          for (const header in raw.message.headers || {}) {
+            msg.headers[header] = raw.message.headers[header]?.toString()
+          }
+          msg.event =
+            raw.message.headers['x-sap-cap-effective-topic']?.toString() ?? raw.message.headers.type?.toString()
+          msg.tenant = raw.message.headers['x-sap-cap-tenant-id']
+          if (!msg.event) return
+
+          await this.tx({ user: cds.User.privileged, tenant: msg.tenant }, tx => tx.emit(msg))
+        } catch (e) {
+          if (e.code === 'NO_HANDLER_FOUND') return // consume
+          this.LOG.error('ERROR occured in asynchronous event processing:', e)
+          throw e
+        }
+      }
+    })
+  }
+}
+
+module.exports = KafkaService
+
+// TODO: Make public?
+const appId = require('./common-utils/appId')
+
+function _JSONorString(string) {
+  try {
+    return JSON.parse(string)
+  } catch (e) {
+    return string
+  }
+}
+
+function _normalizeIncomingMessage(message) {
+  const _payload = _JSONorString(message)
+  let data, headers
+  if (typeof _payload === 'object' && 'data' in _payload) {
+    data = _payload.data
+    headers = { ..._payload }
+    delete headers.data
+  } else {
+    data = _payload
+    headers = {}
+  }
+
+  return {
+    data,
+    headers,
+    inbound: true
+  }
+}
+
+function _getDef(topicOrEvent) {
+  const found = cds?.model.definitions[topicOrEvent]
+  if (found) return found
+
+  for (const def in cds.model?.definitions) {
+    const definition = cds.model.definitions[def]
+    if (definition['@topic'] === topicOrEvent) return definition
+  }
+}
+
+function _getKeyFn(topicOrEvent) {
+  const definition = _getDef(topicOrEvent)
+  if (!definition) return null
+  const keys = []
+  for (const el in definition.elements) {
+    // definition.keys doesn't seem to work
+    const element = definition.elements[el]
+    if (element.key) keys.push(element.name)
+  }
+  if (keys.length) {
+    keys.sort()
+    return data =>
+      JSON.stringify(
+        keys.reduce((res, curr) => {
+          res[curr] = data[curr]
+          return res
+        }, {})
+      )
+  }
+  return null
+}
+
+async function _getConfig(srv) {
+  const caCerts = await _getCaCerts(srv)
+  return {
+    clientId: srv.appId,
+    // logLevel: 4,
+    connectionTimeout: 15000,
+    authenticationTimeout: 15000,
+    brokers: srv.options.credentials.cluster?.['brokers.client_ssl'].split(','),
+    ssl: {
+      rejectUnauthorized: true,
+      ca: caCerts,
+      key: srv.options.credentials.clientkey,
+      cert: srv.options.credentials.clientcert
+    }
+  }
+}
+
+async function _getConfigLocal() {
+  const creds = await fetch('http://localhost:8004/v1/credentials', {
+    headers: { encoding: 'utf-8', accept: 'application/json' }
+  }).then(r => r.json())
+
+  const url = 'http://localhost:8005/v1/undefined/token'
+  const token = await fetch(url, {
+    method: 'POST',
+    body: JSON.stringify({ grant_type: 'client_credentials' }),
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      encoding: 'utf-8',
+      Authorization: 'Basic ' + Buffer.from(`${creds.username}:${creds.password}`, 'utf-8').toString('base64')
+    }
+  })
+    .then(r => r.json())
+    .then(r => r.access_token)
+  return {
+    brokers: ['127.0.0.1:19093', '127.0.0.1:29093', '127.0.0.1:39093'],
+    ssl: {
+      rejectUnauthorized: false
+    },
+    sasl: {
+      mechanism: 'plain',
+      username: creds.username,
+      password: token
+    }
+  }
+}
+
+async function _getCaCerts(srv) {
+  const certCurrent = await fetch(srv.options.credentials.urls.cert_current).then(r => r.text())
+  try {
+    const certNext = await fetch(srv.options.credentials.urls.cert_next).then(r => r.text())
+    return [certCurrent, certNext]
+  } catch (_e) {
+    return [certCurrent]
+  }
+}

package/libx/_runtime/messaging/service.js

@@ -6,12 +6,14 @@ const appId = require('./common-utils/appId')
 
 const _topic = declared => declared['@topic'] || declared.name
 
+const _stripTopicPrefix = event => event.replace(/topic:/, '')
+
 const _warnAndStripTopicPrefix = event => {
-  if (event.startsWith('topic:')) {
-    cds._logDeprecation('The topic prefix `topic:` is deprecated and has no effect. Please remove it.')
-    // backwards compatibility
-    event = event.replace(/topic:/, '')
-  }
+  if (event.startsWith('topic:'))
+    event = cds.utils.deprecated(_stripTopicPrefix, {
+      kind: '',
+      old: 'Unnecessary topic prefix "topic:"'
+    })(event)
   return event
 }
 

package/libx/_runtime/sqlite/convertDraftAdminPathExpression.js

@@ -2,6 +2,7 @@ const cds = require('../cds')
 
 function sqliteConvertDraftAdminPathExpression(req) {
   if (req.query?.SELECT?.from?.SET) return // not supported, won't happen in draft
+  if (req.query?.SELECT?.from?.args) return // not supported, won't happen in draft
   if (
     !req.query?.SELECT ||
     !req.query?._target?.name?.endsWith('.drafts') ||

package/libx/common/assert/validation.js

@@ -64,7 +64,7 @@ const checkMandatory = (v, ele, errs, path, k) => {
   // do not complain about ???
   if (ele.parent?.query?.SELECT?.columns?.find(col => _isNavigationColumn(col, ele.name))) return
 
-  if (!ele.default && _isNotFilled(v)) {
+  if (_isNotFilled(v)) {
     const target = getTarget(path, k)
     errs.push(new cds.error('ASSERT_NOT_NULL', { target, statusCode: 400, code: '400' }))
   }

package/libx/odata/index.js

@@ -28,7 +28,9 @@ const strict = {
     minute: 1,
     second: 1,
     time: 1,
-    now: 1
+    now: 1,
+    round: 1,
+    date: 1
   }
 }
 
@@ -54,6 +56,7 @@ const enhanceCqn = (cqn, options) => {
   if (cqn.__target) query.__target = cqn.__target
   if (cqn._propertyAccess)
     Object.defineProperty(query, '_propertyAccess', { value: cqn._propertyAccess, enumerable: false })
+
   return query
 }
 
@@ -83,6 +86,9 @@ module.exports = {
       }
 
       let offset = err.location && err.location.start.offset
+      if (!offset && err.statusCode && err.message) {
+        throw err
+      }
       if (options.baseUrl) {
         // we need to add the number of chars from base url to the offset
         offset += options.baseUrl.length
@@ -94,7 +100,7 @@ module.exports = {
       throw err
     }
 
-    //cqn is an array, if concat is used
+    // cqn is an array, if concat is used
     if (Array.isArray(cqn)) {
       for (let i = 0; i < cqn.length; i++) {
         cqn[i] = enhanceCqn(cqn[i], options)