@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/common/composition/update.js

@@ -1,354 +0,0 @@
-const parentDataSymbol = Symbol('parentData')
-const cqnSymbol = Symbol('cqn')
-const cds = require('../../cds')
-const { getCompositionTree } = require('./tree')
-const { getDeepInsertCQNs } = require('./insert')
-const { getDeepDeleteCQNs } = require('./delete')
-const ctUtils = require('./utils')
-const { ensureNoDraftsSuffix } = require('../utils/draft')
-const { deepCopy } = require('../utils/copy')
-const getError = require('../../common/error')
-const { getEntityNameFromUpdateCQN } = require('../utils/cqn')
-
-const CHUNK_SIZE = cds.env.features.chunk_deep || Number.MAX_VALUE
-
-/*
- * own utils
- */
-
-const _serializedKey = (entity, data) => {
-  if (data === null) return 'null'
-
-  return JSON.stringify(
-    ctUtils
-      .keyElements(entity)
-      .map(key => key.name)
-      .sort()
-      .map(keyName => data[keyName])
-  )
-}
-
-const _dataByKey = (entity, data) => {
-  const dataByKey = new Map()
-
-  for (const entry of data) {
-    dataByKey.set(_serializedKey(entity, entry), entry)
-  }
-
-  return dataByKey
-}
-
-function _addSubDeepUpdateCQNForDelete({ entity, data, selectData, entityName, deleteCQNs }) {
-  const dataByKey = _dataByKey(entity, data)
-
-  if (selectData.length && selectData[0] && Object.keys(selectData[0]).length) {
-    for (let j = 0; j < selectData.length; j += CHUNK_SIZE) {
-      const deleteCQN = { DELETE: { from: entityName, where: [] } }
-
-      for (let i = j; i < j + CHUNK_SIZE && i < selectData.length; i++) {
-        const selectEntry = selectData[i]
-        if (!selectEntry) continue
-
-        const dataEntry = dataByKey.get(_serializedKey(entity, selectEntry))
-        if (!dataEntry) {
-          if (deleteCQN.DELETE.where.length > 0) {
-            deleteCQN.DELETE.where.push('or')
-          }
-
-          deleteCQN.DELETE.where.push({ xpr: [...ctUtils.whereKey(ctUtils.key(entity, selectEntry))] })
-        }
-      }
-
-      if (deleteCQN.DELETE.where.length) deleteCQNs.push(deleteCQN)
-    }
-  }
-}
-
-const _unwrapVal = obj => {
-  for (const key in obj) {
-    const value = obj[key]
-    if (value && value.val) obj[key] = value.val
-  }
-
-  return obj
-}
-
-function _fillLinkFromStructuredData(entity, entry) {
-  for (const elementName in entity.elements) {
-    const _foreignKey4 = entity.elements._foreignKey4
-    if (_foreignKey4 && entry[_foreignKey4]) {
-      const foreignKey = entity.elements[elementName].name
-      const childKey = foreignKey.split('_')[1]
-      const val = _unwrapVal(entry[_foreignKey4])[childKey]
-      if (val !== undefined) entry[foreignKey] = val
-    }
-  }
-}
-
-const _diffData = (newData, oldData, entity, newEntry, oldEntry, model) => {
-  const result = {}
-
-  const keysSet = new Set(Object.keys(newData).concat(Object.keys(oldData)))
-  for (const key of keysSet.keys()) {
-    const newVal = ctUtils.val(newData[key])
-    const oldVal = ctUtils.val(oldData[key])
-
-    if (newVal !== undefined && newVal !== oldVal) {
-      if (!entity.elements[key]) continue
-
-      if (entity.elements[key]._isStructured && Object.keys(newData[key]).length === 0) {
-        // empty structured -> skip
-        continue
-      }
-
-      result[key] = newData[key]
-      continue
-    }
-
-    // comp2one removed?
-    const fk = entity.elements[key] && entity.elements[key]._foreignKey4
-    if (fk && newVal === undefined && oldVal !== undefined) {
-      const nav = entity.elements[fk]
-      // REVISIT: why check @cds.persistence.skip needed? bad tests?
-      if (
-        nav.isComposition &&
-        nav.is2one &&
-        newEntry[nav.name] !== undefined &&
-        !model.definitions[nav.target]._hasPersistenceSkip
-      ) {
-        result[key] = null
-      }
-    }
-  }
-
-  return result
-}
-
-function _addSubDeepUpdateCQNForUpdateInsert({ entity, entityName, data, selectData, updateCQNs, insertCQN, model }) {
-  const selectDataByKey = _dataByKey(entity, selectData)
-  const deepUpdateData = []
-
-  for (const entry of data) {
-    if (entry === null) continue
-
-    const key = ctUtils.key(entity, entry)
-    const selectEntry = selectDataByKey.get(_serializedKey(entity, entry))
-    _fillLinkFromStructuredData(entity, entry)
-    if (selectEntry) {
-      deepUpdateData.push(entry)
-      const newData = ctUtils.cleanDeepData(entity, entry)
-      const oldData = ctUtils.cleanDeepData(entity, selectEntry)
-      const diff = _diffData(newData, oldData, entity, entry, selectEntry, model)
-      // empty updates will be removed later
-      updateCQNs.push({
-        UPDATE: { entity: entityName, data: Object.assign({}, key, diff), where: ctUtils.whereKey(key) },
-        // We take tree information from data and store
-        // it in the `updateCQN` array (which itself is just a flat list)
-        parent: entry[parentDataSymbol]?.[cqnSymbol]
-      })
-      entry[cqnSymbol] = updateCQNs[updateCQNs.length - 1]
-    } else {
-      insertCQN.INSERT.entries.push(entry)
-      // inserts are handled deep so they must not be put into deepUpdateData
-    }
-  }
-
-  return deepUpdateData
-}
-
-async function _addSubDeepUpdateCQNCollect(model, cqns, updateCQNs, insertCQN, deleteCQNs, req) {
-  if (updateCQNs.length > 0) {
-    cqns[0] = cqns[0] || []
-    const cqn = cqns[0]
-    for (const updateCQN of updateCQNs) cqn.push(updateCQN)
-  }
-
-  if (insertCQN.INSERT.entries.length > 0) {
-    cqns[0] = cqns[0] || []
-    const deepInsertCQNs = getDeepInsertCQNs(model, insertCQN)
-    deepInsertCQNs.forEach(insertCQN => {
-      const intoCQN = cqns[0].find(cqn => cqn.INSERT?.into === insertCQN.INSERT.into)
-      if (!intoCQN) {
-        cqns[0].push(insertCQN)
-      } else {
-        const intoCQNEntries = intoCQN.INSERT.entries
-        for (const entry of insertCQN.INSERT.entries) intoCQNEntries.push(entry)
-      }
-    })
-  }
-
-  for (let deleteCQN of deleteCQNs) {
-    if (deleteCQN.DELETE.where.length > 0) {
-      cqns[0] = cqns[0] || []
-      const deepDeleteCQNs = await getDeepDeleteCQNs(model, req, deleteCQN)
-      deepDeleteCQNs.forEach((delCQNs, index) => {
-        delCQNs.forEach(el => {
-          cqns[index] = cqns[index] || []
-          cqns[index].push(el)
-        })
-      })
-    }
-  }
-}
-
-const _unwrapIfNotArray = x => (Array.isArray(x) ? x : _unwrapVal(x))
-
-const _addToData = (subData, entity, element, entry) => {
-  const value = ctUtils.val(entry[element.name])
-  const subDataEntries = ctUtils.array(value)
-  const unwrappedSubData = subDataEntries.map(entry => _unwrapIfNotArray(entry))
-  for (const val of unwrappedSubData) {
-    if (val != null) {
-      // We need to conserve the tree information which gets
-      // lost because we're creating flat arrays of layers.
-      Object.defineProperty(val, parentDataSymbol, { value: entry })
-    }
-
-    subData.push(val)
-  }
-}
-
-async function _addSubDeepUpdateCQNRecursion({ model, compositionTree, entity, data, selectData, cqns, draft, req }) {
-  const selectDataByKey = _dataByKey(entity, selectData)
-
-  for (const element of compositionTree.compositionElements) {
-    const subData = []
-    const selectSubData = []
-
-    for (const entry of data) {
-      if (element.name in entry) {
-        const selectEntry = selectDataByKey.get(_serializedKey(entity, entry))
-
-        if (selectEntry && element.name in selectEntry) {
-          if (selectEntry[element.name] === null && entry[element.name] === null) {
-            continue
-          }
-
-          _addToData(selectSubData, entity, element, selectEntry)
-        }
-
-        _addToData(subData, entity, element, entry)
-      }
-    }
-
-    await _addSubDeepUpdateCQN({
-      model,
-      compositionTree: element,
-      data: subData,
-      selectData: selectSubData,
-      cqns,
-      draft,
-      req
-    })
-  }
-
-  return cqns
-}
-
-const _addSubDeepUpdateCQN = async ({ model, compositionTree, data, selectData, cqns, draft, req }) => {
-  // We handle each level for deepUpdate, the moment we see that there will be an INSERT,
-  // it'll be removed from our deepUpdateData (and handled deep separately).
-  const entity = model.definitions[compositionTree.source]
-
-  if (entity._hasPersistenceSkip) return Promise.resolve()
-
-  const entityName = ctUtils.addDraftSuffix(draft, entity.name)
-  const updateCQNs = []
-  const insertCQN = { INSERT: { into: entityName, entries: [] } }
-  const deleteCQNs = []
-  _addSubDeepUpdateCQNForDelete({ entity, data, selectData, entityName, deleteCQNs })
-  const deepUpdateData = _addSubDeepUpdateCQNForUpdateInsert({
-    entity,
-    entityName,
-    data,
-    selectData,
-    updateCQNs,
-    insertCQN,
-    model
-  })
-
-  await _addSubDeepUpdateCQNCollect(model, cqns, updateCQNs, insertCQN, deleteCQNs, req)
-  if (deepUpdateData.length === 0) return Promise.resolve()
-
-  return _addSubDeepUpdateCQNRecursion({
-    model,
-    compositionTree,
-    entity,
-    data: deepUpdateData,
-    selectData,
-    cqns,
-    draft,
-    req
-  })
-}
-
-/*
- * exports
- */
-
-const hasDeepUpdate = (model, cqn) => {
-  if (cqn && cqn.UPDATE && cqn.UPDATE.entity && (cqn.UPDATE.data || cqn.UPDATE.with)) {
-    const entityName = getEntityNameFromUpdateCQN(cqn)
-    const entity = model.definitions[ensureNoDraftsSuffix(entityName)]
-
-    if (entity) {
-      const keys = Object.keys(Object.assign({}, cqn.UPDATE.data || {}, cqn.UPDATE.with || {}))
-      return !!keys.find(k => ctUtils.isCompOrAssoc(entity, k))
-    }
-  }
-
-  return false
-}
-
-const getDeepUpdateCQNs = async (model, req, selectData) => {
-  const { query } = req
-  if (!Array.isArray(selectData)) selectData = [selectData]
-  if (selectData.length === 0) return []
-  if (selectData.length > 1) throw getError('Deep update can only be performed on a single instance')
-
-  const cqns = []
-  const from = getEntityNameFromUpdateCQN(query)
-  const entityName = ensureNoDraftsSuffix(from)
-  const draft = entityName !== from
-  const data = query.UPDATE.data ? deepCopy(query.UPDATE.data) : {}
-  const withObj = query.UPDATE.with ? deepCopy(query.UPDATE.with) : {}
-  const entity = model.definitions[entityName]
-  const entry = Object.assign({}, data, withObj, ctUtils.key(entity, selectData[0]))
-  const compositionTree = getCompositionTree({
-    definitions: model.definitions,
-    rootEntityName: entityName,
-    resolveViews: !draft,
-    service: cds.db
-  })
-
-  const subCQNs = await _addSubDeepUpdateCQN({
-    model,
-    compositionTree,
-    data: [entry],
-    selectData,
-    cqns: [],
-    draft,
-    req
-  })
-  subCQNs.forEach((subCQNs, index) => {
-    cqns[index] = cqns[index] || []
-    for (const cqn of subCQNs) cqns[index].push(cqn)
-  })
-
-  // remove empty updates and inserts
-  return cqns
-    .map(cqns => {
-      return cqns.filter(cqn => {
-        if (!cqn.UPDATE && !cqn.INSERT) return true
-        if (cqn.UPDATE) return Object.keys(cqn.UPDATE.data).length > 0
-        if (!cqn.INSERT.entries || cqn.INSERT.entries.length > 1) return true
-        return Object.keys(cqn.INSERT.entries[0]).length > 0
-      })
-    })
-    .filter(cqns => cqns.length > 0)
-}
-
-module.exports = {
-  hasDeepUpdate,
-  getDeepUpdateCQNs
-}

