@webtypen/webframez-core 0.3.61 → 0.3.62

package/dist/Commands/QueueWorkerCommand.js

@@ -553,6 +553,14 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                             throw new Error(`Notification queue-job '${job._id.toString()}' has no _notification reference.`);
                         }
                         jobNotification = yield NotificationService_1.NotificationService.getNotification(job._notification);
+                        const targetContext = yield NotificationService_1.NotificationService.resolveTarget({
+                            target: jobNotification.target,
+                            target_id: jobNotification.target_id,
+                        });
+                        if (!(targetContext === null || targetContext === void 0 ? void 0 : targetContext.targetModel)) {
+                            throw new Error(`Notification queue-job '${job._id.toString()}' references a missing target.`);
+                        }
+                        NotificationService_1.NotificationService.attachTargetModel(jobNotification, targetContext.targetModel);
                         job.notification = jobNotification;
                         yield NotificationService_1.NotificationService.setChangingStatus(jobNotification, "running");
                     }
@@ -628,9 +636,11 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                     });
                     const errorMessage = e instanceof Error ? e.stack || e.message : String(e);
                     const endedAt = new Date();
+                    let notificationFailureStatusSaved = false;
                     if (jobNotification) {
                         try {
                             yield NotificationService_1.NotificationService.setChangingStatus(jobNotification, "error", errorMessage);
+                            notificationFailureStatusSaved = true;
                         }
                         catch (notificationError) {
                             yield ErrorHandler_1.ErrorHandler.report(notificationError, {
@@ -648,6 +658,29 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                             });
                         }
                     }
+                    if (!notificationFailureStatusSaved && job.notification_queue_job && job._notification) {
+                        try {
+                            const notificationFound = yield NotificationService_1.NotificationService.setQueueJobFailureStatus(job._notification, errorMessage);
+                            if (!notificationFound) {
+                                throw new Error(`Notification queue-job '${job._id.toString()}' references a missing notification '${job._notification.toString()}'.`);
+                            }
+                        }
+                        catch (notificationError) {
+                            yield ErrorHandler_1.ErrorHandler.report(notificationError, {
+                                scope: "job",
+                                source: "queue.worker.notification.status.fallback",
+                                job: {
+                                    id: job && job._id ? job._id.toString() : undefined,
+                                    number: job && job.number ? job.number : undefined,
+                                    jobclass: job && job.jobclass ? job.jobclass : undefined,
+                                    worker: this.workerKey,
+                                },
+                                metadata: {
+                                    notification: job._notification.toString(),
+                                },
+                            });
+                        }
+                    }
                     job.status = "failed";
                     job.ended_at = endedAt;
                     job.executions[0].status = "failed";

package/dist/ConsoleApplication.js

@@ -80,6 +80,7 @@ class ConsoleApplication {
             kernel: options && options.kernel ? options.kernel : null,
             options,
         });
+        NotificationService_1.NotificationService.registerTypes(this.modulesLoader.getNotifications());
         if (options && options.datatables) {
             DatatableRegistry_1.DatatableRegistry.registerMany(options.datatables);
         }

package/dist/Modules/ModuleProvider.d.ts

@@ -1,6 +1,7 @@
 import { KernelAiRegistrations } from "../Ai/AiTypes";
 import { ApiScopeRegistrationClass } from "../Api/ApiTypes";
 import { KernelMcpRegistrations } from "../Mcp/McpTypes";
