@sap/cds 8.9.4 → 9.0.2

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

@@ -1,515 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const RepresentationKind = commons.format.RepresentationKind
-const ContentTypes = commons.format.ContentTypeInfo.ContentTypes
-const HttpStatusCode = commons.http.HttpStatusCode
-const ExpressionKind = commons.uri.Expression.ExpressionKind
-const TransformationKind = commons.uri.apply.Transformation.TransformationKind
-const AggregateMethod = commons.uri.apply.AggregateExpression.StandardMethod
-const BottomTopMethod = commons.uri.apply.BottomTopTransformation.Method
-const UriHelper = require('../utils/UriHelper')
-
-class DebugJsonSerializer {
-  /**
-   * Creats an instance of the debug-view JSON serializer.
-   * @param {Object} context - The OData context
-   * @param {string} payload - The response body. It is the result of the previous serializer, referring either to data (e.g. metadata, service, entity collection, .. etc.) for successful request, or to an error (any).
-   * @param {string} err - Error
-   */
-  constructor (context, payload, err) {
-    this._context = context
-    this._payload = payload
-    this._error = err
-  }
-
-  /**
-   * Serializes the debug view and returns a stringified JSON object with the following structure:
-   *      {
-   *          request: {...},
-   *          response: {...},
-   *          context: {...},
-   *      }
-   *
-   * @returns {string} - Stringified JSON object of the debug view
-   */
-  serialize () {
-    const request = this._context.getRequest()
-    const response = this._context.getResponse()
-
-    let body = request.getBody() || ''
-    if (request.getContract().getRepresentationKind() === RepresentationKind.Kinds.BATCH) body = ''
-
-    let output = {
-      request: {
-        method: request.getMethod(),
-        uri: request.getUrlObject().href,
-        headers: request.getHeaders(),
-        body
-      },
-      response: {
-        headers: response.getHeaders(),
-        status: {
-          code: response.getOriginalStatusCode(),
-          info: response.getStatusMessage() || HttpStatusCode.Texts[response.getOriginalStatusCode()]
-        },
-        body: this._payload
-      },
-      context: {
-        uriInfo: null,
-        requestRepresentationKind: request.getContract().getRepresentationKind(),
-        responseRepresentationKind: response.getOriginalContract().getRepresentationKind()
-      },
-      server: {
-        environment: {
-          platform: process.platform,
-          arch: process.arch,
-          node: {
-            version: process.version
-          },
-          process: {
-            uptime: Math.trunc(process.uptime() / 60) + ' minutes'
-          }
-        }
-      },
-      log: this._context.getLogger().getLog()
-    }
-
-    try {
-      if (
-        response
-          .getOriginalContract()
-          .getContentTypeInfo()
-          .getMimeType() === ContentTypes.JSON
-      ) {
-        output.response.body = JSON.parse(this._payload)
-      }
-    } catch (error) {
-      // A possible error can be ignored if the payload is not in JSON.
-      // The payload itself is already in the output.
-    }
-
-    try {
-      output.context.uriInfo = this._buildUriInfo(request.getUriInfo())
-    } catch (error) {
-      this._error = error
-    }
-
-    if (this._error) {
-      output.server.stacktrace = this._collectErrorStacktrace(this._error, [])
-    }
-
-    const mainPm = this._context.getPerformanceMonitor()
-    if (!mainPm.isNoOpMonitor()) {
-      output.profile = mainPm.getResult()
-    }
-
-    return JSON.stringify(output)
-  }
-
-  /**
-   * Build the error stacktrace recursive. If there is a getRootCause method and this methods
-   * returns a root error the stack of the root error will be pushed to the stacktrace.
-   *
-   * @param {Error} error The error to build the stacktrace from.
-   * @param {Array} stacktrace This array will be filled with the stacktrace.
-   *                           Each element is a nested root error.
-   * @returns {Array} the stacktrace
-   * @private
-   */
-  _collectErrorStacktrace (error, stacktrace) {
-    stacktrace.push(error.stack)
-    if (error.getRootCause && error.getRootCause()) {
-      let innerError = error.getRootCause()
-      this._collectErrorStacktrace(innerError, stacktrace)
-    }
-    return stacktrace
-  }
-
-  /**
-   * Serializes the URI info object.
-   * @param {Object} uriInfo - The URI info
-   * @returns {Object} - Serialized JSON object
-   * @private
-   */
-  _buildUriInfo (uriInfo) {
-    if (!uriInfo) return null
-    return {
-      pathSegments: this._buildPathSegments(uriInfo.getPathSegments()),
-      queryOptions: this._buildQueryOptions(uriInfo.getQueryOptions())
-    }
-  }
-
-  /**
-   * Prepare the provided resource-path segments for serialization.
-   * @param {UriResource[]} segments the resource-path segments
-   * @returns {Array} the built segments prepared for serialization
-   * @private
-   */
-  _buildPathSegments (segments) {
-    return segments.map(segment => {
-      let result = {
-        kind: segment.getKind(),
-        name: segment.getPathSegmentIdentifier()
-      }
-
-      let keyPredicates = UriHelper.buildKeyPredicates(segment.getKeyPredicates())
-      for (let keyPredicate of keyPredicates) {
-        keyPredicate.type = keyPredicate.type.getFullQualifiedName().toString()
-      }
-      if (keyPredicates.length) result.keyPredicates = keyPredicates
-
-      if (segment.getProperty()) {
-        const property = segment.getProperty()
-        if (property.getType()) {
-          result.type = property
-            .getType()
-            .getFullQualifiedName()
-            .toString()
-        }
-        result.isCollection = property.isCollection()
-        result.isNullable = property.isNullable()
-      }
-
-      if (segment.getNavigationProperty()) {
-        const edmNavigationProperty = segment.getNavigationProperty()
-        result.isCollection = edmNavigationProperty.isCollection()
-        result.isNullable = edmNavigationProperty.isNullable()
-        const partner = edmNavigationProperty.getPartner()
-        if (partner) {
-          result.partner = {
-            name: partner.getName(),
-            type: partner
-              .getEntityType()
-              .getFullQualifiedName()
-              .toString(),
-            isCollection: partner.isCollection(),
-            isNullable: partner.isNullable()
-          }
-          const partnerConstraints = partner.getReferentialConstraints()
-          if (partnerConstraints && partnerConstraints.size) {
-            result.partner.constraints = Array.from(partnerConstraints.values()).map(constraint => {
-              return {
-                property: constraint.getPropertyName(),
-                referencedProperty: constraint.getReferencedPropertyName()
-              }
-            })
-          }
-        }
-        const constraints = edmNavigationProperty.getReferentialConstraints()
-        if (constraints && constraints.size) {
-          result.constraints = Array.from(constraints.values()).map(constraint => {
-            return {
-              property: constraint.getPropertyName(),
-              referencedProperty: constraint.getReferencedPropertyName()
-            }
-          })
-        }
-      }
-
-      if (segment.getExpression()) result.expression = this._buildExpression(segment.getExpression())
-      if (segment.getExpressionVariableName()) result.variableName = segment.getExpressionVariableName()
-      if (segment.getFunction()) {
-        result.parameters = segment.getFunctionParameters().map(this._buildParameter, this)
-      }
-
-      let type = segment.getEdmType()
-      if (type) result.type = type.getFullQualifiedName().toString()
-
-      return result
-    })
-  }
-
-  /**
-   * Prepare the provided expression for serialization.
-   * @param {Expression} expression the expression to build
-   * @returns {Object} The built expression prepared for serialization
-   * @private
-   */
-  _buildExpression (expression) {
-    let result = {}
-
-    switch (expression.getKind()) {
-      case ExpressionKind.LITERAL:
-        result.nodeType = 'LiteralExpression'
-        result.value = expression.getText()
-        break
-
-      case ExpressionKind.ALIAS:
-        result.nodeType = 'AliasExpression'
-        result.alias = expression.getAlias()
-        result.expression = this._buildExpression(expression.getExpression())
-        break
-
-      case ExpressionKind.UNARY:
-        result.nodeType = 'UnaryExpression'
-        result.operator = expression.getOperator()
-        result.operand = this._buildExpression(expression.getOperand())
-        break
-
-      case ExpressionKind.BINARY:
-        result.nodeType = 'BinaryExpression'
-        result.operator = expression.getOperator()
-        result.left = this._buildExpression(expression.getLeftOperand())
-        result.right = this._buildExpression(expression.getRightOperand())
-        break
-
-      case ExpressionKind.MEMBER:
-        result.nodeType = 'MemberExpression'
-        result.pathSegments = this._buildPathSegments(expression.getPathSegments())
-        break
-
-      case ExpressionKind.METHOD:
-        result.nodeType = 'MethodExpression'
-        result.operator = expression.getMethod()
-        result.parameters = expression.getParameters().map(this._buildExpression, this)
-        break
-
-      default:
-        break
-    }
-
-    let type = expression.getType()
-    if (type) result.type = type.getFullQualifiedName().toString()
-
-    return result
-  }
-
-  /**
-   * Prepare the provided expand query option for serialization.
-   * The preparation is done recursively for all available expands.
-   *
-   * @param {Object} $expand The query option to build
-   * @returns {Object} The built query expand option prepared for serialization
-   * @private
-   */
-  _buildExpandQueryOption ($expand) {
-    return $expand.map(expandItem => {
-      let context = {}
-
-      context.$expandPath = this._buildPathSegments(expandItem.getPathSegments())
-
-      const $select = expandItem.getOption('$select')
-      if ($select) context.$select = this._buildSelectQueryOption($select)
-
-      const nextExpand = expandItem.getOption('$expand')
-      if (nextExpand) context.$expand = this._buildExpandQueryOption(nextExpand)
-
-      if (expandItem.isAll()) context.isAll = true
-
-      return context
-    })
-  }
-
-  /**
-   * Prepare the provided select query option for serialization.
-   * @param {Object} $select The query option to build
-   * @returns {string[]} The built query select option prepared for serialization
-   * @private
-   */
-  _buildSelectQueryOption ($select) {
-    return $select.map(selectItem => {
-      const pathSegments = selectItem.getPathSegments()
-      if (pathSegments.length > 0) {
-        return pathSegments.map(segment => segment.getPathSegmentIdentifier()).join('/')
-      }
-
-      if (selectItem.isAllOperationsInSchema()) {
-        return selectItem.getAllOperationsInSchemaNamespace() + '.*'
-      }
-
-      return '*'
-    })
-  }
-
-  /**
-   * Prepare the provided orderby query option for serialization.
-   * @param {Object} $orderby The query option to build
-   * @returns {Object} The built query orderby option prepared for serialization
-   * @private
-   */
-  _buildOrderByQueryOption ($orderby) {
-    return $orderby.map(this._buildOrderByItem, this)
-  }
-
-  /**
-   * Prepare the provided order-by item for serialization.
-   * @param {OrderByItem} item the order-by item
-   * @returns {Object} the built order-by item prepared for serialization
-   * @private
-   */
-  _buildOrderByItem (item) {
-    return {
-      nodeType: 'Orderby',
-      sortOrder: item.isDescending() ? 'desc' : 'asc',
-      expression: this._buildExpression(item.getExpression())
-    }
-  }
-
-  /**
-   * Prepare the provided apply query option for serialization.
-   * @param {Transformation[]} apply the query option to build
-   * @returns {Array} the built apply query option prepared for serialization
-   * @private
-   */
-  _buildApplyQueryOption (apply) {
-    return apply.map(transformation => {
-      let result = {
-        transformation: Object.keys(TransformationKind).find(
-          name => TransformationKind[name] === transformation.getKind()
-        )
-      }
-
-      switch (transformation.getKind()) {
-        case TransformationKind.AGGREGATE:
-          result.aggregate = transformation.getExpressions().map(this._buildAggregateExpression, this)
-          break
-
-        case TransformationKind.BOTTOM_TOP:
-          result.method = Object.keys(BottomTopMethod).find(
-            name => BottomTopMethod[name] === transformation.getMethod()
-          )
-          result.number = this._buildExpression(transformation.getNumber())
-          result.value = this._buildExpression(transformation.getValue())
-          break
-
-        case TransformationKind.COMPUTE:
-          result.expressions = transformation.getExpressions().map(computeExpression => {
-            return {
-              expression: this._buildExpression(computeExpression.getExpression()),
-              alias: computeExpression.getAlias()
-            }
-          })
-          break
-
-        case TransformationKind.CONCAT:
-          result.sequences = transformation.getSequences().map(this._buildApplyQueryOption, this)
-          break
-
-        case TransformationKind.CUSTOM_FUNCTION:
-          result.function = transformation
-            .getFunction()
-            .getFullQualifiedName()
-            .toString()
-          if (transformation.getParameters()) {
-            result.parameters = transformation.getParameters().map(this._buildParameter, this)
-          }
-          break
-
-        case TransformationKind.EXPAND:
-          result.expand = this._buildExpandQueryOption([transformation.getExpand()])[0]
-          break
-
-        case TransformationKind.FILTER:
-          result.filter = this._buildExpression(transformation.getFilter())
-          break
-
-        case TransformationKind.GROUP_BY:
-          result.items = transformation.getGroupByItems().map(this._buildGroupByItem, this)
-          result.transformations = this._buildApplyQueryOption(transformation.getTransformations())
-          break
-
-        case TransformationKind.ORDER_BY:
-          result.items = this._buildOrderByQueryOption(transformation.getOrderByItems())
-          break
-
-        case TransformationKind.SEARCH:
-          result.search = this._buildExpression(transformation.getSearch())
-          break
-
-        case TransformationKind.SKIP:
-          result.skip = transformation.getSkip()
-          break
-
-        case TransformationKind.TOP:
-          result.top = transformation.getTop()
-          break
-
-        default:
-      }
-      return result
-    })
-  }
-
-  /**
-   * Prepare the provided aggregation expression for serialization.
-   * @param {AggregateExpression} expression the aggregation expression
-   * @returns {Object} the built aggregation expression prepared for serialization
-   * @private
-   */
-  _buildAggregateExpression (expression) {
-    let result = {}
-    if (expression.getPathSegments().length) {
-      result.pathSegments = this._buildPathSegments(expression.getPathSegments())
-    }
-    if (expression.getExpression()) result.expression = this._buildExpression(expression.getExpression())
-    if (expression.getAlias()) result.alias = expression.getAlias()
-    if (expression.getStandardMethod() !== null) {
-      result.standardMethod = Object.keys(AggregateMethod).find(
-        name => AggregateMethod[name] === expression.getStandardMethod()
-      )
-    }
-    if (expression.getCustomMethod()) result.customMethod = expression.getCustomMethod().toString()
-    if (expression.getFrom().length) {
-      result.from = expression.getFrom().map(this._buildAggregateExpression, this)
-    }
-    if (expression.getInlineAggregateExpression()) {
-      result.inlineAggregateExpression = this._buildAggregateExpression(expression.getInlineAggregateExpression())
-    }
-    return result
-  }
-
-  /**
-   * Prepare the provided group-by item for serialization.
-   * @param {GroupByItem} item the group-by item
-   * @returns {Object} the built group-by item prepared for serialization
-   * @private
-   */
-  _buildGroupByItem (item) {
-    let result = {}
-    if (item.getPathSegments().length) result.pathSegments = this._buildPathSegments(item.getPathSegments())
-    if (item.isRollupAll()) result.isRollupAll = true
-    if (item.getRollup().length) result.rollup = item.getRollup().map(this._buildGroupByItem, this)
-    return result
-  }
-  /**
-   * Prepare the provided URI parameter for serialization.
-   * @param {UriParameter} parameter the parameter
-   * @returns {Object} the built parameter prepared for serialization
-   * @private
-   */
-  _buildParameter (parameter) {
-    let result = { name: parameter.getEdmRef().getName() }
-    if (parameter.getText() !== undefined) result.value = parameter.getText()
-    if (parameter.getAlias()) result.alias = parameter.getAlias()
-    if (parameter.getAliasValue()) result.aliasValue = parameter.getAliasValue()
-    if (parameter.getExpression()) result.expression = this._buildExpression(parameter.getExpression())
-    return result
-  }
-
-  /**
-   * Prepare the provided query options for serialization.
-   * @param {Object} queryOptions The query options to build
-   * @param {Object} queryOptions.$filter Odata $filter query option to build
-   * @param {Object} queryOptions.$orderby Odata $orderby query option to build
-   * @param {Object} queryOptions.$search Odata $search query option to build
-   * @returns {Object} The built query options prepared for serialization
-   * @private
-   */
-  _buildQueryOptions (queryOptions) {
-    const result = Object.assign({}, queryOptions)
-
-    if (queryOptions) {
-      if (queryOptions.$apply) result.$apply = this._buildApplyQueryOption(queryOptions.$apply)
-      if (queryOptions.$filter) result.$filter = this._buildExpression(queryOptions.$filter)
-      if (queryOptions.$orderby) result.$orderby = this._buildOrderByQueryOption(queryOptions.$orderby)
-      if (queryOptions.$expand) result.$expand = this._buildExpandQueryOption(queryOptions.$expand)
-      if (queryOptions.$search) result.$search = this._buildExpression(queryOptions.$search)
-      if (queryOptions.$select) result.$select = this._buildSelectQueryOption(queryOptions.$select)
-    }
-
-    return result
-  }
-}
-
-module.exports = DebugJsonSerializer

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

