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

package/dist/globals/operations/update.js

@@ -1,50 +1,122 @@
+import { isDeepStrictEqual } from 'node:util';
 import { executeAccess } from '../../auth/executeAccess.js';
+import { hasWhereAccessResult } from '../../auth/types.js';
+import { assertBranchReadable } from '../../branching/assertBranchReadable.js';
+import { recordBranchGlobalChange, resolveBranchGlobalWrite } from '../../branching/globals.js';
+import { assertBranchMergeValidationWriteAllowed, runBranchMergeWriteGuard } from '../../branching/mergeWriteGuard.js';
+import { branchField, MAIN_BRANCH } from '../../branching/types.js';
+import { combineQueries } from '../../database/combineQueries.js';
+import { Forbidden, ValidationError } from '../../errors/index.js';
 import { afterChange } from '../../fields/hooks/afterChange/index.js';
 import { afterRead } from '../../fields/hooks/afterRead/index.js';
 import { beforeChange } from '../../fields/hooks/beforeChange/index.js';
 import { beforeValidate } from '../../fields/hooks/beforeValidate/index.js';
 import { deepCopyObjectSimple } from '../../index.js';
+import { assertNoValidationWrite } from '../../utilities/assertNoValidationWrite.js';
 import { checkDocumentLockStatus } from '../../utilities/checkDocumentLockStatus.js';
 import { commitTransaction } from '../../utilities/commitTransaction.js';
 import { getSelectMode } from '../../utilities/getSelectMode.js';
+import { getTopLevelFieldNames } from '../../utilities/getTopLevelFieldNames.js';
 import { hasDraftsEnabled, hasDraftValidationEnabled, hasLocalizeStatusEnabled } from '../../utilities/getVersionsConfig.js';
 import { initTransaction } from '../../utilities/initTransaction.js';
 import { killTransaction } from '../../utilities/killTransaction.js';
+import { resolvePublishAllLocales } from '../../utilities/resolvePublishAllLocales.js';
 import { resolveSelect } from '../../utilities/resolveSelect.js';
 import { sanitizeSelect } from '../../utilities/sanitizeSelect.js';
+import { markTransactionWrite } from '../../utilities/transactionMutationTracker.js';
+import { buildAllLocalesPublicationHookDoc, getAllLocalesPublicationStatus, hasAuthorizedAllLocalesPublicationStatus, normalizeAllLocalesPublicationStatus, reconcileAllLocalesPublicationStatus, validateAllLocalesPublicationFlags } from '../../versions/allLocalesPublicationStatus.js';
 import { buildLocalizedPublishData } from '../../versions/buildSingleLocalePublishData.js';
 import { getLatestGlobalVersion } from '../../versions/getLatestGlobalVersion.js';
 import { saveVersion } from '../../versions/saveVersion.js';
