@webtypen/webframez-core 0.3.60 → 0.3.61

package/dist/Commands/QueueWorkerCommand.js

@@ -26,6 +26,7 @@ const ErrorHandler_1 = require("../ErrorHandling/ErrorHandler");
 const BackupManager_1 = require("../Backup/BackupManager");
 const WebframezHooks_1 = require("../Hooks/WebframezHooks");
 const AutomationSchedule_1 = require("../Queue/AutomationSchedule");
+const NotificationService_1 = require("../Notifications/NotificationService");
 class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
     constructor() {
         super(...arguments);
@@ -534,6 +535,7 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                     job_executions_count: job.executions.length,
                 };
                 let jobInstance = null;
+                let jobNotification = null;
                 const jobType = this.jobTypes && this.jobTypes[job.jobclass] ? this.jobTypes[job.jobclass] : null;
                 const jobOperationId = WebframezHooks_1.WebframezHooks.createOperationId("job");
                 yield WebframezHooks_1.WebframezHooks.emit("queue.job.start", {
@@ -546,6 +548,14 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                     },
                 });
                 try {
+                    if (job.notification_queue_job) {
+                        if (!job._notification) {
+                            throw new Error(`Notification queue-job '${job._id.toString()}' has no _notification reference.`);
+                        }
+                        jobNotification = yield NotificationService_1.NotificationService.getNotification(job._notification);
+                        job.notification = jobNotification;
+                        yield NotificationService_1.NotificationService.setChangingStatus(jobNotification, "running");
+                    }
                     if (!jobType) {
                         throw new Error(`QueueError: Invalid job-type ${job.jobclass}`);
                     }
@@ -558,11 +568,13 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                     job.executions[0].ended_at = endedAt;
                     job.executions[0].log = jobInstance.getLog();
                     job.executions[0].duration_ms = (0, moment_timezone_1.default)().diff((0, moment_timezone_1.default)(startedAt), "milliseconds");
-                    const updateData = {};
                     if (result && typeof result === "object" && result.__execute_again) {
                         job.status = "pending";
-                        job.started_at = result.__execute_again;
-                        updateData.started_at = result.__execute_again;
+                        job.ended_at = null;
+                        job.not_before = result.__execute_again;
+                    }
+                    if (jobNotification) {
+                        yield NotificationService_1.NotificationService.setChangingStatus(jobNotification, job.status === "pending" ? "pending" : "success");
                     }
                     yield connection.client
                         .db(null)
@@ -571,6 +583,7 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                         $set: {
                             status: job.status,
                             ended_at: job.ended_at,
+                            not_before: job.status === "pending" ? job.not_before : null,
                             executions: [...job.executions],
                         },
                     });
@@ -615,6 +628,26 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                     });
                     const errorMessage = e instanceof Error ? e.stack || e.message : String(e);
                     const endedAt = new Date();
+                    if (jobNotification) {
+                        try {
+                            yield NotificationService_1.NotificationService.setChangingStatus(jobNotification, "error", errorMessage);
+                        }
+                        catch (notificationError) {
+                            yield ErrorHandler_1.ErrorHandler.report(notificationError, {
+                                scope: "job",
+                                source: "queue.worker.notification.status",
+                                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 ? job._notification.toString() : null,
+                                },
+                            });
+                        }
+                    }
                     job.status = "failed";
                     job.ended_at = endedAt;
                     job.executions[0].status = "failed";

package/dist/ConsoleApplication.js

