adminizer 4.3.0-build.80 → 4.3.0-build.81

package/lib/notifications/NotificationHandler.js

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../Adminizer';
+export class NotificationHandler extends EventEmitter {
+    services = new Map();
+    constructor() {
+        super();
+    }
+    /**
+     * Register a new notification service
+     * @param service
+     */
+    registerService(service) {
+        this.services.set(service.notificationClass, service);
+        Adminizer.log.info(`Notification service registered: ${service.notificationClass}`);
+    }
+    /**
+     * Get a notification service by class
+     * @param notificationClass
+     */
+    getService(notificationClass) {
+        return this.services.get(notificationClass);
+    }
+    /**
+     * Get all registered services
+     */
+    getAllServices() {
+        return Array.from(this.services.values());
+    }
+    /**
+     * Dispatch a notification to a service
+     * @param notificationClass
+     * @param notification
+     */
+    async dispatchNotification(notificationClass, notification) {
+        const service = this.getService(notificationClass);
+        if (!service) {
+            throw new Error(`Notification service not found: ${notificationClass}`);
+        }
+        return service.dispatchNotification(notification);
+    }
+}

package/lib/{v4/notifications → notifications}/SystemNotificationService.d.ts

@@ -1,5 +1,5 @@
 import { AbstractNotificationService } from './AbstractNotificationService';
-import { INotification } from '../../../interfaces/types';
+import { INotification } from '../../interfaces/types';
 export declare class SystemNotificationService extends AbstractNotificationService {
     readonly notificationClass = "system";
     readonly icon: string;
@@ -7,12 +7,13 @@ export declare class SystemNotificationService extends AbstractNotificationServi
     private crudChannels;
     dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
     private broadcastToChannel;
-    addClientToChannel(clientId: string, channel: string): void;
-    removeClientFromChannel(clientId: string, channel: string): void;
-    removeClientFromAllChannels(clientId: string): void;
+    addClientToChannel(clientId: string, channel: string, userId: number): void;
+    removeClientFromChannel(clientId: string, channel: string, userId: number): void;
+    removeClientFromAllChannels(clientId: string, userId: number): void;
     removeClient(clientId: string): void;
     logSystemEvent(title: string, message: string, channel?: string, metadata?: Record<string | number, any>): Promise<boolean>;
     logCreatedEvent(title: string, message: string, metadata?: Record<string | number, any>): Promise<boolean>;
     logUpdatedEvent(title: string, message: string, metadata?: Record<string | number, any>): Promise<boolean>;
     logDeletedEvent(title: string, message: string, metadata?: Record<string | number, any>): Promise<boolean>;
+    getUserChannels(userId: number): Map<string, Set<string>>;
 }

package/lib/notifications/SystemNotificationService.js

