@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/ContentDeserializer.js

@@ -1,222 +0,0 @@
-'use strict'
-
-const Transform = require('stream').Transform // transform catches eos and _flush gets called
-const ApplicationHttpReader = require('./ApplicationHttpReader')
-const Cache = require('./Cache')
-const DataReader = require('./DataReader')
-const MultipartParser = require('./MultipartReader')
-const DeserializationError = require('../errors/DeserializationError')
-
-const DATA_EVENTS = DataReader.EVENTS
-const REQUEST_EVENTS = ApplicationHttpReader.EVENTS
-const PART_EVENTS = require('./PartReader').EVENTS
-const MULTIPART_EVENTS = MultipartParser.EVENTS
-
-/**
- * States
- */
-const STATES = {
-  START: 0,
-  PROCESS: 1,
-  FINISHED: 2
-}
-
-/**
- * Events
- */
-const EVENTS = {
-  UNCONSUMED: 'reader.unconsumed',
-  START: 'reader.start',
-  END: 'reader.end',
-
-  REQUEST_START: REQUEST_EVENTS.START,
-  REQUEST_REQUESTLINE: REQUEST_EVENTS.REQUEST_LINE,
-  REQUEST_HEADERS: REQUEST_EVENTS.HEADERS,
-  REQUEST_BODY_START: REQUEST_EVENTS.BODY_START,
-  REQUEST_BODY_DATA: ApplicationHttpReader.BODY_PREFIX + '.' + DATA_EVENTS.DATA,
-  REQUEST_BODY_END: REQUEST_EVENTS.BODY_END,
-  REQUEST_END: REQUEST_EVENTS.END,
-  PART_START: PART_EVENTS.START,
-  PART_HEADERS: PART_EVENTS.HEADERS,
-  MULTIPART_START: MULTIPART_EVENTS.START,
-  MULTIPART_END: MULTIPART_EVENTS.END
-}
-
-/**
- * Main entry class for reading requests. Allows registering various readers for mime types (e.g. multipart/mixed,
- * application/http and application/octet-stream).
- * Implement as transform to catch the end of input event {@see _flush}.
- * Events are emitted to the emitter object given to constructor.
- *
- * Usage example:
- * const reader = new Reader(partReader, emitter)
- * request.pipe(reader)
- *
- * @extends Transform
- */
-class ContentDeserializer extends Transform {
-  /**
-   * @param {Object} reader - Reader used when starting reading
-   * @param {EventEmitter} emitter - Emitter to be used for reading events
-   */
-  constructor (reader, emitter) {
-    super()
-
-    this._cache = new Cache(Buffer.from([]))
-
-    // State Info
-    this._state = STATES.START
-
-    // Stack info
-    this._mimetypeReader = null
-    this._mimetypeReaderStack = []
-    this._mimetypeReaderFactories = new Map()
-    this._addMimeReaderFactories('application/http', ApplicationHttpReader.createInstance)
-    this._addMimeReaderFactories('application/octet-stream', DataReader.createInstance)
-    this._addMimeReaderFactories('multipart/mixed', MultipartParser.createInstance)
-    this._fallBackReaderFactory = DataReader.createInstance
-
-    this.pushReader(reader)
-
-    this._emitter = emitter
-  }
-
-  /**
-   * Overwritten _transform implementation
-   *
-   * @param {Buffer} buffer - Chunk of bytes
-   * @param {string} enc - Encoding of the chunk
-   * @param {Function} next - Callback function
-   * @private
-   */
-  _transform (buffer, enc, next) {
-    try {
-      this._cache.append(buffer)
-      this.readCache(false)
-      next()
-    } catch (err) {
-      next(err)
-    }
-  }
-
-  /**
-   * Overwritten _flush method to catch the end of the source stream.
-   * @param {Function} next - Callback function
-   * @private
-   */
-  _flush (next) {
-    try {
-      this.readCache(true) // last
-      next()
-    } catch (err) {
-      next(err)
-    }
-  }
-
-  /**
-   * Read data from cache until the catch is empty. The data is passed to the current reader until the
-   * processor is finished or more data is required by the reader.
-   *
-   * @param {boolean} last whether this reader is the last one
-   * @returns {boolean} whether more data is needed
-   * @throws {Error} In case of internal stack error
-   * @throws {Error} In case last === true and more data is required
-   */
-  readCache (last) {
-    let needMoreData = false
-
-    // this._cache.setConsumedBytes(0);
-
-    while (!needMoreData && this._state !== STATES.FINISHED) {
-      switch (this._state) {
-        case STATES.START:
-          this._emitter.emit(EVENTS.START)
-          this._state = STATES.PROCESS
-          break
-        case STATES.PROCESS:
-          needMoreData = this._mimetypeReader.readCache(this, this._cache, last)
-          if (needMoreData === false) {
-            this.popReader()
-          }
-
-          if (!this._mimetypeReader) {
-            this._state = STATES.FINISHED
-          }
-          break
-        default:
-          throw new DeserializationError('default reached')
-      }
-    }
-
-    this._cache.shrink()
-
-    // Ensure proper cleanup
-
-    if (last) {
-      if (needMoreData) throw new DeserializationError('More data required to process multipart')
-      if (this._cache.getLength()) {
-        this._emitter.emit(EVENTS.UNCONSUMED, this._cache.getBytes(this._cache.getLength()))
-      }
-      this._emitter.emit(EVENTS.END)
-    }
-    return needMoreData
-  }
-
-  /**
-   * Register a reader factory to a mime type.
-   * @param {string} mimetype - Mimetype (e.g. multipart/mixed)
-   * @param {Function} factory - Factory for the reader which can parse this mime type payload
-   * @private
-   */
-  _addMimeReaderFactories (mimetype, factory) {
-    this._mimetypeReaderFactories[mimetype] = factory
-  }
-
-  /**
-   * Push a reader to the readers stack.
-   * @param {Reader} mimetypeReader the reader
-   */
-  pushReader (mimetypeReader) {
-    if (this._mimetypeReader) {
-      this._mimetypeReaderStack.push(this._mimetypeReader)
-    }
-    this._mimetypeReader = mimetypeReader
-  }
-
-  /**
-   * Pop a reader from the readers stack.
-   */
-  popReader () {
-    this._mimetypeReader = this._mimetypeReaderStack.pop()
-    // this._mimetypeReader may be null
-  }
-
-  /**
-   * Determine next reader depending on a content-type header.
-   * @param {Object} headers HTTP headers, only "content-type" header is used
-   * @returns {Reader} the next reader
-   */
-  getNextReader (headers) {
-    // default content-type as defined in [RFC7231] 3.1.1.5.  Content-Type
-    const mimeType = (headers['content-type'] && headers['content-type'].getMimeType()) || 'application/octet-stream'
-
-    const nextReader = this.createReader(mimeType, headers)
-    if (!nextReader) throw new DeserializationError('missing mimetype Reader for ' + mimeType)
-    return nextReader
-  }
-
-  /**
-   * Create a reader.
-   * @param {string} mimeType type information used to create this reader
-   * @param {Object} headers the headers
-   * @returns {Reader} the created reader
-   */
-  createReader (mimeType, headers) {
-    let factory = this._mimetypeReaderFactories[mimeType] || this._fallBackReaderFactory
-    return factory(mimeType, headers)
-  }
-}
-
-ContentDeserializer.EVENTS = EVENTS
-
-module.exports = ContentDeserializer

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/DataReader.js

