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

package/dist/branching/endpoints/merge.js

@@ -0,0 +1,119 @@
+import { Forbidden, NotFound } from '../../errors/index.js';
+import { headersWithCors } from '../../utilities/headersWithCors.js';
+import { httpStatus } from '../../utilities/httpStatus.js';
+import { mergeBranch } from '../merge.js';
+import { isolateBranchState } from '../resolveBranch.js';
+import { branchesCollectionSlug } from '../types.js';
+/**
+ * `POST /<branches>/:id/merge`
+ *
+ * Runs with `overrideAccess: false` and the authenticated user, so the
+ * per-document preflight applies. This is the boundary at which branching's
+ * access model is actually enforced. The Local API uses the same secure default;
+ * trusted server-side callers must opt in to bypassing it.
+ *
+ * `stream: true` switches the response to NDJSON progress events. A merge walks
+ * an arbitrary number of documents one at a time, so the admin panel needs to
+ * report where it is; streaming the loop it already runs avoids inventing a job
+ * and a polling endpoint to carry that state.
+ */ export const mergeBranchHandler = async (req)=>{
+    const { payload, routeParams } = req;
+    const id = routeParams?.id;
+    if (!req.user) {
+        throw new Forbidden(req.t);
+    }
+    const branchDoc = await payload.findByID({
+        id,
+        collection: branchesCollectionSlug,
+        disableErrors: true,
+        overrideAccess: false,
+        req
+    });
+    if (!branchDoc) {
+        throw new NotFound(req.t);
+    }
+    const body = req.data ?? {};
+    const branch = branchDoc.slug;
+    if (body.stream && !body.dryRun) {
+        return streamMerge({
+            branch,
+            changes: body.changes,
+            closeBranch: Boolean(body.closeBranch),
+            req
+        });
+    }
+    const result = await mergeBranch(payload, {
+        branch,
+        changes: body.changes,
+        closeBranch: Boolean(body.closeBranch),
+        dryRun: Boolean(body.dryRun),
+        overrideAccess: false,
+        req
+    });
+    // Nothing could be applied and something was refused: report it as a refusal
+    // rather than an empty success, so a programmatic caller sees the same
+    // per-document reasons the admin UI would show.
+    const status = result.validationErrors.length ? httpStatus.UNPROCESSABLE_ENTITY : !result.canMerge && result.blocked.length ? httpStatus.FORBIDDEN : httpStatus.OK;
+    return Response.json(result, {
+        headers: headersWithCors({
+            headers: new Headers(),
+            req
+        }),
+        status
+    });
+};
+const streamMerge = ({ branch, changes, closeBranch, req })=>{
+    const { payload, user } = req;
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start (controller) {
+            const send = (event)=>controller.enqueue(encoder.encode(`${JSON.stringify(event)}\n`));
+            try {
+                const mergeReq = isolateBranchState(req);
+                delete mergeReq.transactionID;
+                const result = await mergeBranch(payload, {
+                    branch,
+                    changes,
+                    closeBranch,
+                    onProgress: (progress)=>send({
+                            type: 'progress',
+                            ...progress
+                        }),
+                    overrideAccess: false,
+                    req: mergeReq,
+                    user: user
+                });
+                send({
+                    type: 'complete',
+                    result
+                });
+            } catch (err) {
+                // The status line is long gone, so a failure has to be reported inside the
+                // body. Clients treat a stream that ends without `complete` as failed too,
+                // which covers a connection dropped mid-merge.
+                payload.logger.error({
+                    err,
+                    msg: `Streamed merge of branch "${branch}" failed`
+                });
+                send({
+                    type: 'error',
+                    message: err instanceof Error ? err.message : 'Unknown error'
+                });
+            } finally{
+                controller.close();
+            }
+        }
+    });
+    return new Response(stream, {
+        headers: headersWithCors({
+            headers: new Headers({
+                'Cache-Control': 'no-cache, no-transform',
+                'Content-Type': 'application/x-ndjson; charset=utf-8'
+            }),
+            req
+        }),
+        status: httpStatus.OK
+    });
+};
+
+//# sourceMappingURL=merge.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/endpoints/merge.ts"],"sourcesContent":["import type { PayloadHandler } from '../../config/types.js'\nimport type { MergeResult } from '../merge.js'\nimport type { MergeProgress } from '../types.js'\n\nimport { Forbidden, NotFound } from '../../errors/index.js'\nimport { headersWithCors } from '../../utilities/headersWithCors.js'\nimport { httpStatus } from '../../utilities/httpStatus.js'\nimport { mergeBranch } from '../merge.js'\nimport { isolateBranchState } from '../resolveBranch.js'\nimport { branchesCollectionSlug } from '../types.js'\n\n/**\n * One line of the streamed merge response.\n *\n * NDJSON rather than server-sent events: the client is a `fetch` reading a\n * `ReadableStream`, not an `EventSource`, so the framing SSE adds buys nothing —\n * and one JSON object per line is trivially parseable from a reader loop.\n */\nexport type MergeStreamEvent =\n  | { message: string; type: 'error' }\n  | { result: MergeResult; type: 'complete' }\n  | ({ type: 'progress' } & MergeProgress)\n\n/**\n * `POST /<branches>/:id/merge`\n *\n * Runs with `overrideAccess: false` and the authenticated user, so the\n * per-document preflight applies. This is the boundary at which branching's\n * access model is actually enforced. The Local API uses the same secure default;\n * trusted server-side callers must opt in to bypassing it.\n *\n * `stream: true` switches the response to NDJSON progress events. A merge walks\n * an arbitrary number of documents one at a time, so the admin panel needs to\n * report where it is; streaming the loop it already runs avoids inventing a job\n * and a polling endpoint to carry that state.\n */\nexport const mergeBranchHandler: PayloadHandler = async (req) => {\n  const { payload, routeParams } = req\n  const id = routeParams?.id as number | string\n\n  if (!req.user) {\n    throw new Forbidden(req.t)\n  }\n\n  const branchDoc = await payload.findByID({\n    id,\n    collection: branchesCollectionSlug,\n    disableErrors: true,\n    overrideAccess: false,\n    req,\n  })\n\n  if (!branchDoc) {\n    throw new NotFound(req.t)\n  }\n\n  const body = (req.data ?? {}) as {\n    changes?: (number | string)[]\n    closeBranch?: boolean\n    dryRun?: boolean\n    stream?: boolean\n  }\n\n  const branch = branchDoc.slug as string\n\n  if (body.stream && !body.dryRun) {\n    return streamMerge({\n      branch,\n      changes: body.changes,\n      closeBranch: Boolean(body.closeBranch),\n      req,\n    })\n  }\n\n  const result = await mergeBranch(payload, {\n    branch,\n    changes: body.changes,\n    closeBranch: Boolean(body.closeBranch),\n    dryRun: Boolean(body.dryRun),\n    overrideAccess: false,\n    req,\n  })\n\n  // Nothing could be applied and something was refused: report it as a refusal\n  // rather than an empty success, so a programmatic caller sees the same\n  // per-document reasons the admin UI would show.\n  const status = result.validationErrors.length\n    ? httpStatus.UNPROCESSABLE_ENTITY\n    : !result.canMerge && result.blocked.length\n      ? httpStatus.FORBIDDEN\n      : httpStatus.OK\n\n  return Response.json(result, {\n    headers: headersWithCors({ headers: new Headers(), req }),\n    status,\n  })\n}\n\nconst streamMerge = ({\n  branch,\n  changes,\n  closeBranch,\n  req,\n}: {\n  branch: string\n  changes?: (number | string)[]\n  closeBranch: boolean\n  req: Parameters<PayloadHandler>[0]\n}): Response => {\n  const { payload, user } = req\n  const encoder = new TextEncoder()\n\n  const stream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      const send = (event: MergeStreamEvent) =>\n        controller.enqueue(encoder.encode(`${JSON.stringify(event)}\\n`))\n\n      try {\n        const mergeReq = isolateBranchState(req)\n\n        delete mergeReq.transactionID\n\n        const result = await mergeBranch(payload, {\n          branch,\n          changes,\n          closeBranch,\n          onProgress: (progress) => send({ type: 'progress', ...progress }),\n          overrideAccess: false,\n          req: mergeReq,\n          user: user!,\n        })\n\n        send({ type: 'complete', result })\n      } catch (err) {\n        // The status line is long gone, so a failure has to be reported inside the\n        // body. Clients treat a stream that ends without `complete` as failed too,\n        // which covers a connection dropped mid-merge.\n        payload.logger.error({ err, msg: `Streamed merge of branch \"${branch}\" failed` })\n\n        send({\n          type: 'error',\n          message: err instanceof Error ? err.message : 'Unknown error',\n        })\n      } finally {\n        controller.close()\n      }\n    },\n  })\n\n  return new Response(stream, {\n    headers: headersWithCors({\n      headers: new Headers({\n        'Cache-Control': 'no-cache, no-transform',\n        'Content-Type': 'application/x-ndjson; charset=utf-8',\n      }),\n      req,\n    }),\n    status: httpStatus.OK,\n  })\n}\n"],"names":["Forbidden","NotFound","headersWithCors","httpStatus","mergeBranch","isolateBranchState","branchesCollectionSlug","mergeBranchHandler","req","payload","routeParams","id","user","t","branchDoc","findByID","collection","disableErrors","overrideAccess","body","data","branch","slug","stream","dryRun","streamMerge","changes","closeBranch","Boolean","result","status","validationErrors","length","UNPROCESSABLE_ENTITY","canMerge","blocked","FORBIDDEN","OK","Response","json","headers","Headers","encoder","TextEncoder","ReadableStream","start","controller","send","event","enqueue","encode","JSON","stringify","mergeReq","transactionID","onProgress","progress","type","err","logger","error","msg","message","Error","close"],"mappings":"AAIA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,wBAAuB;AAC3D,SAASC,eAAe,QAAQ,qCAAoC;AACpE,SAASC,UAAU,QAAQ,gCAA+B;AAC1D,SAASC,WAAW,QAAQ,cAAa;AACzC,SAASC,kBAAkB,QAAQ,sBAAqB;AACxD,SAASC,sBAAsB,QAAQ,cAAa;AAcpD;;;;;;;;;;;;CAYC,GACD,OAAO,MAAMC,qBAAqC,OAAOC;IACvD,MAAM,EAAEC,OAAO,EAAEC,WAAW,EAAE,GAAGF;IACjC,MAAMG,KAAKD,aAAaC;IAExB,IAAI,CAACH,IAAII,IAAI,EAAE;QACb,MAAM,IAAIZ,UAAUQ,IAAIK,CAAC;IAC3B;IAEA,MAAMC,YAAY,MAAML,QAAQM,QAAQ,CAAC;QACvCJ;QACAK,YAAYV;QACZW,eAAe;QACfC,gBAAgB;QAChBV;IACF;IAEA,IAAI,CAACM,WAAW;QACd,MAAM,IAAIb,SAASO,IAAIK,CAAC;IAC1B;IAEA,MAAMM,OAAQX,IAAIY,IAAI,IAAI,CAAC;IAO3B,MAAMC,SAASP,UAAUQ,IAAI;IAE7B,IAAIH,KAAKI,MAAM,IAAI,CAACJ,KAAKK,MAAM,EAAE;QAC/B,OAAOC,YAAY;YACjBJ;YACAK,SAASP,KAAKO,OAAO;YACrBC,aAAaC,QAAQT,KAAKQ,WAAW;YACrCnB;QACF;IACF;IAEA,MAAMqB,SAAS,MAAMzB,YAAYK,SAAS;QACxCY;QACAK,SAASP,KAAKO,OAAO;QACrBC,aAAaC,QAAQT,KAAKQ,WAAW;QACrCH,QAAQI,QAAQT,KAAKK,MAAM;QAC3BN,gBAAgB;QAChBV;IACF;IAEA,6EAA6E;IAC7E,uEAAuE;IACvE,gDAAgD;IAChD,MAAMsB,SAASD,OAAOE,gBAAgB,CAACC,MAAM,GACzC7B,WAAW8B,oBAAoB,GAC/B,CAACJ,OAAOK,QAAQ,IAAIL,OAAOM,OAAO,CAACH,MAAM,GACvC7B,WAAWiC,SAAS,GACpBjC,WAAWkC,EAAE;IAEnB,OAAOC,SAASC,IAAI,CAACV,QAAQ;QAC3BW,SAAStC,gBAAgB;YAAEsC,SAAS,IAAIC;YAAWjC;QAAI;QACvDsB;IACF;AACF,EAAC;AAED,MAAML,cAAc,CAAC,EACnBJ,MAAM,EACNK,OAAO,EACPC,WAAW,EACXnB,GAAG,EAMJ;IACC,MAAM,EAAEC,OAAO,EAAEG,IAAI,EAAE,GAAGJ;IAC1B,MAAMkC,UAAU,IAAIC;IAEpB,MAAMpB,SAAS,IAAIqB,eAA2B;QAC5C,MAAMC,OAAMC,UAAU;YACpB,MAAMC,OAAO,CAACC,QACZF,WAAWG,OAAO,CAACP,QAAQQ,MAAM,CAAC,GAAGC,KAAKC,SAAS,CAACJ,OAAO,EAAE,CAAC;YAEhE,IAAI;gBACF,MAAMK,WAAWhD,mBAAmBG;gBAEpC,OAAO6C,SAASC,aAAa;gBAE7B,MAAMzB,SAAS,MAAMzB,YAAYK,SAAS;oBACxCY;oBACAK;oBACAC;oBACA4B,YAAY,CAACC,WAAaT,KAAK;4BAAEU,MAAM;4BAAY,GAAGD,QAAQ;wBAAC;oBAC/DtC,gBAAgB;oBAChBV,KAAK6C;oBACLzC,MAAMA;gBACR;gBAEAmC,KAAK;oBAAEU,MAAM;oBAAY5B;gBAAO;YAClC,EAAE,OAAO6B,KAAK;gBACZ,2EAA2E;gBAC3E,2EAA2E;gBAC3E,+CAA+C;gBAC/CjD,QAAQkD,MAAM,CAACC,KAAK,CAAC;oBAAEF;oBAAKG,KAAK,CAAC,0BAA0B,EAAExC,OAAO,QAAQ,CAAC;gBAAC;gBAE/E0B,KAAK;oBACHU,MAAM;oBACNK,SAASJ,eAAeK,QAAQL,IAAII,OAAO,GAAG;gBAChD;YACF,SAAU;gBACRhB,WAAWkB,KAAK;YAClB;QACF;IACF;IAEA,OAAO,IAAI1B,SAASf,QAAQ;QAC1BiB,SAAStC,gBAAgB;YACvBsC,SAAS,IAAIC,QAAQ;gBACnB,iBAAiB;gBACjB,gBAAgB;YAClB;YACAjC;QACF;QACAsB,QAAQ3B,WAAWkC,EAAE;IACvB;AACF"}

