adminizer 4.7.0-build.224 → 5.0.0-build.1

package/interfaces/adminpanelConfig.d.ts

@@ -1,14 +1,15 @@
 import { MaterialIcon } from "./MaaterialIcons";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
 import { GridSettings as HandsontableSettings } from "handsontable/settings";
-import { GroupAP } from "../models/GroupAP";
-import { UserAP } from "../models/UserAP";
+import { Group } from "../models/Group";
+import { User } from "../models/User";
 import { InternalModelAccessMap } from "./internalModelAccess";
 /**
  * Controller function type - async function that handles requests and returns a response
  */
 export type ControllerFunction = (req: ReqType, res: ResType) => Promise<any>;
 export type AdminpanelIcon = MaterialIcon;
+export type NonEmptyArray<T> = [T, ...T[]];
 export type FieldsTypes = "string" | "password" | "date" | "datetime" | "time" | "integer" | "number" | "float" | "color" | "email" | "month" | "week" | "range" | "boolean" | "binary" | "text" | "longtext" | "mediumtext" | "ckeditor" | "wysiwyg" | "texteditor" | "word" | 'tui' | 'tuieditor' | 'toast-ui' | "jsoneditor" | "json" | "array" | "object" | "ace" | "code" | "html" | "xml" | "aceeditor" | "menu" | "schedule" | "worktime" | "association" | "association-many" | "select" | "select-many" | "table" | "geojson" | "mediamanager" | "single-file" | 
 /**
  * it will be needed only for polygon data
@@ -58,7 +59,7 @@ export interface AdminpanelConfig {
         /**
          * Optional additional link at the bottom of the login page
          * Example:
-         *  addishinalLoginPage: { link: '/model/userap/register', textKey: 'Additional login page' }
+         *  addishinalLoginPage: { link: '/model/User/register', textKey: 'Additional login page' }
          *  link can be relative to routePrefix (e.g. 'model/help' or '/model/help') or absolute (https://...)
          */
         addishinalLoginPage?: {
@@ -98,13 +99,13 @@ export interface AdminpanelConfig {
          * Optional callback to filter or transform all navbar links after models have been processed.
          * Receives all links (static + model-generated) and the current user; returns the final array.
          */
-        handleAdditionalLinks?: (user: UserAP, allLinks: HrefConfig[]) => HrefConfig[];
+        handleAdditionalLinks?: (user: User, allLinks: HrefConfig[]) => HrefConfig[];
         /**
          * Per-section handlers, applied after all links (static + model-generated) are collected.
          * Each key is a section name; the handler receives links belonging to that section.
          */
         sectionHandlers?: {
-            [section: string]: (user: UserAP, links: HrefConfig[]) => HrefConfig[];
+            [section: string]: (user: User, links: HrefConfig[]) => HrefConfig[];
         };
     };
     /**
@@ -198,10 +199,6 @@ export interface AdminpanelConfig {
      * System field for store absolute root path adminpanel hookfolder
      */
     rootPath?: string;
-    /**
-     *  Navigation
-     */
-    navigation?: NavigationConfig;
     mediamanager?: MediaManagerConfig;
     /** System settings */
     system?: {
@@ -395,15 +392,15 @@ export interface ModelConfig {
      * */
     identifierField?: string;
     /** In this field we can set model field, for which we want to check user access right.
-     *  May be association or association-many to UserAP or GroupAP */
+     *  May be association or association-many to User or Group */
     userAccessRelation?: {
         field: string;
         via?: string;
     } | string;
     userAccessRelationCallback?: (userWithGroups: UserWithGroups, record: any) => boolean;
 }
-type UserWithGroups = UserAP & {
-    groups: GroupAP[];
+type UserWithGroups = User & {
+    groups: Group[];
 };
 export type ModelFieldConfig = (BaseFieldConfig | TuiEditorFieldConfig) & {
     groupsAccessRights?: string[];
@@ -491,7 +488,7 @@ export interface TuiEditorFieldConfig extends BaseFieldConfig {
 export interface MediaManagerOptionsField {
     id: 'default' | string;
     group: string;
-    accept: string[];
+    accept: NonEmptyArray<string>;
     initTab?: 'tile-image' | 'table-video' | 'table-text' | 'table-application' | 'table-all' | 'tile-all';
     config?: Record<string, any>;
     onlyView?: boolean;
@@ -586,26 +583,6 @@ export interface HrefConfig {
      */
     section?: string;
 }
-export interface NavigationItemTypeConfig {
-    model: string;
-    title: string;
-    /**
-     *  /page/${data.record.slug}
-     */
-    urlPath: string | ((v: any) => string);
-}
-export interface NavigationConfig {
-    model?: string;
-    sections: string[];
-    groupField: {
-        name: string;
-        required: boolean;
-        label: string;
-    }[];
-    allowContentInGroup?: boolean;
-    items: NavigationItemTypeConfig[];
-    movingGroupsRootOnly?: boolean;
-}
 export interface MediaManagerConfig {
     fileStoragePath: string;
     allowMIME?: string[];

package/interfaces/global.d.ts

@@ -4,7 +4,8 @@ import multer from "multer";
 import { I18n } from "../lib/I18n";
 import { Inertia } from "../lib/inertia/inertiaAdapter";
 import { Flash } from "../lib/inertia/flash";
-import { UserAP } from "../models/UserAP";
+import { User } from "../models/User";
+import { AppRuntime } from "../lib/app-manager/AdminizerApp";
 declare global {
     /** @deprecated use import from TS model decalration */
     type ModelsAP = {
@@ -38,25 +39,20 @@ declare global {
             isPublic?: boolean;
             parent?: ModelsAP["MediaManagerAP"];
         };
-        NavigationAP: {
-            id?: string;
-            label: string;
-            tree: any;
-        };
     };
     type reqSession = {
         flashMessages: Record<string, string[]>;
         xInertiaCurrentComponent: string | undefined;
-        UserAP: UserAP;
+        User: User;
         messages: {
             adminError: string[];
             adminSuccess: string[];
         };
-        userPretended?: UserAP;
+        userPretended?: User;
     };
     type FlashMessages = 'info' | 'error' | 'success' | string;
     type ReqType = Request & {
-        user: UserAP;
+        user: User;
         Inertia: Inertia;
         flash: Flash<FlashMessages>;
         session: reqSession;
@@ -67,7 +63,11 @@ declare global {
         route: {
             [key: string]: string;
         };
+        /**
+         * @deprecated Will be removed in Adminizer v6. Use `runtime` in app controllers.
+         */
         adminizer: Adminizer;
+        runtime: AppRuntime;
         upload: (options?: {
             destination?: string;
             filename?: (file: Express.Multer.File) => string;
@@ -77,12 +77,7 @@ declare global {
         uploadedFileType: string;
         params: Record<string, string>;
     };
-    type ResType = Response & {
-        /**
-         * @deprecated // TODO delete after finish catalog
-         */
-        viewAdmin(specifiedPath: string, locals?: any, cb_view?: Function): void;
-    };
+    type ResType = Response;
     type MiddlewareType = (req: ReqType, res: ResType, next: NextFunction) => void;
     type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
 }

package/interfaces/listQueryBuilder.d.ts

@@ -1,4 +1,4 @@
-import { FilterCondition } from "../models/FilterAP";
+import { FilterCondition } from "../models/Filter";
 /**
  * Input format for list/feed/export query builder.
  * This is not the internal model query language.

package/lib/Adminizer.d.ts

@@ -14,15 +14,29 @@ import type { ViteDevServer } from 'vite';
 import { MenuHelper } from "../helpers/menuHelper";
 import { ControlsHandler } from "./controls/ControlsHandler";
 import { CatalogHandler } from "./catalog/CatalogHandler";
+import { CatalogTemplateComponentHandler } from "./catalog/CatalogTemplateComponentHandler";
 import { AiAssistantHandler } from './ai-assistant/AiAssistantHandler';
 import { NotificationHandler } from './notifications/NotificationHandler';
 import { INotification } from "../interfaces/types";
 import { MediaManagerHandler } from "./media-manager/MediaManagerHandler";
-import { StorageServices } from "./catalog/Navigation";
 import { HistoryHandler } from "./history-actions/HistoryHandler";
 import { CustomFilterHandler } from "./filters/CustomFilterHandler";
 import { FeedbackHandler } from "./feedback/FeedbackHandler";
+import { AppManager } from "./app-manager/AppManager";
+import { ControllerHandler } from "./app-manager/ControllerHandler";
+import { AssetHandler } from "./app-manager/AssetHandler";
+import { ConfigLayerHandler } from "./app-manager/ConfigLayerHandler";
+import { AccessRightsHandler } from "./access-rights/AccessRightsHandler";
+export declare function createAdminizerLogger(): winston.Logger;
+export interface EmitAsyncOptions {
+    /**
+     * Maximum time to wait for each listener. Set to 0 to disable the timeout.
+     * @default 10000
+     */
+    timeoutMs?: number;
+}
 export declare class Adminizer {
+    private static readonly defaultListenerTimeoutMs;
     /**
      * If you convey this default Middleware, it will add it to the very top of the router,
      * and will contact each request
@@ -46,9 +60,14 @@ export declare class Adminizer {
     vite: ViteDevServer;
     controlsHandler: ControlsHandler;
     catalogHandler: CatalogHandler;
+    catalogTemplateComponentHandler: CatalogTemplateComponentHandler;
     mediaManagerHandler: MediaManagerHandler;
-    storageServices: StorageServices;
     feedbackHandler: FeedbackHandler;
+    appManager: AppManager;
+    controllerHandler: ControllerHandler;
+    assetHandler: AssetHandler;
+    configLayerHandler: ConfigLayerHandler;
+    accessRightsHandler: AccessRightsHandler;
     jwtSecret: string;
     static logger: winston.Logger;
     constructor(ormAdapters: AbstractAdapter[]);
@@ -61,6 +80,10 @@ export declare class Adminizer {
     init(config: AdminpanelConfig): Promise<void>;
     sendNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'icon'>): Promise<boolean>;
     get emitter(): EventEmitter;
+    /**
+     * Runs event listeners and waits for async module side effects before continuing.
+     */
+    emitAsync<TPayload = unknown>(event: string | symbol, payload: TPayload, options?: EmitAsyncOptions): Promise<void>;
     getOrmAdapter(ormType: string): AbstractAdapter;
     static get log(): {
         info: (...args: any[]) => winston.Logger;

package/lib/Adminizer.js

@@ -1,5 +1,6 @@
 import express from "express";
 import cookieParser from 'cookie-parser';
+import * as fs from "fs";
 import * as path from "path";
 import winston from "winston";
 import chalk from "chalk";
@@ -9,11 +10,10 @@ import Router from "./../system/Router.js";
 import bindAssets from "../system/bindAssets.js";
 import bindDev from "../system/bindDev.js";
 import bindDashboardWidgets from "../system/bindDashboardWidgets.js";
-import { bindNavigation } from "../system/bindNavigation.js";
 import bindMediaManager from "../system/bindMediaManager.js";
 import bindAccessRights from "../system/bindAccessRights.js";
 import bindAuthorization from "../system/bindAuthorization.js";
-import bindModels from "../system/bindModels.js";
+import { validateSystemModels } from "../system/validateSystemModels.js";
 import bindTranslations from "../system/bindTranslations.js";
 import { ModelHandler } from "./model/ModelHandler.js";
 import { WidgetHandler } from "./widgets/widgetHandler.js";
@@ -28,16 +28,67 @@ import { MenuHelper } from "../helpers/menuHelper.js";
 import { bindControls } from "../system/bindControls.js";
 import { ControlsHandler } from "./controls/ControlsHandler.js";
 import { CatalogHandler } from "./catalog/CatalogHandler.js";
+import { CatalogTemplateComponentHandler } from "./catalog/CatalogTemplateComponentHandler.js";
 import { v4 as uuid } from "uuid";
 import { bindNotifications } from "../system/bindNotifications.js";
-import { bindAiAssistant } from "../system/bindAiAssistant.js";
 import { MediaManagerHandler } from "./media-manager/MediaManagerHandler.js";
 import { bindCors } from "../system/bindCors.js";
 import bindHistory from "../system/bindHistory.js";
 import bindCustomFilterHandlers from "../system/bindCustomFilterHandlers.js";
 import { FeedbackHandler } from "./feedback/FeedbackHandler.js";
 import { buildInternalModelAccess } from "../system/buildInternalModelAccess.js";
+import { AppManager } from "./app-manager/AppManager.js";
+import { ControllerHandler } from "./app-manager/ControllerHandler.js";
+import { AssetHandler } from "./app-manager/AssetHandler.js";
+import { ConfigLayerHandler } from "./app-manager/ConfigLayerHandler.js";
+import { AccessRightsHandler } from "./access-rights/AccessRightsHandler.js";
+const logFilePath = "logs/app.log";
+function ensureLogDirectory(filePath) {
+    const logDirectory = path.dirname(filePath);
+    if (logDirectory !== ".") {
+        fs.mkdirSync(logDirectory, { recursive: true });
+    }
+}
+function isFileLoggingEnabled() {
+    return ["1", "true", "yes"].includes((process.env.ADMINIZER_LOG_TO_FILE ?? "").toLowerCase());
+}
+export function createAdminizerLogger() {
+    const transports = [
+        new winston.transports.Console({
+            format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+                const metaString = Object.keys(meta).length ? JSON.stringify(meta) : "";
+                const colors = {
+                    error: chalk.red,
+                    warn: chalk.yellow,
+                    info: chalk.green,
+                    http: chalk.magenta,
+                    verbose: chalk.cyan,
+                    debug: chalk.blue,
+                    silly: chalk.gray,
+                };
+                const colorize = colors[level] ?? chalk.white;
+                const line = `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
+                return colorize(line);
+            }))
+        }),
+    ];
+    if (isFileLoggingEnabled()) {
+        ensureLogDirectory(logFilePath);
+        transports.push(new winston.transports.File({
+            filename: logFilePath,
+        }));
+    }
+    return winston.createLogger({
+        level: process.env.LOG_LEVEL ?? "debug",
+        format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+            const metaString = Object.keys(meta).length ? JSON.stringify(meta) : "";
+            return `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
+        })),
+        transports,
+    });
+}
 export class Adminizer {
+    static defaultListenerTimeoutMs = 10_000;
     // Preconfigures
     /**
      * If you convey this default Middleware, it will add it to the very top of the router,
@@ -63,42 +114,36 @@ export class Adminizer {
     vite;
     controlsHandler;
     catalogHandler;
+    catalogTemplateComponentHandler;
     mediaManagerHandler;
-    storageServices;
     feedbackHandler;
+    appManager;
+    controllerHandler;
+    assetHandler;
+    configLayerHandler;
+    accessRightsHandler;
     // Constants
     jwtSecret = process.env.JWT_SECRET ?? uuid();
-    static logger = winston.createLogger({
-        level: process.env.LOG_LEVEL ?? "debug",
-        format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
-            const metaString = Object.keys(meta).length ? JSON.stringify(meta) : "";
-            return `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
-        })),
-        transports: [
-            new winston.transports.Console({
-                format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
-                    const metaString = Object.keys(meta).length ? JSON.stringify(meta) : "";
-                    const colors = {
-                        error: chalk.red,
-                        warn: chalk.yellow,
-                        info: chalk.green,
-                        http: chalk.magenta,
-                        verbose: chalk.cyan,
-                        debug: chalk.blue,
-                        silly: chalk.gray,
-                    };
-                    const colorize = colors[level] ?? chalk.white;
-                    const line = `[${timestamp}] ${level.toUpperCase()}: ${message} ${metaString}`;
-                    return colorize(line);
-                }))
-            }),
-            new winston.transports.File({ filename: "logs/app.log" }),
-        ],
-    });
+    static logger = createAdminizerLogger();
     constructor(ormAdapters) {
         this.app = express();
         this._emitter = new EventEmitter();
         this.ormAdapters = ormAdapters;
+        this.modelHandler = new ModelHandler();
+        this.middlewareManager = new MiddlewareManager(this);
+        this.accessRightsHelper = new AccessRightsHelper(this);
+        this.accessRightsHandler = new AccessRightsHandler(this);
+        this.configHelper = new ConfigHelper(this);
+        this.widgetHandler = new WidgetHandler(this);
+        this.controlsHandler = new ControlsHandler();
+        this.catalogHandler = new CatalogHandler();
+        this.catalogTemplateComponentHandler = new CatalogTemplateComponentHandler();
+        this.mediaManagerHandler = new MediaManagerHandler();
+        this.feedbackHandler = new FeedbackHandler(this);
+        this.controllerHandler = new ControllerHandler(this);
+        this.assetHandler = new AssetHandler(this);
+        this.configLayerHandler = new ConfigLayerHandler(this);
+        this.appManager = new AppManager(this);
     }
     getMiddleware() {
         return (req, res, next) => {
@@ -192,22 +237,14 @@ export class Adminizer {
         if (isViteDev)
             await this.viteMiddleware();
         this.emitter.emit('adminizer:init');
-        this.modelHandler = new ModelHandler();
-        // TODO: 'hot reload' unbind models
-        await bindModels(this);
+        // validate models
+        validateSystemModels(this);
         this.modelHandler.configureInternalAccess(buildInternalModelAccess(this.config, this.modelHandler));
         bindCustomFilterHandlers(this);
         this.config.rootPath = path.resolve(import.meta.dirname + "/..");
-        this.middlewareManager = new MiddlewareManager(this);
         await this.middlewareManager.loadMiddlewares();
         // TODO: 'hot reload' problem with deleting access right tokens
-        this.accessRightsHelper = new AccessRightsHelper(this);
-        // Helpers go to construtor
-        this.configHelper = new ConfigHelper(this);
         this.menuHelper = new MenuHelper(this.config);
-        this.widgetHandler = new WidgetHandler(this);
-        this.catalogHandler = new CatalogHandler();
-        this.mediaManagerHandler = new MediaManagerHandler();
         bindExpressUtils(this.app);
         bindReqFunctions(this);
         // Bind assets
@@ -217,8 +254,7 @@ export class Adminizer {
                 bindDev(this);
             }
         }
-        await bindDashboardWidgets(this);
-        await bindNavigation(this);
+        bindDashboardWidgets(this);
         bindMediaManager(this);
         await bindAccessRights(this);
         if (I18n.appendLocale) {
@@ -228,20 +264,15 @@ export class Adminizer {
             this.config.translation = false;
         }
         //bind controls
-        this.controlsHandler = new ControlsHandler();
         bindControls(this);
         // bind Inertia
         bindInertia(this);
         await bindAuthorization(this);
         // Bind notifications
         if (this.config.notifications.enabled)
-            await bindNotifications(this);
-        if (this.config.aiAssistant?.enabled)
-            await bindAiAssistant(this);
+            bindNotifications(this);
         if (this.config.history?.enabled)
-            await bindHistory(this);
-        // FeedbackHandler registers its own route lazily when handler.register() is called
-        this.feedbackHandler = new FeedbackHandler(this);
+            bindHistory(this);
         this.router = new Router(this);
         await this.router.bind(); // must be after binding policies and req/res functions
         /**
@@ -263,6 +294,49 @@ export class Adminizer {
     get emitter() {
         return this._emitter;
     }
+    /**
+     * Runs event listeners and waits for async module side effects before continuing.
+     */
+    async emitAsync(event, payload, options = {}) {
+        const timeoutMs = options.timeoutMs ?? Adminizer.defaultListenerTimeoutMs;
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new RangeError("emitAsync timeoutMs must be a finite non-negative number");
+        }
+        await Promise.all(this._emitter.listeners(event).map(async (listener, listenerIndex) => {
+            const listenerName = listener.name || "<anonymous>";
+            let timeout;
+            try {
+                const listenerPromise = Promise.resolve().then(() => listener.call(this._emitter, payload));
+                if (timeoutMs === 0) {
+                    await listenerPromise;
+                    return;
+                }
+                const timeoutPromise = new Promise((_, reject) => {
+                    timeout = setTimeout(() => {
+                        reject(new Error(`Listener "${listenerName}" for event "${String(event)}" timed out after ${timeoutMs} ms`));
+                    }, timeoutMs);
+                });
+                await Promise.race([listenerPromise, timeoutPromise]);
+            }
+            catch (error) {
+                const normalizedError = error instanceof Error ? error : new Error(String(error));
+                Adminizer.logger.error("Async event listener failed", {
+                    event: String(event),
+                    listener: listenerName,
+                    listenerIndex,
+                    timeoutMs,
+                    error: normalizedError.message,
+                    stack: normalizedError.stack,
+                });
+                throw error;
+            }
+            finally {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+            }
+        }));
+    }
     getOrmAdapter(ormType) {
         return this.ormAdapters.find(item => item.ormType === ormType);
     }

package/lib/DataAccessor.d.ts

@@ -5,18 +5,19 @@ import { ModelResource } from "../interfaces/types";
 import { ActionType } from "../interfaces/adminpanelConfig";
 import { Fields } from "../helpers/fieldsHelper";
 import { Adminizer } from "./Adminizer";
-import { UserAP } from "../models/UserAP";
+import { User } from "../models/User";
 import { QueryCriteria } from "../interfaces/queryCriteria";
 export declare class DataAccessor {
     readonly adminizer: Adminizer;
-    user: UserAP;
+    user: User;
     modelResource: ModelResource;
     action: ActionType;
     private fields;
     private actionVerb;
-    constructor(adminizer: Adminizer, user: UserAP, modelResource: ModelResource, action: ActionType);
+    constructor(adminizer: Adminizer, user: User, modelResource: ModelResource, action: ActionType);
     private getModelConfig;
     private accessRelationModel;
+    private resolveRelationTarget;
     /**
      * Retrieves the fields for the given ModelResource based on action type,
      * taking into account access rights and configuration settings.
@@ -26,14 +27,17 @@ export declare class DataAccessor {
     private orderFieldsByConfig;
     private getAssociatedFieldsConfig;
     private checkFieldAccess;
+    private getSelectedFields;
+    private getPopulateCriteria;
+    private canUseSelectedFieldFallback;
     /**
      * Returns filtered record applying config from this.fields on this record
      * @data - record from a specific model */
-    process<T>(record: T): Partial<T>;
+    process<T>(record: T, criteria?: QueryCriteria): Partial<T>;
     /** Filters associated records (simplified process() function) */
     private filterAssociatedRecord;
     /** Process for an array of records */
-    processMany<T>(records: T[]): Partial<T>[];
+    processMany<T>(records: T[], criteria?: QueryCriteria): Partial<T>[];
     sanitizeUserRelationAccess(criteria?: QueryCriteria): Promise<QueryCriteria>;
     setUserRelationAccess<T>(record: T): Promise<Partial<T>>;
 }