payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/branching/merge/retryFailedCleanups.js

@@ -0,0 +1,335 @@
+import { getVersionsMax } from '../../utilities/getVersionsConfig.js';
+import { enforceMaxVersions } from '../../versions/enforceMaxVersions.js';
+import { branchChangesCollectionSlug, branchDocIDField, branchField, branchMergesCollectionSlug } from '../types.js';
+import { deleteBranchGlobalVersionChain, deleteBranchVersionChain } from '../versions.js';
+import { deleteVersionsByID } from './applyMergeChange.js';
+import { getGlobalSourceRevision, getMergeErrorMessage, getTimestamp, readSerializedGlobalSourceStates } from './utilities.js';
+const updateMergeEventChange = ({ changeID, changes, update })=>changes.map((change)=>change.changeID === String(changeID) ? {
+            ...change,
+            ...update
+        } : change);
+const toMergeableChange = ({ change })=>{
+    if (change.globalSlug) {
+        return {
+            changeID: change.changeID,
+            entityType: 'global',
+            globalSlug: change.globalSlug,
+            operation: change.operation
+        };
+    }
+    if (!change.collectionSlug || change.docID === undefined) {
+        return null;
+    }
+    return {
+        changeID: change.changeID,
+        collectionSlug: change.collectionSlug,
+        docID: change.docID,
+        entityType: 'collection',
+        operation: change.operation
+    };
+};
+const findRetryableCleanupCandidates = async ({ branch, payload, req, selected })=>{
+    const failedEvents = await payload.find({
+        collection: branchMergesCollectionSlug,
+        depth: 0,
+        overrideAccess: true,
+        pagination: false,
+        req,
+        sort: '-startedAt',
+        where: {
+            and: [
+                {
+                    branch: {
+                        equals: branch
+                    }
+                },
+                {
+                    status: {
+                        equals: 'cleanupFailed'
+                    }
+                }
+            ]
+        }
+    });
+    const selectedChangeIDs = selected ? new Set(selected.map(String)) : null;
+    const candidateChangeIDs = new Set();
+    const candidates = [];
+    for (const eventDocument of failedEvents.docs){
+        const event = eventDocument;
+        for (const change of event.changes ?? []){
+            const canRetryCollection = Boolean(change.collectionSlug && change.sourceID && change.sourceUpdatedAt && change.operation !== 'create');
+            const canRetryGlobal = Boolean(change.globalSlug && change.sourceRevision);
+            const canRetryCreatedCollection = Boolean(change.collectionSlug && change.operation === 'create' && change.sourceID && change.sourceVersionIDs);
+            if (candidateChangeIDs.has(change.changeID) || selectedChangeIDs && !selectedChangeIDs.has(change.changeID) || change.applicationOutcome !== 'committed' || change.cleanupOutcome !== 'failed' || !canRetryCollection && !canRetryCreatedCollection && !canRetryGlobal) {
+                continue;
+            }
+            candidateChangeIDs.add(change.changeID);
+            candidates.push({
+                change,
+                event
+            });
+        }
+    }
+    return candidates;
+};
+/**
+ * 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 const inspectFailedCleanups = async ({ branch, payload, req, selected })=>{
+    const candidates = await findRetryableCleanupCandidates({
+        branch,
+        payload,
+        req,
+        selected
+    });
+    const retryable = candidates.flatMap(({ change })=>{
+        const mergeableChange = toMergeableChange({
+            change
+        });
+        return mergeableChange ? [
+            mergeableChange
+        ] : [];
+    });
+    return {
+        handledChangeIDs: new Set(retryable.map(({ changeID })=>String(changeID))),
+        retryable
+    };
+};
+const persistRetriedMergeEvent = async ({ event, payload, req })=>{
+    const changes = event.changes ?? [];
+    const hasUnresolvedCleanup = changes.some(({ cleanupOutcome })=>[
+            'failed',
+            'pending',
+            'unknown'
+        ].includes(cleanupOutcome));
+    await payload.update({
+        id: event.id,
+        collection: branchMergesCollectionSlug,
+        data: {
+            changes,
+            completedAt: hasUnresolvedCleanup ? event.completedAt : new Date().toISOString(),
+            error: hasUnresolvedCleanup ? event.error : null,
+            status: hasUnresolvedCleanup ? 'cleanupFailed' : 'succeeded'
+        },
+        overrideAccess: true,
+        req
+    });
+};
+/**
+ * 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 const retryFailedCleanups = async ({ branch, payload, req, selected })=>{
+    const candidates = await findRetryableCleanupCandidates({
+        branch,
+        payload,
+        req,
+        selected
+    });
+    const handledChangeIDs = new Set();
+    const retried = [];
+    for (const { change, event } of candidates){
+        const canRetryGlobal = Boolean(change.globalSlug && change.sourceRevision);
+        const canRetryCreatedCollection = Boolean(change.collectionSlug && change.operation === 'create' && change.sourceID && change.sourceVersionIDs);
+        event.changes = updateMergeEventChange({
+            changeID: change.changeID,
+            changes: event.changes ?? [],
+            update: {
+                cleanupError: undefined,
+                cleanupOutcome: 'pending'
+            }
+        });
+        await persistRetriedMergeEvent({
+            event,
+            payload,
+            req
+        });
+        try {
+            let isSuperseded = false;
+            if (canRetryGlobal) {
+                const currentSourceStates = await readSerializedGlobalSourceStates({
+                    branch,
+                    globalSlug: change.globalSlug,
+                    payload,
+                    req
+                });
+                isSuperseded = currentSourceStates.length > 0 && getGlobalSourceRevision({
+                    sourceStates: currentSourceStates
+                }) !== change.sourceRevision;
+                if (!isSuperseded) {
+                    await deleteBranchGlobalVersionChain({
+                        branch,
+                        globalSlug: change.globalSlug,
+                        payload,
+                        req
+                    });
+                    await payload.db.deleteBranchGlobal?.({
+                        branch,
+                        globalSlug: change.globalSlug,
+                        req
+                    });
+                }
+            } else if (canRetryCreatedCollection) {
+                const newerSource = await payload.db.findOne({
+                    branch: false,
+                    collection: change.collectionSlug,
+                    req,
+                    where: {
+                        and: [
+                            {
+                                [branchField]: {
+                                    equals: branch
+                                }
+                            },
+                            {
+                                [branchDocIDField]: {
+                                    equals: change.targetID
+                                }
+                            }
+                        ]
+                    }
+                });
+                isSuperseded = Boolean(newerSource);
+                if (!isSuperseded) {
+                    await deleteVersionsByID({
+                        collectionSlug: change.collectionSlug,
+                        ids: change.sourceVersionIDs,
+                        payload,
+                        req
+                    });
+                    const collection = payload.collections[change.collectionSlug].config;
+                    const maxVersions = getVersionsMax(collection);
+                    if (maxVersions > 0) {
+                        await enforceMaxVersions({
+                            id: change.sourceID,
+                            collection,
+                            max: maxVersions,
+                            payload,
+                            req
+                        });
+                    }
+                }
+            } else {
+                const source = await payload.db.findOne({
+                    branch: false,
+                    collection: change.collectionSlug,
+                    req,
+                    where: {
+                        id: {
+                            equals: change.sourceID
+                        }
+                    }
+                });
+                const currentSourceUpdatedAt = getTimestamp({
+                    value: source?.updatedAt
+                });
+                const mergedSourceUpdatedAt = getTimestamp({
+                    value: change.sourceUpdatedAt
+                });
+                isSuperseded = Boolean(source && currentSourceUpdatedAt !== undefined && mergedSourceUpdatedAt !== undefined && currentSourceUpdatedAt !== mergedSourceUpdatedAt);
+                if (!isSuperseded && source) {
+                    await deleteBranchVersionChain({
+                        branch,
+                        collectionSlug: change.collectionSlug,
+                        payload,
+                        req,
+                        rowID: change.sourceID
+                    });
+                    await payload.db.deleteOne({
+                        branch: false,
+                        collection: change.collectionSlug,
+                        req,
+                        where: {
+                            id: {
+                                equals: change.sourceID
+                            }
+                        }
+                    });
+                }
+            }
+            if (isSuperseded) {
+                event.changes = updateMergeEventChange({
+                    changeID: change.changeID,
+                    changes: event.changes,
+                    update: {
+                        cleanupOutcome: 'superseded'
+                    }
+                });
+                await persistRetriedMergeEvent({
+                    event,
+                    payload,
+                    req
+                });
+                handledChangeIDs.add(change.changeID);
+                continue;
+            }
+            const changeRecord = await payload.db.findOne({
+                collection: branchChangesCollectionSlug,
+                req,
+                where: {
+                    id: {
+                        equals: change.changeID
+                    }
+                }
+            });
+            if (changeRecord) {
+                await payload.delete({
+                    id: change.changeID,
+                    collection: branchChangesCollectionSlug,
+                    overrideAccess: true,
+                    req
+                });
+            }
+            event.changes = updateMergeEventChange({
+                changeID: change.changeID,
+                changes: event.changes,
+                update: {
+                    cleanupOutcome: 'completed'
+                }
+            });
+            await persistRetriedMergeEvent({
+                event,
+                payload,
+                req
+            });
+            const mergeableChange = toMergeableChange({
+                change
+            });
+            if (mergeableChange) {
+                retried.push(mergeableChange);
+            }
+            handledChangeIDs.add(change.changeID);
+        } catch (error) {
+            const cleanupError = getMergeErrorMessage({
+                error
+            });
+            event.changes = updateMergeEventChange({
+                changeID: change.changeID,
+                changes: event.changes,
+                update: {
+                    cleanupError,
+                    cleanupOutcome: 'failed'
+                }
+            });
+            event.error = cleanupError;
+            await persistRetriedMergeEvent({
+                event,
+                payload,
+                req
+            });
+            throw error;
+        }
+    }
+    return {
+        handledChangeIDs,
+        retried
+    };
+};
+
+//# sourceMappingURL=retryFailedCleanups.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/merge/retryFailedCleanups.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from '../../types/index.js'\nimport type { MergeableChange, MergeEventChange } from '../types.js'\n\nimport { getVersionsMax } from '../../utilities/getVersionsConfig.js'\nimport { enforceMaxVersions } from '../../versions/enforceMaxVersions.js'\nimport {\n  branchChangesCollectionSlug,\n  branchDocIDField,\n  branchField,\n  branchMergesCollectionSlug,\n} from '../types.js'\nimport { deleteBranchGlobalVersionChain, deleteBranchVersionChain } from '../versions.js'\nimport { deleteVersionsByID } from './applyMergeChange.js'\nimport {\n  getGlobalSourceRevision,\n  getMergeErrorMessage,\n  getTimestamp,\n  readSerializedGlobalSourceStates,\n} from './utilities.js'\n\ntype PersistedMergeEvent = {\n  changes?: MergeEventChange[]\n  completedAt?: string\n  error?: string\n  id: number | string\n}\n\ntype RetryableCleanupCandidate = {\n  change: MergeEventChange\n  event: PersistedMergeEvent\n}\n\nconst updateMergeEventChange = ({\n  changeID,\n  changes,\n  update,\n}: {\n  changeID: number | string\n  changes: MergeEventChange[]\n  update: Partial<MergeEventChange>\n}): MergeEventChange[] =>\n  changes.map((change) =>\n    change.changeID === String(changeID) ? { ...change, ...update } : change,\n  )\n\nconst toMergeableChange = ({ change }: { change: MergeEventChange }): MergeableChange | null => {\n  if (change.globalSlug) {\n    return {\n      changeID: change.changeID,\n      entityType: 'global',\n      globalSlug: change.globalSlug,\n      operation: change.operation,\n    }\n  }\n\n  if (!change.collectionSlug || change.docID === undefined) {\n    return null\n  }\n\n  return {\n    changeID: change.changeID,\n    collectionSlug: change.collectionSlug,\n    docID: change.docID,\n    entityType: 'collection',\n    operation: change.operation,\n  }\n}\n\nconst findRetryableCleanupCandidates = async ({\n  branch,\n  payload,\n  req,\n  selected,\n}: {\n  branch: string\n  payload: Payload\n  req: PayloadRequest\n  selected?: (number | string)[]\n}): Promise<RetryableCleanupCandidate[]> => {\n  const failedEvents = await payload.find({\n    collection: branchMergesCollectionSlug,\n    depth: 0,\n    overrideAccess: true,\n    pagination: false,\n    req,\n    sort: '-startedAt',\n    where: {\n      and: [{ branch: { equals: branch } }, { status: { equals: 'cleanupFailed' } }],\n    },\n  })\n  const selectedChangeIDs = selected ? new Set(selected.map(String)) : null\n  const candidateChangeIDs = new Set<string>()\n  const candidates: RetryableCleanupCandidate[] = []\n\n  for (const eventDocument of failedEvents.docs) {\n    const event = eventDocument as unknown as PersistedMergeEvent\n\n    for (const change of event.changes ?? []) {\n      const canRetryCollection = Boolean(\n        change.collectionSlug &&\n          change.sourceID &&\n          change.sourceUpdatedAt &&\n          change.operation !== 'create',\n      )\n      const canRetryGlobal = Boolean(change.globalSlug && change.sourceRevision)\n      const canRetryCreatedCollection = Boolean(\n        change.collectionSlug &&\n          change.operation === 'create' &&\n          change.sourceID &&\n          change.sourceVersionIDs,\n      )\n\n      if (\n        candidateChangeIDs.has(change.changeID) ||\n        (selectedChangeIDs && !selectedChangeIDs.has(change.changeID)) ||\n        change.applicationOutcome !== 'committed' ||\n        change.cleanupOutcome !== 'failed' ||\n        (!canRetryCollection && !canRetryCreatedCollection && !canRetryGlobal)\n      ) {\n        continue\n      }\n\n      candidateChangeIDs.add(change.changeID)\n      candidates.push({ change, event })\n    }\n  }\n\n  return candidates\n}\n\n/**\n * Finds cleanup recovery work without changing persisted state.\n *\n * Merge preparation uses this result to exclude already-committed changes from\n * normal target writes. The actual cleanup starts only after the branch has\n * been conditionally claimed as `merging`.\n */\nexport const inspectFailedCleanups = async ({\n  branch,\n  payload,\n  req,\n  selected,\n}: {\n  branch: string\n  payload: Payload\n  req: PayloadRequest\n  selected?: (number | string)[]\n}): Promise<{ handledChangeIDs: Set<string>; retryable: MergeableChange[] }> => {\n  const candidates = await findRetryableCleanupCandidates({ branch, payload, req, selected })\n  const retryable = candidates.flatMap(({ change }) => {\n    const mergeableChange = toMergeableChange({ change })\n\n    return mergeableChange ? [mergeableChange] : []\n  })\n\n  return {\n    handledChangeIDs: new Set(retryable.map(({ changeID }) => String(changeID))),\n    retryable,\n  }\n}\n\nconst persistRetriedMergeEvent = async ({\n  event,\n  payload,\n  req,\n}: {\n  event: PersistedMergeEvent\n  payload: Payload\n  req: PayloadRequest\n}): Promise<void> => {\n  const changes = event.changes ?? []\n  const hasUnresolvedCleanup = changes.some(({ cleanupOutcome }) =>\n    ['failed', 'pending', 'unknown'].includes(cleanupOutcome),\n  )\n\n  await payload.update({\n    id: event.id,\n    collection: branchMergesCollectionSlug,\n    data: {\n      changes,\n      completedAt: hasUnresolvedCleanup ? event.completedAt : new Date().toISOString(),\n      error: hasUnresolvedCleanup ? event.error : null,\n      status: hasUnresolvedCleanup ? 'cleanupFailed' : 'succeeded',\n    },\n    overrideAccess: true,\n    req,\n  })\n}\n\n/**\n * Retries only the source cleanup recorded by a committed merge event.\n *\n * The target write is already durable. Replaying it would run hooks and create\n * versions again, so cleanup uses the stored source row identity and revision.\n * A changed source row belongs to newer branch work and is left for the normal\n * merge path.\n */\nexport const retryFailedCleanups = async ({\n  branch,\n  payload,\n  req,\n  selected,\n}: {\n  branch: string\n  payload: Payload\n  req: PayloadRequest\n  selected?: (number | string)[]\n}): Promise<{ handledChangeIDs: Set<string>; retried: MergeableChange[] }> => {\n  const candidates = await findRetryableCleanupCandidates({ branch, payload, req, selected })\n  const handledChangeIDs = new Set<string>()\n  const retried: MergeableChange[] = []\n\n  for (const { change, event } of candidates) {\n    const canRetryGlobal = Boolean(change.globalSlug && change.sourceRevision)\n    const canRetryCreatedCollection = Boolean(\n      change.collectionSlug &&\n        change.operation === 'create' &&\n        change.sourceID &&\n        change.sourceVersionIDs,\n    )\n\n    event.changes = updateMergeEventChange({\n      changeID: change.changeID,\n      changes: event.changes ?? [],\n      update: { cleanupError: undefined, cleanupOutcome: 'pending' },\n    })\n    await persistRetriedMergeEvent({ event, payload, req })\n\n    try {\n      let isSuperseded = false\n\n      if (canRetryGlobal) {\n        const currentSourceStates = await readSerializedGlobalSourceStates({\n          branch,\n          globalSlug: change.globalSlug!,\n          payload,\n          req,\n        })\n\n        isSuperseded =\n          currentSourceStates.length > 0 &&\n          getGlobalSourceRevision({ sourceStates: currentSourceStates }) !== change.sourceRevision\n\n        if (!isSuperseded) {\n          await deleteBranchGlobalVersionChain({\n            branch,\n            globalSlug: change.globalSlug!,\n            payload,\n            req,\n          })\n          await payload.db.deleteBranchGlobal?.({\n            branch,\n            globalSlug: change.globalSlug!,\n            req,\n          })\n        }\n      } else if (canRetryCreatedCollection) {\n        const newerSource = await payload.db.findOne({\n          branch: false,\n          collection: change.collectionSlug!,\n          req,\n          where: {\n            and: [\n              { [branchField]: { equals: branch } },\n              { [branchDocIDField]: { equals: change.targetID } },\n            ],\n          },\n        })\n\n        isSuperseded = Boolean(newerSource)\n\n        if (!isSuperseded) {\n          await deleteVersionsByID({\n            collectionSlug: change.collectionSlug!,\n            ids: change.sourceVersionIDs!,\n            payload,\n            req,\n          })\n\n          const collection = payload.collections[change.collectionSlug!]!.config\n          const maxVersions = getVersionsMax(collection)\n\n          if (maxVersions > 0) {\n            await enforceMaxVersions({\n              id: change.sourceID!,\n              collection,\n              max: maxVersions,\n              payload,\n              req,\n            })\n          }\n        }\n      } else {\n        const source = (await payload.db.findOne({\n          branch: false,\n          collection: change.collectionSlug!,\n          req,\n          where: { id: { equals: change.sourceID! } },\n        })) as null | Record<string, unknown>\n        const currentSourceUpdatedAt = getTimestamp({ value: source?.updatedAt })\n        const mergedSourceUpdatedAt = getTimestamp({ value: change.sourceUpdatedAt })\n\n        isSuperseded = Boolean(\n          source &&\n            currentSourceUpdatedAt !== undefined &&\n            mergedSourceUpdatedAt !== undefined &&\n            currentSourceUpdatedAt !== mergedSourceUpdatedAt,\n        )\n\n        if (!isSuperseded && source) {\n          await deleteBranchVersionChain({\n            branch,\n            collectionSlug: change.collectionSlug!,\n            payload,\n            req,\n            rowID: change.sourceID!,\n          })\n          await payload.db.deleteOne({\n            branch: false,\n            collection: change.collectionSlug!,\n            req,\n            where: { id: { equals: change.sourceID! } },\n          })\n        }\n      }\n\n      if (isSuperseded) {\n        event.changes = updateMergeEventChange({\n          changeID: change.changeID,\n          changes: event.changes,\n          update: { cleanupOutcome: 'superseded' },\n        })\n        await persistRetriedMergeEvent({ event, payload, req })\n        handledChangeIDs.add(change.changeID)\n        continue\n      }\n\n      const changeRecord = await payload.db.findOne({\n        collection: branchChangesCollectionSlug,\n        req,\n        where: { id: { equals: change.changeID } },\n      })\n\n      if (changeRecord) {\n        await payload.delete({\n          id: change.changeID,\n          collection: branchChangesCollectionSlug,\n          overrideAccess: true,\n          req,\n        })\n      }\n\n      event.changes = updateMergeEventChange({\n        changeID: change.changeID,\n        changes: event.changes,\n        update: { cleanupOutcome: 'completed' },\n      })\n      await persistRetriedMergeEvent({ event, payload, req })\n\n      const mergeableChange = toMergeableChange({ change })\n\n      if (mergeableChange) {\n        retried.push(mergeableChange)\n      }\n      handledChangeIDs.add(change.changeID)\n    } catch (error) {\n      const cleanupError = getMergeErrorMessage({ error })\n\n      event.changes = updateMergeEventChange({\n        changeID: change.changeID,\n        changes: event.changes,\n        update: { cleanupError, cleanupOutcome: 'failed' },\n      })\n      event.error = cleanupError\n      await persistRetriedMergeEvent({ event, payload, req })\n\n      throw error\n    }\n  }\n\n  return { handledChangeIDs, retried }\n}\n"],"names":["getVersionsMax","enforceMaxVersions","branchChangesCollectionSlug","branchDocIDField","branchField","branchMergesCollectionSlug","deleteBranchGlobalVersionChain","deleteBranchVersionChain","deleteVersionsByID","getGlobalSourceRevision","getMergeErrorMessage","getTimestamp","readSerializedGlobalSourceStates","updateMergeEventChange","changeID","changes","update","map","change","String","toMergeableChange","globalSlug","entityType","operation","collectionSlug","docID","undefined","findRetryableCleanupCandidates","branch","payload","req","selected","failedEvents","find","collection","depth","overrideAccess","pagination","sort","where","and","equals","status","selectedChangeIDs","Set","candidateChangeIDs","candidates","eventDocument","docs","event","canRetryCollection","Boolean","sourceID","sourceUpdatedAt","canRetryGlobal","sourceRevision","canRetryCreatedCollection","sourceVersionIDs","has","applicationOutcome","cleanupOutcome","add","push","inspectFailedCleanups","retryable","flatMap","mergeableChange","handledChangeIDs","persistRetriedMergeEvent","hasUnresolvedCleanup","some","includes","id","data","completedAt","Date","toISOString","error","retryFailedCleanups","retried","cleanupError","isSuperseded","currentSourceStates","length","sourceStates","db","deleteBranchGlobal","newerSource","findOne","targetID","ids","collections","config","maxVersions","max","source","currentSourceUpdatedAt","value","updatedAt","mergedSourceUpdatedAt","rowID","deleteOne","changeRecord","delete"],"mappings":"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"}

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

