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

package/dist/branching/merge/prepareMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepareMerge.d.ts","sourceRoot":"","sources":["../../../src/branching/merge/prepareMerge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAmB,eAAe,EAAgB,MAAM,aAAa,CAAA;AACjF,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAA;AA0BlE,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CACpB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAE3B,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,oBAAoB,EAAE,CAAA;IAClC,iBAAiB,EAAE,oBAAoB,EAAE,CAAA;IACzC,SAAS,EAAE;QAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAA;IAClC,SAAS,EAAE,eAAe,EAAE,CAAA;IAC5B,GAAG,EAAE,cAAc,CAAA;IACnB,MAAM,EAAE,WAAW,CAAA;IACnB,iBAAiB,EAAE,eAAe,EAAE,CAAA;CACrC,CAAA;AAED,eAAO,MAAM,YAAY,8EAQtB;IACD,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;IACf,WAAW,CAAC,EAAE,cAAc,CAAA;IAC5B,cAAc,EAAE,OAAO,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IAC9B,IAAI,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAA;CAC3C,KAAG,OAAO,CAAC,aAAa,CAyJxB,CAAA;AAED,eAAO,MAAM,uBAAuB,6EAOjC;IACD,UAAU,EAAE,oBAAoB,EAAE,CAAA;IAClC,iBAAiB,EAAE,oBAAoB,EAAE,CAAA;IACzC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC;IACV,OAAO,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;IAC/B,OAAO,EAAE,OAAO,CAAA;IAChB,gBAAgB,EAAE,0BAA0B,EAAE,CAAA;CAC/C,CAgDA,CAAA"}

package/dist/branching/merge/prepareMerge.js

