@sap/cds 5.9.6 → 6.0.1

package/libx/_runtime/cds-services/adapter/rest/Rest.js

@@ -1,183 +0,0 @@
-const cds = require('../../../cds')
-// requesting logger without module on purpose!
-const LOG = cds.log()
-
-const createHandler = require('./handlers/create')
-const readHandler = require('./handlers/read')
-const updateHandler = require('./handlers/update')
-const deleteHandler = require('./handlers/delete')
-const operationHandler = require('./handlers/operation')
-
-const { contentTypeCheck } = require('./utils/header-checks')
-const parse = require('./utils/parse-url')
-const { base64toBuffer } = require('./utils/binary')
-
-const { UNAUTHORIZED, FORBIDDEN, getRequiresAsArray } = require('../../../auth/utils')
-
-const PPP = { POST: 1, PUT: 1, PATCH: 1 }
-const GH = { GET: 1, HEAD: 1 }
-
-let _i18n
-const i18n = (...args) => {
-  if (!_i18n) _i18n = require('../../../common/i18n')
-  return _i18n(...args)
-}
-
-const { normalizeError, isClientError } = require('../../../common/error/frontend')
-
-const _log = err => {
-  const level = isClientError(err) ? 'warn' : 'error'
-  if ((level === 'warn' && !LOG._warn) || (level === 'error' && !LOG._error)) return
-
-  // replace messages in toLog with developer texts (i.e., undefined locale)
-  const _message = err.message
-  const _details = err.details
-  err.message = i18n(err.message || err.code, undefined, err.args) || err.message
-  if (err.details) {
-    const details = []
-    for (const d of err.details) {
-      details.push(Object.assign({}, d, { message: i18n(d.message || d.code, undefined, d.args) || d.message }))
-    }
-    err.details = details
-  }
-
-  // log it
-  LOG[level](err)
-
-  // restore
-  err.message = _message
-  if (_details) err.details = _details
-}
-
-class Rest {
-  constructor(cdsService) {
-    this._cdsService = cdsService
-    this._createRouter()
-    this._addDispatcher()
-  }
-
-  get _express() {
-    const express = require('express')
-    Object.defineProperty(this, '_express', { value: express })
-    return express
-  }
-
-  _createRouter() {
-    this.router = this._express.Router()
-    this.router.use(this._express.json())
-  }
-
-  _addDispatcher() {
-    const srv = this._cdsService
-
-    const create = createHandler(srv)
-    const read = readHandler(srv)
-    const update = updateHandler(srv)
-    const deleet = deleteHandler(srv)
-    const operation = operationHandler(srv)
-
-    const requires = getRequiresAsArray(srv.definition)
-
-    /*
-     * pre handler stuff
-     */
-    this.router.use('/', (req, res, next) => {
-      // check @requires as soon as possible (DoS)
-      if (req.path !== '/' && requires.length > 0 && !requires.some(r => req.user.is(r))) {
-        // > unauthorized or forbidden?
-        if (req.user._is_anonymous) {
-          if (req.user._challenges) res.set('WWW-Authenticate', req.user._challenges.join(';'))
-          // REVISIT: security log in else case?
-          throw UNAUTHORIZED
-        }
-        // REVISIT: security log?
-        throw FORBIDDEN
-      }
-
-      // service root
-      if (req.path === '/' && GH[req.method]) {
-        if (req.method === 'HEAD') return res.json({})
-        else
-          return res.json(
-            Object.keys(srv.entities).reduce(
-              (acc, cur) => {
-                acc.entities.push({ name: cur, url: cur })
-                return acc
-              },
-              { entities: [] }
-            )
-          )
-      }
-
-      // content-type check, parse url, and base64 to buffer
-      try {
-        if (PPP[req.method]) contentTypeCheck(req)
-        req._parsed = parse[req.method](srv, req)
-        base64toBuffer(req.body, req._parsed.segments[0])
-      } catch (e) {
-        return next(e)
-      }
-
-      next()
-    })
-
-    // POST
-    this.router.post('/*', (req, res, next) => {
-      // CREATE or custom operation?
-      if (req._parsed.event === 'CREATE') {
-        create(req, res, next)
-      } else {
-        operation(req, res, next)
-      }
-    })
-
-    // HEAD
-    this.router.head('/*', (req, res, next) => {
-      read(req, res, next)
-    })
-
-    // GET
-    this.router.get('/*', (req, res, next) => {
-      // READ or custom operation?
-      if (req._parsed.event === 'READ') {
-        read(req, res, next)
-      } else {
-        operation(req, res, next)
-      }
-    })
-
-    // PUT, PATCH, DELETE
-    this.router.put('/*', update)
-    this.router.patch('/*', update)
-    this.router.delete('/*', deleet)
-
-    /*
-     * error handling (the express way)
-     */
-    this.router.use((err, req, res, next) => {
-      // invoke srv.on('error', function (err, req) { ... }) here in special situations
-      // REVISIT: if for compat reasons, remove once cds^5.1
-      if (srv._handlers._error) {
-        let ctx = cds.context
-        if (!ctx) {
-          // > error before req was dispatched
-          ctx = new cds.Request({ req, res: req.res, user: req.user || new cds.User.Anonymous() })
-          for (const each of srv._handlers._error) each.handler.call(srv, err, ctx)
-        }
-      }
-
-      // log the error (4xx -> warn)
-      _log(err)
-
-      const { error, statusCode } = normalizeError(err, req)
-
-      if (res.statusCode === 200) {
-        // > i.e., not set in custom handler
-        res.status(statusCode)
-      }
-      res.send({ error })
-    })
-  }
-}
-
-module.exports = Rest

