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

package/dist/branching/globals.js

@@ -0,0 +1,197 @@
+import { loadBranchRow, resolveBranch, setBranchRow } from './resolveBranch.js';
+import { branchChangesCollectionSlug, branchesCollectionSlug, branchField, MAIN_BRANCH } from './types.js';
+const bypassed = (branch, req)=>branch === false || !req?.payload || Boolean(req.context?._branchBypass);
+const recordedGlobalsKey = '_branchRecordedGlobals';
+const activeBranch = ({ branch, globalSlug, req })=>{
+    if (bypassed(branch, req)) {
+        return null;
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableGlobals.has(globalSlug)) {
+        return null;
+    }
+    return branch === false ? null : branch ?? resolveBranch(req);
+};
+/**
+ * Branch predicate for reading a global.
+ *
+ * Unlike collections, this does not have to resolve everything inside one
+ * query: a global is a single document, so there is no result set to paginate
+ * or count and nothing a post-query step could get wrong. The query fetches the
+ * branch's row and main's row together and `pickBranchGlobal` prefers the
+ * branch's — one round trip, at most two rows.
+ */ export const resolveBranchGlobalQuery = ({ branch, globalSlug, req, where })=>{
+    const active = activeBranch({
+        branch,
+        globalSlug,
+        req
+    });
+    if (!active) {
+        return where;
+    }
+    const base = where && Object.keys(where).length ? [
+        where
+    ] : [];
+    if (active === MAIN_BRANCH) {
+        return {
+            and: [
+                ...base,
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                }
+            ]
+        };
+    }
+    return {
+        and: [
+            ...base,
+            {
+                [branchField]: {
+                    in: [
+                        active,
+                        MAIN_BRANCH
+                    ]
+                }
+            }
+        ]
+    };
+};
+/** True when the read should fetch two rows so the branch's copy can win. */ export const branchGlobalNeedsBothRows = (args)=>{
+    const active = activeBranch(args);
+    return Boolean(active) && active !== MAIN_BRANCH;
+};
+/** Picks the branch's copy of a global when it has one, else main's. */ export const pickBranchGlobal = (docs, branch)=>docs.find((doc)=>doc?.[branchField] === branch) ?? docs[0];
+/**
+ * The branch a global write should be scoped to, or `null` on main.
+ *
+ * Storage differs too much between adapters to upsert the branch's copy here —
+ * Mongo keeps every global in one discriminated collection and Drizzle gives each
+ * its own table, so each adapter performs the upsert. The global operation records
+ * the change after that adapter write succeeds.
+ */ export const resolveBranchGlobalWrite = (args)=>{
+    const active = activeBranch(args);
+    return active && active !== MAIN_BRANCH ? active : null;
+};
+/** Registers a global as changed on a branch, if it is not already. */ export const recordBranchGlobalChange = async ({ branch, globalSlug, req })=>{
+    // Every write to a branched global asks whether it is already registered. The answer
+    // cannot change within a request except by this function, so it is remembered — which
+    // matters for a request that writes several globals, or one global repeatedly.
+    const context = req.context;
+    const recorded = context?.[recordedGlobalsKey] ?? new Set();
+    const key = `${branch}:${globalSlug}`;
+    if (context && !context[recordedGlobalsKey]) {
+        context[recordedGlobalsKey] = recorded;
+    }
+    if (recorded.has(key)) {
+        return;
+    }
+    if (req.payload.db.upsertBranchGlobalChange) {
+        await req.payload.db.upsertBranchGlobalChange({
+            branch,
+            globalSlug,
+            req
+        });
+        await reopenBranchForGlobalChange({
+            branch,
+            req: req
+        });
+        recorded.add(key);
+        return;
+    }
+    const existing = await req.payload.find({
+        collection: branchChangesCollectionSlug,
+        limit: 1,
+        overrideAccess: true,
+        pagination: false,
+        req: req,
+        where: {
+            and: [
+                {
+                    branch: {
+                        equals: branch
+                    }
+                },
+                {
+                    globalSlug: {
+                        equals: globalSlug
+                    }
+                }
+            ]
+        }
+    });
+    if (existing.docs.length) {
+        recorded.add(key);
+        return;
+    }
+    await req.payload.create({
+        collection: branchChangesCollectionSlug,
+        data: {
+            branch,
+            entityType: 'global',
+            globalSlug,
+            operation: 'update'
+        },
+        overrideAccess: true,
+        req: req
+    });
+    recorded.add(key);
+};
+const reopenBranchForGlobalChange = async ({ branch, req })=>{
+    const row = await loadBranchRow({
+        branch,
+        req
+    });
+    if (row?.status !== 'merged') {
+        return;
+    }
+    const reopened = await req.payload.update({
+        id: row.id,
+        collection: branchesCollectionSlug,
+        data: {
+            mergedAt: null,
+            status: 'open'
+        },
+        overrideAccess: true,
+        req
+    });
+    setBranchRow({
+        branch,
+        req,
+        row: reopened
+    });
+};
+/**
+ * Branch predicate for global version reads.
+ *
+ * Strict equality rather than the read-through used for the global itself: a
+ * version list must not interleave two branches' histories, and ordering by
+ * timestamp would pick between them nondeterministically. A branch that has
+ * never touched the global simply has no versions of it, and the global read
+ * still falls back to main.
+ */ export const resolveBranchGlobalVersionQuery = ({ branch, globalSlug, req, where })=>{
+    const active = activeBranch({
+        branch,
+        globalSlug,
+        req
+    });
+    if (!active) {
+        return where;
+    }
+    const base = where && Object.keys(where).length ? [
+        where
+    ] : [];
+    return {
+        and: [
+            ...base,
+            {
+                [branchField]: {
+                    equals: active
+                }
+            }
+        ]
+    };
+};
+
+//# sourceMappingURL=globals.js.map

