@sap/cds 8.9.4 → 9.0.2

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

@@ -1,202 +0,0 @@
-'use strict'
-
-const CRLF = '\r\n'
-
-const commons = require('../../odata-commons')
-const ContentTypes = commons.format.ContentTypeInfo.ContentTypes
-const HeaderNames = commons.http.HttpHeader.HeaderNames
-const SerializationError = require('../errors/SerializationError')
-
-const STATES = {
-  WRITING_PAYLOAD_HEADER: 0,
-  WRITING_OBJECT_HEADER: 1,
-  WRITING_FIRST_PART: 2,
-  WRITING_ENCAPSULATION: 3,
-  WRITING_EPILOGUE: 4
-}
-
-/**
- * Writes content in application/multipart format into an stream.
- * Used to write OData batch responses. For nested multipart (e.g. for change set) one stream can be used with 2 MultipartWriter instances
- *
- * Sample call sequence:
- * - const w = new MultipartWriter(httpResponse)
- * - w->writePreamble (...)
- * - w->writePart (...)
- * - w->writePart (...)
- * - w->writeEpilogue (...)
- * - w->writeEnd
- *
- *
- * 'Content-Type: multipart/mixed; boundary=changeset', <-- written Automatically
- * 'CustomHeader: Value                                 <-- written by MultipartWriter->writeHeader
- * '',
- * '--changeset',                                       <-- written by MultipartWriter->writePart
- * 'Content-Type: application/http',
- * 'Content-ID: 1',                                     <-- extracted from the response headers
- * '',
- * 'POST /service/Customers HTTP/1.1',
- * 'Host: host',
- * 'Content-Type: application/json',
- * '',
- * '{}',
- * '--changeset',  <-- written by MultipartWriter->writePart
- * 'Content-Type: application/http',
- * 'Content-ID: 2',
- * '',
- * "PATCH /service/Customers('ALFKI') HTTP/1.1'",
- * 'Host: host',
- * 'Content-Type: application/json',
- * '',
- * '{}',
- * '--changeset--',  <-- written by MultipartWriter->writeEnd
- */
-class MultipartWriter {
-  /**
-   * Constructor
-   *
-   * @param {Stream} writableStream Destination stream
-   * @param {boolean} writeHeaderAsPayload If false then the headers are set into the destination stream via setHeader. For example if the
-   * destination stream is a http.ServerResponse. If true the headers are serialised as name value pair into the payload.
-   * @param {string} boundary Boundary for the multipart
-   */
-  constructor (writableStream, writeHeaderAsPayload, boundary) {
-    this._state = writeHeaderAsPayload ? STATES.WRITING_PAYLOAD_HEADER : STATES.WRITING_OBJECT_HEADER
-
-    this._writableStream = writableStream
-
-    this._boundary = boundary
-  }
-
-  /**
-   * Writes a http header (name, value) into the destination stream
-   *
-   * @param {string} name Header name
-   * @param {string} value Header value
-   */
-  writeHeader (name, value) {
-    if (this._state === STATES.WRITING_PAYLOAD_HEADER) {
-      this._writableStream.write(name + ': ' + value + CRLF)
-    } else if (this._state === STATES.WRITING_OBJECT_HEADER) {
-      this._writableStream.setHeader(name, value)
-    } else {
-      throw new SerializationError('MultipartWriter: header must be written first')
-    }
-  }
-
-  /**
-   * Writes the content type header (name, value) into the destination stream
-   */
-  writeContentType () {
-    if (this._state === STATES.WRITING_PAYLOAD_HEADER) {
-      this._writableStream.write(
-        HeaderNames.CONTENT_TYPE + ': ' + ContentTypes.MULTIPART_MIXED + '; boundary=' + this._boundary + CRLF,
-        'utf8'
-      )
-    } else {
-      this._writableStream.setHeader(
-        HeaderNames.CONTENT_TYPE,
-        ContentTypes.MULTIPART_MIXED + '; boundary=' + this._boundary
-      )
-    }
-  }
-
-  /**
-   * Writes the preamble into the stream
-   *
-   * @param {Buffer} buffer Preamble
-   */
-  writePreamble (buffer) {
-    if (this._state === STATES.WRITING_PAYLOAD_HEADER || this._state === STATES.WRITING_OBJECT_HEADER) {
-      this.writeContentType()
-
-      // write header separator
-
-      if (this._state === STATES.WRITING_PAYLOAD_HEADER) {
-        this._writableStream.write(CRLF, 'utf8')
-      }
-      this._state = STATES.PREAMBLE
-    }
-
-    this._writableStream.write(buffer)
-  }
-
-  /**
-   * Start writing the part (especially LF and boundaries)
-   *
-   * @throws Error
-   */
-  startPart () {
-    if (this._state === STATES.WRITING_PAYLOAD_HEADER || this._state === STATES.WRITING_OBJECT_HEADER) {
-      this.writeContentType()
-
-      if (this._state === STATES.WRITING_PAYLOAD_HEADER) {
-        this._writableStream.write(CRLF, 'utf8')
-      }
-      this._state = STATES.WRITING_FIRST_PART
-
-      this.writeBoundary()
-    } else if (this._state === STATES.PREAMBLE) {
-      this._writableStream.write(CRLF, 'utf8')
-
-      this.writeBoundary()
-    } else if (this._state === STATES.WRITING_ENCAPSULATION) {
-      this._writableStream.write(CRLF, 'utf8')
-
-      this.writeBoundary()
-    } else {
-      throw new SerializationError('MultipartWriter: part could not be written')
-    }
-  }
-
-  /**
-   * Set state to writing encapsulation indicating that the closing boundary has been written
-   */
-  endPart () {
-    this._state = STATES.WRITING_ENCAPSULATION
-  }
-
-  /**
-   * Write a buffer in a part
-   * @param {Buffer} buffer Buffer with data to be written
-   */
-  writeIntoPart (buffer) {
-    this._writableStream.write(buffer)
-  }
-
-  /**
-   * Writes the closing boundary into the stream.
-   *
-   * @param {boolean} last If true and additional CRLF is added after the end boundary (required for backward compatibility)
-   */
-  writeEndBoundary (last) {
-    this._writableStream.write(CRLF + '--' + this._boundary + '--' + (last ? CRLF : ''))
-  }
-
-  /**
-   * Writes the epilogue into the stream
-   *
-   * @param {Buffer} buffer Preamble
-   */
-  writeEpilogue (buffer) {
-    if (this._state !== STATES.WRITING_ENCAPSULATION) {
-      throw new SerializationError('MultipartWriter: part required before writing epilogue')
-    }
-    this.writeEndBoundary()
-
-    // this.startData();
-    this._writableStream.write(CRLF, 'utf8')
-    this._writableStream.write(buffer)
-    this._state = STATES.WRITING_EPILOGUE
-  }
-
-  /**
-   * Writes a boundary delimiter into the stream
-   */
-  writeBoundary () {
-    const out = this._writableStream
-    out.write('--' + this._boundary + CRLF)
-  }
-}
-
-module.exports = MultipartWriter

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