package/libx/_runtime/cds-services/adapter/rest/RestRequest.js

@@ -1,67 +0,0 @@
-const cds = require('../../../cds')
-// requesting logger without module on purpose!
-const LOG = cds.log()
-
-const restToCqn = require('./rest-to-cqn')
-const { flattenDeepToOneAssociations } = require('../../services/utils/handlerUtils')
-
-/*
- * Class representing a REST request.
- * @extends Request
- *
- * @param {String} parsed - The parsed url of the incoming request
- * @param {Object} data - A deep copy of the request payload
- * @param {Object} req - express' req
- * @param {Object} res - express' res
- * @param {Object} service - The underlying CAP service
- */
-class RestRequest extends cds.Request {
-  constructor(parsed, data, req, res, service) {
-    const { event, target } = parsed
-
-    // for functions, data is in params (if provided)
-    if (parsed.kind === 'function' && parsed.params) data = parsed.params
-
-    /*
-     * query
-     */
-    const query = restToCqn(parsed, data, req, service)
-
-    /*
-     * method, headers
-     */
-    const { method, headers } = req
-
-    /*
-     * super
-     */
-    const { user } = req
-    // REVISIT: _model should not be necessary
-    const _model = service.model
-    // REVISIT: public API for query options (express style req.query already in use)?
-    const _queryOptions = req.query
-    super({ event, target, data, query, user, method, headers, req, res, _model, _queryOptions })
-
-    // REVISIT: validate associations for deep insert
-    flattenDeepToOneAssociations(this, this.model)
-
-    /*
-     * req.run
-     */
-    Object.defineProperty(this, 'run', {
-      configurable: true,
-      get:
-        () =>
-        (...args) => {
-          if (!cds._deprecationWarningForRun) {
-            LOG._warn && LOG.warn('req.run is deprecated and will be removed.')
-            cds._deprecationWarningForRun = true
-          }
-
-          return cds.tx(this).run(...args)
-        }
-    })
-  }
-}
-
-module.exports = RestRequest

package/libx/_runtime/cds-services/adapter/rest/handlers/create.js

