@sap/cds 5.9.8 → 6.0.1

package/libx/_runtime/cds-services/adapter/rest/utils/binary.js

@@ -1,50 +0,0 @@
-const _isKeyTypeBinary = (entity, key) => {
-  return (
-    entity.elements &&
-    entity.elements[key] &&
-    (entity.elements[key]._type === 'cds.Binary' || entity.elements[key]._type === 'cds.LargeBinary')
-  )
-}
-
-const base64toBuffer = (json, entity) => {
-  if (typeof json !== 'object') {
-    return
-  }
-
-  for (const key in json) {
-    if (_isKeyTypeBinary(entity, key) && json[key]) {
-      json[key] = Buffer.from(json[key], 'base64')
-    }
-  }
-}
-
-const _arrayToBase64 = (json, entity) => {
-  json.forEach(element => {
-    if (typeof element === 'object') {
-      bufferToBase64(element, entity)
-    }
-  })
-}
-
-const _objectToBase64 = (json, entity) => {
-  for (const key in json) {
-    if (_isKeyTypeBinary(entity, key) && json[key]) {
-      json[key] = json[key].toString('base64')
-    }
-  }
-}
-
-const bufferToBase64 = (json, entity) => {
-  if (typeof json !== 'object') return
-
-  if (Array.isArray(json)) {
-    _arrayToBase64(json, entity)
-  } else {
-    _objectToBase64(json, entity)
-  }
-}
-
-module.exports = {
-  base64toBuffer,
-  bufferToBase64
-}

package/libx/_runtime/cds-services/adapter/rest/utils/data.js

@@ -1,117 +0,0 @@
-const { getKeyValuePair } = require('./key-value-utils')
-const { validationChecks } = require('./validation-checks')
-const { checkComplexType } = require('../../../util/assert')
-const { deepCopyObject, deepCopyArray } = require('../../../../common/utils/copy')
-
-const _getKeyValues = (event, target, keys) => {
-  if (event === 'CREATE' && !keys) return {}
-  return getKeyValuePair(target, keys)
-}
-
-const _isPrimitiveProperty = ([key], elements) => {
-  return elements[key] && !elements[key].isAssociation
-}
-
-const _addPrimitiveProperty = (row, [key, value]) => {
-  row[key] = value
-}
-
-const _addComplexProperty = (row, [structuredName, structuredValue], elements) => {
-  // Limited to depth 1, same as for checkComplexType
-  const nestedObj = {}
-  for (const [structuredElement, structuredElementValue] of Object.entries(structuredValue)) {
-    if (elements[`${structuredName}_${structuredElement}`]) {
-      nestedObj[structuredElement] = structuredElementValue
-    }
-  }
-  row[structuredName] = nestedObj
-}
-
-const _isCompositionProperty = ([key, value], elements) => {
-  return elements[key] && elements[key].isComposition && value
-}
-
-const _addCompositionProperty = (row, [key, value], elements) => {
-  const target = elements[key]._target
-
-  if (Array.isArray(value)) {
-    row[key] = []
-    for (const child of value) {
-      const filteredChild = {}
-      _copyAndFilterDeep(filteredChild, [child], target)
-      row[key].push(filteredChild)
-    }
-  } else {
-    row[key] = {}
-    _copyAndFilterDeep(row[key], [value], target)
-  }
-}
-
-const _copyAndFilterDeep = (copy, data, entity) => {
-  if (!Array.isArray(data)) data = [data]
-
-  data.forEach(dataEntry => {
-    let row
-    if (Array.isArray(copy)) {
-      row = {}
-      copy.push(row)
-    } else {
-      row = copy
-    }
-
-    for (const prop of Object.entries(dataEntry)) {
-      const elements = entity.elements
-
-      if (_isPrimitiveProperty(prop, elements)) {
-        _addPrimitiveProperty(row, prop)
-      } else if (checkComplexType(prop, elements, false)) {
-        _addComplexProperty(row, prop, elements)
-      } else if (_isCompositionProperty(prop, elements)) {
-        _addCompositionProperty(row, prop, elements)
-      }
-    }
-  })
-}
-
-const _getFilteredCopy = (target, data, keyValues) => {
-  let copy
-
-  if (!target || target._hasPersistenceSkip) {
-    // > unbound or @cds.persistence.skip
-    copy = Array.isArray(data) ? deepCopyArray(data) : deepCopyObject(data)
-  } else {
-    // > bound (incl. CRUD) and no @cds.persistence.skip
-    copy = Array.isArray(data) ? [] : {}
-    _copyAndFilterDeep(copy, data, target)
-  }
-
-  if (keyValues) {
-    Array.isArray(data) ? Object.assign(copy[0], keyValues) : Object.assign(copy, keyValues)
-  }
-
-  return copy
-}
-
-module.exports = (parsed, restReq) => {
-  const { event, kind, segments, target, params } = parsed
-
-  let data, keyValues
-  if (kind) {
-    // > action or function
-    data = params || restReq.body || {}
-  } else {
-    // > CRUD
-    keyValues = _getKeyValues(event, target, segments[1])
-    if (event === 'CREATE') {
-      // > batch
-      data = Array.isArray(restReq.body) ? restReq.body : [restReq.body || {}]
-    } else {
-      data = restReq.body || {}
-    }
-  }
-
-  const err = validationChecks(event, data, target && target.elements ? target : { elements: segments[0].params })
-
-  if (err) return [err]
-  else return [0, _getFilteredCopy(target, data, keyValues)]
-}

