@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/invocation/SerializingCommand.js

@@ -1,159 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const HttpMethods = commons.http.HttpMethod.Methods
-const RepresentationKinds = commons.format.RepresentationKind.Kinds
-const MetaProperties = commons.format.JsonFormat.MetaProperties
-const Command = require('./Command')
-const ContextUrlFactory = require('../serializer/ContextURLFactory')
-const NextLinkSerializer = require('../serializer/NextLinkSerializer')
-const ExpandHelper = require('../utils/ExpandHelper')
-const InternalServerError = require('../errors/InternalServerError')
-
-/**
- * The `next` callback to be called upon finish execution.
- * @callback Next
- * @param {?Error} error An error if there is one or null if not
- */
-
-/**
- * Executes the serialization of the provided data.
- * @extends Command
- */
-class SerializingCommand extends Command {
-  /**
-   * Executes the registered serializing function bound with the contract created from the content negotiation.
-   * @param {Next} next The next callback to be called on finish
-   * @returns {undefined}
-   */
-  execute (next) {
-    const context = this.getContext()
-    const logger = context.getLogger()
-
-    const request = context.getRequest()
-    const response = context.getResponse()
-
-    if (response.isHeadersSent()) {
-      logger.debug('Headers already sent')
-      return next()
-    }
-
-    if (request.getMethod() === HttpMethods.HEAD) {
-      // A body in the response is not needed in a HEAD request.
-      response.setBody('')
-      return next()
-    }
-
-    const responseContract = response.getContract()
-    const representationKind = responseContract.getRepresentationKind()
-    let responseBody = response.getBody()
-
-    if (representationKind === RepresentationKinds.METADATA && responseBody && responseBody.value) {
-      // In case of locale-specific $metadata requests the application sets the metadata document
-      // in the metadata handler. Thus serializing will be skipped in this case.
-      response.setBody(responseBody.value)
-      return next()
-    }
-
-    let options = response.getOdataOptions()
-
-    if (
-      representationKind &&
-      representationKind !== RepresentationKinds.NO_CONTENT &&
-      representationKind !== RepresentationKinds.PRIMITIVE_VALUE &&
-      representationKind !== RepresentationKinds.BINARY &&
-      representationKind !== RepresentationKinds.COUNT &&
-      representationKind !== RepresentationKinds.BATCH
-    ) {
-      if (!options) {
-        options = {}
-        response.setOdataOptions(options)
-      }
-
-      if (responseBody && typeof responseBody === 'object') {
-        if (
-          representationKind === RepresentationKinds.ENTITY ||
-          representationKind === RepresentationKinds.COMPLEX ||
-          representationKind === RepresentationKinds.REFERENCE
-        ) {
-          if (responseBody.value && !responseBody.value[MetaProperties.CONTEXT]) {
-            responseBody.value[MetaProperties.CONTEXT] = this._createContextUrl(request, representationKind, options)
-          }
-        } else if (!responseBody[MetaProperties.CONTEXT]) {
-          responseBody[MetaProperties.CONTEXT] = this._createContextUrl(request, representationKind, options)
-        }
-
-        if (responseBody[MetaProperties.NEXT_LINK]) {
-          // Skiptoken is currently only allowed for collections of entities and of references.
-          if (
-            representationKind !== RepresentationKinds.ENTITY_COLLECTION &&
-            representationKind !== RepresentationKinds.REFERENCE_COLLECTION
-          ) {
-            return next(new InternalServerError('Skiptoken is only allowed for entity- and reference-collections'))
-          }
-
-          // Check whether a maxPageSize is configured for the returned collection.
-          const segment = request
-            .getUriInfo()
-            .getLastSegment(representationKind === RepresentationKinds.REFERENCE_COLLECTION ? -1 : 0)
-          if (
-            (representationKind === RepresentationKinds.ENTITY_COLLECTION ||
-              representationKind === RepresentationKinds.REFERENCE_COLLECTION) &&
-            ((segment.getEntitySet() && !segment.getEntitySet().getMaxPageSize()) ||
-              (segment.getTarget() && !segment.getTarget().getMaxPageSize()))
-          ) {
-            return next(
-              new InternalServerError(
-                'Skiptoken is only allowed for entity- ' +
-                  'and reference-collections where a maximum page size is configured'
-              )
-            )
-          }
-
-          const odataPath = request.getOdataPath()
-          const queryOptionsString = request.getUrlObject().search
-          responseBody[MetaProperties.NEXT_LINK] = new NextLinkSerializer().serializeNextLink(
-            odataPath,
-            queryOptionsString,
-            responseBody[MetaProperties.NEXT_LINK]
-          )
-        }
-      }
-    }
-
-    let serialize = responseContract.getSerializerFunction()
-    serialize(context, responseBody, options, (error, serializedBody) => {
-      response.setBody(serializedBody)
-      next(error)
-    })
-
-    return undefined
-  }
-
-  /**
-   * Creates the context URL for a given request.
-   * @param {OdataRequest} request the OData request
-   * @param {RepresentationKind.Kinds} representationKind representation kind of the target
-   * @param {Object} options optional keys for the building of the context URL
-   * @returns {string} the context URL
-   * @private
-   */
-  _createContextUrl(request, representationKind, options) {
-    const incomingRequest = request.getIncomingRequest()
-    return new ContextUrlFactory().createContextURL(
-      request.getUriInfo(),
-      ExpandHelper.getFinalExpand(request),
-      representationKind,
-      options.keys,
-      this.getContext()
-        .getService()
-        .getEdm(),
-      (incomingRequest && incomingRequest.getBatchContext && incomingRequest.getBatchContext().getRequest().getIncomingRequest())
-      || incomingRequest,
-      this.getContext()
-        .getLogger()
-    )
-  }
-}
-
-module.exports = SerializingCommand

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/invocation/SetResponseHeadersCommand.js

