@ozdao/martyrs 0.2.550 → 0.2.552

package/dist/notifications.server.cjs

@@ -1,822 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const core_abac = require("./core.abac-DqDvtkHR.cjs");
-const mongoose = require("mongoose");
-const apn = require("apn");
-const mailing = require("./mailing-DCvDBHVh.cjs");
-const admin = require("firebase-admin");
-const path = require("path");
-const webpush = require("web-push");
-const NotificationsController = (db, wss, notificationService) => {
-  const create = async (req, res) => {
-    try {
-      const notification = await db.notification.create(req.body);
-      await notificationService.processNotification(notification);
-      return res.status(201).json(notification);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const createBatch = async (req, res) => {
-    try {
-      const { notifications } = req.body;
-      if (!notifications || !Array.isArray(notifications)) {
-        return res.status(400).json({ message: "notifications array is required" });
-      }
-      const createdNotifications = await db.notification.insertMany(notifications);
-      setImmediate(() => {
-        Promise.allSettled(createdNotifications.map(
-          (notif) => notificationService.processNotification(notif)
-        )).then((results) => {
-          const failures = results.filter((r) => r.status === "rejected");
-          if (failures.length > 0) {
-            console.error(
-              "Batch notification processing errors:",
-              failures.map((f) => f.reason?.message || f.reason)
-            );
-          }
-          console.log(`Batch processing complete: ${results.length - failures.length}/${results.length} successful`);
-        });
-      });
-      return res.status(201).json({
-        message: "Batch notifications created",
-        count: createdNotifications.length
-      });
-    } catch (err) {
-      console.error("=== Batch notifications error ===");
-      console.error("Error:", err.message);
-      console.error("Stack:", err.stack);
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const getUserNotifications = async (req, res) => {
-    try {
-      const userId = req.params.userId;
-      const notifications = await db.notification.find({
-        userId,
-        status: { $in: ["sent", "read"] }
-      }).sort({ createdAt: -1 });
-      return res.json(notifications);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const markAsRead = async (req, res) => {
-    try {
-      const notification = await db.notification.findByIdAndUpdate(req.params.id, { status: "read", updatedAt: Date.now() }, { new: true });
-      if (!notification) {
-        return res.status(404).json({ message: "Notification not found" });
-      }
-      await db.notificationLog.create({
-        notificationId: notification._id,
-        userId: notification.userId,
-        channelType: "web",
-        // Assuming web as default
-        status: "read",
-        readAt: Date.now()
-      });
-      return res.json(notification);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const markAllAsRead = async (req, res) => {
-    try {
-      const userId = req.params.userId;
-      const result = await db.notification.updateMany({ userId, status: { $in: ["sent", "unread"] } }, { status: "read", updatedAt: Date.now() });
-      const updatedNotifications = await db.notification.find({
-        userId,
-        status: "read",
-        updatedAt: { $gte: new Date(Date.now() - 1e4) }
-        // Get notifications updated in the last 10 seconds
-      });
-      const logPromises = updatedNotifications.map((notification) => {
-        return db.notificationLog.create({
-          notificationId: notification._id,
-          userId,
-          channelType: "web",
-          // Assuming web as default
-          status: "read",
-          readAt: Date.now()
-        });
-      });
-      await Promise.all(logPromises);
-      return res.json({
-        message: "All notifications marked as read",
-        count: result.modifiedCount
-      });
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const registerDevice = async (req, res) => {
-    try {
-      const { userId, anonymousId, deviceId, deviceType, deviceToken } = req.body;
-      console.log("[RegisterDevice] Request:", { userId, anonymousId, deviceId, isAnonymous: !userId });
-      if (!userId && !anonymousId) {
-        return res.status(400).json({ message: "Either userId or anonymousId is required" });
-      }
-      const tokenDevice = await db.userDevice.findOne({
-        deviceToken,
-        $or: [
-          { userId: { $ne: userId } },
-          { deviceId: { $ne: deviceId } }
-        ]
-      });
-      if (tokenDevice) {
-        console.log("[RegisterDevice] Token exists for different device, removing:", tokenDevice._id);
-        await tokenDevice.deleteOne();
-      }
-      const filter = userId ? { userId, deviceId } : { anonymousId, deviceId };
-      const update = {
-        $set: {
-          deviceToken,
-          deviceType,
-          isActive: true,
-          lastActive: Date.now(),
-          isAnonymous: !userId
-        },
-        $setOnInsert: userId ? { userId, deviceId } : { anonymousId, deviceId }
-      };
-      const device = await db.userDevice.findOneAndUpdate(
-        filter,
-        update,
-        {
-          upsert: true,
-          new: true,
-          runValidators: true
-        }
-      );
-      console.log("[RegisterDevice] Device upserted:", device._id);
-      return res.status(200).json(device);
-    } catch (err) {
-      console.error("[RegisterDevice] Error:", err.message);
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const getUserPreferences = async (req, res) => {
-    try {
-      const userId = req.params.userId;
-      const preferences = await db.notificationPreference.find({ userId });
-      return res.json(preferences || []);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const updatePreferences = async (req, res) => {
-    try {
-      const { userId, preferences } = req.body;
-      const operations = preferences.map((pref) => ({
-        updateOne: {
-          filter: {
-            userId,
-            channelType: pref.channelType,
-            notificationType: pref.notificationType
-          },
-          update: {
-            $set: {
-              isEnabled: pref.isEnabled
-            }
-          },
-          upsert: true
-        }
-      }));
-      await db.notificationPreference.bulkWrite(operations);
-      const updatedPreferences = await db.notificationPreference.find({ userId });
-      return res.json(updatedPreferences);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const sendToTokens = async (req, res) => {
-    try {
-      const { tokens, title, body, data = {} } = req.body;
-      if (!tokens || !Array.isArray(tokens) || tokens.length === 0) {
-        return res.status(400).json({ message: "tokens array is required" });
-      }
-      if (!title || !body) {
-        return res.status(400).json({ message: "title and body are required" });
-      }
-      const devices = await db.userDevice.find({
-        deviceToken: { $in: tokens },
-        isActive: true
-      });
-      const results = [];
-      for (const device of devices) {
-        try {
-          await notificationService.sendToDeviceToken({
-            deviceToken: device.deviceToken,
-            deviceType: device.deviceType,
-            title,
-            body,
-            data
-          });
-          results.push({ token: device.deviceToken, success: true });
-        } catch (error) {
-          results.push({ token: device.deviceToken, success: false, error: error.message });
-        }
-      }
-      return res.json({
-        message: "Notifications sent",
-        results,
-        total: tokens.length,
-        found: devices.length
-      });
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  const sendToAnonymous = async (req, res) => {
-    try {
-      const { anonymousIds, title, body, data = {} } = req.body;
-      if (!title || !body) {
-        return res.status(400).json({ message: "title and body are required" });
-      }
-      let devices;
-      if (anonymousIds && Array.isArray(anonymousIds)) {
-        devices = await db.userDevice.find({
-          anonymousId: { $in: anonymousIds },
-          isAnonymous: true,
-          isActive: true
-        });
-      } else {
-        devices = await db.userDevice.find({
-          isAnonymous: true,
-          isActive: true
-        });
-      }
-      const results = [];
-      for (const device of devices) {
-        try {
-          await notificationService.sendToDeviceToken({
-            deviceToken: device.deviceToken,
-            deviceType: device.deviceType,
-            title,
-            body,
-            data
-          });
-          results.push({ anonymousId: device.anonymousId, deviceToken: device.deviceToken, success: true });
-        } catch (error) {
-          results.push({ anonymousId: device.anonymousId, deviceToken: device.deviceToken, success: false, error: error.message });
-        }
-      }
-      return res.json({
-        message: "Notifications sent to anonymous devices",
-        results,
-        devicesFound: devices.length
-      });
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
-    }
-  };
-  return {
-    create,
-    createBatch,
-    getUserNotifications,
-    markAsRead,
-    registerDevice,
-    updatePreferences,
-    getUserPreferences,
-    markAllAsRead,
-    sendToTokens,
-    sendToAnonymous
-  };
-};
-const NotificationLogModel = (db, additionalFields = {}) => {
-  const schema = new db.mongoose.Schema({
-    notificationId: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Notification",
-      required: true
-    },
-    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: "User", required: true },
-    channelType: { type: String, required: true },
-    status: { type: String, enum: ["sent", "delivered", "failed", "read"], required: true },
-    error: { type: String },
-    sentAt: { type: Date, default: Date.now },
-    deliveredAt: { type: Date },
-    readAt: { type: Date }
-  });
-  return db.mongoose.model("NotificationLog", schema);
-};
-const NotificationPreferenceModel = (db, additionalFields = {}) => {
-  const schema = new db.mongoose.Schema({
-    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: "User", required: true },
-    channelType: {
-      type: String,
-      enum: ["web", "push", "email", "sms", "telegram", "whatsapp"],
-      required: true
-    },
-    notificationType: { type: String, required: true },
-    // Type of notification (alerts, promotions, etc.)
-    isEnabled: { type: Boolean, default: true }
-  });
-  schema.index({ userId: 1, channelType: 1, notificationType: 1 }, { unique: true });
-  return db.mongoose.model("NotificationPreference", schema);
-};
-const NotificationModel = (db, additionalFields = {}) => {
-  const schema = new db.mongoose.Schema({
-    title: { type: String, required: true },
-    body: { type: String, required: true },
-    type: { type: String, required: true },
-    // Type of notification (e.g., 'alert', 'info', 'promo')
-    metadata: { type: Object, default: {} },
-    // Additional data specific to notification type
-    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: "User", required: true },
-    status: { type: String, enum: ["pending", "sent", "failed", "read"], default: "pending" },
-    createdAt: { type: Date, default: Date.now },
-    updatedAt: { type: Date, default: Date.now }
-  });
-  return db.mongoose.model("Notification", schema);
-};
-const UserDeviceModel = (db, additionalFields = {}) => {
-  const schema = new db.mongoose.Schema({
-    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: "User", required: false },
-    anonymousId: { type: String, required: false },
-    // For anonymous users
-    deviceId: { type: String, required: true },
-    deviceType: { type: String, enum: ["ios", "android", "web"], required: true },
-    deviceToken: { type: String, required: true },
-    // Push token for mobile, or web token
-    isActive: { type: Boolean, default: true },
-    lastActive: { type: Date, default: Date.now },
-    isAnonymous: { type: Boolean, default: false }
-    // Flag to identify anonymous devices
-  });
-  schema.index({ userId: 1, deviceId: 1 }, { unique: true, sparse: true });
-  schema.index({ anonymousId: 1, deviceId: 1 }, { unique: true, sparse: true });
-  schema.index({ deviceToken: 1 }, { unique: true });
-  schema.index({ isAnonymous: 1, isActive: 1 });
-  return db.mongoose.model("UserDevice", schema);
-};
-const notificationsRoutes = (app, db, wss, origins, publicPath, notificationService) => {
-  const controller = NotificationsController(db, wss, notificationService);
-  app.get("/api/notifications/user/:userId", controller.getUserNotifications);
-  app.post("/api/notifications", controller.create);
-  app.post("/api/notifications/batch", controller.createBatch);
-  app.put("/api/notifications/:id/read", controller.markAsRead);
-  app.put("/api/notifications/user/:userId/read-all", controller.markAllAsRead);
-  app.post("/api/notifications/devices/register", controller.registerDevice);
-  app.get("/api/notifications/preferences/:userId", controller.getUserPreferences);
-  app.put("/api/notifications/preferences", controller.updatePreferences);
-  app.post("/api/notifications/send-to-tokens", controller.sendToTokens);
-  app.post("/api/notifications/send-to-anonymous", controller.sendToAnonymous);
-};
-let apnProvider = null;
-const getApnProvider = () => {
-  if (!apnProvider) {
-    apnProvider = new apn.Provider({
-      token: {
-        key: process.env.APN_KEY_PATH,
-        keyId: process.env.APN_KEY_ID,
-        teamId: process.env.APN_TEAM_ID
-      },
-      production: process.env.NODE_ENV === "production"
-    });
-  }
-  return apnProvider;
-};
-const ApnsService = {
-  send: async ({ token, title, body, data = {} }) => {
-    try {
-      const provider = getApnProvider();
-      const notification = new apn.Notification();
-      notification.expiry = Math.floor(Date.now() / 1e3) + 3600;
-      notification.badge = 1;
-      notification.sound = "ping.aiff";
-      notification.alert = {
-        title,
-        body
-      };
-      notification.topic = process.env.APN_BUNDLE_ID;
-      notification.payload = data;
-      const result = await provider.send(notification, token);
-      if (result.failed.length > 0) {
-        const error = result.failed[0].response;
-        throw new Error(`APNS send failed: ${error.reason}`);
-      }
-      return { success: true, messageId: result.sent[0].headers["apns-id"] };
-    } catch (error) {
-      console.error("APNS service error:", error);
-      throw error;
-    }
-  }
-};
-const { sendEmail } = mailing.mailing;
-const EmailService = {
-  send: async ({ to, subject, text, html, metadata = {} }) => {
-    try {
-      const files = metadata.attachments || [];
-      const result = await sendEmail(to, subject, text, files);
-      if (!result) {
-        throw new Error("Failed to send email");
-      }
-      return { success: true, messageId: Date.now().toString() };
-    } catch (error) {
-      console.error("Email service error:", error);
-      throw error;
-    }
-  }
-};
-if (!admin.apps.length) {
-  admin.initializeApp({
-    credential: admin.credential.cert(
-      // Load the service account key JSON file
-      path.resolve(process.env.GOOGLE_APPLICATION_CREDENTIALS)
-    )
-    // Optional: databaseURL, storageBucket, etc.
-  });
-}
-const FcmService = {
-  send: async ({ token, title, body, data = {} }) => {
-    try {
-      const message = {
-        notification: {
-          title,
-          body
-        },
-        data: Object.keys(data).reduce((acc, key) => {
-          acc[key] = String(data[key]);
-          return acc;
-        }, {}),
-        token
-      };
-      const response = await admin.messaging().send(message);
-      return { success: true, messageId: response };
-    } catch (error) {
-      console.error("FCM service error:", error);
-      throw error;
-    }
-  },
-  sendMulticast: async ({ tokens, title, body, data = {} }) => {
-    try {
-      const message = {
-        notification: {
-          title,
-          body
-        },
-        data: Object.keys(data).reduce((acc, key) => {
-          acc[key] = String(data[key]);
-          return acc;
-        }, {}),
-        tokens
-      };
-      const response = await admin.messaging().sendMulticast(message);
-      return {
-        success: true,
-        successCount: response.successCount,
-        failureCount: response.failureCount,
-        responses: response.responses
-      };
-    } catch (error) {
-      console.error("FCM multicast service error:", error);
-      throw error;
-    }
-  }
-};
-const { sendSms } = mailing.mailing;
-const SmsService = {
-  send: async ({ to, message }) => {
-    try {
-      const result = await sendSms(to, message);
-      if (!result) {
-        throw new Error("Failed to send SMS");
-      }
-      return { success: true, messageId: Date.now().toString() };
-    } catch (error) {
-      console.error("SMS service error:", error);
-      throw error;
-    }
-  }
-};
-webpush.setVapidDetails(`mailto:${process.env.VAPID_EMAIL}`, process.env.VAPID_PUBLIC_KEY, process.env.VAPID_PRIVATE_KEY);
-const WebPushService = {
-  send: async ({ token, title, body, data = {} }) => {
-    try {
-      const subscription = JSON.parse(token);
-      console.log("title is", title);
-      console.log("body is", body);
-      console.log("data is", data);
-      const payload = JSON.stringify({
-        title,
-        body,
-        icon: process.env.NOTIFICATION_ICON_URL || "/favicon.ico",
-        badge: process.env.NOTIFICATION_BADGE_URL || "/favicon.ico",
-        data
-      });
-      const result = await webpush.sendNotification(subscription, payload);
-      return { success: true, statusCode: result.statusCode };
-    } catch (error) {
-      console.error("Web Push service error:", error);
-      throw error;
-    }
-  }
-};
-const ObjectId = { Types: mongoose.Types }.Types.ObjectId;
-const NotificationService = (function(db, wss) {
-  wss.registerModule("notification", async (ws, msg) => {
-    console.log("[WebSocket][notification] msg:", msg);
-  });
-  const processNotification = async (notification) => {
-    try {
-      const userId = notification.userId.toString();
-      const preferences = await db.notificationPreference.find({
-        userId: new ObjectId(userId)
-        // notificationType: notification.type
-      });
-      console.log("userId", userId);
-      console.log("preferences", preferences);
-      console.log("notificationType", notification.type);
-      console.log("notification", notification);
-      const user = await db.mongoose.model("User").findById(new ObjectId(userId));
-      if (!user) {
-        throw new Error(`User not found: ${userId}`);
-      }
-      const channelRouters = {
-        web: sendWebNotification,
-        push: sendPushNotification,
-        email: sendEmailNotification,
-        sms: sendSmsNotification
-        // telegram: sendTelegramNotification,
-        // whatsapp: sendWhatsAppNotification
-      };
-      const userDevices = await db.userDevice.find({
-        userId: new ObjectId(userId),
-        isActive: true
-      });
-      let channels = ["web"];
-      if (userDevices.length > 0) {
-        channels.push("push");
-      } else {
-        console.log("No push channel - no devices found");
-      }
-      if (user.email) {
-        channels.push("email");
-      }
-      if (user.phoneNumber) {
-        channels.push("sms");
-      }
-      if (preferences.length > 0) {
-        channels = preferences.filter((pref) => pref.isEnabled).map((pref) => pref.channelType);
-      }
-      const channelPromises = [];
-      for (const channel of channels) {
-        const sendFunc = channelRouters[channel];
-        if (!sendFunc) {
-          channelPromises.push(Promise.resolve({
-            channel,
-            success: false,
-            error: "No send function"
-          }));
-          continue;
-        }
-        if (channel === "push") {
-          for (const device of userDevices) {
-            channelPromises.push(
-              sendFunc(notification, user, device).then(() => {
-                return { channel: "push", deviceId: device.deviceId, success: true };
-              }).catch((err) => {
-                return { channel: "push", deviceId: device.deviceId, success: false, error: err.message };
-              })
-            );
-          }
-        } else {
-          channelPromises.push(
-            sendFunc(notification, user).then(() => {
-              console.log(`${channel} notification sent successfully`);
-              return { channel, success: true };
-            }).catch((err) => {
-              console.error(`${channel} notification failed:`, err);
-              return { channel, success: false, error: err.message };
-            })
-          );
-        }
-      }
-      const results = await Promise.allSettled(channelPromises);
-      const logs = [];
-      const channelSuccessMap = /* @__PURE__ */ new Map();
-      results.forEach(({ status, value }) => {
-        if (status === "fulfilled" && value) {
-          const logEntry = {
-            notificationId: notification._id,
-            userId: notification.userId,
-            channelType: value.channel,
-            status: value.success ? "sent" : "failed",
-            sentAt: Date.now()
-          };
-          if (!value.success) {
-            logEntry.error = value.error;
-          }
-          logs.push(logEntry);
-          if (value.success) {
-            channelSuccessMap.set(value.channel, true);
-          }
-        }
-      });
-      if (logs.length > 0) {
-        setImmediate(() => db.notificationLog.insertMany(logs).catch(console.error));
-        console.log(`Scheduled ${logs.length} logs for batch insertion`);
-      }
-      const hasSuccessfulSend = channelSuccessMap.size > 0;
-      console.log(`=== PROCESSING COMPLETE - Success: ${hasSuccessfulSend} ===`);
-      setImmediate(() => {
-        db.notification.findByIdAndUpdate(notification._id, {
-          status: hasSuccessfulSend ? "sent" : "failed",
-          updatedAt: Date.now()
-        }).catch(console.error);
-      });
-    } catch (error) {
-      console.error("Error processing notification:", error);
-      await db.notification.findByIdAndUpdate(notification._id, {
-        status: "failed",
-        updatedAt: Date.now()
-      });
-    }
-  };
-  const sendWebNotification = async (notification, user) => {
-    const result = await wss.sendToUserInModule("notification", user._id, {
-      type: "notification",
-      data: notification
-    });
-    if (!result) {
-      console.log(`Failed to send web notification to user ${user._id}`);
-    }
-  };
-  const sendPushNotification = async (notification, user, device) => {
-    const pushService = getPushServiceByDeviceType(device.deviceType);
-    return pushService.send({
-      token: device.deviceToken,
-      title: notification.title,
-      body: notification.body,
-      data: notification.metadata
-    });
-  };
-  const getPushServiceByDeviceType = (deviceType) => {
-    if (deviceType === "ios") {
-      return ApnsService;
-    } else if (deviceType === "android") {
-      return FcmService;
-    } else {
-      return WebPushService;
-    }
-  };
-  const sendEmailNotification = async (notification, user) => {
-    return EmailService.send({
-      to: user.email,
-      subject: notification.title,
-      text: notification.body,
-      html: `<h1>${notification.title}</h1><p>${notification.body}</p>`,
-      metadata: notification.metadata
-    });
-  };
-  const sendSmsNotification = async (notification, user) => {
-    return SmsService.send({
-      to: user.phoneNumber,
-      message: `${notification.title}: ${notification.body}`
-    });
-  };
-  const processPendingNotifications = async () => {
-    const pendingNotifications = await db.notification.find({
-      status: "pending"
-    }).limit(100);
-    for (const notification of pendingNotifications) {
-      await processNotification(notification);
-    }
-  };
-  const sendToDeviceToken = async ({ deviceToken, deviceType, title, body, data = {} }) => {
-    const pushService = getPushServiceByDeviceType(deviceType);
-    return pushService.send({
-      token: deviceToken,
-      title,
-      body,
-      data
-    });
-  };
-  const sendToDeviceTokens = async ({ tokens, title, body, data = {} }) => {
-    const results = [];
-    for (const token of tokens) {
-      try {
-        const device = await db.userDevice.findOne({ deviceToken: token, isActive: true });
-        if (!device) {
-          results.push({ token, success: false, error: "Device not found" });
-          continue;
-        }
-        await sendToDeviceToken({
-          deviceToken: token,
-          deviceType: device.deviceType,
-          title,
-          body,
-          data
-        });
-        results.push({ token, success: true });
-      } catch (error) {
-        results.push({ token, success: false, error: error.message });
-      }
-    }
-    return results;
-  };
-  const sendToAnonymousDevices = async ({ anonymousIds = null, title, body, data = {} }) => {
-    let devices;
-    if (anonymousIds && Array.isArray(anonymousIds)) {
-      devices = await db.userDevice.find({
-        anonymousId: { $in: anonymousIds },
-        isAnonymous: true,
-        isActive: true
-      });
-    } else {
-      devices = await db.userDevice.find({
-        isAnonymous: true,
-        isActive: true
-      });
-    }
-    const results = [];
-    for (const device of devices) {
-      try {
-        await sendToDeviceToken({
-          deviceToken: device.deviceToken,
-          deviceType: device.deviceType,
-          title,
-          body,
-          data
-        });
-        results.push({
-          anonymousId: device.anonymousId,
-          deviceToken: device.deviceToken,
-          success: true
-        });
-      } catch (error) {
-        results.push({
-          anonymousId: device.anonymousId,
-          deviceToken: device.deviceToken,
-          success: false,
-          error: error.message
-        });
-      }
-    }
-    return results;
-  };
-  return {
-    processNotification,
-    processPendingNotifications,
-    sendToDeviceToken,
-    sendToDeviceTokens,
-    sendToAnonymousDevices
-  };
-});
-const { getInstance } = core_abac.coreabac;
-function initializeNotifications(app, db, wss, origins, publicPath) {
-  db.notification = NotificationModel(db);
-  db.userDevice = UserDeviceModel(db);
-  db.notificationPreference = NotificationPreferenceModel(db);
-  db.notificationLog = NotificationLogModel(db);
-  getInstance(db);
-  if (wss) {
-    const notificationService = NotificationService(db, wss);
-    if (app) {
-      notificationsRoutes(app, db, wss, origins, publicPath, notificationService);
-    }
-    console.log("[DEBUG] WSS in notification init:", wss);
-    let isProcessing = false;
-    setInterval(async () => {
-      if (isProcessing) return;
-      isProcessing = true;
-      try {
-        await notificationService.processPendingNotifications();
-      } catch (error) {
-        console.error("Error in processPendingNotifications:", error);
-      } finally {
-        isProcessing = false;
-      }
-    }, 1e4);
-  } else if (app) {
-    notificationsRoutes(app, db, null, origins, publicPath, null);
-  }
-}
-const models = {
-  NotificationModel,
-  UserDeviceModel,
-  NotificationPreferenceModel,
-  NotificationLogModel
-};
-const routes = {
-  notificationsRoutes
-};
-const controllers = {
-  NotificationsController
-};
-const services = {
-  NotificationService
-};
-const notifications_server = {
-  initialize: initializeNotifications,
-  models,
-  routes,
-  controllers,
-  services
-};
-exports.controllers = controllers;
-exports.default = notifications_server;
-exports.initialize = initializeNotifications;
-exports.models = models;
-exports.routes = routes;
-exports.services = services;