@sap/cds 8.9.3 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/OData.js

@@ -1,275 +0,0 @@
-const cds = require('../../../cds')
-// requesting logger without module on purpose!
-const LOG = cds.log()
-
-const {
-  BatchExitHandler: { ATOMICITY_GROUP_START, ATOMICITY_GROUP_END },
-  Components: {
-    DATA_CREATE_HANDLER,
-    DATA_DELETE_HANDLER,
-    DATA_READ_HANDLER,
-    DATA_UPDATE_HANDLER,
-    ACTION_EXECUTE_HANDLER,
-    LOCALE_NEGOTIATOR,
-    METADATA_HANDLER
-  }
-} = require('./okra/odata-server')
-
-const _config = require('./utils/oDataConfiguration')
-const _error = require('./handlers/error')
-const _debug = require('./handlers/debug')
-const _request = require('./handlers/request')
-const _language = require('./handlers/language')
-const _metadata = require('./handlers/metadata')
-const _create = require('./handlers/create')
-const _update = require('./handlers/update')
-const _delete = require('./handlers/delete')
-const _read = require('./handlers/read')
-const _action = require('./handlers/action')
-const { normalizeError, isClientError } = require('../../../common/error/frontend')
-const { getErrorMessage } = require('../../../common/error/utils')
-
-function _log(level, arg) {
-  const { params } = arg
-
-  // cds.log() called with multiple args or first arg not an object or string? -> pass through
-  if (params.length !== 1 || (typeof params[0] !== 'object' && typeof params[0] !== 'string')) {
-    LOG[level](arg)
-    return
-  }
-
-  // single arg of type object (from string, if necessary)
-  const obj = typeof params[0] === 'object' ? params[0] : { message: params[0] }
-
-  // augment
-  if (!obj.id) obj.id = arg.id
-  if (!obj.level) obj.level = arg.level
-  if (!obj.timestamp) obj.timestamp = arg.timestamp
-
-  // replace messages in toLog with developer texts (i.e., undefined locale) (cf. req.reject() etc.)
-  const _message = obj.message
-  const _code = obj.code
-  const _details = obj.details
-
-  // REVISIT: the (ugly!) stuff re code is somewhat of a duplicate to what we do in normalizeError -> refactor with new adapters!
-  obj.message = getErrorMessage(obj, '')
-  if (_code) obj.code = obj.code.match?.(/^ASSERT_/) ? 400 : obj.code
-  if (_details) {
-    const details = []
-    const codes = new Set()
-    for (const d of obj.details) {
-      const entry = Object.assign({}, d, { message: getErrorMessage(d, '') })
-      if (!_code) {
-        const k = d.statusCode ? 'statusCode' : d.status ? 'status' : d.code ? 'code' : undefined
-        const v = d[k]?.match?.(/^ASSERT_/) ? 400 : d[k]
-        codes.add(v)
-        entry[k] = v
-      }
-      details.push(entry)
-    }
-    obj.details = details
-    if (!_code && codes.size === 1) {
-      const n = Number(codes.values().next().value)
-      if (!isNaN(n)) obj.code = n
-    }
-  }
-
-  // reduce 4xx to warning
-  if (level === 'error') if (isClientError(obj)) level = 'warn'
-
-  // log it
-  LOG[`_${level}`] && LOG[level](obj)
-
-  // restore
-  obj.message = _message
-  if (_code) obj.code = _code
-  if (_details) obj.details = _details
-}
-
-const _logger = {
-  debug: arg => LOG._debug && _log('debug', arg),
-  path: () => {},
-  info: arg => LOG._info && _log('info', arg),
-  warning: arg => LOG._warn && _log('warn', arg),
-  error: arg => _log('error', arg),
-  fatal: arg => _log('error', arg)
-}
-
-/**
- * Facade for creating an instance of a EDM based OData service.
- *
- * @alias module:odata.OData
- */
-class OData {
-  /**
-   * Constructs an OData service for the given EDM model.
-   *
-   * @param {object} edm - the EDM model.
-   * @param {object} csn
-   * @param {object} [options] - optional object with options.
-   * @param {object} [options.logger] - optional logger object to be used in the odata library.
-   * @param {string} [options.logLevel] - optional log level to be used according to winston/npm specification.
-   * @param {boolean} [options.crashOnError] - Application should crash on error. Defaults to true.
-   *
-   * @throws Error in case no or an invalid csn model is provided.
-   */
-  constructor(edm, csn, options = {}) {
-    this._validateEdm(edm)
-    this._options = options
-    this._createOdataService(edm, csn)
-  }
-
-  _validateEdm(edm) {
-    if (typeof edm !== 'object' || !edm.$Version) {
-      const { getModelNotDefinedError } = require('../../util/errors')
-      throw getModelNotDefinedError('EDM model')
-    }
-  }
-
-  _createOdataService(edm, csn) {
-    const ServiceFactory = require('./okra/odata-server').ServiceFactory
-
-    // skip okra's validation in production or implicitly for w4 and x4
-    const { effective } = cds.env
-    const isTrusted =
-      process.env.NODE_ENV === 'production' ||
-      !Object.prototype.hasOwnProperty.call(cds.env.odata, 'skipValidation') ||
-      cds.env.odata.skipValidation ||
-      effective.odata.containment ||
-      effective.odata.structs ||
-      effective.odata.refs ||
-      effective.odata.proxies ||
-      effective.odata.xrefs
-
-    this._odataService = ServiceFactory.createService(edm, _config(edm, csn, this._options)).trust(isTrusted)
-
-    // will be added to express app like app.use('/base/path/', service) and odata-v4 wants app.use('/', service) if basePath is set
-    this._odataService.setBasePath('/')
-  }
-
-  /**
-   * The added cds service will be used at the handlers.
-   * Some channel events have a 1:N relation to service handler events.
-   *
-   * @param {Service} cdsService
-   */
-  addCDSServiceToChannel(cdsService) {
-    // use cds.log and preserve everything
-    this._odataService.log(_logger, arg => arg)
-
-    this._cdsService = cdsService
-
-    this._odataService.on('error', _error(this._options.crashOnError, cdsService))
-    if (this._options.debug) this._odataService.on('debug', _debug)
-    this._odataService.on('request', _request(cdsService))
-
-    this._odataService.on(ATOMICITY_GROUP_START, (odataContext, done) => {
-      const data = odataContext.applicationData
-
-      // start tx
-      const txs = (data.txs = data.txs || {})
-      const { req, res } = data
-      const tx = (txs[odataContext.id] = cdsService.tx({ req, res }))
-      cds.context = tx.context
-      // for collecting results and errors
-      data.results = data.results || {}
-      data.results[odataContext.id] = []
-      data.errors = data.errors || {}
-      data.errors[odataContext.id] = []
-      done()
-    })
-
-    this._odataService.on(ATOMICITY_GROUP_END, async (odataErr, odataContext, done) => {
-      const tx = odataContext.applicationData.txs[odataContext.id]
-      let errors = odataErr || odataContext.failedRequests.length > 0
-
-      if (errors) {
-        // rollback without errors to not trigger srv.on('error') with array
-        await tx.rollback()
-
-        done()
-        return
-      }
-
-      try {
-        await tx.commit(odataContext.applicationData.results[odataContext.id])
-        done()
-      } catch (e) {
-        // tx gets rolled back automatically
-        // set error on each request of changeset, if commit failed
-        const changesetResults = odataContext.applicationData.results[odataContext.id]
-        const failedRequests = changesetResults.reduce((obj, resultEntry) => {
-          const requestId = resultEntry.req._.odataReq.getOdataRequestId()
-          const { error, statusCode } = normalizeError(e, resultEntry.req)
-          obj[requestId] = Object.assign(error, { statusCode })
-          return obj
-        }, {})
-
-        done(e, { failedRequests })
-      }
-    })
-
-    this._odataService.use(LOCALE_NEGOTIATOR, _language)
-    this._odataService.use(METADATA_HANDLER, _metadata(cdsService))
-
-    this._odataService.use(DATA_CREATE_HANDLER, _create(cdsService))
-    this._odataService.use(DATA_READ_HANDLER, _read(cdsService))
-    this._odataService.use(DATA_UPDATE_HANDLER, _update(cdsService))
-    this._odataService.use(DATA_DELETE_HANDLER, _delete(cdsService))
-
-    this._odataService.use(ACTION_EXECUTE_HANDLER, _action(cdsService))
-    return this
-  }
-
-  /**
-   * Process request.
-   *
-   * @param {http.IncomingMessage} req
-   * @param {http.ServerResponse} res
-   * @private
-   */
-  // REVISIT: Remove this when we replaced Okra
-  process(req, res) {
-    // NOTE: do none of this header manipulation in okra successor!
-    // if ExponentialDecimals=true is set in accept header, ensure IEEE754Compatible=true (use case unclear, but don't introduce regression)
-    // if IEEE754Compatible=true is set in accept header, but ExponentialDecimals is not specified, set it based on cds.env.odata.defaultExponentialDecimals
-    const acceptHeader = req.headers.accept
-    if (acceptHeader?.startsWith('application/json')) {
-      if (acceptHeader.includes('ExponentialDecimals=true') && !acceptHeader.includes('IEEE754Compatible')) {
-        req.headers.accept += ';IEEE754Compatible=true'
-      } else if (
-        'defaultExponentialDecimals' in cds.env.odata &&
-        acceptHeader.includes('IEEE754Compatible=true') &&
-        !acceptHeader.includes('ExponentialDecimals')
-      ) {
-        req.headers.accept += `;ExponentialDecimals=${cds.env.odata.defaultExponentialDecimals}`
-      }
-    }
-    // add IEEE754Compatible=true if !strict_numbers
-    const contentType = req.headers['content-type']
-    if (
-      !cds.env.features.strict_numbers &&
-      contentType?.includes('application/json') &&
-      !contentType.includes('IEEE754Compatible')
-    ) {
-      req.headers['content-type'] = contentType.replace('application/json', 'application/json;IEEE754Compatible=true')
-    }
-
-    // this._startPerfMeasurementOData(req)
-    this._odataService.process(req, res).catch(err => {
-      LOG.warn(err)
-      // REVISIT: use i18n
-      // do not reply with error, if response already processed (streaming)
-      // destroy response socket instead
-      if (res.headersSent) {
-        // REVISIT: temp solution until streaming is switched to express middlewares
-        res.socket?.destroy()
-      } else {
-        const { error, statusCode } = normalizeError(err, req)
-        res.status(statusCode).send({ error })
-      }
-    })
-  }
-}
-
-module.exports = OData