@@ -1,90 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const ResourceKind = commons.uri.UriResource.ResourceKind
-const RepresentationKinds = commons.format.RepresentationKind.Kinds
-const HttpMethods = commons.http.HttpMethod.Methods
-const HttpStatusCode = commons.http.HttpStatusCode.StatusCodes
-const PreferenceNames = commons.http.Preferences.ReturnValues
-const Command = require('./Command')
-const ResponseHeaderSetter = require('../core/ResponseHeaderSetter')
-
-/**
- * Executes the setting of response headers.
- * @extends Command
- */
-class SetResponseHeadersCommand extends Command {
-  /**
-   * Creates an instance of SetResponseHeadersCommand.
-   * @param {OdataRequest} request the current OData request
-   * @param {OdataResponse} response the current OData response
-   * @param {FormatManager} formatManager the format manager
-   * @param {LoggerFacade} logger the logger
-   */
-  constructor (request, response, formatManager, logger) {
-    super()
-    this._request = request
-    this._response = response
-    this._formatManager = formatManager
-    this._logger = logger
-  }
-
-  /**
-   * Executes the setting of response headers and OData annotations needed for serializing.
-   * @param {Next} next The next callback to be called on finish
-   */
-  execute (next) {
-    if (this._response.isHeadersSent()) {
-      this._logger.debug('Headers already sent')
-    } else {
-      const responseHeaderSetter = new ResponseHeaderSetter(this._request, this._response, null, this._logger)
-      const responseContract = this._response.getContract()
-
-      responseHeaderSetter.setPreferenceAppliedHeader()
-      if (this._response.getPreferencesApplied().getReturnApplied() === PreferenceNames.MINIMAL) {
-        responseContract.setRepresentationKind(RepresentationKinds.NO_CONTENT)
-        // Overwrite registered serializer with the NO_CONTENT serializer function.
-        responseContract.setSerializerFunction(
-          this._formatManager.getFormatDescriptions(RepresentationKinds.NO_CONTENT, null)[0].getSerializerFunction()
-        )
-      }
-
-      const representationKind = responseContract.getRepresentationKind()
-      const method = this._request.getMethod()
-      const lastSegment = this._request.getUriInfo().getLastSegment()
-
-      // Set the Location response header if the request has been an entity-create request
-      // or if the handler implementation has set the status code to CREATED.
-      if (
-        (method === HttpMethods.POST &&
-          (lastSegment.getKind() === ResourceKind.ENTITY_COLLECTION ||
-            lastSegment.getKind() === ResourceKind.NAVIGATION_TO_MANY)) ||
-        (this._response.getStatusCode() === HttpStatusCode.CREATED &&
-          lastSegment.getKind() !== ResourceKind.ACTION_IMPORT &&
-          lastSegment.getKind() !== ResourceKind.BOUND_ACTION)
-      ) {
-        responseHeaderSetter.setLocationHeader()
-        // Set the OData-EntityId header if a create operation returns 204 No Content.
-        if (representationKind === RepresentationKinds.NO_CONTENT) {
-          responseHeaderSetter.setOdataEntityIdHeader()
-        }
-      }
-
-      if (
-        (lastSegment.getAction()
-          ? lastSegment.getTarget() && lastSegment.getTarget().isConcurrent()
-          : this._request.getConcurrentResource()) &&
-        representationKind !== RepresentationKinds.ENTITY_COLLECTION &&
-        representationKind !== RepresentationKinds.COUNT &&
-        representationKind !== RepresentationKinds.REFERENCE &&
-        representationKind !== RepresentationKinds.REFERENCE_COLLECTION
-      ) {
-        responseHeaderSetter.setEtagHeader()
-      }
-    }
-
-    next()
-  }
-}
-
-module.exports = SetResponseHeadersCommand

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/invocation/SetStatuscodeCommand.js

