@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/cds-services/adapter/odata-v4/odata-to-cqn/applyToCQN.js

@@ -1,243 +0,0 @@
-const odata = require('../okra/odata-server')
-const ResourceKind = odata.uri.UriResource.ResourceKind
-const TransformationKind = odata.uri.Transformation.TransformationKind
-const ExpressionKind = odata.uri.Expression.ExpressionKind
-const StandardMethod = odata.uri.AggregateExpression.StandardMethod
-const BottomTopMethod = odata.uri.BottomTopTransformation.Method
-
-const ExpressionToCQN = require('./ExpressionToCQN')
-const { getFeatureNotSupportedError } = require('../../../util/errors')
-
-const AGGREGATION_METHODS = {
-  [StandardMethod.SUM]: x => `sum(${x})`,
-  [StandardMethod.MIN]: x => `min(${x})`,
-  [StandardMethod.MAX]: x => `max(${x})`,
-  [StandardMethod.AVERAGE]: x => `avg(${x})`,
-  [StandardMethod.COUNT_DISTINCT]: x => `count(distinct ${x})`
-}
-
-const BOTTOMTOP_METHODS = {
-  [BottomTopMethod.TOP_COUNT]: (x, y) => `topcount(${x},${y})`,
-  [BottomTopMethod.BOTTOM_COUNT]: (x, y) => `bottomcount(${x},${y})`
-}
-
-const AGGREGATION_DEFAULT = '@Aggregation.default'
-
-const _createNavGroupBy = pathSegments => {
-  let name = pathSegments[0].getNavigationProperty().getName()
-  for (let i = 1; i < pathSegments.length; i++) {
-    name += pathSegments[i].getProperty()
-      ? '.' + pathSegments[i].getProperty().getName()
-      : '.' + pathSegments[i].getNavigationProperty().getName()
-  }
-  return name
-}
-
-const _getColumnName = expression => {
-  if (expression.getKind() === ExpressionKind.MEMBER) {
-    const pathSegments = expression.getPathSegments()
-
-    if (pathSegments[0].getKind() === 'COMPLEX.PROPERTY') {
-      return _complexProperty(pathSegments)
-    }
-    return pathSegments[0].getNavigationProperty()
-      ? _createNavGroupBy(pathSegments)
-      : pathSegments[0].getProperty().getName()
-  }
-  throw getFeatureNotSupportedError(`Expression ${expression.getKind()} with query option $apply`)
-}
-
-const _checkAggregateExpression = aggregateExpression => {
-  if (
-    aggregateExpression.getInlineAggregateExpression() ||
-    aggregateExpression.getFrom().length ||
-    (aggregateExpression.getPathSegments().length &&
-      aggregateExpression.getPathSegments()[0].getKind() !== ResourceKind.COUNT)
-  ) {
-    throw getFeatureNotSupportedError('Only simple aggregate expressions are supported with query option $apply')
-  }
-}
-
-const _addAggregation = aggregateExpression => {
-  const columnName = _getColumnName(aggregateExpression.getExpression())
-  const aggregate = AGGREGATION_METHODS[aggregateExpression.getStandardMethod()]
-  if (!aggregate) throw new Error('Unsupported aggregate function: ' + aggregateExpression.getStandardMethod())
-  const aggregation = aggregate(columnName)
-  const alias = aggregateExpression.getAlias()
-  if (alias) {
-    const column = {}
-    column[aggregation] = alias
-    return column
-  } else {
-    return aggregation
-  }
-}
-
-const _addCount = aggregateExpression => {
-  const alias = aggregateExpression.getAlias()
-  if (alias) {
-    return { 'count(1)': alias }
-  } else {
-    return 'count(1)'
-  }
-}
-
-const _createColumnsForAggregateExpressions = (aggregateExpressions, entity) => {
-  const columns = []
-  let defaultAggregation
-  for (const aggregateExpression of aggregateExpressions) {
-    // custom aggregates
-    if (aggregateExpression.getPathSegments() && aggregateExpression.getPathSegments().length === 1) {
-      const name =
-        aggregateExpression.getPathSegments()[0].getProperty() &&
-        aggregateExpression.getPathSegments()[0].getProperty().getName()
-      if (
-        name &&
-        entity[`@Aggregation.CustomAggregate#${name}`] &&
-        entity.elements[name] &&
-        entity.elements[name][AGGREGATION_DEFAULT] &&
-        entity.elements[name][AGGREGATION_DEFAULT]['#']
-      ) {
-        defaultAggregation = entity.elements[name][AGGREGATION_DEFAULT]['#'].toLowerCase()
-        if (defaultAggregation === 'count_distinct') defaultAggregation = 'countdistinct'
-        columns.push({ [`${defaultAggregation}(${name})`]: name })
-        continue
-      }
-    }
-
-    _checkAggregateExpression(aggregateExpression)
-    if (aggregateExpression.getExpression() && aggregateExpression.getStandardMethod() !== null) {
-      columns.push(_addAggregation(aggregateExpression))
-    } else {
-      // checked in checkAggregateExpression to be ResourceKind.COUNT
-      columns.push(_addCount(aggregateExpression))
-    }
-  }
-  return columns
-}
-
-const _addAggregationToResult = (transformation, entity, result) => {
-  const expressions = transformation.getExpressions()
-
-  if (expressions.length) {
-    result.aggregations = result.aggregations || []
-    result.aggregations.push(..._createColumnsForAggregateExpressions(expressions, entity))
-  }
-}
-
-const _methodName = transformation => {
-  if (transformation.constructor.Method) {
-    for (const method in transformation.constructor.Method) {
-      if (transformation.getMethod() === transformation.constructor.Method[method]) {
-        return method
-      }
-    }
-  }
-  return transformation.getMethod() // old behaviour if no method can be found
-}
-
-const _addBottomTopTransformation = (transformation, result, withGroupBy) => {
-  const method = transformation.getMethod()
-
-  if (!BOTTOMTOP_METHODS[method]) {
-    throw getFeatureNotSupportedError(`Transformation "${_methodName(transformation)}" with query option $apply`)
-  } else if (!withGroupBy) {
-    result.orderBy = []
-    result.orderBy.push({
-      [_getColumnName(transformation.getValue())]: method === BottomTopMethod.TOP_COUNT ? 'desc' : 'asc'
-    })
-    result.limit = { top: transformation.getNumber().getText() }
-  } else {
-    result.bottomTop = result.bottomTop || []
-    const bottomTop = BOTTOMTOP_METHODS[method]
-    result.bottomTop.push(bottomTop(transformation.getNumber().getText(), _getColumnName(transformation.getValue())))
-  }
-}
-
-const _handleTransformation = (transformation, entity, res) => {
-  if (transformation.getTransformations()[0].getKind() === TransformationKind.AGGREGATE) {
-    _addAggregationToResult(transformation.getTransformations()[0], entity, res)
-  } else if (transformation.getTransformations()[0].getKind() === TransformationKind.BOTTOM_TOP) {
-    _addBottomTopTransformation(transformation.getTransformations()[0], res, true)
-  } else {
-    throw getFeatureNotSupportedError(
-      `Transformation "${_methodName(transformation.getTransformations()[0])}" with query option $apply`
-    )
-  }
-}
-
-function _complexProperty(pathSegments) {
-  const name = []
-  for (const pathSegment of pathSegments) {
-    if (pathSegment.getProperty()) {
-      name.push(pathSegment.getProperty().getName())
-    } else if (pathSegment.getNavigationProperty()) {
-      // future support for assocs in structured
-      // TODO
-    }
-  }
-  return name.join('.')
-}
-
-/**
- * Add odata apply to a CQN object.
- *
- * @param {Array<import('../okra/odata-commons/uri/apply/Transformation')>} transformations - odata-v4 transformation object
- * @param {object} entity - csn entity targeted by the request
- * @param {object} model - reflected model
- *
- * @private
- */
-const applyToCQN = (transformations, entity, model) => {
-  const res = {}
-  for (const transformation of transformations) {
-    switch (transformation.getKind()) {
-      case TransformationKind.GROUP_BY:
-        res.groupBy = []
-        if (transformation.getTransformations().length) {
-          _handleTransformation(transformation, entity, res)
-        }
-        for (const item of transformation.getGroupByItems()) {
-          const pathSegment = item.getPathSegments().length > 0 && item.getPathSegments()[0]
-          if (!pathSegment) {
-            throw getFeatureNotSupportedError(
-              'Transformation "groupby" with query option $apply does not support this request'
-            )
-          }
-          if (pathSegment.getKind() === 'COMPLEX.PROPERTY') {
-            throw getFeatureNotSupportedError(
-              'Transformation "groupby" with query option $apply does not support complex properties'
-            )
-            // TODO support annotations Groupable
-            // Odata spec: http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/cs01/odata-data-aggregation-ext-v4.0-cs01.html#_Toc378326318
-            // res.groupBy.push(_complexProperty(item.getPathSegments()))
-          } else if (pathSegment.getProperty()) {
-            const name = item.getPathSegments()[0].getProperty().getName()
-            res.groupBy.push(name)
-          } else if (pathSegment.getNavigationProperty()) {
-            res.groupBy.push(_createNavGroupBy(item.getPathSegments()))
-          }
-        }
-        break
-      case TransformationKind.AGGREGATE:
-        _addAggregationToResult(transformation, entity, res)
-        break
-      case TransformationKind.FILTER:
-        res.filter = new ExpressionToCQN(entity, model).parse(transformation.getFilter())
-        break
-      case TransformationKind.BOTTOM_TOP:
-        _addBottomTopTransformation(transformation, res)
-        break
-      default: {
-        const numericKind = transformation.getKind()
-        // eslint-disable-next-line no-unused-vars
-        const stringKind = Object.entries(TransformationKind).find(([_, v]) => v === numericKind)?.[0]
-        throw getFeatureNotSupportedError(`Transformation "${stringKind || numericKind}" with query option $apply`)
-      }
-    }
-  }
-
-  return res
-}
-
-module.exports = applyToCQN

