@sap/cds 8.9.4 → 9.0.2

package/libx/rest/RestAdapter.js

@@ -1,27 +1,27 @@
 const cds = require('../_runtime/cds')
 
+const HttpAdapter = require('../../lib/srv/protocols/http')
+const HttpRequest = require('../http/HttpRequest')
+const bodyParser4 = require('../http/body-parser')
+
+class RestRequest extends HttpRequest {
+  get protocol() {
+    return 'rest'
+  }
+}
+
 const parse = require('./middleware/parse')
 const create = require('./middleware/create')
 const read = require('./middleware/read')
 const update = require('./middleware/update')
+const upsert = require('./middleware/upsert')
 const deleet = require('./middleware/delete')
 const operation = require('./middleware/operation')
 const error = require('./middleware/error')
 
 const { postProcessData } = require('./post-processing')
 
-const HttpAdapter = require('../../lib/srv/protocols/http')
-const bodyParser4 = require('../odata/middleware/body-parser')
-
-// REVISIT: ugly hack -> eliminate
-const { NoaRequest } = require('../odata/ODataAdapter')
-class RestRequest extends NoaRequest {
-  get protocol() {
-    return 'rest'
-  }
-}
-
-class RestAdapter extends HttpAdapter {
+module.exports = class RestAdapter extends HttpAdapter {
   request4(args) {
     return new RestRequest(args)
   }
@@ -30,8 +30,6 @@ class RestAdapter extends HttpAdapter {
     const srv = this.service
     const router = super.router
 
-    const jsonBodyParser = bodyParser4(this)
-
     // service root
     router.head('/', (_, res) => res.json({}))
     const entities = Object.keys(srv.entities).map(e => ({ name: e, url: e }))
@@ -54,84 +52,47 @@ class RestAdapter extends HttpAdapter {
 
       return next()
     })
-    router.use(jsonBodyParser)
+    router.use(bodyParser4(this))
     router.use(parse(this))
 
-    // handle
-    const operation_middleware = operation(this)
-    const create_middleware = create(this)
-    const read_middleware = read(this)
-    const update_middleware = update(this)
-    const delete_middleware = deleet(this)
-    router.use(async function dispatch(req, res, next) {
-      try {
-        let result, status, location
-
-        if (req._operation) {
-          // actions and functions
-          ;({ result, status } = await operation_middleware(req, res))
-        } else {
-          // CRUD
-          switch (req.method) {
-            case 'POST':
-              ;({ result, status, location } = await create_middleware(req, res))
-              break
-            case 'HEAD':
-            case 'GET':
-              ;({ result, status } = await read_middleware(req, res))
-              break
-            case 'PUT':
-            case 'PATCH':
-              // eslint-disable-next-line no-case-declarations
-              const _res = await update_middleware(req, res, next)
-              if (_res) ({ result, status } = _res)
-              break
-            case 'DELETE':
-              ;({ result, status } = await delete_middleware(req, res))
-              break
-          }
-        }
+    // handlers
+    const action_handler = operation(this)
+    const crud_handlers = {
+      HEAD: read(this),
+      GET: read(this),
+      PUT: cds.env.runtime.put_as_upsert ? upsert(this) : update(this),
+      POST: create(this),
+      PATCH: cds.env.runtime.patch_as_upsert ? upsert(this) : update(this),
+      DELETE: deleet(this)
+    }
 
-        if (status || result !== undefined) {
-          req._result = { result, status, location }
-          return next()
+    router.use((req, res, next) => {
+      const handle = req._operation ? action_handler : crud_handlers[req.method]
+      handle(req, res).then(outcome => {
+        // if authentication or something else within the processing of a cds.Request terminates the request, no need to continue
+        if (res.headersSent) return next()
+
+        const { result, status, location } = outcome
+
+        // post process
+        if (result) {
+          let def = req._operation || cds.infer.target(req._query)
+          const defs = srv.model.definitions
+          if (typeof def === 'string') def = defs[def] || defs[def.split(':$:')[0]].actions[def.split(':$:')[1]]
+          if (def) postProcessData(result, srv, def)
         }
-      } catch (e) {
-        next(e)
-      }
-    })
 
-    // handle result
-    router.use((req, res) => {
-      // if authentication or something else within the processing of a cds.Request terminates the request, no need to continue
-      if (res.headersSent) return
-
-      const { result, status, location } = req._result // REVISIT: Ugly voodoo _req._result channel -> eliminate
-
-      // post process
-      let definition = req._operation || req._query.__target
-      if (typeof definition === 'string')
-        definition =
-          srv.model.definitions[definition] ||
-          srv.model.definitions[definition.split(':$:')[0]].actions[definition.split(':$:')[1]]
-      if (result && srv && definition) {
-        postProcessData(result, srv, definition)
-      }
+        if (status && res.statusCode === 200) res.status(status) //> only set status if not yet modified
+        if (location && !res.get('location')) res.set('location', location)
 
-      if (status && res.statusCode === 200) res.status(status) //> only set status if not yet modified
-      if (location && !res.getHeader('location')) res.set('location', location)
-
-      // prettier-ignore
-      if (req.method === 'HEAD') res.type('json').set({ 'content-length': JSON.stringify(result).length }).end()
-      else res.send(typeof result === 'number' ? result.toString() : result)
+        if (req.method === 'HEAD') res.type('json').set('content-length', JSON.stringify(result).length).end()
+        else res.send(typeof result === 'number' ? result.toString() : result)
+      }, next)
     })
 
     // error handling
-    if (cds.env.features.rest_error_handler !== false) // REVISIT: unofficial hack for afc!!!
-      router.use(error(this))
+    router.use(error(this))
 
     return router
   }
 }
-
-module.exports = RestAdapter

package/libx/rest/middleware/create.js

@@ -1,40 +1,42 @@
+module.exports = exports = adapter => exports.create.bind(adapter)
+
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+exports.create = async function (req, res) {
+  const { _query: query, _data, _params: params } = req
+
+  let result, location
+
+  // add the data
+  query.entries(_data)
+
+  if (query.INSERT.entries.length > 1) {
+    // > batch insert
+    const cdsReqs = query.INSERT.entries.map(entry => {
+      return this.request4({ query: INSERT.into(query.INSERT.into).entries(entry), params, req, res })
+    })
+    const ress = await Promise.allSettled(cdsReqs.map(req => this.service.dispatch(req)))
+    const rejected = ress.filter(r => r.status === 'rejected')
+    if (rejected.length) throw _error4(rejected)
+    result = ress.map(r => r.value)
+  } else {
+    // > single insert
+    const cdsReq = this.request4({ query, params, req, res })
+    result = await this.service.dispatch(cdsReq)
+    location = location4(cdsReq.target, this.service, result, true)
+  }
+
+  return { result, status: 201, location }
+}
+
 const cds = require('../../_runtime/cds')
 const { INSERT } = cds.ql
 
+const location4 = require('../../http/location')
+
 const _error4 = rejected =>
   rejected.length > 1
     ? Object.assign(new Error('MULTIPLE_ERRORS'), { details: rejected.map(r => r.reason) })
     : rejected[0].reason
-
-module.exports = adapter => {
-  const { service } = adapter
-
-  return async function create(req, res) {
-    const { _query: query, _data, _params: params } = req
-
-    let result, location
-
-    // add the data
-    query.entries(_data)
-    if (query.INSERT.entries.length > 1) {
-      // > batch insert
-      const cdsReqs = query.INSERT.entries.map(entry => {
-        return adapter.request4({ query: INSERT.into(query.INSERT.into).entries(entry), params, req, res })
-      })
-      const ress = await Promise.allSettled(cdsReqs.map(req => service.dispatch(req)))
-      const rejected = ress.filter(r => r.status === 'rejected')
-      if (rejected.length) throw _error4(rejected)
-      result = ress.map(r => r.value)
-    } else {
-      // > single insert
-      const cdsReq = adapter.request4({ query, params, req, res })
-      result = await service.dispatch(cdsReq)
-      // REVISIT: location is a restful feature -> share with odata
-      // REVISIT: Is it guaranteed that the GET works? Why do we need relative urls?
-      location = `../${cdsReq.entity.replace(service.definition.name + '.', '')}`
-      for (const k in cdsReq.target.keys) location += `/${result[k]}`
-    }
-
-    return { result, status: 201, location }
-  }
-}

package/libx/rest/middleware/delete.js

@@ -1,11 +1,13 @@
-module.exports = adapter => {
-  const { service } = adapter
+module.exports = exports = adapter => exports.delete.bind(adapter)
 
-  return async function deleet(req, res) {
-    const { _query: query, _data: data, _params: params } = req
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+exports.delete = async function (req, res) {
+  const { _query: query, _data: data, _params: params } = req
 
-    await service.dispatch(adapter.request4({ query, data, params, req, res }))
+  await this.service.dispatch(this.request4({ query, data, params, req, res }))
 
-    return { result: null, status: 204 }
-  }
+  return { result: null, status: 204 }
 }

package/libx/rest/middleware/error.js

@@ -1,19 +1,12 @@
-const _log = require('../../_runtime/common/error/log')
-const { normalizeError } = require('../../_runtime/common/error/frontend')
-
-module.exports = () => {
-  return function rest_error(err, req, res, next) {
-    if (err == 401 || err.code == 401) return next(err) // speed up logins, at least temporary until we reviewed and eliminated overhead that may be involved below
-
-    // REVISIT: keep?
-    // log the error (4xx -> warn)
-    _log(err)
-
-    const { error, statusCode } = normalizeError(err, req)
-
-    // NOTE: express also looks for numbers in err.status or err.statusCode
-    error.statusCode = statusCode
-
-    next(error)
-  }
+module.exports = exports = adapter => exports.error.bind(adapter)
+
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+exports.error = function (err, req, res, next) {
+  if (!pass_through(err)) normalizeError(err, req, false)
+  return next(err)
 }
+
+const { pass_through, normalizeError } = require('../../odata/middleware/error')

package/libx/rest/middleware/operation.js

@@ -1,143 +1,50 @@
-const cds = require('../../_runtime/cds')
-const getError = require('../../_runtime/common/error')
-
-const { checkStatic } = require('../../_runtime/cds-services/util/assert')
-const { Readable } = require('node:stream')
-
-// REVISIT: strict or relaxed type checkers?
-const typeCheckers = require('../../common/assert/type-strict')
-const streaming = require('../../common/utils/streaming')
-
-// REVISIT: use i18n
-const _enrichErrorDetails = (isPrimitive, error) => {
-  const element = error.target ? ` '${error.target}' ` : ' '
-  const typeDetails = isPrimitive ? '.' : ` according to type definition '${error.type}'.`
-  const value = typeof error.value === 'string' ? `'${error.value}'` : error.value
-  if (element && element.match(/\w/)) return `Value ${value} of element${element}is invalid${typeDetails}`
-  return `Value ${value} is invalid${typeDetails}`
-}
-
-// REVISIT: use i18n
-const _getTypeError = (operation, type, errorDetails) => {
-  const typeErrors = errorDetails.map(error => _enrichErrorDetails(cds.builtin.types[type], error))
-  const msg = `Failed to validate return value ${type ? `of type '${type}' ` : ''}for custom ${operation.kind} '${
-    operation.name
-  }': ${typeErrors.join(' ')}`
-  return getError(msg)
+module.exports = exports = adapter => exports.operation.bind(adapter)
+
+/**
+ * @type {import('express').Handler}
+ * @this import('../RestAdapter')
+ */
+exports.operation = async function (req, res) {
+  const op = req._operation
+  const request = this.request4({ event: op.name, data: req._data, params: req._params, req, res })
+
+  // REVISIT: when/why is a query given for an operation? -> obsolete with req.subject?
+  // REVISIT: when/why are op.names prefixed with service name? -> looks like OData impact?
+  if (req._query) request.query = req._query
+  else request.event = op.name.replace(`${this.service.namespace}.`, '')
+
+  // Send the request to the service to be handled
+  const result = await this.service.dispatch(request)
+
+  // Quick checks if theres anything left to do
+  if (res.headersSent) return // response already sent by the service
+  if (!op.returns || result == null) return { status: 204 }
+
+  // Handle special cases
+  if (result instanceof Readable || (op.returns._type === 'cds.LargeBinary' && 'value' in result))
+    return _stream(result, req, res)
+
+  // Set content type if not already set
+  if (!res.get('Content-Type'))
+    res.set('Content-Type', op.returns._type === 'cds.String' ? 'text/plain' : 'application/json')
+
+  // Done
+  return { result }
 }
 
-const _validateReturnType = (operation, data) => {
-  // array of or single return type
-  // in case of modeled return type: { type: 'bookModel.Books', _type: csnDefinition }
-  // in case of inline return type: { elements: ... } and no explicit name of return type
-  const returnType = operation.returns.items ? operation.returns.items : operation.returns
-
-  if (typeof data === 'undefined') return true
-  if (returnType['@open']) return true
+function _stream(result, req, res) {
+  const stream = streaming.getReadable(result)
+  if (!stream) return res.sendStatus(204)
 
-  let checkResult
+  const { mimetype, filename, disposition } = streaming.collectStreamMetadata(result, req._operation, req._query)
+  streaming.validateMimetypeIsAcceptedOrThrow(req.headers, mimetype)
 
-  // .type of action/function behaves different to .type of other csn elements
-  // Return type contains primitives
-  const _type = typeof returnType._type === 'object' ? returnType.__proto__._type : returnType._type // REVISIT: super dirty hack for compiler's to.edmx polluting the csn definitions with ._type -> please use Symbols instead
-  const typeChecker = typeCheckers[_type] // IMPORTANT: use ._type
-  if (typeChecker) {
-    const array = Array.isArray(data) ? data : [data]
-    checkResult = array.filter(value => !typeChecker(value)).map(value => ({ type: _type, value }))
-  } else {
-    if (typeof data !== 'object') {
-      throw new Error(
-        `Invalid scalar value ${typeof data === 'string' ? `"${data}"` : data} for return type "${returnType.type}"`
-      )
-    }
-
-    // Only check complex objects, ignore non-modelled data
-    data = (Array.isArray(data) ? data : [data]).filter(entry => typeof entry === 'object' && !Array.isArray(entry))
-
-    // Determine entity from bound or unbound action/function
-    const returnTypeCsnDefinition = returnType._type || returnType
-
-    // REVISIT: remove exception with cds^6
-    // mtx returns object instead of string (as in modell) -> skip validation
-    if (returnTypeCsnDefinition.type !== 'cds.String') {
-      checkResult = checkStatic(returnTypeCsnDefinition, data, true)
-    }
-  }
-
-  if (checkResult && checkResult.length !== 0) {
-    throw _getTypeError(operation, returnType.type, checkResult)
-  }
-
-  return true
+  if (mimetype && !res.get('Content-Type')) res.set('Content-Type', mimetype)
+  if (filename && !res.get('Content-Disposition'))
+    res.set('Content-Disposition', `${disposition}; filename="${filename}"`)
+  return pipeline(stream, res)
 }
 
-module.exports = adapter => {
-  const { service } = adapter
-
-  return async function operation(req, res) {
-    const { _query: query, _operation: operation, _data: data, _params: params } = req
-    const request = adapter.request4(
-      Object.assign(
-        query // REVISIT: when is a query given, and when not? -> bound vs unbound? -> obsolete with req.subject? -> deprecated?
-          ? { event: operation.name, query } // REVISIT: why don't we need a similar .replace as below here?
-          : { event: operation.name.replace(`${service.definition.name}.`, '') }, // REVISIT: why is this .replace needed?
-        { data, params, req, res } // REVISIT: req and res are not part of the public API !!!
-      )
-    )
-
-    let result = await service.dispatch(request)
-
-    if (!operation.returns || result == null) return { status: 204 }
-
-    const _isStream = result instanceof Readable || (operation.returns._type === 'cds.LargeBinary' && 'value' in result)
-    if (_isStream) {
-      const stream = streaming.getReadable(result)
-      if (!stream) {
-        if (res.statusCode > 200) return res.end()
-        return res.sendStatus(204)
-      }
-
-      const { mimetype, filename, disposition } = streaming.collectStreamMetadata(result, operation, query)
-      streaming.validateMimetypeIsAcceptedOrThrow(req.headers, mimetype)
-
-      if (mimetype && !res.get('Content-Type')) res.set('Content-Type', mimetype)
-
-      if (filename && !res.get('Content-Disposition'))
-        res.set('Content-Disposition', `${disposition}; filename="${filename}"`)
-      // NOTE: We should NOT use encodeURIComponent here, as it is not needed for the filename in the Content-Disposition header
-      //       and it would break the filename in the header if it contains special characters like
-      //       e.g. German umlauts (ä, ö, ü) or spaces
-      //       See also: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
-
-      return stream.pipe(res) && {} // REVISIT: strange caller expects this
-    }
-
-    // REVISIT: do not use from old rest adapter
-    // REVISIT: new impl should return instead of throwing to avoid try catch
-    _validateReturnType(operation, result)
-
-    // set content-type header to text/plain for returned primitive data types, except for boolean
-    const returnType = operation.returns._type
-    if (
-      cds.builtin.types[returnType] &&
-      !operation.returns.items &&
-      returnType !== 'cds.Boolean' &&
-      !res.get('content-type')
-    ) {
-      res.set('Content-Type', 'text/plain')
-    }
-
-    // REVISIT: Still needed with cds-mtxs?
-    // mtx compat, modeled as string but object returned
-    if (operation.returns._type === 'cds.String' && typeof result === 'object') {
-      res.set('Content-Type', 'application/json')
-    }
-
-    // REVISIT: still needed? // REVISIT: indeed!
-    if (!operation.returns.items && Array.isArray(result)) result = result[0]
-
-    if (result === undefined) return { status: 204 }
-
-    return { result }
-  }
-}
+const { pipeline } = require('node:stream/promises')
+const { Readable } = require('node:stream')
+const streaming = require('../../common/utils/streaming')