@@ -1,220 +0,0 @@
-'use strict'
-
-const Reader = require('./Reader')
-const DeserializationError = require('../errors/DeserializationError')
-
-/**
- * The dataReader can read up to a stop pattern, a given count of bytes and untill no more payload is available
- * @enum {{STOP_PATTERN: string, BYTE_COUNT: string, TILL_END: string}}
- */
-const STOP_CONDITION = {
-  STOP_PATTERN: 'STOP_PATTERN', // Read until stop pattern, after this the caches read position points to begin of stop pattern
-  BYTE_COUNT: 'BYTE_COUNT', // Read a given count of bytes, after this the read position points to the first byte after the read bytes
-  TILL_END: 'TILL_END' // Read until there is no more input data, see "last" parameter on method readCache (avoids search and byte counting)
-}
-
-/**
- * States
- * @type {{READ_NEXT_CHUNK: number, FINISHED: number}}
- */
-const STATES = {
-  READ_NEXT_CHUNK: 0, // data reader consumes chunks from cache
-  FINISHED: 1 // data reader finished (e.g. pattern, length or end of input reached)
-}
-
-/**
- * Events
- * @type {string}
- * @enum {{DATA: string, END: string}}
- */
-const EVENTS = {
-  DATA: 'data', // data reader consumed data from cache
-  END: 'end' // data reader reached state FINISHED
-}
-
-/**
- * The data reader reads bytes from the cache until the stop condition is reached. If the cache is empty
- * and the data reader needs more data, the readCache function returns to the caller signaling that more data is
- * required.
- *
- * There are three available conditions:
- * STOP_PATTERN:    Reader consumed bytes from cache until the stop pattern is reached
- * BYTE_COUNT:      Reader consumes a given amount of bytes from the cache
- * TILL_END:        Reader consumes until the caller signals that the end of data is reached
- *
- * The Following events are emitted through an injected emitter (the prefix is also injected)
- * <prefix>.data:       For every consumed chunk
- * <prefix>.end:        When the reader reaches state finished
- *
- * @extends Reader
- * */
-class DataReader extends Reader {
-  /**
-   * Factory for automatic creation depending on content-type
-   * @param {ContentTypeInfo} contentTypeInfo - Content type which caused using this reader
-   *                                            (here not used, but still in interface due to generic caller)
-   * @param {Object} headers - Header information (currently only the content-length header is evaluated)
-   * @returns {DataReader} a new instance of DataReader
-   */
-  static createInstance (contentTypeInfo, headers) {
-    return new DataReader(headers)
-  }
-
-  /**
-   * Constructor
-   * @param {Object} headers - Header information (currently only the content-length header is evaluated)
-   */
-  constructor (headers) {
-    super()
-
-    /**
-     * @enum {{STOP_PATTERN: string, BYTE_COUNT: string, TILL_END: string}}
-     * @private
-     */
-    this._stopCondition = STOP_CONDITION.TILL_END // default
-
-    /**
-     * Store content-length for STOP_CONDITION.BYTE_COUNT
-     * @type {number}
-     * @private
-     */
-    this._needToRead = null
-
-    // Check for content-length header, please not that these headers are not the nodejs generated headers
-    if (headers) {
-      const contentLength = headers['content-length']
-      if (contentLength) {
-        this._contentLength = Number.parseInt(contentLength.getValue(), 10)
-        this._needToRead = this._contentLength
-        this._stopCondition = STOP_CONDITION.BYTE_COUNT
-      }
-    }
-
-    this._state = STATES.READ_NEXT_CHUNK
-  }
-
-  /**
-   * Sets the stop pattern and sets the mode to STOP_PATTERN
-   * @param {string} stopPattern the stop pattern
-   */
-  setStopPattern (stopPattern) {
-    this._stopPattern = stopPattern
-    this._stopCondition = STOP_CONDITION.STOP_PATTERN // default
-  }
-
-  /**
-   * Consume data from cache. If the cache is empty and more data is required, this is signaled and readCache is called again. The state is preserved.
-   * @param {Reader} reader - Current reader
-   * @param {Cache} cache - Cache containing data for processing
-   * @param {boolean} last - Last call, no more date available
-   * @returns {boolean}
-   *      this: this reader needs more data and caller should call this method again with more data in cache
-   *      false: this reader is finished caller should pop this reader from stack
-   *      null:  new sub reader is on stack, call this method again after the sub reader is finished
-   */
-  readCache (reader, cache, last) {
-    let needMoreData = false
-
-    while (!needMoreData && this._state !== STATES.FINISHED) {
-      switch (this._stopCondition) {
-        case STOP_CONDITION.STOP_PATTERN:
-          needMoreData = this._readToStopPattern(cache, last)
-          break
-        case STOP_CONDITION.BYTE_COUNT:
-          needMoreData = this._readAmount(cache, last)
-          break
-        default:
-          // STOP_CONDITION.TILL_END:
-          needMoreData = this._readUntilEndOfInput(cache, last)
-          break
-      }
-    }
-
-    if (this._state === STATES.FINISHED) {
-      this.emit(EVENTS.END)
-      return false
-    }
-
-    if (last && needMoreData) {
-      throw new DeserializationError('More data required to process multipart')
-    }
-
-    return needMoreData
-  }
-
-  /**
-   * Read data until all input data is consumed.
-   * @param {Cache} cache - Cache containing data for processing
-   * @param {boolean} last - Last call, no more data available
-   * @returns {boolean} - true if more data is required, false if no more data is required
-   */
-  _readUntilEndOfInput (cache, last) {
-    const consumedBytes = cache.getLength() - cache.getReadPos()
-
-    this.emitAndConsume(cache, consumedBytes, EVENTS.DATA)
-
-    if (last) {
-      this._state = STATES.FINISHED
-      return false
-    }
-    return true
-  }
-
-  /**
-   * Read data until the stop pattern is reached. The read position is set to the beginning of the stop pattern.
-   * The caller which starts the body reader is responsible for reading the stop pattern.
-   *
-   * @param {Cache} cache - Cache containing data for processing
-   * @returns {boolean} - true if more data is required, false if no more data is required
-   */
-  _readToStopPattern (cache) {
-    if (cache.getLength() - cache.getReadPos() < this._stopPattern.length) {
-      return true
-    }
-
-    const pos = cache.indexOf(this._stopPattern, cache.getSearchPosition())
-
-    if (pos === -1) {
-      // stop pattern not found
-      const consumed = cache.getLength() - cache.getReadPos() - this._stopPattern.length
-      this.emitAndConsume(cache, consumed, EVENTS.DATA)
-
-      return true
-    }
-
-    // stop pattern found
-    const consumed = pos - cache.getReadPos()
-    this.emitAndConsume(cache, consumed, EVENTS.DATA)
-
-    this._state = STATES.FINISHED
-
-    return false
-  }
-
-  /**
-   * Read data until a given amount of bytes are read.
-   * @param {Cache} cache - Cache containing data for processing
-   * @returns {boolean} - true if more data is required, false if no more data is required
-   */
-  _readAmount (cache) {
-    const available = cache.getLength() - cache.getReadPos()
-
-    if (available < this._needToRead) {
-      this.emitAndConsume(cache, available, EVENTS.DATA)
-      this._needToRead -= available
-      return true
-    }
-
-    // there are more byte in buffer than needed
-    this.emitAndConsume(cache, this._needToRead, EVENTS.DATA)
-
-    this._needToRead = 0
-    this._state = STATES.FINISHED
-
-    return false
-  }
-}
-
-DataReader.EVENTS = EVENTS
-
-module.exports = DataReader

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/DeserializerFactory.js