+import type { NotificationDefinition } from "../Notifications/NotificationService";
 export declare class ModuleProvider {
     static key: string;
     controller: {
@@ -11,6 +12,7 @@ export declare class ModuleProvider {
     };
     apiScopes: ApiScopeRegistrationClass[];
     commands: any[];
+    notifications: NotificationDefinition[];
     mcp?: KernelMcpRegistrations;
     ai?: KernelAiRegistrations;
     boot(_context?: any): void;

package/dist/Modules/ModuleProvider.js

@@ -7,6 +7,7 @@ class ModuleProvider {
         this.middleware = {};
         this.apiScopes = [];
         this.commands = [];
+        this.notifications = [];
     }
     boot(_context) { }
     routes() { }

package/dist/Modules/ModulesLoader.d.ts

@@ -1,3 +1,4 @@
+import type { NotificationDefinition } from "../Notifications/NotificationService";
 export declare class ModulesLoader {
     private loadedModules;
     load(modules: any[], context?: any): void;
@@ -6,6 +7,7 @@ export declare class ModulesLoader {
     };
     getLoadedModuleInstances(): any[];
     getCommands(): any[];
+    getNotifications(): NotificationDefinition[];
     initRoutes(): void;
     loadKernel(kernel: any): void;
 }

package/dist/Modules/ModulesLoader.js

@@ -29,6 +29,16 @@ class ModulesLoader {
         }
         return commands;
     }
+    getNotifications() {
+        const notifications = [];
+        for (const key in this.loadedModules) {
+            const moduleNotifications = this.loadedModules[key].notifications;
+            if (Array.isArray(moduleNotifications)) {
+                notifications.push(...moduleNotifications);
+            }
+        }
+        return notifications;
+    }
     initRoutes() {
         for (let key in this.loadedModules) {
             this.loadedModules[key].routes();

package/dist/Notifications/BaseNotificationsController.d.ts

@@ -2,17 +2,25 @@ import { Controller } from "../Controller/Controller";
 import { Request } from "../Router/Request";
 import { Response } from "../Router/Response";
 import { Notification } from "./Notification";
+import { NotificationTargetContext } from "./NotificationService";
 export declare class BaseNotificationsController extends Controller {
-    endpoint(req: Request, res: Response): Promise<Response>;
-    protected getUserId(req: Request): Promise<any>;
+    endpoint(req: Request, res: Response): Promise<any>;
+    private getActionName;
     protected getNotificationReference(req: Request): any;
     protected serializeNotification(notification: Notification): object;
+    protected createNotification(req: Request, key: string, payload: Record<string, any>, targetContext: NotificationTargetContext): Promise<Notification | null>;
     private parsePaginationValue;
-    private unauthorized;
     private notificationNotFound;
-    list(req: Request, res: Response): Promise<Response>;
-    details(req: Request, res: Response): Promise<Response>;
-    markOneAsRead(req: Request, res: Response): Promise<Response>;
-    markAllAsRead(req: Request, res: Response): Promise<Response>;
-    markAllAsViewed(req: Request, res: Response): Promise<Response>;
+    private getAuthorizedTarget;
+    private getTypeForTarget;
+    definition(req: Request, res: Response): Promise<Response | undefined>;
+    create(req: Request, res: Response): Promise<Response | undefined>;
+    preferences(req: Request, res: Response): Promise<Response | undefined>;
+    savePreferences(req: Request, res: Response): Promise<Response | undefined>;
+    list(req: Request, res: Response): Promise<Response | undefined>;
+    counts(req: Request, res: Response): Promise<Response | undefined>;
+    details(req: Request, res: Response): Promise<Response | undefined>;
+    markOneAsRead(req: Request, res: Response): Promise<Response | undefined>;
+    markAllAsRead(req: Request, res: Response): Promise<Response | undefined>;
+    markAllAsViewed(req: Request, res: Response): Promise<Response | undefined>;
 }

package/dist/Notifications/BaseNotificationsController.js

@@ -16,37 +16,27 @@ class BaseNotificationsController extends Controller_1.Controller {
     endpoint(req, res) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const requestType = (_a = req.body) === null || _a === void 0 ? void 0 : _a.__type;
-            if (requestType === "list") {
-                return yield this.list(req, res);
+            const actionName = this.getActionName((_a = req.body) === null || _a === void 0 ? void 0 : _a.__type);
+            const action = actionName ? this[actionName] : null;
+            if (typeof action !== "function") {
+                return res.status(400).send({ status: "error", message: "Invalid notification request." });
             }
-            if (requestType === "details") {
-                return yield this.details(req, res);
-            }
-            if (requestType === "mark_one_as_read") {
-                return yield this.markOneAsRead(req, res);
-            }
-            if (requestType === "mark_all_as_read") {
-                return yield this.markAllAsRead(req, res);
-            }
-            if (requestType === "mark_all_as_viewed") {
-                return yield this.markAllAsViewed(req, res);
-            }
-            return res.status(400).send({
-                status: "error",
-                message: "Invalid notification request.",
-            });
+            return yield action.call(this, req, res);
         });
     }
-    getUserId(req) {
-        var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function* () {
-            const configuredResolver = (_a = NotificationService_1.NotificationService.notificationsConfig) === null || _a === void 0 ? void 0 : _a.getUserIdByRequest;
-            if (typeof configuredResolver === "function") {
-                return yield configuredResolver(req);
-            }
-            return (_e = (_c = (_b = req.user) === null || _b === void 0 ? void 0 : _b._id) !== null && _c !== void 0 ? _c : (_d = req.user) === null || _d === void 0 ? void 0 : _d.id) !== null && _e !== void 0 ? _e : null;
-        });
+    getActionName(type) {
+        return {
+            list: "list",
+            counts: "counts",
+            details: "details",
+            mark_one_as_read: "markOneAsRead",
+            mark_all_as_read: "markAllAsRead",
+            mark_all_as_viewed: "markAllAsViewed",
+            definition: "definition",
+            create: "create",
+            preferences: "preferences",
+            save_preferences: "savePreferences",
+        }[type];
     }
     getNotificationReference(req) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -55,6 +45,11 @@ class BaseNotificationsController extends Controller_1.Controller {
     serializeNotification(notification) {
         return notification.toArray();
     }
+    createNotification(req, key, payload, targetContext) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield NotificationService_1.NotificationService.create(key, payload, Object.assign(Object.assign({}, targetContext), { request: req }));
+        });
+    }
     parsePaginationValue(value, fallback, maximum) {
         const parsed = Number(value);
         if (!Number.isFinite(parsed) || parsed < 0)
@@ -62,115 +57,222 @@ class BaseNotificationsController extends Controller_1.Controller {
         const integer = Math.floor(parsed);
         return maximum !== undefined ? Math.min(integer, maximum) : integer;
     }
-    unauthorized(res) {
-        return res.status(401).send({
-            status: "error",
-            message: "Authenticated user required.",
+    notificationNotFound(res) {
+        return res.status(404).send({ status: "error", message: "Notification not found." });
+    }
+    getAuthorizedTarget(req, res) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const context = yield NotificationService_1.NotificationService.authorizeTarget({
+                    target: (_a = req.body) === null || _a === void 0 ? void 0 : _a.target,
+                    target_id: (_b = req.body) === null || _b === void 0 ? void 0 : _b.target_id,
+                    request: req,
+                });
+                if (!context) {
+                    res.status(404).send({ status: "error", message: "Notification target not found." });
+                    return null;
+                }
+                return context;
+            }
+            catch (error) {
+                if (error instanceof NotificationService_1.NotificationTargetValidationError) {
+                    res.status(400).send({ status: "error", message: error.message });
+                    return null;
+                }
+                throw error;
+            }
         });
     }
