@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/batch/BatchExitHandler.js

@@ -1,239 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-
-const ComponentManager = require('../core/ComponentManager')
-const ContentTypes = commons.format.ContentTypeInfo.ContentTypes
-const PlainHttpResponse = require('../core/PlainHttpResponse')
-const RepresentationKinds = commons.format.RepresentationKind.Kinds
-
-/**
- * Class containing methods to handle application exit handlers.
- * @hideconstructor
- */
-class BatchExitHandler {
-  /**
-   * Call the batch-start handler.
-   * @param {Function} handler the handler function
-   * @param {BatchContext} batchContext Batch context
-   * @param {Object} data the custom application data
-   * @returns {Promise} a promise
-   */
-  static handleBatchStart (handler, batchContext, data) {
-    return new Promise((resolve, reject) => {
-      try {
-        handler({ applicationData: data }, error => {
-          if (error) {
-            batchContext.setFrameworkError(error)
-            return reject(error)
-          }
-          return resolve()
-        })
-      } catch (error) {
-        batchContext.setFrameworkError(error)
-        reject(error)
-      }
-    })
-  }
-
-  /**
-   * Call the batch-end handler.
-   * @param {Function} handler the handler function
-   * @param {BatchContext} batchContext Batch context
-   * @param {Error} error a previously occurred error
-   * @param {Object} data the custom application data
-   * @param {BatchErrorInfo[]} failedRequests batched requests with an error status code
-   * @returns {Promise} a promise
-   */
-  static handleBatchEnd (handler, batchContext, error, data, failedRequests) {
-    return new Promise((resolve, reject) => {
-      try {
-        handler(error, { applicationData: data, failedRequests: failedRequests }, applicationError => {
-          if (applicationError || error) {
-            batchContext.setFrameworkError(applicationError || error)
-            return reject(applicationError || error)
-          }
-          return resolve()
-        })
-      } catch (applicationError) {
-        batchContext.setFrameworkError(error)
-        reject(applicationError)
-      }
-    })
-  }
-
-  /**
-   * Call the atomicity-group-start handler.
-   * @param {Function} handler the handler function
-   * @param {Object} data the custom application data
-   * @param {string} id atomicity-group ID
-   * @returns {Promise} a promise
-   */
-  static handleGroupStart (handler, data, id) {
-    return new Promise((resolve, reject) => {
-      try {
-        handler({ applicationData: data, id: id }, error => (error ? reject(error) : resolve()))
-      } catch (applicationError) {
-        reject(applicationError)
-      }
-    })
-  }
-
-  /**
-   * Overwrites some responses of an atomicity group with an given error message
-   * @param {BatchContext} batchContext Batch context
-   * @param {Array<string>} options Options object
-   * @param {Array<string>} options.failedRequests Request ids of requests to be overwritten
-   * @param {string} atomicityGroupId Atomicity group id
-   * @param {Error}applicationError Application error, e.g the root causes might be an additional constrains check which triggers an rollback
-   */
-  static handleApplicationError (batchContext, options, atomicityGroupId, applicationError) {
-    const negotiator = batchContext._incomingODataRequest._service._componentManager.getComponent(
-      ComponentManager.Components.CONTENT_NEGOTIATOR
-    )
-    for (const req of batchContext._requests) {
-      if (req.getAtomicityGroupId() === atomicityGroupId) {
-        const requestId = req.getOdataRequestId()
-        const response = batchContext.getResponses().get(requestId)
-        // override error response
-
-        if (options && requestId in options.failedRequests) {
-          // root causes which lead to the rollback (e.g. due to additional constrains check)
-          const incomingResponse = new PlainHttpResponse()
-          response.setInResponse(incomingResponse)
-          const contentTypeInfo = negotiator.negotiateContentType(
-            batchContext._incomingODataRequest._service._formatManager,
-            RepresentationKinds.ERROR,
-            ContentTypes.JSON
-          )
-          const serializer = contentTypeInfo.getSerializerFunction()
-
-          serializer(
-            options.failedRequests[requestId],
-            null,
-            // eslint-disable-next-line handle-callback-err
-            (error, payload) => {
-              incomingResponse.setHeader('content-type', ContentTypes.JSON)
-
-              incomingResponse.write(payload, 'utf8')
-              incomingResponse.statusCode = options.failedRequests[requestId].statusCode
-            }
-          )
-
-          // set response  options.failedRequests[requestId]
-        }
-
-        // mark request as failed in atomicity group
-        batchContext.markRequestAsFailed(requestId, req, response, applicationError)
-      }
-    }
-  }
-
-  /**
-   * Call the atomicity-group-end handler.
-   * @param {Function} handler the handler function
-   * @param {BatchContext} batchContext Batch context
-   * @param {Object} data the custom application data
-   * @param {string} id Atomicity group id
-   * @returns {Promise.<boolean>} a promise resolving to true if the group has to be repeated, otherwise to false
-   */
-  static handleGroupEnd (handler, batchContext, data, id) {
-    const atomicityGroupError = batchContext.getFailedAtomicityGroups().get(id)
-    const failedRequests = batchContext.getFailedRequestsOfAtomicityGroup(id)
-    return new Promise((resolve, reject) => {
-      try {
-        handler(
-          atomicityGroupError,
-          { applicationData: data, failedRequests: failedRequests, id: id },
-          (applicationError, options) => {
-            if (options && options.repeat) {
-              resolve(true)
-            } else if (applicationError) {
-              // mark als responses of atomicity group as error
-              BatchExitHandler.handleApplicationError(batchContext, options, id, applicationError)
-              resolve(false)
-            } else if (atomicityGroupError) {
-              reject(atomicityGroupError)
-            } else {
-              resolve(false)
-            }
-          }
-        )
-      } catch (applicationError) {
-        reject(applicationError)
-      }
-    })
-  }
-}
-
-/**
- * @callback BatchExitHandler~next
- */
-
-/**
- * The BatchStartHandler can be registered for batch processing,
- * it is called before the processing of batched requests starts.
- * - If the application returns or throws an error to the {@see BatchExitHandler~next} callback
- * no batched request is executed and the BatchEndHandler {@see BatchEndHandler} is called with that error.
- *
- * @callback BatchStartHandler
- * @memberOf BatchExitHandler
- * @param {Object} context
- * @param {string} context.applicationData Application data, can be set on the OdataRequest via setApplicationData(...), e.g. within the request event of the $batch request
- * @param {BatchExitHandler~next} done - Callback to be called after transaction start
- */
-BatchExitHandler.BATCH_START = 'batch-start'
-
-/**
- * The BatchEndHandler can be registered for batch processing, it is called after the batched requests are executed.
- * - If the application returns or throws an error to the {@see BatchExitHandler~next} callback this error triggers the
- * error handling of the incoming HTTP request.
- *
- * @callback BatchEndHandler
- * @memberOf BatchExitHandler
- * @param {Error} error Error object which is set in case of runtime errors and errors in previous exit handlers, but
- * not case of failed batched requests (whose error message is caught and written to a batched response)
- * @param {Object} context
- * @param {string} context.applicationData Application data, can be set on the OdataRequest via setApplicationData(...), e.g. within the request event
- * @param {BatchErrorInfo[]} context.failedRequests List of batched requests which returned with an error status code
- * @param {BatchExitHandler~next} done - Callback to be called after transaction start
- */
-BatchExitHandler.BATCH_END = 'batch-end'
-
-/**
- * The AtomicityGroupStartHandler can be registered for batch processing, it is called before the first request of an
- * atomicity group /change set is processed.
- * - If the application returns or throws an error to the {@see BatchExitHandler~next} callback
- * the atomicity group is marked as not executed and further batched requests are executed if continue-on-error is true.
- * This error is also forwarded to the {@see AtomicityGroupEndHandler} handler.
- *
- * @callback AtomicityGroupStartHandler
- * @memberOf BatchExitHandler
- * @param {Object} context
- * @param {string} context.applicationData Application data, can be set on the OdataRequest via setApplicationData(...), e.g. within the request event
- * @param {string} context.id Atomicity group id
- * @param {BatchExitHandler~next} done - Callback to be called after transaction start
- */
-BatchExitHandler.ATOMICITY_GROUP_START = 'atomicity-group-start'
-
-/**
- * The AtomicityGroupEndHandler can be registered for batch processing it is called after all batched requests of an
- * atomicity group / change set are processed
- * - If the application returns or throws an error to the BatchExitHandler~next callback
- * the atomicity group is marked as not executed and further batched requests are executed if continue-on-error is true.
- * - AtomicityGroupEndHandler is called in both cases, error and non error.
- *
- * @callback AtomicityGroupEndHandler
- * @memberOf BatchExitHandler
- * @param {Error} error Error object which is set in case of runtime errors and errors in previous exit handlers, but
- * not case of failed batched requests (whose error message is catched and written to a batched response)
- * @param {Object} context
- * @param {string} context.applicationData Application data, can be set on the OdataRequest via setApplicationData(...), e.g. within the request event
- * @param {Error[]} context.failedRequests List of batch requests which failed and whose error message is written to a batched response. This list
- *     may be used to implement some kind of transaction handling
- * @param {string} context.id Atomicity group id
- * @param {BatchExitHandler~next} done - Callback to be called after transaction start
- */
-BatchExitHandler.ATOMICITY_GROUP_END = 'atomicity-group-end'
-
-module.exports = BatchExitHandler

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/batch/BatchProcessor.js

