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

package/dist/branching/merge.js

@@ -0,0 +1,163 @@
+import { assertBranchUpdateAccess } from './assertBranchUpdateAccess.js';
+import { discardBranchChanges } from './discard.js';
+import { beginBranchMerge, restoreBranchAfterMerge } from './merge/branchMergeStatus.js';
+import { executeMerge, unknownMergeCommitResultContextKey } from './merge/executeMerge.js';
+import { prepareMerge, revalidatePreparedMerge } from './merge/prepareMerge.js';
+import { retryFailedCleanups } from './merge/retryFailedCleanups.js';
+import { refreshBranchState } from './resolveBranch.js';
+import { branchChangesCollectionSlug, branchesCollectionSlug } from './types.js';
+/**
+ * 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 const mergeBranch = async (payload, { branch, changes: selected, closeBranch = false, dryRun = false, onProgress, overrideAccess = false, req: incomingReq, user })=>{
+    const prepared = await prepareMerge({
+        branch,
+        dryRun,
+        incomingReq,
+        overrideAccess,
+        payload,
+        selected,
+        user
+    });
+    const { applicable, applicableGlobals, branchDoc, mergeable, req, result, retryableCleanups } = prepared;
+    const hasChangesToApply = applicable.length > 0 || applicableGlobals.length > 0 || retryableCleanups.length > 0;
+    if (closeBranch && !dryRun && !overrideAccess) {
+        await assertBranchUpdateAccess({
+            branchDoc,
+            req
+        });
+    }
+    if (dryRun || !hasChangesToApply) {
+        return result;
+    }
+    await beginBranchMerge({
+        branchDocID: branchDoc.id,
+        payload,
+        req
+    });
+    try {
+        if (retryableCleanups.length) {
+            const cleanupRetry = await retryFailedCleanups({
+                branch,
+                payload,
+                req,
+                selected
+            });
+            const retryableChangeIDs = new Set(retryableCleanups.map(({ changeID })=>String(changeID)));
+            const retriedChangeIDs = new Set(cleanupRetry.retried.map(({ changeID })=>String(changeID)));
+            const currentMergeable = mergeable.filter(({ changeID })=>!retryableChangeIDs.has(String(changeID)) || retriedChangeIDs.has(String(changeID)));
+            mergeable.splice(0, mergeable.length, ...currentMergeable);
+            result.canMerge = mergeable.length > 0;
+            result.mergeable = mergeable;
+            result.merged.push(...cleanupRetry.retried);
+            if (applicable.length === 0 && applicableGlobals.length === 0) {
+                const remaining = await payload.count({
+                    collection: branchChangesCollectionSlug,
+                    overrideAccess: true,
+                    req,
+                    where: {
+                        branch: {
+                            equals: branch
+                        }
+                    }
+                });
+                const mergedAt = new Date().toISOString();
+                await payload.update({
+                    id: branchDoc.id,
+                    collection: branchesCollectionSlug,
+                    data: remaining.totalDocs === 0 ? {
+                        mergedAt,
+                        status: closeBranch ? 'closed' : 'merged'
+                    } : {
+                        mergedAt: null,
+                        status: 'open'
+                    },
+                    overrideAccess: true,
+                    req
+                });
+                if (incomingReq) {
+                    refreshBranchState(incomingReq);
+                }
+                return result;
+            }
+        }
+        await payload.config.branching?.hooks?.beforeMerge?.({
+            branch,
+            changes: mergeable,
+            req,
+            warnings: result.warnings
+        });
+        const revalidation = await revalidatePreparedMerge({
+            applicable,
+            applicableGlobals,
+            branch,
+            overrideAccess,
+            payload,
+            req
+        });
+        if (!revalidation.isValid) {
+            result.blocked = revalidation.blocked;
+            result.canMerge = false;
+            result.mergeable = [];
+            result.validationErrors = revalidation.validationErrors;
+            await restoreBranchAfterMerge({
+                branchDocID: branchDoc.id,
+                payload,
+                req
+            });
+            return result;
+        }
+        return await executeMerge({
+            applicable,
+            applicableGlobals,
+            branch,
+            branchDoc,
+            closeBranch,
+            incomingReq,
+            mergeable,
+            onProgress,
+            overrideAccess,
+            payload,
+            req,
+            result
+        });
+    } catch (error) {
+        const isCommitResultUnknown = req.context[unknownMergeCommitResultContextKey] === true;
+        delete req.context[unknownMergeCommitResultContextKey];
+        if (!isCommitResultUnknown) {
+            try {
+                await restoreBranchAfterMerge({
+                    branchDocID: branchDoc.id,
+                    payload,
+                    req
+                });
+            } catch (restoreError) {
+                payload.logger.error({
+                    err: restoreError,
+                    msg: `Failed to restore branch "${branch}" after a merge error`
+                });
+            }
+        }
+        throw error;
+    }
+};
+/**
+ * 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 const getBranchesLocalAPI = (payload)=>({
+        discard: (options)=>discardBranchChanges(payload, options),
+        merge: (options)=>mergeBranch(payload, options)
+    });
+
+//# sourceMappingURL=merge.js.map

package/dist/branching/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/merge.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from '../types/index.js'\nimport type { DiscardOptions } from './discard.js'\nimport type { BlockedChange } from './preflight.js'\nimport type { MergeableChange, MergeProgress, MergeWarning } from './types.js'\nimport type { BranchMergeValidationError } from './validation.js'\n\nimport { assertBranchUpdateAccess } from './assertBranchUpdateAccess.js'\nimport { discardBranchChanges } from './discard.js'\nimport { beginBranchMerge, restoreBranchAfterMerge } from './merge/branchMergeStatus.js'\nimport { executeMerge, unknownMergeCommitResultContextKey } from './merge/executeMerge.js'\nimport { prepareMerge, revalidatePreparedMerge } from './merge/prepareMerge.js'\nimport { retryFailedCleanups } from './merge/retryFailedCleanups.js'\nimport { refreshBranchState } from './resolveBranch.js'\nimport { branchChangesCollectionSlug, branchesCollectionSlug } from './types.js'\n\nexport type MergeResult = {\n  /** Changes that cannot be applied because of access or an unavailable dependency. */\n  blocked: BlockedChange[]\n  /** True when at least one selected change can be applied. */\n  canMerge: boolean\n  mergeable: MergeableChange[]\n  merged: MergeableChange[]\n  validationErrors: BranchMergeValidationError[]\n  warnings: MergeWarning[]\n}\n\n/**\n * Emitted once per change, immediately before it is applied.\n *\n * A merge is a sequential loop over an arbitrary number of documents, so it is\n * the one Payload operation where \"what is it doing right now\" is a real\n * question. Reported by callback rather than persisted: the caller decides\n * whether that means a streamed HTTP response, a log line, or nothing.\n */\nexport type MergeOptions = {\n  branch: string\n  /** Change IDs to apply. Omit to apply every pending change. */\n  changes?: (number | string)[]\n  /**\n   * Close the branch once everything it held has been applied.\n   *\n   * Closing is terminal: a closed branch rejects writes and cannot be merged\n   * again. Offered as a choice at merge time rather than implied by merging,\n   * because \"merge and keep working\" and \"merge and be done\" are both ordinary\n   * intents and only the author knows which one this is. Ignored when changes are\n   * left behind — a branch with pending work is not finished by definition.\n   *\n   * @default false\n   */\n  closeBranch?: boolean\n  /** Report what would happen without writing anything. */\n  dryRun?: boolean\n  /**\n   * Called before each change is applied. Awaited, so a slow consumer throttles\n   * the merge rather than falling behind it.\n   */\n  onProgress?: (progress: MergeProgress, req: PayloadRequest) => Promise<void> | void\n  /**\n   * Skip the per-document permission checks.\n   *\n   * HTTP callers must pass `false` together with `user`: branch writes are\n   * deliberately permissive on the assumption that nothing is real until\n   * merge.\n   *\n   * @default false\n   */\n  overrideAccess?: boolean\n  req?: PayloadRequest\n  /**\n   * The user whose production permissions the merge is checked against.\n   * Defaults to `req.user`.\n   */\n  user?: NonNullable<PayloadRequest['user']>\n}\n\n/**\n * Applies a branch's changes to `main`.\n *\n * Branch data wins outright — there is no field-level reconciliation. What\n * replaces conflict resolution is selection: callers choose which changes to\n * apply, and anything left behind keeps the branch open.\n *\n * Every write runs through the ordinary Local API so that all document hooks,\n * validation and version creation behave exactly as they would for a hand-made\n * edit on main.\n */\nexport const mergeBranch = async (\n  payload: Payload,\n  {\n    branch,\n    changes: selected,\n    closeBranch = false,\n    dryRun = false,\n    onProgress,\n    overrideAccess = false,\n    req: incomingReq,\n    user,\n  }: MergeOptions,\n): Promise<MergeResult> => {\n  const prepared = await prepareMerge({\n    branch,\n    dryRun,\n    incomingReq,\n    overrideAccess,\n    payload,\n    selected,\n    user,\n  })\n  const { applicable, applicableGlobals, branchDoc, mergeable, req, result, retryableCleanups } =\n    prepared\n  const hasChangesToApply =\n    applicable.length > 0 || applicableGlobals.length > 0 || retryableCleanups.length > 0\n\n  if (closeBranch && !dryRun && !overrideAccess) {\n    await assertBranchUpdateAccess({ branchDoc, req })\n  }\n\n  if (dryRun || !hasChangesToApply) {\n    return result\n  }\n\n  await beginBranchMerge({ branchDocID: branchDoc.id, payload, req })\n\n  try {\n    if (retryableCleanups.length) {\n      const cleanupRetry = await retryFailedCleanups({ branch, payload, req, selected })\n      const retryableChangeIDs = new Set(retryableCleanups.map(({ changeID }) => String(changeID)))\n      const retriedChangeIDs = new Set(cleanupRetry.retried.map(({ changeID }) => String(changeID)))\n      const currentMergeable = mergeable.filter(\n        ({ changeID }) =>\n          !retryableChangeIDs.has(String(changeID)) || retriedChangeIDs.has(String(changeID)),\n      )\n\n      mergeable.splice(0, mergeable.length, ...currentMergeable)\n      result.canMerge = mergeable.length > 0\n      result.mergeable = mergeable\n      result.merged.push(...cleanupRetry.retried)\n\n      if (applicable.length === 0 && applicableGlobals.length === 0) {\n        const remaining = await payload.count({\n          collection: branchChangesCollectionSlug,\n          overrideAccess: true,\n          req,\n          where: { branch: { equals: branch } },\n        })\n        const mergedAt = new Date().toISOString()\n\n        await payload.update({\n          id: branchDoc.id,\n          collection: branchesCollectionSlug,\n          data:\n            remaining.totalDocs === 0\n              ? { mergedAt, status: closeBranch ? 'closed' : 'merged' }\n              : { mergedAt: null, status: 'open' },\n          overrideAccess: true,\n          req,\n        })\n\n        if (incomingReq) {\n          refreshBranchState(incomingReq)\n        }\n\n        return result\n      }\n    }\n\n    await payload.config.branching?.hooks?.beforeMerge?.({\n      branch,\n      changes: mergeable,\n      req,\n      warnings: result.warnings,\n    })\n\n    const revalidation = await revalidatePreparedMerge({\n      applicable,\n      applicableGlobals,\n      branch,\n      overrideAccess,\n      payload,\n      req,\n    })\n\n    if (!revalidation.isValid) {\n      result.blocked = revalidation.blocked\n      result.canMerge = false\n      result.mergeable = []\n      result.validationErrors = revalidation.validationErrors\n\n      await restoreBranchAfterMerge({ branchDocID: branchDoc.id, payload, req })\n\n      return result\n    }\n\n    return await executeMerge({\n      applicable,\n      applicableGlobals,\n      branch,\n      branchDoc,\n      closeBranch,\n      incomingReq,\n      mergeable,\n      onProgress,\n      overrideAccess,\n      payload,\n      req,\n      result,\n    })\n  } catch (error) {\n    const isCommitResultUnknown =\n      (req.context as Record<PropertyKey, unknown>)[unknownMergeCommitResultContextKey] === true\n\n    delete (req.context as Record<PropertyKey, unknown>)[unknownMergeCommitResultContextKey]\n\n    if (!isCommitResultUnknown) {\n      try {\n        await restoreBranchAfterMerge({ branchDocID: branchDoc.id, payload, req })\n      } catch (restoreError) {\n        payload.logger.error({\n          err: restoreError,\n          msg: `Failed to restore branch \"${branch}\" after a merge error`,\n        })\n      }\n    }\n\n    throw error\n  }\n}\n\n/**\n * A branch document's data, ready to be written onto main's row.\n *\n * Array and block rows carry primary keys belonging to the branch's copy, and writing them\n * onto main's row collides with the rows the branch's copy still owns. Passing an empty\n * `existingDoc` drops every nested key so the write mints its own — which is what\n * `copyDataWithFreshRowIDs` is for, and why the bulk update path already calls it.\n */\nexport const getBranchesLocalAPI = (payload: Payload) => ({\n  discard: (options: DiscardOptions) => discardBranchChanges(payload, options),\n  merge: (options: MergeOptions) => mergeBranch(payload, options),\n})\n"],"names":["assertBranchUpdateAccess","discardBranchChanges","beginBranchMerge","restoreBranchAfterMerge","executeMerge","unknownMergeCommitResultContextKey","prepareMerge","revalidatePreparedMerge","retryFailedCleanups","refreshBranchState","branchChangesCollectionSlug","branchesCollectionSlug","mergeBranch","payload","branch","changes","selected","closeBranch","dryRun","onProgress","overrideAccess","req","incomingReq","user","prepared","applicable","applicableGlobals","branchDoc","mergeable","result","retryableCleanups","hasChangesToApply","length","branchDocID","id","cleanupRetry","retryableChangeIDs","Set","map","changeID","String","retriedChangeIDs","retried","currentMergeable","filter","has","splice","canMerge","merged","push","remaining","count","collection","where","equals","mergedAt","Date","toISOString","update","data","totalDocs","status","config","branching","hooks","beforeMerge","warnings","revalidation","isValid","blocked","validationErrors","error","isCommitResultUnknown","context","restoreError","logger","err","msg","getBranchesLocalAPI","discard","options","merge"],"mappings":"AAMA,SAASA,wBAAwB,QAAQ,gCAA+B;AACxE,SAASC,oBAAoB,QAAQ,eAAc;AACnD,SAASC,gBAAgB,EAAEC,uBAAuB,QAAQ,+BAA8B;AACxF,SAASC,YAAY,EAAEC,kCAAkC,QAAQ,0BAAyB;AAC1F,SAASC,YAAY,EAAEC,uBAAuB,QAAQ,0BAAyB;AAC/E,SAASC,mBAAmB,QAAQ,iCAAgC;AACpE,SAASC,kBAAkB,QAAQ,qBAAoB;AACvD,SAASC,2BAA2B,EAAEC,sBAAsB,QAAQ,aAAY;AA8DhF;;;;;;;;;;CAUC,GACD,OAAO,MAAMC,cAAc,OACzBC,SACA,EACEC,MAAM,EACNC,SAASC,QAAQ,EACjBC,cAAc,KAAK,EACnBC,SAAS,KAAK,EACdC,UAAU,EACVC,iBAAiB,KAAK,EACtBC,KAAKC,WAAW,EAChBC,IAAI,EACS;IAEf,MAAMC,WAAW,MAAMlB,aAAa;QAClCQ;QACAI;QACAI;QACAF;QACAP;QACAG;QACAO;IACF;IACA,MAAM,EAAEE,UAAU,EAAEC,iBAAiB,EAAEC,SAAS,EAAEC,SAAS,EAAEP,GAAG,EAAEQ,MAAM,EAAEC,iBAAiB,EAAE,GAC3FN;IACF,MAAMO,oBACJN,WAAWO,MAAM,GAAG,KAAKN,kBAAkBM,MAAM,GAAG,KAAKF,kBAAkBE,MAAM,GAAG;IAEtF,IAAIf,eAAe,CAACC,UAAU,CAACE,gBAAgB;QAC7C,MAAMpB,yBAAyB;YAAE2B;YAAWN;QAAI;IAClD;IAEA,IAAIH,UAAU,CAACa,mBAAmB;QAChC,OAAOF;IACT;IAEA,MAAM3B,iBAAiB;QAAE+B,aAAaN,UAAUO,EAAE;QAAErB;QAASQ;IAAI;IAEjE,IAAI;QACF,IAAIS,kBAAkBE,MAAM,EAAE;YAC5B,MAAMG,eAAe,MAAM3B,oBAAoB;gBAAEM;gBAAQD;gBAASQ;gBAAKL;YAAS;YAChF,MAAMoB,qBAAqB,IAAIC,IAAIP,kBAAkBQ,GAAG,CAAC,CAAC,EAAEC,QAAQ,EAAE,GAAKC,OAAOD;YAClF,MAAME,mBAAmB,IAAIJ,IAAIF,aAAaO,OAAO,CAACJ,GAAG,CAAC,CAAC,EAAEC,QAAQ,EAAE,GAAKC,OAAOD;YACnF,MAAMI,mBAAmBf,UAAUgB,MAAM,CACvC,CAAC,EAAEL,QAAQ,EAAE,GACX,CAACH,mBAAmBS,GAAG,CAACL,OAAOD,cAAcE,iBAAiBI,GAAG,CAACL,OAAOD;YAG7EX,UAAUkB,MAAM,CAAC,GAAGlB,UAAUI,MAAM,KAAKW;YACzCd,OAAOkB,QAAQ,GAAGnB,UAAUI,MAAM,GAAG;YACrCH,OAAOD,SAAS,GAAGA;YACnBC,OAAOmB,MAAM,CAACC,IAAI,IAAId,aAAaO,OAAO;YAE1C,IAAIjB,WAAWO,MAAM,KAAK,KAAKN,kBAAkBM,MAAM,KAAK,GAAG;gBAC7D,MAAMkB,YAAY,MAAMrC,QAAQsC,KAAK,CAAC;oBACpCC,YAAY1C;oBACZU,gBAAgB;oBAChBC;oBACAgC,OAAO;wBAAEvC,QAAQ;4BAAEwC,QAAQxC;wBAAO;oBAAE;gBACtC;gBACA,MAAMyC,WAAW,IAAIC,OAAOC,WAAW;gBAEvC,MAAM5C,QAAQ6C,MAAM,CAAC;oBACnBxB,IAAIP,UAAUO,EAAE;oBAChBkB,YAAYzC;oBACZgD,MACET,UAAUU,SAAS,KAAK,IACpB;wBAAEL;wBAAUM,QAAQ5C,cAAc,WAAW;oBAAS,IACtD;wBAAEsC,UAAU;wBAAMM,QAAQ;oBAAO;oBACvCzC,gBAAgB;oBAChBC;gBACF;gBAEA,IAAIC,aAAa;oBACfb,mBAAmBa;gBACrB;gBAEA,OAAOO;YACT;QACF;QAEA,MAAMhB,QAAQiD,MAAM,CAACC,SAAS,EAAEC,OAAOC,cAAc;YACnDnD;YACAC,SAASa;YACTP;YACA6C,UAAUrC,OAAOqC,QAAQ;QAC3B;QAEA,MAAMC,eAAe,MAAM5D,wBAAwB;YACjDkB;YACAC;YACAZ;YACAM;YACAP;YACAQ;QACF;QAEA,IAAI,CAAC8C,aAAaC,OAAO,EAAE;YACzBvC,OAAOwC,OAAO,GAAGF,aAAaE,OAAO;YACrCxC,OAAOkB,QAAQ,GAAG;YAClBlB,OAAOD,SAAS,GAAG,EAAE;YACrBC,OAAOyC,gBAAgB,GAAGH,aAAaG,gBAAgB;YAEvD,MAAMnE,wBAAwB;gBAAE8B,aAAaN,UAAUO,EAAE;gBAAErB;gBAASQ;YAAI;YAExE,OAAOQ;QACT;QAEA,OAAO,MAAMzB,aAAa;YACxBqB;YACAC;YACAZ;YACAa;YACAV;YACAK;YACAM;YACAT;YACAC;YACAP;YACAQ;YACAQ;QACF;IACF,EAAE,OAAO0C,OAAO;QACd,MAAMC,wBACJ,AAACnD,IAAIoD,OAAO,AAAiC,CAACpE,mCAAmC,KAAK;QAExF,OAAO,AAACgB,IAAIoD,OAAO,AAAiC,CAACpE,mCAAmC;QAExF,IAAI,CAACmE,uBAAuB;YAC1B,IAAI;gBACF,MAAMrE,wBAAwB;oBAAE8B,aAAaN,UAAUO,EAAE;oBAAErB;oBAASQ;gBAAI;YAC1E,EAAE,OAAOqD,cAAc;gBACrB7D,QAAQ8D,MAAM,CAACJ,KAAK,CAAC;oBACnBK,KAAKF;oBACLG,KAAK,CAAC,0BAA0B,EAAE/D,OAAO,qBAAqB,CAAC;gBACjE;YACF;QACF;QAEA,MAAMyD;IACR;AACF,EAAC;AAED;;;;;;;CAOC,GACD,OAAO,MAAMO,sBAAsB,CAACjE,UAAsB,CAAA;QACxDkE,SAAS,CAACC,UAA4B/E,qBAAqBY,SAASmE;QACpEC,OAAO,CAACD,UAA0BpE,YAAYC,SAASmE;IACzD,CAAA,EAAE"}