package/libx/_runtime/cds-services/adapter/odata-v4/odata-to-cqn/boundToCQN.js

@@ -1,43 +0,0 @@
-const cds = require('../../../../cds')
-const { SELECT } = cds.ql
-
-const { convertUrlPathToCqn, isPathSupported } = require('./utils')
-
-const {
-  BOUND_ACTION,
-  BOUND_FUNCTION,
-  COUNT,
-  ENTITY,
-  ENTITY_COLLECTION,
-  NAVIGATION_TO_MANY,
-  NAVIGATION_TO_ONE,
-  PRIMITIVE_PROPERTY,
-  SINGLETON
-} = require('../okra/odata-server').uri.UriResource.ResourceKind
-
-const SUPPORTED_SEGMENT_KINDS = {
-  [BOUND_ACTION]: 1,
-  [BOUND_FUNCTION]: 1,
-  [COUNT]: 1,
-  [ENTITY]: 1,
-  [ENTITY_COLLECTION]: 1,
-  [NAVIGATION_TO_ONE]: 1,
-  [NAVIGATION_TO_MANY]: 1,
-  [PRIMITIVE_PROPERTY]: 1,
-  [SINGLETON]: 1
-}
-
-/**
- * Transform odata bound action or functiuon request into a CQN object.
- *
- * @param {object} odataReq - An odata request.
- * @private
- */
-const boundToCQN = (service, odataReq) => {
-  const segments = odataReq.getUriInfo().getPathSegments()
-  isPathSupported(SUPPORTED_SEGMENT_KINDS, segments)
-
-  return SELECT.from(convertUrlPathToCqn(segments.slice(0, segments.length - 1), service))
-}
-
-module.exports = boundToCQN