@@ -1,330 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const QueryOptions = commons.uri.UriInfo.QueryOptions
-const ExpressionKind = commons.uri.Expression.ExpressionKind
-const ResourceKind = commons.uri.UriResource.ResourceKind
-const CommonsUriHelper = commons.uri.UriHelper
-const UriHelper = require('../utils/UriHelper')
-const SerializationError = require('../errors/SerializationError')
-
-// A search word is a sequence of one or more non-whitespace characters, excluding
-// parentheses, double-quotes, and semicolons. It must not start with a single quote.
-const WORD_REGEXP = new RegExp('^[^\\s()";\'][^\\s()";]*$', 'u')
-// regular expressions for search phrases; string replacements don't replace all occurrences if used with strings
-const BACKSLASH_REGEXP = new RegExp('\\\\', 'g')
-const DOUBLEQUOTE_REGEXP = new RegExp('"', 'g')
-
-/**
- * This class serializes a nextLink using path segments, query options, and a skiptoken provided by the application.
- */
-class NextLinkSerializer {
-  /**
-   * @param {?PrimitiveValueEncoder} [primitiveValueEncoder] the encoder for primitive values
-   */
-  constructor (primitiveValueEncoder) {
-    this._encoder = primitiveValueEncoder
-  }
-
-  /**
-   * Serializes a nextLink by concatenating parts of the request with the skiptoken query option.
-   * @param {string} odataPath the URL path segments of the request URL that belong to OData
-   * @param {?string} queryOptionsString the raw query string of the incoming request
-   *                                     or null if no query string is present in the incoming request
-   * @param {string} skiptoken the skiptoken that was provided by the application
-   * @returns {string} the serialized nextLink
-   */
-  serializeNextLink (odataPath, queryOptionsString, skiptoken) {
-    const queryOptions = this._removeSkiptoken(queryOptionsString)
-    return (
-      odataPath +
-      (queryOptions ? queryOptions + '&' : '?') +
-      QueryOptions.SKIPTOKEN +
-      '=' +
-      encodeURIComponent(skiptoken)
-    )
-  }
-
-  /**
-   * Removes the query option $skiptoken from the query-options string.
-   * @param {?string} queryOptionsString the query options as string
-   * @returns {?string} query options without $skiptoken
-   * @private
-   */
-  _removeSkiptoken (queryOptionsString) {
-    if (!queryOptionsString) return null
-    const newQueryOptions = queryOptionsString
-      .substring(1)
-      .split('&')
-      .filter(queryOption => !unescape(queryOption).startsWith(QueryOptions.SKIPTOKEN))
-      .join('&')
-    return newQueryOptions ? '?' + newQueryOptions : newQueryOptions
-  }
-
-  /**
-   * Serializes a next link for an expanded collection by creating a URL with appropriate query options
-   * and the new skiptoken.
-   *
-   * We construct an URL by extending the path of the OData request URL with intermediate segments
-   * (e.g., complex properties), the navigation property to be expanded, and potentially $ref for reference
-   * collections. Query options are generated out of $expand options, and the skiptoken is added.
-   *
-   * @param {string} odataPath the URL path segments of the request URL that belong to OData
-   * @param {ExpandItem} expandItem the expand item to be expanded (contains options to be converted to query options)
-   * @param {string} skiptoken the skiptoken value that was provided by the application
-   * @returns {string} the serialized nextLink
-   */
-  serializeExpandNextLink (odataPath, expandItem, skiptoken) {
-    return (
-      odataPath +
-      '?' +
-      this._serializeExpandOptions(expandItem)
-        .concat(QueryOptions.SKIPTOKEN + '=' + encodeURIComponent(skiptoken))
-        .join('&')
-    )
-  }
-
-  /**
-   * Serializes the options of an expand item into a string array.
-   * @param {ExpandItem} expandItem the expand item
-   * @returns {string[]} the serialized options of the expand item
-   * @private
-   */
-  _serializeExpandOptions (expandItem) {
-    // the supported expand options in the order in which they must be applied
-    const expandOptions = [
-      QueryOptions.SEARCH,
-      QueryOptions.FILTER,
-      QueryOptions.COUNT,
-      QueryOptions.ORDERBY,
-      QueryOptions.SKIP,
-      QueryOptions.TOP,
-      QueryOptions.EXPAND,
-      QueryOptions.SELECT
-    ]
-    let options = []
-    for (const name of expandOptions) {
-      const value = expandItem.getOption(name)
-      if (value === undefined || value === null) continue
-      let serializedValue
-      switch (name) {
-        case QueryOptions.SEARCH:
-          serializedValue = this._serializeSearch(value)
-          break
-        case QueryOptions.FILTER:
-          serializedValue = this._serializeExpression(value)
-          break
-        case QueryOptions.ORDERBY:
-          serializedValue = value
-            .map(item => this._serializeExpression(item.getExpression()) + (item.isDescending() ? ' desc' : ''))
-            .join(',')
-          break
-        case QueryOptions.COUNT:
-        case QueryOptions.SKIP:
-        case QueryOptions.TOP:
-          serializedValue = value
-          break
-        case QueryOptions.EXPAND:
-          serializedValue = value.map(this._serializeExpand, this).join(',')
-          break
-        case QueryOptions.SELECT:
-          serializedValue = value.map(this._serializeSelect).join(',')
-          break
-        default:
-          throw new SerializationError('The expand option ' + name + ' is not supported in a next link.')
-      }
-      options.push(name + '=' + serializedValue)
-    }
-    return options
-  }
-
-  /**
-   * Serializes a select item into a string.
-   * @param {SelectItem} selectItem the select item
-   * @returns {string} the serialized select item
-   * @private
-   */
-  _serializeSelect (selectItem) {
-    if (selectItem.isAll()) return '*'
-    return selectItem.isAllOperationsInSchema()
-      ? encodeURIComponent(selectItem.getAllOperationsInSchemaNamespace() + '.*')
-      : selectItem
-        .getPathSegments()
-        .map(segment => encodeURIComponent(segment.getPathSegmentIdentifier()))
-        .join('/')
-  }
-
-  /**
-   * Serializes an expand item into a string.
-   * @param {ExpandItem} expandItem the expand item
-   * @returns {string} the serialized expand item
-   * @private
-   */
-  _serializeExpand (expandItem) {
-    if (expandItem.isAll()) return '*'
-    const options = this._serializeExpandOptions(expandItem)
-    return (
-      expandItem
-        .getPathSegments()
-        .map(this._serializePathSegment, this)
-        .join('/') + (options.length ? '(' + options.join(';') + ')' : '')
-    )
-  }
-
-  /**
-   * Serializes an expression.
-   * @param {Expression} expression the expression
-   * @returns {string} the serialized expression
-   * @private
-   */
-  _serializeExpression (expression) {
-    switch (expression.getKind()) {
-      case ExpressionKind.LITERAL:
-        return encodeURIComponent(CommonsUriHelper.toUriLiteral(expression.getText(), expression.getType()))
-
-      case ExpressionKind.TYPE_LITERAL:
-        return encodeURIComponent(
-          expression
-            .getType()
-            .getFullQualifiedName()
-            .toString()
-        )
-
-      case ExpressionKind.ALIAS:
-        return this._serializeExpression(expression.getExpression())
-
-      case ExpressionKind.UNARY: {
-        const operand = this._serializeExpression(expression.getOperand())
-        return (
-          expression.getOperator() +
-          (expression.getOperator() === 'not' ? ' ' : '') +
-          (expression.getOperand().getKind() === ExpressionKind.BINARY ||
-          expression.getOperand().getKind() === ExpressionKind.ALIAS
-            ? '(' + operand + ')'
-            : operand)
-        )
-      }
-
-      case ExpressionKind.BINARY: {
-        const left = this._serializeExpression(expression.getLeftOperand())
-        const right = this._serializeExpression(expression.getRightOperand())
-        return (
-          (expression.getLeftOperand().getKind() === ExpressionKind.BINARY ||
-          expression.getLeftOperand().getKind() === ExpressionKind.ALIAS
-            ? '(' + left + ')'
-            : left) +
-          ' ' +
-          expression.getOperator() +
-          ' ' +
-          (expression.getRightOperand().getKind() === ExpressionKind.BINARY ||
-          expression.getRightOperand().getKind() === ExpressionKind.ALIAS
-            ? '(' + right + ')'
-            : right)
-        )
-      }
-
-      case ExpressionKind.MEMBER:
-        return expression
-          .getPathSegments()
-          .map(this._serializePathSegment, this)
-          .join('/')
-
-      case ExpressionKind.METHOD:
-        return (
-          expression.getMethod() +
-          '(' +
-          expression
-            .getParameters()
-            .map(this._serializeExpression, this)
-            .join(',') +
-          ')'
-        )
-
-      default:
-        return null
-    }
-  }
-
-  /**
-   * Serializes a search expression. This is unfortunately different from a "normal" expression.
-   * @param {Expression} expression the search expression
-   * @returns {string} the serialized search expression
-   * @private
-   */
-  _serializeSearch (expression) {
-    if (expression.getKind() === ExpressionKind.UNARY) {
-      return expression.getOperator().toUpperCase() + ' ' + this._serializeSearch(expression.getOperand())
-    } else if (expression.getKind() === ExpressionKind.BINARY) {
-      const left = this._serializeSearch(expression.getLeftOperand())
-      const right = this._serializeSearch(expression.getRightOperand())
-      return (
-        (expression.getLeftOperand().getKind() === ExpressionKind.BINARY ? '(' + left + ')' : left) +
-        ' ' +
-        expression.getOperator().toUpperCase() +
-        ' ' +
-        (expression.getRightOperand().getKind() === ExpressionKind.BINARY ? '(' + right + ')' : right)
-      )
-    }
-    // Serializes a search word or a search phrase.
-    const literal = expression.getText()
-    // A search phrase is a doublequoted string with backslash-escaped backslashes and doublequotes.
-    return WORD_REGEXP.test(literal)
-      ? encodeURIComponent(literal)
-      : '"' + encodeURIComponent(literal.replace(BACKSLASH_REGEXP, '\\\\').replace(DOUBLEQUOTE_REGEXP, '\\"')) + '"'
-  }
-
-  /**
-   * Serializes a path segment.
-   * @param {UriResource} segment the path segment
-   * @returns {string} the serialized path segment
-   * @private
-   */
-  _serializePathSegment (segment) {
-    let result = segment.getPathSegmentIdentifier()
-    if (!result.startsWith('$')) result = encodeURIComponent(result)
-
-    const kind = segment.getKind()
-    if (
-      kind === ResourceKind.FUNCTION_IMPORT ||
-      kind === ResourceKind.BOUND_FUNCTION ||
-      kind === ResourceKind.UNBOUND_FUNCTION
-    ) {
-      result +=
-        '(' +
-        segment
-          .getFunctionParameters()
-          .map(
-            parameter =>
-              encodeURIComponent(parameter.getEdmRef().getName()) +
-              '=' +
-              (parameter.getText() === undefined && parameter.getAliasValue() === undefined
-                ? this._serializeExpression(parameter.getExpression())
-                : encodeURIComponent(
-                  parameter.getText() === undefined ? parameter.getAliasValue() : parameter.getText(),
-                  parameter.getEdmRef().getType()
-                ))
-          )
-          .join(',') +
-        ')'
-    }
-
-    if (segment.getKeyPredicates().length) {
-      result += UriHelper.buildKeyString(UriHelper.buildKeyPredicates(segment.getKeyPredicates()))
-    }
-
-    if (kind === ResourceKind.ALL_EXPRESSION || kind === ResourceKind.ANY_EXPRESSION) {
-      result +=
-        '(' +
-        (segment.getExpressionVariableName()
-          ? encodeURIComponent(segment.getExpressionVariableName()) +
-            ':' +
-            this._serializeExpression(segment.getExpression())
-          : '') +
-        ')'
-    }
-
-    return result
-  }
-}
-
-module.exports = NextLinkSerializer