@sap/cds 7.9.2 → 8.0.3

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

@@ -1,21 +0,0 @@
-const cds = require('../../cds')
-const { deleteDraft } = require('../utils/delete')
-
-/**
- * Generic Handler for DELETE requests.
- * In case of success it returns an empty object.
- * If the entry to be deleted does not exist, it rejects with error to return a 404.
- *
- * @param req
- */
-const fioriGenericDelete = function (req, next) {
-  if (!req.target._isDraftEnabled) return next()
-
-  // we should call deleteDraft only for draft tables and call next
-  // to pass delete of active tables to our general implementation
-  return deleteDraft(req, this, true)
-}
-
-module.exports = cds.service.impl(function (srv) {
-  srv.on('DELETE', '*', fioriGenericDelete)
-})

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

@@ -1,157 +0,0 @@
-const cds = require('../../cds')
-const getLockInfo = require('../utils/lockInfo')
-const { INSERT, SELECT, DELETE } = cds.ql
-
-const { getCompositionTree } = require('../../common/composition')
-const { getColumns } = require('../../common/utils/columns')
-const { draftIsLocked, ensureDraftsSuffix, ensureNoDraftsSuffix, getSubCQNs } = require('../utils/handler')
-const { isActiveEntityRequested } = require('../utils/where')
-
-const _getDraftColumns = draftUUID => ({
-  IsActiveEntity: false,
-  HasDraftEntity: false,
-  HasActiveEntity: true,
-  DraftAdministrativeData_DraftUUID: draftUUID
-})
-
-const _getAdminData = ({ user }, draftUUID, time) => {
-  const currentUser = user.id || null
-  return {
-    DraftUUID: draftUUID,
-    CreationDateTime: time,
-    CreatedByUser: currentUser,
-    LastChangeDateTime: time,
-    LastChangedByUser: currentUser,
-    DraftIsCreatedByMe: true,
-    DraftIsProcessedByMe: true,
-    InProcessByUser: currentUser
-  }
-}
-
-const _getInsertAdminDataCQN = ({ user }, draftUUID, time) => {
-  return INSERT.into('DRAFT.DraftAdministrativeData').entries(_getAdminData({ user }, draftUUID, time))
-}
-
-async function _lockAndSelectActive(req, lockRecordCQN, selectCQNs, draftExistsCQN) {
-  try {
-    await this.run(lockRecordCQN)
-  } catch (e) {
-    const drafts = await this.run(draftExistsCQN)
-    if (drafts.length) req.reject(409, 'DRAFT_ALREADY_EXISTS')
-    req.reject(409, 'ENTITY_LOCKED')
-  }
-
-  const cqns = [this.run(draftExistsCQN), ...selectCQNs.map(cqn => this.run(cqn))]
-  const promisesResults = await Promise.allSettled(cqns)
-  const firstRejected = promisesResults.find(r => r.status === 'rejected')
-  if (firstRejected) req.reject(firstRejected.reason)
-  return promisesResults.map(result => result.value)
-}
-
-/**
- * Generic event handler for draft edit requests.
- *
- * @param req
- */
-const fioriGenericEdit = async function (req, next) {
-  if (!req.target._isDraftEnabled) return next()
-
-  if (!isActiveEntityRequested(req.query.SELECT.where || [])) {
-    req.reject(400, 'Action "draftEdit" can only be called on the active entity')
-  }
-
-  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
-
-  const { definitions } = this.model
-  const lockInfo = getLockInfo(req)
-  const rootWhere = lockInfo.rootWhere
-
-  // Ensure exclusive access to the root record of the active entity by applying a lock,
-  // which effectively prevents the creation or overwriting of duplicate draft entities.
-  // This lock mechanism enforces a strict processing order for active entities,
-  // allowing only one entity to be worked on at any given time.
-  // By using .forUpdate() with a wait value of 0, we immediately lock the record,
-  // ensuring there is no waiting time for other users attempting to edit the same record concurrently.
-  const activeLockCQN = SELECT.from(lockInfo.target, [1]).where(lockInfo.where).forUpdate({ wait: 0 })
-
-  const columnNames = getColumns(req.target, { onlyNames: true, filterVirtual: true })
-  const rootCQN = SELECT.from(req.target, columnNames).where(rootWhere)
-  const subCQNs = getSubCQNs({
-    definitions,
-    rootCQN,
-    compositionTree: getCompositionTree({ definitions, rootEntityName: ensureNoDraftsSuffix(req.target.name) })
-  })
-  const rootDraftName = ensureDraftsSuffix(req.target.name)
-  const draftExistsCQN = SELECT.from(rootDraftName, ['DraftAdministrativeData_DraftUUID as DraftUUID']).where(rootWhere)
-  const selectCQNs = [rootCQN, ...subCQNs.map(obj => obj.cqn)]
-
-  // fetch unlocalized data if not a texts entity
-  for (const q of selectCQNs) {
-    const entity = definitions[q.SELECT.from.ref[0]]
-    if (entity && !entity.name.match(/\.texts$/)) {
-      q.SELECT.localized = false
-    }
-  }
-
-  const dbtx = cds.tx(req)
-  // REVISIT: Use service.read with expand **
-  const [draftExists, ...results] = await _lockAndSelectActive.call(
-    dbtx,
-    req,
-    activeLockCQN,
-    [...selectCQNs],
-    draftExistsCQN
-  )
-
-  if (!results[0].length) req.reject(404)
-
-  if (draftExists.length) {
-    const adminData = await dbtx.run(
-      SELECT.one('DRAFT.DraftAdministrativeData', ['InProcessByUser', 'LastChangeDateTime']).where(draftExists[0])
-    )
-
-    // temp check if draft admin data in not maintained - raise 500 error
-    if (!adminData) req.reject(500, 'Draft administrative data is not maintained')
-
-    // draft is locked (default cancellation timeout timer has not expired) OR
-    // draft is not locked but must be rejected for popup
-    if (draftIsLocked(adminData.LastChangeDateTime) || req.data.PreserveChanges) {
-      req.reject(409, 'DRAFT_ALREADY_EXISTS')
-    }
-
-    await Promise.all([
-      dbtx.run(DELETE.from('DRAFT.DraftAdministrativeData').where(draftExists[0])),
-      dbtx.run(DELETE.from(rootDraftName).where(rootWhere))
-    ])
-  }
-
-  const draftUUID = cds.utils.uuid()
-  const insertCQNs = [_getInsertAdminDataCQN(req, draftUUID, req.timestamp)]
-
-  for (const resultIndex in results) {
-    if (results[resultIndex].length === 0) continue
-    const draftEntity = ensureDraftsSuffix(selectCQNs[resultIndex].SELECT.from.ref[0])
-    const entries = results[resultIndex].map(entityResult =>
-      Object.assign({}, entityResult, _getDraftColumns(draftUUID))
-    )
-
-    insertCQNs.push(INSERT.into(draftEntity).entries(entries))
-  }
-
-  await Promise.all(insertCQNs.map(CQN => dbtx.run(CQN)))
-
-  // REVISIT: we need to use okra API here because it must be set in the batched request
-  //          status code must be set in handler to allow overriding for FE V2
-  // REVISIT: needs reworking for new adapter, especially re $batch
-  if (req._?.odataRes) {
-    req._?.odataRes?.setStatusCode(201, { overwrite: true })
-  } else if (req.http?.res) {
-    req.http.res.status(201)
-  }
-
-  return results[0][0]
-}
-
-module.exports = cds.service.impl(function (srv) {
-  srv.on('EDIT', '*', fioriGenericEdit)
-})

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

