payload 3.84.1 → 4.0.0-internal.d28e9fb

package/dist/hierarchy/getInitialTreeData.js

@@ -0,0 +1,125 @@
+import { DEFAULT_HIERARCHY_TREE_LIMIT } from '../hierarchy/constants.js';
+export const getInitialTreeData = async ({ baseFilter, collectionSlug, expandedNodeIds = [], filterByCollections, limit, payload, selectedNodeId, selectedNodeParentId, user })=>{
+    const collectionConfig = payload.collections[collectionSlug]?.config;
+    if (!collectionConfig || !collectionConfig.hierarchy) {
+        throw new Error(`Collection ${collectionSlug} is not a hierarchy`);
+    }
+    const hierarchyConfig = collectionConfig.hierarchy;
+    const parentFieldName = hierarchyConfig.parentFieldName;
+    const useAsTitle = collectionConfig.admin?.useAsTitle ?? 'id';
+    // Get typeFieldName for filtering
+    const typeFieldName = hierarchyConfig.collectionSpecific && typeof hierarchyConfig.collectionSpecific === 'object' ? hierarchyConfig.collectionSpecific.fieldName : undefined;
+    // Build filter condition if filterByCollections is provided
+    // Exclude the hierarchy collection itself (folders always show folders)
+    const filteredTypes = filterByCollections?.filter((t)=>t !== collectionSlug);
+    // Get all possible type values from relatedCollections for detecting empty arrays
+    const allPossibleTypes = hierarchyConfig.relatedCollections ? Object.keys(hierarchyConfig.relatedCollections) : [];
+    const filterCondition = filteredTypes?.length && typeFieldName ? {
+        or: [
+            {
+                [typeFieldName]: {
+                    in: filteredTypes
+                }
+            },
+            {
+                [typeFieldName]: {
+                    exists: false
+                }
+            },
+            // Include unrestricted folders with empty allowedTypes array
+            // Using not_in with all possible values matches empty arrays in both MongoDB and Postgres
+            ...allPossibleTypes.length > 0 ? [
+                {
+                    [typeFieldName]: {
+                        not_in: allPossibleTypes
+                    }
+                }
+            ] : []
+        ]
+    } : null;
+    // Use limit from config if not provided, fallback to config's treeLimit
+    const effectiveLimit = limit ?? hierarchyConfig.admin?.treeLimit ?? DEFAULT_HIERARCHY_TREE_LIMIT;
+    const allDocs = [];
+    const loadedParents = {};
+    // Normalize selectedNodeParentId: treat null/undefined as 'null' (root level)
+    const normalizedSelectedParentId = selectedNodeParentId === null || selectedNodeParentId === undefined ? 'null' : String(selectedNodeParentId);
+    // Helper to check if selectedNodeId is among siblings at a given parent level
+    const needsSelectedNodeIncluded = (parentKey)=>{
+        return !!selectedNodeId && normalizedSelectedParentId === parentKey;
+    };
+    // Helper to fetch children with optional selectedNodeId inclusion
+    const fetchChildrenForParent = async (parentKey, parentCondition)=>{
+        const mustIncludeSelected = needsSelectedNodeIncluded(parentKey);
+        let accumulatedDocs = [];
+        let currentPage = 1;
+        let hasMore = true;
+        let totalDocs = 0;
+        let foundSelected = false;
+        // Combine parent condition with filter condition and baseFilter
+        const conditions = [
+            parentCondition
+        ];
+        if (filterCondition) {
+            conditions.push(filterCondition);
+        }
+        if (baseFilter) {
+            conditions.push(baseFilter);
+        }
+        const whereClause = conditions.length > 1 ? {
+            and: conditions
+        } : parentCondition;
+        while(hasMore){
+            const result = await payload.find({
+                collection: collectionSlug,
+                depth: 0,
+                limit: effectiveLimit,
+                overrideAccess: false,
+                page: currentPage,
+                sort: useAsTitle,
+                user,
+                where: whereClause
+            });
+            accumulatedDocs = [
+                ...accumulatedDocs,
+                ...result.docs
+            ];
+            totalDocs = result.totalDocs;
+            hasMore = result.hasNextPage;
+            // Check if selectedNodeId is in this page's results
+            if (mustIncludeSelected && !foundSelected) {
+                foundSelected = result.docs.some((doc)=>String(doc.id) === String(selectedNodeId));
+            }
+            // Stop if we've found the selected node OR we only need first page
+            if (!mustIncludeSelected || foundSelected || !hasMore) {
+                break;
+            }
+            currentPage++;
+        }
+        allDocs.push(...accumulatedDocs);
+        loadedParents[parentKey] = {
+            hasMore,
+            loadedCount: accumulatedDocs.length,
+            totalDocs
+        };
+    };
+    // Query 1: Fetch root nodes
+    await fetchChildrenForParent('null', {
+        [parentFieldName]: {
+            exists: false
+        }
+    });
+    // Query 2: For each expanded node, fetch its children
+    for (const parentId of expandedNodeIds){
+        await fetchChildrenForParent(String(parentId), {
+            [parentFieldName]: {
+                equals: parentId
+            }
+        });
+    }
+    return {
+        docs: allDocs,
+        loadedParents
+    };
+};
+
+//# sourceMappingURL=getInitialTreeData.js.map

