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

package/lib/history-actions/AbstractHistoryAdapter.d.ts

@@ -1,5 +1,5 @@
-import { HistoryActionsAP } from "../../models/HistoryActionsAP";
-import { UserAP } from "../../models/UserAP";
+import { HistoryActions } from "../../models/HistoryActions";
+import { User } from "../../models/User";
 import { Adminizer } from "../Adminizer";
 import { Fields } from "../../helpers/fieldsHelper";
 import { ActionType } from "../../interfaces/adminpanelConfig";
@@ -49,7 +49,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @param modelName - Name of the model.
      * @returns Promise resolving to an array of history records.
      */
-    abstract getAllModelHistory(modelId: string | number, modelName: string, user: UserAP): Promise<HistoryActionsAP[]>;
+    abstract getAllModelHistory(modelId: string | number, modelName: string, user: User): Promise<HistoryActions[]>;
     /**
      * Retrieves all accessible history records for a user.
      *
@@ -57,8 +57,8 @@ export declare abstract class AbstractHistoryAdapter {
      * @param modelName - Optional model name to filter results.
      * @returns Promise resolving to a record of history data.
      */
-    abstract getAllHistory(user: UserAP, forUserName: string, modelName: string, limit?: number, offset?: number, from?: Date, to?: Date): Promise<{
-        data: HistoryActionsAP[];
+    abstract getAllHistory(user: User, forUserName: string, modelName: string, limit?: number, offset?: number, from?: Date, to?: Date): Promise<{
+        data: HistoryActions[];
     }>;
     /**
      * Saves a new history record.
@@ -66,7 +66,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @param data - History data excluding auto-generated fields (`id`, `createdAt`, `updatedAt`, `isCurrent`).
      * @returns Promise resolving when the record is saved.
      */
-    abstract setHistory(data: Omit<HistoryActionsAP, "id" | "createdAt" | "updatedAt" | "isCurrent" | "user"> & {
+    abstract setHistory(data: Omit<HistoryActions, "id" | "createdAt" | "updatedAt" | "isCurrent" | "user"> & {
         user: string | number;
     }): Promise<void>;
     /**
@@ -77,7 +77,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @param user - User requesting the data (used for access control).
      * @returns Promise resolving to formatted history data.
      */
-    abstract getModelFieldsHistory(historyId: number, user: UserAP): Promise<Record<string, any>>;
+    abstract getModelFieldsHistory(historyId: number, user: User): Promise<Record<string, any>>;
     /**
      * Gets a list of models for which the user has update permissions.
      * Excludes internal models defined in `excludedModels`.
@@ -85,7 +85,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @param user - User whose permissions are checked.
      * @returns Array of model names (in lowercase) the user can access.
      */
-    getModels(user: UserAP): string[];
+    getModels(user: User): string[];
     /**
     * Filters history records based on user access rights.
     * If the user lacks "users-history" permission, only their own records are returned.
@@ -95,7 +95,7 @@ export declare abstract class AbstractHistoryAdapter {
     * @returns A promise resolving to filtered history records accessible to the user.
     * @protected
     */
-    protected _getAllModelHistory(history: HistoryActionsAP[], user: UserAP): Promise<HistoryActionsAP[]>;
+    protected _getAllModelHistory(history: HistoryActions[], user: User): Promise<HistoryActions[]>;
     /**
      * Filters and enhances history records with display names based on model configurations.
      * Ensures only models the user can access are included.
@@ -105,7 +105,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @returns A promise resolving to enhanced history records with `displayName` property.
      * @protected
      */
-    protected _getAllHistory(history: HistoryActionsAP[], user: UserAP): Promise<(HistoryActionsAP & {
+    protected _getAllHistory(history: HistoryActions[], user: User): Promise<(HistoryActions & {
         displayName: string;
     })[]>;
     /**
@@ -117,7 +117,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @returns Promise resolving to formatted data object.
      * @protected
      */
-    protected _getModelFieldsHistory(history: HistoryActionsAP, user: UserAP): Promise<Record<string, any>>;
+    protected _getModelFieldsHistory(history: HistoryActions, user: User): Promise<Record<string, any>>;
     /**
     * Enhances history records with a human-readable display name based on model configuration.
     * Falls back to model ID if display name cannot be determined.
@@ -126,7 +126,7 @@ export declare abstract class AbstractHistoryAdapter {
     * @returns A promise resolving to an array of records with `displayName` property.
     * @protected
     */
-    protected setModelsDisplayName(history: HistoryActionsAP[]): Promise<(HistoryActionsAP & {
+    protected setModelsDisplayName(history: HistoryActions[]): Promise<(HistoryActions & {
         displayName: string;
     })[]>;
     /**
@@ -147,7 +147,7 @@ export declare abstract class AbstractHistoryAdapter {
      * @returns ModelResource object with name, URI, model instance, and config.
      * @protected
      */
-    protected findModelResource(history: HistoryActionsAP): ModelResource;
+    protected findModelResource(history: HistoryActions): ModelResource;
     /**
      * Loads associated records for association-type fields.
      * Populates `records` array in field config for widget rendering.
@@ -158,5 +158,5 @@ export declare abstract class AbstractHistoryAdapter {
      * @returns Promise resolving to updated fields with loaded associations.
      * @protected
      */
-    protected loadAssociations(fields: Fields, user: UserAP, action?: ActionType): Promise<Fields>;
+    protected loadAssociations(fields: Fields, user: User, action?: ActionType): Promise<Fields>;
 }

package/lib/history-actions/AbstractHistoryAdapter.js

@@ -8,15 +8,14 @@ import { isMediaManagerFieldConfig, normalizeMediaManagerWidgetData } from "../m
  * These models are internal or administrative and should not appear in user-accessible history.
  */
 const EXCLUDED_MODELS = new Set([
-    'HistoryActionsAP',
+    'HistoryActions',
     'MediaManagerAP',
     'MediaManagerAssociationsAP',
     'MediaManagerMetaAP',
-    'NavigationAP',
-    'NotificationAP',
-    'UserNotificationAP',
-    'UserAP',
-    'GroupAP'
+    'Notification',
+    'UserNotification',
+    'User',
+    'Group'
 ]);
 /**
  * Abstract base class for handling history operations in the AdminPanel.

package/lib/history-actions/DefaultHistoryAdapter.d.ts

@@ -1,5 +1,5 @@
-import { HistoryActionsAP } from "../../models/HistoryActionsAP";
-import { UserAP } from "../../models/UserAP";
+import { HistoryActions } from "../../models/HistoryActions";
+import { User } from "../../models/User";
 import { Adminizer } from "../Adminizer";
 import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter";
 export declare class DefaultHistoryAdapter extends AbstractHistoryAdapter {
@@ -8,12 +8,12 @@ export declare class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     constructor(adminizer: Adminizer);
     private historyModel;
     private userModel;
-    getAllHistory(user: UserAP, forUserName: string, modelName: string, limit?: number, skip?: number, from?: Date, to?: Date): Promise<{
-        data: HistoryActionsAP[];
+    getAllHistory(user: User, forUserName: string, modelName: string, limit?: number, skip?: number, from?: Date, to?: Date): Promise<{
+        data: HistoryActions[];
     }>;
-    getAllModelHistory(modelId: string | number, modelName: string, user: UserAP): Promise<HistoryActionsAP[]>;
-    getModelFieldsHistory(historyId: number, user: UserAP): Promise<Record<string, any>>;
-    setHistory(data: Omit<HistoryActionsAP, "createdAt" | "updatedAt" | "user"> & {
+    getAllModelHistory(modelId: string | number, modelName: string, user: User): Promise<HistoryActions[]>;
+    getModelFieldsHistory(historyId: number, user: User): Promise<Record<string, any>>;
+    setHistory(data: Omit<HistoryActions, "createdAt" | "updatedAt" | "user"> & {
         user: string | number;
     }): Promise<void>;
 }

package/lib/history-actions/DefaultHistoryAdapter.js

@@ -2,7 +2,7 @@ import { Adminizer } from "../Adminizer.js";
 import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter.js";
 export class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     id = 'default';
-    model = 'historyactionsap';
+    model = 'HistoryActions';
     constructor(adminizer) {
         super(adminizer);
     }
@@ -10,7 +10,7 @@ export class DefaultHistoryAdapter extends AbstractHistoryAdapter {
         return this.adminizer.modelHandler.internal("history").get(this.model);
     }
     userModel() {
-        return this.adminizer.modelHandler.internal("history").get("UserAP");
+        return this.adminizer.modelHandler.internal("history").get("User");
     }
     async getAllHistory(user, forUserName, modelName, limit = 15, skip = 0, from, to) {
         let userId = null;

package/lib/list-query-builder/ListQueryBuilder.d.ts

@@ -1,7 +1,7 @@
 import { Fields } from '../../helpers/fieldsHelper';
 import { AbstractModel } from '../model/AbstractModel';
 import { DataAccessor } from '../DataAccessor';
-import { FilterOperator } from '../../models/FilterAP';
+import { FilterOperator } from '../../models/Filter';
 import { CustomFilterHandler } from '../filters/CustomFilterHandler';
 import { ListQueryBuilderParams, ListQueryBuilderResult } from '../../interfaces/listQueryBuilder';
 import { CriteriaWhere } from '../../interfaces/queryCriteria';

package/lib/media-manager/AbstractMediaManager.d.ts

@@ -1,5 +1,5 @@
+import type { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP";
 import { Adminizer } from "../Adminizer";
-import { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP";
 export interface MediaManagerItem {
     id?: string;
     parent: string | null;
@@ -156,10 +156,21 @@ export declare abstract class AbstractMediaManager {
     abstract id: string;
     readonly itemTypes: File<MediaManagerItem>[];
     /**
-     * @protected
+     * Registers the media manager access right through the legacy Adminizer API.
+     *
+     * @deprecated Starting with Adminizer v6, register access rights through
+     * `ctx.accessRight(...)` in the app's `setup` method.
+     * @param adminizer Adminizer instance used for legacy access-right registration.
      */
-    protected constructor(adminizer: Adminizer);
     private _bindAccessRight;
+    /**
+     * @deprecated The `adminizer` parameter is deprecated and will be removed in
+     * Adminizer v6. Register the media manager through `AppManager` using
+     * `ctx.mediaManager(...)`, and register its access right using
+     * `ctx.accessRight(...)`.
+     * @param adminizer Adminizer instance used by the legacy registration flow.
+     */
+    protected constructor(adminizer: Adminizer);
     /**
      * Upload an item.
      * @param file

package/lib/media-manager/AbstractMediaManager.js

@@ -40,21 +40,32 @@ export class AbstractMediaManager {
     allowSearch;
     itemTypes = [];
     /**
-     * @protected
+     * Registers the media manager access right through the legacy Adminizer API.
+     *
+     * @deprecated Starting with Adminizer v6, register access rights through
+     * `ctx.accessRight(...)` in the app's `setup` method.
+     * @param adminizer Adminizer instance used for legacy access-right registration.
      */
-    constructor(adminizer) {
-        this._bindAccessRight(adminizer);
-    }
     _bindAccessRight(adminizer) {
         setTimeout(() => {
             adminizer.accessRightsHelper.registerToken({
                 id: `mediaManager-${this.id}`,
                 name: this.id,
                 description: `Access to edit media-manager for ${this.id}`,
-                department: 'media-manager',
+                department: "media-manager",
             });
         }, 100);
     }
+    /**
+     * @deprecated The `adminizer` parameter is deprecated and will be removed in
+     * Adminizer v6. Register the media manager through `AppManager` using
+     * `ctx.mediaManager(...)`, and register its access right using
+     * `ctx.accessRight(...)`.
+     * @param adminizer Adminizer instance used by the legacy registration flow.
+     */
+    constructor(adminizer) {
+        this._bindAccessRight(adminizer);
+    }
     /**
      * Upload an item.
      * @param file

package/lib/media-manager/MediaManagerHandler.d.ts

@@ -2,5 +2,8 @@ import { AbstractMediaManager } from "./AbstractMediaManager";
 export declare class MediaManagerHandler {
     private managers;
     add(manager: AbstractMediaManager): void;
+    register(appName: string | undefined, manager: AbstractMediaManager): string;
+    unregister(resourceId: string): void;
     get(id: string): AbstractMediaManager;
+    getByApp(appName: string): AbstractMediaManager[];
 }

package/lib/media-manager/MediaManagerHandler.js

@@ -1,16 +1,36 @@
 import { Adminizer } from "../Adminizer.js";
 export class MediaManagerHandler {
-    managers = [];
+    managers = new Map();
     add(manager) {
-        this.managers.push(manager);
+        this.register(undefined, manager);
+    }
+    register(appName, manager) {
+        if (this.managers.has(manager.id)) {
+            throw new Error(`MediaManager with id "${manager.id}" is already registered`);
+        }
+        const resourceId = appName ? `${appName}:${manager.id}` : manager.id;
+        this.managers.set(manager.id, {
+            resourceId,
+            appName,
+            manager,
+        });
+        return resourceId;
+    }
+    unregister(resourceId) {
+        for (const [managerId, record] of this.managers) {
+            if (record.resourceId === resourceId) {
+                this.managers.delete(managerId);
+                return;
+            }
+        }
     }
     get(id) {
-        let instance = this.managers.find(e => e.id === id);
+        let instance = this.managers.get(id)?.manager;
         /**
          * ✨ We magically get one
          */
-        if (!instance && (id === 'default' || id === undefined) && this.managers.length === 1) {
-            instance = this.managers[0];
+        if (!instance && (id === 'default' || id === undefined) && this.managers.size === 1) {
+            instance = this.managers.values().next().value?.manager;
         }
         if (!instance) {
             Adminizer.log.debug(`MediaManager with id ${id} not found`);
@@ -18,4 +38,9 @@ export class MediaManagerHandler {
         // Adminizer.log.debug(`ins`, instance)  // DEBUG: removed to reduce console noise
         return instance;
     }
+    getByApp(appName) {
+        return Array.from(this.managers.values())
+            .filter((record) => record.appName === appName)
+            .map((record) => record.manager);
+    }
 }

package/lib/media-manager/Thumb.js

@@ -1,6 +1,6 @@
 import sharp from "sharp";
-import { promises as fs } from 'fs';
-import path from 'path';
+import { promises as fs } from "fs";
+import path from "path";
 export class MediaManagerThumb {
     static async getThumb(id, managerId, adminizer) {
         const fileExists = async (filePath) => {
@@ -14,28 +14,22 @@ export class MediaManagerThumb {
         };
         const manager = adminizer.mediaManagerHandler.get(managerId);
         const filePath = await manager.getOrigin(id);
-        // Checking if the path is already absolute
-        const isAbsolute = path.isAbsolute(filePath);
-        // Forming the correct path to the source file
-        const sourcePath = isAbsolute ?
-            path.normalize(filePath) : // If the path is already absolute, normalize it
-            path.join(process.cwd(), filePath); // If relative, add base
-        // Path for thumbnail
-        const baseThumbPath = path.join(process.cwd(), '.tmp', 'thumbs');
+        const sourcePath = path.isAbsolute(filePath)
+            ? path.normalize(filePath)
+            : path.join(process.cwd(), filePath);
+        const baseThumbPath = path.join(process.cwd(), ".tmp", "thumbs");
         await fs.mkdir(baseThumbPath, { recursive: true });
         const thumbPath = path.join(baseThumbPath, `${id}_thumb.webp`);
         if (await fileExists(thumbPath)) {
             return await fs.readFile(thumbPath);
         }
-        // Checking the existence of the file
         if (!await fileExists(sourcePath)) {
             throw new Error(`Source file not found: ${sourcePath}\n` +
                 `Check if file exists at: ${sourcePath}\n` +
                 `Original path from manager: ${filePath}`);
         }
-        // Create a thumbnail
         await sharp(sourcePath)
-            .resize({ width: 150, height: 150, fit: 'cover' })
+            .resize({ width: 150, height: 150, fit: "cover" })
             .toFile(thumbPath);
         return await fs.readFile(thumbPath);
     }

package/lib/media-manager/helpers/MediaManagerHelper.d.ts

@@ -2,6 +2,7 @@ import { Fields } from "../../../helpers/fieldsHelper";
 import { MediaManagerWidgetData, MediaManagerItem, MediaManagerWidgetItem, MediaManagerWidgetJSON } from "../AbstractMediaManager";
 import { BaseFieldConfig } from "../../../interfaces/adminpanelConfig";
 import { Adminizer } from "../../Adminizer";
+import type { AppRuntime } from "../../app-manager/AdminizerApp";
 type PostParams = Record<string, string | number | boolean | object | string[] | number[] | null>;
 export declare function isMediaManagerFieldConfig(fieldConfig: BaseFieldConfig): boolean;
 export declare function normalizeMediaManagerWidgetData(value: PostParams[string] | undefined, prop: string): MediaManagerWidgetData[];
@@ -41,11 +42,12 @@ export declare function getRelationsMediaManager(adminizer: Adminizer, data: Med
 export declare function deleteRelationsMediaManager(adminizer: Adminizer, model: string, record: {
     [p: string]: string | MediaManagerWidgetItem[];
 }[]): Promise<void>;
+type MediaManagerModelHost = Adminizer | Pick<AppRuntime, "models">;
 /**
- * @param adminizer
- * @param variants
- * @param model
+ * Reload variants through the model adapter so their associations are populated.
+ *
+ * Supports both the legacy Adminizer path and app-scoped model access.
  */
-export declare function populateVariants(adminizer: Adminizer, variants: MediaManagerItem[], model: string): Promise<MediaManagerItem[]>;
+export declare function populateVariants(host: MediaManagerModelHost, variants: MediaManagerItem[], model: string): Promise<MediaManagerItem[]>;
 export declare function getAssociationFieldName(model: any, associationName: string): string;
 export {};

package/lib/media-manager/helpers/MediaManagerHelper.js

@@ -80,7 +80,7 @@ export async function updateCurrentHistoryMediaManagerData(adminizer, fields, re
     const mediaData = collectMediaManagerHistoryData(fields, reqData);
     if (!Object.keys(mediaData).length)
         return;
-    const historyModel = adminizer.modelHandler.internal("history").get("HistoryActionsAP");
+    const historyModel = adminizer.modelHandler.internal("history").get("HistoryActions");
     const currentHistory = await historyModel.findOne({
         where: {
             modelId: String(recordId),
@@ -122,33 +122,33 @@ export async function deleteRelationsMediaManager(adminizer, model, record) {
     }
 }
 /**
- * @param adminizer
- * @param variants
- * @param model
+ * Reload variants through the model adapter so their associations are populated.
+ *
+ * Supports both the legacy Adminizer path and app-scoped model access.
  */
-export async function populateVariants(adminizer, variants, model) {
-    let items = [];
-    const mediaModel = adminizer.modelHandler.internal("media-manager").get(model);
-    for (let variant of variants) {
-        variant = await mediaModel.findOne({ where: { id: variant.id } });
-        items.push(variant);
+export async function populateVariants(host, variants, model) {
+    const mediaModel = "models" in host
+        ? host.models.get(model)
+        : host.modelHandler.internal("media-manager").get(model);
+    const items = [];
+    for (const variant of variants ?? []) {
+        const populated = await mediaModel.findOne({ where: { id: variant.id } });
+        if (populated) {
+            items.push(populated);
+        }
     }
     return items;
 }
 export function getAssociationFieldName(model, associationName) {
     const attributes = model.attributes || {};
-    // For your case: file connection uses fileId
-    if (associationName === 'file') {
-        // We check whether there is a file connection and what via it has
-        if (attributes.file?.type === 'association' && attributes.file.via) {
-            return attributes.file.via; // Returns 'fileId'
+    if (associationName === "file") {
+        if (attributes.file?.type === "association" && attributes.file.via) {
+            return attributes.file.via;
         }
-        // Or just check for the presence of fileId
         if (attributes.fileId) {
-            return 'fileId';
+            return "fileId";
         }
     }
-    // General case
     const idField = `${associationName}Id`;
     return attributes[idField] ? idField : associationName;
 }

package/lib/model/AbstractModel.d.ts

@@ -81,14 +81,18 @@ export declare abstract class AbstractAdapter {
     abstract Model: any;
     readonly orm: any;
     readonly ormType: string;
-    protected constructor(type: string, orm: any);
+    readonly systemModels: SystemModelBindings;
+    protected constructor(type: string, orm: any, options?: AbstractAdapterOptions);
     abstract get models(): Record<string, any>;
     /** This function should return constant type from any adapter (for adminizer proper work) */
     abstract getAttributes(modelName: string): ModelAttributes | undefined;
     /** Return full model object */
     abstract getModel(modelName: string): any;
-    /**
-     * This method must ensure system models registration and throw an error in case of errors. We force all adapters to realize it
-     */
-    static registerSystemModels(orm: any): void;
+}
+export type SystemModelBindingValue = string | {
+    model: string;
+};
+export type SystemModelBindings = Record<string, SystemModelBindingValue>;
+export interface AbstractAdapterOptions {
+    systemModels?: SystemModelBindings;
 }

package/lib/model/AbstractModel.js

@@ -128,12 +128,12 @@ export class AbstractModel {
     async findOne(criteria, dataAccessor) {
         criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         let record = await this._findOne(criteria);
-        return record ? dataAccessor.process(record) : null;
+        return record ? dataAccessor.process(record, criteria) : null;
     }
     async find(criteria, dataAccessor) {
         criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         let records = await this._find(criteria);
-        return records.map(record => dataAccessor.process(record));
+        return records.map(record => dataAccessor.process(record, criteria));
     }
     /**
      * Find with raw SQL where clause (Sequelize.literal support)
@@ -165,7 +165,7 @@ export class AbstractModel {
         }
         // Log update event
         await this.logSystemEvent(dataAccessor, 'Updated', dataAccessor.user.id, oldRecord, record);
-        return dataAccessor.process(record);
+        return dataAccessor.process(record, criteria);
     }
     async update(criteria, data, dataAccessor) {
         let _data = dataAccessor.process(data);
@@ -181,7 +181,7 @@ export class AbstractModel {
                 await this.logSystemEvent(dataAccessor, 'Updated', dataAccessor.user.id, oldRecord, record);
             }
         }
-        return records.map(record => dataAccessor.process(record));
+        return records.map(record => dataAccessor.process(record, criteria));
     }
     async destroyOne(criteria, dataAccessor) {
         // Get the record first for diff
@@ -196,7 +196,7 @@ export class AbstractModel {
         }
         // Log delete event
         await this.logSystemEvent(dataAccessor, 'Deleted', dataAccessor.user.id, oldRecord, {});
-        return dataAccessor.process(record);
+        return dataAccessor.process(record, criteria);
     }
     async destroy(criteria, dataAccessor) {
         // Get records first for diff
@@ -211,7 +211,7 @@ export class AbstractModel {
                 await this.logSystemEvent(dataAccessor, 'Deleted', dataAccessor.user.id, oldRecord, {});
             }
         }
-        return records.map(record => dataAccessor.process(record));
+        return records.map(record => dataAccessor.process(record, criteria));
     }
     async count(criteria = {}, dataAccessor) {
         criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
@@ -221,14 +221,10 @@ export class AbstractModel {
 export class AbstractAdapter {
     orm;
     ormType;
-    constructor(type, orm) {
+    systemModels;
+    constructor(type, orm, options = {}) {
         this.ormType = type;
         this.orm = orm;
-    }
-    /**
-     * This method must ensure system models registration and throw an error in case of errors. We force all adapters to realize it
-     */
-    static registerSystemModels(orm) {
-        throw new Error("Function 'registerSystemModels' must be implemented by subclass");
+        this.systemModels = options.systemModels ?? {};
     }
 }

package/lib/model/InternalModelAccessFactory.js

@@ -1,21 +1,20 @@
 import { createInternalModelRepository } from "./internalModelRepository.js";
 export const DEFAULT_INTERNAL_MODEL_ACCESS = {
-    auth: ["UserAP", "GroupAP"],
-    "access-rights": ["UserAP", "GroupAP"],
-    users: ["UserAP", "GroupAP"],
-    filters: ["FilterAP", "FilterColumnAP", "UserAP", "GroupAP"],
+    auth: ["User", "Group"],
+    "access-rights": ["User", "Group"],
+    users: ["User", "Group"],
+    filters: ["Filter", "FilterColumn", "User", "Group"],
     "media-manager": [
         "MediaManagerAP",
         "MediaManagerMetaAP",
         "MediaManagerAssociationsAP",
-        "HistoryActionsAP"
+        "HistoryActions"
     ],
-    history: ["HistoryActionsAP", "UserAP"],
+    history: ["HistoryActions", "User"],
     "data-accessor": [],
-    notifications: ["NotificationAP", "UserNotificationAP", "UserAP"],
-    navigation: ["NavigationAP"],
-    feed: ["FilterAP", "UserAP"],
-    widgets: ["UserAP", "FilterAP"]
+    notifications: ["Notification", "UserNotification", "User"],
+    feed: ["Filter", "User"],
+    widgets: ["User", "Filter"]
 };
 function normalizeName(name) {
     return name.toLowerCase();

package/lib/model/ModelHandler.d.ts

@@ -1,6 +1,26 @@
 import { AbstractModel } from "./AbstractModel";
-import { InternalModelAccessMap } from "../../interfaces/internalModelAccess";
+import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess";
 import { InternalModelScope } from "./InternalModelAccessFactory";
+export interface AppModelAccessRecord {
+    id: string;
+    appName: string;
+    models: string[];
+}
+export interface ModelRecord {
+    id: string;
+    name: string;
+    model: AbstractModel<any>;
+    ownerApp?: string;
+    enabled: boolean;
+}
+export declare class AppModelAccess {
+    private readonly getModel;
+    private readonly appName;
+    private readonly allowedModels;
+    constructor(getModel: (modelName: string) => AbstractModel<any> | undefined, appName: string, allowedModels: () => Set<string>);
+    get<T = any>(modelName: string): InternalModelRepository<T>;
+    has(modelName: string): boolean;
+}
 /**
  * Central registry (service locator) for all AbstractModel instances in the application.
  * A single instance is created in Adminizer and shared across the entire app via `req.adminizer.modelHandler`.
@@ -8,20 +28,32 @@ import { InternalModelScope } from "./InternalModelAccessFactory";
  * Models are registered at startup via `bindModels`, then looked up by name from controllers,
  * services, helpers, and system utilities — without importing each model directly.
  *
- * Lookup is case-insensitive: `"UserAP"`, `"userap"`, and `"USERAP"` all resolve to the same model.
+ * Lookup is case-insensitive and can resolve aliases registered at startup via system model bindings.
  */
 export declare class ModelHandler {
     private models;
+    private modelAliases;
     private internalAccess?;
-    add<T>(modelName: string, modelInstance: AbstractModel<T>): void;
-    /** Improved model getter, so you can write both model.get("UserAP") and model.get("userap") */
+    private appAccessRecords;
+    add<T>(modelName: string, modelInstance: AbstractModel<T>, aliases?: string[]): void;
+    register<T>(appName: string, modelName: string, modelInstance: AbstractModel<T>): string;
+    unregister(id: string): void;
+    disable(id: string): void;
+    enable(id: string): void;
+    getByApp(appName: string): ModelRecord[];
+    registerAppAccess(appName: string, id: string, models: string[]): string;
+    unregisterAppAccess(id: string): void;
+    getAppAccessRecords(appName: string): AppModelAccessRecord[];
+    createAppAccess(appName: string): AppModelAccess;
+    /** Improved model getter with case-insensitive lookup and configured alias support. */
     get model(): {
         get: (modelName: string) => AbstractModel<any>;
         has: (modelName: string) => boolean;
-        entries: () => MapIterator<[string, AbstractModel<any>]>;
-        keys: () => MapIterator<string>;
-        values: () => MapIterator<AbstractModel<any>>;
+        entries: () => IterableIterator<[string, AbstractModel<any>]>;
+        keys: () => IterableIterator<string>;
+        values: () => IterableIterator<AbstractModel<any>>;
     };
+    resolveModelName(modelName: string): string;
     configureInternalAccess(accessMap?: InternalModelAccessMap): void;
     internal(scopeName: string): InternalModelScope;
     private getInternalAccess;
@@ -29,4 +61,10 @@ export declare class ModelHandler {
      * Get all models
      */
     get all(): AbstractModel<any>[];
+    private getAllowedAppModels;
+    private registerAliases;
+    private resolveName;
+    private enabledModelEntries;
+    private enabledModelKeys;
+    private enabledModelValues;
 }