package/libx/_runtime/common/composition/utils.js

@@ -1,95 +0,0 @@
-const { ensureNoDraftsSuffix, ensureDraftsSuffix } = require('../utils/draft')
-
-const addDraftSuffix = (draft, name) => {
-  return draft ? ensureDraftsSuffix(name) : ensureNoDraftsSuffix(name)
-}
-
-const whereKey = key => {
-  const where = []
-  Object.keys(key).forEach(keyPart => {
-    if (where.length > 0) where.push('and')
-    where.push({ ref: [keyPart] }, '=', { val: key[keyPart] })
-  })
-  return where
-}
-
-const keyElements = entity => {
-  // REVISIT: this is expensive
-  return Object.keys(entity.keys)
-    .map(key => entity.keys[key])
-    .filter(e => !e.virtual && !e.isAssociation)
-}
-
-const key = (entity, data) => {
-  return keyElements(entity).reduce((result, element) => {
-    if (element.name === 'IsActiveEntity' && !Object.hasOwn(data, element.name)) return result
-    result[element.name] = data[element.name]
-    return result
-  }, {})
-}
-
-const val = element => (element && element.val) || element
-
-const array = x => (Array.isArray(x) ? x : [x])
-
-const isCompOrAssoc = (entity, elementName, onlyToOne) => {
-  const element = entity.elements && entity.elements[elementName]
-  return !!(element && element.isAssociation && ((onlyToOne && element.is2one) || !onlyToOne))
-}
-
-const cleanDeepData = (entity, data, onlyToOne = false) => {
-  if (!Array.isArray(data)) {
-    return cleanDeepData(entity, [data], onlyToOne)[0]
-  }
-  return data.map(entry => {
-    return Object.keys(entry || {}).reduce((result, k) => {
-      if (!isCompOrAssoc(entity, k, onlyToOne)) {
-        result[k] = entry[k]
-      }
-      return result
-    }, {})
-  })
-}
-
-const _getBacklinkNameFromOnCond = element => {
-  if (element.on && element.on.length === 3 && element.on[0].ref && element.on[2].ref) {
-    if (element.on[0].ref[0] === '$self') {
-      return element.on[2].ref[element.on[2].ref.length - 1]
-    } else if (element.on[2].ref[0] === '$self') {
-      return element.on[0].ref[element.on[0].ref.length - 1]
-    }
-  }
-}
-
-const isBacklink = (element, parent, checkContained, backLinkName) => {
-  if (!element._isAssociationStrict) return false
-  if (!parent || !(element.keys || element.on)) return false
-  if (element.target !== parent.name) return false
-
-  const _isBackLink = parentElement =>
-    (!checkContained || parentElement._isContained) && _getBacklinkNameFromOnCond(parentElement) === element.name
-
-  if (backLinkName) {
-    const parentElement = parent.elements[backLinkName]
-    return parentElement.isAssociation && _isBackLink(parentElement)
-  }
-  for (const parentElementName in parent.elements) {
-    const parentElement = parent.elements[parentElementName]
-    if (!parentElement.isAssociation) continue
-    if (_isBackLink(parentElement)) return true
-  }
-
-  return false
-}
-
-module.exports = {
-  addDraftSuffix,
-  whereKey,
-  keyElements,
-  key,
-  val,
-  array,
-  isCompOrAssoc,
-  cleanDeepData,
-  isBacklink
-}

