payload 4.0.0-internal.ea6e8f8 → 4.0.0-internal.ee5d8bd

package/dist/collections/operations/delete.js

@@ -1,9 +1,4 @@
 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';
@@ -11,11 +6,11 @@ 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 { collectStoredFiles, collectVersionFiles, scheduleUnreferencedFileCleanup } from '../../uploads/fileVersioning/cleanup.js';
 import { abortFileOperationScope, beginFileOperationScope, completeFileOperationScope } from '../../uploads/fileVersioning/fileOperationManager.js';
 import { appendNonTrashedFilter } from '../../utilities/appendNonTrashedFilter.js';
 import { assertNoValidationWrite } from '../../utilities/assertNoValidationWrite.js';
-import { deleteDocumentLocks, getDocumentLockState } from '../../utilities/checkDocumentLockStatus.js';
+import { checkDocumentLockStatus, deleteDocumentLocks, getLockedDocumentIds } from '../../utilities/checkDocumentLockStatus.js';
 import { commitTransaction } from '../../utilities/commitTransaction.js';
 import { hasScheduledPublishEnabled } from '../../utilities/getVersionsConfig.js';
 import { httpStatus } from '../../utilities/httpStatus.js';
@@ -24,20 +19,12 @@ 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);
@@ -50,12 +37,7 @@ export const deleteOperation = async (incomingArgs)=>{
         });
     }
     try {
-        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
-        });
+        const shouldCommit = !args.disableTransaction && !args.req.payload.db.bulkOperationsSingleTransaction && await initTransaction(args.req);
         // /////////////////////////////////////
         // beforeOperation - Collection
         // /////////////////////////////////////
@@ -122,11 +104,6 @@ export const deleteOperation = async (incomingArgs)=>{
         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);
