@sap/cds 7.5.2 → 7.6.1

package/libx/outbox/index.js

@@ -38,56 +38,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 +92,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 +228,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
 }
@@ -303,8 +274,7 @@ function outboxed(srv, customOpts) {
         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 (isStandardError(e)) cds.exit(1)
       }
     })
   }

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.2",
+  "version": "7.6.1",
   "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": {}
-    }
-  }
-}