@@ -1,25 +0,0 @@
-const cds = require('../../cds')
-
-exports.impl = cds.service.impl(function () {
-  _before(this)
-  _new(this)
-  _patch(this)
-  _cancel(this)
-  _edit(this)
-  _prepare(this)
-  _activate(this)
-  _delete(this)
-  _readOverDraft(this)
-  _read(this) // have to go last
-})
-
-const _before = require('../../fiori/generic/before')
-const _new = require('../../fiori/generic/new')
-const _patch = require('../../fiori/generic/patch')
-const _cancel = require('../../fiori/generic/cancel')
-const _edit = require('../../fiori/generic/edit')
-const _prepare = require('../../fiori/generic/prepare')
-const _activate = require('../../fiori/generic/activate')
-const _readOverDraft = require('../../fiori/generic/readOverDraft')
-const _read = require('../../fiori/generic/read')
-const _delete = require('../../fiori/generic/delete')

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

@@ -1,82 +0,0 @@
-const cds = require('../../cds')
-const { INSERT, UPDATE } = cds.ql
-
-const onDraftActivate = require('./activate')._handler
-const { isNavigationToMany } = require('../utils/req')
-const { ensureDraftsSuffix } = require('../utils/handler')
-
-const _getUpdateDraftAdminCQN = ({ user, timestamp }, draftUUID) => {
-  return UPDATE('DRAFT.DraftAdministrativeData')
-    .data({
-      InProcessByUser: user.id,
-      LastChangedByUser: user.id,
-      LastChangeDateTime: timestamp
-    })
-    .where({ DraftUUID: draftUUID })
-}
-
-const _getInsertDraftAdminCQN = ({ user, timestamp }, uuid) => {
-  return INSERT.into('DRAFT.DraftAdministrativeData').entries({
-    DraftUUID: uuid,
-    CreationDateTime: timestamp,
-    CreatedByUser: user.id,
-    LastChangeDateTime: timestamp,
-    LastChangedByUser: user.id,
-    DraftIsCreatedByMe: true,
-    DraftIsProcessedByMe: true,
-    InProcessByUser: user.id
-  })
-}
-
-const _getInsertDataCQN = (req, draftUUID) => {
-  const draftName = ensureDraftsSuffix(req.target.name)
-
-  const insertData = INSERT.into(draftName).entries(req.query.INSERT.entries[0]) // entries is always set because there are no entities without keys
-
-  req.data.IsActiveEntity = false
-  req.data.HasDraftEntity = false
-  req.data.HasActiveEntity = false
-  req.data.DraftAdministrativeData_DraftUUID = draftUUID
-
-  return insertData
-}
-
-/**
- * Generic Handler for CREATE requests in the context of draft.
- * In case of success it returns the created entry.
- *
- * @param req
- * @param next
- */
-const fioriGenericNew = async function (req, next) {
-  if (!req.target._isDraftEnabled) return next()
-
-  if (!req._draftMetadata) {
-    // REVISIT: when is this the case?
-    return onDraftActivate(req, next)
-  }
-
-  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
-
-  const isRoot = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
-  // Only allowed for pseudo draft roots (entities with this action)
-  if (isRoot && !req.target['@Common.DraftRoot.ActivationAction']) req.reject(403, 'DRAFT_MODIFICATION_ONLY_VIA_ROOT')
-
-  const navigationToMany = isNavigationToMany(req, this.model)
-
-  const adminDataCQN = navigationToMany
-    ? _getUpdateDraftAdminCQN(req, req.data.DraftAdministrativeData_DraftUUID)
-    : _getInsertDraftAdminCQN(req, req.data.DraftAdministrativeData_DraftUUID)
-  const insertDataCQN = _getInsertDataCQN(req, req.data.DraftAdministrativeData_DraftUUID)
-
-  const dbtx = cds.tx(req)
-
-  await Promise.all([dbtx.run(adminDataCQN), dbtx.run(insertDataCQN)])
-
-  req._.readAfterWrite = true
-  return { ...req.data, IsActiveEntity: false }
-}
-
-module.exports = cds.service.impl(function (srv) {
-  srv.on('NEW', '*', fioriGenericNew)
-})

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

