@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/utils/UriHelper.js

@@ -1,157 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const CommonsUriHelper = commons.uri.UriHelper
-const AbstractError = commons.errors.AbstractError
-const UriSyntaxError = commons.errors.UriSyntaxError
-const IllegalArgumentError = commons.errors.IllegalArgumentError
-const NotImplementedError = commons.errors.NotImplementedError
-const EdmPrimitiveTypeKind = require('../../odata-commons/edm/EdmPrimitiveTypeKind')
-
-/**
- * UriHelper has utility methods for reading and constructing URIs.
- */
-class UriHelper {
-  /**
-   * Parses the URL query-string parameters. A leading '?' is allowed.
-   * Overloaded parameters will result in an error.
-   *
-   * Example:
-   * Input: '?foo=bar&bar=foo'
-   * Output: { foo: 'bar1', bar: 'foo' }
-   *
-   * @param {string} queryString the query string
-   * @throws {UriSyntaxError} if any parameter is overloaded
-   * @returns {Object} the parsed URL query string represented as key:value pairs
-   */
-  static parseQueryString (queryString) {
-    if (!queryString) return null
-
-    const query = queryString.startsWith('?') ? queryString.substring(1) : queryString
-    try {
-      let result = {}
-      for (const parameter of query.split('&')) {
-        if (!parameter) continue
-        const index = parameter.indexOf('=')
-        const name = decodeURIComponent(index >= 0 ? parameter.substring(0, index) : parameter)
-        if (result[name] !== undefined) {
-          throw new UriSyntaxError(UriSyntaxError.Message.DUPLICATED_OPTION, name)
-        }
-        result[name] = index >= 0 ? decodeURIComponent(parameter.substring(index + 1, parameter.length)) : ''
-      }
-      return result
-    } catch (error) {
-      throw new AbstractError(AbstractError.ErrorNames.URI_SYNTAX, 'wrong percent encoding in query string', error)
-    }
-  }
-
-  /**
-   * Builds an abstract output structure for a given array of UriParameter. The structure would look like
-   * [
-   *  { type: <type of property>, name: <name of key property>, value: <value of key> },
-   *  ...
-   * ]
-   *
-   * @param {UriParameter[]} keyPredicates The array of UriParameter
-   * @returns {Object[]} The key predicates
-   */
-  static buildKeyPredicates (keyPredicates) {
-    if (!Array.isArray(keyPredicates)) return []
-
-    return keyPredicates.map(elem => {
-      const edmRef = elem.getEdmRef()
-      return {
-        type: edmRef.getProperty().getType(),
-        name: edmRef.getAlias() || edmRef.getName(),
-        value: elem.getText()
-      }
-    })
-  }
-
-  /**
-   * Build an array of objects with names, types, and values of the keys of an entity.
-   * @param {EdmEntityType} edmEntityType the entity type
-   * @param {Object} entity the entity
-   * @param {PrimitiveValueEncoder} primitiveValueEncoder the encoder for primitive values
-   * @returns {Object[]} the keys
-   * @throws {IllegalArgumentError} if the key properties in edmEntityType do not match the keys in entity
-   */
-  static buildEntityKeys (edmEntityType, entity, primitiveValueEncoder) {
-    let keys = []
-    for (const [name, keyPropertyRef] of edmEntityType.getKeyPropertyRefs()) {
-      let value = entity
-      const property = keyPropertyRef.getProperty()
-      for (const pathElement of keyPropertyRef.getName().split('/')) {
-        value = value[pathElement]
-        if (value === undefined && name !== 'IsActiveEntity') {
-          throw new IllegalArgumentError(`The key '${pathElement}' does not exist in the given entity`)
-        }
-      }
-      if (value === undefined && name === 'IsActiveEntity') continue
-      value = primitiveValueEncoder.encodeText(value, property)
-      keys.push({ type: property.getType(), name, value })
-    }
-    return keys
-  }
-
-  /**
-   * Build the key as string out of key information in URI form, including parentheses.
-   * @param {Object[]} keys the keys of the entity as array of objects with name, value, and type
-   * @returns {string} the key
-   */
-  static buildKeyString (keys) {
-    let url
-
-    for (const key of keys) {
-      url = url ? url + ',' : ''
-      if (keys.length > 1) url += encodeURIComponent(key.name) + '='
-      url += key.type === EdmPrimitiveTypeKind.Binary
-        ? CommonsUriHelper.toUriLiteral(key.value, key.type)
-        : encodeURIComponent(CommonsUriHelper.toUriLiteral(key.value, key.type))
-    }
-    return '(' + url + ')'
-  }
-
-  /**
-   * Build the canonical URL of an entity.
-   * @param {UriResource[]} pathSegments the path segments leading to the entity
-   * @param {Object[]} keys the keys of the entity as array of objects with name, value, and type
-   * @returns {string} the canonical URL
-   */
-  static buildCanonicalUrl (pathSegments, keys) {
-    let result = ''
-    let isCollection
-    for (const pathSegment of pathSegments) {
-      if (pathSegment.getEntitySet()) {
-        result = encodeURIComponent(pathSegment.getEntitySet().getName())
-        isCollection = true
-      } else if (pathSegment.getSingleton()) {
-        result = encodeURIComponent(pathSegment.getSingleton().getName())
-      } else if (pathSegment.getTarget()) {
-        result = encodeURIComponent(pathSegment.getTarget().getName())
-        isCollection = true
-      } else if (pathSegment.getNavigationProperty() && pathSegment.getNavigationProperty().containsTarget()) {
-        result += '/' + encodeURIComponent(pathSegment.getNavigationProperty().getName())
-        isCollection = pathSegment.isCollection()
-      } else if (pathSegment.getFunction()) {
-        throw new NotImplementedError(
-          'Determination of the canonical URL for the result of a ' +
-            'function import or of a bound function without entity-set definition is not supported.'
-        )
-      }
-      if (
-        pathSegment.getKeyPredicates().length &&
-        // With referential constraints, some key predicates can be omitted.
-        // In that case, we rely on the key values provided with the data.
-        pathSegment.getKeyPredicates().length === pathSegment.getEdmType().getKeyPropertyRefs().size
-      ) {
-        result += UriHelper.buildKeyString(UriHelper.buildKeyPredicates(pathSegment.getKeyPredicates()))
-        isCollection = false
-      }
-    }
-    if (isCollection) result += UriHelper.buildKeyString(keys)
-    return result
-  }
-}
-
-module.exports = UriHelper

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/validator/ConditionalRequestValidator.js

