@sap/cds 7.9.4 → 8.0.4

package/libx/_runtime/fiori/generic/readOverDraft.js

@@ -1,146 +0,0 @@
-const cds = require('../../cds')
-const { SELECT } = cds.ql
-const { getEnrichedCQN, hasDraft, ensureDraftsSuffix } = require('../utils/handler')
-const { readAndDeleteKeywords } = require('../utils/where')
-const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-const { isActiveEntityRequested } = require('../../../_runtime/fiori/utils/where')
-
-const _modifyWhere = (where, context) => {
-  for (let i = 0; i < where.length; i++) {
-    const element = where[i]
-
-    if (element.xpr) {
-      _modifyWhere(element.xpr, context)
-      continue
-    }
-
-    if (element.SELECT) {
-      const subCqnDraft = SELECT.from(
-        {
-          ref: [...element.SELECT.from.ref],
-          as: element.SELECT.from.as
-        },
-        [1]
-      )
-
-      where[i] = subCqnDraft
-      _modifyCQN(subCqnDraft, element.SELECT.where, context)
-    }
-  }
-}
-
-const _modifyCQN = (cqnDraft, where, context) => {
-  const whereDraft = [...where]
-  const result = readAndDeleteKeywords(['IsActiveEntity'], whereDraft)
-  cqnDraft.where(whereDraft)
-
-  if (result && result.value.val === false) {
-    const fromRef = cqnDraft.SELECT.from.ref
-    cqnDraft.SELECT.from.ref[fromRef.length - 1] = ensureDraftsSuffix(fromRef[fromRef.length - 1])
-  }
-  if (cqnDraft.SELECT.columns) {
-    cqnDraft.SELECT.columns = cqnDraft.SELECT.columns.map(e =>
-      e.ref && e.ref.includes('IsActiveEntity') ? { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } } : e
-    )
-  }
-
-  _modifyWhere(cqnDraft.SELECT.where, context)
-}
-
-const _hasNavToNonDraftEnclosedAssoc = (pathSegments, definitions, excludeAssoc) => {
-  if (pathSegments.length < 2) return false
-  const entity = definitions[pathSegments[0]]
-  const nav = entity.elements[pathSegments[1]]
-
-  if (nav._isAssociationStrict) {
-    if (nav['@odata.draft.enclosed']) return false
-    if (excludeAssoc == null) return true
-    if (!excludeAssoc(nav)) return true
-  }
-
-  // At this point we know that nav is a composition, so we have to recursively
-  // follow the navigation until we reach the end or find an association.
-  pathSegments.shift()
-  pathSegments[0] = nav.target
-  return _hasNavToNonDraftEnclosedAssoc(pathSegments, definitions, excludeAssoc)
-}
-
-const _shouldReadOverDraft = (req, definitions) => {
-  const SELECT = req.query.SELECT
-  const fromRef = SELECT.from.ref
-
-  if (!fromRef) return false
-
-  // for $expand requests, read over the draft if the navigation target is non-draft-enabled
-  // REVISIT: this is an interim workaround to be removed
-  if (!req.target._isDraftEnabled && SELECT.columns?.some(column => column.expand)) return true
-
-  // read over the draft only for navigation scenarios
-  if (fromRef.length === 1) return false
-
-  const firstFromRef = fromRef[0]
-  const rootEntityName = typeof firstFromRef === 'string' ? firstFromRef : firstFromRef.id
-  const rootEntity = definitions[rootEntityName]
-
-  // read over the draft only if the root entity is draft-enabled
-  if (!rootEntity._isDraftEnabled) return false
-
-  // read over the draft only if the navigation starts from a draft entity, e.g.,
-  // /Books(ID=1, IsActiveEntity=false)
-  if (isActiveEntityRequested(firstFromRef.where)) return false
-
-  const pathSegments = fromRef.map(path => (typeof path === 'string' ? path : path.id))
-  const excludeAssoc = assoc => assoc.name === 'DraftAdministrativeData' || assoc.name === 'SiblingEntity'
-
-  // Read over the draft only if:
-  // - the navigation target is an association and
-  // - isn't annotated with the @odata.draft.enclosed annotation
-  return _hasNavToNonDraftEnclosedAssoc(pathSegments, definitions, excludeAssoc)
-}
-
-/**
- * Generic Handler for READ requests.
- *
- * @param {import('../../cds-services/adapter/odata-v4/ODataRequest')} req
- * @param next
- * @returns {Promise<Array>}
- */
-const _readOverDraftHandler = async function (req, next) {
-  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
-
-  const definitions = this.model.definitions
-
-  // determine whether the request is handled here (read over draft handler),
-  // or whether it is passed to the next registered handler/route
-  if (!_shouldReadOverDraft(req, definitions)) return next()
-
-  const rows = req.query.SELECT.limit && req.query.SELECT.limit.rows
-  if (rows && rows.val === 0) return Promise.resolve([])
-
-  // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model, { _4db: req.target._isDraftEnabled, _4fiori: true })
-
-  if (cds.env.features.stream_compat && req.query._streaming) {
-    sqlQuery._streaming = true
-  }
-
-  const hasDraftEntity = hasDraft(definitions, sqlQuery)
-
-  if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length) {
-    let cqnDraft = SELECT.from({
-      ref: [...sqlQuery.SELECT.from.ref],
-      as: sqlQuery.SELECT.from.as
-    })
-
-    cqnDraft.SELECT.columns = sqlQuery.SELECT.columns
-    _modifyCQN(cqnDraft, sqlQuery.SELECT.where, req)
-    cqnDraft = getEnrichedCQN(cqnDraft, sqlQuery.SELECT, [])
-    return cds.tx(req).run(cqnDraft)
-  }
-
-  return cds.tx(req).run(sqlQuery)
-}
-
-module.exports = cds.service.impl(function readOverDraft(srv) {
-  srv.on('READ', '*', _readOverDraftHandler)
-})

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