@@ -1,51 +0,0 @@
-'use strict'
-
-const Command = require('./Command')
-const InternalServerError = require('../errors/InternalServerError')
-
-/**
- * The `next` callback to be called upon finish execution.
- * @callback Next
- * @param {?Error} error An error if there is one or null if not
- */
-
-/**
- * Executes the setting of the statuscode in the odata response
- */
-class SetStatuscodeCommand extends Command {
-  /**
-   * Creates an instance of SetStatuscodeCommand.
-   * @param {OdataRequest} request the current OData request
-   * @param {OdataResponse} response the current OData response
-   * @param {Function} resolveFunction The function to resolve the statuscode with parameters context and error
-   * @param {LoggerFacade} logger the logger
-   */
-  constructor (request, response, resolveFunction, logger) {
-    super()
-    this._request = request
-    this._response = response
-    this._resolveStatusCodeFunction = resolveFunction
-    this._logger = logger
-  }
-
-  /**
-   * @param {next} next The next callback to be called on finish
-   * @param {?Error} error An error if there is one or null if not
-   */
-  execute (next, error) {
-    const statusCode = this._resolveStatusCodeFunction(this._request, this._response, error)
-
-    if (statusCode) {
-      const options = error || this._request.getContract().isDebug() ? { overwrite: true } : undefined
-
-      this._logger.debug('Set response status code:', statusCode, ', options:', options)
-      this._response.setStatusCode(statusCode, options)
-
-      next()
-    } else {
-      next(new InternalServerError('Invalid state: status code is not defined'))
-    }
-  }
-}
-
-module.exports = SetStatuscodeCommand

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/invocation/UriParserCommand.js

