payload 4.0.0-internal.fa345ef → 4.0.0-internal.ff27d6e

package/dist/collections/operations/delete.js

@@ -1,32 +1,61 @@
-import { status as httpStatus } from 'http-status';
 import { executeAccess } from '../../auth/executeAccess.js';
+import { assertBranchMergeValidationWriteAllowed } from '../../branching/mergeWriteGuard.js';
+import { refreshBranchState, resetBranchState, resolveBranch } from '../../branching/resolveBranch.js';
+import { assertBranchCreatedDeleteUnreferenced, assertBranchDeleteCanUseCallerTransaction, requireBranchDeleteOutcome, setBranchDeleteOperation, willBranchAbsorbDelete } from '../../branching/tombstone.js';
+import { MAIN_BRANCH } from '../../branching/types.js';
+import { resolveBranchOwnVersions } from '../../branching/versions.js';
 import { combineQueries } from '../../database/combineQueries.js';
 import { validateQueryPaths } from '../../database/queryValidation/validateQueryPaths.js';
 import { sanitizeWhereQuery } from '../../database/sanitizeWhereQuery.js';
-import { APIError } from '../../errors/index.js';
+import { APIError, Locked } from '../../errors/index.js';
 import { afterRead } from '../../fields/hooks/afterRead/index.js';
 import { deleteUserPreferences } from '../../preferences/deleteUserPreferences.js';
 import { deleteAssociatedFiles } from '../../uploads/deleteAssociatedFiles.js';
+import { collectDocumentDeleteFileCandidates, scheduleUnreferencedFileCleanup } from '../../uploads/fileVersioning/cleanup.js';
+import { abortFileOperationScope, beginFileOperationScope, completeFileOperationScope } from '../../uploads/fileVersioning/fileOperationManager.js';
 import { appendNonTrashedFilter } from '../../utilities/appendNonTrashedFilter.js';
-import { checkDocumentLockStatus } from '../../utilities/checkDocumentLockStatus.js';
+import { assertNoValidationWrite } from '../../utilities/assertNoValidationWrite.js';
+import { deleteDocumentLocks, getDocumentLockState } from '../../utilities/checkDocumentLockStatus.js';
 import { commitTransaction } from '../../utilities/commitTransaction.js';
 import { hasScheduledPublishEnabled } from '../../utilities/getVersionsConfig.js';
+import { httpStatus } from '../../utilities/httpStatus.js';
 import { initTransaction } from '../../utilities/initTransaction.js';
 import { isErrorPublic } from '../../utilities/isErrorPublic.js';
 import { killTransaction } from '../../utilities/killTransaction.js';
 import { resolveSelect } from '../../utilities/resolveSelect.js';
 import { sanitizeSelect } from '../../utilities/sanitizeSelect.js';