@@ -0,0 +1,35 @@
+import type { Payload, PayloadRequest } from '../../types/index.js';
+export type SourceCleanupOutcome = 'completed' | 'superseded';
+export type SourceRecoveryOutcome = 'deleted' | 'restored';
+export type AppliedChangeResult = {
+    cleanup: () => Promise<SourceCleanupOutcome>;
+    recover?: () => Promise<SourceRecoveryOutcome>;
+    sourceID?: string;
+    sourceRevision?: string;
+    sourceUpdatedAt?: string;
+    sourceVersionIDs?: (number | string)[];
+};
+export type SerializedGlobalSourceState = {
+    data: string;
+    draft: boolean;
+    locale: string;
+};
+export declare const changeDocID: ({ doc }: {
+    doc?: unknown;
+}) => number | string;
+export declare const getMergeErrorMessage: ({ error }: {
+    error: unknown;
+}) => string;
+export declare const getTimestamp: ({ value }: {
+    value: unknown;
+}) => number | undefined;
+export declare const getGlobalSourceRevision: ({ sourceStates, }: {
+    sourceStates: SerializedGlobalSourceState[];
+}) => string;
+export declare const readSerializedGlobalSourceStates: ({ branch, globalSlug, payload, req, }: {
+    branch: string;
+    globalSlug: string;
+    payload: Payload;
+    req: PayloadRequest;
+}) => Promise<SerializedGlobalSourceState[]>;
+//# sourceMappingURL=utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../src/branching/merge/utilities.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AASnE,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG,YAAY,CAAA;AAC7D,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,UAAU,CAAA;AAE1D,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,MAAM,OAAO,CAAC,oBAAoB,CAAC,CAAA;IAC5C,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,qBAAqB,CAAC,CAAA;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,gBAAgB,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;CACvC,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,WAAW,YAAa;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,KAAG,MAAM,GAAG,MACD,CAAA;AAEjE,eAAO,MAAM,oBAAoB,cAAe;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,KAAG,MACb,CAAA;AAExD,eAAO,MAAM,YAAY,cAAe;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,KAAG,MAAM,GAAG,SAYrE,CAAA;AAED,eAAO,MAAM,uBAAuB,sBAEjC;IACD,YAAY,EAAE,2BAA2B,EAAE,CAAA;CAC5C,KAAG,MAAiF,CAAA;AAErF,eAAO,MAAM,gCAAgC,0CAK1C;IACD,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,2BAA2B,EAAE,CAuBxC,CAAA"}