@@ -0,0 +1,234 @@
+import { createPayloadRequest } from '../../utilities/createPayloadRequest.js';
+import { assertBranchActionAccess } from '../assertBranchActionAccess.js';
+import { resolveEffectiveOperations } from '../effectiveOperations.js';
+import { runGlobalMergePreflight, runMergeDependencyPreflight, runMergePreflight } from '../preflight.js';
+import { withoutBranch } from '../resolveBranch.js';
+import { selectBranchChanges } from '../selectBranchChanges.js';
+import { branchChangesCollectionSlug, branchesCollectionSlug, branchField, MAIN_BRANCH } from '../types.js';
+import { createBranchMergeValidationRequest, createMainBranchRequest, prepareBranchMergeValidationCandidates } from '../validation.js';
+import { inspectFailedCleanups } from './retryFailedCleanups.js';
+import { changeDocID } from './utilities.js';
+export const prepareMerge = async ({ branch, dryRun, incomingReq, overrideAccess, payload, selected, user })=>{
+    const req = incomingReq ? withoutBranch(incomingReq) : await createPayloadRequest({
+        branch: false,
+        payload,
+        user
+    });
+    if (user && !req.user) {
+        req.user = user;
+    }
+    const branchDocs = await payload.find({
+        collection: branchesCollectionSlug,
+        limit: 1,
+        overrideAccess,
+        pagination: false,
+        req,
+        where: {
+            slug: {
+                equals: branch
+            }
+        }
+    });
+    const branchDoc = branchDocs.docs[0];
+    if (!branchDoc) {
+        throw new Error(`Branch "${branch}" was not found.`);
+    }
+    if (!overrideAccess) {
+        await assertBranchActionAccess({
+            action: 'mergeBranch',
+            branchDoc,
+            req
+        });
+    }
+    const cleanupRetry = dryRun ? {
+        handledChangeIDs: new Set(),
+        retryable: []
+    } : await inspectFailedCleanups({
+        branch,
+        payload,
+        req,
+        selected
+    });
+    const retryableCleanups = cleanupRetry.retryable;
+    const allChanges = await payload.find({
+        collection: branchChangesCollectionSlug,
+        overrideAccess: true,
+        pagination: false,
+        req,
+        sort: 'createdAt',
+        where: {
+            branch: {
+                equals: branch
+            }
+        }
+    });
+    const selectedChanges = selectBranchChanges({
+        changes: allChanges.docs,
+        excluded: cleanupRetry.handledChangeIDs,
+        selected
+    });
+    const pending = selectedChanges.filter((change)=>change.entityType !== 'global');
+    const pendingGlobals = selectedChanges.filter((change)=>change.entityType === 'global');
+    const resolved = await resolveEffectiveOperations({
+        branch,
+        changes: pending,
+        payload,
+        req
+    });
+    const targetReq = createMainBranchRequest({
+        req
+    });
+    const blocked = overrideAccess ? [] : await runMergePreflight({
+        payload,
+        pending: resolved,
+        req: targetReq
+    });
+    const blockedGlobals = overrideAccess ? [] : await runGlobalMergePreflight({
+        payload,
+        pending: pendingGlobals,
+        req: targetReq
+    });
+    blocked.push(...blockedGlobals);
+    blocked.push(...await runMergeDependencyPreflight({
+        initiallyBlocked: blocked,
+        payload,
+        pending: resolved,
+        pendingGlobals,
+        req: targetReq
+    }));
+    const validationCandidates = await prepareBranchMergeValidationCandidates({
+        payload,
+        pending: resolved,
+        pendingGlobals,
+        req: targetReq
+    });
+    const validation = await payload.config.branching.validate({
+        branch,
+        candidates: validationCandidates,
+        req: createBranchMergeValidationRequest({
+            req: targetReq
+        }),
+        target: MAIN_BRANCH
+    });
+    const hasPreflightErrors = blocked.length > 0 || !validation.valid;
+    const applicable = hasPreflightErrors ? [] : pending;
+    const applicableGlobals = hasPreflightErrors ? [] : pendingGlobals;
+    const mergeable = [
+        ...retryableCleanups,
+        ...applicable.map((change)=>({
+                changeID: change.id,
+                collectionSlug: change.collectionSlug,
+                docID: changeDocID(change),
+                entityType: 'collection',
+                operation: change.operation
+            }))
+    ];
+    mergeable.push(...applicableGlobals.map((change)=>({
+            changeID: change.id,
+            entityType: 'global',
+            globalSlug: change.globalSlug,
+            operation: 'update'
+        })));
+    const warnings = [];
+    for (const change of applicable){
+        if (change.operation === 'create' || !change.baseUpdatedAt) {
+            continue;
+        }
+        const collectionSlug = change.collectionSlug;
+        const docID = changeDocID(change);
+        const mainDoc = await payload.db.findOne({
+            branch: false,
+            collection: collectionSlug,
+            req,
+            where: {
+                and: [
+                    {
+                        [branchField]: {
+                            equals: MAIN_BRANCH
+                        }
+                    },
+                    {
+                        id: {
+                            equals: docID
+                        }
+                    }
+                ]
+            }
+        });
+        if (mainDoc?.updatedAt && new Date(mainDoc.updatedAt) > new Date(change.baseUpdatedAt)) {
+            warnings.push({
+                changeID: change.id,
+                collectionSlug,
+                docID,
+                message: `"${collectionSlug}" document ${docID} changed on main after it was branched. Merging will overwrite that change.`,
+                reason: 'main-moved'
+            });
+        }
+    }
+    return {
+        applicable,
+        applicableGlobals,
+        branchDoc,
+        mergeable,
+        req,
+        result: {
+            blocked,
+            canMerge: mergeable.length > 0,
+            mergeable,
+            merged: [],
+            validationErrors: validation.errors,
+            warnings
+        },
+        retryableCleanups
+    };
+};
+export const revalidatePreparedMerge = async ({ applicable, applicableGlobals, branch, overrideAccess, payload, req })=>{
+    const refreshedResolved = await resolveEffectiveOperations({
+        branch,
+        changes: applicable,
+        payload,
+        req
+    });
+    const targetReq = createMainBranchRequest({
+        req
+    });
+    const blocked = overrideAccess ? [] : await runMergePreflight({
+        payload,
+        pending: refreshedResolved,
+        req: targetReq
+    });
+    const blockedGlobals = overrideAccess ? [] : await runGlobalMergePreflight({
+        payload,
+        pending: applicableGlobals,
+        req: targetReq
+    });
+    blocked.push(...blockedGlobals);
+    blocked.push(...await runMergeDependencyPreflight({
+        initiallyBlocked: blocked,
+        payload,
+        pending: refreshedResolved,
+        pendingGlobals: applicableGlobals,
+        req: targetReq
+    }));
+    const validationCandidates = await prepareBranchMergeValidationCandidates({
+        payload,
+        pending: refreshedResolved,
+        pendingGlobals: applicableGlobals,
+        req: targetReq
+    });
+    const validation = await payload.config.branching.validate({
+        branch,
+        candidates: validationCandidates,
+        req: createBranchMergeValidationRequest({
+            req: targetReq
+        }),
+        target: MAIN_BRANCH
+    });
+    return {
+        blocked,
+        isValid: blocked.length === 0 && validation.valid,
+        validationErrors: validation.errors
+    };
+};
+
+//# sourceMappingURL=prepareMerge.js.map

