adminizer 5.0.0-build.8 → 5.1.0-build.24

package/helpers/assetVersionHelper.js

@@ -0,0 +1,42 @@
+import fs from "fs";
+import path from "node:path";
+let cachedVersion = null;
+/**
+ * Adminizer package version. Some built entries keep stable file names because
+ * they are imported by a hard-coded path and so cannot be looked up in the
+ * manifest (agent.es.js, controls/*.es.js and controls/*.css); for those this
+ * version is appended as a query string to invalidate browser caches on release.
+ *
+ * Only ever put this on a *self-contained* bundle. An entry whose split chunks
+ * import it back by name (app.js) must be content-hashed instead — a query
+ * string there makes the browser instantiate the module twice.
+ */
+export function getAssetVersion() {
+    if (cachedVersion !== null) {
+        return cachedVersion;
+    }
+    let version = "";
+    // Compiled sources sit one level below the package root in the published
+    // package (helpers/) and two below it in the repo (dist/helpers/).
+    for (const candidate of ["../package.json", "../../package.json"]) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.resolve(import.meta.dirname, candidate), "utf-8"));
+            if (pkg?.name === "adminizer" && typeof pkg.version === "string") {
+                version = pkg.version;
+                break;
+            }
+        }
+        catch {
+            // Missing or unreadable package.json: try the next candidate.
+        }
+    }
+    cachedVersion = version;
+    return version;
+}
+export function withAssetVersion(url) {
+    const version = getAssetVersion();
+    if (!url || !version || process.env.ADMINIZER_ENV === "dev") {
+        return url;
+    }
+    return `${url}${url.includes("?") ? "&" : "?"}v=${version}`;
+}

package/helpers/configHelper.js

