@rebasepro/cms 0.17.3 → 0.18.1

package/src/hooks/navigation/useNavigationResolution.ts

@@ -1,271 +0,0 @@
-import type { AuthCollectionConfig } from "@rebasepro/types";
-import type { AppView, AppViewsBuilder, EntityAction, CollectionConfigsBuilder, RebaseContext, RebasePlugin, UserCreationResult, AdminCollection } from "@rebasepro/cms-types";
-import { type User, type RebaseData } from "@rebasepro/types";
-import { type AuthController, resolveAdminCollection } from "@rebasepro/cms-types";
-import { canReadCollection } from "@rebasepro/common";
-import { resetPasswordAction } from "../../components/common/default_entity_actions";
-import { CreationResultDialog } from "../../components/admin/CreationResultDialog";
-import React from "react";
-
-/**
- * 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: AdminCollection[], authController: AuthController): AdminCollection[] {
-    return resolvedCollections
-        .filter((c) => canReadCollection(c, authController))
-        .map((c) => {
-            if (!c.childCollections) return c;
-            return {
-                ...c,
-                childCollections: () => filterOutNotAllowedCollections(c.childCollections!() ?? [], authController)
-            };
-        });
-}
-
-export function applyPluginModifyCollection(resolvedCollections: AdminCollection[], modifyCollection: (collection: AdminCollection) => AdminCollection): AdminCollection[] {
-    return resolvedCollections.map((collection): AdminCollection => {
-        const modifiedCollection = modifyCollection(collection);
-        if (modifiedCollection.childCollections) {
-            return {
-                ...modifiedCollection,
-                childCollections: () => applyPluginModifyCollection(modifiedCollection.childCollections!() ?? [], modifyCollection)
-            };
-        }
-        return modifiedCollection;
-    });
-}
-
-/**
- * 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: AdminCollection[],
-    adminPasswordResetSupported: boolean
-): AdminCollection[] {
-    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.
-            // `auth.actions.resetPassword`'s object form is an EntityAction; core
-            // types it as `object` because a server never renders one.
-            actionToInject = resetPref as EntityAction;
-        } else if (!adminPasswordResetSupported) {
-            actionToInject = undefined;
-        } else {
-            actionToInject = resetPasswordAction;
-        }
-
-        if (actionToInject) {
-            const injectedAction = actionToInject;
-            const existing = result.entityActions ?? [];
-            // An entry is either the action or the key of an app-level one, and a
-            // collection that names `"reset_password"` already has this action — so
-            // the string form has to count here too, or the reset action is injected
-            // a second time and the user gets two identical buttons.
-            const alreadyHas = existing.some((a) =>
-                typeof a === "string"
-                    ? a === injectedAction.key
-                    : 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 | AdminCollection[] | CollectionConfigsBuilder,
-    authController: AuthController,
-    data: RebaseData,
-    plugins: RebasePlugin[] | undefined
-): Promise<AdminCollection[]> {
-    let resolvedCollections: AdminCollection[] = [];
-    if (typeof collections === "function") {
-        resolvedCollections = await collections({
-            user: authController.user,
-            authController,
-            data
-        });
-    } else if (Array.isArray(collections)) {
-        resolvedCollections = collections;
-    }
-
-    // Collections arrive in the authoring shape, with presentation nested under
-    // `admin`. Everything downstream — plugins, navigation, the drawer — reads the
-    // panel's flat view model, so `admin.group` or `admin.hideFromNavigation`
-    // would otherwise be silently ignored.
-    resolvedCollections = resolvedCollections.map(resolveAdminCollection);
-
-    if (plugins) {
-        for (const plugin of plugins) {
-            if (plugin.hooks?.modifyCollection) {
-                resolvedCollections = applyPluginModifyCollection(resolvedCollections, plugin.hooks.modifyCollection);
-            }
-
-            if (plugin.hooks?.injectCollections) {
-                // A plugin may return collections in the authoring shape too; the
-                // flattening is idempotent, so re-running it is safe.
-                resolvedCollections = plugin.hooks.injectCollections(resolvedCollections).map(resolveAdminCollection);
-            }
-        }
-    }
-
-    // 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(
-    baseViews: AppView[] | AppViewsBuilder | undefined,
-    authController: AuthController,
-    data: RebaseData,
-    plugins?: RebasePlugin[]
-): Promise<AppView[]> {
-    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];
-            }
-        }
-    }
-
-    // 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 admin views and plugins.`
-                );
-            }
-        });
-    }
-
-    // Filter by roles — applies to admin, 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));
-    });
-}

package/src/hooks/navigation/useResolvedCollections.ts

@@ -1,102 +0,0 @@
-
-import type { RebasePlugin, AdminCollection } from "@rebasepro/cms-types";
-import { useRef, useMemo } from "react";
-
-import { CollectionRegistryController, RebaseData, User } from "@rebasepro/types";
-import { AuthController } from "@rebasepro/cms-types";
-import type { CollectionConfigsBuilder } from "@rebasepro/cms-types";
-import { CollectionRegistry } from "@rebasepro/common";
-
-import { resolveCollections } from "./useNavigationResolution";
-import { areCollectionListsEqual } from "./utils";
-import { useAsyncResolver } from "./useAsyncResolver";
-
-export type UseResolvedCollectionsProps<EC extends AdminCollection, USER extends User> = {
-    authController: AuthController<USER>;
-    collections?: EC[] | CollectionConfigsBuilder<EC>;
-    data: RebaseData;
-    plugins?: RebasePlugin[];
-    disabled?: boolean;
-    collectionRegistryController: CollectionRegistryController<EC> & { collectionRegistryRef: React.MutableRefObject<CollectionRegistry> };
-
-};
-
-export type UseResolvedCollectionsResult = {
-    collections: AdminCollection[];
-    loading: boolean;
-    error: Error | undefined;
-    refresh: () => void;
-};
-
-/**
- * Hook that resolves collection props (which may be async builders or arrays)
- * into concrete AdminCollection[], and registers them with the CollectionRegistry.
- *
- * When userManagement is provided, the default users collection is always
- * prepended. Developer collections override via generic slug-based dedup
- * (Map keyed by slug, last-write-wins). No hardcoded string checks.
- *
- * Uses refs for potentially-unstable dependencies (driver, authController,
- * plugins) to avoid re-triggering effects when their object identity changes.
- */
-export function useResolvedCollections<EC extends AdminCollection, USER extends User>(
-    props: UseResolvedCollectionsProps<EC, USER>
-): UseResolvedCollectionsResult {
-
-    const {
-        authController,
-        collections: collectionsProp,
-        data,
-        plugins,
-        disabled,
-        collectionRegistryController
-    } = props;
-
-    // Stable identity string for the user — avoids re-triggering when the
-    // authController object reference changes but uid/roles are the same.
-    const userIdentity = authController.user
-        ? `${authController.user.uid}:${(authController.user.roles ?? []).sort().join(',')}`
-        : null;
-
-    // Use refs for values that may be new objects each render but shouldn't
-    // re-trigger the effect. The effect reads them at execution time.
-    const dataRef = useRef(data);
-    dataRef.current = data;
-    const authControllerRef = useRef(authController);
-    authControllerRef.current = authController;
-    const pluginsRef = useRef(plugins);
-    pluginsRef.current = plugins;
-
-    const { data: collections, loading, error, refresh } = useAsyncResolver<AdminCollection[]>({
-        resolver: async () => {
-            const resolved = await resolveCollections(
-                collectionsProp,
-                authControllerRef.current,
-                dataRef.current,
-                pluginsRef.current
-            );
-
-            const deduped = [...resolved];
-
-            // Register with the CollectionRegistry; returns true if changed
-            const changed = collectionRegistryController.collectionRegistryRef.current.registerMultiple(deduped);
-
-            if (changed) {
-                console.debug("Collections have changed", deduped);
-            }
-
-            return deduped;
-        },
-        initialValue: [],
-        isEqual: areCollectionListsEqual,
-        deps: [collectionsProp, userIdentity, disabled],
-        disabled: disabled || authController.initialLoading,
-    });
-
-    return useMemo(() => ({
-        collections,
-        loading,
-        error,
-        refresh
-    }), [collections, loading, error, refresh]);
-}

