payload 3.80.0-internal-debug.cd99b1f → 3.80.0-internal.21e9c47

package/dist/hierarchy/hooks/collectionAfterDelete.js

@@ -0,0 +1,21 @@
+/**
+ * afterDelete Hook Responsibilities:
+ * - Clear folder references from related documents when folder is deleted
+ */ export const hierarchyCollectionAfterDelete = ({ relatedCollections })=>async ({ id, req })=>{
+        for (const [collectionSlug, fieldName] of Object.entries(relatedCollections)){
+            await req.payload.update({
+                collection: collectionSlug,
+                data: {
+                    [fieldName]: null
+                },
+                req,
+                where: {
+                    [fieldName]: {
+                        equals: id
+                    }
+                }
+            });
+        }
+    };
+
+//# sourceMappingURL=collectionAfterDelete.js.map

package/dist/hierarchy/hooks/collectionAfterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/hooks/collectionAfterDelete.ts"],"sourcesContent":["/**\n * afterDelete Hook Responsibilities:\n * - Clear folder references from related documents when folder is deleted\n */\n\nimport type { CollectionAfterDeleteHook } from '../../index.js'\n\ntype Args = {\n  /**\n   * Map of collection slugs to their field names\n   */\n  relatedCollections: Record<string, string>\n}\n\nexport const hierarchyCollectionAfterDelete =\n  ({ relatedCollections }: Args): CollectionAfterDeleteHook =>\n  async ({ id, req }) => {\n    for (const [collectionSlug, fieldName] of Object.entries(relatedCollections)) {\n      await req.payload.update({\n        collection: collectionSlug,\n        data: {\n          [fieldName]: null,\n        },\n        req,\n        where: {\n          [fieldName]: {\n            equals: id,\n          },\n        },\n      })\n    }\n  }\n"],"names":["hierarchyCollectionAfterDelete","relatedCollections","id","req","collectionSlug","fieldName","Object","entries","payload","update","collection","data","where","equals"],"mappings":"AAAA;;;CAGC,GAWD,OAAO,MAAMA,iCACX,CAAC,EAAEC,kBAAkB,EAAQ,GAC7B,OAAO,EAAEC,EAAE,EAAEC,GAAG,EAAE;QAChB,KAAK,MAAM,CAACC,gBAAgBC,UAAU,IAAIC,OAAOC,OAAO,CAACN,oBAAqB;YAC5E,MAAME,IAAIK,OAAO,CAACC,MAAM,CAAC;gBACvBC,YAAYN;gBACZO,MAAM;oBACJ,CAACN,UAAU,EAAE;gBACf;gBACAF;gBACAS,OAAO;oBACL,CAACP,UAAU,EAAE;wBACXQ,QAAQX;oBACV;gBACF;YACF;QACF;IACF,EAAC"}

package/dist/hierarchy/hooks/collectionAfterRead.d.ts

@@ -0,0 +1,27 @@
+/**
+ * afterRead Hook Responsibilities:
+ * - Automatically compute and attach _h_slugPath and _h_titlePath to documents
+ * - Use cached ancestors to optimize queries when reading multiple documents
+ * - Only computes when explicitly requested via:
+ *   1. context.computeHierarchyPaths flag
+ *   2. ?computeHierarchyPaths=true query param
+ *   3. Selecting path fields in query (select parameter)
+ */
+import type { CollectionAfterReadHook } from '../../index.js';
+type Args = {
+    /**
+     * The name of the field that contains the parent document ID
+     */
+    parentFieldName: string;
+    /**
+     * The name of the field to populate with the slug-based path
+     */
+    slugPathFieldName: string;
+    /**
+     * The name of the field to populate with the title-based path
+     */
+    titlePathFieldName: string;
+};
+export declare const hierarchyCollectionAfterRead: ({ parentFieldName, slugPathFieldName, titlePathFieldName }: Args) => CollectionAfterReadHook;
+export {};
+//# sourceMappingURL=collectionAfterRead.d.ts.map

package/dist/hierarchy/hooks/collectionAfterRead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectionAfterRead.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/collectionAfterRead.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAkB,MAAM,gBAAgB,CAAA;AAgC7E,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,eAAO,MAAM,4BAA4B,+DACsB,IAAI,KAAG,uBA8CnE,CAAA"}

package/dist/hierarchy/hooks/collectionAfterRead.js

@@ -0,0 +1,64 @@
+/**
+ * afterRead Hook Responsibilities:
+ * - Automatically compute and attach _h_slugPath and _h_titlePath to documents
+ * - Use cached ancestors to optimize queries when reading multiple documents
+ * - Only computes when explicitly requested via:
+ *   1. context.computeHierarchyPaths flag
+ *   2. ?computeHierarchyPaths=true query param
+ *   3. Selecting path fields in query (select parameter)
+ */ import { computePaths } from '../utils/computePaths.js';
+import { findUseAsTitleField } from '../utils/findUseAsTitle.js';
+/**
+ * Checks if path fields are being selected in the query
+ */ function isPathFieldSelected(req, slugPathFieldName, titlePathFieldName) {
+    // Check query.select parameter (REST API)
+    const selectParam = req.query?.select;
+    if (selectParam) {
+        if (typeof selectParam === 'string') {
+            const selectedFields = selectParam.split(',').map((f)=>f.trim());
+            return selectedFields.includes(slugPathFieldName) || selectedFields.includes(titlePathFieldName);
+        }
+        // Could be an array or object depending on query parser
+        if (Array.isArray(selectParam)) {
+            return selectParam.includes(slugPathFieldName) || selectParam.includes(titlePathFieldName);
+        }
+    }
+    return false;
+}
+export const hierarchyCollectionAfterRead = ({ parentFieldName, slugPathFieldName, titlePathFieldName })=>async ({ collection, context, doc, req })=>{
+        // Skip if deleting
+        if (context?.isDeleting) {
+            return doc;
+        }
+        // Determine if paths should be computed
+        const shouldComputePaths = context?.computeHierarchyPaths === true || // Explicit flag
+        req.query?.computeHierarchyPaths === 'true' || // Query parameter
+        isPathFieldSelected(req, slugPathFieldName, titlePathFieldName) // Field selection detection
+        ;
+        if (!shouldComputePaths) {
+            return doc;
+        }
+        try {
+            const { localized: isTitleLocalized } = findUseAsTitleField(collection);
+            const { slugPath, titlePath } = await computePaths({
+                collection,
+                doc,
+                draft: doc._status === 'draft',
+                locale: isTitleLocalized && req.locale === 'all' ? 'all' : req.locale === 'all' ? undefined : req.locale || undefined,
+                parentFieldName,
+                req,
+                slugPathFieldName,
+                titlePathFieldName
+            });
+            // Attach computed paths to document using configured field names
+            doc[slugPathFieldName] = slugPath;
+            doc[titlePathFieldName] = titlePath;
+        } catch (error) {
+            // If path computation fails, log but don't break the document read
+            // eslint-disable-next-line no-console
+            console.error(`Failed to compute hierarchy paths for document ${doc.id}:`, error);
+        }
+        return doc;
+    };
+
+//# sourceMappingURL=collectionAfterRead.js.map