@@ -1,47 +0,0 @@
-'use strict'
-
-const ErrorSerializer = require('./ErrorSerializer')
-
-/**
- * The ErrorJsonSerializer serializes an error to an OData error in JSON format.
- * @extends ErrorSerializer
- */
-class ErrorJsonSerializer extends ErrorSerializer {
-  /**
-   * Serializes the provided error to an OData error in JSON format.
-   * @returns {string} an OData error JSON string
-   */
-  serialize () {
-    function addAnnotations (source, target) {
-      for (const name in source) if (name[0] === '@') target[name] = source[name]
-    }
-
-    let result = {
-      code: this._error.code || 'null',
-      message: this._error.message,
-      target: this._error.target,
-    }
-    // REVISIT: We should also pass stack traces in development
-    // if (!cds.env.production) result.stack = this._error.stack
-
-    if (this._error.details) {
-      result.details = this._error.details.map(d => {
-        let detail = {
-          code: d.code || 'null',
-          message: d.message,
-          target: d.target
-        }
-        addAnnotations(d, detail)
-        return detail
-      })
-    }
-
-    if (this._error.innererror) result.innererror = this._error.innererror
-
-    addAnnotations(this._error, result)
-
-    return JSON.stringify({ error: result })
-  }
-}
-
-module.exports = ErrorJsonSerializer

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