@@ -1,82 +0,0 @@
-const cds = require('../../../../cds')
-
-const RestRequest = require('../RestRequest')
-
-const getData = require('../utils/data')
-const { bufferToBase64 } = require('../utils/binary')
-
-const _locationHeader = (entity, serviceName, resultObject) => {
-  const keyName = Object.keys(entity.keys)[0]
-  const entityNameWithoutServicePrefix = entity.name.replace(`${serviceName}.`, '')
-  return `../${entityNameWithoutServicePrefix}/${resultObject[keyName]}`
-}
-
-/*
- * optimistically transforms result from flat to complex based on input
- */
-const _transformToComplex = (result, data) => {
-  for (let i = 0; i < result.length; i++) {
-    const d = result[i]
-    const cd = data[i]
-
-    const props = Object.keys(d)
-    const keys = Object.keys(cd).filter(k => !props.includes(k))
-
-    for (const k of keys) {
-      const inner = props.filter(p => p.startsWith(`${k}_`)).map(p => p.split(`${k}_`)[1])
-      if (inner.length > 0) {
-        d[k] = {}
-        for (const i of inner) {
-          d[k][i] = d[`${k}_${i}`]
-          delete d[`${k}_${i}`]
-        }
-      }
-    }
-  }
-}
-
-module.exports = service => {
-  return async (restReq, restRes, next) => {
-    const {
-      _parsed: parsed,
-      _parsed: { target }
-    } = restReq
-
-    const [validationError, data] = getData(parsed, restReq)
-    if (validationError) return next(validationError)
-
-    // create tx and set as cds.context
-    // REVISIT: _model should not be necessary
-    const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
-    cds.context = tx
-
-    let result, err, location
-    try {
-      const reqs = data.map(d => new RestRequest(parsed, d, restReq, restRes, service))
-      result = await Promise.all(reqs.map(req => tx.dispatch(req)))
-
-      _transformToComplex(result, data)
-      bufferToBase64(result, target)
-
-      // batch?
-      if (!Array.isArray(restReq.body)) {
-        result = result[0]
-        location = _locationHeader(target, service.name, result)
-      }
-
-      await tx.commit(result)
-    } catch (e) {
-      err = e
-      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
-      await tx.rollback(e).catch(() => {})
-    } finally {
-      if (err) next(err)
-      else {
-        // only set status if not yet modified
-        if (restRes.statusCode === 200) restRes.status(201)
-        if (location) restRes.set('location', location)
-        restRes.send(result)
-      }
-    }
-  }
-}

package/libx/_runtime/cds-services/adapter/rest/handlers/delete.js

@@ -1,39 +0,0 @@
-const cds = require('../../../../cds')
-
-const RestRequest = require('../RestRequest')
-
-const getData = require('../utils/data')
-
-module.exports = service => {
-  return async (restReq, restRes, next) => {
-    const { _parsed: parsed } = restReq
-
-    const [validationError, data] = getData(parsed, restReq)
-    if (validationError) return next(validationError)
-
-    // create tx and set as cds.context
-    // REVISIT: _model should not be necessary
-    const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
-    cds.context = tx
-
-    const req = new RestRequest(parsed, data, restReq, restRes, service)
-
-    let err
-    try {
-      await tx.dispatch(req)
-
-      await tx.commit(null)
-    } catch (e) {
-      err = e
-      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
-      await tx.rollback(e).catch(() => {})
-    } finally {
-      if (err) next(err)
-      else {
-        // only set status if not yet modified
-        if (restRes.statusCode === 200) restRes.status(204)
-        restRes.send()
-      }
-    }
-  }
-}

package/libx/_runtime/cds-services/adapter/rest/handlers/operation.js

@@ -1,63 +0,0 @@
-const cds = require('../../../../cds')
-
-const RestRequest = require('../RestRequest')
-
-const getData = require('../utils/data')
-const { validateReturnType } = require('../utils/validation-checks')
-const { bufferToBase64 } = require('../utils/binary')
-const { toRestResult } = require('../utils/result')
-
-const _convertCustomOperationReturnValue = (returns, result) => {
-  if (returns.items) {
-    return result
-  } else {
-    return Array.isArray(result) ? result[0] : result
-  }
-}
-
-module.exports = service => {
-  return async (restReq, restRes, next) => {
-    const {
-      _parsed: parsed,
-      _parsed: { segments, operation }
-    } = restReq
-
-    const [validationError, data] = getData(parsed, restReq)
-    if (validationError) return next(validationError)
-
-    // create tx and set as cds.context
-    // REVISIT: _model should not be necessary
-    const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
-    cds.context = tx
-
-    const req = new RestRequest(parsed, data, restReq, restRes, service)
-
-    let result, err, status, body
-    try {
-      result = await tx.dispatch(req)
-
-      if (!operation.returns) {
-        status = 204
-      } else {
-        validateReturnType(operation, result)
-        bufferToBase64(result, segments[0])
-        body = _convertCustomOperationReturnValue(operation.returns, result)
-      }
-
-      await tx.commit(result)
-    } catch (e) {
-      err = e
-      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
-      await tx.rollback(e).catch(() => {})
-    } finally {
-      if (err) next(err)
-      else {
-        // only set status if not yet modified
-        const { statusCode } = restRes
-        if (statusCode === 200 && status) restRes.status(status)
-        if (body === undefined) restRes.status(statusCode === 200 ? 204 : statusCode).end()
-        else restRes.send(toRestResult(body))
-      }
-    }
-  }
-}