+import { validateGlobalLocalWithLocaleKeyedData } from './local/validate.js';
 export const updateOperation = async (args)=>{
-    const { slug, autosave, depth, disableTransaction, draft: draftArg, globalConfig, overrideAccess, overrideLock, populate, publishAllLocales: publishAllLocalesArg, req: { fallbackLocale, locale, payload, payload: { config } = {} }, req, select: incomingSelect, showHiddenFields, unpublishAllLocales: unpublishAllLocalesArg } = args;
+    assertNoValidationWrite(args.req);
+    const req = args.req;
+    const initialGlobalConfig = args.globalConfig;
+    assertBranchMergeValidationWriteAllowed({
+        req
+    });
+    if (!args.overrideAccess) {
+        await assertBranchReadable({
+            globalSlug: initialGlobalConfig.slug,
+            req
+        });
+    }
+    validateAllLocalesPublicationFlags({
+        publishAllLocales: args.publishAllLocales,
+        unpublishAllLocales: args.unpublishAllLocales
+    });
+    const initialPublishAllLocales = resolvePublishAllLocales({
+        draft: args.draft,
+        hasLocalizeStatusEnabled: hasLocalizeStatusEnabled(initialGlobalConfig),
+        locale: req.locale,
+        publishAllLocalesArg: args.publishAllLocales
+    });
+    const initialAllLocalesPublicationStatus = getAllLocalesPublicationStatus({
+        hasLocalizedStatus: Boolean(req.payload.config.localization && hasLocalizeStatusEnabled(initialGlobalConfig)),
+        publishAllLocales: initialPublishAllLocales,
+        unpublishAllLocales: Boolean(args.unpublishAllLocales)
+    });
+    const initialAllLocalesPublicationIntent = normalizeAllLocalesPublicationStatus({
+        data: args.data,
+        status: initialAllLocalesPublicationStatus
+    });
+    let shouldCommit = false;
     try {
-        const shouldCommit = !disableTransaction && await initTransaction(req);
+        shouldCommit = !args.disableTransaction && await initTransaction(req);
         // /////////////////////////////////////
         // beforeOperation - Global
         // /////////////////////////////////////
-        if (globalConfig.hooks?.beforeOperation?.length) {
-            for (const hook of globalConfig.hooks.beforeOperation){
+        if (initialGlobalConfig.hooks?.beforeOperation?.length) {
+            for (const hook of initialGlobalConfig.hooks.beforeOperation){
                 args = await hook({
                     args,
                     context: args.req.context,
-                    global: globalConfig,
+                    global: initialGlobalConfig,
                     operation: 'update',
-                    overrideAccess,
+                    overrideAccess: args.overrideAccess,
                     req: args.req
                 }) || args;
             }
         }
+        const { slug, autosave, depth, draft: draftArg, globalConfig, overrideAccess, overrideLock, populate, publishAllLocales: publishAllLocalesArg, req: { fallbackLocale, locale, payload, payload: { config } = {} }, select: incomingSelect, showHiddenFields, unpublishAllLocales: unpublishAllLocalesArg } = args;
         let { data } = args;
-        const publishAllLocales = !draftArg && (publishAllLocalesArg ?? (hasLocalizeStatusEnabled(globalConfig) && locale !== 'all' ? false : true));
-        const unpublishAllLocales = typeof unpublishAllLocalesArg === 'string' ? unpublishAllLocalesArg === 'true' : !!unpublishAllLocalesArg;
+        validateAllLocalesPublicationFlags({
+            publishAllLocales: publishAllLocalesArg,
+            unpublishAllLocales: unpublishAllLocalesArg
+        });
+        let publishAllLocales = resolvePublishAllLocales({
+            draft: draftArg,
+            hasLocalizeStatusEnabled: hasLocalizeStatusEnabled(globalConfig),
+            locale,
+            publishAllLocalesArg
+        });
+        let unpublishAllLocales = typeof unpublishAllLocalesArg === 'string' ? unpublishAllLocalesArg === 'true' : !!unpublishAllLocalesArg;
+        const requestedAllLocalesPublicationStatus = getAllLocalesPublicationStatus({
+            hasLocalizedStatus: Boolean(config?.localization && hasLocalizeStatusEnabled(globalConfig)),
+            publishAllLocales,
+            unpublishAllLocales
+        });
+        const allLocalesPublicationStatus = reconcileAllLocalesPublicationStatus({
+            data,
+            intent: initialAllLocalesPublicationIntent,
+            status: requestedAllLocalesPublicationStatus
+        });
+        if (requestedAllLocalesPublicationStatus && !allLocalesPublicationStatus) {
+            publishAllLocales = false;
+            unpublishAllLocales = false;
+        }
         const isSavingDraft = Boolean(draftArg && hasDraftsEnabled(globalConfig)) && data._status !== 'published' && !publishAllLocales;
         if (isSavingDraft) {
             data._status = 'draft';
         }
+        const incomingTopLevelFieldNames = getTopLevelFieldNames(data);
+        const submittedTopLevelFieldNames = unpublishAllLocales ? incomingTopLevelFieldNames : undefined;
         // /////////////////////////////////////
         // 1. Retrieve and execute access
         // /////////////////////////////////////
         const accessResults = !overrideAccess ? await executeAccess({
+            slug: globalConfig.slug,
             data,
             req
         }, globalConfig.access.update) : true;
@@ -52,6 +124,15 @@ export const updateOperation = async (args)=>{
         // Retrieve document
         // /////////////////////////////////////
         const query = overrideAccess ? undefined : accessResults;
+        const writeBranch = resolveBranchGlobalWrite({
+            globalSlug: slug,
+            req
+        });
+        const mainStorageQuery = !writeBranch && config?.branching?.branchableGlobals.has(slug) ? {
+            [branchField]: {
+                equals: MAIN_BRANCH
+            }
+        } : undefined;
         // /////////////////////////////////////
         // 2. Retrieve document
         // /////////////////////////////////////
@@ -61,9 +142,25 @@ export const updateOperation = async (args)=>{
             locale: publishAllLocales || unpublishAllLocales ? 'all' : locale,
             payload,
             req,
+            storageWhere: mainStorageQuery,
             where: query
         });
-        const { global, globalExists } = globalVersionResult || {};
+        const { global, globalExists, hasLiveGlobal } = globalVersionResult || {};
+        if (hasWhereAccessResult(accessResults) && globalExists && (!global || Object.keys(global).length === 0)) {
+            throw new Forbidden(req.t);
+        }
+        if (!isSavingDraft && hasDraftsEnabled(globalConfig) && hasLiveGlobal && hasWhereAccessResult(accessResults)) {
+            // Draft access does not authorize overwriting an inaccessible live global.
+            const accessibleLiveGlobal = await payload.db.findGlobal({
+                slug,
+                locale: publishAllLocales || unpublishAllLocales ? 'all' : locale,
+                req,
+                where: mainStorageQuery ? combineQueries(accessResults, mainStorageQuery) : accessResults
+            });
+            if (!accessibleLiveGlobal || Object.keys(accessibleLiveGlobal).length === 0) {
+                throw new Forbidden(req.t);
+            }
+        }
         let globalJSON = {};
         if (globalVersionResult && globalVersionResult.global) {
             globalJSON = deepCopyObjectSimple(global);
@@ -91,21 +188,39 @@ export const updateOperation = async (args)=>{
             globalSlug: slug,
             lockErrorMessage: `Global with slug "${slug}" is currently locked by another user and cannot be updated.`,
             overrideLock,
-            req
+            req,
+            shouldDeleteLock: false
         });
         // /////////////////////////////////////
         // beforeValidate - Fields
         // /////////////////////////////////////
+        let statusFieldAccess = false;
+        const publicationFieldPolicyDoc = buildAllLocalesPublicationHookDoc({
+            doc: originalDoc,
+            docWithLocales: globalJSON,
+            status: data._status === allLocalesPublicationStatus ? allLocalesPublicationStatus : undefined
+        });
         data = await beforeValidate({
             collection: null,
             context: req.context,
             data,
             doc: originalDoc,
+            docForHooks: publicationFieldPolicyDoc,
             global: globalConfig,
+            onFieldAccess: ({ accessResult, path })=>{
+                if (path === '_status') {
+                    statusFieldAccess = accessResult;
+                }
+            },
             operation: 'update',
             overrideAccess: overrideAccess,
             req
         });
+        const publicationHookDoc = buildAllLocalesPublicationHookDoc({
+            doc: originalDoc,
+            docWithLocales: globalJSON,
+            status: statusFieldAccess && data._status === allLocalesPublicationStatus ? allLocalesPublicationStatus : undefined
+        });
         // /////////////////////////////////////
         // beforeValidate - Global
         // /////////////////////////////////////
@@ -115,7 +230,8 @@ export const updateOperation = async (args)=>{
                     context: req.context,
                     data,
                     global: globalConfig,
-                    originalDoc,
+                    operation: 'update',
+                    originalDoc: publicationHookDoc,
                     overrideAccess,
                     req
                 }) || data;
@@ -130,12 +246,16 @@ export const updateOperation = async (args)=>{
                     context: req.context,
                     data,
                     global: globalConfig,
-                    originalDoc,
+                    operation: 'update',
+                    originalDoc: publicationHookDoc,
                     overrideAccess,
                     req
                 }) || data;
             }
         }