@@ -33,6 +33,7 @@ const BackupRestorePointsCommand_1 = require("./Commands/BackupRestorePointsComm
 const BackupRunJob_1 = require("./Backup/Jobs/BackupRunJob");
 const SystemCommands_1 = require("./Commands/SystemCommands");
 const ModulesLoader_1 = require("./Modules/ModulesLoader");
+const NotificationService_1 = require("./Notifications/NotificationService");
 class ConsoleApplication {
     constructor() {
         this.modulesLoader = null;
@@ -62,6 +63,7 @@ class ConsoleApplication {
                 Config_1.Config.register(key, options.config[key]);
             }
         }
+        NotificationService_1.NotificationService.init();
         if (options && options.errorHandler) {
             if (Array.isArray(options.errorHandler)) {
                 ErrorHandler_1.ErrorHandler.setHandlers(options.errorHandler);

package/dist/Notifications/BaseNotificationsController.d.ts

@@ -0,0 +1,18 @@
+import { Controller } from "../Controller/Controller";
+import { Request } from "../Router/Request";
+import { Response } from "../Router/Response";
+import { Notification } from "./Notification";
+export declare class BaseNotificationsController extends Controller {
+    endpoint(req: Request, res: Response): Promise<Response>;
+    protected getUserId(req: Request): Promise<any>;
+    protected getNotificationReference(req: Request): any;
+    protected serializeNotification(notification: Notification): object;
+    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>;
+}

package/dist/Notifications/BaseNotificationsController.js

@@ -0,0 +1,177 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseNotificationsController = void 0;
+const Controller_1 = require("../Controller/Controller");
+const NotificationService_1 = require("./NotificationService");
+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);
+            }
+            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.",
+            });
+        });
+    }
+    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;
+        });
+    }
+    getNotificationReference(req) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return (_h = (_f = (_d = (_b = (_a = req.body) === null || _a === void 0 ? void 0 : _a._notification) !== null && _b !== void 0 ? _b : (_c = req.body) === null || _c === void 0 ? void 0 : _c.notification) !== null && _d !== void 0 ? _d : (_e = req.body) === null || _e === void 0 ? void 0 : _e._id) !== null && _f !== void 0 ? _f : (_g = req.body) === null || _g === void 0 ? void 0 : _g.id) !== null && _h !== void 0 ? _h : null;
+    }
+    serializeNotification(notification) {
+        return notification.toArray();
+    }
+    parsePaginationValue(value, fallback, maximum) {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed) || parsed < 0)
+            return fallback;
+        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.",
+        });
+    }
+    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 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 hasMore = loadedNotifications.length > limit;
+            const entries = loadedNotifications.slice(0, limit).map((notification) => this.serializeNotification(notification));
+            return res.send({
+                status: "success",
+                data: {
+                    entries,
+                    unread_count: unreadCount,
+                    unviewed_count: unviewedCount,
+                    has_more: hasMore,
+                },
+            });
+        });
+    }
+    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);
+            if (!notification)
+                return this.notificationNotFound(res);
+            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);
+            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.",
+                },
+            });
+        });
+    }
+    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.",
+                },
+            });
+        });
+    }
+    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.",
+                },
+            });
+        });
+    }
+}
+exports.BaseNotificationsController = BaseNotificationsController;

package/dist/Notifications/Notification.d.ts

@@ -0,0 +1,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 {
+    key?: string;
+    mode?: NotificationModes;
+    changing_status?: NotificationChangingStatus;
+    changing_error?: string | null;
+    _queue_job?: ObjectId;
+    read_status?: NotificationReadStatus;
+    read_at?: Date | null;
+    view_status?: NotificationViewStatus;
+    viewed_at?: Date | null;
+    __table: string;
+}

package/dist/Notifications/Notification.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notification = void 0;
+const Model_1 = require("../Database/Model");
+class Notification extends Model_1.Model {
+    constructor() {
+        super(...arguments);
+        this.__table = "notifications";
+    }
+}
+exports.Notification = Notification;

package/dist/Notifications/NotificationService.d.ts

@@ -0,0 +1,86 @@
+import { ObjectId } from "mongodb";
+import { Request } from "../Router/Request";
+import { Notification } from "./Notification";
+export type NotificationModes = "fixed" | "changing";
+export type NotificationReadStatus = "unread" | "read";
+export type NotificationViewStatus = "unviewed" | "viewed";
+export type NotificationChangingStatus = "pending" | "running" | "success" | "error";
+export type NotificationOptions = {
+    showAt?: Date;
+    baseData?: {
+        [key: string]: any;
+    };
+    _user: ObjectId | string;
+};
+export type NotificationPayload = {
+    [key: string]: any;
+};
+export type NotificationQueueJobAutomation = {
+    job: string;
+    check?: (notification: Notification) => boolean | Promise<boolean>;
+};
+export type NotificationDefinition = {
+    key: string;
+    mode?: NotificationModes;
+    baseData?: {
+        [key: string]: any;
+    };
+    payload?: {
+        [key: string]: any;
+    };
+    title?: string | null;
+    getTitle?: (notification: Notification) => Promise<String | null>;
+    description?: string | null;
+    getDescription?: (notification: Notification) => Promise<String | null>;
+    link?: string | null;
+    getLink?: (notification: Notification) => Promise<String | null>;
+    groupKey?: string | null;
+    getGroupKey?: (payload?: NotificationPayload, options?: NotificationOptions) => Promise<String | null>;
+    beforeSave?: (notification: Notification) => Promise<void>;
+    afterSave?: (notification: Notification) => Promise<void>;
+    queueJobAutomation?: NotificationQueueJobAutomation;
+};
+declare class NotificationServiceFacade {
+    registy: {
+        [key: string]: NotificationDefinition;
+    };
+    notificationsConfig: any;
+    init(): void;
+    getTypeOrFail(typeKey: string): NotificationDefinition;
+    private getErrorMessage;
+    private normalizeUserId;
+    private getLoadMatch;
+    private enrichNotification;
+    create(typeKey: string, payload: NotificationPayload, options?: NotificationOptions): Promise<Notification>;
+    getNotification(notificationRef: Notification | ObjectId | string | null): Promise<Notification>;
+    markAsRead(notification: Notification | ObjectId | string | null): Promise<Notification>;
+    markAsViewed(notification: Notification | ObjectId | string | null): Promise<Notification>;
+    markAllAsRead(_user: ObjectId | string, request?: Request): Promise<void>;
+    markAllAsViewed(_user: ObjectId | string, request?: Request): Promise<void>;
+    getNotificationForUser(notificationRef: Notification | ObjectId | string | null, _user: ObjectId | string, request?: Request): Promise<Notification | null>;
+    private countByStatus;
+    getUserUnreadCount(_user: ObjectId | string, request?: Request): Promise<number>;
+    getUserUnviewedCount(_user: ObjectId | string, request?: Request): Promise<number>;
+    countUnreadNotifications(options: {
+        _user: ObjectId | string;
+        request?: Request;
+    }): Promise<number>;
+    updateNotification(notification: Notification | ObjectId | string | null, updateData: {
+        payload?: NotificationPayload;
+        _user?: ObjectId | string;
+        show_at?: Date | null;
+        read_status?: NotificationReadStatus;
+        read_at?: Date | null;
+        view_status?: NotificationViewStatus;
+        viewed_at?: Date | null;
+    }): Promise<Notification>;
+    setChangingStatus(notification: Notification | ObjectId | string | null, status: NotificationChangingStatus, error?: string | null): Promise<Notification>;
+    loadNotifications(options?: {
+        _user: ObjectId | string;
+        offset?: number;
+        limit?: number;
+        request?: Request;
+    }): Promise<Notification[]>;
+}
+export declare const NotificationService: NotificationServiceFacade;
+export {};

