@firecms/core 3.4.0-canary.8635253 → 3.4.0-canary.ce97da7

package/src/core/index.tsx

@@ -1,4 +1,5 @@
 export * from "./FireCMS";
+export * from "./pro_plugins";
 
 export * from "./DefaultDrawer";
 export * from "./DrawerNavigationItem";

package/src/core/plugin_translations.ts

@@ -0,0 +1,87 @@
+import type { i18n } from "i18next";
+import { FireCMSPlugin, PluginTranslations } from "../types";
+
+const FIRECMS_NS = "firecms_core";
+
+/**
+ * Record of which bundles have already been written to which locale, so the
+ * same one is never written twice.
+ *
+ * Plugin translation objects are module-level constants and a lazily loaded one
+ * resolves to the same module object every time, so identity is a sound test.
+ */
+export type AppliedBundles = Map<string, Set<object>>;
+
+export function createAppliedBundles(): AppliedBundles {
+    return new Map();
+}
+
+/**
+ * Write the plugins' strings for one language into a live i18next instance.
+ *
+ * Only the language in use is resolved, plus English, which every other language
+ * falls back to — a locale given as a function is a bundle that has not been
+ * downloaded yet, and downloading all of them would undo the point of deferring
+ * them. Plain records are applied for every locale, as before: they are already
+ * in the bundle, so there is nothing to save by holding them back.
+ *
+ * `applied` is what stops the injection feeding itself. A write raises a store
+ * event; the event repaints everything subscribed to this instance, including
+ * the component that owns the `plugins` array — the collection editor and SaaS
+ * plugin hooks both call `useTranslation` — and that array is an inline literal,
+ * so its fresh identity re-runs the effect that called this. react-i18next
+ * happens to stop re-rendering after one pass, but that is a bail-out rather
+ * than a guarantee, and the redundant writes are worth avoiding regardless.
+ *
+ * Returns a function that reports whether the caller is still mounted, so a
+ * bundle that arrives after unmount is dropped rather than written.
+ */
+export function applyPluginTranslations({
+    i18n,
+    plugins,
+    language,
+    applied,
+    isActive = () => true
+}: {
+    i18n: i18n;
+    plugins?: FireCMSPlugin<any, any, any>[];
+    language: string;
+    applied: AppliedBundles;
+    isActive?: () => boolean;
+}) {
+    const wanted = new Set([language.split("-")[0], "en"]);
+
+    const add = (locale: string, bundle: PluginTranslations) => {
+        if (!isActive()) return;
+        let written = applied.get(locale);
+        if (!written) {
+            written = new Set();
+            applied.set(locale, written);
+        }
+        if (written.has(bundle)) return;
+        written.add(bundle);
+        i18n.addResourceBundle(
+            locale,
+            FIRECMS_NS,
+            bundle,
+            true,  // deep merge
+            true   // overwrite
+        );
+    };
+
+    plugins?.forEach((plugin) => {
+        if (!plugin.i18n) return;
+        Object.entries(plugin.i18n).forEach(([locale, translations]) => {
+            if (typeof translations === "function") {
+                if (!wanted.has(locale.split("-")[0])) return;
+                translations()
+                    .then((bundle) => add(locale, bundle))
+                    .catch(() => {
+                        // A locale that fails to load falls back to English.
+                    });
+            } else {
+                add(locale, translations);
+            }
+        });
+    });
+}

package/src/core/pro_plugins.ts