@@ -1,101 +0,0 @@
-const cds = require('../../cds')
-const { UPDATE, SELECT } = cds.ql
-
-const { getUpdateDraftAdminCQN, ensureDraftsSuffix } = require('../utils/handler')
-const { removeIsActiveEntityRecursively } = require('../utils/where')
-const { deepCopyArray } = require('../../common/utils/copy')
-const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-
-const _getSelectCQN = ({ query }) => {
-  const fromRef = deepCopyArray(query.UPDATE.entity.ref)
-  for (const item of fromRef) {
-    if (item.where) {
-      item.where = removeIsActiveEntityRecursively(item.where)
-    }
-  }
-  fromRef[0].id = ensureDraftsSuffix(fromRef[0].id)
-  const from = { ref: fromRef }
-
-  return SELECT.from(from)
-}
-
-const _getUpdateDraftCQN = ({ query }, where, targetRef) => {
-  const set = {}
-
-  for (const entry in query.UPDATE.data) {
-    if (entry === 'DraftAdministrativeData_DraftUUID') {
-      continue
-    }
-
-    set[entry] = query.UPDATE.data[entry]
-  }
-
-  if (set.IsActiveEntity) set.IsActiveEntity = false
-
-  return UPDATE(targetRef).data(set).where(where)
-}
-
-const _joinDraftAdministrativeData = (selectResolved, target) => {
-  const columns = []
-  columns.push({ ref: ['DRAFT.DraftAdministrativeData', 'inProcessByUser'], as: 'draftAdmin_inProcessByUser' })
-  columns.push({ ref: [target, 'DraftAdministrativeData_DraftUUID'] })
-
-  return selectResolved
-    .columns(columns)
-    .join('DRAFT.DraftAdministrativeData')
-    .on([
-      { ref: [target, 'DraftAdministrativeData_DraftUUID'] },
-      '=',
-      { ref: ['DRAFT.DraftAdministrativeData', 'DraftUUID'] }
-    ])
-}
-
-/**
- * Generic Handler for PATCH requests in the context of draft.
- * In case of success it returns the updated entry.
- * If the entry to be updated does not exist, it rejects with error to return a 404.
- * If a draft is already in process of another user it rejects with 403.
- *
- * @param req
- */
-const fioriGenericPatch = async function (req, next) {
-  if (!req.target._isDraftEnabled) return next()
-
-  if (req.data.IsActiveEntity === true) req.reject(400, 'Patch can only be applied to a draft entity')
-
-  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
-
-  const dbtx = cds.tx(req)
-
-  const selectResolved = cqn2cqn4sql(_getSelectCQN(req), this.model)
-
-  const targetName = selectResolved.SELECT.from.ref[selectResolved.SELECT.from.ref.length - 1]
-  const alias = selectResolved.SELECT.from.as
-  const selectWithAdmin = _joinDraftAdministrativeData(selectResolved, alias || targetName)
-
-  if (req._etagValidationClause) selectWithAdmin.where(removeIsActiveEntityRecursively(req._etagValidationClause))
-
-  const results = await dbtx.run(selectWithAdmin)
-
-  if (results.length === 0) req.reject(req._etagValidationType ? 412 : 404)
-
-  const result = results[0]
-
-  // Potential timeout scenario supported
-  if (result.draftAdmin_inProcessByUser && result.draftAdmin_inProcessByUser !== req.user.id) req.reject(403)
-
-  const updateDraftCQN = _getUpdateDraftCQN(req, selectResolved.SELECT.where, {
-    ref: [targetName],
-    as: alias || targetName
-  })
-  const updateDraftAdminCQN = getUpdateDraftAdminCQN(req, result.DraftAdministrativeData_DraftUUID)
-
-  await Promise.all([dbtx.run(updateDraftCQN), dbtx.run(updateDraftAdminCQN)])
-  req._.readAfterWrite = true
-
-  return { ...req.data, IsActiveEntity: false }
-}
-
-module.exports = cds.service.impl(function (srv) {
-  srv.on('PATCH', '*', fioriGenericPatch)
-})

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

