@sap/cds 7.3.0 → 7.4.0

package/libx/{_runtime/messaging/outbox/utils.js → outbox/index.js}

@@ -1,19 +1,17 @@
-const cds = require('../../cds')
-const waitingTime = require('../common-utils/waitingTime')
-const OutboxRunner = require('./OutboxRunner')
-const { isStandardError } = require('../../common/error/standardError')
+const cds = require('../_runtime/cds')
 const LOG = cds.log('persistent-outbox')
-const util = require('util')
-const _safeJSONParse = string => {
-  try {
-    return string && JSON.parse(string)
-  } catch (_e) {
-    // Don't throw
-  }
-}
+
+const { inspect } = require('util')
+
+const OutboxRunner = require('./OutboxRunner')
 const outboxRunner = new OutboxRunner()
+
+const waitingTime = require('../_runtime/common/utils/waitingTime')
+const { isStandardError } = require('../_runtime/common/error/standardError')
+
 const cdsUser = 'cds.internal.user'
-const messageProcessorRegistered = Symbol('message processor registered')
+const $messageProcessorRegistered = Symbol('message processor registered')
+const $outboxed = Symbol('outboxed')
 
 const _get100NanosecondTimestampISOString = () => {
   const [now, nanoseconds] = [new Date(), process.hrtime()[1]]
@@ -33,10 +31,8 @@ const _getMessagesEntity = () => {
 const _isProviderTenant = tenant =>
   cds.requires.auth && cds.requires.auth.credentials && cds.requires.auth.credentials.identityzoneid === tenant
 
-const hasPersistentOutbox = (srv, tenant) => {
+const hasPersistentOutbox = tenant => {
   if (!cds.requires.outbox || cds.requires.outbox.kind !== 'persistent-outbox') return false
-  if (srv.options && srv.options.outbox && srv.options.outbox.kind && srv.options.outbox.kind !== 'persistent-outbox')
-    return false
   if (cds.requires.multitenancy && tenant && _isProviderTenant(tenant)) return false // no persistence for provider account
   return true
 }
@@ -91,6 +87,14 @@ const processDefault = async (messages, { toBeDeleted, toBeUpdated, options, ser
   }
 }
 
+const _safeJSONParse = string => {
+  try {
+    return string && JSON.parse(string)
+  } catch (_e) {
+    // Don't throw
+  }
+}
+
 // Note: This function can also run for each tenant on startup
 const processMessages = async (service, tenant, _opts = {}) => {
   const opts = Object.assign({ attempt: 0 }, _opts)
@@ -127,8 +131,11 @@ const processMessages = async (service, tenant, _opts = {}) => {
       let currMaxAttempts = 0
       const messagesGen = function* () {
         for (const _message of messages) {
-          const msg = _safeJSONParse(_message.msg)
-          const userId = msg[cdsUser]
+          const _msg = _safeJSONParse(_message.msg)
+          const userId = _msg[cdsUser]
+          const msg = _msg._fromSend ? new cds.Request(_msg) : new cds.Event(_msg)
+          delete msg._fromSend
+          Object.defineProperty(msg, '_fromOutbox', { value: true, enumerable: false })
           delete msg[cdsUser]
           currMaxAttempts = Math.max(_message.attempts || 0, currMaxAttempts)
           const user = new cds.User.Privileged(userId)
@@ -137,7 +144,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
             process: () =>
               cds._context.run({ user, tenant }, async () => {
                 try {
-                  return service._emitImmediate && (await service._emitImmediate(msg))
+                  return await service.handle(msg)
                 } catch (e) {
                   if (isUnrecoverable(service, e)) e.unrecoverable = true
                   throw e
@@ -160,7 +167,6 @@ const processMessages = async (service, tenant, _opts = {}) => {
           toBeDeleted,
           toBeUpdated,
           service,
-          emit: service._emitImmediate.bind(service),
           options: opts
         })
       } catch (e) {
@@ -177,7 +183,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
             attempts: { '+=': 1 }
           }
           Object.assign(data, toBeUpdatedMsg)
-          if (data.lastError && typeof data.lastError !== 'string') data.lastError = util.inspect(data.lastError)
+          if (data.lastError && typeof data.lastError !== 'string') data.lastError = inspect(data.lastError)
           queries.push(UPDATE(messagesEntity).where({ ID: toBeUpdatedMsg.ID }).set(data))
         }
       }
@@ -212,7 +218,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
 }
 
 const registerMessageProcessor = (name, context) => {
-  const registry = context[messageProcessorRegistered] || (context[messageProcessorRegistered] = new Set())
+  const registry = context[$messageProcessorRegistered] || (context[$messageProcessorRegistered] = new Set())
   if (!registry.has(name)) {
     registry.add(name)
     return true
@@ -221,7 +227,13 @@ const registerMessageProcessor = (name, context) => {
 }
 
 const _createMessage = (name, msg, context) => {
-  const _msg = { ...msg, [cdsUser]: context.user.id }
+  const _msg = { [cdsUser]: context.user.id }
+  if (msg._fromSend || msg.reply) _msg._fromSend = true // send or emit?
+  if (msg.inbound) _msg.inbound = msg.inbound
+  if (msg.event) _msg.event = msg.event
+  if (msg.data) _msg.data = msg.data
+  if (msg.headers) _msg.headers = msg.headers
+  if (msg.query) _msg.query = msg.query
   const outboxMsg = {
     ID: cds.utils.uuid(),
     target: name,
@@ -237,4 +249,62 @@ const writeInOutbox = async (name, msg, context) => {
   return cds.tx(context).run(INSERT.into(messagesEntity).entries(outboxMsg))
 }
 
-module.exports = { processMessages, registerMessageProcessor, writeInOutbox, hasPersistentOutbox, isUnrecoverable }
+// REVIST: Should we also support the following API?
+// cds.outboxed(srv, {
+//   onInsert(msg){ ... }
+//   onForward(msg){ ... }
+//   onProcess(msgs){ ... }
+// })
+
+function outboxed(srv, customOpts) {
+  // outbox max. once
+  if (!new.target) {
+    const former = srv[$outboxed]
+    if (former) return former
+  }
+
+  const originalSrv = srv.immediate || srv
+  const outboxedSrv = Object.create(originalSrv)
+  outboxedSrv.immediate = originalSrv
+
+  if (!new.target) Object.defineProperty(srv, $outboxed, { value: outboxedSrv })
+
+  const outboxOpts = Object.assign(
+    {},
+    (typeof cds.requires.outbox === 'object' && cds.requires.outbox) || {},
+    (typeof srv.options?.outbox === 'object' && srv.options.outbox) || {},
+    customOpts || {}
+  )
+
+  outboxedSrv.handle = async function (req) {
+    const context = req.context || cds.context
+    if (outboxOpts.kind === 'persistent-outbox' && hasPersistentOutbox(context.tenant)) {
+      // returns true if not yet registered
+      if (registerMessageProcessor(srv.name, context)) {
+        // NOTE: What if there are different outbox options for the same service?!
+        //       There could be messages for srv1 with { maxAttempts: 1 }
+        //       and messages for srv1 with { maxAttempts: 9 }.
+        //       How would they be processed? I'd rather not have dedicated
+        //       service names or store serialized options for each message.
+        context.on('succeeded', () => processMessages(originalSrv, context.tenant, outboxOpts))
+      }
+      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)
+      }
+    })
+  }
+
+  return outboxedSrv
+}
+
+module.exports = outboxed

package/libx/rest/middleware/parse.js

@@ -3,7 +3,7 @@ const { INSERT, SELECT, UPDATE, DELETE } = cds.ql
 
 const { where2obj } = require('../../_runtime/common/utils/cqn')
 
-const { convertStructured } = require('../../common/utils/ucsn')
+const { convertStructured } = require('../../_runtime/common/utils/ucsn')
 const { deepCopy } = require('../../_runtime/common/utils/copy')
 
 module.exports = (req, res, next) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "7.3.0",
+  "version": "7.4.0",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -35,7 +35,7 @@
   "dependencies": {
     "@sap/cds-compiler": "^4",
     "@sap/cds-fiori": "^1",
-    "@sap/cds-foss": "^4"
+    "@sap/cds-foss": "^5.0.0"
   },
   "cds": {
     "plugins": [

package/apis/connect.d.ts

@@ -1,39 +0,0 @@
-import { Service } from "./services"
-
-export = cds
-declare class cds {
-
-	connect : {
-		/**
-		 * Connects to a specific datasource.
-		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
-		 */
-		to (datasource: string, options?: ConnectOptions) : Promise<Service>
-
-		/**
-		 * Connects to a specific datasource via options.
-		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
-		 */
-		to (options: ConnectOptions) : Promise<Service>
-
-		/**
-		 * Connects the primary datasource.
-		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect)
-		 */
-		(options?: string | ConnectOptions) : Promise<typeof cds>  //> cds.connect(<options>)
-	}
-
-	/**
-	 * Emitted whenever a specific service is connected for the first time.
-	 */
-	on (event : 'connect', listener : (srv : Service) => void) : this
-
-}
-
-type ConnectOptions = {
-    impl?: string,
-	service?: string,
-	kind?:string,
-	model?:string,
-	credentials?: object
-}

package/bin/utils/modules.js

@@ -1,7 +0,0 @@
-module.exports = {
-  npmGlobalModules: function() {
-    try {
-      return require ('child_process').execSync('npm root -g').toString().trim()
-    } catch (err) { return }
-  }
-}

package/bin/utils/term.js

@@ -1,56 +0,0 @@
-// FIXME: Nicht gut, das wir das zweimal redundant haben!
-const debug = process.env.DEBUG
-
-// https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences
-const t = exports.codes = {
-  reset: '\x1b[0m', // Default
-  bold: '\x1b[1m', // Bold/Bright
-  link: '\x1b[4m', // underline
-  red: '\x1b[91m', // Bright Foreground Red
-  green: '\x1b[32m', // Foreground Green
-  orange: '\x1b[38;2;255;140;0m' // darker orange, works with bright and dark background
-}
-
-Object.defineProperty(exports, 'isTTY',  { get: () => process.stdin.isTTY && process.stderr.isTTY })
-
-const as = exports.as = (codes, o) => {
-  return exports.isTTY ? (codes + o + t.reset) : ('' + o)
-}
-
-const asErr = exports.error = o => debug ? o : as(t.red + t.bold, o)
-const asWarn = exports.warn = o => debug ? o : as(t.orange + t.bold, o)
-const asInfo = exports.info = o => debug ? o : as(t.green + t.bold, o)
-exports.warn  = o => as(t.orange, o)
-exports.info  = o => as(t.green, o)
-exports.link  = o => as(t.link, o)
-exports.bold  = o => as(t.bold, o)
-
-const format = exports.format = (o, severity='Error', asInternalError=false, withStack=false) => {
-  switch (severity) {
-    case 'Error'  : return format.error (o, asInternalError, withStack)
-    case 'Warning': return format.warn (o)
-    default       : return format.info (o)
-  }
-}
-
-// decorate.error, .warning, .info
-// 'Error: foo'  ->  '[ERROR] foo'  (Maven-like, allows for better grepping in logs)
-Object.assign (format, {
-  error: (o, asInternalError, withStack) => {
-    if (debug)  return o
-    if (asInternalError) {
-      return `[${asErr('INTERNAL ERROR')}] ${o.stack || o.toString()}\n`
-    }
-    return `[${asErr('ERROR')}] ${toString(o, 'Error', withStack)}`
-  },
-  warn: o => debug ? o : `[${asWarn('WARNING')}] ${toString(o, 'Warning')}`,
-  info: o => debug ? o : `[${asInfo('INFO')}] ${toString(o, 'Info')}`,
-})
-
-function toString(o, severity, withStack) {
-  if (!o || !o.toString)  return o
-  return (withStack && o.stack ? o.stack : o.toString())
-      // strips the 'Error: ' prefix in the message, so that we can add our own prefix
-      .replace(new RegExp('^' + severity + ': ', 'i'), '')  // beginning
-      .replace(new RegExp(' ' + severity + ':' , 'i'), '')  // middle
-}

package/lib/env/schema.js

@@ -1,9 +0,0 @@
-const cds = require('../index')
-const { join } = cds.utils.path
-
-
-module.exports = {
-    default4: async (name) => {
-        return cds.utils.read(join(__dirname, 'schemas', name), 'json')
-    }
-}

package/lib/linked/queries.js

@@ -1,41 +0,0 @@
-const { entity } = require('./entities')
-
-/** Lazily resolves a query's _target property */
-module.exports = (q,defs) => {
-  if (!q._target || q._target.kind !== 'entity') Object.defineProperty (q, '_target', {value:(
-    q.SELECT ? _resolve (q.SELECT.from, defs) :
-    q.INSERT ? _resolve (q.INSERT.into, defs) :
-    q.UPSERT ? _resolve (q.UPSERT.into, defs) :
-    q.UPDATE ? _resolve (q.UPDATE.entity, defs) :
-    q.DELETE ? _resolve (q.DELETE.from, defs) :
-    q.STREAM?.from ? _resolve (q.STREAM.from, defs) :
-    q.STREAM?.into ? _resolve (q.STREAM.into, defs) :
-    _resolve (undefined)
-  ), configurable:true, writable:true })
-  return q._target
-}
-
-const _resolve = (from, defs) => {
-  if (!from || from.name) return from
-  while (from.SELECT) from = from.SELECT.from
-  if (from.join || from.set) return //_unresolved()
-  if (from.ref) {
-    if (from.ref.length === 1) {
-      from = from.ref[0]
-      if (from.id) from = from.id
-    } else {
-      let target = {elements:defs}
-      for (let each of from.ref) {
-        const e = each.id || each
-        const a = target.elements[e]; if (!a) return _unresolved (target.name +':'+e)
-        target = defs [a.target || a.name]; if (!target) return _unresolved (a.target)
-      }
-      return target
-    }
-  }
-  return defs[from] || _unresolved(from)
-}
-
-const _unresolved = (name) => {
-  return { name, __proto__:entity.prototype, _unresolved:true }
-}