@@ -1,281 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const HttpStatusCode = commons.http.HttpStatusCode
-const HttpStatusCodes = HttpStatusCode.StatusCodes
-const HttpStatusCodesText = HttpStatusCode.Texts
-const OdataResponseInBatch = require('../core/OdataResponseInBatch')
-const PlainHttpResponse = require('../core/PlainHttpResponse')
-const BatchExitHandler = require('./BatchExitHandler')
-const BatchedRequestExecutor = require('./BatchedRequestExecutor')
-const BatchContext = require('./BatchContext')
-const cds = require('../../../../../../cds')
-
-/**
- * The BatchProcessor executes the batched requests and handles possible errors.
- * The error handling respects the $batch error specifications.
- */
-class BatchProcessor {
-  /**
-   * Creates an instance of BatchProcessor.
-   * @param {BatchContext} batchContext the batch context
-   */
-  constructor (batchContext) {
-    /**
-     * Batch context
-     * @type {BatchContext}
-     * @private
-     */
-    this._batchContext = batchContext
-
-    this._logger = batchContext.getRequest().getLogger()
-  }
-
-  /**
-   * Process the requests contained in the batch request.
-   * @returns {Promise} the overall result
-   */
-  process () {
-    if(cds.env.odata.batch_limit < this._batchContext.getRequestList().length) return Promise.reject({statusCode: 429, code: 'BATCH_TOO_MANY_REQ'})
-    const request = this._batchContext.getRequest()
-    const componentManager = request.getService().getComponentManager()
-
-    let result
-    const batchStartHandler = componentManager.getComponent(BatchExitHandler.BATCH_START)
-    if (batchStartHandler) {
-      result = BatchExitHandler.handleBatchStart(batchStartHandler, this._batchContext, request.getApplicationData())
-    } else {
-      result = Promise.resolve()
-    }
-
-    this._requests = new Map(this._batchContext.getRequestList().map(req => [req.getOdataRequestId(), req]))
-    this._openRequestIds = new Set(this._requests.keys())
-    this._finishedRequestIds = new Set()
-    this._openGroups = new Map()
-    this._finishedGroups = new Set()
-    result = result
-      .then(() => this._executeOpenRequests())
-      // Discard previous useless return values.
-      .then(() => {
-        if (this._batchContext.isContinueOnError() && this._batchContext.getFailedAtomicityGroups().size > 0) {
-          // Continue execution -> Preference continue-on-error was applied.
-          this._batchContext
-            .getResponse()
-            .getPreferencesApplied()
-            .setOdataContinueOnErrorApplied(true)
-        }
-
-        return Promise.resolve(this._batchContext.getFrameworkError())
-      })
-      .catch(frameworkError => {
-        return Promise.resolve(frameworkError)
-      })
-
-    const batchEndHandler = componentManager.getComponent(BatchExitHandler.BATCH_END)
-    if (batchEndHandler) {
-      result = result.then(frameworkError => {
-        const failedRequests = this._batchContext.getFailedRequestsOfAtomicityGroup(null)
-        return BatchExitHandler.handleBatchEnd(
-          batchEndHandler,
-          this._batchContext,
-          frameworkError,
-          request.getApplicationData(),
-          failedRequests
-        )
-      })
-    } else {
-      // Resurrect error.
-      result = result.then(error => (error ? Promise.reject(error) : Promise.resolve()))
-    }
-
-    return result
-  }
-
-  /**
-   * Executes the open requests contained in the batch request, calling itself as long as requests are still open.
-   * @returns {Promise} the overall result
-   * @private
-   */
-  _executeOpenRequests () {
-    const batchRequest = this._batchContext.getRequest()
-    const groupStartHandler = batchRequest
-      .getService()
-      .getComponentManager()
-      .getComponent(BatchExitHandler.ATOMICITY_GROUP_START)
-    let promises = []
-    for (const id of this._openRequestIds) {
-      const request = this._requests.get(id)
-      if (this._isRequestStartable(request)) {
-        const groupId = request.getAtomicityGroupId()
-
-        if (groupId === null || this._openGroups.get(groupId)) {
-          this._openRequestIds.delete(id)
-          promises.push(
-            new BatchedRequestExecutor(this._batchContext, request)
-              .execute()
-              .catch(frameworkError => {
-                // This framework Error here is NOT caused by an request execution, because those errors
-                // would be serialised into the response of the sub request.
-                this._batchContext.setFrameworkError(frameworkError)
-                this._handleFrameworkError(frameworkError, groupId)
-              })
-              .then(() => {
-                this._finishedRequestIds.add(id)
-                return this._executeOpenRequests()
-              })
-          )
-        } else if (!this._openGroups.has(groupId) && !this._finishedGroups.has(groupId)) {
-          if (groupStartHandler) {
-            this._openGroups.set(groupId, false)
-            promises.push(
-              BatchExitHandler.handleGroupStart(groupStartHandler, batchRequest.getApplicationData(), groupId)
-                .then(() => this._openGroups.set(groupId, true))
-                .catch(frameworkError => {
-                  this._handleFrameworkError(frameworkError, groupId)
-                })
-                .then(() => this._executeOpenRequests())
-            )
-          } else {
-            this._openGroups.set(groupId, true)
-            promises.push(this._executeOpenRequests())
-          }
-        }
-      } else {
-        this._checkFailedDependency(id, request)
-      }
-    }
-
-    const groupEndHandler = batchRequest
-      .getService()
-      .getComponentManager()
-      .getComponent(BatchExitHandler.ATOMICITY_GROUP_END)
-    for (const [groupId, isStarted] of this._openGroups) {
-      const groupRequestIds = Array.from(this._requests.keys()).filter(
-        id => this._requests.get(id).getAtomicityGroupId() === groupId
-      )
-      // Either the group is completely finished, or it has at least one failed request and no request is running.
-      if (
-        (isStarted && groupRequestIds.every(id => this._finishedRequestIds.has(id))) ||
-        (this._batchContext.getFailedAtomicityGroups().has(groupId) &&
-          !groupRequestIds.some(id => !this._openRequestIds.has(id) && !this._finishedRequestIds.has(id)))
-      ) {
-        this._openGroups.delete(groupId)
-        if (groupEndHandler) {
-          promises.push(
-            BatchExitHandler.handleGroupEnd(
-              groupEndHandler,
-              this._batchContext,
-              batchRequest.getApplicationData(),
-              groupId
-            )
-              .then(repeat => {
-                if (repeat) {
-                  for (const [id, request] of this._requests) {
-                    if (request.getAtomicityGroupId() === groupId) {
-                      this._finishedRequestIds.delete(id)
-                      this._openRequestIds.add(id)
-                    }
-                  }
-                  this._batchContext.removeAtomicityGroup(groupId)
-                } else {
-                  this._finishedGroups.add(groupId)
-                }
-
-                const failedRequests = this._batchContext.getFailedRequestsOfAtomicityGroup(groupId)
-                if (failedRequests.length > 0 && !this._batchContext.isContinueOnError()) {
-                  // stop processing
-                  for (const id of this._openRequestIds) this._finishedRequestIds.add(id)
-                  this._openRequestIds.clear()
-                }
-              })
-              .catch(frameworkError => {
-                this._handleFrameworkError(frameworkError, groupId)
-              })
-              .then(() => this._executeOpenRequests())
-          )
-        } else {
-          this._finishedGroups.add(groupId)
-        }
-      }
-    }
-
-    return Promise.all(promises)
-  }
-
-  /**
-   * Determines whether a request can be started by looking at its dependencies and the general state.
-   * @param {OdataRequestInBatch} request the request
-   * @returns {boolean} whether the request can be started
-   * @private
-   */
-  _isRequestStartable (request) {
-    const continueOnError = this._batchContext.isContinueOnError()
-    return (
-      request.getDependsOn().every(
-        id =>
-          // if dependent is request and finished (with or without error)
-          (this._finishedRequestIds.has(id) && (continueOnError || !this._batchContext.isRequestFailed(id))) ||
-          // if dependent is atomicity group and finished (with or without error)
-          (this._finishedGroups.has(id) && (continueOnError || !this._batchContext.getFailedAtomicityGroups().get(id)))
-      ) &&
-      // TODO check this and clause for MULTIPART<>JSON
-      (continueOnError ||
-        this._batchContext.getSemantics() === BatchContext.SEMANTICS.MULTIPART ||
-        this._batchContext.getFailedAtomicityGroups().size === 0)
-    )
-  }
-
-  /**
-   * Sets a request to FAILED_DEPENDENCY if one of its dependencies failed already
-   * and to finished if it can no longer run
-   * if we have neither to continue on error nor multipart semantics.
-   * @param {string} id the request ID
-   * @param {OdataRequestInBatch} request the request
-   * @private
-   */
-  _checkFailedDependency (id, request) {
-    if (
-      this._batchContext.getSemantics() !== BatchContext.SEMANTICS.MULTIPART &&
-      !this._batchContext.isContinueOnError()
-    ) {
-      if (request.getDependsOn().some(dependentId => this._batchContext.isRequestFailed(dependentId))) {
-        this._openRequestIds.delete(id)
-        this._finishedRequestIds.add(id)
-        let plainHttpResponse = new PlainHttpResponse()
-        plainHttpResponse.statusCode = HttpStatusCodes.FAILED_DEPENDENCY
-        plainHttpResponse.statusMessage = HttpStatusCodesText[HttpStatusCodes.FAILED_DEPENDENCY]
-        const odataResponseInBatch = new OdataResponseInBatch(plainHttpResponse, id)
-        this._batchContext.addResponseInBatch(odataResponseInBatch)
-        this._batchContext.markRequestAsFailed(id, request, odataResponseInBatch)
-      } else if (
-        this._batchContext.getFailedAtomicityGroups().size &&
-        request
-          .getDependsOn()
-          .every(dependentId => this._finishedRequestIds.has(dependentId) || this._finishedGroups.has(dependentId))
-      ) {
-        this._openRequestIds.delete(id)
-        this._finishedRequestIds.add(id)
-        let plainHttpResponse = new PlainHttpResponse()
-        plainHttpResponse.statusCode = HttpStatusCodes.UNPROCESSABLE_ENTITY
-        plainHttpResponse.statusMessage = HttpStatusCodesText[HttpStatusCodes.UNPROCESSABLE_ENTITY]
-        const odataResponseInBatch = new OdataResponseInBatch(plainHttpResponse, id)
-        this._batchContext.markRequestAsFailed(id, request, odataResponseInBatch)
-      }
-    }
-  }
-
-  /**
-   * Handles a framework error.
-   * @param {Error} frameworkError the framework error
-   * @param {?string} groupId the atomicity-group ID
-   * @private
-   */
-  _handleFrameworkError (frameworkError, groupId) {
-    this._batchContext.markAtomicityGroupAsFailed(groupId, frameworkError)
-    this._finishedGroups.add(groupId)
-    for (const id of this._openRequestIds) this._finishedRequestIds.add(id)
-    this._openRequestIds.clear()
-  }
-}
-
-module.exports = BatchProcessor

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/batch/BatchValidator.js

