@firecms/core 3.0.0-canary.24 → 3.0.0-canary.240

package/src/hooks/useBuildNavigationController.tsx

@@ -9,6 +9,8 @@ import {
     EntityCollection,
     EntityCollectionsBuilder,
     EntityReference,
+    FireCMSPlugin,
+    NavigationBlocker,
     NavigationController,
     PermissionsBuilder,
     TopNavigationEntry,
@@ -20,19 +22,21 @@ import {
     applyPermissionsFunctionIfEmpty,
     getCollectionByPathOrId,
     mergeDeep,
+    removeFunctions,
     removeInitialAndTrailingSlashes,
     resolveCollectionPathIds,
     resolvePermissions
 } from "../util";
 import { getParentReferencesFromPath } from "../util/parent_references_from_path";
+import { useBlocker, useNavigate } from "react-router-dom";
 
 const DEFAULT_BASE_PATH = "/";
 const DEFAULT_COLLECTION_PATH = "/c";
 
-type BuildNavigationContextProps<EC extends EntityCollection, UserType extends User> = {
+export type BuildNavigationContextProps<EC extends EntityCollection, USER extends User> = {
     basePath?: string,
     baseCollectionPath?: string,
-    authController: AuthController<UserType>;
+    authController: AuthController<USER>;
     collections?: EC[] | EntityCollectionsBuilder<EC>;
     collectionPermissions?: PermissionsBuilder;
     views?: CMSView[] | CMSViewsBuilder;
@@ -40,17 +44,14 @@ type BuildNavigationContextProps<EC extends EntityCollection, UserType extends U
     viewsOrder?: string[];
     userConfigPersistence?: UserConfigurationPersistence;
     dataSourceDelegate: DataSourceDelegate;
+    plugins?: FireCMSPlugin[];
     /**
-     * Use this method to inject collections to the CMS.
-     * You receive the current collections as a parameter, and you can return
-     * a new list of collections.
-     * @see {@link joinCollectionLists}
-     * @param collections
+     * If true, the navigation logic will not be updated until this flag is false
      */
-    injectCollections?: (collections: EntityCollection[]) => EntityCollection[];
+    disabled?: boolean;
 };
 
-export function useBuildNavigationController<EC extends EntityCollection, UserType extends User>(props: BuildNavigationContextProps<EC, UserType>): NavigationController {
+export function useBuildNavigationController<EC extends EntityCollection, USER extends User>(props: BuildNavigationContextProps<EC, USER>): NavigationController {
     const {
         basePath = DEFAULT_BASE_PATH,
         baseCollectionPath = DEFAULT_COLLECTION_PATH,
@@ -60,11 +61,14 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         views: viewsProp,
         adminViews: adminViewsProp,
         viewsOrder,
+        plugins,
         userConfigPersistence,
         dataSourceDelegate,
-        injectCollections
+        disabled
     } = props;
 
+    const navigate = useNavigate();
+
     const collectionsRef = useRef<EntityCollection[] | undefined>();
     const viewsRef = useRef<CMSView[] | undefined>();
     const adminViewsRef = useRef<CMSView[] | undefined>();
@@ -130,6 +134,30 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
                 .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);
@@ -160,48 +188,62 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
     const refreshNavigation = useCallback(async () => {
 
-        if (authController.initialLoading)
+        if (disabled || authController.initialLoading)
             return;
 
+        console.debug("Refreshing navigation");
+
         try {
-            console.debug("Refreshing navigation", {
-                authController
-            })
+
             const [resolvedCollections = [], resolvedViews, resolvedAdminViews = []] = await Promise.all([
-                    resolveCollections(collectionsProp, collectionPermissions, authController, dataSourceDelegate, injectCollections),
+                    resolveCollections(collectionsProp, collectionPermissions, authController, dataSourceDelegate, plugins),
                     resolveCMSViews(viewsProp, authController, dataSourceDelegate),
                     resolveCMSViews(adminViewsProp, authController, dataSourceDelegate)
                 ]
             );
 
-            if (
-                !equal(collectionsRef.current, resolvedCollections) ||
-                !equal(viewsRef.current, resolvedViews) ||
-                !equal(adminViewsRef.current, resolvedAdminViews) ||
-                !equal(topLevelNavigation, computeTopNavigation(resolvedCollections, resolvedViews, resolvedAdminViews, viewsOrder))
-            ) {
+            let shouldUpdateTopLevelNav = false;
+            if (!areCollectionListsEqual(collectionsRef.current ?? [], resolvedCollections)) {
+                collectionsRef.current = resolvedCollections;
+                console.debug("Collections have changed", resolvedCollections);
+                shouldUpdateTopLevelNav = true;
+            }
+            if (collectionsRef.current === undefined) {
                 collectionsRef.current = resolvedCollections;
+                shouldUpdateTopLevelNav = true;
+            }
+            if (!equal(viewsRef.current, resolvedViews)) {
                 viewsRef.current = resolvedViews;
+                shouldUpdateTopLevelNav = true;
+            }
+            if (!equal(adminViewsRef.current, resolvedAdminViews)) {
                 adminViewsRef.current = resolvedAdminViews;
-                setTopLevelNavigation(computeTopNavigation(resolvedCollections ?? [], resolvedViews, resolvedAdminViews, viewsOrder));
+                shouldUpdateTopLevelNav = true;
+            }
+
+            const computedTopLevelNav = computeTopNavigation(resolvedCollections, resolvedViews, resolvedAdminViews, viewsOrder);
+            if (shouldUpdateTopLevelNav && !equal(topLevelNavigation, computedTopLevelNav)) {
+                setTopLevelNavigation(computedTopLevelNav);
             }
         } catch (e) {
             console.error(e);
             setNavigationLoadingError(e as any);
         }
 
-        setNavigationLoading(false);
-        setInitialised(true);
+        if (navigationLoading)
+            setNavigationLoading(false);
+        if (!initialised)
+            setInitialised(true);
 
     }, [
         collectionsProp,
         collectionPermissions,
         authController.user,
         authController.initialLoading,
+        disabled,
         viewsProp,
         adminViewsProp,
-        computeTopNavigation,
-        injectCollections
+        computeTopNavigation
     ]);
 
     useEffect(() => {
@@ -210,7 +252,6 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
     const getCollection = useCallback((
         idOrPath: string,
-        entityId?: string,
         includeUserOverride = false
     ): EC | undefined => {
         const collections = collectionsRef.current;
@@ -220,8 +261,7 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         const baseCollection = getCollectionByPathOrId(removeInitialAndTrailingSlashes(idOrPath), collections);
 
         const userOverride = includeUserOverride ? userConfigPersistence?.getCollectionConfig(idOrPath) : undefined;
-
-        const overriddenCollection = baseCollection ? mergeDeep(baseCollection, userOverride) : undefined;
+        const overriddenCollection = baseCollection ? mergeDeep(baseCollection, userOverride ?? {}) : undefined;
 
         let result: Partial<EntityCollection> | undefined = overriddenCollection;
 
@@ -243,12 +283,22 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
 
     }, [userConfigPersistence]);
 
+    const getCollectionById = useCallback((id: string): EC | undefined => {
+        const collections = collectionsRef.current;
+        if (collections === undefined)
+            throw Error("getCollectionById: Collections have not been initialised yet");
+        const collection: EntityCollection | undefined = collections.find(c => c.id === id);
+        if (!collection)
+            return undefined;
+        return collection as EC;
+    }, []);
+
     const getCollectionFromPaths = useCallback(<EC extends EntityCollection>(pathSegments: string[]): EC | undefined => {
 
         const collections = collectionsRef.current;
+        if (collections === undefined)
+            throw Error("getCollectionFromPaths: Collections have not been initialised yet");
         let currentCollections: EntityCollection[] | undefined = [...(collections ?? [])];
-        if (!currentCollections)
-            throw Error("Collections have not been initialised yet");
 
         for (let i = 0; i < pathSegments.length; i++) {
             const pathSegment = pathSegments[i];
@@ -267,9 +317,9 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
     const getCollectionFromIds = useCallback(<EC extends EntityCollection>(ids: string[]): EC | undefined => {
 
         const collections = collectionsRef.current;
+        if (collections === undefined)
+            throw Error("getCollectionFromIds: Collections have not been initialised yet");
         let currentCollections: EntityCollection[] | undefined = [...(collections ?? [])];
-        if (!currentCollections)
-            throw Error("Collections have not been initialised yet");
 
         for (let i = 0; i < ids.length; i++) {
             const id = ids[i];
@@ -295,19 +345,8 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         throw Error("Expected path starting with " + fullCollectionPath);
     }, [fullCollectionPath]);
 
-    const buildUrlEditCollectionPath = useCallback(({
-                                                        path
-                                                    }: {
-            path: string
-        }): string => {
-            return `s/edit/${encodePath(path)}`;
-        },
-        []);
-
-    const resolveAliasesFrom = useCallback((path: string): string => {
-        const collections = collectionsRef.current;
-        if (!collections)
-            throw Error("Collections have not been initialised yet");
+    const resolveIdsFrom = useCallback((path: string): string => {
+        const collections = collectionsRef.current ?? [];
         return resolveCollectionPathIds(path, collections);
     }, []);
 
@@ -350,10 +389,6 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         return paths;
     }, [getCollectionFromIds]);
 
-    console.debug("Navigation", {
-        initialised,
-        navigationLoading
-    });
     return {
         collections: collectionsRef.current,
         views: viewsRef.current,
@@ -365,29 +400,22 @@ export function useBuildNavigationController<EC extends EntityCollection, UserTy
         baseCollectionPath,
         initialised,
         getCollection,
+        getCollectionById,
         getCollectionFromPaths,
         getCollectionFromIds,
         isUrlCollectionPath,
         urlPathToDataPath,
         buildUrlCollectionPath,
-        buildUrlEditCollectionPath,
-        buildCMSUrlPath,
-        resolveAliasesFrom,
+        resolveIdsFrom,
         topLevelNavigation,
         refreshNavigation,
         getParentReferencesFromPath: getAllParentReferencesForPath,
         getParentCollectionIds,
-        convertIdsToPaths
+        convertIdsToPaths,
+        navigate,
     };
 }
 
-export function getSidePanelKey(path: string, entityId?: string) {
-    if (entityId)
-        return `${removeInitialAndTrailingSlashes(path)}/${removeInitialAndTrailingSlashes(entityId)}`;
-    else
-        return removeInitialAndTrailingSlashes(path);
-}
-
 function encodePath(input: string) {
     return encodeURIComponent(removeInitialAndTrailingSlashes(input))
         .replaceAll("%2F", "/")
@@ -396,9 +424,10 @@ function encodePath(input: string) {
 
 function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[], authController: AuthController<User>): EntityCollection[] {
     return resolvedCollections
+        .filter((c) => Boolean(c.path))
         .filter((c) => {
             if (!c.permissions) return true;
-            const resolvedPermissions = resolvePermissions(c, authController, c.path, null)
+            const resolvedPermissions = resolvePermissions(c, authController, c.path, null);
             return resolvedPermissions?.read !== false;
         })
         .map((c) => {
@@ -410,11 +439,24 @@ function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[],
         });
 }
 
+function applyPluginModifyCollection(resolvedCollections: EntityCollection[], modifyCollection: (collection: EntityCollection) => EntityCollection) {
+    return resolvedCollections.map((collection: EntityCollection): EntityCollection => {
+        const modifiedCollection = modifyCollection(collection);
+        if (modifiedCollection.subcollections) {
+            return {
+                ...modifiedCollection,
+                subcollections: applyPluginModifyCollection(modifiedCollection.subcollections, modifyCollection)
+            } satisfies EntityCollection;
+        }
+        return modifiedCollection;
+    });
+}
+
 async function resolveCollections(collections: undefined | EntityCollection[] | EntityCollectionsBuilder<any>,
                                   collectionPermissions: PermissionsBuilder | undefined,
                                   authController: AuthController,
                                   dataSource: DataSourceDelegate,
-                                  injectCollections?: (collections: EntityCollection[]) => EntityCollection[]) {
+                                  plugins: FireCMSPlugin[] | undefined): Promise<EntityCollection[]> {
     let resolvedCollections: EntityCollection[] = [];
     if (typeof collections === "function") {
         resolvedCollections = await collections({
@@ -426,14 +468,20 @@ async function resolveCollections(collections: undefined | EntityCollection[] |
         resolvedCollections = collections;
     }
 
-    resolvedCollections = applyPermissionsFunctionIfEmpty(resolvedCollections, collectionPermissions);
-
-    resolvedCollections = filterOutNotAllowedCollections(resolvedCollections, authController);
+    if (plugins) {
+        for (const plugin of plugins) {
+            if (plugin.collection?.modifyCollection) {
+                resolvedCollections = applyPluginModifyCollection(resolvedCollections, plugin.collection.modifyCollection);
+            }
 
-    if (injectCollections) {
-        resolvedCollections = injectCollections(resolvedCollections ?? []);
+            if (plugin.collection?.injectCollections) {
+                resolvedCollections = plugin.collection.injectCollections(resolvedCollections ?? []);
+            }
+        }
     }
 
+    resolvedCollections = applyPermissionsFunctionIfEmpty(resolvedCollections, collectionPermissions);
+    resolvedCollections = filterOutNotAllowedCollections(resolvedCollections, authController);
     return resolvedCollections;
 }
 
@@ -458,3 +506,80 @@ function getGroup(collectionOrView: EntityCollection<any, any> | CMSView) {
     }
     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(removeFunctions(restA), removeFunctions(restB));
+}
+
+function useCustomBlocker(): NavigationBlocker {
+    const [blockListeners, setBlockListeners] = useState<Record<string, {
+        block: boolean,
+        basePath?: string
+    }>>({});
+
+    const shouldBlock = Object.values(blockListeners).some(b => b.block);
+
+    let blocker: any;
+    try {
+        blocker = useBlocker(({
+                                  nextLocation
+                              }) => {
+            const allBasePaths = Object.values(blockListeners).map(b => b.basePath).filter(Boolean) as string[];
+            if (allBasePaths && allBasePaths.some(path => nextLocation.pathname.startsWith(path)))
+                return false;
+            return shouldBlock;
+        });
+    } catch (e) {
+        // console.warn("Blocker not available, navigation will not be blocked");
+    }
+
+    const updateBlockListener = (path: string, block: boolean, basePath?: string) => {
+        setBlockListeners(prev => ({
+            ...prev,
+            [path]: {
+                block,
+                basePath
+            }
+        }));
+        return () => setBlockListeners(prev => {
+            const {
+                [path]: removed,
+                ...rest
+            } = prev;
+            return rest;
+        })
+    };
+
+    const isBlocked = (path: string) => {
+        return (blockListeners[path]?.block ?? false) && blocker?.state === "blocked";
+    }
+
+    return {
+        updateBlockListener,
+        isBlocked,
+        proceed: blocker?.proceed,
+        reset: blocker?.reset
+    }
+}

package/src/hooks/useFireCMSContext.tsx

@@ -21,9 +21,9 @@ import React, { useEffect } from "react";
  * @see FireCMSContext
  * @group Hooks and utilities
  */
-export const useFireCMSContext = <UserType extends User = User, AuthControllerType extends AuthController<UserType> = AuthController<UserType>>(): FireCMSContext<UserType, AuthControllerType> => {
+export const useFireCMSContext = <USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>(): FireCMSContext<USER, AuthControllerType> => {
 
-    const authController = useAuthController<UserType, AuthControllerType>();
+    const authController = useAuthController<USER, AuthControllerType>();
     const sideDialogsController = useSideDialogsController();
     const sideEntityController = useSideEntityController();
     const navigation = useNavigationController();
@@ -35,7 +35,7 @@ export const useFireCMSContext = <UserType extends User = User, AuthControllerTy
     const customizationController = useCustomizationController();
     const analyticsController = useAnalyticsController();
 
-    const fireCMSContextRef = React.useRef<FireCMSContext<UserType, AuthControllerType>>({
+    const fireCMSContextRef = React.useRef<FireCMSContext<USER, AuthControllerType>>({
         authController,
         sideDialogsController,
         sideEntityController,
@@ -67,33 +67,3 @@ export const useFireCMSContext = <UserType extends User = User, AuthControllerTy
 
     return fireCMSContextRef.current;
 }
-
-// export const useFireCMSContext = <UserType extends User = User, AuthControllerType extends AuthController<UserType> = AuthController<UserType>>(): FireCMSContext<UserType, AuthControllerType> => {
-//
-//     const authController = useAuthController<UserType, AuthControllerType>();
-//     const sideDialogsController = useSideDialogsController();
-//     const sideEntityController = useSideEntityController();
-//     const navigation = useNavigationController();
-//     const dataSource = useDataSource();
-//     const storageSource = useStorageSource();
-//     const snackbarController = useSnackbarController();
-//     const userConfigPersistence = useUserConfigurationPersistence();
-//     const dialogsController = useDialogsController();
-//     const customizationController = useCustomizationController();
-//     const analyticsController = useAnalyticsController();
-//
-//     return {
-//         authController,
-//         sideDialogsController,
-//         sideEntityController,
-//         navigation,
-//         dataSource,
-//         storageSource,
-//         snackbarController,
-//         userConfigPersistence,
-//         dialogsController,
-//         customizationController,
-//         analyticsController
-//     };
-//
-// };

package/src/hooks/useLargeLayout.tsx

@@ -63,38 +63,3 @@ function checkLargeLayout(breakpoint: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" |
         return false;
     return window.matchMedia(`(min-width: ${breakpoints[breakpoint] + 1}px)`).matches;
 }
-
-// import { useEffect, useState } from "react";
-//
-// const breakpoints = {
-//     xs: 0,
-//     sm: 640,
-//     md: 768,
-//     lg: 1024,
-//     xl: 1280,
-//     "2xl": 1536,
-//     "3xl": 1920
-// }
-// export const useLargeLayout = (breakpoint: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" = "lg"): boolean => {
-//     const [isLargeLayout, setIsLargeLayout] = useState<boolean>(false);
-//
-//     useEffect(() => {
-//         const handleResize = () => {
-//             const matched = window.matchMedia(`(min-width: ${breakpoints[breakpoint] + 1}px)`).matches;
-//             setIsLargeLayout(matched);
-//         };
-//
-//         // Set initial state
-//         handleResize();
-//
-//         // Set up event listener for resize events
-//         window.addEventListener("resize", handleResize);
-//
-//         // Clean up event listener when component unmounts
-//         return () => {
-//             window.removeEventListener("resize", handleResize);
-//         };
-//     }, []);
-//
-//     return isLargeLayout;
-// };

package/src/hooks/useModeController.tsx

@@ -7,8 +7,7 @@ import { useContext } from "react";
  */
 export interface ModeController {
     mode: "light" | "dark";
-    setMode: (mode: "light" | "dark") => void;
-    toggleMode: () => void;
+    setMode: (mode: "light" | "dark" | "system") => void;
 }
 
 /**

package/src/hooks/useProjectLog.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useRef, useState } from "react";
-import { AuthController, FireCMSPlugin } from "../types";
+import { AuthController, DataSourceDelegate, FireCMSPlugin } from "../types";
 
 export const DEFAULT_SERVER_DEV = "https://api-kdoe6pj3qq-ey.a.run.app";
 export const DEFAULT_SERVER = "https://api-drplyi3b6q-ey.a.run.app";
@@ -9,33 +9,55 @@ export type AccessResponse = {
     message?: string;
 }
 
-async function makeRequest(authController: AuthController, pluginKeys: string | undefined) {
-    const firebaseToken = await authController.getAuthToken();
+async function makeRequest(authController: AuthController, dataSourceKey: string, pluginKeys: string[] | undefined, apiKey?: string): Promise<AccessResponse> {
+    let idToken: string | null;
+    try {
+        idToken = await authController.getAuthToken();
+    } catch (e) {
+        idToken = null;
+    }
     return fetch(DEFAULT_SERVER + "/access_log",
         {
             // mode: "no-cors",
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
-                Authorization: `Basic ${firebaseToken}`,
+                Authorization: `Basic ${idToken}`
             },
-            body: JSON.stringify({ plugins: pluginKeys })
+            body: JSON.stringify({
+                apiKey,
+                email: authController.user?.email ?? null,
+                datasource: dataSourceKey,
+                plugins: pluginKeys
+            })
         })
         .then(async (res) => {
             return res.json();
         });
 }
 
-export function useProjectLog(authController: AuthController,
-                              plugins?: FireCMSPlugin<any, any, any>[]): AccessResponse | null {
+export interface UseProjectLogParams {
+    apiKey?: string;
+    authController: AuthController;
+    dataSourceDelegate: DataSourceDelegate;
+    plugins?: FireCMSPlugin<any, any, any>[];
+}
+
+export function useProjectLog({
+                                  authController,
+                                  dataSourceDelegate,
+                                  plugins,
+                                  apiKey
+                              }: UseProjectLogParams): AccessResponse | null {
     const [accessResponse, setAccessResponse] = useState<AccessResponse | null>(null);
     const accessedUserRef = useRef<string | null>(null);
-    const pluginKeys = plugins?.map(plugin => plugin.key).join(",");
+    const dataSourceKey = dataSourceDelegate.key;
+    const pluginKeys = plugins?.map(plugin => plugin.key);
     useEffect(() => {
         if (authController.user && authController.user.uid !== accessedUserRef.current && !authController.initialLoading) {
-            makeRequest(authController, pluginKeys).then(setAccessResponse);
+            makeRequest(authController, dataSourceKey, pluginKeys, apiKey).then(setAccessResponse);
             accessedUserRef.current = authController.user.uid;
         }
-    }, [authController]);
+    }, [authController, dataSourceKey, pluginKeys]);
     return accessResponse;
 }