package/dist/branching/forkDocument.d.ts

@@ -0,0 +1,20 @@
+import type { PayloadRequest } from '../types/index.js';
+type Args = {
+    collectionSlug: string;
+    id: number | string;
+    req: PayloadRequest;
+    /** Creates a new shadow in the request's existing transaction. */
+    useAmbientTransaction?: boolean;
+};
+/**
+ * Copy-on-write: ensures the active branch has its own row for a document, and
+ * returns that row's primary key.
+ *
+ * Returns the id unchanged on main, or when the branch already has a shadow
+ * row. Otherwise it copies the main row wholesale — a full copy rather than a
+ * diff, so the branch's version can be filtered and sorted on by the database
+ * like any other row.
+ */
+export declare const forkDocument: ({ id, collectionSlug, req, useAmbientTransaction, }: Args) => Promise<number | string>;
+export {};
+//# sourceMappingURL=forkDocument.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"forkDocument.d.ts","sourceRoot":"","sources":["../../src/branching/forkDocument.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAgBvD,KAAK,IAAI,GAAG;IACV,cAAc,EAAE,MAAM,CAAA;IACtB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,GAAG,EAAE,cAAc,CAAA;IACnB,kEAAkE;IAClE,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,wDAKtB,IAAI,KAAG,OAAO,CAAC,MAAM,GAAG,MAAM,CA+HhC,CAAA"}