@@ -1,133 +0,0 @@
-'use strict'
-
-const DeserializationError = require('../errors/DeserializationError')
-
-/** List of headers not allowed in batched requests */
-const forbiddenHeaders = ['authorization', 'proxy-authorization', 'expect', 'from', 'max-forwards', 'range', 'TE']
-
-/** Class containing method to validate batched requests */
-class BatchValidator {
-  /**
-   * Validates batched requests for correct request IDs, headers, dependencies, ...
-   * @param {OdataRequestInBatch[]} requests batched requests
-   */
-  static validate (requests) {
-    /**
-     * @type {Map.<string, OdataRequestInBatch>}
-     * @private
-     */
-    let usedIds = new Map()
-
-    /**
-     * @type {Set<number>}
-     * @private
-     */
-    let usedAtomicGroups = new Map()
-
-    /**
-     * @type {string}
-     * @private
-     */
-    let lastUsedAtomicityGroupId = null
-
-    let index = 0
-
-    for (const request of requests) {
-      const requestID = request.getOdataRequestId()
-      const atomicityGroupId = request.getAtomicityGroupId()
-      const dependsOn = request.getDependsOn()
-
-      // CHECK - Forbidden headers
-      for (const header of forbiddenHeaders) {
-        if (request.getHeader(header)) {
-          throw new DeserializationError(
-            'Request in batch at position ' + index + " contains invalid header '" + header + "'"
-          )
-        }
-      }
-
-      // CHECK - Request ID must be filled
-      if (!requestID) {
-        throw new DeserializationError('Request in batch at position ' + index + ' must have a request ID')
-      }
-
-      // CHECK - Request IDs must be unique
-      BatchValidator.assertUnique(usedIds, requestID, 'Request ID', index)
-      usedIds.set(requestID, request)
-
-      // CHECK - Request IDs must not collide with atomicity group IDs
-      BatchValidator.assertUnique(usedAtomicGroups, requestID, 'Request ID', index)
-
-      // CHECK - Atomicity groups must be continuous and unique
-      if (atomicityGroupId !== lastUsedAtomicityGroupId) {
-        if (atomicityGroupId) {
-          BatchValidator.assertUnique(usedAtomicGroups, atomicityGroupId, 'Atomicity group', index)
-          usedAtomicGroups.set(atomicityGroupId)
-        }
-        // CHECK - Atomicity group IDs must not collide with request IDs
-        BatchValidator.assertUnique(usedIds, atomicityGroupId, 'Atomicity group', index)
-      }
-
-      for (const id of dependsOn) {
-        // CHECK - no self referencing
-        if (id === requestID) {
-          throw new DeserializationError('Request in batch at position ' + index + " depends on own ID '" + id + "'")
-        }
-
-        // CHECK - IDs in dependsOn list must already have been collected as atomicity group or as request
-        if (!usedIds.has(id) && !usedAtomicGroups.has(id)) {
-          throw new DeserializationError(
-            'Request in batch at position ' +
-              index +
-              ' depends on unknown ' +
-              "request/atomicity group with ID '" +
-              id +
-              "'"
-          )
-        }
-
-        if (usedIds.has(id)) {
-          // CHECK - if request ID in dependOn references a request
-          // then the request's atomicity group must also referenced
-          const requiredAtomicityGroup = usedIds.get(id).getAtomicityGroupId()
-          if (
-            requiredAtomicityGroup &&
-            requiredAtomicityGroup !== atomicityGroupId &&
-            !dependsOn.includes(requiredAtomicityGroup)
-          ) {
-            throw new DeserializationError(
-              'Request in batch at position ' +
-                index +
-                " depends on request with ID '" +
-                id +
-                "'" +
-                ' whose atomicity group ' +
-                requiredAtomicityGroup +
-                ' must also be referenced'
-            )
-          }
-        }
-      }
-
-      lastUsedAtomicityGroupId = atomicityGroupId
-      index++
-    }
-  }
-
-  /**
-   * Assess that a key is not inside a map.
-   * @param {Map.<string, Object>} map Map to be searched
-   * @param {string} key Key which is search
-   * @param {string} itemName item name
-   * @param {number} index position
-   */
-  static assertUnique (map, key, itemName, index) {
-    if (map.has(key)) {
-      throw new DeserializationError(
-        itemName + " '" + key + "' of request in batch at position " + index + ' already in use'
-      )
-    }
-  }
-}
-
-module.exports = BatchValidator