package/dist/Notifications/NotificationService.js

@@ -0,0 +1,371 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const mongodb_1 = require("mongodb");
+const Notification_1 = require("./Notification");
+const Config_1 = require("../Config");
+const DBConnection_1 = require("../Database/DBConnection");
+const QueueJobsRegisty_1 = require("../Queue/QueueJobsRegisty");
+class NotificationServiceFacade {
+    constructor() {
+        this.registy = {};
+        this.notificationsConfig = {};
+    }
+    init() {
+        this.registy = {};
+        this.notificationsConfig = Config_1.Config.get("notifications") || {};
+        if (Array.isArray(this.notificationsConfig.types)) {
+            for (let t of this.notificationsConfig.types) {
+                this.registy[t.key] = t;
+            }
+        }
+    }
+    getTypeOrFail(typeKey) {
+        if (this.registy[typeKey]) {
+            return this.registy[typeKey];
+        }
+        throw new Error("Invalid notification-type '" + typeKey + "' ...");
+    }
+    getErrorMessage(error) {
+        if ((error === null || error === void 0 ? void 0 : error.message) && error.message.toString().trim() !== "") {
+            return error.message.toString();
+        }
+        if (error && error.toString().trim() !== "") {
+            return error.toString();
+        }
+        return "Unknown notification queue-job error";
+    }
+    normalizeUserId(_user) {
+        return typeof _user === "string" && _user.length === 24 && mongodb_1.ObjectId.isValid(_user) ? new mongodb_1.ObjectId(_user) : _user;
+    }
+    getLoadMatch(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const additionalMatch = ((_a = this.notificationsConfig) === null || _a === void 0 ? void 0 : _a.onLoadNotificationsMatch)
+                ? yield this.notificationsConfig.onLoadNotificationsMatch(options)
+                : {};
+            return Object.assign(Object.assign({}, (additionalMatch || {})), { _user: this.normalizeUserId(options._user), key: { $in: Object.keys(this.registy) }, show_at: { $lte: new Date() } });
+        });
+    }
+    enrichNotification(notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notType = (notification === null || notification === void 0 ? void 0 : notification.key) ? this.registy[notification.key] : null;
+            if (!notType)
+                return null;
+            notification.title = notType.getTitle
+                ? yield notType.getTitle(notification)
+                : notType.title !== undefined
+                    ? notType.title
+                    : null;
+            notification.description = notType.getDescription
+                ? yield notType.getDescription(notification)
+                : notType.description !== undefined
+                    ? notType.description
+                    : null;
+            notification.link = notType.getLink
+                ? yield notType.getLink(notification)
+                : notType.link !== undefined
+                    ? notType.link
+                    : null;
+            return notification;
+        });
+    }
+    create(typeKey, payload, options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const notType = this.getTypeOrFail(typeKey);
+            const notificationMode = notType.mode || "fixed";
+            if (notType.queueJobAutomation && notificationMode !== "changing") {
+                throw new Error(`Notification-type '${notType.key}' can only use queueJobAutomation in changing mode.`);
+            }
+            const notification = new Notification_1.Notification();
+            notification.key = notType.key;
+            notification.mode = notificationMode;
+            notification.group_key = notType.getGroupKey ? yield notType.getGroupKey(payload, options) : null;
+            if (options === null || options === void 0 ? void 0 : options.baseData) {
+                for (let key in options.baseData) {
+                    notification[key] = options.baseData[key];
+                }
+            }
+            if (notification.payload) {
+                notification.payload = Object.assign(Object.assign({}, notification.payload), payload);
+            }
+            else {
+                notification.payload = payload;
+            }
+            notification.key = notType.key;
+            notification.mode = notificationMode;
+            notification.created_at = new Date();
+            notification.read_status = "unread";
+            notification.read_at = null;
+            notification.view_status = "unviewed";
+            notification.viewed_at = null;
+            notification.show_at = (options === null || options === void 0 ? void 0 : options.showAt) || new Date();
+            if (notification.mode === "changing") {
+                notification.changing_status = "pending";
+                notification.changing_error = null;
+            }
+            if (options === null || options === void 0 ? void 0 : options._user) {
+                if (typeof options._user === "string" && options._user.length === 24) {
+                    notification._user = new mongodb_1.ObjectId(options._user);
+                }
+                else {
+                    notification._user = options._user;
+                }
+            }
+            if ((_a = this.notificationsConfig) === null || _a === void 0 ? void 0 : _a.beforeNotificationSave) {
+                yield this.notificationsConfig.beforeNotificationSave(notification);
+            }
+            if (notType.beforeSave) {
+                yield notType.beforeSave(notification);
+            }
+            yield notification.save();
+            if (notType.queueJobAutomation) {
+                try {
+                    const shouldCreateJob = notType.queueJobAutomation.check
+                        ? yield notType.queueJobAutomation.check(notification)
+                        : true;
+                    if (!shouldCreateJob) {
+                        yield this.setChangingStatus(notification, "success");
+                    }
+                    else {
+                        const queueJobType = QueueJobsRegisty_1.QueueJobsRegisty.getJobOrFail(notType.queueJobAutomation.job);
+                        const queueJob = yield queueJobType.create({
+                            status: "initializing",
+                            notification_queue_job: true,
+                            _notification: notification._id,
+                        });
+                        notification._queue_job = queueJob._id;
+                        yield notification.save();
+                        queueJob.status = "pending";
+                        yield queueJob.save();
+                    }
+                }
+                catch (error) {
+                    yield this.setChangingStatus(notification, "error", this.getErrorMessage(error));
+                    throw error;
+                }
+            }
+            if ((_b = this.notificationsConfig) === null || _b === void 0 ? void 0 : _b.afterNotificationSave) {
+                yield this.notificationsConfig.afterNotificationSave(notification);
+            }
+            if (notType.afterSave) {
+                yield notType.afterSave(notification);
+            }
+            return notification;
+        });
+    }
+    getNotification(notificationRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (notificationRef instanceof Notification_1.Notification) {
+                return notificationRef;
+            }
+            if (typeof notificationRef === "string" || notificationRef instanceof mongodb_1.ObjectId) {
+                const loadNotification = yield Notification_1.Notification.where("_id", "=", yield Notification_1.Notification.objectId(notificationRef)).first();
+                if (loadNotification) {
+                    return loadNotification;
+                }
+            }
+            throw new Error("Invalid notification type provided: " + (notificationRef === null || notificationRef === void 0 ? void 0 : notificationRef.toString()));
+        });
+    }
+    markAsRead(notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            notification = yield this.getNotification(notification);
+            if (notification.read_status === "read" && notification.view_status === "viewed") {
+                return notification;
+            }
+            const now = new Date();
+            notification.read_at = notification.read_at || now;
+            notification.read_status = "read";
+            notification.viewed_at = notification.viewed_at || now;
+            notification.view_status = "viewed";
+            yield notification.save();
+            return notification;
+        });
+    }
+    markAsViewed(notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            notification = yield this.getNotification(notification);
+            if (notification.view_status === "viewed") {
+                return notification;
+            }
+            notification.viewed_at = new Date();
+            notification.view_status = "viewed";
+            yield notification.save();
+            return notification;
+        });
+    }
+    markAllAsRead(_user, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield DBConnection_1.DBConnection.getConnection();
+            const now = new Date();
+            yield connection.client
+                .db(null)
+                .collection(new Notification_1.Notification().__table)
+                .updateMany(Object.assign(Object.assign({}, (yield this.getLoadMatch({ _user, request }))), { $or: [{ read_status: "unread" }, { view_status: "unviewed" }] }), [
+                {
+                    $set: {
+                        read_at: { $ifNull: ["$read_at", now] },
+                        read_status: "read",
+                        viewed_at: { $ifNull: ["$viewed_at", now] },
+                        view_status: "viewed",
+                    },
+                },
+            ]);
+        });
+    }
+    markAllAsViewed(_user, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield DBConnection_1.DBConnection.getConnection();
+            yield connection.client
+                .db(null)
+                .collection(new Notification_1.Notification().__table)
+                .updateMany(Object.assign(Object.assign({}, (yield this.getLoadMatch({ _user, request }))), { view_status: "unviewed" }), {
+                $set: {
+                    viewed_at: new Date(),
+                    view_status: "viewed",
+                },
+            });
+        });
+    }
+    getNotificationForUser(notificationRef, _user, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notificationId = notificationRef instanceof Notification_1.Notification ? notificationRef._id : notificationRef;
+            if (!notificationId)
+                return null;
+            let objectId;
+            if (notificationId instanceof mongodb_1.ObjectId) {
+                objectId = notificationId;
+            }
+            else if (typeof notificationId === "string" && mongodb_1.ObjectId.isValid(notificationId)) {
+                objectId = new mongodb_1.ObjectId(notificationId);
+            }
+            else {
+                return null;
+            }
+            const notifications = yield Notification_1.Notification.aggregate([
+                {
+                    $match: Object.assign(Object.assign({}, (yield this.getLoadMatch({ _user, request }))), { _id: objectId }),
+                },
+                { $limit: 1 },
+            ]);
+            if (!notifications || notifications.length === 0)
+                return null;
+            const notification = DBConnection_1.DBConnection.mapDataToModel(Notification_1.Notification, notifications[0]);
+            return yield this.enrichNotification(notification);
+        });
+    }
+    countByStatus(options, match) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield Notification_1.Notification.aggregate([
+                {
+                    $match: Object.assign(Object.assign({}, (yield this.getLoadMatch(options))), match),
+                },
+                { $count: "count" },
+            ]);
+            return result && result[0] && typeof result[0].count === "number" ? result[0].count : 0;
+        });
+    }
+    getUserUnreadCount(_user, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.countByStatus({ _user, request }, { read_status: "unread" });
+        });
+    }
+    getUserUnviewedCount(_user, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.countByStatus({ _user, request }, { view_status: "unviewed" });
+        });
+    }
+    countUnreadNotifications(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getUserUnreadCount(options._user, options.request);
+        });
+    }
+    updateNotification(notification, updateData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            notification = yield this.getNotification(notification);
+            if (updateData.payload) {
+                notification.payload = Object.assign(Object.assign({}, notification.payload), updateData.payload);
+            }
+            if (updateData._user !== undefined) {
+                if (typeof updateData._user === "string" && updateData._user.length === 24) {
+                    notification._user = new mongodb_1.ObjectId(updateData._user);
+                }
+                else {
+                    notification._user = updateData._user;
+                }
+            }
+            if (updateData.show_at !== undefined) {
+                notification.show_at = updateData.show_at;
+            }
+            if (updateData.read_status !== undefined) {
+                notification.read_status = updateData.read_status;
+            }
+            if (updateData.read_at !== undefined) {
+                notification.read_at = updateData.read_at;
+            }
+            if (updateData.view_status !== undefined) {
+                notification.view_status = updateData.view_status;
+            }
+            if (updateData.viewed_at !== undefined) {
+                notification.viewed_at = updateData.viewed_at;
+            }
+            yield notification.save();
+            return notification;
+        });
+    }
+    setChangingStatus(notification, status, error) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            notification = yield this.getNotification(notification);
+            if (notification.mode !== "changing") {
+                throw new Error(`Notification '${(_a = notification._id) === null || _a === void 0 ? void 0 : _a.toString()}' is not in changing mode.`);
+            }
+            notification.changing_status = status;
+            notification.changing_error = status === "error" ? error || "Unknown notification error" : null;
+            yield notification.save();
+            return notification;
+        });
+    }
+    loadNotifications(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(options === null || options === void 0 ? void 0 : options._user))
+                return [];
+            const notifications = yield Notification_1.Notification.aggregate([
+                {
+                    $match: yield this.getLoadMatch(options),
+                },
+                {
+                    $sort: { show_at: -1 },
+                },
+                {
+                    $skip: (options === null || options === void 0 ? void 0 : options.offset) || 0,
+                },
+                {
+                    $limit: (options === null || options === void 0 ? void 0 : options.limit) || 10,
+                },
+            ]);
+            if (!notifications || notifications.length === 0)
+                return [];
+            const out = [];
+            for (const notificationData of notifications) {
+                const el = DBConnection_1.DBConnection.mapDataToModel(Notification_1.Notification, notificationData);
+                const enrichedNotification = yield this.enrichNotification(el);
+                if (enrichedNotification)
+                    out.push(enrichedNotification);
+            }
+            return out;
+        });
+    }
+}
+exports.NotificationService = new NotificationServiceFacade();