package/dist/branching/merge/utilities.js

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import { extractRelationshipID } from '../../utilities/extractRelationshipID.js';
+import { getGlobalMergeLocales, readBranchGlobalWrite, resolveGlobalMergeWrites } from '../globalMergeWrites.js';
+export const changeDocID = ({ doc })=>extractRelationshipID({
+        relationship: doc
+    });
+export const getMergeErrorMessage = ({ error })=>error instanceof Error ? error.message : String(error);
+export const getTimestamp = ({ value })=>{
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        return undefined;
+    }
+    const timestamp = new Date(value).getTime();
+    return Number.isNaN(timestamp) ? undefined : timestamp;
+};
+export const getGlobalSourceRevision = ({ sourceStates })=>createHash('sha256').update(JSON.stringify(sourceStates)).digest('hex');
+export const readSerializedGlobalSourceStates = async ({ branch, globalSlug, payload, req })=>{
+    const writes = await resolveGlobalMergeWrites({
+        branch,
+        globalSlug,
+        payload,
+        req
+    });
+    const locales = getGlobalMergeLocales({
+        globalSlug,
+        payload,
+        req
+    });
+    const sourceStates = [];
+    for (const write of writes){
+        for (const locale of locales){
+            const data = await readBranchGlobalWrite({
+                branch,
+                draft: write.draft,
+                globalSlug,
+                locale,
+                payload,
+                req
+            });
+            if (data) {
+                sourceStates.push({
+                    data: JSON.stringify(data),
+                    draft: write.draft,
+                    locale
+                });
+            }
+        }
+    }
+    return sourceStates;
+};
+
+//# sourceMappingURL=utilities.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/merge/utilities.ts"],"sourcesContent":["import { createHash } from 'node:crypto'\n\nimport type { Payload, PayloadRequest } from '../../types/index.js'\n\nimport { extractRelationshipID } from '../../utilities/extractRelationshipID.js'\nimport {\n  getGlobalMergeLocales,\n  readBranchGlobalWrite,\n  resolveGlobalMergeWrites,\n} from '../globalMergeWrites.js'\n\nexport type SourceCleanupOutcome = 'completed' | 'superseded'\nexport type SourceRecoveryOutcome = 'deleted' | 'restored'\n\nexport type AppliedChangeResult = {\n  cleanup: () => Promise<SourceCleanupOutcome>\n  recover?: () => Promise<SourceRecoveryOutcome>\n  sourceID?: string\n  sourceRevision?: string\n  sourceUpdatedAt?: string\n  sourceVersionIDs?: (number | string)[]\n}\n\nexport type SerializedGlobalSourceState = {\n  data: string\n  draft: boolean\n  locale: string\n}\n\nexport const changeDocID = ({ doc }: { doc?: unknown }): number | string =>\n  extractRelationshipID({ relationship: doc }) as number | string\n\nexport const getMergeErrorMessage = ({ error }: { error: unknown }): string =>\n  error instanceof Error ? error.message : String(error)\n\nexport const getTimestamp = ({ value }: { value: unknown }): number | undefined => {\n  if (value instanceof Date) {\n    return value.getTime()\n  }\n\n  if (typeof value !== 'number' && typeof value !== 'string') {\n    return undefined\n  }\n\n  const timestamp = new Date(value).getTime()\n\n  return Number.isNaN(timestamp) ? undefined : timestamp\n}\n\nexport const getGlobalSourceRevision = ({\n  sourceStates,\n}: {\n  sourceStates: SerializedGlobalSourceState[]\n}): string => createHash('sha256').update(JSON.stringify(sourceStates)).digest('hex')\n\nexport const readSerializedGlobalSourceStates = async ({\n  branch,\n  globalSlug,\n  payload,\n  req,\n}: {\n  branch: string\n  globalSlug: string\n  payload: Payload\n  req: PayloadRequest\n}): Promise<SerializedGlobalSourceState[]> => {\n  const writes = await resolveGlobalMergeWrites({ branch, globalSlug, payload, req })\n  const locales = getGlobalMergeLocales({ globalSlug, payload, req })\n  const sourceStates: SerializedGlobalSourceState[] = []\n\n  for (const write of writes) {\n    for (const locale of locales) {\n      const data = await readBranchGlobalWrite({\n        branch,\n        draft: write.draft,\n        globalSlug,\n        locale,\n        payload,\n        req,\n      })\n\n      if (data) {\n        sourceStates.push({ data: JSON.stringify(data), draft: write.draft, locale })\n      }\n    }\n  }\n\n  return sourceStates\n}\n"],"names":["createHash","extractRelationshipID","getGlobalMergeLocales","readBranchGlobalWrite","resolveGlobalMergeWrites","changeDocID","doc","relationship","getMergeErrorMessage","error","Error","message","String","getTimestamp","value","Date","getTime","undefined","timestamp","Number","isNaN","getGlobalSourceRevision","sourceStates","update","JSON","stringify","digest","readSerializedGlobalSourceStates","branch","globalSlug","payload","req","writes","locales","write","locale","data","draft","push"],"mappings":"AAAA,SAASA,UAAU,QAAQ,cAAa;AAIxC,SAASC,qBAAqB,QAAQ,2CAA0C;AAChF,SACEC,qBAAqB,EACrBC,qBAAqB,EACrBC,wBAAwB,QACnB,0BAAyB;AAoBhC,OAAO,MAAMC,cAAc,CAAC,EAAEC,GAAG,EAAqB,GACpDL,sBAAsB;QAAEM,cAAcD;IAAI,GAAqB;AAEjE,OAAO,MAAME,uBAAuB,CAAC,EAAEC,KAAK,EAAsB,GAChEA,iBAAiBC,QAAQD,MAAME,OAAO,GAAGC,OAAOH,OAAM;AAExD,OAAO,MAAMI,eAAe,CAAC,EAAEC,KAAK,EAAsB;IACxD,IAAIA,iBAAiBC,MAAM;QACzB,OAAOD,MAAME,OAAO;IACtB;IAEA,IAAI,OAAOF,UAAU,YAAY,OAAOA,UAAU,UAAU;QAC1D,OAAOG;IACT;IAEA,MAAMC,YAAY,IAAIH,KAAKD,OAAOE,OAAO;IAEzC,OAAOG,OAAOC,KAAK,CAACF,aAAaD,YAAYC;AAC/C,EAAC;AAED,OAAO,MAAMG,0BAA0B,CAAC,EACtCC,YAAY,EAGb,GAAatB,WAAW,UAAUuB,MAAM,CAACC,KAAKC,SAAS,CAACH,eAAeI,MAAM,CAAC,OAAM;AAErF,OAAO,MAAMC,mCAAmC,OAAO,EACrDC,MAAM,EACNC,UAAU,EACVC,OAAO,EACPC,GAAG,EAMJ;IACC,MAAMC,SAAS,MAAM5B,yBAAyB;QAAEwB;QAAQC;QAAYC;QAASC;IAAI;IACjF,MAAME,UAAU/B,sBAAsB;QAAE2B;QAAYC;QAASC;IAAI;IACjE,MAAMT,eAA8C,EAAE;IAEtD,KAAK,MAAMY,SAASF,OAAQ;QAC1B,KAAK,MAAMG,UAAUF,QAAS;YAC5B,MAAMG,OAAO,MAAMjC,sBAAsB;gBACvCyB;gBACAS,OAAOH,MAAMG,KAAK;gBAClBR;gBACAM;gBACAL;gBACAC;YACF;YAEA,IAAIK,MAAM;gBACRd,aAAagB,IAAI,CAAC;oBAAEF,MAAMZ,KAAKC,SAAS,CAACW;oBAAOC,OAAOH,MAAMG,KAAK;oBAAEF;gBAAO;YAC7E;QACF;IACF;IAEA,OAAOb;AACT,EAAC"}