package/dist/branching/mergeWriteGuard.d.ts

@@ -0,0 +1,20 @@
+import type { PayloadRequest } from '../types/index.js';
+export type BranchMergeWrite = {
+    collectionSlug?: string;
+    data: Record<string, unknown>;
+    globalSlug?: string;
+    req: PayloadRequest;
+};
+export type BranchMergeWriteGuard = (write: BranchMergeWrite) => Promise<void>;
+export declare const branchMergeValidationContextKey: unique symbol;
+export declare const branchMergeWriteGuardContextKey: unique symbol;
+/** Prevents content writes made through a branch merge validation request. */
+export declare const assertBranchMergeValidationWriteAllowed: ({ req, }: {
+    req?: Partial<PayloadRequest>;
+}) => void;
+export declare const isBranchMergeValidationRequest: ({ req, }: {
+    req?: Partial<PayloadRequest>;
+}) => boolean;
+/** Runs the active merge's final-data guard after hooks and field processing. */
+export declare const runBranchMergeWriteGuard: ({ collectionSlug, data, globalSlug, req, }: BranchMergeWrite) => Promise<void>;
+//# sourceMappingURL=mergeWriteGuard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeWriteGuard.d.ts","sourceRoot":"","sources":["../../src/branching/mergeWriteGuard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAMvD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE9E,eAAO,MAAM,+BAA+B,eAAkC,CAAA;AAC9E,eAAO,MAAM,+BAA+B,eAAkC,CAAA;AAE9E,8EAA8E;AAC9E,eAAO,MAAM,uCAAuC,aAEjD;IACD,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC9B,KAAG,IAIH,CAAA;AAED,eAAO,MAAM,8BAA8B,aAExC;IACD,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC9B,KAAG,OAGD,CAAA;AAEH,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,+CAKlC,gBAAgB,KAAG,OAAO,CAAC,IAAI,CAUjC,CAAA"}

