@rebasepro/admin 0.0.1-canary.4f204c2

package/src/hooks/navigation/useBuildCollectionRegistryController.tsx

@@ -0,0 +1,171 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { useCallback, useRef, useState, useMemo } from "react";
+import { CollectionRegistry, getParentReferencesFromPath as commonGetParentReferencesFromPath, removeInitialAndTrailingSlashes, getSubcollections } from "@rebasepro/common";
+import { EntityReference, UserConfigurationPersistence, CollectionRegistryController } from "@rebasepro/types";
+import { mergeDeep } from "@rebasepro/utils";
+
+export function useBuildCollectionRegistryController(props: {
+    userConfigPersistence?: UserConfigurationPersistence
+}): CollectionRegistryController & {
+    collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+} {
+    const { userConfigPersistence } = props;
+    const collectionRegistryRef = useRef<CollectionRegistry>(new CollectionRegistry());
+    const [initialised, setInitialised] = useState(false);
+
+    const getCollection = useCallback((
+        slugOrPath: string,
+        includeUserOverride = false
+    ): EntityCollection | undefined => {
+
+        const registry = collectionRegistryRef.current;
+
+        const cleanedPath = removeInitialAndTrailingSlashes(slugOrPath);
+        if (!cleanedPath) return undefined;
+
+        const pathSegments = cleanedPath.split("/");
+
+        let collectionPath = pathSegments.join("/");
+        // If the path has an even number of segments, it points to an entity, so we get the parent collection
+        if (pathSegments.length > 0 && pathSegments.length % 2 === 0) {
+            collectionPath = pathSegments.slice(0, -1).join("/");
+        }
+
+        if (!collectionPath) return undefined;
+
+        let collection: EntityCollection | undefined;
+        try {
+            collection = registry.resolvePathToCollections(collectionPath).finalCollection;
+        } catch (e) {
+            console.debug(`Could not resolve path to collection: ${collectionPath}`, e);
+            return undefined;
+        }
+
+        if (!collection) {
+            return undefined;
+        }
+
+
+        const userOverride = includeUserOverride ? userConfigPersistence?.getCollectionConfig(slugOrPath) : undefined;
+        const overriddenCollection = collection ? mergeDeep(collection, userOverride ?? {}) : undefined;
+
+        if (!overriddenCollection) return undefined;
+
+        let result: Partial<EntityCollection> | undefined = overriddenCollection;
+        const subcollections = "subcollections" in overriddenCollection ? overriddenCollection.subcollections : undefined;
+        const callbacks = overriddenCollection.callbacks;
+        result = {
+            ...result,
+            callbacks: result?.callbacks ?? callbacks
+        };
+        // Preserve subcollections if they exist
+        if (subcollections && "subcollections" in result) {
+            (result as Record<string, unknown>).subcollections = (result as Record<string, unknown>).subcollections ?? subcollections;
+        }
+
+        return { ...overriddenCollection,
+...result } as EntityCollection;
+
+    }, [userConfigPersistence]);
+
+    const getRawCollection = useCallback((slugOrPath: string): EntityCollection | undefined => {
+        const registry = collectionRegistryRef.current;
+        if (registry === undefined) return undefined;
+
+        const cleanedPath = removeInitialAndTrailingSlashes(slugOrPath);
+        if (!cleanedPath) return undefined;
+
+        const pathSegments = cleanedPath.split("/");
+
+        return registry.getRaw(pathSegments.join("/")) as EntityCollection | undefined;
+    }, []);
+
+    const getParentReferencesFromPath = useCallback((path: string): EntityReference[] => {
+        const registry = collectionRegistryRef.current;
+        if (!registry) {
+            return [];
+        }
+        const cleanedPath = removeInitialAndTrailingSlashes(path);
+        const pathSegments = cleanedPath.split("/");
+
+        return commonGetParentReferencesFromPath({
+            path: pathSegments.join("/"),
+            collections: registry.getCollections()
+        });
+    }, []);
+
+    const getParentCollectionIds = useCallback((path: string): string[] => {
+        const registry = collectionRegistryRef.current;
+        if (!registry) {
+            return [];
+        }
+        const cleanedPath = removeInitialAndTrailingSlashes(path);
+        const strings = cleanedPath.split("/");
+        const oddPathSegments = strings.filter((_, i) => i % 2 === 0);
+        oddPathSegments.pop();
+
+        const result: string[][] = [];
+
+        for (let i = 1; i <= oddPathSegments.length; i++) {
+            result.push(oddPathSegments.slice(0, i));
+        }
+
+        const getCollectionFromPaths = (pathSegments: string[]): EntityCollection | undefined => {
+            if (!pathSegments?.length) return undefined;
+            const testPath = pathSegments.reduce((acc, segment, idx) => {
+                if (idx === 0) return segment;
+                return `${acc}/fake_id/${segment}`;
+            }, "");
+            try {
+                return registry.resolvePathToCollections(testPath).finalCollection;
+            } catch (e) {
+                return undefined;
+            }
+        };
+
+        return result.map(r => getCollectionFromPaths(r)?.slug).filter(Boolean) as string[];
+    }, []);
+
+    const convertIdsToPaths = useCallback((ids: string[]): string[] => {
+        const registry = collectionRegistryRef.current;
+        if (!registry) return [];
+        let currentCollections: EntityCollection[] = registry.getCollections();
+        const paths: string[] = [];
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            const collection: EntityCollection | undefined = currentCollections.find(c => c.slug === id);
+            if (!collection)
+                throw Error(`Collection with id ${id} not found`);
+            paths.push(collection.slug);
+            currentCollections = getSubcollections(collection) ?? [];
+        }
+        return paths;
+    }, []);
+
+    const collections = collectionRegistryRef.current.getCollections();
+
+    // Determine initialised automatically based on whether collections exist,
+    // though the NavigationStateController also plays a role in overall init
+    if (!initialised && collections.length > 0) {
+        setInitialised(true);
+    }
+
+    return useMemo(() => ({
+        collections,
+        initialised,
+        getCollection,
+        getRawCollection,
+        getParentReferencesFromPath,
+        getParentCollectionIds,
+        convertIdsToPaths,
+        collectionRegistryRef
+    }), [
+        collections,
+        initialised,
+        getCollection,
+        getRawCollection,
+        getParentReferencesFromPath,
+        getParentCollectionIds,
+        convertIdsToPaths
+    ]);
+}