package/libx/_runtime/cds-services/adapter/odata-v4/odata-to-cqn/createToCQN.js

@@ -1,37 +0,0 @@
-const cds = require('../../../../cds')
-const { INSERT } = cds.ql
-
-const { getFeatureNotSupportedError } = require('../../../util/errors')
-const { convertUrlPathToCqn } = require('./utils')
-
-const { ENTITY, SINGLETON, NAVIGATION_TO_ONE } = require('../okra/odata-server').uri.UriResource.ResourceKind
-
-const UPSERT_KINDS = {
-  [ENTITY]: 1,
-  [SINGLETON]: 1,
-  [NAVIGATION_TO_ONE]: 1
-}
-
-/**
- * Transform odata CREATE request into a CQN object.
- *
- * @param {object} target
- * @param {object | Array} data
- * @param {object} odataReq - OKRA's req
- * @param {boolean} upsert - CREATE on PUT/PATCH
- * @throw Error - if invalid segments are provided in request
- * @private
- */
-const createToCQN = (service, target, data, odataReq, upsert) => {
-  const segments = odataReq.getUriInfo().getPathSegments()
-  const lastSegment = odataReq.getUriInfo().getLastSegment()
-
-  const kind = lastSegment.getKind()
-  if (kind === 'ENTITY.COLLECTION' || kind === 'NAVIGATION.TO.MANY' || (upsert && UPSERT_KINDS[kind])) {
-    return INSERT.into(convertUrlPathToCqn(segments, service)).entries(data)
-  }
-
-  throw getFeatureNotSupportedError(`INSERT of kind "${lastSegment.getKind()}"`)
-}
-
-module.exports = createToCQN