package/dist/branching/globals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/globals.ts"],"sourcesContent":["import type { PayloadRequest, Where } from '../types/index.js'\n\nimport { loadBranchRow, resolveBranch, setBranchRow } from './resolveBranch.js'\nimport {\n  branchChangesCollectionSlug,\n  branchesCollectionSlug,\n  branchField,\n  MAIN_BRANCH,\n} from './types.js'\n\ntype BaseArgs = {\n  branch?: false | string\n  globalSlug: string\n  req?: Partial<PayloadRequest>\n}\n\nconst bypassed = (branch: false | string | undefined, req?: Partial<PayloadRequest>): boolean =>\n  branch === false ||\n  !req?.payload ||\n  Boolean((req.context as Record<string, unknown> | undefined)?._branchBypass)\n\nconst recordedGlobalsKey = '_branchRecordedGlobals'\n\nconst activeBranch = ({ branch, globalSlug, req }: BaseArgs): null | string => {\n  if (bypassed(branch, req)) {\n    return null\n  }\n\n  const branching = req!.payload!.config?.branching\n\n  if (!branching?.enabled || !branching.branchableGlobals.has(globalSlug)) {\n    return null\n  }\n\n  return branch === false ? null : (branch ?? resolveBranch(req as PayloadRequest))\n}\n\n/**\n * Branch predicate for reading a global.\n *\n * Unlike collections, this does not have to resolve everything inside one\n * query: a global is a single document, so there is no result set to paginate\n * or count and nothing a post-query step could get wrong. The query fetches the\n * branch's row and main's row together and `pickBranchGlobal` prefers the\n * branch's — one round trip, at most two rows.\n */\nexport const resolveBranchGlobalQuery = ({\n  branch,\n  globalSlug,\n  req,\n  where,\n}: { where: undefined | Where } & BaseArgs): undefined | Where => {\n  const active = activeBranch({ branch, globalSlug, req })\n\n  if (!active) {\n    return where\n  }\n\n  const base = where && Object.keys(where).length ? [where] : []\n\n  if (active === MAIN_BRANCH) {\n    return { and: [...base, { [branchField]: { equals: MAIN_BRANCH } }] }\n  }\n\n  return { and: [...base, { [branchField]: { in: [active, MAIN_BRANCH] } }] }\n}\n\n/** True when the read should fetch two rows so the branch's copy can win. */\nexport const branchGlobalNeedsBothRows = (args: BaseArgs): boolean => {\n  const active = activeBranch(args)\n\n  return Boolean(active) && active !== MAIN_BRANCH\n}\n\n/** Picks the branch's copy of a global when it has one, else main's. */\nexport const pickBranchGlobal = <T extends Record<string, any>>(\n  docs: T[],\n  branch: string,\n): T | undefined => docs.find((doc) => doc?.[branchField] === branch) ?? docs[0]\n\n/**\n * The branch a global write should be scoped to, or `null` on main.\n *\n * Storage differs too much between adapters to upsert the branch's copy here —\n * Mongo keeps every global in one discriminated collection and Drizzle gives each\n * its own table, so each adapter performs the upsert. The global operation records\n * the change after that adapter write succeeds.\n */\nexport const resolveBranchGlobalWrite = (args: BaseArgs): null | string => {\n  const active = activeBranch(args)\n\n  return active && active !== MAIN_BRANCH ? active : null\n}\n\n/** Registers a global as changed on a branch, if it is not already. */\nexport const recordBranchGlobalChange = async ({\n  branch,\n  globalSlug,\n  req,\n}: { branch: string } & BaseArgs): Promise<void> => {\n  // Every write to a branched global asks whether it is already registered. The answer\n  // cannot change within a request except by this function, so it is remembered — which\n  // matters for a request that writes several globals, or one global repeatedly.\n  const context = req!.context as Record<string, unknown> | undefined\n  const recorded = (context?.[recordedGlobalsKey] as Set<string> | undefined) ?? new Set<string>()\n  const key = `${branch}:${globalSlug}`\n\n  if (context && !context[recordedGlobalsKey]) {\n    context[recordedGlobalsKey] = recorded\n  }\n\n  if (recorded.has(key)) {\n    return\n  }\n\n  if (req!.payload!.db.upsertBranchGlobalChange) {\n    await req!.payload!.db.upsertBranchGlobalChange({ branch, globalSlug, req })\n    await reopenBranchForGlobalChange({ branch, req: req as PayloadRequest })\n    recorded.add(key)\n\n    return\n  }\n\n  const existing = await req!.payload!.find({\n    collection: branchChangesCollectionSlug,\n    limit: 1,\n    overrideAccess: true,\n    pagination: false,\n    req: req as PayloadRequest,\n    where: {\n      and: [{ branch: { equals: branch } }, { globalSlug: { equals: globalSlug } }],\n    },\n  })\n\n  if (existing.docs.length) {\n    recorded.add(key)\n\n    return\n  }\n\n  await req!.payload!.create({\n    collection: branchChangesCollectionSlug,\n    data: {\n      branch,\n      entityType: 'global',\n      globalSlug,\n      operation: 'update',\n    },\n    overrideAccess: true,\n    req: req as PayloadRequest,\n  })\n\n  recorded.add(key)\n}\n\nconst reopenBranchForGlobalChange = async ({\n  branch,\n  req,\n}: {\n  branch: string\n  req: PayloadRequest\n}): Promise<void> => {\n  const row = await loadBranchRow({ branch, req })\n\n  if (row?.status !== 'merged') {\n    return\n  }\n\n  const reopened = await req.payload.update({\n    id: row.id as number | string,\n    collection: branchesCollectionSlug,\n    data: { mergedAt: null, status: 'open' },\n    overrideAccess: true,\n    req,\n  })\n\n  setBranchRow({ branch, req, row: reopened as Record<string, unknown> })\n}\n\n/**\n * Branch predicate for global version reads.\n *\n * Strict equality rather than the read-through used for the global itself: a\n * version list must not interleave two branches' histories, and ordering by\n * timestamp would pick between them nondeterministically. A branch that has\n * never touched the global simply has no versions of it, and the global read\n * still falls back to main.\n */\nexport const resolveBranchGlobalVersionQuery = ({\n  branch,\n  globalSlug,\n  req,\n  where,\n}: { where: undefined | Where } & BaseArgs): undefined | Where => {\n  const active = activeBranch({ branch, globalSlug, req })\n\n  if (!active) {\n    return where\n  }\n\n  const base = where && Object.keys(where).length ? [where] : []\n\n  return { and: [...base, { [branchField]: { equals: active } }] }\n}\n"],"names":["loadBranchRow","resolveBranch","setBranchRow","branchChangesCollectionSlug","branchesCollectionSlug","branchField","MAIN_BRANCH","bypassed","branch","req","payload","Boolean","context","_branchBypass","recordedGlobalsKey","activeBranch","globalSlug","branching","config","enabled","branchableGlobals","has","resolveBranchGlobalQuery","where","active","base","Object","keys","length","and","equals","in","branchGlobalNeedsBothRows","args","pickBranchGlobal","docs","find","doc","resolveBranchGlobalWrite","recordBranchGlobalChange","recorded","Set","key","db","upsertBranchGlobalChange","reopenBranchForGlobalChange","add","existing","collection","limit","overrideAccess","pagination","create","data","entityType","operation","row","status","reopened","update","id","mergedAt","resolveBranchGlobalVersionQuery"],"mappings":"AAEA,SAASA,aAAa,EAAEC,aAAa,EAAEC,YAAY,QAAQ,qBAAoB;AAC/E,SACEC,2BAA2B,EAC3BC,sBAAsB,EACtBC,WAAW,EACXC,WAAW,QACN,aAAY;AAQnB,MAAMC,WAAW,CAACC,QAAoCC,MACpDD,WAAW,SACX,CAACC,KAAKC,WACNC,QAASF,IAAIG,OAAO,EAA0CC;AAEhE,MAAMC,qBAAqB;AAE3B,MAAMC,eAAe,CAAC,EAAEP,MAAM,EAAEQ,UAAU,EAAEP,GAAG,EAAY;IACzD,IAAIF,SAASC,QAAQC,MAAM;QACzB,OAAO;IACT;IAEA,MAAMQ,YAAYR,IAAKC,OAAO,CAAEQ,MAAM,EAAED;IAExC,IAAI,CAACA,WAAWE,WAAW,CAACF,UAAUG,iBAAiB,CAACC,GAAG,CAACL,aAAa;QACvE,OAAO;IACT;IAEA,OAAOR,WAAW,QAAQ,OAAQA,UAAUP,cAAcQ;AAC5D;AAEA;;;;;;;;CAQC,GACD,OAAO,MAAMa,2BAA2B,CAAC,EACvCd,MAAM,EACNQ,UAAU,EACVP,GAAG,EACHc,KAAK,EACmC;IACxC,MAAMC,SAAST,aAAa;QAAEP;QAAQQ;QAAYP;IAAI;IAEtD,IAAI,CAACe,QAAQ;QACX,OAAOD;IACT;IAEA,MAAME,OAAOF,SAASG,OAAOC,IAAI,CAACJ,OAAOK,MAAM,GAAG;QAACL;KAAM,GAAG,EAAE;IAE9D,IAAIC,WAAWlB,aAAa;QAC1B,OAAO;YAAEuB,KAAK;mBAAIJ;gBAAM;oBAAE,CAACpB,YAAY,EAAE;wBAAEyB,QAAQxB;oBAAY;gBAAE;aAAE;QAAC;IACtE;IAEA,OAAO;QAAEuB,KAAK;eAAIJ;YAAM;gBAAE,CAACpB,YAAY,EAAE;oBAAE0B,IAAI;wBAACP;wBAAQlB;qBAAY;gBAAC;YAAE;SAAE;IAAC;AAC5E,EAAC;AAED,2EAA2E,GAC3E,OAAO,MAAM0B,4BAA4B,CAACC;IACxC,MAAMT,SAAST,aAAakB;IAE5B,OAAOtB,QAAQa,WAAWA,WAAWlB;AACvC,EAAC;AAED,sEAAsE,GACtE,OAAO,MAAM4B,mBAAmB,CAC9BC,MACA3B,SACkB2B,KAAKC,IAAI,CAAC,CAACC,MAAQA,KAAK,CAAChC,YAAY,KAAKG,WAAW2B,IAAI,CAAC,EAAE,CAAA;AAEhF;;;;;;;CAOC,GACD,OAAO,MAAMG,2BAA2B,CAACL;IACvC,MAAMT,SAAST,aAAakB;IAE5B,OAAOT,UAAUA,WAAWlB,cAAckB,SAAS;AACrD,EAAC;AAED,qEAAqE,GACrE,OAAO,MAAMe,2BAA2B,OAAO,EAC7C/B,MAAM,EACNQ,UAAU,EACVP,GAAG,EAC2B;IAC9B,qFAAqF;IACrF,sFAAsF;IACtF,+EAA+E;IAC/E,MAAMG,UAAUH,IAAKG,OAAO;IAC5B,MAAM4B,WAAW,AAAC5B,SAAS,CAACE,mBAAmB,IAAgC,IAAI2B;IACnF,MAAMC,MAAM,GAAGlC,OAAO,CAAC,EAAEQ,YAAY;IAErC,IAAIJ,WAAW,CAACA,OAAO,CAACE,mBAAmB,EAAE;QAC3CF,OAAO,CAACE,mBAAmB,GAAG0B;IAChC;IAEA,IAAIA,SAASnB,GAAG,CAACqB,MAAM;QACrB;IACF;IAEA,IAAIjC,IAAKC,OAAO,CAAEiC,EAAE,CAACC,wBAAwB,EAAE;QAC7C,MAAMnC,IAAKC,OAAO,CAAEiC,EAAE,CAACC,wBAAwB,CAAC;YAAEpC;YAAQQ;YAAYP;QAAI;QAC1E,MAAMoC,4BAA4B;YAAErC;YAAQC,KAAKA;QAAsB;QACvE+B,SAASM,GAAG,CAACJ;QAEb;IACF;IAEA,MAAMK,WAAW,MAAMtC,IAAKC,OAAO,CAAE0B,IAAI,CAAC;QACxCY,YAAY7C;QACZ8C,OAAO;QACPC,gBAAgB;QAChBC,YAAY;QACZ1C,KAAKA;QACLc,OAAO;YACLM,KAAK;gBAAC;oBAAErB,QAAQ;wBAAEsB,QAAQtB;oBAAO;gBAAE;gBAAG;oBAAEQ,YAAY;wBAAEc,QAAQd;oBAAW;gBAAE;aAAE;QAC/E;IACF;IAEA,IAAI+B,SAASZ,IAAI,CAACP,MAAM,EAAE;QACxBY,SAASM,GAAG,CAACJ;QAEb;IACF;IAEA,MAAMjC,IAAKC,OAAO,CAAE0C,MAAM,CAAC;QACzBJ,YAAY7C;QACZkD,MAAM;YACJ7C;YACA8C,YAAY;YACZtC;YACAuC,WAAW;QACb;QACAL,gBAAgB;QAChBzC,KAAKA;IACP;IAEA+B,SAASM,GAAG,CAACJ;AACf,EAAC;AAED,MAAMG,8BAA8B,OAAO,EACzCrC,MAAM,EACNC,GAAG,EAIJ;IACC,MAAM+C,MAAM,MAAMxD,cAAc;QAAEQ;QAAQC;IAAI;IAE9C,IAAI+C,KAAKC,WAAW,UAAU;QAC5B;IACF;IAEA,MAAMC,WAAW,MAAMjD,IAAIC,OAAO,CAACiD,MAAM,CAAC;QACxCC,IAAIJ,IAAII,EAAE;QACVZ,YAAY5C;QACZiD,MAAM;YAAEQ,UAAU;YAAMJ,QAAQ;QAAO;QACvCP,gBAAgB;QAChBzC;IACF;IAEAP,aAAa;QAAEM;QAAQC;QAAK+C,KAAKE;IAAoC;AACvE;AAEA;;;;;;;;CAQC,GACD,OAAO,MAAMI,kCAAkC,CAAC,EAC9CtD,MAAM,EACNQ,UAAU,EACVP,GAAG,EACHc,KAAK,EACmC;IACxC,MAAMC,SAAST,aAAa;QAAEP;QAAQQ;QAAYP;IAAI;IAEtD,IAAI,CAACe,QAAQ;QACX,OAAOD;IACT;IAEA,MAAME,OAAOF,SAASG,OAAOC,IAAI,CAACJ,OAAOK,MAAM,GAAG;QAACL;KAAM,GAAG,EAAE;IAE9D,OAAO;QAAEM,KAAK;eAAIJ;YAAM;gBAAE,CAACpB,YAAY,EAAE;oBAAEyB,QAAQN;gBAAO;YAAE;SAAE;IAAC;AACjE,EAAC"}

package/dist/branching/hooks.d.ts

@@ -0,0 +1,24 @@
+import type { CollectionAfterChangeHook, CollectionBeforeChangeHook, CollectionBeforeOperationHook, GlobalBeforeOperationHook } from '../index.js';
+/**
+ * Stamps documents created on a branch so the read predicate can find them.
+ *
+ * `_branchDocID` is deliberately left null. For a document created on a branch
+ * the canonical ID *is* the row's own ID, and the ID rewrite treats a null
+ * `_branchDocID` as "self" — so setting it would mean an extra write after
+ * insert to learn the generated ID, for no gain. Only forked rows, which point
+ * at a different main row, need it populated.
+ */
+export declare const stampBranchOnCreate: CollectionBeforeChangeHook;
+/**
+ * Records a branch-created document in the changeset registry.
+ *
+ * The registry is not consulted to *read* branch-created documents — those are
+ * found by `_branch` alone. It exists so merge and the changed-documents view
+ * can enumerate what a branch has done.
+ */
+export declare const recordBranchCreate: CollectionAfterChangeHook;
+/** Refuses collection writes before they can make changes on a closed branch. */
+export declare const assertBranchWritableBeforeCollectionWrite: CollectionBeforeOperationHook;
+/** Refuses global writes before they can make changes on a closed branch. */
+export declare const assertBranchWritableBeforeGlobalWrite: GlobalBeforeOperationHook;
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/branching/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,6BAA6B,EAC7B,yBAAyB,EAC1B,MAAM,aAAa,CAAA;AAMpB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,0BAWjC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,yBAqChC,CAAA;AAED,iFAAiF;AACjF,eAAO,MAAM,yCAAyC,EAAE,6BAkBvD,CAAA;AAED,6EAA6E;AAC7E,eAAO,MAAM,qCAAqC,EAAE,yBAwBnD,CAAA"}

package/dist/branching/hooks.js

@@ -0,0 +1,92 @@
+import { assertBranchWritable } from './assertBranchWritable.js';
+import { addToBranchManifest, refreshRequestDataLoader, resolveBranch } from './resolveBranch.js';
+import { branchChangesCollectionSlug, branchField, MAIN_BRANCH } from './types.js';
+/**
+ * Stamps documents created on a branch so the read predicate can find them.
+ *
+ * `_branchDocID` is deliberately left null. For a document created on a branch
+ * the canonical ID *is* the row's own ID, and the ID rewrite treats a null
+ * `_branchDocID` as "self" — so setting it would mean an extra write after
+ * insert to learn the generated ID, for no gain. Only forked rows, which point
+ * at a different main row, need it populated.
+ */ export const stampBranchOnCreate = ({ data, operation, req })=>{
+    const branch = resolveBranch(req);
+    if (branch === MAIN_BRANCH || operation !== 'create') {
+        return data;
+    }
+    return {
+        ...data,
+        [branchField]: branch
+    };
+};
+/**
+ * Records a branch-created document in the changeset registry.
+ *
+ * The registry is not consulted to *read* branch-created documents — those are
+ * found by `_branch` alone. It exists so merge and the changed-documents view
+ * can enumerate what a branch has done.
+ */ export const recordBranchCreate = async ({ collection, doc, operation, req })=>{
+    const branch = resolveBranch(req);
+    if (branch === MAIN_BRANCH || operation !== 'create') {
+        return doc;
+    }
+    await assertBranchWritable({
+        branch,
+        req
+    });
+    await req.payload.create({
+        collection: branchChangesCollectionSlug,
+        data: {
+            branch,
+            collectionSlug: collection.slug,
+            doc: {
+                relationTo: collection.slug,
+                value: doc.id
+            },
+            documentID: String(doc.id),
+            entityType: 'collection',
+            operation: 'create'
+        },
+        overrideAccess: true,
+        req
+    });
+    addToBranchManifest({
+        collectionSlug: collection.slug,
+        docID: doc.id,
+        operation: 'create',
+        req
+    });
+    refreshRequestDataLoader(req);
+    return doc;
+};
+/** Refuses collection writes before they can make changes on a closed branch. */ export const assertBranchWritableBeforeCollectionWrite = async ({ args, operation, req })=>{
+    if (operation !== 'create' && operation !== 'restoreVersion' && operation !== 'update') {
+        return args;
+    }
+    const branch = resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return args;
+    }
+    await assertBranchWritable({
+        branch,
+        req
+    });
+    return args;
+};
+/** Refuses global writes before they can make changes on a closed branch. */ export const assertBranchWritableBeforeGlobalWrite = async ({ args, global, operation, req })=>{
+    if (operation !== 'restoreVersion' && operation !== 'update') {
+        return args;
+    }
+    const branch = resolveBranch(req);
+    const branching = req.payload.config.branching;
+    if (branch === MAIN_BRANCH || !branching?.enabled || !branching.branchableGlobals.has(global.slug)) {
+        return args;
+    }
+    await assertBranchWritable({
+        branch,
+        req
+    });
+    return args;
+};
+
+//# sourceMappingURL=hooks.js.map