@@ -1,240 +0,0 @@
-'use strict'
-
-const cds = require('../../../../../../cds')
-
-const stream = require('stream')
-const commons = require('../../odata-commons')
-const PrimitiveValueDecoder = commons.utils.PrimitiveValueDecoder
-const RepresentationKinds = commons.format.RepresentationKind.Kinds
-const JsonContentTypeInfo = commons.format.JsonContentTypeInfo
-const EdmTypeKind = commons.edm.EdmType.TypeKind
-const EdmPrimitiveTypeKind = commons.edm.EdmPrimitiveTypeKind
-const ResourceJsonDeserializer = require('./ResourceJsonDeserializer')
-const BatchJsonDeserializer = require('./BatchJsonDeserializer')
-const BatchRequestListBuilder = require('./BatchRequestListBuilder')
-const BatchContext = require('../batch/BatchContext')
-const BufferedWriter = require('../utils/BufferedWriter')
-const DeserializationError = require('../errors/DeserializationError')
-
-/**
- * The DeserializerFactory is responsible for creating parsing facade functions
- * for a specific payload type regarding to the corresponding request
- * representation kind like ENTITY and the corresponding request mime type.
- */
-class DeserializerFactory {
-  /**
-   * Creates and returns the deserialization facade function for application/json requests.
-   * This function is called on deserialization of the incoming payload.
-   *
-   * @param {Edm} edm the current EDM instance
-   * @param {RepresentationKind.Kinds} representationKind the representation kind
-   * @returns {Function} The deserialization facade function
-   */
-  static createJsonDeserializer (edm, representationKind) {
-    const getPropertyFunction = uriInfo => uriInfo.getLastSegment().getProperty()
-
-    function getCreateDeserializerFunction (name) {
-      return contract => {
-        const jsonContentTypeInfo = new JsonContentTypeInfo(contract.getContentTypeInfo())
-        let expand = []
-        let additionalInformation = { hasDelta: false }
-        const deserializer = new ResourceJsonDeserializer(edm, jsonContentTypeInfo)
-        return (edmObject, value) => {
-          const body = deserializer[name](edmObject, value, expand, additionalInformation)
-
-          return {
-            body,
-            expand,
-            additionalInformation
-          }
-        }
-      }
-    }
-
-    switch (representationKind) {
-      case RepresentationKinds.ENTITY:
-        return DeserializerFactory._createDeserializer(
-          uriInfo => uriInfo.getFinalEdmType(),
-          getCreateDeserializerFunction('deserializeEntity')
-        )
-
-      case RepresentationKinds.PRIMITIVE:
-        return DeserializerFactory._createDeserializer(
-          getPropertyFunction,
-          getCreateDeserializerFunction('deserializePrimitiveProperty')
-        )
-
-      case RepresentationKinds.PRIMITIVE_COLLECTION:
-        return DeserializerFactory._createDeserializer(
-          getPropertyFunction,
-          getCreateDeserializerFunction('deserializePrimitivePropertyCollection')
-        )
-
-      case RepresentationKinds.COMPLEX:
-        return DeserializerFactory._createDeserializer(
-          getPropertyFunction,
-          getCreateDeserializerFunction('deserializeComplexProperty')
-        )
-
-      case RepresentationKinds.COMPLEX_COLLECTION:
-        return DeserializerFactory._createDeserializer(
-          getPropertyFunction,
-          getCreateDeserializerFunction('deserializeComplexPropertyCollection')
-        )
-
-      case RepresentationKinds.ACTION_PARAMETERS:
-        return DeserializerFactory._createDeserializer(
-          uriInfo => uriInfo.getLastSegment().getAction(),
-          getCreateDeserializerFunction('deserializeActionParameters')
-        )
-
-      case RepresentationKinds.REFERENCE:
-        return DeserializerFactory._createDeserializer(
-          uriInfo => uriInfo.getFinalEdmType(),
-          getCreateDeserializerFunction('deserializeReference')
-        )
-
-      default:
-        return null
-    }
-  }
-
-  /**
-   * Create and return the deserialization function for text/plain requests
-   * containing a single primitive value.
-   * This function is called on deserialization of the incoming payload.
-   *
-   * @returns {Function} the deserialization function
-   */
-  static createTextValueDeserializer () {
-    return DeserializerFactory._createDeserializer(
-      uriInfo => uriInfo.getLastSegment(-1).getProperty(),
-      () => {
-        const deserializer = new PrimitiveValueDecoder()
-        return (edmProperty, value) => {
-          return { body: deserializer.decodeText(value.toString(), edmProperty) }
-        }
-      }
-    )
-  }
-
-  /**
-   * Create and return the deserialization function for binary requests.
-   * This function is called on deserialization of the incoming payload.
-   *
-   * @returns {Function} the deserialization function
-   */
-  static createBinaryDeserializer () {
-    return (request, next) => {
-      let type = request.getUriInfo() && request.getUriInfo().getFinalEdmType()
-      if (type && type.getKind() === EdmTypeKind.DEFINITION) type = type.getUnderlyingType()      
-      if (type && type === EdmPrimitiveTypeKind.Stream) {
-        if (request.getIncomingRequest().complete) { // empty or NULL
-          next(null, request.getIncomingRequest())
-        } else {
-          const streamPipeline = stream.pipeline(request.getIncomingRequest(), new stream.PassThrough(), () => {})
-          next(null, streamPipeline)
-        }
-      } else {
-        request
-          .getIncomingRequest()
-          .on('error', next)
-          .pipe(new BufferedWriter())
-          .on('error', next)
-          .on('result', rawBody => next(null, rawBody))
-      }
-    }
-  }
-
-  /**
-   * Create and return the deserialization function for batch requests in the multipart/mixed format.
-   * This function is called on deserialization of the incoming payload.
-   *
-   * @returns {Function} the deserialization function
-   */
-  static createMultipartMixedDeserializer () {
-    return (request, next) => {
-      const batchRequestListBuilder = new BatchRequestListBuilder()
-      batchRequestListBuilder.build(request, (err, list) =>
-        err
-          ? next(err)
-          : next(null, {
-            boundary: batchRequestListBuilder.getBatchBoundary(),
-            requests: list,
-            semantics: BatchContext.SEMANTICS.MULTIPART
-          })
-      )
-    }
-  }
-
-  /**
-   * Creates and returns the deserialization function for batch requests in JSON format.
-   * @returns {Function} the deserialization function
-   */
-  static createBatchJsonDeserializer () {
-    return (request, next) => {
-      request
-        .getIncomingRequest()
-        .on('error', next)
-        .pipe(new BufferedWriter())
-        .on('error', next)
-        .on('result', rawBody => {
-          try {
-            const body = JSON.parse(rawBody)
-            const list = new BatchJsonDeserializer().deserialize(body)
-            next(null, {
-              requests: list,
-              semantics: BatchContext.SEMANTICS.JSON
-            })
-          } catch (error) {
-            next(new DeserializationError('Error while deserializing payload', error))
-          }
-        })
-    }
-  }
-
-  /**
-   * Create and return a deserialization function.
-   * @param {Function} edmFunction function to get from URI info the EDM object for the parse function
-   * @param {Function} createDeserializerFunction function to create the deserialize function
-   *                                              (with parameters EDM object and input)
-   * @returns {Function} the deserialization function
-   */
-  static _createDeserializer (edmFunction, createDeserializerFunction) {
-    return (request, next) => {
-      request
-        .getIncomingRequest()
-        .on('error', next)
-        .pipe(new BufferedWriter())
-        .on('error', next)
-        .on('result', rawBody => {
-          try {
-            const edmObject = edmFunction(request.getUriInfo())
-            const deserializeFunction = createDeserializerFunction(request.getContract())
-            const result = deserializeFunction(edmObject, rawBody)
-
-            if (result.expand && result.expand.length > 0) request.setDeepInsertExpand(result.expand)
-            if (result.additionalInformation && result.additionalInformation.hasDelta) {
-              request.setHasDelta(true)
-            }
-
-            next(null, result.body)
-          } catch (error) {
-            let text = 'Error while deserializing payload'
-            let err = error
-            while (err) {
-              if (err.message.includes('IEEE754Compatible') || err.message.includes('JSON number is not supported')) {
-                text +=
-                  '; consider using parameter IEEE754Compatible=true in content-type ' + 'with adjusted formatting'
-                break
-              }
-              err = typeof err.getRootCause === 'function' ? err.getRootCause() : undefined
-            }
-            next(new DeserializationError(text, error), rawBody)
-          }
-        })
-    }
-  }
-}
-
-module.exports = DeserializerFactory