adminizer 4.1.0-commit.d8a06d3 → 4.1.1

package/controllers/catalog/FrontentCatalogAdapter.d.ts

@@ -1,9 +1,9 @@
-import { AbstractCatalog, Item } from "../../lib/catalog/AbstractCatalog";
+import { AbstractCatalog, Item } from "../../lib/v4/catalog/AbstractCatalog";
 interface NodeModel<TDataType> {
-    title: string;
-    isLeaf: boolean;
-    isExpanded: boolean;
-    ind: number;
+    text: string;
+    droppable: boolean;
+    id: string;
+    parent: string;
     data?: TDataType;
     children?: NodeModel<TDataType>[];
     isSelected?: boolean;
@@ -18,40 +18,50 @@ interface NodeModel<TDataType> {
 }
 interface NodeData extends Item {
 }
-interface obj {
-    [key: string]: string;
-}
 interface RequestData {
     reqNode: NodeModel<NodeData>[];
     reqParent: NodeModel<NodeData>;
     _method: string;
 }
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
 export declare class VueCatalog {
     catalog: AbstractCatalog;
     constructor(_catalog: AbstractCatalog);
     setId(id: string): void;
-    getItemType(type: string): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>;
-    getAddHTML(item: any, req: ReqType): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getItemType(type: string): import("../../lib/v4/catalog/AbstractCatalog").BaseItem<Item>;
+    getAddTemplate(item: any, req: ReqType): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
-    getEditHTML(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getEditTemplate(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
-    getitemTypes(): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>[];
-    getLocales(req: ReqType): obj;
-    getActions(items: NodeModel<any>[], type: string): Promise<import("../../lib/catalog/AbstractCatalog").ActionHandler[]>;
-    handleAction(actionId: string, items: any[], config: any): Promise<void>;
-    getPopUpHTML(actionId: string): Promise<string>;
+    getitemTypes(): {
+        type: string;
+        name: string;
+        isGroup: boolean;
+        allowedRoot: boolean;
+        icon: string;
+        actionHandlers: import("../../lib/v4/catalog/AbstractCatalog").ActionHandler[];
+    }[];
+    getLocales(req: ReqType): {
+        [key: string]: string;
+    };
+    getActions(items: NodeModel<any>[], type: string): Promise<import("../../lib/v4/catalog/AbstractCatalog").ActionHandler[]>;
+    handleAction(actionId: string, items: any[], data: any, req: ReqType): Promise<string | void>;
+    getPopUpTemplate(actionId: string, req: ReqType): Promise<string>;
     getLink(actionId: string): Promise<string>;
     getCatalog(): Promise<NodeModel<Item>[]>;
-    createItem(data: any): Promise<any>;
-    getChilds(data: any): Promise<NodeModel<Item>[]>;
-    search(s: string): Promise<NodeModel<Item>[]>;
-    updateTree(data: RequestData): Promise<any>;
-    updateItem(item: any, modelId: string, data: any): Promise<any>;
-    deleteItem(items: NodeModel<any>[]): Promise<{
+    createItem(data: any, req: ReqType): Promise<any>;
+    getChilds(data: any, req: ReqType): Promise<NodeModel<Item>[]>;
+    search(s: string, req: ReqType): Promise<NodeModel<Item>[]>;
+    updateTree(data: RequestData, req: ReqType): Promise<any>;
+    updateItem(item: any, modelId: string, data: any, req: ReqType): Promise<any>;
+    deleteItem(item: Item, req: ReqType): Promise<{
         ok: boolean;
     }>;
 }

package/controllers/catalog/FrontentCatalogAdapter.js

@@ -1,4 +1,7 @@
-import { AbstractCatalog } from "../../lib/catalog/AbstractCatalog";
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
 export class VueCatalog {
     catalog;
     constructor(_catalog) {
@@ -10,11 +13,11 @@ export class VueCatalog {
     getItemType(type) {
         return this.catalog.getItemType(type);
     }
-    getAddHTML(item, req) {
-        return this.catalog.getAddHTML(item, req);
+    getAddTemplate(item, req) {
+        return this.catalog.getAddTemplate(item, req);
     }
-    getEditHTML(item, id, req, modelId) {
-        return this.catalog.getEditHTML(item, id, req, modelId);
+    getEditTemplate(item, id, req, modelId) {
+        return this.catalog.getEditTemplate(item, id, req, modelId);
     }
     getitemTypes() {
         return this.catalog.getitemTypes();
@@ -28,28 +31,35 @@ export class VueCatalog {
             "Select Item type": "",
             "Select Items": "",
             "Save": "",
-            "No, cancel": "",
+            "No": "",
             "Are you sure?": "",
-            "Yes, I'm sure": "",
-            "Select Ids": ""
+            "Yes": "",
+            "Select Ids": "",
+            "OR": "",
+            "Open in a new window": "",
+            "Clean": "",
+            "Performing an action...": "",
+            "Action completed": "",
         };
         obj[this.catalog.name] = "";
         for (const actionHandler of this.catalog.actionHandlers) {
             obj[actionHandler.name] = "";
         }
         let messages = obj;
-        req.i18n.setLocale(req.user.locale);
         let outMessages = {};
         for (const mess of Object.keys(messages)) {
             outMessages[mess] = req.i18n.__(mess);
         }
-        return outMessages;
+        return {
+            ...outMessages,
+        };
     }
     async getActions(items, type) {
         let arrItems = [];
         for (const item of items) {
             arrItems.push(await this.catalog.find(item.data));
         }
+        console.log(arrItems);
         if (type === 'tools') {
             return (await this.catalog.getActions(arrItems))?.filter(e => e.displayTool);
         }
@@ -57,94 +67,83 @@ export class VueCatalog {
             return (await this.catalog.getActions(arrItems))?.filter(e => e.displayContext);
         }
     }
-    async handleAction(actionId, items, config) {
+    async handleAction(actionId, items, data, req) {
         let arrItems = [];
         for (const item of items) {
             arrItems.push(await this.catalog.find(item.data));
         }
-        return this.catalog.handleAction(actionId, arrItems, config);
+        console.log(arrItems);
+        return this.catalog.handleAction(actionId, arrItems, data, req);
     }
-    async getPopUpHTML(actionId) {
-        return this.catalog.getPopUpHTML(actionId);
+    async getPopUpTemplate(actionId, req) {
+        return this.catalog.getPopUpTemplate(actionId, req);
     }
     async getLink(actionId) {
         return this.catalog.getLink(actionId);
     }
     //Below are the methods that require action
     async getCatalog() {
-        let rootItems = await this.catalog.getChilds(null);
+        let rootItems = await this.catalog.getChilds(0);
         return VueCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
     }
-    createItem(data) {
+    async createItem(data, req) {
+        // TODO It's not clear why it's here.
         //data = VueCatalogUtils.refinement(data);
-        if (this.catalog.slug !== "navigation") {
-            let item = data.record;
-            item.parenId = data.parenId;
-            return this.catalog.createItem(item);
-        }
-        else {
-            return this.catalog.createItem(data);
-        }
-    }
-    async getChilds(data) {
+        // if (this.catalog.slug !== "navigation") {
+        //     let item = data.record;
+        //     item.parenId = data.parenId;
+        //     return await this.catalog.createItem(item, req);
+        // } else {
+        return await this.catalog.createItem(data, req);
+        // }
+    }
+    async getChilds(data, req) {
         data = VueCatalogUtils.refinement(data);
-        return VueCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id), this.catalog.getGroupType().type);
+        return VueCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
     }
     // Moved into actions
     // getCreatedItems(data: any) {
     //   data = VueCatalogUtils.refinement(data);
     //   return this.catalog.getChilds(data.id);
     // }
-    async search(s) {
-        let searchResult = await this.catalog.search(s);
-        let itemsTree = AbstractCatalog.buildTree(searchResult);
-        return VueCatalogUtils.treeToNode(itemsTree, this.catalog.getGroupType().type);
-    }
-    async updateTree(data) {
-        let reqNodes = data.reqNode;
-        if (!Array.isArray(data.reqNode)) {
-            reqNodes = [data.reqNode];
-        }
+    async search(s, req) {
+        let searchResult = await this.catalog.search(s, undefined, req);
+        // let itemsTree = AbstractCatalog.buildTree(searchResult);
+        // console.log(itemsTree)
+        return VueCatalogUtils.treeToNode(searchResult, this.catalog.getGroupType().type);
+    }
+    async updateTree(data, req) {
+        // console.dir(data, {depth: null})
+        // return
         let reqParent = data.reqParent;
-        if (reqParent.data.id === 0) {
-            reqParent.data.id = null;
-        }
-        if (reqParent.data.id === undefined) {
-            throw `reqParent.data.id not defined`;
-        }
-        // It’s unclear why he’s coming reqNodes
-        for (const reqNode of reqNodes) {
-            const item = await this.catalog.find(reqNode.data);
-            if (!item) {
-                throw `reqNode Item not found`;
-            }
-        }
         // Update all items into parent (for two reason: update parent, updare sorting order)
         let sortCount = 0;
         for (const childNode of reqParent.children) {
             childNode.data.sortOrder = sortCount;
             childNode.data.parentId = reqParent.data.id;
-            await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data);
+            await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data, req);
             sortCount++;
         }
         return Promise.resolve('ok');
     }
-    async updateItem(item, modelId, data) {
+    async updateItem(item, modelId, data, req) {
+        //TODO It's not clear why it's here.
         //data = VueCatalogUtils.refinement(data);
-        if (this.catalog.slug !== "navigation") {
-            return await this.catalog.updateModelItems(data.modelId, data.type, data.record);
-        }
-        else {
-            return await this.catalog.updateModelItems(modelId, item.type, data);
-        }
-    }
-    async deleteItem(items) {
-        for (const item1 of items) {
-            if (item1.children?.length) {
-                await this.deleteItem(item1.children);
-            }
-            this.catalog.deleteItem(item1.data.type, item1.data.id);
-        }
+        // if (this.catalog.slug !== "navigation") {
+        //     return await this.catalog.updateModelItems(data.modelId, data.type, data.record, req);
+        // } else {
+        return await this.catalog.updateModelItems(modelId, item.type, data, req);
+        // }
+    }
+    async deleteItem(item, req) {
+        // Получаем всех непосредственных потомков текущего элемента
+        const children = await this.catalog.getChilds(item.id, undefined, req);
+        // Рекурсивно удаляем всех потомков
+        for (const child of children) {
+            await this.deleteItem(child, req);
+        }
+        // После удаления всех потомков удаляем сам элемент
+        await this.catalog.deleteItem(item.type, item.id, req);
         return { ok: true };
     }
 }
@@ -161,16 +160,16 @@ export class VueCatalogUtils {
     static toNode(data, groupTypeName) {
         return {
             data: data,
-            isLeaf: data.type !== groupTypeName,
-            isExpanded: false,
-            ind: data.sortOrder,
-            title: data.name
+            droppable: data.type === groupTypeName,
+            id: data.id,
+            text: data.name,
+            parent: data.parentId,
         };
     }
     static expandTo(vueCatalogData, theseItemIdsNeedToBeOpened) {
         function expand(node) {
             if (theseItemIdsNeedToBeOpened.includes(node.data.id)) {
-                node.isExpanded = true;
+                // node.isExpanded = true;
             }
             if (node.children) {
                 for (const child of node.children) {
@@ -191,7 +190,7 @@ export class VueCatalogUtils {
                     // Sort the children before building their nodes
                     item.childs.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
                     node.children = buildNodes(item.childs);
-                    node.isExpanded = !node.isLeaf;
+                    // node.isExpanded = !node.droppable;
                 }
                 return node;
             });

package/controllers/edit.js

@@ -1,7 +1,7 @@
 import { ControllerHelper } from "../helpers/controllerHelper";
 import { RequestProcessor } from "../lib/requestProcessor";
 import { FieldsHelper } from "../helpers/fieldsHelper";
-import { CatalogHandler } from "../lib/catalog/CatalogHandler";
+import { CatalogHandler } from "../lib/v4/catalog/CatalogHandler";
 import { getRelationsMediaManager, saveRelationsMediaManager } from "../lib/media-manager/helpers/MediaManagerHelper";
 import { DataAccessor } from "../lib/v4/DataAccessor";
 import { Adminizer } from "../lib/Adminizer";
@@ -30,7 +30,7 @@ export default async function edit(req, res) {
     let dataAccessor;
     try {
         const id = req.params.id;
-        dataAccessor = new DataAccessor(req, entity, "edit");
+        dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "edit");
         record = await entity.model.findOne({ id: id }, dataAccessor);
         if (!record)
             return res.status(404).send("Adminpanel > Record not found");
@@ -125,7 +125,7 @@ export default async function edit(req, res) {
                     for (const section of req.adminizer.config.navigation.sections) {
                         let navigation = CatalogHandler.getCatalog('navigation');
                         navigation.setId(section);
-                        let navItem = navigation.itemTypes.find(item => item.type === entity.name);
+                        let navItem = navigation.itemTypes.find(item => item.type === entity.name.toLowerCase());
                         if (navItem) {
                             await navItem.updateModelItems(newRecord[0].id, { record: newRecord[0] }, section);
                         }
@@ -155,16 +155,13 @@ export default async function edit(req, res) {
             }
         }
     }
-    if (req.query.without_layout) {
-        // return res.viewAdmin("./../ejs/partials/content/editPopup.ejs", {
-        //     entity: entity,
-        //     record: record,
-        //     fields: fields
-        // });
-        return null;
+    const props = inertiaAddHelper(req, entity, fields, record);
+    if (req.query?.without_layout) {
+        return res.json({
+            props: props
+        });
     }
     else {
-        const props = inertiaAddHelper(req, entity, fields, record);
         return req.Inertia.render({
             component: 'add',
             props: props

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) {
@@ -16,7 +16,7 @@ export default async function list(req, res) {
             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";

package/controllers/login.js

@@ -33,10 +33,12 @@ export default async function login(req, res) {
                 }
                 return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/`);
             }
-            // Verify CAPTCHA solution
-            const isCaptchaValid = powCaptcha.check(captchaSolution, `login:${req.ip}`);
-            if (!isCaptchaValid) {
-                return inertiaAdminMessage(req, "Invalid CAPTCHA solution", 'captchaSolution');
+            // 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) {
                 return inertiaAdminMessage(req, "Wrong username", 'login');
@@ -66,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: {
@@ -97,7 +102,11 @@ export default async function login(req, res) {
 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/navigation/edit.js

@@ -7,7 +7,7 @@ export default async function edit(req, res) {
         }
     }
     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/remove.js

@@ -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/view.js

@@ -25,7 +25,7 @@ export default async function view(req, res) {
             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/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

@@ -13,3 +13,6 @@ export declare class AccessRightsHelper {
     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;
+        }
+        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/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,9 +1,9 @@
-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;
@@ -15,6 +15,7 @@ export type Field = {
         [key: string]: Field;
     } | undefined;
     model: Attribute;
+    modelConfig: ModelConfig;
 };
 export type Fields = {
     [key: string]: Field;