package/libx/_runtime/cds-services/adapter/rest/utils/header-checks.js

@@ -1,14 +0,0 @@
-const getError = require('../../../../common/error')
-
-const contentTypeCheck = req => {
-  const contentType = req.headers['content-type'] && req.headers['content-type'].split(';')
-  if (
-    contentType &&
-    (!contentType[0].match(/^application\/json$/) || (typeof contentType[1] === 'string' && !contentType[1]))
-  ) {
-    throw getError(415, 'INVALID_CONTENT_TYPE_ONLY_JSON')
-  }
-}
-module.exports = {
-  contentTypeCheck
-}

package/libx/_runtime/cds-services/adapter/rest/utils/key-value-utils.js

@@ -1,30 +0,0 @@
-const _keyFromEntity = entity => {
-  const keyName = Object.keys(entity.keys)[0]
-  return entity.keys[keyName]
-}
-
-const getConvertedValue = (type, value) => {
-  // TODO: part of input validation?
-  // TODO: what to do with binaries (Buffer?!)
-  switch (type) {
-    case 'cds.Boolean':
-      return value === 'true'
-    case 'cds.Integer':
-    case 'cds.Integer64':
-    case 'cds.Decimal':
-    case 'cds.DecimalFloat':
-    case 'cds.Double':
-      return Number(value)
-    default:
-      return value
-  }
-}
-
-module.exports = {
-  getKeyValuePair: (entity, value) => {
-    if (value === undefined) return {}
-    const key = _keyFromEntity(entity)
-    return { [key.name]: getConvertedValue(key._type, value) }
-  },
-  getConvertedValue
-}

package/libx/_runtime/cds-services/adapter/rest/utils/parse-url.js

