payload 4.0.0-internal.ea6e8f8 → 4.0.0-internal.ee5d8bd

package/dist/branching/merge/retryFailedCleanups.js

@@ -1,335 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,35 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,54 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,88 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}