@rebasepro/admin 0.0.1-canary.eae7889 → 0.0.1-canary.eb08332

package/src/hooks/navigation/useBuildCollectionRegistryController.tsx

@@ -1,22 +1,27 @@
-import type { EntityCollection } from "@rebasepro/types";
-import { useCallback, useRef, useState, useMemo } from "react";
+import type { CollectionConfig, DataSourceDefinition } from "@rebasepro/types";
+import { useCallback, useEffect, 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
+    userConfigPersistence?: UserConfigurationPersistence,
+    dataSources?: Record<string, DataSourceDefinition>
 }): CollectionRegistryController & {
     collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
 } {
-    const { userConfigPersistence } = props;
-    const collectionRegistryRef = useRef<CollectionRegistry>(new CollectionRegistry());
+    const { userConfigPersistence, dataSources } = props;
+    const collectionRegistryRef = useRef<CollectionRegistry>(new CollectionRegistry(undefined, dataSources));
+    // Keep the registry's data sources in sync (used to resolve engine during
+    // normalization). Applied synchronously before the async registration
+    // effect in useResolvedCollections runs.
+    if (dataSources) collectionRegistryRef.current.setDataSources(dataSources);
     const [initialised, setInitialised] = useState(false);
 
     const getCollection = useCallback((
         slugOrPath: string,
         includeUserOverride = false
-    ): EntityCollection | undefined => {
+    ): CollectionConfig | undefined => {
 
         const registry = collectionRegistryRef.current;
 
@@ -26,14 +31,14 @@ export function useBuildCollectionRegistryController(props: {
         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 the path has an even number of segments, it points to a 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;
+        let collection: CollectionConfig | undefined;
         try {
             collection = registry.resolvePathToCollections(collectionPath).finalCollection;
         } catch (e) {
@@ -51,7 +56,7 @@ export function useBuildCollectionRegistryController(props: {
 
         if (!overriddenCollection) return undefined;
 
-        let result: Partial<EntityCollection> | undefined = overriddenCollection;
+        let result: Partial<CollectionConfig> | undefined = overriddenCollection;
         const subcollections = "subcollections" in overriddenCollection ? overriddenCollection.subcollections : undefined;
         const callbacks = overriddenCollection.callbacks;
         result = {
@@ -64,11 +69,11 @@ export function useBuildCollectionRegistryController(props: {
         }
 
         return { ...overriddenCollection,
-...result } as EntityCollection;
+...result } as CollectionConfig;
 
     }, [userConfigPersistence]);
 
-    const getRawCollection = useCallback((slugOrPath: string): EntityCollection | undefined => {
+    const getRawCollection = useCallback((slugOrPath: string): CollectionConfig | undefined => {
         const registry = collectionRegistryRef.current;
         if (registry === undefined) return undefined;
 
@@ -77,7 +82,7 @@ export function useBuildCollectionRegistryController(props: {
 
         const pathSegments = cleanedPath.split("/");
 
-        return registry.getRaw(pathSegments.join("/")) as EntityCollection | undefined;
+        return registry.getRaw(pathSegments.join("/")) as CollectionConfig | undefined;
     }, []);
 
     const getParentReferencesFromPath = useCallback((path: string): EntityReference[] => {
@@ -94,7 +99,7 @@ export function useBuildCollectionRegistryController(props: {
         });
     }, []);
 
-    const getParentCollectionIds = useCallback((path: string): string[] => {
+    const getParentCollectionSlugs = useCallback((path: string): string[] => {
         const registry = collectionRegistryRef.current;
         if (!registry) {
             return [];
@@ -110,7 +115,7 @@ export function useBuildCollectionRegistryController(props: {
             result.push(oddPathSegments.slice(0, i));
         }
 
-        const getCollectionFromPaths = (pathSegments: string[]): EntityCollection | undefined => {
+        const getCollectionFromPaths = (pathSegments: string[]): CollectionConfig | undefined => {
             if (!pathSegments?.length) return undefined;
             const testPath = pathSegments.reduce((acc, segment, idx) => {
                 if (idx === 0) return segment;
@@ -126,14 +131,24 @@ export function useBuildCollectionRegistryController(props: {
         return result.map(r => getCollectionFromPaths(r)?.slug).filter(Boolean) as string[];
     }, []);
 
+    const getParentEntityIds = useCallback((path: string): string[] => {
+        const cleanedPath = removeInitialAndTrailingSlashes(path);
+        const strings = cleanedPath.split("/");
+        const evenPathSegments = strings.filter((_, i) => i % 2 !== 0);
+        if (strings.length % 2 === 0) {
+            evenPathSegments.pop();
+        }
+        return evenPathSegments;
+    }, []);
+
     const convertIdsToPaths = useCallback((ids: string[]): string[] => {
         const registry = collectionRegistryRef.current;
         if (!registry) return [];
-        let currentCollections: EntityCollection[] = registry.getCollections();
+        let currentCollections: CollectionConfig[] = 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);
+            const collection: CollectionConfig | undefined = currentCollections.find(c => c.slug === id);
             if (!collection)
                 throw Error(`Collection with id ${id} not found`);
             paths.push(collection.slug);
@@ -146,9 +161,11 @@ export function useBuildCollectionRegistryController(props: {
 
     // 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);
-    }
+    useEffect(() => {
+        if (!initialised && collections.length > 0) {
+            setInitialised(true);
+        }
+    }, [initialised, collections.length]);
 
     return useMemo(() => ({
         collections,
@@ -156,7 +173,8 @@ export function useBuildCollectionRegistryController(props: {
         getCollection,
         getRawCollection,
         getParentReferencesFromPath,
-        getParentCollectionIds,
+        getParentCollectionSlugs,
+        getParentEntityIds,
         convertIdsToPaths,
         collectionRegistryRef
     }), [
@@ -165,7 +183,8 @@ export function useBuildCollectionRegistryController(props: {
         getCollection,
         getRawCollection,
         getParentReferencesFromPath,
-        getParentCollectionIds,
+        getParentCollectionSlugs,
+        getParentEntityIds,
         convertIdsToPaths
     ]);
 }

package/src/hooks/navigation/useBuildNavigationStateController.tsx

@@ -1,19 +1,18 @@
-import type { AppView, EntityCollection, NavigationResult, RebasePlugin, NavigationStateController, UrlController, NavigationGroupMapping } from "@rebasepro/types";
-import { useCallback, useMemo } from "react";
+import type { AppView, CollectionConfig, NavigationResult, RebasePlugin, NavigationStateController, UrlController, NavigationGroupMapping } from "@rebasepro/types";
+import { useCallback, useMemo, useRef } from "react";
 
 import { AuthController, RebaseData, CollectionRegistryController, User } from "@rebasepro/types";
-import type { EntityCollectionsBuilder, AppViewsBuilder, EffectiveRoleController } from "@rebasepro/types";
+import type { CollectionConfigsBuilder, 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> = {
+export type BuildNavigationStateProps<EC extends CollectionConfig, USER extends User> = {
     authController: AuthController<USER>;
-    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    collections?: EC[] | CollectionConfigsBuilder<EC>;
     views?: AppView[] | AppViewsBuilder;
     adminViews?: AppView[] | AppViewsBuilder;
     data: RebaseData;
@@ -25,7 +24,7 @@ export type BuildNavigationStateProps<EC extends EntityCollection, USER extends
     urlController: UrlController;
     adminMode?: "content" | "studio" | "settings";
     effectiveRoleController?: EffectiveRoleController;
-    userManagement?: UserManagementDelegate<USER>;
+
 };
 
 /**
@@ -33,12 +32,12 @@ export type BuildNavigationStateProps<EC extends EntityCollection, USER extends
  * 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
+ * - useResolvedViews: resolves view/admin view props
  * - 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>(
+export function useBuildNavigationStateController<EC extends CollectionConfig, USER extends User>(
     props: BuildNavigationStateProps<EC, USER>
 ): NavigationStateController {
 
@@ -55,11 +54,9 @@ export function useBuildNavigationStateController<EC extends EntityCollection, U
         collectionRegistryController,
         urlController,
         adminMode = "content",
-        effectiveRoleController,
-        userManagement
+        effectiveRoleController
     } = props;
 
-    // Step 1: Resolve collections
     const {
         collections,
         loading: collectionsLoading,
@@ -74,7 +71,6 @@ export function useBuildNavigationStateController<EC extends EntityCollection, U
         collectionRegistryController
     });
 
-    // Step 2: Resolve views and admin views
     const {
         views,
         adminViews,
@@ -88,8 +84,7 @@ export function useBuildNavigationStateController<EC extends EntityCollection, U
         data,
         plugins,
         adminMode,
-        effectiveRoleController,
-        userManagement
+        effectiveRoleController
     });
 
     // Step 3: Compute top-level navigation (pure derived state)
@@ -105,10 +100,16 @@ export function useBuildNavigationStateController<EC extends EntityCollection, U
         collectionRegistryController
     });
 
-    // Expose a combined refresh function
+    // Expose a combined refresh function with microtask batching
+    const pendingRefreshRef = useRef(false);
     const refreshNavigation = useCallback(() => {
-        refreshCollections();
-        refreshViews();
+        if (pendingRefreshRef.current) return;
+        pendingRefreshRef.current = true;
+        queueMicrotask(() => {
+            pendingRefreshRef.current = false;
+            refreshCollections();
+            refreshViews();
+        });
     }, [refreshCollections, refreshViews]);
 
     return useMemo(() => ({
@@ -117,8 +118,7 @@ export function useBuildNavigationStateController<EC extends EntityCollection, U
         topLevelNavigation,
         loading: collectionsLoading || viewsLoading,
         navigationLoadingError: collectionsError ?? viewsError,
-        refreshNavigation,
-        plugins
+        refreshNavigation
     }), [
         views,
         adminViews,
@@ -127,7 +127,6 @@ export function useBuildNavigationStateController<EC extends EntityCollection, U
         viewsLoading,
         collectionsError,
         viewsError,
-        refreshNavigation,
-        plugins
+        refreshNavigation
     ]);
 }

package/src/hooks/navigation/useNavigationResolution.ts

@@ -1,40 +1,173 @@
-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 type {
+    AppView,
+    AppViewsBuilder,
+    AuthCollectionConfig,
+    EntityAction,
+    CollectionConfig,
+    CollectionConfigsBuilder,
+    RebaseContext,
+    RebasePlugin,
+    UserCreationResult
+} from "@rebasepro/types";
+import { type AuthController, type User, type RebaseData } from "@rebasepro/types";
 import { canReadCollection } from "@rebasepro/common";
+import { resetPasswordAction } from "../../components/common/default_entity_actions";
+import { CreationResultDialog } from "../../components/admin/CreationResultDialog";
+import React from "react";
 
-export function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[], authController: AuthController<User>): EntityCollection[] {
+/**
+ * Check whether a `RebaseCallContext` is actually the full frontend
+ * `RebaseContext` (which carries `dialogsController`).
+ */
+function isRebaseContext(ctx: unknown): ctx is RebaseContext {
+    return typeof ctx === "object" && ctx !== null && "dialogsController" in ctx;
+}
+
+export function filterOutNotAllowedCollections(resolvedCollections: CollectionConfig[], authController: AuthController): CollectionConfig[] {
     return resolvedCollections
         .filter((c) => canReadCollection(c, authController))
         .map((c) => {
-            if (!("subcollections" in c) || !c.subcollections) return c;
+            if (!c.childCollections) return c;
             return {
                 ...c,
-                subcollections: () => filterOutNotAllowedCollections((c as FirebaseCollection).subcollections?.() ?? [], authController)
-            } as FirebaseCollection;
+                childCollections: () => filterOutNotAllowedCollections(c.childCollections!() ?? [], authController)
+            };
         });
 }
 
-export function applyPluginModifyCollection(resolvedCollections: EntityCollection[], modifyCollection: (collection: EntityCollection) => EntityCollection) {
-    return resolvedCollections.map((collection: EntityCollection): EntityCollection => {
+export function applyPluginModifyCollection(resolvedCollections: CollectionConfig[], modifyCollection: (collection: CollectionConfig) => CollectionConfig): CollectionConfig[] {
+    return resolvedCollections.map((collection): CollectionConfig => {
         const modifiedCollection = modifyCollection(collection);
-        if ("subcollections" in modifiedCollection && modifiedCollection.subcollections) {
+        if (modifiedCollection.childCollections) {
             return {
                 ...modifiedCollection,
-                subcollections: () => applyPluginModifyCollection((modifiedCollection as FirebaseCollection).subcollections?.() ?? [], modifyCollection)
-            } as FirebaseCollection;
+                childCollections: () => applyPluginModifyCollection(modifiedCollection.childCollections!() ?? [], modifyCollection)
+            };
         }
         return modifiedCollection;
     });
 }
 
-export async function resolveCollections<U extends User, EC extends EntityCollection>(
-    collections: undefined | EC[] | EntityCollectionsBuilder<EC>,
-    authController: AuthController<U>,
+/**
+ * Auto-inject auth-specific entity actions and callbacks for collections
+ * with `auth: true` or `auth: { enabled: true }`.
+ *
+ * Injections:
+ * 1. **resetPasswordAction** — adds the entity action unless explicitly disabled,
+ *    or unless the auth adapter reports no `adminPasswordReset` support. Custom
+ *    adapters mount their own admin routes and may not implement
+ *    `POST /admin/users/:userId/reset-password`; injecting the action anyway
+ *    would show a button that can only ever 404.
+ * 2. **afterSave callback** — shows the `CreationResultDialog` when a new user
+ *    is created with `invitationSent` or `temporaryPassword` in the response
+ *
+ * Skips injection if the collection already has the action/callback present.
+ */
+function injectAuthCollectionConfig(
+    collections: CollectionConfig[],
+    adminPasswordResetSupported: boolean
+): CollectionConfig[] {
+    return collections.map((collection) => {
+        const authProp = collection.auth;
+        if (!authProp) return collection;
+
+        const isAuth = authProp === true || (typeof authProp === "object" && authProp.enabled === true);
+        if (!isAuth) return collection;
+
+        const authConfig: AuthCollectionConfig | undefined = typeof authProp === "object" ? authProp : undefined;
+
+        let result = collection;
+
+        // ─── Entity Action injection (resetPassword) ─────────────────────
+        const resetPref = authConfig?.actions?.resetPassword;
+        let actionToInject: EntityAction | undefined;
+
+        if (resetPref === false) {
+            actionToInject = undefined;
+        } else if (typeof resetPref === "object") {
+            // An explicitly supplied action is the collection author's own; they
+            // own its backend, so the adapter capability doesn't apply.
+            actionToInject = resetPref;
+        } else if (!adminPasswordResetSupported) {
+            actionToInject = undefined;
+        } else {
+            actionToInject = resetPasswordAction;
+        }
+
+        if (actionToInject) {
+            const injectedAction = actionToInject;
+            const existing = result.entityActions ?? [];
+            const alreadyHas = existing.some(
+                (a) => a.key != null && a.key === injectedAction.key
+            );
+            if (!alreadyHas) {
+                result = {
+                    ...result,
+                    entityActions: [...existing, injectedAction]
+                };
+            }
+        }
+
+        // ─── afterSave callback (creation result dialog) ─────────────────
+        const existingAfterSave = result.callbacks?.afterSave;
+        result = {
+            ...result,
+            callbacks: {
+                ...result.callbacks,
+                afterSave: async (props) => {
+                    await existingAfterSave?.(props);
+
+                    const { values, status, context } = props;
+                    if (status !== "new" && status !== "copy") return;
+
+                    const hasCreationInfo = values.invitationSent !== undefined || values.temporaryPassword !== undefined;
+                    if (!hasCreationInfo || !isRebaseContext(context) || !context.dialogsController) return;
+
+                    const { dialogsController } = context;
+
+                    const creationResult: UserCreationResult = {
+                        user: {
+                            uid: String(props.id),
+                            email: typeof values.email === "string" ? values.email : "",
+                            displayName: typeof values.displayName === "string" ? values.displayName : "",
+                            roles: Array.isArray(values.roles) ? values.roles as string[] : [],
+                            photoURL: typeof values.photoURL === "string"
+                                ? values.photoURL
+                                : typeof values.photoUrl === "string"
+                                    ? values.photoUrl
+                                    : null,
+                            providerId: "password",
+                            isAnonymous: false
+                        },
+                        invitationSent: !!values.invitationSent,
+                        temporaryPassword: typeof values.temporaryPassword === "string" ? values.temporaryPassword : undefined,
+                        emailDeliveryFailed: !!values.emailDeliveryFailed
+                    };
+
+                    const { closeDialog } = dialogsController.open({
+                        key: "user_creation_result",
+                        Component: () => (
+                            React.createElement(CreationResultDialog, {
+                                result: creationResult,
+                                onClose: () => closeDialog()
+                            })
+                        )
+                    });
+                }
+            }
+        };
+
+        return result;
+    });
+}
+
+export async function resolveCollections(
+    collections: undefined | CollectionConfig[] | CollectionConfigsBuilder,
+    authController: AuthController,
     data: RebaseData,
     plugins: RebasePlugin[] | undefined
-): Promise<EntityCollection[]> {
-    let resolvedCollections: EntityCollection[] = [];
+): Promise<CollectionConfig[]> {
+    let resolvedCollections: CollectionConfig[] = [];
     if (typeof collections === "function") {
         resolvedCollections = await collections({
             user: authController.user,
@@ -52,21 +185,27 @@ export async function resolveCollections<U extends User, EC extends EntityCollec
             }
 
             if (plugin.hooks?.injectCollections) {
-                resolvedCollections = plugin.hooks.injectCollections(resolvedCollections ?? []);
+                resolvedCollections = plugin.hooks.injectCollections(resolvedCollections);
             }
         }
     }
 
+    // Auto-inject auth entity actions and callbacks (resetPassword, creation dialog, etc.)
+    resolvedCollections = injectAuthCollectionConfig(
+        resolvedCollections,
+        authController.capabilities?.adminPasswordReset ?? true
+    );
+
     resolvedCollections = filterOutNotAllowedCollections(resolvedCollections, authController);
     return resolvedCollections;
 }
 
-export async function resolveAppViews<U extends User>(
+export async function resolveAppViews(
     baseViews: AppView[] | AppViewsBuilder | undefined,
-    authController: AuthController<U>,
+    authController: AuthController,
     data: RebaseData,
     plugins?: RebasePlugin[]
-) {
+): Promise<AppView[]> {
     let resolvedViews: AppView[] = [];
     if (typeof baseViews === "function") {
         resolvedViews = await baseViews({
@@ -87,5 +226,38 @@ export async function resolveAppViews<U extends User>(
         }
     }
 
+    // Detect duplicate view slugs (dev warning)
+    if (process.env.NODE_ENV !== 'production') {
+        const slugCounts = new Map<string, number>();
+        resolvedViews.forEach(v => {
+            slugCounts.set(v.slug, (slugCounts.get(v.slug) ?? 0) + 1);
+        });
+        slugCounts.forEach((count, slug) => {
+            if (count > 1) {
+                console.warn(
+                    `[Rebase] Duplicate view slug "${slug}" detected (${count} views). ` +
+                    `Last-write-wins. Ensure unique slugs across CMS views and plugins.`
+                );
+            }
+        });
+    }
+
+    // Filter by roles — applies to CMS, plugin, and builder-returned views
+    resolvedViews = filterViewsByRole(resolvedViews, authController);
+
     return resolvedViews;
 }
+
+/**
+ * Filter views by the `roles` field on AppView.
+ * When `roles` is set, the view is only included if the current user
+ * has at least one of the listed roles. Views without `roles` (or with
+ * an empty array) are always included.
+ */
+function filterViewsByRole(views: AppView[], authController: AuthController): AppView[] {
+    const userRoles = authController.user?.roles ?? [];
+    return views.filter(view => {
+        if (!view.roles || view.roles.length === 0) return true;
+        return view.roles.some(role => userRoles.includes(role));
+    });
+}