adminizer 5.1.0-build.29 → 5.2.0-build.30

package/lib/app-manager/ContextHandler.js

@@ -0,0 +1,446 @@
+import { Adminizer } from "../Adminizer.js";
+import { filterAccessibleHrefItems, listAccessibleMenuItems, resolveMenuBadge } from "../../helpers/navigationAccessHelper.js";
+import { requirePermission } from "../../policies/authPolicies.js";
+export const DEFAULT_ADMIN_CONTEXT_ID = "default";
+const CONTEXT_COOKIE = "adminizer_context";
+/** Registry of layout contexts contributed by the host and by apps. */
+export class ContextHandler {
+    adminizer;
+    contexts = new Map();
+    assignments = new Set();
+    reportedMissing = new Set();
+    defaultOptions = {};
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+    }
+    /**
+     * Registers a context. The returned scope adds pages to it; they are
+     * registered as `owner`'s controllers.
+     */
+    register(context, owner = "host") {
+        const id = context.id?.trim();
+        if (!id || !context.title)
+            throw new Error("Admin context requires id and title");
+        if (id === DEFAULT_ADMIN_CONTEXT_ID)
+            throw new Error(`Admin context id "${id}" is reserved; use configureDefault()`);
+        if (this.contexts.has(id))
+            throw new Error(`Admin context "${id}" is already registered`);
+        const prefix = this.normalizePrefix(context.prefix);
+        if (!prefix)
+            throw new Error(`Admin context "${id}" requires a non-empty prefix`);
+        for (const other of this.contexts.values()) {
+            if (other.prefix === prefix)
+                throw new Error(`Admin context prefix "${prefix}" is already used by "${other.id}"`);
+        }
+        // Own copy: page() and menuItem() append to the items.
+        const navbar = typeof context.navbar === "object"
+            ? { ...context.navbar, items: [...(context.navbar.items ?? [])] }
+            : context.navbar;
+        this.contexts.set(id, { ...context, id, prefix, navbar, owner });
+        this.adminizer.emitter.emit("app:context:registered", { appName: owner, resourceId: `${owner}:${id}`, id, prefix });
+        return this.scope(id, {
+            controller: (controller) => this.adminizer.controllerHandler.register(owner, controller),
+            component: (url) => url,
+        });
+    }
+    unregister(id, owner) {
+        const record = this.contexts.get(id);
+        if (!record || (owner && record.owner !== owner))
+            return;
+        this.contexts.delete(id);
+        this.adminizer.emitter.emit("app:context:unregistered", { appName: record.owner, resourceId: `${record.owner}:${id}`, id });
+    }
+    /** A scope adding pages to a registered context through the given registrar. */
+    scope(id, registrar) {
+        return {
+            id,
+            page: (page) => this.addPage(id, page, registrar),
+            controller: (controller) => this.addController(id, controller, registrar),
+            menuItem: (item) => this.addMenuItem(id, item),
+        };
+    }
+    /** Overrides title, icon, layout or navbar of the built-in context. */
+    configureDefault(options) {
+        this.defaultOptions = { ...this.defaultOptions, ...options };
+    }
+    getDefault() {
+        return {
+            title: this.adminizer.menuHelper.getBrandTitle(),
+            ...this.defaultOptions,
+            id: DEFAULT_ADMIN_CONTEXT_ID,
+            prefix: "",
+        };
+    }
+    get(id) {
+        return id === DEFAULT_ADMIN_CONTEXT_ID ? this.getDefault() : this.contexts.get(id);
+    }
+    list() {
+        return [this.getDefault(), ...this.contexts.values()];
+    }
+    /** Contexts this user may enter, the default one first. */
+    async listAccessible(user) {
+        const accessible = [];
+        for (const context of this.list()) {
+            if (await this.isAccessible(context, user))
+                accessible.push(context);
+        }
+        return accessible;
+    }
+    /**
+     * Declares that the pages at `path` (below `routePrefix`, `:params`
+     * allowed) belong to a context: they render in it wherever the user came
+     * from, and only users who may enter the context may open them. Covers
+     * everything below `path` too unless `exact`. Returns a function removing
+     * the declaration.
+     */
+    assign(path, contextId, options = {}) {
+        const relative = this.normalizePrefix(path);
+        const assignment = {
+            contextId,
+            owner: options.owner ?? "host",
+            matcher: this.compilePattern(`${this.root()}${relative}`, options.exact ?? false),
+            specificity: this.specificity(relative),
+        };
+        this.assignments.add(assignment);
+        return () => {
+            this.assignments.delete(assignment);
+        };
+    }
+    /**
+     * The context the page at `url` is declared to belong to: by `assign()`,
+     * a controller's `context` or a model's `context`. The most specific
+     * declaration wins. Login, logout, registration and the first-user setup
+     * never belong to a context.
+     */
+    declaredFor(url) {
+        const path = this.normalizePath(url);
+        if (this.isAuthPath(path))
+            return undefined;
+        let best;
+        for (const assignment of this.assignments) {
+            if (assignment.matcher.test(path) && (!best || assignment.specificity > best.specificity))
+                best = assignment;
+        }
+        const model = this.modelDeclaration(path);
+        if (model && (!best || model.specificity > best.specificity))
+            best = model;
+        return best?.contextId;
+    }
+    /** True when the page at `url` belongs to a context this user may not enter. */
+    async isBlocked(url, user) {
+        const contextId = this.declaredFor(url);
+        if (contextId === undefined)
+            return false;
+        const context = this.get(contextId);
+        if (!context)
+            return true;
+        if (!this.adminizer.config.auth?.enable || !context.accessRightsToken)
+            return false;
+        return !user || !await this.isAccessible(context, user);
+    }
+    /**
+     * Blocks the pages declared to belong to a context the user may not
+     * enter, before any handler and for every method: not logged in — the
+     * login page (401 for API calls), no context token — 403, a context that
+     * is not registered (a typo, a disabled app) — 404. Pages without a
+     * declaration pass untouched.
+     */
+    guard() {
+        return (req, res, next) => {
+            const path = this.requestPath(req);
+            const contextId = this.declaredFor(path);
+            if (contextId === undefined)
+                return next();
+            const context = this.get(contextId);
+            const mode = this.isPageRequest(req) ? "ui" : "api";
+            if (!context) {
+                if (!this.reportedMissing.has(contextId)) {
+                    this.reportedMissing.add(contextId);
+                    Adminizer.log.error(`Layout context "${contextId}" is declared for ${path} but not registered; its pages answer 404`);
+                }
+                if (mode === "ui")
+                    return res.sendStatus(404);
+                return res.status(404).json({ error: req.i18n?.__("Not found") || "Not found" });
+            }
+            if (!context.accessRightsToken)
+                return next();
+            return requirePermission(context.accessRightsToken, { mode })(req, res, next);
+        };
+    }
+    /**
+     * The context a request belongs to.
+     *
+     * A page declared to belong to a context renders in it. A URL under a
+     * context prefix belongs to that context. Any other URL (the built-in
+     * `/model/...` pages, for one) stays in the context the user came from —
+     * remembered in a cookie — as long as that context's navbar links to it;
+     * otherwise it falls back to the default context.
+     */
+    async resolve(req) {
+        const path = this.requestPath(req);
+        const user = req.user;
+        const declared = this.declaredFor(path);
+        if (declared !== undefined) {
+            // A declared context the user may not enter never renders: guard() answers first.
+            const context = this.get(declared);
+            return context && user && await this.isAccessible(context, user) ? context : this.getDefault();
+        }
+        let byPrefix;
+        for (const context of this.contexts.values()) {
+            const full = this.fullPrefix(context);
+            if ((path === full || path.startsWith(`${full}/`)) && (!byPrefix || context.prefix.length > byPrefix.prefix.length)) {
+                byPrefix = context;
+            }
+        }
+        if (byPrefix) {
+            return user && await this.isAccessible(byPrefix, user) ? byPrefix : this.getDefault();
+        }
+        const remembered = this.contexts.get(this.readCookie(req) ?? "");
+        if (remembered && user && typeof remembered.navbar === "object"
+            && await this.isAccessible(remembered, user) && this.claims(remembered.navbar.items ?? [], path)) {
+            return remembered;
+        }
+        return this.getDefault();
+    }
+    /** Remembers the context of a page visit; see {@link resolve}. */
+    remember(req, res, context) {
+        if (req.method !== "GET" || (this.readCookie(req) ?? DEFAULT_ADMIN_CONTEXT_ID) === context.id)
+            return;
+        res.cookie(CONTEXT_COOKIE, context.id, { path: this.root() || "/", sameSite: "lax", httpOnly: true });
+    }
+    /** The untranslated menu of a context for this user. */
+    async listMenuItems(context, user) {
+        if (!context.navbar || context.navbar === "inherit") {
+            return context.id === DEFAULT_ADMIN_CONTEXT_ID
+                ? listAccessibleMenuItems(this.adminizer, user)
+                : this.listMenuItems(this.getDefault(), user);
+        }
+        const menu = [];
+        for (const item of context.navbar.items ?? []) {
+            if (await this.isBlocked(item.link, user))
+                continue;
+            const actions = await filterAccessibleHrefItems(this.adminizer, user, item.subItems ?? []);
+            const tokens = actions.map((action) => action.accessRightsToken).filter(Boolean);
+            if (item.accessRightsToken)
+                tokens.push(item.accessRightsToken);
+            if (!await this.adminizer.accessRightsHelper.checkAnyPermission(tokens, user))
+                continue;
+            menu.push({
+                id: item.id || item.title.replace(" ", "_"),
+                link: item.link,
+                title: item.title,
+                type: item.type,
+                actions: item.subItems ? actions : null,
+                icon: item.icon || null,
+                accessRightsToken: item.accessRightsToken || null,
+                section: item.section || context.title,
+                badge: await resolveMenuBadge(user, item.badge, item.id),
+            });
+        }
+        return menu;
+    }
+    getSections(context) {
+        if (typeof context.navbar === "object")
+            return { ...(context.navbar.sections ?? {}) };
+        return context.id === DEFAULT_ADMIN_CONTEXT_ID
+            ? this.adminizer.menuHelper.getSections()
+            : this.getSections(this.getDefault());
+    }
+    /**
+     * The layout of a context with inheritance from the default context
+     * applied. Layers always add up along the chain: a module over a parent
+     * keeps the parent's layers, whatever they replace.
+     */
+    resolveLayout(context) {
+        const stock = { root: "stock", layers: [], stylesheets: [] };
+        const parent = context.id === DEFAULT_ADMIN_CONTEXT_ID ? stock : this.resolveLayout(this.getDefault());
+        const layout = context.layout ?? "inherit";
+        if (layout === "inherit")
+            return parent;
+        if (layout === "stock" || layout === "default")
+            return stock;
+        if (layout === "none" || layout === "bare")
+            return { root: "none", layers: [], stylesheets: [] };
+        if ("component" in layout) {
+            // A whole layout of its own: nothing of the parent is drawn, as before.
+            return {
+                root: "stock",
+                layers: [{ module: layout.component, default: "Layout" }],
+                stylesheets: layout.stylesheet ? [layout.stylesheet] : [],
+            };
+        }
+        const module = "module" in layout ? layout.module : layout.overrides;
+        const base = "module" in layout && layout.base === "stock" ? stock : parent;
+        return {
+            root: base.root,
+            layers: [...base.layers, { module }],
+            stylesheets: layout.stylesheet ? [...base.stylesheets, layout.stylesheet] : base.stylesheets,
+        };
+    }
+    toProps(context) {
+        return {
+            id: context.id,
+            title: context.title,
+            icon: context.icon ?? null,
+            prefix: this.fullPrefix(context),
+            link: `${this.root()}${context.home ? this.normalizePrefix(context.home) : context.prefix}` || "/",
+            layout: this.resolveLayout(context),
+        };
+    }
+    addPage(id, page, registrar) {
+        const record = this.require(id);
+        if (!page.id || !page.title)
+            throw new Error(`A page of admin context "${id}" requires id and title`);
+        if ((page.component === undefined) === (page.middleware === undefined)) {
+            throw new Error(`Page "${page.id}" of admin context "${id}" requires either component or middleware`);
+        }
+        const menu = page.menu ?? record.navbar !== "inherit";
+        const moduleComponent = page.component === undefined ? undefined : registrar.component(page.component);
+        const link = this.addController(id, {
+            id: `context:${id}:page:${page.id}`,
+            method: page.method ?? "get",
+            path: page.path,
+            policies: page.policies,
+            middleware: page.middleware ?? this.renderPage(id, page, moduleComponent),
+        }, registrar);
+        const item = { id: page.id, title: page.title, link, type: "self" };
+        if (page.icon)
+            item.icon = page.icon;
+        if (page.section)
+            item.section = page.section;
+        if (page.badge !== undefined)
+            item.badge = page.badge;
+        if (page.accessRightsToken)
+            item.accessRightsToken = page.accessRightsToken;
+        if (menu)
+            this.addMenuItem(id, item);
+        return item;
+    }
+    addController(id, controller, registrar) {
+        const record = this.require(id);
+        const { path, policies, ...rest } = controller;
+        return registrar.controller({
+            ...rest,
+            route: `${record.prefix}${this.normalizePrefix(path)}`,
+            policies: policies ?? [{ type: "auth", mode: controller.method === "get" ? "ui" : "api" }],
+            context: id,
+        });
+    }
+    addMenuItem(id, item) {
+        const record = this.require(id);
+        if (record.navbar === "inherit") {
+            throw new Error(`Admin context "${id}" inherits its navbar; give it a navbar of its own to add "${item.id}"`);
+        }
+        record.navbar ??= { items: [] };
+        (record.navbar.items ??= []).push(item);
+    }
+    /** Renders a `component` page: the module page with context breadcrumbs. */
+    renderPage(id, page, moduleComponent) {
+        return async (req) => {
+            const context = this.require(id);
+            const props = typeof page.props === "function" ? await page.props(req) : page.props ?? {};
+            const contextTitle = req.i18n.__(context.title);
+            const title = req.i18n.__(page.title);
+            return req.Inertia.render({
+                component: "module",
+                props: {
+                    moduleComponent,
+                    title: `${title} · ${contextTitle}`,
+                    breadcrumbs: [{ title: contextTitle, href: this.fullPrefix(context) }, { title }],
+                    ...props,
+                },
+            });
+        };
+    }
+    require(id) {
+        const record = this.contexts.get(id);
+        if (!record)
+            throw new Error(`Admin context "${id}" is not registered`);
+        return record;
+    }
+    async isAccessible(context, user) {
+        return !context.accessRightsToken
+            || await this.adminizer.accessRightsHelper.checkPermission(context.accessRightsToken, user);
+    }
+    claims(items, path) {
+        return items.some((item) => {
+            const link = typeof item.link === "string" ? item.link.split(/[?#]/)[0].replace(/\/+$/, "") : "";
+            return (link.startsWith("/") && (path === link || path.startsWith(`${link}/`)))
+                || this.claims(item.subItems ?? [], path);
+        });
+    }
+    /** A model page `/model/<name>/...` of a model whose config declares a context. */
+    modelDeclaration(path) {
+        const prefix = `${this.root()}/model/`;
+        if (!path.startsWith(prefix))
+            return undefined;
+        let name;
+        try {
+            name = decodeURIComponent(path.slice(prefix.length).split("/")[0]);
+        }
+        catch {
+            return undefined;
+        }
+        const contextId = name ? this.findModelConfig(name)?.context : undefined;
+        return contextId ? { contextId, specificity: this.specificity(`/model/${name}`) } : undefined;
+    }
+    /** Model config by resource name, matched the way the model routes match it. */
+    findModelConfig(name) {
+        const models = this.adminizer.config.models ?? {};
+        const key = Object.prototype.hasOwnProperty.call(models, name)
+            ? name
+            : (() => {
+                const keys = Object.keys(models).filter((candidate) => candidate.toLowerCase() === name.toLowerCase());
+                return keys.length === 1 ? keys[0] : undefined;
+            })();
+        const config = key ? models[key] : undefined;
+        return config && typeof config === "object" ? config : undefined;
+    }
+    isAuthPath(path) {
+        const root = this.root();
+        if (path === `${root}/init_user` || path.startsWith(`${root}/init_user/`))
+            return true;
+        if (!path.startsWith(`${root}/model/`))
+            return false;
+        const action = path.slice(root.length + "/model/".length).split("/")[1];
+        return action === "login" || action === "logout" || action === "register";
+    }
+    /** A route pattern as a regexp: `:param`, `*splat` and `{optional}` parts of Express routes. */
+    compilePattern(pattern, exact) {
+        const source = pattern
+            .replace(/[.+?^$()|[\]\\]/g, "\\$&")
+            .replace(/:[A-Za-z0-9_]+/g, "[^/]+")
+            .replace(/\*[A-Za-z0-9_]*/g, ".+")
+            .replace(/\{/g, "(?:")
+            .replace(/\}/g, ")?");
+        return new RegExp(`^${source}${exact ? "" : "(?:/.*)?"}$`);
+    }
+    /** Static segments weigh more than parameters. */
+    specificity(relativePath) {
+        return relativePath.split("/").filter(Boolean)
+            .reduce((score, segment) => score + (/^[:*]/.test(segment) ? 1 : 2), 0);
+    }
+    isPageRequest(req) {
+        return req.headers["x-inertia"] !== undefined || (req.headers.accept ?? "").includes("text/html");
+    }
+    root() {
+        return (this.adminizer.config.routePrefix || "").replace(/\/+$/, "");
+    }
+    fullPrefix(context) {
+        return `${this.root()}${context.prefix}`;
+    }
+    normalizePrefix(prefix) {
+        const trimmed = (prefix ?? "").trim().replace(/\/+$/, "");
+        return trimmed && !trimmed.startsWith("/") ? `/${trimmed}` : trimmed;
+    }
+    normalizePath(url) {
+        return (url || "").split(/[?#]/)[0].replace(/\/+$/, "");
+    }
+    requestPath(req) {
+        return this.normalizePath(req.originalUrl || req.url || "");
+    }
+    readCookie(req) {
+        const value = req.cookies?.[CONTEXT_COOKIE];
+        return typeof value === "string" ? value : undefined;
+    }
+}

package/lib/app-manager/ControllerHandler.d.ts

@@ -6,6 +6,8 @@ interface ControllerRecord {
     method: AppControllerMethod;
     path: string;
     enabled: boolean;
+    /** Removes the route's layout context declaration. */
+    unassign?: () => void;
 }
 export declare class ControllerHandler {
     private adminizer;

package/lib/app-manager/ControllerHandler.js

@@ -19,6 +19,12 @@ export class ControllerHandler {
             path: fullPath,
             enabled: true,
         };
+        if (controller.context) {
+            record.unassign = this.adminizer.contextHandler.assign(controller.route, controller.context, {
+                owner: appName,
+                exact: true,
+            });
+        }
         const middleware = bindWithMiddlewares(this.adminizer, this.adminizer.config.middlewares ?? [], (req, res, next) => {
             if (!record.enabled) {
                 return next();
@@ -69,6 +75,7 @@ export class ControllerHandler {
             return;
         }
         this.removeRoute(record.path, record.method);
+        record.unassign?.();
         this.controllers.delete(id);
         this.adminizer.emitter.emit("app:controller:unregistered", {
             appName: record.appName,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "5.1.0-build.29",
+  "version": "5.2.0-build.30",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
@@ -30,7 +30,8 @@
     "build": "npm run copy:backend && npm run compile:backend && npm run compile:ui && npm run build:assets",
     "build:catalog-modules": "cross-env CATALOG_COMPONENT=catalogAction vite build --config fixture/virtual-catalog/vite.config.module.ts && cross-env CATALOG_COMPONENT=Group vite build --config fixture/virtual-catalog/vite.config.module.ts",
     "start:typeorm:seed": "cross-env ORM=typeorm tsx --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
-    "build:apps": "vite build --config fixture/apps/notification-sender/vite.config.module.ts && vite build --config fixture/apps/module-manager/vite.config.module.ts && vite build --config fixture/apps/navigation/vite.config.module.ts && vite build --config fixture/apps/quill-editor/vite.config.module.ts && vite build --config fixture/apps/widgets/vite.config.module.ts && vite build --config fixture/apps/handsontable-test/vite.config.module.ts && vite build --config fixture/apps/record-scope-test/vite.config.module.ts && npm run build:catalog-modules",
+    "build:context-apps": "cross-env CONTEXT_ENTRY=ContextDemoPage vite build --config fixture/apps/contexts/vite.config.module.ts && cross-env CONTEXT_ENTRY=SupportLayout vite build --config fixture/apps/contexts/vite.config.module.ts && cross-env CONTEXT_ENTRY=StudioLayout vite build --config fixture/apps/contexts/vite.config.module.ts && cross-env CONTEXT_ENTRY=DefaultShellOverrides vite build --config fixture/apps/contexts/vite.config.module.ts && cross-env CONTEXT_ENTRY=SystemShellOverrides vite build --config fixture/apps/contexts/vite.config.module.ts && cross-env CONTEXT_ENTRY=ReportsShellOverrides vite build --config fixture/apps/contexts/vite.config.module.ts",
+    "build:apps": "npm run build:context-apps && vite build --config fixture/apps/notification-sender/vite.config.module.ts && vite build --config fixture/apps/module-manager/vite.config.module.ts && vite build --config fixture/apps/navigation/vite.config.module.ts && vite build --config fixture/apps/quill-editor/vite.config.module.ts && vite build --config fixture/apps/widgets/vite.config.module.ts && vite build --config fixture/apps/handsontable-test/vite.config.module.ts && vite build --config fixture/apps/record-scope-test/vite.config.module.ts && npm run build:catalog-modules",
     "build:ai-assistant": "vite build --config vite.config.ai-assistant.ts",
     "lint": "eslint src",
     "lint:async": "eslint src -c eslint.config.async.mjs"

package/system/bindInertia.js

@@ -132,7 +132,7 @@ export function bindInertia(adminizer) {
             headerName: 'x-xsrf-token'
         }
     }));
-    adminizer.app.use(async (req, _, next) => {
+    adminizer.app.use(async (req, res, next) => {
         checkAuth(req, adminizer);
         const defaultLocale = typeof req.adminizer.config.translation !== "boolean"
             ? req.adminizer.config.translation.defaultLocale
@@ -143,13 +143,30 @@ export function bindInertia(adminizer) {
             lang: locale,
         });
         const menuHelper = new InertiaMenuHelper(adminizer);
-        // Contextual documentation of this page: metadata only, and null when
-        // the subsystem is off or the user may not read documentation.
-        // A broken implementation must never take the panel down with it.
-        const menu = req.user ? await menuHelper.getMenuItems(req) : null;
+        // The layout context of the request decides which menu and which
+        // layout the page gets; the default context reproduces the plain panel.
+        // Context, menu and switcher are computed once, and only when a page
+        // is rendered: API calls and partial reloads that skip them pay nothing.
+        let resolvedContext;
+        const resolveContext = () => resolvedContext ??= (async () => {
+            const context = await adminizer.contextHandler.resolve(req);
+            const contexts = req.user ? await adminizer.contextHandler.listAccessible(req.user) : [];
+            // Only page visits move the user between contexts: a rendered page
+            // asked for by the browser, never an asset or an API call.
+            const isPageVisit = req.headers["x-inertia"] !== undefined || (req.headers.accept ?? "").includes("text/html");
+            if (req.user && contexts.length > 1 && isPageVisit)
+                adminizer.contextHandler.remember(req, res, context);
+            return { context, contexts };
+        })();
+        let resolvedMenu;
+        const resolveMenu = () => resolvedMenu ??= (async () => req.user ? menuHelper.getMenuItems(req, (await resolveContext()).context) : null)();
+        const contextProps = (context) => adminizer.contextHandler.toProps({ ...context, title: req.i18n.__(context.title) });
         const historyAccess = req.user && req.adminizer.config.history.enabled
             ? await req.adminizer.accessRightsHelper.checkPermission(`history-${req.adminizer.config.history?.adapter ?? 'default'}`, req.user)
             : false;
+        // Contextual documentation of this page: metadata only, and null when
+        // the subsystem is off or the user may not read documentation.
+        // A broken implementation must never take the panel down with it.
         let docs = null;
         try {
             docs = req.user ? await adminizer.documentationHandler.forContextMeta(req.user, req.path) : null;
@@ -166,16 +183,21 @@ export function bindInertia(adminizer) {
                 locale,
                 common: commonMessages,
             },
-            menu,
-            menuSections: req.user ? menuHelper.getSections(req) : null,
+            menu: resolveMenu,
+            menuSections: async () => req.user ? menuHelper.getSections(req, (await resolveContext()).context) : null,
+            adminContext: async () => contextProps((await resolveContext()).context),
+            adminContexts: async () => (await resolveContext()).contexts
+                .filter((item) => item.switcher !== false)
+                .map(contextProps),
             // Auto breadcrumbs. A function prop is evaluated by the Inertia
             // adapter only when the key is rendered and only when the page did
             // not send `breadcrumbs` of its own — page props override shared
             // props before evaluation.
-            ...(menu && adminizer.config.navbar?.breadcrumbs === 'auto' ? {
+            ...(req.user && adminizer.config.navbar?.breadcrumbs === 'auto' ? {
                 breadcrumbs: async () => {
                     try {
-                        const crumbs = await adminizer.adminLinkHandler.locate(req.user, req.originalUrl || req.url, menu);
+                        const menu = await resolveMenu();
+                        const crumbs = await adminizer.adminLinkHandler.locate(req.user, req.originalUrl || req.url, menu ?? undefined);
                         return crumbs.map((crumb) => ({ ...crumb, title: req.i18n.__(crumb.title) }));
                     }
                     catch (error) {
@@ -224,6 +246,9 @@ export function bindInertia(adminizer) {
         });
         next();
     });
+    // Pages declared to belong to a layout context the user may not enter are
+    // blocked here, before any route; `req.user` is known by now.
+    adminizer.app.use(adminizer.contextHandler.guard());
 }
 function checkAuth(req, adminizer) {
     let locale = "";