package/dist/hierarchy/getInitialTreeData.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/getInitialTreeData.ts"],"sourcesContent":["import type { TypeWithID } from '../collections/config/types.js'\nimport type { PayloadRequest, Where } from '../types/index.js'\n\nimport { DEFAULT_HIERARCHY_TREE_LIMIT } from '../hierarchy/constants.js'\n\nexport type GetInitialTreeDataArgs = {\n  /** Base filter to apply to all queries (e.g., tenant filter) */\n  baseFilter?: null | Where\n  collectionSlug: string\n  expandedNodeIds?: (number | string)[]\n  /** Filter tree to only show folders that allow these collection types (or are unrestricted) */\n  filterByCollections?: string[]\n  limit?: number\n  payload: PayloadRequest['payload']\n  /** The currently selected node ID. When provided, ensures siblings are loaded to include this node. */\n  selectedNodeId?: null | number | string\n  /** The parent ID of the selected node. Required when selectedNodeId is provided. */\n  selectedNodeParentId?: null | number | string\n  user: PayloadRequest['user']\n}\n\nexport type InitialTreeData = {\n  docs: TypeWithID[]\n  // Metadata about what was loaded - keyed by parent ID ('null' for root)\n  loadedParents: Record<string, { hasMore: boolean; loadedCount?: number; totalDocs: number }>\n}\n\nexport const getInitialTreeData = async ({\n  baseFilter,\n  collectionSlug,\n  expandedNodeIds = [],\n  filterByCollections,\n  limit,\n  payload,\n  selectedNodeId,\n  selectedNodeParentId,\n  user,\n}: GetInitialTreeDataArgs): Promise<InitialTreeData> => {\n  const collectionConfig = payload.collections[collectionSlug]?.config\n\n  if (!collectionConfig || !collectionConfig.hierarchy) {\n    throw new Error(`Collection ${collectionSlug} is not a hierarchy`)\n  }\n\n  const hierarchyConfig = collectionConfig.hierarchy\n  const parentFieldName = hierarchyConfig.parentFieldName\n  const useAsTitle = collectionConfig.admin?.useAsTitle ?? 'id'\n\n  // Get typeFieldName for filtering\n  const typeFieldName =\n    hierarchyConfig.collectionSpecific && typeof hierarchyConfig.collectionSpecific === 'object'\n      ? hierarchyConfig.collectionSpecific.fieldName\n      : undefined\n\n  // Build filter condition if filterByCollections is provided\n  // Exclude the hierarchy collection itself (folders always show folders)\n  const filteredTypes = filterByCollections?.filter((t) => t !== collectionSlug)\n\n  // Get all possible type values from relatedCollections for detecting empty arrays\n  const allPossibleTypes = hierarchyConfig.relatedCollections\n    ? Object.keys(hierarchyConfig.relatedCollections)\n    : []\n\n  const filterCondition =\n    filteredTypes?.length && typeFieldName\n      ? {\n          or: [\n            { [typeFieldName]: { in: filteredTypes } },\n            { [typeFieldName]: { exists: false } }, // Include unrestricted folders (field doesn't exist)\n            // Include unrestricted folders with empty allowedTypes array\n            // Using not_in with all possible values matches empty arrays in both MongoDB and Postgres\n            ...(allPossibleTypes.length > 0\n              ? [{ [typeFieldName]: { not_in: allPossibleTypes } }]\n              : []),\n          ],\n        }\n      : null\n\n  // Use limit from config if not provided, fallback to config's treeLimit\n  const effectiveLimit = limit ?? hierarchyConfig.admin?.treeLimit ?? DEFAULT_HIERARCHY_TREE_LIMIT\n\n  const allDocs: TypeWithID[] = []\n  const loadedParents: Record<\n    string,\n    { hasMore: boolean; loadedCount: number; totalDocs: number }\n  > = {}\n\n  // Normalize selectedNodeParentId: treat null/undefined as 'null' (root level)\n  const normalizedSelectedParentId =\n    selectedNodeParentId === null || selectedNodeParentId === undefined\n      ? 'null'\n      : String(selectedNodeParentId)\n\n  // Helper to check if selectedNodeId is among siblings at a given parent level\n  const needsSelectedNodeIncluded = (parentKey: string): boolean => {\n    return !!selectedNodeId && normalizedSelectedParentId === parentKey\n  }\n\n  // Helper to fetch children with optional selectedNodeId inclusion\n  const fetchChildrenForParent = async (\n    parentKey: string,\n    parentCondition: Where,\n  ): Promise<void> => {\n    const mustIncludeSelected = needsSelectedNodeIncluded(parentKey)\n    let accumulatedDocs: TypeWithID[] = []\n    let currentPage = 1\n    let hasMore = true\n    let totalDocs = 0\n    let foundSelected = false\n\n    // Combine parent condition with filter condition and baseFilter\n    const conditions: Where[] = [parentCondition]\n    if (filterCondition) {\n      conditions.push(filterCondition)\n    }\n    if (baseFilter) {\n      conditions.push(baseFilter)\n    }\n    const whereClause = conditions.length > 1 ? { and: conditions } : parentCondition\n\n    while (hasMore) {\n      const result = await payload.find({\n        collection: collectionSlug,\n        depth: 0,\n        limit: effectiveLimit,\n        overrideAccess: false,\n        page: currentPage,\n        sort: useAsTitle,\n        user,\n        where: whereClause,\n      })\n\n      accumulatedDocs = [...accumulatedDocs, ...result.docs]\n      totalDocs = result.totalDocs\n      hasMore = result.hasNextPage\n\n      // Check if selectedNodeId is in this page's results\n      if (mustIncludeSelected && !foundSelected) {\n        foundSelected = result.docs.some(\n          (doc: TypeWithID) => String(doc.id) === String(selectedNodeId),\n        )\n      }\n\n      // Stop if we've found the selected node OR we only need first page\n      if (!mustIncludeSelected || foundSelected || !hasMore) {\n        break\n      }\n\n      currentPage++\n    }\n\n    allDocs.push(...accumulatedDocs)\n    loadedParents[parentKey] = {\n      hasMore,\n      loadedCount: accumulatedDocs.length,\n      totalDocs,\n    }\n  }\n\n  // Query 1: Fetch root nodes\n  await fetchChildrenForParent('null', {\n    [parentFieldName]: { exists: false },\n  })\n\n  // Query 2: For each expanded node, fetch its children\n  for (const parentId of expandedNodeIds) {\n    await fetchChildrenForParent(String(parentId), {\n      [parentFieldName]: { equals: parentId },\n    })\n  }\n\n  return {\n    docs: allDocs,\n    loadedParents,\n  }\n}\n"],"names":["DEFAULT_HIERARCHY_TREE_LIMIT","getInitialTreeData","baseFilter","collectionSlug","expandedNodeIds","filterByCollections","limit","payload","selectedNodeId","selectedNodeParentId","user","collectionConfig","collections","config","hierarchy","Error","hierarchyConfig","parentFieldName","useAsTitle","admin","typeFieldName","collectionSpecific","fieldName","undefined","filteredTypes","filter","t","allPossibleTypes","relatedCollections","Object","keys","filterCondition","length","or","in","exists","not_in","effectiveLimit","treeLimit","allDocs","loadedParents","normalizedSelectedParentId","String","needsSelectedNodeIncluded","parentKey","fetchChildrenForParent","parentCondition","mustIncludeSelected","accumulatedDocs","currentPage","hasMore","totalDocs","foundSelected","conditions","push","whereClause","and","result","find","collection","depth","overrideAccess","page","sort","where","docs","hasNextPage","some","doc","id","loadedCount","parentId","equals"],"mappings":"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"}

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

@@ -0,0 +1,14 @@
+/**
+ * afterDelete Hook Responsibilities:
+ * - Clear folder references from related documents when folder is deleted
+ */
+import type { CollectionAfterDeleteHook } from '../../index.js';
+type Args = {
+    /**
+     * Map of collection slugs to their field names
+     */
+    relatedCollections: Record<string, string>;
+};
+export declare const hierarchyCollectionAfterDelete: ({ relatedCollections }: Args) => CollectionAfterDeleteHook;
+export {};
+//# sourceMappingURL=collectionAfterDelete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectionAfterDelete.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/collectionAfterDelete.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAA;AAE/D,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3C,CAAA;AAED,eAAO,MAAM,8BAA8B,2BAChB,IAAI,KAAG,yBAgB/B,CAAA"}

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,uBAuDnE,CAAA"}

package/dist/hierarchy/hooks/collectionAfterRead.js

@@ -0,0 +1,72 @@
+/**
+ * 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 in context
+        context?.computeHierarchyPathsViaSelect === true || // Flag from beforeOperation (select-triggered)
+        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);
+        }
+        // Strip auto-added fields that were only included for path computation
+        const autoAddedFields = context?.hierarchyAutoSelectedFields;
+        if (autoAddedFields && autoAddedFields.length > 0) {
+            for (const fieldName of autoAddedFields){
+                delete doc[fieldName];
+            }
+        }
+        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 in context\n      context?.computeHierarchyPathsViaSelect === true || // Flag from beforeOperation (select-triggered)\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    // Strip auto-added fields that were only included for path computation\n    const autoAddedFields = context?.hierarchyAutoSelectedFields as string[] | undefined\n    if (autoAddedFields && autoAddedFields.length > 0) {\n      for (const fieldName of autoAddedFields) {\n        delete doc[fieldName]\n      }\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","computeHierarchyPathsViaSelect","localized","isTitleLocalized","slugPath","titlePath","draft","_status","locale","undefined","error","console","id","autoAddedFields","hierarchyAutoSelectedFields","length","fieldName"],"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,2BAA2B;QACtEJ,SAASK,mCAAmC,QAAQ,+CAA+C;QACnGtB,IAAII,KAAK,EAAEiB,0BAA0B,UAAU,kBAAkB;QACjEtB,oBAAoBC,KAAKC,mBAAmBC,oBAAoB,4BAA4B;;QAE9F,IAAI,CAACkB,oBAAoB;YACvB,OAAOF;QACT;QAEA,IAAI;YACF,MAAM,EAAEK,WAAWC,gBAAgB,EAAE,GAAG1B,oBAAoBkB;YAE5D,MAAM,EAAES,QAAQ,EAAEC,SAAS,EAAE,GAAG,MAAM7B,aAAa;gBACjDmB;gBACAE;gBACAS,OAAOT,IAAIU,OAAO,KAAK;gBACvBC,QACEL,oBAAoBxB,IAAI6B,MAAM,KAAK,QAC/B,QACA7B,IAAI6B,MAAM,KAAK,QACbC,YACA9B,IAAI6B,MAAM,IAAIC;gBACtBf;gBACAf;gBACAC;gBACAC;YACF;YAEA,iEAAiE;YACjEgB,GAAG,CAACjB,kBAAkB,GAAGwB;YACzBP,GAAG,CAAChB,mBAAmB,GAAGwB;QAC5B,EAAE,OAAOK,OAAO;YACd,mEAAmE;YACnE,sCAAsC;YACtCC,QAAQD,KAAK,CAAC,CAAC,+CAA+C,EAAEb,IAAIe,EAAE,CAAC,CAAC,CAAC,EAAEF;QAC7E;QAEA,uEAAuE;QACvE,MAAMG,kBAAkBjB,SAASkB;QACjC,IAAID,mBAAmBA,gBAAgBE,MAAM,GAAG,GAAG;YACjD,KAAK,MAAMC,aAAaH,gBAAiB;gBACvC,OAAOhB,GAAG,CAACmB,UAAU;YACvB;QACF;QAEA,OAAOnB;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/collectionBeforeOperation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * beforeOperation Hook Responsibilities:
+ * - Detect when path fields (_h_slugPath, _h_titlePath) are selected
+ * - Auto-include required fields (parent, title, slugField) for ancestor traversal
+ * - Track auto-added fields in context so afterRead can strip them from response
+ */
+import type { BeforeOperationHook } from '../../collections/config/types.js';
+import type { CollectionSlug } from '../../index.js';
+type Args = {
+    /**
+     * The name of the field that contains the parent document ID
+     */
+    parentFieldName: string;
+    /**
+     * Optional dedicated slug field for path generation
+     */
+    slugFieldName?: string;
+    /**
+     * The name of the field to populate with the slug-based path
+     */
+    slugPathFieldName: string;
+    /**
+     * The name of the title field (from useAsTitle)
+     */
+    titleFieldName: string;
+    /**
+     * The name of the field to populate with the title-based path
+     */
+    titlePathFieldName: string;
+};
+export declare const hierarchyCollectionBeforeOperation: <TSlug extends CollectionSlug>({ parentFieldName, slugFieldName, slugPathFieldName, titleFieldName, titlePathFieldName, }: Args) => BeforeOperationHook<TSlug>;
+export {};
+//# sourceMappingURL=collectionBeforeOperation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectionBeforeOperation.d.ts","sourceRoot":"","sources":["../../../src/hierarchy/hooks/collectionBeforeOperation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAA;IACtB;;OAEG;IACH,kBAAkB,EAAE,MAAM,CAAA;CAC3B,CAAA;AA0BD,eAAO,MAAM,kCAAkC,GAAI,KAAK,SAAS,cAAc,8FAM5E,IAAI,KAAG,mBAAmB,CAAC,KAAK,CA0DlC,CAAA"}

package/dist/hierarchy/hooks/collectionBeforeOperation.js

@@ -0,0 +1,66 @@
+/**
+ * beforeOperation Hook Responsibilities:
+ * - Detect when path fields (_h_slugPath, _h_titlePath) are selected
+ * - Auto-include required fields (parent, title, slugField) for ancestor traversal
+ * - Track auto-added fields in context so afterRead can strip them from response
+ */ /**
+ * Checks if a field is selected in the select object
+ */ function isFieldInSelect(select, fieldName) {
+    if (!select) {
+        return false;
+    }
+    return select[fieldName] === true;
+}
+/**
+ * Checks if path fields are being selected
+ */ function isPathFieldSelected(select, slugPathFieldName, titlePathFieldName) {
+    if (!select) {
+        return false;
+    }
+    return isFieldInSelect(select, slugPathFieldName) || isFieldInSelect(select, titlePathFieldName);
+}
+export const hierarchyCollectionBeforeOperation = ({ parentFieldName, slugFieldName, slugPathFieldName, titleFieldName, titlePathFieldName })=>{
+    return (hookArgs)=>{
+        const { args, context, operation } = hookArgs;
+        // Only process read operations that have select
+        if (operation !== 'find' && operation !== 'findByID' && operation !== 'read' && operation !== 'findDistinct' && operation !== 'readDistinct') {
+            return;
+        }
+        // Type guard - these operations have select in their args
+        const operationArgs = args;
+        const select = operationArgs.select;
+        // No select means all fields are returned - no augmentation needed
+        if (!select || typeof select !== 'object') {
+            return;
+        }
+        // Check if path fields are being selected
+        if (!isPathFieldSelected(select, slugPathFieldName, titlePathFieldName)) {
+            return;
+        }
+        // Track which fields we auto-add so afterRead can strip them
+        const autoAddedFields = [];
+        // Add parent field if not already selected
+        if (!isFieldInSelect(select, parentFieldName)) {
+            select[parentFieldName] = true;
+            autoAddedFields.push(parentFieldName);
+        }
+        // Add title field if not already selected
+        if (!isFieldInSelect(select, titleFieldName)) {
+            select[titleFieldName] = true;
+            autoAddedFields.push(titleFieldName);
+        }
+        // Add slug field if configured and not already selected
+        if (slugFieldName && !isFieldInSelect(select, slugFieldName)) {
+            select[slugFieldName] = true;
+            autoAddedFields.push(slugFieldName);
+        }
+        // Store auto-added fields in context for afterRead to clean up
+        if (autoAddedFields.length > 0) {
+            context.hierarchyAutoSelectedFields = autoAddedFields;
+        }
+        // Set flag to trigger path computation in afterRead
+        context.computeHierarchyPathsViaSelect = true;
+    };
+};
+
+//# sourceMappingURL=collectionBeforeOperation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/hierarchy/hooks/collectionBeforeOperation.ts"],"sourcesContent":["/**\n * beforeOperation Hook Responsibilities:\n * - Detect when path fields (_h_slugPath, _h_titlePath) are selected\n * - Auto-include required fields (parent, title, slugField) for ancestor traversal\n * - Track auto-added fields in context so afterRead can strip them from response\n */\n\nimport type { BeforeOperationHook } from '../../collections/config/types.js'\nimport type { CollectionSlug } 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   * Optional dedicated slug field for path generation\n   */\n  slugFieldName?: 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 title field (from useAsTitle)\n   */\n  titleFieldName: string\n  /**\n   * The name of the field to populate with the title-based path\n   */\n  titlePathFieldName: string\n}\n\n/**\n * Checks if a field is selected in the select object\n */\nfunction isFieldInSelect(select: Record<string, unknown> | undefined, fieldName: string): boolean {\n  if (!select) {\n    return false\n  }\n  return select[fieldName] === true\n}\n\n/**\n * Checks if path fields are being selected\n */\nfunction isPathFieldSelected(\n  select: Record<string, unknown> | undefined,\n  slugPathFieldName: string,\n  titlePathFieldName: string,\n): boolean {\n  if (!select) {\n    return false\n  }\n  return isFieldInSelect(select, slugPathFieldName) || isFieldInSelect(select, titlePathFieldName)\n}\n\nexport const hierarchyCollectionBeforeOperation = <TSlug extends CollectionSlug>({\n  parentFieldName,\n  slugFieldName,\n  slugPathFieldName,\n  titleFieldName,\n  titlePathFieldName,\n}: Args): BeforeOperationHook<TSlug> => {\n  return (hookArgs) => {\n    const { args, context, operation } = hookArgs\n\n    // Only process read operations that have select\n    if (\n      operation !== 'find' &&\n      operation !== 'findByID' &&\n      operation !== 'read' &&\n      operation !== 'findDistinct' &&\n      operation !== 'readDistinct'\n    ) {\n      return\n    }\n\n    // Type guard - these operations have select in their args\n    const operationArgs = args as { select?: Record<string, unknown> }\n    const select = operationArgs.select\n\n    // No select means all fields are returned - no augmentation needed\n    if (!select || typeof select !== 'object') {\n      return\n    }\n\n    // Check if path fields are being selected\n    if (!isPathFieldSelected(select, slugPathFieldName, titlePathFieldName)) {\n      return\n    }\n\n    // Track which fields we auto-add so afterRead can strip them\n    const autoAddedFields: string[] = []\n\n    // Add parent field if not already selected\n    if (!isFieldInSelect(select, parentFieldName)) {\n      select[parentFieldName] = true\n      autoAddedFields.push(parentFieldName)\n    }\n\n    // Add title field if not already selected\n    if (!isFieldInSelect(select, titleFieldName)) {\n      select[titleFieldName] = true\n      autoAddedFields.push(titleFieldName)\n    }\n\n    // Add slug field if configured and not already selected\n    if (slugFieldName && !isFieldInSelect(select, slugFieldName)) {\n      select[slugFieldName] = true\n      autoAddedFields.push(slugFieldName)\n    }\n\n    // Store auto-added fields in context for afterRead to clean up\n    if (autoAddedFields.length > 0) {\n      context.hierarchyAutoSelectedFields = autoAddedFields\n    }\n\n    // Set flag to trigger path computation in afterRead\n    context.computeHierarchyPathsViaSelect = true\n  }\n}\n"],"names":["isFieldInSelect","select","fieldName","isPathFieldSelected","slugPathFieldName","titlePathFieldName","hierarchyCollectionBeforeOperation","parentFieldName","slugFieldName","titleFieldName","hookArgs","args","context","operation","operationArgs","autoAddedFields","push","length","hierarchyAutoSelectedFields","computeHierarchyPathsViaSelect"],"mappings":"AAAA;;;;;CAKC,GA4BD;;CAEC,GACD,SAASA,gBAAgBC,MAA2C,EAAEC,SAAiB;IACrF,IAAI,CAACD,QAAQ;QACX,OAAO;IACT;IACA,OAAOA,MAAM,CAACC,UAAU,KAAK;AAC/B;AAEA;;CAEC,GACD,SAASC,oBACPF,MAA2C,EAC3CG,iBAAyB,EACzBC,kBAA0B;IAE1B,IAAI,CAACJ,QAAQ;QACX,OAAO;IACT;IACA,OAAOD,gBAAgBC,QAAQG,sBAAsBJ,gBAAgBC,QAAQI;AAC/E;AAEA,OAAO,MAAMC,qCAAqC,CAA+B,EAC/EC,eAAe,EACfC,aAAa,EACbJ,iBAAiB,EACjBK,cAAc,EACdJ,kBAAkB,EACb;IACL,OAAO,CAACK;QACN,MAAM,EAAEC,IAAI,EAAEC,OAAO,EAAEC,SAAS,EAAE,GAAGH;QAErC,gDAAgD;QAChD,IACEG,cAAc,UACdA,cAAc,cACdA,cAAc,UACdA,cAAc,kBACdA,cAAc,gBACd;YACA;QACF;QAEA,0DAA0D;QAC1D,MAAMC,gBAAgBH;QACtB,MAAMV,SAASa,cAAcb,MAAM;QAEnC,mEAAmE;QACnE,IAAI,CAACA,UAAU,OAAOA,WAAW,UAAU;YACzC;QACF;QAEA,0CAA0C;QAC1C,IAAI,CAACE,oBAAoBF,QAAQG,mBAAmBC,qBAAqB;YACvE;QACF;QAEA,6DAA6D;QAC7D,MAAMU,kBAA4B,EAAE;QAEpC,2CAA2C;QAC3C,IAAI,CAACf,gBAAgBC,QAAQM,kBAAkB;YAC7CN,MAAM,CAACM,gBAAgB,GAAG;YAC1BQ,gBAAgBC,IAAI,CAACT;QACvB;QAEA,0CAA0C;QAC1C,IAAI,CAACP,gBAAgBC,QAAQQ,iBAAiB;YAC5CR,MAAM,CAACQ,eAAe,GAAG;YACzBM,gBAAgBC,IAAI,CAACP;QACvB;QAEA,wDAAwD;QACxD,IAAID,iBAAiB,CAACR,gBAAgBC,QAAQO,gBAAgB;YAC5DP,MAAM,CAACO,cAAc,GAAG;YACxBO,gBAAgBC,IAAI,CAACR;QACvB;QAEA,+DAA+D;QAC/D,IAAIO,gBAAgBE,MAAM,GAAG,GAAG;YAC9BL,QAAQM,2BAA2B,GAAGH;QACxC;QAEA,oDAAoD;QACpDH,QAAQO,8BAA8B,GAAG;IAC3C;AACF,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"}