@@ -1,47 +0,0 @@
-'use strict'
-
-const Command = require('./Command')
-
-/**
- * The `next` callback to be called upon finish execution.
- * @callback Next
- * @param {?Error} error An error if there is one or null if not
- */
-
-/**
- * Executes the URI parser.
- * @extends Command
- */
-class UriParserCommand extends Command {
-  /**
-   * Creates an instance of the UriParserCommand.
-   * @param {UriParser} uriParser the URI parser
-   * @param {OdataRequest} request the current OData request
-   * @param {LoggerFacade} logger the logger
-   */
-  constructor (uriParser, request, logger) {
-    super()
-    this._uriParser = uriParser
-    this._request = request
-    this._logger = logger
-  }
-
-  /**
-   * Execute the URI parsing and set the resulting UriInfo object to OData request.
-   * @param {Next} next the callback to be called on finish
-   */
-  execute (next) {
-    const uriInfo = this._uriParser.parseRelativeUri(this._request.getOdataPath(), this._request.getQueryOptions())
-    this._logger.debug(
-      'Parsed path segments:',
-      uriInfo
-        .getPathSegments()
-        .map(segment => 'Kind: ' + segment.getKind() + ', Name: ' + segment.getPathSegmentIdentifier())
-    )
-    this._request.setUriInfo(uriInfo)
-
-    next()
-  }
-}
-
-module.exports = UriParserCommand

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/logging/DebugLogger.js

