@sap/cds 5.5.5 → 5.6.3

package/libx/_runtime/common/utils/{enrichWithKeysFromWhere.js → keys.js}

@@ -1,8 +1,23 @@
-const { getOnCondElements } = require('./backlinks')
+const { where2obj } = require('./cqn')
+
+function _getOnCondElements(onCond, onCondElements = []) {
+  const andIndex = onCond.indexOf('and')
+  const entityKey = onCond[2].ref && onCond[2].ref.join('.')
+  const entityVal = onCond[2].val
+  const targetKey = onCond[0].ref && onCond[0].ref.join('.')
+  const targetVal = onCond[0].val
+  onCondElements.push({ entityKey, targetKey, entityVal, targetVal })
+
+  if (andIndex !== -1) {
+    _getOnCondElements(onCond.slice(andIndex + 1), onCondElements)
+  }
+  return onCondElements
+}
 
 function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName) {
   if (where) {
-    const whereCopy = JSON.parse(JSON.stringify(where)) // copy where else query will be modified
+    // copy where else query will be modified
+    const whereCopy = JSON.parse(JSON.stringify(where))
     if (newWhere.length > 0) newWhere.push('and')
     newWhere.push(...whereCopy)
   }
@@ -14,7 +29,7 @@ function _modifyWhereWithNavigations(where, newWhere, targetKeyElement, keyName)
   })
 }
 