package/dist/Notifications/NotificationsOutputChannel.d.ts

@@ -0,0 +1,9 @@
+import { Notification } from "./Notification";
+export declare class NotificationOutputChannel {
+    key: string;
+    activated: boolean;
+    handle(notification: Notification): Promise<{
+        status: boolean;
+        payload?: any;
+    }>;
+}

package/dist/Notifications/NotificationsOutputChannel.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationOutputChannel = void 0;
+class NotificationOutputChannel {
+    constructor() {
+        this.key = "example-output-channel";
+        this.activated = false;
+    }
+    handle(notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return { status: true };
+        });
+    }
+}
+exports.NotificationOutputChannel = NotificationOutputChannel;

package/dist/Notifications/NotificationsOutputChannelsJob.d.ts

@@ -0,0 +1,15 @@
+import { BaseQueueJob } from "../Queue/BaseQueueJob";
+export declare class NotificationsOutputChannelsJob extends BaseQueueJob {
+    static title: string;
+    attempts: number;
+    perAttempt: number;
+    private positiveNumber;
+    private getErrorMessage;
+    private getActiveChannels;
+    private getChannelResults;
+    private hasSuccessfulDelivery;
+    private claimNotification;
+    private saveChannelResult;
+    private deliverNotification;
+    handle(): Promise<void>;
+}

