@sap/cds 9.4.5 → 9.5.1

package/libx/_runtime/common/generic/flows.js

@@ -5,12 +5,10 @@ const { getFrom } = require('../../../../lib/compile/for/flows')
 const FLOW_STATUS = '@flow.status'
 const FROM = '@from'
 const TO = '@to'
-// backwards compat
-const FLOW_FROM = '@flow.from'
-const FLOW_TO = '@flow.to'
-
 const FLOW_PREVIOUS = '$flow.previous'
 
+const $transitions_ = Symbol.for('transitions_')
+
 function buildAllowedCondition(action, statusElementName, statusEnum) {
   const fromList = getFrom(action)
   const conditions = fromList.map(from => {
@@ -20,154 +18,216 @@ function buildAllowedCondition(action, statusElementName, statusEnum) {
   return `(${conditions.join(' OR ')})`
 }
 
-async function isCurrentStatusInFrom(req, action, statusElementName, statusEnum) {
+async function isCurrentStatusInFrom(subject, action, statusElementName, statusEnum) {
   const cond = buildAllowedCondition(action, statusElementName, statusEnum)
   const parsedXpr = cds.parse.expr(cond)
-  const dbEntity = await SELECT.one.from(req.subject).where(parsedXpr)
+  const dbEntity = await SELECT.one.from(subject).where(parsedXpr)
   return dbEntity !== undefined
 }
 
-async function checkStatus(req, action, statusElementName, statusEnum) {
-  const allowed = await isCurrentStatusInFrom(req, action, statusElementName, statusEnum)
+async function checkStatus(subject, action, statusElementName, statusEnum) {
+  const allowed = await isCurrentStatusInFrom(subject, action, statusElementName, statusEnum)
   if (!allowed) {
     const from = getFrom(action)
     const fromValues = JSON.stringify(from.flatMap(el => Object.values(el)))
     cds.error({
-      code: 409,
+      status: 409,
       message: from.length > 1 ? 'INVALID_FLOW_TRANSITION_MULTI' : 'INVALID_FLOW_TRANSITION_SINGLE',
       args: [action.name, statusElementName, fromValues]
     })
   }
 }
 
-const buildUpKeys = parentKeys => {
+// REVISIT: what about renamed keys?
+const buildUpKeys = async (entity, data, subject) => {
+  const parentKeys = Object.keys(entity.keys).filter(k => k !== 'IsActiveEntity')
+  // REVISIT: when do we not hava all keys?
+  const keyValues =
+    data && parentKeys.every(key => key in data) ? data : await SELECT.one.from(subject).columns(parentKeys)
   const upKeys = {}
-  for (const key in parentKeys) {
-    upKeys[`up__${key}`] = parentKeys[key]
+  for (let i = 0; i < parentKeys.length; i++) {
+    upKeys[`up__${parentKeys[i]}`] = keyValues[parentKeys[i]]
   }
   return upKeys
 }
 
-const updateFlowHistory = async (req, toValue, upKeys, changes, isPrevious) => {
-  if (cds.env.features.flows_history_stack && isPrevious) {
-    await DELETE.from(req.target.compositions['transitions_'].target).where({
-      timestamp: changes[changes.length - 1].timestamp
-    })
+const resolveTo = (action, statusEnum) => {
+  let to = action[TO]
+  to = to['#'] ? (statusEnum[to['#']].val ?? statusEnum[to['#']]['$path'].at(-1)) : to
+  return to
+}
+
+const handleTransition = async (entity, data, subject, to) => {
+  const isPrevious = to['='] === FLOW_PREVIOUS
+  if (isPrevious) {
+    const upKeys = await buildUpKeys(entity, data, subject)
+    const previous = await SELECT.one
+      .from(entity[$transitions_].target)
+      .where({ ...upKeys })
+      .orderBy('timestamp desc')
+      .limit(1, 1)
+    if (!previous)
+      cds.error({ status: 409, message: 'No change has been made yet, cannot transition to previous status.' })
+    to = previous.status
+  }
+  return to
+}
+
+const getStatusInfo = statusElement => {
+  let statusEnum, statusElementName
+  if (statusElement.enum) {
+    statusEnum = statusElement.enum
+    statusElementName = statusElement.name
+  } else if (statusElement?._target?.elements['code']) {
+    statusEnum = statusElement._target.elements['code'].enum
+    statusElementName = statusElement.name + '_code'
   } else {
-    await INSERT.into(req.target.compositions['transitions_'].target).entries({
-      ...upKeys,
-      status: toValue
+    cds.error({
+      status: 409,
+      message: `Status element in ${statusElement.parent.name} must be an enum or target an entity with an enum named "code"`
     })
   }
+  return { statusEnum, statusElementName }
 }
 
-const buildToKey = (action, statusEnum) => {
-  const to = action[TO] ?? action[FLOW_TO]
-  const toKey = to['#'] ? (statusEnum[to['#']].val ?? statusEnum[to['#']]['$path'].at(-1)) : to
-  return toKey
+const from_factory = (entity, action, { statusElementName, statusEnum }) => {
+  async function handle_flow_from(req) {
+    const subject = cds.clone(req.subject)
+    if (entity.name.endsWith('.drafts')) subject.ref[0].id = entity.name
+
+    await checkStatus(subject, action, statusElementName, statusEnum)
+  }
+  handle_flow_from._initial = true
+  return handle_flow_from
 }
 
-const handleStatusTransitionWithHistory = async (req, statusElementName, toKey, service) => {
-  let upKeys, changes
-  upKeys = buildUpKeys(req.params[0])
-  changes = await SELECT.from(req.target.compositions['transitions_'].target)
-    .where({ ...upKeys })
-    .orderBy('timestamp asc')
-  const isPrevious = toKey['='] === FLOW_PREVIOUS
-  if (isPrevious) {
-    if (changes.length <= 1)
-      return cds.error({ code: 409, message: 'No change has been made yet, cannot transition to previous status.' })
-    toKey = changes[changes.length - 2].status
+const to___factory = (entity, action, { statusElementName, statusEnum }) => {
+  return async function handle_flow_to(req, next) {
+    const res = await next()
+
+    let subject = cds.clone(req.subject)
+    if (entity.name.endsWith('.drafts')) subject.ref[0].id = entity.name
+
+    // REVISIT: this only happens on CREATE, where req.subject is a collection
+    //          -> could be avoided if setting the status would be done via req.data
+    if (!subject.ref[0].id) {
+      const keys = Object.keys(entity.keys).reduce((acc, cur) => {
+        acc[cur] = res[cur]
+        return acc
+      }, {})
+      subject = SELECT.from(entity.name, keys).SELECT.from
+    }
+
+    let to = resolveTo(action, statusEnum)
+
+    if (Object.prototype.hasOwnProperty.call(entity, $transitions_)) {
+      to = await handleTransition(entity, req.data, subject, to)
+    }
+
+    await UPDATE(subject).with({ [statusElementName]: to })
+
+    // REVISIT: for stack, we now need to delete the last to transitions
+    if (cds.env.features.flows_history_stack && resolveTo(action, statusEnum)['='] === FLOW_PREVIOUS) {
+      const upKeys = await buildUpKeys(entity, req.data, req.subject)
+      const timestamps = SELECT('timestamp')
+        .from(entity[$transitions_].target)
+        .where({ ...upKeys })
+        .orderBy('timestamp desc')
+        .limit(2)
+      await DELETE.from(entity[$transitions_].target)
+        .where({ ...upKeys })
+        .where(`timestamp in`, timestamps)
+    }
+
+    return res
   }
-  await service.run(UPDATE(req.subject).with({ [statusElementName]: toKey }))
-  await updateFlowHistory(req, toKey, upKeys, changes, isPrevious)
 }
 
 /**
  * handler registration
  */
 module.exports = cds.service.impl(function () {
-  const entry = []
-  const exit = []
+  const b4 = []
+  const on = []
+  const after = []
 
   for (const entity of this.entities) {
     if (!entity.actions || !entity.elements) continue
 
-    const fromActions = []
-    const toActions = []
-    for (const action of entity.actions) {
-      if (action[FROM] || action[FLOW_FROM]) fromActions.push(action)
-      if (action[TO] || action[FLOW_TO]) toActions.push(action)
-    }
-    if (fromActions.length === 0 && toActions.length === 0) continue
-
-    let statusElement = Object.values(entity.elements).find(el => el[FLOW_STATUS])
-    if (!statusElement) {
-      cds.error({
-        code: 409,
-        message: `Entity ${entity.name} does not have a status element, but its actions have registered @flow annotations.`
+    const statusElement = Object.values(entity.elements).find(el => el[FLOW_STATUS])
+    if (!statusElement) continue
+
+    const statusInfo = getStatusInfo(statusElement)
+
+    // determine and cache target for transitions recording, if any
+    let base = entity
+    while (base.__proto__.kind === 'entity') base = base.__proto__
+    if (base.compositions?.transitions_) {
+      entity[$transitions_] = base.compositions.transitions_
+      // track changes on db level
+      cds.connect.to('db').then(db => {
+        db.after(['CREATE', 'UPDATE', 'UPSERT'], entity, async (res, req) => {
+          if ((res.affectedRows ?? res) !== 1) return
+          if (!(statusInfo.statusElementName in req.data)) return
+          const status = req.data[statusInfo.statusElementName]
+          const upKeys = await buildUpKeys(entity, req.data, req.subject)
+          const last = await SELECT.one.from(entity[$transitions_].target).orderBy('timestamp desc').where(upKeys)
+          if (last?.status !== status) await UPSERT.into(entity[$transitions_].target).entries({ ...upKeys, status })
+        })
       })
     }
 
-    let statusEnum, statusElementName
-    if (statusElement.enum) {
-      statusEnum = statusElement.enum
-      statusElementName = statusElement.name
-    } else if (statusElement?._target?.elements['code']) {
-      statusEnum = statusElement._target.elements['code'].enum
-      statusElementName = statusElement.name + '_code'
-    } else {
-      cds.error({
-        code: 409,
-        message: `Status element in entity ${entity.name} is not an enum and does not have a valid target with code enum.`
-      })
+    // register handlers
+    for (const action of entity.actions) {
+      const to__ = action[TO]
+      const from = action[FROM]
+
+      // REVISIT: for CRUD and Draft, we could set status in before handlers (on db level) to save roundtrips
+      switch (action.name) {
+        // CRUD
+        case 'CREATE':
+          if (to__) on.push([action.name, entity, to___factory(entity, action, statusInfo)])
+          break
+        case 'READ':
+          // nothing to do
+          break
+        case 'UPDATE':
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          if (to__) on.push([action.name, entity, to___factory(entity, action, statusInfo)])
+          break
+        case 'DELETE':
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          break
+        // Draft
+        case 'NEW':
+          if (to__) on.push(['CREATE', entity.drafts, to___factory(entity.drafts, action, statusInfo)])
+          break
+        case 'PATCH':
+          if (from) b4.push(['UPDATE', entity.drafts, from_factory(entity.drafts, action, statusInfo)])
+          if (to__) on.push(['UPDATE', entity.drafts, to___factory(entity.drafts, action, statusInfo)])
+          break
+        case 'SAVE':
+          if (from) b4.push([action.name, entity.drafts, from_factory(entity.drafts, action, statusInfo)])
+          if (to__) on.push([action.name, entity.drafts, to___factory(entity, action, statusInfo)])
+          break
+        case 'EDIT':
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          if (to__) on.push([action.name, entity, to___factory(entity.drafts, action, statusInfo)])
+          break
+        case 'DISCARD':
+          if (from) b4.push([action.name, entity.drafts, from_factory(entity.drafts, action, statusInfo)])
+          break
+        // custom actions
+        default:
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          if (to__) on.push([action.name, entity, to___factory(entity, action, statusInfo)])
+      }
     }
-
-    entry.push({ events: fromActions, entity, statusElementName, statusEnum })
-    exit.push({ events: toActions, entity, statusElementName, statusEnum })
   }
 
   this.prepend(function () {
-    for (const each of entry) {
-      this.before(
-        each.events,
-        each.entity,
-        Object.assign(
-          async function handle_entry_state(req) {
-            const action = req.target.actions[req.event]
-            await checkStatus(req, action, each.statusElementName, each.statusEnum)
-          },
-          { _initial: true }
-        )
-      )
-    }
-
-    for (const each of exit) {
-      async function handle_after_create(res, req) {
-        const parentKeys = Object.keys(req.target.keys)
-        const entry = {}
-        for (let i = 0; i < parentKeys.length; i++) {
-          entry[`up__${parentKeys[i]}`] = req.data[parentKeys[i]]
-        }
-        await INSERT.into(req.target.compositions['transitions_'].target).entries({
-          ...entry,
-          status: res[each.statusElementName]
-        })
-      }
-      if ('transitions_' in (each.entity.compositions ?? {})) this.after('CREATE', each.entity, handle_after_create)
-
-      async function handle_exit_state(req, next) {
-        const res = await next()
-        const action = req.target.actions[req.event]
-        let toKey = buildToKey(action, each.statusEnum)
-        if ('transitions_' in (req.target.compositions ?? {})) {
-          await handleStatusTransitionWithHistory(req, each.statusElementName, toKey, this)
-        } else {
-          await this.run(UPDATE(req.subject).with({ [each.statusElementName]: toKey }))
-        }
-        return res
-      }
-      this.on(each.events, each.entity, handle_exit_state)
-    }
+    for (const each of b4) this.before(...each)
+    for (const each of on) this.on(...each)
+    for (const each of after) this.after(...each)
   })
 })

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

@@ -2,28 +2,6 @@ const cds = require('../../cds')
 const { SELECT } = cds.ql
 const { setEntityContained } = require('./csn')
 
-const getEntityNameFromDeleteCQN = cqn => {
-  let from
-  if (cqn && cqn.DELETE && cqn.DELETE.from) {
-    if (typeof cqn.DELETE.from === 'string') {
-      from = cqn.DELETE.from
-    } else if (cqn.DELETE.from.name) {
-      from = cqn.DELETE.from.name
-    } else if (cqn.DELETE.from.ref && cqn.DELETE.from.ref.length === 1) {
-      from = cqn.DELETE.from.ref[0]
-    }
-  }
-  return from
-}
-
-const getEntityNameFromUpdateCQN = cqn => {
-  return (
-    (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0] && (cqn.UPDATE.entity.ref[0].id || cqn.UPDATE.entity.ref[0])) ||
-    cqn.UPDATE.entity.name ||
-    cqn.UPDATE.entity
-  )
-}
-
 // scope: simple wheres à la "[{ ref: ['foo'] }, '=', { val: 'bar' }, 'and', ... ]"
 function where2obj(where, target = null, data = {}) {
   for (let i = 0; i < where.length; ) {
@@ -89,8 +67,6 @@ const resolveFromSelect = query => {
 }
 
 module.exports = {
-  getEntityNameFromDeleteCQN,
-  getEntityNameFromUpdateCQN,
   where2obj,
   targetFromPath,
   resolveFromSelect

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

@@ -11,7 +11,7 @@ module.exports = value => {
   if (typeof value === 'number') value = new Date(value).toISOString()
   if (typeof value !== 'string') {
     const msg = `Value "${value}" is not a valid Timestamp`
-    throw Object.assign(new Error(msg), { statusCode: 400 })
+    cds.error({ status: 400, message: msg })
   }
 
   const decimalPointIndex = _lengthIfNotFoundIndex(value.lastIndexOf('.'), value.length)
@@ -22,7 +22,7 @@ module.exports = value => {
   let dt = new Date(value.slice(0, dateEndIndex) + tz)
   if (isNaN(dt)) {
     const msg = `Value "${value}" is not a valid Timestamp`
-    throw Object.assign(new Error(msg), { statusCode: 400 })
+    cds.error({ status: 400, message: msg })
   }
   const dateNoMillisNoTZ = dt.toISOString().slice(0, 19)
   const normalizedFractionalDigits = value

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

@@ -473,8 +473,14 @@ const _newDelete = (query, transitions, options) => {
     : targetName
 
   if (newDelete.where) {
-    const from = typeof query.DELETE.from === 'string' ? query.DELETE.from : query.DELETE.from.ref[0]
-    newDelete.where = _newWhere(newDelete.where, targetTransition, from, query.DELETE.from.as, undefined, options)
+    newDelete.where = _newWhere(
+      newDelete.where,
+      targetTransition,
+      query.DELETE.from.ref[0],
+      query.DELETE.from.as,
+      undefined,
+      options
+    )
   }
 
   return newDelete

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

@@ -45,14 +45,23 @@ const _processComplex = (processFn, row, template, key, pathOptions) => {
   if (rows.length === 0) return
   const keyNames = pathOptions.includeKeyValues && _getTargetKeyNames(template.target)
 
+  let rowIndex = -1
   for (const row of rows) {
+    rowIndex++
     if (row == null) continue
     const args = { processFn, data: row, template, isRoot: false, pathOptions }
 
     let pathSegmentInfo
     if (pathOptions.includeKeyValues) {
       pathOptions.rowUUIDGenerator?.(keyNames, row, template)
-      pathSegmentInfo = { key, keyNames, row, elements: template.target.elements, draftKeys: pathOptions.draftKeys }
+      pathSegmentInfo = {
+        key,
+        keyNames,
+        row,
+        rowIndex,
+        elements: template.target.elements,
+        draftKeys: pathOptions.draftKeys
+      }
     }
 
     if (pathOptions.pathSegmentsInfo) pathOptions.pathSegmentsInfo.push(pathSegmentInfo || key)

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

@@ -1,24 +1,30 @@
-const segmentSerializer = pathSegmentInfo => {
+const segmentKeySerializer = pathSegmentInfo => {
   const { key: tKey, row, elements, draftKeys } = pathSegmentInfo
   let keyNames = pathSegmentInfo.keyNames
 
   const keyValuePairs = keyNames
     .map(key => {
-      let quote
+      const keyValue = row[key] ?? draftKeys?.[key]
+      if (keyValue == null) return
+
+      let formattedValue
 
       switch (elements[key].type) {
         case 'cds.String':
-          quote = "'"
+          formattedValue = `'${keyValue}'`
+          break
+
+        case 'cds.Binary':
+          if (Buffer.isBuffer(keyValue)) formattedValue = keyValue.toString('base64')
+          formattedValue = `binary'${formattedValue}'`
           break
 
         default:
-          quote = ''
+          formattedValue = keyValue
           break
       }
 
-      const keyValue = row[key] ?? draftKeys?.[key]
-      if (keyValue == null) return
-      return `${key}=${quote}${keyValue}${quote}`
+      return `${key}=${formattedValue}`
     })
     .filter(c => c)
 
@@ -27,10 +33,16 @@ const segmentSerializer = pathSegmentInfo => {
   return pathSegment
 }
 
-const templatePathSerializer = (elementName, pathSegmentsInfo) => {
+const segmentIndexSerializer = pathSegmentInfo => {
+  const { key: tKey, rowIndex } = pathSegmentInfo
+  return `${tKey}[${rowIndex}]`
+}
+
+const templatePathSerializer = (elementName, pathSegmentsInfo, serializeWithIndices = false) => {
   const pathSegments = pathSegmentsInfo.map(pathSegmentInfo => {
     if (typeof pathSegmentInfo === 'string') return pathSegmentInfo
-    return segmentSerializer(pathSegmentInfo)
+    if (serializeWithIndices) return segmentIndexSerializer(pathSegmentInfo)
+    return segmentKeySerializer(pathSegmentInfo)
   })
   const path = `${pathSegments.join('/')}${pathSegments.length ? '/' : ''}${elementName}`
   return path