-    notificationNotFound(res) {
-        return res.status(404).send({
-            status: "error",
-            message: "Notification not found.",
+    getTypeForTarget(key, target) {
+        const type = NotificationService_1.NotificationService.getTypeOrFail(key);
+        return type.targets.includes(target) ? type : null;
+    }
+    definition(req, res) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const key = (_a = req.body) === null || _a === void 0 ? void 0 : _a.key;
+            if (typeof key !== "string" || key.trim() === "") {
+                return res.status(400).send({ status: "error", message: "Notification type key required." });
+            }
+            try {
+                if (!this.getTypeForTarget(key, context.target))
+                    throw new Error("not available");
+                return res.send({
+                    status: "success",
+                    data: { definition: NotificationService_1.NotificationService.getPublicTypeDefinition(key) },
+                });
+            }
+            catch (_error) {
+                return res.status(404).send({ status: "error", message: "Notification type not found." });
+            }
+        });
+    }
+    create(req, res) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const key = (_a = req.body) === null || _a === void 0 ? void 0 : _a.key;
+            if (typeof key !== "string" || key.trim() === "") {
+                return res.status(400).send({ status: "error", message: "Notification type key required." });
+            }
+            const payload = (_b = req.body) === null || _b === void 0 ? void 0 : _b.payload;
+            if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+                return res.status(400).send({ status: "error", message: "Notification payload must be an object." });
+            }
+            let type;
+            try {
+                type = this.getTypeForTarget(key, context.target);
+            }
+            catch (_error) {
+                type = null;
+            }
+            if (!type)
+                return res.status(404).send({ status: "error", message: "Notification type not found." });
+            if ((type.mode || "fixed") !== "changing" || !type.queueJobAutomation) {
+                return res.status(400).send({
+                    status: "error",
+                    message: "Notification type does not start an automated queue job.",
+                });
+            }
+            try {
+                const notification = yield this.createNotification(req, key, payload, context);
+                if (!notification) {
+                    return res.status(403).send({ status: "error", message: "Notification type is disabled." });
+                }
+                return res.send({ status: "success", data: { entry: this.serializeNotification(notification) } });
+            }
+            catch (error) {
+                return res
+                    .status(error instanceof NotificationService_1.NotificationPayloadValidationError ||
+                    error instanceof NotificationService_1.NotificationTargetValidationError
+                    ? 400
+                    : 500)
+                    .send({ status: "error", message: (error === null || error === void 0 ? void 0 : error.message) || "Notification could not be created." });
+            }
+        });
+    }
+    preferences(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const preferences = yield NotificationService_1.NotificationService.getTargetPreferences(context);
+            if (!preferences) {
+                return res.status(404).send({ status: "error", message: "Notification target not found." });
+            }
+            return res.send({ status: "success", data: preferences });
+        });
+    }
+    savePreferences(req, res) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const key = (_a = req.body) === null || _a === void 0 ? void 0 : _a.key;
+            const enabled = (_b = req.body) === null || _b === void 0 ? void 0 : _b.enabled;
+            const outputChannels = (_c = req.body) === null || _c === void 0 ? void 0 : _c.output_channels;
+            if (typeof key !== "string" || key.trim() === "") {
+                return res.status(400).send({ status: "error", message: "Notification type key required." });
+            }
+            if (typeof enabled !== "boolean") {
+                return res.status(400).send({ status: "error", message: "Enabled must be a boolean." });
+            }
+            if (!Array.isArray(outputChannels) || outputChannels.some((channel) => typeof channel !== "string")) {
+                return res.status(400).send({ status: "error", message: "Output channels must be an array of strings." });
+            }
+            try {
+                const entry = yield NotificationService_1.NotificationService.saveTargetPreference(key, { enabled, output_channels: outputChannels }, context);
+                if (!entry)
+                    return res.status(404).send({ status: "error", message: "Notification target not found." });
+                return res.send({ status: "success", data: { entry } });
+            }
+            catch (error) {
+                return res.status(400).send({ status: "error", message: (error === null || error === void 0 ? void 0 : error.message) || "Preferences could not be saved." });
+            }
         });
     }
     list(req, res) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const userId = yield this.getUserId(req);