package/libx/_runtime/cds-services/adapter/odata-v4/ODataRequest.js

@@ -1,217 +0,0 @@
-const cds = require('../../../cds')
-
-const {
-  uri: {
-    UriResource: {
-      ResourceKind: { BOUND_ACTION, BOUND_FUNCTION, ACTION_IMPORT, FUNCTION_IMPORT }
-    }
-  }
-} = require('./okra/odata-server')
-
-const { findCsnTargetFor } = require('../../../common/utils/csn')
-const metaInfo = require('./utils/metaInfo')
-const odataToCQN = require('./odata-to-cqn')
-const { getData, getParams } = require('./utils/data')
-const { isCustomOperation } = require('./utils/request')
-const { isStreaming } = require('./utils/stream')
-const { handleStreamProperties } = require('../../../common/utils/streamProp')
-
-function _isCorrectCallToViewWithParams(csdlStructuredType) {
-  return (
-    csdlStructuredType.navigationProperties &&
-    csdlStructuredType.navigationProperties[0] &&
-    csdlStructuredType.navigationProperties[0].name === 'Parameters' &&
-    csdlStructuredType.navigationProperties[0].partner === 'Set'
-  )
-}
-
-function _getTarget(service, segments) {
-  let last = segments.pop()
-
-  if (!last || last.getKind() === ACTION_IMPORT || last.getKind() === FUNCTION_IMPORT) {
-    return
-  }
-
-  if (last.getKind() === BOUND_FUNCTION || last.getKind() === BOUND_ACTION) {
-    last = segments.pop()
-  }
-
-  if (last.getEdmType() && last.getEdmType().csdlStructuredType) {
-    const { namespace } = last.getEdmType().getFullQualifiedName()
-    // REVISIT: better way to identify situation "view with parameters"
-    const name = _isCorrectCallToViewWithParams(last.getEdmType().csdlStructuredType)
-      ? last.getEdmType().csdlStructuredType.navigationProperties[0].type.name
-      : last.getEdmType().csdlStructuredType.name
-
-    // autoexposed entities now used . in csn and _ in edm
-    const target = findCsnTargetFor(name, service.model, namespace)
-
-    if (target && target.kind === 'entity') {
-      return target
-    }
-  }
-
-  return _getTarget(service, segments)
-}
-
-function _add4Odata(query) {
-  if (Array.isArray(query))
-    for (let i = 0; i < query.length; i++) Object.defineProperty(query[i].SELECT, '_4odata', { value: true })
-  else Object.defineProperty(query.SELECT, '_4odata', { value: true })
-}
-
-function _addAllColumns(query) {
-  if (Array.isArray(query)) {
-    query.forEach(q => {
-      if (!q.SELECT.from.SELECT) _addAllColumns(q)
-    })
-  } else {
-    if (!query.SELECT.columns) query.SELECT.columns = ['*']
-  }
-}
-
-function _handleStreamProperties(target, query, model) {
-  if (Array.isArray(query)) {
-    query.forEach(q => {
-      _handleStreamProperties(target, q, model)
-    })
-  } else {
-    handleStreamProperties(target, query.SELECT.columns, model)
-  }
-}
-
-/**
- * Class representing an OData request.
- * @extends cds.Request
- *
- * @param {string} type - The OData request type (a.k.a. "Component")
- * @param {import('../../../common/Service')} service - The underlying CAP service
- * @param {import('./okra/odata-server/core/OdataRequest')} odataReq - OKRA's req
- * @param {import('./okra/odata-server/core/OdataResponse')} odataRes - OKRA's res
- */
-class ODataRequest extends cds.Request {
-  constructor(type, service, odataReq, odataRes, upsert) {
-    const req = odataReq.getBatchApplicationData()
-      ? odataReq.getBatchApplicationData().req
-      : odataReq.getIncomingRequest()
-    const res = req.res
-    const segments = odataReq.getUriInfo().getPathSegments()
-
-    if (cds.env.features.odata_new_parser) {
-      // REVISIT need to resolve target after replacing okra <= maybe just take one from afterburner?
-      const target = _getTarget(service, [...segments])
-      // REVISIT payload after replacing okra
-      const data = getData(type, odataReq, service, target)
-      const query = odataToCQN(type, service, target, data, odataReq, upsert)
-      const headers = Object.assign({}, req.headers, odataReq.getHeaders())
-      // REVISIT needed in case of $batch, replace after removing okra
-      const method = odataReq.getIncomingRequest().method
-      const { user, tenant } = cds.context
-      const info = metaInfo(query, type, service, data, req, upsert)
-      const { event, unbound } = info
-      if (event === 'READ') {
-        _add4Odata(query)
-        _addAllColumns(query)
-        if (!isStreaming(segments)) _handleStreamProperties(target, query, service.model)
-      }
-      const _queryOptions = odataReq.getQueryOptions()
-      // prettier-ignore
-      super({ event, target, data, query: unbound ? {} : query, user, tenant, method, headers, req, res, _queryOptions })
-      this._metaInfo = info.metadata
-    } else {
-      /*
-       * target
-       */
-      const target = _getTarget(service, [...segments])
-
-      /*
-       * data
-       */
-      const data = getData(type, odataReq, service, target)
-
-      /*
-       * query
-       */
-      const operation = isCustomOperation(segments) ? odataReq.getUriInfo().getLastSegment().getKind() : type
-      const query = odataToCQN(operation, service, target, data, odataReq, upsert)
-
-      /*
-       * event
-       */
-      let event = type
-
-      // actions & functions
-      const uriInfoLastSegment = odataReq.getUriInfo().getLastSegment()
-
-      switch (uriInfoLastSegment && uriInfoLastSegment.getKind()) {
-        case 'BOUND.ACTION':
-          event = uriInfoLastSegment.getAction().getName()
-          break
-
-        case 'ACTION.IMPORT':
-          event = uriInfoLastSegment.getActionImport().getName()
-          break
-
-        case 'BOUND.FUNCTION':
-          event = uriInfoLastSegment.getFunction().getName()
-          break
-
-        case 'FUNCTION.IMPORT':
-          event = uriInfoLastSegment.getFunctionImport().getName()
-          break
-
-        // no default
-      }
-
-      // draft
-      if (target && target._isDraftEnabled) {
-        if (type === 'CREATE') event = 'NEW'
-        else if (event === 'draftEdit') event = 'EDIT'
-        else if (type === 'UPDATE') event = 'PATCH'
-        else if (type === 'DELETE' && data.IsActiveEntity !== true) event = 'CANCEL'
-      }
-
-      // mark query as for an OData READ
-      if (event === 'READ') Object.defineProperty(query.SELECT, '_4odata', { value: true })
-
-      /*
-       * method, headers
-       */
-      const method = odataReq.getMethod()
-
-      // REVISIT: Why do we mix headers of $batch and batched request headers??
-      const headers = Object.assign({}, req.headers, odataReq.getHeaders())
-
-      /*
-       * super
-       */
-      const { user, tenant } = cds.context
-      // REVISIT: public API for query options (express style req.query already in use)?
-      const _queryOptions = odataReq.getQueryOptions()
-      super({ event, target, data, query, user, method, headers, req, res, _queryOptions, tenant })
-    }
-
-    /*
-     * req.params
-     */
-    Object.defineProperty(this, 'params', {
-      configurable: true,
-      get: function () {
-        this._params = this._params || getParams(odataReq)
-        return this._params
-      }
-    })
-
-    /*
-     * REVISIT: compat req._.*
-     */
-    // odataReq and odataRes
-    this._.odataReq = odataReq
-    this._.odataRes = odataRes
-
-    Object.defineProperty(this, 'protocol', { value: 'odata' })
-    req._okra_logger?.(this)
-  }
-}
-
-module.exports = ODataRequest

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/action.js