package/libx/_runtime/cds-services/adapter/rest/handlers/read.js

@@ -1,52 +0,0 @@
-const cds = require('../../../../cds')
-
-const RestRequest = require('../RestRequest')
-
-const getData = require('../utils/data')
-const { toRestResult } = require('../utils/result')
-const getError = require('../../../../common/error')
-const { bufferToBase64 } = require('../utils/binary')
-
-module.exports = service => {
-  return async (restReq, restRes, next) => {
-    const {
-      _parsed: parsed,
-      _parsed: { segments }
-    } = restReq
-
-    const [validationError, data] = getData(parsed, restReq)
-    if (validationError) return next(validationError)
-
-    // create tx and set as cds.context
-    // REVISIT: _model should not be necessary
-    const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
-    cds.context = tx
-
-    let result, err
-    try {
-      const req = new RestRequest(parsed, data, restReq, restRes, service)
-
-      result = await tx.dispatch(req)
-
-      if (result == null) throw getError(404, 'NO_MATCHING_RESOURCE')
-
-      bufferToBase64(result, segments[0])
-
-      await tx.commit(result)
-    } catch (e) {
-      err = e
-      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
-      await tx.rollback(e).catch(() => {})
-    } finally {
-      if (err) next(err)
-      else if (restReq.method === 'HEAD')
-        restRes
-          .set({
-            'content-type': 'application/json; charset=utf-8',
-            'content-length': JSON.stringify(result).length
-          })
-          .end()
-      else restRes.send(toRestResult(result))
-    }
-  }
-}

package/libx/_runtime/cds-services/adapter/rest/handlers/update.js

@@ -1,81 +0,0 @@
-const cds = require('../../../../cds')
-
-const RestRequest = require('../RestRequest')
-
-const getData = require('../utils/data')
-const getError = require('../../../../common/error')
-const { bufferToBase64 } = require('../utils/binary')
-
-const UPSERT_ALLOWED = !(cds.env.runtime && cds.env.runtime.allow_upsert === false)
-
-const _getData = (parsed, restReq) => {
-  const [validationError, data] = getData(parsed, restReq)
-  if (validationError) throw validationError
-  if (parsed.event === 'CREATE') return data[0]
-  if (Array.isArray(data)) throw getError(400, 'Batch updates are no longer supported.')
-  return data
-}
-
-const _updateThenCreate = async (parsed, restReq, restRes, tx) => {
-  let req, result
-
-  try {
-    req = new RestRequest(parsed, _getData(parsed, restReq), restReq, restRes, tx)
-    result = await tx.dispatch(req)
-  } catch (e) {
-    if ((e.code === 404 || e.status === 404 || e.statusCode === 404) && UPSERT_ALLOWED) {
-      // REVISIT: remove error (and child?) from tx.context? -> would require a unique req.id
-
-      parsed.event = 'CREATE'
-      req = new RestRequest(parsed, _getData(parsed, restReq), restReq, restRes, tx)
-      result = await tx.dispatch(req)
-
-      // REVISIT
-      result = Array.isArray(result) ? result[0] : result
-    } else {
-      throw e
-    }
-  }
-
-  return result
-}
-
-const update = service => {
-  return async (restReq, restRes, next) => {
-    const {
-      _parsed: parsed,
-      _parsed: { target }
-    } = restReq
-
-    // create tx and set as cds.context
-    // REVISIT: _model should not be necessary
-    const tx = service.tx({ user: restReq.user, req: restReq, _model: service.model })
-    cds.context = tx
-
-    let result, err, status
-    try {
-      // try UPDATE and, on 404 error, try CREATE
-      result = await _updateThenCreate(parsed, restReq, restRes, tx)
-
-      // PUT resulting in CREATE shall return 201
-      if (restReq.method === 'PUT' && parsed.event === 'CREATE') status = 201
-
-      bufferToBase64(result, target)
-
-      await tx.commit(result)
-    } catch (e) {
-      err = e
-      // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
-      await tx.rollback(e).catch(() => {})
-    } finally {
-      if (err) next(err)
-      else {
-        // only set status if not yet modified
-        if (restRes.statusCode === 200 && status) restRes.status(status)
-        restRes.send(result)
-      }
-    }
-  }
-}
-
-module.exports = update