@@ -1,39 +0,0 @@
-'use strict'
-
-const validateThat = require('../../odata-commons').validator.ParameterValidator.validateThat
-
-/**
- * The ErrorSerializer serializes an error to an OData error.
- * @abstract
- */
-class ErrorSerializer {
-  /**
-   * Creates an instance of ErrorSerializer.
-   * @param {Error} error The error to serialize.
-   * @throws {IllegalArgumentError} if the provided error is undefined or does not have the correct structure
-   */
-  constructor (error) {
-    validateThat('error', error).truthy()
-    validateThat('error.message', error.message).typeOf('string')
-    if (error.code) validateThat('error.code', error.code).typeOf('string')
-    if (error.target) validateThat('error.target', error.target).typeOf('string')
-    if (error.details) {
-      validateThat('error.details', error.details)
-        .array()
-        .containsElementsOfType('object')
-      for (let index = 0; index < error.details.length; index++) {
-        validateThat('error.details[' + index + '].message', error.details[index].message).typeOf('string')
-        if (error.details[index].code) {
-          validateThat('error.details[' + index + '].code', error.details[index].code).typeOf('string')
-        }
-        if (error.details[index].target) {
-          validateThat('error.details[' + index + '].target', error.details[index].target).typeOf('string')
-        }
-      }
-    }
-
-    this._error = error
-  }
-}
-
-module.exports = ErrorSerializer

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