package/dist/hierarchy/hooks/collectionAfterRead.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/hooks/collectionAfterRead.ts"],"sourcesContent":["/**\n * afterRead Hook Responsibilities:\n * - Automatically compute and attach _h_slugPath and _h_titlePath to documents\n * - Use cached ancestors to optimize queries when reading multiple documents\n * - Only computes when explicitly requested via:\n *   1. context.computeHierarchyPaths flag\n *   2. ?computeHierarchyPaths=true query param\n *   3. Selecting path fields in query (select parameter)\n */\n\nimport type { CollectionAfterReadHook, PayloadRequest } from '../../index.js'\n\nimport { computePaths } from '../utils/computePaths.js'\nimport { findUseAsTitleField } from '../utils/findUseAsTitle.js'\n\n/**\n * Checks if path fields are being selected in the query\n */\nfunction isPathFieldSelected(\n  req: PayloadRequest,\n  slugPathFieldName: string,\n  titlePathFieldName: string,\n): boolean {\n  // Check query.select parameter (REST API)\n  const selectParam = req.query?.select\n\n  if (selectParam) {\n    if (typeof selectParam === 'string') {\n      const selectedFields = selectParam.split(',').map((f) => f.trim())\n      return (\n        selectedFields.includes(slugPathFieldName) || selectedFields.includes(titlePathFieldName)\n      )\n    }\n    // Could be an array or object depending on query parser\n    if (Array.isArray(selectParam)) {\n      return selectParam.includes(slugPathFieldName) || selectParam.includes(titlePathFieldName)\n    }\n  }\n\n  return false\n}\n\ntype Args = {\n  /**\n   * The name of the field that contains the parent document ID\n   */\n  parentFieldName: string\n  /**\n   * The name of the field to populate with the slug-based path\n   */\n  slugPathFieldName: string\n  /**\n   * The name of the field to populate with the title-based path\n   */\n  titlePathFieldName: string\n}\n\nexport const hierarchyCollectionAfterRead =\n  ({ parentFieldName, slugPathFieldName, titlePathFieldName }: Args): CollectionAfterReadHook =>\n  async ({ collection, context, doc, req }) => {\n    // Skip if deleting\n    if (context?.isDeleting) {\n      return doc\n    }\n\n    // Determine if paths should be computed\n    const shouldComputePaths =\n      context?.computeHierarchyPaths === true || // Explicit flag\n      req.query?.computeHierarchyPaths === 'true' || // Query parameter\n      isPathFieldSelected(req, slugPathFieldName, titlePathFieldName) // Field selection detection\n\n    if (!shouldComputePaths) {\n      return doc\n    }\n\n    try {\n      const { localized: isTitleLocalized } = findUseAsTitleField(collection)\n\n      const { slugPath, titlePath } = await computePaths({\n        collection,\n        doc,\n        draft: doc._status === 'draft',\n        locale:\n          isTitleLocalized && req.locale === 'all'\n            ? 'all'\n            : req.locale === 'all'\n              ? undefined\n              : req.locale || undefined,\n        parentFieldName,\n        req,\n        slugPathFieldName,\n        titlePathFieldName,\n      })\n\n      // Attach computed paths to document using configured field names\n      doc[slugPathFieldName] = slugPath\n      doc[titlePathFieldName] = titlePath\n    } catch (error) {\n      // If path computation fails, log but don't break the document read\n      // eslint-disable-next-line no-console\n      console.error(`Failed to compute hierarchy paths for document ${doc.id}:`, error)\n    }\n\n    return doc\n  }\n"],"names":["computePaths","findUseAsTitleField","isPathFieldSelected","req","slugPathFieldName","titlePathFieldName","selectParam","query","select","selectedFields","split","map","f","trim","includes","Array","isArray","hierarchyCollectionAfterRead","parentFieldName","collection","context","doc","isDeleting","shouldComputePaths","computeHierarchyPaths","localized","isTitleLocalized","slugPath","titlePath","draft","_status","locale","undefined","error","console","id"],"mappings":"AAAA;;;;;;;;CAQC,GAID,SAASA,YAAY,QAAQ,2BAA0B;AACvD,SAASC,mBAAmB,QAAQ,6BAA4B;AAEhE;;CAEC,GACD,SAASC,oBACPC,GAAmB,EACnBC,iBAAyB,EACzBC,kBAA0B;IAE1B,0CAA0C;IAC1C,MAAMC,cAAcH,IAAII,KAAK,EAAEC;IAE/B,IAAIF,aAAa;QACf,IAAI,OAAOA,gBAAgB,UAAU;YACnC,MAAMG,iBAAiBH,YAAYI,KAAK,CAAC,KAAKC,GAAG,CAAC,CAACC,IAAMA,EAAEC,IAAI;YAC/D,OACEJ,eAAeK,QAAQ,CAACV,sBAAsBK,eAAeK,QAAQ,CAACT;QAE1E;QACA,wDAAwD;QACxD,IAAIU,MAAMC,OAAO,CAACV,cAAc;YAC9B,OAAOA,YAAYQ,QAAQ,CAACV,sBAAsBE,YAAYQ,QAAQ,CAACT;QACzE;IACF;IAEA,OAAO;AACT;AAiBA,OAAO,MAAMY,+BACX,CAAC,EAAEC,eAAe,EAAEd,iBAAiB,EAAEC,kBAAkB,EAAQ,GACjE,OAAO,EAAEc,UAAU,EAAEC,OAAO,EAAEC,GAAG,EAAElB,GAAG,EAAE;QACtC,mBAAmB;QACnB,IAAIiB,SAASE,YAAY;YACvB,OAAOD;QACT;QAEA,wCAAwC;QACxC,MAAME,qBACJH,SAASI,0BAA0B,QAAQ,gBAAgB;QAC3DrB,IAAII,KAAK,EAAEiB,0BAA0B,UAAU,kBAAkB;QACjEtB,oBAAoBC,KAAKC,mBAAmBC,oBAAoB,4BAA4B;;QAE9F,IAAI,CAACkB,oBAAoB;YACvB,OAAOF;QACT;QAEA,IAAI;YACF,MAAM,EAAEI,WAAWC,gBAAgB,EAAE,GAAGzB,oBAAoBkB;YAE5D,MAAM,EAAEQ,QAAQ,EAAEC,SAAS,EAAE,GAAG,MAAM5B,aAAa;gBACjDmB;gBACAE;gBACAQ,OAAOR,IAAIS,OAAO,KAAK;gBACvBC,QACEL,oBAAoBvB,IAAI4B,MAAM,KAAK,QAC/B,QACA5B,IAAI4B,MAAM,KAAK,QACbC,YACA7B,IAAI4B,MAAM,IAAIC;gBACtBd;gBACAf;gBACAC;gBACAC;YACF;YAEA,iEAAiE;YACjEgB,GAAG,CAACjB,kBAAkB,GAAGuB;YACzBN,GAAG,CAAChB,mBAAmB,GAAGuB;QAC5B,EAAE,OAAOK,OAAO;YACd,mEAAmE;YACnE,sCAAsC;YACtCC,QAAQD,KAAK,CAAC,CAAC,+CAA+C,EAAEZ,IAAIc,EAAE,CAAC,CAAC,CAAC,EAAEF;QAC7E;QAEA,OAAOZ;IACT,EAAC"}

package/dist/hierarchy/hooks/collectionBeforeChange.d.ts

@@ -0,0 +1,19 @@
+/**
+ * beforeChange Hook Responsibilities:
+ * - Validate circular references when parent changes
+ * - Prevent moving a folder into its own subfolder
+ *
+ * Does NOT handle:
+ * - Tree structure (no stored tree anymore)
+ * - Path computation (done in afterRead)
+ */
+import type { CollectionBeforeChangeHook } from '../../index.js';
+type Args = {
+    /**
+     * The name of the field that contains the parent document ID
+     */
+    parentFieldName: string;
+};
+export declare const hierarchyCollectionBeforeChange: ({ parentFieldName }: Args) => CollectionBeforeChangeHook;
+export {};
+//# sourceMappingURL=collectionBeforeChange.d.ts.map

package/dist/hierarchy/hooks/collectionBeforeChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectionBeforeChange.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/collectionBeforeChange.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,0BAA0B,EAI3B,MAAM,gBAAgB,CAAA;AAEvB,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,+BAA+B,wBACpB,IAAI,KAAG,0BAgC5B,CAAA"}

package/dist/hierarchy/hooks/collectionBeforeChange.js

@@ -0,0 +1,90 @@
+/**
+ * beforeChange Hook Responsibilities:
+ * - Validate circular references when parent changes
+ * - Prevent moving a folder into its own subfolder
+ *
+ * Does NOT handle:
+ * - Tree structure (no stored tree anymore)
+ * - Path computation (done in afterRead)
+ */ export const hierarchyCollectionBeforeChange = ({ parentFieldName })=>async ({ collection, data, operation, originalDoc, req })=>{
+        // Determine the new parent ID
+        const newParentID = data[parentFieldName] !== undefined ? data[parentFieldName] : originalDoc?.[parentFieldName];
+        const parentChanged = operation === 'update' && data[parentFieldName] !== undefined && data[parentFieldName] !== originalDoc?.[parentFieldName];
+        // Validate circular references when parent is changing
+        if (parentChanged && newParentID) {
+            // Extract parent ID (could be plain ID or populated object with id)
+            const parentId = typeof newParentID === 'object' && 'id' in newParentID ? newParentID.id : newParentID;
+            // Prevent self-referential parent
+            if (parentId === (originalDoc?.id || data.id)) {
+                throw new Error('Document cannot be its own parent');
+            }
+            // Check for true circular references (loops in the chain), but allow
+            // moving into a child - that will be handled by afterChange reparenting
+            await validateNoCircularReference({
+                collection,
+                currentDocId: originalDoc?.id,
+                parentId,
+                req
+            });
+        }
+        return data;
+    };
+/**
+ * Walks up the parent chain to detect true circular references (loops).
+ * Does NOT throw when moving into a child - that case is handled by afterChange
+ * which will automatically reparent the child.
+ */ async function validateNoCircularReference({ collection, currentDocId, parentId, req }) {
+    const parentFieldName = collection.hierarchy && collection.hierarchy !== true ? collection.hierarchy.parentFieldName : undefined;
+    if (!parentFieldName) {
+        return;
+    }
+    const fieldName = parentFieldName;
+    async function checkAncestor(ancestorId, visitedNodes = new Set()) {
+        // Create unique key for this node
+        const nodeKey = `${collection.slug}:${ancestorId}`;
+        // Check if we've visited this node before (true loop in the chain)
+        if (visitedNodes.has(nodeKey)) {
+            throw new Error(`Circular reference detected: the parent chain contains a loop`);
+        }
+        // If we've reached the current document, this means we're trying to move into a child
+        if (ancestorId === currentDocId) {
+            throw new Error('Cannot move folder into its own subfolder');
+        }
+        // Add this node to visited set
+        visitedNodes.add(nodeKey);
+        try {
+            const ancestor = await req.payload.findByID({
+                id: ancestorId,
+                collection: collection.slug,
+                depth: 0,
+                req,
+                select: {
+                    [fieldName]: true
+                }
+            });
+            const nextParent = ancestor?.[fieldName];
+            if (!nextParent) {
+                return; // No parent, end of chain
+            }
+            // Extract next parent ID (could be plain ID or populated object)
+            let nextParentId = nextParent;
+            if (typeof nextParent === 'object' && 'id' in nextParent) {
+                nextParentId = nextParent.id;
+            }
+            // Continue traversal if parent exists
+            if (nextParentId !== null && nextParentId !== undefined && (typeof nextParentId === 'string' || typeof nextParentId === 'number')) {
+                return checkAncestor(nextParentId, visitedNodes);
+            }
+        } catch (error) {
+            // If it's our validation error, re-throw it
+            if (error instanceof Error && error.message?.includes('Circular reference detected')) {
+                throw error;
+            }
+            // Non-existent parent can't create a circular reference
+            return;
+        }
+    }
+    await checkAncestor(parentId);
+}
+
+//# sourceMappingURL=collectionBeforeChange.js.map

package/dist/hierarchy/hooks/collectionBeforeChange.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/hooks/collectionBeforeChange.ts"],"sourcesContent":["/**\n * beforeChange Hook Responsibilities:\n * - Validate circular references when parent changes\n * - Prevent moving a folder into its own subfolder\n *\n * Does NOT handle:\n * - Tree structure (no stored tree anymore)\n * - Path computation (done in afterRead)\n */\n\nimport type {\n  CollectionBeforeChangeHook,\n  CollectionConfig,\n  JsonObject,\n  PayloadRequest,\n} from '../../index.js'\n\ntype Args = {\n  /**\n   * The name of the field that contains the parent document ID\n   */\n  parentFieldName: string\n}\n\nexport const hierarchyCollectionBeforeChange =\n  ({ parentFieldName }: Args): CollectionBeforeChangeHook =>\n  async ({ collection, data, operation, originalDoc, req }) => {\n    // Determine the new parent ID\n    const newParentID =\n      data[parentFieldName] !== undefined ? data[parentFieldName] : originalDoc?.[parentFieldName]\n    const parentChanged =\n      operation === 'update' &&\n      data[parentFieldName] !== undefined &&\n      data[parentFieldName] !== originalDoc?.[parentFieldName]\n\n    // Validate circular references when parent is changing\n    if (parentChanged && newParentID) {\n      // Extract parent ID (could be plain ID or populated object with id)\n      const parentId =\n        typeof newParentID === 'object' && 'id' in newParentID ? newParentID.id : newParentID\n\n      // Prevent self-referential parent\n      if (parentId === (originalDoc?.id || data.id)) {\n        throw new Error('Document cannot be its own parent')\n      }\n\n      // Check for true circular references (loops in the chain), but allow\n      // moving into a child - that will be handled by afterChange reparenting\n      await validateNoCircularReference({\n        collection,\n        currentDocId: originalDoc?.id,\n        parentId,\n        req,\n      })\n    }\n\n    return data\n  }\n\n/**\n * Walks up the parent chain to detect true circular references (loops).\n * Does NOT throw when moving into a child - that case is handled by afterChange\n * which will automatically reparent the child.\n */\nasync function validateNoCircularReference({\n  collection,\n  currentDocId,\n  parentId,\n  req,\n}: {\n  collection: CollectionConfig\n  currentDocId: number | string\n  parentId: number | string\n  req: PayloadRequest\n}) {\n  const parentFieldName =\n    collection.hierarchy && collection.hierarchy !== true\n      ? collection.hierarchy.parentFieldName\n      : undefined\n\n  if (!parentFieldName) {\n    return\n  }\n\n  const fieldName = parentFieldName\n\n  async function checkAncestor(\n    ancestorId: number | string,\n    visitedNodes: Set<string> = new Set(),\n  ): Promise<void> {\n    // Create unique key for this node\n    const nodeKey = `${collection.slug}:${ancestorId}`\n\n    // Check if we've visited this node before (true loop in the chain)\n    if (visitedNodes.has(nodeKey)) {\n      throw new Error(`Circular reference detected: the parent chain contains a loop`)\n    }\n\n    // If we've reached the current document, this means we're trying to move into a child\n    if (ancestorId === currentDocId) {\n      throw new Error('Cannot move folder into its own subfolder')\n    }\n\n    // Add this node to visited set\n    visitedNodes.add(nodeKey)\n\n    try {\n      const ancestor = (await req.payload.findByID({\n        id: ancestorId,\n        collection: collection.slug,\n        depth: 0,\n        req,\n        select: {\n          [fieldName]: true,\n        },\n      })) as JsonObject\n\n      const nextParent = ancestor?.[fieldName]\n\n      if (!nextParent) {\n        return // No parent, end of chain\n      }\n\n      // Extract next parent ID (could be plain ID or populated object)\n      let nextParentId = nextParent\n      if (typeof nextParent === 'object' && 'id' in nextParent) {\n        nextParentId = nextParent.id\n      }\n\n      // Continue traversal if parent exists\n      if (\n        nextParentId !== null &&\n        nextParentId !== undefined &&\n        (typeof nextParentId === 'string' || typeof nextParentId === 'number')\n      ) {\n        return checkAncestor(nextParentId, visitedNodes)\n      }\n    } catch (error) {\n      // If it's our validation error, re-throw it\n      if (error instanceof Error && error.message?.includes('Circular reference detected')) {\n        throw error\n      }\n      // Non-existent parent can't create a circular reference\n      return\n    }\n  }\n\n  await checkAncestor(parentId)\n}\n"],"names":["hierarchyCollectionBeforeChange","parentFieldName","collection","data","operation","originalDoc","req","newParentID","undefined","parentChanged","parentId","id","Error","validateNoCircularReference","currentDocId","hierarchy","fieldName","checkAncestor","ancestorId","visitedNodes","Set","nodeKey","slug","has","add","ancestor","payload","findByID","depth","select","nextParent","nextParentId","error","message","includes"],"mappings":"AAAA;;;;;;;;CAQC,GAgBD,OAAO,MAAMA,kCACX,CAAC,EAAEC,eAAe,EAAQ,GAC1B,OAAO,EAAEC,UAAU,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,GAAG,EAAE;QACtD,8BAA8B;QAC9B,MAAMC,cACJJ,IAAI,CAACF,gBAAgB,KAAKO,YAAYL,IAAI,CAACF,gBAAgB,GAAGI,aAAa,CAACJ,gBAAgB;QAC9F,MAAMQ,gBACJL,cAAc,YACdD,IAAI,CAACF,gBAAgB,KAAKO,aAC1BL,IAAI,CAACF,gBAAgB,KAAKI,aAAa,CAACJ,gBAAgB;QAE1D,uDAAuD;QACvD,IAAIQ,iBAAiBF,aAAa;YAChC,oEAAoE;YACpE,MAAMG,WACJ,OAAOH,gBAAgB,YAAY,QAAQA,cAAcA,YAAYI,EAAE,GAAGJ;YAE5E,kCAAkC;YAClC,IAAIG,aAAcL,CAAAA,aAAaM,MAAMR,KAAKQ,EAAE,AAAD,GAAI;gBAC7C,MAAM,IAAIC,MAAM;YAClB;YAEA,qEAAqE;YACrE,wEAAwE;YACxE,MAAMC,4BAA4B;gBAChCX;gBACAY,cAAcT,aAAaM;gBAC3BD;gBACAJ;YACF;QACF;QAEA,OAAOH;IACT,EAAC;AAEH;;;;CAIC,GACD,eAAeU,4BAA4B,EACzCX,UAAU,EACVY,YAAY,EACZJ,QAAQ,EACRJ,GAAG,EAMJ;IACC,MAAML,kBACJC,WAAWa,SAAS,IAAIb,WAAWa,SAAS,KAAK,OAC7Cb,WAAWa,SAAS,CAACd,eAAe,GACpCO;IAEN,IAAI,CAACP,iBAAiB;QACpB;IACF;IAEA,MAAMe,YAAYf;IAElB,eAAegB,cACbC,UAA2B,EAC3BC,eAA4B,IAAIC,KAAK;QAErC,kCAAkC;QAClC,MAAMC,UAAU,GAAGnB,WAAWoB,IAAI,CAAC,CAAC,EAAEJ,YAAY;QAElD,mEAAmE;QACnE,IAAIC,aAAaI,GAAG,CAACF,UAAU;YAC7B,MAAM,IAAIT,MAAM,CAAC,6DAA6D,CAAC;QACjF;QAEA,sFAAsF;QACtF,IAAIM,eAAeJ,cAAc;YAC/B,MAAM,IAAIF,MAAM;QAClB;QAEA,+BAA+B;QAC/BO,aAAaK,GAAG,CAACH;QAEjB,IAAI;YACF,MAAMI,WAAY,MAAMnB,IAAIoB,OAAO,CAACC,QAAQ,CAAC;gBAC3ChB,IAAIO;gBACJhB,YAAYA,WAAWoB,IAAI;gBAC3BM,OAAO;gBACPtB;gBACAuB,QAAQ;oBACN,CAACb,UAAU,EAAE;gBACf;YACF;YAEA,MAAMc,aAAaL,UAAU,CAACT,UAAU;YAExC,IAAI,CAACc,YAAY;gBACf,QAAO,0BAA0B;YACnC;YAEA,iEAAiE;YACjE,IAAIC,eAAeD;YACnB,IAAI,OAAOA,eAAe,YAAY,QAAQA,YAAY;gBACxDC,eAAeD,WAAWnB,EAAE;YAC9B;YAEA,sCAAsC;YACtC,IACEoB,iBAAiB,QACjBA,iBAAiBvB,aAChB,CAAA,OAAOuB,iBAAiB,YAAY,OAAOA,iBAAiB,QAAO,GACpE;gBACA,OAAOd,cAAcc,cAAcZ;YACrC;QACF,EAAE,OAAOa,OAAO;YACd,4CAA4C;YAC5C,IAAIA,iBAAiBpB,SAASoB,MAAMC,OAAO,EAAEC,SAAS,gCAAgC;gBACpF,MAAMF;YACR;YACA,wDAAwD;YACxD;QACF;IACF;IAEA,MAAMf,cAAcP;AACtB"}

package/dist/hierarchy/hooks/collectionBeforeDelete.d.ts

@@ -0,0 +1,15 @@
+/**
+ * beforeDelete Hook Responsibilities:
+ * - Delete child folders when parent is deleted (cascade delete)
+ * - Set context flag for deletion tracking
+ */
+import type { CollectionBeforeDeleteHook } from '../../index.js';
+type Args = {
+    /**
+     * The name of the field that contains the parent document ID
+     */
+    parentFieldName: string;
+};
+export declare const hierarchyCollectionBeforeDelete: ({ parentFieldName }: Args) => CollectionBeforeDeleteHook;
+export {};
+//# sourceMappingURL=collectionBeforeDelete.d.ts.map

package/dist/hierarchy/hooks/collectionBeforeDelete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectionBeforeDelete.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/collectionBeforeDelete.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAEhE,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,eAAO,MAAM,+BAA+B,wBACpB,IAAI,KAAG,0BAe5B,CAAA"}

package/dist/hierarchy/hooks/collectionBeforeDelete.js

@@ -0,0 +1,20 @@
+/**
+ * beforeDelete Hook Responsibilities:
+ * - Delete child folders when parent is deleted (cascade delete)
+ * - Set context flag for deletion tracking
+ */ export const hierarchyCollectionBeforeDelete = ({ parentFieldName })=>async ({ id, collection, req })=>{
+        req.context = req.context || {};
+        req.context.isDeleting = true;
+        // Delete all child folders (cascade delete)
+        await req.payload.delete({
+            collection: collection.slug,
+            req,
+            where: {
+                [parentFieldName]: {
+                    equals: id
+                }
+            }
+        });
+    };
+
+//# sourceMappingURL=collectionBeforeDelete.js.map

package/dist/hierarchy/hooks/collectionBeforeDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/hooks/collectionBeforeDelete.ts"],"sourcesContent":["/**\n * beforeDelete Hook Responsibilities:\n * - Delete child folders when parent is deleted (cascade delete)\n * - Set context flag for deletion tracking\n */\n\nimport type { CollectionBeforeDeleteHook } from '../../index.js'\n\ntype Args = {\n  /**\n   * The name of the field that contains the parent document ID\n   */\n  parentFieldName: string\n}\n\nexport const hierarchyCollectionBeforeDelete =\n  ({ parentFieldName }: Args): CollectionBeforeDeleteHook =>\n  async ({ id, collection, req }) => {\n    req.context = req.context || {}\n    req.context.isDeleting = true\n\n    // Delete all child folders (cascade delete)\n    await req.payload.delete({\n      collection: collection.slug,\n      req,\n      where: {\n        [parentFieldName]: {\n          equals: id,\n        },\n      },\n    })\n  }\n"],"names":["hierarchyCollectionBeforeDelete","parentFieldName","id","collection","req","context","isDeleting","payload","delete","slug","where","equals"],"mappings":"AAAA;;;;CAIC,GAWD,OAAO,MAAMA,kCACX,CAAC,EAAEC,eAAe,EAAQ,GAC1B,OAAO,EAAEC,EAAE,EAAEC,UAAU,EAAEC,GAAG,EAAE;QAC5BA,IAAIC,OAAO,GAAGD,IAAIC,OAAO,IAAI,CAAC;QAC9BD,IAAIC,OAAO,CAACC,UAAU,GAAG;QAEzB,4CAA4C;QAC5C,MAAMF,IAAIG,OAAO,CAACC,MAAM,CAAC;YACvBL,YAAYA,WAAWM,IAAI;YAC3BL;YACAM,OAAO;gBACL,CAACT,gBAAgB,EAAE;oBACjBU,QAAQT;gBACV;YACF;QACF;IACF,EAAC"}

package/dist/hierarchy/hooks/ensureSafeCollectionsChange.d.ts

@@ -0,0 +1,8 @@
+import { type CollectionBeforeValidateHook, type CollectionSlug } from '../../index.js';
+export declare const ensureSafeCollectionsChange: ({ folderFieldName, foldersSlug, parentFieldName, typeFieldName, }: {
+    folderFieldName: string;
+    foldersSlug: CollectionSlug;
+    parentFieldName?: string;
+    typeFieldName?: string;
+}) => CollectionBeforeValidateHook;
+//# sourceMappingURL=ensureSafeCollectionsChange.d.ts.map

package/dist/hierarchy/hooks/ensureSafeCollectionsChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureSafeCollectionsChange.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/ensureSafeCollectionsChange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,4BAA4B,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAIjG,eAAO,MAAM,2BAA2B,sEAMnC;IACD,eAAe,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,cAAc,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,KAAG,4BAmIH,CAAA"}

package/dist/hierarchy/hooks/ensureSafeCollectionsChange.js

@@ -0,0 +1,108 @@
+import { APIError } from '../../index.js';
+import { extractID } from '../../utilities/extractID.js';
+import { getTranslatedLabel } from '../../utilities/getTranslatedLabel.js';
+export const ensureSafeCollectionsChange = ({ folderFieldName, foldersSlug, parentFieldName = 'folder', typeFieldName = 'hierarchyType' })=>async ({ data, originalDoc, req })=>{
+        const currentFolderID = extractID(originalDoc || {});
+        const parentFolderID = extractID(data?.[parentFieldName] || originalDoc?.[parentFieldName] || {});
+        if (Array.isArray(data?.[typeFieldName]) && data[typeFieldName].length > 0) {
+            const typeFieldValue = data[typeFieldName];
+            const currentlyAssignedCollections = Array.isArray(originalDoc?.[typeFieldName]) && originalDoc[typeFieldName].length > 0 ? originalDoc[typeFieldName] : undefined;
+            /**
+       * Check if the assigned collections have changed.
+       * example:
+       * - originalAssignedCollections: ['posts', 'pages']
+       * - folderType: ['posts']
+       *
+       * The user is narrowing the types of documents that can be associated with this folder.
+       * If the user is only expanding the types of documents that can be associated with this folder,
+       * we do not need to do anything.
+       */ const newCollections = currentlyAssignedCollections ? currentlyAssignedCollections.filter((c)=>!typeFieldValue.includes(c)) : typeFieldValue;
+            if (newCollections && newCollections.length > 0) {
+                let dependentCollection = null;
+                if (typeof currentFolderID === 'string' || typeof currentFolderID === 'number') {
+                    // Check each collection being removed for dependent documents
+                    for (const collectionSlug of newCollections){
+                        const result = await req.payload.find({
+                            collection: collectionSlug,
+                            limit: 1,
+                            overrideAccess: true,
+                            req,
+                            where: {
+                                [folderFieldName]: {
+                                    equals: currentFolderID
+                                }
+                            }
+                        });
+                        if (result.totalDocs > 0) {
+                            dependentCollection = collectionSlug;
+                            break;
+                        }
+                    }
+                    // Also check for child folders with these types
+                    if (!dependentCollection) {
+                        const childFoldersResult = await req.payload.find({
+                            collection: foldersSlug,
+                            limit: 1,
+                            overrideAccess: true,
+                            req,
+                            where: {
+                                and: [
+                                    {
+                                        [typeFieldName]: {
+                                            in: newCollections
+                                        }
+                                    },
+                                    {
+                                        [parentFieldName]: {
+                                            equals: currentFolderID
+                                        }
+                                    }
+                                ]
+                            }
+                        });
+                        if (childFoldersResult.totalDocs > 0) {
+                            dependentCollection = foldersSlug;
+                        }
+                    }
+                }
+                if (dependentCollection) {
+                    const translatedLabels = newCollections.map((collectionSlug)=>{
+                        if (req.payload.collections[collectionSlug]?.config.labels.singular) {
+                            return getTranslatedLabel(req.payload.collections[collectionSlug]?.config.labels.plural, req.i18n);
+                        }
+                        return collectionSlug;
+                    });
+                    const isFolder = dependentCollection === foldersSlug;
+                    throw new APIError(`The folder "${data.name || originalDoc.name}" contains ${isFolder ? 'folders' : 'documents'} that still belong to the following collections: ${translatedLabels.join(', ')}`, 400);
+                }
+                return data;
+            }
+        } else if ((data?.[typeFieldName] === null || Array.isArray(data?.[typeFieldName]) && data?.[typeFieldName].length === 0) && parentFolderID) {
+            // attempting to set the type to catch-all, so we need to ensure that the parent allows this
+            let parentFolder;
+            if (typeof parentFolderID === 'string' || typeof parentFolderID === 'number') {
+                try {
+                    parentFolder = await req.payload.findByID({
+                        id: parentFolderID,
+                        collection: foldersSlug,
+                        overrideAccess: true,
+                        req,
+                        select: {
+                            name: true,
+                            [typeFieldName]: true
+                        },
+                        user: req.user
+                    });
+                } catch (_) {
+                // parent folder does not exist
+                }
+            }
+            const parentTypeValue = parentFolder?.[typeFieldName];
+            if (parentFolder && parentTypeValue && Array.isArray(parentTypeValue) && parentTypeValue.length > 0) {
+                throw new APIError(`The folder "${data?.name || originalDoc.name}" must have folder-type set since its parent folder ${parentFolder?.name ? `"${parentFolder?.name}" ` : ''}has a folder-type set.`, 400);
+            }
+        }
+        return data;
+    };
+
+//# sourceMappingURL=ensureSafeCollectionsChange.js.map

package/dist/hierarchy/hooks/ensureSafeCollectionsChange.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/hooks/ensureSafeCollectionsChange.ts"],"sourcesContent":["import { APIError, type CollectionBeforeValidateHook, type CollectionSlug } from '../../index.js'\nimport { extractID } from '../../utilities/extractID.js'\nimport { getTranslatedLabel } from '../../utilities/getTranslatedLabel.js'\n\nexport const ensureSafeCollectionsChange =\n  ({\n    folderFieldName,\n    foldersSlug,\n    parentFieldName = 'folder',\n    typeFieldName = 'hierarchyType',\n  }: {\n    folderFieldName: string\n    foldersSlug: CollectionSlug\n    parentFieldName?: string\n    typeFieldName?: string\n  }): CollectionBeforeValidateHook =>\n  async ({ data, originalDoc, req }) => {\n    const currentFolderID = extractID(originalDoc || {})\n    const parentFolderID = extractID(\n      data?.[parentFieldName] || originalDoc?.[parentFieldName] || {},\n    )\n    if (Array.isArray(data?.[typeFieldName]) && data[typeFieldName].length > 0) {\n      const typeFieldValue = data[typeFieldName] as string[]\n      const currentlyAssignedCollections: string[] | undefined =\n        Array.isArray(originalDoc?.[typeFieldName]) && originalDoc[typeFieldName].length > 0\n          ? originalDoc[typeFieldName]\n          : undefined\n      /**\n       * Check if the assigned collections have changed.\n       * example:\n       * - originalAssignedCollections: ['posts', 'pages']\n       * - folderType: ['posts']\n       *\n       * The user is narrowing the types of documents that can be associated with this folder.\n       * If the user is only expanding the types of documents that can be associated with this folder,\n       * we do not need to do anything.\n       */\n      const newCollections = currentlyAssignedCollections\n        ? // user is narrowing the current scope of the folder\n          currentlyAssignedCollections.filter((c) => !typeFieldValue.includes(c))\n        : // user is adding a scope to the folder\n          typeFieldValue\n\n      if (newCollections && newCollections.length > 0) {\n        let dependentCollection: null | string = null\n\n        if (typeof currentFolderID === 'string' || typeof currentFolderID === 'number') {\n          // Check each collection being removed for dependent documents\n          for (const collectionSlug of newCollections) {\n            const result = await req.payload.find({\n              collection: collectionSlug,\n              limit: 1,\n              overrideAccess: true,\n              req,\n              where: {\n                [folderFieldName]: { equals: currentFolderID },\n              },\n            })\n\n            if (result.totalDocs > 0) {\n              dependentCollection = collectionSlug\n              break\n            }\n          }\n\n          // Also check for child folders with these types\n          if (!dependentCollection) {\n            const childFoldersResult = await req.payload.find({\n              collection: foldersSlug,\n              limit: 1,\n              overrideAccess: true,\n              req,\n              where: {\n                and: [\n                  { [typeFieldName]: { in: newCollections } },\n                  { [parentFieldName]: { equals: currentFolderID } },\n                ],\n              },\n            })\n\n            if (childFoldersResult.totalDocs > 0) {\n              dependentCollection = foldersSlug\n            }\n          }\n        }\n\n        if (dependentCollection) {\n          const translatedLabels = newCollections.map((collectionSlug) => {\n            if (req.payload.collections[collectionSlug]?.config.labels.singular) {\n              return getTranslatedLabel(\n                req.payload.collections[collectionSlug]?.config.labels.plural,\n                req.i18n,\n              )\n            }\n            return collectionSlug\n          })\n\n          const isFolder = dependentCollection === foldersSlug\n          throw new APIError(\n            `The folder \"${data.name || originalDoc.name}\" contains ${isFolder ? 'folders' : 'documents'} that still belong to the following collections: ${translatedLabels.join(', ')}`,\n            400,\n          )\n        }\n\n        return data\n      }\n    } else if (\n      (data?.[typeFieldName] === null ||\n        (Array.isArray(data?.[typeFieldName]) && data?.[typeFieldName].length === 0)) &&\n      parentFolderID\n    ) {\n      // attempting to set the type to catch-all, so we need to ensure that the parent allows this\n      let parentFolder\n      if (typeof parentFolderID === 'string' || typeof parentFolderID === 'number') {\n        try {\n          parentFolder = await req.payload.findByID({\n            id: parentFolderID,\n            collection: foldersSlug,\n            overrideAccess: true,\n            req,\n            select: {\n              name: true,\n              [typeFieldName]: true,\n            },\n            user: req.user,\n          })\n        } catch (_) {\n          // parent folder does not exist\n        }\n      }\n\n      const parentTypeValue = parentFolder?.[typeFieldName]\n      if (\n        parentFolder &&\n        parentTypeValue &&\n        Array.isArray(parentTypeValue) &&\n        parentTypeValue.length > 0\n      ) {\n        throw new APIError(\n          `The folder \"${data?.name || originalDoc.name}\" must have folder-type set since its parent folder ${parentFolder?.name ? `\"${parentFolder?.name}\" ` : ''}has a folder-type set.`,\n          400,\n        )\n      }\n    }\n\n    return data\n  }\n"],"names":["APIError","extractID","getTranslatedLabel","ensureSafeCollectionsChange","folderFieldName","foldersSlug","parentFieldName","typeFieldName","data","originalDoc","req","currentFolderID","parentFolderID","Array","isArray","length","typeFieldValue","currentlyAssignedCollections","undefined","newCollections","filter","c","includes","dependentCollection","collectionSlug","result","payload","find","collection","limit","overrideAccess","where","equals","totalDocs","childFoldersResult","and","in","translatedLabels","map","collections","config","labels","singular","plural","i18n","isFolder","name","join","parentFolder","findByID","id","select","user","_","parentTypeValue"],"mappings":"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"}

package/dist/hierarchy/injectHierarchyButton.d.ts

@@ -0,0 +1,14 @@
+import type { CollectionConfig } from '../collections/config/types.js';
+/**
+ * Injects the HierarchyButton component into a collection's BeforeDocumentMeta slot.
+ *
+ * The HierarchyButton provides a header UI for selecting parent hierarchy items
+ * via miller columns, replacing the standard relationship field input.
+ */
+export declare const injectHierarchyButton: ({ collection, fieldName, hierarchyCollectionSlug, parentFieldName, }: {
+    collection: CollectionConfig;
+    fieldName: string;
+    hierarchyCollectionSlug: string;
+    parentFieldName: string;
+}) => void;
+//# sourceMappingURL=injectHierarchyButton.d.ts.map

package/dist/hierarchy/injectHierarchyButton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectHierarchyButton.d.ts","sourceRoot":"","sources":["../../src/hierarchy/injectHierarchyButton.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,yEAK/B;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,SAAS,EAAE,MAAM,CAAA;IACjB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,eAAe,EAAE,MAAM,CAAA;CACxB,KAAG,IAiCH,CAAA"}

package/dist/hierarchy/injectHierarchyButton.js

@@ -0,0 +1,37 @@
+/**
+ * Injects the HierarchyButton component into a collection's BeforeDocumentMeta slot.
+ *
+ * The HierarchyButton provides a header UI for selecting parent hierarchy items
+ * via miller columns, replacing the standard relationship field input.
+ */ export const injectHierarchyButton = ({ collection, fieldName, hierarchyCollectionSlug, parentFieldName })=>{
+    collection.admin = collection.admin || {};
+    collection.admin.components = collection.admin.components || {};
+    collection.admin.components.edit = collection.admin.components.edit || {};
+    const hierarchyComponent = {
+        path: '@payloadcms/ui/rsc#HierarchyButton',
+        serverProps: {
+            fieldName,
+            hierarchyCollectionSlug,
+            parentFieldName
+        }
+    };
+    const existingComponents = collection.admin.components.edit.BeforeDocumentMeta || [];
+    const componentPath = '@payloadcms/ui/rsc#HierarchyButton';
+    const alreadyInjected = existingComponents.some((c)=>{
+        if (typeof c === 'string') {
+            return c === componentPath;
+        }
+        if (c && typeof c === 'object' && 'path' in c) {
+            return c.path === componentPath;
+        }
+        return false;
+    });
+    if (!alreadyInjected) {
+        collection.admin.components.edit.BeforeDocumentMeta = [
+            hierarchyComponent,
+            ...existingComponents
+        ];
+    }
+};
+
+//# sourceMappingURL=injectHierarchyButton.js.map

package/dist/hierarchy/injectHierarchyButton.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/injectHierarchyButton.ts"],"sourcesContent":["import type { CollectionConfig } from '../collections/config/types.js'\n\n/**\n * Injects the HierarchyButton component into a collection's BeforeDocumentMeta slot.\n *\n * The HierarchyButton provides a header UI for selecting parent hierarchy items\n * via miller columns, replacing the standard relationship field input.\n */\nexport const injectHierarchyButton = ({\n  collection,\n  fieldName,\n  hierarchyCollectionSlug,\n  parentFieldName,\n}: {\n  collection: CollectionConfig\n  fieldName: string\n  hierarchyCollectionSlug: string\n  parentFieldName: string\n}): void => {\n  collection.admin = collection.admin || {}\n  collection.admin.components = collection.admin.components || {}\n  collection.admin.components.edit = collection.admin.components.edit || {}\n\n  const hierarchyComponent = {\n    path: '@payloadcms/ui/rsc#HierarchyButton',\n    serverProps: {\n      fieldName,\n      hierarchyCollectionSlug,\n      parentFieldName,\n    },\n  }\n\n  const existingComponents = collection.admin.components.edit.BeforeDocumentMeta || []\n  const componentPath = '@payloadcms/ui/rsc#HierarchyButton'\n\n  const alreadyInjected = existingComponents.some((c) => {\n    if (typeof c === 'string') {\n      return c === componentPath\n    }\n    if (c && typeof c === 'object' && 'path' in c) {\n      return c.path === componentPath\n    }\n    return false\n  })\n\n  if (!alreadyInjected) {\n    collection.admin.components.edit.BeforeDocumentMeta = [\n      hierarchyComponent,\n      ...existingComponents,\n    ]\n  }\n}\n"],"names":["injectHierarchyButton","collection","fieldName","hierarchyCollectionSlug","parentFieldName","admin","components","edit","hierarchyComponent","path","serverProps","existingComponents","BeforeDocumentMeta","componentPath","alreadyInjected","some","c"],"mappings":"AAEA;;;;;CAKC,GACD,OAAO,MAAMA,wBAAwB,CAAC,EACpCC,UAAU,EACVC,SAAS,EACTC,uBAAuB,EACvBC,eAAe,EAMhB;IACCH,WAAWI,KAAK,GAAGJ,WAAWI,KAAK,IAAI,CAAC;IACxCJ,WAAWI,KAAK,CAACC,UAAU,GAAGL,WAAWI,KAAK,CAACC,UAAU,IAAI,CAAC;IAC9DL,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,GAAGN,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,IAAI,CAAC;IAExE,MAAMC,qBAAqB;QACzBC,MAAM;QACNC,aAAa;YACXR;YACAC;YACAC;QACF;IACF;IAEA,MAAMO,qBAAqBV,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,CAACK,kBAAkB,IAAI,EAAE;IACpF,MAAMC,gBAAgB;IAEtB,MAAMC,kBAAkBH,mBAAmBI,IAAI,CAAC,CAACC;QAC/C,IAAI,OAAOA,MAAM,UAAU;YACzB,OAAOA,MAAMH;QACf;QACA,IAAIG,KAAK,OAAOA,MAAM,YAAY,UAAUA,GAAG;YAC7C,OAAOA,EAAEP,IAAI,KAAKI;QACpB;QACA,OAAO;IACT;IAEA,IAAI,CAACC,iBAAiB;QACpBb,WAAWI,KAAK,CAACC,UAAU,CAACC,IAAI,CAACK,kBAAkB,GAAG;YACpDJ;eACGG;SACJ;IACH;AACF,EAAC"}

package/dist/hierarchy/operations/findRelatedDocuments.d.ts

@@ -0,0 +1,24 @@
+import type { PaginatedDocs, PayloadRequest, SanitizedCollectionConfig } from '../../index.js';
+type RelatedDocumentsResult = {
+    [collectionSlug: string]: PaginatedDocs;
+};
+type Args = {
+    collection: SanitizedCollectionConfig;
+    depth?: number;
+    id: number | string;
+    limit?: number;
+    page?: number;
+    req: PayloadRequest;
+};
+/**
+ * Find all documents across collections that reference a hierarchy item
+ *
+ * This operation:
+ * 1. Finds child hierarchy items (same collection with matching parent)
+ * 2. Uses pre-computed relatedCollections from sanitized hierarchy config
+ * 3. Queries each related collection for documents referencing this hierarchy item
+ * 4. Returns grouped results by collection slug
+ */
+export declare function findRelatedDocuments({ id, collection, depth, limit, page, req, }: Args): Promise<RelatedDocumentsResult>;
+export {};
+//# sourceMappingURL=findRelatedDocuments.d.ts.map

package/dist/hierarchy/operations/findRelatedDocuments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRelatedDocuments.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/operations/findRelatedDocuments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,yBAAyB,EAE1B,MAAM,gBAAgB,CAAA;AAEvB,KAAK,sBAAsB,GAAG;IAC5B,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,CAAA;CACxC,CAAA;AAED,KAAK,IAAI,GAAG;IACV,UAAU,EAAE,yBAAyB,CAAA;IACrC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,EAAE,EACF,UAAU,EACV,KAAS,EACT,KAAU,EACV,IAAQ,EACR,GAAG,GACJ,EAAE,IAAI,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAuExC"}

package/dist/hierarchy/operations/findRelatedDocuments.js

@@ -0,0 +1,73 @@
+/**
+ * Find all documents across collections that reference a hierarchy item
+ *
+ * This operation:
+ * 1. Finds child hierarchy items (same collection with matching parent)
+ * 2. Uses pre-computed relatedCollections from sanitized hierarchy config
+ * 3. Queries each related collection for documents referencing this hierarchy item
+ * 4. Returns grouped results by collection slug
+ */ export async function findRelatedDocuments({ id, collection, depth = 0, limit = 50, page = 1, req }) {
+    const { payload } = req;
+    const results = {};
+    // Get the parent field name from hierarchy config
+    const hierarchyConfig = collection.hierarchy;
+    const parentFieldName = hierarchyConfig && typeof hierarchyConfig === 'object' ? hierarchyConfig.parentFieldName : undefined;
+    if (!parentFieldName) {
+        return results;
+    }
+    // 1. Query child hierarchy items (same collection)
+    results[collection.slug] = await payload.find({
+        collection: collection.slug,
+        depth,
+        limit,
+        overrideAccess: false,
+        page,
+        req,
+        user: req.user,
+        where: {
+            [parentFieldName]: {
+                equals: id
+            }
+        }
+    });
+    // 2. Use pre-computed relatedCollections from sanitized hierarchy config
+    const relatedCollectionsConfig = (hierarchyConfig && typeof hierarchyConfig === 'object' ? hierarchyConfig.relatedCollections : undefined) || {};
+    // 3. Query each related collection
+    for (const [relatedSlug, fieldInfo] of Object.entries(relatedCollectionsConfig)){
+        const relatedCollection = payload.config.collections.find((c)=>c.slug === relatedSlug);
+        if (!relatedCollection) {
+            continue;
+        }
+        const { fieldName, hasMany } = fieldInfo;
+        // Build where clause using pre-computed field info
+        const where = {
+            [fieldName]: hasMany ? {
+                in: [
+                    id
+                ]
+            } : {
+                equals: id
+            }
+        };
+        try {
+            results[relatedSlug] = await payload.find({
+                collection: relatedSlug,
+                depth,
+                limit,
+                overrideAccess: false,
+                page,
+                req,
+                user: req.user,
+                where
+            });
+        } catch (error) {
+            req.payload.logger.warn({
+                err: error,
+                msg: `Failed to query ${relatedSlug} for hierarchy ${collection.slug}:${id}`
+            });
+        }
+    }
+    return results;
+}
+
+//# sourceMappingURL=findRelatedDocuments.js.map