@webtypen/webframez-core 0.3.60 → 0.3.62

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,22 @@ 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);
+                        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");
+                    }
                     if (!jobType) {
                         throw new Error(`QueueError: Invalid job-type ${job.jobclass}`);
                     }
@@ -558,11 +576,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 +591,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 +636,51 @@ 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, {
+                                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,
+                                },
+                            });
+                        }
+                    }
+                    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

@@ -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);
@@ -78,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

@@ -0,0 +1,26 @@
+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<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 notificationNotFound;
+    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

@@ -0,0 +1,279 @@
+"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 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." });
+            }
+            return yield action.call(this, req, res);
+        });
+    }
+    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;
+        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();
+    }
+    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)
+            return fallback;
+        const integer = Math.floor(parsed);
+        return maximum !== undefined ? Math.min(integer, maximum) : integer;
+    }
+    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;
+            }
+        });
+    }
+    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 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 [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),
+            ]);
+            return res.send({
+                status: "success",
+                data: {
+                    entries: loaded.slice(0, limit).map((entry) => this.serializeNotification(entry)),
+                    unread_count: unreadCount,
+                    unviewed_count: unviewedCount,
+                    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 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) } });
+        });
+    }
+    markOneAsRead(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 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 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 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." } });
+        });
+    }
+}
+exports.BaseNotificationsController = BaseNotificationsController;

package/dist/Notifications/Notification.d.ts

@@ -0,0 +1,19 @@
+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;
+    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;