vasuzex 2.1.12 → 2.1.14

package/framework/Services/Notification/Channels/FcmChannel.js

@@ -0,0 +1,201 @@
+/**
+ * FCM Notification Channel
+ * Firebase Cloud Messaging channel for push notifications
+ * 
+ * Features:
+ * - Multi-device notification (sends to all user devices)
+ * - Automatic invalid token cleanup
+ * - Platform-specific configurations
+ * - Respects user notification preferences
+ */
+
+import { Channel } from '../Channel.js';
+import { getMessaging } from '../FirebaseAdmin.js';
+import { Log } from '../../../Support/Facades/index.js';
+
+export class FcmChannel extends Channel {
+  constructor(tokenRepository) {
+    super();
+    this.tokenRepository = tokenRepository; // Repository for user_device_tokens
+  }
+
+  /**
+   * Send notification via FCM
+   * @param {Object} notifiable - User object with id
+   * @param {Object} notification - Notification instance
+   */
+  async send(notifiable, notification) {
+    const messaging = getMessaging();
+    
+    if (!messaging) {
+      Log.warning('FCM not available - skipping push notification', {
+        userId: notifiable.id,
+        notificationType: notification.constructor.name
+      });
+      return;
+    }
+
+    // Get FCM message from notification
+    const fcmData = notification.toFcm 
+      ? notification.toFcm(notifiable)
+      : this.buildDefaultMessage(notification, notifiable);
+
+    if (!fcmData) {
+      return;
+    }
+
+    // Get all active tokens for user
+    const tokens = await this.getActiveTokens(notifiable.id);
+
+    if (tokens.length === 0) {
+      Log.debug('No FCM tokens found for user', { userId: notifiable.id });
+      return;
+    }
+
+    // Send to all devices
+    await this.sendToMultipleDevices(tokens, fcmData, notifiable.id);
+  }
+
+  /**
+   * Get active FCM tokens for user
+   */
+  async getActiveTokens(userId) {
+    if (!this.tokenRepository) {
+      Log.error('Token repository not configured for FcmChannel');
+      return [];
+    }
+
+    return await this.tokenRepository.getActiveTokensForUser(userId);
+  }
+
+  /**
+   * Send notification to multiple devices
+   */
+  async sendToMultipleDevices(tokens, fcmData, userId) {
+    const messaging = getMessaging();
+    const tokenStrings = tokens.map(t => t.token);
+
+    try {
+      const message = {
+        notification: {
+          title: fcmData.title,
+          body: fcmData.body,
+          ...(fcmData.imageUrl && { imageUrl: fcmData.imageUrl })
+        },
+        data: this.stringifyData(fcmData.data || {}),
+        tokens: tokenStrings
+      };
+
+      // Add platform-specific config
+      if (fcmData.android) {
+        message.android = fcmData.android;
+      }
+      if (fcmData.apns) {
+        message.apns = fcmData.apns;
+      }
+      if (fcmData.webpush) {
+        message.webpush = fcmData.webpush;
+      }
+
+      const response = await messaging.sendEachForMulticast(message);
+
+      Log.info('FCM multicast sent', {
+        userId,
+        successCount: response.successCount,
+        failureCount: response.failureCount,
+        totalTokens: tokenStrings.length
+      });
+
+      // Handle failed tokens
+      if (response.failureCount > 0) {
+        await this.handleFailedTokens(tokens, response.responses, userId);
+      }
+
+      // Update last_used_at for successful sends
+      const successfulTokenIds = tokens
+        .filter((_, index) => response.responses[index].success)
+        .map(t => t.id);
+
+      if (successfulTokenIds.length > 0 && this.tokenRepository) {
+        await this.tokenRepository.updateLastUsed(successfulTokenIds);
+      }
+
+      return response;
+    } catch (error) {
+      Log.error('FCM multicast failed', {
+        userId,
+        error: error.message,
+        code: error.code
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Handle failed token deliveries
+   * Removes invalid/expired tokens
+   */
+  async handleFailedTokens(tokens, responses, userId) {
+    const invalidTokenIds = [];
+    const invalidReasons = [
+      'messaging/invalid-registration-token',
+      'messaging/registration-token-not-registered',
+      'messaging/invalid-argument'
+    ];
+
+    responses.forEach((response, index) => {
+      if (!response.success && response.error) {
+        const errorCode = response.error.code;
+        
+        if (invalidReasons.includes(errorCode)) {
+          invalidTokenIds.push(tokens[index].id);
+          Log.info('Removing invalid FCM token', {
+            userId,
+            tokenId: tokens[index].id,
+            platform: tokens[index].platform,
+            errorCode
+          });
+        }
+      }
+    });
+
+    if (invalidTokenIds.length > 0 && this.tokenRepository) {
+      await this.tokenRepository.deactivateTokens(invalidTokenIds);
+    }
+  }
+
+  /**
+   * Build default FCM message from notification
+   */
+  buildDefaultMessage(notification, notifiable) {
+    // Try to get data from toArray or toDatabase
+    const data = notification.toArray 
+      ? notification.toArray(notifiable)
+      : (notification.toDatabase ? notification.toDatabase(notifiable) : null);
+
+    if (!data) {
+      return null;
+    }
+
+    return {
+      title: data.title || 'Notification',
+      body: data.body || data.message || '',
+      data: data.data || {},
+      imageUrl: data.imageUrl || data.image_url
+    };
+  }
+
+  /**
+   * Stringify all data values for FCM
+   * FCM data payload must have string values only
+   */
+  stringifyData(data) {
+    const stringified = {};
+    for (const [key, value] of Object.entries(data)) {
+      stringified[key] = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    return stringified;
+  }
+}
+
+export default FcmChannel;

package/framework/Services/Notification/FirebaseAdmin.js

@@ -0,0 +1,90 @@
+/**
+ * Firebase Admin SDK Singleton
+ * Centralized Firebase Admin initialization for FCM
+ * 
+ * Configuration from environment variables:
+ * - FIREBASE_PROJECT_ID
+ * - FIREBASE_CLIENT_EMAIL  
+ * - FIREBASE_PRIVATE_KEY
+ */
+
+import admin from 'firebase-admin';
+import { Config, Log } from '../../Support/Facades/index.js';
+
+let firebaseApp = null;
+let isInitialized = false;
+
+/**
+ * Initialize Firebase Admin SDK
+ * Safe to call multiple times - will only initialize once
+ */
+export function initializeFirebaseAdmin() {
+  if (isInitialized) {
+    return firebaseApp;
+  }
+
+  try {
+    const projectId = Config.get('notification.fcm.project_id') || process.env.FIREBASE_PROJECT_ID;
+    const clientEmail = Config.get('notification.fcm.client_email') || process.env.FIREBASE_CLIENT_EMAIL;
+    const privateKey = Config.get('notification.fcm.private_key') || process.env.FIREBASE_PRIVATE_KEY;
+
+    if (!projectId || !clientEmail || !privateKey) {
+      Log.warning('Firebase Admin SDK not configured - FCM notifications disabled', {
+        hasProjectId: !!projectId,
+        hasClientEmail: !!clientEmail,
+        hasPrivateKey: !!privateKey
+      });
+      return null;
+    }
+
+    // Handle escaped newlines in private key
+    const formattedPrivateKey = privateKey.replace(/\\n/g, '\n');
+
+    firebaseApp = admin.initializeApp({
+      credential: admin.credential.cert({
+        projectId,
+        clientEmail,
+        privateKey: formattedPrivateKey,
+      }),
+    });
+
+    isInitialized = true;
+    Log.info('Firebase Admin SDK initialized successfully', { projectId });
+
+    return firebaseApp;
+  } catch (error) {
+    Log.error('Failed to initialize Firebase Admin SDK', {
+      error: error.message,
+      stack: error.stack
+    });
+    return null;
+  }
+}
+
+/**
+ * Get Firebase Messaging instance
+ */
+export function getMessaging() {
+  if (!isInitialized) {
+    initializeFirebaseAdmin();
+  }
+
+  if (!firebaseApp) {
+    return null;
+  }
+
+  return admin.messaging();
+}
+
+/**
+ * Check if Firebase Admin is initialized
+ */
+export function isFirebaseInitialized() {
+  return isInitialized && firebaseApp !== null;
+}
+
+export default {
+  initialize: initializeFirebaseAdmin,
+  getMessaging,
+  isInitialized: isFirebaseInitialized
+};

package/framework/Services/Notification/NotificationManager.js

@@ -6,6 +6,7 @@
 import { MailChannel } from './Channels/MailChannel.js';
 import { SmsChannel } from './Channels/SmsChannel.js';
 import { DatabaseChannel } from './Channels/DatabaseChannel.js';
+import { FcmChannel } from './Channels/FcmChannel.js';
 
 export class NotificationManager {
   constructor(app) {
@@ -125,6 +126,17 @@ export class NotificationManager {
     return new DatabaseChannel(database);
   }
 
+  /**
+   * Create an instance of the FCM driver
+   */
+  createFcmDriver() {
+    // Get token repository from app container
+    const tokenRepository = this.app.has('tokenRepository') 
+      ? this.app.make('tokenRepository')
+      : null;
+    return new FcmChannel(tokenRepository);
+  }
+
   /**
    * Get the default channel name
    */

package/frontend/react-ui/components/DataTable/TableBody.jsx

@@ -136,9 +136,9 @@ export function TableBody({
                   // Get icon, class, title, and content
                   const Icon = action.icon;
                   const className =
-                    typeof action.extraClass === "function"
-                      ? action.extraClass(row)
-                      : action.extraClass || "";
+                    typeof action.className === "function"
+                      ? action.className(row)
+                      : action.className || "";
                   const title =
                     typeof action.title === "function"
                       ? action.title(row)

package/frontend/react-ui/components/PhotoManager/EnhancedPhotoManager.jsx

@@ -63,8 +63,10 @@ export function EnhancedPhotoManager({
   description,
   emptyStateText = "No photos uploaded yet",
   maxFiles = 20,
+  maxFileSize = 5 * 1024 * 1024, // 5MB default
   gridCols = "grid-cols-2 sm:grid-cols-3 md:grid-cols-4",
   components = {},
+  dropzoneProps = {},
 }) {
   const {
     photos = [],
@@ -210,6 +212,8 @@ export function EnhancedPhotoManager({
           onFilesSelected={handleFilesSelected}
           disabled={loading}
           maxFiles={maxFiles - sortedPhotos.length}
+          maxSize={dropzoneProps.maxSize || maxFileSize}
+          {...dropzoneProps}
         />
       )}
 
@@ -299,6 +303,8 @@ EnhancedPhotoManager.propTypes = {
   emptyStateText: PropTypes.string,
   /** Maximum number of photos */
   maxFiles: PropTypes.number,
+  /** Maximum file size in bytes (default 5MB) */
+  maxFileSize: PropTypes.number,
   /** Grid columns CSS classes */
   gridCols: PropTypes.string,
   /** Custom components */
@@ -308,6 +314,8 @@ EnhancedPhotoManager.propTypes = {
     UploadProgressCard: PropTypes.elementType,
     TrashIcon: PropTypes.elementType,
   }),
+  /** Additional props to pass to UploadDropZone */
+  dropzoneProps: PropTypes.object,
 };
 
 export default EnhancedPhotoManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vasuzex",
-  "version": "2.1.12",
+  "version": "2.1.14",
   "description": "Laravel-inspired framework for Node.js monorepos - V2 with optimized dependencies",
   "type": "module",
   "main": "./framework/index.js",
@@ -19,6 +19,7 @@
     "./Support/Facades": "./framework/Support/Facades/index.js",
     "./Support/Facades/*": "./framework/Support/Facades/*.js",
     "./Services/*": "./framework/Services/*/index.js",
+    "./framework/*": "./framework/*",
     "./client": "./frontend/client/index.js",
     "./client/*": "./frontend/client/*/index.js",
     "./react": "./frontend/react-ui/index.js",