package/src/hooks/navigation/useBuildNavigationStateController.tsx

@@ -0,0 +1,133 @@
+import type { AppView, EntityCollection, NavigationResult, RebasePlugin, NavigationStateController, UrlController, NavigationGroupMapping } from "@rebasepro/types";
+import { useCallback, useMemo } from "react";
+
+import { AuthController, RebaseData, CollectionRegistryController, User } from "@rebasepro/types";
+import type { EntityCollectionsBuilder, AppViewsBuilder, EffectiveRoleController } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+
+import { UserManagementDelegate } from "@rebasepro/types";
+
+import { useResolvedCollections } from "./useResolvedCollections";
+import { useResolvedViews } from "./useResolvedViews";
+import { useTopLevelNavigation } from "./useTopLevelNavigation";
+
+export type BuildNavigationStateProps<EC extends EntityCollection, USER extends User> = {
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    views?: AppView[] | AppViewsBuilder;
+    adminViews?: AppView[] | AppViewsBuilder;
+    data: RebaseData;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    disabled?: boolean;
+    viewsOrder?: string[];
+    collectionRegistryController: CollectionRegistryController<EC> & { collectionRegistryRef: React.MutableRefObject<CollectionRegistry> };
+    urlController: UrlController;
+    adminMode?: "content" | "studio" | "settings";
+    effectiveRoleController?: EffectiveRoleController;
+    userManagement?: UserManagementDelegate<USER>;
+};
+
+/**
+ * Main hook that resolves collections, views, and admin views into a
+ * NavigationStateController. This is a thin composition of three focused hooks:
+ *
+ * - useResolvedCollections: resolves collection props and registers with CollectionRegistry
+ * - useResolvedViews: resolves view/admin view props and injects Users/Roles views
+ * - useTopLevelNavigation: computes the NavigationResult from resolved data
+ *
+ * The NavigationStateController type is preserved as a public API.
+ */
+export function useBuildNavigationStateController<EC extends EntityCollection, USER extends User>(
+    props: BuildNavigationStateProps<EC, USER>
+): NavigationStateController {
+
+    const {
+        authController,
+        collections: collectionsProp,
+        views: viewsProp,
+        adminViews: adminViewsProp,
+        viewsOrder,
+        plugins,
+        data,
+        disabled,
+        navigationGroupMappings,
+        collectionRegistryController,
+        urlController,
+        adminMode = "content",
+        effectiveRoleController,
+        userManagement
+    } = props;
+
+    // Step 1: Resolve collections
+    const {
+        collections,
+        loading: collectionsLoading,
+        error: collectionsError,
+        refresh: refreshCollections
+    } = useResolvedCollections({
+        authController,
+        collections: collectionsProp,
+        data,
+        plugins,
+        disabled,
+        collectionRegistryController
+    });
+
+    // Step 2: Resolve views and admin views
+    const {
+        views,
+        adminViews,
+        loading: viewsLoading,
+        error: viewsError,
+        refresh: refreshViews
+    } = useResolvedViews({
+        authController,
+        views: viewsProp,
+        adminViews: adminViewsProp,
+        data,
+        plugins,
+        adminMode,
+        effectiveRoleController,
+        userManagement
+    });
+
+    // Step 3: Compute top-level navigation (pure derived state)
+    const { topLevelNavigation } = useTopLevelNavigation({
+        collections,
+        views,
+        adminViews,
+        plugins,
+        navigationGroupMappings,
+        viewsOrder,
+        urlController,
+        adminMode,
+        collectionRegistryController
+    });
+
+    // Expose a combined refresh function
+    const refreshNavigation = useCallback(() => {
+        refreshCollections();
+        refreshViews();
+    }, [refreshCollections, refreshViews]);
+
+    return useMemo(() => ({
+        views,
+        adminViews,
+        topLevelNavigation,
+        loading: collectionsLoading || viewsLoading,
+        navigationLoadingError: collectionsError ?? viewsError,
+        refreshNavigation,
+        plugins
+    }), [
+        views,
+        adminViews,
+        topLevelNavigation,
+        collectionsLoading,
+        viewsLoading,
+        collectionsError,
+        viewsError,
+        refreshNavigation,
+        plugins
+    ]);
+}

