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

package/dist/branching/versions.d.ts

@@ -0,0 +1,131 @@
+import type { Payload } from '../index.js';
+import type { PayloadRequest, Where } from '../types/index.js';
+type QueryArgs = {
+    branch?: false | string;
+    collectionSlug: string;
+    req?: Partial<PayloadRequest>;
+    where: undefined | Where;
+};
+export declare const findBranchVersionForkBoundary: ({ collectionSlug, docID, req, }: {
+    collectionSlug: string;
+    docID: number | string;
+    req: PayloadRequest;
+}) => Promise<{
+    baseVersionID?: string;
+    baseVersionUpdatedAt?: string;
+}>;
+/**
+ * Branch predicate for version queries.
+ *
+ * Mirrors the collection predicate, but a version row's canonical identity is
+ * its `parent` on main and its `_branchParent` on a branch — so the exclusion of
+ * shadowed main versions compares `parent`, which for a main version row is
+ * already the canonical document ID.
+ */
+export declare const resolveBranchVersionQuery: ({ branch: branchOverride, collectionSlug, req, where, }: QueryArgs) => Promise<undefined | Where>;
+/**
+ * Synchronous branch predicate for version joins.
+ *
+ * Join query builders run after the top-level read has loaded and memoized the branch manifest.
+ * This uses that state while sharing the exact query construction with
+ * {@link resolveBranchVersionQuery}.
+ */
+export declare const resolveBranchVersionQuerySync: ({ branch: branchOverride, collectionSlug, req, where, }: QueryArgs) => undefined | Where;
+/**
+ * Branch predicate for reading version *history*, as opposed to listing drafts.
+ *
+ * A branch's history reads as a continuation of main's: main's versions up to the
+ * point the branch forked are the branch's ancestry, the branch's own versions sit
+ * on top, and no other branch is visible. Anything main recorded after the fork
+ * belongs to main alone — it is not this branch's past.
+ *
+ * Deliberately *not* {@link resolveBranchVersionQuery}. That one hides main's
+ * versions for any shadowed document, which is right when listing one row per
+ * document and exactly wrong here: those hidden rows are the ancestry.
+ */
+export declare const resolveBranchVersionHistoryQuery: ({ branch: branchOverride, collectionSlug, req, where, }: QueryArgs) => Promise<undefined | Where>;
+/**
+ * Restores canonical document IDs on version rows read from a branch, whose
+ * `parent` is the shadow row rather than the document.
+ */
+export declare const projectBranchVersionParents: (docs: Record<string, any>[]) => void;
+/**
+ * Attaches a new version to the branch's own copy of the document.
+ *
+ * Without this a draft saved on a branch would append to main's version chain,
+ * which is both visible on main and destructive to its `latest` bookkeeping.
+ */
+export declare const resolveBranchVersionParent: ({ branch: branchOverride, collectionSlug, parent, req, versionData, }: {
+    branch?: false | string;
+    collectionSlug: string;
+    parent: number | string;
+    req?: Partial<PayloadRequest>;
+    versionData: Record<string, unknown>;
+}) => Promise<{
+    parent: number | string;
+    versionData: Record<string, unknown>;
+}>;
+/**
+ * Restores canonical document IDs on rows returned by `queryDrafts`, which
+ * surfaces a version's `parent` as the document ID.
+ */
+export declare const projectBranchVersionParent: (row: Record<string, any>) => number | string;
+/**
+ * The version rows this branch owns for one document.
+ *
+ * Every operation that reaches into an existing version chain needs this, not just
+ * deletes: a cascade after a delete, pruning to `maxPerDoc`, and rewriting the latest
+ * row on unpublish are all the same question — which rows belong to the branch doing
+ * the writing.
+ *
+ * Deleting a document cascades to its versions by `parent`. On a branch that is
+ * destructive: the delete becomes a tombstone rather than a real delete, but the
+ * cascade still names the canonical ID — which is main's `parent` — so main loses
+ * its version chain while its row survives. A published document then vanishes
+ * from main's own drafts list, and nothing about the branch says why.
+ *
+ * Adding `_branch` makes the cascade hit only the rows belonging to the branch in
+ * play. It also protects a branch's chain from a delete performed on main, whose
+ * versions share no `parent` with it but are cheap to exclude explicitly.
+ */
+export declare const resolveBranchOwnVersions: ({ id, branch: branchOverride, collectionSlug, req, }: {
+    branch?: false | string;
+    collectionSlug: string;
+    id: number | string;
+    req?: Partial<PayloadRequest>;
+}) => Promise<Where>;
+/**
+ * Drops a branch's version chain for one document.
+ *
+ * Every way a branch stops owning a document ends here: merged, discarded, or
+ * promoted to main. A branch's versions hang off its *shadow row's* primary key
+ * rather than the canonical ID, so they do not travel with the document and are not
+ * cascaded by anything that addresses it — they have to be deleted deliberately.
+ *
+ * Leaving them behind is not inert. The drafts list reads through versions, so an
+ * orphaned branch chain keeps answering for a document the branch no longer has a
+ * row for: the branch lists the document twice, once from its stale chain and once
+ * from main's, as two identical rows.
+ *
+ * Scoped by `_branch` as well as `parent`: main's chain shares no parent with this
+ * one, but saying so costs nothing and a wrong delete here would strip production
+ * history. `_branchParent` is required for the same reason — only rows that were
+ * written as branch versions are in scope.
+ */
+export declare const deleteBranchVersionChain: ({ branch, collectionSlug, payload, req, rowID, }: {
+    branch: string;
+    collectionSlug: string;
+    payload: Payload;
+    req: PayloadRequest;
+    /** Primary key the branch's versions hang off — the shadow row, not the document. */
+    rowID: number | string;
+}) => Promise<void>;
+/** Drops every version of one global owned by a branch that is being discarded or merged. */
+export declare const deleteBranchGlobalVersionChain: ({ branch, globalSlug, payload, req, }: {
+    branch: string;
+    globalSlug: string;
+    payload: Payload;
+    req: PayloadRequest;
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=versions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"versions.d.ts","sourceRoot":"","sources":["../../src/branching/versions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAmB9D,KAAK,SAAS,GAAG;IACf,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;IAC7B,KAAK,EAAE,SAAS,GAAG,KAAK,CAAA;CACzB,CAAA;AAcD,eAAO,MAAM,6BAA6B,oCAIvC;IACD,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAAE,CA+BpE,CAAA;AAqDD;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,4DAKnC,SAAS,KAAG,OAAO,CAAC,SAAS,GAAG,KAAK,CAuBvC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,4DAKvC,SAAS,KAAG,SAAS,GAAG,KAsB1B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,4DAK1C,SAAS,KAAG,OAAO,CAAC,SAAS,GAAG,KAAK,CAuFvC,CAAA;AAyCD;;;GAGG;AACH,eAAO,MAAM,2BAA2B,SAAU,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAG,IAQzE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,0EAMpC;IACD,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;IAC7B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC,KAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CA2B5E,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAG,MAAM,GAAG,MACH,CAAA;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,wBAAwB,yDAKlC;IACD,MAAM,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;IACtB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,GAAG,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAA;CAC9B,KAAG,OAAO,CAAC,KAAK,CA0BhB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,wBAAwB,qDAMlC;IACD,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,qFAAqF;IACrF,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CACvB,KAAG,OAAO,CAAC,IAAI,CAkBf,CAAA;AAED,6FAA6F;AAC7F,eAAO,MAAM,8BAA8B,0CAKxC;IACD,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,IAAI,CAYf,CAAA"}

package/dist/branching/versions.js

@@ -0,0 +1,572 @@
+import { extractRelationshipID } from '../utilities/extractRelationshipID.js';
+import { rewriteBranchVersionParents } from './branchIDs.js';
+import { loadBranchDeletions, loadBranchManifest, peekBranchDeletions, peekBranchManifest, resolveBranch } from './resolveBranch.js';
+import { resolveBranchRowID } from './resolveBranchRowID.js';
+import { branchChangesCollectionSlug, branchField, branchParentField, MAIN_BRANCH } from './types.js';
+const bypassed = (branch, req)=>branch === false || !req?.payload || Boolean(req.context?._branchBypass);
+export const findBranchVersionForkBoundary = async ({ collectionSlug, docID, req })=>{
+    if (!req.payload.collections[collectionSlug]?.config.versions) {
+        return {};
+    }
+    const { docs } = await req.payload.db.findVersions({
+        branch: false,
+        collection: collectionSlug,
+        limit: 1,
+        pagination: false,
+        req,
+        sort: '-updatedAt',
+        where: {
+            and: [
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                },
+                {
+                    parent: {
+                        equals: docID
+                    }
+                }
+            ]
+        }
+    });
+    const latestMainVersion = docs[0];
+    if (latestMainVersion?.id === undefined || !latestMainVersion.updatedAt) {
+        return {};
+    }
+    return {
+        baseVersionID: String(latestMainVersion.id),
+        baseVersionUpdatedAt: latestMainVersion.updatedAt instanceof Date ? latestMainVersion.updatedAt.toISOString() : latestMainVersion.updatedAt
+    };
+};
+const buildBranchVersionQuery = ({ branch, deletedIDs, shadowedIDs, where })=>{
+    if (branch === MAIN_BRANCH) {
+        const mainBase = where && Object.keys(where).length ? [
+            where
+        ] : [];
+        return {
+            and: [
+                ...mainBase,
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                }
+            ]
+        };
+    }
+    // `id` arrives here as `parent` (`appendVersionToQueryKey`), and on a branch a version
+    // row's `parent` is the shadow row while the caller means the canonical document. Same
+    // rewrite the history query does — without it, filtering a drafts read by document ID
+    // matched nothing on a branch while working on main, which is the admin panel's own
+    // read of a single draft.
+    const base = (()=>{
+        const rewritten = rewriteBranchVersionParents(where);
+        return rewritten && Object.keys(rewritten).length ? [
+            rewritten
+        ] : [];
+    })();
+    const mainVersions = shadowedIDs.length ? {
+        and: [
+            {
+                [branchField]: {
+                    equals: MAIN_BRANCH
+                }
+            },
+            {
+                parent: {
+                    not_in: shadowedIDs
+                }
+            }
+        ]
+    } : {
+        [branchField]: {
+            equals: MAIN_BRANCH
+        }
+    };
+    // A tombstone is a flag on the collection row, which version rows know nothing
+    // about — so a document deleted on this branch would keep its branch version
+    // chain and go on appearing in drafts reads, while every other read on the
+    // branch treats it as gone. `_branchParent` is a relationship field, so
+    // `not_in` is null-safe on relational adapters as well as Mongo.
+    const branchVersions = deletedIDs.length ? {
+        and: [
+            {
+                [branchField]: {
+                    equals: branch
+                }
+            },
+            {
+                [branchParentField]: {
+                    not_in: deletedIDs
+                }
+            }
+        ]
+    } : {
+        [branchField]: {
+            equals: branch
+        }
+    };
+    return {
+        and: [
+            ...base,
+            {
+                or: [
+                    branchVersions,
+                    mainVersions
+                ]
+            }
+        ]
+    };
+};
+/**
+ * Branch predicate for version queries.
+ *
+ * Mirrors the collection predicate, but a version row's canonical identity is
+ * its `parent` on main and its `_branchParent` on a branch — so the exclusion of
+ * shadowed main versions compares `parent`, which for a main version row is
+ * already the canonical document ID.
+ */ export const resolveBranchVersionQuery = async ({ branch: branchOverride, collectionSlug, req, where })=>{
+    if (bypassed(branchOverride, req)) {
+        return where;
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return where;
+    }
+    const branch = typeof branchOverride === 'string' ? branchOverride : resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return buildBranchVersionQuery({
+            branch,
+            deletedIDs: [],
+            shadowedIDs: [],
+            where
+        });
+    }
+    const manifest = await loadBranchManifest(req);
+    const shadowedIDs = manifest.get(collectionSlug) ?? [];
+    const deletedIDs = (await loadBranchDeletions(req)).get(collectionSlug) ?? [];
+    return buildBranchVersionQuery({
+        branch,
+        deletedIDs,
+        shadowedIDs,
+        where
+    });
+};
+/**
+ * Synchronous branch predicate for version joins.
+ *
+ * Join query builders run after the top-level read has loaded and memoized the branch manifest.
+ * This uses that state while sharing the exact query construction with
+ * {@link resolveBranchVersionQuery}.
+ */ export const resolveBranchVersionQuerySync = ({ branch: branchOverride, collectionSlug, req, where })=>{
+    if (bypassed(branchOverride, req)) {
+        return where;
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return where;
+    }
+    const branch = typeof branchOverride === 'string' ? branchOverride : resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return buildBranchVersionQuery({
+            branch,
+            deletedIDs: [],
+            shadowedIDs: [],
+            where
+        });
+    }
+    const shadowedIDs = peekBranchManifest(req).get(collectionSlug) ?? [];
+    const deletedIDs = peekBranchDeletions(req).get(collectionSlug) ?? [];
+    return buildBranchVersionQuery({
+        branch,
+        deletedIDs,
+        shadowedIDs,
+        where
+    });
+};
+/**
+ * Branch predicate for reading version *history*, as opposed to listing drafts.
+ *
+ * A branch's history reads as a continuation of main's: main's versions up to the
+ * point the branch forked are the branch's ancestry, the branch's own versions sit
+ * on top, and no other branch is visible. Anything main recorded after the fork
+ * belongs to main alone — it is not this branch's past.
+ *
+ * Deliberately *not* {@link resolveBranchVersionQuery}. That one hides main's
+ * versions for any shadowed document, which is right when listing one row per
+ * document and exactly wrong here: those hidden rows are the ancestry.
+ */ export const resolveBranchVersionHistoryQuery = async ({ branch: branchOverride, collectionSlug, req, where })=>{
+    if (bypassed(branchOverride, req)) {
+        return where;
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return where;
+    }
+    const branch = branchOverride ?? resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        const base = where && Object.keys(where).length ? [
+            where
+        ] : [];
+        return {
+            and: [
+                ...base,
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                }
+            ]
+        };
+    }
+    const rewritten = rewriteBranchVersionParents(where);
+    const base = rewritten && Object.keys(rewritten).length ? [
+        rewritten
+    ] : [];
+    const requestedParentIDs = findVersionHistoryParentIDs({
+        where
+    });
+    const changeWhere = [
+        {
+            branch: {
+                equals: branch
+            }
+        },
+        {
+            collectionSlug: {
+                equals: collectionSlug
+            }
+        }
+    ];
+    if (requestedParentIDs.length) {
+        changeWhere.push({
+            documentID: {
+                in: requestedParentIDs.map(String)
+            }
+        });
+    }
+    const changes = await req.payload.db.find({
+        branch: false,
+        collection: branchChangesCollectionSlug,
+        pagination: false,
+        req,
+        where: {
+            and: changeWhere
+        }
+    });
+    const branchChanges = changes.docs;
+    const changedDocumentIDs = branchChanges.flatMap((change)=>{
+        const documentID = extractRelationshipID({
+            relationship: change.doc
+        });
+        return documentID === undefined ? [] : [
+            documentID
+        ];
+    });
+    const mainDocumentHistories = [];
+    if (changedDocumentIDs.length) {
+        mainDocumentHistories.push({
+            and: [
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                },
+                {
+                    parent: {
+                        not_in: changedDocumentIDs
+                    }
+                }
+            ]
+        });
+    } else {
+        mainDocumentHistories.push({
+            [branchField]: {
+                equals: MAIN_BRANCH
+            }
+        });
+    }
+    for (const change of branchChanges){
+        if (change.operation === 'create') {
+            continue;
+        }
+        const documentID = extractRelationshipID({
+            relationship: change.doc
+        });
+        if (documentID === undefined) {
+            continue;
+        }
+        const boundary = [];
+        if (change.baseVersionID) {
+            boundary.push({
+                id: {
+                    equals: change.baseVersionID
+                }
+            });
+        }
+        if (change.baseVersionUpdatedAt) {
+            boundary.push({
+                updatedAt: {
+                    less_than_equal: change.baseVersionUpdatedAt
+                }
+            });
+        }
+        mainDocumentHistories.push({
+            and: [
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                },
+                {
+                    parent: {
+                        equals: documentID
+                    }
+                },
+                ...boundary.length ? [
+                    {
+                        or: boundary
+                    }
+                ] : []
+            ]
+        });
+    }
+    return {
+        and: [
+            ...base,
+            {
+                or: [
+                    {
+                        [branchField]: {
+                            equals: branch
+                        }
+                    },
+                    ...mainDocumentHistories
+                ]
+            }
+        ]
+    };
+};
+const findVersionHistoryParentIDs = ({ where })=>{
+    if (!where || typeof where !== 'object') {
+        return [];
+    }
+    const parentIDs = [];
+    for (const [key, value] of Object.entries(where)){
+        if ((key === 'and' || key === 'or') && Array.isArray(value)) {
+            for (const clause of value){
+                parentIDs.push(...findVersionHistoryParentIDs({
+                    where: clause
+                }));
+            }
+            continue;
+        }
+        if (key !== 'parent' || !value || typeof value !== 'object') {
+            continue;
+        }
+        const constraint = value;
+        const values = constraint.in ?? [
+            constraint.equals
+        ];
+        for (const candidate of values){
+            const parentID = extractRelationshipID({
+                relationship: candidate
+            });
+            if (parentID !== undefined) {
+                parentIDs.push(parentID);
+            }
+        }
+    }
+    return [
+        ...new Set(parentIDs)
+    ];
+};
+/**
+ * Restores canonical document IDs on version rows read from a branch, whose
+ * `parent` is the shadow row rather than the document.
+ */ export const projectBranchVersionParents = (docs)=>{
+    for (const doc of docs){
+        const canonical = doc?.[branchParentField];
+        if (canonical !== undefined && canonical !== null) {
+            doc.parent = extractRelationshipID({
+                relationship: canonical
+            });
+        }
+    }
+};
+/**
+ * Attaches a new version to the branch's own copy of the document.
+ *
+ * Without this a draft saved on a branch would append to main's version chain,
+ * which is both visible on main and destructive to its `latest` bookkeeping.
+ */ export const resolveBranchVersionParent = async ({ branch: branchOverride, collectionSlug, parent, req, versionData })=>{
+    if (bypassed(branchOverride, req)) {
+        return {
+            parent,
+            versionData
+        };
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return {
+            parent,
+            versionData
+        };
+    }
+    const branch = branchOverride ?? resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return {
+            parent,
+            versionData
+        };
+    }
+    const rowID = await resolveBranchRowID({
+        id: parent,
+        collectionSlug,
+        req
+    });
+    return {
+        parent: rowID,
+        versionData: {
+            ...versionData,
+            [branchField]: branch,
+            [branchParentField]: parent
+        }
+    };
+};
+/**
+ * Restores canonical document IDs on rows returned by `queryDrafts`, which
+ * surfaces a version's `parent` as the document ID.
+ */ export const projectBranchVersionParent = (row)=>row?.[branchParentField]?.value ?? row?.[branchParentField] ?? row?.parent;
+/**
+ * The version rows this branch owns for one document.
+ *
+ * Every operation that reaches into an existing version chain needs this, not just
+ * deletes: a cascade after a delete, pruning to `maxPerDoc`, and rewriting the latest
+ * row on unpublish are all the same question — which rows belong to the branch doing
+ * the writing.
+ *
+ * Deleting a document cascades to its versions by `parent`. On a branch that is
+ * destructive: the delete becomes a tombstone rather than a real delete, but the
+ * cascade still names the canonical ID — which is main's `parent` — so main loses
+ * its version chain while its row survives. A published document then vanishes
+ * from main's own drafts list, and nothing about the branch says why.
+ *
+ * Adding `_branch` makes the cascade hit only the rows belonging to the branch in
+ * play. It also protects a branch's chain from a delete performed on main, whose
+ * versions share no `parent` with it but are cheap to exclude explicitly.
+ */ export const resolveBranchOwnVersions = async ({ id, branch: branchOverride, collectionSlug, req })=>{
+    const unscoped = {
+        parent: {
+            equals: id
+        }
+    };
+    if (bypassed(branchOverride, req)) {
+        return unscoped;
+    }
+    const branching = req.payload.config?.branching;
+    if (!branching?.enabled || !branching.branchableCollections.has(collectionSlug)) {
+        return unscoped;
+    }
+    const branch = branchOverride ?? resolveBranch(req);
+    if (branch === MAIN_BRANCH) {
+        return {
+            and: [
+                unscoped,
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                }
+            ]
+        };
+    }
+    // The branch's own versions hang off its shadow row, so the cascade has to
+    // address that row rather than the canonical ID. When the branch has no copy
+    // yet, `resolveBranchRowID` returns the canonical ID — and the `_branch`
+    // constraint is what then keeps the cascade off main's rows.
+    const rowID = await resolveBranchRowID({
+        id,
+        collectionSlug,
+        req
+    });
+    return {
+        and: [
+            {
+                parent: {
+                    equals: rowID
+                }
+            },
+            {
+                [branchField]: {
+                    equals: branch
+                }
+            }
+        ]
+    };
+};
+/**
+ * Drops a branch's version chain for one document.
+ *
+ * Every way a branch stops owning a document ends here: merged, discarded, or
+ * promoted to main. A branch's versions hang off its *shadow row's* primary key
+ * rather than the canonical ID, so they do not travel with the document and are not
+ * cascaded by anything that addresses it — they have to be deleted deliberately.
+ *
+ * Leaving them behind is not inert. The drafts list reads through versions, so an
+ * orphaned branch chain keeps answering for a document the branch no longer has a
+ * row for: the branch lists the document twice, once from its stale chain and once
+ * from main's, as two identical rows.
+ *
+ * Scoped by `_branch` as well as `parent`: main's chain shares no parent with this
+ * one, but saying so costs nothing and a wrong delete here would strip production
+ * history. `_branchParent` is required for the same reason — only rows that were
+ * written as branch versions are in scope.
+ */ export const deleteBranchVersionChain = async ({ branch, collectionSlug, payload, req, rowID })=>{
+    // Asking a collection without versions to delete versions throws, and a
+    // branchable collection need not be versioned.
+    if (!payload.collections[collectionSlug]?.config.versions) {
+        return;
+    }
+    await payload.db.deleteVersions({
+        collection: collectionSlug,
+        req,
+        where: {
+            and: [
+                {
+                    parent: {
+                        equals: rowID
+                    }
+                },
+                {
+                    [branchField]: {
+                        equals: branch
+                    }
+                },
+                {
+                    [branchParentField]: {
+                        exists: true
+                    }
+                }
+            ]
+        }
+    });
+};
+/** Drops every version of one global owned by a branch that is being discarded or merged. */ export const deleteBranchGlobalVersionChain = async ({ branch, globalSlug, payload, req })=>{
+    const globalConfig = payload.globals.config.find(({ slug })=>slug === globalSlug);
+    if (!globalConfig?.versions) {
+        return;
+    }
+    await payload.db.deleteVersions({
+        globalSlug,
+        req,
+        where: {
+            [branchField]: {
+                equals: branch
+            }
+        }
+    });
+};
+
+//# sourceMappingURL=versions.js.map