package/dist/branching/merge/prepareMerge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/merge/prepareMerge.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from '../../types/index.js'\nimport type { MergeResult } from '../merge.js'\nimport type { BranchOperation, MergeableChange, MergeWarning } from '../types.js'\nimport type { BranchMergeValidationError } from '../validation.js'\n\nimport { createPayloadRequest } from '../../utilities/createPayloadRequest.js'\nimport { assertBranchActionAccess } from '../assertBranchActionAccess.js'\nimport { resolveEffectiveOperations } from '../effectiveOperations.js'\nimport {\n  runGlobalMergePreflight,\n  runMergeDependencyPreflight,\n  runMergePreflight,\n} from '../preflight.js'\nimport { withoutBranch } from '../resolveBranch.js'\nimport { selectBranchChanges } from '../selectBranchChanges.js'\nimport {\n  branchChangesCollectionSlug,\n  branchesCollectionSlug,\n  branchField,\n  MAIN_BRANCH,\n} from '../types.js'\nimport {\n  createBranchMergeValidationRequest,\n  createMainBranchRequest,\n  prepareBranchMergeValidationCandidates,\n} from '../validation.js'\nimport { inspectFailedCleanups } from './retryFailedCleanups.js'\nimport { changeDocID } from './utilities.js'\n\nexport type PreparedBranchChange = {\n  doc?: unknown\n  id: number | string\n} & Record<string, unknown>\n\nexport type PreparedMerge = {\n  applicable: PreparedBranchChange[]\n  applicableGlobals: PreparedBranchChange[]\n  branchDoc: { id: number | string }\n  mergeable: MergeableChange[]\n  req: PayloadRequest\n  result: MergeResult\n  retryableCleanups: MergeableChange[]\n}\n\nexport const prepareMerge = async ({\n  branch,\n  dryRun,\n  incomingReq,\n  overrideAccess,\n  payload,\n  selected,\n  user,\n}: {\n  branch: string\n  dryRun: boolean\n  incomingReq?: PayloadRequest\n  overrideAccess: boolean\n  payload: Payload\n  selected?: (number | string)[]\n  user?: NonNullable<PayloadRequest['user']>\n}): Promise<PreparedMerge> => {\n  const req = incomingReq\n    ? withoutBranch(incomingReq)\n    : await createPayloadRequest({ branch: false, payload, user })\n\n  if (user && !req.user) {\n    req.user = user\n  }\n\n  const branchDocs = await payload.find({\n    collection: branchesCollectionSlug,\n    limit: 1,\n    overrideAccess,\n    pagination: false,\n    req,\n    where: { slug: { equals: branch } },\n  })\n  const branchDoc = branchDocs.docs[0]\n\n  if (!branchDoc) {\n    throw new Error(`Branch \"${branch}\" was not found.`)\n  }\n\n  if (!overrideAccess) {\n    await assertBranchActionAccess({ action: 'mergeBranch', branchDoc, req })\n  }\n\n  const cleanupRetry = dryRun\n    ? { handledChangeIDs: new Set<string>(), retryable: [] }\n    : await inspectFailedCleanups({ branch, payload, req, selected })\n  const retryableCleanups = cleanupRetry.retryable\n  const allChanges = await payload.find({\n    collection: branchChangesCollectionSlug,\n    overrideAccess: true,\n    pagination: false,\n    req,\n    sort: 'createdAt',\n    where: { branch: { equals: branch } },\n  })\n  const selectedChanges = selectBranchChanges({\n    changes: allChanges.docs,\n    excluded: cleanupRetry.handledChangeIDs,\n    selected,\n  })\n  const pending = selectedChanges.filter(\n    (change) => change.entityType !== 'global',\n  ) as PreparedBranchChange[]\n  const pendingGlobals = selectedChanges.filter(\n    (change) => change.entityType === 'global',\n  ) as PreparedBranchChange[]\n  const resolved = await resolveEffectiveOperations({ branch, changes: pending, payload, req })\n  const targetReq = createMainBranchRequest({ req })\n  const blocked = overrideAccess\n    ? []\n    : await runMergePreflight({ payload, pending: resolved, req: targetReq })\n  const blockedGlobals = overrideAccess\n    ? []\n    : await runGlobalMergePreflight({ payload, pending: pendingGlobals, req: targetReq })\n\n  blocked.push(...blockedGlobals)\n  blocked.push(\n    ...(await runMergeDependencyPreflight({\n      initiallyBlocked: blocked,\n      payload,\n      pending: resolved,\n      pendingGlobals,\n      req: targetReq,\n    })),\n  )\n\n  const validationCandidates = await prepareBranchMergeValidationCandidates({\n    payload,\n    pending: resolved,\n    pendingGlobals,\n    req: targetReq,\n  })\n  const validation = await payload.config.branching.validate({\n    branch,\n    candidates: validationCandidates,\n    req: createBranchMergeValidationRequest({ req: targetReq }),\n    target: MAIN_BRANCH,\n  })\n  const hasPreflightErrors = blocked.length > 0 || !validation.valid\n  const applicable = hasPreflightErrors ? [] : pending\n  const applicableGlobals = hasPreflightErrors ? [] : pendingGlobals\n  const mergeable: MergeableChange[] = [\n    ...retryableCleanups,\n    ...applicable.map((change) => ({\n      changeID: change.id,\n      collectionSlug: change.collectionSlug as string,\n      docID: changeDocID(change),\n      entityType: 'collection' as const,\n      operation: change.operation as BranchOperation,\n    })),\n  ]\n\n  mergeable.push(\n    ...applicableGlobals.map((change) => ({\n      changeID: change.id,\n      entityType: 'global' as const,\n      globalSlug: change.globalSlug as string,\n      operation: 'update' as const,\n    })),\n  )\n\n  const warnings: MergeWarning[] = []\n\n  for (const change of applicable) {\n    if (change.operation === 'create' || !change.baseUpdatedAt) {\n      continue\n    }\n\n    const collectionSlug = change.collectionSlug as string\n    const docID = changeDocID(change)\n    const mainDoc = (await payload.db.findOne({\n      branch: false,\n      collection: collectionSlug,\n      req,\n      where: {\n        and: [{ [branchField]: { equals: MAIN_BRANCH } }, { id: { equals: docID } }],\n      },\n    })) as null | Record<string, unknown>\n\n    if (\n      mainDoc?.updatedAt &&\n      new Date(mainDoc.updatedAt as string) > new Date(change.baseUpdatedAt as string)\n    ) {\n      warnings.push({\n        changeID: change.id,\n        collectionSlug,\n        docID,\n        message: `\"${collectionSlug}\" document ${docID} changed on main after it was branched. Merging will overwrite that change.`,\n        reason: 'main-moved',\n      })\n    }\n  }\n\n  return {\n    applicable,\n    applicableGlobals,\n    branchDoc,\n    mergeable,\n    req,\n    result: {\n      blocked,\n      canMerge: mergeable.length > 0,\n      mergeable,\n      merged: [],\n      validationErrors: validation.errors,\n      warnings,\n    },\n    retryableCleanups,\n  }\n}\n\nexport const revalidatePreparedMerge = async ({\n  applicable,\n  applicableGlobals,\n  branch,\n  overrideAccess,\n  payload,\n  req,\n}: {\n  applicable: PreparedBranchChange[]\n  applicableGlobals: PreparedBranchChange[]\n  branch: string\n  overrideAccess: boolean\n  payload: Payload\n  req: PayloadRequest\n}): Promise<{\n  blocked: MergeResult['blocked']\n  isValid: boolean\n  validationErrors: BranchMergeValidationError[]\n}> => {\n  const refreshedResolved = await resolveEffectiveOperations({\n    branch,\n    changes: applicable,\n    payload,\n    req,\n  })\n  const targetReq = createMainBranchRequest({ req })\n  const blocked = overrideAccess\n    ? []\n    : await runMergePreflight({ payload, pending: refreshedResolved, req: targetReq })\n  const blockedGlobals = overrideAccess\n    ? []\n    : await runGlobalMergePreflight({\n        payload,\n        pending: applicableGlobals,\n        req: targetReq,\n      })\n\n  blocked.push(...blockedGlobals)\n  blocked.push(\n    ...(await runMergeDependencyPreflight({\n      initiallyBlocked: blocked,\n      payload,\n      pending: refreshedResolved,\n      pendingGlobals: applicableGlobals,\n      req: targetReq,\n    })),\n  )\n\n  const validationCandidates = await prepareBranchMergeValidationCandidates({\n    payload,\n    pending: refreshedResolved,\n    pendingGlobals: applicableGlobals,\n    req: targetReq,\n  })\n  const validation = await payload.config.branching.validate({\n    branch,\n    candidates: validationCandidates,\n    req: createBranchMergeValidationRequest({ req: targetReq }),\n    target: MAIN_BRANCH,\n  })\n\n  return {\n    blocked,\n    isValid: blocked.length === 0 && validation.valid,\n    validationErrors: validation.errors,\n  }\n}\n"],"names":["createPayloadRequest","assertBranchActionAccess","resolveEffectiveOperations","runGlobalMergePreflight","runMergeDependencyPreflight","runMergePreflight","withoutBranch","selectBranchChanges","branchChangesCollectionSlug","branchesCollectionSlug","branchField","MAIN_BRANCH","createBranchMergeValidationRequest","createMainBranchRequest","prepareBranchMergeValidationCandidates","inspectFailedCleanups","changeDocID","prepareMerge","branch","dryRun","incomingReq","overrideAccess","payload","selected","user","req","branchDocs","find","collection","limit","pagination","where","slug","equals","branchDoc","docs","Error","action","cleanupRetry","handledChangeIDs","Set","retryable","retryableCleanups","allChanges","sort","selectedChanges","changes","excluded","pending","filter","change","entityType","pendingGlobals","resolved","targetReq","blocked","blockedGlobals","push","initiallyBlocked","validationCandidates","validation","config","branching","validate","candidates","target","hasPreflightErrors","length","valid","applicable","applicableGlobals","mergeable","map","changeID","id","collectionSlug","docID","operation","globalSlug","warnings","baseUpdatedAt","mainDoc","db","findOne","and","updatedAt","Date","message","reason","result","canMerge","merged","validationErrors","errors","revalidatePreparedMerge","refreshedResolved","isValid"],"mappings":"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"}

