@sap/cds 5.8.4 → 5.9.2

package/libx/_runtime/db/data-conversion/post-processing.js

@@ -1,50 +1,7 @@
-const cds = require('../../cds')
-
-const { ensureUnlocalized, ensureNoDraftsSuffix } = require('../../common/utils/draft')
-
-/**
- * Check if the value is a function or reference to private function.
- * Return if any of the cases are true.
- *
- * @param {string|Function} fn -
- * @returns {Function}
- * @throws Error if no valid parameter fn provided
- * @private
- */
-const _getMethod = fn => {
-  if (typeof fn === 'function') {
-    return fn
-  }
-
-  throw new Error(`Method "${fn}" does not exist.`)
-}
-
-/**
- * Get the entity name from CQN and check if it exists at CSN.
- *
- * @param {object} csn - Reflected CSN
- * @param {string} from - Entity name
- * @returns {string|undefined}
- * @private
- */
-const _getEntityName = (csn, from) => {
-  if (!from.ref || typeof csn !== 'object') {
-    return
-  }
-
-  let entityName = from.ref[0].id ? from.ref[0].id : from.ref[0]
-
-  if (csn.definitions && csn.definitions[entityName]) {
-    return entityName
-  }
-
-  // REVISIT: Find better solution
-  entityName = entityName.replace(/_drafts$/i, '')
-
-  if (csn.definitions && csn.definitions[entityName]) {
-    return entityName
-  }
-}
+const { getEntityNameFromCQN, traverseFroms } = require('../../common/utils/entityFromCqn')
+const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { proxifyIfFlattened } = require('../../../common/utils/ucsn')
+const cds = require('../../../../lib')
 
 const _refs = (refs, as) => {
   const arr = []
@@ -90,114 +47,135 @@ const _extractRefs = (from, as) => {
   return [ref]
 }
 
-// REVISIT: check why we need includeAlias for some draft cases (check AFC tests)
-const _addMapperFunction = (elements, toService, key, type, alias, includeAlias) => {
-  if (!toService.has(type)) {
-    return
-  }
-
-  const convertFunction = _getMethod(toService.get(type))
-
-  // ambiguous cases will lead to SQL syntax errors anyway, so no need for a check
-  elements.set(key, convertFunction)
-  if (includeAlias && alias) {
-    elements.set(`${alias}_${key}`, convertFunction)
+const _getCastFunction = ({ type }) => {
+  switch (type) {
+    case 'cds.Boolean':
+      return Boolean
+    case 'cds.Integer':
+      return Number
+    default:
+      return String
   }
 }
 
-const _filterUnique = (value, index, arr) => {
-  return arr.indexOf(value) === index
-}
-
-const _addMapperFunction4struct = (elements, toService, parent, struct, alias, includeAlias) => {
-  for (const k in struct.elements) {
-    const current = struct.elements[k]
-    if (current._isStructured) {
-      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, alias, includeAlias)
-    } else {
-      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, alias, includeAlias)
-    }
+const _structElement = (definition, structPath) => {
+  if (definition.elements) {
+    return _structElement(definition.elements[structPath[0]], structPath.slice(1))
   }
-}
 
-/**
- * Get a map of all possible elements and their mappers.
- *
- * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
- * @param {object} csn - Reflected CSN
- * @param {object} cqn - CQN that is used to query the DB.
- * @returns {Map<any, any>}
- * @private
- */
-const _getElementCombinations = (toService, csn, cqn, includeAlias = false) => {
-  const elements = new Map()
+  return definition
+}
 
-  // Get list of available and relevant entities as defined by from
-  for (const from of _extractRefs(cqn.SELECT.from).filter(_filterUnique)) {
-    const entityName = _getEntityName(csn, from)
+const _getNestedElement = (entity, key) => {
+  if (entity.elements[key]) return entity.elements[key]
 
-    if (!entityName) {
-      continue
-    }
+  const structPath = entity._flat2struct[key]
+  if (!structPath) return
 
-    const entity = csn.definitions[ensureUnlocalized(entityName)]
-    for (const key in entity.elements) {
-      const element = entity.elements[key]
-      if (element._isStructured) {
-        _addMapperFunction4struct(elements, toService, key, element, from.as, includeAlias)
-      } else {
-        if ('SET' in cqn.SELECT.from) {
-          _addMapperFunction(elements, toService, key, element.type, cqn.SELECT.from.as, includeAlias)
-        } else {
-          _addMapperFunction(elements, toService, key, element.type, from.as, includeAlias)
-        }
-      }
-    }
-  }
+  return _structElement(entity, structPath)
+}
 
-  return elements
+const _structure = csnEntity => (value, key, row, unaliasedKey) => {
+  proxifyIfFlattened(csnEntity, row)
+  const effectiveKey = unaliasedKey || key
+  delete row[effectiveKey]
+  row[effectiveKey] = value
 }
 
-const _getCastFunction = ({ type }) => {
-  switch (type) {
-    case 'cds.Boolean':
-      return Boolean
-    case 'cds.Integer':
-      return Number
-    default:
-      return String
+const _addConverter = (mapper, name, converter) => {
+  if (mapper.has(name)) {
+    const oldConverter = mapper.get(name)
+    mapper.set(name, (val, key, row, unaliasedKey) => {
+      oldConverter(val, key, row, unaliasedKey)
+      converter(row[unaliasedKey || key], key, row, unaliasedKey)
+    })
+  } else {
+    mapper.set(name, converter)
   }
 }
 
 /**
  * Get a map of to be converted elements and their conversion functions.
  *
- * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
+ * @param {Map} conversionMap - Mapping instructions for data conversions based on CDS data types
  * @param {object} csn - Reflected CSN
  * @param {object} cqn - CQN that is used to query the DB.
  * @returns {Map<any, any>}
  * @private
  */
-const _getMapperForListedElements = (toService, csn, cqn) => {
-  const elements = _getElementCombinations(toService, csn, cqn, true)
+// eslint-disable-next-line complexity
+const _getMapperForListedElements = (conversionMap, csn, cqn) => {
   const mapper = new Map()
 
-  for (const element of cqn.SELECT.columns) {
-    if (element.ref) {
-      const identifier = element.ref.length === 1 ? element.ref[0] : undefined
-      const name = element.as ? element.as : identifier
+  const alias2entity = {}
+  if (cqn.SELECT.from.args) {
+    for (const each of cqn.SELECT.from.args) {
+      const { entityName, alias } = getEntityNameFromCQN(each)
+      let as = each.as || alias
+      if (as) as = ensureNoDraftsSuffix(as) // > in comp2one, the alias gets suffixed with "_drafts"
+      alias2entity[as] =
+        csn.definitions[ensureNoDraftsSuffix(entityName)] || csn.definitions[entityName.replace(/\.drafts$/, '')]
+    }
+    // additionally, for deeply nested args, find pairs of single-element ref + as and build alias to entity mapping
+    const ref2as = []
+    traverseFroms(cqn.SELECT.from, from => ref2as.push({ ref: from.ref, as: from.as }))
+    for (const each of ref2as) {
+      alias2entity[each.as] =
+        csn.definitions[ensureNoDraftsSuffix(each.ref[0])] || csn.definitions[each.ref[0].replace(/\.drafts$/, '')]
+    }
+  } else {
+    const { entityName } = getEntityNameFromCQN(cqn)
+    alias2entity[0] = csn.definitions[ensureNoDraftsSuffix(entityName)]
+  }
+
+  for (const col of cqn.SELECT.columns) {
+    if (col.cast) {
+      const name = col.as ? col.as : col.ref[col.ref.length - 1]
+      _addConverter(mapper, name, (val, key, row, unaliasedKey) => {
+        row[unaliasedKey || key] = _getCastFunction(col.cast)(val)
+      })
+      continue
+    }
+    if (col.ref) {
+      const name = col.ref[col.ref.length - 1]
+
+      const entity =
+        col.ref.length > 1
+          ? alias2entity[col.ref[0]] || alias2entity[0]
+          : alias2entity[0] || alias2entity[getEntityNameFromCQN(cqn).alias]
+      if (!entity) {
+        // REVISIT: should not be necessary, but HasActiveEntity is not always prefixed with alias
+        if (col.ref.length === 1 && col.ref[0] === 'HasActiveEntity')
+          _addConverter(mapper, col.as ? col.as : name, (val, key, row, unaliasedKey) => {
+            row[unaliasedKey || key] = conversionMap.get('cds.Boolean')(val)
+          })
+        continue
+      }
+
+      const element = _getNestedElement(entity, name)
+      if (!element) continue
+
+      // REVISIT: _type is undefined for cds.hana.CLOB etc.
+      const type = element._type || element.type
+      if (conversionMap.has(type)) {
+        _addConverter(mapper, col.as ? col.as : name, (val, key, row, unaliasedKey) => {
+          row[unaliasedKey || key] = conversionMap.get(type)(val)
+        })
+      } else if (element.items) {
+        _addConverter(mapper, col.as ? col.as : name, (val, key, row, unaliasedKey) => {
+          const effectiveKey = unaliasedKey || key
+          row[effectiveKey] = JSON.parse(val)
+        }) // > arrayed elements
+      }
 
-      if (element.cast) {
-        mapper.set(name, _getCastFunction(element.cast))
-      } else if (elements.has(name)) {
-        mapper.set(name, elements.get(name))
-      } else if (elements.has(identifier)) {
-        mapper.set(name, elements.get(identifier))
-      } else if (elements.has(element.ref.join('_'))) {
-        mapper.set(name || element.ref[element.ref.length - 1], elements.get(element.ref.join('_')))
+      if (
+        cds.env.features.ucsn_struct_conversion &&
+        element.parent &&
+        element.parent._isStructured &&
+        !element._isStructured
+      ) {
+        _addConverter(mapper, col.as ? col.as : name, _structure(entity))
       }
-    } else if (element.as && element.cast) {
-      mapper.set(element.as, _getCastFunction(element.cast))
     }
   }
 
@@ -207,143 +185,25 @@ const _getMapperForListedElements = (toService, csn, cqn) => {
 /**
  * Based on CSN and CQN get a map on how to map the result.
  *
- * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
+ * @param {Map} conversionMap - Mapping instructions for data conversions based on CDS data types
  * @param {object} csn - Reflected CSN
  * @param {object} cqn - CQN that is used to query the DB.
  * @returns {Map<any, any>}
  * @private
  */
-const getPostProcessMapper = (toService, csn = {}, cqn = {}) => {
+const getPostProcessMapper = (conversionMap, csn = {}, cqn = {}) => {
   // No mapper defined or irrelevant as no READ request
   if (!Object.prototype.hasOwnProperty.call(cqn, 'SELECT')) {
     return new Map()
   }
 
-  if (Array.isArray(cqn.SELECT.columns) && cqn.SELECT.columns.length !== 0 && !cqn.SELECT.columns.includes('*')) {
-    return _getMapperForListedElements(toService, csn, cqn)
-  }
-
-  // No element/column specified
-  return _getElementCombinations(toService, csn, cqn)
-}
-
-const _getCombineStructureConvert = (structure, columnName, propName, fn) => {
-  const length = structure.length
-
-  return row => {
-    if (row[columnName] === undefined) {
-      return
-    }
-
-    if (!row[structure[0]]) {
-      row[structure[0]] = {}
-    }
-
-    let subObj = row[structure[0]]
-
-    for (let i = 1; i < length; i++) {
-      subObj = subObj[structure[i]] = {}
-    }
-
-    subObj[propName] = fn ? fn(row[columnName]) : row[columnName]
-
-    delete row[columnName]
-  }
-}
-
-const _getCombineRenameConvert = (columnName, propName, fn) => {
-  return row => {
-    if (row[columnName] === undefined) {
-      return
-    }
-
-    row[propName] = fn ? fn(row[columnName]) : row[columnName]
-    delete row[columnName]
-  }
-}
-
-const _getConvert = (columnName, fn) => {
-  return row => {
-    row[columnName] = fn(row[columnName])
-  }
-}
-
-const _getRemoveMapper = (mapper, propName) => {
-  if (mapper) {
-    const fn = mapper.get(propName)
-    mapper.delete(propName)
-
-    return fn
-  }
+  return cqn.SELECT.columns ? _getMapperForListedElements(conversionMap, csn, cqn) : new Map()
 }
 
-const _propertyMapper = (dataMapper, propertyMapper, objStructMapper, mapper) => {
-  if (!propertyMapper) {
-    return
-  }
-
-  for (const [columnName, propName] of propertyMapper.entries()) {
-    const fn = _getRemoveMapper(dataMapper, propName)
-    const structure = _getRemoveMapper(objStructMapper, propName)
-
-    mapper.push(
-      structure
-        ? _getCombineStructureConvert(structure, columnName, propName, fn)
-        : _getCombineRenameConvert(columnName, propName, fn)
-    )
-  }
-}
-
-const _objStructMapper = (dataMapper, propertyMapper, objStructMapper, mapper) => {
-  if (!objStructMapper) {
-    return
-  }
-
-  for (const [propName, structure] of objStructMapper.entries()) {
-    mapper.push(_getCombineStructureConvert(structure, propName, propName, _getRemoveMapper(dataMapper, propName)))
-  }
-}
-
-const _dataMapper = (dataMapper, propertyMapper, objStructMapper, mapper) => {
-  if (!dataMapper) {
-    return
-  }
-
-  for (const [columnName, converter] of dataMapper.entries()) {
-    mapper.push(_getConvert(columnName, converter))
-  }
-}
-
-/**
- * Generate the mapper per row up front, so that we do not have to iterate over possibly three mappers
- *
- * @param dataMapper
- * @param propertyMapper
- * @param objStructMapper
- * @returns {Array}
- * @private
- */
-const _combineMappers = (dataMapper, propertyMapper, objStructMapper) => {
-  const mapper = []
-
-  // Technical names + optionally structure and/or type conversions
-  _propertyMapper(dataMapper, propertyMapper, objStructMapper, mapper)
-
-  // Deep structures + optionally type conversions
-  _objStructMapper(dataMapper, propertyMapper, objStructMapper, mapper)
-
-  // type conversion
-  _dataMapper(dataMapper, propertyMapper, objStructMapper, mapper)
-
-  return mapper
-}
-
-const _processRow = (mapper, mapperCount, row) => {
-  // REVISIT: when is this the case?
+const _processRow = (mapper, row) => {
   if (!row) return
-
-  for (let i = 0; i < mapperCount; i++) {
-    mapper[i](row)
+  for (const [columnName, converter] of mapper.entries()) {
+    converter(row[columnName], columnName, row)
   }
 }
 
@@ -351,179 +211,25 @@ const _processRow = (mapper, mapperCount, row) => {
  * Post process the result as given by the db driver.
  *
  * @param {*} result - The result as returned by the db driver.
- * @param {Map} dataMapper - Instructions, how to transform.
+ * @param {Map} mapper - Instructions, how to transform.
  * @param {Map} propertyMapper - Instructions, how to rename properties.
  * @param {Map} objStructMapper - Instructions, how to rename properties.
  * @returns {*}
  * @private
  */
-const postProcess = (result, dataMapper, propertyMapper, objStructMapper) => {
-  const mapper = _combineMappers(dataMapper, propertyMapper, objStructMapper)
-  const mapperCount = mapper.length
+const postProcess = (result, mapper = new Map()) => {
+  if (mapper.size === 0) return result
 
-  if (mapperCount === 0) {
-    return result
-  }
-
-  if (Array.isArray(result)) {
-    for (let i = 0, length = result.length; i < length; i++) {
-      _processRow(mapper, mapperCount, result[i])
-    }
-  } else {
-    _processRow(mapper, mapperCount, result)
-  }
+  if (Array.isArray(result)) for (const each of result) _processRow(mapper, each)
+  else _processRow(mapper, result)
 
   return result
 }
 
-const _checkExpressionsAmbiguousNaming = (csn, entity, element) => {
-  if (!entity.as || !Array.isArray(element.ref)) {
-    return
-  }
-
-  if (
-    entity.as === element.ref[0] &&
-    csn.definitions[entity.ref[0]] &&
-    csn.definitions[entity.ref[0]].elements[element.ref[1]] &&
-    csn.definitions[entity.ref[0]].elements[element.ref[0]] &&
-    csn.definitions[entity.ref[0]].elements[element.ref[0]].isAssociation
-  ) {
-    throw new Error(`Ambiguous entity property and alias name: "${entity.as}"`)
-  }
-}
-
-const _checkColumnsAmbiguousNaming = (csn, entity, columns) => {
-  for (const element of columns) {
-    _checkExpressionsAmbiguousNaming(csn, entity, element)
-  }
-}
-
-const _checkJoinAmbiguousNaming = (csn, select) => {
-  for (const subSelect of select.from.args) {
-    if (Array.isArray(select.columns)) {
-      _checkColumnsAmbiguousNaming(csn, subSelect, select.columns)
-    }
-  }
-}
-
-const _checkSelectAmbiguousNaming = (csn, select) => {
-  if (Array.isArray(select.columns)) {
-    _checkColumnsAmbiguousNaming(csn, select.from, select.columns)
-  }
-}
-
-const _checkRecursiveSelectAmbiguousNaming = (csn, select) => {
-  if (select.from.SELECT) {
-    _checkRecursiveSelectAmbiguousNaming(csn, select.from.SELECT)
-  } else if (select.from.join) {
-    _checkJoinAmbiguousNaming(csn, select)
-  } else if (select.from.as) {
-    // Check innermost select statement
-    _checkSelectAmbiguousNaming(csn, select)
-  }
-}
-
-const getStructMapper = (csn, cqn, propertyMapper) => {
-  if (csn && cqn.SELECT) {
-    _checkRecursiveSelectAmbiguousNaming(csn, cqn.SELECT)
-  }
-
-  // REVISIT still needed?
-
-  return new Map()
-}
-
-const _addToMap = (map, key) => {
-  const allUpperKey = key.toUpperCase()
-
-  if (key === allUpperKey) {
-    return
-  }
-
-  map.set(allUpperKey, key)
-}
-
-const _addColumn = (map, from, element) => {
-  _addToMap(map, element)
-
-  if (from.ref[0] && from.ref[0].id) {
-    _addToMap(map, `${from.ref[0].id}.${element}`)
-  } else {
-    if (from.ref) {
-      _addToMap(map, `${from.ref.join('.')}.${element}`)
-    }
-  }
-
-  if (from.as) {
-    _addToMap(map, `${from.as}.${element}`)
-  }
-}
-
-const _addAssociationToMap = (map, from, element) => {
-  const assocs = element.keys ? element.keys.map(key => `${element.name}_${key.ref[0]}`) : []
-  for (const assocName of assocs) {
-    _addColumn(map, from, assocName)
-  }
-}
-
-const _addComplexTypeToMap = (map, from, name, element) => {
-  for (const complexName in element.elements) {
-    _addColumn(map, from, `${name}_${complexName}`)
-  }
-}
-
-const _getKeyMapForAllElements = (csn, cqn) => {
-  const map = new Map()
-
-  // Get list of available and relevant entities as defined by from
-  for (const from of _extractRefs(cqn.SELECT.from)) {
-    const entityName = _getEntityName(csn, from)
-
-    if (!entityName) {
-      continue
-    }
-
-    for (const name in csn.definitions[entityName].elements) {
-      const element = csn.definitions[entityName].elements[name]
-
-      if (element.isAssociation) {
-        _addAssociationToMap(map, from, element)
-      } else if (element._isStructured) {
-        _addComplexTypeToMap(map, from, name, element)
-      } else {
-        _addColumn(map, from, name)
-      }
-    }
-  }
-
-  return map
-}
-
-/**
- * Provide a map with to be renamed properties.
- *
- * @param {object} csn - Reflected CSN
- * @param {object} cqn - CQN that is used to query the DB.
- * @returns {Map<any, any>}
- */
-const getPropertyMapper = (csn, cqn) => {
-  if (
-    cds.env.sql.names === 'plain' &&
-    cqn.SELECT &&
-    (cqn.SELECT.columns === undefined || (cqn.SELECT.columns && cqn.SELECT.columns.includes('*')))
-  ) {
-    return _getKeyMapForAllElements(csn, cqn)
-  }
-
-  return new Map()
-}
-
 /*
  * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
  */
 module.exports = {
-  getPropertyMapper,
   getPostProcessMapper,
-  getStructMapper,
   postProcess
 }