@sap/cds 5.8.2 → 5.9.0

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

@@ -1,30 +1,21 @@
 const resolveStructured = require('./resolveStructured')
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { traverseFroms } = require('../../common/utils/entityFromCqn')
 // TODO move to commons as also used in cqn2cqn4sql
-const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
-
-const _getEntityNames = from => {
-  if (from.ref) {
-    return [ensureNoDraftsSuffix(from.ref[0])]
-  }
-
-  if (from.SET) {
-    return Array.from(
-      from.SET.args.reduce((set, elem) => {
-        for (const entityName of _getEntityNames(elem.SELECT.from)) {
-          set.add(entityName)
-        }
-        return set
-      }, new Set())
-    )
-  }
-
-  if (Array.isArray(from.args)) {
-    // TODO this only considers first level refs and not from sub selects
-    return from.args.filter(arg => arg.ref).map(arg => ensureNoDraftsSuffix(arg.ref[0]))
-  }
-
-  return []
+const OPERATIONS_MAP = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in'].reduce((acc, cur) => {
+  acc[cur] = 1
+  return acc
+}, {})
+
+const _getEntityNamesAndIds = from => {
+  const nameAndIds = []
+  traverseFroms(from, from => {
+    const nameAndId = { name: ensureNoDraftsSuffix(from.ref[0].id || from.ref[0]), id: from.as || from.ref[0] }
+    if (nameAndIds.some(x => x.name === nameAndId.name)) return // no duplicates
+    nameAndIds.push(nameAndId)
+  })
+
+  return nameAndIds
 }
 
 const _flattenStructuredInExpand = (column, { _target: expandedEntity }) => {
@@ -117,8 +108,8 @@ const _filterForStructProperty = (structElement, structData, op, prefix = '', na
       )
     } else {
       if (element.isAssociation) continue
-      if (element['@odata.foreignKey4']) {
-        const assocName = element['@odata.foreignKey4']
+      const assocName = element._foreignKey4
+      if (assocName) {
         const assoc = structElement.elements[assocName]
         if (assoc.is2one && !assoc.on) {
           for (const key in assoc._target.keys) {
@@ -214,7 +205,7 @@ const flattenStructuredWhereHaving = (filterArray, csnEntity, model) => {
 
   const newFilterArray = []
   for (let i = 0; i < filterArray.length; i++) {
-    if (OPERATIONS.includes(filterArray[i + 1])) {
+    if (filterArray[i + 1] in OPERATIONS_MAP) {
       const refElement = filterArray[i].ref ? filterArray[i] : filterArray[i + 2]
 
       // copy for processing
@@ -254,42 +245,47 @@ const getNavigationIfStruct = (entity, ref) => {
   return element
 }
 
-const _flattenColumns = (SELECT, flattenedElements, toBeDeleted, csnEntity) => {
+const _flattenColumns = (SELECT, flattenedElements, toBeDeleted, csnEntity, tableId) => {
   for (const column of SELECT.columns) {
     if (!column.ref) continue
 
-    // TODO aliases are not working right now
-    const structName = column.ref[0]
+    // might begin with table id
+    const cleanedUpRef = column.ref.length > 1 && column.ref[0] === tableId ? column.ref.slice(1) : column.ref
+    const structName = cleanedUpRef[0]
 
     const element = csnEntity.elements[structName]
     if (!element) continue
 
     if (column.expand) {
-      _flattenStructuredInExpand(column, getNavigationIfStruct(csnEntity, column.ref))
+      _flattenStructuredInExpand(column, getNavigationIfStruct(csnEntity, cleanedUpRef))
       continue
     }
 
     if (element._isStructured) {
       toBeDeleted.push(structName) // works with aliases?
       flattenedElements.push(
-        ...resolveStructured({ structName, structProperties: column.ref.slice(1) }, element.elements)
+        ...resolveStructured({ structName, structProperties: cleanedUpRef.slice(1) }, element.elements)
       )
     }
+    if (cleanedUpRef.length < column.ref.length) {
+      flattenedElements.forEach(e => e.ref.unshift(tableId))
+    }
   }
 }
 
 const flattenStructuredSelect = ({ SELECT }, model) => {
-  const entityNames = _getEntityNames(SELECT.from) // TODO consider alias for custom CQNs?
+  const entityNamesAndIds = _getEntityNamesAndIds(SELECT.from)
 
-  for (const entityName of entityNames) {
-    const entity = model.definitions[entityName]
+  for (const entityNameAndId of entityNamesAndIds) {
+    const entity = model.definitions[entityNameAndId.name]
+    const tableId = entityNameAndId.id
 
     if (Array.isArray(SELECT.columns) && SELECT.columns.length > 0) {
       const flattenedElements = []
       const toBeDeleted = []
-      _flattenColumns(SELECT, flattenedElements, toBeDeleted, entity)
+      _flattenColumns(SELECT, flattenedElements, toBeDeleted, entity, tableId)
       SELECT.columns = SELECT.columns.filter(column => {
-        const columnName = column.ref ? column.ref[0] : column.as
+        const columnName = column.ref ? (column.ref[0] === tableId ? column.ref[1] : column.ref[0]) : column.as
         return (columnName && !toBeDeleted.includes(columnName)) || column.func || column.expand || 'val' in column
       })
       if (flattenedElements.length) SELECT.columns.push(...flattenedElements)

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

@@ -73,15 +73,25 @@ const _getNextTarget = (model, element, currentPath = []) => {
  * @param {array} [targetPath=[]]
  */
 function _getTemplate(model, cache, targetEntity, callbacks, parent = null, _entityMap = new Map(), targetPath = []) {
-  const { pick, ignore } = callbacks
+  const { pick, ignore, flatAccess } = callbacks
   const templateElements = new Map()
   const template = { target: targetEntity, elements: templateElements }
   const currentPath = [...targetPath, targetEntity.name]
   _entityMap.set(currentPath.join(DELIMITER), { template })
-  if (!targetEntity.elements) return template
+  const elements = targetEntity.elements || targetEntity.params
+  if (!elements) return template
+
+  if (flatAccess) {
+    if (targetEntity._flat2struct) {
+      for (const elementName in targetEntity._flat2struct) {
+        const element = targetEntity._flat2struct[elementName]
+        _pick(pick, element, targetEntity, parent, templateElements, elementName)
+      }
+    }
+  }
 
-  for (const elementName in targetEntity.elements) {
-    const element = targetEntity.elements[elementName]
+  for (const elementName in elements) {
+    const element = elements[elementName]
     if (ignore && ignore(element, targetEntity, parent)) continue
 
     _pick(pick, element, targetEntity, parent, templateElements, elementName)
@@ -99,12 +109,11 @@ function _getTemplate(model, cache, targetEntity, callbacks, parent = null, _ent
       // 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))
+        ? _getTemplate(model, cache, nextTarget, callbacks, targetEntity, _entityMap, currentPath)
+        : cache.for(nextTarget, getTemplate(model, callbacks, targetEntity, _entityMap))
       _addSubTemplate(templateElements, elementName, subTemplate)
     }
   }
-
   return template
 }
 
@@ -131,7 +140,7 @@ module.exports = (usecase, tx, target, ...args) => {
   // 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)
+  const root = (model && model.definitions[target.name]) || target
   if (!root) return
 
   // tx could be the service itself

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

@@ -6,54 +6,57 @@ const _formatRowContext = (tKey, keyNames, row) => {
   return `${tKey}(${keyValuePairsSerialized})`
 }
 
-const _processElement = (processFn, row, key, elements, picked = {}, complex = false, isRoot, pathOptions) => {
-  const { segments: pathSegments } = pathOptions
-  const element = elements[key]
+const _processElement = (processFn, row, key, target, picked = {}, isRoot, path) => {
+  const element = (target.elements || target.params)[key]
   const { plain } = picked
 
-  if (plain) {
-    if (!complex && pathSegments) pathSegments.push(key)
-
-    /**
-     * @type import('../../types/api').templateProcessorProcessFnArgs
-     */
-    const elementInfo = { row, key, element, plain, isRoot, pathSegments }
-    processFn(elementInfo)
+  if (!plain) return
+  /**
+   * @type import('../../types/api').templateProcessorProcessFnArgs
+   */
+  const elementInfo = { row, key, element, target, plain, isRoot, path }
+  if (!element && target._flat2struct && target._flat2struct[key]) {
+    elementInfo.path = path.slice(0)
+    elementInfo.path.push(...target._flat2struct[key].map(key => ({ key })))
   }
+  processFn(elementInfo)
 }
 
 const _processRow = (processFn, row, template, tKey, tValue, isRoot, pathOptions) => {
   const { template: subTemplate, picked } = tValue
   const key = tKey.split(DELIMITER).pop()
 
-  _processElement(processFn, row, key, template.target.elements, picked, !!subTemplate, isRoot, pathOptions)
+  _processElement(processFn, row, key, template.target, picked, isRoot, pathOptions.path)
 
   // process deep
-  if (subTemplate) {
-    let subRows = row && row[key]
-    subRows = Array.isArray(subRows) ? subRows : [subRows]
-    _processComplex(processFn, subRows, subTemplate, key, pathOptions)
+  if (subTemplate && typeof row === 'object' && row) {
+    _processComplex(processFn, row, subTemplate, key, pathOptions)
   }
 }
 
-const _processComplex = (processFn, rows, template, tKey, pathOptions) => {
+const _processComplex = (processFn, row, template, key, pathOptions) => {
+  const value = row && row[key]
+  const _is2many = Array.isArray(value)
+  const rows = _is2many ? value : [value]
   if (rows.length === 0) return
+  const keyNames = (template.target.keys && Object.keys(template.target.keys)) || []
 
-  const segments = pathOptions.segments
-  let keyNames
-
-  for (const row of rows) {
+  for (let idx = 0; idx < rows.length; idx++) {
+    const row = rows[idx]
     if (row == null) continue
     const args = { processFn, row, template, isRoot: false, pathOptions }
 
+    let url
     if (pathOptions.includeKeyValues) {
-      keyNames = keyNames || (template.target.keys && Object.keys(template.target.keys)) || []
-      pathOptions.rowKeysGenerator(keyNames, row, template)
-      const pathSegment = _formatRowContext(tKey, keyNames, { ...row, ...pathOptions.extraKeys })
-      args.pathOptions.segments = segments ? [...segments, pathSegment] : [pathSegment]
+      if (pathOptions.rowKeysGenerator) pathOptions.rowKeysGenerator(keyNames, row, template)
+      url = _formatRowContext(key, keyNames, Object.assign({}, row, pathOptions.extraKeys))
     }
 
+    if (pathOptions.path) pathOptions.path.push({ key, idx: _is2many && idx, url })
+
     templateProcessor(args)
+
+    if (pathOptions.path) pathOptions.path.pop()
   }
 }
 
@@ -61,10 +64,7 @@ const _processComplex = (processFn, rows, template, tKey, pathOptions) => {
  * @param {import("../../types/api").TemplateProcessor} args
  */
 const templateProcessor = ({ processFn, row, template, isRoot = true, pathOptions = {} }) => {
-  const segments = pathOptions.segments && [...pathOptions.segments]
-
   for (const [tKey, tValue] of template.elements) {
-    if (segments) pathOptions.segments = [...segments]
     _processRow(processFn, row, template, tKey, tValue, isRoot, pathOptions)
   }
 }