-            if (!userId)
-                return this.unauthorized(res);
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
             const offset = this.parsePaginationValue((_a = req.body) === null || _a === void 0 ? void 0 : _a.offset, 0);
             const limit = this.parsePaginationValue((_b = req.body) === null || _b === void 0 ? void 0 : _b.limit, 10, 100) || 10;
-            const [loadedNotifications, unreadCount, unviewedCount] = yield Promise.all([
-                NotificationService_1.NotificationService.loadNotifications({
-                    _user: userId,
-                    offset,
-                    limit: limit + 1,
-                    request: req,
-                }),
-                NotificationService_1.NotificationService.getUserUnreadCount(userId, req),
-                NotificationService_1.NotificationService.getUserUnviewedCount(userId, req),
+            const [loaded, unreadCount, unviewedCount] = yield Promise.all([
+                NotificationService_1.NotificationService.loadNotifications(Object.assign(Object.assign({}, context), { offset, limit: limit + 1 })),
+                NotificationService_1.NotificationService.getUnreadCount(context),
+                NotificationService_1.NotificationService.getUnviewedCount(context),
             ]);
-            const hasMore = loadedNotifications.length > limit;
-            const entries = loadedNotifications.slice(0, limit).map((notification) => this.serializeNotification(notification));
             return res.send({
                 status: "success",
                 data: {
-                    entries,
+                    entries: loaded.slice(0, limit).map((entry) => this.serializeNotification(entry)),
                     unread_count: unreadCount,
                     unviewed_count: unviewedCount,
-                    has_more: hasMore,
+                    has_more: loaded.length > limit,
                 },
             });
         });
     }