+import { beginDeferredCleanupScope, clearDeferredCleanupScope, flushDeferredCleanupScope, flushDeferredCleanupScopeAfterOperation } from '../../utilities/transactionCallbacks.js';
+import { markTransactionWrite } from '../../utilities/transactionMutationTracker.js';
 import { deleteCollectionVersions } from '../../versions/deleteCollectionVersions.js';
 import { deleteScheduledPublishJobs } from '../../versions/deleteScheduledPublishJobs.js';
 import { buildAfterOperation } from './utilities/buildAfterOperation.js';
 import { buildBeforeOperation } from './utilities/buildBeforeOperation.js';
 export const deleteOperation = async (incomingArgs)=>{
     let args = incomingArgs;
+    let cleanupScope = null;
+    let hasCallerTransaction = false;
+    let shouldCommit = false;
+    assertBranchMergeValidationWriteAllowed({
+        req: args.req
+    });
+    assertNoValidationWrite(args.req);
     if (args.collection.config.disableBulkDelete && !args.overrideAccess) {
         throw new APIError(`Collection ${args.collection.config.slug} has disabled bulk delete`, 403);
     }
+    const hasFileOperationScope = Boolean(args.collection.config.upload) && !args.req.payload.db.bulkOperationsSingleTransaction;
+    const markedManagedDeletes = new Set();
+    if (hasFileOperationScope) {
+        beginFileOperationScope({
+            req: args.req
+        });
+    }
     try {
-        const shouldCommit = !args.disableTransaction && await initTransaction(args.req);
+        hasCallerTransaction = Boolean(await args.req.transactionID);
+        shouldCommit = !args.disableTransaction && !args.req.payload.db.bulkOperationsSingleTransaction && await initTransaction(args.req);
+        const hasSharedTransaction = hasCallerTransaction || shouldCommit;
+        cleanupScope = await beginDeferredCleanupScope({
+            req: args.req
+        });
         // /////////////////////////////////////
         // beforeOperation - Collection
         // /////////////////////////////////////
@@ -46,6 +75,7 @@ export const deleteOperation = async (incomingArgs)=>{
         let accessResult;
         if (!overrideAccess) {
             accessResult = await executeAccess({
+                slug: collectionConfig.slug,
                 req
             }, collectionConfig.access.delete);
         }
@@ -83,56 +113,568 @@ export const deleteOperation = async (incomingArgs)=>{
             collection: collectionConfig.slug,
             locale: locale,
             req,
-            select,
+            // File cleanup needs every stored representation even when the response selects only an ID.
+            select: collectionConfig.upload ? undefined : select,
             where: fullWhere
         });
         const errors = [];
-        const promises = docs.map(async (doc)=>{
-            let result;
-            const { id } = doc;
+        let didBatchDeleteFail = false;
+        const deletedFilesByID = new Map();
+        req.context ??= {};
+        const managedDeletedUploads = req.context._payloadManagedDeletedUploads ??= new Set();
+        const deletedDocumentIDs = new Map();
+        const hasWriteCapableBeforeDeleteHooks = Boolean(collectionConfig.hooks?.beforeDelete?.length);
+        const branch = resolveBranch({
+            req: req
+        });
+        const isDeletingFromBranch = Boolean(config.branching?.enabled && config.branching.branchableCollections.has(collectionConfig.slug)) && branch !== MAIN_BRANCH;
+        const hasBranchSharedTransaction = isDeletingFromBranch && hasSharedTransaction;
+        const pushError = (id, error, message)=>{
+            errors.push({
+                id,
+                isPublic: error instanceof Error ? isErrorPublic(error, config) : false,
+                message: message ?? (error instanceof Error ? error.message : 'Unknown error')
+            });
+        };
+        // /////////////////////////////////////
+        // beforeDelete - Collection, and associated files
+        // /////////////////////////////////////
+        const assertDeleteUnreferenced = async ({ doc })=>await assertBranchCreatedDeleteUnreferenced({
+                collectionSlug: collectionConfig.slug,
+                doc,
+                req
+            });
+        const runBeforeDeleteHooks = async ({ doc })=>{
+            if (collectionConfig.hooks?.beforeDelete?.length) {
+                for (const hook of collectionConfig.hooks.beforeDelete){
+                    await hook({
+                        id: doc.id,
+                        collection: collectionConfig,
+                        context: req.context,
+                        req
+                    });
+                }
+            }
+        };
+        const storeDeleteFileCandidates = async ({ fullDocument })=>{
+            const documentID = fullDocument.id;
+            if (!collectionConfig.upload || deletedFilesByID.has(documentID)) {
+                return;
+            }
+            const candidates = await collectDocumentDeleteFileCandidates({
+                collection: collectionConfig,
+                doc: fullDocument,
+                parentID: documentID,
+                req
+            });
+            deletedFilesByID.set(documentID, candidates);
+            if (candidates.length) {
+                const identity = JSON.stringify([
+                    collectionConfig.slug,
+                    String(documentID)
+                ]);
+                managedDeletedUploads.add(identity);
+                markedManagedDeletes.add(identity);
+            }
+        };
+        const findBranchVersionIDs = async ({ fullDocument })=>{
+            if (!collectionConfig.versions) {
+                return [];
+            }
+            const where = await resolveBranchOwnVersions({
+                id: fullDocument.id,
+                collectionSlug: collectionConfig.slug,
+                req
+            });
+            const { docs: versions } = await payload.db.findVersions({
+                branch: false,
+                collection: collectionConfig.slug,
+                limit: 0,
+                pagination: false,
+                req,
+                where
+            });
+            return versions.map(({ id })=>id);
+        };
+        const runDeleteCleanup = async ({ fullDocument, isTombstone })=>{
+            const absorbedByBranch = isTombstone ?? await willBranchAbsorbDelete({
+                collectionSlug: collectionConfig.slug,
+                doc: fullDocument,
+                req
+            });
+            await storeDeleteFileCandidates({
+                fullDocument
+            });
+            if (!absorbedByBranch) {
+                await deleteAssociatedFiles({
+                    collectionConfig,
+                    config,
+                    doc: fullDocument,
+                    overrideDelete: true,
+                    req
+                });
+            }
+            return absorbedByBranch;
+        };
+        const runBeforeDeleteHooksInDocumentTransaction = async ({ entry })=>{
+            let hookCleanupScope = null;
+            let hookShouldCommit = false;
             try {
-                // Each document gets its own transaction when singleTransaction is enabled
-                let docShouldCommit = false;
-                if (req.payload.db.bulkOperationsSingleTransaction) {
-                    docShouldCommit = await initTransaction(req);
+                hookShouldCommit = await initTransaction(req);
+                hookCleanupScope = await beginDeferredCleanupScope({
+                    req
+                });
+                await runBeforeDeleteHooks({
+                    doc: entry.doc
+                });
+                await flushDeferredCleanupScope({
+                    req,
+                    scope: hookCleanupScope
+                });
+                if (hookShouldCommit) {
+                    await commitTransaction(req);
                 }
-                // /////////////////////////////////////
-                // Handle potentially locked documents
-                // /////////////////////////////////////
-                await checkDocumentLockStatus({
-                    id,
+                return entry;
+            } catch (error) {
+                if (hookCleanupScope) {
+                    clearDeferredCleanupScope({
+                        req,
+                        scope: hookCleanupScope
+                    });
+                }
+                if (hookShouldCommit) {
+                    await killTransaction(req);
+                }
+                if (hasCallerTransaction) {
+                    throw error;
+                }
+                pushError(entry.doc.id, error);
+                return null;
+            }
+        };
+        const prepareDocumentsForDelete = async ()=>{
+            const { lockDocumentIDsByDocumentID, lockedDocumentIDs } = await getDocumentLockState({
+                collectionSlug: collectionConfig.slug,
+                ids: docs.map(({ id })=>id),
+                overrideLock,
+                req
+            });
+            const unlocked = [];
+            docs.forEach((doc, index)=>{
+                if (lockedDocumentIDs.has(String(doc.id))) {
+                    pushError(doc.id, new Locked(`Document with ID ${doc.id} is currently locked and cannot be deleted.`));
+                    return;
+                }
+                unlocked.push({
+                    doc,
+                    index
+                });
+            });
+            const initialCheckResults = await Promise.all(unlocked.map(async (entry)=>{
+                try {
+                    const fullDocument = await assertDeleteUnreferenced({
+                        doc: entry.doc
+                    });
+                    if (hasCallerTransaction && isDeletingFromBranch) {
+                        await assertBranchDeleteCanUseCallerTransaction({
+                            branch,
+                            collectionSlug: collectionConfig.slug,
+                            docID: entry.doc.id,
+                            req
+                        });
+                    }
+                    return {
+                        ...entry,
+                        fullDocument,
+                        lockDocumentIDs: lockDocumentIDsByDocumentID.get(String(entry.doc.id)) ?? []
+                    };
+                } catch (error) {
+                    pushError(entry.doc.id, error);
+                    return null;
+                }
+            }));
+            const initiallyChecked = initialCheckResults.filter((entry)=>entry !== null);
+            const hookResults = [];
+            if (req.payload.db.bulkOperationsSingleTransaction) {
+                for (const entry of initiallyChecked){
+                    hookResults.push(hasWriteCapableBeforeDeleteHooks ? await runBeforeDeleteHooksInDocumentTransaction({
+                        entry
+                    }) : entry);
+                }
+            } else if (hasBranchSharedTransaction) {
+                for (const entry of initiallyChecked){
+                    try {
+                        await runBeforeDeleteHooks({
+                            doc: entry.doc
+                        });
+                        hookResults.push(entry);
+                    } catch (error) {
+                        if (hasCallerTransaction) {
+                            throw error;
+                        }
+                        didBatchDeleteFail = true;
+                        await killTransaction(req);
+                        for (const rolledBackEntry of initiallyChecked){
+                            pushError(rolledBackEntry.doc.id, error, rolledBackEntry === entry ? undefined : `Bulk delete was rolled back because the beforeDelete hook failed for document ${entry.doc.id}.`);
+                        }
+                        return [];
+                    }
+                }
+            } else {
+                hookResults.push(...await Promise.all(initiallyChecked.map(async (entry)=>{
+                    try {
+                        await runBeforeDeleteHooks({
+                            doc: entry.doc
+                        });
+                        return entry;
+                    } catch (error) {
+                        pushError(entry.doc.id, error);
+                        return null;
+                    }
+                })));
+            }
+            const hookCompleted = hookResults.filter((entry)=>entry !== null);
+            const { lockDocumentIDsByDocumentID: refreshedLockDocumentIDsByDocumentID, lockedDocumentIDs: refreshedLockedDocumentIDs } = await getDocumentLockState({
+                collectionSlug: collectionConfig.slug,
+                ids: hookCompleted.map(({ doc })=>doc.id),
+                overrideLock,
+                req
+            });
+            const lockCheckedAfterHooks = [];
+            for (const entry of hookCompleted){
+                const documentID = String(entry.doc.id);
+                if (refreshedLockedDocumentIDs.has(documentID)) {
+                    pushError(entry.doc.id, new Locked(`Document with ID ${entry.doc.id} is currently locked and cannot be deleted.`));
+                    continue;
+                }
+                lockCheckedAfterHooks.push({
+                    ...entry,
+                    lockDocumentIDs: refreshedLockDocumentIDsByDocumentID.get(documentID) ?? []
+                });
+            }
+            const postHookCheckResults = [];
+            if (hasBranchSharedTransaction) {
+                for (const entry of lockCheckedAfterHooks){
+                    const fullDocument = await assertDeleteUnreferenced({
+                        doc: entry.fullDocument
+                    });
+                    postHookCheckResults.push({
+                        ...entry,
+                        fullDocument
+                    });
+                }
+            } else {
+                postHookCheckResults.push(...await Promise.all(lockCheckedAfterHooks.map(async (entry)=>{
+                    try {
+                        const fullDocument = await assertDeleteUnreferenced({
+                            doc: entry.fullDocument
+                        });
+                        return {
+                            ...entry,
+                            fullDocument
+                        };
+                    } catch (error) {
+                        pushError(entry.doc.id, error);
+                        return null;
+                    }
+                })));
+            }
+            return postHookCheckResults.filter((entry)=>entry !== null);
+        };
+        // /////////////////////////////////////
+        // afterRead - Fields, afterRead - Collection, afterDelete - Collection
+        // /////////////////////////////////////
+        const runAfterDeleteWork = async (doc)=>{
+            let result = await afterRead({
+                collection: collectionConfig,
+                context: req.context,
+                depth: depth,
+                doc,
+                // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+                draft: undefined,
+                fallbackLocale: fallbackLocale,
+                global: null,
+                locale: locale,
+                overrideAccess: overrideAccess,
+                populate,
+                req,
+                select,
+                showHiddenFields: showHiddenFields
+            });
+            // Add collection property for auth collections
+            if (collectionConfig.auth) {
+                result = {
+                    ...result,
+                    collection: collectionConfig.slug
+                };
+            }
+            if (collectionConfig.hooks?.afterRead?.length) {
+                for (const hook of collectionConfig.hooks.afterRead){
+                    result = await hook({
+                        collection: collectionConfig,
+                        context: req.context,
+                        doc: result || doc,
+                        overrideAccess,
+                        req
+                    }) || result;
+                }
+            }
+            if (collectionConfig.hooks?.afterDelete?.length) {
+                for (const hook of collectionConfig.hooks.afterDelete){
+                    result = await hook({
+                        id: doc.id,
+                        collection: collectionConfig,
+                        context: req.context,
+                        doc: result,
+                        req
+                    }) || result;
+                }
+            }
+            return result;
+        };
+        /**
+     * One transaction and one set of database calls per document. Only used when
+     * `bulkOperationsSingleTransaction` is enabled, which requires each document to be committed
+     * on its own and therefore cannot share a batched write with the rest of the operation.
+     */ const deleteDocumentIndividually = async ({ doc, fullDocument: initiallyCheckedDocument, lockDocumentIDs })=>{
+            let docCleanupScope = null;
+            let docShouldCommit = false;
+            let hasReachedWriteCapableStage = hasCallerTransaction && hasWriteCapableBeforeDeleteHooks;
+            const hasIndividualFileScope = Boolean(collectionConfig.upload);
+            if (hasIndividualFileScope) {
+                beginFileOperationScope({
+                    req
+                });
+            }
+            try {
+                docShouldCommit = await initTransaction(req);
+                docCleanupScope = await beginDeferredCleanupScope({
+                    req
+                });
+                const fullDocument = await assertDeleteUnreferenced({
+                    doc: initiallyCheckedDocument
+                });
+                const absorbedByBranch = await willBranchAbsorbDelete({
                     collectionSlug: collectionConfig.slug,
-                    lockErrorMessage: `Document with ID ${id} is currently locked and cannot be deleted.`,
-                    overrideLock,
+                    doc: fullDocument,
                     req
                 });
-                // /////////////////////////////////////
-                // beforeDelete - Collection
-                // /////////////////////////////////////
-                if (collectionConfig.hooks?.beforeDelete?.length) {
-                    for (const hook of collectionConfig.hooks.beforeDelete){
-                        await hook({
-                            id,
-                            collection: collectionConfig,
-                            context: req.context,
+                let branchDeleteOutcome;
+                let branchVersionIDs = [];
+                if (isDeletingFromBranch) {
+                    await storeDeleteFileCandidates({
+                        fullDocument
+                    });
+                    branchVersionIDs = await findBranchVersionIDs({
+                        fullDocument
+                    });
+                }
+                if (!isDeletingFromBranch) {
+                    await runDeleteCleanup({
+                        fullDocument
+                    });
+                    if (collectionConfig.versions) {
+                        hasReachedWriteCapableStage = true;
+                        await deleteCollectionVersions({
+                            id: doc.id,
+                            slug: collectionConfig.slug,
+                            payload,
+                            req
+                        });
+                    }
+                    if (hasScheduledPublishEnabled(collectionConfig) && !absorbedByBranch) {
+                        hasReachedWriteCapableStage = true;
+                        await deleteScheduledPublishJobs({
+                            id: doc.id,
+                            slug: collectionConfig.slug,
+                            payload,
                             req
                         });
                     }
                 }
-                await deleteAssociatedFiles({
-                    collectionConfig,
-                    config,
-                    doc,
-                    overrideDelete: true,
+                hasReachedWriteCapableStage = true;
+                if (isDeletingFromBranch) {
+                    setBranchDeleteOperation({
+                        branch,
+                        collectionSlug: collectionConfig.slug,
+                        docID: doc.id,
+                        isTombstoneExpected: absorbedByBranch,
+                        onResolved: (outcome)=>{
+                            branchDeleteOutcome = outcome;
+                        },
+                        req,
+                        useAmbientTransaction: docShouldCommit
+                    });
+                }
+                await payload.db.deleteOne({
+                    collection: collectionConfig.slug,
+                    req,
+                    returning: false,
+                    where: {
+                        id: {
+                            equals: doc.id
+                        }
+                    }
+                });
+                markTransactionWrite({
                     req
                 });
+                const finalBranchDeleteOutcome = isDeletingFromBranch ? requireBranchDeleteOutcome({
+                    outcome: branchDeleteOutcome
+                }) : {
+                    doc: fullDocument,
+                    tombstoned: false
+                };
+                if (!finalBranchDeleteOutcome.tombstoned) {
+                    deletedDocumentIDs.set(String(doc.id), doc.id);
+                }
+                if (isDeletingFromBranch) {
+                    await runDeleteCleanup({
+                        fullDocument: finalBranchDeleteOutcome.doc,
+                        isTombstone: finalBranchDeleteOutcome.tombstoned
+                    });
+                    if (collectionConfig.versions) {
+                        hasReachedWriteCapableStage = true;
+                        await deleteCollectionVersions({
+                            id: doc.id,
+                            slug: collectionConfig.slug,
+                            payload,
+                            req,
+                            versionIDs: branchVersionIDs
+                        });
+                    }
+                    if (hasScheduledPublishEnabled(collectionConfig) && !finalBranchDeleteOutcome.tombstoned) {
+                        hasReachedWriteCapableStage = true;
+                        await deleteScheduledPublishJobs({
+                            id: doc.id,
+                            slug: collectionConfig.slug,
+                            payload,
+                            req
+                        });
+                    }
+                }
+                if (collectionConfig.upload) {
+                    await scheduleUnreferencedFileCleanup({
+                        candidates: deletedFilesByID.get(doc.id) ?? [],
+                        collection: collectionConfig,
+                        req
+                    });
+                }
+                await deleteDocumentLocks({
+                    collectionSlug: collectionConfig.slug,
+                    ids: [
+                        doc.id
+                    ],
+                    lockDocumentIDs,
+                    req
+                });
+                const result = await runAfterDeleteWork(isDeletingFromBranch ? finalBranchDeleteOutcome.doc : doc);
+                if (docCleanupScope) {
+                    await flushDeferredCleanupScope({
+                        req,
+                        scope: docCleanupScope
+                    });
+                }
+                if (docShouldCommit) {
+                    await commitTransaction(req);
+                }
+                if (hasIndividualFileScope) {
+                    await completeFileOperationScope({
+                        req
+                    });
+                }
+                return result;
+            } catch (error) {
+                if (docCleanupScope) {
+                    clearDeferredCleanupScope({
+                        req,
+                        scope: docCleanupScope
+                    });
+                }
+                if (docShouldCommit) {
+                    await killTransaction(req);
+                    deletedDocumentIDs.delete(String(doc.id));
+                    resetBranchState({
+                        req: req
+                    });
+                }
+                if (hasIndividualFileScope) {
+                    await abortFileOperationScope({
+                        req
+                    });
+                }
+                if (hasCallerTransaction && hasReachedWriteCapableStage) {
+                    throw error;
+                }
+                pushError(doc.id, error);
+                return null;
+            }
+        };
+        /**
+     * Deletes unbranched rows as one batch. Branch deletes use the per-document adapter path so it
+     * can create tombstones and remove branch-created rows from the change registry. Hooks still
+     * run for each document.
+     */ const deleteDocumentsInBulk = async (preparedDocuments)=>{
+            const results = new Array(docs.length).fill(null);
+            let deletable;
+            if (isDeletingFromBranch) {
+                deletable = await Promise.all(preparedDocuments.map(async (entry)=>({
+                        ...entry,
+                        absorbedByBranch: await willBranchAbsorbDelete({
+                            collectionSlug: collectionConfig.slug,
+                            doc: entry.fullDocument,
+                            req
+                        })
+                    })));
+            } else {
+                const cleanupResults = [];
+                for (const entry of preparedDocuments){
+                    let documentCleanupScope = null;
+                    try {
+                        documentCleanupScope = await beginDeferredCleanupScope({
+                            req
+                        });
+                        const absorbedByBranch = await runDeleteCleanup({
+                            fullDocument: entry.fullDocument
+                        });
+                        await flushDeferredCleanupScope({
+                            req,
+                            scope: documentCleanupScope
+                        });
+                        cleanupResults.push({
+                            ...entry,
+                            absorbedByBranch
+                        });
+                    } catch (error) {
+                        if (documentCleanupScope) {
+                            clearDeferredCleanupScope({
+                                req,
+                                scope: documentCleanupScope
+                            });
+                        }
+                        if (hasBranchSharedTransaction && hasWriteCapableBeforeDeleteHooks) {
+                            throw error;
+                        }
+                        pushError(entry.doc.id, error);
+                        cleanupResults.push(null);
+                    }
+                }
+                deletable = cleanupResults.filter((entry)=>entry !== null);
+            }
+            if (!deletable.length) {
+                return results;
+            }
+            const ids = deletable.map(({ doc })=>doc.id);
+            const lockDocumentIDs = deletable.flatMap((entry)=>entry.lockDocumentIDs);
+            const hardDeleteIDs = deletable.filter(({ absorbedByBranch })=>!absorbedByBranch).map(({ doc })=>doc.id);
+            if (!isDeletingFromBranch) {
                 // /////////////////////////////////////
                 // Delete versions
                 // /////////////////////////////////////
                 if (collectionConfig.versions) {
                     await deleteCollectionVersions({
-                        id,
                         slug: collectionConfig.slug,
+                        ids,
                         payload,
                         req
                     });
@@ -140,125 +682,236 @@ export const deleteOperation = async (incomingArgs)=>{
                 // /////////////////////////////////////
                 // Delete scheduled posts
                 // /////////////////////////////////////
-                if (hasScheduledPublishEnabled(collectionConfig)) {
+                if (hasScheduledPublishEnabled(collectionConfig) && hardDeleteIDs.length) {
                     await deleteScheduledPublishJobs({
-                        id,
                         slug: collectionConfig.slug,
+                        ids: hardDeleteIDs,
                         payload,
                         req
                     });
                 }
-                // /////////////////////////////////////
-                // Delete document
-                // /////////////////////////////////////
-                await payload.db.deleteOne({
-                    collection: collectionConfig.slug,
-                    req,
-                    returning: false,
-                    where: {
-                        id: {
-                            equals: id
+            }
+            // /////////////////////////////////////
+            // Delete documents
+            // /////////////////////////////////////
+            const deletedInBatch = [];
+            const branchDeleteOutcomes = new Map();
+            const branchDeleteEntries = [];
+            try {
+                if (isDeletingFromBranch) {
+                    for (const entry of deletable){
+                        const { absorbedByBranch, doc, fullDocument } = entry;
+                        await storeDeleteFileCandidates({
+                            fullDocument
+                        });
+                        branchDeleteEntries.push({
+                            ...entry,
+                            branchVersionIDs: await findBranchVersionIDs({
+                                fullDocument
+                            })
+                        });
+                        setBranchDeleteOperation({
+                            branch,
+                            collectionSlug: collectionConfig.slug,
+                            docID: doc.id,
+                            isTombstoneExpected: absorbedByBranch,
+                            onResolved: (outcome)=>{
+                                branchDeleteOutcomes.set(String(doc.id), outcome);
+                            },
+                            req,
+                            useAmbientTransaction: shouldCommit
+                        });
+                        await payload.db.deleteOne({
+                            collection: collectionConfig.slug,
+                            req,
+                            returning: false,
+                            where: {
+                                id: {
+                                    equals: doc.id
+                                }
+                            }
+                        });
+                        markTransactionWrite({
+                            req
+                        });
+                        const finalBranchDeleteOutcome = requireBranchDeleteOutcome({
+                            outcome: branchDeleteOutcomes.get(String(doc.id))
+                        });
+                        if (!finalBranchDeleteOutcome.tombstoned) {
+                            deletedDocumentIDs.set(String(doc.id), doc.id);
                         }
+                        deletedInBatch.push(doc.id);
                     }
-                });
-                // /////////////////////////////////////
-                // afterRead - Fields
-                // /////////////////////////////////////
-                result = await afterRead({
-                    collection: collectionConfig,
-                    context: req.context,
-                    depth: depth,
-                    doc: result || doc,
-                    // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
-                    draft: undefined,
-                    fallbackLocale: fallbackLocale,
-                    global: null,
-                    locale: locale,
-                    overrideAccess: overrideAccess,
-                    populate,
-                    req,
-                    select,
-                    showHiddenFields: showHiddenFields
-                });
-                // /////////////////////////////////////
-                // Add collection property for auth collections
-                // /////////////////////////////////////
-                if (collectionConfig.auth) {
-                    result = {
-                        ...result,
-                        collection: collectionConfig.slug
-                    };
-                }
-                // /////////////////////////////////////
-                // afterRead - Collection
-                // /////////////////////////////////////
-                if (collectionConfig.hooks?.afterRead?.length) {
-                    for (const hook of collectionConfig.hooks.afterRead){
-                        result = await hook({
-                            collection: collectionConfig,
-                            context: req.context,
-                            doc: result || doc,
-                            overrideAccess,
-                            req
-                        }) || result;
+                } else {
+                    await payload.db.deleteMany({
+                        collection: collectionConfig.slug,
+                        req,
+                        where: {
+                            id: {
+                                in: ids
+                            }
+                        }
+                    });
+                    markTransactionWrite({
+                        req
+                    });
+                    for (const id of ids){
+                        deletedDocumentIDs.set(String(id), id);
+                        deletedInBatch.push(id);
                     }
                 }
-                // /////////////////////////////////////
-                // afterDelete - Collection
-                // /////////////////////////////////////
-                if (collectionConfig.hooks?.afterDelete?.length) {
-                    for (const hook of collectionConfig.hooks.afterDelete){
-                        result = await hook({
-                            id,
-                            collection: collectionConfig,
-                            context: req.context,
-                            doc: result,
+                if (isDeletingFromBranch) {
+                    for (const { doc } of deletable){
+                        const finalBranchDeleteOutcome = requireBranchDeleteOutcome({
+                            outcome: branchDeleteOutcomes.get(String(doc.id))
+                        });
+                        await runDeleteCleanup({
+                            fullDocument: finalBranchDeleteOutcome.doc,
+                            isTombstone: finalBranchDeleteOutcome.tombstoned
+                        });
+                    }
+                    if (collectionConfig.versions) {
+                        await deleteCollectionVersions({
+                            slug: collectionConfig.slug,
+                            ids,
+                            payload,
+                            req,
+                            versionIDs: branchDeleteEntries.flatMap(({ branchVersionIDs })=>branchVersionIDs)
+                        });
+                    }
+                    const finalHardDeleteIDs = deletable.filter(({ doc })=>{
+                        const outcome = requireBranchDeleteOutcome({
+                            outcome: branchDeleteOutcomes.get(String(doc.id))
+                        });
+                        return !outcome.tombstoned;
+                    }).map(({ doc })=>doc.id);
+                    if (hasScheduledPublishEnabled(collectionConfig) && finalHardDeleteIDs.length) {
+                        await deleteScheduledPublishJobs({
+                            slug: collectionConfig.slug,
+                            ids: finalHardDeleteIDs,
+                            payload,
                             req
-                        }) || result;
+                        });
                     }
                 }
-                // /////////////////////////////////////
-                // 8. Return results
-                // /////////////////////////////////////
-                if (docShouldCommit) {
-                    await commitTransaction(req);
-                }
-                return result;
+                await deleteDocumentLocks({
+                    collectionSlug: collectionConfig.slug,
+                    ids,
+                    lockDocumentIDs,
+                    req
+                });
             } catch (error) {
-                const isPublic = error instanceof Error ? isErrorPublic(error, config) : false;
-                if (req.payload.db.bulkOperationsSingleTransaction) {
+                didBatchDeleteFail = true;
+                if (shouldCommit) {
                     await killTransaction(req);
+                    resetBranchState({
+                        req: req
+                    });
+                    for (const id of deletedInBatch){
+                        deletedDocumentIDs.delete(String(id));
+                    }
                 }
-                errors.push({
-                    id: doc.id,
-                    isPublic,
-                    message: error instanceof Error ? error.message : 'Unknown error'
+                if (hasCallerTransaction) {
+                    throw error;
+                }
+                // The delete covers the whole batch, so a failure here belongs to the batch rather than to
+                // any single document. Say so explicitly, otherwise one batch failure reads as N unrelated
+                // per-document failures.
+                const message = `Bulk delete failed for this batch of ${deletable.length} documents: ${error instanceof Error ? error.message : 'Unknown error'}`;
+                for (const { doc } of deletable){
+                    pushError(doc.id, error, message);
+                }
+                return results;
+            }
+            if (collectionConfig.upload) {
+                await scheduleUnreferencedFileCleanup({
+                    candidates: deletable.flatMap(({ doc })=>deletedFilesByID.get(doc.id) ?? []),
+                    collection: collectionConfig,
+                    req
                 });
             }
-            return null;
-        });
-        // Process sequentially when using single transaction mode to avoid shared state issues
-        // Process in parallel when using one transaction for better performance
+            if (hasBranchSharedTransaction) {
+                for (const entry of deletable){
+                    const resultDocument = isDeletingFromBranch ? requireBranchDeleteOutcome({
+                        outcome: branchDeleteOutcomes.get(String(entry.doc.id))
+                    }).doc : entry.doc;
+                    try {
+                        results[entry.index] = await runAfterDeleteWork(resultDocument);
+                    } catch (error) {
+                        if (hasCallerTransaction) {
+                            throw error;
+                        }
+                        didBatchDeleteFail = true;
+                        await killTransaction(req);
+                        resetBranchState({
+                            req: req
+                        });
+                        results.fill(null);
+                        for (const id of deletedInBatch){
+                            deletedDocumentIDs.delete(String(id));
+                        }
+                        for (const rolledBackEntry of deletable){
+                            pushError(rolledBackEntry.doc.id, error, rolledBackEntry === entry ? undefined : `Bulk delete was rolled back because post-delete work failed for document ${entry.doc.id}.`);
+                        }
+                        return results;
+                    }
+                }
+                return results;
+            }
+            const postDeleteResults = await Promise.all(deletable.map(async (entry)=>{
+                try {
+                    const resultDocument = isDeletingFromBranch ? requireBranchDeleteOutcome({
+                        outcome: branchDeleteOutcomes.get(String(entry.doc.id))
+                    }).doc : entry.doc;
+                    return {
+                        entry,
+                        result: await runAfterDeleteWork(resultDocument),
+                        status: 'fulfilled'
+                    };
+                } catch (error) {
+                    return {
+                        entry,
+                        error,
+                        status: 'rejected'
+                    };
+                }
+            }));
+            for (const outcome of postDeleteResults){
+                if (outcome.status === 'rejected') {
+                    pushError(outcome.entry.doc.id, outcome.error);
+                } else {
+                    results[outcome.entry.index] = outcome.result;
+                }
+            }
+            return results;
+        };
         let awaitedDocs;
+        const preparedDocuments = await prepareDocumentsForDelete();
         if (req.payload.db.bulkOperationsSingleTransaction) {
+            // Process sequentially so that each document's transaction is isolated from the next
             awaitedDocs = [];
-            for (const promise of promises){
-                awaitedDocs.push(await promise);
+            for (const preparedDocument of preparedDocuments){
+                awaitedDocs.push(await deleteDocumentIndividually(preparedDocument));
             }
         } else {
-            awaitedDocs = await Promise.all(promises);
+            awaitedDocs = await deleteDocumentsInBulk(preparedDocuments);
         }
         // /////////////////////////////////////
         // Delete Preferences
         // /////////////////////////////////////
-        await deleteUserPreferences({
-            collectionConfig,
-            ids: docs.map(({ id })=>id),
-            payload,
-            req
-        });
+        const deletedPreferenceIDs = [
+            ...deletedDocumentIDs.values()
+        ];
+        if (deletedPreferenceIDs.length) {
+            await deleteUserPreferences({
+                collectionConfig,
+                ids: deletedPreferenceIDs,
+                payload,
+                req
+            });
+        }
         let result = {
-            docs: awaitedDocs.filter(Boolean),
+            docs: awaitedDocs.filter((doc)=>Boolean(doc)),
             errors
         };
         // /////////////////////////////////////
@@ -271,13 +924,60 @@ export const deleteOperation = async (incomingArgs)=>{
             overrideAccess,
             result
         });
-        if (shouldCommit) {
+        if (cleanupScope) {
+            if (didBatchDeleteFail) {
+                clearDeferredCleanupScope({
+                    req: args.req,
+                    scope: cleanupScope
+                });
+            } else {
+                await flushDeferredCleanupScopeAfterOperation({
+                    req,
+                    scope: cleanupScope
+                });
+            }
+        }
+        if (shouldCommit && !didBatchDeleteFail) {
             await commitTransaction(req);
         }
+        if (hasFileOperationScope) {
+            await completeFileOperationScope({
+                req
+            });
+        }
+        if (isDeletingFromBranch) {
+            refreshBranchState({
+                req: req
+            });
+        }
         return result;
     } catch (error) {
-        await killTransaction(args.req);
+        if (cleanupScope) {
+            clearDeferredCleanupScope({
+                req: args.req,
+                scope: cleanupScope
+            });
+        }
+        if (shouldCommit) {
+            await killTransaction(args.req);
+        }
+        resetBranchState({
+            req: args.req
+        });
+        if (hasFileOperationScope) {
+            await abortFileOperationScope({
+                req: args.req
+            });
+        }
         throw error;
+    } finally{
+        const managedDeletedUploads = args.req.context?._payloadManagedDeletedUploads;
+        for (const identity of markedManagedDeletes){
+            managedDeletedUploads?.delete(identity);
+        }
+        if (managedDeletedUploads?.size === 0) {
+            delete args.req.context._payloadManagedDeletedUploads;
+        }
     }
 };