package/dist/branching/merge.d.ts

@@ -0,0 +1,88 @@
+import type { Payload, PayloadRequest } from '../types/index.js';
+import type { DiscardOptions } from './discard.js';
+import type { BlockedChange } from './preflight.js';
+import type { MergeableChange, MergeProgress, MergeWarning } from './types.js';
+import type { BranchMergeValidationError } from './validation.js';
+export type MergeResult = {
+    /** Changes that cannot be applied because of access or an unavailable dependency. */
+    blocked: BlockedChange[];
+    /** True when at least one selected change can be applied. */
+    canMerge: boolean;
+    mergeable: MergeableChange[];
+    merged: MergeableChange[];
+    validationErrors: BranchMergeValidationError[];
+    warnings: MergeWarning[];
+};
+/**
+ * Emitted once per change, immediately before it is applied.
+ *
+ * A merge is a sequential loop over an arbitrary number of documents, so it is
+ * the one Payload operation where "what is it doing right now" is a real
+ * question. Reported by callback rather than persisted: the caller decides
+ * whether that means a streamed HTTP response, a log line, or nothing.
+ */
+export type MergeOptions = {
+    branch: string;
+    /** Change IDs to apply. Omit to apply every pending change. */
+    changes?: (number | string)[];
+    /**
+     * Close the branch once everything it held has been applied.
+     *
+     * Closing is terminal: a closed branch rejects writes and cannot be merged
+     * again. Offered as a choice at merge time rather than implied by merging,
+     * because "merge and keep working" and "merge and be done" are both ordinary
+     * intents and only the author knows which one this is. Ignored when changes are
+     * left behind — a branch with pending work is not finished by definition.
+     *
+     * @default false
+     */
+    closeBranch?: boolean;
+    /** Report what would happen without writing anything. */
+    dryRun?: boolean;
+    /**
+     * Called before each change is applied. Awaited, so a slow consumer throttles
+     * the merge rather than falling behind it.
+     */
+    onProgress?: (progress: MergeProgress, req: PayloadRequest) => Promise<void> | void;
+    /**
+     * Skip the per-document permission checks.
+     *
+     * HTTP callers must pass `false` together with `user`: branch writes are
+     * deliberately permissive on the assumption that nothing is real until
+     * merge.
+     *
+     * @default false
+     */
+    overrideAccess?: boolean;
+    req?: PayloadRequest;
+    /**
+     * The user whose production permissions the merge is checked against.
+     * Defaults to `req.user`.
+     */
+    user?: NonNullable<PayloadRequest['user']>;
+};
+/**
+ * Applies a branch's changes to `main`.
+ *
+ * Branch data wins outright — there is no field-level reconciliation. What
+ * replaces conflict resolution is selection: callers choose which changes to
+ * apply, and anything left behind keeps the branch open.
+ *
+ * Every write runs through the ordinary Local API so that all document hooks,
+ * validation and version creation behave exactly as they would for a hand-made
+ * edit on main.
+ */
+export declare const mergeBranch: (payload: Payload, { branch, changes: selected, closeBranch, dryRun, onProgress, overrideAccess, req: incomingReq, user, }: MergeOptions) => Promise<MergeResult>;
+/**
+ * A branch document's data, ready to be written onto main's row.
+ *
+ * Array and block rows carry primary keys belonging to the branch's copy, and writing them
+ * onto main's row collides with the rows the branch's copy still owns. Passing an empty
+ * `existingDoc` drops every nested key so the write mints its own — which is what
+ * `copyDataWithFreshRowIDs` is for, and why the bulk update path already calls it.
+ */
+export declare const getBranchesLocalAPI: (payload: Payload) => {
+    discard: (options: DiscardOptions) => Promise<import("./discard.js").DiscardResult>;
+    merge: (options: MergeOptions) => Promise<MergeResult>;
+};
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/branching/merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAA;AAWjE,MAAM,MAAM,WAAW,GAAG;IACxB,qFAAqF;IACrF,OAAO,EAAE,aAAa,EAAE,CAAA;IACxB,6DAA6D;IAC7D,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,eAAe,EAAE,CAAA;IAC5B,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,gBAAgB,EAAE,0BAA0B,EAAE,CAAA;IAC9C,QAAQ,EAAE,YAAY,EAAE,CAAA;CACzB,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,+DAA+D;IAC/D,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IAC7B;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,yDAAyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACnF;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAA;CAC3C,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,YACb,OAAO,2GAUb,YAAY,KACd,OAAO,CAAC,WAAW,CAgIrB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,YAAa,OAAO;IAClD,OAAO,YAAY,cAAc;IACjC,KAAK,YAAY,YAAY;CAC7B,CAAA"}