@@ -1,101 +0,0 @@
-const cds = require('../../../../cds')
-
-const ODataRequest = require('../ODataRequest')
-
-const {
-  Components: { ACTION_EXECUTE_HANDLER }
-} = require('../okra/odata-server')
-
-const { getSapMessages } = require('../../../../common/error/frontend')
-const { getActionOrFunctionReturnType, isReturnMinimal } = require('../utils/handlerUtils')
-const { validateResourcePath } = require('../utils/request')
-const { toODataResult, postProcess } = require('../utils/result')
-const { DRAFT_EVENTS } = require('../../../../common/constants/events')
-const { readAfterWrite } = require('../utils/readAfterWrite')
-const { toBase64url } = require('../../../../common/utils/binary')
-
-const _postProcess = async (req, odataReq, odataRes, tx, result) => {
-  const returnType = getActionOrFunctionReturnType(odataReq.getUriInfo().getPathSegments(), tx.model.definitions)
-  // as of spec meeting: no generic support of $select/$expand for custom actions/functions
-  if (returnType && returnType.kind === 'entity' && (req.event in DRAFT_EVENTS || req.event === 'EDIT')) {
-    result = await readAfterWrite(req, tx, { operation: { result, returnType } })
-    if (result && !('IsActiveEntity' in result)) result.IsActiveEntity = req.event === 'draftActivate'
-  }
-  const _req = Object.setPrototypeOf({ target: returnType || req.target }, req)
-  postProcess(_req, odataRes, tx, result)
-  return result
-}
-
-/**
- * The handler that will be registered with odata-v4.
- *
- * @param {import('../../../../common/Service')} service
- * @returns {function}
- */
-const action = service => {
-  return async (odataReq, odataRes, next) => {
-    let req
-
-    try {
-      validateResourcePath(odataReq, service)
-      req = new ODataRequest(ACTION_EXECUTE_HANDLER, service, odataReq, odataRes)
-    } catch (e) {
-      return next(e)
-    }
-
-    const changeset = odataReq.getAtomicityGroupId()
-    const tx = changeset ? odataReq.getBatchApplicationData().txs[changeset] : service.tx(req)
-    cds.context = tx
-
-    let result, err
-
-    try {
-      result = await tx.dispatch(req)
-
-      result = await _postProcess(req, odataReq, odataRes, tx, result)
-
-      if (changeset) {
-        // for passing into commit
-        odataReq.getBatchApplicationData().results[changeset].push({ result, req })
-      } else {
-        await tx.commit(result)
-      }
-
-      if (result == null || isReturnMinimal(req)) odataRes.setStatusCode(204, { overwrite: true })
-      else if (req.event === 'draftActivate' || req.event === 'EDIT') {
-        const keys = Object.keys(req.target.keys).filter(k => {
-          return k !== 'IsActiveEntity' && !req.target.keys[k]._isAssociationStrict
-        })
-        const keysString = keys
-          .map(key => {
-            let val = result[key]
-            if (Buffer.isBuffer(val)) {
-              val = toBase64url(result[key])
-            }
-            return `${key}=${val}`
-          })
-          .join(',')
-        odataRes.setHeader(
-          'location',
-          `../${req.target.name.replace(`${service.name}.`, '')}(${keysString},IsActiveEntity=${
-            req.event === 'draftActivate'
-          })`
-        )
-      }
-    } catch (e) {
-      err = e
-
-      if (!changeset) {
-        // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
-        await tx.rollback(e).catch(() => {})
-      }
-    } finally {
-      req.messages?.length && odataRes.setHeader('sap-messages', getSapMessages(req.messages, req.http.req))
-
-      if (err) next(err)
-      else next(null, toODataResult(result, req))
-    }
-  }
-}
-
-module.exports = action

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

