adminizer 4.1.0-commit.ad1476a → 4.1.1

package/controllers/getAllWidgets.js

@@ -1,15 +1,15 @@
 export default async function getAllWidgets(req, res) {
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`widgets`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`widgets`, req.user)) {
             return res.sendStatus(403);
         }
     }
     if (req.method.toUpperCase() === 'GET') {
         try {
-            return res.json({ widgets: await req.adminizer.widgetHandler.getAll(req.session.UserAP) });
+            return res.json({ widgets: await req.adminizer.widgetHandler.getAll(req.user, req.i18n) });
         }
         catch (e) {
             return res.status(500).send({ error: e.message || 'Internal Server Error' });

package/controllers/initUser.js

@@ -29,12 +29,11 @@ export default async function initUser(req, res) {
         }
         try {
             Adminizer.log.debug(`Created admin`);
-            let passwordHashed = generate(login + password);
+            let passwordHashed = generate(login + password + process.env.AP_PASSWORD_SALT);
             password = 'masked';
             // TODO refactor CRUD functions for DataAccessor usage
             await req.adminizer.modelHandler.model.get("UserAP")["_create"]({
                 login: login,
-                password: password,
                 passwordHashed: passwordHashed,
                 fullName: "Administrator",
                 isActive: true,

package/controllers/list.js

@@ -1,6 +1,6 @@
 import { ControllerHelper } from "../helpers/controllerHelper";
 import { DataAccessor } from "../lib/v4/DataAccessor";
-import { NodeTable } from "../lib/datatable/NodeTable";
+import { NodeTable } from "../lib/v4/datatable/NodeTable";
 import { Adminizer } from "../lib/Adminizer";
 import { inertiaListHelper } from "../helpers/inertiaListHelper";
 export default async function list(req, res) {
@@ -9,14 +9,14 @@ export default async function list(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`read-${entity.name}-model`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`read-${entity.name}-model`, req.user)) {
             return res.sendStatus(403);
         }
     }
-    let dataAccessor = new DataAccessor(req, entity, "list");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "list");
     let fields = dataAccessor.getFieldsConfig();
     const header = inertiaListHelper(entity, req, fields);
     let start = "0";
@@ -46,8 +46,8 @@ export default async function list(req, res) {
     const searchMap = new Map();
     for (let i = 0; i < searchColumns.length; i++) {
         const column = searchColumns[i];
-        const value = searchColumnValues[i] || ""; // Если нет значения, ставим пустую строку
-        searchMap.set(column, value); // Если column повторяется, перезаписываем
+        const value = searchColumnValues[i] || "";
+        searchMap.set(column, value);
     }
     const searchPairs = Array.from(searchMap.entries()).map(([column, value]) => ({
         column,

package/controllers/login.js

@@ -1,6 +1,9 @@
 import { POWCaptcha } from "../lib/v4/POWCaptcha";
 import passwordHash from "password-hash";
 import { inertiaLoginHelper } from "../helpers/inertiaAutHelper";
+import { Adminizer } from "../lib/Adminizer";
+import { signUser } from "../lib/v4/helper/jwt";
+import { serialize } from "cookie";
 export default async function login(req, res) {
     const powCaptcha = new POWCaptcha();
     if (req.originalUrl.indexOf("login") >= 0) {
@@ -11,11 +14,6 @@ export default async function login(req, res) {
             let login = req.body.login;
             let password = req.body.password;
             let captchaSolution = req.body.captchaSolution;
-            // Verify CAPTCHA solution
-            const isCaptchaValid = powCaptcha.check(captchaSolution, `login:${req.ip}`);
-            if (!isCaptchaValid) {
-                return inertiaAdminMessage(req, "Invalid CAPTCHA solution", 'captchaSolution');
-            }
             let user;
             try {
                 // TODO refactor CRUD functions for DataAccessor usage
@@ -28,10 +26,18 @@ export default async function login(req, res) {
                 if (!user) {
                     return res.sendStatus(404);
                 }
-                if (req.session.UserAP.isAdministrator) {
-                    req.session.adminPretender = req.session.UserAP;
-                    req.session.UserAP = user;
-                    return res.sendStatus(200);
+                if (req.user.isAdministrator) {
+                    req.session.userPretended = user;
+                    // return res.sendStatus(200);
+                    return req.Inertia.redirect(`${req.adminizer.config.routePrefix}`);
+                }
+                return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/`);
+            }
+            // Verify CAPTCHA solution if enabled
+            if (req.adminizer.config.auth.captcha !== false) {
+                const isCaptchaValid = powCaptcha.check(captchaSolution, `login:${req.ip}`);
+                if (!isCaptchaValid) {
+                    return inertiaAdminMessage(req, "Invalid CAPTCHA solution", 'captchaSolution');
                 }
             }
             if (!user) {
@@ -42,12 +48,18 @@ export default async function login(req, res) {
                     //Here we use the captchaSolution key to output messages unrelated to the form fields.
                     return inertiaAdminMessage(req, "Profile is not confirmed, please contact to administrator", 'captchaSolution');
                 }
-                if (passwordHash.verify(login + password, user.passwordHashed)) {
+                if (passwordHash.verify(login + password + process.env.AP_PASSWORD_SALT, user.passwordHashed)) {
                     if (user.expires && Date.now() > Date.parse(user.expires)) {
                         //Here we use the captchaSolution key to output messages unrelated to the form fields.
                         return inertiaAdminMessage(req, "Profile expired, contact the administrator", 'captchaSolution');
                     }
-                    req.session.UserAP = user;
+                    const token = signUser(user, req.adminizer.jwtSecret);
+                    res.setHeader('Set-Cookie', serialize('adminizer_jwt', token, {
+                        httpOnly: true,
+                        sameSite: 'lax',
+                        path: '/',
+                        maxAge: 60 * 60 * 24 * 7 * 2,
+                    }));
                     return req.Inertia.redirect(`${req.adminizer.config.routePrefix}`);
                 }
                 else {
@@ -56,8 +68,11 @@ export default async function login(req, res) {
             }
         }
         if (req.method.toUpperCase() === "GET") {
-            // Generate new CAPTCHA job
-            const captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+            // Generate new CAPTCHA task if enabled
+            let captchaTask = [];
+            if (req.adminizer.config.auth.captcha !== false) {
+                captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+            }
             return req.Inertia.render({
                 component: 'login',
                 props: {
@@ -69,19 +84,29 @@ export default async function login(req, res) {
         }
     }
     else if (req.originalUrl.indexOf("logout") >= 0) {
-        if (req.session.adminPretender && req.session.adminPretender.id && req.session.UserAP && req.session.UserAP.id) {
-            req.session.UserAP = req.session.adminPretender;
-            req.session.adminPretender = {};
+        if (req.session.userPretended && req.session.userPretended.id && req.user && req.user.id) {
+            delete (req.session.userPretended);
             return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/`);
         }
-        req.session.UserAP = undefined;
+        req.user = undefined;
+        res.setHeader('Set-Cookie', serialize('adminizer_jwt', '', {
+            httpOnly: true,
+            sameSite: 'lax',
+            path: '/',
+            expires: new Date(0),
+        }));
         req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
     }
     return res.status(404);
 }
 async function inertiaAdminMessage(req, message, messageType) {
+    Adminizer.log.warn(message);
     const powCaptcha = new POWCaptcha();
-    const captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+    // Generate new CAPTCHA task if enabled
+    let captchaTask = [];
+    if (req.adminizer.config.auth.captcha !== false) {
+        captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+    }
     let errors = {};
     errors[messageType] = message;
     return req.Inertia.render({

package/controllers/media-manager/mediaManagerAdapter.js

@@ -123,7 +123,6 @@ export class MediaManagerAdapter {
             }
             try {
                 const item = await this.manager.upload(req.file, filename, origFileName, group);
-                console.log(item);
                 if (item) {
                     return res.send({
                         msg: "success",
@@ -150,7 +149,7 @@ export class MediaManagerAdapter {
             return;
         }
         catch (e) {
-            console.log(e);
+            console.error(e);
         }
     }
 }

package/controllers/media-manager/mediaManagerApi.js

@@ -4,10 +4,10 @@ export async function mediaManagerController(req, res) {
     const method = req.method.toUpperCase();
     let id = req.params.id ? req.params.id : '';
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`catalog-${id}`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`catalog-${id}`, req.user)) {
             return res.sendStatus(403);
         }
     }

package/controllers/navigation/edit.js

@@ -2,12 +2,12 @@ import { ControllerHelper } from "../../helpers/controllerHelper";
 import { DataAccessor } from "../../lib/v4/DataAccessor";
 export default async function edit(req, res) {
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
     }
     let entity = ControllerHelper.findEntityObject(req);
-    let dataAccessor = new DataAccessor(req, entity, "edit");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "edit");
     let record = await entity.model.findOne({ id: req.params.id }, dataAccessor);
     return res.redirect(`${req.adminizer.config.routePrefix}/catalog/navigation/${record.label}`);
 }

package/controllers/register.js

@@ -5,7 +5,6 @@ export default async function register(req, res) {
         return res.redirect(`${req.adminizer.config.routePrefix}/`);
     }
     if (req.method.toUpperCase() === "POST") {
-        // console.log("req.body", req.body);
         for (const key of ["login", "fullName", "password"]) {
             if (!req.body[key]) {
                 let errors = {};
@@ -40,12 +39,11 @@ export default async function register(req, res) {
         }
         else {
             try {
-                let passwordHashed = generate(req.body.login + req.body.password);
+                let passwordHashed = generate(req.body.login + req.body.password + process.env.AP_PASSWORD_SALT);
                 let password = 'masked';
                 // TODO refactor CRUD functions for DataAccessor usage
                 let userap = await req.adminizer.modelHandler.model.get("UserAP")["_create"]({
                     login: req.body.login,
-                    password: password,
                     passwordHashed: passwordHashed,
                     fullName: req.body.fullName,
                     email: req.body.email,
@@ -53,7 +51,6 @@ export default async function register(req, res) {
                 });
                 // TODO refactor CRUD functions for DataAccessor usage
                 let defaultUserGroup = await req.adminizer.modelHandler.model.get("GroupAP")["_findOne"]({ name: req.adminizer.config.registration.defaultUserGroup });
-                console.log(userap);
                 // TODO refactor CRUD functions for DataAccessor usage
                 await req.adminizer.modelHandler.model.get("UserAP")["_updateOne"]({ id: userap.id }, {
                     groups: [defaultUserGroup.id]

package/controllers/remove.js

@@ -18,10 +18,10 @@ export default async function remove(req, res) {
         return res.redirect(`${req.adminizer.config.routePrefix}/${entity.uri}`);
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`delete-${entity.name}-model`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`delete-${entity.name}-model`, req.user)) {
             return res.sendStatus(403);
         }
     }
@@ -31,7 +31,7 @@ export default async function remove(req, res) {
     let record;
     let dataAccessor;
     try {
-        dataAccessor = new DataAccessor(req, entity, "remove");
+        dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "remove");
         record = await entity.model.findOne({ id: req.params.id }, dataAccessor);
     }
     catch (e) {

package/controllers/timezones.js

@@ -1,6 +1,6 @@
 export default async function timezones(req, res) {
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
     }

package/controllers/view.js

@@ -18,14 +18,14 @@ export default async function view(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`read-${entity.name}-model`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`read-${entity.name}-model`, req.user)) {
             return res.sendStatus(403);
         }
     }
-    let dataAccessor = new DataAccessor(req, entity, "view");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "view");
     let fields = dataAccessor.getFieldsConfig();
     let record;
     try {

package/controllers/welcome.js

@@ -2,7 +2,7 @@
  * Welcome text
  */
 export default function welcome(req, res) {
-    if (req.adminizer.config.auth.enable && !req.session.UserAP) {
+    if (!req.user) {
         return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
     }
     let text = '';

package/controllers/widgets/Action.js

@@ -4,10 +4,10 @@ export async function widgetActionController(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.user)) {
             return res.sendStatus(403);
         }
     }

package/controllers/widgets/Custom.js

@@ -4,10 +4,10 @@ export async function widgetCustomController(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.user)) {
             return res.sendStatus(403);
         }
     }

package/controllers/widgets/Info.js

@@ -4,10 +4,10 @@ export async function widgetInfoController(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.user)) {
             return res.sendStatus(403);
         }
     }

package/controllers/widgets/switch.js

@@ -4,10 +4,10 @@ export async function widgetSwitchController(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`widget-${widgetId}`, req.user)) {
             return res.sendStatus(403);
         }
     }

package/controllers/widgetsDB.js

@@ -2,17 +2,17 @@ export default async function widgetsDB(req, res) {
     let id = 0;
     let auth = req.adminizer.config.auth.enable;
     if (auth) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`widgets`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`widgets`, req.user)) {
             return res.sendStatus(403);
         }
-        id = req.session.UserAP.id;
+        id = req.user.id;
     }
     if (req.method.toUpperCase() === 'GET') {
         try {
-            let widgets = await req.adminizer.widgetHandler.getWidgetsDB(id, auth);
+            let widgets = await req.adminizer.widgetHandler.getWidgetsDB(id, auth, req.i18n);
             return res.json({ widgetsDB: widgets });
         }
         catch (e) {
@@ -25,7 +25,7 @@ export default async function widgetsDB(req, res) {
         }
         try {
             return res.json({
-                userID: await req.adminizer.widgetHandler.setWidgetsDB(id, req.body.widgets, auth),
+                userID: await req.adminizer.widgetHandler.setWidgetsDB(id, req.body, auth),
                 status: 'ok'
             });
         }

package/helpers/JsUtils.d.ts

@@ -0,0 +1 @@
+export declare function isObject(obj: unknown): obj is object;

package/helpers/JsUtils.js

@@ -0,0 +1,3 @@
+export function isObject(obj) {
+    return typeof obj === "object" && obj !== null;
+}

package/helpers/accessRightsHelper.d.ts

@@ -1,3 +1,4 @@
+import { UserAP } from "models/UserAP";
 import { AccessRightsToken } from "../interfaces/types";
 import { Adminizer } from "../lib/Adminizer";
 export declare class AccessRightsHelper {
@@ -9,6 +10,9 @@ export declare class AccessRightsHelper {
     getTokens(): AccessRightsToken[];
     getTokensByDepartment(department: string): AccessRightsToken[];
     getAllDepartments(): string[];
-    enoughPermissions(tokens: string[], user: ModelsAP["UserAP"]): boolean;
-    hasPermission(tokenId: string, user: ModelsAP["UserAP"]): boolean;
+    enoughPermissions(tokens: string[], user: UserAP): boolean;
+    hasPermission(tokenId: string, user: UserAP): boolean;
+}
+export declare class GroupsAccessRightsHelper {
+    static hasAccess(user: UserAP, groupsAccessRights?: string[]): boolean;
 }

package/helpers/accessRightsHelper.js

@@ -6,12 +6,14 @@ export class AccessRightsHelper {
         this.adminizer = adminizer;
     }
     registerToken(accessRightsToken) {
+        accessRightsToken.id = accessRightsToken.id.toLowerCase();
         if (!accessRightsToken.id || !accessRightsToken.name || !accessRightsToken.description || !accessRightsToken.department) {
             throw new Error("Adminpanel > Can not register token: Missed one or more required parameters");
         }
-        for (let token of this._tokens) {
-            if (token.id === accessRightsToken.id) {
-                throw new Error("Adminpanel > Can not register token: Token with this id already registered");
+        for (let i = 0; i < this._tokens.length; i++) {
+            if (this._tokens[i].id === accessRightsToken.id) {
+                this._tokens.splice(i, 1);
+                break;
             }
         }
         this._tokens.push(accessRightsToken);
@@ -42,6 +44,11 @@ export class AccessRightsHelper {
         return tokens.some((token) => this.hasPermission(token, user));
     }
     hasPermission(tokenId, user) {
+        if (!tokenId) {
+            Adminizer.log.error(`AccessRightsHelper > hasPermission no tokenId: ${tokenId}`);
+            return false;
+        }
+        tokenId = tokenId.toLowerCase();
         if (!this.adminizer.config.auth.enable) {
             return true;
         }
@@ -50,9 +57,25 @@ export class AccessRightsHelper {
         }
         const tokenIsValid = this._tokens.some((token) => token.id === tokenId);
         if (!tokenIsValid) {
-            Adminizer.log.error("Adminpanel > Token is not valid");
+            Adminizer.log.error("Adminpanel > Token is not valid", tokenId, user.login);
             return false;
         }
-        return user.groups.some((group) => group.tokens.includes(tokenId));
+        if (!user.groups) {
+            Adminizer.log.error('User has no groups');
+            return false;
+        }
+        return user.groups.some((group) => group.tokens?.includes(tokenId));
+    }
+}
+export class GroupsAccessRightsHelper {
+    static hasAccess(user, groupsAccessRights) {
+        const userGroups = user.groups?.map(group => group.name.toLowerCase());
+        if (groupsAccessRights) {
+            const allowedGroups = groupsAccessRights.map(item => item.toLowerCase());
+            return userGroups?.some(group => allowedGroups.includes(group)) ?? false;
+        }
+        else {
+            return true;
+        }
     }
 }

package/helpers/configHelper.js

@@ -77,7 +77,7 @@ export class ConfigHelper {
         }
         // Boolean notation: `true` means field is visible; `false` means field is hidden.
         if (typeof config === "boolean") {
-            return config ? { title: key } : false;
+            return config ? { title: key } : { visible: false };
         }
         // String notation: Interpreted as the field title.
         if (typeof config === "string") {
@@ -86,6 +86,7 @@ export class ConfigHelper {
         // Object notation: Allows full customization of the field.
         if (typeof config === "object" && config !== null) {
             config.title = config.title || key;
+            config.visible = config.visible === undefined ? true : Boolean(config.visible);
             // For association types, determine display field by checking model attributes.
             if (["association", "association-many"].includes(config.type)) {
                 let associatedModelAttributes = {};

package/helpers/controllerHelper.js

@@ -28,7 +28,15 @@ export class ControllerHelper {
      * @private
      */
     static _isValidModelConfig(config) {
-        return (typeof config === "object" && typeof config.model === "string");
+        try {
+            if (!config)
+                throw `Config is not defined ${config}`;
+            return (typeof config === "object" && typeof config.model === "string");
+        }
+        catch (error) {
+            Adminizer.log.error(error);
+            return false;
+        }
     }
     ;
     /**
@@ -84,7 +92,7 @@ export class ControllerHelper {
         const entityType = req.params.entityType;
         if (!entityType) {
             const extractedEntityType = req.originalUrl.split('/')[2];
-            if (["form", "model", "wizard"].includes(extractedEntityType)) {
+            if (["form", "model"].includes(extractedEntityType)) {
                 return extractedEntityType;
             }
             else {
@@ -101,22 +109,28 @@ export class ControllerHelper {
      * @returns {?string}
      */
     static findEntityName(req) {
-        if (!req.params.entityName) {
-            let entityType = req.originalUrl.split('/')[2];
-            let entityName = req.originalUrl.split('/')[3];
-            if (entityType === "form" && (!req.adminizer.config.forms || !req.adminizer.config.forms.data || !req.adminizer.config.forms.data[entityName])) {
-                return null;
-            }
-            else if (entityType === "model" && (!req.adminizer.config.models || !req.adminizer.config.models[entityName])) {
-                return null;
+        if (req.params.entityName) {
+            return req.params.entityName;
+        }
+        const urlParts = req.originalUrl.split('/');
+        const entityType = urlParts[2];
+        const entityName = urlParts[3];
+        if (entityType === 'form') {
+            const forms = req.adminizer.config.forms?.data;
+            if (!forms || !Object.keys(forms).some(key => key.toLowerCase() === entityName.toLowerCase())) {
+                throw new Error(`Form "${entityName}" not found`);
             }
-            else {
-                return entityName;
+            return Object.keys(forms).find(key => key.toLowerCase() === entityName.toLowerCase());
+        }
+        if (entityType === 'model') {
+            const models = req.adminizer.config.models;
+            if (!models || !Object.keys(models).some(key => key.toLowerCase() === entityName.toLowerCase())) {
+                throw new Error(`Model "${entityName}" not found`);
             }
+            return Object.keys(models).find(key => key.toLowerCase() === entityName.toLowerCase());
         }
-        return req.params.entityName;
+        throw new Error(`Unsupported entity type "${entityType}" in URL`);
     }
-    ;
     /**
      * Searches for config from admin panel
      *
@@ -125,11 +139,17 @@ export class ControllerHelper {
      * @returns {?Object}
      */
     static findModelConfig(req, entityName) {
-        if (!req.adminizer.config.models || !req.adminizer.config.models[entityName]) {
-            Adminizer.log.error('No such route exists');
+        const models = req.adminizer.config.models;
+        if (!models) {
+            Adminizer.log.error('No models configuration found');
+            return null;
+        }
+        const foundKey = Object.keys(models).find(key => key.toLowerCase() === entityName.toLowerCase());
+        if (!foundKey) {
+            Adminizer.log.error(`No such route exists: ${entityName}`);
             return null;
         }
-        return this._normalizeModelConfig(entityName, req.adminizer.config.models[entityName]);
+        return this._normalizeModelConfig(foundKey, models[foundKey]);
     }
     /**
      * Will get action config from configuration file depending to given action
@@ -200,7 +220,8 @@ export class ControllerHelper {
             name: entityName,
             uri: entityUri,
             type: entityType,
-            model: null
+            model: null,
+            config: null
         };
         // If the entity type is "model", add additional properties
         if (entityType === "model") {

package/helpers/fieldsHelper.d.ts

@@ -1,20 +1,21 @@
-import { ActionType, BaseFieldConfig, FieldsTypes } from "../interfaces/adminpanelConfig";
+import { ActionType, BaseFieldConfig, FieldsTypes, ModelConfig } from "../interfaces/adminpanelConfig";
 import { Attribute } from "../lib/v4/model/AbstractModel";
 export type Field = {
     config: BaseFieldConfig & {
         /** @deprecated record should not be in config anymore */
-        records?: object[];
+        records?: Record<string, any>[];
         file?: string;
         key?: string;
         required?: boolean;
         type?: FieldsTypes;
         groupsAccessRights?: string[];
     } | string | boolean;
-    /** for populated fields' configs */
+    /** For render associalitons fields */
     populated: {
         [key: string]: Field;
     } | undefined;
     model: Attribute;
+    modelConfig: ModelConfig;
 };
 export type Fields = {
     [key: string]: Field;