package/dist/branching/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/hooks.ts"],"sourcesContent":["import type {\n  CollectionAfterChangeHook,\n  CollectionBeforeChangeHook,\n  CollectionBeforeOperationHook,\n  GlobalBeforeOperationHook,\n} from '../index.js'\n\nimport { assertBranchWritable } from './assertBranchWritable.js'\nimport { addToBranchManifest, refreshRequestDataLoader, resolveBranch } from './resolveBranch.js'\nimport { branchChangesCollectionSlug, branchField, MAIN_BRANCH } from './types.js'\n\n/**\n * Stamps documents created on a branch so the read predicate can find them.\n *\n * `_branchDocID` is deliberately left null. For a document created on a branch\n * the canonical ID *is* the row's own ID, and the ID rewrite treats a null\n * `_branchDocID` as \"self\" — so setting it would mean an extra write after\n * insert to learn the generated ID, for no gain. Only forked rows, which point\n * at a different main row, need it populated.\n */\nexport const stampBranchOnCreate: CollectionBeforeChangeHook = ({ data, operation, req }) => {\n  const branch = resolveBranch(req)\n\n  if (branch === MAIN_BRANCH || operation !== 'create') {\n    return data\n  }\n\n  return {\n    ...data,\n    [branchField]: branch,\n  }\n}\n\n/**\n * Records a branch-created document in the changeset registry.\n *\n * The registry is not consulted to *read* branch-created documents — those are\n * found by `_branch` alone. It exists so merge and the changed-documents view\n * can enumerate what a branch has done.\n */\nexport const recordBranchCreate: CollectionAfterChangeHook = async ({\n  collection,\n  doc,\n  operation,\n  req,\n}) => {\n  const branch = resolveBranch(req)\n\n  if (branch === MAIN_BRANCH || operation !== 'create') {\n    return doc\n  }\n\n  await assertBranchWritable({ branch, req })\n\n  await req.payload.create({\n    collection: branchChangesCollectionSlug,\n    data: {\n      branch,\n      collectionSlug: collection.slug,\n      doc: { relationTo: collection.slug, value: doc.id },\n      documentID: String(doc.id),\n      entityType: 'collection',\n      operation: 'create',\n    },\n    overrideAccess: true,\n    req,\n  })\n\n  addToBranchManifest({\n    collectionSlug: collection.slug,\n    docID: doc.id,\n    operation: 'create',\n    req,\n  })\n  refreshRequestDataLoader(req)\n\n  return doc\n}\n\n/** Refuses collection writes before they can make changes on a closed branch. */\nexport const assertBranchWritableBeforeCollectionWrite: CollectionBeforeOperationHook = async ({\n  args,\n  operation,\n  req,\n}) => {\n  if (operation !== 'create' && operation !== 'restoreVersion' && operation !== 'update') {\n    return args\n  }\n\n  const branch = resolveBranch(req)\n\n  if (branch === MAIN_BRANCH) {\n    return args\n  }\n\n  await assertBranchWritable({ branch, req })\n\n  return args\n}\n\n/** Refuses global writes before they can make changes on a closed branch. */\nexport const assertBranchWritableBeforeGlobalWrite: GlobalBeforeOperationHook = async ({\n  args,\n  global,\n  operation,\n  req,\n}) => {\n  if (operation !== 'restoreVersion' && operation !== 'update') {\n    return args\n  }\n\n  const branch = resolveBranch(req)\n  const branching = req.payload.config.branching\n\n  if (\n    branch === MAIN_BRANCH ||\n    !branching?.enabled ||\n    !branching.branchableGlobals.has(global.slug)\n  ) {\n    return args\n  }\n\n  await assertBranchWritable({ branch, req })\n\n  return args\n}\n"],"names":["assertBranchWritable","addToBranchManifest","refreshRequestDataLoader","resolveBranch","branchChangesCollectionSlug","branchField","MAIN_BRANCH","stampBranchOnCreate","data","operation","req","branch","recordBranchCreate","collection","doc","payload","create","collectionSlug","slug","relationTo","value","id","documentID","String","entityType","overrideAccess","docID","assertBranchWritableBeforeCollectionWrite","args","assertBranchWritableBeforeGlobalWrite","global","branching","config","enabled","branchableGlobals","has"],"mappings":"AAOA,SAASA,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,mBAAmB,EAAEC,wBAAwB,EAAEC,aAAa,QAAQ,qBAAoB;AACjG,SAASC,2BAA2B,EAAEC,WAAW,EAAEC,WAAW,QAAQ,aAAY;AAElF;;;;;;;;CAQC,GACD,OAAO,MAAMC,sBAAkD,CAAC,EAAEC,IAAI,EAAEC,SAAS,EAAEC,GAAG,EAAE;IACtF,MAAMC,SAASR,cAAcO;IAE7B,IAAIC,WAAWL,eAAeG,cAAc,UAAU;QACpD,OAAOD;IACT;IAEA,OAAO;QACL,GAAGA,IAAI;QACP,CAACH,YAAY,EAAEM;IACjB;AACF,EAAC;AAED;;;;;;CAMC,GACD,OAAO,MAAMC,qBAAgD,OAAO,EAClEC,UAAU,EACVC,GAAG,EACHL,SAAS,EACTC,GAAG,EACJ;IACC,MAAMC,SAASR,cAAcO;IAE7B,IAAIC,WAAWL,eAAeG,cAAc,UAAU;QACpD,OAAOK;IACT;IAEA,MAAMd,qBAAqB;QAAEW;QAAQD;IAAI;IAEzC,MAAMA,IAAIK,OAAO,CAACC,MAAM,CAAC;QACvBH,YAAYT;QACZI,MAAM;YACJG;YACAM,gBAAgBJ,WAAWK,IAAI;YAC/BJ,KAAK;gBAAEK,YAAYN,WAAWK,IAAI;gBAAEE,OAAON,IAAIO,EAAE;YAAC;YAClDC,YAAYC,OAAOT,IAAIO,EAAE;YACzBG,YAAY;YACZf,WAAW;QACb;QACAgB,gBAAgB;QAChBf;IACF;IAEAT,oBAAoB;QAClBgB,gBAAgBJ,WAAWK,IAAI;QAC/BQ,OAAOZ,IAAIO,EAAE;QACbZ,WAAW;QACXC;IACF;IACAR,yBAAyBQ;IAEzB,OAAOI;AACT,EAAC;AAED,+EAA+E,GAC/E,OAAO,MAAMa,4CAA2E,OAAO,EAC7FC,IAAI,EACJnB,SAAS,EACTC,GAAG,EACJ;IACC,IAAID,cAAc,YAAYA,cAAc,oBAAoBA,cAAc,UAAU;QACtF,OAAOmB;IACT;IAEA,MAAMjB,SAASR,cAAcO;IAE7B,IAAIC,WAAWL,aAAa;QAC1B,OAAOsB;IACT;IAEA,MAAM5B,qBAAqB;QAAEW;QAAQD;IAAI;IAEzC,OAAOkB;AACT,EAAC;AAED,2EAA2E,GAC3E,OAAO,MAAMC,wCAAmE,OAAO,EACrFD,IAAI,EACJE,MAAM,EACNrB,SAAS,EACTC,GAAG,EACJ;IACC,IAAID,cAAc,oBAAoBA,cAAc,UAAU;QAC5D,OAAOmB;IACT;IAEA,MAAMjB,SAASR,cAAcO;IAC7B,MAAMqB,YAAYrB,IAAIK,OAAO,CAACiB,MAAM,CAACD,SAAS;IAE9C,IACEpB,WAAWL,eACX,CAACyB,WAAWE,WACZ,CAACF,UAAUG,iBAAiB,CAACC,GAAG,CAACL,OAAOZ,IAAI,GAC5C;QACA,OAAOU;IACT;IAEA,MAAM5B,qBAAqB;QAAEW;QAAQD;IAAI;IAEzC,OAAOkB;AACT,EAAC"}

