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

package/dist/branching/versions.d.ts

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

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

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