package/src/hooks/navigation/useResolvedViews.tsx

@@ -1,139 +0,0 @@
-
-import type { EffectiveRoleController } from "@rebasepro/types";
-import type { AppView, AppViewsBuilder, RebasePlugin } from "@rebasepro/cms-types";
-import { useMemo, useRef } from "react";
-
-/**
- * Compare two view arrays by their slug identity.
- * Returns true when the sets of slugs are identical (same order, same values).
- * This avoids deepEqual on React elements, which have unstable internal refs.
- */
-function viewSlugsEqual(a: AppView[] | undefined, b: AppView[] | undefined): boolean {
-    if (a === b) return true;
-    if (!a || !b) return false;
-    if (a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i].slug !== b[i].slug) return false;
-    }
-    return true;
-}
-
-import type { RebaseData, User } from "@rebasepro/types";
-import type { AuthController } from "@rebasepro/cms-types";
-
-import { resolveAppViews } from "./useNavigationResolution";
-import { useAsyncResolver } from "./useAsyncResolver";
-
-export type UseResolvedViewsProps<USER extends User> = {
-    authController: AuthController<USER>;
-    views?: AppView[] | AppViewsBuilder;
-    adminViews?: AppView[] | AppViewsBuilder;
-    data: RebaseData;
-    plugins?: RebasePlugin[];
-    adminMode?: "cms" | "studio" | "settings";
-    effectiveRoleController?: EffectiveRoleController;
-};
-
-export type UseResolvedViewsResult = {
-    views: AppView[] | undefined;
-    adminViews: AppView[] | undefined;
-    loading: boolean;
-    error: Error | undefined;
-    refresh: () => void;
-};
-
-/**
- * Combined result type for the async resolver — holds both views and
- * adminViews so they can be resolved together in a single async call.
- */
-type ResolvedViewsData = {
-    views: AppView[] | undefined;
-    adminViews: AppView[] | undefined;
-};
-
-/**
- * Equality check for the combined views data.
- * Compares both views and adminViews by slug identity.
- */
-function areResolvedViewsEqual(a: ResolvedViewsData, b: ResolvedViewsData): boolean {
-    return viewSlugsEqual(a.views, b.views) && viewSlugsEqual(a.adminViews, b.adminViews);
-}
-
-/**
- * Hook that resolves view and admin view props (which may be async builders or arrays)
- * into concrete AppView[].
- *
- * Uses refs for potentially-unstable dependencies (driver, authController,
- * plugins) to avoid re-triggering effects when their object identity changes.
- */
-export function useResolvedViews<USER extends User>(
-    props: UseResolvedViewsProps<USER>
-): UseResolvedViewsResult {
-
-    const {
-        authController,
-        views: viewsProp,
-        adminViews: adminViewsProp,
-        data,
-        plugins,
-        adminMode = "cms",
-        effectiveRoleController
-    } = props;
-
-    // Stable identity string for the user — avoids re-triggering when the
-    // authController object reference changes but uid/roles are the same.
-    const userIdentity = authController.user
-        ? `${authController.user.uid}:${(authController.user.roles ?? []).sort().join(',')}`
-        : null;
-
-    // Use refs for values that may be new objects each render but shouldn't
-    // re-trigger the effect. The effect reads them at execution time.
-    const dataRef = useRef(data);
-    dataRef.current = data;
-    const authControllerRef = useRef(authController);
-    authControllerRef.current = authController;
-    const pluginsRef = useRef(plugins);
-    pluginsRef.current = plugins;
-
-    // Build the resolved auth controller (with effective role override for studio mode)
-    const resolvedAuthController = useMemo(() => {
-        if (adminMode === "studio" && effectiveRoleController?.effectiveRole && authController.user) {
-            return {
-                ...authController,
-                user: {
-                    ...authController.user,
-                    roles: [effectiveRoleController.effectiveRole]
-                }
-            };
-        }
-        return authController;
-    }, [adminMode, effectiveRoleController?.effectiveRole, authController]);
-
-    // Store resolvedAuthController in a ref for effect access without re-triggering
-    const resolvedAuthControllerRef = useRef(resolvedAuthController);
-    resolvedAuthControllerRef.current = resolvedAuthController;
-
-    const initialLoading = resolvedAuthController.initialLoading;
-
-    const { data: resolvedData, loading, error, refresh } = useAsyncResolver<ResolvedViewsData>({
-        resolver: async () => {
-            const [newViews, newAdminViews] = await Promise.all([
-                resolveAppViews(viewsProp, resolvedAuthControllerRef.current, dataRef.current, pluginsRef.current),
-                resolveAppViews(adminViewsProp, resolvedAuthControllerRef.current, dataRef.current)
-            ]);
-            return { views: newViews, adminViews: newAdminViews };
-        },
-        initialValue: { views: undefined, adminViews: undefined },
-        isEqual: areResolvedViewsEqual,
-        deps: [viewsProp, adminViewsProp, adminMode, userIdentity],
-        disabled: initialLoading,
-    });
-
-    return useMemo(() => ({
-        views: resolvedData.views,
-        adminViews: resolvedData.adminViews,
-        loading,
-        error,
-        refresh
-    }), [resolvedData, loading, error, refresh]);
-}