@@ -34,23 +34,17 @@ export class ConfigHelper {
         if (!modelName) {
             throw new Error("Model name is not defined");
         }
-        let config = this.adminizer.config;
-        let modelConfig;
-        Object.keys(config.models).forEach((modelResourceName) => {
-            const model = config.models[modelResourceName];
-            if (typeof model !== "boolean") {
-                if (model.model === modelName.toLowerCase()) {
-                    if (typeof config.models[modelResourceName] !== "boolean") {
-                        modelConfig = config.models[modelResourceName];
-                    }
-                }
-            }
-        });
+        const resourceName = this.adminizer.modelHandler.getResourceRecord(modelName)?.name
+            ?? this.adminizer.modelHandler.resolveResourceByHostModel(modelName);
+        const modelConfig = resourceName && typeof this.adminizer.config.models[resourceName] !== "boolean"
+            ? this.adminizer.config.models[resourceName]
+            : undefined;
+        const model = resourceName ? this.adminizer.modelHandler.getResource(resourceName) : undefined;
         if (modelConfig && modelConfig.identifierField) {
             return modelConfig.identifierField;
         }
-        else if (this.adminizer.modelHandler.model.get(modelName.toLowerCase()).primaryKey) {
-            return this.adminizer.modelHandler.model.get(modelName.toLowerCase()).primaryKey;
+        else if (model?.primaryKey) {
+            return model.primaryKey;
         }
         else {
             throw new Error("ConfigHelper > Identifier field was not found");
@@ -87,12 +81,13 @@ export class ConfigHelper {
             let displayField;
             try {
                 const associatedModelName = config.type === "association"
-                    ? modelField.model?.toLowerCase()
-                    : modelField.collection?.toLowerCase();
+                    ? modelField.model
+                    : modelField.collection;
                 if (!associatedModelName) {
                     throw new Error(`No model/collection defined for association field: ${key}`);
                 }
-                const associatedModel = adminizer.modelHandler.model.get(associatedModelName);
+                const resourceName = adminizer.modelHandler.resolveAssociationResource(associatedModelName, modelField.resourceName);
+                const associatedModel = resourceName ? adminizer.modelHandler.getResource(resourceName) : undefined;
                 if (!associatedModel) {
                     throw new Error(`Can not add relations to unloaded models; Config: ${JSON.stringify(config, null, 2)}`);
                 }
@@ -139,7 +134,13 @@ export class ConfigHelper {
                 additionalLinks: [
                     ...builtinLinks,
                     ...(config.navbar?.additionalLinks || [])
-                ]
+                ],
+                // Merged per section name so an app declaring its own sections
+                // keeps the built-in ones, while still being able to override them.
+                sections: {
+                    ...defaultConfig.navbar?.sections,
+                    ...config.navbar?.sections
+                }
             }
         };
         // Normalize auth config if it's a boolean

package/helpers/controllerHelper.d.ts

@@ -51,6 +51,7 @@ export declare class ControllerHelper {
      * @returns {?string}
      */
     static findModelResourceName(req: ReqType): string;
+    private static resolveConfiguredResourceName;
     /**
      * Searches for config from admin panel
      *

package/helpers/controllerHelper.js

@@ -89,19 +89,27 @@ export class ControllerHelper {
      * @returns {?string}
      */
     static findModelResourceName(req) {
-        if (req.params.modelResourceName) {
-            return req.params.modelResourceName;
+        const models = req.adminizer.config.models;
+        const requestedName = req.params.modelResourceName
+            ?? req.params.model
+            ?? req.originalUrl.split('/')[3];
+        return this.resolveConfiguredResourceName(models, requestedName);
+    }
+    static resolveConfiguredResourceName(models, requestedName) {
+        if (!models || !requestedName) {
+            throw new Error(`Model "${requestedName}" not found`);
         }
-        if (req.params.model) {
-            return req.params.model;
+        if (Object.prototype.hasOwnProperty.call(models, requestedName)) {
+            return requestedName;
         }
-        const urlParts = req.originalUrl.split('/');
-        const modelResourceName = urlParts[3];
-        const models = req.adminizer.config.models;
-        if (!models || !Object.keys(models).some(key => key.toLowerCase() === modelResourceName.toLowerCase())) {
-            throw new Error(`Model "${modelResourceName}" not found`);
+        const candidates = Object.keys(models).filter((key) => key.toLowerCase() === requestedName.toLowerCase());
+        if (candidates.length === 1) {
+            return candidates[0];
+        }
+        if (candidates.length > 1) {
+            throw new Error(`Model resource "${requestedName}" is ambiguous: ${candidates.join(", ")}`);
         }
-        return Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
+        throw new Error(`Model "${requestedName}" not found`);
     }
     /**
      * Searches for config from admin panel
@@ -116,12 +124,14 @@ export class ControllerHelper {
             Adminizer.log.error('No models configuration found');
             return null;
         }
-        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
-        if (!foundKey) {
-            Adminizer.log.error(`No such route exists: ${modelResourceName}`);
+        try {
+            const foundKey = this.resolveConfiguredResourceName(models, modelResourceName);
+            return this._normalizeModelConfig(foundKey, models[foundKey]);
+        }
+        catch (error) {
+            Adminizer.log.error(error);
             return null;
         }
-        return this._normalizeModelConfig(foundKey, models[foundKey]);
     }
     /**
      * Will get action config from configuration file depending to given action
@@ -197,7 +207,7 @@ export class ControllerHelper {
         modelResource.config = this.findModelConfig(req, modelResourceName);
         // Find and add the model itself to the ModelResource
         if (this._isValidModelConfig(modelResource.config)) {
-            modelResource.model = req.adminizer.modelHandler.model.get(modelResource.config.model);
+            modelResource.model = req.adminizer.modelHandler.getResource(modelResourceName);
         }
         // Return the completed ModelResource object
         return modelResource;

package/helpers/fieldsHelper.d.ts

@@ -1,5 +1,6 @@
 import { ActionType, BaseFieldConfig, FieldsTypes, ModelConfig } from "../interfaces/adminpanelConfig.js";
 import { Attribute } from "../lib/model/AbstractModel.js";
+import { RecordAccessCache } from "../lib/access-graph/RecordAccessCache.js";
 export type Field = {
     config: BaseFieldConfig & {
         /** @deprecated record should not be in config anymore */
@@ -30,5 +31,5 @@ export declare class FieldsHelper {
      * @param action
      * @deprecated this method has overload association tree on each request that is not optimize
      */
-    static loadAssociations(req: ReqType, fields: Fields, action?: ActionType): Promise<Fields>;
+    static loadAssociations(req: ReqType, fields: Fields, action?: ActionType, recordAccessCache?: RecordAccessCache): Promise<Fields>;
 }

package/helpers/fieldsHelper.js

@@ -1,4 +1,5 @@
 import { DataAccessor } from "../lib/DataAccessor.js";
+import { RecordAccessCache } from "../lib/access-graph/RecordAccessCache.js";
 import { Adminizer } from "../lib/Adminizer.js";
 export class FieldsHelper {
     /**
@@ -11,7 +12,11 @@ export class FieldsHelper {
      * @deprecated this method has overload association tree on each request that is not optimize
      */
     // TODO: make separate request for all dropdown relations by api call
-    static async loadAssociations(req, fields, action) {
+    static async loadAssociations(req, fields, action, recordAccessCache = new RecordAccessCache()) {
+        // `getFieldsConfig()` returns undefined when the user has no rights on the model at all
+        if (!fields) {
+            return {};
+        }
         /**
          * Load all associated records for given field key
          *
@@ -30,9 +35,9 @@ export class FieldsHelper {
                 Adminizer.log.error('No model found for field: ', fields[key]);
                 return;
             }
-            const resolvedModelName = req.adminizer.modelHandler.resolveModelName(modelName);
-            let Model = req.adminizer.modelHandler.model.get(resolvedModelName);
-            if (!Model) {
+            const resolvedModelName = req.adminizer.modelHandler.resolveAssociationResource(modelName, fields[key].model.resourceName);
+            let Model = resolvedModelName ? req.adminizer.modelHandler.getResource(resolvedModelName) : undefined;
+            if (!Model || !resolvedModelName) {
                 return;
             }
             let list;
@@ -46,7 +51,8 @@ export class FieldsHelper {
                     model: Model,
                     uri: `${req.adminizer.config.routePrefix}/model/${resolvedModelName}`
                 };
-                let dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "view");
+                // One cache for every dropdown of the page: the record-access lookups are identical
+                let dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "view", recordAccessCache);
                 list = await Model.find({}, dataAccessor);
             }
             catch (e) {

package/helpers/inertiaActionsHelper.d.ts

@@ -7,4 +7,4 @@ export interface Actions {
     title: string;
     icon: string;
 }
-export default function inertiaActionsHelper(actionType: ActionType, modelResource: ModelResource, req: ReqType): Actions[];
+export default function inertiaActionsHelper(actionType: ActionType, modelResource: ModelResource, req: ReqType): Promise<Actions[]>;

package/helpers/inertiaActionsHelper.js

@@ -1,11 +1,10 @@
-export default function inertiaActionsHelper(actionType, modelResource, req) {
+export default async function inertiaActionsHelper(actionType, modelResource, req) {
     let resActions = [];
     if (req.adminizer.menuHelper.hasGlobalActions(modelResource.config, actionType)) {
         const actions = req.adminizer.menuHelper.getGlobalActions(modelResource.config, actionType);
         if (actions && actions.length > 0) {
-            actions.forEach(function (action) {
-                const context = `global action "${action.title}" (${action.id}) on model "${modelResource.name}"`;
-                if (req.adminizer.accessRightsHelper.hasPermission(action.accessRightsToken, req.user, context)) {
+            for (const action of actions) {
+                if (await req.adminizer.accessRightsHelper.hasPermission(action.accessRightsToken, req.user)) {
                     resActions.push({
                         link: action.link,
                         id: action.id,
@@ -14,7 +13,7 @@ export default function inertiaActionsHelper(actionType, modelResource, req) {
                         icon: action.icon
                     });
                 }
-            });
+            }
         }
     }
     return resActions;

package/helpers/inertiaAddHelper.d.ts

@@ -23,7 +23,7 @@ interface FieldProps extends Record<string | number | symbol, unknown> {
     postLink: string;
     model: string;
 }
-export default function inertiaAddHelper(req: ReqType, modelResource: ModelResource, fields: Fields, record?: Record<string, string | boolean | number | string[]>, view?: boolean): FieldProps;
+export default function inertiaAddHelper(req: ReqType, modelResource: ModelResource, fields: Fields, record?: Record<string, string | boolean | number | string[]>, view?: boolean): Promise<FieldProps>;
 export declare function getControlsOptions(fieldConfig: Field["config"], req: ReqType, type: ControlType, defaultControlName: string, context?: string): {
     name: string;
     config: any;

package/helpers/inertiaAddHelper.js

@@ -1,5 +1,6 @@
 import inertiaActionsHelper from "./inertiaActionsHelper.js";
 import { isObject } from "./JsUtils.js";
+import { withAssetVersion } from "./assetVersionHelper.js";
 import { Adminizer } from "../lib/Adminizer.js";
 const missingControlWarnings = new Set();
 /**
@@ -14,7 +15,7 @@ function getWeekNumber(date) {
     const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
     return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
 }
-export default function inertiaAddHelper(req, modelResource, fields, record, view = false) {
+export default async function inertiaAddHelper(req, modelResource, fields, record, view = false) {
     const actionType = 'add';
     let props = {
         edit: !!record,
@@ -36,7 +37,7 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
         postLink: record ? `${modelResource.uri}/edit/${record.id}` : `${modelResource.uri}/add`,
         model: modelResource.name.toLocaleLowerCase()
     };
-    props.actions = inertiaActionsHelper(actionType, modelResource, req);
+    props.actions = await inertiaActionsHelper(actionType, modelResource, req);
     const config = req.adminizer.configHelper.getConfig();
     for (const key of Object.keys(fields)) {
         if ((!config.showORMtime) && (key === 'createdAt' || key === 'updatedAt'))
@@ -62,7 +63,7 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
         let canCreateRelated = false;
         const controlContext = `${modelResource.name}.${key}`;
         //@ts-ignore TODO: fix field type
-        if (modelResource.config.model && req.adminizer.configHelper.isId(field, modelResource.config.model)) {
+        if (req.adminizer.configHelper.isId(field, modelResource.name)) {
             disabled = true;
         }
         if (['string', 'password', 'date', 'datetime', 'time', 'integer', 'number', 'float', 'email', 'month', 'week', 'range'].includes(type)) {
@@ -118,7 +119,7 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
                 ? req.adminizer.modelHandler.resolveModelName(rawRelatedModel)
                 : undefined;
             if (relatedModel && req.user) {
-                canCreateRelated = req.adminizer.accessRightsHelper.hasPermission(`create-${relatedModel}-model`, req.user);
+                canCreateRelated = await req.adminizer.accessRightsHelper.hasPermission(`create-${relatedModel}-model`, req.user);
             }
             else if (relatedModel && !req.adminizer.config.auth?.enable) {
                 canCreateRelated = true;
@@ -195,8 +196,8 @@ export function getControlsOptions(fieldConfig, req, type, defaultControlName, c
             ...(control?.getConfig() || {}), // Base config of the editor
             ...(shouldUseFieldConfig ? fieldOptions?.config || {} : {}),
         },
-        path: control.getJsPath(),
-        cssPath: control.getCssPath(),
+        path: withAssetVersion(control.getJsPath()),
+        cssPath: withAssetVersion(control.getCssPath()),
     };
     // If items are provided, use them instead of the CKEditor defaults.
     if (type === 'wysiwyg'

package/helpers/inertiaGroupHelper.js

@@ -1,3 +1,4 @@
+import { parseGroupPermissionGrant } from "./accessRightsHelper.js";
 export function inertiaGroupHelper(modelResource, req, users, groupedTokens, group, view = false) {
     let props = {
         edit: !!group,
@@ -55,8 +56,15 @@ export function inertiaGroupHelper(modelResource, req, users, groupedTokens, gro
                     label: token.name,
                     tooltip: token.description,
                     name: `token-checkbox-${token.id}`,
-                    value: group ? (group.tokens && group.tokens?.includes(token.id)) : false,
-                    type: 'checkbox'
+                    value: group ? Boolean(group.tokens?.some((value) => value === token.id || parseGroupPermissionGrant(value)?.tokenId === token.id)) : false,
+                    type: 'checkbox',
+                    options: token.getOptions ? {
+                        permissionOptions: {
+                            rights: group?.tokens
+                                ?.map(parseGroupPermissionGrant)
+                                .find((value) => value?.tokenId === token.id)?.rights ?? [],
+                        },
+                    } : undefined,
                 });
             }
             props.groupedTokens.push({

package/helpers/inertiaListHelper.d.ts

@@ -28,5 +28,5 @@ interface listProps extends Record<string | number | symbol, unknown> {
     defaultPageSize: number;
     pageSizeOptions: number[];
 }
-export declare function inertiaListHelper(modelResource: ModelResource, req: ReqType, fields: Fields, activeFilterName?: string): listProps;
+export declare function inertiaListHelper(modelResource: ModelResource, req: ReqType, fields: Fields, activeFilterName?: string): Promise<listProps>;
 export {};

package/helpers/inertiaListHelper.js

@@ -1,5 +1,5 @@
 import inertiaActionsHelper from "./inertiaActionsHelper.js";
-export function inertiaListHelper(modelResource, req, fields, activeFilterName) {
+export async function inertiaListHelper(modelResource, req, fields, activeFilterName) {
     const actionType = 'list';
     // Check if filters are enabled for this model
     // Preferred: model-level `models.<Model>.filters`; fallback: legacy top-level `modelFilters.<Model>`
@@ -31,23 +31,22 @@ export function inertiaListHelper(modelResource, req, fields, activeFilterName)
         defaultPageSize: req.adminizer.config.list?.defaultPageSize ?? 50,
         pageSizeOptions: [5, 20, 50],
     };
-    if (modelResource.config.add && req.adminizer.accessRightsHelper.hasPermission(`create-${modelResource.name}-model`, req.user, `CRUD create on model "${modelResource.name}"`)) {
+    if (modelResource.config.add && await req.adminizer.accessRightsHelper.hasPermission(`create-${modelResource.name}-model`, req.user)) {
         props.crudActions.createTitle = req.i18n.__('create');
     }
-    if (modelResource.config.edit && req.adminizer.accessRightsHelper.hasPermission(`update-${modelResource.name}-model`, req.user, `CRUD update on model "${modelResource.name}"`)) {
+    if (modelResource.config.edit && await req.adminizer.accessRightsHelper.hasPermission(`update-${modelResource.name}-model`, req.user)) {
         props.crudActions.editTitle = req.i18n.__('Edit');
     }
-    if (modelResource.config.view && req.adminizer.accessRightsHelper.hasPermission(`read-${modelResource.name}-model`, req.user, `CRUD read on model "${modelResource.name}"`)) {
+    if (modelResource.config.view && await req.adminizer.accessRightsHelper.hasPermission(`read-${modelResource.name}-model`, req.user)) {
         props.crudActions.viewsTitle = req.i18n.__('View');
     }
-    if (modelResource.config.remove && req.adminizer.accessRightsHelper.hasPermission(`delete-${modelResource.name}-model`, req.user, `CRUD delete on model "${modelResource.name}"`)) {
+    if (modelResource.config.remove && await req.adminizer.accessRightsHelper.hasPermission(`delete-${modelResource.name}-model`, req.user)) {
         props.crudActions.deleteTitle = req.i18n.__('Delete');
     }
-    props.actions = inertiaActionsHelper(actionType, modelResource, req);
+    props.actions = await inertiaActionsHelper(actionType, modelResource, req);
     if (req.adminizer.menuHelper.hasInlineActions(modelResource.config, 'list')) {
         for (const inlineAction of req.adminizer.menuHelper.getInlineActions(modelResource.config, 'list')) {
-            const context = `inline action "${inlineAction.title}" (${inlineAction.id}) on model "${modelResource.name}"`;
-            if (req.adminizer.accessRightsHelper.hasPermission(inlineAction.accessRightsToken, req.user, context)) {
+            if (await req.adminizer.accessRightsHelper.hasPermission(inlineAction.accessRightsToken, req.user)) {
                 props.inlineActions.push({
                     icon: inlineAction.icon,
                     id: inlineAction.id,

package/helpers/inertiaMenuHelper.d.ts

@@ -1,12 +1,17 @@
 import { Adminizer } from "../lib/Adminizer.js";
+import { NavbarSectionConfig } from "../interfaces/adminpanelConfig.js";
 import { MenuItem } from "./menuHelper.js";
 export declare class InertiaMenuHelper {
     private adminizer;
     constructor(adminizer: Adminizer);
-    getMenuItems(req: ReqType): MenuItem[];
-    private filterAccessibleItems;
+    getMenuItems(req: ReqType): Promise<MenuItem[]>;
     private translateMenuItem;
     private translateHrefItem;
+    /**
+     * Navbar section metadata keyed by the *translated* section name, so the UI
+     * can look it up with the already-translated `section` of a menu item.
+     */
+    getSections(req: ReqType): Record<string, NavbarSectionConfig>;
     getBrandTitle(): string;
     getLogoutUrl(): string;
 }

package/helpers/inertiaMenuHelper.js

@@ -1,35 +1,12 @@
+import { listAccessibleMenuItems } from "./navigationAccessHelper.js";
 export class InertiaMenuHelper {
     adminizer;
     constructor(adminizer) {
         this.adminizer = adminizer;
     }
-    getMenuItems(req) {
-        const menu = [];
-        for (const menuItem of this.adminizer.menuHelper.getMenuItems(req.user)) {
-            const filteredActions = this.filterAccessibleItems(menuItem.actions ?? [], req);
-            const menuItemTokens = filteredActions.map(item => {
-                return item.accessRightsToken;
-            }).filter(item => {
-                return item;
-            });
-            if (menuItem.accessRightsToken)
-                menuItemTokens.push(menuItem.accessRightsToken);
-            if (this.adminizer.accessRightsHelper.enoughPermissions(menuItemTokens, req.user)) {
-                menu.push(this.translateMenuItem(req, {
-                    ...menuItem,
-                    actions: filteredActions
-                }));
-            }
-        }
-        return menu;
-    }
-    filterAccessibleItems(items, req) {
-        return items
-            .filter((item) => !item.accessRightsToken || this.adminizer.accessRightsHelper.hasPermission(item.accessRightsToken, req.user))
-            .map((item) => ({
-            ...item,
-            subItems: item.subItems ? this.filterAccessibleItems(item.subItems, req) : item.subItems
-        }));
+    async getMenuItems(req) {
+        return (await listAccessibleMenuItems(this.adminizer, req.user))
+            .map((menuItem) => this.translateMenuItem(req, menuItem));
     }
     translateMenuItem(req, menuItem) {
         return {
@@ -47,6 +24,14 @@ export class InertiaMenuHelper {
             subItems: item.subItems?.map((subItem) => this.translateHrefItem(req, subItem)),
         };
     }
+    /**
+     * Navbar section metadata keyed by the *translated* section name, so the UI
+     * can look it up with the already-translated `section` of a menu item.
+     */
+    getSections(req) {
+        const sections = this.adminizer.menuHelper.getSections();
+        return Object.fromEntries(Object.entries(sections).map(([name, section]) => [req.i18n.__(name), section]));
+    }
     getBrandTitle() {
         return this.adminizer.menuHelper.getBrandTitle();
     }

package/helpers/menuHelper.d.ts

@@ -4,7 +4,7 @@
  * @constructor
  */
 import { User } from "../models/User.js";
-import { ActionType, AdminpanelConfig, HrefConfig, ModelConfig } from "../interfaces/adminpanelConfig.js";
+import { ActionType, AdminpanelConfig, HrefConfig, ModelConfig, NavbarSectionConfig } from "../interfaces/adminpanelConfig.js";
 export type MenuItem = {
     link: string;
     title: string;
@@ -28,6 +28,16 @@ export declare class MenuHelper {
      * @returns {string}
      */
     getBrandTitle(): string;
+    /**
+     * Presentation metadata of navbar sections, keyed by section name.
+     *
+     * Only sections declared under `navbar.sections` are present: a section
+     * used by links but never configured simply has no entry, and the UI falls
+     * back to its default rendering.
+     *
+     * @returns {Record<string, NavbarSectionConfig>}
+     */
+    getSections(): Record<string, NavbarSectionConfig>;
     /**
      * Check if global actions buttons added to action
      *

package/helpers/menuHelper.js

@@ -63,6 +63,18 @@ export class MenuHelper {
         }
         return 'Adminizer';
     }
+    /**
+     * Presentation metadata of navbar sections, keyed by section name.
+     *
+     * Only sections declared under `navbar.sections` are present: a section
+     * used by links but never configured simply has no entry, and the UI falls
+     * back to its default rendering.
+     *
+     * @returns {Record<string, NavbarSectionConfig>}
+     */
+    getSections() {
+        return { ...(this.config.navbar?.sections ?? {}) };
+    }
     /**
      * Check if global actions buttons added to action
      *

package/helpers/modelResourceHelper.d.ts

@@ -0,0 +1,9 @@
+import type { ModelConfig } from '../interfaces/adminpanelConfig.js';
+import type { ModelResource } from '../interfaces/types.js';
+import type { Adminizer } from '../lib/Adminizer.js';
+/** Config defaults of a model resource declared as `true` in the panel config. */
+export declare function normalizeModelConfig(name: string, config: ModelConfig | boolean): ModelConfig;
+/** Every configured model resource whose model is actually registered. */
+export declare function listModelResources(adminizer: Adminizer): ModelResource[];
+/** Resolves a resource by its Adminizer name, then by a uniquely registered host model name. */
+export declare function resolveModelResource(adminizer: Adminizer, modelName: string): ModelResource | undefined;

package/helpers/modelResourceHelper.js

@@ -0,0 +1,43 @@
+/** Config defaults of a model resource declared as `true` in the panel config. */
+export function normalizeModelConfig(name, config) {
+    const baseConfig = {
+        model: name,
+        icon: "description",
+        title: name,
+        list: true,
+        add: true,
+        edit: true,
+        remove: true,
+        view: true,
+    };
+    if (typeof config === "boolean") {
+        return config ? baseConfig : { ...baseConfig, list: false, add: false, edit: false, remove: false, view: false };
+    }
+    return { ...baseConfig, ...config };
+}
+/** Every configured model resource whose model is actually registered. */
+export function listModelResources(adminizer) {
+    const resources = [];
+    for (const [configName, configValue] of Object.entries(adminizer.config.models ?? {})) {
+        const config = normalizeModelConfig(configName, configValue);
+        const model = adminizer.modelHandler.getResource(configName);
+        if (!model)
+            continue;
+        resources.push({
+            name: configName,
+            uri: `${adminizer.config.routePrefix}/model/${configName}`,
+            config,
+            model,
+        });
+    }
+    return resources;
+}
+/** Resolves a resource by its Adminizer name, then by a uniquely registered host model name. */
+export function resolveModelResource(adminizer, modelName) {
+    const requestedName = modelName.trim();
+    const resourceName = adminizer.modelHandler.getResourceRecord(requestedName)?.name
+        ?? adminizer.modelHandler.resolveResourceByHostModel(requestedName);
+    return resourceName
+        ? listModelResources(adminizer).find((resource) => resource.name === resourceName)
+        : undefined;
+}

package/helpers/navigationAccessHelper.d.ts

@@ -0,0 +1,13 @@
+import type { HrefConfig } from '../interfaces/adminpanelConfig.js';
+import type { Adminizer } from '../lib/Adminizer.js';
+import type { User } from '../models/User.js';
+import type { MenuItem } from './menuHelper.js';
+/** Drops the sub-items this user may not open, recursively. */
+export declare function filterAccessibleHrefItems(adminizer: Adminizer, user: User, items: HrefConfig[]): Promise<HrefConfig[]>;
+/**
+ * The navigation menu a user may actually open: configured models, additional
+ * links and app-contributed pages, filtered with the very same rules the
+ * sidebar uses. Titles are left untranslated, so callers that need i18n (the
+ * Inertia page props) translate on top of this.
+ */
+export declare function listAccessibleMenuItems(adminizer: Adminizer, user: User): Promise<MenuItem[]>;

package/helpers/navigationAccessHelper.js

@@ -0,0 +1,45 @@
+/** Drops the sub-items this user may not open, recursively. */
+export async function filterAccessibleHrefItems(adminizer, user, items) {
+    const accessible = [];
+    for (const item of items) {
+        if (item.accessRightsToken && !await adminizer.accessRightsHelper.hasPermission(item.accessRightsToken, user)) {
+            continue;
+        }
+        accessible.push({
+            ...item,
+            subItems: item.subItems ? await filterAccessibleHrefItems(adminizer, user, item.subItems) : item.subItems,
+        });
+    }
+    return accessible;
+}
+/**
+ * The navigation menu a user may actually open: configured models, additional
+ * links and app-contributed pages, filtered with the very same rules the
+ * sidebar uses. Titles are left untranslated, so callers that need i18n (the
+ * Inertia page props) translate on top of this.
+ */
+export async function listAccessibleMenuItems(adminizer, user) {
+    const menu = [];
+    for (const menuItem of adminizer.menuHelper.getMenuItems(user)) {
+        const actions = await filterAccessibleHrefItems(adminizer, user, menuItem.actions ?? []);
+        const tokens = actions.map((item) => item.accessRightsToken).filter(Boolean);
+        if (menuItem.accessRightsToken)
+            tokens.push(menuItem.accessRightsToken);
+        if (await adminizer.accessRightsHelper.enoughPermissions(tokens, user)) {
+            menu.push({ ...menuItem, actions });
+        }
+    }
+    for (const link of await adminizer.adminLinkHandler.list(user)) {
+        menu.push({
+            id: link.id,
+            link: link.link,
+            title: link.title,
+            type: link.type === 'blank' ? 'blank' : 'self',
+            actions: null,
+            icon: null,
+            accessRightsToken: link.accessRightsToken ?? null,
+            section: link.section || 'Platform',
+        });
+    }
+    return menu;
+}