package/dist/branching/merge/recoverMerge.d.ts

@@ -0,0 +1,16 @@
+import type { Payload, PayloadRequest } from '../../types/index.js';
+import type { SourceCleanupPlan } from './finalizeMerge.js';
+import type { MergeLedger } from './mergeLedger.js';
+export declare const recoverMergeFailure: ({ activeChangeID, didRollbackTransaction, error, hasTransaction, isTransactionOutcomeUnknown, ledger, overrideAccess, payload, req, sourceCleanupPlans, }: {
+    activeChangeID?: number | string;
+    didRollbackTransaction: boolean;
+    error: unknown;
+    hasTransaction: boolean;
+    isTransactionOutcomeUnknown: boolean;
+    ledger: MergeLedger;
+    overrideAccess: boolean;
+    payload: Payload;
+    req: PayloadRequest;
+    sourceCleanupPlans: SourceCleanupPlan[];
+}) => Promise<void>;
+//# sourceMappingURL=recoverMerge.d.ts.map

package/dist/branching/merge/recoverMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recoverMerge.d.ts","sourceRoot":"","sources":["../../../src/branching/merge/recoverMerge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAEnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAkDnD,eAAO,MAAM,mBAAmB,8JAW7B;IACD,cAAc,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC,sBAAsB,EAAE,OAAO,CAAA;IAC/B,KAAK,EAAE,OAAO,CAAA;IACd,cAAc,EAAE,OAAO,CAAA;IACvB,2BAA2B,EAAE,OAAO,CAAA;IACpC,MAAM,EAAE,WAAW,CAAA;IACnB,cAAc,EAAE,OAAO,CAAA;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,kBAAkB,EAAE,iBAAiB,EAAE,CAAA;CACxC,KAAG,OAAO,CAAC,IAAI,CAoIf,CAAA"}