package/dist/branching/mergeWriteGuard.js

@@ -0,0 +1,27 @@
+import { APIError } from '../errors/index.js';
+import { resolveBranch } from './resolveBranch.js';
+import { MAIN_BRANCH } from './types.js';
+export const branchMergeValidationContextKey = Symbol('branchMergeValidation');
+export const branchMergeWriteGuardContextKey = Symbol('branchMergeWriteGuard');
+/** Prevents content writes made through a branch merge validation request. */ export const assertBranchMergeValidationWriteAllowed = ({ req })=>{
+    if (isBranchMergeValidationRequest({
+        req
+    })) {
+        throw new APIError('Content cannot be changed during branch merge validation.', 409);
+    }
+};
+export const isBranchMergeValidationRequest = ({ req })=>Boolean(req?.context?.[branchMergeValidationContextKey]);
+/** Runs the active merge's final-data guard after hooks and field processing. */ export const runBranchMergeWriteGuard = async ({ collectionSlug, data, globalSlug, req })=>{
+    if (resolveBranch(req) !== MAIN_BRANCH) {
+        return;
+    }
+    const guard = req.context?.[branchMergeWriteGuardContextKey];
+    await guard?.({
+        collectionSlug,
+        data,
+        globalSlug,
+        req
+    });
+};
+
+//# sourceMappingURL=mergeWriteGuard.js.map

