payload 4.0.0-internal.e7d4ebc → 4.0.0-internal.ea6e8f8

package/dist/collections/operations/updateByID.js

@@ -1,25 +1,187 @@
-import { status as httpStatus } from 'http-status';
 import { executeAccess } from '../../auth/executeAccess.js';
 import { hasWhereAccessResult } from '../../auth/types.js';
+import { retryConcurrentShadowOperation } from '../../branching/createShadowRow.js';
+import { forkDocument } from '../../branching/forkDocument.js';
+import { assertBranchMergeValidationWriteAllowed } from '../../branching/mergeWriteGuard.js';
+import { refreshRequestDataLoader, resetBranchState, resolveBranch } from '../../branching/resolveBranch.js';
+import { branchField, MAIN_BRANCH } from '../../branching/types.js';
 import { combineQueries } from '../../database/combineQueries.js';
 import { APIError, Forbidden, NotFound } from '../../errors/index.js';
 import { deepCopyObjectSimple } from '../../index.js';
+import { runCloudFileUpdate } from '../../uploads/fileVersioning/cloudStorage.js';
+import { abortFileOperationScope, beginFileOperationScope, completeFileOperationScope } from '../../uploads/fileVersioning/fileOperationManager.js';
+import { withLegacyCloudUploadFileData } from '../../uploads/fileVersioning/storedFiles.js';
 import { generateFileData } from '../../uploads/generateFileData.js';
+import { getLocalizedUploadProperties, getUploadDestination, mergeUploadDataWithDocument, sanitizeUploadData } from '../../uploads/sanitizeUploadData.js';
 import { unlinkTempFiles } from '../../uploads/unlinkTempFiles.js';
+import { cleanupUploadFileRollbacks, rollbackUploadFiles } from '../../uploads/uploadFileRollback.js';
 import { appendNonTrashedFilter } from '../../utilities/appendNonTrashedFilter.js';
-import { commitTransaction } from '../../utilities/commitTransaction.js';
+import { assertNoValidationWrite } from '../../utilities/assertNoValidationWrite.js';
+import { commitTransaction, shouldRollbackTransactionArtifacts } from '../../utilities/commitTransaction.js';
+import { hasLocalizeStatusEnabled } from '../../utilities/getVersionsConfig.js';
+import { httpStatus } from '../../utilities/httpStatus.js';
 import { initTransaction } from '../../utilities/initTransaction.js';
 import { killTransaction } from '../../utilities/killTransaction.js';
 import { resolveSelect } from '../../utilities/resolveSelect.js';
 import { sanitizeSelect } from '../../utilities/sanitizeSelect.js';
+import { beginDeferredCleanupScope, clearDeferredCleanupScope, flushDeferredCleanupScopeAfterOperation, hasActiveDeferredCleanupScope } from '../../utilities/transactionCallbacks.js';
+import { getAllLocalesPublicationStatus, normalizeAllLocalesPublicationStatus, reconcileAllLocalesPublicationStatus, validateAllLocalesPublicationFlags } from '../../versions/allLocalesPublicationStatus.js';
 import { getLatestCollectionVersion } from '../../versions/getLatestCollectionVersion.js';
 import { buildAfterOperation } from './utilities/buildAfterOperation.js';
 import { buildBeforeOperation } from './utilities/buildBeforeOperation.js';
+import { commitOperationRetryRequestContext, createOperationRetryRequest, shouldRetryOperationRequest } from './utilities/createOperationRetryRequest.js';
 import { updateDocument } from './utilities/update.js';
