adminizer 4.2.0 → 4.3.0-build.101

package/lib/model/AbstractModel.js

@@ -0,0 +1,178 @@
+import { formatChanges, sanitizeForDiff } from "../../helpers/diffHelpers";
+import { diff } from "deep-object-diff";
+export class AbstractModel {
+    modelname;
+    attributes;
+    primaryKey;
+    identity;
+    constructor(modelname, attributes, primaryKey, identity) {
+        this.modelname = modelname;
+        this.attributes = attributes;
+        this.primaryKey = primaryKey;
+        this.identity = identity;
+    }
+    /**
+     * Generate diff between old and new records
+     */
+    generateDiff(oldRecord, newRecord) {
+        const cleanOldRecord = sanitizeForDiff(oldRecord);
+        const cleanNewRecord = sanitizeForDiff(newRecord);
+        const changesDiff = diff(cleanOldRecord, cleanNewRecord);
+        const formattedChanges = formatChanges(changesDiff, cleanOldRecord, cleanNewRecord);
+        return {
+            changesDiff,
+            formattedChanges,
+            cleanOldRecord,
+            cleanNewRecord
+        };
+    }
+    /**
+     * Generate delete diff (record vs empty object)
+     */
+    generateDeleteDiff(record) {
+        const cleanRecord = sanitizeForDiff(record);
+        const changesDiff = diff(cleanRecord, {});
+        const formattedChanges = formatChanges(changesDiff, cleanRecord, {});
+        return {
+            changesDiff,
+            formattedChanges,
+            cleanRecord
+        };
+    }
+    /**
+     * Log system event with diff
+     */
+    async logSystemEvent(dataAccessor, eventType, message, oldRecord, newRecord) {
+        let formattedChanges = [];
+        let summary = '';
+        switch (eventType) {
+            case 'Created':
+                const cleanNewRecord = sanitizeForDiff(newRecord);
+                formattedChanges = formatChanges({}, {}, cleanNewRecord, 'add');
+                summary = `Created ${formattedChanges.length} fields`;
+                break;
+            case 'Updated':
+                const { formattedChanges: updateChanges } = this.generateDiff(oldRecord, newRecord);
+                formattedChanges = updateChanges;
+                summary = `Changes ${formattedChanges.length} fields`;
+                break;
+            case 'Deleted':
+                const { formattedChanges: deleteChanges } = this.generateDeleteDiff(oldRecord);
+                formattedChanges = deleteChanges;
+                summary = `Deleted ${formattedChanges.length} fields`;
+                break;
+        }
+        // log system event notification
+        await dataAccessor.adminizer.logSystemEvent(eventType, message, {
+            changes: formattedChanges,
+            summary
+        });
+    }
+    async create(data, dataAccessor) {
+        let _data = await dataAccessor.setUserRelationAccess(dataAccessor.process(data));
+        let record = await this._create(_data);
+        // Log creation event
+        await this.logSystemEvent(dataAccessor, 'Created', 
+        // @ts-ignore
+        `user ${dataAccessor.user.login} create ${dataAccessor.entity.name} ${record[this.primaryKey]}`, {}, _data);
+        return dataAccessor.process(record);
+    }
+    async findOne(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        let record = await this._findOne(criteria);
+        return record ? dataAccessor.process(record) : null;
+    }
+    async find(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        let records = await this._find(criteria);
+        return records.map(record => dataAccessor.process(record));
+    }
+    async updateOne(criteria, data, dataAccessor) {
+        let _data = dataAccessor.process(data);
+        // Get the old record first for diff
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        const oldRecord = await this._findOne(criteria);
+        if (!oldRecord) {
+            return null;
+        }
+        let record = await this._updateOne(criteria, _data);
+        if (!record) {
+            return null;
+        }
+        // Log update event
+        await this.logSystemEvent(dataAccessor, 'Updated', 
+        // @ts-ignore
+        `user ${dataAccessor.user.login} update ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, record);
+        return dataAccessor.process(record);
+    }
+    async update(criteria, data, dataAccessor) {
+        let _data = dataAccessor.process(data);
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        // Get old records automatically
+        const oldRecords = await this._find(criteria);
+        let records = await this._update(criteria, _data);
+        // Log update events for each record
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            const oldRecord = oldRecords[i];
+            if (oldRecord) {
+                await this.logSystemEvent(dataAccessor, 'Updated', 
+                // @ts-ignore
+                `user ${dataAccessor.user.login} update ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, record);
+            }
+        }
+        return records.map(record => dataAccessor.process(record));
+    }
+    async destroyOne(criteria, dataAccessor) {
+        // Get the record first for diff
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        const oldRecord = await this._findOne(criteria);
+        if (!oldRecord) {
+            return null;
+        }
+        let record = await this._destroyOne(criteria);
+        if (!record) {
+            return null;
+        }
+        // Log delete event
+        await this.logSystemEvent(dataAccessor, 'Deleted', 
+        //@ts-ignore
+        `user ${dataAccessor.user.login} delete ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, {});
+        return dataAccessor.process(record);
+    }
+    async destroy(criteria, dataAccessor) {
+        // Get records first for diff
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        const oldRecords = await this._find(criteria);
+        let records = await this._destroy(criteria);
+        // Log delete events for each record
+        for (let i = 0; i < records.length; i++) {
+            const record = records[i];
+            const oldRecord = oldRecords[i];
+            if (oldRecord) {
+                await this.logSystemEvent(dataAccessor, 'Deleted', 
+                //@ts-ignore
+                `user ${dataAccessor.user.login} delete ${dataAccessor.entity.name} ${record[this.primaryKey]}`, oldRecord, {});
+            }
+        }
+        return records.map(record => dataAccessor.process(record));
+    }
+    async count(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
+        return this._count(criteria);
+    }
+}
+export class AbstractAdapter {
+    orm;
+    ormType;
+    constructor(type, orm) {
+        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");
+    }
+}

package/lib/{v4/model → model}/ModelHandler.js

@@ -1,4 +1,4 @@
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../Adminizer";
 export class ModelHandler {
     models = new Map();
     add(modelName, modelInstance) {

package/lib/{v4/model → model}/adapter/sequelize.d.ts

@@ -22,14 +22,13 @@ export declare class SequelizeModel<T> extends AbstractModel<T> {
     protected _count(criteria?: Partial<T>): Promise<number>;
     private _buildIncludes;
 }
-/** SequelizeAdapter — адаптер, заменяющий WaterlineAdapter */
 export declare class SequelizeAdapter extends AbstractAdapter {
-    private sequelize;
+    sequelize: Sequelize;
     Model: typeof SequelizeModel;
     constructor(sequelize: Sequelize);
     get models(): Record<string, any>;
     getModel(modelName: string): any;
     getAttributes(modelName: string): any;
-    /**Registration of system models*/
-    static registerSystemModels(sequelize: Sequelize): Promise<void>;
+    /** Registration of system models */
+    static registerSystemModels(sequelize: Sequelize, alter?: boolean): Promise<void>;
 }

package/lib/{v4/model → model}/adapter/sequelize.js

@@ -15,7 +15,11 @@ function generateAssociationsFromSchema(models, schemas) {
                 const targetModel = models[field.collection];
                 const targetSchema = schemas[field.collection];
                 const inverseField = targetSchema?.[field.via];
-                const throughTableName = [modelName, field.collection].sort().join("");
+                // Normalize join table to lowercase for consistency across dialects
+                const throughTableName = [modelName, field.collection]
+                    .sort()
+                    .join("")
+                    .toLowerCase();
                 // 💡 M:N связь
                 if (inverseField && inverseField.collection === modelName) {
                     model.belongsToMany(targetModel, {
@@ -170,6 +174,10 @@ export class SequelizeModel extends AbstractModel {
             if (value === null) {
                 result[targetKey] = { [Op.is]: null };
             }
+            else if (Array.isArray(value)) {
+                // ✅ Обработка массивов - используем оператор IN
+                result[targetKey] = { [Op.in]: value };
+            }
             else if (typeof value === "object" && !Array.isArray(value)) {
                 const operatorEntries = Object.entries(value)
                     .filter(([_, v]) => v !== undefined && v !== null)
@@ -321,7 +329,7 @@ export class SequelizeModel extends AbstractModel {
         }
         await instance.reload({ include: Object.values(this.model.associations) });
         const pk = this.primaryKey;
-        const fresh = await this.model.findByPk(instance.get(pk), { include: assocNames.map(a => ({ association: a })) });
+        const fresh = (await this.model.findByPk(instance.get(pk), { include: assocNames.map(a => ({ association: a })) })).toJSON();
         // console.debug(">> Результат после reload:", fresh?.toJSON());
         return fresh;
     }
@@ -440,7 +448,7 @@ export class SequelizeModel extends AbstractModel {
             where,
             include: Object.values(this.model.associations)
         });
-        return reloaded.map(r => r.get({ plain: true }));
+        return reloaded.map((r) => r.get({ plain: true }));
     }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
@@ -510,7 +518,7 @@ export class SequelizeModel extends AbstractModel {
                 }
             }
         }
-        const raw = records.map(r => r.get({ plain: true }));
+        const raw = records.map((r) => r.get({ plain: true }));
         await this.model.destroy({ where });
         return raw;
     }
@@ -525,7 +533,6 @@ export class SequelizeModel extends AbstractModel {
         return Object.keys(this.model.associations).map(key => ({ association: key }));
     }
 }
-/** SequelizeAdapter — адаптер, заменяющий WaterlineAdapter */
 export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
     Model = SequelizeModel;
@@ -547,18 +554,33 @@ export class SequelizeAdapter extends AbstractAdapter {
         const model = this.getModel(modelName);
         return model?.getAttributes();
     }
-    /**Registration of system models*/
-    static async registerSystemModels(sequelize) {
-        let modelsDir = path.resolve(import.meta.dirname, "../../../../models");
-        if (!fs.existsSync(modelsDir)) {
-            modelsDir = path.resolve(import.meta.dirname, "../../../../src/models");
+    /** Registration of system models */
+    static async registerSystemModels(sequelize, alter = true) {
+        // Try multiple possible model locations
+        const possiblePaths = [
+            path.resolve(import.meta.dirname, "../../../../models"),
+            path.resolve(import.meta.dirname, "../../../../src/models"),
+            path.resolve(import.meta.dirname, "../../../models"),
+            path.resolve(import.meta.dirname, "../../../src/models"),
+            path.resolve(process.cwd(), "node_modules/adminizer/src/models"),
+            path.resolve(process.cwd(), "node_modules/adminizer/models")
+        ];
+        let modelsDir = null;
+        for (const possiblePath of possiblePaths) {
+            if (fs.existsSync(possiblePath)) {
+                modelsDir = possiblePath;
+                break;
+            }
         }
-        let files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".js"));
+        if (!modelsDir) {
+            return;
+        }
+        let files = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".js"));
         if (!files.length) {
-            files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".ts") && !f.endsWith(".d.ts"));
+            files = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"));
         }
         if (!files.length) {
-            throw `Model files not found in dir ${modelsDir}`;
+            return;
         }
         const schemas = {};
         for (const file of files) {
@@ -570,7 +592,12 @@ export class SequelizeAdapter extends AbstractAdapter {
             generateSequelizeModel(sequelize, modelName, definition);
         }
         generateAssociationsFromSchema(sequelize.models, schemas);
-        await sequelize.sync();
+        // Check ORM_ALTER environment variable before sync
+        if (process.env.ORM_ALTER !== 'false' && alter) {
+            await sequelize.sync();
+        }
+        else {
+        }
     }
 }
 /**Generation of the SEQUELIZE model from the definition, analogue of Waterinecollection.extenD*/

package/lib/notifications/AbstractNotificationService.d.ts

@@ -0,0 +1,163 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../Adminizer';
+import { INotification, INotificationEvent } from '../../interfaces/types';
+import { NotificationAPModel } from "../../models/NotificationAP";
+import { UserAP } from "../../models/UserAP";
+/**
+ * ░█████╗░██████╗░░██████╗████████╗██████╗░░█████╗░░█████╗░████████╗
+ * ██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝
+ * ███████║██████╦╝╚█████╗░░░░██║░░░██████╔╝███████║██║░░╚═╝░░░██║░░░
+ * ██╔══██║██╔══██╗░╚═══██╗░░░██║░░░██╔══██╗██╔══██║██║░░██╗░░░██║░░░
+ * ██║░░██║██████╦╝██████╔╝░░░██║░░░██║░░██║██║░░██║╚█████╔╝░░░██║░░░
+ * ╚═╝░░╚═╝╚═════╝░╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░░░░╚═╝░░░
+ *
+ * ███╗░░██╗░█████╗░████████╗██╗███████╗██╗░█████╗░░█████╗░████████╗██╗░█████╗░███╗░░██╗
+ * ████╗░██║██╔══██╗╚══██╔══╝██║██╔════╝██║██╔══██╗██╔══██╗╚══██╔══╝██║██╔══██╗████╗░██║
+ * ██╔██╗██║██║░░██║░░░██║░░░██║█████╗░░██║██║░░╚═╝███████║░░░██║░░░██║██║░░██║██╔██╗██║
+ * ██║╚████║██║░░██║░░░██║░░░██║██╔══╝░░██║██║░░██╗██╔══██║░░░██║░░░██║██║░░██║██║╚████║
+ * ██║░╚███║╚█████╔╝░░░██║░░░██║██║░░░░░██║╚█████╔╝██║░░██║░░░██║░░░██║╚█████╔╝██║░╚███║
+ * ╚═╝░░╚══╝░╚════╝░░░░╚═╝░░░╚═╝╚═╝░░░░░╚═╝░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░╚═╝░╚════╝░╚═╝░░╚══╝
+ *
+ * Class: AbstractNotificationService
+ *
+ * Description:
+ * The `AbstractNotificationService` is a base class that provides the fundamental structure and functionality
+ * for implementing notification services in the application. It manages client connections, dispatches notifications,
+ * tracks user notification status, and handles database interactions for storing and retrieving notification data.
+ * This abstract class is intended to be extended by concrete notification service implementations.
+ *
+ * Key Features:
+ * - Manages a registry of clients associated with users using a nested Map structure.
+ * - Provides methods to add, remove, and retrieve clients.
+ * - Dispatches notifications to connected clients via an abstract method to be implemented by subclasses.
+ * - Sends heartbeat (ping) messages to keep client connections alive.
+ * - Creates and retrieves user notification records in the database.
+ * - Fetches paginated and filtered notification lists for a specific user.
+ * - Supports searching notifications by message content.
+ * - Marks notifications as read or all notifications as read for a user.
+ * - Emits events using Node.js EventEmitter for extensibility and integration.
+ *
+ * Usage Example:
+ * Subclasses should override the `dispatchNotification` method to implement custom notification logic.
+ *
+ * @abstract
+ * @extends EventEmitter
+ * @property {Map<number, Map<string, Function>>} clients - A map of user IDs to their client maps.
+ * @property {Adminizer} adminizer - Reference to the Adminizer instance for accessing helpers and models.
+ * @property {string} notificationClass - Abstract property representing the class name of the notification.
+ * @property {string} icon - Abstract property for the notification icon.
+ * @property {string} iconColor - Abstract property for the notification icon color.
+ */
+export declare abstract class AbstractNotificationService extends EventEmitter {
+    protected clients: Map<number, Map<string, (event: INotificationEvent) => void>>;
+    protected adminizer: Adminizer;
+    abstract readonly notificationClass: string;
+    abstract readonly icon: string;
+    abstract readonly iconColor: string;
+    constructor(adminizer: Adminizer);
+    private _bindAccessRight;
+    /**
+     * Registers a client for a user and associates it with a send function.
+     * If the user does not yet have a Map of clients, one is created.
+     * The client is then added to the user's Map with the provided send function.
+     * @param {string} clientId - The unique identifier of the client to be registered.
+     * @param {(event: INotificationEvent) => void} sendFn - The function used to send notifications to the client.
+     * @param {UserAP} user - The user associated with the client.
+     */
+    addClient(clientId: string, sendFn: (event: INotificationEvent) => void, user: UserAP): void;
+    /**
+     * Removes a client from the internal tracking structure.
+     * If the user associated with the client has no more clients after removal, the user's Map is also removed.
+     * @param {string} clientId - The unique identifier of the client to be removed.
+     */
+    removeClient(clientId: string): void;
+    /**
+     * Retrieves the Map of clients associated with a specific user.
+     * If the user has no clients, an empty Map is returned.
+     * @param {number} userId - The unique identifier of the user whose clients should be retrieved.
+     * @returns {Map<string, (event: INotificationEvent) => void>} A Map where the keys are client IDs and the values are send functions.
+     */
+    getUserClients(userId: number): Map<string, (event: INotificationEvent) => void>;
+    /**
+     * Returns the total number of users who have at least one connected client.
+     * @returns {number} The count of users with active clients.
+     */
+    getClientCount(): number;
+    /**
+     * Aggregates all clients from all users into a single Map for backward compatibility.
+     * Each client is uniquely identified by its ID and mapped to its corresponding send function.
+     * @returns {Map<string, (event: INotificationEvent) => void>} A combined Map of all client IDs and their send functions.
+     */
+    getAllClients(): Map<string, (event: INotificationEvent) => void>;
+    /**
+     * Abstract method that must be implemented by subclasses to dispatch a notification.
+     * @param {Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>} notification - The notification data to be dispatched (excluding id, createdAt, notificationClass, and icon).
+     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the notification was successfully dispatched.
+     */
+    abstract dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
+    /**
+     * Sends a notification event to all connected clients.
+     * Iterates through each user's client Map and invokes the send function for each client.
+     * If sending fails, logs an error and removes the client.
+     * @param {INotificationEvent} event - The notification event to broadcast.
+     */
+    protected broadcast(event: INotificationEvent): void;
+    /**
+     * Sends a heartbeat (ping) message to a specific client.
+     * Searches for the client across all user client Maps and sends a heartbeat event if found.
+     * @param {string} clientId - The unique identifier of the client to receive the heartbeat.
+     */
+    sendHeartbeat(clientId: string): void;
+    /**
+     * Creates a new user notification record in the 'usernotificationap' model.
+     * This method is used to associate a notification with a specific user and mark it as unread.
+     * @param {string} notificationId - The unique identifier of the notification.
+     * @param {number} [userId] - The ID of the user to associate the notification with. Optional.
+     * @returns {Promise<void>} A promise that resolves when the record is created or an error is logged.
+     */
+    protected createUserNotification(notificationId: string, userId?: number): Promise<void>;
+    /**
+     * Retrieves a user notification record from the 'usernotificationap' model.
+     * The record is fetched based on the provided notification ID and user ID.
+     * @param {string} notificationId - The unique identifier of the notification.
+     * @param {number} userId - The ID of the user associated with the notification.
+     * @returns {Promise<any>} A promise that resolves with the found record or null if not found or an error occurs.
+     */
+    protected getUserNotification(notificationId: string, userId: number): Promise<any>;
+    /**
+     * Retrieves a paginated list of notifications for a specific user, optionally filtered by read status.
+     * @param {number} userId - The ID of the user whose notifications should be fetched.
+     * @param {number} [limit=20] - The maximum number of notifications to return.
+     * @param {number} [skip=0] - The number of notifications to skip (used for pagination).
+     * @param {boolean} [unreadOnly=false] - Whether to return only unread notifications.
+     * @returns {Promise<INotification[]>} A promise that resolves with an array of notification objects.
+     */
+    getNotifications(userId: number, limit?: number, skip?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    /**
+     * Prepares notification data by enriching it with user-specific read status and icon information.
+     * @param {NotificationAPModel[]} notificationsDB - An array of raw notification records from the database.
+     * @param {number} userId - The ID of the user for whom the read status is determined.
+     * @returns {Promise<INotification[]>} A promise that resolves with an array of enriched notification objects.
+     */
+    protected prepareNotification(notificationsDB: NotificationAPModel[], userId: number): Promise<INotification[]>;
+    /**
+     * Searches for notifications for a specific user based on a message keyword.
+     * @param {string} s - The search string used to filter notifications by message content.
+     * @param {number} userId - The ID of the user whose notifications should be searched.
+     * @returns {Promise<INotification[]>} A promise that resolves with an array of matching notification objects.
+     */
+    search(s: string, userId: number): Promise<INotification[]>;
+    /**
+     * Marks a specific notification as read for a given user.
+     * @param {number} userId - The ID of the user for whom the notification should be marked as read.
+     * @param {string} id - The ID of the notification to mark as read.
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    markAsRead(userId: number, id: string): Promise<void>;
+    /**
+     * Marks all notifications as read for a given user.
+     * @param {number} userId - The ID of the user for whom all notifications should be marked as read.
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    markAllAsRead(userId: number): Promise<void>;
+}