@@ -0,0 +1,79 @@
+import { AccessResponse, FireCMSPlugin } from "../types";
+
+/**
+ * Keys of the plugins that need a FireCMS PRO license.
+ *
+ * Kept in sync by hand with `PRO_PLUGIN_KEYS` in
+ * `saas_backend/functions/src/business_rules/licenses.ts`, which decides from
+ * the same list whether a project needs a license. Change both together.
+ *
+ * @group Core
+ */
+export const PRO_PLUGIN_KEYS: readonly string[] = [
+    "collection_editor",
+    "user_management",
+    "import_export",
+    "import",
+    "export",
+    "entity_history",
+    "data_enhancement",
+    "datatalk"
+];
+
+/**
+ * PRO plugins that stay mounted while PRO is paused. `user_management` supplies
+ * sign-in checks and roles, so removing it would lock users out of the CMS
+ * instead of pausing a feature; its own Users and Roles views show a notice.
+ */
+const KEPT_WHILE_PAUSED: readonly string[] = ["user_management"];
+
+/**
+ * Whether PRO features are paused for this license status. Any `blocked`
+ * response pauses them, whatever its `licenseState` (`expired` and
+ * `invalid_project` both come with it). An unknown status pauses nothing.
+ *
+ * @group Core
+ */
+export function isProPaused(licenseStatus?: AccessResponse | null): boolean {
+    return Boolean(licenseStatus?.blocked);
+}
+
+/**
+ * Whether this plugin is dropped while PRO is paused.
+ *
+ * @group Core
+ */
+export function isPausedPlugin(plugin: Pick<FireCMSPlugin, "key">): boolean {
+    return PRO_PLUGIN_KEYS.includes(plugin.key) && !KEPT_WHILE_PAUSED.includes(plugin.key);
+}
+
+/**
+ * Where to get or fix the license for this status: the server's
+ * `subscribeUrl` when it is an https URL, otherwise the license page on
+ * app.firecms.co with the project, when known.
+ *
+ * @group Core
+ */
+export function getLicenseSubscribeUrl(licenseStatus?: AccessResponse | null): string {
+    const subscribeUrl = licenseStatus?.subscribeUrl;
+    if (subscribeUrl && /^https:\/\//i.test(subscribeUrl))
+        return subscribeUrl;
+    const params = new URLSearchParams({ intent: "pro" });
+    if (licenseStatus?.projectId) params.set("projectId", licenseStatus.projectId);
+    return `https://app.firecms.co/subscriptions?${params.toString()}`;
+}
+
+/**
+ * The plugins that stay active under this license status. Returns the same
+ * array when nothing is dropped, so it can feed memo and effect dependencies.
+ *
+ * @group Core
+ */
+export function filterPausedPlugins<P extends Pick<FireCMSPlugin, "key">>(
+    plugins: P[] | undefined,
+    licenseStatus?: AccessResponse | null
+): P[] | undefined {
+    if (!plugins || !isProPaused(licenseStatus)) return plugins;
+    const active = plugins.filter(plugin => !isPausedPlugin(plugin));
+    return active.length === plugins.length ? plugins : active;
+}

package/src/editor/components/SlashCommandMenu.tsx

@@ -198,11 +198,14 @@ const autocompleteSuggestionItem: SuggestionItem = {
         let buffer = "";
         const result = await aiController.autocomplete(textBeforeCursor, textAfterCursor, (delta) => {
             buffer += delta;
-            if (delta.length !== 0) {
+            if (delta.length !== 0 && !view.isDestroyed) {
                 textLoadingCommands.toggleLoadingDecoration(view.state, view.dispatch, buffer);
             }
         });
 
+        // The editor may have been unmounted while the completion streamed in.
+        if (view.isDestroyed) return;
+
         // Insert parsed text result at cursor natively
         try {
             // The AI controller might stream literal "\n" characters depending on its JSON decoding layer.

package/src/editor/extensions/Image.ts

@@ -4,9 +4,20 @@ import { Plugin, PluginKey } from "prosemirror-state";
 
 export type UploadFn = (image: File) => Promise<string>;
 
+/**
+ * Shows the image as a placeholder at `pos`, uploads it, and swaps the
+ * placeholder for the uploaded image once it has loaded.
+ *
+ * Every step after the first runs asynchronously — the FileReader callback that
+ * calls this, the upload, and the preload of the uploaded image — and the editor
+ * can be unmounted during any of them (the user closes the entity or navigates
+ * away while an image is still uploading). Dispatching on a destroyed
+ * `EditorView` throws inside ProseMirror (`docView` is null), so each step
+ * checks the view is still alive before touching it.
+ */
 export async function onFileRead(view: EditorView, readerEvent: ProgressEvent<FileReader>, pos: number, upload: UploadFn, image: File) {
 
-    const { schema } = view.state;
+    if (view.isDestroyed) return;
 
     // @ts-ignore
     const plugin = view.state.plugins.find((p: Plugin) => p.key === ImagePluginKey.key);
@@ -31,7 +42,12 @@ export async function onFileRead(view: EditorView, readerEvent: ProgressEvent<Fi
     const src = await upload(image);
     console.debug("Uploaded image", src);
 
+    // The upload is kept (the caller stored the file), but there is no longer
+    // an editor to put it in.
+    if (view.isDestroyed) return;
+
     const replacePlaceholder = () => {
+        if (view.isDestroyed) return;
         // Retrieve the LATEST state after the async upload
         let currentDecos = plugin.getState(view.state) as DecorationSet;
         const foundDecos = currentDecos.find(undefined, undefined, spec => spec.id === decoId);

package/src/editor/hooks/useProseMirror.ts

@@ -58,6 +58,11 @@ export function useProseMirror({ initialContent, editable = true, handleImageUpl
             state: defaultState,
             editable: () => editable,
             dispatchTransaction: (tr: Transaction) => {
+                // Async work (image uploads and their preload, AI autocomplete
+                // streams) can finish after the editor unmounted. Applying a
+                // transaction to a destroyed view throws inside ProseMirror
+                // (`docView` is null), so drop it: there is nothing to update.
+                if (editorView.isDestroyed) return;
                 const newState = editorView.state.apply(tr);
                 editorView.updateState(newState);
                 setState(newState);

package/src/editor/index.ts

@@ -1,2 +1,12 @@
-export * from "./editor";
+// The editor's runtime entry point is the lazy wrapper, not the implementation:
+// a static re-export here would pull ProseMirror into every consumer of
+// `@firecms/core`. The types come straight from the implementation and are
+// erased at build time, so they cost nothing.
+export { FireCMSEditor } from "./lazy_editor";
+export type {
+    CustomEditorComponent,
+    MarkdownEditorConfig,
+    FireCMSEditorTextSize,
+    FireCMSEditorProps
+} from "./editor";
 export * from "./types";

package/src/editor/lazy_editor.tsx

@@ -0,0 +1,33 @@
+"use client";
+
+import React from "react";
+
+import { CircularProgressCenter } from "../components/CircularProgressCenter";
+import type { FireCMSEditorProps } from "./editor";
+
+/**
+ * `FireCMSEditor`, loaded on demand.
+ *
+ * The editor is built on ProseMirror — roughly 250KB across a dozen packages —
+ * and is only reachable from a markdown field, which most views never render.
+ * `MarkdownEditorFieldBinding` already loaded it lazily, but that split was
+ * defeated by `src/index.ts` re-exporting the editor from the package barrel:
+ * a static re-export puts the module back in the entry graph regardless of who
+ * imports it dynamically. So ProseMirror sat in `@firecms/core` for everyone.
+ *
+ * The name and props are unchanged, and this component carries its own Suspense
+ * boundary, so it stays a drop-in for the synchronous component it replaces —
+ * a consumer rendering it without a boundary of their own still works.
+ */
+const LazyFireCMSEditor = React.lazy(() =>
+    import("./editor").then((module) => ({ default: module.FireCMSEditor })));
+
+export function FireCMSEditor(props: FireCMSEditorProps) {
+    return (
+        <React.Suspense fallback={<CircularProgressCenter/>}>
+            <LazyFireCMSEditor {...props}/>
+        </React.Suspense>
+    );
+}
+
+FireCMSEditor.displayName = "FireCMSEditor";

package/src/form/EntityForm.tsx

@@ -48,6 +48,7 @@ import { useAnalyticsController } from "../hooks/useAnalyticsController";
 import { FormEntry, FormLayout, LabelWithIconAndTooltip, PropertyFieldBinding } from "../form";
 import { ValidationError } from "yup";
 import {
+    entityCacheKey,
     flattenKeys,
     getEntityFromCache,
     removeEntityFromCache,
@@ -64,6 +65,8 @@ export type OnUpdateParams = {
     entity: Entity<any>,
     status: EntityStatus,
     path: string,
+    /** `path` split at its real segment boundaries, when known. Never derived from `path`. */
+    pathSegments?: string[],
     entityId?: string;
     selectedTab?: string;
     collection: EntityCollection<any>
@@ -71,6 +74,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 +222,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,
@@ -270,6 +279,7 @@ export function EntityForm<M extends Record<string, any>>({
                 entityId: entityIdProp,
                 collection,
                 path,
+                pathSegments,
                 values: valuesToBeSaved
             });
     }, false, 2000);
@@ -292,7 +302,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;
@@ -308,7 +318,7 @@ export function EntityForm<M extends Record<string, any>>({
     const baseInitialValues = useMemo(() => getInitialEntityValues(authController, collection, path, status, entity, customizationController.propertyConfigs), [authController, collection, path, status, entity, customizationController.propertyConfigs]);
 
     const localChangesDataRaw = useMemo(() => entityId
-        ? getEntityFromCache(path + "/" + entityId)
+        ? getEntityFromCache(entityCacheKey(path, entityId))
         : getEntityFromCache(path + "#new"), [entityId, path]);
 
     const [localChangesCleared, setLocalChangesCleared] = useState<boolean>(false);
@@ -387,8 +397,8 @@ export function EntityForm<M extends Record<string, any>>({
             onValuesModified?.(false, initialValues as M);
         },
         onValuesChangeDeferred: (values: M, controller: FormexController<M>) => {
-            const key = (status === "new" || status === "copy") ? path + "#new" : path + "/" + entityId;
-            if (controller.dirty) {
+            const key = (status === "new" || status === "copy") ? path + "#new" : entityCacheKey(path, entityId);
+            if (controller.dirty && localChangesBackup !== false) {
                 const touchedValues = removeEmptyContainers(extractTouchedValues(values, controller.touched));
                 if (touchedValues && Object.keys(touchedValues).length > 0) {
                     saveEntityToCache(key, touchedValues);
@@ -468,8 +478,8 @@ export function EntityForm<M extends Record<string, any>>({
             removeEntityFromMemoryCache(path + "#new");
             removeEntityFromCache(path + "#new");
         } else {
-            removeEntityFromMemoryCache(path + "/" + entityId);
-            removeEntityFromCache(path + "/" + entityId);
+            removeEntityFromMemoryCache(entityCacheKey(path, entityId));
+            removeEntityFromCache(entityCacheKey(path, entityId));
         }
     }
 
@@ -491,6 +501,7 @@ export function EntityForm<M extends Record<string, any>>({
                 entity: updatedEntity,
                 status,
                 path,
+                pathSegments,
                 entityId: updatedEntity.id,
                 collection
             });
@@ -511,16 +522,20 @@ export function EntityForm<M extends Record<string, any>>({
         previousValues,
         entityId,
         collection,
-        path
+        path,
+        pathSegments
     }: {
         collection: EntityCollection<M>,
         path: string,
+        /** `path` split at its real segment boundaries, travelling with the `path` above. */
+        pathSegments?: string[],
         entityId: string | undefined,
         values: M,
         previousValues?: M,
     }) => {
         return saveEntityWithCallbacks({
             path,
+            pathSegments,
             entityId,
             values,
             previousValues,
@@ -538,6 +553,7 @@ export function EntityForm<M extends Record<string, any>>({
     type EntityFormSaveParams<M extends Record<string, any>> = {
         collection: ResolvedEntityCollection<M>,
         path: string,
+        pathSegments?: string[],
         entityId: string | undefined,
         values: EntityValues<M>,
         previousValues?: EntityValues<M>,
@@ -547,6 +563,7 @@ export function EntityForm<M extends Record<string, any>>({
     const onSaveEntityRequest = async ({
         collection,
         path,
+        pathSegments,
         entityId,
         values,
         previousValues,
@@ -560,6 +577,7 @@ export function EntityForm<M extends Record<string, any>>({
             return saveEntity({
                 collection,
                 path,
+                pathSegments,
                 entityId,
                 values,
                 previousValues
@@ -573,6 +591,7 @@ export function EntityForm<M extends Record<string, any>>({
         return onSaveEntityRequest({
             collection: resolvedCollection,
             path,
+            pathSegments,
             entityId,
             values,
             previousValues: entity?.values,
@@ -623,13 +642,14 @@ export function EntityForm<M extends Record<string, any>>({
     const plugins = customizationController.plugins;
 
     const actionsDisabled = disabled || formex.isSubmitting || (status === "existing" && !formex.dirty) || Boolean(disabledProp);
-    const parentCollectionIds = navigationController.getParentCollectionIds(path);
+    const parentCollectionIds = navigationController.getParentCollectionIds(path, pathSegments);
 
     if (plugins && collection) {
         const actionProps: PluginFormActionProps = {
             entityId,
             parentCollectionIds,
             path,
+            pathSegments,
             status,
             collection,
             context,
@@ -692,7 +712,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
@@ -890,6 +910,7 @@ export function EntityForm<M extends Record<string, any>>({
     const dialogActions = <EntityFormActionsComponent
         collection={resolvedCollection}
         path={path}
+        pathSegments={pathSegments}
         fullPath={path}
         fullIdPath={fullIdPath}
         entity={entity}
@@ -924,7 +945,7 @@ export function EntityForm<M extends Record<string, any>>({
 
                             {manualApplyLocalChanges && hasLocalChanges &&
                                 <LocalChangesMenu
-                                    cacheKey={status === "new" || status === "copy" ? path + "#new" : path + "/" + entityId}
+                                    cacheKey={status === "new" || status === "copy" ? path + "#new" : entityCacheKey(path, entityId)}
                                     properties={resolvedCollection.properties}
                                     cachedData={localChangesDataRaw as Partial<M>}
                                     formex={formex}

package/src/form/EntityFormActions.tsx

@@ -26,6 +26,8 @@ export interface EntityFormActionsProps {
     fullIdPath?: string;
     collection: ResolvedEntityCollection;
     path: string;
+    /** `path` split at its real segment boundaries, when known. Never derived from `path`. */
+    pathSegments?: string[];
     entity?: Entity;
     layout: "bottom" | "side";
     savingError?: Error;

package/src/hooks/data/delete.ts

@@ -46,6 +46,7 @@ export type DeleteEntityWithCallbacksProps<M extends Record<string, any>, USER e
 export async function deleteEntityWithCallbacks<M extends Record<string, any>, USER extends User>({
                                                                                                           dataSource,
                                                                                                           entity,
+                                                                                                          pathSegments,
                                                                                                           collection,
                                                                                                           callbacks,
                                                                                                           onDeleteSuccess,
@@ -62,11 +63,17 @@ export async function deleteEntityWithCallbacks<M extends Record<string, any>, U
 
     console.debug("Deleting entity", entity.path, entity.id);
 
+    // An explicit `pathSegments` wins, then the ones the entity was loaded with. The prop
+    // used to be accepted and silently ignored, which is the same class of bug this field
+    // exists to prevent.
+    const resolvedPathSegments = pathSegments ?? entity.pathSegments;
+
     const entityDeleteProps: EntityOnDeleteProps<M, any> = {
         entity,
         collection,
         entityId: entity.id,
         path: entity.path,
+        pathSegments: resolvedPathSegments,
         context
     };
 
@@ -81,6 +88,7 @@ export async function deleteEntityWithCallbacks<M extends Record<string, any>, U
         }
     }
     return dataSource.deleteEntity({
+        pathSegments: resolvedPathSegments,
         entity,
         collection
     }).then(() => {

package/src/hooks/data/save.ts

@@ -43,6 +43,7 @@ export type SaveEntityWithCallbacksProps<M extends Record<string, any>> =
 export async function saveEntityWithCallbacks<M extends Record<string, any>, USER extends User>({
                                                                                                     collection,
                                                                                                     path,
+                                                                                                    pathSegments,
                                                                                                     entityId,
                                                                                                     values,
                                                                                                     previousValues,
@@ -67,7 +68,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, USE
 
     const customizationController = context.customizationController;
 
-    const resolvedPath = context.navigation.resolveIdsFrom(path);
+    const resolvedPath = context.navigation.resolveIdsFrom(path, pathSegments);
 
     const callbacks = collection.callbacks;
     if (callbacks?.onPreSave) {
@@ -83,6 +84,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, USE
             updatedValues = await callbacks.onPreSave({
                 collection: resolvedCollection,
                 path,
+                pathSegments,
                 resolvedPath,
                 entityId,
                 values,
@@ -103,6 +105,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, USE
     return dataSource.saveEntity({
         collection,
         path: resolvedPath,
+        pathSegments,
         entityId,
         values: updatedValues,
         previousValues,
@@ -121,6 +124,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, USE
                 callbacks.onSaveSuccess({
                     collection: resolvedCollection,
                     path,
+                    pathSegments,
                     resolvedPath,
                     entityId: entity.id,
                     values: updatedValues,
@@ -150,6 +154,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, USE
                 callbacks.onSaveFailure({
                     collection: resolvedCollection,
                     path,
+                    pathSegments,
                     resolvedPath,
                     entityId,
                     values: updatedValues,

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: inputPathSegments,
         collection,
         filterValues,
         sortBy,
@@ -73,7 +80,13 @@ export function useCollectionFetch<M extends Record<string, any>, USER extends U
     const dataSource = useDataSource(collection);
     const navigationController = useNavigationController();
 
-    const path = navigationController.resolveIdsFrom(inputPath);
+    // Resolved together so the two representations always describe the same chain.
+    // Segments are resolved, never derived: only collection ids are swapped for their
+    // real paths, and entity ids are carried through whole (see useEntityFetch).
+    const pathSegments = inputPathSegments
+        ? (navigationController.resolveSegmentsFrom?.(inputPathSegments) ?? inputPathSegments)
+        : undefined;
+    const path = navigationController.resolveIdsFrom(inputPath, inputPathSegments);
 
     const sortByProperty = sortBy ? sortBy[0] : undefined;
     const currentSort = sortBy ? sortBy[1] : undefined;
@@ -91,6 +104,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(
@@ -98,6 +115,7 @@ export function useCollectionFetch<M extends Record<string, any>, USER extends U
                             collection.callbacks!.onFetch!({
                                 collection,
                                 path,
+                                pathSegments,
                                 entity,
                                 context
                             })));
@@ -124,6 +142,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 +156,7 @@ export function useCollectionFetch<M extends Record<string, any>, USER extends U
         } else {
             dataSource.fetchCollection<M>({
                 path,
+                pathSegments,
                 collection,
                 searchString,
                 filter: filterValues,