package/dist/branching/mergeWriteGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/mergeWriteGuard.ts"],"sourcesContent":["import type { PayloadRequest } from '../types/index.js'\n\nimport { APIError } from '../errors/index.js'\nimport { resolveBranch } from './resolveBranch.js'\nimport { MAIN_BRANCH } from './types.js'\n\nexport type BranchMergeWrite = {\n  collectionSlug?: string\n  data: Record<string, unknown>\n  globalSlug?: string\n  req: PayloadRequest\n}\n\nexport type BranchMergeWriteGuard = (write: BranchMergeWrite) => Promise<void>\n\nexport const branchMergeValidationContextKey = Symbol('branchMergeValidation')\nexport const branchMergeWriteGuardContextKey = Symbol('branchMergeWriteGuard')\n\n/** Prevents content writes made through a branch merge validation request. */\nexport const assertBranchMergeValidationWriteAllowed = ({\n  req,\n}: {\n  req?: Partial<PayloadRequest>\n}): void => {\n  if (isBranchMergeValidationRequest({ req })) {\n    throw new APIError('Content cannot be changed during branch merge validation.', 409)\n  }\n}\n\nexport const isBranchMergeValidationRequest = ({\n  req,\n}: {\n  req?: Partial<PayloadRequest>\n}): boolean =>\n  Boolean(\n    (req?.context as Record<PropertyKey, unknown> | undefined)?.[branchMergeValidationContextKey],\n  )\n\n/** Runs the active merge's final-data guard after hooks and field processing. */\nexport const runBranchMergeWriteGuard = async ({\n  collectionSlug,\n  data,\n  globalSlug,\n  req,\n}: BranchMergeWrite): Promise<void> => {\n  if (resolveBranch(req) !== MAIN_BRANCH) {\n    return\n  }\n\n  const guard = (req.context as Record<PropertyKey, unknown> | undefined)?.[\n    branchMergeWriteGuardContextKey\n  ] as BranchMergeWriteGuard | undefined\n\n  await guard?.({ collectionSlug, data, globalSlug, req })\n}\n"],"names":["APIError","resolveBranch","MAIN_BRANCH","branchMergeValidationContextKey","Symbol","branchMergeWriteGuardContextKey","assertBranchMergeValidationWriteAllowed","req","isBranchMergeValidationRequest","Boolean","context","runBranchMergeWriteGuard","collectionSlug","data","globalSlug","guard"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,qBAAoB;AAC7C,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,WAAW,QAAQ,aAAY;AAWxC,OAAO,MAAMC,kCAAkCC,OAAO,yBAAwB;AAC9E,OAAO,MAAMC,kCAAkCD,OAAO,yBAAwB;AAE9E,4EAA4E,GAC5E,OAAO,MAAME,0CAA0C,CAAC,EACtDC,GAAG,EAGJ;IACC,IAAIC,+BAA+B;QAAED;IAAI,IAAI;QAC3C,MAAM,IAAIP,SAAS,6DAA6D;IAClF;AACF,EAAC;AAED,OAAO,MAAMQ,iCAAiC,CAAC,EAC7CD,GAAG,EAGJ,GACCE,QACGF,KAAKG,SAAsD,CAACP,gCAAgC,EAC9F;AAEH,+EAA+E,GAC/E,OAAO,MAAMQ,2BAA2B,OAAO,EAC7CC,cAAc,EACdC,IAAI,EACJC,UAAU,EACVP,GAAG,EACc;IACjB,IAAIN,cAAcM,SAASL,aAAa;QACtC;IACF;IAEA,MAAMa,QAASR,IAAIG,OAAO,EAA+C,CACvEL,gCACD;IAED,MAAMU,QAAQ;QAAEH;QAAgBC;QAAMC;QAAYP;IAAI;AACxD,EAAC"}

