@sap/cds 5.6.1 → 5.7.1

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

@@ -6,54 +6,13 @@ const getEtagElement = entity => {
   return Object.values(entity.elements).find(element => element['@odata.etag'])
 }
 
-const _isDependent = (assoc, parent, target) => {
-  return (
-    assoc._isAssociationStrict &&
-    assoc.is2one &&
-    !assoc.on &&
-    !parent['@cds.persistence.skip'] &&
-    assoc['@assert.integrity'] !== false &&
-    parent['@assert.integrity'] !== false &&
-    (!parent._service || parent._service['@assert.integrity'] !== false) &&
-    !assoc._isCompositionBacklink
-  )
-}
-
-/*
- * this modifies the csn on purpose for caching effect!
- * doing as aspect is difficult due to no global definitons per tenant
- */
-const getDependents = (entity, model) => {
-  if (entity.own('__dependents')) return entity.__dependents
-
-  /** @type {Array|boolean} */
-  let dependents = []
-  for (const def of Object.values(model.definitions)) {
-    if (def.kind !== 'entity') continue
-    if (!def.associations) continue
-
-    for (const assoc of Object.values(def.associations)) {
-      if (assoc.target !== entity.name) continue
-
-      const parent = assoc.parent
-      const target = model.definitions[assoc.target]
-      if (_isDependent(assoc, parent, target)) {
-        dependents.push({ element: assoc, parent, target })
-      }
-    }
-  }
-
-  if (dependents.length === 0) dependents = false
-  return entity.set('__dependents', dependents)
-}
-
 const _getUps = (entity, model) => {
   const ups = []
   for (const def of Object.values(model.definitions)) {
-    if (def.kind !== 'entity') continue
-    if (!def.associations) continue
+    if (def.kind !== 'entity' || !def.associations) continue
     for (const element of Object.values(def.associations)) {
       if (element.target !== entity.name || element._isBacklink) continue
+      if (element.name === 'SiblingEntity') continue
       ups.push(element)
     }
   }
@@ -64,26 +23,50 @@ const _ifDataSubject = (entity, role) => {
   return entity['@PersonalData.EntitySemantics'] === 'DataSubject' && entity['@PersonalData.DataSubjectRole'] === role
 }
 
-const _getDataSubjectUp = (role, model, element, first = element) => {
-  const upElements = _getUps(element.parent, model)
-  for (const element of upElements) {
+const _getDataSubjectUp = (role, model, entity, prev, next, result) => {
+  for (const element of _getUps(entity, model)) {
+    const me = { entity, relative: element.parent, element }
+    if (prev) prev.next = me
     if (_ifDataSubject(element.parent, role)) {
-      return { element: first, up: { element }, entity: element.parent }
+      if (!result) result = { dataSubjectEntity: element.parent, subs: [] }
+      result.subs.push(next || me)
+      return result
+    } else {
+      // dfs is a must here
+      result = _getDataSubjectUp(role, model, element.parent, me, next || me, result)
     }
-    // dfs is a must here
-    const dataSubject = _getDataSubjectUp(role, model, element, first)
-    if (dataSubject) {
-      dataSubject.up = { element, up: dataSubject.up }
-      return dataSubject
+  }
+  return result
+}
+
+const _getDataSubjectDown = (role, entity, prev, next) => {
+  const associations = Object.values(entity.associations).filter(e => !e._isBacklink)
+  for (const element of associations) {
+    const me = { entity, relative: entity, element }
+    if (_ifDataSubject(element._target, role)) {
+      if (prev) prev.next = me
+      return { dataSubjectEntity: element._target, subs: [next || me] }
     }
   }
+  // bfs makes more sense here
+  for (const element of associations) {
+    const me = { entity, relative: entity, element }
+    if (prev) prev.next = me
+    const dataSubject = _getDataSubjectDown(role, element._target, me, next || me)
+    if (dataSubject) return dataSubject
+  }
 }
 
-const getDataSubject = (entity, model, role, element) => {
+const getDataSubject = (entity, model, role) => {
   const hash = '__dataSubject4' + role
   if (entity.own(hash)) return entity[hash]
-  if (_ifDataSubject(element.parent, role)) return entity.set(hash, { element, entity: element.parent })
-  return entity.set(hash, _getDataSubjectUp(role, model, element))
+  // entities with EntitySemantics 'DataSubjectDetails' or 'Other' must not necessarily
+  // be always below or always above 'DataSubject' entity in CSN tree
+  let dataSubject = _getDataSubjectUp(role, model, entity)
+  if (!dataSubject) {
+    dataSubject = _getDataSubjectDown(role, entity)
+  }
+  return entity.set(hash, dataSubject)
 }
 
 const _resolve = (name, model, namespace) =>
@@ -204,7 +187,6 @@ module.exports = {
   getEtagElement,
   findCsnTargetFor,
   getElementDeep,
-  getDependents,
   isRootEntity,
   getDataSubject,
   alias2ref

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

@@ -5,26 +5,26 @@ const getEntityNameFromCQN = cqn => {
 
   // Do the most likely first -> {ref}
   if (cqn.ref) {
-    return cqn.ref[0].id || cqn.ref[0]
+    return { entityName: cqn.ref[0].id || cqn.ref[0], alias: cqn.as }
   }
 
   // TODO cleanup
   // REVISIT infer should do this for req.target
   // REVISIT2 No, req.target doesn't make sense for joins
   if (cqn.SET) {
-    return cqn.SET.args.map(getEntityNameFromCQN).find(n => n !== 'DRAFT.DraftAdministrativeData')
+    return cqn.SET.args.map(getEntityNameFromCQN).find(n => n.entityName !== 'DRAFT.DraftAdministrativeData')
   }
   if (cqn.join) {
-    return cqn.args.map(getEntityNameFromCQN).find(n => n !== 'DRAFT.DraftAdministrativeData')
+    return cqn.args.map(getEntityNameFromCQN).find(n => n.entityName !== 'DRAFT.DraftAdministrativeData')
   }
+  return {}
 }
 
 // Note: This also works for the common draft scenarios
 const getEntityFromCQN = (req, service) => {
   if (!req.target || req.target._unresolved) {
-    const entity = getEntityNameFromCQN(req.query)
-    if (!entity) return
-    return service.model.definitions[ensureNoDraftsSuffix(entity)]
+    const { entityName } = getEntityNameFromCQN(req.query)
+    return entityName && service.model.definitions[ensureNoDraftsSuffix(entityName)]
   }
   return req.target
 }

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

@@ -98,17 +98,16 @@ const _newNestedData = (queryTarget, newData, ref, value) => {
   }
 }
 
+// eslint-disable-next-line complexity
 const _newData = (data, transition, inverse, service) => {
+  if (data === null) return null
   // no transition -> nothing to do
   if (transition.target && transition.target.name === transition.queryTarget.name) return data
 
+  // REVISIT this does not copy deep
   const newData = { ...data }
   const queryTarget = transition.queryTarget
 
-  /*
-   * REVISIT: the current impl results in {} instead of keeping null for compo to one.
-   *          unfortunately, many follow-up errors occur (e.g., prop in null checks) if changed.
-   */
   for (const key in newData) {
     const el = queryTarget && queryTarget.elements && queryTarget.elements[key]
     const isAssoc = el && el.isAssociation
@@ -339,7 +338,7 @@ const _newSelect = (query, transitions, service) => {
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
   if (newSelect.columns) {
     const isDB = service instanceof cds.DatabaseService
-    rewriteAsterisks({ SELECT: newSelect }, targetTransition.queryTarget, isDB)
+    rewriteAsterisks({ SELECT: newSelect }, service.model, isDB)
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)

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

@@ -1,6 +1,7 @@
 const { getNavigationIfStruct } = require('./structured')
 const getColumns = require('../../db/utils/columns')
-const { ensureDraftsSuffix } = require('./draft')
+const { ensureDraftsSuffix, ensureNoDraftsSuffix } = require('./draft')
+const { getEntityNameFromCQN } = require('./entityFromCqn')
 
 const isAsteriskColumn = col => col === '*' || (col.ref && col.ref[0] === '*' && !col.expand)
 
@@ -75,15 +76,55 @@ const _rewriteAsterisks = (cqn, target, db, isRoot) => {
   return columns
 }
 
-const rewriteAsterisks = (query, target, db = false, isDraft = false, onlyKeys = false) => {
+const _targetOfQueryIfNotDraft = (query, model) => {
+  const { entityName } = getEntityNameFromCQN(query)
+  const target = model.definitions[entityName]
   if (!target || target.name.endsWith('_drafts')) return
-  if (!query.SELECT.columns || (query.SELECT.columns && !query.SELECT.columns.length)) {
+  return target
+}
+
+const rewriteAsterisks = (query, model, db = false, isDraft = false, onlyKeys = false) => {
+  if (!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))
+      if (
+        query.SELECT.from.SET &&
+        query.SELECT.from.SET.args[0] &&
+        query.SELECT.from.SET.args[0].SELECT &&
+        query.SELECT.from.SET.args[0].SELECT.columns
+      ) {
+        // > best-effort derive column list from first join element if given
+        query.SELECT.columns = query.SELECT.from.SET.args[0].SELECT.columns.map(c => ({
+          ref: [c.as || c.ref[c.ref.length - 1]]
+        }))
+      } else if (query.SELECT.from.join && query.SELECT.from.args) {
+        if (!query.SELECT.columns) query.SELECT.columns = []
+        for (const arg of query.SELECT.from.args) {
+          const _targetName = arg.ref[0].id || arg.ref[0]
+          const _target = model.definitions[ensureNoDraftsSuffix(_targetName)]
+          const columns = getColumns(_target, { db, onlyKeys })
+            .filter(
+              c =>
+                !query.SELECT.columns.some(
+                  existing => (existing.as || existing.ref[existing.ref.length - 1]) === c.name
+                )
+            )
+            .map(col => ({
+              ref: [arg.as || _targetName, col.name]
+            }))
+          columns.forEach(c => query.SELECT.columns.push(c))
+        }
+      } else {
+        const target = _targetOfQueryIfNotDraft(query, model)
+        if (!target) return
+        query.SELECT.columns = getColumns(target, { db, onlyKeys }).map(col => ({ ref: [col.name] }))
+        if (db && target._isDraftEnabled) query.SELECT.columns.push(..._cqlDraftColumns(target))
+      }
     }
     return
   }
+  const target = _targetOfQueryIfNotDraft(query, model)
+  if (!target) return
+  // REVISIT: Also support JOINs/SETs here
   query.SELECT.columns = _rewriteAsterisks(query.SELECT, target, db, true)
 }
 

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

@@ -1,12 +1,20 @@
 const { computeColumnsToBeSearched } = require('../../../../libx/_runtime/cds-services/services/utils/columns')
 const searchToLike = require('./searchToLike')
+const { ensureNoDraftsSuffix } = require('./draft')
+const { getEntityNameFromCQN } = require('./entityFromCqn')
 
-// convert $search system query option to WHERE/HAVING clause using
-// the operator LIKE or CONTAINS
-const search2cqn4sql = (query, model, options) => {
-  const { search2cqn4sql, targetName = query.SELECT.from.ref[0] } = options
-  const entity = model.definitions[targetName]
-  const columns = computeColumnsToBeSearched(query, entity)
+const _targetFrom = (cqn, options) => {
+  if (options && options.entityName) return options
+  return getEntityNameFromCQN(cqn)
+}
+
+const _search2cqn4sql = (query, model, options = {}) => {
+  const cqnSearchPhrase = query.SELECT.search
+  if (!cqnSearchPhrase) return
+  const { search2cqn4sql } = options
+  const { entityName, alias } = _targetFrom(query.SELECT.from, options)
+  const entity = model.definitions[ensureNoDraftsSuffix(entityName)]
+  const columns = computeColumnsToBeSearched(query, entity, alias)
 
   // Call custom (optimized search to cqn for sql implementation) that tries
   // to optimize the search behavior for a specific database service.
@@ -16,11 +24,15 @@ const search2cqn4sql = (query, model, options) => {
     return search2cqn4sql(query, entity, search2cqnOptions)
   }
 
-  const cqnSearchPhrase = query.SELECT.search
   const expression = searchToLike(cqnSearchPhrase, columns)
 
   // REVISIT: find out here if where or having must be used
-  query._aggregated ? query.having(expression) : query.where(expression)
+  query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
 }
 
-module.exports = search2cqn4sql
+// convert $search system query option to WHERE/HAVING clause using
+// the operator LIKE or CONTAINS
+module.exports = (query, model, options) => {
+  if (query.SELECT.from.SET) return query.SELECT.from.SET.args.forEach(arg => _search2cqn4sql(arg, model, options))
+  return _search2cqn4sql(query, model, options)
+}

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

@@ -204,36 +204,43 @@ const _structFromRef = (ref, csnEntity, model) => {
 }
 
 const flattenStructuredWhereHaving = (filterArray, csnEntity, model) => {
-  if (filterArray) {
-    const newFilterArray = []
-    for (let i = 0; i < filterArray.length; i++) {
-      if (OPERATIONS.includes(filterArray[i + 1])) {
-        const refElement = filterArray[i].ref ? filterArray[i] : filterArray[i + 2]
-        // copy for processing
-        const ref = refElement.ref && refElement.ref.map(ele => ele)
-        // is ref[0] an alias? -> remove
-        const isAliased = ref && ref.length > 1 && !csnEntity.elements[ref[0]]
-        if (isAliased) ref.shift()
-        const { element, idx } = _structFromRef(ref, csnEntity, model)
-        // REVISIT: We cannot make the simple distinction between ref and others
-        // for xpr, subselect, we need to call this method recursively
-        if (element) {
-          if (isAliased) refElement.ref.shift()
-          // REVISIT: This does not support operator like "between", "in" or a different order of elements like val,op,ref or expressions like ref,op,val+val
-          _transformStructToFlatWhereHaving(filterArray.slice(i, i + 3), newFilterArray, element, idx)
-          i += 2 // skip next two entries e.g. ('=', '{struct:{int:1}}')
-          continue
-        }
-      }
+  if (!filterArray) return
+
+  const newFilterArray = []
+  for (let i = 0; i < filterArray.length; i++) {
+    if (OPERATIONS.includes(filterArray[i + 1])) {
+      const refElement = filterArray[i].ref ? filterArray[i] : filterArray[i + 2]
+
+      // copy for processing
+      const ref = refElement.ref && refElement.ref.map(ele => ele)
+
+      // is ref[0] an alias? -> remove
+      const isAliased = ref && ref.length > 1 && !csnEntity.elements[ref[0]]
+      if (isAliased) ref.shift()
+      const { element, idx } = _structFromRef(ref, csnEntity, model)
+
+      // REVISIT: We cannot make the simple distinction between ref and others
+      // for xpr, subselect, we need to call this method recursively
+      if (element) {
+        if (isAliased) refElement.ref.shift()
 
-      newFilterArray.push(filterArray[i])
+        // REVISIT: This does not support operator like "between", "in" or a different order of elements like val,op,ref or expressions like ref,op,val+val
+        _transformStructToFlatWhereHaving(filterArray.slice(i, i + 3), newFilterArray, element, idx)
+        i += 2 // skip next two entries e.g. ('=', '{struct:{int:1}}')
+        continue
+      }
     }
-    return newFilterArray
+
+    newFilterArray.push(filterArray[i])
   }
+
+  return newFilterArray
 }
+
 const _entityFromRef = ref => {
   if (ref) return ref[0].id || ref[0]
 }
+
 const getNavigationIfStruct = (entity, ref) => {
   const element = entity && entity.elements && entity.elements[_entityFromRef(ref)]
   if (!element) return
@@ -275,8 +282,11 @@ const flattenStructuredSelect = ({ SELECT }, model) => {
       const flattenedElements = []
       const toBeDeleted = []
       _flattenColumns(SELECT, flattenedElements, toBeDeleted, entity)
-      SELECT.columns = SELECT.columns.filter(e => (e.ref && !toBeDeleted.includes(e.ref[0])) || e.func || e.expand) // TODO aliases?
-      SELECT.columns.push(...flattenedElements)
+      SELECT.columns = SELECT.columns.filter(column => {
+        const columnName = column.ref ? column.ref[0] : column.as
+        return (columnName && !toBeDeleted.includes(columnName)) || column.func || column.expand
+      })
+      if (flattenedElements.length) SELECT.columns.push(...flattenedElements)
     }
     if (SELECT.from.args) {
       for (const arg of SELECT.from.args) {

package/libx/_runtime/db/Service.js

@@ -38,12 +38,6 @@ class DatabaseService extends cds.Service {
     // REVISIT: how to generic handler registration?
   }
 
-  set model(m) {
-    // Ensure the model we get has unfolded entities for localized data, drafts, etc.
-    // Note: cds.deploy and some tests set the model of cds.db outside the constructor
-    super.model = m && 'definitions' in m ? cds.compile.for.odata(m) : m
-  }
-
   /*
    * tx
    */

package/libx/_runtime/db/expand/expand-v2.js

@@ -0,0 +1,130 @@
+const cds = require('../../cds')
+const getColumns = require('../utils/columns')
+
+const _identifierForRow = (row, prefix, keys) => {
+  return keys.map(k => row[`${prefix}${k}`]).join(',')
+}
+
+const _removeParentKeysFromRow = (row, prefix, keys) => {
+  for (const k of keys) {
+    delete row[`${prefix}${k}`]
+  }
+}
+
+const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) => {
+  for (const nav in entity._associations) {
+    const navigation = entity._associations[nav]
+
+    // do not expand backlinks
+    if (navigation._isBacklink) continue
+
+    const childAlias = 'child'
+    const parentAlias = 'parent'
+
+    const cqnQuery = SELECT.from(`${navigation.target} as ${childAlias}`)
+      .join(`${entity.name} as ${parentAlias}`)
+      .on(entity._relations[navigation.name].join(childAlias, parentAlias))
+
+    // set alias for expanded columns already
+    const childColumns = getColumns(navigation._target).map(c => ({ ref: [childAlias, c.name] }))
+    const parentKeys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
+    // mark parent key with prefix in alias
+    const parentKeysWithAlias = parentKeys.map(pk => ({ ref: [parentAlias, pk], as: `$$pk_${pk}` }))
+    cqnQuery.columns(...childColumns, ...parentKeysWithAlias)
+
+    // add tuple comparison for where clause
+    cqnQuery.where([
+      { list: parentKeys.map(pk => ({ ref: [parentAlias, pk] })) },
+      'in',
+      { list: previousResult.map(row => ({ list: parentKeys.map(pk => ({ val: row[pk] })) })) }
+    ])
+
+    // sort by primary keys of parent, required in future
+    cqnQuery.orderBy(parentKeys.map(pk => ({ ref: [parentAlias, pk] })))
+
+    const result = await cds.db.run(cqnQuery)
+
+    // TODO: Is there a more efficient/stable way to handle compound keys?
+    const map = new Map()
+    for (const row of result) {
+      const identifier = _identifierForRow(row, '$$pk_', parentKeys)
+      _removeParentKeysFromRow(row, '$$pk_', parentKeys)
+      if (map.has(identifier)) {
+        map.get(identifier).push(row)
+      } else {
+        map.set(identifier, [row])
+      }
+    }
+
+    // link previous result with current result
+    previousResult.forEach(row => {
+      const identifier = _identifierForRow(row, '', parentKeys)
+      if (map.has(identifier)) {
+        const entry = map.get(identifier)
+        row[nav] = navigation.is2one ? entry[0] : entry
+      } else {
+        row[nav] = navigation.is2one ? null : []
+      }
+    })
+
+    // expand next level if needed
+    if (depth - 1 !== 0 && result.length && navigation._target._associations) {
+      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1)
+    }
+  }
+
+  return previousResult
+}
+
+const _foreignKeysOfTopLevelNavs = entity => {
+  const requiredFks = new Set()
+  for (const nav in entity._associations) {
+    const onCond = entity._relations[nav].join('child', 'parent')
+    for (const ele of onCond) {
+      if (ele.ref && ele.ref[0] === 'parent') {
+        requiredFks.add(ele.ref.slice(1).join('_'))
+      }
+    }
+  }
+  return [...requiredFks]
+}
+
+/**
+ * 1. Creates flattened SQL statements for each expand layer
+ * 2. Mixes in foreign keys if needed
+ * 3. Merges results
+ * 4. Cleans result if needed
+ *
+ * @returns object
+ */
+const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSelectCQN) => {
+  // remove expand columns from query without modifying
+  const topLevelSelect = query.clone().columns(query.SELECT.columns.filter(c => !c.expand))
+
+  const entity = model.definitions[topLevelSelect.SELECT.from.ref[0]]
+
+  // ensure foreign keys are selected if needed
+  const fks = _foreignKeysOfTopLevelNavs(entity)
+  fks.forEach(fk => {
+    if (!topLevelSelect.SELECT.columns.some(c => c.ref[0] === fk)) {
+      topLevelSelect.SELECT.columns.push({ ref: [fk] })
+    }
+  })
+
+  const result = await executeSelectCQN(model, dbc, topLevelSelect, user, locale, txTimestamp)
+
+  if (!result || (Array.isArray(result) && !result.length)) {
+    return result
+  }
+
+  // _associations contains compositions and associations
+  if (entity._associations) {
+    const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
+    const depth = expandColumn.expand === '**' ? -1 : Number(expandColumn.expand.replace('*', ''))
+    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth)
+  }
+
+  return result
+}
+
+module.exports = expandV2