@sap/cds 5.4.6 → 5.5.0

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

@@ -1,6 +1,7 @@
 const { getNavigationIfStruct } = require('./structured')
 const getColumns = require('../../db/utils/columns')
 const _isAsteriskCol = col => col === '*' || (col.ref && col.ref[0] === '*')
+const cds = require('../../../../libx/_runtime/cds')
 
 const _isDraft = req => {
   return (
@@ -10,43 +11,62 @@ const _isDraft = req => {
   )
 }
 
-const _rewriteExpandAsterisks = (expand, entity, refs) => {
+const _getColumns = target => {
+  const columns = getColumns(target)
+  return columns.map(col => ({ ref: [col.name] }))
+}
+
+const _rewriteExpandAsterisks = (column, entity, refs) => {
   const navigation = getNavigationIfStruct(entity, refs)
-  const targetEntity = navigation._target
+  const targetEntity = navigation && navigation._target
 
-  expand.forEach(col => {
-    if (col.ref && col.expand) {
-      _rewriteExpandAsterisks(col.expand, targetEntity, col.ref)
-    }
-  })
+  if (Array.isArray(column.expand) && targetEntity) {
+    column.expand.forEach(col => {
+      if (col.ref && col.expand) {
+        _rewriteExpandAsterisks(col, targetEntity, col.ref)
+      }
+    })
+  }
+
+  if (column.expand === '*') {
+    column.expand = _getColumns(targetEntity)
+    return
+  }
 
-  const asteriskColumnIndex = expand.findIndex(col => _isAsteriskCol(col))
+  if (Array.isArray(column.expand)) {
+    const asteriskColumnIndex = column.expand.findIndex(col => _isAsteriskCol(col))
+    if (asteriskColumnIndex === -1) return // * not found
 
-  if (asteriskColumnIndex !== -1) {
-    expand.splice(asteriskColumnIndex, 1)
-    getColumns(targetEntity).forEach(col => {
-      expand.push({ ref: [col.name] })
+    column.expand.splice(asteriskColumnIndex, 1)
+    const columns = getColumns(targetEntity)
+    columns.forEach(col => {
+      column.expand.push({ ref: [col.name] })
     })
   }
 }
 
 const _rewriteAsterisks = req => {
-  if (!_isDraft(req) && req.query.SELECT && req.query.SELECT.columns) {
-    const asteriskColumnIndex = req.query.SELECT.columns.findIndex(col => _isAsteriskCol(col))
-
-    if (asteriskColumnIndex !== -1) {
-      req.query.SELECT.columns.splice(asteriskColumnIndex, 1)
-      getColumns(req.target).forEach(col => {
-        req.query.SELECT.columns.push({ ref: [col.name] })
-      })
-    }
+  if (_isDraft(req) || !req.query.SELECT) return
 
-    req.query.SELECT.columns.forEach(col => {
-      if (col.ref && col.ref[0] !== 'DraftAdministrativeData' && col.expand && req.target) {
-        _rewriteExpandAsterisks(col.expand, req.target, col.ref)
-      }
-    })
+  if (cds.env.features.odata_new_parser && !req.query.SELECT.columns) {
+    req.query.SELECT.columns = _getColumns(req.target)
+    return
   }
+
+  if (!req.query.SELECT.columns) return
+  const columnsIncludesAsterisk = req.query.SELECT.columns.some(col => _isAsteriskCol(col))
+
+  if (columnsIncludesAsterisk) {
+    const expandColumns = req.query.SELECT.columns.filter(column => column.expand)
+    const columns = _getColumns(req.target)
+    req.query.SELECT.columns = expandColumns.length ? [...columns, ...expandColumns] : columns
+  }
+
+  req.query.SELECT.columns.forEach(col => {
+    if (col.ref && col.ref[0] !== 'DraftAdministrativeData' && col.expand && req.target) {
+      _rewriteExpandAsterisks(col, req.target, col.ref)
+    }
+  })
 }
 
 module.exports = _rewriteAsterisks

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

@@ -36,6 +36,7 @@ const _flattenStructuredInExpand = (column, { _target: expandedEntity }) => {
       continue
     }
 
+    if (!expandElement.ref) continue
     const propertyName = expandElement.ref[expandElement.ref.length - 1]
     const element = expandedEntity.elements[expandElement.ref[0]] // TODO alias
     if (!element) continue
@@ -56,7 +57,7 @@ const _flattenStructuredInExpand = (column, { _target: expandedEntity }) => {
     column.orderBy = orderBy
   }
   column.where = flattenStructuredWhereHaving(column.where, expandedEntity)
-  column.expand = column.expand.filter(e => !toBeDeleted.includes(e.ref[e.ref.length - 1]))
+  column.expand = column.expand.filter(e => !e.ref || !toBeDeleted.includes(e.ref[e.ref.length - 1]))
   column.expand.push(...flattenedElements)
 }
 
@@ -175,7 +176,7 @@ const _transformStructToFlatWhereHaving = ([first, op, second], resArray, struct
   } catch (e) {
     /* since val === string */
   }
-  if (flattenedElement && structData === val) {
+  if (flattenedElement && (structData === val || `${structData}` === val)) {
     flattenedElement.ref.unshift(...nav)
     resArray.push(flattenedElement, op, { val })
   } else {
@@ -234,17 +235,10 @@ const _entityFromRef = ref => {
   if (ref) return ref[0].id || ref[0]
 }
 const getNavigationIfStruct = (entity, ref) => {
-  const element = entity.elements[_entityFromRef(ref)]
-
+  const element = entity && entity.elements && entity.elements[_entityFromRef(ref)]
   if (!element) return
-
-  if (element._target) return element
-
-  if (ref.length > 1) {
-    return getNavigationIfStruct(element, ref.slice(1))
-  }
-
-  return element.elements[_entityFromRef(ref)]
+  if (ref.length > 1) return getNavigationIfStruct(element._target || element, ref.slice(1))
+  return element
 }
 
 const _flattenColumns = (SELECT, flattenedElements, toBeDeleted, csnEntity) => {

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

@@ -1,3 +1,5 @@
+const DELIMITER = require('./templateDelimiter')
+
 const _addSubTemplate = (templateElements, elementName, subTemplate) => {
   if (subTemplate.elements.size > 0) {
     const t = templateElements.get(elementName)
@@ -48,7 +50,7 @@ const _getNextTarget = (model, element, currentPath = []) => {
     }
   } else if (_isInlineStructured(element)) {
     return {
-      nextTargetName: [...currentPath, element.name].join(' '),
+      nextTargetName: [...currentPath, element.name].join(DELIMITER),
       nextTarget: element.items || element
     }
   }
@@ -73,7 +75,7 @@ function _getTemplate(model, cache, target, { pick, ignore }, parent = null, ent
   const templateElements = new Map()
   const template = { target, elements: templateElements }
   const currentPath = [...targetPath, target.name]
-  entityMap.set(currentPath.join(' '), { template })
+  entityMap.set(currentPath.join(DELIMITER), { template })
 
   if (target.elements) {
     for (const elementName in target.elements) {
@@ -82,7 +84,7 @@ function _getTemplate(model, cache, target, { pick, ignore }, parent = null, ent
 
       _pick(pick, element, target, parent, templateElements, elementName)
       if (element.items) {
-        _pick(pick, element.items, target, parent, templateElements, ['_itemsOf', elementName].join(' '))
+        _pick(pick, element.items, target, parent, templateElements, ['_itemsOf', elementName].join(DELIMITER))
       }
 
       const { nextTargetName, nextTarget } = _getNextTarget(model, element, currentPath)
@@ -121,16 +123,19 @@ const getCache = (anything, cache, newCacheFn) => {
 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
-  const root = target && model && model.definitions[target.name]
+  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
   const service = tx.context
     ? (tx.context._tx && Object.getPrototypeOf(tx.context._tx)) || Object.getPrototypeOf(tx)
     : tx
-  if (!model || !service || !root) return
+  if (!service) return
   // cache templates at service for garbage collection
   if (!service._templateCache) service._templateCache = new Map()
   // model can be also a subset from tx

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

@@ -0,0 +1 @@
+module.exports = '|$|'

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

@@ -1,11 +1,12 @@
-const _formatRowContext = ({ tKey, keyNames, row }) => {
+const DELIMITER = require('./templateDelimiter')
+
+const _formatRowContext = (tKey, keyNames, row) => {
   const keyValuePairs = keyNames.map(key => `${key}=${row[key]}`)
   const keyValuePairsSerialized = keyValuePairs.join(',')
   return `${tKey}(${keyValuePairsSerialized})`
 }
 
-const _processElement = args => {
-  const { processFn, row, key, elements, picked = {}, complex = false, isRoot, pathOptions } = args
+const _processElement = (processFn, row, key, elements, picked = {}, complex = false, isRoot, pathOptions) => {
   const { segments: pathSegments } = pathOptions
   const element = elements[key]
   const { plain } = picked
@@ -13,53 +14,45 @@ const _processElement = args => {
   if (plain) {
     if (!complex && pathSegments) pathSegments.push(key)
 
-    // skip processing if row is undefined, it is not mandatory, and null is allowed
-    // where should this go? `if (row && (row[key] !== undefined || element._isMandatory || element.notNull))`
-    processFn(row, key, element, plain, isRoot, pathSegments)
+    /**
+     * @type import('../../types/api').templateProcessorProcessFnArgs
+     */
+    const elementInfo = { row, key, element, plain, isRoot, pathSegments }
+    processFn(elementInfo)
   }
 }
 
-const _processRow = ({ processFn, row, template, tKey, tValue, isRoot, pathOptions }) => {
+const _processRow = (processFn, row, template, tKey, tValue, isRoot, pathOptions) => {
   const { template: subTemplate, picked } = tValue
-  const key = tKey.split(' ').pop()
+  const key = tKey.split(DELIMITER).pop()
 
-  const args = {
-    processFn,
-    row,
-    key,
-    elements: template.target.elements,
-    picked,
-    complex: !!subTemplate,
-    isRoot,
-    pathOptions
-  }
-  _processElement(args)
+  _processElement(processFn, row, key, template.target.elements, picked, !!subTemplate, isRoot, pathOptions)
 
   // process deep
   if (subTemplate) {
     let subRows = row && row[key]
     subRows = Array.isArray(subRows) ? subRows : [subRows]
-    const complexArgs = { processFn, rows: subRows, template: subTemplate, tKey: key, pathOptions }
-    _processComplex(complexArgs)
+    _processComplex(processFn, subRows, subTemplate, key, pathOptions)
   }
 }
 
-const _processComplex = ({ processFn, rows, template, tKey, pathOptions }) => {
+const _processComplex = (processFn, rows, template, tKey, pathOptions) => {
   if (rows.length === 0) return
 
-  const segments = pathOptions.segments && [...pathOptions.segments]
-
+  const segments = pathOptions.segments
   let keyNames
+
   for (const row of rows) {
     if (row == null) continue
-
     const args = { processFn, row, template, isRoot: false, pathOptions }
+
     if (pathOptions.includeKeyValues) {
       keyNames = keyNames || (template.target.keys && Object.keys(template.target.keys)) || []
-      pathOptions.rowKeysGenerator({ keyNames, row, template })
-      const pathSegment = _formatRowContext({ tKey, keyNames, row: { ...row, ...pathOptions.extraKeys } })
+      pathOptions.rowKeysGenerator(keyNames, row, template)
+      const pathSegment = _formatRowContext(tKey, keyNames, { ...row, ...pathOptions.extraKeys })
       args.pathOptions.segments = segments ? [...segments, pathSegment] : [pathSegment]
     }
+
     templateProcessor(args)
   }
 }
@@ -71,9 +64,8 @@ const templateProcessor = ({ processFn, row, template, isRoot = true, pathOption
   const segments = pathOptions.segments && [...pathOptions.segments]
 
   for (const [tKey, tValue] of template.elements) {
-    const args = { processFn, row, template, tKey, tValue, isRoot, pathOptions }
-    if (segments) args.pathOptions.segments = [...segments]
-    _processRow(args)
+    if (segments) pathOptions.segments = [...segments]
+    _processRow(processFn, row, template, tKey, tValue, isRoot, pathOptions)
   }
 }
 

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

@@ -0,0 +1,31 @@
+const CQN_TEMPLATE_STRING = JSON.stringify(require('./unionCqnTemplate'))
+
+function getCQNUnionFrom(columns, active, draft, keys, user) {
+  let cqn = CQN_TEMPLATE_STRING
+
+  const activeCols = []
+  const draftCols = []
+  for (const col of columns) {
+    activeCols.push(`{ "ref": ["${col}"] }`)
+    draftCols.push(`{ "ref": ["${draft}", "${col}"] }`)
+  }
+  cqn = cqn.replace(/"%%ACTIVE_COLUMNS%%"/g, activeCols.join(', '))
+  cqn = cqn.replace(/"%%DRAFT_COLUMNS%%"/g, draftCols.join(', '))
+
+  cqn = cqn.replace(/%%ACTIVE%%/g, active)
+  cqn = cqn.replace(/%%DRAFT%%/g, draft)
+
+  const keyCondition = []
+  for (const key of keys) {
+    keyCondition.push(`{ "ref": ["${active}", "${key}"] }, "=", { "ref": ["${draft}", "${key}"] }`)
+  }
+  cqn = cqn.replace(/"%%KEYS%%"/g, keyCondition.join(', "and", '))
+
+  cqn = cqn.replace(/%%USER%%/g, user)
+
+  return JSON.parse(cqn)
+}
+
+module.exports = {
+  getCQNUnionFrom
+}

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

@@ -0,0 +1,184 @@
+module.exports = {
+  SET: {
+    op: 'union',
+    all: true,
+    args: [
+      {
+        SELECT: {
+          from: {
+            join: 'inner',
+            args: [
+              {
+                ref: ['%%DRAFT%%']
+              },
+              {
+                ref: ['DRAFT.DraftAdministrativeData'],
+                as: 'filterAdmin'
+              }
+            ],
+            on: [
+              {
+                ref: ['%%DRAFT%%', 'DraftAdministrativeData_DraftUUID']
+              },
+              '=',
+              {
+                ref: ['filterAdmin', 'DraftUUID']
+              }
+            ]
+          },
+          where: [
+            {
+              ref: ['filterAdmin', 'InProcessByUser']
+            },
+            '=',
+            {
+              val: '%%USER%%'
+            }
+          ],
+          columns: [
+            '%%DRAFT_COLUMNS%%',
+            {
+              ref: ['IsActiveEntity'],
+              cast: {
+                type: 'cds.Boolean'
+              }
+            },
+            {
+              ref: ['HasActiveEntity'],
+              cast: {
+                type: 'cds.Boolean'
+              }
+            },
+            {
+              ref: ['HasDraftEntity'],
+              cast: {
+                type: 'cds.Boolean'
+              }
+            },
+            {
+              ref: ['DraftAdministrativeData_DraftUUID']
+            }
+          ]
+        }
+      },
+      {
+        SELECT: {
+          from: {
+            ref: ['%%ACTIVE%%']
+          },
+          columns: [
+            '%%ACTIVE_COLUMNS%%',
+            {
+              val: true,
+              as: 'IsActiveEntity',
+              cast: {
+                type: 'cds.Boolean'
+              }
+            },
+            {
+              val: false,
+              as: 'HasActiveEntity',
+              cast: {
+                type: 'cds.Boolean'
+              }
+            },
+            {
+              xpr: [
+                'case',
+                'when',
+                {
+                  SELECT: {
+                    from: {
+                      ref: ['%%DRAFT%%']
+                    },
+                    columns: [
+                      {
+                        val: 1
+                      }
+                    ],
+                    where: ['(', '%%KEYS%%', ')']
+                  },
+                  as: 'HasDraftEntity',
+                  cast: {
+                    type: 'cds.Boolean'
+                  }
+                },
+                'IS NOT NULL',
+                'then',
+                'true',
+                'else',
+                'false',
+                'end'
+              ],
+              as: 'HasDraftEntity',
+              cast: {
+                type: 'cds.Boolean'
+              }
+            },
+            {
+              SELECT: {
+                from: {
+                  ref: ['%%DRAFT%%']
+                },
+                columns: [
+                  {
+                    ref: ['DraftAdministrativeData_DraftUUID']
+                  }
+                ],
+                where: ['(', '%%KEYS%%', ')']
+              }
+            }
+          ],
+          where: [
+            'not exists',
+            {
+              SELECT: {
+                from: {
+                  join: 'inner',
+                  args: [
+                    {
+                      ref: ['%%DRAFT%%']
+                    },
+                    {
+                      ref: ['DRAFT.DraftAdministrativeData'],
+                      as: 'filterAdmin'
+                    }
+                  ],
+                  on: [
+                    {
+                      ref: ['%%DRAFT%%', 'DraftAdministrativeData_DraftUUID']
+                    },
+                    '=',
+                    {
+                      ref: ['filterAdmin', 'DraftUUID']
+                    }
+                  ]
+                },
+                columns: [
+                  {
+                    val: 1
+                  }
+                ],
+                where: [
+                  '(',
+                  {
+                    ref: ['filterAdmin', 'InProcessByUser']
+                  },
+                  '=',
+                  {
+                    val: '%%USER%%'
+                  },
+                  ')',
+                  'and',
+                  '(',
+                  '%%KEYS%%',
+                  ')'
+                ]
+              }
+            }
+          ]
+        }
+      }
+    ]
+  }
+}

package/libx/_runtime/db/Service.js

@@ -106,7 +106,7 @@ class DatabaseService extends cds.Service {
     return {
       from: (...args) => {
         const streamQuery = SELECT.from(...args)
-        if (!streamQuery.SELECT.columns || streamQuery.SELECT.columns.length !== 0) {
+        if (query && (!streamQuery.SELECT.columns || streamQuery.SELECT.columns.length !== 0)) {
           streamQuery.columns([query])
         }
         delete streamQuery.SELECT.one

package/libx/_runtime/db/data-conversion/timestamp.js

@@ -1,13 +1,6 @@
 function timestampToISO(ts) {
-  if (typeof ts === 'number') {
-    return new Date(ts).toISOString()
-  }
-
-  // REVISIT: instanceof or object
-  if (ts instanceof Date) {
-    return ts.toISOString()
-  }
-
+  if (typeof ts === 'number') return new Date(ts).toISOString()
+  if (ts instanceof Date) return ts.toISOString()
   return ts
 }