adminizer 5.0.0-build.11 → 5.0.0-build.13

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.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/inertiaAddHelper.js

@@ -62,7 +62,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)) {

package/helpers/inertiaMenuHelper.d.ts

@@ -4,7 +4,6 @@ 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/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/index.d.ts

@@ -46,6 +46,12 @@ export * from "./lib/ai-assistant/AbstractAiModelService.js";
 export * from "./lib/ai-assistant/AbstractAiConversationHistoryService.js";
 export * from "./lib/ai-assistant/AiAssistantHandler.js";
 export * from "./lib/ai-assistant/AiAgentRunManager.js";
+export * from "./lib/ai-assistant/jsonSafe.js";
+export * from "./lib/ai-assistant/AiAssistantUiMethodHandler.js";
+export * from "./lib/ai-assistant/AiAssistantAgentSkillHandler.js";
+export * from "./lib/admin-links/AdminLinkHandler.js";
+export * from "./helpers/modelResourceHelper.js";
+export * from "./helpers/navigationAccessHelper.js";
 export * from "./lib/DataAccessor.js";
 export * from "./lib/history-actions/AbstractHistoryAdapter.js";
 export * from "./lib/filters/CustomFilterHandler.js";

package/index.js

@@ -46,6 +46,12 @@ export * from "./lib/ai-assistant/AbstractAiModelService.js";
 export * from "./lib/ai-assistant/AbstractAiConversationHistoryService.js";
 export * from "./lib/ai-assistant/AiAssistantHandler.js";
 export * from "./lib/ai-assistant/AiAgentRunManager.js";
+export * from "./lib/ai-assistant/jsonSafe.js";
+export * from "./lib/ai-assistant/AiAssistantUiMethodHandler.js";
+export * from "./lib/ai-assistant/AiAssistantAgentSkillHandler.js";
+export * from "./lib/admin-links/AdminLinkHandler.js";
+export * from "./helpers/modelResourceHelper.js";
+export * from "./helpers/navigationAccessHelper.js";
 export * from "./lib/DataAccessor.js";
 export * from "./lib/history-actions/AbstractHistoryAdapter.js";
 export * from "./lib/filters/CustomFilterHandler.js";

package/interfaces/adminpanelConfig.d.ts

@@ -299,9 +299,14 @@ export interface ModelConfig {
     adapter?: string;
     title: string;
     /**
-     * Model name
+     * Physical host ORM model name.
      * */
     model: string;
+    /**
+     * Required only when two or more Adminizer resources use the same host model.
+     * The primary resource is selected for associations that reference the host model.
+     */
+    primary?: boolean;
     /**
      * Optional display name for history. Should be a attribute of the model, or a function.
      */

package/interfaces/types.d.ts

@@ -123,6 +123,29 @@ export interface AiAgentConnectionStatus {
     expiresAt?: string | null;
     [key: string]: unknown;
 }
+/** States for which an agent can describe its connection screen. */
+export type AiAgentConnectionState = Exclude<AiAgentConnectionStatus['state'], 'ready'>;
+/**
+ * Declarative connection screen supplied by an agent service. The shared panel
+ * owns rendering, while the agent owns its copy, CTA and which status details
+ * are useful to expose.
+ */
+export interface AiAgentConnectionScreen {
+    title?: string;
+    description?: string;
+    icon?: 'spinner' | 'bot' | 'error';
+    action?: {
+        label: string;
+        href: string;
+    };
+    /** Status values the agent wants to render on this screen. */
+    details?: Array<{
+        field: string;
+        label?: string;
+        format?: 'text' | 'local-time';
+        tone?: 'muted' | 'error';
+    }>;
+}
 /** Normalized budget / rate limits of the provider key, when it exposes them. */
 export interface AiAgentLimits {
     provider: string;
@@ -144,9 +167,8 @@ export interface AiAgentLimits {
     [key: string]: unknown;
 }
 /**
- * Copy the panel shows instead of its neutral defaults. Strings go through the
- * panel's own dictionary first, so English source strings it already knows are
- * still translated.
+ * Copy the panel shows instead of its neutral defaults. `getUiHints(locale)`
+ * receives the admin user's locale, so agents can return localized copy.
  */
 export interface AiAgentUiHints {
     title?: string;
@@ -157,14 +179,29 @@ export interface AiAgentUiHints {
     setupSetting?: string;
     /** Where to fill it in; rendered as a button on the connection loader. */
     setupUrl?: string;
+    /**
+     * Per-state pages rendered while this agent is not ready. `default` is
+     * used for any state without its own screen.
+     */
+    connectionScreens?: Partial<Record<AiAgentConnectionState | 'default', AiAgentConnectionScreen>>;
     [key: string]: unknown;
 }
+/** A browser-side capability which an agent may call through `ui.method`. */
+export interface AiAgentUiMethod {
+    id: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    action: string;
+    accessRightsToken?: string;
+}
 /** Declarative UI contract consumed by the shared assistant panel. */
 export interface AiAgentUiSchema extends AiAgentUiHints {
     commands: Array<{
         id: string;
         description?: string;
     }>;
+    uiMethods?: AiAgentUiMethod[];
     panels: {
         history: boolean;
         models: boolean;

package/lib/Adminizer.d.ts

@@ -27,6 +27,9 @@ import { ControllerHandler } from "./app-manager/ControllerHandler.js";
 import { AssetHandler } from "./app-manager/AssetHandler.js";
 import { ConfigLayerHandler } from "./app-manager/ConfigLayerHandler.js";
 import { AccessRightsHandler } from "./access-rights/AccessRightsHandler.js";
+import { AiAssistantUiMethodHandler } from './ai-assistant/AiAssistantUiMethodHandler.js';
+import { AdminLinkHandler } from './admin-links/AdminLinkHandler.js';
+import { AiAssistantAgentSkillHandler } from './ai-assistant/AiAssistantAgentSkillHandler.js';
 export declare function createAdminizerLogger(): winston.Logger;
 export interface EmitAsyncOptions {
     /**
@@ -54,6 +57,9 @@ export declare class Adminizer {
     notificationHandler: NotificationHandler;
     historyHandler: HistoryHandler;
     private _aiAssistantHandler?;
+    aiAssistantUiMethodHandler: AiAssistantUiMethodHandler;
+    adminLinkHandler: AdminLinkHandler;
+    aiAssistantAgentSkillHandler: AiAssistantAgentSkillHandler;
     modelHandler: ModelHandler;
     widgetHandler: WidgetHandler;
     customFilterHandler: CustomFilterHandler;

package/lib/Adminizer.js

@@ -43,6 +43,9 @@ import { ControllerHandler } from "./app-manager/ControllerHandler.js";
 import { AssetHandler } from "./app-manager/AssetHandler.js";
 import { ConfigLayerHandler } from "./app-manager/ConfigLayerHandler.js";
 import { AccessRightsHandler } from "./access-rights/AccessRightsHandler.js";
+import { AiAssistantUiMethodHandler } from './ai-assistant/AiAssistantUiMethodHandler.js';
+import { AdminLinkHandler } from './admin-links/AdminLinkHandler.js';
+import { AiAssistantAgentSkillHandler } from './ai-assistant/AiAssistantAgentSkillHandler.js';
 const logFilePath = "logs/app.log";
 function ensureLogDirectory(filePath) {
     const logDirectory = path.dirname(filePath);
@@ -109,6 +112,9 @@ export class Adminizer {
     notificationHandler;
     historyHandler;
     _aiAssistantHandler;
+    aiAssistantUiMethodHandler;
+    adminLinkHandler;
+    aiAssistantAgentSkillHandler;
     modelHandler;
     widgetHandler;
     customFilterHandler;
@@ -141,6 +147,9 @@ export class Adminizer {
         this.catalogTemplateComponentHandler = new CatalogTemplateComponentHandler();
         this.mediaManagerHandler = new MediaManagerHandler();
         this.feedbackHandler = new FeedbackHandler(this);
+        this.aiAssistantUiMethodHandler = new AiAssistantUiMethodHandler(this);
+        this.adminLinkHandler = new AdminLinkHandler(this);
+        this.aiAssistantAgentSkillHandler = new AiAssistantAgentSkillHandler(this);
         this.controllerHandler = new ControllerHandler(this);
         this.assetHandler = new AssetHandler(this);
         this.configLayerHandler = new ConfigLayerHandler(this);

package/lib/DataAccessor.d.ts

@@ -18,6 +18,7 @@ export declare class DataAccessor {
     private getModelConfig;
     private accessRelationModel;
     private resolveRelationTarget;
+    private getRelationModel;
     /**
      * Retrieves the fields for the given ModelResource based on action type,
      * taking into account access rights and configuration settings.

package/lib/DataAccessor.js

@@ -46,29 +46,28 @@ export class DataAccessor {
         this.action = action;
         this.actionVerb = getTokenAction(this.action);
     }
-    getModelConfig(modelName) {
-        const resolvedModelName = this.adminizer.modelHandler.resolveModelName(modelName);
-        const entry = Object.entries(this.adminizer.config.models)
-            .find(([key, config]) => {
-            if (key.toLowerCase() === resolvedModelName.toLowerCase()) {
-                return true;
-            }
-            if (!isObject(config)) {
-                return false;
-            }
-            return config.model?.toLowerCase() === resolvedModelName.toLowerCase();
-        });
-        const config = entry ? entry[1] : undefined;
+    getModelConfig(resourceName) {
+        const config = this.adminizer.config.models?.[resourceName];
         return isObject(config) ? config : undefined;
     }
-    accessRelationModel(modelName) {
-        return this.adminizer.modelHandler.internal("data-accessor").get(modelName);
+    accessRelationModel(modelName, resourceName) {
+        const resolvedResourceName = this.resolveRelationTarget(modelName, resourceName);
+        if (!resolvedResourceName) {
+            throw new Error(`Relation model "${modelName}" was not found`);
+        }
+        return this.adminizer.modelHandler.internal("data-accessor").get(resolvedResourceName);
     }
-    resolveRelationTarget(modelName) {
+    resolveRelationTarget(modelName, resourceName) {
         if (!modelName) {
             return undefined;
         }
-        return this.adminizer.modelHandler.resolveModelName(modelName).toLowerCase();
+        return this.adminizer.modelHandler.resolveAssociationResource(modelName, resourceName);
+    }
+    getRelationModel(modelName, resourceName) {
+        const resolvedResourceName = this.resolveRelationTarget(modelName, resourceName);
+        return resolvedResourceName
+            ? this.adminizer.modelHandler.getResource(resolvedResourceName)
+            : undefined;
     }
     /**
      * Retrieves the fields for the given ModelResource based on action type,
@@ -86,9 +85,9 @@ export class DataAccessor {
         const actionConfig = ControllerHelper.findActionConfig(this.modelResource, this.action);
         const fieldsConfig = this.modelResource.config?.fields || {};
         const modelAttributes = this.modelResource.model.attributes;
-        const tokenId = `${this.actionVerb}-${this.modelResource.model.modelname}-${MODEL_TOKEN_SUFFIX}`;
+        const tokenId = `${this.actionVerb}-${this.modelResource.name}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.model.modelname}`);
+            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.name}`);
             return undefined;
         }
         const result = {};
@@ -131,14 +130,14 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
-                const resolvedModelName = modelName ? this.adminizer.modelHandler.resolveModelName(modelName) : undefined;
+                const resolvedModelName = this.resolveRelationTarget(modelName, modelField.resourceName);
                 if (modelName && resolvedModelName) {
                     const tokenId = `read-${resolvedModelName}-${MODEL_TOKEN_SUFFIX}`;
                     if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-                        Adminizer.log.silly(`No access rights to model: ${this.modelResource.model.modelname}`);
+                        Adminizer.log.silly(`No access rights to model: ${this.modelResource.name}`);
                         return undefined;
                     }
-                    const model = this.adminizer.modelHandler.model.get(modelName);
+                    const model = this.adminizer.modelHandler.getResource(resolvedModelName);
                     if (model) {
                         populatedModelFieldsConfig = this.getAssociatedFieldsConfig(resolvedModelName);
                         const modelCfg = this.getModelConfig(resolvedModelName);
@@ -186,17 +185,16 @@ export class DataAccessor {
         Object.keys(fields).forEach(appendField);
         return orderedFields;
     }
-    getAssociatedFieldsConfig(modelName) {
-        const resolvedModelName = this.adminizer.modelHandler.resolveModelName(modelName);
-        const model = this.adminizer.modelHandler.model.get(resolvedModelName);
-        const modelConfig = this.getModelConfig(resolvedModelName);
+    getAssociatedFieldsConfig(resourceName) {
+        const model = this.adminizer.modelHandler.getResource(resourceName);
+        const modelConfig = this.getModelConfig(resourceName);
         if (!model || !modelConfig) {
             return undefined;
         }
         // Check if user has access to the associated model
-        const tokenId = `read-${resolvedModelName}-${MODEL_TOKEN_SUFFIX}`;
+        const tokenId = `read-${resourceName}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${resolvedModelName}`);
+            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${resourceName}`);
             return undefined;
         }
         const associatedFields = {};
@@ -379,7 +377,7 @@ export class DataAccessor {
     async sanitizeUserRelationAccess(criteria = {}) {
         let sanitizedCriteria = {};
         // Retrieve model configuration from adminpanel config
-        const modelName = this.modelResource.model.modelname;
+        const modelName = this.modelResource.name;
         const modelConfig = this.modelResource.config;
         // Check if the model has `userAccessRelation` configured
         if (!this.user.isAdministrator && modelConfig && modelConfig.userAccessRelation) {
@@ -392,18 +390,18 @@ export class DataAccessor {
                 // Check if the relation points to `User` or `Group` in the model's attributes
                 const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
-                const relationModel = this.resolveRelationTarget(relation?.model);
-                const relationCollection = this.resolveRelationTarget(relation?.collection);
-                if (!relation || !['user', 'group'].includes(relationModel ?? relationCollection ?? "")) {
+                const relationModel = this.resolveRelationTarget(relation?.model, relation?.resourceName);
+                const relationCollection = this.resolveRelationTarget(relation?.collection, relation?.resourceName);
+                if (!relation || !['User', 'Group'].includes(relationModel ?? relationCollection ?? "")) {
                     throw new Error(`Invalid userAccessRelation configuration for model ${modelName}`);
                 }
                 // Determine if the current user matches the access criteria
                 if (relationModel) {
-                    if (relationModel === 'user') {
+                    if (relationModel === 'User') {
                         // Filter by the user's ID if related to User as a model
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: this.user.id };
                     }
-                    else if (relationModel === 'group') {
+                    else if (relationModel === 'Group') {
                         // Filter by user's group membership if related to Group as a model
                         const userGroups = this.user.groups?.map((group) => group.id);
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { in: userGroups } };
@@ -412,11 +410,11 @@ export class DataAccessor {
                 /** Warning: collection relation access is not supported and needs adapter-level processing */
                 if (relationCollection) {
                     Adminizer.log.warn(`Collection relation is not supported and was not tested. You may have an error here: ${JSON.stringify(relation, null, 2)}`);
-                    if (relationCollection === 'user') {
+                    if (relationCollection === 'User') {
                         // Ensure user's ID is part of the associated collection to User
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { contains: this.user.id } };
                     }
-                    else if (relationCollection === 'group') {
+                    else if (relationCollection === 'Group') {
                         // Ensure user's groups intersect with the collection to Group
                         const userGroups = this.user.groups?.map((group) => group.id);
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { intersects: userGroups } };
@@ -433,19 +431,19 @@ export class DataAccessor {
                     throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${modelName}`);
                 }
                 // Retrieve the intermediate model
-                const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
+                const intermediateModel = this.getRelationModel(intermediateRelation.model, intermediateRelation.resourceName);
                 if (!intermediateModel) {
                     throw new Error(`Intermediate model "${intermediateRelation.model}" not found`);
                 }
                 // Validate the `via` field in the intermediate model
                 const intermediateAttributes = intermediateModel.attributes;
                 const viaRelation = intermediateAttributes[via];
-                if (!viaRelation || this.resolveRelationTarget(viaRelation.model) !== 'user') {
+                if (!viaRelation || this.resolveRelationTarget(viaRelation.model, viaRelation.resourceName) !== 'User') {
                     throw new Error(`Unsupported or invalid via field "${via}" in intermediate model "${intermediateRelation.model}". ` +
                         `Currently, only relations to "User" are supported`);
                 }
                 // Fetch all intermediate records associated with the user
-                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model).find({ where: { [via]: this.user.id } });
+                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model, intermediateRelation.resourceName).find({ where: { [via]: this.user.id } });
                 const intermediateIds = (intermediateRecords || []).map((r) => r.id);
                 // Filter main model by all matching intermediate record IDs
                 sanitizedCriteria = { ...sanitizedCriteria, [field]: { in: intermediateIds } };
@@ -471,14 +469,14 @@ export class DataAccessor {
                 // Check if the relation points to `User` or `Group` in the model's attributes
                 const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
-                const relationModel = this.resolveRelationTarget(relation?.model);
-                if (relation && ['user', 'group'].includes(relationModel ?? "")) {
-                    if (relationModel === 'user') {
+                const relationModel = this.resolveRelationTarget(relation?.model, relation?.resourceName);
+                if (relation && ['User', 'Group'].includes(relationModel ?? "")) {
+                    if (relationModel === 'User') {
                         if (!this.user.isAdministrator) {
                             updatedRecord[accessField] = this.user.id;
                         }
                     }
-                    else if (relationModel === 'group') {
+                    else if (relationModel === 'Group') {
                         const userGroups = this.user.groups || [];
                         if (userGroups.length === 1) {
                             updatedRecord[accessField] = userGroups[0].id;
@@ -500,16 +498,16 @@ export class DataAccessor {
                     const modelAttributes = this.modelResource.model.attributes;
                     const intermediateRelation = modelAttributes[field];
                     if (!intermediateRelation || !intermediateRelation.model) {
-                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.model.modelname}`);
+                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.name}`);
                     }
-                    const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
+                    const intermediateModel = this.getRelationModel(intermediateRelation.model, intermediateRelation.resourceName);
                     if (!intermediateModel) {
                         throw new Error(`Intermediate model "${intermediateRelation.model}" not found`);
                     }
                     // Validate the `via` field in the intermediate model
                     const intermediateAttributes = intermediateModel.attributes;
                     const viaRelation = intermediateAttributes[via];
-                    if (!viaRelation || this.resolveRelationTarget(viaRelation.model) !== 'user') {
+                    if (!viaRelation || this.resolveRelationTarget(viaRelation.model, viaRelation.resourceName) !== 'User') {
                         throw new Error(`Unsupported or invalid via field "${via}" in intermediate model "${intermediateRelation.model}". ` +
                             `Currently, only relations to "User" are supported`);
                     }
@@ -517,7 +515,7 @@ export class DataAccessor {
                     const chosenId = typeof updatedRecord[field] === 'object'
                         ? updatedRecord[field][intermediatePk]
                         : updatedRecord[field];
-                    const record = await this.accessRelationModel(intermediateRelation.model).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
+                    const record = await this.accessRelationModel(intermediateRelation.model, intermediateRelation.resourceName).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
                     if (!record) {
                         throw new Error(`Access denied: "${field}" does not belong to the current user`);
                     }