package/libx/_runtime/cds-services/adapter/odata-v4/odata-to-cqn/deleteToCQN.js

@@ -1,36 +0,0 @@
-const cds = require('../../../../cds')
-const { UPDATE, DELETE } = cds.ql
-
-const { getFeatureNotSupportedError } = require('../../../util/errors')
-const { convertUrlPathToCqn } = require('./utils')
-
-const { ENTITY, NAVIGATION_TO_ONE, SINGLETON } = require('../okra/odata-server').uri.UriResource.ResourceKind
-
-const SUPPORTED_KINDS = {
-  [ENTITY]: 1,
-  [SINGLETON]: 1,
-  [NAVIGATION_TO_ONE]: 1
-}
-
-/**
- * Transform odata DELETE request into a CQN object.
- *
- * @param {object} odataReq - OKRA's req
- * @throws Error - If invalid path segment provided
- * @private
- */
-const deleteToCQN = (service, odataReq) => {
-  const segments = odataReq.getUriInfo().getPathSegments()
-  const segment = segments[segments.length - 1]
-
-  if (SUPPORTED_KINDS[segment.getKind()]) {
-    return DELETE.from(convertUrlPathToCqn(segments, service))
-  }
-  if (segment.getKind() === 'PRIMITIVE.PROPERTY') {
-    return UPDATE(convertUrlPathToCqn(segments, service)).data({ [segment.getProperty().getName()]: null })
-  }
-
-  throw getFeatureNotSupportedError(`DELETE of kind "${segment.getKind()}"`)
-}
-
-module.exports = deleteToCQN

package/libx/_runtime/cds-services/adapter/odata-v4/odata-to-cqn/expandToCQN.js