package/dist/branching/merge/recoverMerge.js

@@ -0,0 +1,199 @@
+import { createMainBranchRequest } from '../validation.js';
+import { getMergeErrorMessage } from './utilities.js';
+const hasTargetVersion = async ({ change, payload, req })=>{
+    if (!change.beforeVersionID) {
+        return false;
+    }
+    if (change.globalSlug) {
+        const { docs } = await payload.db.findGlobalVersions({
+            branch: false,
+            global: change.globalSlug,
+            limit: 1,
+            pagination: false,
+            req,
+            where: {
+                id: {
+                    equals: change.beforeVersionID
+                }
+            }
+        });
+        return docs.length > 0;
+    }
+    if (!change.collectionSlug) {
+        return false;
+    }
+    const { docs } = await payload.db.findVersions({
+        branch: false,
+        collection: change.collectionSlug,
+        limit: 1,
+        pagination: false,
+        req,
+        where: {
+            and: [
+                {
+                    id: {
+                        equals: change.beforeVersionID
+                    }
+                },
+                {
+                    parent: {
+                        equals: change.targetID
+                    }
+                }
+            ]
+        }
+    });
+    return docs.length > 0;
+};
+export const recoverMergeFailure = async ({ activeChangeID, didRollbackTransaction, error, hasTransaction, isTransactionOutcomeUnknown, ledger, overrideAccess, payload, req, sourceCleanupPlans })=>{
+    if (isTransactionOutcomeUnknown) {
+        ledger.mapChanges({
+            update: (change)=>change.applicationOutcome === 'applied' ? {
+                    ...change,
+                    applicationOutcome: 'unknown',
+                    cleanupOutcome: 'unknown'
+                } : change
+        });
+    } else if (didRollbackTransaction) {
+        ledger.mapChanges({
+            update: (change)=>change.applicationOutcome === 'applied' ? {
+                    ...change,
+                    applicationOutcome: 'rolledBack',
+                    cleanupOutcome: 'pending'
+                } : change
+        });
+    }
+    if (!hasTransaction) {
+        for (const recoveryPlan of [
+            ...sourceCleanupPlans
+        ].reverse()){
+            const change = ledger.findChange({
+                changeID: recoveryPlan.changeID
+            });
+            if (!change || change.applicationOutcome !== 'applied') {
+                continue;
+            }
+            ledger.updateChange({
+                changeID: change.changeID,
+                update: {
+                    recoveryOutcome: 'pending'
+                }
+            });
+            if (!await ledger.persistRecovery({
+                changeID: change.changeID
+            })) {
+                continue;
+            }
+            if (!recoveryPlan.recover && (!change.beforeVersionID || !change.collectionSlug && !change.globalSlug)) {
+                ledger.updateChange({
+                    changeID: change.changeID,
+                    update: {
+                        recoveryOutcome: 'unavailable'
+                    }
+                });
+                await ledger.persistRecovery({
+                    changeID: change.changeID
+                });
+                continue;
+            }
+            try {
+                let recoveryOutcome;
+                if (recoveryPlan.recover) {
+                    recoveryOutcome = await recoveryPlan.recover();
+                } else {
+                    const recoveryReq = createMainBranchRequest({
+                        req
+                    });
+                    if (!await hasTargetVersion({
+                        change,
+                        payload,
+                        req: recoveryReq
+                    })) {
+                        ledger.updateChange({
+                            changeID: change.changeID,
+                            update: {
+                                recoveryOutcome: 'unavailable'
+                            }
+                        });
+                        await ledger.persistRecovery({
+                            changeID: change.changeID
+                        });
+                        continue;
+                    }
+                    if (change.globalSlug) {
+                        await payload.restoreGlobalVersion({
+                            id: change.beforeVersionID,
+                            slug: change.globalSlug,
+                            overrideAccess,
+                            req: recoveryReq
+                        });
+                    } else {
+                        await payload.restoreVersion({
+                            id: change.beforeVersionID,
+                            collection: change.collectionSlug,
+                            overrideAccess,
+                            req: recoveryReq
+                        });
+                    }
+                    recoveryOutcome = 'restored';
+                }
+                ledger.updateChange({
+                    changeID: change.changeID,
+                    update: {
+                        recoveryOutcome
+                    }
+                });
+            } catch (recoveryError) {
+                ledger.updateChange({
+                    changeID: change.changeID,
+                    update: {
+                        recoveryError: getMergeErrorMessage({
+                            error: recoveryError
+                        }),
+                        recoveryOutcome: 'failed'
+                    }
+                });
+            }
+            await ledger.persistRecovery({
+                changeID: change.changeID
+            });
+        }
+    }
+    const errorMessage = getMergeErrorMessage({
+        error
+    });
+    if (activeChangeID !== undefined) {
+        const activeChange = ledger.findChange({
+            changeID: activeChangeID
+        });
+        if (activeChange?.applicationOutcome === 'attempted') {
+            ledger.updateChange({
+                changeID: activeChangeID,
+                update: {
+                    applicationOutcome: 'failed',
+                    error: errorMessage
+                }
+            });
+        }
+    }
+    ledger.mapChanges({
+        update: (change)=>change.applicationOutcome === 'attempted' ? {
+                ...change,
+                applicationOutcome: 'unattempted'
+            } : change
+    });
+    try {
+        await ledger.persist({
+            completedAt: new Date().toISOString(),
+            error: errorMessage,
+            status: 'failed'
+        });
+    } catch (mergeEventError) {
+        payload.logger.error({
+            err: mergeEventError,
+            msg: 'Failed to record a branch merge failure.'
+        });
+    }
+};
+
+//# sourceMappingURL=recoverMerge.js.map

