payload 3.84.1 → 4.0.0-internal.d28e9fb

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 currentParentDocID = extractID(originalDoc || {});
+        const newParentDocID = 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 currentParentDocID === 'string' || typeof currentParentDocID === '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: currentParentDocID
+                                }
+                            }
+                        });
+                        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: currentParentDocID
+                                        }
+                                    }
+                                ]
+                            }
+                        });
+                        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) && newParentDocID) {
+            // attempting to set the type to catch-all, so we need to ensure that the parent allows this
+            let parentFolder;
+            if (typeof newParentDocID === 'string' || typeof newParentDocID === 'number') {
+                try {
+                    parentFolder = await req.payload.findByID({
+                        id: newParentDocID,
+                        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 currentParentDocID = extractID(originalDoc || {})\n    const newParentDocID = 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 currentParentDocID === 'string' || typeof currentParentDocID === '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: currentParentDocID },\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: currentParentDocID } },\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      newParentDocID\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 newParentDocID === 'string' || typeof newParentDocID === 'number') {\n        try {\n          parentFolder = await req.payload.findByID({\n            id: newParentDocID,\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","currentParentDocID","newParentDocID","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/presets.d.ts

@@ -0,0 +1,13 @@
+import type { FoldersConfig, TagsConfig } from '../collections/config/types.js';
+import type { HierarchyConfig } from './types.js';
+/**
+ * Builds hierarchy config from folders preset.
+ * Applies folder defaults: allowHasMany: false, FolderIcon, useHeaderButton: true
+ */
+export declare function buildFoldersHierarchy(config: FoldersConfig | true, slug: string): HierarchyConfig;
+/**
+ * Builds hierarchy config from tags preset.
+ * Applies tag defaults: allowHasMany: true, TagIcon
+ */
+export declare function buildTagsHierarchy(config: TagsConfig | true, slug: string): HierarchyConfig;
+//# sourceMappingURL=presets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/hierarchy/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIjD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAqBjG;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAoB3F"}

package/dist/hierarchy/presets.js

@@ -0,0 +1,52 @@
+import { getHierarchyFieldName } from './constants.js';
+/**
+ * Builds hierarchy config from folders preset.
+ * Applies folder defaults: allowHasMany: false, FolderIcon, useHeaderButton: true
+ */ export function buildFoldersHierarchy(config, slug) {
+    const options = config === true ? {} : config;
+    const parentFieldName = options.parentFieldName ?? getHierarchyFieldName(slug);
+    return {
+        ...options,
+        admin: {
+            ...options.admin,
+            components: {
+                Icon: {
+                    clientProps: {
+                        color: 'muted'
+                    },
+                    path: '@payloadcms/ui#FolderIcon'
+                },
+                ...options.admin?.components
+            },
+            useHeaderButton: options.admin?.useHeaderButton ?? true
+        },
+        allowHasMany: false,
+        parentFieldName
+    };
+}
+/**
+ * Builds hierarchy config from tags preset.
+ * Applies tag defaults: allowHasMany: true, TagIcon
+ */ export function buildTagsHierarchy(config, slug) {
+    const options = config === true ? {} : config;
+    const parentFieldName = options.parentFieldName ?? getHierarchyFieldName(slug);
+    return {
+        ...options,
+        admin: {
+            ...options.admin,
+            components: {
+                Icon: {
+                    clientProps: {
+                        color: 'muted'
+                    },
+                    path: '@payloadcms/ui#TagIcon'
+                },
+                ...options.admin?.components
+            }
+        },
+        allowHasMany: options.allowHasMany ?? true,
+        parentFieldName
+    };
+}
+
+//# sourceMappingURL=presets.js.map

package/dist/hierarchy/presets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hierarchy/presets.ts"],"sourcesContent":["import type { FoldersConfig, TagsConfig } from '../collections/config/types.js'\nimport type { HierarchyConfig } from './types.js'\n\nimport { getHierarchyFieldName } from './constants.js'\n\n/**\n * Builds hierarchy config from folders preset.\n * Applies folder defaults: allowHasMany: false, FolderIcon, useHeaderButton: true\n */\nexport function buildFoldersHierarchy(config: FoldersConfig | true, slug: string): HierarchyConfig {\n  const options = config === true ? {} : config\n\n  const parentFieldName = options.parentFieldName ?? getHierarchyFieldName(slug)\n\n  return {\n    ...options,\n    admin: {\n      ...options.admin,\n      components: {\n        Icon: {\n          clientProps: { color: 'muted' },\n          path: '@payloadcms/ui#FolderIcon',\n        },\n        ...options.admin?.components,\n      },\n      useHeaderButton: options.admin?.useHeaderButton ?? true,\n    },\n    allowHasMany: false, // Enforced for folders\n    parentFieldName,\n  }\n}\n\n/**\n * Builds hierarchy config from tags preset.\n * Applies tag defaults: allowHasMany: true, TagIcon\n */\nexport function buildTagsHierarchy(config: TagsConfig | true, slug: string): HierarchyConfig {\n  const options = config === true ? {} : config\n\n  const parentFieldName = options.parentFieldName ?? getHierarchyFieldName(slug)\n\n  return {\n    ...options,\n    admin: {\n      ...options.admin,\n      components: {\n        Icon: {\n          clientProps: { color: 'muted' },\n          path: '@payloadcms/ui#TagIcon',\n        },\n        ...options.admin?.components,\n      },\n    },\n    allowHasMany: options.allowHasMany ?? true, // Default true, can override\n    parentFieldName,\n  }\n}\n"],"names":["getHierarchyFieldName","buildFoldersHierarchy","config","slug","options","parentFieldName","admin","components","Icon","clientProps","color","path","useHeaderButton","allowHasMany","buildTagsHierarchy"],"mappings":"AAGA,SAASA,qBAAqB,QAAQ,iBAAgB;AAEtD;;;CAGC,GACD,OAAO,SAASC,sBAAsBC,MAA4B,EAAEC,IAAY;IAC9E,MAAMC,UAAUF,WAAW,OAAO,CAAC,IAAIA;IAEvC,MAAMG,kBAAkBD,QAAQC,eAAe,IAAIL,sBAAsBG;IAEzE,OAAO;QACL,GAAGC,OAAO;QACVE,OAAO;YACL,GAAGF,QAAQE,KAAK;YAChBC,YAAY;gBACVC,MAAM;oBACJC,aAAa;wBAAEC,OAAO;oBAAQ;oBAC9BC,MAAM;gBACR;gBACA,GAAGP,QAAQE,KAAK,EAAEC,UAAU;YAC9B;YACAK,iBAAiBR,QAAQE,KAAK,EAAEM,mBAAmB;QACrD;QACAC,cAAc;QACdR;IACF;AACF;AAEA;;;CAGC,GACD,OAAO,SAASS,mBAAmBZ,MAAyB,EAAEC,IAAY;IACxE,MAAMC,UAAUF,WAAW,OAAO,CAAC,IAAIA;IAEvC,MAAMG,kBAAkBD,QAAQC,eAAe,IAAIL,sBAAsBG;IAEzE,OAAO;QACL,GAAGC,OAAO;QACVE,OAAO;YACL,GAAGF,QAAQE,KAAK;YAChBC,YAAY;gBACVC,MAAM;oBACJC,aAAa;wBAAEC,OAAO;oBAAQ;oBAC9BC,MAAM;gBACR;gBACA,GAAGP,QAAQE,KAAK,EAAEC,UAAU;YAC9B;QACF;QACAM,cAAcT,QAAQS,YAAY,IAAI;QACtCR;IACF;AACF"}

package/dist/hierarchy/resolveHierarchyCollections.d.ts

@@ -0,0 +1,23 @@
+import type { Config } from '../config/types.js';
+/**
+ * Resolves hierarchy relationships across collections.
+ *
+ * This function runs after individual collection sanitization to establish
+ * cross-collection hierarchy relationships. It discovers which collections
+ * reference each hierarchy and configures the necessary fields, components,
+ * and hooks.
+ *
+ * @remarks
+ * Must be called after all collections are sanitized.
+ *
+ * **What it does:**
+ * - Discovers related collections by scanning for hierarchy relationship fields
+ * - Injects `HierarchyButton` component when `custom.hierarchy.injectHeaderButton` is set
+ * - Adds `collectionSpecific` validation to ensure hierarchy items accept the document type
+ * - Injects the `hierarchyType` select field when `collectionSpecific` is enabled
+ * - Injects join field when `joinField` is configured
+ * - Adds `afterDelete` hook to clear hierarchy references when items are deleted
+ * - Populates `relatedCollections` in the sanitized hierarchy config
+ */
+export declare const resolveHierarchyCollections: (config: Config) => void;
+//# sourceMappingURL=resolveHierarchyCollections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHierarchyCollections.d.ts","sourceRoot":"","sources":["../../src/hierarchy/resolveHierarchyCollections.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAuBhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,2BAA2B,WAAY,MAAM,KAAG,IAiJ5D,CAAA"}

package/dist/hierarchy/resolveHierarchyCollections.js

@@ -0,0 +1,321 @@
+import { sanitizeJoinField } from '../fields/config/sanitizeJoinField.js';
+import { fieldAffectsData } from '../fields/config/types.js';
+import { extractID } from '../utilities/extractID.js';
+import { flattenAllFields } from '../utilities/flattenAllFields.js';
+import { getHierarchyFieldName } from './constants.js';
+import { hierarchyCollectionAfterDelete } from './hooks/collectionAfterDelete.js';
+import { injectHierarchyButton } from './injectHierarchyButton.js';
+/**
+ * Resolves hierarchy relationships across collections.
+ *
+ * This function runs after individual collection sanitization to establish
+ * cross-collection hierarchy relationships. It discovers which collections
+ * reference each hierarchy and configures the necessary fields, components,
+ * and hooks.
+ *
+ * @remarks
+ * Must be called after all collections are sanitized.
+ *
+ * **What it does:**
+ * - Discovers related collections by scanning for hierarchy relationship fields
+ * - Injects `HierarchyButton` component when `custom.hierarchy.injectHeaderButton` is set
+ * - Adds `collectionSpecific` validation to ensure hierarchy items accept the document type
+ * - Injects the `hierarchyType` select field when `collectionSpecific` is enabled
+ * - Injects join field when `joinField` is configured
+ * - Adds `afterDelete` hook to clear hierarchy references when items are deleted
+ * - Populates `relatedCollections` in the sanitized hierarchy config
+ */ export const resolveHierarchyCollections = (config)=>{
+    const hierarchyCollections = config.collections?.filter((col)=>col.hierarchy && typeof col.hierarchy === 'object') || [];
+    for (const hierarchyCollection of hierarchyCollections){
+        const hierarchy = hierarchyCollection.hierarchy;
+        // TypeScript guard - hierarchy is guaranteed to be an object by the filter above
+        if (!hierarchy || typeof hierarchy !== 'object') {
+            continue;
+        }
+        const hierarchyConfig = hierarchy;
+        const defaultFieldName = getHierarchyFieldName(hierarchyCollection.slug);
+        const parentFieldName = hierarchyConfig.parentFieldName ?? defaultFieldName;
+        const isParentFieldNameOverridden = parentFieldName !== defaultFieldName;
+        const collectionSpecific = hierarchyConfig.collectionSpecific;
+        const typeFieldName = collectionSpecific ? collectionSpecific.fieldName : undefined;
+        const allowHasMany = hierarchyConfig.allowHasMany ?? true;
+        // Build relatedCollections by scanning all collections for hierarchy fields
+        const sanitizedRelatedCollections = {};
+        const selfParentField = hierarchyCollection.fields.find((field)=>fieldAffectsData(field) && field.name === parentFieldName && field.type === 'relationship' && field.relationTo === hierarchyCollection.slug);
+        // Check if the hierarchy collection's own parent field should be replaced with a header button
+        if (selfParentField?.custom?.hierarchy?.injectHeaderButton === true) {
+            injectHierarchyButton({
+                collection: hierarchyCollection,
+                fieldName: parentFieldName,
+                hierarchyCollectionSlug: hierarchyCollection.slug,
+                parentFieldName: hierarchyConfig.parentFieldName
+            });
+        }
+        for (const collection of config.collections || []){
+            // Skip the hierarchy collection itself (handled above)
+            if (collection.slug === hierarchyCollection.slug) {
+                continue;
+            }
+            // Find hierarchy field by the default name (what createFolderField uses)
+            const hierarchyField = collection.fields.find((field)=>fieldAffectsData(field) && field.name === defaultFieldName && field.type === 'relationship' && field.relationTo === hierarchyCollection.slug);
+            // If parentFieldName is overridden, rename the field to match
+            if (hierarchyField && isParentFieldNameOverridden) {
+                hierarchyField.name = parentFieldName;
+            }
+            if (!hierarchyField) {
+                continue;
+            }
+            const fieldHasMany = hierarchyField.hasMany ?? allowHasMany;
+            // If collectionSpecific, inject validation to check hierarchy allows this collection type
+            if (collectionSpecific) {
+                injectCollectionSpecificValidation({
+                    hierarchyField,
+                    hierarchySlug: hierarchyCollection.slug,
+                    typeFieldName: typeFieldName
+                });
+            }
+            // Store discovered collection with hasMany info
+            sanitizedRelatedCollections[collection.slug] = {
+                fieldName: parentFieldName,
+                hasMany: fieldHasMany
+            };
+            // Inject HierarchyButton if field requests it
+            if (hierarchyField.custom?.hierarchy?.injectHeaderButton === true) {
+                injectHierarchyButton({
+                    collection,
+                    fieldName: parentFieldName,
+                    hierarchyCollectionSlug: hierarchyCollection.slug,
+                    parentFieldName: hierarchyConfig.parentFieldName
+                });
+            }
+        }
+        // If collectionSpecific, add type field to hierarchy collection
+        if (hierarchyConfig.collectionSpecific) {
+            injectTypeField({
+                config,
+                hierarchyCollection: hierarchyCollection,
+                parentFieldName: hierarchyConfig.parentFieldName,
+                sanitizedRelatedCollections,
+                typeFieldName: hierarchyConfig.collectionSpecific.fieldName
+            });
+        }
+        // If joinField is configured, add the join field to query children
+        if (hierarchyConfig.joinField) {
+            injectJoinField({
+                config,
+                hierarchyCollection: hierarchyCollection,
+                joinFieldConfig: hierarchyConfig.joinField,
+                parentFieldName,
+                relatedSlugs: Object.keys(sanitizedRelatedCollections)
+            });
+        }
+        // Update hierarchy config with sanitized relatedCollections
+        if (hierarchyConfig) {
+            hierarchyConfig.relatedCollections = sanitizedRelatedCollections;
+        }
+        // Add afterDelete hook to clear folder references from related documents
+        if (Object.keys(sanitizedRelatedCollections).length > 0) {
+            injectAfterDeleteHook({
+                hierarchyCollection: hierarchyCollection,
+                sanitizedRelatedCollections
+            });
+        }
+        // Add sidebar tab for this hierarchy collection (unless explicitly disabled)
+        if (hierarchyConfig.admin.injectSidebarTab !== false) {
+            injectSidebarTab({
+                config,
+                hierarchyCollection,
+                hierarchyConfig
+            });
+            // Hide from nav when sidebar tab is injected (unless user explicitly set group)
+            if (hierarchyCollection.admin?.group === undefined) {
+                hierarchyCollection.admin = {
+                    ...hierarchyCollection.admin,
+                    group: false
+                };
+            }
+        }
+    }
+};
+/**
+ * Injects validation for collectionSpecific hierarchy fields.
+ * Ensures the selected hierarchy item allows documents of this collection type.
+ */ function injectCollectionSpecificValidation({ hierarchyField, hierarchySlug, typeFieldName }) {
+    const existingValidate = hierarchyField.validate;
+    const validate = async (value, options)=>{
+        // Run existing validation first if present
+        if (existingValidate) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const existingResult = await existingValidate(value, options);
+            if (existingResult !== true) {
+                return existingResult;
+            }
+        }
+        // No hierarchy selected, no validation needed
+        if (!value) {
+            return true;
+        }
+        const { collectionSlug, overrideAccess, previousValue, req } = options;
+        const newID = extractID(value);
+        // Value didn't change, no validation needed
+        if (previousValue && extractID(previousValue) === newID) {
+            return true;
+        }
+        // Fetch the hierarchy item to check its type field
+        let parentItem = null;
+        if (typeof newID === 'string' || typeof newID === 'number') {
+            try {
+                parentItem = await req.payload.findByID({
+                    id: newID,
+                    collection: hierarchySlug,
+                    depth: 0,
+                    overrideAccess: overrideAccess ?? false,
+                    req,
+                    select: {
+                        [typeFieldName]: true
+                    }
+                });
+            } catch  {
+                return `Hierarchy item with ID ${newID} not found`;
+            }
+        }
+        if (!parentItem) {
+            return `Hierarchy item with ID ${newID} not found`;
+        }
+        const allowedTypes = parentItem[typeFieldName] || [];
+        // If hierarchy has no types, it accepts all collections
+        if (allowedTypes.length === 0) {
+            return true;
+        }
+        // Check if this collection is allowed
+        if (collectionSlug && allowedTypes.includes(collectionSlug)) {
+            return true;
+        }
+        return `Hierarchy item "${newID}" does not allow documents of type "${collectionSlug}"`;
+    };
+    hierarchyField.validate = validate;
+}
+/**
+ * Injects the hierarchyType select field into a hierarchy collection.
+ */ function injectTypeField({ config, hierarchyCollection, parentFieldName, sanitizedRelatedCollections, typeFieldName }) {
+    const collectionOptions = Object.keys(sanitizedRelatedCollections).map((slug)=>{
+        const relatedCollection = config.collections?.find((c)=>c.slug === slug);
+        return {
+            label: relatedCollection?.labels?.plural || slug,
+            value: slug
+        };
+    });
+    const typeField = {
+        name: typeFieldName,
+        type: 'select',
+        admin: {
+            components: {
+                Field: {
+                    path: '@payloadcms/next/rsc#HierarchyTypeFieldServer',
+                    serverProps: {
+                        collectionOptions,
+                        parentFieldName
+                    }
+                }
+            },
+            position: 'sidebar'
+        },
+        hasMany: true,
+        options: collectionOptions
+    };
+    hierarchyCollection.fields = hierarchyCollection.fields || [];
+    hierarchyCollection.fields.push(typeField);
+    // Recompute flattenedFields since we added a field after initial sanitization
+    // This is required for the field to be queryable
+    if ('flattenedFields' in hierarchyCollection) {
+        hierarchyCollection.flattenedFields = flattenAllFields({
+            fields: hierarchyCollection.fields
+        });
+    }
+}
+/**
+ * Injects a join field to query all children of a hierarchy item.
+ */ function injectJoinField({ config, hierarchyCollection, joinFieldConfig, parentFieldName, relatedSlugs }) {
+    const { name, admin: userAdmin, ...userConfig } = joinFieldConfig;
+    const hasJoinField = hierarchyCollection.fields?.some((field)=>'name' in field && field.name === name);
+    if (hasJoinField) {
+        return;
+    }
+    const joinField = {
+        // User config (spread first so auto-generated values take precedence for required fields)
+        ...userConfig,
+        // Auto-generated values (these cannot be overridden)
+        name,
+        type: 'join',
+        collection: [
+            hierarchyCollection.slug,
+            ...relatedSlugs
+        ],
+        hasMany: true,
+        on: parentFieldName,
+        // Merge admin config
+        admin: {
+            ...userAdmin
+        }
+    };
+    hierarchyCollection.fields = hierarchyCollection.fields || [];
+    hierarchyCollection.fields.push(joinField);
+    // Sanitize the join field to register it properly
+    sanitizeJoinField({
+        config,
+        field: joinField,
+        joins: hierarchyCollection.joins,
+        parentIsLocalized: false,
+        polymorphicJoins: hierarchyCollection.polymorphicJoins
+    });
+    // Recompute flattenedFields since we added a field after initial sanitization
+    hierarchyCollection.flattenedFields = flattenAllFields({
+        fields: hierarchyCollection.fields
+    });
+}
+/**
+ * Injects afterDelete hook to clear hierarchy references from related documents.
+ */ function injectAfterDeleteHook({ hierarchyCollection, sanitizedRelatedCollections }) {
+    // Build map of collection slugs to their field names
+    const relatedCollectionFieldMap = {};
+    for (const [slug, relatedConfig] of Object.entries(sanitizedRelatedCollections)){
+        relatedCollectionFieldMap[slug] = relatedConfig.fieldName;
+    }
+    hierarchyCollection.hooks = hierarchyCollection.hooks || {};
+    hierarchyCollection.hooks.afterDelete = [
+        ...hierarchyCollection.hooks.afterDelete || [],
+        hierarchyCollectionAfterDelete({
+            relatedCollections: relatedCollectionFieldMap
+        })
+    ];
+}
+/**
+ * Injects a sidebar tab for a hierarchy collection.
+ */ function injectSidebarTab({ config, hierarchyCollection, hierarchyConfig }) {
+    const tabSlug = `hierarchy-${hierarchyCollection.slug}`;
+    const Icon = hierarchyConfig.admin.components.Icon;
+    // Initialize admin config structure
+    config.admin = config.admin || {};
+    config.admin.components = config.admin.components || {};
+    config.admin.components.sidebar = config.admin.components.sidebar || {};
+    config.admin.components.sidebar.tabs = config.admin.components.sidebar.tabs || [];
+    // Check if tab already exists
+    const hasTab = config.admin.components.sidebar.tabs.some((tab)=>tab.slug === tabSlug);
+    if (!hasTab) {
+        config.admin.components.sidebar.tabs.push({
+            slug: tabSlug,
+            components: {
+                Content: {
+                    clientProps: {
+                        hierarchyCollectionSlug: hierarchyCollection.slug
+                    },
+                    path: '@payloadcms/ui/rsc#HierarchySidebarTabServer'
+                },
+                Icon
+            },
+            label: hierarchyCollection.labels?.plural || hierarchyCollection.slug
+        });
+    }
+}
+
+//# sourceMappingURL=resolveHierarchyCollections.js.map