@@ -1,97 +0,0 @@
-'use strict'
-
-const util = require('util')
-const LoggerFacade = require('../../odata-commons').logging.LoggerFacade
-
-/**
- * The debug logger stores all log strings for retrieval from the debug-output serializer.
- * The originally registered logger is called additionally so nothing is lost.
- * This class has to extend LoggerFacade for context.setLogger(...) to do the right things.
- * @extends LoggerFacade
- */
-class DebugLogger extends LoggerFacade {
-  /**
-   * Creates an instance of DebugLogger.
-   * @param {LoggerFacade} loggerFacade the original logger facade
-   */
-  constructor (loggerFacade) {
-    super(loggerFacade, loggerFacade.getId())
-    this._logStrings = []
-  }
-
-  /**
-   * Logging for log level debug
-   * @param {Array} params The provided parameters
-   * @override
-   */
-  debug (...params) {
-    this._logger.debug(...params)
-    this._logStrings.push(this._format(LoggerFacade.LogLevel.DEBUG, ...params))
-  }
-
-  /**
-   * Logging for log level info
-   * @param {Array} params The provided parameters
-   * @override
-   */
-  info (...params) {
-    this._logger.info(...params)
-    this._logStrings.push(this._format(LoggerFacade.LogLevel.INFO, ...params))
-  }
-
-  /**
-   * Logging for log level warning
-   * @param {Array} params The provided parameters
-   * @override
-   */
-  warning (...params) {
-    this._logger.warning(...params)
-    this._logStrings.push(this._format(LoggerFacade.LogLevel.WARNING, ...params))
-  }
-
-  /**
-   * Logging for log level error
-   * @param {Array} params The provided parameters
-   * @override
-   */
-  error (...params) {
-    this._logger.error(...params)
-    this._logStrings.push(this._format(LoggerFacade.LogLevel.ERROR, ...params))
-  }
-
-  /**
-   * Logging for log level fatal
-   * @param {Array} params The provided parameters
-   * @override
-   */
-  fatal (...params) {
-    this._logger.fatal(...params)
-    this._logStrings.push(this._format(LoggerFacade.LogLevel.FATAL, ...params))
-  }
-
-  /**
-   * Format the log.
-   * @param {LoggerFacade.LogLevel} level the logging level
-   * @param {Array} params The provided parameters
-   * @returns {string} the formatted log
-   * @private
-   */
-  _format (level, ...params) {
-    const inspectOptions = { breakLength: Infinity, compact: true, depth: 4, maxArrayLength: Infinity }
-    return (
-      level +
-      ': ' +
-      params.map(elem => (typeof elem === 'string' ? elem : util.inspect(elem, inspectOptions))).join(' ')
-    )
-  }
-
-  /**
-   * Get the collected log.
-   * @returns {string[]} the collected log
-   */
-  getLog () {
-    return this._logStrings
-  }
-}
-
-module.exports = DebugLogger

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/serializer/ApplicationHttpWriter.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const CRLF = '\r\n'
-
-/**
- * Writes content in application/multipart format into an stream.
- * Used to write a OData batch response. Usage:
- *
- * E.g.:
- * '--boundary',                                            <-- not written by this class
- * 'Content-ID: 2',                                         <-- written by ApplicationHttpWriter->writeHeader
- * 'Content-Type: application/http',
- * '',
- * "PATCH /service/Customers('ALFKI') HTTP/1.1'",           <-- written by ApplicationHttpWriter->write(response)
- * 'Host: host',
- * 'Content-Type: application/json',
- * '',
- * '{}',
- * '--boundary--',                                          <-- not written by this class
- */
-class ApplicationHttpWriter {
-  /**
-   * Constructor
-   * @param {Stream} writableStream Destination stream
-   */
-  constructor (writableStream) {
-    this._writableStream = writableStream
-
-    this._appHeaderWritten = false
-  }
-
-  /**
-   * Writes the content type into the destination stream if not already done.
-   */
-  writeContentType () {
-    if (!this._appHeaderWritten) {
-      this._appHeaderWritten = true
-      this._writableStream.write('content-type: application/http' + CRLF, 'utf8')
-      this._writableStream.write('content-transfer-encoding: binary' + CRLF, 'utf8')
-    }
-  }
-
-  /**
-   * Writes a http header (name, value) into the destination stream
-   *
-   * @param {string} name Header name
-   * @param {string} value Header value
-   */
-  writeHeader (name, value) {
-    this.writeContentType()
-    this._writableStream.write(name + ': ' + value + CRLF, 'utf8')
-  }
-
-  /**
-   * Write a response object into the destination stream
-   * @param {PlainHttpResponse} response the response object
-   */
-  write (response) {
-    this.writeContentType()
-    this._writableStream.write(CRLF)
-    response.writeTo(this._writableStream)
-  }
-}
-
-module.exports = ApplicationHttpWriter

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/serializer/BatchJsonSerializer.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const HttpHeaders = commons.http.HttpHeader.HeaderNames
-const ContentTypes = commons.format.ContentTypeInfo.ContentTypes
-
-/**
- * Serializes the list of batched responses.
- */
-class BatchJsonSerializer {
-  /**
-   * Serializes batched responses to OData JSON string.
-   * @param {Map.<string, OdataResponseInBatch>} responses responses to be written, with response ID as key
-   * @returns {string} the serialized responses
-   */
-  serialize (responses) {
-    return JSON.stringify({
-      responses: Array.from(responses.values()).map(response => {
-        let result = { status: response.getStatusCode() }
-
-        const id = response.getOdataResponseId()
-        if (id) result.id = id
-
-        const atomicityGroup = response.getAtomicityGroupId()
-        if (atomicityGroup) result.atomicityGroup = atomicityGroup
-
-        const httpResponse = response.getIncomingResponse()
-        result.headers = httpResponse.getHeaders()
-
-        const contentType = httpResponse.getHeader(HttpHeaders.CONTENT_TYPE)
-        const isJson = contentType && contentType.startsWith(ContentTypes.JSON)
-        const isText = contentType && contentType.startsWith('text/')
-        const body = httpResponse.getBody()
-        if (body.length) {
-          if (isJson) result.body = JSON.parse(body.toString())
-          else if (isText) result.body = body.toString()
-          else result.body = body.toString('base64')
-        }
-
-        return result
-      })
-    })
-  }
-}
-
-module.exports = BatchJsonSerializer

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/serializer/BatchMultipartSerializer.js