package/dist/branching/merge/recoverMerge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/merge/recoverMerge.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from '../../types/index.js'\nimport type { MergeEventChange } from '../types.js'\nimport type { SourceCleanupPlan } from './finalizeMerge.js'\nimport type { MergeLedger } from './mergeLedger.js'\nimport type { SourceRecoveryOutcome } from './utilities.js'\n\nimport { createMainBranchRequest } from '../validation.js'\nimport { getMergeErrorMessage } from './utilities.js'\n\nconst hasTargetVersion = async ({\n  change,\n  payload,\n  req,\n}: {\n  change: MergeEventChange\n  payload: Payload\n  req: PayloadRequest\n}): Promise<boolean> => {\n  if (!change.beforeVersionID) {\n    return false\n  }\n\n  if (change.globalSlug) {\n    const { docs } = await payload.db.findGlobalVersions({\n      branch: false,\n      global: change.globalSlug,\n      limit: 1,\n      pagination: false,\n      req,\n      where: { id: { equals: change.beforeVersionID } },\n    })\n\n    return docs.length > 0\n  }\n\n  if (!change.collectionSlug) {\n    return false\n  }\n\n  const { docs } = await payload.db.findVersions({\n    branch: false,\n    collection: change.collectionSlug,\n    limit: 1,\n    pagination: false,\n    req,\n    where: {\n      and: [{ id: { equals: change.beforeVersionID } }, { parent: { equals: change.targetID } }],\n    },\n  })\n\n  return docs.length > 0\n}\n\nexport const recoverMergeFailure = async ({\n  activeChangeID,\n  didRollbackTransaction,\n  error,\n  hasTransaction,\n  isTransactionOutcomeUnknown,\n  ledger,\n  overrideAccess,\n  payload,\n  req,\n  sourceCleanupPlans,\n}: {\n  activeChangeID?: number | string\n  didRollbackTransaction: boolean\n  error: unknown\n  hasTransaction: boolean\n  isTransactionOutcomeUnknown: boolean\n  ledger: MergeLedger\n  overrideAccess: boolean\n  payload: Payload\n  req: PayloadRequest\n  sourceCleanupPlans: SourceCleanupPlan[]\n}): Promise<void> => {\n  if (isTransactionOutcomeUnknown) {\n    ledger.mapChanges({\n      update: (change) =>\n        change.applicationOutcome === 'applied'\n          ? { ...change, applicationOutcome: 'unknown', cleanupOutcome: 'unknown' }\n          : change,\n    })\n  } else if (didRollbackTransaction) {\n    ledger.mapChanges({\n      update: (change) =>\n        change.applicationOutcome === 'applied'\n          ? { ...change, applicationOutcome: 'rolledBack', cleanupOutcome: 'pending' }\n          : change,\n    })\n  }\n\n  if (!hasTransaction) {\n    for (const recoveryPlan of [...sourceCleanupPlans].reverse()) {\n      const change = ledger.findChange({ changeID: recoveryPlan.changeID })\n\n      if (!change || change.applicationOutcome !== 'applied') {\n        continue\n      }\n\n      ledger.updateChange({\n        changeID: change.changeID,\n        update: { recoveryOutcome: 'pending' },\n      })\n\n      if (!(await ledger.persistRecovery({ changeID: change.changeID }))) {\n        continue\n      }\n\n      if (\n        !recoveryPlan.recover &&\n        (!change.beforeVersionID || (!change.collectionSlug && !change.globalSlug))\n      ) {\n        ledger.updateChange({\n          changeID: change.changeID,\n          update: { recoveryOutcome: 'unavailable' },\n        })\n        await ledger.persistRecovery({ changeID: change.changeID })\n        continue\n      }\n\n      try {\n        let recoveryOutcome: SourceRecoveryOutcome\n\n        if (recoveryPlan.recover) {\n          recoveryOutcome = await recoveryPlan.recover()\n        } else {\n          const recoveryReq = createMainBranchRequest({ req })\n\n          if (!(await hasTargetVersion({ change, payload, req: recoveryReq }))) {\n            ledger.updateChange({\n              changeID: change.changeID,\n              update: { recoveryOutcome: 'unavailable' },\n            })\n            await ledger.persistRecovery({ changeID: change.changeID })\n            continue\n          }\n\n          if (change.globalSlug) {\n            await payload.restoreGlobalVersion({\n              id: change.beforeVersionID!,\n              slug: change.globalSlug,\n              overrideAccess,\n              req: recoveryReq,\n            })\n          } else {\n            await payload.restoreVersion({\n              id: change.beforeVersionID!,\n              collection: change.collectionSlug!,\n              overrideAccess,\n              req: recoveryReq,\n            })\n          }\n\n          recoveryOutcome = 'restored'\n        }\n\n        ledger.updateChange({\n          changeID: change.changeID,\n          update: { recoveryOutcome },\n        })\n      } catch (recoveryError) {\n        ledger.updateChange({\n          changeID: change.changeID,\n          update: {\n            recoveryError: getMergeErrorMessage({ error: recoveryError }),\n            recoveryOutcome: 'failed',\n          },\n        })\n      }\n\n      await ledger.persistRecovery({ changeID: change.changeID })\n    }\n  }\n\n  const errorMessage = getMergeErrorMessage({ error })\n\n  if (activeChangeID !== undefined) {\n    const activeChange = ledger.findChange({ changeID: activeChangeID })\n\n    if (activeChange?.applicationOutcome === 'attempted') {\n      ledger.updateChange({\n        changeID: activeChangeID,\n        update: { applicationOutcome: 'failed', error: errorMessage },\n      })\n    }\n  }\n\n  ledger.mapChanges({\n    update: (change) =>\n      change.applicationOutcome === 'attempted'\n        ? { ...change, applicationOutcome: 'unattempted' }\n        : change,\n  })\n\n  try {\n    await ledger.persist({\n      completedAt: new Date().toISOString(),\n      error: errorMessage,\n      status: 'failed',\n    })\n  } catch (mergeEventError) {\n    payload.logger.error({\n      err: mergeEventError,\n      msg: 'Failed to record a branch merge failure.',\n    })\n  }\n}\n"],"names":["createMainBranchRequest","getMergeErrorMessage","hasTargetVersion","change","payload","req","beforeVersionID","globalSlug","docs","db","findGlobalVersions","branch","global","limit","pagination","where","id","equals","length","collectionSlug","findVersions","collection","and","parent","targetID","recoverMergeFailure","activeChangeID","didRollbackTransaction","error","hasTransaction","isTransactionOutcomeUnknown","ledger","overrideAccess","sourceCleanupPlans","mapChanges","update","applicationOutcome","cleanupOutcome","recoveryPlan","reverse","findChange","changeID","updateChange","recoveryOutcome","persistRecovery","recover","recoveryReq","restoreGlobalVersion","slug","restoreVersion","recoveryError","errorMessage","undefined","activeChange","persist","completedAt","Date","toISOString","status","mergeEventError","logger","err","msg"],"mappings":"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"}

