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

package/dist/branching/assertBranchCreatedDocumentsUnreferenced.js

@@ -0,0 +1,833 @@
+import { APIError } from '../errors/index.js';
+import { fieldIsVirtual, fieldShouldBeLocalized } from '../fields/config/types.js';
+import { flattenAllFields } from '../utilities/flattenAllFields.js';
+import { corePayloadCollectionSlugs, hardExcludedSlugs } from './sanitizeBranchingConfig.js';
+import { branchesCollectionSlug, branchField, MAIN_BRANCH } from './types.js';
+/**
+ * Refuses to hard-delete branch-created documents while surviving content refers to them.
+ *
+ * Reads through the database adapter so access, hooks, hidden fields and configured selects
+ * cannot hide a relationship that the database would remove or leave dangling.
+ */ export const assertBranchCreatedDocumentsUnreferenced = async ({ ignoredGlobalOwnerBranches, ignoredOwnerBranch, ignoredOwnerRowIDs, req, targets })=>{
+    const excludedCollectionSlugs = new Set([
+        ...corePayloadCollectionSlugs,
+        ...hardExcludedSlugs
+    ]);
+    let globalOwnerBranches;
+    const getGlobalOwnerBranches = async ()=>{
+        if (globalOwnerBranches) {
+            return globalOwnerBranches;
+        }
+        const { docs } = await req.payload.db.find({
+            branch: false,
+            collection: branchesCollectionSlug,
+            limit: 0,
+            pagination: false,
+            req,
+            where: {}
+        });
+        globalOwnerBranches = [
+            MAIN_BRANCH,
+            ...docs.flatMap((doc)=>{
+                const branchSlug = doc.slug;
+                return typeof branchSlug === 'string' ? [
+                    branchSlug
+                ] : [];
+            })
+        ];
+        return globalOwnerBranches;
+    };
+    for (const target of deduplicateTargets(targets)){
+        for (const ownerCollection of req.payload.config.collections){
+            if (excludedCollectionSlugs.has(ownerCollection.slug)) {
+                continue;
+            }
+            const relationshipPaths = getRelationshipPaths({
+                fields: ownerCollection.flattenedFields,
+                payloadBlocks: req.payload.blocks,
+                targetCollectionSlug: target.collectionSlug
+            });
+            const richTextPaths = getRichTextPaths({
+                fields: ownerCollection.flattenedFields,
+                payloadBlocks: req.payload.blocks
+            });
+            const hasRecursiveBlockReferences = hasRecursiveBlocks({
+                fields: ownerCollection.flattenedFields,
+                payloadBlocks: req.payload.blocks
+            });
+            if (!relationshipPaths.length && !richTextPaths.length) {
+                continue;
+            }
+            const ignoredRowIDs = ignoredOwnerRowIDs?.get(ownerCollection.slug);
+            const liveConditions = [];
+            if (ignoredOwnerBranch && req.payload.config.branching.branchableCollections.has(ownerCollection.slug)) {
+                liveConditions.push({
+                    [branchField]: {
+                        not_equals: ignoredOwnerBranch
+                    }
+                });
+            }
+            if (ignoredRowIDs?.size) {
+                liveConditions.push({
+                    id: {
+                        not_in: [
+                            ...ignoredRowIDs
+                        ]
+                    }
+                });
+            }
+            const shouldScanEveryDocument = richTextPaths.length > 0 || hasRecursiveBlockReferences || relationshipPaths.some(({ hasBlockAncestor, hasLocalizedAncestor })=>hasBlockAncestor || hasLocalizedAncestor);
+            const possibleOwners = await req.payload.db.find({
+                branch: false,
+                collection: ownerCollection.slug,
+                limit: 0,
+                locale: 'all',
+                pagination: false,
+                req,
+                where: shouldScanEveryDocument ? liveConditions.length ? combineConditions(liveConditions) : {} : combineConditions([
+                    buildRelationshipWhere({
+                        relationshipPaths,
+                        target
+                    }),
+                    ...liveConditions
+                ])
+            });
+            if (possibleOwners.docs.some((doc)=>hasBranchCreatedDocumentReference({
+                    data: doc,
+                    dataShape: 'withLocales',
+                    fields: ownerCollection.flattenedFields,
+                    payloadBlocks: req.payload.blocks,
+                    req,
+                    target
+                }))) {
+                throwReferenceError();
+            }
+            if (!ownerCollection.versions) {
+                continue;
+            }
+            const versionConditions = [];
+            if (ignoredOwnerBranch && req.payload.config.branching.branchableCollections.has(ownerCollection.slug)) {
+                versionConditions.push({
+                    [branchField]: {
+                        not_equals: ignoredOwnerBranch
+                    }
+                });
+            }
+            if (ignoredRowIDs?.size) {
+                versionConditions.push({
+                    parent: {
+                        not_in: [
+                            ...ignoredRowIDs
+                        ]
+                    }
+                });
+            }
+            const possibleVersions = await req.payload.db.findVersions({
+                branch: false,
+                collection: ownerCollection.slug,
+                limit: 0,
+                locale: 'all',
+                pagination: false,
+                req,
+                where: shouldScanEveryDocument ? versionConditions.length ? combineConditions(versionConditions) : {} : combineConditions([
+                    buildRelationshipWhere({
+                        pathPrefix: 'version',
+                        relationshipPaths,
+                        target
+                    }),
+                    ...versionConditions
+                ])
+            });
+            if (possibleVersions.docs.some((version)=>hasBranchCreatedDocumentReference({
+                    data: version.version,
+                    dataShape: 'withLocales',
+                    fields: ownerCollection.flattenedFields,
+                    payloadBlocks: req.payload.blocks,
+                    req,
+                    target
+                }))) {
+                throwReferenceError();
+            }
+        }
+        for (const ownerGlobal of req.payload.globals.config){
+            const relationshipPaths = getRelationshipPaths({
+                fields: ownerGlobal.flattenedFields,
+                payloadBlocks: req.payload.blocks,
+                targetCollectionSlug: target.collectionSlug
+            });
+            const richTextPaths = getRichTextPaths({
+                fields: ownerGlobal.flattenedFields,
+                payloadBlocks: req.payload.blocks
+            });
+            const hasRecursiveBlockReferences = hasRecursiveBlocks({
+                fields: ownerGlobal.flattenedFields,
+                payloadBlocks: req.payload.blocks
+            });
+            if (!relationshipPaths.length && !richTextPaths.length) {
+                continue;
+            }
+            const ignoredGlobalBranches = new Set(ignoredGlobalOwnerBranches?.get(ownerGlobal.slug) ?? []);
+            if (ignoredOwnerBranch && req.payload.config.branching.branchableGlobals.has(ownerGlobal.slug)) {
+                ignoredGlobalBranches.add(ignoredOwnerBranch);
+            }
+            const isBranchableGlobal = req.payload.config.branching.branchableGlobals.has(ownerGlobal.slug);
+            const shouldScanEveryGlobal = richTextPaths.length > 0 || hasRecursiveBlockReferences || relationshipPaths.some(({ hasBlockAncestor, hasLocalizedAncestor })=>hasBlockAncestor || hasLocalizedAncestor);
+            const ownerBranches = isBranchableGlobal ? await getGlobalOwnerBranches() : [
+                MAIN_BRANCH
+            ];
+            for (const ownerBranch of ownerBranches){
+                if (ignoredGlobalBranches.has(ownerBranch)) {
+                    continue;
+                }
+                const ownerConditions = [];
+                if (isBranchableGlobal) {
+                    ownerConditions.push({
+                        [branchField]: {
+                            equals: ownerBranch
+                        }
+                    });
+                }
+                if (!shouldScanEveryGlobal) {
+                    ownerConditions.unshift(buildRelationshipWhere({
+                        relationshipPaths,
+                        target
+                    }));
+                }
+                const possibleOwner = await req.payload.db.findGlobal({
+                    slug: ownerGlobal.slug,
+                    branch: false,
+                    locale: 'all',
+                    req,
+                    where: ownerConditions.length ? combineConditions(ownerConditions) : undefined
+                });
+                if (possibleOwner && hasBranchCreatedDocumentReference({
+                    data: possibleOwner,
+                    dataShape: 'withLocales',
+                    fields: ownerGlobal.flattenedFields,
+                    payloadBlocks: req.payload.blocks,
+                    req,
+                    target
+                })) {
+                    throwReferenceError();
+                }
+            }
+            if (!ownerGlobal.versions) {
+                continue;
+            }
+            const versionConditions = [];
+            if (ignoredGlobalBranches.size && req.payload.config.branching.branchableGlobals.has(ownerGlobal.slug)) {
+                versionConditions.push({
+                    [branchField]: {
+                        not_in: [
+                            ...ignoredGlobalBranches
+                        ]
+                    }
+                });
+            }
+            const possibleVersions = await req.payload.db.findGlobalVersions({
+                branch: false,
+                global: ownerGlobal.slug,
+                limit: 0,
+                locale: 'all',
+                pagination: false,
+                req,
+                where: shouldScanEveryGlobal ? versionConditions.length ? combineConditions(versionConditions) : {} : combineConditions([
+                    buildRelationshipWhere({
+                        pathPrefix: 'version',
+                        relationshipPaths,
+                        target
+                    }),
+                    ...versionConditions
+                ])
+            });
+            if (possibleVersions.docs.some((version)=>hasBranchCreatedDocumentReference({
+                    data: version.version,
+                    dataShape: 'withLocales',
+                    fields: ownerGlobal.flattenedFields,
+                    payloadBlocks: req.payload.blocks,
+                    req,
+                    target
+                }))) {
+                throwReferenceError();
+            }
+        }
+    }
+};
+/** Checks persisted field data for a direct or serialized reference to one document. */ export const hasBranchCreatedDocumentReference = ({ data, dataShape, fields, payloadBlocks, req, target })=>hasReferenceInFields({
+        data,
+        dataShape,
+        fields,
+        payloadBlocks,
+        req,
+        target
+    });
+/**
+ * Returns the collection types that a configured field tree can reference.
+ *
+ * `undefined` means the field tree can contain references that are not described by static field
+ * configuration. Rich text is intentionally unbounded because serialized nodes and editor-provided
+ * subfields can reference collections at runtime.
+ */ export const getPossibleRelationshipCollectionSlugs = ({ fields, payloadBlocks })=>collectPossibleRelationshipCollectionSlugs({
+        fields,
+        payloadBlocks,
+        visitedBlockSlugs: new Set()
+    });
+const collectPossibleRelationshipCollectionSlugs = ({ fields, payloadBlocks, visitedBlockSlugs })=>{
+    const collectionSlugs = new Set();
+    for (const field of fields){
+        if (fieldIsVirtual(field)) {
+            continue;
+        }
+        if (field.type === 'relationship' || field.type === 'upload') {
+            for (const relationTo of Array.isArray(field.relationTo) ? field.relationTo : [
+                field.relationTo
+            ]){
+                collectionSlugs.add(relationTo);
+            }
+            continue;
+        }
+        if (field.type === 'richText') {
+            return undefined;
+        }
+        if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+            const nestedCollectionSlugs = collectPossibleRelationshipCollectionSlugs({
+                fields: field.flattenedFields,
+                payloadBlocks,
+                visitedBlockSlugs
+            });
+            if (!nestedCollectionSlugs) {
+                return undefined;
+            }
+            for (const collectionSlug of nestedCollectionSlugs){
+                collectionSlugs.add(collectionSlug);
+            }
+            continue;
+        }
+        if (field.type !== 'blocks') {
+            continue;
+        }
+        for (const blockReference of field.blocks){
+            const block = typeof blockReference === 'string' ? payloadBlocks[blockReference] : blockReference;
+            if (!block) {
+                return undefined;
+            }
+            if (visitedBlockSlugs.has(block.slug)) {
+                continue;
+            }
+            visitedBlockSlugs.add(block.slug);
+            const nestedCollectionSlugs = collectPossibleRelationshipCollectionSlugs({
+                fields: block.flattenedFields,
+                payloadBlocks,
+                visitedBlockSlugs
+            });
+            if (!nestedCollectionSlugs) {
+                return undefined;
+            }
+            for (const collectionSlug of nestedCollectionSlugs){
+                collectionSlugs.add(collectionSlug);
+            }
+        }
+    }
+    return collectionSlugs;
+};
+/** Returns whether configured relationship or upload fields contain any stored value. */ export const hasConfiguredRelationshipValue = ({ data, dataShape, fields, payloadBlocks })=>hasConfiguredRelationshipValueInFields({
+        data,
+        dataShape,
+        fields,
+        parentIsLocalized: false,
+        payloadBlocks
+    });
+const hasConfiguredRelationshipValueInFields = ({ data, dataShape, fields, parentIsLocalized, payloadBlocks })=>{
+    if (Array.isArray(data)) {
+        return data.some((entry)=>hasConfiguredRelationshipValueInFields({
+                data: entry,
+                dataShape,
+                fields,
+                parentIsLocalized,
+                payloadBlocks
+            }));
+    }
+    if (!data || typeof data !== 'object') {
+        return false;
+    }
+    const record = data;
+    for (const field of fields){
+        if (fieldIsVirtual(field)) {
+            continue;
+        }
+        const fieldValues = getFieldValues({
+            dataShape,
+            field,
+            parentIsLocalized,
+            record
+        });
+        const nestedParentIsLocalized = parentIsLocalized || 'localized' in field && Boolean(field.localized);
+        if (field.type === 'relationship' || field.type === 'upload') {
+            if (fieldValues.some((value)=>nestedValueMatches({
+                    matches: (nestedValue)=>nestedValue !== undefined && nestedValue !== null && nestedValue !== '',
+                    value
+                }))) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type === 'richText') {
+            if (fieldValues.some((value)=>value !== undefined && value !== null)) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+            if (fieldValues.some((value)=>hasConfiguredRelationshipValueInFields({
+                    data: value,
+                    dataShape,
+                    fields: field.flattenedFields,
+                    parentIsLocalized: nestedParentIsLocalized,
+                    payloadBlocks
+                }))) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type !== 'blocks') {
+            continue;
+        }
+        if (fieldValues.some((value)=>nestedValueMatches({
+                matches: (row)=>{
+                    if (!row || typeof row !== 'object') {
+                        return false;
+                    }
+                    const rowRecord = row;
+                    const block = resolveBlock({
+                        blockType: rowRecord.blockType,
+                        field,
+                        payloadBlocks
+                    });
+                    return block ? hasConfiguredRelationshipValueInFields({
+                        data: rowRecord,
+                        dataShape,
+                        fields: block.flattenedFields,
+                        parentIsLocalized: nestedParentIsLocalized,
+                        payloadBlocks
+                    }) : true;
+                },
+                value
+            }))) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasReferenceInFields = ({ data, dataShape, fields, parentIsLocalized = false, payloadBlocks, req, target })=>{
+    if (Array.isArray(data)) {
+        return data.some((entry)=>hasReferenceInFields({
+                data: entry,
+                dataShape,
+                fields,
+                parentIsLocalized,
+                payloadBlocks,
+                req,
+                target
+            }));
+    }
+    if (!data || typeof data !== 'object') {
+        return false;
+    }
+    const record = data;
+    for (const field of fields){
+        if (fieldIsVirtual(field)) {
+            continue;
+        }
+        const fieldValues = getFieldValues({
+            dataShape,
+            field,
+            parentIsLocalized,
+            record
+        });
+        const nestedParentIsLocalized = parentIsLocalized || 'localized' in field && Boolean(field.localized);
+        if (field.type === 'relationship' || field.type === 'upload') {
+            const isPolymorphic = Array.isArray(field.relationTo);
+            const relationTargets = isPolymorphic ? field.relationTo : [
+                field.relationTo
+            ];
+            if (relationTargets.includes(target.collectionSlug) && fieldValues.some((value)=>nestedValueMatches({
+                    matches: (nestedValue)=>isRelationshipReference({
+                            isPolymorphic,
+                            target,
+                            value: nestedValue
+                        }),
+                    value
+                }))) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type === 'richText') {
+            if (fieldValues.some((value)=>hasRichTextReferenceValue({
+                    dataShape,
+                    editor: typeof field.editor === 'function' ? undefined : field.editor,
+                    parentIsLocalized: nestedParentIsLocalized,
+                    payloadBlocks,
+                    req,
+                    target,
+                    value
+                }))) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+            if (fieldValues.some((value)=>hasReferenceInFields({
+                    data: value,
+                    dataShape,
+                    fields: field.flattenedFields,
+                    parentIsLocalized: nestedParentIsLocalized,
+                    payloadBlocks,
+                    req,
+                    target
+                }))) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type === 'blocks') {
+            if (fieldValues.some((value)=>nestedValueMatches({
+                    matches: (row)=>{
+                        if (!row || typeof row !== 'object') {
+                            return false;
+                        }
+                        const rowRecord = row;
+                        const block = resolveBlock({
+                            blockType: rowRecord.blockType,
+                            field,
+                            payloadBlocks
+                        });
+                        return block ? hasReferenceInFields({
+                            data: rowRecord,
+                            dataShape,
+                            fields: block.flattenedFields,
+                            parentIsLocalized: nestedParentIsLocalized,
+                            payloadBlocks,
+                            req,
+                            target
+                        }) : false;
+                    },
+                    value
+                }))) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const getFieldValues = ({ dataShape, field, parentIsLocalized, record })=>{
+    const value = record[field.name];
+    const shouldReadLocaleMap = dataShape === 'withLocales' && fieldShouldBeLocalized({
+        field,
+        parentIsLocalized
+    });
+    if (!shouldReadLocaleMap) {
+        return [
+            value
+        ];
+    }
+    return value && typeof value === 'object' && !Array.isArray(value) ? Object.values(value) : [];
+};
+const nestedValueMatches = ({ matches, value })=>Array.isArray(value) ? value.some((entry)=>nestedValueMatches({
+            matches,
+            value: entry
+        })) : matches(value);
+const resolveBlock = ({ blockType, field, payloadBlocks })=>{
+    if (typeof blockType !== 'string') {
+        return undefined;
+    }
+    const blockReference = field.blocks.find((block)=>typeof block === 'string' ? block === blockType : block.slug === blockType);
+    return typeof blockReference === 'string' ? payloadBlocks[blockReference] : blockReference;
+};
+const hasRichTextReferenceValue = ({ dataShape, editor, parentIsLocalized, payloadBlocks, req, target, value })=>{
+    const features = editor?.editorConfig?.features;
+    if (!features) {
+        return containsSerializedReference({
+            target,
+            value
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry)=>hasRichTextReferenceValue({
+                dataShape,
+                editor,
+                parentIsLocalized,
+                payloadBlocks,
+                req,
+                target,
+                value: entry
+            }));
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const node = value;
+    const nodeType = node.type;
+    if ((nodeType === 'relationship' || nodeType === 'upload') && node.relationTo === target.collectionSlug && relationshipIDEquals({
+        targetID: target.docID,
+        value: node.value
+    })) {
+        return true;
+    }
+    if (typeof nodeType === 'string') {
+        const getSubFields = features?.getSubFields?.get(nodeType);
+        const getSubFieldsData = features?.getSubFieldsData?.get(nodeType);
+        if (getSubFields && getSubFieldsData) {
+            const subFields = getSubFields({
+                node,
+                req
+            });
+            const subFieldData = getSubFieldsData({
+                node,
+                req
+            });
+            if (subFields?.length && subFieldData && hasReferenceInFields({
+                data: subFieldData,
+                dataShape,
+                fields: flattenAllFields({
+                    fields: subFields
+                }),
+                parentIsLocalized,
+                payloadBlocks,
+                req,
+                target
+            })) {
+                return true;
+            }
+        }
+    }
+    return [
+        node.root,
+        node.children
+    ].some((nestedValue)=>hasRichTextReferenceValue({
+            dataShape,
+            editor,
+            parentIsLocalized,
+            payloadBlocks,
+            req,
+            target,
+            value: nestedValue
+        }));
+};
+const deduplicateTargets = (targets)=>{
+    const seen = new Set();
+    return targets.filter(({ collectionSlug, docID })=>{
+        const key = `${collectionSlug}:${String(docID)}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+};
+const combineConditions = (conditions)=>conditions.length === 1 ? conditions[0] : {
+        and: conditions
+    };
+const buildRelationshipWhere = ({ pathPrefix, relationshipPaths, target })=>({
+        or: relationshipPaths.map(({ isPolymorphic, path })=>({
+                [pathPrefix ? `${pathPrefix}.${path}` : path]: {
+                    equals: isPolymorphic ? {
+                        relationTo: target.collectionSlug,
+                        value: target.docID
+                    } : target.docID
+                }
+            }))
+    });
+const hasRecursiveBlocks = ({ activeBlockSlugs = new Set(), fields, payloadBlocks })=>{
+    for (const field of fields){
+        if (fieldIsVirtual(field)) {
+            continue;
+        }
+        if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+            if (hasRecursiveBlocks({
+                activeBlockSlugs,
+                fields: field.flattenedFields,
+                payloadBlocks
+            })) {
+                return true;
+            }
+            continue;
+        }
+        if (field.type !== 'blocks') {
+            continue;
+        }
+        for (const blockReference of field.blocks){
+            const block = typeof blockReference === 'string' ? payloadBlocks[blockReference] : blockReference;
+            if (!block) {
+                continue;
+            }
+            if (activeBlockSlugs.has(block.slug)) {
+                return true;
+            }
+            const nestedActiveBlockSlugs = new Set(activeBlockSlugs);
+            nestedActiveBlockSlugs.add(block.slug);
+            if (hasRecursiveBlocks({
+                activeBlockSlugs: nestedActiveBlockSlugs,
+                fields: block.flattenedFields,
+                payloadBlocks
+            })) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const getRelationshipPaths = ({ activeBlockSlugs = new Set(), fields, hasBlockAncestor = false, parentIsLocalized = false, parentPath = '', payloadBlocks, targetCollectionSlug })=>{
+    const paths = [];
+    for (const field of fields){
+        if (fieldIsVirtual(field)) {
+            continue;
+        }
+        const path = parentPath ? `${parentPath}.${field.name}` : field.name;
+        const isLocalized = parentIsLocalized || fieldShouldBeLocalized({
+            field,
+            parentIsLocalized
+        });
+        if (field.type === 'relationship' || field.type === 'upload') {
+            if ('virtual' in field && field.virtual) {
+                continue;
+            }
+            const relationTargets = Array.isArray(field.relationTo) ? field.relationTo : [
+                field.relationTo
+            ];
+            if (relationTargets.includes(targetCollectionSlug)) {
+                paths.push({
+                    hasBlockAncestor,
+                    hasLocalizedAncestor: isLocalized,
+                    isPolymorphic: Array.isArray(field.relationTo),
+                    path
+                });
+            }
+            continue;
+        }
+        if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+            paths.push(...getRelationshipPaths({
+                activeBlockSlugs,
+                fields: field.flattenedFields,
+                hasBlockAncestor,
+                parentIsLocalized: isLocalized,
+                parentPath: path,
+                payloadBlocks,
+                targetCollectionSlug
+            }));
+            continue;
+        }
+        if (field.type === 'blocks') {
+            for (const blockReference of field.blocks){
+                const block = typeof blockReference === 'string' ? payloadBlocks[blockReference] : blockReference;
+                if (!block || activeBlockSlugs.has(block.slug)) {
+                    continue;
+                }
+                const nestedActiveBlockSlugs = new Set(activeBlockSlugs);
+                nestedActiveBlockSlugs.add(block.slug);
+                paths.push(...getRelationshipPaths({
+                    activeBlockSlugs: nestedActiveBlockSlugs,
+                    fields: block.flattenedFields,
+                    hasBlockAncestor: true,
+                    parentIsLocalized: isLocalized,
+                    parentPath: path,
+                    payloadBlocks,
+                    targetCollectionSlug
+                }));
+            }
+        }
+    }
+    return paths;
+};
+const getRichTextPaths = ({ activeBlockSlugs = new Set(), fields, parentPath = '', payloadBlocks })=>{
+    const paths = [];
+    for (const field of fields){
+        if (fieldIsVirtual(field)) {
+            continue;
+        }
+        const path = parentPath ? `${parentPath}.${field.name}` : field.name;
+        if (field.type === 'richText') {
+            paths.push({
+                path
+            });
+            continue;
+        }
+        if (field.type === 'array' || field.type === 'group' || field.type === 'tab') {
+            paths.push(...getRichTextPaths({
+                activeBlockSlugs,
+                fields: field.flattenedFields,
+                parentPath: path,
+                payloadBlocks
+            }));
+            continue;
+        }
+        if (field.type === 'blocks') {
+            for (const blockReference of field.blocks){
+                const block = typeof blockReference === 'string' ? payloadBlocks[blockReference] : blockReference;
+                if (!block || activeBlockSlugs.has(block.slug)) {
+                    continue;
+                }
+                const nestedActiveBlockSlugs = new Set(activeBlockSlugs);
+                nestedActiveBlockSlugs.add(block.slug);
+                paths.push(...getRichTextPaths({
+                    activeBlockSlugs: nestedActiveBlockSlugs,
+                    fields: block.flattenedFields,
+                    parentPath: path,
+                    payloadBlocks
+                }));
+            }
+        }
+    }
+    return [
+        ...new Set(paths)
+    ];
+};
+const isRelationshipReference = ({ isPolymorphic, target, value })=>{
+    if (isPolymorphic) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const relation = value;
+        return relation.relationTo === target.collectionSlug && relationshipIDEquals({
+            targetID: target.docID,
+            value: relation.value
+        });
+    }
+    return relationshipIDEquals({
+        targetID: target.docID,
+        value
+    });
+};
+const relationshipIDEquals = ({ targetID, value })=>{
+    const relatedID = value && typeof value === 'object' && 'id' in value ? value.id : value;
+    return (typeof relatedID === 'number' || typeof relatedID === 'string') && String(relatedID) === String(targetID);
+};
+const containsSerializedReference = ({ target, value })=>{
+    if (Array.isArray(value)) {
+        return value.some((entry)=>containsSerializedReference({
+                target,
+                value: entry
+            }));
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    if (record.relationTo === target.collectionSlug) {
+        if (relationshipIDEquals({
+            targetID: target.docID,
+            value: record.value
+        })) {
+            return true;
+        }
+    }
+    return Object.values(record).some((nestedValue)=>containsSerializedReference({
+            target,
+            value: nestedValue
+        }));
+};
+const throwReferenceError = ()=>{
+    throw new APIError('Branch-created content cannot be deleted while a surviving document or version references it.', 409);
+};
+
+//# sourceMappingURL=assertBranchCreatedDocumentsUnreferenced.js.map