90dc-core 1.19.3 → 1.19.4

package/dist/lib/clients/FirebasePushNotificationClient.js

@@ -1,688 +0,0 @@
-/**
- * Firebase Push Notification Client
- *
- * Industry-standard implementation using Firebase Admin SDK for:
- * - iOS (APNs via FCM)
- * - Android (FCM)
- *
- * Features:
- * - Multicast messaging (up to 500 tokens per request)
- * - Topic-based messaging for efficient broadcasting
- * - Automatic token validation and cleanup
- * - Built-in retry logic and error handling
- * - Message delivery tracking
- * - Type-safe API
- */ import admin from "firebase-admin";
-import { CommonSchemas } from "../config/ConfigValidator.js";
-import { ExternalAPIError } from "../Errors/AppError.js";
-import { Log } from "../utils/Logger.js";
-import { SecretManager } from "../utils/SecretManager.js";
-import { DeviceTokens } from "../dbmodels/user/DeviceTokens.js";
-import { PersistedUser } from "../dbmodels/user/PersistedUser.js";
-import { NotificationModels } from "../dbmodels/notifications/NotificationModels.js";
-import { TranslatedNotification } from "../dbmodels/notifications/TranslatedNotification.js";
-export class FirebasePushNotificationClient {
-    static instance;
-    static initPromise = null;
-    logger = Log.getInstance().extend("firebase-push");
-    app = null;
-    serviceAccount = null;
-    constructor(_config, serviceAccount){
-        // config parameter kept for backward compatibility but not used (FCM config comes from Secret Manager)
-        this.serviceAccount = serviceAccount;
-        this.initializeApp();
-    }
-    static async getInstance() {
-        if (FirebasePushNotificationClient.instance) {
-            return FirebasePushNotificationClient.instance;
-        }
-        // If already initializing, wait for that to complete
-        if (FirebasePushNotificationClient.initPromise) {
-            return FirebasePushNotificationClient.initPromise;
-        }
-        // Start initialization
-        FirebasePushNotificationClient.initPromise = (async ()=>{
-            // Parse config (mostly for optional APNs fields, FCM comes from Secret Manager)
-            const parsedConfig = CommonSchemas.pushNotification.parse(process.env);
-            const serviceAccount = await FirebasePushNotificationClient.loadServiceAccount();
-            FirebasePushNotificationClient.instance = new FirebasePushNotificationClient(parsedConfig, serviceAccount);
-            FirebasePushNotificationClient.initPromise = null;
-            return FirebasePushNotificationClient.instance;
-        })();
-        return FirebasePushNotificationClient.initPromise;
-    }
-    static async loadServiceAccount() {
-        const logger = Log.getInstance().extend("firebase-push");
-        const PROJECT_ID = "1033066542238";
-        const SECRET_NAME = "firebase_new_key";
-        try {
-            // Check if FIREBASE_SERVICE_ACCOUNT_KEY env variable is set (for local development)
-            const localKeyPath = process.env.FIREBASE_SERVICE_ACCOUNT_KEY;
-            if (localKeyPath) {
-                const fs = await import("node:fs/promises");
-                const serviceAccountJson = await fs.readFile(localKeyPath, "utf-8");
-                const serviceAccount = JSON.parse(serviceAccountJson);
-                logger.info("Firebase service account loaded from local file");
-                return serviceAccount;
-            }
-            // Production: Load from Secret Manager using shared utility
-            // This provides better error handling, caching, and reuses the client instance
-            logger.info("Loading Firebase service account from Secret Manager", {
-                projectId: PROJECT_ID,
-                secretName: SECRET_NAME
-            });
-            const serviceAccount = await SecretManager.loadSecretJSON(SECRET_NAME, PROJECT_ID);
-            logger.info("Firebase service account loaded successfully from Secret Manager", {
-                projectId: serviceAccount.project_id,
-                clientEmail: serviceAccount.client_email
-            });
-            return serviceAccount;
-        } catch (error) {
-            logger.error("Failed to load Firebase service account", {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : undefined
-            });
-            throw new ExternalAPIError("Failed to load Firebase credentials", `Error: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    static resetInstance() {
-        FirebasePushNotificationClient.instance?.shutdown();
-        FirebasePushNotificationClient.instance = undefined;
-        FirebasePushNotificationClient.initPromise = null;
-    }
-    initializeApp() {
-        try {
-            // Check if app already exists
-            if (admin.apps?.length && admin.apps.length > 0) {
-                this.app = admin.app();
-                this.logger.info("Using existing Firebase app");
-                return;
-            }
-            if (!this.serviceAccount) {
-                throw new Error("Service account not loaded");
-            }
-            // Validate service account has all required fields
-            if (!this.serviceAccount.project_id || !this.serviceAccount.client_email || !this.serviceAccount.private_key) {
-                throw new Error("Invalid service account: missing required fields");
-            }
-            this.logger.info("Initializing Firebase Admin SDK", {
-                projectId: this.serviceAccount.project_id,
-                clientEmail: this.serviceAccount.client_email
-            });
-            this.app = admin.initializeApp({
-                credential: admin.credential.cert(this.serviceAccount)
-            });
-            this.logger.info("Firebase Admin SDK initialized successfully");
-        } catch (error) {
-            this.logger.error("Failed to initialize Firebase Admin SDK", {
-                error
-            });
-            throw new ExternalAPIError("Failed to initialize Firebase", `Error: ${String(error)}`);
-        }
-    }
-    shutdown() {
-        if (this.app) {
-            this.app.delete().catch((error)=>{
-                this.logger.error("Error shutting down Firebase app", {
-                    error
-                });
-            });
-            this.app = null;
-        }
-    }
-    /**
-   * Detect if a token is a legacy APN token (hex format, 64 characters)
-   */ isLegacyAPNToken(token) {
-        // Legacy APN tokens are 64 hex characters (sometimes with spaces or angle brackets)
-        const cleanToken = token.replace(/[<>\s]/g, '');
-        return /^[0-9a-fA-F]{64}$/.test(cleanToken);
-    }
-    /**
-   * Send notifications using multicast (up to 500 tokens at once)
-   * Automatically handles token validation and cleanup
-   */ async sendMulticast(tokens, notification, platform) {
-        if (tokens.length === 0) {
-            return {
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            };
-        }
-        const messaging = admin.messaging();
-        const invalidTokens = [];
-        let successCount = 0;
-        let failureCount = 0;
-        // Detect if any tokens are legacy APN tokens
-        const hasLegacyAPNTokens = tokens.some((token)=>this.isLegacyAPNToken(token));
-        const isIOSPlatform = platform === "ios" || hasLegacyAPNTokens;
-        if (hasLegacyAPNTokens) {
-            this.logger.info("Detected legacy APN tokens in batch", {
-                totalTokens: tokens.length,
-                legacyCount: tokens.filter((t)=>this.isLegacyAPNToken(t)).length
-            });
-        }
-        // Firebase allows max 500 tokens per multicast
-        const BATCH_SIZE = 500;
-        for(let i = 0; i < tokens.length; i += BATCH_SIZE){
-            const batch = tokens.slice(i, i + BATCH_SIZE);
-            const message = {
-                tokens: batch,
-                notification: {
-                    title: notification.title,
-                    body: notification.body,
-                    ...notification.imageUrl && {
-                        imageUrl: notification.imageUrl
-                    }
-                },
-                data: notification.data || {},
-                ...isIOSPlatform && {
-                    apns: {
-                        payload: {
-                            aps: {
-                                sound: notification.sound || "default",
-                                ...notification.badge !== undefined && {
-                                    badge: notification.badge
-                                },
-                                contentAvailable: true
-                            }
-                        },
-                        fcmOptions: {
-                            ...notification.imageUrl && {
-                                imageUrl: notification.imageUrl
-                            }
-                        }
-                    }
-                },
-                ...platform === "android" && {
-                    android: {
-                        priority: "high",
-                        notification: {
-                            sound: notification.sound || "default",
-                            channelId: "default",
-                            ...notification.imageUrl && {
-                                imageUrl: notification.imageUrl
-                            }
-                        }
-                    }
-                }
-            };
-            try {
-                const response = await messaging.sendEachForMulticast(message);
-                successCount += response.successCount;
-                failureCount += response.failureCount;
-                // Identify and collect invalid tokens
-                response.responses.forEach((resp, idx)=>{
-                    if (!resp.success && resp.error) {
-                        const errorCode = resp.error.code;
-                        // Token is invalid or unregistered
-                        if (errorCode === "messaging/invalid-registration-token" || errorCode === "messaging/registration-token-not-registered") {
-                            invalidTokens.push(batch[idx]);
-                        }
-                        this.logger.warn("Message send failed", {
-                            token: batch[idx],
-                            error: resp.error.message,
-                            code: errorCode
-                        });
-                    }
-                });
-                this.logger.info("Multicast batch sent", {
-                    batchSize: batch.length,
-                    successCount: response.successCount,
-                    failureCount: response.failureCount
-                });
-            } catch (error) {
-                this.logger.error("Multicast send error", {
-                    error,
-                    batchSize: batch.length
-                });
-                failureCount += batch.length;
-            }
-        }
-        // Clean up invalid tokens from database
-        if (invalidTokens.length > 0) {
-            await this.removeInvalidTokens(invalidTokens);
-        }
-        return {
-            successCount,
-            failureCount,
-            invalidTokens
-        };
-    }
-    /**
-   * Remove invalid device tokens from database
-   */ async removeInvalidTokens(tokens) {
-        try {
-            const deleted = await DeviceTokens.destroy({
-                where: {
-                    deviceToken: tokens
-                }
-            });
-            this.logger.info("Removed invalid tokens from database", {
-                count: deleted,
-                tokens: tokens.length
-            });
-        } catch (error) {
-            this.logger.error("Failed to remove invalid tokens", {
-                error
-            });
-        }
-    }
-    /**
-   * Send notification to specific device tokens
-   */ async sendToTokens(tokens, platform, notification) {
-        if (tokens.length === 0) {
-            this.logger.warn("No tokens provided, skipping notification");
-            return {
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            };
-        }
-        this.logger.info("Sending notification to tokens", {
-            tokenCount: tokens.length,
-            platform,
-            title: notification.title
-        });
-        return await this.sendMulticast(tokens, notification, platform);
-    }
-    /**
-   * Send notification to a single user (all their devices)
-   */ async sendToUser(params) {
-        this.logger.info("Sending notification to user", {
-            userUuid: params.userUuid
-        });
-        const deviceTokens = await DeviceTokens.findAll({
-            where: {
-                userUuid: params.userUuid
-            },
-            attributes: [
-                "deviceToken",
-                "platform"
-            ]
-        });
-        if (deviceTokens.length === 0) {
-            this.logger.warn("No device tokens found for user", {
-                userUuid: params.userUuid
-            });
-            return {
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            };
-        }
-        // Separate tokens by platform, also detecting legacy APN tokens
-        const iosTokens = deviceTokens.filter((dt)=>dt.platform === "ios" || this.isLegacyAPNToken(dt.deviceToken)).map((dt)=>dt.deviceToken);
-        const androidTokens = deviceTokens.filter((dt)=>dt.platform === "android" && !this.isLegacyAPNToken(dt.deviceToken)).map((dt)=>dt.deviceToken);
-        const legacyAPNCount = deviceTokens.filter((dt)=>this.isLegacyAPNToken(dt.deviceToken)).length;
-        if (legacyAPNCount > 0) {
-            this.logger.info("Found legacy APN tokens for user", {
-                userUuid: params.userUuid,
-                legacyTokenCount: legacyAPNCount
-            });
-        }
-        const [iosResult, androidResult] = await Promise.all([
-            iosTokens.length > 0 ? this.sendToTokens(iosTokens, "ios", params.notification) : Promise.resolve({
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            }),
-            androidTokens.length > 0 ? this.sendToTokens(androidTokens, "android", params.notification) : Promise.resolve({
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            })
-        ]);
-        return {
-            successCount: iosResult.successCount + androidResult.successCount,
-            failureCount: iosResult.failureCount + androidResult.failureCount,
-            invalidTokens: [
-                ...iosResult.invalidTokens,
-                ...androidResult.invalidTokens
-            ]
-        };
-    }
-    /**
-   * Send notification to multiple users
-   */ async sendToUsers(params) {
-        this.logger.info("Sending notification to multiple users", {
-            count: params.userUuids.length
-        });
-        const deviceTokens = await DeviceTokens.findAll({
-            where: {
-                userUuid: params.userUuids
-            },
-            attributes: [
-                "deviceToken",
-                "platform"
-            ]
-        });
-        if (deviceTokens.length === 0) {
-            this.logger.warn("No device tokens found for users");
-            return {
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            };
-        }
-        // Separate tokens by platform, also detecting legacy APN tokens
-        const iosTokens = deviceTokens.filter((dt)=>dt.platform === "ios" || this.isLegacyAPNToken(dt.deviceToken)).map((dt)=>dt.deviceToken);
-        const androidTokens = deviceTokens.filter((dt)=>dt.platform === "android" && !this.isLegacyAPNToken(dt.deviceToken)).map((dt)=>dt.deviceToken);
-        const legacyAPNCount = deviceTokens.filter((dt)=>this.isLegacyAPNToken(dt.deviceToken)).length;
-        if (legacyAPNCount > 0) {
-            this.logger.info("Found legacy APN tokens for users", {
-                legacyTokenCount: legacyAPNCount
-            });
-        }
-        const [iosResult, androidResult] = await Promise.all([
-            iosTokens.length > 0 ? this.sendToTokens(iosTokens, "ios", params.notification) : Promise.resolve({
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            }),
-            androidTokens.length > 0 ? this.sendToTokens(androidTokens, "android", params.notification) : Promise.resolve({
-                successCount: 0,
-                failureCount: 0,
-                invalidTokens: []
-            })
-        ]);
-        return {
-            successCount: iosResult.successCount + androidResult.successCount,
-            failureCount: iosResult.failureCount + androidResult.failureCount,
-            invalidTokens: [
-                ...iosResult.invalidTokens,
-                ...androidResult.invalidTokens
-            ]
-        };
-    }
-    /**
-   * Subscribe users to a topic for efficient group messaging
-   */ async subscribeToTopic(tokens, topic) {
-        if (tokens.length === 0) {
-            return {
-                successCount: 0,
-                failureCount: 0
-            };
-        }
-        this.logger.info("Subscribing tokens to topic", {
-            tokenCount: tokens.length,
-            topic
-        });
-        try {
-            const response = await admin.messaging().subscribeToTopic(tokens, topic);
-            this.logger.info("Topic subscription complete", {
-                successCount: response.successCount,
-                failureCount: response.failureCount,
-                topic
-            });
-            return {
-                successCount: response.successCount,
-                failureCount: response.failureCount
-            };
-        } catch (error) {
-            this.logger.error("Topic subscription error", {
-                error,
-                topic
-            });
-            throw new ExternalAPIError("Failed to subscribe to topic", `Topic: ${topic}, Error: ${String(error)}`);
-        }
-    }
-    /**
-   * Send notification to a topic (efficient for large groups)
-   */ async sendToTopic(params) {
-        this.logger.info("Sending notification to topic", {
-            topic: params.topic
-        });
-        const message = {
-            topic: params.topic,
-            notification: {
-                title: params.notification.title,
-                body: params.notification.body,
-                ...params.notification.imageUrl && {
-                    imageUrl: params.notification.imageUrl
-                }
-            },
-            data: params.notification.data || {},
-            apns: {
-                payload: {
-                    aps: {
-                        sound: params.notification.sound || "default",
-                        ...params.notification.badge !== undefined && {
-                            badge: params.notification.badge
-                        },
-                        contentAvailable: true
-                    }
-                }
-            },
-            android: {
-                priority: "high",
-                notification: {
-                    sound: params.notification.sound || "default",
-                    channelId: "default"
-                }
-            }
-        };
-        try {
-            const messageId = await admin.messaging().send(message);
-            this.logger.info("Topic notification sent", {
-                topic: params.topic,
-                messageId
-            });
-            return {
-                messageId
-            };
-        } catch (error) {
-            this.logger.error("Topic send error", {
-                error,
-                topic: params.topic
-            });
-            throw new ExternalAPIError("Failed to send topic notification", `Topic: ${params.topic}, Error: ${String(error)}`);
-        }
-    }
-    /**
-   * Send notification using a template
-   */ async sendTemplateToUser(params) {
-        this.logger.info("Sending template notification to user", {
-            userUuid: params.userUuid,
-            notificationType: params.notificationType,
-            language: params.language
-        });
-        const includeOptions = {
-            model: TranslatedNotification,
-            as: "translations",
-            required: false
-        };
-        if (params.language) {
-            includeOptions.where = {
-                language: params.language
-            };
-        }
-        const template = await NotificationModels.findOne({
-            where: {
-                type: params.notificationType
-            },
-            include: [
-                includeOptions
-            ]
-        });
-        if (!template) {
-            throw new ExternalAPIError("Notification template not found", `Type: ${params.notificationType}`);
-        }
-        const translation = template.translations?.find((t)=>t.language === params.language);
-        let text = translation?.text || template.text;
-        if (params.data) {
-            Object.entries(params.data).forEach(([key, value])=>{
-                text = text.replace(new RegExp(`{{${key}}}`, "g"), value);
-            });
-        }
-        return await this.sendToUser({
-            userUuid: params.userUuid,
-            notification: {
-                title: params.notificationType,
-                body: text,
-                ...params.data && {
-                    data: params.data
-                }
-            }
-        });
-    }
-    /**
-   * Send templated notification to multiple users
-   */ async sendTemplateToUsers(params) {
-        this.logger.info("Sending template notification to multiple users", {
-            count: params.userUuids.length,
-            notificationType: params.notificationType
-        });
-        const includeOptions = {
-            model: TranslatedNotification,
-            as: "translations",
-            required: false
-        };
-        if (params.language) {
-            includeOptions.where = {
-                language: params.language
-            };
-        }
-        const template = await NotificationModels.findOne({
-            where: {
-                type: params.notificationType
-            },
-            include: [
-                includeOptions
-            ]
-        });
-        if (!template) {
-            throw new ExternalAPIError("Notification template not found", `Type: ${params.notificationType}`);
-        }
-        const translation = template.translations?.find((t)=>t.language === params.language);
-        let text = translation?.text || template.text;
-        if (params.data) {
-            Object.entries(params.data).forEach(([key, value])=>{
-                text = text.replace(new RegExp(`{{${key}}}`, "g"), value);
-            });
-        }
-        return await this.sendToUsers({
-            userUuids: params.userUuids,
-            notification: {
-                title: params.notificationType,
-                body: text,
-                ...params.data && {
-                    data: params.data
-                }
-            }
-        });
-    }
-    /**
-   * Send notification to all users (uses topic for efficiency)
-   * Consider subscribing users to an "all_users" topic for better performance
-   */ async sendToAllUsers(params) {
-        const batchSize = params.batchSize || 1000;
-        let offset = 0;
-        let totalSent = 0;
-        this.logger.info("Starting broadcast notification", {
-            batchSize
-        });
-        while(true){
-            const deviceTokens = await DeviceTokens.findAll({
-                limit: batchSize,
-                offset,
-                attributes: [
-                    "deviceToken",
-                    "platform"
-                ]
-            });
-            if (deviceTokens.length === 0) {
-                break;
-            }
-            const iosTokens = deviceTokens.filter((dt)=>dt.platform === "ios").map((dt)=>dt.deviceToken);
-            const androidTokens = deviceTokens.filter((dt)=>dt.platform === "android").map((dt)=>dt.deviceToken);
-            const [iosResult, androidResult] = await Promise.all([
-                iosTokens.length > 0 ? this.sendToTokens(iosTokens, "ios", params.notification) : Promise.resolve({
-                    successCount: 0,
-                    failureCount: 0,
-                    invalidTokens: []
-                }),
-                androidTokens.length > 0 ? this.sendToTokens(androidTokens, "android", params.notification) : Promise.resolve({
-                    successCount: 0,
-                    failureCount: 0,
-                    invalidTokens: []
-                })
-            ]);
-            totalSent += iosResult.successCount + androidResult.successCount;
-            offset += batchSize;
-            this.logger.info("Broadcast batch sent", {
-                batchSent: iosResult.successCount + androidResult.successCount,
-                totalSent
-            });
-        }
-        this.logger.info("Broadcast notification complete", {
-            totalSent
-        });
-        return {
-            totalSent
-        };
-    }
-    /**
-   * Send notification to a user group
-   * Recommended: Use topics instead for better performance
-   */ async sendToGroup(params) {
-        const batchSize = params.batchSize || 1000;
-        let offset = 0;
-        let totalSent = 0;
-        this.logger.info("Starting group notification", {
-            group: params.group,
-            batchSize
-        });
-        while(true){
-            const users = await PersistedUser.findAll({
-                where: {
-                    subscriptionType: params.group
-                },
-                include: [
-                    {
-                        model: DeviceTokens,
-                        as: "deviceTokens",
-                        attributes: [
-                            "deviceToken",
-                            "platform"
-                        ]
-                    }
-                ],
-                limit: batchSize,
-                offset
-            });
-            if (users.length === 0) {
-                break;
-            }
-            const allTokens = users.flatMap((user)=>user.deviceTokens || []);
-            const iosTokens = allTokens.filter((dt)=>dt.platform === "ios").map((dt)=>dt.deviceToken);
-            const androidTokens = allTokens.filter((dt)=>dt.platform === "android").map((dt)=>dt.deviceToken);
-            const [iosResult, androidResult] = await Promise.all([
-                iosTokens.length > 0 ? this.sendToTokens(iosTokens, "ios", params.notification) : Promise.resolve({
-                    successCount: 0,
-                    failureCount: 0,
-                    invalidTokens: []
-                }),
-                androidTokens.length > 0 ? this.sendToTokens(androidTokens, "android", params.notification) : Promise.resolve({
-                    successCount: 0,
-                    failureCount: 0,
-                    invalidTokens: []
-                })
-            ]);
-            totalSent += iosResult.successCount + androidResult.successCount;
-            offset += batchSize;
-            this.logger.info("Group batch sent", {
-                batchSent: iosResult.successCount + androidResult.successCount,
-                totalSent
-            });
-        }
-        this.logger.info("Group notification complete", {
-            totalSent,
-            group: params.group
-        });
-        return {
-            totalSent
-        };
-    }
-}
-
-//# sourceMappingURL=FirebasePushNotificationClient.js.map