@@ -1,250 +0,0 @@
-const getError = require('../../../../common/error')
-const { getConvertedValue } = require('./key-value-utils')
-const { checkStatic } = require('../../../util/assert')
-const { findCsnTargetFor } = require('../../../../common/utils/csn')
-
-const _normalizeAndSplitUrl = req => {
-  // Normalize /path////to/someWhere into path/to/someWhere and split by /
-  const parts = `/${req.path}/`
-    .replace(/[/]+/g, '/')
-    .replace(/\/(.*)\//, '$1')
-    .split('/')
-
-  // TODO: replace with generic solution, currently we do not support longer urls
-  if (parts.length > 3) {
-    throw getError(501, 'CRUD_VIA_NAVIGATION_NOT_SUPPORTED')
-  }
-
-  return parts
-}
-
-const _enrichCustomOperation = (csnElement, customOperationName) => {
-  const obj = { name: customOperationName }
-  Object.setPrototypeOf(obj, csnElement)
-  return obj
-}
-
-const _initializeParsed = event => {
-  return { event, segments: [] }
-}
-
-const _parseEntityOrOperation = part => {
-  let decodedPart = decodeURI(part)
-  decodedPart = decodedPart.replace(/"/gi, '')
-  const [, name, paramsString = ''] = decodedPart.match(/([^(]+)\(?(.*[^)]+)?\)?/)
-  const params = paramsString
-    .split(',')
-    .map(keyValue => keyValue.split('='))
-    .reduce((obj, [key, value]) => {
-      if (key) {
-        obj[key] = value
-      }
-      return obj
-    }, {})
-  const returnObj = { name }
-  if (Object.keys(params).length > 0) {
-    returnObj.params = params
-  }
-  return returnObj
-}
-
-const _findEntityOrCustomOperation = (customOperation, service, name) => {
-  const thing =
-    service.entities[name] || service.operations[name] || findCsnTargetFor(name, service.model, service.namespace)
-  if (!thing) {
-    throw getError(404, 'INVALID_RESOURCE', [name])
-  }
-
-  if (thing.kind === 'entity') {
-    return thing
-  }
-
-  if (thing.kind === customOperation) {
-    return _enrichCustomOperation(thing, name)
-  }
-
-  throw getError(400, 'INVALID_RESOURCE', [name])
-}
-
-const _validateEntity = entity => {
-  if (!entity) {
-    throw getError(404)
-  }
-
-  if (entity.kind === 'entity') {
-    return entity
-  }
-
-  throw getError(400, 'INVALID_RESOURCE', [entity.name])
-}
-
-const _validateCustomOperation = (entity, name, customOperation) => {
-  if (entity.actions && entity.actions[name] && entity.actions[name].kind === customOperation) {
-    return _enrichCustomOperation(entity.actions[name], name)
-  } else if (entity.elements && entity.elements[name] && entity.elements[name]._isAssociationEffective) {
-    // REVISIT hack to at least support one step navigations
-    return _enrichCustomOperation(entity.elements[name], name)
-  }
-
-  throw getError(400, 'INVALID_OPERATION_FOR_ENTITY', [entity.name, customOperation.toUpperCase(), name])
-}
-
-const _validateAndConvertParamValues = (csnElement, params = {}) => {
-  for (const param in params) {
-    const csnElementParam = csnElement.params[param]
-    if (!csnElementParam) {
-      throw getError(400, 'INVALID_PARAMETER', [param])
-    }
-    const convertedParam = getConvertedValue(csnElementParam._type, params[param])
-    if (Number.isNaN(convertedParam)) {
-      throw getError(400, 'INVALID_PARAMETER_VALUE_TYPE', [param, csnElementParam._type])
-    }
-    params[param] = convertedParam
-  }
-  checkStatic({ elements: csnElement.params }, params)
-}
-
-const _getLastEntity = segments => {
-  let last
-  for (let i = segments.length - 1; i >= 0; i--) {
-    if (segments[i].target) {
-      last = segments[i].target
-      break
-    } else if (segments[i].kind === 'entity') {
-      last = segments[i]
-      break
-    }
-  }
-  return last
-}
-
-const _setConvenienceProperties = parsed => {
-  const lastElement = parsed.segments[parsed.segments.length - 1]
-
-  if (typeof lastElement === 'string') {
-    parsed.isCollection = false
-  } else if (lastElement.kind === 'entity') {
-    parsed.isCollection = true
-  } else if (lastElement.isAssociation) {
-    parsed.isCollection = true
-  } else {
-    parsed.operation = lastElement
-    parsed.kind = lastElement.kind
-    parsed.event = lastElement.name
-  }
-
-  parsed.target = _getLastEntity(parsed.segments)
-}
-
-const _parseCreateOrRead1 = (parts, customOperation, service, parsed) => {
-  const { name, params } = _parseEntityOrOperation(parts[0])
-  const entityOrCustomOperation = _findEntityOrCustomOperation(customOperation, service, name)
-  if (params) {
-    _validateAndConvertParamValues(entityOrCustomOperation, params)
-  }
-  if (params && customOperation === 'function') {
-    parsed.params = params
-  }
-  parsed.segments.push(entityOrCustomOperation)
-}
-
-const _parseCreateOrRead2 = (event, parsed, service, parts) => {
-  if (event === 'CREATE') {
-    throw getError(400, 'INVALID_POST')
-  }
-
-  parsed.segments.push(
-    _validateEntity(service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.namespace)),
-    parts[1]
-  )
-}
-
-const _parseCreateOrRead3 = (service, parts, customOperation, parsed) => {
-  const entity = _validateEntity(
-    service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.namespace)
-  )
-  const key = parts[1]
-  const { name, params } = _parseEntityOrOperation(parts[2])
-  const operation = _validateCustomOperation(entity, name, customOperation)
-  if (params) {
-    _validateAndConvertParamValues(operation, params)
-  }
-  if (params && customOperation === 'function') {
-    parsed.params = params
-  }
-  parsed.segments.push(entity, key, operation)
-}
-
-const parseCreateOrReadUrl = (event, service, req) => {
-  const parts = _normalizeAndSplitUrl(req)
-  const customOperation = event === 'READ' ? 'function' : 'action'
-  const parsed = _initializeParsed(event)
-
-  // TODO: replace with generic solution
-  if (parts.length === 1) {
-    _parseCreateOrRead1(parts, customOperation, service, parsed)
-  }
-
-  if (parts.length === 2) {
-    _parseCreateOrRead2(event, parsed, service, parts)
-  }
-
-  if (parts.length === 3) {
-    _parseCreateOrRead3(service, parts, customOperation, parsed)
-  }
-
-  _setConvenienceProperties(parsed)
-  if (typeof parsed.target === 'string') parsed.target = service.model.definitions[parsed.target]
-
-  return parsed
-}
-
-const parseUpdateOrDeleteUrl = (event, service, req) => {
-  const parts = _normalizeAndSplitUrl(req)
-
-  // TODO: replace with generic solution
-  if (req.method === 'DELETE' && parts.length !== 2) {
-    throw getError(400, 'INVALID_DELETE')
-  }
-  if (req.method === 'PATCH' && parts.length !== 2) {
-    throw getError(400, 'INVALID_PATCH')
-  }
-  if (req.method === 'PUT' && parts.length !== 2) {
-    throw getError(400, 'INVALID_PUT')
-  }
-
-  const entity = _validateEntity(
-    service.entities[parts[0]] || findCsnTargetFor(parts[0], service.model, service.namespace)
-  )
-  const segments = [entity]
-
-  if (parts[1]) {
-    segments.push(parts[1])
-  }
-
-  let target = _getLastEntity(segments)
-  if (typeof target === 'string') target = service.model.definitions[target]
-
-  return { event, segments, target }
-}
-
-module.exports = {
-  POST: (service, req) => {
-    return parseCreateOrReadUrl('CREATE', service, req)
-  },
-  HEAD: (service, req) => {
-    return parseCreateOrReadUrl('READ', service, req)
-  },
-  GET: (service, req) => {
-    return parseCreateOrReadUrl('READ', service, req)
-  },
-  PUT: (service, req) => {
-    return parseUpdateOrDeleteUrl('UPDATE', service, req)
-  },
-  PATCH: (service, req) => {
-    return parseUpdateOrDeleteUrl('UPDATE', service, req)
-  },
-  DELETE: (service, req) => {
-    return parseUpdateOrDeleteUrl('DELETE', service, req)
-  }
-}

