adminizer 5.0.0-build.2 → 5.0.0-build.21

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)}`);
                 }
@@ -119,6 +114,13 @@ export class ConfigHelper {
      */
     static normalizeConfig(config) {
         const defaultConfig = getDefaultConfig();
+        const defaultPrefix = defaultConfig.routePrefix;
+        const routePrefix = config.routePrefix ?? defaultPrefix;
+        // Built-in navbar links are written against the default prefix, so retarget
+        // them whenever the app overrides routePrefix (otherwise they 404).
+        const builtinLinks = (defaultConfig.navbar?.additionalLinks || []).map((item) => typeof item.link === 'string' && item.link.startsWith(`${defaultPrefix}/`)
+            ? { ...item, link: routePrefix + item.link.slice(defaultPrefix.length) }
+            : item);
         const mergedConfig = {
             ...defaultConfig,
             ...config,
@@ -130,7 +132,7 @@ export class ConfigHelper {
                 ...defaultConfig.navbar,
                 ...config.navbar,
                 additionalLinks: [
-                    ...(defaultConfig.navbar?.additionalLinks || []),
+                    ...builtinLinks,
                     ...(config.navbar?.additionalLinks || [])
                 ]
             }

package/helpers/controllerHelper.d.ts

@@ -1,5 +1,5 @@
-import { ModelResource } from "../interfaces/types";
-import { ActionType, CreateUpdateConfig, ModelConfig } from "../interfaces/adminpanelConfig";
+import { ModelResource } from "../interfaces/types.js";
+import { ActionType, CreateUpdateConfig, ModelConfig } from "../interfaces/adminpanelConfig.js";
 /**
  * @deprecated need refactor actions
  */
@@ -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,5 @@
-import { ActionType, BaseFieldConfig, FieldsTypes, ModelConfig } from "../interfaces/adminpanelConfig";
-import { Attribute } from "../lib/model/AbstractModel";
+import { ActionType, BaseFieldConfig, FieldsTypes, ModelConfig } from "../interfaces/adminpanelConfig.js";
+import { Attribute } from "../lib/model/AbstractModel.js";
 export type Field = {
     config: BaseFieldConfig & {
         /** @deprecated record should not be in config anymore */

package/helpers/fieldsHelper.js

@@ -30,9 +30,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;

package/helpers/filterDatetimeHelper.d.ts

@@ -1,4 +1,4 @@
-import { FilterCondition } from "../models/Filter";
+import { FilterCondition } from "../models/Filter.js";
 export interface ConvertDatetimeConditionsOptions {
     dropEmptyValues?: boolean;
 }

package/helpers/inertiaActionsHelper.d.ts

@@ -1,5 +1,5 @@
-import { ModelResource } from "../interfaces/types";
-import { ActionType } from "../interfaces/adminpanelConfig";
+import { ModelResource } from "../interfaces/types.js";
+import { ActionType } from "../interfaces/adminpanelConfig.js";
 export interface Actions {
     link: string;
     id: string;
@@ -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

@@ -1,7 +1,7 @@
-import { ModelResource, PropsField } from "../interfaces/types";
-import { Actions } from "./inertiaActionsHelper";
-import { Fields, Field } from "./fieldsHelper";
-import { Control, ControlType } from "../lib/controls/Control";
+import { ModelResource, PropsField } from "../interfaces/types.js";
+import { Actions } from "./inertiaActionsHelper.js";
+import { Fields, Field } from "./fieldsHelper.js";
+import { Control, ControlType } from "../lib/controls/Control.js";
 export type PropsFieldType = 'text' | 'number' | 'range' | 'week' | 'month' | 'email' | 'color' | 'time' | 'date' | 'datetime-local' | 'password' | 'select' | 'select-many' | 'association-many' | 'association' | 'textarea' | 'mediamanager' | 'single-file' | 'checkbox' | ControlType;
 interface FieldProps extends Record<string | number | symbol, unknown> {
     edit: boolean;
@@ -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.d.ts

@@ -1,6 +1,6 @@
-import { Group } from "../models/Group";
-import { User } from "../models/User";
-import { AccessRightsToken, ModelResource, PropsField } from "../interfaces/types";
+import { Group } from "../models/Group.js";
+import { User } from "../models/User.js";
+import { AccessRightsToken, ModelResource, PropsField } from "../interfaces/types.js";
 interface groupedTokens {
     header: string;
     fields: PropsField[];

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

@@ -1,6 +1,6 @@
-import { ModelResource } from "../interfaces/types";
-import { Fields } from "./fieldsHelper";
-import { Actions } from "./inertiaActionsHelper";
+import { ModelResource } from "../interfaces/types.js";
+import { Fields } from "./fieldsHelper.js";
+import { Actions } from "./inertiaActionsHelper.js";
 interface listProps extends Record<string | number | symbol, unknown> {
     actions: Actions[];
     thActionsTitle: string;
@@ -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,10 +1,9 @@
-import { Adminizer } from "../lib/Adminizer";
-import { MenuItem } from "./menuHelper";
+import { Adminizer } from "../lib/Adminizer.js";
+import { MenuItem } from "./menuHelper.js";
 export declare class InertiaMenuHelper {
     private adminizer;
     constructor(adminizer: Adminizer);
     getMenuItems(req: ReqType): MenuItem[];
-    private filterAccessibleItems;
     private translateMenuItem;
     private translateHrefItem;
     getBrandTitle(): 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
-        }));
+        return listAccessibleMenuItems(this.adminizer, req.user)
+            .map((menuItem) => this.translateMenuItem(req, menuItem));
     }
     translateMenuItem(req, menuItem) {
         return {

package/helpers/inertiaUserHelper.d.ts

@@ -1,6 +1,6 @@
-import { Group } from "../models/Group";
-import { User } from "../models/User";
-import { ModelResource, PropsField } from "../interfaces/types";
+import { Group } from "../models/Group.js";
+import { User } from "../models/User.js";
+import { ModelResource, PropsField } from "../interfaces/types.js";
 interface listProps extends Record<string | number | symbol, unknown> {
     edit: boolean;
     view: boolean;

package/helpers/menuHelper.d.ts

@@ -3,8 +3,8 @@
  *
  * @constructor
  */
-import { User } from "../models/User";
-import { ActionType, AdminpanelConfig, HrefConfig, ModelConfig } from "../interfaces/adminpanelConfig";
+import { User } from "../models/User.js";
+import { ActionType, AdminpanelConfig, HrefConfig, ModelConfig } from "../interfaces/adminpanelConfig.js";
 export type MenuItem = {
     link: string;
     title: string;

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[]): 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): MenuItem[];

package/helpers/navigationAccessHelper.js

@@ -0,0 +1,40 @@
+/** Drops the sub-items this user may not open, recursively. */
+export function filterAccessibleHrefItems(adminizer, user, items) {
+    return items
+        .filter((item) => !item.accessRightsToken || adminizer.accessRightsHelper.hasPermission(item.accessRightsToken, user))
+        .map((item) => ({
+        ...item,
+        subItems: item.subItems ? filterAccessibleHrefItems(adminizer, user, item.subItems) : item.subItems,
+    }));
+}
+/**
+ * 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 function listAccessibleMenuItems(adminizer, user) {
+    const menu = [];
+    for (const menuItem of adminizer.menuHelper.getMenuItems(user)) {
+        const actions = filterAccessibleHrefItems(adminizer, user, menuItem.actions ?? []);
+        const tokens = actions.map((item) => item.accessRightsToken).filter(Boolean);
+        if (menuItem.accessRightsToken)
+            tokens.push(menuItem.accessRightsToken);
+        if (adminizer.accessRightsHelper.enoughPermissions(tokens, user)) {
+            menu.push({ ...menuItem, actions });
+        }
+    }
+    for (const link of 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;
+}

package/helpers/translationHelper.d.ts

@@ -1,5 +1,5 @@
-import { Adminizer } from "../lib/Adminizer";
-import { I18n } from "../lib/I18n";
+import { Adminizer } from "../lib/Adminizer.js";
+import { I18n } from "../lib/I18n.js";
 export declare class TranslationHelper {
     static loadTranslations(adminizer: Adminizer, translationsPath: string): void;
     static translateProperties(i18n: I18n, object: any, fields: string[]): any;