package/dist/branching/preflight.d.ts

@@ -0,0 +1,71 @@
+import type { Payload, PayloadRequest } from '../types/index.js';
+import type { EffectiveOperation, ResolvedChange } from './effectiveOperations.js';
+export type { EffectiveOperation };
+export type BlockedChange = {
+    changeID: number | string;
+    /** Absent for a global. */
+    collectionSlug?: string;
+    /** Absent for a global. */
+    docID?: number | string;
+    docTitle: string;
+    globalSlug?: string;
+    message: string;
+    operation: EffectiveOperation;
+    reason: 'access' | 'dependency';
+};
+type MergeDependencyPreflightResult = {
+    blocked: BlockedChange[];
+    dependencyChangeIDsByChangeID: Map<string, Set<string>>;
+};
+type RunMergeDependencyPreflightArgs = {
+    availableChangeIDs?: Set<string>;
+    initiallyBlocked: BlockedChange[];
+    payload: Payload;
+    pending: ResolvedChange[];
+    pendingGlobals: Record<string, unknown>[];
+    req: PayloadRequest;
+};
+/**
+ * Checks the merging user's production permission for every change.
+ *
+ * A branch is a proposal; nothing on it is real until merge, which is what
+ * makes permissive branch writes safe. This is therefore the enforcement
+ * boundary, not a second check layered on top of one.
+ *
+ * Access functions receive the exact data each effective write proposes. A
+ * data-dependent result cannot be shared between documents, so each write is
+ * evaluated separately.
+ */
+export declare const runMergePreflight: ({ payload, pending, req, }: {
+    payload: Payload;
+    pending: ResolvedChange[];
+    req: PayloadRequest;
+}) => Promise<BlockedChange[]>;
+/**
+ * The same enforcement boundary for globals.
+ *
+ * The branch copy is the exact data the merge will submit. A `Where` result is
+ * applied to the current main global in the same way as an ordinary global update.
+ */
+export declare const runGlobalMergePreflight: ({ payload, pending, req, }: {
+    payload: Payload;
+    pending: Record<string, unknown>[];
+    req: PayloadRequest;
+}) => Promise<BlockedChange[]>;
+/**
+ * Blocks selected changes that would make main refer to content which only exists on a branch.
+ *
+ * Dependencies are resolved as a group. This also handles chains: if one selected create is
+ * blocked, every selected change which depends on that create becomes blocked in turn.
+ */
+export declare const runMergeDependencyPreflight: ({ availableChangeIDs, initiallyBlocked, payload, pending, pendingGlobals, req, }: RunMergeDependencyPreflightArgs) => Promise<BlockedChange[]>;
+export declare const hasUnavailableBranchCreatedDependency: ({ availableChangeIDs, collectionSlug, data, globalSlug, payload, req, }: {
+    availableChangeIDs?: Set<string>;
+    collectionSlug?: string;
+    data: Record<string, unknown>;
+    globalSlug?: string;
+    payload: Payload;
+    req: PayloadRequest;
+}) => Promise<boolean>;
+export declare const resolveMergeDependencies: ({ availableChangeIDs, initiallyBlocked, payload, pending, pendingGlobals, req, }: RunMergeDependencyPreflightArgs) => Promise<MergeDependencyPreflightResult>;
+//# sourceMappingURL=preflight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.d.ts","sourceRoot":"","sources":["../../src/branching/preflight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAkB,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAwBlG,YAAY,EAAE,kBAAkB,EAAE,CAAA;AAElC,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,kBAAkB,CAAA;IAC7B,MAAM,EAAE,QAAQ,GAAG,YAAY,CAAA;CAChC,CAAA;AA4BD,KAAK,8BAA8B,GAAG;IACpC,OAAO,EAAE,aAAa,EAAE,CAAA;IACxB,6BAA6B,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CACxD,CAAA;AAED,KAAK,+BAA+B,GAAG;IACrC,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAChC,gBAAgB,EAAE,aAAa,EAAE,CAAA;IACjC,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,cAAc,EAAE,CAAA;IACzB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;IACzC,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAmBD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,+BAI3B;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,cAAc,EAAE,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,aAAa,EAAE,CA6J1B,CAAA;AA4FD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,+BAIjC;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;IAClC,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,aAAa,EAAE,CAqI1B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,qFAOrC,+BAA+B,KAAG,OAAO,CAAC,aAAa,EAAE,CAUjD,CAAA;AAEX,eAAO,MAAM,qCAAqC,4EAO/C;IACD,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAChC,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,OAAO,CAsClB,CAAA;AAED,eAAO,MAAM,wBAAwB,qFAOlC,+BAA+B,KAAG,OAAO,CAAC,8BAA8B,CAkL1E,CAAA"}