package/src/hooks/navigation/useBuildUrlController.tsx

@@ -0,0 +1,66 @@
+import type { UrlController, NavigateOptions } from "@rebasepro/types";
+import { useCallback, useMemo } from "react";
+import { removeInitialAndTrailingSlashes, resolveCollectionPathIds } from "@rebasepro/common";
+import { CollectionRegistryController } from "@rebasepro/types";
+import { useNavigate } from "react-router-dom";
+
+export function useBuildUrlController(props: {
+    basePath: string,
+    baseCollectionPath: string,
+    collectionRegistryController: CollectionRegistryController
+}): UrlController {
+
+    const { basePath, baseCollectionPath, collectionRegistryController } = props;
+    const navigate = useNavigate();
+
+    const homeUrl = basePath === "/" ? "/" : `/${removeInitialAndTrailingSlashes(basePath)}`;
+
+    const buildUrlCollectionPath = useCallback((path: string): string => {
+        const fullPath = basePath === "/" ? `${baseCollectionPath}/${path}` : `${basePath}${baseCollectionPath}/${path}`;
+        return fullPath.replace(/\/\//g, "/");
+    }, [basePath, baseCollectionPath]);
+
+    const buildAppUrlPath = useCallback((path: string): string => {
+        const fullPath = basePath === "/" ? `/${path}` : `${basePath}/${path}`;
+        return fullPath.replace(/\/\//g, "/");
+    }, [basePath]);
+
+    const urlPathToDataPath = useCallback((cmsPath: string): string => {
+        let path = cmsPath;
+        if (basePath !== "/" && path.startsWith(basePath)) {
+            path = path.replace(basePath, "");
+        }
+        if (path.startsWith(baseCollectionPath)) {
+            path = path.replace(baseCollectionPath, "");
+        }
+        return removeInitialAndTrailingSlashes(path);
+    }, [basePath, baseCollectionPath]);
+
+    const isUrlCollectionPath = useCallback((urlPath: string): boolean => {
+        let path = urlPath;
+        if (basePath !== "/" && path.startsWith(basePath)) {
+            path = path.replace(basePath, "");
+        }
+        return path === baseCollectionPath || path.startsWith(baseCollectionPath + "/");
+    }, [basePath, baseCollectionPath]);
+
+    const resolveDatabasePathsFrom = useCallback((path: string): string => {
+        return resolveCollectionPathIds(path, collectionRegistryController.collections ?? []);
+    }, [collectionRegistryController]);
+
+    const navigateTo = useCallback((to: string, options?: NavigateOptions) => {
+        navigate(to, options);
+    }, [navigate]);
+
+    return useMemo(() => ({
+        basePath,
+        baseCollectionPath,
+        urlPathToDataPath,
+        homeUrl,
+        isUrlCollectionPath,
+        buildUrlCollectionPath,
+        buildAppUrlPath,
+        resolveDatabasePathsFrom,
+        navigate: navigateTo
+    }), [basePath, baseCollectionPath, urlPathToDataPath, homeUrl, isUrlCollectionPath, buildUrlCollectionPath, buildAppUrlPath, resolveDatabasePathsFrom, navigateTo]);
+}

package/src/hooks/navigation/useNavigationRegistry.ts

@@ -0,0 +1,153 @@
+import type { EntityCollection } from "@rebasepro/types";
+import { useCallback, useRef, useMemo } from "react";
+import { CollectionRegistry, getParentReferencesFromPath, getSubcollections, removeInitialAndTrailingSlashes } from "@rebasepro/common";
+import { EntityReference, UserConfigurationPersistence } from "@rebasepro/types";
+import { mergeDeep } from "@rebasepro/utils";
+
+export function useNavigationRegistry(userConfigPersistence?: UserConfigurationPersistence) {
+    const collectionRegistryRef = useRef<CollectionRegistry>(new CollectionRegistry());
+
+    const getCollection = useCallback((
+        slugOrPath: string,
+        includeUserOverride = false
+    ): EntityCollection | undefined => {
+
+        const registry = collectionRegistryRef.current;
+
+        const cleanedPath = removeInitialAndTrailingSlashes(slugOrPath);
+        if (!cleanedPath) return undefined;
+
+        const pathSegments = cleanedPath.split("/");
+
+        let collectionPath = cleanedPath;
+        // If the path has an even number of segments, it points to an entity, so we get the parent collection
+        if (pathSegments.length > 0 && pathSegments.length % 2 === 0) {
+            collectionPath = pathSegments.slice(0, -1).join("/");
+        }
+
+        if (!collectionPath) return undefined;
+
+        let collection: EntityCollection | undefined;
+        try {
+            collection = registry.resolvePathToCollections(collectionPath).finalCollection;
+        } catch (e) {
+            console.debug(`Could not resolve path to collection: ${collectionPath}`, e);
+            return undefined;
+        }
+
+        if (!collection) {
+            return undefined;
+        }
+
+        const userOverride = includeUserOverride ? userConfigPersistence?.getCollectionConfig(slugOrPath) : undefined;
+        const overriddenCollection = collection ? mergeDeep(collection, userOverride ?? {}) : undefined;
+
+        if (!overriddenCollection) return undefined;
+
+        let result: Partial<EntityCollection> | undefined = overriddenCollection;
+        const subcollections = "subcollections" in overriddenCollection ? overriddenCollection.subcollections : undefined;
+        const callbacks = overriddenCollection.callbacks;
+        result = {
+            ...result,
+            callbacks: result?.callbacks ?? callbacks
+        };
+        if (subcollections && "subcollections" in result) {
+            (result as Record<string, unknown>).subcollections = (result as Record<string, unknown>).subcollections ?? subcollections;
+        }
+
+        return { ...overriddenCollection,
+...result } as EntityCollection;
+
+    }, [userConfigPersistence]);
+
+    const getRawCollection = useCallback((slugOrPath: string): EntityCollection | undefined => {
+        const registry = collectionRegistryRef.current;
+        if (registry === undefined) return undefined;
+
+        const cleanedPath = removeInitialAndTrailingSlashes(slugOrPath);
+        if (!cleanedPath) return undefined;
+
+        return registry.getRaw(cleanedPath) as EntityCollection | undefined;
+    }, []);
+
+    const getCollectionFromPaths = useCallback(<EC extends EntityCollection>(pathSegments: string[]): EC | undefined => {
+        const registry = collectionRegistryRef.current;
+        if (registry === undefined)
+            throw Error("getCollectionFromPaths: Collections have not been initialised yet");
+
+        if (!pathSegments?.length) {
+            return undefined;
+        }
+
+        const path = pathSegments.reduce((acc, segment, i) => {
+            if (i === 0) return segment;
+            return `${acc}/fake_id/${segment}`;
+        }, "");
+
+        try {
+            const { finalCollection } = registry.resolvePathToCollections(path);
+            return finalCollection as EC | undefined;
+        } catch (e) {
+            console.debug(`Could not resolve path segments to collection: ${pathSegments.join("/")}`, e);
+            return undefined;
+        }
+    }, []);
+
+    const getAllParentReferencesForPath = useCallback((path: string): EntityReference[] => {
+        const registry = collectionRegistryRef.current;
+        if (!registry) {
+            return [];
+        }
+        return getParentReferencesFromPath({
+            path,
+            collections: registry.getCollections()
+        });
+    }, []);
+
+    const getParentCollectionIds = useCallback((path: string): string[] => {
+        const strings = path.split("/");
+        const oddPathSegments = strings.filter((_, i) => i % 2 === 0);
+        oddPathSegments.pop();
+
+        const result: string[][] = [];
+
+        for (let i = 1; i <= oddPathSegments.length; i++) {
+            result.push(oddPathSegments.slice(0, i));
+        }
+
+        return result.map(r => getCollectionFromPaths(r)?.slug).filter(Boolean) as string[];
+    }, [getAllParentReferencesForPath, getCollectionFromPaths]);
+
+    const convertIdsToPaths = useCallback((ids: string[]): string[] => {
+        const registry = collectionRegistryRef.current;
+        if (!registry) {
+            throw new Error("convertIdsToPaths: collectionRegistryRef not initialised");
+        }
+        let currentCollections: EntityCollection[] = registry.getCollections();
+        const paths: string[] = [];
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            const collection: EntityCollection | undefined = currentCollections.find(c => c.slug === id);
+            if (!collection)
+                throw Error(`Collection with id ${id} not found`);
+            paths.push(collection.slug);
+            currentCollections = getSubcollections(collection) ?? [];
+        }
+        return paths;
+    }, []);
+
+    return useMemo(() => ({
+        collectionRegistryRef,
+        getCollection,
+        getRawCollection,
+        getParentReferencesFromPath: getAllParentReferencesForPath,
+        getParentCollectionIds,
+        convertIdsToPaths
+    }), [
+        getCollection,
+        getRawCollection,
+        getAllParentReferencesForPath,
+        getParentCollectionIds,
+        convertIdsToPaths
+    ]);
+}

package/src/hooks/navigation/useNavigationResolution.ts

@@ -0,0 +1,91 @@
+import type { AppView, AppViewsBuilder, EntityCollection, FirebaseCollection, RebasePlugin } from "@rebasepro/types";
+import { AuthController, DataDriver, User, RebaseData } from "@rebasepro/types";
+import type { EntityCollectionsBuilder } from "@rebasepro/types";
+import { canReadCollection } from "@rebasepro/common";
+
+export function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[], authController: AuthController<User>): EntityCollection[] {
+    return resolvedCollections
+        .filter((c) => canReadCollection(c, authController))
+        .map((c) => {
+            if (!("subcollections" in c) || !c.subcollections) return c;
+            return {
+                ...c,
+                subcollections: () => filterOutNotAllowedCollections((c as FirebaseCollection).subcollections?.() ?? [], authController)
+            } as FirebaseCollection;
+        });
+}
+
+export function applyPluginModifyCollection(resolvedCollections: EntityCollection[], modifyCollection: (collection: EntityCollection) => EntityCollection) {
+    return resolvedCollections.map((collection: EntityCollection): EntityCollection => {
+        const modifiedCollection = modifyCollection(collection);
+        if ("subcollections" in modifiedCollection && modifiedCollection.subcollections) {
+            return {
+                ...modifiedCollection,
+                subcollections: () => applyPluginModifyCollection((modifiedCollection as FirebaseCollection).subcollections?.() ?? [], modifyCollection)
+            } as FirebaseCollection;
+        }
+        return modifiedCollection;
+    });
+}
+
+export async function resolveCollections<U extends User, EC extends EntityCollection>(
+    collections: undefined | EC[] | EntityCollectionsBuilder<EC>,
+    authController: AuthController<U>,
+    data: RebaseData,
+    plugins: RebasePlugin[] | undefined
+): Promise<EntityCollection[]> {
+    let resolvedCollections: EntityCollection[] = [];
+    if (typeof collections === "function") {
+        resolvedCollections = await collections({
+            user: authController.user,
+            authController,
+            data
+        });
+    } else if (Array.isArray(collections)) {
+        resolvedCollections = collections;
+    }
+
+    if (plugins) {
+        for (const plugin of plugins) {
+            if (plugin.hooks?.modifyCollection) {
+                resolvedCollections = applyPluginModifyCollection(resolvedCollections, plugin.hooks.modifyCollection);
+            }
+
+            if (plugin.hooks?.injectCollections) {
+                resolvedCollections = plugin.hooks.injectCollections(resolvedCollections ?? []);
+            }
+        }
+    }
+
+    resolvedCollections = filterOutNotAllowedCollections(resolvedCollections, authController);
+    return resolvedCollections;
+}
+
+export async function resolveAppViews<U extends User>(
+    baseViews: AppView[] | AppViewsBuilder | undefined,
+    authController: AuthController<U>,
+    data: RebaseData,
+    plugins?: RebasePlugin[]
+) {
+    let resolvedViews: AppView[] = [];
+    if (typeof baseViews === "function") {
+        resolvedViews = await baseViews({
+            user: authController.user,
+            authController,
+            data
+        }) ?? [];
+    } else if (Array.isArray(baseViews)) {
+        resolvedViews = baseViews;
+    }
+
+    // Inject views from plugins
+    if (plugins) {
+        for (const plugin of plugins) {
+            if (plugin.views && plugin.views.length > 0) {
+                resolvedViews = [...resolvedViews, ...plugin.views];
+            }
+        }
+    }
+
+    return resolvedViews;
+}

