adminizer 4.2.0 → 4.3.0-build.100

package/lib/Adminizer.d.ts

@@ -1,17 +1,19 @@
-import { Express } from "express";
+import express, { Express } from "express";
 import winston from "winston";
 import EventEmitter from 'events';
 import { AdminpanelConfig } from "../interfaces/adminpanelConfig";
-import PolicyManager from "./v4/PolicyManager";
-import { ModelHandler } from "./v4/model/ModelHandler";
-import { WidgetHandler } from "./v4/widgets/widgetHandler";
+import PolicyManager from "./PolicyManager";
+import { ModelHandler } from "./model/ModelHandler";
+import { WidgetHandler } from "./widgets/widgetHandler";
 import { AccessRightsHelper } from "../helpers/accessRightsHelper";
 import { ConfigHelper } from "../helpers/configHelper";
-import { AbstractAdapter } from "./v4/model/AbstractModel";
+import { AbstractAdapter } from "./model/AbstractModel";
 import type { ViteDevServer } from 'vite';
 import { MenuHelper } from "../helpers/menuHelper";
-import { ControlsHandler } from "./v4/controls/ControlsHandler";
-import { CatalogHandler } from "./v4/catalog/CatalogHandler";
+import { ControlsHandler } from "./controls/ControlsHandler";
+import { CatalogHandler } from "./catalog/CatalogHandler";
+import { NotificationHandler } from './notifications/NotificationHandler';
+import { INotification } from "../interfaces/types";
 export declare class Adminizer {
     /**
      * If you convey this default Middleware, it will add it to the very top of the router,
@@ -26,6 +28,7 @@ export declare class Adminizer {
     accessRightsHelper: AccessRightsHelper;
     configHelper: ConfigHelper;
     menuHelper: MenuHelper;
+    notificationHandler: NotificationHandler;
     modelHandler: ModelHandler;
     widgetHandler: WidgetHandler;
     vite: ViteDevServer;
@@ -34,13 +37,18 @@ export declare class Adminizer {
     jwtSecret: string;
     static logger: winston.Logger;
     constructor(ormAdapters: AbstractAdapter[]);
-    getMiddleware(): (req: any, res: any) => void;
+    getMiddleware(): (req: express.Request, res: express.Response, next: () => void) => void;
     /**
      * Vite middleware
      * @protected
      */
     protected viteMiddleware(): Promise<void>;
     init(config: AdminpanelConfig): Promise<void>;
+    sendNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'icon'>): Promise<boolean>;
+    logSystemEvent(title: string, message: string, metadata?: any): Promise<boolean>;
+    logSystemCreatedEvent(title: string, message: string, metadata?: any): Promise<boolean>;
+    logSystemUpdatedEvent(title: string, message: string, metadata?: any): Promise<boolean>;
+    logSystemDeletedEvent(title: string, message: string, metadata?: any): Promise<boolean>;
     get emitter(): EventEmitter;
     getOrmAdapter(ormType: string): AbstractAdapter;
     static get log(): {

package/lib/Adminizer.js

@@ -3,7 +3,7 @@ import cookieParser from 'cookie-parser';
 import * as path from "path";
 import winston from "winston";
 import EventEmitter from 'events';
-import PolicyManager from "./v4/PolicyManager";
+import PolicyManager from "./PolicyManager";
 import Router from "./../system/Router";
 import bindAssets from "../system/bindAssets";
 import bindDev from "../system/bindDev";
@@ -15,20 +15,21 @@ import bindAuthorization from "../system/bindAuthorization";
 import bindModels from "../system/bindModels";
 import bindForms from "../system/bindForms";
 import bindTranslations from "../system/bindTranslations";
-import { ModelHandler } from "./v4/model/ModelHandler";
-import { WidgetHandler } from "./v4/widgets/widgetHandler";
+import { ModelHandler } from "./model/ModelHandler";
+import { WidgetHandler } from "./widgets/widgetHandler";
 import { AccessRightsHelper } from "../helpers/accessRightsHelper";
 import bindReqFunctions from "../system/bindReqFunctions";
 import { ConfigHelper } from "../helpers/configHelper";
-import { I18n } from "./v4/I18n";
+import { I18n } from "./I18n";
 import { getDefaultConfig } from "../system/defaults";
 import bindExpressUtils from "../system/bindExpressUtils";
 import { bindInertia } from "../system/bindInertia";
 import { MenuHelper } from "../helpers/menuHelper";
 import { bindControls } from "../system/bindControls";
-import { ControlsHandler } from "./v4/controls/ControlsHandler";
-import { CatalogHandler } from "./v4/catalog/CatalogHandler";
+import { ControlsHandler } from "./controls/ControlsHandler";
+import { CatalogHandler } from "./catalog/CatalogHandler";
 import { v4 as uuid } from "uuid";
+import { bindNotifications } from "../system/bindNotifications";
 export class Adminizer {
     // Preconfigures
     /**
@@ -45,6 +46,7 @@ export class Adminizer {
     accessRightsHelper;
     configHelper;
     menuHelper;
+    notificationHandler;
     modelHandler;
     widgetHandler;
     vite;
@@ -69,16 +71,61 @@ export class Adminizer {
         this.ormAdapters = ormAdapters;
     }
     getMiddleware() {
-        return (req, res) => {
+        return (req, res, next) => {
+            try {
+                const prefix = (this.config && this.config.routePrefix) ? String(this.config.routePrefix) : '';
+                if (prefix === '/') {
+                    throw new Error('Using "/" as routePrefix is temporarily prohibited');
+                }
+                const normalizedPrefix = prefix.replace(/\/+/g, '/').replace(/\/+$/g, '');
+                // Check if this middleware is already mounted under a prefix
+                const isMountedUnderPrefix = req.baseUrl && req.baseUrl === normalizedPrefix;
+                if (normalizedPrefix && !isMountedUnderPrefix) {
+                    // Legacy behavior: middleware not mounted under prefix, check URL manually
+                    const url = req.originalUrl || req.url || '';
+                    const condition1 = url === normalizedPrefix;
+                    const condition2 = url.startsWith(normalizedPrefix + '/');
+                    const condition3 = url.startsWith('/public');
+                    const conditions = [
+                        condition1,
+                        condition2
+                    ];
+                    if (process.env.IS_SAILS === undefined) {
+                        conditions.push(condition3);
+                    }
+                    if (!conditions.some(condition => condition)) {
+                        return typeof next === 'function' ? next() : undefined;
+                    }
+                }
+                else if (isMountedUnderPrefix) {
+                    // When mounted under prefix, we need to restore the full path for internal routing
+                    // because Router expects routes with full prefix
+                    const originalUrl = req.url;
+                    req.url = normalizedPrefix + req.url;
+                }
+                else {
+                    // No prefix configured, handling all requests
+                }
+            }
+            catch (e) {
+                // fall back to handling the request
+            }
             this.app(req, res, (err) => {
                 if (err) {
-                    console.error("Error in Adminizer", err);
-                    res.writeHead(500, { 'Content-Type': 'text/plain' });
-                    res.end('Internal Server Error');
+                    console.error("❌ Error in Adminizer:", err);
+                    if (!res.headersSent) {
+                        res.writeHead(500, { 'Content-Type': 'text/plain' });
+                        res.end('Internal Server Error');
+                    }
                 }
                 else {
-                    res.writeHead(404, { 'Content-Type': 'text/plain' });
-                    res.end('Route Not Found in Adminizer');
+                    if (typeof next === 'function') {
+                        return next();
+                    }
+                    if (!res.headersSent) {
+                        res.writeHead(404, { 'Content-Type': 'text/plain' });
+                        res.end('Route Not Found in Adminizer');
+                    }
                 }
             });
         };
@@ -173,6 +220,9 @@ export class Adminizer {
         // bind Inertia
         bindInertia(this);
         await bindAuthorization(this);
+        // Bind notifications
+        if (this.config.notifications.enabled)
+            await bindNotifications(this);
         await Router.bind(this); // must be after binding policies and req/res functions
         /**
          * Adminizer loaded
@@ -180,6 +230,39 @@ export class Adminizer {
          */
         this._emitter.emit('adminizer:loaded');
     }
+    // Хелпер для отправки уведомлений
+    async sendNotification(notification) {
+        if (this.config.notifications.enabled) {
+            const notificationClass = notification.notificationClass || 'general';
+            return this.notificationHandler.dispatchNotification(notificationClass, notification);
+        }
+        else {
+            return Promise.resolve(false);
+        }
+    }
+    // Хелпер для системных событий
+    async logSystemEvent(title, message, metadata) {
+        if (this.config.notifications.enabled) {
+            const systemNotificationService = this.notificationHandler.getService('system');
+            return systemNotificationService.logSystemEvent(title, message, 'system', metadata);
+        }
+        else {
+            return Promise.resolve(false);
+        }
+    }
+    // Хелпер для CRUD системных событий
+    async logSystemCreatedEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logCreatedEvent(title, message, metadata);
+    }
+    async logSystemUpdatedEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logUpdatedEvent(title, message, metadata);
+    }
+    async logSystemDeletedEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logDeletedEvent(title, message, metadata);
+    }
     get emitter() {
         return this._emitter;
     }