package/libx/_runtime/cds-services/adapter/rest/utils/result.js

@@ -1,26 +0,0 @@
-/**
- * Convert any result to the format expected of rest.
- *
- * @param {*} result
- * @returns {string | object | boolean}
- */
-const toRestResult = result => {
-  let restResult = result
-
-  // compat for mtx returning strings instead of objects
-  if (typeof result === 'object' && '$count' in result) {
-    restResult = {
-      count: result.$count,
-      value: result
-    }
-    // need to convert number to string because express interprets integer as status code
-  } else if (typeof result === 'number') {
-    restResult = result.toString()
-  }
-
-  return restResult
-}
-
-module.exports = {
-  toRestResult
-}

package/libx/_runtime/cds-services/services/utils/handlerUtils.js

@@ -1,200 +0,0 @@
-const cds = require('../../../cds')
-const { SELECT } = cds.ql
-
-const { processDeep } = require('../../util/dataProcessUtils')
-
-const { DRAFT_COLUMNS_MAP } = require('../../../common/constants/draft')
-
-const _isAssociationToOneManaged = element => element._isAssociationEffective && element.is2one && !element.on
-
-const _getWheres = (key, data) => {
-  const wheres = []
-  for (const d of data) {
-    wheres.push({ [key.name]: d[key.name] })
-  }
-  return wheres
-}
-
-const allKeysAreProvided = req => {
-  const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
-  for (const key of Object.values(req.target.keys || {})) {
-    if (key._isAssociationStrict || key.name in DRAFT_COLUMNS_MAP) {
-      continue
-    }
-    for (const d of data) {
-      if (d[key.name] === undefined) return false
-    }
-  }
-  return true
-}
-
-const _addWhereToCqn = (wheres, target, cqn) => {
-  if (wheres.length === 1) {
-    const whereObj = wheres[0]
-    for (const key in whereObj) {
-      // check if we have structured elements
-      if (target.elements[key].elements) {
-        whereObj[key] = { val: JSON.stringify(whereObj[key]) }
-      }
-    }
-    cqn.where(whereObj)
-  } else {
-    cqn.where({ or: wheres })
-  }
-}
-
-const _getSelectCQN = (req, columns) => {
-  const cqn = SELECT.from(req.target)
-
-  if (columns) {
-    cqn.columns(...columns)
-  }
-
-  const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
-
-  for (const key of Object.values(req.target.keys || {})) {
-    if (key._isAssociationStrict || key.name in DRAFT_COLUMNS_MAP) {
-      continue
-    }
-
-    const wheres = _getWheres(key, data)
-    if (wheres.length) {
-      _addWhereToCqn(wheres, req.target, cqn)
-    }
-  }
-
-  if (req.target.query && req.target.query.SELECT && req.target.query.SELECT.orderBy) {
-    cqn.SELECT.orderBy = req.target.query.SELECT.orderBy
-  }
-
-  return cqn
-}
-
-function _fillForeignKeysWithNull(managedAssocToOneElement, row) {
-  for (const key of managedAssocToOneElement._foreignKeys) {
-    if (key.parentElement) row[key.parentElement.name] = null
-  }
-}
-
-const _flattenManagedToOneAssociation = (managedAssocToOneElement, entity, row, property, csn, req) => {
-  const targetEntity = managedAssocToOneElement._target
-  for (const key in targetEntity.keys) {
-    const el = targetEntity.keys[key]
-    if (_isAssociationToOneManaged(el)) {
-      if (row[managedAssocToOneElement.name] === null) {
-        _fillForeignKeysWithNull(managedAssocToOneElement, row)
-        continue
-      }
-      _flattenManagedToOneAssociation(el, targetEntity, row[managedAssocToOneElement.name], key, csn, req)
-      continue
-    }
-
-    if (row[managedAssocToOneElement.name] === null) {
-      row[managedAssocToOneElement.name + '_' + key] = null
-    } else {
-      row[managedAssocToOneElement.name + '_' + key] = row[managedAssocToOneElement.name][key]
-      delete row[managedAssocToOneElement.name][key]
-    }
-  }
-
-  if (row[managedAssocToOneElement.name] === null || Object.keys(row[managedAssocToOneElement.name]).length === 0) {
-    // if there are no non key values left, remove assoc object
-    delete row[managedAssocToOneElement.name]
-  }
-}
-
-const _flattenDeepToOneAssociations = (entity, data, csn, req) => {
-  if (!Array.isArray(data)) {
-    return _flattenDeepToOneAssociations(entity, [data], csn, req)
-  }
-
-  for (const row of data) {
-    for (const property in row) {
-      const element = entity.elements[property]
-      if (!element) continue
-
-      if (_isAssociationToOneManaged(element)) {
-        _flattenManagedToOneAssociation(element, entity, row, property, csn, req)
-      } else if (element.elements) {
-        _flattenDeepToOneAssociations(element, [row[element.name]], csn, req)
-      }
-    }
-  }
-}
-
-const flattenDeepToOneAssociations = (req, csn) => {
-  if (!req.target) {
-    return
-  }
-
-  if (req.event !== 'CREATE' && req.event !== 'UPDATE') {
-    return
-  }
-
-  // REVISIT: adopt template mechanism?
-  processDeep(
-    (data, entity) => {
-      _flattenDeepToOneAssociations(entity, data, csn, req)
-    },
-    req.data,
-    req.target,
-    false,
-    true
-  )
-}
-
-/*
- * merge CQNs
- */
-const _mergeExpandCQNs = cqns => {
-  const cols = cqns[0].SELECT.columns
-  for (const c of cqns) {
-    for (const col of c.SELECT.columns) {
-      if (col.expand && !cols.find(ele => ele.ref[0] === col.ref[0])) {
-        cols.push(col)
-      }
-    }
-  }
-  return cqns[0]
-}
-
-/*
- * recursively builds a select cqn for deep read after write
- * (depth determined by req.data)
- */
-const getDeepSelect = req => {
-  // REVISIT: Why do we do such expensive deep reads after write at all ???
-  const { elements } = req.target
-  const cols = []
-
-  for (const each in elements) {
-    if (each in DRAFT_COLUMNS_MAP) continue
-    const e = elements[each]
-    if (!e.isAssociation) cols.push(each)
-    else if (e._isCompositionEffective) {
-      const cqns = []
-      // REVISIT: This recursively creates lots of nested selects only to keep a few
-      for (const row of Array.isArray(req.data) ? req.data : [req.data]) {
-        let d = row[each]
-        if (!d) continue
-        else if (!Array.isArray(d)) d = [d]
-        else if (d.length === 0) continue
-        const nested = d.map(data => getDeepSelect({ target: e._target, data }))
-        cqns.push(_mergeExpandCQNs(nested))
-      }
-      if (cqns.length > 0) {
-        const { SELECT } = _mergeExpandCQNs(cqns)
-        cols.push({ ref: [each], expand: SELECT.columns })
-      }
-    }
-  }
-
-  // root? -> with where clause
-  return req.event ? _getSelectCQN(req, cols) : SELECT.from(req.target, cols)
-}
-
-module.exports = {
-  getDeepSelect,
-  allKeysAreProvided,
-  flattenDeepToOneAssociations
-}