@@ -1,79 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const HttpMethods = commons.http.HttpMethod.Methods
-const ResourceKinds = commons.uri.UriResource.ResourceKind
-const PreconditionFailedError = require('../errors/PreconditionFailedError')
-const PreconditionRequiredError = require('../errors/PreconditionRequiredError')
-
-/**
- * Class to validate conditional requests.
- */
-class ConditionalRequestValidator {
-  /**
-   * Pre-validate a request.
-   * @param {string} ifMatch the value of the If-Match HTTP header
-   * @param {string} ifNoneMatch the value of the If-None-Match HTTP header
-   * @param {HttpMethod.Methods} method the HTTP method
-   * @param {boolean} isConcurrentResource if the request is for a concurrent resource
-   * @throws {PreconditionRequiredError} if a conditional HTTP header is required but not there
-   * @throws {ConflictError} if a conditional HTTP header is set but the resource is not concurrent
-   */
-  preValidate (ifMatch, ifNoneMatch, method, isConcurrentResource) {
-    if (isConcurrentResource) {
-      if (method !== HttpMethods.GET && !ifMatch && !ifNoneMatch) throw new PreconditionRequiredError()
-      return
-    }
-  }
-
-  /**
-   * Validate the ETag for the given request.
-   * @param {string} ifMatch the value of the If-Match HTTP header
-   * @param {string} ifNoneMatch the value of the If-None-Match HTTP header
-   * @param {HttpMethod.Methods} method the HTTP method
-   * @param {UriResource.ResourceKind} kind the kind of the addressed resource
-   * @param {string} etag the ETag provided by the handler implementation
-   * @returns {boolean} true if the result of the validation is "not modified", otherwise false
-   * @throws {PreconditionFailedError} if the validation failed
-   */
-  validateEtag (ifMatch, ifNoneMatch, method, kind, etag) {
-    const ifMatchEtags = ifMatch ? this._parseHeaderEtagValue(ifMatch) : []
-    const ifNoneMatchEtags = ifNoneMatch ? this._parseHeaderEtagValue(ifNoneMatch) : []
-
-    if (ifMatch && !ifMatchEtags.includes(etag) && !ifMatchEtags.includes('*')) throw new PreconditionFailedError()
-
-    if (
-      method !== HttpMethods.GET &&
-      method !== HttpMethods.HEAD &&
-      (ifNoneMatchEtags.includes(etag) ||
-        (ifNoneMatchEtags.includes('*') &&
-          ![HttpMethods.PUT, HttpMethods.PATCH].includes(method) &&
-          kind !== ResourceKinds.BOUND_ACTION))
-    ) {
-      throw new PreconditionFailedError()
-    }
-
-    return Boolean(
-      (method === HttpMethods.GET || method === HttpMethods.HEAD) &&
-        ifNoneMatch &&
-        (ifNoneMatchEtags.includes('*') || ifNoneMatchEtags.includes(etag))
-    )
-  }
-
-  /**
-   * Parse the ETags in an HTTP header.
-   * @param {string} value the value of the HTTP header
-   * @returns {string[]} the parsed ETag values
-   * @private
-   */
-  _parseHeaderEtagValue (value) {
-    return value.split(',').map(str => {
-      let result = str.trim()
-      if (result === '*') return result
-      if (result.startsWith('W/')) result = result.substring(2)
-      return result.startsWith('"') && result.endsWith('"') ? result.substring(1, result.length - 1) : null
-    })
-  }
-}
-
-module.exports = ConditionalRequestValidator

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/validator/OperationValidator.js

