@sap/cds 9.5.1 → 9.6.0

package/libx/queue/index.js

@@ -8,14 +8,19 @@ const taskRunner = new TaskRunner()
 
 const { expBkfFix: waitingTime } = require('../_runtime/common/utils/waitingTime')
 
+const QUEUE = 'queue'
 const PROCESSING = 'processing'
+
 const INTERNAL_USER = 'cds.internal.user'
+// prettier-ignore
+const TO_COPY = ['inbound', 'event', 'data', 'headers', 'queue', 'results', 'method', 'path', 'params', 'entity', 'service']
 
 const $taskProcessorRegistered = Symbol('task processor registered')
 const $queued = Symbol('queued')
 const $unqueued = Symbol('unqueued')
 const $stored_reqs = Symbol('stored_reqs')
 const $error = Symbol('error')
+const $service = Symbol('service')
 
 const _get100NanosecondTimestampISOString = (offset = 0) => {
   const [now, nanoseconds] = [new Date(Date.now() + offset), process.hrtime()[1]]
@@ -58,31 +63,30 @@ const _targetName = (name, opts) => (opts.targetPrefix ? opts.targetPrefix + nam
 // Process messages (in parallel or sequentially)
 // tx2 (legacyLocking: tx1): Update/Delete messages based on outcome, set status to null
 //
-const processTasks = (service, tenant, _opts = {}) => {
+const _processTasks = (target, tenant, _opts = {}) => {
   const opts = Object.assign({ attempt: 0 }, _opts)
   if (!opts.parallel) opts.chunkSize = 1
 
   // Add the current done callback if provided
   if (opts.done) {
-    taskRunner.addCallback({ name: service.name, tenant }, opts.done)
+    taskRunner.addCallback({ name: target, tenant }, opts.done)
     delete opts.done // Remove to avoid re-adding in recursive calls
   }
 
-  const name = service.name
   const tasksEntity = _getTasksEntity()
 
   let letAppCrash = false
 
   const __done = () => {
     if (letAppCrash) cds.exit(1)
-    taskRunner.end({ name, tenant }, () => processTasks(service, tenant, opts))
+    taskRunner.end({ name: target, tenant }, () => _processTasks(target, tenant, opts))
   }
   const _done = () => {
     if (!opts.legacyLocking) __done()
     // else will be handled in spawn
   }
 
-  return taskRunner.run({ name, tenant }, () => {
+  return taskRunner.run({ name: target, tenant }, () => {
     const config = tenant ? { tenant, user: cds.User.privileged } : { user: cds.User.privileged }
     config.after = 1 // make sure spawn puts its cb on the `timer` queue (via setTimeout), which is also used by `taskRunner`
 
@@ -102,8 +106,12 @@ const processTasks = (service, tenant, _opts = {}) => {
         else currMinWaitingTime = Math.min(currMinWaitingTime, time)
       }
 
+      const whereClause = { target: _targetName(target, opts) }
+      // Fallback: To flush messages which have been stored with target = service.name
+      if (target === QUEUE && opts[$service]) whereClause.or = { target: _targetName(opts[$service], opts) }
+
       const tasksQuery = SELECT.from(tasksEntity)
-        .where({ target: _targetName(name, opts) })
+        .where(whereClause)
         .orderBy(opts.parallel ? ['status', 'timestamp', 'ID'] : ['timestamp', 'status', 'ID'])
         .limit(opts.chunkSize)
         .forUpdate()
@@ -117,7 +125,7 @@ const processTasks = (service, tenant, _opts = {}) => {
         // it would (in the worst case) select <chunkSize> messages which are all in process
         // and not yet timed out, hence only <chunkSize> messages could be processed at any given time.
       }
-      LOG._debug && LOG.debug(`${name}: Fetch messages`)
+      LOG._debug && LOG.debug(`${target}: Fetch messages`)
       try {
         // Use dedicated transaction to fetch relevant messages
         // and _immediately_ set their status to 'processing' and commit
@@ -154,7 +162,7 @@ const processTasks = (service, tenant, _opts = {}) => {
           // Note: There's also no scheduling for tasks which are not yet timed out.
           if (!processableTasks.length) return [] // all in process
           // prettier-ignore
-          LOG._debug && LOG.debug(`${name}: Process ${processableTasks.length} ${processableTasks.length > 1 ? 'messages' : 'message'}`)
+          LOG._debug && LOG.debug(`${target}: Process ${processableTasks.length} ${processableTasks.length > 1 ? 'messages' : 'message'}`)
           if (!opts.legacyLocking) {
             await UPDATE(tasksEntity)
               .set({ status: PROCESSING })
@@ -166,44 +174,53 @@ const processTasks = (service, tenant, _opts = {}) => {
         // could potentially be a timeout
         const _waitingTime = waitingTime(opts.attempt)
         // prettier-ignore
-        LOG.error(`${name}: Message retrieval failed`, e, `Retry${_waitingTime > 0 ? ` in ${Math.round(_waitingTime / 1000)} s` : ''}`)
+        LOG.error(`${target}: Message retrieval failed`, e, `Retry${_waitingTime > 0 ? ` in ${Math.round(_waitingTime / 1000)} s` : ''}`)
         taskRunner.plan(
           {
-            name,
+            name: target,
             tenant,
             waitingTime: _waitingTime
           },
-          () => processTasks(service, tenant, { ...opts, attempt: opts.attempt + 1 })
+          () => _processTasks(target, tenant, { ...opts, attempt: opts.attempt + 1 })
         )
         return _done()
       }
+
       const tasksGen = function* () {
-        for (const task of selectedTasks) {
-          const _msg = _safeJSONParse(task.msg)
+        for (const _task of selectedTasks) {
+          const _msg = _safeJSONParse(_task.msg)
+
           const context = _msg.context || {}
-          const userId = _msg[INTERNAL_USER]
-          if (_msg.query) {
-            const q = (_msg.query = cds.ql(_msg.query))
-            q.bind(service)
-            _msg.target = cds.infer.target(q)
-          }
+          delete _msg.context
 
-          const msg = _msg._fromSend ? new cds.Request(_msg) : new cds.Event(_msg)
-          delete msg._fromSend
-          delete msg[INTERNAL_USER]
+          const userId = _msg[INTERNAL_USER]
+          delete _msg[INTERNAL_USER]
           const user = new cds.User.Privileged(userId)
           context.user = user
+
+          // The latter is for backwards compatibility where `service` was not stored and `target` was the service name
+          const srvName = _msg.service || _task.target
+          delete _msg.service
+
+          const fromSend = _msg._fromSend
+          delete _msg._fromSend
+
+          const msg = fromSend ? new cds.Request(_msg) : new cds.Event(_msg)
           if (!msg) continue
-          const res = {
-            ID: task.ID,
+
+          const task = {
+            ID: _task.ID,
             msg,
             context,
-            attempts: task.attempts || 0
+            srvName,
+            attempts: _task.attempts || 0
           }
-          yield res
+
+          yield task
         }
       }
 
+      const succeeded = []
       const toBeDeleted = []
       const toBeUpdated = []
       const toBeCreated = []
@@ -212,17 +229,26 @@ const processTasks = (service, tenant, _opts = {}) => {
       let minAttemptFailed
       try {
         const _handleWithErr = async task => {
+          const service = cds.unqueued(await cds.connect.to(task.srvName))
           try {
+            if (task.msg.query) {
+              const q = (task.msg.query = cds.ql(task.msg.query))
+              q.bind(service)
+              task.msg.target = cds.infer.target(q)
+            }
+
             // REVISIT: Shouldn't that work like a standard inbound adapter? I.e. either of:
             // - cds._with({...}, ()=> srv.dispatch(task.msg)) // instead of srv.handle(task.msg)
             // - cds.tx({...}, ()=> srv.dispatch(task.msg)) // instead of srv.handle(task.msg)
             // Problem: If task involves db, dedicated transactions will block on SQLite if an outer transaction is open
             const _run = opts.legacyLocking && cds.db?.kind === 'sqlite' ? cds._with : service.tx.bind(service)
             const result = await _run({ ...task.context, tenant }, async () => {
-              return opts.handle ? await opts.handle.call(service, task.msg) : await service.handle(task.msg)
+              const result = opts.handle ? await opts.handle.call(service, task.msg) : await service.handle(task.msg)
+              await DELETE.from(tasksEntity).where({ ID: task.ID })
+              return result
             })
             task.results = result
-            toBeDeleted.push(task)
+            succeeded.push(task)
           } catch (e) {
             if (!minAttemptFailed) minAttemptFailed = task.attempts
             else minAttemptFailed = Math.min(minAttemptFailed, task.attempts)
@@ -253,7 +279,7 @@ const processTasks = (service, tenant, _opts = {}) => {
           const res = await Promise.allSettled([...tasks].map(_handleWithErr))
           const errors = res.filter(r => r.status === 'rejected').map(r => r.reason)
           if (errors.length) {
-            throw new Error(`${service.name}: Programming errors detected.`)
+            throw new Error(`${target}: Programming errors detected.`)
           }
         } else {
           // In principle, this branch is not needed as for `parallel == false`, there's only one chunk at a time,
@@ -279,7 +305,10 @@ const processTasks = (service, tenant, _opts = {}) => {
 
       // There can be tasks which are not updated / deleted, their status must be set back to `null`
       const updateTasks = selectedTasks.filter(
-        task => !toBeDeleted.some(t => t.ID === task.ID) && !toBeUpdated.some(t => t.ID === task.ID)
+        task =>
+          !toBeDeleted.some(t => t.ID === task.ID) &&
+          !succeeded.some(t => t.ID === task.ID) &&
+          !toBeUpdated.some(t => t.ID === task.ID)
       )
       if (updateTasks.length) {
         queries.push(
@@ -290,7 +319,7 @@ const processTasks = (service, tenant, _opts = {}) => {
       }
 
       for (const each of toBeUpdated) {
-        if (toBeDeleted.some(d => d.ID === each.ID)) continue
+        if (toBeDeleted.some(d => d.ID === each.ID) || succeeded.some(d => d.ID === each.ID)) continue
         each.updateData.status = null
         if (opts.storeLastError !== false) each.updateData.lastError = inspect(each[$error])
         if (each.updateData.lastError && typeof each.updateData.lastError !== 'string') {
@@ -312,7 +341,7 @@ const processTasks = (service, tenant, _opts = {}) => {
         return newMsg
       }
 
-      const _failed = task => {
+      const _failed = async task => {
         const msg = _newMsgFrom(task.msg)
         msg.event = msg.event + '/#failed'
         const _errorToObj = error => {
@@ -326,25 +355,27 @@ const processTasks = (service, tenant, _opts = {}) => {
           }
         }
         msg.results = _errorToObj(task[$error])
+        const service = await cds.connect.to(task.srvName)
         if (service.handlers.on.some(h => h.for(msg)) || service.handlers.after.some(h => h.for(msg))) {
-          toBeCreated.push(_createTask(service.name, msg, task.context, opts))
+          toBeCreated.push(_createTask(target, msg, task.context, task.srvName, opts))
         }
       }
 
-      const _succeeded = task => {
+      const _succeeded = async task => {
         const msg = _newMsgFrom(task.msg)
         msg.event = msg.event + '/#succeeded'
+        const service = await cds.connect.to(task.srvName)
         if (service.handlers.on.some(h => h.for(msg)) || service.handlers.after.some(h => h.for(msg))) {
-          toBeCreated.push(_createTask(service.name, msg, task.context, opts))
+          toBeCreated.push(_createTask(target, msg, task.context, task.srvName, opts))
         }
       }
 
-      for (const task of toBeDeleted) {
+      for (const task of succeeded) {
         // invoke succeeded handlers
         if (!task.msg.event.endsWith('/#succeeded') && !task.msg.event.endsWith('/#failed')) {
           if (!task.error) {
             // skip programming errors & unrecoverable without maxAttempts
-            _succeeded(task)
+            await _succeeded(task)
           }
         }
 
@@ -352,7 +383,7 @@ const processTasks = (service, tenant, _opts = {}) => {
         if (task.msg.queue?.every) {
           const _m = { ...task.msg }
           _m._fromSend = task.msg instanceof cds.Request
-          const _task = _createTask(service.name, _m, task.context, opts)
+          const _task = _createTask(target, _m, task.context, task.srvName, opts)
           _task.timestamp = _get100NanosecondTimestampISOString(task.msg.queue.every)
           toBeCreated.push(_task)
         }
@@ -365,7 +396,7 @@ const processTasks = (service, tenant, _opts = {}) => {
           opts.maxAttempts &&
           task.updateData.attempts >= opts.maxAttempts
         ) {
-          _failed(task)
+          await _failed(task)
         }
       }
 
@@ -374,40 +405,40 @@ const processTasks = (service, tenant, _opts = {}) => {
       if (queries.length) {
         await _tx(() => Promise.all(queries))
         // prettier-ignore
-        LOG._debug && LOG.debug(`${name}: Messages modified (-${toBeDeleted.length}, ~${toBeUpdated.length + updateTasks.length}, +${toBeCreated.length})`)
+        LOG._debug && LOG.debug(`${target}: Messages modified (-${toBeDeleted.length + succeeded.length}, ~${toBeUpdated.length + updateTasks.length}, +${toBeCreated.length})`)
       }
 
       if (letAppCrash) return _done()
 
       if (toBeUpdated.length) {
-        LOG.error(`${name}: Some messages could not be processed`)
+        LOG.error(`${target}: Some messages could not be processed`)
         _setWaitingTime(waitingTime(minAttemptFailed + 1))
       }
-      if (toBeDeleted.length === opts.chunkSize || toBeCreated.length) {
+      if (toBeDeleted.length + succeeded.length === opts.chunkSize || toBeCreated.length) {
         _setWaitingTime(0)
       }
       if (currMinWaitingTime !== undefined) {
         // prettier-ignore
-        LOG._debug && LOG.debug(`${name}: Process${currMinWaitingTime > 0 ? ` in ${Math.round(currMinWaitingTime / 1000)} s` : ''}`)
+        LOG._debug && LOG.debug(`${target}: Process${currMinWaitingTime > 0 ? ` in ${Math.round(currMinWaitingTime / 1000)} s` : ''}`)
         taskRunner.plan(
           {
-            name,
+            name: target,
             tenant,
             waitingTime: currMinWaitingTime
           },
-          () => processTasks(service, tenant, opts)
+          () => _processTasks(target, tenant, opts)
         )
         return _done()
       }
 
-      LOG._debug && LOG.debug(`${name}: Done`)
+      LOG._debug && LOG.debug(`${target}: Done`)
       return _done()
     }, config)
     _end(spawn)
   })
 }
 
-const registerTaskProcessor = (name, context) => {
+const _registerTaskProcessor = (name, context) => {
   const registry = context[$taskProcessorRegistered] || (context[$taskProcessorRegistered] = new Set())
   if (!registry.has(name)) {
     registry.add(name)
@@ -416,8 +447,13 @@ const registerTaskProcessor = (name, context) => {
   return false
 }
 
-const _createTask = (name, msg, context, taskOpts) => {
-  const _msg = { [INTERNAL_USER]: context.user.id }
+const _createTask = (name, msg, context, serviceName, taskOpts) => {
+  // REVISIT: use something like $cds for control data
+  const _msg = {
+    [INTERNAL_USER]: context.user.id,
+    service: serviceName
+  }
+
   const _newContext = {}
   for (const key in context) {
     if (!taskOpts.ignoredContext.includes(key)) _newContext[key] = context[key]
@@ -425,9 +461,9 @@ const _createTask = (name, msg, context, taskOpts) => {
   _msg.context = _newContext
 
   if (msg._fromSend || msg.reply) _msg._fromSend = true // send or emit?
-  for (const prop of ['inbound', 'event', 'data', 'headers', 'queue', 'results', 'method', 'path', 'params', 'entity']) {
-    if (msg[prop]) _msg[prop] = msg[prop]
-  }
+
+  for (const prop of TO_COPY) if (msg[prop]) _msg[prop] = msg[prop]
+
   if (msg.query) {
     _msg.query = typeof msg.query.flat === 'function' ? msg.query.flat() : msg.query
     delete _msg.query._target
@@ -435,17 +471,19 @@ const _createTask = (name, msg, context, taskOpts) => {
     delete _msg.query.target
     delete _msg.data // `req.data` should be a getter to whatever is in `req.query`
   }
+
   const taskMsg = {
     ID: cds.utils.uuid(),
     target: _targetName(name, taskOpts),
     timestamp: _get100NanosecondTimestampISOString(msg.queue?.after), // needs to be different for each emit
     msg: JSON.stringify(_msg)
   }
+
   return taskMsg
 }
 
-const writeInQueue = async (name, msg, context, taskOpts) => {
-  const taskMsg = _createTask(name, msg, context, taskOpts)
+const _writeInQueue = async (name, msg, context, serviceName, taskOpts) => {
+  const taskMsg = _createTask(name, msg, context, serviceName, taskOpts)
   const tasksEntity = _getTasksEntity()
   LOG._debug && LOG.debug(`${name}: Write message to queue`)
   return INSERT.into(tasksEntity).entries(taskMsg)
@@ -455,7 +493,14 @@ exports.unqueued = function unqueued(srv) {
   return srv[$unqueued] || srv
 }
 
-exports.queued = function queued(srv, customOpts) {
+exports.queued = function queued(srv, opts) {
+  // REVISIT: officially deprecate `outbox`
+  if ('outbox' in cds.requires) {
+    if (typeof cds.requires.outbox === 'object') Object.assign(cds.requires.queue, cds.requires.outbox)
+    else cds.requires.queue = cds.requires.outbox
+  }
+  if ('outbox' in srv.options) srv.options.outboxed = srv.options.outbox
+
   // queue max. once
   if (!new.target) {
     const former = srv[$queued]
@@ -468,28 +513,17 @@ exports.queued = function queued(srv, customOpts) {
 
   if (!new.target) Object.defineProperty(srv, $queued, { value: queuedSrv })
 
-  let requiresOpts = cds.requires.queue
-  if (cds.requires.outbox !== undefined) {
-    cds.utils.deprecated({ old: 'cds.requires.outbox', use: 'cds.requires.queue' })
-    requiresOpts = cds.requires.outbox ? Object.assign({}, requiresOpts, cds.requires.outbox) : false
-  }
-
-  let serviceOpts = srv.options?.queued ?? srv.options?.outboxed
-  if (srv.options?.outbox !== undefined) {
-    // REVISIT: cds.utils.deprecated({ old: 'cds.requires.<srv>.outbox', use: 'cds.requires.<srv>.queued or cds.requires.<srv>.outboxed' })
-    serviceOpts = srv.options.outbox ? Object.assign({}, serviceOpts, srv.options.outbox) : false
+  const queueCfg = srv.options?.queued ?? srv.options?.outboxed
+  if (queueCfg && typeof queueCfg === 'object') {
+    if (opts) opts = Object.assign(queueCfg, opts)
+    else opts = queueCfg
   }
+  const queueOpts = opts
+    ? Object.assign({}, cds.requires.queue, opts)
+    : cds.requires[typeof queueCfg === 'string' ? queueCfg : QUEUE]
+  const queueName = opts ? srv.name : typeof queueCfg === 'string' ? queueCfg : QUEUE // Generated name for the queue of that service
 
-  if (typeof requiresOpts === 'string') requiresOpts = { kind: requiresOpts }
-  if (typeof serviceOpts === 'string') serviceOpts = { kind: serviceOpts }
-
-  const queueOpts = Object.assign(
-    {},
-    (typeof requiresOpts === 'object' && requiresOpts) || {},
-    (typeof serviceOpts === 'object' && serviceOpts) || {},
-    customOpts || {}
-  )
-
+  // REVISIT: shouldn't it be "queued"? -> normalize during bootstrapping and here (for ad-hoc queue config)
   queuedSrv.outboxed = queueOpts // Store effective outbox configuration (e.g. used in telemetry)
 
   queuedSrv.handle = async function (req) {
@@ -499,15 +533,15 @@ exports.queued = function queued(srv, customOpts) {
       _hasPersistentQueue(context.tenant)
     ) {
       // returns true if not yet registered
-      if (registerTaskProcessor(srv.name, context)) {
+      if (_registerTaskProcessor(srv.name, context)) {
         // NOTE: What if there are different queue options for the same service?!
         //       There could be tasks for srv1 with { maxAttempts: 1 }
         //       and tasks for srv1 with { maxAttempts: 9 }.
         //       How would they be processed? I'd rather not have dedicated
         //       service names or store serialized options for each task.
-        context.on('succeeded', () => processTasks(originalSrv, context.tenant, queueOpts))
+        context.on('succeeded', () => _processTasks(queueName, context.tenant, queueOpts))
       }
-      await writeInQueue(srv.name, req, context, queueOpts)
+      await _writeInQueue(queueName, req, context, srv.name, queueOpts)
       return
     }
 
@@ -533,13 +567,22 @@ exports.queued = function queued(srv, customOpts) {
     context[$stored_reqs].push(req)
   }
 
-  queuedSrv.flush = function flush(tenant = cds.context?.tenant, opts) {
-    // Flush resolves once there's nothing to do _now_. But there can still be
-    // messages with _future_ timestamps. Those are then planned with the scheduler service.
-    return new Promise(resolve =>
-      processTasks(originalSrv, tenant, Object.assign({ done: resolve }, queueOpts, opts))
-    )
+  // REVISIT:
+  // Not great to have `flush` on the service, because it will flush the corresponding queue.
+  // A better API would be: (await cds.connect.to('queueName')).flush()
+  // But the current logic of connect.to doesn't allow having a model but no service.
+  queuedSrv.flush = function flush(opts) {
+    queueOpts[$service] = srv.name
+    const tenant = cds.context?.tenant
+    return new Promise(resolve => _processTasks(queueName, tenant, Object.assign({ done: resolve }, queueOpts, opts)))
   }
 
   return queuedSrv
 }
+
+exports.cdsFlush = function cdsFlush(target, opts) {
+  if (typeof target === 'object') [opts, target] = [target, QUEUE]
+  const tenant = cds.context?.tenant
+  const queueOpts = Object.assign({}, cds.requires.queue, cds.requires[target] || {}, opts || {})
+  return new Promise(resolve => _processTasks(target, tenant, Object.assign({ done: resolve }, queueOpts)))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "9.5.1",
+  "version": "9.6.0",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -34,7 +34,7 @@
   "dependencies": {
     "@sap/cds-compiler": "^6.3",
     "@sap/cds-fiori": "^2",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.1"
   },
   "peerDependencies": {
     "@eslint/js": "^9",

package/srv/outbox.cds

@@ -10,4 +10,6 @@ entity Messages {
       lastError            : LargeString;
       lastAttemptTimestamp : Timestamp @cds.on.update: $now;
       status               : String(23);
+      task                 : String(255);
+      appid                : String(255);
 }

package/tasks/enterprise-messaging-deploy.js

@@ -5,12 +5,14 @@ const authorizedRequest = require('../libx/_runtime/messaging/common-utils/autho
 const cds = require('../libx/_runtime/cds.js')
 const LOG = cds.log('messaging')
 
-const VCAPSERVICESstr = process.env.VCAP_SERVICES
-if (!VCAPSERVICESstr) throw new Error('Please provide environment variable `VCAP_SERVICES`')
-const VCAPSERVICES = JSON.parse(process.env.VCAP_SERVICES)
+let vcap_services = process.env.VCAP_SERVICES_FILE_PATH
+  ? cds.utils.fs.readFileSync(process.env.VCAP_SERVICES_FILE_PATH, 'utf-8')
+  : process.env.VCAP_SERVICES
+if (!vcap_services) throw new Error('Please provide environment variable `VCAP_SERVICES`')
+vcap_services = JSON.parse(vcap_services)
 
-const xsuaaSrv = Object.keys(VCAPSERVICES)
-  .map(k => VCAPSERVICES[k])
+const xsuaaSrv = Object.keys(vcap_services)
+  .map(k => vcap_services[k])
   .map(e => e[0])
   .find(srv => srv.label === 'xsuaa')
 

package/lib/srv/middlewares/sap-statistics.js

@@ -1,13 +0,0 @@
-const { performance } = require ('perf_hooks')
-
-module.exports = (prec = 1000) => function sap_statistics (req, res, next) {
-  if (req.query['sap-statistics'] || req.headers['sap-statistics']) {
-    const { writeHead } = res, t0 = performance.now()
-    res.writeHead = function (...args) {
-      const total = ((performance.now() - t0) / prec).toFixed(2)
-      if (res.statusCode < 400) res.setHeader('sap-statistics', `total=${total}`)
-      writeHead.call(this, ...args)
-    }
-  }
-  next()
-}

package/lib/utils/index.js

@@ -1,2 +0,0 @@
-// for compatibility with old releases of cds-lint
-module.exports = require('./cds-utils')

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

@@ -1,21 +0,0 @@
-const cds = require('../../cds')
-
-// register after input.js in order to write content-type also for @Core.Computed fields
-module.exports = cds.service.impl(function () {
-  this.before('UPDATE', '*', function fill_media_types(req) {
-    if (!req.data || !req.target) return
-    if (_is_field_request(req)) {
-      for (let e in req.data) {
-        let ref = _media_type_ref4(req.target.elements[e])
-        if (ref) {
-          let content_type = req.req?.get('content-type')
-          if (_is_valid(content_type)) req.data[ref] = content_type
-        }
-      }
-    }
-  })
-})
-
-const _media_type_ref4 = media_element => media_element['@Core.MediaType']?.['=']
-const _is_field_request = req => req.req?._query?._propertyAccess
-const _is_valid = content_type => content_type && !content_type.includes('multipart')

package/libx/_runtime/common/i18n/index.js

@@ -1,79 +0,0 @@
-//
-// REVISIT: Not used any longer -> move to @sap/cds-attic ...
-//
-const fs = require('fs')
-const path = require('path')
-
-const cds = require('../../cds')
-
-const dirs = (cds.env.i18n && cds.env.i18n.folders) || []
-
-const i18ns = {}
-
-function exists(args, locale) {
-  const file = path.join(cds.root, ...args, locale ? `messages_${locale}.properties` : 'messages.properties')
-  return fs.existsSync(file) ? file : undefined
-}
-
-function findFile(locale) {
-  // lookup all paths to model files
-  const prefixes = new Set()
-  if (cds.env.folders && cds.env.folders.srv) prefixes.add(cds.env.folders.srv.replace(/\/$/, ''))
-  if (cds.services) {
-    for (const outer in cds.services) {
-      if (cds.services[outer].definition && cds.services[outer].definition['@source']) {
-        prefixes.add(path.dirname(cds.services[outer].definition['@source']))
-      }
-    }
-  }
-
-  let file
-  // find first messages_${locale}.properties file in cds.env.i18n.folders
-  for (const dir of dirs) {
-    // w/o prefix
-    file = exists([dir], locale)
-    if (file) break
-
-    // w/ prefix
-    for (const prefix of prefixes.keys()) {
-      file = exists([prefix, dir], locale)
-      if (file) break
-    }
-
-    if (file) break
-  }
-
-  return file
-}
-
-function init(locale, file) {
-  if (!i18ns[locale]) i18ns[locale] = {}
-
-  if (!file) file = findFile(locale)
-  if (!file) return
-
-  const props = cds.load.properties(file)
-  i18ns[locale] = props
-}
-
-init('default', path.resolve(__dirname, '../../../../_i18n/messages.properties'))
-init('')
-
-module.exports = (key, locale = '', args = {}) => {
-  if (typeof locale !== 'string') {
-    args = locale
-    locale = ''
-  }
-
-  // initialize locale if not yet done
-  if (!i18ns[locale]) {
-    init(locale)
-  }
-
-  // for locale OR app default OR cds default
-  let text = i18ns[locale][key] || i18ns[''][key] || i18ns.default[key]
-  return text?.replace(/{(\w+)}/g, (_, k) => {
-    let x = args[k]
-    return i18ns[locale][x] || i18ns[''][x] || i18ns.default[x] || (x ?? 'NULL') // REVISIT: i'm afraid this twofold localization is a rather bad idea
-  })
-}