@@ -1,250 +0,0 @@
-const cds = require('../../../../cds')
-const { SELECT } = cds.ql
-
-const {
-  QueryOptions,
-  edm: { EdmTypeKind }
-} = require('../okra/odata-server')
-
-const { getFeatureNotSupportedError } = require('../../../util/errors')
-const orderByToCQN = require('./orderByToCQN')
-const ExpressionToCQN = require('./ExpressionToCQN')
-const { getColumns } = require('../../../../common/utils/columns')
-const { addLimit, isSameArray } = require('./utils')
-const { findCsnTargetFor } = require('../../../../common/utils/csn')
-const getError = require('../../../../common/error')
-/**
- * Check which element(s) of the entity has been expanded.
- *
- * @param isAll
- * @param {Array} expandItems
- * @param name
- * @returns {Array | null}
- * @private
- */
-const _getExpandItem = (isAll, expandItems, name) => {
-  if (isAll) return null
-
-  return expandItems.find(item => {
-    const pathSegments = item.getPathSegments()
-    if (pathSegments[pathSegments.length - 1].getKind() === 'COUNT') {
-      throw getError(501, '"/$count" is not supported for expand operation')
-    }
-
-    const navigation = pathSegments[pathSegments.length - 1].getNavigationProperty()
-    return navigation && navigation.getName() === name
-  })
-}
-
-/**
- * Check if not supported function is used and if so, throw an error.
- *
- * @param expandItem
- * @private
- */
-const _notSupported = expandItem => {
-  if (!expandItem) return
-
-  if (expandItem.getOption(QueryOptions.COUNT)) {
-    throw getFeatureNotSupportedError(`Expand with query option "${QueryOptions.COUNT}"`)
-  }
-
-  if (expandItem.getOption(QueryOptions.SEARCH)) {
-    throw getFeatureNotSupportedError(`Expand with query option "${QueryOptions.SEARCH}"`)
-  }
-}
-
-/**
- * No lookup at the CSN needed. Get columns from target.
- *
- * @param targetType
- * @param relatedEntity
- * @param all
- * @returns {Array}
- * @private
- */
-const _getColumnsFromTargetType = (targetType, relatedEntity, all = false) => {
-  if (!targetType || targetType.getKind() !== EdmTypeKind.ENTITY) {
-    return []
-  }
-
-  if (all) {
-    return getColumns(relatedEntity, { onlyNames: true, removeIgnore: true, filterDraft: false })
-      .filter(column => column !== 'DraftAdministrativeData_DraftUUID')
-      .map(column => ({
-        ref: [column]
-      }))
-  }
-
-  const columnNames = []
-
-  const keyNames = Object.keys(relatedEntity.keys).filter(keyName => {
-    const key = relatedEntity.keys[keyName]
-    return !key.is2one && !key.is2many
-  })
-
-  columnNames.push(...keyNames)
-  return columnNames.map(element => ({ ref: [element] }))
-}
-
-const _getInnerSelect = expandItem => {
-  if (!expandItem) return []
-  return expandItem.getOption(QueryOptions.SELECT) || []
-}
-
-const _isProxy = (service, targetType, relatedEntity) => {
-  // REVISIT still not perfect solution
-  if (!cds.env.effective.odata.proxies && !cds.env.effective.odata.xrefs) return
-  // proxy => target entity not exposed in service (model.namespace)
-  if (targetType.getName() in service.entities()) return
-  for (const key of targetType.getProperties().keys()) {
-    if (!relatedEntity.keys[key]) return
-  }
-  return true
-}
-
-/**
- * Get the selected columns and navigation paths.
- *
- * @param expandItem
- * @param targetType
- * @param relatedEntity
- * @returns {Array}
- * @private
- */
-const _getSelectedElements = (expandItem, targetType, service, options) => {
-  const { name: entityName, namespace } = targetType.getFullQualifiedName()
-
-  // autoexposed entities now used . in csn and _ in edm
-  const relatedEntity = findCsnTargetFor(entityName, service.model, namespace)
-  // proxy target?
-  if (_isProxy(service, targetType, relatedEntity)) {
-    return _getColumnsFromTargetType(targetType, relatedEntity)
-  }
-
-  let innerSelectItems = _getInnerSelect(expandItem)
-
-  if (innerSelectItems.length === 0 || innerSelectItems.some(item => item.isAll())) {
-    // REVISIT: Remove once we clean up our draft handling
-    if (options && options.rewriteAsterisks) return _getColumnsFromTargetType(targetType, relatedEntity, true)
-    return ['*']
-  }
-
-  // remove navigations from select clause
-  innerSelectItems = innerSelectItems.filter(item => {
-    // check only last segment, could be complex type
-    return !_getNavigationProperty(item.getPathSegments())
-  })
-
-  const selectedPaths = _getColumnsFromTargetType(targetType, relatedEntity)
-
-  for (const selectItem of innerSelectItems) {
-    const selectRef = { ref: [] }
-    for (const segment of selectItem.getPathSegments()) {
-      selectRef.ref.push(segment.getPathSegmentIdentifier())
-    }
-
-    // don't add already existing refs
-    if (selectedPaths.some(ref => isSameArray(ref.ref, selectRef.ref))) {
-      continue
-    }
-
-    if (selectRef.ref.length) {
-      selectedPaths.push(selectRef)
-    }
-  }
-
-  return selectedPaths
-}
-
-const _filter = (item, expression) => {
-  if (!expression) return
-  const expressionToCQN = new ExpressionToCQN()
-  item.where = SELECT.from('a').where(expressionToCQN.parse(expression)).SELECT.where
-}
-
-const _getItemCQN = (service, name, navigationProperty, expandItem, options) => {
-  _notSupported(expandItem)
-
-  const targetType = navigationProperty.getEntityType()
-
-  const expand = _getSelectedElements(expandItem, targetType, service, options)
-  const item = {
-    ref: name, // ['structured', 'nested_', nestedAssocToOne] if expand on structured
-    expand
-  }
-
-  if (!expandItem) {
-    // $expand=* can't have own query options -> no limit, orderBy, etc. needed
-    return item
-  }
-
-  item.expand.push(...expandToCQN(expandItem.getOption(QueryOptions.EXPAND), targetType, service, options))
-
-  const orderBy = expandItem.getOption(QueryOptions.ORDERBY)
-  if (orderBy) {
-    orderByToCQN(item, orderBy)
-  }
-
-  const top = expandItem.getOption(QueryOptions.TOP)
-  if (navigationProperty.isCollection())
-    addLimit(item, top != null ? top : null, expandItem.getOption(QueryOptions.SKIP) || 0)
-
-  _filter(item, expandItem.getOption(QueryOptions.FILTER))
-  return item
-}
-
-const _getNavigationProperty = pathSegments => {
-  if (pathSegments.length === 0) return
-  return pathSegments[pathSegments.length - 1].getNavigationProperty()
-}
-
-const _name = expandItem =>
-  expandItem
-    .getPathSegments()
-    .map(
-      item =>
-        (item.getProperty() && item.getProperty().getName()) ||
-        (item.getNavigationProperty() && item.getNavigationProperty().getName())
-    )
-
-/**
- * Convert odata-v4 expand to into argument for query API.
- *
- * @param model
- * @param expandItems
- * @param type
- * @returns {Array}
- */
-const expandToCQN = (expandItems, type, service, options) => {
-  if (!expandItems || !expandItems.length) return []
-
-  const allElements = []
-  const isAll = expandItems.some(item => item.isAll())
-
-  for (const [name, navigationProperty] of type.getNavigationProperties()) {
-    const expandItem = _getExpandItem(isAll, expandItems, name)
-
-    if (isAll || expandItem) {
-      const itemCQN = _getItemCQN(service, [name], navigationProperty, expandItem, options)
-      allElements.push(itemCQN)
-    }
-  }
-
-  // structured
-  for (const expandItem of expandItems) {
-    const pathSegments = expandItem.getPathSegments()
-
-    if (pathSegments.length && pathSegments[0].getKind() === 'COMPLEX.PROPERTY') {
-      const navigationProperty = _getNavigationProperty(pathSegments)
-
-      if (isAll || expandItem) {
-        allElements.push(_getItemCQN(service, _name(expandItem), navigationProperty, expandItem))
-      }
-    }
-  }
-
-  return allElements
-}
-
-module.exports = expandToCQN