@@ -0,0 +1,173 @@
+import { AbstractNotificationService } from './AbstractNotificationService';
+import { Adminizer } from '../Adminizer';
+export class SystemNotificationService extends AbstractNotificationService {
+    notificationClass = 'system';
+    icon = 'settings';
+    iconColor = '#1eb707';
+    // Изменяем структуру каналов: храним по userId -> channel -> clientIds
+    crudChannels = new Map();
+    async dispatchNotification(notification) {
+        const fullNotification = {
+            ...notification,
+            notificationClass: this.notificationClass,
+            channel: notification.channel ?? ''
+        };
+        let notificationDB;
+        // Сохраняем в базу
+        if (this.adminizer.modelHandler.model.has('notificationap')) {
+            try {
+                notificationDB = await this.adminizer.modelHandler.model.get('notificationap')["_create"](fullNotification);
+                const users = await this.adminizer.modelHandler.model.get('userap')["_find"]({});
+                for (const user of users) {
+                    try {
+                        if (this.adminizer.accessRightsHelper.hasPermission(`notification-${this.notificationClass}`, user)) {
+                            await this.createUserNotification(notificationDB.id, user.id);
+                        }
+                    }
+                    catch (error) {
+                        Adminizer.log.error('Error creating UserNotificationAP:', error);
+                    }
+                }
+                const event = {
+                    type: 'notification',
+                    data: {
+                        ...notificationDB,
+                        icon: {
+                            icon: this.icon,
+                            iconColor: this.iconColor
+                        },
+                    },
+                    notificationClass: this.notificationClass,
+                    userId: notification.userId ?? null,
+                    channel: notification.channel ?? 'system'
+                };
+                // Отправляем на все каналы или на конкретный канал
+                if (notification.channel) {
+                    this.broadcastToChannel(notification.channel, event);
+                }
+                else {
+                    this.broadcastToChannel('system', event);
+                }
+                Adminizer.log.info(`[System] Notification dispatched: ${fullNotification.title}`);
+                return true;
+            }
+            catch (error) {
+                Adminizer.log.error('Error saving system notification to database:', error);
+            }
+        }
+        return false;
+    }
+    // Обновляем broadcastToChannel для работы с новой структурой
+    broadcastToChannel(channel, event) {
+        // Отправляем всем пользователям, подписанным на этот канал
+        this.crudChannels.forEach((userChannels, userId) => {
+            const channelClients = userChannels.get(channel);
+            if (channelClients) {
+                const userClients = this.clients.get(userId);
+                if (userClients) {
+                    channelClients.forEach(clientId => {
+                        const sendFn = userClients.get(clientId);
+                        if (sendFn) {
+                            try {
+                                sendFn(event);
+                            }
+                            catch (error) {
+                                Adminizer.log.error(`[${this.notificationClass}] Error sending to client ${clientId} on channel ${channel}:`, error);
+                                this.removeClient(clientId);
+                            }
+                        }
+                    });
+                }
+            }
+        });
+    }
+    // Добавляем клиента к каналу с привязкой к пользователю
+    addClientToChannel(clientId, channel, userId) {
+        if (!this.crudChannels.has(userId)) {
+            this.crudChannels.set(userId, new Map());
+        }
+        const userChannels = this.crudChannels.get(userId);
+        if (!userChannels.has(channel)) {
+            userChannels.set(channel, new Set());
+        }
+        userChannels.get(channel).add(clientId);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} (user ${userId}) added to channel ${channel}`);
+    }
+    // Удаляем клиента из канала конкретного пользователя
+    removeClientFromChannel(clientId, channel, userId) {
+        const userChannels = this.crudChannels.get(userId);
+        if (userChannels) {
+            const channelClients = userChannels.get(channel);
+            if (channelClients) {
+                channelClients.delete(clientId);
+                Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} (user ${userId}) removed from channel ${channel}`);
+                // Если в канале больше нет клиентов - удаляем канал
+                if (channelClients.size === 0) {
+                    userChannels.delete(channel);
+                }
+            }
+            // Если у пользователя больше нет каналов - удаляем запись пользователя
+            if (userChannels.size === 0) {
+                this.crudChannels.delete(userId);
+            }
+        }
+    }
+    // Удаляем клиента из всех каналов пользователя
+    removeClientFromAllChannels(clientId, userId) {
+        const userChannels = this.crudChannels.get(userId);
+        if (userChannels) {
+            userChannels.forEach((clients, channel) => {
+                clients.delete(clientId);
+                Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} (user ${userId}) removed from channel ${channel}`);
+                // Если в канале больше нет клиентов - удаляем канал
+                if (clients.size === 0) {
+                    userChannels.delete(channel);
+                }
+            });
+            // Если у пользователя больше нет каналов - удаляем запись пользователя
+            if (userChannels.size === 0) {
+                this.crudChannels.delete(userId);
+            }
+        }
+    }
+    // Переопределяем removeClient для очистки каналов
+    removeClient(clientId) {
+        // Находим userId по clientId
+        let foundUserId = null;
+        for (const [userId, userClients] of this.clients.entries()) {
+            if (userClients.has(clientId)) {
+                foundUserId = userId;
+                break;
+            }
+        }
+        // Удаляем клиента из основного хранилища
+        super.removeClient(clientId);
+        // Удаляем клиента из каналов
+        if (foundUserId !== null) {
+            this.removeClientFromAllChannels(clientId, foundUserId);
+        }
+    }
+    // Специальный метод для системных событий с указанием канала
+    async logSystemEvent(title, message, channel, metadata) {
+        return this.dispatchNotification({
+            title: title,
+            message: message,
+            metadata: metadata,
+            channel: channel
+        });
+    }
+    // Методы для CRUD операций
+    async logCreatedEvent(title, message, metadata) {
+        return this.logSystemEvent(title, message, 'created', metadata);
+    }
+    async logUpdatedEvent(title, message, metadata) {
+        return this.logSystemEvent(title, message, 'updated', metadata);
+    }
+    async logDeletedEvent(title, message, metadata) {
+        return this.logSystemEvent(title, message, 'deleted', metadata);
+    }
+    // Новый метод для получения каналов пользователя
+    getUserChannels(userId) {
+        return this.crudChannels.get(userId) || new Map();
+    }
+}

package/lib/{v4/widgets → widgets}/abstractCustom.d.ts

@@ -1,4 +1,4 @@
-import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../interfaces/MaaterialIcons";
 export declare abstract class CustomBase {
     /** Widget unique id */
     abstract readonly id: string;

package/lib/{v4/widgets → widgets}/abstractLink.d.ts

@@ -1,5 +1,5 @@
 import { BaseWidget } from "./abstractWidgetBase";
-import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../interfaces/MaaterialIcons";
 export interface Links {
     name: string;
     description: string;

package/lib/{v4/widgets → widgets}/abstractWidgetBase.d.ts

@@ -1,4 +1,4 @@
-import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../interfaces/MaaterialIcons";
 export declare abstract class BaseWidget {
     /** Widget unique id */
     abstract readonly id: string;

package/lib/{v4/widgets → widgets}/widgetHandler.d.ts

@@ -3,8 +3,8 @@ import { InfoBase } from "./abstractInfo";
 import { ActionBase } from "./abstractAction";
 import { LinkBase } from "./abstractLink";
 import { CustomBase } from "./abstractCustom";
-import { AdminpanelIcon } from "../../../interfaces/adminpanelConfig";
-import { Adminizer } from "../../Adminizer";
+import { AdminpanelIcon } from "../../interfaces/adminpanelConfig";
+import { Adminizer } from "../Adminizer";
 import { UserAP } from "models/UserAP";
 import { I18n } from "../I18n";
 export type WidgetType = (SwitchBase | InfoBase | ActionBase | LinkBase | CustomBase);

package/migrations/index.d.ts

@@ -0,0 +1,3 @@
+export declare const migrations: {
+    umzug: import("..").Migration[];
+};

package/migrations/index.js

@@ -0,0 +1,4 @@
+import { migrationsUmzug as umzug } from "./umzug";
+export const migrations = {
+    umzug
+};

package/migrations/index.ts

@@ -0,0 +1,5 @@
+import { migrationsUmzug as umzug } from "./umzug";
+
+export const migrations = {
+    umzug
+}

package/migrations/umzug/0001.d.ts

@@ -0,0 +1,7 @@
+import { QueryInterface } from "sequelize";
+type Ctx = {
+    context: QueryInterface;
+};
+export declare function up({ context }: Ctx): Promise<void>;
+export declare function down({ context }: Ctx): Promise<void>;
+export {};

package/migrations/umzug/0001.js

@@ -0,0 +1,119 @@
+import { DataTypes } from "sequelize";
+// Creates all system model tables according to src/models/* and
+// SequelizeAdapter.generateSequelizeModel naming: tableName = modelName.toLowerCase()
+// Associations:
+// - UserAP <-> GroupAP: M:N via through table "groupapuserap" (UserAPId, GroupAPId)
+// - MediaManagerAP.parent -> MediaManagerAP (parentId)
+// - MediaManagerAP hasMany MediaManagerMetaAP via parent (MediaManagerMetaAP.parentId)
+// - MediaManagerAP hasMany MediaManagerAssociationsAP via file (MediaManagerAssociationsAP.fileId)
+// - UserNotificationAP belongsTo NotificationAP via alias "notificationId" -> FK column "notificationIdId"
+export async function up({ context }) {
+    // userap
+    await context.createTable("userap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        login: { type: DataTypes.STRING, unique: true },
+        fullName: { type: DataTypes.STRING },
+        email: { type: DataTypes.STRING },
+        avatar: { type: DataTypes.STRING },
+        passwordHashed: { type: DataTypes.STRING },
+        timezone: { type: DataTypes.STRING },
+        expires: { type: DataTypes.STRING },
+        locale: { type: DataTypes.STRING },
+        isDeleted: { type: DataTypes.BOOLEAN },
+        isActive: { type: DataTypes.BOOLEAN },
+        isAdministrator: { type: DataTypes.BOOLEAN },
+        widgets: { type: DataTypes.JSON },
+        isConfirmed: { type: DataTypes.BOOLEAN },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // groupap
+    await context.createTable("groupap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        name: { type: DataTypes.STRING, unique: true },
+        description: { type: DataTypes.STRING },
+        tokens: { type: DataTypes.JSON },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // mediamanagerap (self-ref via parentId)
+    await context.createTable("mediamanagerap", {
+        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+        parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+        mimeType: { type: DataTypes.STRING },
+        path: { type: DataTypes.STRING },
+        size: { type: DataTypes.INTEGER },
+        group: { type: DataTypes.STRING },
+        tag: { type: DataTypes.STRING },
+        url: { type: DataTypes.STRING },
+        filename: { type: DataTypes.STRING },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // mediamanagermetaap (belongsTo mediamanagerap via parentId)
+    await context.createTable("mediamanagermetaap", {
+        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+        key: { type: DataTypes.STRING },
+        value: { type: DataTypes.JSON },
+        isPublic: { type: DataTypes.BOOLEAN },
+        parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // mediamanagerassociationsap (belongsTo mediamanagerap via fileId)
+    await context.createTable("mediamanagerassociationsap", {
+        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+        mediaManagerId: { type: DataTypes.STRING },
+        model: { type: DataTypes.JSON },
+        modelId: { type: DataTypes.JSON },
+        widgetName: { type: DataTypes.STRING },
+        sortOrder: { type: DataTypes.INTEGER },
+        fileId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // notificationap
+    await context.createTable("notificationap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        title: { type: DataTypes.STRING },
+        message: { type: DataTypes.STRING },
+        notificationClass: { type: DataTypes.STRING },
+        channel: { type: DataTypes.STRING },
+        metadata: { type: DataTypes.JSON },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // usernotificationap (FK to notificationap via column notificationIdId)
+    await context.createTable("usernotificationap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        userId: { type: DataTypes.INTEGER },
+        notificationIdId: { type: DataTypes.INTEGER, allowNull: true, references: { model: "notificationap", key: "id" } },
+        read: { type: DataTypes.BOOLEAN },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // navigationap
+    await context.createTable("navigationap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        label: { type: DataTypes.STRING, unique: true },
+        tree: { type: DataTypes.JSON },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // M:N join: GroupAP <-> UserAP via "groupapuserap"
+    await context.createTable("groupapuserap", {
+        UserAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "userap", key: "id" } },
+        GroupAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "groupap", key: "id" } },
+    });
+}
+export async function down({ context }) {
+    await context.dropTable("groupapuserap");
+    await context.dropTable("usernotificationap");
+    await context.dropTable("mediamanagermetaap");
+    await context.dropTable("mediamanagerassociationsap");
+    await context.dropTable("mediamanagerap");
+    await context.dropTable("navigationap");
+    await context.dropTable("notificationap");
+    await context.dropTable("groupap");
+    await context.dropTable("userap");
+}

package/migrations/umzug/0001.ts

@@ -0,0 +1,132 @@
+import { QueryInterface, DataTypes } from "sequelize";
+
+type Ctx = { context: QueryInterface };
+
+// Creates all system model tables according to src/models/* and
+// SequelizeAdapter.generateSequelizeModel naming: tableName = modelName.toLowerCase()
+// Associations:
+// - UserAP <-> GroupAP: M:N via through table "groupapuserap" (UserAPId, GroupAPId)
+// - MediaManagerAP.parent -> MediaManagerAP (parentId)
+// - MediaManagerAP hasMany MediaManagerMetaAP via parent (MediaManagerMetaAP.parentId)
+// - MediaManagerAP hasMany MediaManagerAssociationsAP via file (MediaManagerAssociationsAP.fileId)
+// - UserNotificationAP belongsTo NotificationAP via alias "notificationId" -> FK column "notificationIdId"
+
+export async function up({ context }: Ctx): Promise<void> {
+  // userap
+  await context.createTable("userap", {
+    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+    login: { type: DataTypes.STRING, unique: true },
+    fullName: { type: DataTypes.STRING },
+    email: { type: DataTypes.STRING },
+    avatar: { type: DataTypes.STRING },
+    passwordHashed: { type: DataTypes.STRING },
+    timezone: { type: DataTypes.STRING },
+    expires: { type: DataTypes.STRING },
+    locale: { type: DataTypes.STRING },
+    isDeleted: { type: DataTypes.BOOLEAN },
+    isActive: { type: DataTypes.BOOLEAN },
+    isAdministrator: { type: DataTypes.BOOLEAN },
+    widgets: { type: DataTypes.JSON },
+    isConfirmed: { type: DataTypes.BOOLEAN },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // groupap
+  await context.createTable("groupap", {
+    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+    name: { type: DataTypes.STRING, unique: true },
+    description: { type: DataTypes.STRING },
+    tokens: { type: DataTypes.JSON },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // mediamanagerap (self-ref via parentId)
+  await context.createTable("mediamanagerap", {
+    id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+    parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+    mimeType: { type: DataTypes.STRING },
+    path: { type: DataTypes.STRING },
+    size: { type: DataTypes.INTEGER },
+    group: { type: DataTypes.STRING },
+    tag: { type: DataTypes.STRING },
+    url: { type: DataTypes.STRING },
+    filename: { type: DataTypes.STRING },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // mediamanagermetaap (belongsTo mediamanagerap via parentId)
+  await context.createTable("mediamanagermetaap", {
+    id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+    key: { type: DataTypes.STRING },
+    value: { type: DataTypes.JSON },
+    isPublic: { type: DataTypes.BOOLEAN },
+    parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // mediamanagerassociationsap (belongsTo mediamanagerap via fileId)
+  await context.createTable("mediamanagerassociationsap", {
+    id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+    mediaManagerId: { type: DataTypes.STRING },
+    model: { type: DataTypes.JSON },
+    modelId: { type: DataTypes.JSON },
+    widgetName: { type: DataTypes.STRING },
+    sortOrder: { type: DataTypes.INTEGER },
+    fileId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // notificationap
+  await context.createTable("notificationap", {
+    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+    title: { type: DataTypes.STRING },
+    message: { type: DataTypes.STRING },
+    notificationClass: { type: DataTypes.STRING },
+    channel: { type: DataTypes.STRING },
+    metadata: { type: DataTypes.JSON },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // usernotificationap (FK to notificationap via column notificationIdId)
+  await context.createTable("usernotificationap", {
+    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+    userId: { type: DataTypes.INTEGER },
+    notificationIdId: { type: DataTypes.INTEGER, allowNull: true, references: { model: "notificationap", key: "id" } },
+    read: { type: DataTypes.BOOLEAN },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // navigationap
+  await context.createTable("navigationap", {
+    id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+    label: { type: DataTypes.STRING, unique: true },
+    tree: { type: DataTypes.JSON },
+    createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+  });
+
+  // M:N join: GroupAP <-> UserAP via "groupapuserap"
+  await context.createTable("groupapuserap", {
+    UserAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "userap", key: "id" } },
+    GroupAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "groupap", key: "id" } },
+  });
+}
+
+export async function down({ context }: Ctx): Promise<void> {
+  await context.dropTable("groupapuserap");
+  await context.dropTable("usernotificationap");
+  await context.dropTable("mediamanagermetaap");
+  await context.dropTable("mediamanagerassociationsap");
+  await context.dropTable("mediamanagerap");
+  await context.dropTable("navigationap");
+  await context.dropTable("notificationap");
+  await context.dropTable("groupap");
+  await context.dropTable("userap");
+}

package/migrations/umzug.d.ts

@@ -0,0 +1,2 @@
+import { Migration } from "interfaces/types";
+export declare const migrationsUmzug: Migration[];

package/migrations/umzug.js

@@ -0,0 +1,8 @@
+import { up as up0001, down as down0001 } from "./umzug/0001";
+export const migrationsUmzug = [
+    {
+        name: "0001",
+        up: up0001,
+        down: down0001
+    }
+];

package/migrations/umzug.ts

@@ -0,0 +1,9 @@
+import { Migration } from "interfaces/types"
+import {up as up0001, down as down0001 } from "./umzug/0001"
+export const migrationsUmzug: Migration[] = [
+    {
+        name: "0001",
+        up: up0001,
+        down: down0001
+    }   
+]

package/models/NotificationAP.d.ts

@@ -20,6 +20,14 @@ declare const _default: {
     metadata: {
         type: string;
     };
+    createdAt: {
+        type: string;
+        autoCreatedAt: boolean;
+    };
+    updatedAt: {
+        type: string;
+        autoUpdatedAt: boolean;
+    };
 };
 export default _default;
 export interface NotificationAP {

package/models/NotificationAP.js

@@ -18,5 +18,13 @@ export default {
     },
     metadata: {
         type: 'json'
+    },
+    createdAt: {
+        type: 'number',
+        autoCreatedAt: true
+    },
+    updatedAt: {
+        type: 'number',
+        autoUpdatedAt: true
     }
 };

package/models/UserAP.d.ts

@@ -1,4 +1,4 @@
-import { WidgetConfig, WidgetsLayouts } from "lib/v4/widgets/widgetHandler";
+import { WidgetConfig, WidgetsLayouts } from "lib/widgets/widgetHandler";
 import { GroupAP } from "./GroupAP";
 declare const _default: {
     id: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.3.0-build.80",
+  "version": "4.3.0-build.81",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
@@ -15,6 +15,7 @@
     "dev:no-seed": "cross-env VITE_ENV=dev NO_SEED_DATA=true ORM=sequelize tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
     "dev:no-seed-clean": "cross-env VITE_ENV=dev NO_SEED_DATA=true CLEAN_TMP=true ORM=sequelize tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
     "dev:waterline": "cross-env VITE_ENV=dev ORM=waterline tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
+    "dev:waterline:no-seed": "cross-env VITE_ENV=dev NO_SEED_DATA=true ORM=waterline tsx watch --tsconfig ./fixture/tsconfig.json ./fixture/index.ts",
     "build:assets": "vite build",
     "compile:backend": "tsc -p src/tsconfig.json",
     "compile:ui": "tsc -p tsconfig.ui.json",
@@ -67,12 +68,11 @@
     "react-dnd": "^16.0.1",
     "reflect-metadata": "^0.2.2",
     "sharp": "^0.33.5",
+    "sprintf-js": "^1.1.3",
     "typeorm": "^0.3.20",
     "uuid": "^11.0.5",
     "waterline": "^0.15.2",
-    "winston": "^3.17.0",
-    "sprintf-js": "^1.1.3",
-    "sequelize": "^6.37.7"
+    "winston": "^3.17.0"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^7.27.1",
@@ -147,6 +147,7 @@
     "sails-disk": "^2.1.2",
     "sails-postgresql": "^5.0.1",
     "sequelize-typescript": "^2.1.6",
+    "sequelize": "^6.37.7",
     "shelljs": "^0.9.2",
     "sonner": "^2.0.3",
     "sqlite3": "^5.1.7",