package/libx/_runtime/cds-services/adapter/rest/rest-to-cqn/index.js

@@ -1,56 +0,0 @@
-const cds = require('../../../../cds')
-
-const { INSERT, SELECT, UPDATE, DELETE } = cds.ql
-
-const { createCqlString } = require('./utils')
-const { getColumns } = require('../../../services/utils/columns')
-const { getMaxPageSize, getDefaultPageSize } = require('../../../../common/utils/page')
-
-const _readToCQN = ({ isCollection, segments }, target, restReq) => {
-  const key = Object.keys(target.keys)[0]
-
-  const cqn = SELECT.from(
-    createCqlString(target, key, segments[1]),
-    getColumns(target, {
-      onlyNames: true,
-      removeIgnore: true
-    })
-  )
-
-  if (!isCollection) cqn.SELECT.one = true
-
-  if (isCollection && (restReq.query.$top || restReq.query.$skip)) {
-    const top = restReq.query.$top ? parseInt(restReq.query.$top) : getDefaultPageSize(target)
-    cqn.limit(Math.min(top, getMaxPageSize(target)), parseInt(restReq.query.$skip) || 0)
-  }
-
-  return cqn
-}
-
-/**
- * @param {object} parsed
- * @param {object} data
- * @param {object} restReq
- * @returns {object}
- */
-module.exports = (parsed, data, restReq, service) => {
-  const odata2cqn = cds.env.features.rest_new_parser
-
-  const { event, segments, target } = parsed
-
-  const key = target && Object.keys(target.keys)[0]
-  const value = segments && segments.length > 1 && segments[1]
-
-  switch (event) {
-    case 'CREATE':
-      return INSERT.into(target).entries(data)
-    case 'READ':
-      return odata2cqn ? cds.odata.parse(restReq, { service }) : _readToCQN(parsed, target, restReq)
-    case 'UPDATE':
-      return UPDATE(createCqlString(target, key, value)).data(data)
-    case 'DELETE':
-      return DELETE.from(createCqlString(target, key, value))
-    default:
-      return target ? SELECT.from(createCqlString(target, key, value)) : undefined
-  }
-}

package/libx/_runtime/cds-services/adapter/rest/rest-to-cqn/utils.js

@@ -1,33 +0,0 @@
-const DATA_TYPES_NOT_TO_BE_CONVERTED_BY_COMPILER = {
-  'cds.Boolean': 1,
-  'cds.Integer': 1,
-  'cds.Integer16': 1,
-  'cds.Integer32': 1,
-  'cds.Integer64': 1,
-  'cds.Decimal': 1,
-  'cds.DecimalFloat': 1,
-  'cds.Float': 1,
-  'cds.Double': 1
-}
-
-const _convertKeyForCompiler = (keyValue, type) => {
-  if (!DATA_TYPES_NOT_TO_BE_CONVERTED_BY_COMPILER[type]) {
-    return `'${keyValue}'`
-  }
-
-  return keyValue
-}
-
-const createCqlString = (target, key, keyValue) => {
-  let keyString = ''
-
-  if (keyValue !== undefined) {
-    keyString = `[${key}=${_convertKeyForCompiler(keyValue, target.keys[key]._type)}]`
-  }
-
-  return `${target.name}${keyString}`
-}
-
-module.exports = {
-  createCqlString
-}

package/libx/_runtime/cds-services/adapter/rest/to.js

@@ -1,8 +0,0 @@
-const to = service => {
-  const Rest = require('./Rest')
-  const rest = new Rest(service)
-
-  return rest.router
-}
-
-module.exports = to