-        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,
@@ -137,12 +114,7 @@ export const deleteOperation = async (incomingArgs)=>{
         // /////////////////////////////////////
         // beforeDelete - Collection, and associated files
         // /////////////////////////////////////
-        const assertDeleteUnreferenced = async ({ doc })=>await assertBranchCreatedDeleteUnreferenced({
-                collectionSlug: collectionConfig.slug,
-                doc,
-                req
-            });
-        const runBeforeDeleteHooks = async ({ doc })=>{
+        const runBeforeDeleteWork = async (doc)=>{
             if (collectionConfig.hooks?.beforeDelete?.length) {
                 for (const hook of collectionConfig.hooks.beforeDelete){
                     await hook({
@@ -153,231 +125,35 @@ export const deleteOperation = async (incomingArgs)=>{
                     });
                 }
             }
-        };
-        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)
+            if (collectionConfig.upload) {
+                deletedFilesByID.set(doc.id, [
+                    ...await collectStoredFiles({
+                        collection: collectionConfig,
+                        doc,
+                        req
+                    }),
+                    ...collectionConfig.versions ? await collectVersionFiles({
+                        collection: collectionConfig,
+                        parentID: doc.id,
+                        req
+                    }) : []
                 ]);
-                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 {
-                hookShouldCommit = await initTransaction(req);
-                hookCleanupScope = await beginDeferredCleanupScope({
-                    req
-                });
-                await runBeforeDeleteHooks({
-                    doc: entry.doc
-                });
-                await flushDeferredCleanupScope({
-                    req,
-                    scope: hookCleanupScope
-                });
-                if (hookShouldCommit) {
-                    await commitTransaction(req);
+                if (deletedFilesByID.get(doc.id)?.length) {
+                    const identity = JSON.stringify([
+                        collectionConfig.slug,
+                        String(doc.id)
+                    ]);
+                    managedDeletedUploads.add(identity);
+                    markedManagedDeletes.add(identity);
                 }
-                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,
+            await deleteAssociatedFiles({
+                collectionConfig,
+                config,
+                doc,
+                overrideDelete: true,
                 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
@@ -434,10 +210,7 @@ export const deleteOperation = async (incomingArgs)=>{
      * 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 deleteDocumentIndividually = async (doc)=>{
             const hasIndividualFileScope = Boolean(collectionConfig.upload);
             if (hasIndividualFileScope) {
                 beginFileOperationScope({
@@ -445,63 +218,29 @@ export const deleteOperation = async (incomingArgs)=>{
                 });
             }
             try {
-                docShouldCommit = await initTransaction(req);
-                docCleanupScope = await beginDeferredCleanupScope({
-                    req
-                });
-                const fullDocument = await assertDeleteUnreferenced({
-                    doc: initiallyCheckedDocument
-                });
-                const absorbedByBranch = await willBranchAbsorbDelete({
+                const docShouldCommit = await initTransaction(req);
+                await checkDocumentLockStatus({
+                    id: doc.id,
                     collectionSlug: collectionConfig.slug,
-                    doc: fullDocument,
+                    lockErrorMessage: `Document with ID ${doc.id} is currently locked and cannot be deleted.`,
+                    overrideLock,
                     req
                 });
-                let branchDeleteOutcome;
-                let branchVersionIDs = [];
-                if (isDeletingFromBranch) {
-                    await storeDeleteFileCandidates({
-                        fullDocument
-                    });
-                    branchVersionIDs = await findBranchVersionIDs({
-                        fullDocument
-                    });
-                }
-                if (!isDeletingFromBranch) {
-                    await runDeleteCleanup({
-                        fullDocument
+                await runBeforeDeleteWork(doc);
+                if (collectionConfig.versions) {
+                    await deleteCollectionVersions({
+                        id: doc.id,
+                        slug: collectionConfig.slug,
+                        payload,
+                        req
                     });
-                    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
-                        });
-                    }
                 }
-                hasReachedWriteCapableStage = true;
-                if (isDeletingFromBranch) {
-                    setBranchDeleteOperation({
-                        branch,
-                        collectionSlug: collectionConfig.slug,
-                        docID: doc.id,
-                        isTombstoneExpected: absorbedByBranch,
-                        onResolved: (outcome)=>{
-                            branchDeleteOutcome = outcome;
-                        },
-                        req,
-                        useAmbientTransaction: docShouldCommit
+                if (hasScheduledPublishEnabled(collectionConfig)) {
+                    await deleteScheduledPublishJobs({
+                        id: doc.id,
+                        slug: collectionConfig.slug,
+                        payload,
+                        req
                     });
                 }
                 await payload.db.deleteOne({
@@ -514,43 +253,6 @@ export const deleteOperation = async (incomingArgs)=>{
                         }
                     }
                 });
-                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) ?? [],
@@ -558,21 +260,7 @@ export const deleteOperation = async (incomingArgs)=>{
                         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
-                    });
-                }
+                const result = await runAfterDeleteWork(doc);
                 if (docShouldCommit) {
                     await commitTransaction(req);
                 }
@@ -583,230 +271,98 @@ export const deleteOperation = async (incomingArgs)=>{
                 }
                 return result;
             } catch (error) {
-                if (docCleanupScope) {
-                    clearDeferredCleanupScope({
-                        req,
-                        scope: docCleanupScope
-                    });
-                }
-                if (docShouldCommit) {
-                    await killTransaction(req);
-                    deletedDocumentIDs.delete(String(doc.id));
-                    resetBranchState(req);
-                }
+                await killTransaction(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)=>{
+     * Deletes the whole batch using a constant number of database calls, independent of how many
+     * documents matched. Hooks still run per document, they just no longer each carry a write.
+     */ const deleteDocumentsInBulk = async ()=>{
             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);
-                    }
+            // /////////////////////////////////////
+            // Handle potentially locked documents
+            // /////////////////////////////////////
+            const lockedIds = await getLockedDocumentIds({
+                collectionSlug: collectionConfig.slug,
+                ids: docs.map(({ id })=>id),
+                overrideLock,
+                req
+            });
+            const unlocked = [];
+            docs.forEach((doc, index)=>{
+                if (lockedIds.has(String(doc.id))) {
+                    pushError(doc.id, new Locked(`Document with ID ${doc.id} is currently locked and cannot be deleted.`));
+                    return;
                 }
-                deletable = cleanupResults.filter((entry)=>entry !== null);
-            }
+                unlocked.push({
+                    doc,
+                    index
+                });
+            });
+            await deleteDocumentLocks({
+                collectionSlug: collectionConfig.slug,
+                ids: unlocked.map(({ doc })=>doc.id),
+                req
+            });
+            const deletable = [];
+            await Promise.all(unlocked.map(async (entry)=>{
+                try {
+                    await runBeforeDeleteWork(entry.doc);
+                    deletable.push(entry);
+                } catch (error) {
+                    pushError(entry.doc.id, error);
+                }
+            }));
             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({
-                        slug: collectionConfig.slug,
-                        ids,
-                        payload,
-                        req
-                    });
-                }
-                // /////////////////////////////////////
-                // Delete scheduled posts
-                // /////////////////////////////////////
-                if (hasScheduledPublishEnabled(collectionConfig) && hardDeleteIDs.length) {
-                    await deleteScheduledPublishJobs({
-                        slug: collectionConfig.slug,
-                        ids: hardDeleteIDs,
-                        payload,
-                        req
-                    });
-                }
+            // /////////////////////////////////////
+            // Delete versions
+            // /////////////////////////////////////
+            if (collectionConfig.versions) {
+                await deleteCollectionVersions({
+                    slug: collectionConfig.slug,
+                    ids,
+                    payload,
+                    req
+                });
+            }
+            // /////////////////////////////////////
+            // Delete scheduled posts
+            // /////////////////////////////////////
+            if (hasScheduledPublishEnabled(collectionConfig)) {
+                await deleteScheduledPublishJobs({
+                    slug: collectionConfig.slug,
+                    ids,
+                    payload,
+                    req
+                });
             }
             // /////////////////////////////////////
             // 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);
-                    }
-                } else {
-                    await payload.db.deleteMany({
-                        collection: collectionConfig.slug,
-                        req,
-                        where: {
-                            id: {
-                                in: ids
-                            }
+                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);
-                    }
-                }
-                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
-                        });
-                    }
-                }
-                await deleteDocumentLocks({
-                    collectionSlug: collectionConfig.slug,
-                    ids,
-                    lockDocumentIDs,
-                    req
                 });
             } catch (error) {
                 didBatchDeleteFail = true;
                 if (shouldCommit) {
                     await killTransaction(req);
-                    resetBranchState(req);
-                    for (const id of deletedInBatch){
-                        deletedDocumentIDs.delete(String(id));
-                    }
-                }
-                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
@@ -824,80 +380,32 @@ export const deleteOperation = async (incomingArgs)=>{
                     req
                 });
             }
-            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);
-                        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)=>{
+            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'
-                    };
+                    results[entry.index] = await runAfterDeleteWork(entry.doc);
                 } catch (error) {
-                    return {
-                        entry,
-                        error,
-                        status: 'rejected'
-                    };
+                    pushError(entry.doc.id, error);
                 }
             }));
