klz-cables.com/.pnpm-store/v10/files/49/bfa9d93f9310a05cd674e6645730f645c238910b291c04c20e2d3b65366fd59aa4fa0d54ee32d881157aced708971f7241be54c5ec1289b47cd9da26303631

import { executeAccess } from '../../auth/executeAccess.js';
import { hasWhereAccessResult } from '../../auth/types.js';
import { combineQueries } from '../../database/combineQueries.js';
import { Forbidden, NotFound } 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 { appendNonTrashedFilter } from '../../utilities/appendNonTrashedFilter.js';
import { checkDocumentLockStatus } from '../../utilities/checkDocumentLockStatus.js';
import { commitTransaction } from '../../utilities/commitTransaction.js';
import { hasScheduledPublishEnabled } from '../../utilities/getVersionsConfig.js';
import { initTransaction } from '../../utilities/initTransaction.js';
import { killTransaction } from '../../utilities/killTransaction.js';
import { sanitizeSelect } from '../../utilities/sanitizeSelect.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 deleteByIDOperation = async (incomingArgs)=>{
    let args = incomingArgs;
    try {
        const shouldCommit = !args.disableTransaction && await initTransaction(args.req);
        // /////////////////////////////////////
        // beforeOperation - Collection
        // /////////////////////////////////////
        args = await buildBeforeOperation({
            args,
            collection: args.collection.config,
            operation: 'delete',
            overrideAccess: args.overrideAccess
        });
        const { id, collection: { config: collectionConfig }, depth, overrideAccess, overrideLock, populate, req: { fallbackLocale, locale, payload: { config }, payload }, req, select: incomingSelect, showHiddenFields, trash = false } = args;
        // /////////////////////////////////////
        // Access
        // /////////////////////////////////////
        const accessResults = !overrideAccess ? await executeAccess({
            id,
            req
        }, collectionConfig.access.delete) : true;
        const hasWhereAccess = hasWhereAccessResult(accessResults);
        // /////////////////////////////////////
        // beforeDelete - Collection
        // /////////////////////////////////////
        if (collectionConfig.hooks?.beforeDelete?.length) {
            for (const hook of collectionConfig.hooks.beforeDelete){
                await hook({
                    id,
                    collection: collectionConfig,
                    context: req.context,
                    req
                });
            }
        }
        // /////////////////////////////////////
        // Retrieve document
        // /////////////////////////////////////
        let where = combineQueries({
            id: {
                equals: id
            }
        }, accessResults);
        // Exclude trashed documents when trash: false
        where = appendNonTrashedFilter({
            enableTrash: collectionConfig.trash,
            trash,
            where
        });
        const docToDelete = await req.payload.db.findOne({
            collection: collectionConfig.slug,
            locale: req.locale,
            req,
            where
        });
        if (!docToDelete && !hasWhereAccess) {
            throw new NotFound(req.t);
        }
        if (!docToDelete && hasWhereAccess) {
            throw new Forbidden(req.t);
        }
        // /////////////////////////////////////
        // Handle potentially locked documents
        // /////////////////////////////////////
        await checkDocumentLockStatus({
            id,
            collectionSlug: collectionConfig.slug,
            lockErrorMessage: `Document with ID ${id} is currently locked and cannot be deleted.`,
            overrideLock,
            req
        });
        await deleteAssociatedFiles({
            collectionConfig,
            config,
            doc: docToDelete,
            overrideDelete: true,
            req
        });
        // /////////////////////////////////////
        // Delete versions
        // /////////////////////////////////////
        if (collectionConfig.versions) {
            await deleteCollectionVersions({
                id,
                slug: collectionConfig.slug,
                payload,
                req
            });
        }
        // /////////////////////////////////////
        // Delete scheduled posts
        // /////////////////////////////////////
        if (hasScheduledPublishEnabled(collectionConfig)) {
            await deleteScheduledPublishJobs({
                id,
                slug: collectionConfig.slug,
                payload,
                req
            });
        }
        const select = sanitizeSelect({
            fields: collectionConfig.flattenedFields,
            forceSelect: collectionConfig.forceSelect,
            select: incomingSelect
        });
        // /////////////////////////////////////
        // Delete document
        // /////////////////////////////////////
        let result = await req.payload.db.deleteOne({
            collection: collectionConfig.slug,
            req,
            select,
            where: {
                id: {
                    equals: id
                }
            }
        });
        // /////////////////////////////////////
        // Add collection property for auth collections
        // /////////////////////////////////////
        if (collectionConfig.auth) {
            result = {
                ...result,
                collection: collectionConfig.slug
            };
        }
        // /////////////////////////////////////
        // Delete Preferences
        // /////////////////////////////////////
        await deleteUserPreferences({
            collectionConfig,
            ids: [
                id
            ],
            payload,
            req
        });
        // /////////////////////////////////////
        // afterRead - Fields
        // /////////////////////////////////////
        result = await afterRead({
            collection: collectionConfig,
            context: req.context,
            depth: depth,
            doc: result,
            draft: undefined,
            fallbackLocale: fallbackLocale,
            global: null,
            locale: locale,
            overrideAccess: overrideAccess,
            populate,
            req,
            select,
            showHiddenFields: showHiddenFields
        });
        // /////////////////////////////////////
        // afterRead - Collection
        // /////////////////////////////////////
        if (collectionConfig.hooks?.afterRead?.length) {
            for (const hook of collectionConfig.hooks.afterRead){
                result = await hook({
                    collection: collectionConfig,
                    context: req.context,
                    doc: result,
                    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;
            }
        }
        // /////////////////////////////////////
        // afterOperation - Collection
        // /////////////////////////////////////
        result = await buildAfterOperation({
            args,
            collection: collectionConfig,
            operation: 'deleteByID',
            overrideAccess,
            result
        });
        // /////////////////////////////////////
        // 8. Return results
        // /////////////////////////////////////
        if (shouldCommit) {
            await commitTransaction(req);
        }
        return result;
    } catch (error) {
        await killTransaction(args.req);
        throw error;
    }
};

//# sourceMappingURL=deleteByID.js.map