package/libx/_runtime/common/error/constants.js

@@ -1,20 +0,0 @@
-module.exports = {
-  ALLOWED_PROPERTIES_MAP: { code: 1, message: 1, target: 1, details: 1, innererror: 1 },
-  ADDITIONAL_MSG_PROPERTIES_MAP: { numericSeverity: 1, longtextUrl: 1, transition: 1 },
-  /*
-   * severities:
-   *   1: success
-   *   2: info
-   *   3: warning
-   *   4: error
-   */
-  DEFAULT_SEVERITY: 2,
-  MIN_SEVERITY: 1,
-  MAX_SEVERITY: 4,
-  MULTIPLE_ERRORS: 'MULTIPLE_ERRORS',
-  /*
-   * OData
-   */
-  ODATA_UNAUTHORIZED: { statusCode: 401, code: '401', message: 'Unauthorized' },
-  ODATA_FORBIDDEN: { statusCode: 403, code: '403', message: 'Forbidden' }
-}

package/libx/_runtime/common/error/entry.js

@@ -1,36 +0,0 @@
-/**
- * @param {number|object} [code] - The numeric code. Only if typeof msg === 'string'.
- * @param {string|object} msg - The message or text key (string), or entry object (if more details are needed)
- * @param {number|string} [msg.code] - The numeric or text code.
- * @param {string} [msg.message] - The message or text key.
- * @param {string} [msg.target] - The target of the message.
- * @param {Array|object} [msg.args] - The placeholder values for messages with placeholders.
- * @param {any} [msg.<key>] - Additional properties, e.g., for processing in custom logging (will not reach client).
- * @param {string} [target] - The target of the message. Only if typeof msg === 'string'.
- * @param {Array|object} [args] - The placeholder values for messages with placeholders. Only if typeof msg === 'string'.
- * @returns {object} - The normalized entry
- */
-module.exports = (code, msg, target, args) => {
-  if (typeof code === 'object') {
-    // > params: msg
-    return code
-  }
-
-  // sort out params
-  if (typeof code !== 'number') {
-    // > params: msg, target?, args?
-    ;[code, msg, target, args] = [undefined, code, msg, target]
-  }
-
-  if (target && typeof target === 'object') {
-    // > params: code?, msg, args?
-    ;[args, target] = [target]
-  }
-
-  return {
-    code,
-    message: msg || (code && String(code)),
-    target,
-    args
-  }
-}

