payload 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

package/dist/collections/operations/delete.js

@@ -1,16 +1,19 @@
-import { status as httpStatus } from 'http-status';
 import { executeAccess } from '../../auth/executeAccess.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 { collectStoredFiles, collectVersionFiles, 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 { 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';
 import { initTransaction } from '../../utilities/initTransaction.js';
 import { isErrorPublic } from '../../utilities/isErrorPublic.js';
 import { killTransaction } from '../../utilities/killTransaction.js';
@@ -22,11 +25,19 @@ import { buildAfterOperation } from './utilities/buildAfterOperation.js';
 import { buildBeforeOperation } from './utilities/buildBeforeOperation.js';
 export const deleteOperation = async (incomingArgs)=>{
     let args = incomingArgs;
+    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);
+        const shouldCommit = !args.disableTransaction && !args.req.payload.db.bulkOperationsSingleTransaction && await initTransaction(args.req);
         // /////////////////////////////////////
         // beforeOperation - Collection
         // /////////////////////////////////////
@@ -46,6 +57,7 @@ export const deleteOperation = async (incomingArgs)=>{
         let accessResult;
         if (!overrideAccess) {
             accessResult = await executeAccess({
+                slug: collectionConfig.slug,
                 req
             }, collectionConfig.access.delete);
         }
@@ -83,182 +95,323 @@ 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;
-            try {
-                // Each document gets its own transaction when singleTransaction is enabled
-                let docShouldCommit = false;
-                if (req.payload.db.bulkOperationsSingleTransaction) {
-                    docShouldCommit = await initTransaction(req);
+        let didBatchDeleteFail = false;
+        const deletedFilesByID = new Map();
+        req.context ??= {};
+        const managedDeletedUploads = req.context._payloadManagedDeletedUploads ??= new Set();
+        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 runBeforeDeleteWork = 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
+                    });
+                }
+            }
+            if (collectionConfig.upload) {
+                deletedFilesByID.set(doc.id, [
+                    ...await collectStoredFiles({
+                        collection: collectionConfig,
+                        doc,
+                        req
+                    }),
+                    ...collectionConfig.versions ? await collectVersionFiles({
+                        collection: collectionConfig,
+                        parentID: doc.id,
+                        req
+                    }) : []
+                ]);
+                if (deletedFilesByID.get(doc.id)?.length) {
+                    const identity = JSON.stringify([
+                        collectionConfig.slug,
+                        String(doc.id)
+                    ]);
+                    managedDeletedUploads.add(identity);
+                    markedManagedDeletes.add(identity);
+                }
+            }
+            await deleteAssociatedFiles({
+                collectionConfig,
+                config,
+                doc,
+                overrideDelete: true,
+                req
+            });
+        };
+        // /////////////////////////////////////
+        // 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;
                 }
