@sap/cds 5.8.4 → 5.9.2

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)
   }
 }