@sap/cds 7.5.3 → 7.6.2

package/libx/outbox/index.js

@@ -13,6 +13,7 @@ const cdsUser = 'cds.internal.user'
 const $messageProcessorRegistered = Symbol('message processor registered')
 const $outboxed = Symbol('outboxed')
 const $unboxed = Symbol('unboxed')
+const $stored_reqs = Symbol('stored_reqs')
 
 const _get100NanosecondTimestampISOString = () => {
   const [now, nanoseconds] = [new Date(), process.hrtime()[1]]
@@ -38,56 +39,6 @@ const hasPersistentOutbox = tenant => {
   return true
 }
 
-const isUnrecoverable = (service, error) => {
-  let unrecoverable = service.isUnrecoverableError && service.isUnrecoverableError(error)
-  if (unrecoverable === undefined) unrecoverable = error.unrecoverable
-  return unrecoverable || isStandardError(error)
-}
-
-const processDefault = async (messages, { toBeDeleted, toBeUpdated, options, service }) => {
-  /** throws if an emit failed due to a programming error
-   * returns false if an emit failed due to temporary issues **/
-  const run = async ({ ID, process }) => {
-    try {
-      await process()
-      toBeDeleted.push(ID)
-    } catch (e) {
-      if (isStandardError(e)) {
-        LOG.error(`${service.name}: Programming error detected:`, e)
-        toBeDeleted.push(ID)
-        throw new Error(`${service.name}: Programming error detected.`)
-      }
-      if (e.unrecoverable) {
-        LOG.error(`${service.name}: Unrecoverable error:`, e)
-        if (options.maxAttempts) {
-          const _msg = { ID, attempts: options.maxAttempts }
-          if (options.storeLastError !== false) _msg.lastError = e
-          toBeUpdated.push(_msg)
-        } else toBeDeleted.push(ID)
-      } else {
-        LOG.error(`${service.name}: Emit failed:`, e)
-        const _msg = { ID }
-        if (options.storeLastError !== false) _msg.lastError = e
-        toBeUpdated.push(_msg)
-        return false
-      }
-    }
-  }
-  if (options.parallel) {
-    const first = messages.next()?.value // First try to see if message can be emitted
-    if (first && (await run(first)) === false) return // No need to process the rest if the emit failed
-    const res = await Promise.allSettled([...messages].map(run))
-    const errors = res.filter(r => r.status === 'rejected').map(r => r.reason)
-    if (errors.length) {
-      throw new Error(`${service.name}: Programming errors detected.`)
-    }
-  } else {
-    for (const msg of messages) {
-      if ((await run(msg)) === false) break
-    }
-  }
-}
-
 const _safeJSONParse = string => {
   try {
     return string && JSON.parse(string)
@@ -142,36 +93,64 @@ const processMessages = async (service, tenant, _opts = {}) => {
           const user = new cds.User.Privileged(userId)
           if (!msg) continue
           const res = {
-            process: () =>
-              cds._context.run({ user, tenant }, async () => {
-                try {
-                  return await service.handle(msg)
-                } catch (e) {
-                  if (isUnrecoverable(service, e)) e.unrecoverable = true
-                  throw e
-                }
-              }),
             ID: _message.ID,
             msg,
-            user,
-            opts
+            user
           }
           yield res
         }
       }
 
-      const process = service.options.outbox?.process || this.process || processDefault
       const toBeDeleted = []
       const toBeUpdated = []
       try {
-        await process(messagesGen(), {
-          toBeDeleted,
-          toBeUpdated,
-          service,
-          options: opts
-        })
+        const _handleWithErr = async ({ msg, user, ID }) => {
+          try {
+            await cds._context.run({ user, tenant }, async () => {
+              if (opts.handle) await opts.handle.call(service, msg)
+              else await service.handle(msg)
+            })
+            toBeDeleted.push(ID)
+          } catch (e) {
+            if (isStandardError(e)) {
+              LOG.error(`${service.name}: Programming error detected:`, e)
+              toBeDeleted.push(ID)
+              throw new Error(`${service.name}: Programming error detected.`)
+            }
+            if (e.unrecoverable) {
+              LOG.error(`${service.name}: Unrecoverable error:`, e)
+              if (opts.maxAttempts) {
+                const _msg = { ID, attempts: opts.maxAttempts }
+                if (opts.storeLastError !== false) _msg.lastError = e
+                toBeUpdated.push(_msg)
+              } else toBeDeleted.push(ID)
+            } else {
+              LOG.error(`${service.name}: Emit failed:`, e)
+              const _msg = { ID }
+              if (opts.storeLastError !== false) _msg.lastError = e
+              toBeUpdated.push(_msg)
+              return false
+            }
+          }
+        }
+        const messages = messagesGen()
+        // REVISIT: Maybe we can also support handleMany and provide the iterator (for batch processing)
+        if (opts.parallel) {
+          const first = messages.next()?.value // First try to see if message can be emitted
+          if (!(first && (await _handleWithErr(first)) === false)) { // No need to process the rest if the first emit failed
+            const res = await Promise.allSettled([...messages].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.`)
+            }
+          }
+        } else {
+          for (const msg of messages) {
+            if ((await _handleWithErr(msg)) === false) break
+          }
+        }
       } catch (e) {
-        if (opts.crashOnError !== false) letAppCrash = true
+        letAppCrash = true
       }
 
       const queries = []
@@ -250,13 +229,6 @@ const writeInOutbox = async (name, msg, context) => {
   return cds.tx(context).run(INSERT.into(messagesEntity).entries(outboxMsg))
 }
 
-// REVIST: Should we also support the following API?
-// cds.outboxed(srv, {
-//   onInsert(msg){ ... }
-//   onForward(msg){ ... }
-//   onProcess(msgs){ ... }
-// })
-
 function unboxed(srv) {
   return srv[$unboxed] || srv
 }
@@ -274,13 +246,20 @@ function outboxed(srv, customOpts) {
 
   if (!new.target) Object.defineProperty(srv, $outboxed, { value: outboxedSrv })
 
+  let requiresOpts = cds.requires.outbox
+  let serviceOpts = srv.options?.outbox
+
+  if (typeof requiresOpts === 'string') requiresOpts = { kind: requiresOpts }
+  if (typeof serviceOpts === 'string') serviceOpts = { kind: serviceOpts }
+
   const outboxOpts = Object.assign(
     {},
-    (typeof cds.requires.outbox === 'object' && cds.requires.outbox) || {},
-    (typeof srv.options?.outbox === 'object' && srv.options.outbox) || {},
+    (typeof requiresOpts === 'object' && requiresOpts) || {},
+    (typeof serviceOpts === 'object' && serviceOpts) || {},
     customOpts || {}
   )
 
+
   outboxedSrv.handle = async function (req) {
     const context = req.context || cds.context
     if (outboxOpts.kind === 'persistent-outbox' && hasPersistentOutbox(context.tenant)) {
@@ -296,17 +275,23 @@ function outboxed(srv, customOpts) {
       await writeInOutbox(srv.name, req, context)
       return
     }
-    // REVISIT: Also allow maxAttempts for in-memory outbox?
-    context.on('succeeded', async () => {
-      try {
-        if (req.reply) await originalSrv.send(req)
-        else await originalSrv.emit(req)
-      } catch (e) {
-        LOG.error('Emit failed', { event: req.event, cause: e })
-        // opts.crashOnError is not official!!!
-        if (isUnrecoverable(originalSrv, e) && outboxOpts.crashOnError !== false) cds.exit(1)
-      }
-    })
+    if (!context[$stored_reqs]) {
+      context[$stored_reqs] = [] 
+      context.on('succeeded', async () => {
+        // REVISIT: Also allow maxAttempts for in-memory outbox?
+        for (const _req of context[$stored_reqs]) {
+          try {
+            if (req.reply) await originalSrv.send(req)
+            else await originalSrv.emit(req)
+          } catch (e) {
+            LOG.error('Emit failed', { event: req.event, cause: e })
+            if (isStandardError(e)) cds.exit(1)
+          }
+        }
+        delete context[$stored_reqs]
+      })
+    }
+    context[$stored_reqs].push(req)
   }
 
   return outboxedSrv

package/libx/rest/RestAdapter.js

@@ -16,7 +16,6 @@ const payload_factory = require('./middleware/payload')
 const error_factory = require('./middleware/error')
 
 const { bufferToBase64 } = require('../_runtime/common/utils/binary')
-const { alias2ref } = require('../_runtime/common/utils/csn')
 const { getAccessRestrictions } = require('../_runtime/common/utils/restrictions')
 
 const RestAdapter = function (srv) {
@@ -24,8 +23,6 @@ const RestAdapter = function (srv) {
   const input = input_factory(srv)
   const payload = payload_factory(srv)
 
-  alias2ref(srv)
-
   const router = express.Router()
 
   // -----------------------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "7.5.3",
+  "version": "7.6.2",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [

package/lib/env/schemas/cds-package.json

@@ -1,17 +0,0 @@
-{
-  "title": "JSON schema for CDS configuration in package.json",
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "description": "This is a JSON schema representation of the CDS project configuration inside a project root level package.json",
-  "type": "object",
-  "properties": {
-    "extends": {
-      "description": "Name of the application that shall be extended",
-      "type": "string"
-    },
-    "cds": {
-      "$ref": "cdsJsonSchema://schemas/cds-rc.json",
-      "description": "CDS configuration",
-      "default": {}
-    }
-  }
-}