-                // /////////////////////////////////////
-                // Handle potentially locked documents
-                // /////////////////////////////////////
+            }
+            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)=>{
+            const hasIndividualFileScope = Boolean(collectionConfig.upload);
+            if (hasIndividualFileScope) {
+                beginFileOperationScope({
+                    req
+                });
+            }
+            try {
+                const docShouldCommit = await initTransaction(req);
                 await checkDocumentLockStatus({
-                    id,
+                    id: doc.id,
                     collectionSlug: collectionConfig.slug,
-                    lockErrorMessage: `Document with ID ${id} is currently locked and cannot be deleted.`,
+                    lockErrorMessage: `Document with ID ${doc.id} is currently locked and cannot be deleted.`,
                     overrideLock,
                     req
                 });
-                // /////////////////////////////////////
-                // beforeDelete - Collection
-                // /////////////////////////////////////
-                if (collectionConfig.hooks?.beforeDelete?.length) {
-                    for (const hook of collectionConfig.hooks.beforeDelete){
-                        await hook({
-                            id,
-                            collection: collectionConfig,
-                            context: req.context,
-                            req
-                        });
-                    }
-                }
-                await deleteAssociatedFiles({
-                    collectionConfig,
-                    config,
-                    doc,
-                    overrideDelete: true,
-                    req
-                });
-                // /////////////////////////////////////
-                // Delete versions
-                // /////////////////////////////////////
+                await runBeforeDeleteWork(doc);
                 if (collectionConfig.versions) {
                     await deleteCollectionVersions({
-                        id,
+                        id: doc.id,
                         slug: collectionConfig.slug,
                         payload,
                         req
                     });
                 }
-                // /////////////////////////////////////
-                // Delete scheduled posts
-                // /////////////////////////////////////
                 if (hasScheduledPublishEnabled(collectionConfig)) {
                     await deleteScheduledPublishJobs({
-                        id,
+                        id: doc.id,
                         slug: collectionConfig.slug,
                         payload,
                         req
                     });
                 }
-                // /////////////////////////////////////
-                // Delete document
-                // /////////////////////////////////////
                 await payload.db.deleteOne({
                     collection: collectionConfig.slug,
                     req,
                     returning: false,
                     where: {
                         id: {
-                            equals: id
+                            equals: 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;
-                    }
-                }
-                // /////////////////////////////////////
-                // 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,
-                            req
-                        }) || result;
-                    }
+                if (collectionConfig.upload) {
+                    await scheduleUnreferencedFileCleanup({
+                        candidates: deletedFilesByID.get(doc.id) ?? [],
+                        collection: collectionConfig,
+                        req
+                    });
                 }
-                // /////////////////////////////////////
-                // 8. Return results
-                // /////////////////////////////////////
+                const result = await runAfterDeleteWork(doc);
                 if (docShouldCommit) {
                     await commitTransaction(req);
                 }
+                if (hasIndividualFileScope) {
+                    await completeFileOperationScope({
+                        req
+                    });
+                }
                 return result;
             } catch (error) {
-                const isPublic = error instanceof Error ? isErrorPublic(error, config) : false;
-                if (req.payload.db.bulkOperationsSingleTransaction) {
+                await killTransaction(req);
+                if (hasIndividualFileScope) {
+                    await abortFileOperationScope({
+                        req
+                    });
+                }
+                pushError(doc.id, error);
+                return null;
+            }
+        };
+        /**
+     * 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);
+            // /////////////////////////////////////
+            // 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;
+                }
+                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);
+            // /////////////////////////////////////
+            // 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
+            // /////////////////////////////////////
+            try {
+                await payload.db.deleteMany({
+                    collection: collectionConfig.slug,
+                    req,
+                    where: {
+                        id: {
+                            in: ids
+                        }
+                    }
+                });
+            } catch (error) {
+                didBatchDeleteFail = true;
+                if (shouldCommit) {
                     await killTransaction(req);
                 }
-                errors.push({
-                    id: doc.id,
-                    isPublic,
-                    message: error instanceof Error ? error.message : 'Unknown 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
+            await Promise.all(deletable.map(async (entry)=>{
+                try {
+                    results[entry.index] = await runAfterDeleteWork(entry.doc);
+                } catch (error) {
+                    pushError(entry.doc.id, error);
+                }
+            }));
+            return results;
+        };
         let awaitedDocs;
         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 doc of docs){
+                awaitedDocs.push(await deleteDocumentIndividually(doc));
             }
         } else {
-            awaitedDocs = await Promise.all(promises);
+            awaitedDocs = await deleteDocumentsInBulk();
         }
         // /////////////////////////////////////
         // Delete Preferences
         // /////////////////////////////////////
-        await deleteUserPreferences({
-            collectionConfig,
-            ids: docs.map(({ id })=>id),
-            payload,
-            req
-        });
+        if (!didBatchDeleteFail) {
+            await deleteUserPreferences({
+                collectionConfig,
+                ids: docs.map(({ id })=>id),
+                payload,
+                req
+            });
+        }
         let result = {
-            docs: awaitedDocs.filter(Boolean),
+            docs: awaitedDocs.filter((doc)=>Boolean(doc)),
             errors
         };
         // /////////////////////////////////////
@@ -271,13 +424,31 @@ export const deleteOperation = async (incomingArgs)=>{
             overrideAccess,
             result
         });
-        if (shouldCommit) {
+        if (shouldCommit && !didBatchDeleteFail) {
             await commitTransaction(req);
         }
+        if (hasFileOperationScope) {
+            await completeFileOperationScope({
+                req
+            });
+        }
         return result;
     } catch (error) {
         await killTransaction(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;
+        }
     }
 };