@firecms/core 3.4.0-canary.63041d0 → 3.4.0-canary.d20cc85

package/dist/types/datasource.d.ts

@@ -96,6 +96,11 @@ export interface SaveEntityProps<M extends Record<string, any> = any> {
  */
 export interface DeleteEntityProps<M extends Record<string, any> = any> {
     entity: Entity<M>;
+    /**
+     * `entity.path` split at its real segment boundaries, when the caller knows them.
+     * Never derived from `entity.path` — see `pathSegments` on FetchCollectionProps.
+     */
+    pathSegments?: string[];
     collection?: EntityCollection<M> | ResolvedEntityCollection<M>;
 }
 /**
@@ -175,11 +180,17 @@ export interface DataSource {
      * @param entityId
      * @return `true` if there are no other fields besides the given entity
      */
-    checkUniqueField(path: string, name: string, value: any, entityId?: string, collection?: EntityCollection): Promise<boolean>;
+    checkUniqueField(path: string, name: string, value: any, entityId?: string, collection?: EntityCollection, 
+    /**
+     * Appended last, and optional, so existing implementations and callers keep
+     * working unchanged — a function declaring fewer parameters stays assignable.
+     * See `pathSegments` on FetchCollectionProps.
+     */
+    pathSegments?: string[]): Promise<boolean>;
     /**
      * Generate an id for a new entity
      */
-    generateEntityId(path: string, collection: EntityCollection): string;
+    generateEntityId(path: string, collection: EntityCollection, pathSegments?: string[]): string;
     /**
      * Count the number of entities in a collection
      */
@@ -202,6 +213,8 @@ export interface DataSource {
     }) => Promise<boolean>;
 }
 export type FilterCombinationValidProps = {
+    /** `path` split at its real segment boundaries — see `pathSegments` on FetchCollectionProps. */
+    pathSegments?: string[];
     path: string;
     collection: EntityCollection<any>;
     filterValues: FilterValues<any>;
@@ -287,11 +300,11 @@ export interface DataSourceDelegate {
      * @param collection
      * @return `true` if there are no other fields besides the given entity
      */
-    checkUniqueField(path: string, name: string, value: any, entityId?: string, collection?: EntityCollection): Promise<boolean>;
+    checkUniqueField(path: string, name: string, value: any, entityId?: string, collection?: EntityCollection, pathSegments?: string[]): Promise<boolean>;
     /**
      * Generate an id for a new entity
      */
-    generateEntityId(path: string, collection?: EntityCollection): string;
+    generateEntityId(path: string, collection?: EntityCollection, pathSegments?: string[]): string;
     /**
      * Count the number of entities in a collection
      */

package/dist/types/entities.d.ts

@@ -17,6 +17,16 @@ export interface Entity<M extends object = any> {
      * to the root of the database).
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * `path` is a single flattened string, so a parent entity id containing "/" cannot be
+     * recovered from it. This keeps each segment whole.
+     *
+     * Optional, and never derived by splitting `path` — a guess would be wrong in exactly
+     * the case the field exists for. Absent means "not known here", not "no slashes".
+     */
+    pathSegments?: string[];
     /**
      * Current values
      */
@@ -46,7 +56,17 @@ export declare class EntityReference {
      * Optional database ID where the entity is stored (if multiple databases are used)
      */
     readonly databaseId?: string;
-    constructor(id: string, path: string, databaseId?: string);
+    /**
+     * `path` split at its real segment boundaries, e.g. `["nodes", "node/42", "edges"]`.
+     *
+     * `path` is a single flattened string, so a parent entity id containing "/" cannot be
+     * recovered from it. This keeps each segment whole.
+     *
+     * Optional, and never derived by splitting `path` — a guess would be wrong in exactly
+     * the case the field exists for. Absent means "not known here", not "no slashes".
+     */
+    readonly pathSegments?: string[];
+    constructor(id: string, path: string, databaseId?: string, pathSegments?: string[]);
     get pathWithId(): string;
     get pathWithIdAndDatabase(): string;
     isEntityReference(): boolean;

package/dist/util/parent_references_from_path.d.ts

@@ -3,4 +3,5 @@ export declare function getParentReferencesFromPath(props: {
     path: string;
     collections: EntityCollection[] | undefined;
     currentFullPath?: string;
+    currentPathSegments?: string[];
 }): EntityReference[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@firecms/core",
   "type": "module",
-  "version": "3.4.0-canary.63041d0",
+  "version": "3.4.0-canary.d20cc85",
   "description": "Awesome Firebase/Firestore-based headless open-source CMS",
   "funding": {
     "url": "https://github.com/sponsors/firecmsco"
@@ -53,8 +53,8 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",
     "@dnd-kit/sortable": "^10.0.0",
-    "@firecms/formex": "3.4.0-canary.63041d0",
-    "@firecms/ui": "3.4.0-canary.63041d0",
+    "@firecms/formex": "3.4.0-canary.d20cc85",
+    "@firecms/ui": "3.4.0-canary.d20cc85",
     "@floating-ui/dom": "^1.7.4",
     "@radix-ui/react-portal": "^1.1.10",
     "@radix-ui/react-slot": "^1.2.4",
@@ -89,7 +89,7 @@
     "prosemirror-view": "^1.33.8",
     "react-dropzone": "^14.3.8",
     "react-fast-compare": "^3.2.2",
-    "react-i18next": "^14.1.3",
+    "react-i18next": "^17.0.11",
     "react-image-crop": "^11.0.10",
     "react-markdown": "^9.1.0",
     "react-moveable": "^0.56.0",

package/src/components/EntityCollectionTable/internal/popup_field/PopupFormField.tsx

@@ -26,6 +26,8 @@ import { OnCellValueChangeParams } from "../../../common";
 interface PopupFormFieldProps<M extends Record<string, any>> {
     customFieldValidator?: CustomFieldValidator;
     path: string;
+    /** `path` split at its real segment boundaries; forwarded to the datasource. */
+    pathSegments?: string[];
     entityId: string;
     tableKey: string;
     propertyKey?: Extract<keyof M, string>;
@@ -54,6 +56,7 @@ export function PopupFormFieldLoading<M extends Record<string, any>>({
                                                                          propertyKey,
                                                                          collection: inputCollection,
                                                                          path,
+                                                                         pathSegments,
                                                                          cellRect,
                                                                          open,
                                                                          onClose,
@@ -66,11 +69,12 @@ export function PopupFormFieldLoading<M extends Record<string, any>>({
         if (entityId && inputCollection) {
             dataSource.fetchEntity({
                 path,
+                pathSegments,
                 entityId,
                 collection: inputCollection
             }).then(setEntity);
         }
-    }, [entityId, inputCollection, dataSource, path]);
+    }, [entityId, inputCollection, dataSource, path, pathSegments]);
 
     if (!entity) return null;
     return <PopupFormFieldInternal {...{

package/src/components/EntityCollectionView/EntityCollectionBoardView.tsx

@@ -42,6 +42,8 @@ export type EntityCollectionBoardViewProps<M extends Record<string, any> = any>
     collection: EntityCollection<M>;
     tableController: EntityTableController<M>;
     fullPath: string;
+    /** `fullPath` split at its real segment boundaries; forwarded to the datasource. */
+    pathSegments?: string[];
     parentCollectionIds?: string[];
     columnProperty: string;
     onEntityClick?: (entity: Entity<M>) => void;
@@ -60,6 +62,7 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
     collection,
     tableController,
     fullPath,
+    pathSegments,
     parentCollectionIds = [],
     columnProperty,
     onEntityClick,
@@ -169,6 +172,7 @@ export function EntityCollectionBoardView<M extends Record<string, any> = any>({
     // Use the new per-column data controller
     const boardDataController = useBoardDataController<M>({
         fullPath,
+        pathSegments,
         collection,
         columnProperty,
         columns,

package/src/components/EntityCollectionView/EntityCollectionView.tsx

@@ -789,6 +789,7 @@ export const EntityCollectionView = React.memo(
         // EntitiesCount fetches count and updates breadcrumb - no visual rendering needed here
         const countFetcher = <EntitiesCount
             fullPath={fullPath}
+            pathSegments={pathSegments}
             collection={collection}
             filter={tableController.filterValues}
             sortBy={tableController.sortBy}
@@ -933,6 +934,7 @@ export const EntityCollectionView = React.memo(
                         collection={collection}
                         tableController={tableController}
                         fullPath={fullPath}
+                        pathSegments={pathSegments}
                         parentCollectionIds={parentCollectionIds}
                         columnProperty={selectedKanbanProperty}
                         onEntityClick={onEntityClick}
@@ -1063,6 +1065,7 @@ export const EntityCollectionView = React.memo(
 
                 {popupCell && <PopupFormField
                     key={`popup_form_${popupCell?.propertyKey}_${popupCell?.entityId}`}
+                    pathSegments={pathSegments}
                     open={Boolean(popupCell)}
                     onClose={onPopupClose}
                     cellRect={popupCell?.cellRect}
@@ -1118,13 +1121,16 @@ function EntitiesCount({
     collection,
     filter,
     sortBy,
-    onCountChange
+    onCountChange,
+    pathSegments
 }: {
     fullPath: string,
     collection: EntityCollection,
     filter?: FilterValues<any>,
     sortBy?: [string, "asc" | "desc"],
     onCountChange?: (count: number) => void,
+    /** `fullPath` split at its real segment boundaries; forwarded to countEntities. */
+    pathSegments?: string[],
 }) {
 
     const dataSource = useDataSource(collection);
@@ -1135,17 +1141,19 @@ function EntitiesCount({
     const sortByProperty = sortBy ? sortBy[0] : undefined;
     const currentSort = sortBy ? sortBy[1] : undefined;
     const resolvedPath = useMemo(() => navigation.resolveIdsFrom(fullPath), [fullPath, navigation.resolveIdsFrom]);
+    const resolvedPathSegments = pathSegments;
 
     useEffect(() => {
         if (dataSource.countEntities)
             dataSource.countEntities({
                 path: resolvedPath,
+                pathSegments: resolvedPathSegments,
                 collection,
                 filter,
                 orderBy: sortByProperty,
                 order: currentSort
             }).then(setCount).catch(setError);
-    }, [fullPath, dataSource.countEntities, resolvedPath, collection, filter, sortByProperty, currentSort]);
+    }, [fullPath, dataSource.countEntities, resolvedPath, resolvedPathSegments, collection, filter, sortByProperty, currentSort]);
 
     useEffect(() => {
         if (onCountChange && count !== undefined) {

package/src/components/EntityCollectionView/useBoardDataController.tsx

@@ -45,6 +45,8 @@ export interface BoardDataController<M extends Record<string, any> = any, COLUMN
 export interface UseBoardDataControllerProps<M extends Record<string, any> = any> {
     /** Full path to the collection */
     fullPath: string;
+    /** `fullPath` split at its real segment boundaries; forwarded to the datasource. */
+    pathSegments?: string[];
     /** The entity collection configuration */
     collection: EntityCollection<M>;
     /** Property key used for column assignment */
@@ -67,6 +69,7 @@ export interface UseBoardDataControllerProps<M extends Record<string, any> = any
  */
 export function useBoardDataController<M extends Record<string, any> = any, COLUMN extends string = string>({
     fullPath,
+    pathSegments,
     collection,
     columnProperty,
     columns,
@@ -80,6 +83,7 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
     const dataSource = useDataSource(collection);
     const navigation = useNavigationController();
     const resolvedPath = useMemo(() => navigation.resolveIdsFrom(fullPath), [fullPath, navigation.resolveIdsFrom]);
+    const resolvedPathSegments = pathSegments;
 
     // Stable refs for objects that shouldn't trigger re-subscriptions
     const dataSourceRef = useRef(dataSource);
@@ -95,11 +99,13 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
     const orderPropertyRef = useRef(orderProperty);
     const searchStringRef = useRef(searchString);
     const resolvedPathRef = useRef(resolvedPath);
+    const resolvedPathSegmentsRef = useRef(resolvedPathSegments);
     filterValuesRef.current = filterValues;
     columnPropertyRef.current = columnProperty;
     orderPropertyRef.current = orderProperty;
     searchStringRef.current = searchString;
     resolvedPathRef.current = resolvedPath;
+    resolvedPathSegmentsRef.current = resolvedPathSegments;
 
     // Track item count per column for pagination
     const [columnItemCounts, setColumnItemCounts] = useState<Record<string, number>>(() => {
@@ -168,6 +174,7 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
         const currentOrderProperty = orderPropertyRef.current;
         const currentSearchString = searchStringRef.current;
         const currentResolvedPath = resolvedPathRef.current;
+        const currentPathSegments = resolvedPathSegmentsRef.current;
 
         // Build filter for this column
         const columnFilter: FilterValues<string> = {
@@ -248,6 +255,7 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
         if (currentDataSource.listenCollection) {
             const unsubscribe = currentDataSource.listenCollection<M>({
                 path: currentResolvedPath,
+                pathSegments: currentPathSegments,
                 collection: currentCollection,
                 onUpdate,
                 onError,
@@ -262,6 +270,7 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
         } else {
             currentDataSource.fetchCollection<M>({
                 path: currentResolvedPath,
+                pathSegments: currentPathSegments,
                 collection: currentCollection,
                 searchString: currentSearchString,
                 filter: columnFilter,
@@ -297,6 +306,7 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
         const currentColumnProperty = columnPropertyRef.current;
         const currentSearchString = searchStringRef.current;
         const currentResolvedPath = resolvedPathRef.current;
+        const currentPathSegments = resolvedPathSegmentsRef.current;
         const currentColumns = columns;
         const currentColumnItemCounts = columnItemCounts;
 
@@ -316,6 +326,7 @@ export function useBoardDataController<M extends Record<string, any> = any, COLU
                     };
                     currentDataSource.countEntities({
                         path: currentResolvedPath,
+                        pathSegments: currentPathSegments,
                         collection: currentCollection,
                         filter: columnFilter,
                         searchString: currentSearchString

package/src/components/ReferenceTable/ReferenceSelectionTable.tsx

@@ -44,6 +44,15 @@ export interface ReferenceSelectionInnerProps<M extends Record<string, any>> {
      * dynamic. If not set, the dialog won't open.
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries, when the caller knows them.
+     *
+     * Left undefined by default and deliberately NOT derived from `path`: a reference
+     * path comes from a property's configuration, so there is no entity chain to recover
+     * the boundaries from. Splitting it would silently produce the wrong segments for a
+     * subcollection under a slash-bearing parent id, which is worse than not answering.
+     */
+    pathSegments?: string[];
 
     /**
      * If you are opening the dialog for the first time, you can select some
@@ -96,6 +105,7 @@ export function ReferenceSelectionTable<M extends Record<string, any>>(
         multiselect,
         collection,
         path: pathInput,
+        pathSegments,
         selectedEntityIds: selectedEntityIdsProp,
         description,
         forceFilter,
@@ -153,6 +163,7 @@ export function ReferenceSelectionTable<M extends Record<string, any>>(
                 selectedEntityIds.map((entityId) =>
                     dataSource.fetchEntity({
                         path: fullPath,
+                        pathSegments,
                         entityId,
                         collection
                     })))

package/src/components/common/useDataSourceTableController.tsx

@@ -95,8 +95,8 @@ export function useDataSourceTableController<M extends Record<string, any> = any
     const navigation = useNavigationController();
     const dataSource = useDataSource(collection);
     const resolvedPath = useMemo(() => navigation.resolveIdsFrom(fullPath), [fullPath, navigation.resolveIdsFrom]);
-    const resolvedPathSegments = useMemo(() => pathSegments ?? resolvedPath.split("/"),
-        [pathSegments, resolvedPath]);
+    // Passed through as-is; never derived from `resolvedPath` (see useEntityFetch).
+    const resolvedPathSegments = pathSegments;
 
     const forceFilter = forceFilterFromProps ?? forceFilterFromCollection;
     const paginationEnabled = collection.pagination === undefined || Boolean(collection.pagination);
@@ -108,6 +108,7 @@ export function useDataSourceTableController<M extends Record<string, any> = any
             return true;
         return dataSource.isFilterCombinationValid({
             path: resolvedPath,
+            pathSegments: resolvedPathSegments,
             collection,
             filterValues,
             sortBy
@@ -234,6 +235,11 @@ export function useDataSourceTableController<M extends Record<string, any> = any
         setDataLoading(true);
 
         const onEntitiesUpdate = async (entities: Entity<M>[]) => {
+            // See useEntityFetch: entities carry the segments they were loaded with, so a
+            // reference or a delete derived from a table row stays resolvable.
+            if (resolvedPathSegments) {
+                entities = entities.map(e => e.pathSegments ? e : { ...e, pathSegments: resolvedPathSegments });
+            }
             if (collection.callbacks?.onFetch) {
                 try {
                     entities = await Promise.all(

package/src/core/EntityEditView.tsx

@@ -361,9 +361,11 @@ export function EntityEditViewInner<M extends Record<string, any>>({
         const newFullIdPath = fullIdPath && usedEntity ? `${fullIdPath}/${encodeEntityId(usedEntity.id)}/${removeInitialAndTrailingSlashes(subcollectionId)}` : undefined;
         // The subcollection sits under this entity, so its segments are ours plus this
         // entity's id (kept whole, slashes and all) plus the subcollection's own path.
-        const newPathSegments = usedEntity
+        // Only extendable when we were given real segments — deriving the parent chain
+        // from the flattened `path` would drop the boundary of a slash-bearing parent id.
+        const newPathSegments = usedEntity && pathSegments
             ? [
-                ...(pathSegments ?? path.split("/")),
+                ...pathSegments,
                 usedEntity.id,
                 ...removeInitialAndTrailingSlashes(subcollection.path).split("/")
             ]
@@ -432,6 +434,7 @@ export function EntityEditViewInner<M extends Record<string, any>>({
         fullIdPath={fullIdPath}
         collection={collection}
         path={path}
+        pathSegments={pathSegments}
         entityId={entityId ?? usedEntity?.id}
         onValuesModified={onValuesModified}
         entity={entity}

package/src/form/EntityForm.tsx

@@ -71,6 +71,11 @@ export type OnUpdateParams = {
 
 export type EntityFormProps<M extends Record<string, any>> = {
     path: string;
+    /**
+     * `path` split at its real segment boundaries; forwarded to the datasource for
+     * generateEntityId and checkUniqueField. Never derived from `path`.
+     */
+    pathSegments?: string[];
     fullIdPath?: string;
     collection: EntityCollection<M>;
     entityId?: string;
@@ -214,6 +219,7 @@ export function getChanges<T extends object>(source: Partial<T>, comparison: Par
 
 export function EntityForm<M extends Record<string, any>>({
     path,
+    pathSegments,
     fullIdPath,
     entityId: entityIdProp,
     collection,
@@ -292,7 +298,7 @@ export function EntityForm<M extends Record<string, any>>({
             if (mustSetCustomId) {
                 return undefined;
             } else {
-                return dataSource.generateEntityId(path, collection);
+                return dataSource.generateEntityId(path, collection, pathSegments);
             }
         } else {
             return entityIdProp;
@@ -692,7 +698,7 @@ export function EntityForm<M extends Record<string, any>>({
     const uniqueFieldValidator: CustomFieldValidator = useCallback(({
         name,
         value
-    }) => dataSource.checkUniqueField(path, name, value, entityId, collection),
+    }) => dataSource.checkUniqueField(path, name, value, entityId, collection, pathSegments),
         [dataSource, path, entityId]);
 
     const validationSchema = useMemo(() => entityId

package/src/hooks/data/delete.ts

@@ -81,6 +81,8 @@ export async function deleteEntityWithCallbacks<M extends Record<string, any>, U
         }
     }
     return dataSource.deleteEntity({
+        // Carried by the entity from the fetch that produced it; undefined if unknown.
+        pathSegments: entity.pathSegments,
         entity,
         collection
     }).then(() => {

package/src/hooks/data/save.ts

@@ -104,7 +104,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, USE
     return dataSource.saveEntity({
         collection,
         path: resolvedPath,
-        pathSegments: pathSegments ?? resolvedPath.split("/"),
+        pathSegments,
         entityId,
         values: updatedValues,
         previousValues,

package/src/hooks/data/useCollectionFetch.tsx

@@ -13,6 +13,12 @@ export interface CollectionFetchProps<M extends Record<string, any>> {
      * Absolute collection path
      */
     path: string;
+    /**
+     * `path` split at its real segment boundaries. Forwarded to the datasource so a parent
+     * entity id containing "/" stays unambiguous. Never derived from `path` — see
+     * `pathSegments` on the datasource props.
+     */
+    pathSegments?: string[];
 
     /**
      * collection of the entity displayed by this collection
@@ -63,6 +69,7 @@ export interface CollectionFetchResult<M extends Record<string, any>> {
 export function useCollectionFetch<M extends Record<string, any>, USER extends User>(
     {
         path: inputPath,
+        pathSegments,
         collection,
         filterValues,
         sortBy,
@@ -91,6 +98,10 @@ export function useCollectionFetch<M extends Record<string, any>, USER extends U
         setDataLoading(true);
 
         const onEntitiesUpdate = async (entities: Entity<M>[]) => {
+            // See useEntityFetch: entities carry the segments they were loaded with.
+            if (pathSegments) {
+                entities = entities.map(e => e.pathSegments ? e : { ...e, pathSegments });
+            }
             if (collection.callbacks?.onFetch) {
                 try {
                     entities = await Promise.all(
@@ -124,6 +135,7 @@ export function useCollectionFetch<M extends Record<string, any>, USER extends U
         if (dataSource.listenCollection) {
             return dataSource.listenCollection<M>({
                 path,
+                pathSegments,
                 collection,
                 onUpdate: onEntitiesUpdate,
                 onError,
@@ -137,6 +149,7 @@ export function useCollectionFetch<M extends Record<string, any>, USER extends U
         } else {
             dataSource.fetchCollection<M>({
                 path,
+                pathSegments,
                 collection,
                 searchString,
                 filter: filterValues,

package/src/hooks/data/useEntityFetch.tsx

@@ -55,7 +55,10 @@ export function useEntityFetch<M extends Record<string, any>, USER extends User>
     const navigationController = useNavigationController();
 
     const path = navigationController.resolveIdsFrom(inputPath);
-    const pathSegments = inputPathSegments ?? path.split("/");
+    // Never fabricate segments. If the caller did not thread them, pass undefined so a
+    // delegate can tell "not provided" from a real answer — splitting `path` here would
+    // produce a confidently wrong array for any id containing "/".
+    const pathSegments = inputPathSegments;
 
     const context: FireCMSContext<USER> = useFireCMSContext();
 
@@ -68,6 +71,12 @@ export function useEntityFetch<M extends Record<string, any>, USER extends User>
         setDataLoading(true);
 
         const onEntityUpdate = async (updatedEntity: Entity<M> | undefined) => {
+            // Attach the segments this entity was loaded with, so anything derived from it
+            // later — a reference, a delete — stays resolvable without re-deriving them
+            // from the flattened path. Delegates are not required to set this themselves.
+            if (updatedEntity && pathSegments && !updatedEntity.pathSegments) {
+                updatedEntity = { ...updatedEntity, pathSegments };
+            }
             if (collection.callbacks?.onFetch && updatedEntity) {
                 try {
                     updatedEntity = await collection.callbacks.onFetch({

package/src/hooks/useResolvedNavigationFrom.tsx

@@ -86,6 +86,8 @@ export function resolveNavigationFrom<M extends Record<string, any>, USER extend
                 }
                 return dataSource.fetchEntity({
                     path: entry.path,
+                    // The navigation entry already knows the real segment boundaries.
+                    pathSegments: entry.pathSegments,
                     entityId: entry.entityId,
                     collection
                 })

package/src/internal/useBuildDataSource.ts

@@ -303,12 +303,15 @@ export function useBuildDataSource({
         deleteEntity: useCallback(<M extends Record<string, any>>(
             {
                 entity,
+                pathSegments,
                 collection
             }: DeleteEntityProps<M>
         ): Promise<void> => {
             const usedDelegate = collection?.overrides?.dataSourceDelegate ?? delegate;
             return usedDelegate.deleteEntity({
                 entity,
+                // Falls back to what the entity carries from the fetch that produced it.
+                pathSegments: pathSegments ?? entity.pathSegments,
                 collection
             });
         }, [delegate.deleteEntity]),
@@ -328,25 +331,28 @@ export function useBuildDataSource({
             name: string,
             value: any,
             entityId?: string,
-            collection?: EntityCollection
+            collection?: EntityCollection,
+            pathSegments?: string[]
         ): Promise<boolean> => {
             const usedDelegate = collection?.overrides?.dataSourceDelegate ?? delegate;
-            return usedDelegate.checkUniqueField(path, name, value, entityId, collection);
+            return usedDelegate.checkUniqueField(path, name, value, entityId, collection, pathSegments);
         }, [delegate.checkUniqueField]),
 
-        generateEntityId: useCallback((path: string, collection: EntityCollection): string => {
+        generateEntityId: useCallback((path: string, collection: EntityCollection, pathSegments?: string[]): string => {
             const usedDelegate = collection?.overrides?.dataSourceDelegate ?? delegate;
-            return usedDelegate.generateEntityId(path, collection);
+            return usedDelegate.generateEntityId(path, collection, pathSegments);
         }, [delegate.generateEntityId]),
 
         countEntities: delegate.countEntities ? async ({
             path,
+            pathSegments,
             collection,
             filter,
             order,
             orderBy
         }: {
             path: string,
+            pathSegments?: string[],
             collection: EntityCollection<any>,
             filter?: FilterValues<Extract<keyof any, string>>,
             orderBy?: string,
@@ -355,6 +361,7 @@ export function useBuildDataSource({
             const usedDelegate = collection?.overrides?.dataSourceDelegate ?? delegate;
             return usedDelegate.countEntities!({
                 path,
+                pathSegments,
                 filter,
                 orderBy,
                 order,
@@ -364,11 +371,13 @@ export function useBuildDataSource({
 
         isFilterCombinationValid: useCallback(({
             path,
+            pathSegments,
             databaseId,
             filterValues,
             sortBy
         }: {
             path: string,
+            pathSegments?: string[],
             databaseId?: string,
             filterValues: FilterValues<any>,
             sortBy?: [string, "asc" | "desc"]
@@ -378,6 +387,7 @@ export function useBuildDataSource({
             return delegate.isFilterCombinationValid(
                 {
                     path,
+                    pathSegments,
                     databaseId,
                     filterValues,
                     sortBy