@ozdao/martyrs 0.2.423

package/src/modules/notifications/models/notification-log.model.js

@@ -0,0 +1,14 @@
+module.exports = (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);
+};

package/src/modules/notifications/models/notification-preference.model.js

@@ -0,0 +1,12 @@
+module.exports = (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);
+};

package/src/modules/notifications/models/notification.model.js

@@ -0,0 +1,14 @@
+module.exports = (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);
+};

package/src/modules/notifications/models/user-device.model.js

@@ -0,0 +1,14 @@
+module.exports = (db, additionalFields = {}) => {
+  const schema = new db.mongoose.Schema({
+    userId: { type: db.mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
+    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 }
+  });
+  
+  schema.index({ userId: 1, deviceId: 1 }, { unique: true });
+  
+  return db.mongoose.model('UserDevice', schema);
+};

package/src/modules/notifications/notifications.client.js

@@ -0,0 +1,440 @@
+import { watch, toRefs } from "vue";
+// Router import 
+import routerNotifications from './router/notifications.router.js'; 
+// Store 
+import * as storeNotifications from './store/notifications.store.js'; 
+// Auth store import
+import * as auth from '@martyrs/src/modules/auth/views/store/auth';
+// Global WebSocket import
+import globalWebSocket from '@martyrs/src/modules/globals/views/classes/globals.websocket.js';
+// Layouts 
+import NotificationsLayout from './components/layouts/NotificationsLayout.vue'; 
+// Sections 
+import NotificationsList from './components/sections/NotificationsList.vue'; 
+import NotificationPreferences from './components/sections/NotificationPreferences.vue'; 
+// Pages 
+import Notifications from './components/pages/Notifications.vue'; 
+// Components 
+import NotificationBadge from './components/elements/NotificationBadge.vue'; 
+import NotificationItem from './components/blocks/NotificationItem.vue'; 
+
+/**
+ * WebSocket notification handler that uses the global WebSocket connection
+ */
+class WebSocketNotificationHandler {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.options = options;
+    this.moduleName = 'notifications';
+    this.listeners = [];
+  }
+
+  /**
+   * Connect to notifications channel
+   */
+  connect(userId) {
+    // Skip if running in SSR
+    if (typeof window === 'undefined' || !userId) {
+      return Promise.resolve(false);
+    }
+
+    // First ensure the global WebSocket is connected
+    return globalWebSocket.connect(userId).then(() => {
+      // Register event listeners
+      this._registerListeners();
+      return true;
+    });
+  }
+
+  /**
+   * Disconnect notification listeners
+   */
+  disconnect() {
+    globalWebSocket.removeModuleListeners(this.moduleName);
+  }
+
+  /**
+   * Register notification event listeners
+   */
+  _registerListeners() {
+    // Listen for notification events
+    this.listeners.push(
+      globalWebSocket.addEventListener('notification', this._processNotification.bind(this), {
+        module: this.moduleName
+      })
+    );
+    
+    // Listen for notification read status changes
+    this.listeners.push(
+      globalWebSocket.addEventListener('notification_read', (data) => {
+        this.store.notifications.actions.syncNotificationStatus(data.notificationId, 'read');
+      }, { module: this.moduleName })
+    );
+  }
+
+  /**
+   * Process incoming notification
+   */
+  _processNotification(data) {
+    if (!data || !data.data) return;
+    
+    const notification = data.data;
+    
+    // Add notification to store
+    this.store.notifications.actions.addLocalNotification({
+      _id: notification._id,
+      title: notification.title,
+      body: notification.body,
+      type: notification.type || 'info',
+      metadata: notification.metadata || {},
+      status: 'unread',
+      createdAt: notification.createdAt || new Date().toISOString(),
+      updatedAt: notification.updatedAt || new Date().toISOString()
+    });
+  }
+}
+
+/**
+ * Capacitor Push Notification handler
+ */
+class CapacitorPushHandler {
+  constructor(store) {
+    this.store = store;
+    this.pushNotifications = null;
+    this.device = null;
+    this.isInitialized = false;
+  }
+
+  /**
+   * Initialize Capacitor plugins
+   */
+  async initialize() {
+    // Skip if running in SSR
+    if (typeof window === 'undefined') {
+      return false;
+    }
+
+    try {
+      // Dynamic imports to prevent errors in web environment
+      const { Capacitor } = await import('@capacitor/core');
+      const { PushNotifications } = await import('@capacitor/push-notifications');
+      const { Device } = await import('@capacitor/device');
+      
+      this.capacitor = Capacitor;
+      this.pushNotifications = PushNotifications;
+      this.device = Device;
+      
+      // Only proceed if running on a native platform
+      if (!this.capacitor.isNativePlatform()) {
+        return false;
+      }
+      
+      this.isInitialized = true;
+      return true;
+    } catch (error) {
+      console.error('Error importing Capacitor plugins:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request permission and register for push notifications
+   */
+  async requestPermissions() {
+    // Skip if running in SSR
+    if (typeof window === 'undefined') {
+      return false;
+    }
+
+    if (!this.isInitialized) {
+      const initialized = await this.initialize();
+      if (!initialized) return false;
+    }
+
+    try {
+      // Request permission
+      const permissionResult = await this.pushNotifications.requestPermissions();
+      if (permissionResult.receive !== 'granted') {
+        console.log('Push notification permission denied');
+        return false;
+      }
+      
+      // Set up event listeners
+      this._setupListeners();
+      
+      // Register with Apple/Google
+      await this.pushNotifications.register();
+      return true;
+    } catch (error) {
+      console.error('Error requesting push notification permissions:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Setup push notification event listeners
+   */
+  _setupListeners() {
+    // Registration event
+    this.pushNotifications.addListener('registration', 
+      this._handleRegistration.bind(this)
+    );
+    
+    // Notification received event
+    this.pushNotifications.addListener('pushNotificationReceived',
+      this._handleNotificationReceived.bind(this)
+    );
+    
+    // Notification action performed event
+    this.pushNotifications.addListener('pushNotificationActionPerformed',
+      this._handleNotificationAction.bind(this)
+    );
+  }
+
+  /**
+   * Handle registration token received
+   */
+  async _handleRegistration(token) {
+    try {
+      // Get device info
+      const deviceInfo = await this.device.getInfo();
+      const deviceId = await this.device.getId();
+      
+      // Prepare device data
+      const deviceData = {
+        deviceId: deviceId.uuid,
+        deviceType: deviceInfo.platform.toLowerCase(),
+        deviceToken: token.value
+      };
+      
+      // Register device with backend
+      await this.store.notifications.actions.registerDevice(deviceData);
+    } catch (error) {
+      console.error('Error handling push registration:', error);
+    }
+  }
+
+  /**
+   * Handle received notification
+   */
+  _handleNotificationReceived(notification) {
+    // Add notification to store
+    this.store.notifications.actions.addLocalNotification({
+      title: notification.title,
+      body: notification.body,
+      data: notification.data || {}
+    });
+  }
+
+  /**
+   * Handle notification action (when user taps on notification)
+   */
+  _handleNotificationAction(actionData) {
+    if (actionData.notification && actionData.notification.data) {
+      this.store.notifications.actions.handleNotificationAction(
+        actionData.notification.data
+      );
+    }
+  }
+
+  /**
+   * Remove push notification listeners
+   */
+  removeListeners() {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    
+    if (this.pushNotifications) {
+      this.pushNotifications.removeAllListeners();
+    }
+  }
+}
+
+/**
+ * Notification Manager for coordinating WebSocket and Push notifications
+ */
+class NotificationManager {
+  constructor(store, options = {}) {
+    this.store = store;
+    this.options = options;
+    this.wsHandler = new WebSocketNotificationHandler(store, options);
+    this.pushHandler = new CapacitorPushHandler(store);
+    this.initialized = false;
+    this.isServer = typeof window === 'undefined';
+  }
+
+  /**
+   * Initialize notifications
+   */
+  async initialize() {
+    if (this.initialized || this.isServer) return;
+    
+    // Get current user ID from auth store instead of localStorage
+    const userId = this.store.auth.state.user?._id;
+    if (!userId) {
+      console.warn('Cannot initialize notifications: No user ID found in auth store');
+      return;
+    }
+    
+    // Initialize WebSocket for realtime notifications
+    await this.wsHandler.connect(userId);
+    
+    // Initialize push notifications for mobile if enabled
+    if (this.options.enablePush !== false) {
+      await this.pushHandler.requestPermissions();
+    }
+    
+    this.initialized = true;
+    
+    // Fetch existing notifications
+    await this.store.notifications.actions.getNotifications(userId);
+  }
+
+  /**
+   * Disconnect and clean up
+   */
+  disconnect() {
+    if (this.isServer) return;
+    
+    this.wsHandler.disconnect();
+    this.pushHandler.removeListeners();
+    this.initialized = false;
+  }
+}
+
+/**
+ * Server-side utility for pre-fetching notification data
+ */
+const SSRUtils = {
+  /**
+   * Pre-fetch notifications for SSR
+   * @param {Object} store - Store instance
+   * @param {Object} context - SSR context
+   */
+  async prefetchNotifications(store, context) {
+    try {
+      const userId = store.auth.state.user?._id;
+      if (userId) {
+        // Fetch notifications without WebSocket or push setup
+        await store.notifications.actions.getNotifications(userId);
+      }
+    } catch (error) {
+      console.error('Error pre-fetching notifications for SSR:', error);
+    }
+  }
+};
+
+/**
+ * Function to initialize the notifications module
+ * @param {Object} app - Vue app instance
+ * @param {Object} store - Vuex/Pinia store
+ * @param {Object} router - Vue Router instance
+ * @param {Object} options - Configuration options
+ */
+function initializeNotifications(app, store, router, options = {}) {
+  // Add routes and store
+  const route = options.route || 'User Profile Root';
+  router.addRoute(route, routerNotifications);
+  store.addStore('notifications', storeNotifications);
+  
+  // Initialize global WebSocket if needed
+  if (options.wsUrl) {
+    globalWebSocket.initialize({ wsUrl: options.wsUrl });
+  }
+  
+  // Create notification manager
+  const notificationManager = new NotificationManager(store, {
+    enablePush: options.enablePush !== false,
+    maxReconnectAttempts: options.maxReconnectAttempts || 5,
+    reconnectDelay: options.reconnectDelay || 3000,
+    pingInterval: options.pingInterval || 30000
+  });
+  
+  // Attach notification manager to store for access in components
+  store.notificationManager = notificationManager;
+  
+  // Don't auto-initialize on server
+  const isServer = typeof window === 'undefined';
+  const autoInit = !isServer && options.autoInit !== false;
+  
+  if (autoInit) {
+    // Initialize after auth is confirmed
+    const isAuthenticated = store.auth.state.isAuthenticated;
+    const userId = store.auth.state.user?._id;
+    
+    if (isAuthenticated && userId) {
+      notificationManager.initialize();
+    }
+    
+    // Watch for user login/logout using auth store
+    watch(() => store.auth.state.isAuthenticated, (isAuthenticated) => {
+      if (isAuthenticated) {
+        notificationManager.initialize();
+      } else {
+        notificationManager.disconnect();
+        store.notifications.mutations.resetNotifications();
+      }
+    });
+  }
+  
+  // Provide composable for components to access notification functionality
+  app.provide('useNotifications', () => {
+    return {
+      ...toRefs(store.notifications.state),
+      ...store.notifications.actions,
+      ...store.notifications.mutations,
+      init: notificationManager.initialize.bind(notificationManager),
+      disconnect: notificationManager.disconnect.bind(notificationManager),
+      isServer
+    };
+  });
+  
+  return notificationManager;
+}
+
+// Module export
+const ModuleNotifications = {
+  initialize: initializeNotifications,
+  SSR: SSRUtils, // Export SSR utilities
+  views: {
+    store: {
+      storeNotifications,
+    },
+    router: {
+      routerNotifications
+    },
+    components: {
+      // Elements
+      NotificationBadge,
+      // Blocks
+      NotificationItem,
+      // Sections
+      NotificationsList,
+      NotificationPreferences,
+      // Pages
+      Notifications,
+      // Layouts
+      NotificationsLayout
+    }
+  }
+};
+
+// Component exports
+export {
+  // Elements
+  NotificationBadge,
+  // Blocks
+  NotificationItem,
+  // Sections
+  NotificationsList,
+  NotificationPreferences,
+  // Pages
+  Notifications,
+  // Layouts
+  NotificationsLayout,
+  // SSR Utilities
+  SSRUtils
+};
+
+export default ModuleNotifications;

package/src/modules/notifications/notifications.server.js

@@ -0,0 +1,64 @@
+// index.js
+// Import controllers
+const NotificationsController = require('./controllers/notifications.controller.js');
+
+// Import routes
+const notificationsRoutes = require('./routes/notifications.routes.js');
+
+// Import models
+const NotificationModel = require('./models/notification.model.js');
+const UserDeviceModel = require('./models/user-device.model.js');
+const NotificationPreferenceModel = require('./models/notification-preference.model.js');
+const NotificationLogModel = require('./models/notification-log.model.js');
+
+// Import ABAC policies
+const initNotificationPolicies = require('./middlewares/notifications.abac.js');
+
+// Import services
+const NotificationService = require('./services/notification.service.js');
+
+const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
+
+function initializeNotifications(app, db, wss, origins, publicPath) {
+  // Set up models in the database object
+  db.notification = NotificationModel(db);
+  db.userDevice = UserDeviceModel(db);
+  db.notificationPreference = NotificationPreferenceModel(db);
+  db.notificationLog = NotificationLogModel(db);
+
+  const abac = getInstance(db);
+  // const notificationPolicies = initNotificationPolicies(abac, db);
+
+  // Set up routes if app is provided
+  if (app) {
+    notificationsRoutes(app, db, origins, publicPath);
+  }
+  
+  // Initialize notification service and related background tasks
+  const notificationService = NotificationService(db, wss);
+  
+  // Set up a scheduler to process pending notifications
+  setInterval(() => {
+    notificationService.processPendingNotifications();
+  }, 60000); // Every minute
+}
+
+// Export initialization function, controllers, routes, and models
+module.exports = {
+  initialize: initializeNotifications,
+  models: {
+    NotificationModel,
+    UserDeviceModel,
+    NotificationPreferenceModel,
+    NotificationLogModel
+  },
+  routes: {
+    notificationsRoutes
+  },
+  controllers: {
+    NotificationsController
+  },
+  services: {
+    NotificationService
+  }
+};

package/src/modules/notifications/router/notifications.router.js

@@ -0,0 +1,30 @@
+import Notifications from '../components/pages/Notifications.vue';
+import NotificationPreferences from '../components/sections/NotificationPreferences.vue';
+import NotificationsLayout from '../components/layouts/NotificationsLayout.vue';
+
+const nofitications = {
+  path: '/notifications',
+  component: NotificationsLayout,
+  children: [
+    {
+      path: '',
+      name: 'Notifications',
+      component: Notifications,
+      meta: {
+        // requiresAuth: true,
+        title: 'Notifications'
+      }
+    },
+    {
+      path: 'preferences',
+      name: 'NotificationPreferences',
+      component: NotificationPreferences,
+      meta: {
+        // requiresAuth: true,
+        title: 'Notification Preferences'
+      }
+    }
+  ]
+};
+
+export default nofitications;

package/src/modules/notifications/routes/notifications.routes.js

@@ -0,0 +1,24 @@
+// routes/notifications.routes.js
+const notificationsRoutes = (app, db, origins, publicPath) => {
+  const controller = require('../controllers/notifications.controller')(db);
+  
+  // Get notifications for a user
+  app.get('/api/notifications/user/:userId', controller.getUserNotifications);
+  
+  // Create a new notification
+  app.post('/api/notifications', controller.create);
+  
+  // Mark notification as read
+  app.put('/api/notifications/:id/read', controller.markAsRead);
+  
+  // Register a device for push notifications
+  app.post('/api/notifications/devices/register', controller.registerDevice);
+
+  // Add this to routes/notifications.routes.js
+  app.get('/api/notifications/preferences/:userId', controller.getUserPreferences);
+  
+  // Update notification preferences
+  app.put('/api/notifications/preferences', controller.updatePreferences);
+};
+
+module.exports = notificationsRoutes;

package/src/modules/notifications/services/apns.service.js

@@ -0,0 +1,52 @@
+// services/push/apns.service.js
+const apn = require('apn');
+
+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() / 1000) + 3600; // Expires in 1 hour
+      notification.badge = 1;
+      notification.sound = "ping.aiff";
+      notification.alert = {
+        title: title,
+        body: body,
+      };
+      notification.topic = process.env.APN_BUNDLE_ID;
+      notification.payload = data;
+      
+      const result = await provider.send(notification, token);
+      
+      // Check for sent/failed
+      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;
+    }
+  }
+};
+
+module.exports = ApnsService;

package/src/modules/notifications/services/email.service.js

@@ -0,0 +1,25 @@
+// services/email.service.js
+const { sendEmail } = require('@martyrs/src/modules/globals/controllers/utils/mailing');
+
+const EmailService = {
+  send: async ({ to, subject, text, html, metadata = {} }) => {
+    try {
+      // Convert any attachments from metadata if present
+      const files = metadata.attachments || [];
+      
+      // Send email using the utility function
+      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;
+    }
+  }
+};
+
+module.exports = EmailService;