package/src/hooks/navigation/useNavigationURLs.ts

@@ -0,0 +1,56 @@
+import { useCallback, useMemo } from "react";
+import { removeInitialAndTrailingSlashes, resolveCollectionPathIds } from "@rebasepro/common";
+import { CollectionRegistry } from "@rebasepro/common";
+
+export function encodePath(input: string) {
+    return encodeURIComponent(removeInitialAndTrailingSlashes(input))
+        .replaceAll("%2F", "/")
+        .replaceAll("%23", "#");
+}
+
+export function useNavigationURLs(basePath: string, baseCollectionPath: string, collectionRegistryRef: React.MutableRefObject<CollectionRegistry>) {
+
+    const cleanBasePath = removeInitialAndTrailingSlashes(basePath);
+    const cleanBaseCollectionPath = removeInitialAndTrailingSlashes(baseCollectionPath);
+
+    const homeUrl = cleanBasePath ? `/${cleanBasePath}` : "/";
+    const fullCollectionPath = cleanBasePath ? `/${cleanBasePath}/${cleanBaseCollectionPath}` : `/${cleanBaseCollectionPath}`;
+
+    const buildAppUrlPath = useCallback((path: string): string => {
+        // Strip trailing /* wildcard from paths (used for nested routes in React Router)
+        const cleanPath = path.replace(/\/\*$/, "");
+        return cleanBasePath ? `/${cleanBasePath}/${encodePath(cleanPath)}` : `/${encodePath(cleanPath)}`;
+    }, [cleanBasePath]);
+
+    const buildUrlCollectionPath = useCallback((path: string): string => `${removeInitialAndTrailingSlashes(baseCollectionPath)}/${encodePath(path)}`,
+        [baseCollectionPath]);
+
+    const isUrlCollectionPath = useCallback(
+        (path: string): boolean => removeInitialAndTrailingSlashes(path + "/").startsWith(removeInitialAndTrailingSlashes(fullCollectionPath) + "/"),
+        [fullCollectionPath]);
+
+    const urlPathToDataPath = useCallback((path: string): string => {
+        const decodedPath = decodeURIComponent(path);
+        if (decodedPath.startsWith(fullCollectionPath))
+            return decodedPath.replace(fullCollectionPath, "");
+        throw Error("Expected path starting with " + fullCollectionPath);
+    }, [fullCollectionPath]);
+
+    const resolveDatabasePathsFrom = useCallback((path: string): string => {
+        const registry = collectionRegistryRef.current;
+        if (!registry) {
+            return resolveCollectionPathIds(path, []);
+        }
+        return resolveCollectionPathIds(path, registry.getCollections());
+    }, [collectionRegistryRef]);
+
+    return useMemo(() => ({
+        homeUrl,
+        fullCollectionPath,
+        buildAppUrlPath,
+        buildUrlCollectionPath,
+        isUrlCollectionPath,
+        urlPathToDataPath,
+        resolveDatabasePathsFrom
+    }), [homeUrl, fullCollectionPath, buildAppUrlPath, buildUrlCollectionPath, isUrlCollectionPath, urlPathToDataPath, resolveDatabasePathsFrom]);
+}