package/dist/branching/injectBranchFields.d.ts

@@ -0,0 +1,40 @@
+import type { CollectionConfig } from '../collections/config/types.js';
+import type { Field, TextField } from '../fields/config/types.js';
+import type { GlobalConfig } from '../globals/config/types.js';
+/**
+ * `_branch` — which branch a row belongs to. `'main'` is a non-null sentinel
+ * rather than NULL so that compound `(field, _branch)` unique indexes keep
+ * enforcing uniqueness among main rows on Postgres, which treats NULLs as
+ * distinct.
+ */
+export declare const buildBranchField: () => TextField;
+/**
+ * `_branchDocID` — the canonical document this row represents. Null on main
+ * rows, meaning "self".
+ *
+ * Declared as a self-referential `relationship` rather than `text` for two
+ * reasons: it inherits the collection's own ID type (which may be text,
+ * number, or a custom ID), and Payload's Drizzle builder special-cases
+ * `not_in` for relationship fields to emit `(col NOT IN (...) OR col IS NULL)`,
+ * without which every main row would be excluded from a branch read.
+ */
+export declare const buildBranchDocIDField: (slug: string) => Field;
+/** `_branchParent` — the canonical parent document, for version rows. */
+export declare const buildBranchParentField: (slug: string) => Field;
+/**
+ * Injects the branch discriminator fields and rewrites `unique: true` fields
+ * into branch-scoped compound indexes.
+ *
+ * A branch holds a full copy of a document, so an unscoped unique index would
+ * reject the copy outright. Scoping by `_branch` lets two branches each hold a
+ * document with the same value while preserving uniqueness within a branch.
+ */
+export declare const injectBranchFields: (collection: CollectionConfig) => CollectionConfig;
+/**
+ * Globals need only the discriminator.
+ *
+ * No `_branchDocID`, because a global's identity is its slug and is stable
+ * across branches — the whole canonical-ID translation problem does not arise.
+ */
+export declare const injectGlobalBranchFields: (global: GlobalConfig) => GlobalConfig;
+//# sourceMappingURL=injectBranchFields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"injectBranchFields.d.ts","sourceRoot":"","sources":["../../src/branching/injectBranchFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAiB,MAAM,gCAAgC,CAAA;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAkD9D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,QAAO,SAQlC,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,SAAU,MAAM,KAAG,KAQnD,CAAA;AAEF,yEAAyE;AACzE,eAAO,MAAM,sBAAsB,SAAU,MAAM,KAAG,KAQpD,CAAA;AAkDF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,eAAgB,gBAAgB,KAAG,gBAyDjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,WAAY,YAAY,KAAG,YAe/D,CAAA"}