package/dist/branching/merge/retryFailedCleanups.d.ts

@@ -0,0 +1,36 @@
+import type { Payload, PayloadRequest } from '../../types/index.js';
+import type { MergeableChange } from '../types.js';
+/**
+ * Finds cleanup recovery work without changing persisted state.
+ *
+ * Merge preparation uses this result to exclude already-committed changes from
+ * normal target writes. The actual cleanup starts only after the branch has
+ * been conditionally claimed as `merging`.
+ */
+export declare const inspectFailedCleanups: ({ branch, payload, req, selected, }: {
+    branch: string;
+    payload: Payload;
+    req: PayloadRequest;
+    selected?: (number | string)[];
+}) => Promise<{
+    handledChangeIDs: Set<string>;
+    retryable: MergeableChange[];
+}>;
+/**
+ * Retries only the source cleanup recorded by a committed merge event.
+ *
+ * The target write is already durable. Replaying it would run hooks and create
+ * versions again, so cleanup uses the stored source row identity and revision.
+ * A changed source row belongs to newer branch work and is left for the normal
+ * merge path.
+ */
+export declare const retryFailedCleanups: ({ branch, payload, req, selected, }: {
+    branch: string;
+    payload: Payload;
+    req: PayloadRequest;
+    selected?: (number | string)[];
+}) => Promise<{
+    handledChangeIDs: Set<string>;
+    retried: MergeableChange[];
+}>;
+//# sourceMappingURL=retryFailedCleanups.d.ts.map

package/dist/branching/merge/retryFailedCleanups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retryFailedCleanups.d.ts","sourceRoot":"","sources":["../../../src/branching/merge/retryFailedCleanups.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACnE,OAAO,KAAK,EAAE,eAAe,EAAoB,MAAM,aAAa,CAAA;AAiIpE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,wCAK/B;IACD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;CAC/B,KAAG,OAAO,CAAC;IAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAAC,SAAS,EAAE,eAAe,EAAE,CAAA;CAAE,CAY1E,CAAA;AA8BD;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,wCAK7B;IACD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;CAC/B,KAAG,OAAO,CAAC;IAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,eAAe,EAAE,CAAA;CAAE,CA8KxE,CAAA"}