package/dist/Notifications/NotificationsOutputChannelsJob.js

@@ -0,0 +1,245 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsOutputChannelsJob = void 0;
+const mongodb_1 = require("mongodb");
+const Config_1 = require("../Config");
+const DBConnection_1 = require("../Database/DBConnection");
+const BaseQueueJob_1 = require("../Queue/BaseQueueJob");
+const Notification_1 = require("./Notification");
+const NotificationService_1 = require("./NotificationService");
+class NotificationsOutputChannelsJob extends BaseQueueJob_1.BaseQueueJob {
+    constructor() {
+        super(...arguments);
+        this.attempts = 10;
+        this.perAttempt = 50;
+    }
+    positiveNumber(value, fallback) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    }
+    getErrorMessage(error) {
+        if ((error === null || error === void 0 ? void 0 : error.message) && error.message.toString().trim() !== "") {
+            return error.message.toString();
+        }
+        if (error && error.toString().trim() !== "") {
+            return error.toString();
+        }
+        return "Failed without exception";
+    }
+    getActiveChannels(notificationsConfig) {
+        const channels = [];
+        const registeredKeys = new Set();
+        for (const channel of notificationsConfig.output_channels) {
+            if (!channel || !channel.key || !channel.is_active || !channel.driver)
+                continue;
+            if (registeredKeys.has(channel.key)) {
+                throw new Error(`Duplicate notification output-channel key '${channel.key}'.`);
+            }
+            const driver = new channel.driver();
+            if (!driver || !driver.activated)
+                continue;
+            registeredKeys.add(channel.key);
+            channels.push({ key: channel.key, driver });
+        }
+        return channels;
+    }
+    getChannelResults(notification, channelKey) {
+        if (!Array.isArray(notification.output_channels_result))
+            return [];
+        return notification.output_channels_result.filter((result) => (result === null || result === void 0 ? void 0 : result.channel) === channelKey);
+    }
+    hasSuccessfulDelivery(notification, channelKey) {
+        return this.getChannelResults(notification, channelKey).some((result) => result.status === "success");
+    }
+    claimNotification(collection, claimTimeoutMinutes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = new Date();
+            const staleClaimBefore = new Date(now.getTime() - claimTimeoutMinutes * 60 * 1000);
+            const claimToken = new mongodb_1.ObjectId().toHexString();
+            const claimResult = yield collection.findOneAndUpdate({
+                key: { $ne: null },
+                show_at: { $lte: now },
+                output_channels_finished_at: null,
+                $and: [
+                    {
+                        $or: [
+                            { output_channels_next_attempt_at: null },
+                            { output_channels_next_attempt_at: { $lte: now } },
+                        ],
+                    },
+                    {
+                        $or: [
+                            { output_channels_claimed_at: null },
+                            { output_channels_claimed_at: { $lte: staleClaimBefore } },
+                        ],
+                    },
+                    {
+                        $or: [
+                            { mode: null },
+                            { mode: "fixed" },
+                            { mode: "changing", changing_status: { $in: ["success", "error"] } },
+                        ],
+                    },
+                ],
+            }, {
+                $set: {
+                    output_channels_status: "processing",
+                    output_channels_claimed_at: now,
+                    output_channels_claim_token: claimToken,
+                    output_channels_handled_at: now,
+                },
+                $inc: { output_channels_attempts: 1 },
+            }, {
+                sort: { show_at: 1, created_at: 1 },
+                returnDocument: "after",
+            });
+            const notificationData = claimResult && claimResult._id
+                ? claimResult
+                : (claimResult === null || claimResult === void 0 ? void 0 : claimResult.value) && claimResult.value._id
+                    ? claimResult.value
+                    : null;
+            if (!notificationData)
+                return null;
+            return DBConnection_1.DBConnection.mapDataToModel(Notification_1.Notification, notificationData);
+        });
+    }
+    saveChannelResult(collection, notification, result) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const updateResult = yield collection.updateOne({
+                _id: notification._id,
+                output_channels_claim_token: notification.output_channels_claim_token,
+            }, {
+                $push: { output_channels_result: result },
+            });
+            if ((updateResult === null || updateResult === void 0 ? void 0 : updateResult.matchedCount) === 0) {
+                throw new Error(`Lost delivery claim for notification '${(_a = notification._id) === null || _a === void 0 ? void 0 : _a.toString()}'.`);
+            }
+            if (!Array.isArray(notification.output_channels_result)) {
+                notification.output_channels_result = [];
+            }
+            notification.output_channels_result.push(result);
+        });
+    }
+    deliverNotification(collection, notification, channels, maxChannelAttempts, retryDelayMinutes) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const notType = notification.key ? NotificationService_1.NotificationService.registy[notification.key] : null;
+            if (!notType) {
+                yield collection.updateOne({
+                    _id: notification._id,
+                    output_channels_claim_token: notification.output_channels_claim_token,
+                }, {
+                    $set: {
+                        output_channels_status: "failed",
+                        output_channels_error: "Invalid notification-type: " + notification.key,
+                        output_channels_finished_at: new Date(),
+                        output_channels_claimed_at: null,
+                        output_channels_claim_token: null,
+                        output_channels_next_attempt_at: null,
+                    },
+                });
+                return;
+            }
+            if (!Array.isArray(notification.output_channels_result)) {
+                notification.output_channels_result = [];
+            }
+            for (const channel of channels) {
+                if (this.hasSuccessfulDelivery(notification, channel.key))
+                    continue;
+                const previousAttempts = this.getChannelResults(notification, channel.key).length;
+                if (previousAttempts >= maxChannelAttempts)
+                    continue;
+                let result;
+                try {
+                    const status = yield channel.driver.handle(notification);
+                    if (!(status === null || status === void 0 ? void 0 : status.status)) {
+                        result = {
+                            channel: channel.key,
+                            date: new Date(),
+                            attempt: previousAttempts + 1,
+                            status: "error",
+                            error_message: "Output-channel returned status false.",
+                        };
+                    }
+                    else {
+                        const payload = status.payload;
+                        result = Object.assign(Object.assign({}, (payload && typeof payload === "object" && !Array.isArray(payload)
+                            ? payload
+                            : payload !== undefined
+                                ? { payload }
+                                : {})), { channel: channel.key, date: new Date(), attempt: previousAttempts + 1, status: "success" });
+                    }
+                }
+                catch (error) {
+                    result = {
+                        channel: channel.key,
+                        date: new Date(),
+                        attempt: previousAttempts + 1,
+                        status: "error",
+                        error_message: this.getErrorMessage(error),
+                    };
+                }
+                yield this.saveChannelResult(collection, notification, result);
+            }
+            const failedChannels = channels.filter((channel) => !this.hasSuccessfulDelivery(notification, channel.key));
+            const retryableChannels = failedChannels.filter((channel) => this.getChannelResults(notification, channel.key).length < maxChannelAttempts);
+            const now = new Date();
+            const isSuccessful = failedChannels.length === 0;
+            const isTerminalFailure = !isSuccessful && retryableChannels.length === 0;
+            const outputStatus = isSuccessful ? "sent" : isTerminalFailure ? "failed" : "retry_pending";
+            const errorMessage = failedChannels.length > 0 ? `Failed output-channels: ${failedChannels.map((c) => c.key).join(", ")}` : null;
+            const updateResult = yield collection.updateOne({
+                _id: notification._id,
+                output_channels_claim_token: notification.output_channels_claim_token,
+            }, {
+                $set: {
+                    output_channels_status: outputStatus,
+                    output_channels_error: errorMessage,
+                    output_channels_finished_at: isSuccessful || isTerminalFailure ? now : null,
+                    output_channels_next_attempt_at: isSuccessful || isTerminalFailure ? null : new Date(now.getTime() + retryDelayMinutes * 60 * 1000),
+                    output_channels_claimed_at: null,
+                    output_channels_claim_token: null,
+                },
+            });
+            if ((updateResult === null || updateResult === void 0 ? void 0 : updateResult.matchedCount) === 0) {
+                throw new Error(`Lost delivery claim for notification '${(_a = notification._id) === null || _a === void 0 ? void 0 : _a.toString()}'.`);
+            }
+        });
+    }
+    handle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const notificationsConfig = Config_1.Config.get("notifications");
+            if (!(notificationsConfig === null || notificationsConfig === void 0 ? void 0 : notificationsConfig.output_channels) || !Array.isArray(notificationsConfig.output_channels)) {
+                return;
+            }
+            const channels = this.getActiveChannels(notificationsConfig);
+            if (channels.length === 0)
+                return;
+            const deliveryConfig = notificationsConfig.output_channels_delivery || {};
+            const maxChannelAttempts = this.positiveNumber(deliveryConfig.max_attempts, 3);
+            const retryDelayMinutes = this.positiveNumber(deliveryConfig.retry_delay_minutes, 5);
+            const claimTimeoutMinutes = this.positiveNumber(deliveryConfig.claim_timeout_minutes, 30);
+            const connection = yield DBConnection_1.DBConnection.getConnection();
+            const collection = connection.client.db(null).collection(new Notification_1.Notification().__table);
+            const maxNotifications = this.attempts * this.perAttempt;
+            for (let handledNotifications = 0; handledNotifications < maxNotifications; handledNotifications++) {
+                const notification = yield this.claimNotification(collection, claimTimeoutMinutes);
+                if (!notification)
+                    break;
+                yield this.deliverNotification(collection, notification, channels, maxChannelAttempts, retryDelayMinutes);
+            }
+        });
+    }
+}
+exports.NotificationsOutputChannelsJob = NotificationsOutputChannelsJob;
+NotificationsOutputChannelsJob.title = "NotificationsOutputChannelsJob";