package/dist/branching/injectBranchFields.js

@@ -0,0 +1,229 @@
+import { fieldAffectsData, tabHasName } from '../fields/config/types.js';
+import { assertBranchWritableBeforeCollectionWrite, assertBranchWritableBeforeGlobalWrite, recordBranchCreate, stampBranchOnCreate } from './hooks.js';
+import { branchDocIDField, branchField, branchParentField, MAIN_BRANCH } from './types.js';
+/**
+ * These columns are branch bookkeeping, not content. They are `admin.hidden`,
+ * but hidden is not the same as read-only: the admin form round-trips every
+ * field it loaded, so an edit made on a branch would submit the `_branch` it
+ * was read with and stamp it back onto the shadow row — quietly moving that
+ * row onto `main` and duplicating the document in production.
+ *
+ * Denying field-level create/update makes them internally writable only.
+ * Field access is skipped under `overrideAccess: true`, which is exactly the
+ * exemption merge needs to flip `_branch` to `'main'` (§16), and the
+ * copy-on-write paths write through `payload.db` directly, below field access
+ * entirely.
+ */ const internalOnly = {
+    access: {
+        create: ()=>false,
+        update: ()=>false
+    },
+    admin: {
+        disabled: {
+            bulkEdit: true
+        },
+        hidden: true
+    }
+};
+/**
+ * `hidden` on top of that, for the columns nothing outside the branching engine
+ * ever reads back.
+ *
+ * `admin.hidden` only keeps a field out of the edit form — it still ships in every
+ * API response, which muddies the shape of every branched document. `hidden`
+ * removes it from responses altogether. Reads that legitimately need to inspect
+ * these columns pass `showHiddenFields: true`; the engine itself is unaffected,
+ * because copy-on-write, merge and tombstoning all read through `payload.db`
+ * directly, below the `afterRead` layer that does the stripping.
+ *
+ * Writes must never take these from round-tripped data: a read strips them, the
+ * field default silently refills `_branch` with `main`, and writing that back
+ * would flip a branch's row onto main. Both adapters set `_branch` explicitly on
+ * global writes for exactly this reason.
+ */ const bookkeepingOnly = {
+    ...internalOnly,
+    hidden: true
+};
+/**
+ * `_branch` — which branch a row belongs to. `'main'` is a non-null sentinel
+ * rather than NULL so that compound `(field, _branch)` unique indexes keep
+ * enforcing uniqueness among main rows on Postgres, which treats NULLs as
+ * distinct.
+ */ export const buildBranchField = ()=>({
+        name: branchField,
+        type: 'text',
+        ...bookkeepingOnly,
+        defaultValue: MAIN_BRANCH,
+        index: true,
+        label: 'Branch',
+        required: true
+    });
+/**
+ * `_branchDocID` — the canonical document this row represents. Null on main
+ * rows, meaning "self".
+ *
+ * Declared as a self-referential `relationship` rather than `text` for two
+ * reasons: it inherits the collection's own ID type (which may be text,
+ * number, or a custom ID), and Payload's Drizzle builder special-cases
+ * `not_in` for relationship fields to emit `(col NOT IN (...) OR col IS NULL)`,
+ * without which every main row would be excluded from a branch read.
+ */ export const buildBranchDocIDField = (slug)=>({
+        name: branchDocIDField,
+        type: 'relationship',
+        ...bookkeepingOnly,
+        index: true,
+        label: 'Branch Document',
+        maxDepth: 0,
+        relationTo: slug
+    });
+/** `_branchParent` — the canonical parent document, for version rows. */ export const buildBranchParentField = (slug)=>({
+        name: branchParentField,
+        type: 'relationship',
+        ...bookkeepingOnly,
+        index: true,
+        label: 'Branch Parent Document',
+        maxDepth: 0,
+        relationTo: slug
+    });
+const hasField = (fields, name)=>fields.some((field)=>'name' in field && field.name === name);
+const joinFieldPath = ({ name, parentPath })=>parentPath ? `${parentPath}.${name}` : name;
+const rewriteUniqueFields = ({ fields, indexes, parentPath = '' })=>{
+    for (const field of fields){
+        if (fieldAffectsData(field) && 'unique' in field && field.unique) {
+            const fieldPath = joinFieldPath({
+                name: field.name,
+                parentPath
+            });
+            field.unique = false;
+            indexes.push({
+                fields: [
+                    fieldPath,
+                    branchField
+                ],
+                ...field.required === true ? {} : {
+                    requireExists: [
+                        fieldPath
+                    ]
+                },
+                unique: true
+            });
+        }
+        if (field.type === 'collapsible' || field.type === 'group' || field.type === 'row') {
+            rewriteUniqueFields({
+                fields: field.fields,
+                indexes,
+                parentPath: field.type === 'group' && fieldAffectsData(field) ? joinFieldPath({
+                    name: field.name,
+                    parentPath
+                }) : parentPath
+            });
+        } else if (field.type === 'tabs') {
+            for (const tab of field.tabs){
+                rewriteUniqueFields({
+                    fields: tab.fields,
+                    indexes,
+                    parentPath: tabHasName(tab) ? joinFieldPath({
+                        name: tab.name,
+                        parentPath
+                    }) : parentPath
+                });
+            }
+        }
+    }
+};
+/**
+ * Injects the branch discriminator fields and rewrites `unique: true` fields
+ * into branch-scoped compound indexes.
+ *
+ * A branch holds a full copy of a document, so an unscoped unique index would
+ * reject the copy outright. Scoping by `_branch` lets two branches each hold a
+ * document with the same value while preserving uniqueness within a branch.
+ */ export const injectBranchFields = (collection)=>{
+    if (!hasField(collection.fields, branchField)) {
+        collection.fields.push(buildBranchField());
+    }
+    if (!hasField(collection.fields, branchDocIDField)) {
+        collection.fields.push(buildBranchDocIDField(collection.slug));
+    }
+    const indexes = (collection.indexes ?? []).map((index)=>index.unique && !index.fields.includes(branchField) ? {
+            ...index,
+            fields: [
+                ...index.fields,
+                branchField
+            ]
+        } : index);
+    // Catches two concurrent first-edits of the same document on the same branch:
+    // whichever write loses the race gets a constraint violation from the
+    // database instead of a second, silently duplicate shadow row. Scoped to rows
+    // that have a `_branchDocID` at all — a main row's is null, and a unique
+    // index would otherwise treat every main row as colliding with every other.
+    indexes.push({
+        fields: [
+            branchDocIDField,
+            branchField
+        ],
+        requireExists: [
+            branchDocIDField
+        ],
+        unique: true
+    });
+    rewriteUniqueFields({
+        fields: collection.fields,
+        indexes
+    });
+    collection.indexes = indexes;
+    // `filename` is unique on upload collections, but it is added by upload
+    // sanitization — which runs *after* this — so the loop above cannot reach it and
+    // it would keep a global unique index. A branch's copy of an upload then
+    // collides with main's on filename, and forking or tombstoning it fails
+    // outright. Declaring the compound index up front is the supported way to scope
+    // it: `getBaseUploadFields` leaves `filename.unique` unset when it is present.
+    if (collection.upload) {
+        const upload = collection.upload === true ? {} : collection.upload;
+        upload.filenameCompoundIndex ??= [
+            'filename'
+        ];
+        if (!upload.filenameCompoundIndex.includes(branchField)) {
+            upload.filenameCompoundIndex.push(branchField);
+        }
+        collection.upload = upload;
+    }
+    collection.hooks = collection.hooks ?? {};
+    collection.hooks.beforeChange = [
+        ...collection.hooks.beforeChange ?? [],
+        stampBranchOnCreate
+    ];
+    collection.hooks.afterChange = [
+        ...collection.hooks.afterChange ?? [],
+        recordBranchCreate
+    ];
+    collection.hooks.beforeOperation = [
+        assertBranchWritableBeforeCollectionWrite,
+        ...collection.hooks.beforeOperation ?? []
+    ];
+    return collection;
+};
+/**
+ * Globals need only the discriminator.
+ *
+ * No `_branchDocID`, because a global's identity is its slug and is stable
+ * across branches — the whole canonical-ID translation problem does not arise.
+ */ export const injectGlobalBranchFields = (global)=>{
+    if (!hasField(global.fields, branchField)) {
+        // Each global has at most one row on a branch. Besides expressing that
+        // invariant, the unique key is the conflict target used by adapter upserts
+        // when concurrent requests make the first branch write.
+        global.fields.push({
+            ...buildBranchField(),
+            unique: true
+        });
+    }
+    global.hooks = global.hooks ?? {};
+    global.hooks.beforeOperation = [
+        assertBranchWritableBeforeGlobalWrite,
+        ...global.hooks.beforeOperation ?? []
+    ];
+    return global;
+};
+
+//# sourceMappingURL=injectBranchFields.js.map