@@ -1,113 +0,0 @@
-'use strict'
-
-const MultipartWriter = require('./MultipartWriter')
-const ApplicationHttpWriter = require('./ApplicationHttpWriter')
-
-/**
- * Serializes the list of batched responses into the outgoing response which is sent to the client.
- */
-class BatchMultipartSerializer {
-  /**
-   * @param {BatchContext} batchContext the batch context
-   */
-  constructor (batchContext) {
-    this._batchContext = batchContext
-    this._outgoingResponse = this._batchContext.getResponse()
-  }
-
-  /**
-   * Creates a 2 layered list to ease writing the batched responses into the outgoing response.
-   * The first layer contains batched responses or and array of batched responses.
-   * In the second case the array contains the responses of an atomicity group.
-   *
-   * @returns {Array.<OdataResponseInBatch|OdataResponseInBatch[]>} the responses
-   * @private
-   */
-  _createSendList () {
-    const responsesInBatch = this._batchContext.getResponses()
-    let lastUsedAtomicityGroup = null
-    let list = []
-    let grp = null
-
-    // Loop over requests to ensure that responses are serialized in request order.
-    for (const request of this._batchContext.getRequestList()) {
-      const id = request.getOdataRequestId()
-      const response = responsesInBatch.get(id)
-      let atomicityGroup = response.getAtomicityGroupId()
-
-      if (atomicityGroup) {
-        if (atomicityGroup !== lastUsedAtomicityGroup) {
-          lastUsedAtomicityGroup = atomicityGroup
-          grp = []
-          list.push(grp)
-        }
-        grp.push(response)
-      } else {
-        list.push(response)
-      }
-      // If continue-on-error is not set, exit after the first failed request.
-      if (!this._batchContext.isContinueOnError() && this._batchContext.isRequestFailed(id)) break
-    }
-
-    return list
-  }
-
-  /**
-   * Writes one batched response as new part into the multipart document.
-   * @param {MultipartWriter} multipartWriter Writer of the multipart document
-   * @param {OdataResponseInBatch} response Response to be written
-   * @param {boolean} writeContentId ContentId should be written only in changesets
-   * @private
-   */
-  _writeResponse (multipartWriter, response, writeContentId) {
-    multipartWriter.startPart()
-    const applicationHttpWriter = new ApplicationHttpWriter(this._outgoingResponse)
-    const contentID = response.getOdataResponseId()
-    if (writeContentId && contentID) {
-      applicationHttpWriter.writeHeader('content-id', contentID)
-    }
-    applicationHttpWriter.write(response.getIncomingResponse())
-    multipartWriter.endPart()
-  }
-
-  /**
-   * Writes all batched responses with help of an multipart writer into the outgoing response
-   */
-  execute () {
-    const sendList = this._createSendList()
-
-    // write multipart containing the the whole payload
-    let multipartWriter = new MultipartWriter(this._outgoingResponse, false, this._batchContext.getBoundary())
-
-    for (const entry of sendList) {
-      if (!Array.isArray(entry)) {
-        // write normal response in batch
-        this._writeResponse(multipartWriter, entry)
-      } else {
-        // write atomicity group/change set into a nested multipart
-
-        // get atomicity group ID
-        const atomicityGroup = entry[0].getAtomicityGroupId()
-
-        if (this._batchContext.isAtomicityGroupExecuted(atomicityGroup)) {
-          // ok case
-          multipartWriter.startPart()
-          const atomicityGroupWriter = new MultipartWriter(this._outgoingResponse, true, atomicityGroup)
-          for (const atomicityGroupEntry of entry) {
-            this._writeResponse(atomicityGroupWriter, atomicityGroupEntry, true)
-          }
-          atomicityGroupWriter.writeEndBoundary()
-          multipartWriter.endPart()
-        } else {
-          // atomicity group failed, the the error response replaces the change set
-          const response = this._batchContext.getFailedRequestsOfAtomicityGroup(atomicityGroup)[0].getResponse()
-          this._writeResponse(multipartWriter, response, true)
-        }
-      }
-    }
-
-    multipartWriter.writeEndBoundary(true)
-  }
-}
-
-module.exports = BatchMultipartSerializer