adminizer 4.7.0-build.222 → 5.0.0-build.0

package/controllers/editUser.js

@@ -5,8 +5,8 @@ import { inertiaUserHelper } from "../helpers/inertiaUserHelper.js";
 export default async function (req, res) {
     let modelResource = ControllerHelper.findModelResource(req);
     const internalUsers = req.adminizer.modelHandler.internal("users");
-    const userModel = internalUsers.get("UserAP");
-    const groupModel = internalUsers.get("GroupAP");
+    const userModel = internalUsers.get("User");
+    const groupModel = internalUsers.get("Group");
     // Check id
     if (!req.params.id) {
         return res.status(404).send({ error: 'Not Found' });
@@ -62,7 +62,7 @@ export default async function (req, res) {
             }
             Adminizer.log.debug(`User was updated: `, updatedUser);
             req.flash.setFlashMessage('success', 'User was updated !');
-            return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/userap`);
+            return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/User`);
         }
         catch (e) {
             Adminizer.log.error(e);

package/controllers/feed.js

@@ -36,7 +36,7 @@ export default async function feedController(req, res) {
         }
         const user = await req.adminizer.modelHandler
             .internal("feed")
-            .get("UserAP")
+            .get("User")
             .findOne({ where: { apiKey: userKey } });
         if (!user) {
             return res.status(403).json({ error: 'Invalid userKey' });

package/controllers/filter-fields/columns.js

@@ -85,7 +85,7 @@ export async function updateFilterColumns(req, res) {
         if (!filter) {
             return res.status(404).send({ error: req.i18n.__('Filter not found or access denied') });
         }
-        // Convert frontend column format to FilterColumnAP format
+        // Convert frontend column format to FilterColumn format
         const filterColumns = columns.map((col, index) => ({
             fieldName: col.fieldName,
             order: col.order !== undefined ? col.order : index

package/controllers/filter-fields/getAllUserFilters.js

@@ -7,8 +7,8 @@ import { Adminizer } from "../../lib/Adminizer.js";
  */
 export async function getAllUserFilters(req, res) {
     const filterService = new FilterService(req.adminizer);
-    const userModel = req.adminizer.modelHandler.model.get('userap');
-    const groupModel = req.adminizer.modelHandler.model.get('groupap');
+    const userModel = req.adminizer.modelHandler.model.get('User');
+    const groupModel = req.adminizer.modelHandler.model.get('Group');
     // Cache for group names: { groupId: groupName }
     const groupNamesCache = {};
     const getGroupName = async (groupId) => {

package/controllers/filter-fields/groups.js

@@ -4,9 +4,9 @@
  */
 export async function getAllGroups(req, res) {
     try {
-        const groupModel = req.adminizer.modelHandler.model.get('groupap');
+        const groupModel = req.adminizer.modelHandler.model.get('Group');
         if (!groupModel) {
-            return res.status(500).send({ error: req.i18n.__('GroupAP model not found') });
+            return res.status(500).send({ error: req.i18n.__('Group model not found') });
         }
         const groups = await groupModel['_find']({});
         return res.json({

package/controllers/filter-fields/savedFilters.js

@@ -71,7 +71,7 @@ export async function getSavedFilters(req, res) {
         includeSystem: false
     });
     // Load owner info for each filter
-    const userModel = req.adminizer.modelHandler.model.get('userap');
+    const userModel = req.adminizer.modelHandler.model.get('User');
     const filtersWithOwner = await Promise.all(filters.map(async (filter) => {
         let ownerInfo = null;
         if (userModel && filter.ownerId) {

package/controllers/history-actions/HistoryController.js

@@ -13,7 +13,7 @@ export class HistoryController {
                 `users-history-${adapter.id}`
             ], req.user);
             if (accessToUsersHistory)
-                users = await req.adminizer.modelHandler.model.get('userap')['_find']({});
+                users = await req.adminizer.modelHandler.model.get('User')['_find']({});
             // Getting an array of config.models keys in lowercase for comparison
             const normalizedModelConfig = new Map(Object.entries(req.adminizer.config.models || {}).map(([key, value]) => [
                 key.toLowerCase(),

package/controllers/initUser.js

@@ -6,10 +6,10 @@ export default async function initUser(req, res) {
     if (!req.adminizer.config.auth.enable) {
         return res.redirect(`${req.adminizer.config.routePrefix}/`);
     }
-    const userModel = req.adminizer.modelHandler.internal("auth").get("UserAP");
+    const userModel = req.adminizer.modelHandler.internal("auth").get("User");
     let admins = await userModel.find({ where: { isAdministrator: true } });
     if (admins.length) {
-        res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
+        res.redirect(`${req.adminizer.config.routePrefix}/model/User/login`);
     }
     if (req.method.toUpperCase() === "POST") {
         let login = req.body.login;

package/controllers/list.d.ts

@@ -1 +1 @@
-export default function list(req: ReqType, res: ResType): Promise<import("express").Response<any, Record<string, any>>>;
+export default function list(req: ReqType, res: ResType): Promise<ResType>;

package/controllers/login.d.ts

@@ -1 +1 @@
-export default function login(req: ReqType, res: ResType): Promise<void | (import("express-session").Session & Partial<import("express-session").SessionData> & reqSession) | import("express").Response<any, Record<string, any>>>;
+export default function login(req: ReqType, res: ResType): Promise<void | (import("express-session").Session & Partial<import("express-session").SessionData> & reqSession) | ResType>;

package/controllers/login.js

@@ -14,7 +14,7 @@ export default async function login(req, res) {
             let login = req.body.login;
             let password = req.body.password;
             let captchaSolution = req.body.captchaSolution;
-            const userModel = req.adminizer.modelHandler.internal("auth").get("UserAP");
+            const userModel = req.adminizer.modelHandler.internal("auth").get("User");
             let user;
             try {
                 user = await userModel.findOne({ where: { login: login } });
@@ -122,9 +122,9 @@ export default async function login(req, res) {
         }));
         // Force full page reload after logout
         if (req.headers['x-inertia']) {
-            return res.writeHead(409, { 'x-inertia-location': `${req.adminizer.config.routePrefix}/model/userap/login` }).end();
+            return res.writeHead(409, { 'x-inertia-location': `${req.adminizer.config.routePrefix}/model/User/login` }).end();
         }
-        return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
+        return res.redirect(`${req.adminizer.config.routePrefix}/model/User/login`);
     }
     return res.status(404);
 }

package/controllers/media-manager/ThumbController.js

@@ -3,8 +3,8 @@ export async function thumbController(req, res) {
     const method = req.method.toUpperCase();
     const id = req.query.id;
     const managerId = req.query.managerId;
-    if (method === 'GET') {
-        res.setHeader('Content-Type', 'image/webp');
+    if (method === "GET") {
+        res.setHeader("Content-Type", "image/webp");
         res.send(await MediaManagerThumb.getThumb(id, managerId, req.adminizer));
     }
 }

package/controllers/media-manager/mediaManagerApi.js

@@ -1,39 +1,37 @@
 import { MediaManagerAdapter } from "./mediaManagerAdapter.js";
 export async function mediaManagerController(req, res) {
     const method = req.method.toUpperCase();
-    let id = req.params.id ? req.params.id : '';
-    // const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-    // await delay(1000);
+    const id = req.params.id ? req.params.id : "";
     if (!id) {
         return res.sendStatus(404);
     }
-    const _manager = req.adminizer.mediaManagerHandler.get(id);
-    const manager = new MediaManagerAdapter(_manager);
-    if (method === 'GET') {
-        if (req.query._method === 'getLocales') {
+    const mediaManager = req.adminizer.mediaManagerHandler.get(id);
+    const manager = new MediaManagerAdapter(mediaManager);
+    if (method === "GET") {
+        if (req.query._method === "getLocales") {
             return res.json({ data: manager.getLocales(req) });
         }
         return await manager.get(req, res);
     }
-    if (method === 'POST') {
-        if (req.path.endsWith('/upload')) {
+    if (method === "POST") {
+        if (req.path.endsWith("/upload")) {
             return await manager.upload(req, res);
         }
-        if (req.path.endsWith('/upload-variant')) {
+        if (req.path.endsWith("/upload-variant")) {
             return await manager.uploadVariant(req, res);
         }
         switch (req.body._method) {
-            case 'addMeta':
+            case "addMeta":
                 return await manager.setMeta(req, res);
-            case 'getMeta':
+            case "getMeta":
                 return await manager.getMeta(req, res);
-            case 'getChildren':
+            case "getChildren":
                 return await manager.getVariants(req, res);
-            case 'search':
+            case "search":
                 return await manager.search(req, res);
         }
     }
-    if (method === 'DELETE') {
+    if (method === "DELETE") {
         return await manager.delete(req, res);
     }
 }

package/controllers/register.d.ts

@@ -1 +1 @@
-export default function register(req: ReqType, res: ResType): Promise<void | import("express").Response<any, Record<string, any>>>;
+export default function register(req: ReqType, res: ResType): Promise<void | ResType>;

package/controllers/register.js

@@ -6,8 +6,8 @@ export default async function register(req, res) {
         return res.redirect(`${req.adminizer.config.routePrefix}/`);
     }
     const authModels = req.adminizer.modelHandler.internal("auth");
-    const userModel = authModels.get("UserAP");
-    const groupModel = authModels.get("GroupAP");
+    const userModel = authModels.get("User");
+    const groupModel = authModels.get("Group");
     if (req.method.toUpperCase() === "POST") {
         for (const key of ["login", "fullName", "password"]) {
             if (!req.body[key]) {
@@ -44,7 +44,7 @@ export default async function register(req, res) {
             try {
                 let passwordHashed = generate(req.body.login + req.body.password + process.env.AP_PASSWORD_SALT);
                 let password = 'masked';
-                let userap = await userModel.create({
+                let User = await userModel.create({
                     login: req.body.login,
                     passwordHashed: passwordHashed,
                     fullName: req.body.fullName,
@@ -53,9 +53,9 @@ export default async function register(req, res) {
                     apiKey: generateUserApiKey()
                 });
                 let defaultUserGroup = await groupModel.findOne({ where: { name: req.adminizer.config.registration.defaultUserGroup } });
-                await userModel.updateOne({ where: { id: userap.id } }, {
+                await userModel.updateOne({ where: { id: User.id } }, {
                     groups: [defaultUserGroup.id]
-                }); // instead of UserAP.addToCollection;
+                }); // instead of User.addToCollection;
                 return req.Inertia.redirect(`${req.adminizer.config.routePrefix}`);
             }
             catch (e) {

package/controllers/remove.d.ts

@@ -1 +1 @@
-export default function remove(req: ReqType, res: ResType): Promise<void | import("express").Response<any, Record<string, any>>>;
+export default function remove(req: ReqType, res: ResType): Promise<void | ResType>;

package/controllers/userApiKey.js

@@ -10,7 +10,7 @@ export async function getUserApiKey(req, res) {
     if (!req.user.apiKey) {
         const newKey = generateUserApiKey();
         try {
-            const userModel = req.adminizer.modelHandler.internal("auth").get("UserAP");
+            const userModel = req.adminizer.modelHandler.internal("auth").get("User");
             await userModel.updateOne({ where: { id: req.user.id } }, { apiKey: newKey });
             req.user.apiKey = newKey;
         }
@@ -24,7 +24,7 @@ export async function getUserApiKey(req, res) {
 export async function regenerateUserApiKey(req, res) {
     const newKey = generateUserApiKey();
     try {
-        const userModel = req.adminizer.modelHandler.internal("auth").get("UserAP");
+        const userModel = req.adminizer.modelHandler.internal("auth").get("User");
         await userModel.updateOne({ where: { id: req.user.id } }, { apiKey: newKey });
         Adminizer.log.debug(`User ${req.user.id} regenerated their API key`);
         return res.json({ apiKey: newKey });

package/controllers/view.d.ts

@@ -1 +1 @@
-export default function view(req: ReqType, res: ResType): Promise<void | import("express").Response<any, Record<string, any>>>;
+export default function view(req: ReqType, res: ResType): Promise<void | ResType>;

package/controllers/view.js

@@ -30,10 +30,10 @@ export default async function view(req, res) {
         return res.status(500).send({ error: 'Internal Server Error' });
     }
     switch (modelResource.config.model) {
-        case 'userap':
+        case 'User':
             let groups;
             try {
-                groups = await req.adminizer.modelHandler.internal("users").get("GroupAP").find({});
+                groups = await req.adminizer.modelHandler.internal("users").get("Group").find({});
             }
             catch (e) {
                 Adminizer.log.error(e);
@@ -43,17 +43,17 @@ export default async function view(req, res) {
                 component: 'add-user',
                 props: userProps
             });
-        case 'groupap':
+        case 'Group':
             let users;
             try {
-                users = await req.adminizer.modelHandler.internal("users").get("UserAP").find({ where: { isAdministrator: false } });
+                users = await req.adminizer.modelHandler.internal("users").get("User").find({ where: { isAdministrator: false } });
             }
             catch (e) {
                 Adminizer.log.error(e);
             }
             let group;
             try {
-                group = await req.adminizer.modelHandler.internal("users").get("GroupAP").findOne({ where: { id: Number(req.params.id) } });
+                group = await req.adminizer.modelHandler.internal("users").get("Group").findOne({ where: { id: Number(req.params.id) } });
             }
             catch (e) {
                 Adminizer.log.error('Admin edit error: ');

package/controllers/widgets/Action.js

@@ -9,8 +9,11 @@ export async function widgetActionController(req, res) {
     }
     else if (req.method.toUpperCase() === 'POST') {
         try {
-            await widget.action();
-            return res.json({ ok: true });
+            const data = await widget.action();
+            if (data && typeof data === "object" && !Array.isArray(data)) {
+                return res.json({ ok: true, ...data });
+            }
+            return res.json({ ok: true, data });
         }
         catch (error) {
             return res.json(error);

package/controllers/widgets/Info.js

@@ -10,7 +10,7 @@ export async function widgetInfoController(req, res) {
     /** get state */
     if (req.method.toUpperCase() === 'GET') {
         try {
-            let text = await widget.getInfo();
+            let text = await widget.getInfo({ user: req.user });
             return res.send(text);
         }
         catch (e) {

package/controllers/widgets/filterInfo.js

@@ -4,7 +4,7 @@ async function resolveDashboardUser(req) {
         return req.user;
     }
     const adminLogin = req.adminizer.config.administrator?.login ?? "admin";
-    const userModel = req.adminizer.modelHandler.internal("widgets").get("UserAP");
+    const userModel = req.adminizer.modelHandler.internal("widgets").get("User");
     const user = await userModel.findOne({ where: { login: adminLogin } });
     return user ?? null;
 }

package/helpers/accessRightsHelper.d.ts

@@ -1,4 +1,4 @@
-import { UserAP } from "../models/UserAP";
+import { User } from "../models/User";
 import { AccessRightsToken } from "../interfaces/types";
 import { Adminizer } from "../lib/Adminizer";
 export declare class AccessRightsHelper {
@@ -6,14 +6,16 @@ export declare class AccessRightsHelper {
     adminizer: Adminizer;
     constructor(adminizer: Adminizer);
     registerToken(accessRightsToken: AccessRightsToken): void;
+    unregisterToken(tokenId: string): boolean;
+    hasToken(tokenId: string): boolean;
     registerTokens(accessRightsTokens: AccessRightsToken[]): void;
     registerModelTokens(modelName: string, department?: string): void;
     getTokens(): AccessRightsToken[];
     getTokensByDepartment(department: string): AccessRightsToken[];
     getAllDepartments(): string[];
-    enoughPermissions(tokens: string[], user: UserAP): boolean;
-    hasPermission(tokenId: string | undefined, user: UserAP, context?: string): boolean;
+    enoughPermissions(tokens: string[], user: User): boolean;
+    hasPermission(tokenId: string | undefined, user: User, context?: string): boolean;
 }
 export declare class GroupsAccessRightsHelper {
-    static hasAccess(user: UserAP, groupsAccessRights?: string[]): boolean;
+    static hasAccess(user: User, groupsAccessRights?: string[]): boolean;
 }

package/helpers/accessRightsHelper.js

@@ -18,6 +18,19 @@ export class AccessRightsHelper {
         }
         this._tokens.push(accessRightsToken);
     }
+    unregisterToken(tokenId) {
+        const normalizedTokenId = tokenId.toLowerCase();
+        const index = this._tokens.findIndex((token) => token.id === normalizedTokenId);
+        if (index === -1) {
+            return false;
+        }
+        this._tokens.splice(index, 1);
+        return true;
+    }
+    hasToken(tokenId) {
+        const normalizedTokenId = tokenId.toLowerCase();
+        return this._tokens.some((token) => token.id === normalizedTokenId);
+    }
     registerTokens(accessRightsTokens) {
         for (let token of accessRightsTokens) {
             this.registerToken(token);

package/helpers/diffHelpers.js

@@ -6,7 +6,7 @@ export function sanitizeForDiff(data) {
     const systemFields = ['id', 'createdAt', 'updatedAt', 'deletedAt', '__v', '_id'];
     systemFields.forEach(field => delete result[field]);
     // Cleaning sensitive data
-    // TODO: Place in environment variables or config
+    // TODO: Place in environment variables or config & put in docs
     const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'creditCard'];
     sensitiveFields.forEach(field => {
         if (result[field] !== undefined) {

package/helpers/fieldsHelper.d.ts

@@ -28,7 +28,7 @@ export declare class FieldsHelper {
      * @param {Object} fields
      * @param user
      * @param action
-     * @deprecated use DataModel class
+     * @deprecated this method has overload association tree on each request that is not optimize
      */
     static loadAssociations(req: ReqType, fields: Fields, action?: ActionType): Promise<Fields>;
 }

package/helpers/fieldsHelper.js

@@ -8,8 +8,9 @@ export class FieldsHelper {
      * @param {Object} fields
      * @param user
      * @param action
-     * @deprecated use DataModel class
+     * @deprecated this method has overload association tree on each request that is not optimize
      */
+    // TODO: make separate request for all dropdown relations by api call
     static async loadAssociations(req, fields, action) {
         /**
          * Load all associated records for given field key
@@ -29,7 +30,8 @@ export class FieldsHelper {
                 Adminizer.log.error('No model found for field: ', fields[key]);
                 return;
             }
-            let Model = req.adminizer.modelHandler.model.get(modelName);
+            const resolvedModelName = req.adminizer.modelHandler.resolveModelName(modelName);
+            let Model = req.adminizer.modelHandler.model.get(resolvedModelName);
             if (!Model) {
                 return;
             }
@@ -39,8 +41,10 @@ export class FieldsHelper {
                 Adminizer.log.warn("Warning: executing malicious job trying to add a huge amount of records in field config," +
                     " please rewrite this part of code in the nearest future");
                 let modelResource = {
-                    name: modelName, config: req.adminizer.config.models[modelName],
-                    model: Model, uri: `${req.adminizer.config.routePrefix}/model/${modelName}`
+                    name: resolvedModelName,
+                    config: req.adminizer.config.models[resolvedModelName],
+                    model: Model,
+                    uri: `${req.adminizer.config.routePrefix}/model/${resolvedModelName}`
                 };
                 let dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "view");
                 list = await Model.find({}, dataAccessor);

package/helpers/filterDatetimeHelper.d.ts

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

package/helpers/inertiaAddHelper.d.ts

@@ -1,7 +1,7 @@
 import { ModelResource, PropsField } from "../interfaces/types";
 import { Actions } from "./inertiaActionsHelper";
 import { Fields, Field } from "./fieldsHelper";
-import { AbstractControls, ControlType } from "../lib/controls/AbstractControls";
+import { Control, ControlType } from "../lib/controls/Control";
 export type PropsFieldType = 'text' | 'number' | 'range' | 'week' | 'month' | 'email' | 'color' | 'time' | 'date' | 'datetime-local' | 'password' | 'select' | 'select-many' | 'association-many' | 'association' | 'textarea' | 'mediamanager' | 'single-file' | 'checkbox' | ControlType;
 interface FieldProps extends Record<string | number | symbol, unknown> {
     edit: boolean;
@@ -24,13 +24,14 @@ interface FieldProps extends Record<string | number | symbol, unknown> {
     model: string;
 }
 export default function inertiaAddHelper(req: ReqType, modelResource: ModelResource, fields: Fields, record?: Record<string, string | boolean | number | string[]>, view?: boolean): FieldProps;
-export declare function getControlsOptions(fieldConfig: Field["config"], req: ReqType, type: ControlType, defaultControlName: string): {
+export declare function getControlsOptions(fieldConfig: Field["config"], req: ReqType, type: ControlType, defaultControlName: string, context?: string): {
     name: string;
     config: any;
-    path: {};
+    path: string;
+    cssPath: string;
 };
-export declare function inputText(type: string, isIn: string[]): "email" | "password" | "date" | "time" | "number" | "color" | "month" | "week" | "range" | "text" | "select" | "datetime-local";
-export declare function getControl(req: ReqType, type: ControlType, name: string | undefined, defaultControlName: string): AbstractControls;
+export declare function inputText(type: string, isIn: string[]): "email" | "password" | "month" | "text" | "number" | "date" | "time" | "color" | "week" | "range" | "select" | "datetime-local";
+export declare function getControl(req: ReqType, type: ControlType, name: string | undefined, defaultControlName: string, context?: string): Control;
 export declare function setAssociationValues(field: Field, value: string[]): {
     initOptions: {
         label: any;

package/helpers/inertiaAddHelper.js

@@ -1,6 +1,7 @@
 import inertiaActionsHelper from "./inertiaActionsHelper.js";
-import chalk from "chalk";
 import { isObject } from "./JsUtils.js";
+import { Adminizer } from "../lib/Adminizer.js";
+const missingControlWarnings = new Set();
 /**
  * Get ISO week number from date
  * @param date - Date object
@@ -59,6 +60,7 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
         let value = record ? record[key] : undefined;
         let relatedModel = undefined;
         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)) {
             disabled = true;
@@ -111,7 +113,10 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
             const { initValue, initOptions } = setAssociationValues(field, value);
             options = initOptions;
             value = initValue;
-            relatedModel = (field.model?.model || field.model?.collection);
+            const rawRelatedModel = (field.model?.model || field.model?.collection);
+            relatedModel = rawRelatedModel
+                ? req.adminizer.modelHandler.resolveModelName(rawRelatedModel)
+                : undefined;
             if (relatedModel && req.user) {
                 canCreateRelated = req.adminizer.accessRightsHelper.hasPermission(`create-${relatedModel}-model`, req.user);
             }
@@ -127,27 +132,27 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
         }
         if (['ckeditor', 'wysiwyg', 'texteditor', 'word'].includes(type)) {
             fieldType = 'wysiwyg';
-            options = getControlsOptions(fieldConfig, req, fieldType, 'ckeditor');
+            options = getControlsOptions(fieldConfig, req, fieldType, 'ckeditor', controlContext);
         }
         if (['tui', 'tuieditor', 'toast-ui'].includes(type)) {
             fieldType = 'markdown';
-            options = getControlsOptions(fieldConfig, req, fieldType, 'toast-ui');
+            options = getControlsOptions(fieldConfig, req, fieldType, 'toast-ui', controlContext);
         }
         if (type === 'table') {
             fieldType = 'table';
-            options = getControlsOptions(fieldConfig, req, fieldType, 'handsontable');
+            options = getControlsOptions(fieldConfig, req, fieldType, 'handsontable', controlContext);
         }
         if (['jsoneditor', 'json', 'array', 'object'].includes(type)) {
             fieldType = 'jsonEditor';
-            options = getControlsOptions(fieldConfig, req, fieldType, 'jsoneditor');
+            options = getControlsOptions(fieldConfig, req, fieldType, 'jsoneditor', controlContext);
         }
         if (['ace', 'html', 'xml', 'aceeditor', 'code'].includes(type)) {
             fieldType = 'codeEditor';
-            options = getControlsOptions(fieldConfig, req, fieldType, 'monaco');
+            options = getControlsOptions(fieldConfig, req, fieldType, 'monaco', controlContext);
         }
         if (['geojson', 'geo-polygon', 'geo-marker'].includes(type)) {
             fieldType = 'geoJson';
-            options = getControlsOptions(fieldConfig, req, fieldType, 'leaflet');
+            options = getControlsOptions(fieldConfig, req, fieldType, 'leaflet', controlContext);
         }
         if (type === 'mediamanager' || type === 'single-file') {
             const mConfig = field.config;
@@ -177,30 +182,28 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
     }
     return props;
 }
-export function getControlsOptions(fieldConfig, req, type, defaultControlName) {
+export function getControlsOptions(fieldConfig, req, type, defaultControlName, context) {
     if (!isObject(fieldConfig))
         throw `Type error: fieldConfig is object`;
     const fieldOptions = fieldConfig?.options;
-    let control = getControl(req, type, fieldOptions?.name, defaultControlName);
-    let editorName = control.getName();
-    let options = {
+    const control = getControl(req, type, fieldOptions?.name, defaultControlName, context);
+    const editorName = control.getName();
+    const shouldUseFieldConfig = !fieldOptions?.name || fieldOptions.name === editorName;
+    const options = {
         name: editorName,
         config: {
             ...(control?.getConfig() || {}), // Base config of the editor
-            ...(fieldOptions?.config || {}), // Additional config provided in the field config
+            ...(shouldUseFieldConfig ? fieldOptions?.config || {} : {}),
         },
-        path: control?.getJsPath() || {},
+        path: control.getJsPath(),
+        cssPath: control.getCssPath(),
     };
-    if (type === 'wysiwyg') {
-        let options = {
-            name: editorName,
-            config: control?.getConfig() || {},
-            path: control?.getJsPath() || {},
-        };
-        // If items are provided, use them instead of the editor's config
-        if (fieldOptions?.config?.items && editorName === 'ckeditor') {
-            options.config = { items: fieldOptions.config.items };
-        }
+    // If items are provided, use them instead of the CKEditor defaults.
+    if (type === 'wysiwyg'
+        && editorName === 'ckeditor'
+        && shouldUseFieldConfig
+        && fieldOptions?.config?.items) {
+        options.config = { items: fieldOptions.config.items };
     }
     return options;
 }
@@ -237,21 +240,26 @@ export function inputText(type, isIn) {
         }
     }
 }
-export function getControl(req, type, name, defaultControlName) {
-    let control;
-    let editorName = defaultControlName; // default editor name
-    // Determine which editor to use
+export function getControl(req, type, name, defaultControlName, context) {
+    const requestedControlName = name ?? defaultControlName;
+    const requestedControl = req.adminizer.controlsHandler.get(type, requestedControlName);
+    if (requestedControl) {
+        return requestedControl;
+    }
     if (name) {
-        editorName = name;
+        const warningKey = `${context ?? "unknown"}:${type}:${name}:${defaultControlName}`;
+        if (!missingControlWarnings.has(warningKey)) {
+            missingControlWarnings.add(warningKey);
+            Adminizer.log.warn(`Control "${name}" for ${context ?? `type "${type}"`} is unavailable; ` +
+                `falling back to "${defaultControlName}".`);
+        }
     }
-    // Get the editor instance
-    control = req.adminizer.controlsHandler.get(type, editorName);
-    // Fallback to ckeditor if specified editor not found
-    if (!control) {
-        console.log(chalk.yellow(`Control ${type} - ${name} not found, falling back to default`));
-        control = req.adminizer.controlsHandler.get(type, defaultControlName);
+    const defaultControl = req.adminizer.controlsHandler.get(type, defaultControlName);
+    if (!defaultControl) {
+        throw new Error(`Default control "${defaultControlName}" for type "${type}" is not registered` +
+            (context ? ` (${context})` : ""));
     }
-    return control;
+    return defaultControl;
 }
 export function setAssociationValues(field, value) {
     let options = [];
@@ -282,7 +290,7 @@ export function setAssociationValues(field, value) {
     };
     for (let opt of config.records) {
         const optAny = opt;
-        const displayField = typeof field.modelConfig.titleField !== 'undefined'
+        const displayField = typeof field.modelConfig?.titleField !== 'undefined'
             ? field.modelConfig.titleField
             : typeof optAny.title !== 'undefined'
                 ? 'title'