package/dist/Queue/QueueJob.d.ts

@@ -1,4 +1,9 @@
+import type { ObjectId } from "mongodb";
 import { Model } from "../Database/Model";
+import type { Notification } from "../Notifications/Notification";
 export declare class QueueJob extends Model {
+    notification_queue_job?: boolean;
+    _notification?: ObjectId;
+    notification?: Notification;
     __table: string;
 }

package/dist/Queue/QueueJobsRegisty.d.ts

@@ -3,6 +3,7 @@ declare class QueueJobsRegistyFacade {
     private registeredByKey;
     private registeredByReference;
     getJobs(): any[];
+    getJobOrFail(name: string): any;
     private getJobKey;
     private addJob;
     registerJob(data: any): this;

package/dist/Queue/QueueJobsRegisty.js

@@ -10,6 +10,13 @@ class QueueJobsRegistyFacade {
     getJobs() {
         return this.jobs;
     }
+    getJobOrFail(name) {
+        const job = this.jobs.find((entry) => typeof entry === "function" && entry.name === name && typeof entry.create === "function");
+        if (!job) {
+            throw new Error(`Queue job '${name}' is not registered.`);
+        }
+        return job;
+    }
     getJobKey(job) {
         if (!job) {
             return null;

package/dist/WebApplication.js

@@ -24,6 +24,7 @@ const ErrorHandler_1 = require("./ErrorHandling/ErrorHandler");
 const WebframezHooks_1 = require("./Hooks/WebframezHooks");
 const HttpKernelHandlerRegistry_1 = require("./Http/HttpKernelHandlerRegistry");
 const ApiScopeRegistry_1 = require("./Api/ApiScopeRegistry");
+const NotificationService_1 = require("./Notifications/NotificationService");
 // import { SigNozTelemetry } from "./Telemetry/SigNozTelemetry";
 class WebApplication {
     constructor() {
@@ -46,6 +47,7 @@ class WebApplication {
                 Config_1.Config.register(key, options.config[key]);
             }
         }
+        NotificationService_1.NotificationService.init();
         if (options && options.errorHandler) {
             if (Array.isArray(options.errorHandler)) {
                 ErrorHandler_1.ErrorHandler.setHandlers(options.errorHandler);

package/dist/index.d.ts

@@ -54,4 +54,9 @@ export * from "./Ai/AiTypes";
 export * from "./Mcp/McpTypes";
 export * from "./Http/HttpKernelHandlerRegistry";
 export * from "./Auth";
+export * from "./Notifications/Notification";
+export * from "./Notifications/BaseNotificationsController";
+export * from "./Notifications/NotificationService";
+export * from "./Notifications/NotificationsOutputChannel";
+export * from "./Notifications/NotificationsOutputChannelsJob";
 export * from "./info";

package/dist/index.js

@@ -70,4 +70,9 @@ __exportStar(require("./Ai/AiTypes"), exports);
 __exportStar(require("./Mcp/McpTypes"), exports);
 __exportStar(require("./Http/HttpKernelHandlerRegistry"), exports);
 __exportStar(require("./Auth"), exports);
+__exportStar(require("./Notifications/Notification"), exports);
+__exportStar(require("./Notifications/BaseNotificationsController"), exports);
+__exportStar(require("./Notifications/NotificationService"), exports);
+__exportStar(require("./Notifications/NotificationsOutputChannel"), exports);
+__exportStar(require("./Notifications/NotificationsOutputChannelsJob"), exports);
 __exportStar(require("./info"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.3.60",
+    "version": "0.3.61",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",