@@ -1,57 +0,0 @@
-const cds = require('../../cds')
-const { SELECT } = cds.ql
-
-const { isActiveEntityRequested } = require('../utils/where')
-const { ensureDraftsSuffix, ensureNoDraftsSuffix } = require('../utils/handler')
-const { getColumns } = require('../../common/utils/columns')
-
-/**
- * Generic Handler for PreparationAction requests.
- * In case of success it returns the prepared draft entry.
- *
- * @param req
- */
-const fioriGenericPrepare = async function (req, next) {
-  if (!req.target._isDraftEnabled) return next()
-
-  if (req.query.SELECT.from.ref.length > 1 || isActiveEntityRequested(req.query.SELECT.from.ref[0].where || [])) {
-    req.reject(400, 'Action "draftPrepare" can only be called on a draft entity')
-  }
-
-  if (!cds.db) req.reject('NO_DATABASE_CONNECTION')
-
-  const target = ensureDraftsSuffix(req.target.name)
-
-  const columns = getColumns(this.model.definitions[ensureNoDraftsSuffix(req.target.name)], {
-    keysOnly: true,
-    removeIgnore: true,
-    filterVirtual: true,
-    onlyNames: true
-  })
-  columns.push({ ref: ['DRAFT.DraftAdministrativeData', 'inProcessByUser'], as: 'draftAdmin_inProcessByUser' })
-
-  const select = SELECT.one(target)
-    .columns(columns)
-    .join('DRAFT.DraftAdministrativeData')
-    .on([
-      { ref: [target, 'DraftAdministrativeData_DraftUUID'] },
-      '=',
-      { ref: ['DRAFT.DraftAdministrativeData', 'DraftUUID'] }
-    ])
-    .where(req.query.SELECT.from.ref[0].where)
-
-  const result = await cds.tx(req).run(select)
-
-  if (!result) req.reject(404)
-
-  if (result.draftAdmin_inProcessByUser !== req.user.id)
-    req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [result.draftAdmin_inProcessByUser])
-
-  delete result.draftAdmin_inProcessByUser
-
-  return result
-}
-
-module.exports = cds.service.impl(function (srv) {
-  srv.on('draftPrepare', '*', fioriGenericPrepare)
-})