package/libx/_runtime/cds-services/adapter/odata-v4/odata-to-cqn/index.js

@@ -1,81 +0,0 @@
-const cds = require('../../../../cds')
-
-const {
-  Components: { DATA_CREATE_HANDLER, DATA_DELETE_HANDLER, DATA_READ_HANDLER, DATA_UPDATE_HANDLER }
-} = require('../okra/odata-server')
-
-const boundToCQN = require('./boundToCQN')
-const readToCQN = require('./readToCQN')
-const updateToCQN = require('./updateToCQN')
-const createToCQN = require('./createToCQN')
-const deleteToCQN = require('./deleteToCQN')
-
-const parseToCqn = (component, service, target, data, odataReq, upsert) => {
-  let query = cds.odata.parse(odataReq.getIncomingRequest().url, { service, protocol: 'odata' })
-
-  // for concat
-  if (component === 'READ' && Array.isArray(query)) return query
-
-  const _target = query.SELECT && query.SELECT.from
-
-  const {
-    SELECT: { one }
-  } = query
-
-  switch (component) {
-    case 'CREATE':
-      // create
-      // error in cases like `POST Books(1)` i.e. `POST` with navigation to single entity
-      if (one && !upsert) cds.error('POST not allowed on entity', { code: 400 })
-      return INSERT.into(_target).entries(data)
-    case 'DELETE':
-      if (!one) cds.error('DELETE not allowed on collection', { code: 400 })
-      // eslint-disable-next-line no-case-declarations
-      const last = query._propertyAccess || (_target.ref && _target.ref[_target.ref.length - 1])
-      if (target.elements[last] || target.elements[query._propertyAccess]) {
-        // delete simple property
-        const ref = { ref: query._propertyAccess ? _target.ref : _target.ref.slice(0, -1) }
-        return UPDATE(ref).data({ [last]: null })
-      } else {
-        return DELETE.from(_target)
-      }
-    case 'UPDATE':
-      if (!one) throw { statusCode: 400, code: '400', message: `INVALID_${odataReq.getMethod()}` }
-      return UPDATE(_target).data(data)
-    default:
-      return query
-  }
-}
-
-/**
- * This method transforms an odata request into a CQN object.
- *
- * @param {string} component - Component name
- * @param {object} service - Service, which will process this request
- * @param {object} target - The target entity
- * @param {object | Array} data - A copy of the request payload
- * @param {object} odataReq - OKRA's req
- * @param {boolean} upsert - CREATE on PUT/PATCH
- * @returns {object} - The CQN object
- */
-module.exports = (component, service, target, data, odataReq, upsert) => {
-  if (cds.env.features.odata_new_parser) {
-    return parseToCqn(component, service, target, data, odataReq, upsert)
-  }
-
-  switch (component) {
-    case DATA_CREATE_HANDLER:
-      return createToCQN(service, target, data, odataReq, upsert)
-    case DATA_DELETE_HANDLER:
-      return deleteToCQN(service, odataReq)
-    case DATA_READ_HANDLER:
-      return readToCQN(service, target, odataReq)
-    case DATA_UPDATE_HANDLER:
-      return updateToCQN(service, data, odataReq)
-    case 'BOUND.ACTION':
-    case 'BOUND.FUNCTION':
-      return boundToCQN(service, odataReq)
-    default:
-      return {}
-  }
-}