package/dist/branching/forkDocument.js

@@ -0,0 +1,169 @@
+import { APIError } from '../errors/index.js';
+import { copyUploadFilesToBranch } from './copyUploadFilesToBranch.js';
+import { createShadowRow } from './createShadowRow.js';
+import { addToBranchManifest, loadBranchManifest, peekBranchOperation, peekBranchRowID, rememberBranchRowID, resolveBranch } from './resolveBranch.js';
+import { branchChangesCollectionSlug, branchDocIDField, branchField, MAIN_BRANCH } from './types.js';
+import { findBranchVersionForkBoundary } from './versions.js';
+/**
+ * Copy-on-write: ensures the active branch has its own row for a document, and
+ * returns that row's primary key.
+ *
+ * Returns the id unchanged on main, or when the branch already has a shadow
+ * row. Otherwise it copies the main row wholesale — a full copy rather than a
+ * diff, so the branch's version can be filtered and sorted on by the database
+ * like any other row.
+ */ export const forkDocument = async ({ id, collectionSlug, req, useAmbientTransaction = false })=>{
+    const branch = resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return id;
+    }
+    const branching = req.payload.config.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return id;
+    }
+    const remembered = peekBranchRowID({
+        collectionSlug,
+        docID: id,
+        req
+    });
+    if (remembered !== undefined) {
+        await loadBranchManifest(req);
+        if (!peekBranchOperation({
+            collectionSlug,
+            docID: id,
+            req
+        })) {
+            throw new APIError(`The ${collectionSlug} branch row for document ${String(id)} has no change record.`, 409);
+        }
+        return remembered;
+    }
+    // One query for all three questions this used to ask separately: does the branch
+    // already have a copy (by canonical ID), is this row the branch's own creation (by its
+    // primary key), and failing both, what does main hold? A branch row wins when both come
+    // back — the same pick `pickBranchGlobal` makes for globals.
+    const { docs } = await req.payload.db.find({
+        branch: false,
+        collection: collectionSlug,
+        limit: 2,
+        pagination: false,
+        req,
+        where: {
+            and: [
+                {
+                    [branchField]: {
+                        in: [
+                            branch,
+                            MAIN_BRANCH
+                        ]
+                    }
+                },
+                {
+                    or: [
+                        {
+                            id: {
+                                equals: id
+                            }
+                        },
+                        {
+                            [branchDocIDField]: {
+                                equals: id
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    });
+    const rows = docs;
+    const onBranch = rows.find((row)=>row[branchField] === branch);
+    if (onBranch) {
+        await loadBranchManifest(req);
+        if (!peekBranchOperation({
+            collectionSlug,
+            docID: id,
+            req
+        })) {
+            throw new APIError(`The ${collectionSlug} branch row for document ${String(id)} has no change record.`, 409);
+        }
+        const rowID = onBranch.id;
+        rememberBranchRowID({
+            collectionSlug,
+            docID: id,
+            req,
+            rowID
+        });
+        return rowID;
+    }
+    const mainDoc = rows.find((row)=>row[branchField] === MAIN_BRANCH);
+    if (!mainDoc) {
+        return id;
+    }
+    const shadow = await createShadowRow({
+        branch,
+        collectionSlug,
+        data: {
+            [branchDocIDField]: id,
+            [branchField]: branch
+        },
+        docID: id,
+        onCreated: async (createReq, createdShadow)=>{
+            const collection = createReq.payload.collections[collectionSlug];
+            if (collection?.config.upload) {
+                await copyUploadFilesToBranch({
+                    branch,
+                    collection: collection.config,
+                    doc: createdShadow,
+                    req: createReq
+                });
+            }
+            const versionBoundary = await findBranchVersionForkBoundary({
+                collectionSlug,
+                docID: id,
+                req: createReq
+            });
+            return createReq.payload.create({
+                collection: branchChangesCollectionSlug,
+                data: {
+                    baseUpdatedAt: mainDoc.updatedAt,
+                    ...versionBoundary,
+                    branch,
+                    collectionSlug,
+                    doc: {
+                        relationTo: collectionSlug,
+                        value: id
+                    },
+                    documentID: String(id),
+                    entityType: 'collection',
+                    operation: 'update',
+                    rowID: String(createdShadow.id)
+                },
+                overrideAccess: true,
+                req: createReq
+            });
+        },
+        req,
+        source: {
+            id,
+            branch: MAIN_BRANCH
+        },
+        useAmbientTransaction
+    });
+    // The manifest now has one more entry. Added rather than reloaded: dropping the memoized
+    // copy made the next read in this request re-query every change row on the branch to
+    // learn one ID, and every save the admin panel makes is a write followed by a read.
+    addToBranchManifest({
+        collectionSlug,
+        docID: id,
+        operation: 'update',
+        req
+    });
+    rememberBranchRowID({
+        collectionSlug,
+        docID: id,
+        req,
+        rowID: shadow.id
+    });
+    return shadow.id;
+};
+
+//# sourceMappingURL=forkDocument.js.map

package/dist/branching/forkDocument.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/forkDocument.ts"],"sourcesContent":["import type { PayloadRequest } from '../types/index.js'\n\nimport { APIError } from '../errors/index.js'\nimport { copyUploadFilesToBranch } from './copyUploadFilesToBranch.js'\nimport { createShadowRow } from './createShadowRow.js'\nimport {\n  addToBranchManifest,\n  loadBranchManifest,\n  peekBranchOperation,\n  peekBranchRowID,\n  rememberBranchRowID,\n  resolveBranch,\n} from './resolveBranch.js'\nimport { branchChangesCollectionSlug, branchDocIDField, branchField, MAIN_BRANCH } from './types.js'\nimport { findBranchVersionForkBoundary } from './versions.js'\n\ntype Args = {\n  collectionSlug: string\n  id: number | string\n  req: PayloadRequest\n  /** Creates a new shadow in the request's existing transaction. */\n  useAmbientTransaction?: boolean\n}\n\n/**\n * Copy-on-write: ensures the active branch has its own row for a document, and\n * returns that row's primary key.\n *\n * Returns the id unchanged on main, or when the branch already has a shadow\n * row. Otherwise it copies the main row wholesale — a full copy rather than a\n * diff, so the branch's version can be filtered and sorted on by the database\n * like any other row.\n */\nexport const forkDocument = async ({\n  id,\n  collectionSlug,\n  req,\n  useAmbientTransaction = false,\n}: Args): Promise<number | string> => {\n  const branch = resolveBranch(req)\n\n  if (branch === MAIN_BRANCH) {\n    return id\n  }\n\n  const branching = req.payload.config.branching\n\n  if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {\n    return id\n  }\n\n  const remembered = peekBranchRowID({ collectionSlug, docID: id, req })\n\n  if (remembered !== undefined) {\n    await loadBranchManifest(req)\n\n    if (!peekBranchOperation({ collectionSlug, docID: id, req })) {\n      throw new APIError(\n        `The ${collectionSlug} branch row for document ${String(id)} has no change record.`,\n        409,\n      )\n    }\n\n    return remembered\n  }\n\n  // One query for all three questions this used to ask separately: does the branch\n  // already have a copy (by canonical ID), is this row the branch's own creation (by its\n  // primary key), and failing both, what does main hold? A branch row wins when both come\n  // back — the same pick `pickBranchGlobal` makes for globals.\n  const { docs } = await req.payload.db.find({\n    branch: false,\n    collection: collectionSlug,\n    limit: 2,\n    pagination: false,\n    req,\n    where: {\n      and: [\n        { [branchField]: { in: [branch, MAIN_BRANCH] } },\n        { or: [{ id: { equals: id } }, { [branchDocIDField]: { equals: id } }] },\n      ],\n    },\n  })\n\n  const rows = docs as Record<string, unknown>[]\n  const onBranch = rows.find((row) => row[branchField] === branch)\n\n  if (onBranch) {\n    await loadBranchManifest(req)\n\n    if (!peekBranchOperation({ collectionSlug, docID: id, req })) {\n      throw new APIError(\n        `The ${collectionSlug} branch row for document ${String(id)} has no change record.`,\n        409,\n      )\n    }\n\n    const rowID = onBranch.id as number | string\n\n    rememberBranchRowID({ collectionSlug, docID: id, req, rowID })\n\n    return rowID\n  }\n\n  const mainDoc = rows.find((row) => row[branchField] === MAIN_BRANCH)\n\n  if (!mainDoc) {\n    return id\n  }\n\n  const shadow = await createShadowRow({\n    branch,\n    collectionSlug,\n    data: {\n      [branchDocIDField]: id,\n      [branchField]: branch,\n    },\n    docID: id,\n    onCreated: async (createReq, createdShadow) => {\n      const collection = createReq.payload.collections[collectionSlug]\n\n      if (collection?.config.upload) {\n        await copyUploadFilesToBranch({\n          branch,\n          collection: collection.config,\n          doc: createdShadow,\n          req: createReq,\n        })\n      }\n\n      const versionBoundary = await findBranchVersionForkBoundary({\n        collectionSlug,\n        docID: id,\n        req: createReq,\n      })\n\n      return createReq.payload.create({\n        collection: branchChangesCollectionSlug,\n        data: {\n          baseUpdatedAt: mainDoc.updatedAt,\n          ...versionBoundary,\n          branch,\n          collectionSlug,\n          doc: { relationTo: collectionSlug, value: id },\n          documentID: String(id),\n          entityType: 'collection',\n          operation: 'update',\n          rowID: String(createdShadow.id),\n        },\n        overrideAccess: true,\n        req: createReq,\n      })\n    },\n    req,\n    source: { id, branch: MAIN_BRANCH },\n    useAmbientTransaction,\n  })\n\n  // The manifest now has one more entry. Added rather than reloaded: dropping the memoized\n  // copy made the next read in this request re-query every change row on the branch to\n  // learn one ID, and every save the admin panel makes is a write followed by a read.\n  addToBranchManifest({ collectionSlug, docID: id, operation: 'update', req })\n  rememberBranchRowID({ collectionSlug, docID: id, req, rowID: shadow.id as number | string })\n\n  return shadow.id as number | string\n}\n"],"names":["APIError","copyUploadFilesToBranch","createShadowRow","addToBranchManifest","loadBranchManifest","peekBranchOperation","peekBranchRowID","rememberBranchRowID","resolveBranch","branchChangesCollectionSlug","branchDocIDField","branchField","MAIN_BRANCH","findBranchVersionForkBoundary","forkDocument","id","collectionSlug","req","useAmbientTransaction","branch","branching","payload","config","enabled","branchableCollections","has","remembered","docID","undefined","String","docs","db","find","collection","limit","pagination","where","and","in","or","equals","rows","onBranch","row","rowID","mainDoc","shadow","data","onCreated","createReq","createdShadow","collections","upload","doc","versionBoundary","create","baseUpdatedAt","updatedAt","relationTo","value","documentID","entityType","operation","overrideAccess","source"],"mappings":"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"}

package/dist/branching/globalMergeWrites.d.ts

@@ -0,0 +1,21 @@
+import type { Payload, PayloadRequest } from '../types/index.js';
+export type GlobalMergeWrite = {
+    draft: boolean;
+};
+type BaseArgs = {
+    branch: string;
+    globalSlug: string;
+    payload: Payload;
+    req: PayloadRequest;
+};
+/** Resolves only the latest source state that should be applied to main. */
+export declare const resolveGlobalMergeWrites: ({ branch, globalSlug, payload, req, }: BaseArgs) => Promise<GlobalMergeWrite[]>;
+/** Returns the locales that require distinct writes for one global. */
+export declare const getGlobalMergeLocales: ({ globalSlug, payload, req, }: Omit<BaseArgs, 'branch'>) => string[];
+/** Reads one exact stored branch-global state without hooks, defaults, access, or population. */
+export declare const readBranchGlobalWrite: ({ branch, draft, globalSlug, locale, payload, req, }: {
+    draft: boolean;
+    locale: string;
+} & BaseArgs) => Promise<null | Record<string, unknown>>;
+export {};
+//# sourceMappingURL=globalMergeWrites.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globalMergeWrites.d.ts","sourceRoot":"","sources":["../../src/branching/globalMergeWrites.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAOhE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,4EAA4E;AAC5E,eAAO,MAAM,wBAAwB,0CAKlC,QAAQ,KAAG,OAAO,CAAC,gBAAgB,EAAE,CAmCvC,CAAA;AAED,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,kCAI/B,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAG,MAAM,EAWnC,CAAA;AAED,iGAAiG;AACjG,eAAO,MAAM,qBAAqB,yDAO/B;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,QAAQ,KAAG,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA6DxF,CAAA"}

package/dist/branching/globalMergeWrites.js

@@ -0,0 +1,146 @@
+import { afterRead } from '../fields/hooks/afterRead/index.js';
+import { traverseForLocalizedFields } from '../utilities/traverseForLocalizedFields.js';
+import { isolateBranchState } from './resolveBranch.js';
+import { branchField, MAIN_BRANCH } from './types.js';
+/** Resolves only the latest source state that should be applied to main. */ export const resolveGlobalMergeWrites = async ({ branch, globalSlug, payload, req })=>{
+    const branchGlobal = await payload.db.findGlobal({
+        slug: globalSlug,
+        branch: false,
+        locale: 'all',
+        req,
+        where: {
+            [branchField]: {
+                equals: branch
+            }
+        }
+    });
+    const hasPublishedWrite = Boolean(branchGlobal && Object.keys(branchGlobal).length);
+    const globalConfig = payload.globals.config.find(({ slug })=>slug === globalSlug);
+    if (!globalConfig?.versions) {
+        return hasPublishedWrite ? [
+            {
+                draft: false
+            }
+        ] : [];
+    }
+    const { docs } = await payload.db.findGlobalVersions({
+        branch: false,
+        global: globalSlug,
+        limit: 1,
+        locale: 'all',
+        pagination: false,
+        req,
+        sort: '-updatedAt',
+        where: {
+            and: [
+                {
+                    [branchField]: {
+                        equals: branch
+                    }
+                },
+                {
+                    latest: {
+                        equals: true
+                    }
+                }
+            ]
+        }
+    });
+    const latestVersion = docs[0]?.version;
+    const hasNewerDraft = latestVersion ? statusIncludesDraft(latestVersion._status) : false;
+    if (hasNewerDraft) {
+        return [
+            {
+                draft: true
+            }
+        ];
+    }
+    return hasPublishedWrite ? [
+        {
+            draft: false
+        }
+    ] : [];
+};
+/** Returns the locales that require distinct writes for one global. */ export const getGlobalMergeLocales = ({ globalSlug, payload, req })=>{
+    const globalConfig = payload.globals.config.find(({ slug })=>slug === globalSlug);
+    const localization = payload.config.localization;
+    if (globalConfig && localization && traverseForLocalizedFields(globalConfig.fields)) {
+        return localization.localeCodes;
+    }
+    const defaultLocale = localization && localization.defaultLocale;
+    return [
+        req.locale && req.locale !== 'all' ? req.locale : defaultLocale || 'en'
+    ];
+};
+/** Reads one exact stored branch-global state without hooks, defaults, access, or population. */ export const readBranchGlobalWrite = async ({ branch, draft, globalSlug, locale, payload, req })=>{
+    const branchReq = isolateBranchState(req);
+    branchReq.branch = MAIN_BRANCH;
+    branchReq.locale = locale;
+    branchReq.context._branchBypass = true;
+    const globalConfig = payload.globals.config.find(({ slug })=>slug === globalSlug);
+    if (!globalConfig) {
+        return null;
+    }
+    let storedDocument;
+    if (draft && globalConfig.versions) {
+        const { docs } = await payload.db.findGlobalVersions({
+            branch: false,
+            global: globalSlug,
+            limit: 1,
+            locale,
+            pagination: false,
+            req: branchReq,
+            sort: '-updatedAt',
+            where: {
+                and: [
+                    {
+                        [branchField]: {
+                            equals: branch
+                        }
+                    },
+                    {
+                        latest: {
+                            equals: true
+                        }
+                    }
+                ]
+            }
+        });
+        storedDocument = docs[0]?.version ?? null;
+    } else {
+        storedDocument = await payload.db.findGlobal({
+            slug: globalSlug,
+            branch: false,
+            locale,
+            req: branchReq,
+            where: {
+                [branchField]: {
+                    equals: branch
+                }
+            }
+        });
+    }
+    if (!storedDocument || Object.keys(storedDocument).length === 0) {
+        return null;
+    }
+    return afterRead({
+        collection: null,
+        context: branchReq.context,
+        depth: 0,
+        doc: storedDocument,
+        draft,
+        fallbackLocale: null,
+        global: globalConfig,
+        locale,
+        overrideAccess: true,
+        req: branchReq,
+        showHiddenFields: true,
+        triggerAccessControl: false,
+        triggerDefaultValue: false,
+        triggerHooks: false,
+        triggerPopulation: false
+    });
+};
+const statusIncludesDraft = (status)=>status === 'draft' || Boolean(status) && typeof status === 'object' && Object.values(status).includes('draft');
+
+//# sourceMappingURL=globalMergeWrites.js.map

package/dist/branching/globalMergeWrites.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/globalMergeWrites.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from '../types/index.js'\n\nimport { afterRead } from '../fields/hooks/afterRead/index.js'\nimport { traverseForLocalizedFields } from '../utilities/traverseForLocalizedFields.js'\nimport { isolateBranchState } from './resolveBranch.js'\nimport { branchField, MAIN_BRANCH } from './types.js'\n\nexport type GlobalMergeWrite = {\n  draft: boolean\n}\n\ntype BaseArgs = {\n  branch: string\n  globalSlug: string\n  payload: Payload\n  req: PayloadRequest\n}\n\n/** Resolves only the latest source state that should be applied to main. */\nexport const resolveGlobalMergeWrites = async ({\n  branch,\n  globalSlug,\n  payload,\n  req,\n}: BaseArgs): Promise<GlobalMergeWrite[]> => {\n  const branchGlobal = await payload.db.findGlobal({\n    slug: globalSlug,\n    branch: false,\n    locale: 'all',\n    req,\n    where: { [branchField]: { equals: branch } },\n  })\n  const hasPublishedWrite = Boolean(branchGlobal && Object.keys(branchGlobal).length)\n  const globalConfig = payload.globals.config.find(({ slug }) => slug === globalSlug)\n\n  if (!globalConfig?.versions) {\n    return hasPublishedWrite ? [{ draft: false }] : []\n  }\n\n  const { docs } = await payload.db.findGlobalVersions({\n    branch: false,\n    global: globalSlug,\n    limit: 1,\n    locale: 'all',\n    pagination: false,\n    req,\n    sort: '-updatedAt',\n    where: {\n      and: [{ [branchField]: { equals: branch } }, { latest: { equals: true } }],\n    },\n  })\n  const latestVersion = docs[0]?.version as Record<string, unknown> | undefined\n  const hasNewerDraft = latestVersion ? statusIncludesDraft(latestVersion._status) : false\n\n  if (hasNewerDraft) {\n    return [{ draft: true }]\n  }\n\n  return hasPublishedWrite ? [{ draft: false }] : []\n}\n\n/** Returns the locales that require distinct writes for one global. */\nexport const getGlobalMergeLocales = ({\n  globalSlug,\n  payload,\n  req,\n}: Omit<BaseArgs, 'branch'>): string[] => {\n  const globalConfig = payload.globals.config.find(({ slug }) => slug === globalSlug)\n  const localization = payload.config.localization\n\n  if (globalConfig && localization && traverseForLocalizedFields(globalConfig.fields)) {\n    return localization.localeCodes\n  }\n\n  const defaultLocale = localization && localization.defaultLocale\n\n  return [req.locale && req.locale !== 'all' ? req.locale : defaultLocale || 'en']\n}\n\n/** Reads one exact stored branch-global state without hooks, defaults, access, or population. */\nexport const readBranchGlobalWrite = async ({\n  branch,\n  draft,\n  globalSlug,\n  locale,\n  payload,\n  req,\n}: { draft: boolean; locale: string } & BaseArgs): Promise<null | Record<string, unknown>> => {\n  const branchReq = isolateBranchState(req)\n\n  branchReq.branch = MAIN_BRANCH\n  branchReq.locale = locale\n  ;(branchReq.context as Record<string, unknown>)._branchBypass = true\n\n  const globalConfig = payload.globals.config.find(({ slug }) => slug === globalSlug)\n\n  if (!globalConfig) {\n    return null\n  }\n\n  let storedDocument: null | Record<string, unknown>\n\n  if (draft && globalConfig.versions) {\n    const { docs } = await payload.db.findGlobalVersions({\n      branch: false,\n      global: globalSlug,\n      limit: 1,\n      locale,\n      pagination: false,\n      req: branchReq,\n      sort: '-updatedAt',\n      where: {\n        and: [{ [branchField]: { equals: branch } }, { latest: { equals: true } }],\n      },\n    })\n\n    storedDocument = (docs[0]?.version as Record<string, unknown> | undefined) ?? null\n  } else {\n    storedDocument = (await payload.db.findGlobal({\n      slug: globalSlug,\n      branch: false,\n      locale,\n      req: branchReq,\n      where: { [branchField]: { equals: branch } },\n    })) as null | Record<string, unknown>\n  }\n\n  if (!storedDocument || Object.keys(storedDocument).length === 0) {\n    return null\n  }\n\n  return afterRead({\n    collection: null,\n    context: branchReq.context,\n    depth: 0,\n    doc: storedDocument,\n    draft,\n    fallbackLocale: null,\n    global: globalConfig,\n    locale,\n    overrideAccess: true,\n    req: branchReq,\n    showHiddenFields: true,\n    triggerAccessControl: false,\n    triggerDefaultValue: false,\n    triggerHooks: false,\n    triggerPopulation: false,\n  })\n}\n\nconst statusIncludesDraft = (status: unknown): boolean =>\n  status === 'draft' ||\n  (Boolean(status) &&\n    typeof status === 'object' &&\n    Object.values(status as Record<string, unknown>).includes('draft'))\n"],"names":["afterRead","traverseForLocalizedFields","isolateBranchState","branchField","MAIN_BRANCH","resolveGlobalMergeWrites","branch","globalSlug","payload","req","branchGlobal","db","findGlobal","slug","locale","where","equals","hasPublishedWrite","Boolean","Object","keys","length","globalConfig","globals","config","find","versions","draft","docs","findGlobalVersions","global","limit","pagination","sort","and","latest","latestVersion","version","hasNewerDraft","statusIncludesDraft","_status","getGlobalMergeLocales","localization","fields","localeCodes","defaultLocale","readBranchGlobalWrite","branchReq","context","_branchBypass","storedDocument","collection","depth","doc","fallbackLocale","overrideAccess","showHiddenFields","triggerAccessControl","triggerDefaultValue","triggerHooks","triggerPopulation","status","values","includes"],"mappings":"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"}

package/dist/branching/globals.d.ts

@@ -0,0 +1,49 @@
+import type { PayloadRequest, Where } from '../types/index.js';
+type BaseArgs = {
+    branch?: false | string;
+    globalSlug: string;
+    req?: Partial<PayloadRequest>;
+};
+/**
+ * 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 declare const resolveBranchGlobalQuery: ({ branch, globalSlug, req, where, }: {
+    where: undefined | Where;
+} & BaseArgs) => undefined | Where;
+/** True when the read should fetch two rows so the branch's copy can win. */
+export declare const branchGlobalNeedsBothRows: (args: BaseArgs) => boolean;
+/** Picks the branch's copy of a global when it has one, else main's. */
+export declare const pickBranchGlobal: <T extends Record<string, any>>(docs: T[], branch: string) => T | undefined;
+/**
+ * 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 declare const resolveBranchGlobalWrite: (args: BaseArgs) => null | string;
+/** Registers a global as changed on a branch, if it is not already. */
+export declare const recordBranchGlobalChange: ({ branch, globalSlug, req, }: {
+    branch: string;
+} & BaseArgs) => Promise<void>;
+/**
+ * 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 declare const resolveBranchGlobalVersionQuery: ({ branch, globalSlug, req, where, }: {
+    where: undefined | Where;
+} & BaseArgs) => undefined | Where;
+export {};
+//# sourceMappingURL=globals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../../src/branching/globals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAU9D,KAAK,QAAQ,GAAG;IACd,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC9B,CAAA;AAuBD;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,wCAKlC;IAAE,KAAK,EAAE,SAAS,GAAG,KAAK,CAAA;CAAE,GAAG,QAAQ,KAAG,SAAS,GAAG,KAcxD,CAAA;AAED,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,SAAU,QAAQ,KAAG,OAI1D,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,QACtD,CAAC,EAAE,UACD,MAAM,KACb,CAAC,GAAG,SAAyE,CAAA;AAEhF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,SAAU,QAAQ,KAAG,IAAI,GAAG,MAIhE,CAAA;AAED,uEAAuE;AACvE,eAAO,MAAM,wBAAwB,iCAIlC;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,QAAQ,KAAG,OAAO,CAAC,IAAI,CAsD9C,CAAA;AA0BD;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,wCAKzC;IAAE,KAAK,EAAE,SAAS,GAAG,KAAK,CAAA;CAAE,GAAG,QAAQ,KAAG,SAAS,GAAG,KAUxD,CAAA"}