package/libx/_runtime/common/error/frontend.js

@@ -1,199 +0,0 @@
-// REVISIT: Requires thorough cleanup and refactoring, or elimination
-/*
- * OData spec:
- *   This object MUST contain name/value pairs with the names code and message,
- *   and it MAY contain name/value pairs with the names target, details and innererror.
- *   [...]
- *   Error responses MAY contain annotations in any of its JSON objects.
- */
-const localeFrom = require('../../../../lib/req/locale')
-const { getErrorMessage } = require('./utils')
-const { i18n } = require('../../../../lib')
-
-const {
-  ALLOWED_PROPERTIES_MAP,
-  ADDITIONAL_MSG_PROPERTIES_MAP,
-  DEFAULT_SEVERITY,
-  MIN_SEVERITY,
-  MAX_SEVERITY
-} = require('./constants')
-const ADDITIONAL_MSG_PROPERTIES = Object.keys(ADDITIONAL_MSG_PROPERTIES_MAP)
-
-const _getFiltered = err => {
-  const error = {}
-  for (let k in err) {
-    // IMPORTANT: do not use Object.keys(err) here as that ignores enumerable properties from __proto__!
-    if (k in ALLOWED_PROPERTIES_MAP || k.startsWith('@')) {
-      error[k] = err[k]
-    } else if (k === 'numericSeverity') {
-      error['@Common.numericSeverity'] = err[k]
-    }
-  }
-  if ('message' in err) error.message = err.message
-  return error
-}
-
-const _rewriteError = error => {
-  let { code, message } = error
-  code = String(code || 'null')
-
-  // REVISIT: db stuff probably shouldn't be here
-  if (code === 'SQLITE_ERROR') {
-    error.code = 'null'
-    return
-  }
-
-  if (
-    (code.startsWith('SQLITE_CONSTRAINT') && (message.match(/COMMIT/) || message.match(/FOREIGN KEY/))) ||
-    (code === '155' && message.match(/fk constraint violation/))
-  ) {
-    // > foreign key constaint violation on sqlite/ hana
-    error.code = '400'
-    error.message = 'FK_CONSTRAINT_VIOLATION'
-    return
-  }
-
-  if (code.startsWith('ASSERT_')) {
-    error.code = '400'
-    return
-  }
-}
-
-const _isInHttpResponseCodeRange = errorCode => errorCode >= 300 && errorCode <= 599
-
-const BAD_REQUEST_ERRORS = new Set(['ENTITY_ALREADY_EXISTS', 'FK_CONSTRAINT_VIOLATION', 'UNIQUE_CONSTRAINT_VIOLATION'])
-
-const _normalize = (err, locale, formatterFn = _getFiltered) => {
-  // REVISIT: code and message rewriting
-  _rewriteError(err)
-
-  const { message: originalMessage } = err
-
-  // message (i18n)
-  err.message = getErrorMessage(err, locale)
-
-  // ensure code is set and a string
-  err.code = String(err.code || 'null')
-
-  // determine status code from error
-  let statusCode = err.status || err.statusCode //> REVISIT: why prefer status over statusCode?
-  // well-defined bad request errors
-  if (!statusCode && BAD_REQUEST_ERRORS.has(originalMessage)) statusCode = 400
-  if (!statusCode && _isInHttpResponseCodeRange(err.code)) {
-    if ('sqlState' in err) {
-      // HANA/ database error -> don't use code as status code
-    } else {
-      statusCode = err.code
-    }
-  }
-
-  // details
-  if (err.details) {
-    const childErrorCodes = new Set()
-    err.details = err.details.map(ele => {
-      const { error: childError, statusCode: childStatusCode } = _normalize(ele, locale, formatterFn)
-      childErrorCodes.add(childStatusCode)
-      return childError
-    })
-    statusCode = statusCode || _statusCodeFromDetails(childErrorCodes)
-  }
-
-  // make sure it's a number if set, otherwise will be assigned as 500 in normalizeError
-  statusCode = statusCode ? Number(statusCode) : undefined
-
-  // only allowed properties
-  const error = formatterFn(err)
-
-  return { error, statusCode }
-}
-
-// - for one unique value, we use it
-// - if at least one 5xx exists, we use 500
-// - else if at least one 4xx exists, we use 400
-const _statusCodeFromDetails = uniqueStatusCodes => {
-  if (uniqueStatusCodes.size === 1) return uniqueStatusCodes.values().next().value
-  if ([...uniqueStatusCodes].some(s => s >= 500)) return 500
-  if ([...uniqueStatusCodes].some(s => s >= 400)) return 400
-}
-
-const _getSanitizedError = (statusCode, locale) => ({
-  error: { code: String(statusCode), message: i18n.messages.at(statusCode, locale) }, // REVISIT: don't do that
-  statusCode
-})
-
-const normalizeError = (err, req, formatterFn) => {
-  const locale = req.locale || (req.locale = localeFrom(req))
-  let { error, statusCode } = _normalize(err, locale, formatterFn)
-
-  if (process.env.NODE_ENV === 'production') {
-    // > return sanitized error to client
-
-    if (!statusCode) return _getSanitizedError(500, locale)
-
-    if (statusCode >= 500 && err._thrownByFramework) {
-      return _getSanitizedError(statusCode, locale)
-    }
-  }
-
-  if (!statusCode) statusCode = 500
-
-  // no top level null codes
-  if (error.code === 'null') error.code = String(statusCode)
-
-  return { error, statusCode }
-}
-
-const _ensureSeverity = arg => {
-  if (typeof arg !== 'number') return DEFAULT_SEVERITY
-
-  if (arg >= MIN_SEVERITY && arg <= MAX_SEVERITY) return arg
-
-  return DEFAULT_SEVERITY
-}
-
-const _normalizeMessage = (message, locale) => {
-  const { error: normalized } = _normalize(message, locale)
-
-  // numericSeverity without @Common
-  normalized.numericSeverity = _ensureSeverity(message.numericSeverity)
-  delete normalized['@Common.numericSeverity']
-
-  ADDITIONAL_MSG_PROPERTIES.forEach(k => {
-    if (message[k] && typeof message[k] === 'string') {
-      normalized[k] = message[k]
-    }
-  })
-
-  return normalized
-}
-
-const getSapMessages = (messages, req) => {
-  const locale = req.locale || (req.locale = localeFrom(req))
-  const s = JSON.stringify(messages.map(message => _normalizeMessage(message, locale)))
-  // convert non ascii to unicode
-  return s.replace(/[\u007F-\uFFFF]/g, chr => {
-    return '\\u' + ('0000' + chr.charCodeAt(0).toString(16)).substr(-4)
-  })
-}
-
-const isClientError = e => {
-  // e.code may be undefined, string, number, ... -> NaN -> not a client error
-  const numericCode = e.statusCode || e.status || Number(e.code)
-  return numericCode >= 400 && numericCode < 500
-}
-
-const unwrapMultipleErrors = error => {
-  // According to the Fiori Elements Failed Message specification, the format must be:
-  // Root level: First error, Details: Other errors
-  const [firstDetail, ...restDetails] = error.details
-  Object.assign(error, firstDetail)
-  if (restDetails.length) error.details = restDetails
-  else delete error.details
-}
-
-module.exports = {
-  normalizeError,
-  getSapMessages,
-  isClientError,
-  unwrapMultipleErrors
-}