@@ -1,13 +0,0 @@
-/**
- * Returns true/false if entity is root of a document in a draft enabled service.
- *
- * @param {object} definitions Definitions of the reflected model
- * @param {string} entityName Name of the entity
- */
-const isDraftRootEntity = (definitions, entityName) => {
-  return definitions[entityName] && definitions[entityName]['@Common.DraftRoot.PreparationAction']
-}
-
-module.exports = {
-  isDraftRootEntity
-}

package/libx/_runtime/fiori/utils/delete.js

@@ -1,114 +0,0 @@
-const cds = require('../../cds')
-const getError = require('../../common/error')
-const { SELECT, DELETE } = cds.ql
-
-const { isDraftRootEntity } = require('./csn')
-const {
-  getUpdateDraftAdminCQN,
-  ensureDraftsSuffix,
-  ensureNoDraftsSuffix,
-  getDeleteDraftAdminCqn,
-  getCompositionTargets
-} = require('./handler')
-const { extractKeyConditions } = require('./where')
-
-const _getSelectCQN = (req, keys) => {
-  return SELECT.from(ensureNoDraftsSuffix(req.target.name), [1]).where(keys.keyList)
-}
-
-const _getDraftSelectCQN = (req, keys) => {
-  const draftEntityName = ensureDraftsSuffix(req.target.name)
-
-  return SELECT.from(draftEntityName, ['DraftUUID'])
-    .join('DRAFT.DraftAdministrativeData')
-    .on('DraftAdministrativeData_DraftUUID =', { ref: ['DRAFT.DraftAdministrativeData', 'DraftUUID'] })
-    .where(keys.keyList)
-}
-
-const _validate = (activeResult, draftResult, req, IsActiveEntity) => {
-  if (
-    (IsActiveEntity === true && activeResult.length === 0) ||
-    (IsActiveEntity === false && draftResult.length === 0)
-  ) {
-    req.reject(req._etagValidationClause ? 412 : 404)
-  }
-}
-
-const deleteDraft = async (req, srv, includingActive = false) => {
-  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
-
-  const dbtx = cds.tx(req)
-  const definitions = srv.model.definitions
-
-  const where = req.query.DELETE.from.ref?.[req.query.DELETE.from.ref.length - 1].where
-  if (!where) {
-    req.reject(getError(500, 'Invalid delete draft request'))
-  }
-
-  // REVISIT: how to handle delete of to 1 assoc
-  const keys = extractKeyConditions(where)
-
-  // IsActiveEntity is deleted from where clause in auth.js, hence keys.IsActiveEntity is undefined here.
-  // Intentional?
-  const deleteActive = keys.IsActiveEntity !== false
-
-  const selectActive = _getSelectCQN(req, keys)
-  const selectDraft = _getDraftSelectCQN(req, keys)
-
-  if (req._etagValidationClause) {
-    if (keys.IsActiveEntity) selectActive.where(req._etagValidationClause)
-    else selectDraft.where(req._etagValidationClause)
-  }
-
-  const [activeResult, draftResult] = await Promise.all([dbtx.run(selectActive), dbtx.run(selectDraft)])
-
-  _validate(activeResult, draftResult, req, deleteActive)
-
-  if (isDraftRootEntity(definitions, ensureNoDraftsSuffix(req.target.name)) && !deleteActive) {
-    const draftUUID = draftResult[0].DraftUUID
-
-    const draftTablesToDeleteFrom = [req.target.name + '_drafts']
-    for (const [entity] of getCompositionTargets(req.target, srv).entries()) {
-      if (!draftTablesToDeleteFrom.includes(entity + '_drafts')) draftTablesToDeleteFrom.push(entity + '_drafts')
-    }
-
-    const deleteDraftAdminCqn = getDeleteDraftAdminCqn(draftUUID)
-
-    return dbtx.run([
-      deleteDraftAdminCqn,
-      ...draftTablesToDeleteFrom.map(dt => {
-        const d = DELETE.from(dt).where({ DraftAdministrativeData_DraftUUID: draftUUID })
-        d._suppressDeepDelete = true // hidden flag to tell db layer that no deep delete is required
-        return d
-      })
-    ])
-  }
-
-  const source = definitions[ensureNoDraftsSuffix(req.target.name)]
-  const delCQNs = []
-
-  if (includingActive) {
-    const r = new cds.Request({ query: DELETE.from(ensureNoDraftsSuffix(req.target.name)).where(keys.keyList) })
-
-    // REVISIT: should not be necessary
-    r._ = Object.assign(r._, req._)
-    r._.query = req.query
-
-    await dbtx.dispatch(r)
-  }
-
-  if (draftResult.length !== 0) {
-    delCQNs.push(DELETE.from(ensureDraftsSuffix(source.name)).where(keys.keyList))
-
-    const draftUUID = draftResult[0].DraftUUID
-    if (isDraftRootEntity(definitions, ensureNoDraftsSuffix(req.target.name))) {
-      delCQNs.push(DELETE.from('DRAFT.DraftAdministrativeData').where({ draftUUID }))
-    } else {
-      delCQNs.push(getUpdateDraftAdminCQN(req, draftUUID))
-    }
-  }
-
-  return Promise.all(delCQNs.map(cqn => dbtx.run(cqn)))
-}
-
-module.exports = { deleteDraft }