-            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 preparedDocument of preparedDocuments){
-                awaitedDocs.push(await deleteDocumentIndividually(preparedDocument));
+            for (const doc of docs){
+                awaitedDocs.push(await deleteDocumentIndividually(doc));
             }
         } else {
-            awaitedDocs = await deleteDocumentsInBulk(preparedDocuments);
+            awaitedDocs = await deleteDocumentsInBulk();
         }
         // /////////////////////////////////////
         // Delete Preferences
         // /////////////////////////////////////
-        const deletedPreferenceIDs = [
-            ...deletedDocumentIDs.values()
-        ];
-        if (deletedPreferenceIDs.length) {
+        if (!didBatchDeleteFail) {
             await deleteUserPreferences({
                 collectionConfig,
-                ids: deletedPreferenceIDs,
+                ids: docs.map(({ id })=>id),
                 payload,
                 req
             });
@@ -916,19 +424,6 @@ export const deleteOperation = async (incomingArgs)=>{
             overrideAccess,
             result
         });
-        if (cleanupScope) {
-            if (didBatchDeleteFail) {
-                clearDeferredCleanupScope({
-                    req: args.req,
-                    scope: cleanupScope
-                });
-            } else {
-                await flushDeferredCleanupScopeAfterOperation({
-                    req,
-                    scope: cleanupScope
-                });
-            }
-        }
         if (shouldCommit && !didBatchDeleteFail) {
             await commitTransaction(req);
         }
@@ -937,21 +432,9 @@ export const deleteOperation = async (incomingArgs)=>{
                 req
             });
         }
-        if (isDeletingFromBranch) {
-            refreshBranchState(req);
-        }
         return result;
     } catch (error) {
-        if (cleanupScope) {
-            clearDeferredCleanupScope({
-                req: args.req,
-                scope: cleanupScope
-            });
-        }
-        if (shouldCommit) {
-            await killTransaction(args.req);
-        }
-        resetBranchState(args.req);
+        await killTransaction(args.req);
         if (hasFileOperationScope) {
             await abortFileOperationScope({
                 req: args.req