package/dist/branching/injectBranchFields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/injectBranchFields.ts"],"sourcesContent":["import type { CollectionConfig, CompoundIndex } from '../collections/config/types.js'\nimport type { Field, TextField } from '../fields/config/types.js'\nimport type { GlobalConfig } from '../globals/config/types.js'\n\nimport { fieldAffectsData, tabHasName } from '../fields/config/types.js'\nimport {\n  assertBranchWritableBeforeCollectionWrite,\n  assertBranchWritableBeforeGlobalWrite,\n  recordBranchCreate,\n  stampBranchOnCreate,\n} from './hooks.js'\nimport { branchDocIDField, branchField, branchParentField, MAIN_BRANCH } from './types.js'\n\n/**\n * These columns are branch bookkeeping, not content. They are `admin.hidden`,\n * but hidden is not the same as read-only: the admin form round-trips every\n * field it loaded, so an edit made on a branch would submit the `_branch` it\n * was read with and stamp it back onto the shadow row — quietly moving that\n * row onto `main` and duplicating the document in production.\n *\n * Denying field-level create/update makes them internally writable only.\n * Field access is skipped under `overrideAccess: true`, which is exactly the\n * exemption merge needs to flip `_branch` to `'main'` (§16), and the\n * copy-on-write paths write through `payload.db` directly, below field access\n * entirely.\n */\nconst internalOnly = {\n  access: { create: () => false, update: () => false },\n  admin: { disabled: { bulkEdit: true }, hidden: true },\n} as const\n\n/**\n * `hidden` on top of that, for the columns nothing outside the branching engine\n * ever reads back.\n *\n * `admin.hidden` only keeps a field out of the edit form — it still ships in every\n * API response, which muddies the shape of every branched document. `hidden`\n * removes it from responses altogether. Reads that legitimately need to inspect\n * these columns pass `showHiddenFields: true`; the engine itself is unaffected,\n * because copy-on-write, merge and tombstoning all read through `payload.db`\n * directly, below the `afterRead` layer that does the stripping.\n *\n * Writes must never take these from round-tripped data: a read strips them, the\n * field default silently refills `_branch` with `main`, and writing that back\n * would flip a branch's row onto main. Both adapters set `_branch` explicitly on\n * global writes for exactly this reason.\n */\nconst bookkeepingOnly = {\n  ...internalOnly,\n  hidden: true,\n} as const\n\n/**\n * `_branch` — which branch a row belongs to. `'main'` is a non-null sentinel\n * rather than NULL so that compound `(field, _branch)` unique indexes keep\n * enforcing uniqueness among main rows on Postgres, which treats NULLs as\n * distinct.\n */\nexport const buildBranchField = (): TextField => ({\n  name: branchField,\n  type: 'text',\n  ...bookkeepingOnly,\n  defaultValue: MAIN_BRANCH,\n  index: true,\n  label: 'Branch',\n  required: true,\n})\n\n/**\n * `_branchDocID` — the canonical document this row represents. Null on main\n * rows, meaning \"self\".\n *\n * Declared as a self-referential `relationship` rather than `text` for two\n * reasons: it inherits the collection's own ID type (which may be text,\n * number, or a custom ID), and Payload's Drizzle builder special-cases\n * `not_in` for relationship fields to emit `(col NOT IN (...) OR col IS NULL)`,\n * without which every main row would be excluded from a branch read.\n */\nexport const buildBranchDocIDField = (slug: string): Field => ({\n  name: branchDocIDField,\n  type: 'relationship',\n  ...bookkeepingOnly,\n  index: true,\n  label: 'Branch Document',\n  maxDepth: 0,\n  relationTo: slug,\n})\n\n/** `_branchParent` — the canonical parent document, for version rows. */\nexport const buildBranchParentField = (slug: string): Field => ({\n  name: branchParentField,\n  type: 'relationship',\n  ...bookkeepingOnly,\n  index: true,\n  label: 'Branch Parent Document',\n  maxDepth: 0,\n  relationTo: slug,\n})\n\nconst hasField = (fields: Field[], name: string): boolean =>\n  fields.some((field) => 'name' in field && field.name === name)\n\nconst joinFieldPath = ({ name, parentPath }: { name: string; parentPath: string }): string =>\n  parentPath ? `${parentPath}.${name}` : name\n\nconst rewriteUniqueFields = ({\n  fields,\n  indexes,\n  parentPath = '',\n}: {\n  fields: Field[]\n  indexes: CompoundIndex[]\n  parentPath?: string\n}): void => {\n  for (const field of fields) {\n    if (fieldAffectsData(field) && 'unique' in field && field.unique) {\n      const fieldPath = joinFieldPath({ name: field.name, parentPath })\n\n      field.unique = false\n      indexes.push({\n        fields: [fieldPath, branchField],\n        ...(field.required === true ? {} : { requireExists: [fieldPath] }),\n        unique: true,\n      })\n    }\n\n    if (field.type === 'collapsible' || field.type === 'group' || field.type === 'row') {\n      rewriteUniqueFields({\n        fields: field.fields,\n        indexes,\n        parentPath:\n          field.type === 'group' && fieldAffectsData(field)\n            ? joinFieldPath({ name: field.name, parentPath })\n            : parentPath,\n      })\n    } else if (field.type === 'tabs') {\n      for (const tab of field.tabs) {\n        rewriteUniqueFields({\n          fields: tab.fields,\n          indexes,\n          parentPath: tabHasName(tab) ? joinFieldPath({ name: tab.name, parentPath }) : parentPath,\n        })\n      }\n    }\n  }\n}\n\n/**\n * Injects the branch discriminator fields and rewrites `unique: true` fields\n * into branch-scoped compound indexes.\n *\n * A branch holds a full copy of a document, so an unscoped unique index would\n * reject the copy outright. Scoping by `_branch` lets two branches each hold a\n * document with the same value while preserving uniqueness within a branch.\n */\nexport const injectBranchFields = (collection: CollectionConfig): CollectionConfig => {\n  if (!hasField(collection.fields, branchField)) {\n    collection.fields.push(buildBranchField())\n  }\n\n  if (!hasField(collection.fields, branchDocIDField)) {\n    collection.fields.push(buildBranchDocIDField(collection.slug))\n  }\n\n  const indexes = (collection.indexes ?? []).map((index) =>\n    index.unique && !index.fields.includes(branchField)\n      ? { ...index, fields: [...index.fields, branchField] }\n      : index,\n  )\n\n  // Catches two concurrent first-edits of the same document on the same branch:\n  // whichever write loses the race gets a constraint violation from the\n  // database instead of a second, silently duplicate shadow row. Scoped to rows\n  // that have a `_branchDocID` at all — a main row's is null, and a unique\n  // index would otherwise treat every main row as colliding with every other.\n  indexes.push({\n    fields: [branchDocIDField, branchField],\n    requireExists: [branchDocIDField],\n    unique: true,\n  })\n\n  rewriteUniqueFields({ fields: collection.fields, indexes })\n\n  collection.indexes = indexes\n\n  // `filename` is unique on upload collections, but it is added by upload\n  // sanitization — which runs *after* this — so the loop above cannot reach it and\n  // it would keep a global unique index. A branch's copy of an upload then\n  // collides with main's on filename, and forking or tombstoning it fails\n  // outright. Declaring the compound index up front is the supported way to scope\n  // it: `getBaseUploadFields` leaves `filename.unique` unset when it is present.\n  if (collection.upload) {\n    const upload = collection.upload === true ? {} : collection.upload\n\n    upload.filenameCompoundIndex ??= ['filename']\n\n    if (!upload.filenameCompoundIndex.includes(branchField)) {\n      upload.filenameCompoundIndex.push(branchField)\n    }\n\n    collection.upload = upload\n  }\n\n  collection.hooks = collection.hooks ?? {}\n  collection.hooks.beforeChange = [...(collection.hooks.beforeChange ?? []), stampBranchOnCreate]\n  collection.hooks.afterChange = [...(collection.hooks.afterChange ?? []), recordBranchCreate]\n  collection.hooks.beforeOperation = [\n    assertBranchWritableBeforeCollectionWrite,\n    ...(collection.hooks.beforeOperation ?? []),\n  ]\n\n  return collection\n}\n\n/**\n * Globals need only the discriminator.\n *\n * No `_branchDocID`, because a global's identity is its slug and is stable\n * across branches — the whole canonical-ID translation problem does not arise.\n */\nexport const injectGlobalBranchFields = (global: GlobalConfig): GlobalConfig => {\n  if (!hasField(global.fields, branchField)) {\n    // Each global has at most one row on a branch. Besides expressing that\n    // invariant, the unique key is the conflict target used by adapter upserts\n    // when concurrent requests make the first branch write.\n    global.fields.push({ ...buildBranchField(), unique: true })\n  }\n\n  global.hooks = global.hooks ?? {}\n  global.hooks.beforeOperation = [\n    assertBranchWritableBeforeGlobalWrite,\n    ...(global.hooks.beforeOperation ?? []),\n  ]\n\n  return global\n}\n"],"names":["fieldAffectsData","tabHasName","assertBranchWritableBeforeCollectionWrite","assertBranchWritableBeforeGlobalWrite","recordBranchCreate","stampBranchOnCreate","branchDocIDField","branchField","branchParentField","MAIN_BRANCH","internalOnly","access","create","update","admin","disabled","bulkEdit","hidden","bookkeepingOnly","buildBranchField","name","type","defaultValue","index","label","required","buildBranchDocIDField","slug","maxDepth","relationTo","buildBranchParentField","hasField","fields","some","field","joinFieldPath","parentPath","rewriteUniqueFields","indexes","unique","fieldPath","push","requireExists","tab","tabs","injectBranchFields","collection","map","includes","upload","filenameCompoundIndex","hooks","beforeChange","afterChange","beforeOperation","injectGlobalBranchFields","global"],"mappings":"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"}