@firecms/core 3.0.0-canary.5 → 3.0.0-canary.51

package/src/hooks/data/delete.ts

@@ -12,10 +12,10 @@ import {
 /**
  * @group Hooks and utilities
  */
-export type DeleteEntityWithCallbacksProps<M extends Record<string, any>> =
+export type DeleteEntityWithCallbacksProps<M extends Record<string, any>, UserType extends User = User> =
     DeleteEntityProps<M>
     & {
-    callbacks?: EntityCallbacks<M>;
+    callbacks?: EntityCallbacks<M, UserType>;
     onDeleteSuccess?: (entity: Entity<M>) => void;
     onDeleteFailure?: (entity: Entity<M>, e: Error) => void;
     onPreDeleteHookError?: (entity: Entity<M>, e: Error) => void;
@@ -62,7 +62,7 @@ export async function deleteEntityWithCallbacks<M extends Record<string, any>, U
 
     console.debug("Deleting entity", entity.path, entity.id);
 
-    const entityDeleteProps: EntityOnDeleteProps<M, UserType> = {
+    const entityDeleteProps: EntityOnDeleteProps<M, any> = {
         entity,
         collection,
         entityId: entity.id,

package/src/hooks/data/save.ts

@@ -17,7 +17,6 @@ import { resolveCollection } from "../../util";
 export type SaveEntityWithCallbacksProps<M extends Record<string, any>> =
     SaveEntityProps<M> &
     {
-        callbacks?: EntityCallbacks<M>;
         onSaveSuccess?: (updatedEntity: Entity<M>) => void,
         onSaveFailure?: (e: Error) => void,
         onPreSaveHookError?: (e: Error) => void,
@@ -64,7 +63,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, Use
                                                                                                         onPreSaveHookError,
                                                                                                         onSaveSuccessHookError
                                                                                                     }: SaveEntityWithCallbacksProps<M> & {
-                                                                                                        collection: EntityCollection<M>,
+                                                                                                        collection: EntityCollection<M, UserType>,
                                                                                                         dataSource: DataSource,
                                                                                                         context: FireCMSContext<UserType>,
                                                                                                     }
@@ -145,6 +144,7 @@ export async function saveEntityWithCallbacks<M extends Record<string, any>, Use
             onSaveSuccess(entity);
     })
         .catch((e) => {
+            console.error("!!!", e);
             if (callbacks?.onSaveFailure) {
 
                 const resolvedCollection = resolveCollection<M>({

package/src/hooks/data/useCollectionFetch.tsx

@@ -70,7 +70,7 @@ export function useCollectionFetch<M extends Record<string, any>, UserType exten
         searchString
     }: CollectionFetchProps<M>): CollectionFetchResult<M> {
 
-    const dataSource = useDataSource();
+    const dataSource = useDataSource(collection);
     const navigationController = useNavigationController();
 
     const path = navigationController.resolveAliasesFrom(inputPath);

package/src/hooks/data/useDataSource.tsx

@@ -1,9 +1,14 @@
-import { useContext } from "react";
-import { DataSource } from "../../types";
+import { useContext, useMemo } from "react";
+import { DataSource, EntityCollection } from "../../types";
 import { DataSourceContext } from "../../contexts/DataSourceContext";
 
 /**
  * Use this hook to get the datasource being used
  * @group Hooks and utilities
  */
-export const useDataSource = (): DataSource => useContext(DataSourceContext);
+export const useDataSource = (collection?: EntityCollection<any, any>): DataSource => {
+    const defaultDataSource = useContext(DataSourceContext);
+    if (collection?.overrides?.dataSource)
+        return collection?.overrides.dataSource;
+    return defaultDataSource;
+};

package/src/hooks/data/useEntityFetch.tsx

@@ -7,10 +7,10 @@ import { useFireCMSContext } from "../useFireCMSContext";
 /**
  * @group Hooks and utilities
  */
-export interface EntityFetchProps<M extends Record<string, any>> {
+export interface EntityFetchProps<M extends Record<string, any>, UserType extends User = User> {
     path: string;
     entityId?: string;
-    collection: EntityCollection<M>;
+    collection: EntityCollection<M, UserType>;
     useCache?: boolean;
 }
 
@@ -41,9 +41,9 @@ export function useEntityFetch<M extends Record<string, any>, UserType extends U
         entityId,
         collection,
         useCache = false
-    }: EntityFetchProps<M>): EntityFetchResult<M> {
+    }: EntityFetchProps<M, UserType>): EntityFetchResult<M> {
 
-    const dataSource = useDataSource();
+    const dataSource = useDataSource(collection);
     const navigationController = useNavigationController();
 
     const path = navigationController.resolveAliasesFrom(inputPath);

package/src/hooks/index.tsx

@@ -10,6 +10,7 @@ export * from "./useResolvedNavigationFrom";
 
 export * from "./useStorageSource";
 export * from "./useAuthController";
+export * from "./useDialogsController";
 export * from "./useSideDialogsController";
 export * from "./useSideEntityController";
 export * from "./useFireCMSContext";
@@ -25,3 +26,5 @@ export * from "./useBuildNavigationController";
 
 export * from "./useBuildLocalConfigurationPersistence";
 export * from "./useBuildModeController";
+
+export * from "./useValidateAuthenticator";

package/src/hooks/useBuildLocalConfigurationPersistence.tsx

@@ -1,10 +1,10 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { PartialEntityCollection, UserConfigurationPersistence } from "../types";
 import { mergeDeep, stripCollectionPath } from "../util";
 
 export function useBuildLocalConfigurationPersistence(): UserConfigurationPersistence {
 
-    const [configCache, setConfigCache] = useState<Record<string, PartialEntityCollection>>({});
+    const configCache = useRef<Record<string, PartialEntityCollection>>({});
 
     const getCollectionFromStorage = useCallback((storageKey: string) => {
         const item = localStorage.getItem(storageKey);
@@ -13,20 +13,19 @@ export function useBuildLocalConfigurationPersistence(): UserConfigurationPersis
 
     const getCollectionConfig = useCallback(<M extends Record<string, any>>(path: string): PartialEntityCollection<M> => {
         const storageKey = `collection_config::${stripCollectionPath(path)}`;
-        if (configCache[storageKey]) {
-            return configCache[storageKey] as PartialEntityCollection<M>;
+        if (configCache.current[storageKey]) {
+            return configCache.current[storageKey] as PartialEntityCollection<M>;
         }
         return getCollectionFromStorage(storageKey);
-    }, [configCache, getCollectionFromStorage]);
+    }, [getCollectionFromStorage]);
 
     const onCollectionModified = useCallback(<M extends Record<string, any>>(path: string, data: PartialEntityCollection<M>) => {
         const storageKey = `collection_config::${stripCollectionPath(path)}`;
         localStorage.setItem(storageKey, JSON.stringify(data));
-        setConfigCache((currentCache) => {
-            const cachedConfig = currentCache[storageKey];
-            const newConfig = mergeDeep(cachedConfig ?? getCollectionFromStorage(path), data);
-            return (mergeDeep(currentCache, newConfig));
-        });
+        const currentCache = configCache.current;
+        const cachedConfig = currentCache[storageKey];
+        const newConfig = mergeDeep(cachedConfig ?? getCollectionFromStorage(path), data);
+        configCache.current = mergeDeep(currentCache, newConfig);
     }, [getCollectionFromStorage]);
 
     const [recentlyVisitedPaths, _setRecentlyVisitedPaths] = useState<string[]>([]);

package/src/hooks/useBuildModeController.tsx

@@ -8,8 +8,13 @@ import { ModeController } from "./index";
  */
 export function useBuildModeController(): ModeController {
 
-    const prefersDarkModeQuery = typeof window !== "undefined" &&
-        window.matchMedia("(prefers-color-scheme: dark)");
+    const prefersDarkModeQuery = useCallback((): boolean => {
+        if (typeof window === "undefined")
+            return false;
+        const mediaQueryList = window.matchMedia("(prefers-color-scheme: dark)");
+        return mediaQueryList.matches;
+    }, []);
+
     const prefersDarkModeStorage: boolean | null = localStorage.getItem("prefers-dark-mode") != null ? localStorage.getItem("prefers-dark-mode") === "true" : null;
     const prefersDarkMode = prefersDarkModeStorage ?? prefersDarkModeQuery;
     const [mode, setMode] = useState<"light" | "dark">(prefersDarkMode ? "dark" : "light");
@@ -23,7 +28,7 @@ export function useBuildModeController(): ModeController {
     const setDarkMode = useCallback(() => {
         setMode("dark");
         setDocumentMode("dark");
-    }, [prefersDarkModeQuery]);
+    }, []);
 
     const setLightMode = useCallback(() => {
         setMode("light");
@@ -37,14 +42,15 @@ export function useBuildModeController(): ModeController {
 
     const toggleMode = useCallback(() => {
 
+        const prefersDarkModeQueryResult = prefersDarkModeQuery();
         if (mode === "light") {
-            if (!prefersDarkModeQuery)
+            if (!prefersDarkModeQueryResult)
                 localStorage.setItem("prefers-dark-mode", "true");
             else
                 localStorage.removeItem("prefers-dark-mode");
             setDarkMode();
         } else {
-            if (prefersDarkModeQuery)
+            if (prefersDarkModeQueryResult)
                 localStorage.setItem("prefers-dark-mode", "false");
             else
                 localStorage.removeItem("prefers-dark-mode");

package/src/hooks/useBuildNavigationController.tsx

@@ -1,5 +1,4 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { useLocation } from "react-router-dom";
 import equal from "react-fast-compare"
 
 import {
@@ -11,12 +10,14 @@ import {
     EntityCollectionsBuilder,
     EntityReference,
     NavigationController,
+    PermissionsBuilder,
     TopNavigationEntry,
     TopNavigationResult,
     User,
     UserConfigurationPersistence
 } from "../types";
 import {
+    applyPermissionsFunctionIfEmpty,
     getCollectionByPathOrId,
     mergeDeep,
     removeInitialAndTrailingSlashes,
@@ -28,12 +29,15 @@ import { getParentReferencesFromPath } from "../util/parent_references_from_path
 const DEFAULT_BASE_PATH = "/";
 const DEFAULT_COLLECTION_PATH = "/c";
 
-type BuildNavigationContextProps<EC extends EntityCollection, UserType extends User> = {
+export type BuildNavigationContextProps<EC extends EntityCollection, UserType extends User> = {
     basePath?: string,
     baseCollectionPath?: string,
     authController: AuthController<UserType>;
     collections?: EC[] | EntityCollectionsBuilder<EC>;
+    collectionPermissions?: PermissionsBuilder;
     views?: CMSView[] | CMSViewsBuilder;
+    adminViews?: CMSView[] | CMSViewsBuilder;
+    viewsOrder?: string[];
     userConfigPersistence?: UserConfigurationPersistence;
     dataSourceDelegate: DataSourceDelegate;
     /**
@@ -46,22 +50,25 @@ type BuildNavigationContextProps<EC extends EntityCollection, UserType extends U
     injectCollections?: (collections: EntityCollection[]) => EntityCollection[];
 };
 
-export function useBuildNavigationController<EC extends EntityCollection, UserType extends User>({
-                                                                                                     basePath = DEFAULT_BASE_PATH,
-                                                                                                     baseCollectionPath = DEFAULT_COLLECTION_PATH,
-                                                                                                     authController,
-                                                                                                     collections: collectionsProp,
-                                                                                                     views: baseViews,
-                                                                                                     userConfigPersistence,
-                                                                                                     dataSourceDelegate,
-                                                                                                     injectCollections
-                                                                                                 }: BuildNavigationContextProps<EC, UserType>): NavigationController {
-
-    const location = useLocation();
-
-    const collectionsRef = useRef<EntityCollection[] | null>();
-    const [collections, setCollections] = useState<EntityCollection[] | undefined>();
-    const [views, setViews] = useState<CMSView[] | undefined>();
+export function useBuildNavigationController<EC extends EntityCollection, UserType extends User>(props: BuildNavigationContextProps<EC, UserType>): NavigationController {
+    const {
+        basePath = DEFAULT_BASE_PATH,
+        baseCollectionPath = DEFAULT_COLLECTION_PATH,
+        authController,
+        collections: collectionsProp,
+        collectionPermissions,
+        views: viewsProp,
+        adminViews: adminViewsProp,
+        viewsOrder,
+        userConfigPersistence,
+        dataSourceDelegate,
+        injectCollections
+    } = props;
+
+    const collectionsRef = useRef<EntityCollection[] | undefined>();
+    const viewsRef = useRef<CMSView[] | undefined>();
+    const adminViewsRef = useRef<CMSView[] | undefined>();
+
     const [initialised, setInitialised] = useState<boolean>(false);
 
     const [topLevelNavigation, setTopLevelNavigation] = useState<TopNavigationResult | undefined>(undefined);
@@ -81,18 +88,18 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
     const buildUrlCollectionPath = useCallback((path: string): string => `${removeInitialAndTrailingSlashes(baseCollectionPath)}/${encodePath(path)}`,
         [baseCollectionPath]);
 
-    const computeTopNavigation = useCallback((collections: EntityCollection[], views: CMSView[]): TopNavigationResult => {
-        const navigationEntries: TopNavigationEntry[] = [
+    const computeTopNavigation = useCallback((collections: EntityCollection[], views: CMSView[], adminViews: CMSView[], viewsOrder?: string[]): TopNavigationResult => {
+        let navigationEntries: TopNavigationEntry[] = [
             ...(collections ?? []).map(collection => (!collection.hideFromNavigation
-                ? {
+                ? ({
                     url: buildUrlCollectionPath(collection.id ?? collection.path),
                     type: "collection",
                     name: collection.name.trim(),
                     path: collection.id ?? collection.path,
                     collection,
                     description: collection.description?.trim(),
-                    group: collection.group?.trim()
-                }
+                    group: getGroup(collection)
+                } satisfies TopNavigationEntry)
                 : undefined))
                 .filter(Boolean) as TopNavigationEntry[],
             ...(views ?? []).map(view =>
@@ -101,18 +108,74 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
                         url: buildCMSUrlPath(Array.isArray(view.path) ? view.path[0] : view.path),
                         name: view.name.trim(),
                         type: "view",
+                        path: view.path,
+                        view,
+                        description: view.description?.trim(),
+                        group: getGroup(view)
+                    } satisfies TopNavigationEntry)
+                    : undefined)
+                .filter(Boolean) as TopNavigationEntry[],
+            ...(adminViews ?? []).map(view =>
+                !view.hideFromNavigation
+                    ? ({
+                        url: buildCMSUrlPath(Array.isArray(view.path) ? view.path[0] : view.path),
+                        name: view.name.trim(),
+                        type: "admin",
+                        path: view.path,
                         view,
                         description: view.description?.trim(),
-                        group: view.group?.trim()
-                    })
+                        group: "Admin"
+                    } satisfies TopNavigationEntry)
                     : undefined)
                 .filter(Boolean) as TopNavigationEntry[]
         ];
 
+        // Sort by group, entries with group "Admin" will go last, and second to last will be the group "Views"
+        navigationEntries = navigationEntries.sort((a, b) => {
+            if (a.group !== "Views" && a.group !== "Admin" && (b.group === "Views" || b.group === "Admin")) {
+                return -1;
+            }
+            if (b.group !== "Views" && b.group !== "Admin" && (a.group === "Views" || a.group === "Admin")) {
+                return 1;
+            }
+            if (a.group === "Admin" && b.group !== "Admin") {
+                return 1;
+            }
+            if (a.group !== "Admin" && b.group === "Admin") {
+                return -1;
+            }
+            if (a.group === "Views" && b.group !== "Views") {
+                return -1;
+            }
+            if (a.group !== "Views" && b.group === "Views") {
+                return 1;
+            }
+            return 0;
+
+        });
+
+        if (viewsOrder) {
+            navigationEntries = navigationEntries.sort((a, b) => {
+                const aIndex = viewsOrder.indexOf(a.path);
+                const bIndex = viewsOrder.indexOf(b.path);
+                if (aIndex === -1 && bIndex === -1) {
+                    return 0;
+                }
+                if (aIndex === -1) {
+                    return 1;
+                }
+                if (bIndex === -1) {
+                    return -1;
+                }
+                return aIndex - bIndex;
+            });
+        }
+
         const groups: string[] = Object.values(navigationEntries)
             .map(e => e.group)
             .filter(Boolean)
             .filter((value, index, array) => array.indexOf(value) === index) as string[];
+
         return {
             navigationEntries,
             groups
@@ -124,17 +187,34 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         if (authController.initialLoading)
             return;
 
+        console.debug("Refreshing navigation");
+
         try {
-            const [resolvedCollections = [], resolvedViews = []] = await Promise.all([
-                    resolveCollections(collectionsProp, authController, dataSourceDelegate, injectCollections),
-                    resolveCMSViews(baseViews, authController, dataSourceDelegate)
+
+            const [resolvedCollections = [], resolvedViews, resolvedAdminViews = []] = await Promise.all([
+                    resolveCollections(collectionsProp, collectionPermissions, authController, dataSourceDelegate, injectCollections),
+                    resolveCMSViews(viewsProp, authController, dataSourceDelegate),
+                    resolveCMSViews(adminViewsProp, authController, dataSourceDelegate)
                 ]
             );
-            if (!equal(collectionsRef.current, resolvedCollections) || !equal(views, resolvedViews) || !equal(topLevelNavigation, computeTopNavigation(resolvedCollections, resolvedViews))) {
+
+            let shouldUpdateTopLevelNav = false;
+            if (!areCollectionListsEqual(collectionsRef.current ?? [], resolvedCollections)) {
                 collectionsRef.current = resolvedCollections;
-                setCollections(resolvedCollections);
-                setViews(resolvedViews);
-                setTopLevelNavigation(computeTopNavigation(resolvedCollections ?? [], resolvedViews));
+                shouldUpdateTopLevelNav = true;
+            }
+            if (!equal(viewsRef.current, resolvedViews)) {
+                viewsRef.current = resolvedViews;
+                shouldUpdateTopLevelNav = true;
+            }
+            if (!equal(adminViewsRef.current, resolvedAdminViews)) {
+                adminViewsRef.current = resolvedAdminViews;
+                shouldUpdateTopLevelNav = true;
+            }
+
+            const computedTopLevelNav = computeTopNavigation(resolvedCollections, resolvedViews, resolvedAdminViews, viewsOrder);
+            if (shouldUpdateTopLevelNav && !equal(topLevelNavigation, computedTopLevelNav)) {
+                setTopLevelNavigation(computedTopLevelNav);
             }
         } catch (e) {
             console.error(e);
@@ -143,25 +223,34 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
         setNavigationLoading(false);
         setInitialised(true);
-    }, [collectionsProp, authController.user, authController.initialLoading, baseViews, computeTopNavigation, injectCollections]);
+
+    }, [
+        collectionsProp,
+        collectionPermissions,
+        authController.user,
+        authController.initialLoading,
+        viewsProp,
+        adminViewsProp,
+        computeTopNavigation,
+        injectCollections
+    ]);
 
     useEffect(() => {
         refreshNavigation();
     }, [refreshNavigation]);
 
-    const getCollection = useCallback(<EC extends EntityCollection>(
+    const getCollection = useCallback((
         idOrPath: string,
         entityId?: string,
         includeUserOverride = false
     ): EC | undefined => {
-
+        const collections = collectionsRef.current;
         if (!collections)
             return undefined;
 
         const baseCollection = getCollectionByPathOrId(removeInitialAndTrailingSlashes(idOrPath), collections);
 
         const userOverride = includeUserOverride ? userConfigPersistence?.getCollectionConfig(idOrPath) : undefined;
-
         const overriddenCollection = baseCollection ? mergeDeep(baseCollection, userOverride) : undefined;
 
         let result: Partial<EntityCollection> | undefined = overriddenCollection;
@@ -182,16 +271,14 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
         return { ...overriddenCollection, ...result } as EC;
 
-    }, [
-        basePath,
-        baseCollectionPath,
-        collections,
-    ]);
+    }, [userConfigPersistence]);
 
     const getCollectionFromPaths = useCallback(<EC extends EntityCollection>(pathSegments: string[]): EC | undefined => {
-        let currentCollections = collections;
-        if (!currentCollections)
-            throw Error("Collections have not been initialised yet");
+
+        const collections = collectionsRef.current;
+        if (collections === undefined)
+            throw Error("getCollectionFromPaths: Collections have not been initialised yet");
+        let currentCollections: EntityCollection[] | undefined = [...(collections ?? [])];
 
         for (let i = 0; i < pathSegments.length; i++) {
             const pathSegment = pathSegments[i];
@@ -205,12 +292,14 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
         return undefined;
 
-    }, [collections]);
+    }, []);
 
     const getCollectionFromIds = useCallback(<EC extends EntityCollection>(ids: string[]): EC | undefined => {
-        let currentCollections = collections;
-        if (!currentCollections)
-            throw Error("Collections have not been initialised yet");
+
+        const collections = collectionsRef.current;
+        if (collections === undefined)
+            throw Error("getCollectionFromIds: Collections have not been initialised yet");
+        let currentCollections: EntityCollection[] | undefined = [...(collections ?? [])];
 
         for (let i = 0; i < ids.length; i++) {
             const id = ids[i];
@@ -224,7 +313,7 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
         return undefined;
 
-    }, [collections]);
+    }, []);
 
     const isUrlCollectionPath = useCallback(
         (path: string): boolean => removeInitialAndTrailingSlashes(path + "/").startsWith(removeInitialAndTrailingSlashes(fullCollectionPath) + "/"),
@@ -246,25 +335,17 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         []);
 
     const resolveAliasesFrom = useCallback((path: string): string => {
-        if (!collections)
-            throw Error("Collections have not been initialised yet");
+        const collections = collectionsRef.current ?? [];
         return resolveCollectionPathIds(path, collections);
-    }, [collections]);
-
-    const state = location.state as any;
-    /**
-     * The location can be overridden if `base_location` is set in the
-     * state field of the current location. This can happen if you open
-     * a side entity, like `products`, from a different one, like `users`
-     */
-    const baseLocation = state && state.base_location ? state.base_location : location;
+    }, []);
 
     const getAllParentReferencesForPath = useCallback((path: string): EntityReference[] => {
+        const collections = collectionsRef.current ?? [];
         return getParentReferencesFromPath({
             path,
             collections
         });
-    }, [collections]);
+    }, []);
 
     const getParentCollectionIds = useCallback((path: string): string[] => {
 
@@ -283,23 +364,24 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
     }, [getAllParentReferencesForPath])
 
     const convertIdsToPaths = useCallback((ids: string[]): string[] => {
-            let currentCollections = collections;
-            const paths: string[] = [];
-            for (let i = 0; i < ids.length; i++) {
-                const id = ids[i];
-                const collection: EntityCollection | undefined = currentCollections!.find(c => c.id === id);
-                if (!collection)
-                    throw Error(`Collection with id ${id} not found`);
-                paths.push(collection.path);
-                currentCollections = collection.subcollections;
-            }
-            return paths;
+        const collections = collectionsRef.current;
+        let currentCollections = collections;
+        const paths: string[] = [];
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            const collection: EntityCollection | undefined = currentCollections!.find(c => c.id === id);
+            if (!collection)
+                throw Error(`Collection with id ${id} not found`);
+            paths.push(collection.path);
+            currentCollections = collection.subcollections;
         }
-        , [getCollectionFromIds]);
+        return paths;
+    }, [getCollectionFromIds]);
 
     return {
-        collections,
-        views,
+        collections: collectionsRef.current,
+        views: viewsRef.current,
+        adminViews: adminViewsRef.current,
         loading: !initialised || navigationLoading,
         navigationLoadingError,
         homeUrl,
@@ -316,7 +398,6 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         buildCMSUrlPath,
         resolveAliasesFrom,
         topLevelNavigation,
-        baseLocation,
         refreshNavigation,
         getParentReferencesFromPath: getAllParentReferencesForPath,
         getParentCollectionIds,
@@ -341,8 +422,8 @@ function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[],
     return resolvedCollections
         .filter((c) => {
             if (!c.permissions) return true;
-            const resolvedPermissions = resolvePermissions(c, authController, [c.path], null,)
-            return resolvedPermissions.read !== false;
+            const resolvedPermissions = resolvePermissions(c, authController, c.path, null)
+            return resolvedPermissions?.read !== false;
         })
         .map((c) => {
             if (!c.subcollections) return c;
@@ -354,9 +435,10 @@ function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[],
 }
 
 async function resolveCollections(collections: undefined | EntityCollection[] | EntityCollectionsBuilder<any>,
+                                  collectionPermissions: PermissionsBuilder | undefined,
                                   authController: AuthController,
                                   dataSource: DataSourceDelegate,
-                                  injectCollections?: (collections: EntityCollection[]) => EntityCollection[]) {
+                                  injectCollections?: (collections: EntityCollection[]) => EntityCollection[]): Promise<EntityCollection[]> {
     let resolvedCollections: EntityCollection[] = [];
     if (typeof collections === "function") {
         resolvedCollections = await collections({
@@ -368,12 +450,14 @@ async function resolveCollections(collections: undefined | EntityCollection[] |
         resolvedCollections = collections;
     }
 
-    resolvedCollections = filterOutNotAllowedCollections(resolvedCollections, authController);
-
     if (injectCollections) {
         resolvedCollections = injectCollections(resolvedCollections ?? []);
     }
 
+    resolvedCollections = applyPermissionsFunctionIfEmpty(resolvedCollections, collectionPermissions);
+
+    resolvedCollections = filterOutNotAllowedCollections(resolvedCollections, authController);
+
     return resolvedCollections;
 }
 
@@ -390,3 +474,37 @@ async function resolveCMSViews(baseViews: CMSView[] | CMSViewsBuilder | undefine
     }
     return resolvedViews;
 }
+
+function getGroup(collectionOrView: EntityCollection<any, any> | CMSView) {
+    const trimmed = collectionOrView.group?.trim();
+    if (!trimmed || trimmed === "") {
+        return "Views";
+    }
+    return trimmed ?? "Views";
+}
+
+function areCollectionListsEqual(a: EntityCollection[], b: EntityCollection[]) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const aCopy = [...a];
+    const bCopy = [...b];
+    const aSorted = aCopy.sort((x, y) => x.id.localeCompare(y.id));
+    const bSorted = bCopy.sort((x, y) => x.id.localeCompare(y.id));
+    return aSorted.every((value, index) => areCollectionsEqual(value, bSorted[index]));
+}
+
+function areCollectionsEqual(a: EntityCollection, b: EntityCollection) {
+    const {
+        subcollections: subcollectionsA,
+        ...restA
+    } = a;
+    const {
+        subcollections: subcollectionsB,
+        ...restB
+    } = b;
+    if (!areCollectionListsEqual(subcollectionsA ?? [], subcollectionsB ?? [])) {
+        return false;
+    }
+    return equal(restA, restB);
+}