+        const publicationData = {
+            ...data
+        };
         // /////////////////////////////////////
         // beforeChange - Fields
         // /////////////////////////////////////
@@ -143,21 +263,46 @@ export const updateOperation = async (args)=>{
             collection: null,
             context: req.context,
             data,
-            doc: originalDoc,
+            doc: publicationHookDoc,
             docWithLocales: globalJSON,
+            fieldsToValidate: submittedTopLevelFieldNames,
             global: globalConfig,
             operation: 'update',
             req,
-            skipValidation: isSavingDraft && !hasDraftValidationEnabled(globalConfig) || // Skip validation for unpublish operations — they only change _status, not document data
-            unpublishAllLocales
+            skipValidation: isSavingDraft && !hasDraftValidationEnabled(globalConfig)
         };
-        let result = await beforeChange(beforeChangeArgs);
+        let statusFieldValue;
+        let result = await beforeChange({
+            ...beforeChangeArgs,
+            onDataProcessed: (processedData)=>{
+                statusFieldValue = processedData._status;
+            }
+        });
+        const hasAuthorizedPublicationStatus = hasAuthorizedAllLocalesPublicationStatus({
+            data: publicationData,
+            fieldAccessDenied: !statusFieldAccess,
+            fieldValue: statusFieldValue,
+            status: allLocalesPublicationStatus
+        });
+        if (allLocalesPublicationStatus && !hasAuthorizedPublicationStatus && typeof statusFieldValue === 'undefined' && typeof globalJSON._status === 'object' && globalJSON._status !== null) {
+            result._status = {
+                ...globalJSON._status
+            };
+        }
         if (config?.localization && hasLocalizeStatusEnabled(globalConfig) && typeof result._status === 'string') {
             const statusStr = result._status;
-            result._status = {};
-            for (const localeCode of config.localization.localeCodes){
-                ;
-                result._status[localeCode] = statusStr;
+            if (hasAuthorizedPublicationStatus && typeof globalJSON._status === 'object' && globalJSON._status !== null) {
+                result._status = {
+                    ...globalJSON._status
+                };
+            } else {
+                result._status = {};
+            }
+            if (!hasAuthorizedPublicationStatus) {
+                for (const localeCode of config.localization.localeCodes){
+                    ;
+                    result._status[localeCode] = statusStr;
+                }
             }
         }
         // /////////////////////////////////////
@@ -166,7 +311,7 @@ export const updateOperation = async (args)=>{
         let localizedPublishData = null;
         if (config && config.localization && globalConfig.versions) {
             if (hasLocalizeStatusEnabled(globalConfig)) {
-                if (publishAllLocales || unpublishAllLocales) {
+                if (hasAuthorizedPublicationStatus) {
                     let accessibleLocaleCodes = config.localization.localeCodes;
                     if (config.localization.filterAvailableLocales) {
                         const filteredLocales = await config.localization.filterAvailableLocales({
@@ -186,7 +331,7 @@ export const updateOperation = async (args)=>{
                         slug: globalConfig.slug,
                         locale: 'all',
                         req,
-                        where: query
+                        where: mainStorageQuery === undefined ? query : combineQueries(query, mainStorageQuery)
                     });
                     localizedPublishData = buildLocalizedPublishData({
                         config,
@@ -198,9 +343,53 @@ export const updateOperation = async (args)=>{
                 }
             }
         }
+        if (config?.localization && hasDraftsEnabled(globalConfig) && publishAllLocales && !unpublishAllLocales && (!hasLocalizeStatusEnabled(globalConfig) || hasAuthorizedPublicationStatus)) {
+            const validationResult = await validateGlobalLocalWithLocaleKeyedData({
+                operation: 'update',
+                options: {
+                    slug: globalConfig.slug,
+                    data: result,
+                    draft: true,
+                    locale: 'all',
+                    overrideAccess,
+                    req
+                },
+                payload,
+                sourceData: {
+                    docWithLocales: globalJSON,
+                    originalDoc: publicationHookDoc,
+                    originalLocale: locale
+                }
+            });
+            if (!validationResult.valid) {
+                throw new ValidationError({
+                    errors: validationResult.errors,
+                    global: globalConfig.slug,
+                    req
+                }, req.t);
+            }
+        }
         const dataToUpdate = {
             ...localizedPublishData ?? result
         };
+        await runBranchMergeWriteGuard({
+            data: dataToUpdate,
+            globalSlug: slug,
+            req
+        });
+        if (localizedPublishData) {
+            await runBranchMergeWriteGuard({
+                data: result,
+                globalSlug: slug,
+                req
+            });
+        }
+        const branchConflictFieldNames = new Set(incomingTopLevelFieldNames);
+        for (const [fieldName, value] of Object.entries(dataToUpdate)){
+            if (!isDeepStrictEqual(value, globalJSON[fieldName])) {
+                branchConflictFieldNames.add(fieldName);
+            }
+        }
         // /////////////////////////////////////
         // Update
         // /////////////////////////////////////
@@ -213,6 +402,12 @@ export const updateOperation = async (args)=>{
                 select: incomingSelect
             })
         });
+        await checkDocumentLockStatus({
+            globalSlug: slug,
+            lockErrorMessage: `Global with slug "${slug}" is currently locked by another user and cannot be updated.`,
+            overrideLock,
+            req
+        });
         let resultWithLocales = result;
         if (!isSavingDraft) {
             const now = new Date().toISOString();
@@ -222,9 +417,17 @@ export const updateOperation = async (args)=>{
             }
             // Ensure updatedAt date is always updated
             dataToUpdate.updatedAt = now;
-            if (globalExists) {
+            const branchConflictData = deepCopyObjectSimple(Object.fromEntries([
+                ...branchConflictFieldNames
+            ].filter((fieldName)=>Object.hasOwn(dataToUpdate, fieldName)).map((fieldName)=>[
+                    fieldName,
+                    dataToUpdate[fieldName]
+                ])));
+            branchConflictData.updatedAt = now;
+            if (hasLiveGlobal || writeBranch) {
                 resultWithLocales = await payload.db.updateGlobal({
                     slug,
+                    branchConflictData,
                     data: dataToUpdate,
                     req,
                     select
@@ -236,6 +439,9 @@ export const updateOperation = async (args)=>{
                     req
                 });
             }
+            markTransactionWrite({
+                req
+            });
             resultWithLocales.updatedAt = now;
             if (localizedPublishData) {
                 // Keep full locale payload for version writes during single-locale publish.
@@ -250,6 +456,9 @@ export const updateOperation = async (args)=>{
         // Create version
         // /////////////////////////////////////
         if (globalConfig.versions) {
+            if (config?.branching?.branchableGlobals.has(slug)) {
+                resultWithLocales[branchField] = writeBranch ?? MAIN_BRANCH;
+            }
             const { globalType } = resultWithLocales;
             resultWithLocales = await saveVersion({
                 autosave,
@@ -262,11 +471,21 @@ export const updateOperation = async (args)=>{
                 select,
                 unpublish: unpublishAllLocales
             });
+            markTransactionWrite({
+                req
+            });
             resultWithLocales = {
                 ...resultWithLocales,
                 globalType
             };
         }
+        if (writeBranch) {
+            await recordBranchGlobalChange({
+                branch: writeBranch,
+                globalSlug: slug,
+                req
+            });
+        }
         // /////////////////////////////////////
         // Execute globalType field if not selected
         // /////////////////////////////////////
@@ -331,6 +550,7 @@ export const updateOperation = async (args)=>{
                     data,
                     doc: result,
                     global: globalConfig,
+                    operation: 'update',
                     overrideAccess,
                     previousDoc: originalDoc,
                     req
@@ -345,7 +565,9 @@ export const updateOperation = async (args)=>{
         }
         return result;
     } catch (error) {
-        await killTransaction(req);
+        if (shouldCommit) {
+            await killTransaction(req);
+        }
         throw error;
     }
 };