package/libx/_runtime/fiori/utils/handler.js

@@ -1,264 +0,0 @@
-const cds = require('../../cds')
-const { Object_keys } = cds.utils
-const { UPDATE, SELECT } = cds.ql
-const { getColumns } = require('../../common/utils/columns')
-const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
-const getTemplate = require('../../common/utils/template')
-
-const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
-
-// unofficial config!
-const MAX_RECURSION_DEPTH = (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 2
-
-const _getParentCQNWithKeyColumn = (parentCQN, parentKeyName) => {
-  const parentCQNWithKeyColumn = Object.assign({}, parentCQN)
-  parentCQNWithKeyColumn.SELECT = Object.assign({}, parentCQN.SELECT)
-  parentCQNWithKeyColumn.SELECT.columns = [{ ref: [parentKeyName] }]
-  return parentCQNWithKeyColumn
-}
-
-const _getSubSelectFromCQN = (element, columns, selectFromDraft) => {
-  return SELECT.from(
-    selectFromDraft ? ensureDraftsSuffix(element.source) : element.source,
-    selectFromDraft ? [...columns, 'DraftAdministrativeData_DraftUUID'] : columns
-  )
-}
-
-const getSubCQNs = ({ definitions, rootCQN, compositionTree, selectFromDraft = false }) => {
-  const subCQNs = []
-  // only one backLink
-  const _generateSubCQNs = (parentCQN, compositionElements, elementMap = new Map()) => {
-    for (const element of compositionElements) {
-      const backLink = element.backLinks[0] || element.customBackLinks[0]
-      if (backLink) {
-        const fqn = element.source + ':' + element.name
-        const seen = elementMap.get(fqn)
-        if (seen && seen >= MAX_RECURSION_DEPTH) {
-          // recursion -> abort
-          continue
-        }
-
-        const columns = getColumns(definitions[element.source], { onlyNames: true, filterVirtual: true })
-        const subCQN = _getSubSelectFromCQN(element, columns, selectFromDraft)
-        subCQN.where([{ ref: [backLink.entityKey] }, 'in', _getParentCQNWithKeyColumn(parentCQN, backLink.targetKey)])
-        subCQNs.push({ cqn: subCQN })
-        const newElementMap = new Map(elementMap)
-        newElementMap.set(fqn, (seen && seen + 1) || 1)
-        _generateSubCQNs(subCQN, element.compositionElements, newElementMap)
-      }
-    }
-  }
-
-  _generateSubCQNs(rootCQN, compositionTree.compositionElements)
-
-  return subCQNs
-}
-
-const proxifyToNoDraftsName = target => {
-  const entityProxyHandler = {
-    get: (obj, prop) => (prop === 'name' ? ensureNoDraftsSuffix(target.name) : obj[prop])
-  }
-  return new Proxy(target, entityProxyHandler)
-}
-
-const hasDraft = (definitions, cqn) => {
-  if (
-    cqn.SELECT.from.ref &&
-    definitions[cqn.SELECT.from.ref[cqn.SELECT.from.ref.length - 1]] &&
-    definitions[cqn.SELECT.from.ref[cqn.SELECT.from.ref.length - 1]]._isDraftEnabled
-  ) {
-    return true
-  }
-
-  if (cqn.SELECT.where) {
-    for (const element of cqn.SELECT.where) {
-      if (element.SELECT && hasDraft(definitions, element)) {
-        return true
-      }
-    }
-  }
-
-  return false
-}
-
-const getUpdateDraftAdminCQN = ({ user }, draftUUID) => {
-  const set = {
-    InProcessByUser: user.id,
-    LastChangedByUser: user.id,
-    LastChangeDateTime: new Date()
-  }
-
-  return UPDATE('DRAFT.DraftAdministrativeData').data(set).where({ DraftUUID: draftUUID })
-}
-
-const _addAlias = (where, tableName) => {
-  // copy where
-  return where.map(element => {
-    if (element.xpr) {
-      return { xpr: _addAlias(element.xpr, tableName) }
-    }
-    if (element.ref && element.ref.length === 1) {
-      // and copy ref
-      return { ref: [tableName, element.ref[0]] }
-    }
-    return element
-  })
-}
-
-const _getSelectedColumns = (columns, selectedColumns) => {
-  return columns.filter(col => {
-    if (
-      col.ref &&
-      selectedColumns.some(sel => sel.ref && sel.ref[sel.ref.length - 1] === col.ref[col.ref.length - 1])
-    ) {
-      return true
-    } else if (col.as && selectedColumns.some(sel => sel.as && sel.as === col.as)) {
-      return true
-    }
-
-    return false
-  })
-}
-
-const getEnrichedCQN = (cqn, select, draftWhere, scenarioAlias, addLimitOrder = true) => {
-  const tableName =
-    (cqn.SELECT.from.ref && cqn.SELECT.from.ref[0]) || (cqn.SELECT.from.args && cqn.SELECT.from.args[0].ref[0])
-
-  if (draftWhere && draftWhere.length !== 0) {
-    cqn.where(_addAlias(draftWhere, tableName))
-  }
-
-  if (select.distinct) {
-    cqn.SELECT.distinct = true
-  }
-
-  const alias = (select.from && select.from.as) || scenarioAlias
-
-  if (select.count) cqn.SELECT.count = true
-  if (select.one) cqn.SELECT.one = true
-
-  if (select.having) {
-    cqn.having(_aliased(select.having, select.columns, alias))
-  }
-
-  // groupBy, orderBy and limit do not support partial CQNs
-  if (select.groupBy) {
-    cqn.SELECT.groupBy = _aliased(select.groupBy, select.columns, alias)
-    cqn.SELECT.columns = _getSelectedColumns(cqn.SELECT.columns, select.columns)
-  }
-
-  if (select.orderBy && addLimitOrder) {
-    cqn.SELECT.orderBy = _aliased(select.orderBy, select.columns, alias)
-  }
-
-  if (select.limit && addLimitOrder) {
-    cqn.SELECT.limit = select.limit
-  }
-
-  return cqn
-}
-
-const _aliasRef = (ref, alias) => {
-  const newRef = [...ref]
-  // we skip draft columns because they are mostly calculated later on
-  if (alias && !(ref[ref.length - 1] in DRAFT_COLUMNS_MAP)) {
-    newRef.unshift(alias)
-  }
-  return newRef
-}
-
-const getDeleteDraftAdminCqn = draftUUID =>
-  DELETE.from('DRAFT.DraftAdministrativeData').where([{ ref: ['DraftUUID'] }, '=', { val: draftUUID }])
-
-const _aliased = (arr, columns, alias) =>
-  arr.map(item => {
-    if (item.ref && columns.some(c => c.as === item.ref[item.ref.length - 1])) {
-      // remove table alias if present for a calculated field
-      if (item.ref[0] === alias) {
-        return item.ref.splice(0, 1)
-      }
-    } else if (alias && item.ref && item.ref[0] !== alias) {
-      return Object.assign({}, item, { ref: _aliasRef(item.ref, alias) })
-    }
-    return item
-  })
-
-// Only works for root entity, otherwise the relative position needs to be adapted
-const removeDraftUUIDIfNecessary = req =>
-  req.http?.req?.headers?.['x-cds-odata-version'] === 'v2'
-    ? () => {}
-    : result => delete result.DraftAdministrativeData_DraftUUID
-
-const addColumnAlias = (columns, alias) => {
-  if (!alias) {
-    return columns
-  }
-
-  return columns.map(col => {
-    if (typeof col === 'string') {
-      return { ref: [alias, col] }
-    }
-
-    if (col.ref && !col.expand) {
-      const obj = Object.assign({}, col)
-      obj.ref = [alias, ...col.ref.slice(0)]
-      return obj
-    }
-
-    if (col.func && col.args) {
-      const obj = Object.assign({}, col)
-      obj.args = addColumnAlias(col.args, alias)
-      return obj
-    }
-
-    return col
-  })
-}
-
-const getCompositionTargets = (entity, srv) => {
-  if (!entity.own('_deepCompositionTargets')) {
-    const _deepCompositionTargets = []
-    getTemplate(undefined, srv, entity, {
-      pick: element => {
-        if (element.isAssociation && !element._isAssociationStrict && srv.model.definitions[element.target].drafts)
-          _deepCompositionTargets.push(element.target)
-      },
-      ignore: element => !element.isAssociation || element._isAssociationStrict
-    })
-    entity.set('_deepCompositionTargets', new Set(_deepCompositionTargets))
-  }
-
-  return entity.own('_deepCompositionTargets')
-}
-
-const replaceRefWithDraft = ref => {
-  if (!ref || !ref[0]) return
-  ref[0] = ensureDraftsSuffix(ref[0])
-}
-
-const draftIsLocked = lastChangedAt => {
-  // default timeout timer is 15 minutes
-  const DRAFT_CANCEL_TIMEOUT_IN_MS = ((cds.env.drafts && cds.env.drafts.cancellationTimeout) || 15) * 60 * 1000
-  return DRAFT_CANCEL_TIMEOUT_IN_MS > Date.now() - Date.parse(lastChangedAt)
-}
-
-const entity_keys = entity =>
-  Object_keys(entity.keys).filter(key => key !== 'IsActiveEntity' && !entity.keys[key]._isAssociationStrict)
-
-module.exports = {
-  getSubCQNs,
-  draftIsLocked,
-  getUpdateDraftAdminCQN,
-  getEnrichedCQN,
-  removeDraftUUIDIfNecessary,
-  ensureDraftsSuffix,
-  ensureNoDraftsSuffix,
-  ensureUnlocalized,
-  hasDraft,
-  proxifyToNoDraftsName,
-  addColumnAlias,
-  replaceRefWithDraft,
-  entity_keys,
-  getDeleteDraftAdminCqn,
-  getCompositionTargets
-}

package/libx/_runtime/fiori/utils/lockInfo.js

@@ -1,27 +0,0 @@
-const cds = require('../../cds')
-const { getTransition } = require('../../common/utils/resolveView')
-const { getKeyData, getLockWhere } = require('../utils/where')
-const { entity_keys } = require('../utils/handler')
-
-const getLockInfo = (req, dataSource) => {
-  const keys = entity_keys(req.target)
-  const keyData = getKeyData(keys, req.query.SELECT.from.ref[0].where)
-  const rootWhere = keys.reduce((res, key) => {
-    res[key] = keyData[key]
-    return res
-  }, {})
-
-  if (dataSource === undefined || dataSource === cds.db) {
-    const transition = getTransition(req.target, cds.db)
-
-    // gets the underlying target entity, as record locking can't be
-    // applied to localized views
-    const target = transition.target
-    const where = getLockWhere(rootWhere, transition.mapping)
-    return { target, where, rootWhere }
-  }
-
-  return { target: req.target, where: req.query.SELECT.from.ref[0].where, rootWhere }
-}
-
-module.exports = getLockInfo

package/libx/_runtime/fiori/utils/req.js

@@ -1,23 +0,0 @@
-const _ref2name = ref => (ref.id || ref).replace(/_drafts$/, '')
-
-const isNavigationToMany = (req, model) => {
-  // only one segment -> false
-  if (req.subject.ref.length < 2) return
-
-  // last segment has it's own where -> false
-  if (req.subject.ref[req.subject.ref.length - 1].where) return
-
-  // determine the csn element of the last navigation and return it's is2many property
-  let cur
-  for (let i = 0; i < req.subject.ref.length - 1; i++) {
-    cur = cur
-      ? model.definitions[cur.elements[_ref2name(req.subject.ref[i])].target]
-      : model.definitions[_ref2name(req.subject.ref[i])]
-  }
-  const last = cur.elements[_ref2name(req.subject.ref[req.subject.ref.length - 1])]
-  return last.is2many
-}
-
-module.exports = {
-  isNavigationToMany
-}

package/libx/_runtime/fiori/utils/stream.js

@@ -1,36 +0,0 @@
-const { ensureDraftsSuffix } = require('./handler')
-const { removeIsActiveEntityRecursively, isActiveEntityRequested } = require('./where')
-
-const _adaptSubSelectsDraft = select => {
-  if (select.SELECT.from.ref) {
-    const index = select.SELECT.from.ref.length - 1
-    select.SELECT.from.ref[index] = ensureDraftsSuffix(select.SELECT.from.ref[index])
-  }
-
-  if (select.SELECT.where) {
-    for (let i = 0; i < select.SELECT.where.length; i++) {
-      const element = select.SELECT.where[i]
-      if (element.SELECT) {
-        _adaptSubSelectsDraft(element)
-      } else if (element.xpr) {
-        _adaptSubSelectsDraft({ SELECT: { from: {}, where: element.xpr } })
-      }
-    }
-  }
-}
-
-const adaptStreamCQN = (cqn, isDraft = false) => {
-  let draft = isDraft
-  if (!draft) {
-    draft = !isActiveEntityRequested(cqn.SELECT.where)
-    const ref = cqn.SELECT.from?.ref
-    if (!draft && ref) draft = !isActiveEntityRequested(ref[ref.length - 1].where)
-  }
-
-  if (draft) _adaptSubSelectsDraft(cqn)
-  cqn.SELECT.where = removeIsActiveEntityRecursively(cqn.SELECT.where)
-}
-
-module.exports = {
-  adaptStreamCQN
-}