+    counts(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const [unreadCount, unviewedCount] = yield Promise.all([
+                NotificationService_1.NotificationService.getUnreadCount(context),
+                NotificationService_1.NotificationService.getUnviewedCount(context),
+            ]);
+            return res.send({ status: "success", data: { unread_count: unreadCount, unviewed_count: unviewedCount } });
+        });
+    }
     details(req, res) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userId = yield this.getUserId(req);
-            if (!userId)
-                return this.unauthorized(res);
-            const notificationRef = this.getNotificationReference(req);
-            if (!notificationRef)
-                return this.notificationNotFound(res);
-            const notification = yield NotificationService_1.NotificationService.getNotificationForUser(notificationRef, userId, req);
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const notification = yield NotificationService_1.NotificationService.getNotificationForTarget(this.getNotificationReference(req), context);
             if (!notification)
                 return this.notificationNotFound(res);
-            return res.send({
-                status: "success",
-                data: {
-                    entry: this.serializeNotification(notification),
-                },
-            });
+            return res.send({ status: "success", data: { entry: this.serializeNotification(notification) } });
         });
     }
     markOneAsRead(req, res) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userId = yield this.getUserId(req);
-            if (!userId)
-                return this.unauthorized(res);
-            const notificationRef = this.getNotificationReference(req);
-            if (!notificationRef)
-                return this.notificationNotFound(res);
-            const notification = yield NotificationService_1.NotificationService.getNotificationForUser(notificationRef, userId, req);
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            const notification = yield NotificationService_1.NotificationService.getNotificationForTarget(this.getNotificationReference(req), context);
             if (!notification)
                 return this.notificationNotFound(res);
-            const updatedNotification = yield NotificationService_1.NotificationService.markAsRead(notification);
-            return res.send({
-                status: "success",
-                data: {
-                    entry: this.serializeNotification(updatedNotification),
-                    message: "Notification marked as read.",
-                },
-            });
+            const entry = yield NotificationService_1.NotificationService.markAsRead(notification);
+            return res.send({ status: "success", data: { entry: this.serializeNotification(entry) } });
         });
     }
     markAllAsRead(req, res) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userId = yield this.getUserId(req);
-            if (!userId)
-                return this.unauthorized(res);
-            yield NotificationService_1.NotificationService.markAllAsRead(userId, req);
-            return res.send({
-                status: "success",
-                data: {
-                    message: "All notifications marked as read.",
-                },
-            });
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            yield NotificationService_1.NotificationService.markAllAsRead(context);
+            return res.send({ status: "success", data: { message: "All notifications marked as read." } });
         });
     }
     markAllAsViewed(req, res) {
         return __awaiter(this, void 0, void 0, function* () {
-            const userId = yield this.getUserId(req);
-            if (!userId)
-                return this.unauthorized(res);
-            yield NotificationService_1.NotificationService.markAllAsViewed(userId, req);
-            return res.send({
-                status: "success",
-                data: {
-                    message: "All notifications marked as viewed.",
-                },
-            });
+            const context = yield this.getAuthorizedTarget(req, res);
+            if (!context)
+                return;
+            yield NotificationService_1.NotificationService.markAllAsViewed(context);
+            return res.send({ status: "success", data: { message: "All notifications marked as viewed." } });
         });
     }
 }

package/dist/Notifications/Notification.d.ts

@@ -2,11 +2,15 @@ import type { ObjectId } from "mongodb";
 import { Model } from "../Database/Model";
 import type { NotificationChangingStatus, NotificationModes, NotificationReadStatus, NotificationViewStatus } from "./NotificationService";
 export declare class Notification extends Model {
+    target?: string;
+    target_id?: ObjectId;
+    targetModel?: any;
     key?: string;
     mode?: NotificationModes;
     changing_status?: NotificationChangingStatus;
     changing_error?: string | null;
     _queue_job?: ObjectId;
+    _files?: ObjectId[];
     read_status?: NotificationReadStatus;
     read_at?: Date | null;
     view_status?: NotificationViewStatus;