-export const updateByIDOperation = async (incomingArgs)=>{
+export const branchMergeUploadDataContextKey = Symbol('branchMergeUploadData');
+export const updateByIDOperation = (incomingArgs)=>updateByIDOperationWithLifecycle({
+        incomingArgs,
+        lifecycleOperation: 'update'
+    });
+/**
+ * Promotes a branch-created row while applying create access and lifecycle hooks.
+ * This module is not a package export; external callers use `updateByIDOperation`.
+ *
+ * @internal
+ */ export const updateByIDOperationForBranchMerge = (incomingArgs)=>updateByIDOperationWithLifecycle({
+        incomingArgs,
+        lifecycleOperation: 'create',
+        trustedUploadData: incomingArgs.data
+    });
+const updateByIDOperationWithLifecycle = async ({ incomingArgs, lifecycleOperation, trustedUploadData })=>{
+    assertNoValidationWrite(incomingArgs.req);
+    const reqContext = incomingArgs.req.context;
+    const pendingBranchMergeUploadData = reqContext?.[branchMergeUploadDataContextKey];
+    let branchMergeUploadDataToTrust = trustedUploadData === undefined ? undefined : {
+        id: incomingArgs.id,
+        collectionSlug: incomingArgs.collection.config.slug,
+        data: trustedUploadData
+    };
+    if (pendingBranchMergeUploadData?.collectionSlug === incomingArgs.collection.config.slug && pendingBranchMergeUploadData.id === incomingArgs.id) {
+        branchMergeUploadDataToTrust ??= pendingBranchMergeUploadData;
+        delete reqContext[branchMergeUploadDataContextKey];
+    }
+    const hasCallerTransaction = Boolean(await incomingArgs.req.transactionID);
+    const pristineData = deepCopyObjectSimple(incomingArgs.data);
+    const shouldIsolateTempFile = Boolean(!hasCallerTransaction && incomingArgs.req.file?.tempFilePath && (incomingArgs.req.payload.config.upload?.useTempFiles || incomingArgs.req.file.uploadReference || incomingArgs.req.context?._payloadClientUploadTempFile));
+    let didOwnAttemptTransaction = false;
+    let didReachFinalCommit = false;
+    let isRetrySafe = false;
+    try {
+        return await retryConcurrentShadowOperation({
+            operation: async ()=>{
+                didOwnAttemptTransaction = false;
+                didReachFinalCommit = false;
+                isRetrySafe = false;
+                const shouldReuseParentRequest = incomingArgs.disableTransaction && hasActiveDeferredCleanupScope({
+                    req: incomingArgs.req
+                });
+                const retryRequest = hasCallerTransaction || shouldReuseParentRequest ? undefined : await createOperationRetryRequest({
+                    copyFileTempPath: shouldIsolateTempFile,
+                    req: incomingArgs.req
+                });
+                isRetrySafe = retryRequest?.isRetrySafe ?? false;
+                const attemptArgs = retryRequest ? {
+                    ...incomingArgs,
+                    data: deepCopyObjectSimple(pristineData),
+                    req: retryRequest.req
+                } : incomingArgs;
+                const result = await updateByIDOperationWithLifecycleAttempt({
+                    branchMergeUploadDataToTrust,
+                    hasCallerTransaction,
+                    incomingArgs: attemptArgs,
+                    lifecycleOperation,
+                    reportFinalCommit: ()=>{
+                        didReachFinalCommit = true;
+                    },
+                    reportTransactionOwnership: ({ isOperationTransaction })=>{
+                        didOwnAttemptTransaction = isOperationTransaction;
+                    }
+                });
+                if (retryRequest?.isRetrySafe) {
+                    commitOperationRetryRequestContext({
+                        req: attemptArgs.req
+                    });
+                }
+                return result;
+            },
+            shouldRetry: ({ error })=>shouldRetryOperationRequest({
+                    didOwnAttemptTransaction,
+                    didReachFinalCommit,
+                    error,
+                    hasCallerTransaction,
+                    isRetrySafe
+                })
+        });
+    } finally{
+        if (shouldIsolateTempFile) {
+            await unlinkTempFiles({
+                collectionConfig: incomingArgs.collection.config,
+                config: incomingArgs.req.payload.config,
+                req: incomingArgs.req
+            }).catch((unlinkError)=>{
+                incomingArgs.req.payload.logger.error({
+                    err: unlinkError,
+                    msg: 'Failed to remove temp file'
+                });
+            });
+        }
+    }
+};
+const updateByIDOperationWithLifecycleAttempt = async ({ branchMergeUploadDataToTrust, hasCallerTransaction, incomingArgs, lifecycleOperation, reportFinalCommit, reportTransactionOwnership })=>{
     let args = incomingArgs;
+    let cleanupScope = null;
+    let didResolveBranchFork = false;
+    let shouldCommit = false;
+    const uploadFileRollbacks = new Map();
+    const hasFileOperationScope = Boolean(args.collection.config.upload);
+    assertBranchMergeValidationWriteAllowed({
+        req: args.req
+    });
+    if (hasFileOperationScope) {
+        beginFileOperationScope({
+            req: args.req
+        });
+    }
     try {
-        const shouldCommit = !args.disableTransaction && await initTransaction(args.req);
+        shouldCommit = !args.disableTransaction && await initTransaction(args.req);
+        reportTransactionOwnership({
+            isOperationTransaction: shouldCommit
+        });
+        cleanupScope = await beginDeferredCleanupScope({
+            req: args.req
+        });
+        if (args.collection.config.upload && !args.overrideAccess) {
+            const { objectKey, prefix } = getUploadDestination({
+                data: args.data,
+                file: args.req.file
+            });
+            const data = sanitizeUploadData(args.data, 'update');
+            args = {
+                ...args,
+                data: typeof data === 'object' && data !== null ? {
+                    ...data,
+                    ...prefix !== undefined ? {
+                        prefix
+                    } : {},
+                    ...objectKey !== undefined ? {
+                        _objectKey: objectKey
+                    } : {}
+                } : data
+            };
+        }
+        validateAllLocalesPublicationFlags({
+            publishAllLocales: args.publishAllLocales,
+            unpublishAllLocales: args.unpublishAllLocales
+        });
+        const initialCollectionConfig = args.collection.config;
+        const initialAllLocalesPublicationStatus = getAllLocalesPublicationStatus({
+            hasLocalizedStatus: Boolean(args.req.payload.config.localization && hasLocalizeStatusEnabled(initialCollectionConfig)),
+            publishAllLocales: !args.draft && (args.publishAllLocales ?? (hasLocalizeStatusEnabled(initialCollectionConfig) && args.req.locale !== 'all' ? false : true)),
+            unpublishAllLocales: Boolean(args.unpublishAllLocales)
+        });
+        const initialAllLocalesPublicationIntent = normalizeAllLocalesPublicationStatus({
+            data: args.data,
+            status: initialAllLocalesPublicationStatus
+        });
         // /////////////////////////////////////
         // beforeOperation - Collection
         // /////////////////////////////////////
@@ -29,65 +191,81 @@ export const updateByIDOperation = async (incomingArgs)=>{
             operation: 'update',
             overrideAccess: args.overrideAccess
         });
-        const { id, autosave = false, collection: { config: collectionConfig }, collection, depth, draft: draftArg = false, overrideAccess, overrideLock, overwriteExistingFiles = false, populate, publishAllLocales, req: { fallbackLocale, locale, payload: { config }, payload }, req, select: incomingSelect, showHiddenFields, trash = false, unpublishAllLocales } = args;
+        const { id, autosave = false, branchMergeStorageReq, collection: { config: collectionConfig }, collection, depth, draft: draftArg = false, overrideAccess, overrideLock, overwriteExistingFiles = false, populate, publishAllLocales: publishAllLocalesArg, req: { fallbackLocale, locale, payload: { config }, payload }, req, select: incomingSelect, showHiddenFields, trash = false, unpublishAllLocales: unpublishAllLocalesArg } = args;
         if (!id) {
             throw new APIError('Missing ID of document to update.', httpStatus.BAD_REQUEST);
         }
-        const { data } = args;
-        // /////////////////////////////////////
-        // Access
-        // /////////////////////////////////////
-        const accessResults = !overrideAccess ? await executeAccess({
-            id,
+        let { data } = args;
+        validateAllLocalesPublicationFlags({
+            publishAllLocales: publishAllLocalesArg,
+            unpublishAllLocales: unpublishAllLocalesArg
+        });
+        const requestedAllLocalesPublicationStatus = getAllLocalesPublicationStatus({
+            hasLocalizedStatus: Boolean(config.localization && hasLocalizeStatusEnabled(collectionConfig)),
+            publishAllLocales: !draftArg && (publishAllLocalesArg ?? !(hasLocalizeStatusEnabled(collectionConfig) && locale !== 'all')),
+            unpublishAllLocales: Boolean(unpublishAllLocalesArg)
+        });
+        const allLocalesPublicationStatus = reconcileAllLocalesPublicationStatus({
             data,
-            req
-        }, collectionConfig.access.update) : true;
-        const hasWherePolicy = hasWhereAccessResult(accessResults);
-        // /////////////////////////////////////
-        // Retrieve document
-        // /////////////////////////////////////
-        const where = {
-            id: {
-                equals: id
-            }
-        };
-        let fullWhere = combineQueries(where, accessResults);
-        const isTrashAttempt = collectionConfig.trash && typeof data === 'object' && data !== null && 'deletedAt' in data && data.deletedAt != null;
-        if (isTrashAttempt && !overrideAccess) {
-            // Pass data so access function can check data.deletedAt to know it's a trash attempt
-            const deleteAccessResult = await executeAccess({
-                data,
-                req
-            }, collectionConfig.access.delete);
-            fullWhere = combineQueries(fullWhere, deleteAccessResult);
-        }
-        // Exclude trashed documents when trash: false
-        fullWhere = appendNonTrashedFilter({
-            enableTrash: collectionConfig.trash,
-            trash,
-            where: fullWhere
+            intent: initialAllLocalesPublicationIntent,
+            status: requestedAllLocalesPublicationStatus
         });
-        const findOneArgs = {
-            collection: collectionConfig.slug,
+        const publicationIntentSurvivedBeforeOperation = !requestedAllLocalesPublicationStatus || Boolean(allLocalesPublicationStatus);
+        const publishAllLocales = publicationIntentSurvivedBeforeOperation ? publishAllLocalesArg : false;
+        const unpublishAllLocales = publicationIntentSurvivedBeforeOperation ? unpublishAllLocalesArg : false;
+        const authorizedDocument = await readAuthorizedUpdateDocument({
+            id,
+            collectionConfig,
+            data,
+            lifecycleOperation,
             locale: locale,
+            overrideAccess: overrideAccess,
             req,
-            where: fullWhere
-        };
-        const docWithLocales = await getLatestCollectionVersion({
-            id,
-            config: collectionConfig,
-            payload,
-            query: findOneArgs,
-            req
+            storageReq: branchMergeStorageReq,
+            trash
         });
-        if (!docWithLocales && !hasWherePolicy) {
-            throw new NotFound(req.t);
+        let { docWithLocales } = authorizedDocument;
+        const branch = resolveBranch(req);
+        const isBranchingDocument = branch !== MAIN_BRANCH && req.payload.config.branching?.branchableCollections.has(collectionConfig.slug);
+        if (isBranchingDocument) {
+            const isExistingBranchDocument = docWithLocales[branchField] === branch;
+            if (hasCallerTransaction && !isExistingBranchDocument) {
+                throw new APIError('Cannot update an untouched branch document within an existing transaction.', httpStatus.CONFLICT);
+            }
+            await forkDocument({
+                id,
+                collectionSlug: collectionConfig.slug,
+                req,
+                // Without an operation-owned transaction, retain the isolated race-recovery path. An
+                // adapter with transactions disabled or unavailable cannot roll back a later hook failure.
+                useAmbientTransaction: shouldCommit
+            });
+            didResolveBranchFork = true;
+            if (!isExistingBranchDocument) {
+                docWithLocales = await readUpdateDocument({
+                    id,
+                    collectionConfig,
+                    hasWherePolicy: authorizedDocument.hasWherePolicy,
+                    locale: locale,
+                    req,
+                    where: authorizedDocument.where
+                });
+            }
         }
-        if (!docWithLocales && hasWherePolicy) {
-            throw new Forbidden(req.t);
+        const storedDocWithLocales = docWithLocales;
+        if (collectionConfig.upload.fileOperations) {
+            docWithLocales = await withLegacyCloudUploadFileData({
+                collection: collectionConfig,
+                doc: docWithLocales,
+                req
+            });
         }
-        if (!docWithLocales) {
-            throw new NotFound(req.t);
+        if (collectionConfig.upload && !overrideAccess) {
+            const trustedUploadDataForDocument = branchMergeUploadDataToTrust?.collectionSlug === collectionConfig.slug && branchMergeUploadDataToTrust.id === id ? branchMergeUploadDataToTrust.data : docWithLocales;
+            data = mergeUploadDataWithDocument(data, trustedUploadDataForDocument, {
+                locale: locale === 'all' || !locale ? config.localization ? config.localization.defaultLocale : undefined : locale,
+                localizedProperties: getLocalizedUploadProperties(collectionConfig.flattenedFields)
+            });
         }
         // /////////////////////////////////////
         // Generate data for all files and sizes
@@ -97,6 +275,7 @@ export const updateByIDOperation = async (incomingArgs)=>{
             config,
             data,
             operation: 'update',
+            originalDoc: docWithLocales,
             overwriteExistingFiles,
             req,
             throwOnMissingFile: false
@@ -113,18 +292,20 @@ export const updateByIDOperation = async (incomingArgs)=>{
         // ///////////////////////////////////////////////
         // Update document, runs all document level hooks
         // ///////////////////////////////////////////////
-        let result = await updateDocument({
+        const updateArgs = {
             id,
             autosave,
             collectionConfig,
             config,
             data: deepCopyObjectSimple(newFileData),
+            databaseReq: branchMergeStorageReq,
             depth: depth,
             docWithLocales,
             draftArg,
             fallbackLocale: fallbackLocale,
             filesToUpload,
             locale: locale,
+            operation: lifecycleOperation,
             overrideAccess: overrideAccess,
             overrideLock: overrideLock,
             payload,
@@ -132,9 +313,21 @@ export const updateByIDOperation = async (incomingArgs)=>{
             publishAllLocales,
             req,
             select: select,
+            shouldManageLocalFiles: true,
             showHiddenFields: showHiddenFields,
-            unpublishAllLocales
-        });
+            unpublishAllLocales,
+            uploadFileRollbacks: shouldCommit && collectionConfig.upload && !collectionConfig.upload.disableLocalStorage ? uploadFileRollbacks : undefined
+        };
+        const write = ()=>updateDocument(updateArgs);
+        let result = collectionConfig.upload.fileOperations ? await runCloudFileUpdate({
+            id,
+            collection: collectionConfig,
+            current: storedDocWithLocales,
+            data: updateArgs.data,
+            files: filesToUpload,
+            req,
+            write
+        }) : await write();
         // /////////////////////////////////////
         // Add collection property for auth collections
         // /////////////////////////////////////
@@ -148,6 +341,11 @@ export const updateByIDOperation = async (incomingArgs)=>{
             collectionConfig,
             config,
             req
+        }).catch((unlinkError)=>{
+            req.payload.logger.error({
+                err: unlinkError,
+                msg: 'Failed to remove temp file'
+            });
         });
         // /////////////////////////////////////
         // afterOperation - Collection
@@ -162,14 +360,139 @@ export const updateByIDOperation = async (incomingArgs)=>{
         // /////////////////////////////////////
         // Return results
         // /////////////////////////////////////
+        if (cleanupScope) {
+            await flushDeferredCleanupScopeAfterOperation({
+                req,
+                scope: cleanupScope
+            });
+        }
         if (shouldCommit) {
+            reportFinalCommit();
             await commitTransaction(req);
+            await cleanupUploadFileRollbacks({
+                rollbacks: uploadFileRollbacks
+            }).catch((error)=>{
+                args.req.payload.logger.error({
+                    err: error,
+                    msg: 'Failed to remove an upload rollback backup after committing its database write.'
+                });
+            });
+        }
+        if (isBranchingDocument) {
+            refreshRequestDataLoader(req);
+        }
+        if (hasFileOperationScope) {
+            await completeFileOperationScope({
+                req
+            });
         }
         return result;
     } catch (error) {
-        await killTransaction(args.req);
+        const shouldRollbackArtifacts = shouldRollbackTransactionArtifacts({
+            error
+        });
+        if (cleanupScope) {
+            clearDeferredCleanupScope({
+                req: args.req,
+                scope: cleanupScope
+            });
+        }
+        await unlinkTempFiles({
+            collectionConfig: args.collection.config,
+            config: args.req.payload.config,
+            req: args.req
+        }).catch((unlinkError)=>{
+            args.req.payload.logger.error({
+                err: unlinkError,
+                msg: 'Failed to remove temp file'
+            });
+        });
+        if (shouldCommit) {
+            await killTransaction(args.req);
+            if (didResolveBranchFork) {
+                resetBranchState(args.req);
+            }
+            if (shouldRollbackArtifacts) {
+                await rollbackUploadFiles({
+                    rollbacks: uploadFileRollbacks
+                });
+            }
+        }
+        if (hasFileOperationScope) {
+            await abortFileOperationScope({
+                req: args.req
+            });
+        }
         throw error;
     }
 };
+const readAuthorizedUpdateDocument = async ({ id, collectionConfig, data, lifecycleOperation, locale, overrideAccess, req, storageReq, trash })=>{
+    if (!id) {
+        throw new APIError('Missing ID of document to update.', httpStatus.BAD_REQUEST);
+    }
+    const accessResults = !overrideAccess ? await executeAccess({
+        id: lifecycleOperation === 'create' ? undefined : id,
+        slug: collectionConfig.slug,
+        data,
+        req
+    }, collectionConfig.access[lifecycleOperation]) : true;
+    const hasWherePolicy = lifecycleOperation !== 'create' && hasWhereAccessResult(accessResults);
+    const where = {
+        id: {
+            equals: id
+        }
+    };
+    let fullWhere = hasWherePolicy ? combineQueries(where, accessResults) : where;
+    const isTrashAttempt = collectionConfig.trash && typeof data === 'object' && data !== null && 'deletedAt' in data && data.deletedAt != null;
+    if (isTrashAttempt && !overrideAccess) {
+        const deleteAccessResult = await executeAccess({
+            id,
+            slug: collectionConfig.slug,
+            data,
+            req
+        }, collectionConfig.access.delete);
+        fullWhere = combineQueries(fullWhere, deleteAccessResult);
+    }
+    fullWhere = appendNonTrashedFilter({
+        enableTrash: collectionConfig.trash,
+        trash,
+        where: fullWhere
+    });
+    const docWithLocales = await readUpdateDocument({
+        id,
+        collectionConfig,
+        hasWherePolicy,
+        locale,
+        req: storageReq ?? req,
+        where: fullWhere
+    });
+    return {
+        docWithLocales,
+        hasWherePolicy,
+        where: fullWhere
+    };
+};
+const readUpdateDocument = async ({ id, collectionConfig, hasWherePolicy, locale, req, where })=>{
+    const findOneArgs = {
+        collection: collectionConfig.slug,
+        locale,
+        req,
+        where
+    };
+    const docWithLocales = await getLatestCollectionVersion({
+        id,
+        config: collectionConfig,
+        payload: req.payload,
+        query: findOneArgs,
+        req
+    });
+    if (!docWithLocales) {
+        if (hasWherePolicy) {
+            throw new Forbidden(req.t);
+        }
+        throw new NotFound(req.t);
+    }
+    return docWithLocales;
+};
 
 //# sourceMappingURL=updateByID.js.map