package/lib/{v4/DataAccessor.d.ts → DataAccessor.d.ts}

@@ -1,13 +1,13 @@
 /**
  * The class manages the interaction between the user and the database entry, taking into account user permissions and the main config file settings.
  */
-import { Entity } from "../../interfaces/types";
-import { ActionType } from "../../interfaces/adminpanelConfig";
-import { Fields } from "../../helpers/fieldsHelper";
-import { Adminizer } from "../Adminizer";
+import { Entity } from "../interfaces/types";
+import { ActionType } from "../interfaces/adminpanelConfig";
+import { Fields } from "../helpers/fieldsHelper";
+import { Adminizer } from "./Adminizer";
 import { UserAP } from "models/UserAP";
 export declare class DataAccessor {
-    private readonly adminizer;
+    readonly adminizer: Adminizer;
     user: UserAP;
     entity: Entity;
     action: ActionType;

package/lib/{v4/DataAccessor.js → DataAccessor.js}

@@ -1,6 +1,6 @@
-import { ControllerHelper } from "../../helpers/controllerHelper";
-import { Adminizer } from "../Adminizer";
-import { isObject } from "../../helpers/JsUtils";
+import { ControllerHelper } from "../helpers/controllerHelper";
+import { Adminizer } from "./Adminizer";
+import { isObject } from "../helpers/JsUtils";
 export class DataAccessor {
     adminizer;
     user;

package/lib/{v4/I18n.js → I18n.js}

@@ -1,7 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { vsprintf } from "sprintf-js";
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "./Adminizer";
 export class I18n {
     devMode;
     static locales = {};
@@ -18,7 +18,7 @@ export class I18n {
     constructor(options = {}) {
         this.devMode = process.env.NODE_ENV !== "production";
         this.defaultLocale = options.defaultLocale || "en";
-        this.directory = options.directory || path.join(import.meta.filename, '../../../translations');
+        this.directory = options.directory || path.join(import.meta.filename, '../../translations');
         this.extension = options.extension || ".json";
         this.cookieName = options.cookieName || "lang";
         this.sessionVarName = options.sessionVarName || "locale";

package/lib/{v4/PolicyManager.d.ts → PolicyManager.d.ts}

@@ -1,4 +1,4 @@
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "./Adminizer";
 declare class PolicyManager {
     private readonly _adminizer;
     constructor(adminizer: Adminizer);

package/lib/{v4/PolicyManager.js → PolicyManager.js}

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "./Adminizer";
 import { pathToFileURL } from "url";
 class PolicyManager {
     _adminizer;
@@ -9,7 +9,7 @@ class PolicyManager {
     }
     async loadPolicies() {
         try {
-            const policiesDirPath = path.join(import.meta.dirname, "../../policies");
+            const policiesDirPath = path.join(import.meta.dirname, "../policies");
             const policiesDir = fs.readdirSync(policiesDirPath);
             for (const policyFile of policiesDir) {
                 if (path.extname(policyFile).toLowerCase() === ".js") {

package/lib/{v4/catalog → catalog}/AbstractCatalog.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../Adminizer";
 /**
  * Interface `Item` describes the data that the UI will operate on
  * This is a common interface for all data that is linked to the catalog

package/lib/{v4/catalog → catalog}/Navigation.d.ts

@@ -1,6 +1,6 @@
 import { AbstractCatalog, ActionHandler, Item } from "./AbstractCatalog";
-import { NavigationConfig } from "../../../interfaces/adminpanelConfig";
-import { Adminizer } from "../../Adminizer";
+import { NavigationConfig } from "../../interfaces/adminpanelConfig";
+import { Adminizer } from "../Adminizer";
 export interface NavItem extends Item {
     urlPath?: string;
     modelId?: string | number;

package/lib/{v4/catalog → catalog}/Navigation.js

@@ -1,6 +1,6 @@
 import { AbstractCatalog, AbstractGroup, AbstractItem } from "./AbstractCatalog";
 import { v4 as uuid } from "uuid";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../Adminizer";
 class StorageService {
     storageMap = new Map();
     id;

package/lib/{v4/controls → controls}/AbstractControls.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../Adminizer";
 export type ControlType = 'wysiwyg' | 'jsonEditor' | 'geoJson' | 'markdown' | 'table' | 'codeEditor';
 export interface Path {
     jsPath: {

package/lib/{v4/controls → controls}/codeEditor/MonacoEditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class MonacoEditor extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{v4/controls → controls}/geojsoneditor/GeoEditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class GeoEditor extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{v4/controls → controls}/jsoneditor/JsonEditor.d.ts

@@ -1,6 +1,6 @@
 import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class JsonEditor extends AbstractControls {
     readonly config: Partial<EditorOptions>;
     readonly name: string;

package/lib/{v4/controls → controls}/markdown/ToastUiEditor.d.ts

@@ -1,6 +1,6 @@
 import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class ToastUiEditor extends AbstractControls {
     readonly config: Partial<EditorOptions>;
     readonly name: string;

package/lib/{v4/controls → controls}/table/Handsontable.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class Handsontable extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{v4/controls → controls}/wysiwyg/CKeditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export declare class CKeditor extends AbstractControls {
     readonly name: string;
     readonly type: ControlType;

package/lib/{v4/controls → controls}/wysiwyg/CKeditor.js

@@ -22,7 +22,7 @@ export class CKeditor extends AbstractControls {
             '|',
             'horizontalLine',
             'link',
-            'insertImageViaUrl',
+            'insertImage',
             'insertTable',
             'blockQuote',
             '|',

package/lib/{v4/datatable → datatable}/NodeTable.d.ts

@@ -1,4 +1,4 @@
-import { Fields } from '../../../helpers/fieldsHelper';
+import { Fields } from '../../helpers/fieldsHelper';
 import { AbstractModel } from '../model/AbstractModel';
 import { DataAccessor } from "../DataAccessor";
 interface Request {

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

@@ -104,7 +104,7 @@ export declare abstract class File<T extends MediaManagerItem> {
      * Delete an item.
      * @param id
      */
-    abstract delete(id: string): Promise<void>;
+    abstract delete(id: string): Promise<boolean>;
     /**
      * Get all items of a type.
      * @param limit
@@ -208,7 +208,7 @@ export declare abstract class AbstractMediaManager {
      * widget Id in the model in which the mediafile was added
      */
     modelId: string, widgetName: string): Promise<void>;
-    abstract getRelations(items: MediaManagerWidgetItem[]): Promise<MediaManagerWidgetClientItem[]>;
+    abstract getItemsList(items: MediaManagerWidgetItem[]): Promise<MediaManagerWidgetClientItem[]>;
     /**
      * Search all items.
      * If not this.allowSearch = true then it will not come here
@@ -258,6 +258,6 @@ export declare abstract class AbstractMediaManager {
      * Delete an item.
      * @param item
      */
-    delete(item: MediaManagerItem): Promise<void>;
+    delete(item: MediaManagerItem): Promise<boolean>;
 }
 export {};

package/lib/media-manager/AbstractMediaManager.js

@@ -50,8 +50,8 @@ export class AbstractMediaManager {
             adminizer.accessRightsHelper.registerToken({
                 id: `mediaManager-${this.id}`,
                 name: this.id,
-                description: `Access to edit catalog for ${this.id}`,
-                department: 'catalog'
+                description: `Access to edit media-manager for ${this.id}`,
+                department: 'media-manager',
             });
         }, 100);
     }

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

@@ -13,5 +13,5 @@ export declare class DefaultMediaManager extends AbstractMediaManager {
     }>;
     searchAll(s: string, group: string): Promise<MediaManagerItem[]>;
     setRelations(data: MediaManagerWidgetData[], model: string, modelId: string, widgetName: string): Promise<void>;
-    getRelations(items: MediaManagerWidgetItem[]): Promise<MediaManagerWidgetClientItem[]>;
+    getItemsList(items: MediaManagerWidgetItem[]): Promise<MediaManagerWidgetClientItem[]>;
 }

package/lib/media-manager/DefaultMediaManager.js

@@ -19,7 +19,7 @@ export class DefaultMediaManager extends AbstractMediaManager {
         this.adminizer = adminizer;
     }
     async getAll(limit, skip, sort, group) {
-        // TODO refactor CRUD functions for DataAccessor usage
+        //TODO refactor CRUD functions for DataAccessor usage
         let data = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
             where: { parent: null, group: group },
             limit: limit,
@@ -41,7 +41,7 @@ export class DefaultMediaManager extends AbstractMediaManager {
         };
     }
     async searchAll(s, group) {
-        // TODO refactor CRUD functions for DataAccessor usage
+        //TODO refactor CRUD functions for DataAccessor usage
         let data = await this.adminizer.modelHandler.model.get(this.model)["_find"]({
             where: { filename: { contains: s }, parent: null, group: group },
             sort: "createdAt DESC",
@@ -56,7 +56,6 @@ export class DefaultMediaManager extends AbstractMediaManager {
         return data;
     }
     async setRelations(data, model, modelId, widgetName) {
-        // TODO refactor CRUD functions for DataAccessor usage
         let modelAssociations = await this.adminizer.modelHandler.model.get(this.modelAssoc)["_find"]({
             where: { modelId: modelId, model: model, widgetName: widgetName },
         });
@@ -64,25 +63,24 @@ export class DefaultMediaManager extends AbstractMediaManager {
             const q = {};
             const pk = this.adminizer.modelHandler.model.get(this.modelAssoc).primaryKey;
             q[pk] = modelAssociation.id;
-            // TODO refactor CRUD functions for DataAccessor usage
             await this.adminizer.modelHandler.model.get(this.modelAssoc)["_destroy"](q);
         }
+        const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileId' : 'file';
         for (const [key, widgetItem] of data.entries()) {
-            // TODO refactor CRUD functions for DataAccessor usage
             await this.adminizer.modelHandler.model.get(this.modelAssoc)["_create"]({
                 mediaManagerId: this.id,
                 model: model,
                 modelId: modelId,
-                file: widgetItem.id,
+                [fieldName]: widgetItem.id,
                 widgetName: widgetName,
                 sortOrder: key + 1,
             });
         }
     }
-    async getRelations(items) {
+    async getItemsList(items) {
         let widgetItems = [];
         for (const item of items) {
-            // TODO refactor CRUD functions for DataAccessor usage
+            //TODO refactor CRUD functions for DataAccessor usage
             let file = (await this.adminizer.modelHandler.model.get(this.model)["_find"]({
                 where: { id: item.id }
             }, { populate: [["variants", { sort: "createdAt DESC" }]] }))[0];

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

@@ -5,6 +5,7 @@ export declare class ImageItem extends File<MediaManagerItem> {
     type: MediaFileType;
     model: string;
     metaModel: string;
+    modelAssoc: string;
     imageSizes: any;
     protected readonly adminizer: Adminizer;
     constructor(adminizer: Adminizer, urlPathPrefix: string, fileStoragePath: string);
@@ -28,7 +29,7 @@ export declare class ImageItem extends File<MediaManagerItem> {
     }): Promise<void>;
     protected resizeImage(input: string, output: string, width: number, height: number): Promise<sharp.OutputInfo>;
     uploadVariant(parent: MediaManagerItem, file: UploaderFile, filename: string, group: string, localeId: string): Promise<MediaManagerItem>;
-    delete(id: string): Promise<void>;
+    delete(id: string): Promise<boolean>;
 }
 export declare class TextItem extends ImageItem {
     type: MediaFileType;

package/lib/media-manager/Items.js

@@ -8,6 +8,7 @@ export class ImageItem extends File {
     type = "image";
     model = "mediamanagerap";
     metaModel = "mediamanagermetaap";
+    modelAssoc = "mediamanagerassociationsap";
     imageSizes;
     adminizer;
     constructor(adminizer, urlPathPrefix, fileStoragePath) {
@@ -176,6 +177,11 @@ export class ImageItem extends File {
         return (await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ where: { id: item.id } }));
     }
     async delete(id) {
+        const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileId' : 'file';
+        const assoc = await this.adminizer.modelHandler.model.get(this.modelAssoc)["_find"]({ where: { [fieldName]: id } });
+        if (assoc.length) {
+            return Promise.resolve(false);
+        }
         const criteria = { where: { id: id } };
         // TODO refactor CRUD functions for DataAccessor usage
         let record = await this.adminizer.modelHandler.model.get(this.model)["_findOne"](criteria);
@@ -189,6 +195,7 @@ export class ImageItem extends File {
                 await deleteFile(variant.path);
             }
         }
+        return Promise.resolve(true);
     }
 }
 /*

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

@@ -17,7 +17,16 @@ export declare function randomFileName(filenameOrig: string, type: string, prefi
  * @param recordId
  */
 export declare function saveRelationsMediaManager(fields: Fields, reqData: PostParams, model: string, recordId: string): Promise<void>;
+/**
+ * Get realtions
+ * @param data
+ */
 export declare function getRelationsMediaManager(data: MediaManagerWidgetJSON): Promise<import("../AbstractMediaManager").MediaManagerWidgetClientItem[]>;
+/**
+ * Delate Ralations
+ * @param model
+ * @param record
+ */
 export declare function deleteRelationsMediaManager(adminizer: Adminizer, model: string, record: {
     [p: string]: string | MediaManagerWidgetItem[];
 }[]): Promise<void>;
@@ -27,4 +36,5 @@ export declare function deleteRelationsMediaManager(adminizer: Adminizer, model:
  * @param model
  */
 export declare function populateVariants(adminizer: Adminizer, variants: MediaManagerItem[], model: string): Promise<MediaManagerItem[]>;
+export declare function getAssociationFieldName(model: any, associationName: string): string;
 export {};

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

@@ -29,19 +29,19 @@ export async function saveRelationsMediaManager(fields, reqData, model, recordId
         }
     }
 }
-/*
-* Get realtions
-* @param data
-*/
+/**
+ * Get realtions
+ * @param data
+ */
 export async function getRelationsMediaManager(data) {
     let mediaManager = MediaManagerHandler.get(data.mediaManagerId);
-    return await mediaManager.getRelations(data.list ?? []);
+    return await mediaManager.getItemsList(data.list ?? []);
 }
-/*
-* Delate Ralations
-* @param model
-* @param record
-*/
+/**
+ * Delate Ralations
+ * @param model
+ * @param record
+ */
 export async function deleteRelationsMediaManager(adminizer, model, record) {
     let config = adminizer.config.models[model];
     for (const key of Object.keys(record[0])) {
@@ -68,3 +68,20 @@ export async function populateVariants(adminizer, variants, model) {
     }
     return items;
 }
+export function getAssociationFieldName(model, associationName) {
+    const attributes = model.attributes || {};
+    // Для вашего случая: file связь использует fileId
+    if (associationName === 'file') {
+        // Проверяем есть ли связь file и какое у нее via
+        if (attributes.file?.type === 'association' && attributes.file.via) {
+            return attributes.file.via; // Вернет 'fileId'
+        }
+        // Или просто проверяем наличие fileId
+        if (attributes.fileId) {
+            return 'fileId';
+        }
+    }
+    // Общий случай
+    const idField = `${associationName}Id`;
+    return attributes[idField] ? idField : associationName;
+}

package/lib/{v4/model → model}/AbstractModel.d.ts

@@ -46,6 +46,18 @@ export declare abstract class AbstractModel<T> {
     protected abstract _destroyOne(criteria: Partial<T>): Promise<T | null>;
     protected abstract _destroy(criteria: Partial<T>): Promise<T[]>;
     protected abstract _count(criteria: Partial<T> | undefined): Promise<number>;
+    /**
+     * Generate diff between old and new records
+     */
+    private generateDiff;
+    /**
+     * Generate delete diff (record vs empty object)
+     */
+    private generateDeleteDiff;
+    /**
+     * Log system event with diff
+     */
+    private logSystemEvent;
     create(data: T, dataAccessor: DataAccessor): Promise<Partial<T>>;
     findOne(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
     find(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;