@@ -1,98 +0,0 @@
-'use strict'
-
-const ErrorSerializer = require('./ErrorSerializer')
-
-/**
- * The ErrorXmlSerializer serializes an error to an OData error in XML format.
- * @extends ErrorSerializer
- */
-class ErrorXmlSerializer extends ErrorSerializer {
-  /**
-   * Serializes the provided error to an OData error in XML format.
-   * @returns {string} an OData error XML string
-   */
-  serialize () {
-    let result =
-      '<?xml version="1.0" encoding="UTF-8"?>' +
-      '<error xmlns="http://docs.oasis-open.org/odata/ns/metadata">' +
-      '<code>' +
-      this._escapeXmlChars(this._error.code || 'null') +
-      '</code>' +
-      '<message>' +
-      this._escapeXmlChars(this._error.message) +
-      '</message>'
-    if (this._error.target) result += '<target>' + this._escapeXmlChars(this._error.target) + '</target>'
-    if (this._error.details && this._error.details.length) {
-      result += '<details>'
-      for (const detail of this._error.details) {
-        result +=
-          '<detail>' +
-          '<code>' +
-          this._escapeXmlChars(detail.code || 'null') +
-          '</code>' +
-          '<message>' +
-          this._escapeXmlChars(detail.message) +
-          '</message>'
-        if (detail.target) result += '<target>' + this._escapeXmlChars(detail.target) + '</target>'
-        result += this._serializeAnnnotations(detail) + '</detail>'
-      }
-      result += '</details>'
-    }
-    result += this._serializeAnnnotations(this._error) + '</error>'
-    return result
-  }
-
-  /**
-   * Serializes the annotations of an element.
-   * @param {string} element the annnotated element
-   * @returns {string} the serialized annotation
-   * @private
-   */
-  _serializeAnnnotations (element) {
-    let result = ''
-    for (const name in element) {
-      if (name[0] !== '@') continue
-      const value = element[name]
-      if (value !== null && typeof value === 'object') {
-        throw new Error('Only primitive annotation values are supported in error XML serialization')
-      }
-      // "If the type of the annotation value being specified is anything other than
-      // Edm.String the metadata:annotation element MUST contain a metadata:type
-      // attribute to specify the appropriate type of the annotation value."
-      // TODO: Determine the type for string- or number-valued annotation values
-      //       that are not of type 'Edm.String' or 'Edm.Decimal', respectively.
-      let type
-      if (typeof value === 'boolean') type = 'Edm.Boolean'
-      if (typeof value === 'number') type = 'Edm.Decimal'
-      let valueLiteral = value === null ? '' : String(value)
-      if (!type) valueLiteral = this._escapeXmlChars(valueLiteral)
-      result +=
-        '<annotation term="' +
-        name.substring(1) +
-        '"' +
-        (value === null ? ' null="true"' : '') +
-        (type ? ' type="' + type + '"' : '') +
-        '>' +
-        valueLiteral +
-        '</annotation>'
-    }
-    return result
-  }
-
-  /**
-   * Escapes XML characters &,",',<,> with corresponding escapes sequences.
-   * @param {string} input the original string
-   * @returns {string} the modified string
-   * @private
-   */
-  _escapeXmlChars (input) {
-    return input
-      .replace(/&/g, '&amp;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&apos;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-  }
-}
-
-module.exports = ErrorXmlSerializer