-const _buildWhereForNavigations = (ref, newWhere, model, target) => {
+function _buildWhereForNavigations(ref, newWhere, model, target) {
   const currentRef = ref[0]
   const nextRef = ref[1]
 
@@ -24,7 +39,7 @@ const _buildWhereForNavigations = (ref, newWhere, model, target) => {
 
     if (!navigationElement || !navigationElement.on) return
 
-    const nextKeys = getOnCondElements(navigationElement.on)
+    const nextKeys = _getOnCondElements(navigationElement.on)
     for (const key of nextKeys) {
       const keyName = key.targetKey.replace(navigationElement.name + '.', '')
       const targetKeyElement = navigationElement._target.elements[keyName]
@@ -55,37 +70,23 @@ function _getWhereFromUpdate(query, target, model) {
   return query.UPDATE.where
 }
 
-function _addKeysFromWhereToData(where, target, data) {
-  const whereLength = where.length
-  for (let i = 0; i < whereLength; i++) {
-    const whereEl = where[i]
-    const colName = whereEl.ref && whereEl.ref[whereEl.ref.length - 1]
-    const colEl = colName && target.elements[colName]
-    if (colEl && colEl.key) {
-      const opWhere = where[i + 1]
-      const valWhere = where[i + 2]
-      if (opWhere === '=' && valWhere && 'val' in valWhere) {
-        data[colName] = valWhere.val
-      }
-    }
-  }
-}
-
 // params: data, req, service/tx
-module.exports = (data, { query, target }, { model }) => {
+function enrichDataWithKeysFromWhere(data, { query, target }, { model }) {
   if (query.INSERT) {
     const where = _getWhereFromInsert(query, target, model)
     if (!where || !where.length) return
-
     if (!Array.isArray(data)) data = [data]
-
-    for (const d of data) {
-      _addKeysFromWhereToData(where, target, d)
-    }
+    for (const d of data) Object.assign(d, where2obj(where, target))
   } else if (query.UPDATE) {
     const where = _getWhereFromUpdate(query, target, model)
     if (!where || !where.length) return
-    if (!data) data = query.UPDATE.data = {} // REVISIT: We should not expect data to be present always!
-    _addKeysFromWhereToData(where, target, data)
+    // REVISIT: We should not expect data to be present always!
+    if (!data) data = query.UPDATE.data = {}
+    Object.assign(data, where2obj(where, target))
   }
 }
+
+module.exports = {
+  where2obj,
+  enrichDataWithKeysFromWhere
+}

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

@@ -64,6 +64,9 @@ const handleAliasInResult = (columns, result) => {
 // REVISIT: todo renaming for deep operations
 const postProcess = (query, result, service, onlySelectAliases = false) => {
   if (query.SELECT) {
+    if (query.SELECT.columns && query.SELECT.columns.find(col => col.func === 'count' && col.as === '$count')) {
+      return [{ $count: result }]
+    }
     handleAliasInResult(query.SELECT.columns, result)
 
     if (!onlySelectAliases) {

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

@@ -0,0 +1,84 @@
+const cds = require('../../cds')
+
+const _generateParentField = ({ parentElement }, row) => {
+  if (_autoGenerate(parentElement) && !row[parentElement.name]) {
+    row[parentElement.name] = cds.utils.uuid()
+  }
+}
+
+const _generateChildField = ({ deep, childElement }, childRow) => {
+  if (deep) {
+    _generateChildField(deep.propagation, childRow[deep.targetName])
+  } else if (_autoGenerate(childElement) && childRow && !childRow[childElement.name]) {
+    childRow[childElement.name] = cds.utils.uuid()
+  }
+}
+
+const _autoGenerate = e => e && e.type === 'cds.UUID' && e.key
+
+const _getNestedVal = (row, prefix) => {
+  let val = row
+  const splitted = prefix.split('_')
+  let k = ''
+
+  while (splitted.length > 0) {
+    k += splitted.shift()
+    if (k in val) {
+      val = val[k]
+      k = ''
+    } else {
+      k += '_'
+    }
+  }
+
+  return val
+}
+
+const _propagateToChid = ({ parentElement, childElement, prefix, parentFieldValue }, row, childRow) => {
+  if (!childElement) return
+  if (parentElement) {
+    if (prefix) {
+      const nested = _getNestedVal(row, prefix)
+      childRow[childElement.name] = nested[parentElement.name]
+    } else {
+      childRow[childElement.name] = row[parentElement.name]
+    }
+  } else if (parentFieldValue !== undefined) {
+    childRow[childElement.name] = parentFieldValue
+  }
+}
+
+const _propagateToParent = ({ parentElement, childElement, deep }, childRow, row) => {
+  if (deep) {
+    _propagateToParent(deep.propagation, childRow[deep.targetName], childRow)
+  }
+  if (parentElement && childElement && childRow && Object.prototype.hasOwnProperty.call(childRow, childElement.name)) {
+    row[parentElement.name] = childRow[childElement.name]
+  }
+}
+
+const propagateForeignKeys = (tKey, row, foreignKeyPropagations, isCompositionEffective) => {
+  const childRows = Array.isArray(row[tKey]) ? row[tKey] : [row[tKey]]
+
+  for (const childRow of childRows) {
+    if (!childRow) return
+
+    for (const foreignKeyPropagation of foreignKeyPropagations) {
+      if (foreignKeyPropagation.fillChild) {
+        _generateParentField(foreignKeyPropagation, row)
+        if (!isCompositionEffective) {
+          delete row[tKey]
+        } else {
+          _propagateToChid(foreignKeyPropagation, row, childRow)
+        }
+      } else {
+        _generateChildField(foreignKeyPropagation, childRow)
+        _propagateToParent(foreignKeyPropagation, childRow, row)
+      }
+    }
+  }
+}
+
+module.exports = {
+  propagateForeignKeys
+}

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

@@ -22,7 +22,7 @@ const _flattenProps = (subElement, structName, structProperties, structElement,
 
 const _resolveStructured = ({ structName, structProperties }, subElements, asRef = true) => {
   if (!subElements) {
-    return
+    return []
   }
 
   // only add from structProperties

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

@@ -2,6 +2,7 @@ const cds = require('../../cds')
 let LOG = cds.log('app')
 let _event
 const PERSISTENCE_TABLE = '@cds.persistence.table'
+const { rewriteAsterisks } = require('../../common/utils/rewriteAsterisks')
 
 const getError = require('../error')
 const { getEntityNameFromDeleteCQN, getEntityNameFromUpdateCQN } = require('../utils/cqn')
@@ -172,7 +173,7 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
     }
 
     // ensure that renaming of a redirected assoc are also respected
-    if (column.expand) {
+    if (mapped && column.expand) {
       // column.ref might be structured elements
       let def
       column.ref.forEach((ref, i) => {
@@ -186,9 +187,7 @@ const _newColumns = (columns = [], transition, service, withAlias = false) => {
       // reuse _newColumns with new transition
       const expandTarget = def._target
       const subtransition = getTransition(expandTarget, service)
-
-      // REVISIT: in edom-retailer case, mapped was undefined which lead to a type error
-      if (mapped) mapped.transition = subtransition
+      mapped.transition = subtransition
 
       newColumn.expand = _newColumns(column.expand, subtransition, service, withAlias)
     }
@@ -338,8 +337,11 @@ const _newSelect = (query, transitions, service) => {
     ref: _rewriteQueryPath(query.SELECT.from, transitions)
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
-  if (newSelect.columns)
+  if (newSelect.columns) {
+    const isDB = service instanceof cds.DatabaseService
+    rewriteAsterisks({ SELECT: newSelect }, targetTransition.queryTarget, isDB)
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
+  }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)
   if (newSelect.groupBy) newSelect.groupBy = _newColumns(newSelect.groupBy, targetTransition)
   if (newSelect.orderBy) newSelect.orderBy = _newColumns(newSelect.orderBy, targetTransition)

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

@@ -0,0 +1,94 @@
+const { getNavigationIfStruct } = require('./structured')
+const getColumns = require('../../db/utils/columns')
+const { ensureDraftsSuffix } = require('./draft')
+
+const isAsteriskColumn = col => col === '*' || (col.ref && col.ref[0] === '*' && !col.expand)
+
+const _isDuplicate = newColumn => column => {
+  if (newColumn.as) return column.as && column.as === newColumn.as
+  if (!column.ref) return
+  if (Array.isArray(newColumn)) newColumn = { ref: newColumn }
+  return newColumn.ref ? newColumn.ref.join('_') === column.ref.join('_') : newColumn === column.ref.join('_')
+}
+
+const _cqlDraftColumns = target => {
+  if (target.name.endsWith('DraftAdministrativeData')) return []
+  const draftName = ensureDraftsSuffix(target.name)
+  const subSelect = SELECT.from(draftName).columns([1])
+  for (const key in target.keys) {
+    if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [draftName, key] }])
+  }
+  return [
+    { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+    { val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } },
+    {
+      xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+      as: 'HasDraftEntity',
+      cast: { type: 'cds.Boolean' }
+    }
+  ]
+}
+
+const _expandColumn = (column, target, db) => {
+  if (!(column.ref && column.expand)) return
+  const nextTarget = getNavigationIfStruct(target, column.ref)
+  if (nextTarget && nextTarget._target && nextTarget._target.elements) _rewriteAsterisks(column, nextTarget._target, db)
+  return column
+}
+
+const rewriteExpandAsterisk = (columns, target) => {
+  const expandAllColIdx = columns.findIndex(col => {
+    if (col.ref || !col.expand) return
+    return !Array.isArray(col.expand) ? col.expand === '*' : col.expand.indexOf('*') > -1
+  })
+  if (expandAllColIdx > -1) {
+    const { expand } = columns.splice(expandAllColIdx, 1)[0]
+    for (const elName in target.elements) {
+      if (target.elements[elName]._target && !columns.find(col => col.expand && col.ref && col.ref[0] === elName)) {
+        columns.push({ ref: [elName], expand: [...expand] })
+      }
+    }
+  }
+}
+
+const _rewriteAsterisk = (columns, target, db, isRoot) => {
+  const asteriskColumnIndex = columns.findIndex(col => isAsteriskColumn(col))
+  if (asteriskColumnIndex > -1) {
+    columns.splice(
+      asteriskColumnIndex,
+      1,
+      ...getColumns(target, { db })
+        .map(c => ({ ref: [c.name] }))
+        .filter(c => !columns.find(_isDuplicate(c)) && (isRoot || c.ref[0] !== 'DraftAdministrativeData_DraftUUID'))
+    )
+  }
+}
+
+const _rewriteAsterisks = (cqn, target, db, isRoot) => {
+  if (cqn.expand === '*') cqn.expand = ['*']
+  const columns = cqn.expand || cqn.columns
+  _rewriteAsterisk(columns, target, db, isRoot)
+  rewriteExpandAsterisk(columns, target)
+  for (const column of columns) {
+    _expandColumn(column, target, db)
+  }
+  return columns
+}
+
+const rewriteAsterisks = (query, target, db = false, isDraft = false, onlyKeys = false) => {
+  if (!target || target.name.endsWith('_drafts')) return
+  if (!query.SELECT.columns || (query.SELECT.columns && !query.SELECT.columns.length)) {
+    if (isDraft || db) {
+      query.SELECT.columns = getColumns(target, { db, onlyKeys }).map(col => ({ ref: [col.name] }))
+      if (db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
+    }
+    return
+  }
+  query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, db, true)
+}
+
+module.exports = {
+  rewriteAsterisks,
+  isAsteriskColumn,
+  rewriteExpandAsterisk
+}

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

@@ -3,23 +3,24 @@ const searchToLike = require('./searchToLike')
 
 // convert $search system query option to WHERE/HAVING clause using
 // the operator LIKE or CONTAINS
-const search2cqn4sql = (cqn, model, options) => {
-  const { search2cqn4sql, targetName = cqn.SELECT.from.ref[0] } = options
+const search2cqn4sql = (query, model, options) => {
+  const { search2cqn4sql, targetName = query.SELECT.from.ref[0] } = options
   const entity = model.definitions[targetName]
-  const columns = computeColumnsToBeSearched(cqn, entity)
+  const columns = computeColumnsToBeSearched(query, entity)
 
-  // call custom (optimized search to cqn for sql implementation) that tries
+  // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
-  if (typeof search2cqn4sql === 'function') {
+  // Note: $search query option combined with $filter is not currently optimized
+  if (typeof search2cqn4sql === 'function' && !query.SELECT.where) {
     const search2cqnOptions = { columns, locale: options.locale }
-    return search2cqn4sql(cqn, entity, search2cqnOptions)
+    return search2cqn4sql(query, entity, search2cqnOptions)
   }
 
-  const cqnSearchPhrase = cqn.SELECT.search
+  const cqnSearchPhrase = query.SELECT.search
   const expression = searchToLike(cqnSearchPhrase, columns)
 
   // REVISIT: find out here if where or having must be used
-  cqn._aggregated ? cqn.having(expression) : cqn.where(expression)
+  query._aggregated ? query.having(expression) : query.where(expression)
 }
 
 module.exports = search2cqn4sql

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

@@ -48,57 +48,60 @@ const _getNextTarget = (model, element, currentPath = []) => {
       nextTargetName,
       nextTarget: model.definitions[nextTargetName]
     }
-  } else if (_isInlineStructured(element)) {
+  }
+
+  if (_isInlineStructured(element)) {
     return {
       nextTargetName: [...currentPath, element.name].join(DELIMITER),
       nextTarget: element.items || element
     }
   }
+
   return {}
 }
 
 /**
  *
- * @param {CSN} model: Model
- * @param {*} cache: Internal - do not use
- * @param {CSN} target: target entity which needs to be traversed
- * @param {*} param1.pick: Function to pick items. If it returns a truthy value, the item will be picked. The returned value is part of the template.
- * @param {*} param1.ignore: Function to ignore items. If it returns a truthy value, the item will be ignored.
- * @param {*} parent: The parent entity
- * @param {*} entityMap: Internal - do not use
- * @param model
- * @param targetName
- * @param parent
- * @param entityMap
+ * @param {import('@sap/cds-compiler/lib/api/main').CSN} model Model
+ * @param {Map} cache Internal - do not use
+ * @param {object} targetEntity The target entity which needs to be traversed
+ * @param {object} callbacks
+ * @param {function} callbacks.pick Callback function to pick elements. If it returns a truthy value, the element will be picked. The returned value is part of the template.
+ * @param {function} callbacks.ignore Callback function to ignore elements. If it returns a truthy value, the element will be ignored.
+ * @param {object} [parent=null] The parent entity
+ * @param {Map} [_entityMap] This parameter is an implementation side-effect — don't use it
+ * @param {array} [targetPath=[]]
  */
-function _getTemplate(model, cache, target, { pick, ignore }, parent = null, entityMap = new Map(), targetPath = []) {
+function _getTemplate(model, cache, targetEntity, callbacks, parent = null, _entityMap = new Map(), targetPath = []) {
+  const { pick, ignore } = callbacks
   const templateElements = new Map()
-  const template = { target, elements: templateElements }
-  const currentPath = [...targetPath, target.name]
-  entityMap.set(currentPath.join(DELIMITER), { template })
-
-  if (target.elements) {
-    for (const elementName in target.elements) {
-      const element = target.elements[elementName]
-      if (ignore && ignore(element, target, parent)) continue
-
-      _pick(pick, element, target, parent, templateElements, elementName)
-      if (element.items) {
-        _pick(pick, element.items, target, parent, templateElements, ['_itemsOf', elementName].join(DELIMITER))
-      }
-
-      const { nextTargetName, nextTarget } = _getNextTarget(model, element, currentPath)
-      const nextTargetCached = entityMap.get(nextTargetName)
-      if (nextTargetCached) {
-        _addCacheToTemplateElements(templateElements, elementName, nextTargetCached)
-      } else if (nextTarget) {
-        // For associations and _typed_ structured elements, there's a (cacheable) target,
-        // inline structures must be handled separately.
-        const subTemplate = _isInlineStructured(element)
-          ? _getTemplate(model, cache, nextTarget, { pick, ignore }, target, entityMap, currentPath)
-          : cache.for(nextTarget, getTemplate(model, { pick, ignore }, target, entityMap))
-        _addSubTemplate(templateElements, elementName, subTemplate)
-      }
+  const template = { target: targetEntity, elements: templateElements }
+  const currentPath = [...targetPath, targetEntity.name]
+  _entityMap.set(currentPath.join(DELIMITER), { template })
+  if (!targetEntity.elements) return template
+
+  for (const elementName in targetEntity.elements) {
+    const element = targetEntity.elements[elementName]
+    if (ignore && ignore(element, targetEntity, parent)) continue
+
+    _pick(pick, element, targetEntity, parent, templateElements, elementName)
+
+    if (element.items) {
+      _pick(pick, element.items, targetEntity, parent, templateElements, ['_itemsOf', elementName].join(DELIMITER))
+    }
+
+    const { nextTargetName, nextTarget } = _getNextTarget(model, element, currentPath)
+    const nextTargetCached = _entityMap.get(nextTargetName)
+
+    if (nextTargetCached) {
+      _addCacheToTemplateElements(templateElements, elementName, nextTargetCached)
+    } else if (nextTarget) {
+      // For associations and _typed_ structured elements, there's a (cacheable) target,
+      // inline structures must be handled separately.
+      const subTemplate = _isInlineStructured(element)
+        ? _getTemplate(model, cache, nextTarget, { pick, ignore }, targetEntity, _entityMap, currentPath)
+        : cache.for(nextTarget, getTemplate(model, { pick, ignore }, targetEntity, _entityMap))
+      _addSubTemplate(templateElements, elementName, subTemplate)
     }
   }
 
@@ -112,11 +115,11 @@ const getTemplate =
 
 const getCache = (anything, cache, newCacheFn) => {
   let _cached = cache.get(anything)
-  if (!_cached) {
-    _cached = (typeof newCacheFn === 'function' && newCacheFn(anything, cache)) || new Map()
-    _cached.for = (_usecase, _newCacheFn) => getCache(_usecase, _cached, _newCacheFn)
-    cache.set(anything, _cached)
-  }
+  if (_cached) return _cached
+
+  _cached = (typeof newCacheFn === 'function' && newCacheFn(anything, cache)) || new Map()
+  _cached.for = (_usecase, _newCacheFn) => getCache(_usecase, _cached, _newCacheFn)
+  cache.set(anything, _cached)
   return _cached
 }
 
@@ -124,11 +127,13 @@ module.exports = (usecase, tx, target, ...args) => {
   // get model first as it may be added to tx (cf. "_ensureModel")
   const model = tx.model
   if (!model) return
+
   // double-check with get target from model
   // since target might come from anywhere like via cqn etc
   if (!target) return
   const root = (model && model.definitions[target.name]) || (target.elements && target)
   if (!root) return
+
   // tx could be the service itself
   // prefer ApplicationService (i.e., tx.context._tx.__proto__)
   // REVISIT: context._tx is not a stable API -> pls do not rely on that
@@ -136,10 +141,13 @@ module.exports = (usecase, tx, target, ...args) => {
     ? (tx.context._tx && Object.getPrototypeOf(tx.context._tx)) || Object.getPrototypeOf(tx)
     : tx
   if (!service) return
+
   // cache templates at service for garbage collection
-  if (!service._templateCache) service._templateCache = new Map()
+  if (usecase && !service._templateCache) service._templateCache = new Map()
   // model can be also a subset from tx
-  return getCache(usecase, service._templateCache)
+
+  // if no usecase, don't save cache on the service object
+  return getCache(usecase, usecase ? service._templateCache : new Map())
     .for(model)
     .for(root, getTemplate(model, ...args))
 }

package/libx/_runtime/db/Service.js

@@ -109,6 +109,7 @@ class DatabaseService extends cds.Service {
         if (query && (!streamQuery.SELECT.columns || streamQuery.SELECT.columns.length !== 0)) {
           streamQuery.columns([query])
         }
+
         delete streamQuery.SELECT.one
         streamQuery._streaming = true
 
@@ -119,12 +120,18 @@ class DatabaseService extends cds.Service {
           }
         })
 
-        if (!streamQuery.SELECT.where) {
+        if (
+          !streamQuery.SELECT.where &&
+          !(
+            streamQuery.SELECT.from &&
+            streamQuery.SELECT.from.ref &&
+            streamQuery.SELECT.from.ref[streamQuery.SELECT.from.ref.length - 1].where
+          )
+        ) {
           return {
             where: (...args) => {
               streamQuery.where(...args)
               this._runStream(streamQuery, result)
-
               return result
             }
           }