@@ -1,199 +0,0 @@
-'use strict'
-
-const commons = require('../../odata-commons')
-const HttpMethods = commons.http.HttpMethod.Methods
-const UriResource = commons.uri.UriResource
-const ResourceKinds = UriResource.ResourceKind
-const FeatureSupport = commons.FeatureSupport
-const NotImplementedError = commons.errors.NotImplementedError
-const MethodNotAllowedError = require('../errors/MethodNotAllowedError')
-const BadRequestError = require('../errors/BadRequestError')
-
-/**
- * White list of the allowed HTTP requests for each defined resource kind.
- * @type {Map.<UriResource.ResourceKind, Map.<HttpMethods, boolean>>}
- * @private
- */
-const whiteList = new Map()
-  .set(ResourceKinds.SERVICE, new Map().set(HttpMethods.GET, true).set(HttpMethods.HEAD, true))
-  .set(ResourceKinds.METADATA, new Map().set(HttpMethods.GET, true).set(HttpMethods.HEAD, false))
-
-  .set(ResourceKinds.BATCH, new Map().set(HttpMethods.POST, true))
-  .set(ResourceKinds.CROSSJOIN, new Map().set(HttpMethods.GET, FeatureSupport.features.CrossJoin))
-  .set(ResourceKinds.ALL, new Map().set(HttpMethods.GET, FeatureSupport.features.All))
-  .set(
-    ResourceKinds.ENTITY_ID,
-    new Map()
-      .set(HttpMethods.GET, FeatureSupport.features.Entity_id)
-      .set(HttpMethods.PUT, FeatureSupport.features.Entity_id)
-      .set(HttpMethods.PATCH, FeatureSupport.features.Entity_id)
-      .set(HttpMethods.DELETE, FeatureSupport.features.Entity_id)
-  )
-  .set(
-    ResourceKinds.ENTITY,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.PATCH, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(ResourceKinds.ENTITY_COLLECTION, new Map().set(HttpMethods.GET, true).set(HttpMethods.POST, true))
-  .set(
-    ResourceKinds.SINGLETON,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.PATCH, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(
-    ResourceKinds.NAVIGATION_TO_ONE,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.PATCH, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(ResourceKinds.NAVIGATION_TO_MANY, new Map().set(HttpMethods.GET, true).set(HttpMethods.POST, true))
-
-  .set(ResourceKinds.COUNT, new Map().set(HttpMethods.GET, true))
-  .set(
-    ResourceKinds.REF,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(
-    ResourceKinds.REF_COLLECTION,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.POST, true)
-      .set(HttpMethods.DELETE, FeatureSupport.features.Ref)
-  )
-  .set(
-    ResourceKinds.VALUE,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.DELETE, true)
-  )
-
-  .set(
-    ResourceKinds.PRIMITIVE_PROPERTY,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(
-    ResourceKinds.COMPLEX_PROPERTY,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.PATCH, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(
-    ResourceKinds.PRIMITIVE_COLLECTION_PROPERTY,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.DELETE, true)
-  )
-  .set(
-    ResourceKinds.COMPLEX_COLLECTION_PROPERTY,
-    new Map()
-      .set(HttpMethods.GET, true)
-      .set(HttpMethods.PUT, true)
-      .set(HttpMethods.DELETE, true)
-  )
-
-  // modification should be done through canonical resource path
-  .set(ResourceKinds.TYPE_CAST, new Map().set(HttpMethods.GET, FeatureSupport.features.TypeCast))
-
-  .set(ResourceKinds.FUNCTION_IMPORT, new Map().set(HttpMethods.GET, true))
-  .set(ResourceKinds.BOUND_FUNCTION, new Map().set(HttpMethods.GET, true))
-
-  .set(ResourceKinds.ACTION_IMPORT, new Map().set(HttpMethods.POST, true))
-  .set(ResourceKinds.BOUND_ACTION, new Map().set(HttpMethods.POST, true))
-
-class OperationValidator {
-  /**
-   * Creates an instance of OperationValidator.
-   * @param {LoggerFacade} logger the logger
-   */
-  constructor (logger) {
-    this._logger = logger
-  }
-
-  /**
-   * Proves the given HTTP method against the given path segments.
-   *
-   * The last path segment is checked against a defined white list.
-   * If a request on a specific resource kind is not found, then this method throws a MethodNotAllowedError.
-   * If it is found with a value not "true", it throws a NotImplementedError.
-   *
-   * If the HTTP method is DELETE, it is checked whether the delete operation is on a
-   * not nullable property or property value. If yes, a Bad Request error is thrown.
-   *
-   * If the HTTP method is not GET and the last segment is "$ref", it is checked that the previous segment is a
-   * navigation; otherwise a MethodNotAllowedError is thrown.
-   *
-   * If all checks are passed, this method returns true.
-   *
-   * @param {HttpMethod.Methods|string} httpMethod the HTTP method
-   * @param {UriResource[]} pathSegments the URI path segments
-   * @returns {boolean} whether the HTTP method is valid for the path segments
-   */
-  validate (httpMethod, pathSegments) {
-    const length = pathSegments.length
-    const lastSegmentResourceKind = pathSegments[length - 1].getKind()
-
-    const allowedResKind = whiteList.get(lastSegmentResourceKind)
-    if (!allowedResKind) throw new Error('Unknown resource kind ' + lastSegmentResourceKind)
-
-    const allowedHttpMethod = allowedResKind.get(httpMethod)
-    if (allowedHttpMethod === undefined) {
-      throw new MethodNotAllowedError('Method ' + httpMethod + ' not allowed for ' + lastSegmentResourceKind)
-    } else if (allowedHttpMethod === false) {
-      throw new NotImplementedError()
-    } else if (allowedHttpMethod !== true) {
-      FeatureSupport.failUnsupported(allowedHttpMethod)
-    }
-
-    if (httpMethod === HttpMethods.DELETE) {
-      if (
-        (lastSegmentResourceKind === ResourceKinds.VALUE && !pathSegments[length - 2].getProperty().isNullable()) ||
-        ((lastSegmentResourceKind === ResourceKinds.PRIMITIVE_PROPERTY ||
-          lastSegmentResourceKind === ResourceKinds.COMPLEX_PROPERTY) &&
-          !pathSegments[length - 1].getProperty().isNullable())
-      ) {
-        throw new BadRequestError("Can't DELETE a non-nullable value.")
-      }
-    }
-
-    if (httpMethod !== HttpMethods.GET) {
-      if (
-        (lastSegmentResourceKind === ResourceKinds.REF || lastSegmentResourceKind === ResourceKinds.REF_COLLECTION) &&
-        !pathSegments[length - 2].getNavigationProperty()
-      ) {
-        throw new MethodNotAllowedError("Modification requests on '$ref' are only allowed on navigation.")
-      }
-    }
-
-    if (
-      httpMethod === HttpMethods.PUT &&
-      lastSegmentResourceKind === ResourceKinds.REF &&
-      pathSegments[length - 2].getNavigationProperty().isCollection()
-    ) {
-      throw new MethodNotAllowedError(
-        "Update requests on '$ref' are only allowed on non-collection navigation properties."
-      )
-    }
-
-    return true
-  }
-}
-
-module.exports = OperationValidator