@@ -1,79 +0,0 @@
-const cds = require('../../../../cds')
-const ODataRequest = require('../ODataRequest')
-
-const {
-  Components: { DATA_CREATE_HANDLER }
-} = require('../okra/odata-server')
-
-const { validateResourcePath } = require('../utils/request')
-const { isReturnMinimal } = require('../utils/handlerUtils')
-const { readAfterWrite } = require('../utils/readAfterWrite')
-const { toODataResult, postProcess, postProcessMinimal } = require('../utils/result')
-
-const { getSapMessages } = require('../../../../common/error/frontend')
-
-/**
- * The handler that will be registered with odata-v4.
- *
- * @param {import('../../../../common/Service')} service
- * @returns {function}
- */
-const create = service => {
-  return async (odataReq, odataRes, next) => {
-    let req
-
-    try {
-      validateResourcePath(odataReq, service)
-      req = new ODataRequest(DATA_CREATE_HANDLER, service, odataReq, odataRes)
-    } catch (e) {
-      return next(e)
-    }
-
-    const changeset = odataReq.getAtomicityGroupId()
-    const tx = changeset ? odataReq.getBatchApplicationData().txs[changeset] : service.tx(req)
-    cds.context = tx
-
-    let result, err
-
-    try {
-      result = await tx.dispatch(req)
-
-      // REVISIT:
-      // Performance: For `isReturnMinimal` it's enough to just read the etag.
-      // Note: Without read access, one cannot return the etag.
-      if (req._.readAfterWrite) {
-        result = await readAfterWrite(req, service, { operation: { result } })
-      }
-      if (isReturnMinimal(req)) {
-        result = postProcessMinimal(req, service, result)
-      } else {
-        postProcess(req, odataRes, service, result)
-      }
-
-      if (changeset) {
-        // for passing into commit
-        odataReq.getBatchApplicationData().results[changeset].push({ result, req })
-      } else {
-        await tx.commit(result)
-      }
-
-      if (result == null || isReturnMinimal(req)) {
-        odataRes.setStatusCode(204, { overwrite: true })
-      }
-    } catch (e) {
-      err = e
-
-      if (!changeset) {
-        // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
-        await tx.rollback(e).catch(() => {})
-      }
-    } finally {
-      req.messages?.length && odataRes.setHeader('sap-messages', getSapMessages(req.messages, req.http.req))
-
-      if (err) next(err)
-      else next(null, toODataResult(result, req))
-    }
-  }
-}
-
-module.exports = create

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/debug.js

@@ -1,6 +0,0 @@
-const debug = (req, res, next) => {
-  req.getContract().enableDebugMode(true)
-  next()
-}
-
-module.exports = debug