@quatrain/messaging-firebase 1.0.1

package/lib/FirebaseMessagingAdapter.d.ts

@@ -0,0 +1,21 @@
+import { AbstractMessagingAdapter, MessagingParameters, MessagingRecipient, NotificationCapableAdapter, NotificationMessage } from '@quatrain/messaging';
+export declare class FirebaseMessagingAdapter extends AbstractMessagingAdapter implements NotificationCapableAdapter {
+    private _messaging;
+    constructor(params?: MessagingParameters);
+    private _initializeFirebase;
+    /**
+     * Sends a notification to a single recipient via Firebase Cloud Messaging
+     *
+     * @param recipient - The message recipient containing contact info and FCM token
+     * @param message - The notification message with title, body, and optional data
+     * @returns Promise<string> - The Firebase message ID on successful delivery
+     * @throws Error if recipient has no message token or Firebase send fails
+     */
+    sendNotification(recipient: MessagingRecipient, message: NotificationMessage): Promise<string>;
+    sendNotifications(recipients: MessagingRecipient[], message: NotificationMessage): Promise<{
+        successCount: number;
+        failureCount: number;
+        responses: any[];
+    }>;
+    private _serializeData;
+}

package/lib/FirebaseMessagingAdapter.js

@@ -0,0 +1,110 @@
+"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.FirebaseMessagingAdapter = void 0;
+const messaging_1 = require("@quatrain/messaging");
+const app_1 = require("firebase-admin/app");
+const messaging_2 = require("firebase-admin/messaging");
+class FirebaseMessagingAdapter extends messaging_1.AbstractMessagingAdapter {
+    constructor(params = {}) {
+        super(params);
+        this._initializeFirebase();
+    }
+    _initializeFirebase() {
+        try {
+            if ((0, app_1.getApps)().length === 0) {
+                if (!this._params.config) {
+                    throw new Error('Firebase config is required');
+                }
+                (0, app_1.initializeApp)(this._params.config);
+            }
+            this._messaging = (0, messaging_2.getMessaging)();
+        }
+        catch (error) {
+            messaging_1.Messaging.error(`Failed to initialize Firebase: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Sends a notification to a single recipient via Firebase Cloud Messaging
+     *
+     * @param recipient - The message recipient containing contact info and FCM token
+     * @param message - The notification message with title, body, and optional data
+     * @returns Promise<string> - The Firebase message ID on successful delivery
+     * @throws Error if recipient has no message token or Firebase send fails
+     */
+    sendNotification(recipient, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!recipient.messageToken) {
+                    throw new Error('Recipient message token is required');
+                }
+                const firebaseMessage = {
+                    token: message.token || recipient.messageToken,
+                    notification: {
+                        title: message.title,
+                        body: message.body || '',
+                    },
+                    data: this._serializeData(message.data || {}),
+                };
+                const response = yield this._messaging.send(firebaseMessage);
+                messaging_1.Messaging.info(`Notification sent successfully to ${recipient.firstname} ${recipient.lastname}: ${response}`);
+                return response;
+            }
+            catch (error) {
+                const errorMessage = `Failed to send notification to ${recipient.firstname} ${recipient.lastname}: ${error.message}`;
+                messaging_1.Messaging.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+        });
+    }
+    sendNotifications(recipients, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokens = recipients
+                    .map((recipient) => recipient.messageToken)
+                    .filter((token) => token);
+                if (tokens.length === 0) {
+                    throw new Error('No valid message tokens found');
+                }
+                const multicastMessage = {
+                    tokens,
+                    notification: {
+                        title: message.title,
+                        body: message.body || '',
+                    },
+                    data: this._serializeData(message.data || {}),
+                };
+                const response = yield this._messaging.sendMulticast(multicastMessage);
+                messaging_1.Messaging.info(`Multicast notification sent: ${response.successCount} successful, ${response.failureCount} failed`);
+                return response;
+            }
+            catch (error) {
+                const errorMessage = `Failed to send multicast notification: ${error.message}`;
+                messaging_1.Messaging.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+        });
+    }
+    _serializeData(data) {
+        const serialized = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (typeof value === 'string') {
+                serialized[key] = value;
+            }
+            else {
+                serialized[key] = JSON.stringify(value);
+            }
+        }
+        return serialized;
+    }
+}
+exports.FirebaseMessagingAdapter = FirebaseMessagingAdapter;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import { FirebaseMessagingAdapter } from './FirebaseMessagingAdapter';
+export { FirebaseMessagingAdapter };

package/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebaseMessagingAdapter = void 0;
+const FirebaseMessagingAdapter_1 = require("./FirebaseMessagingAdapter");
+Object.defineProperty(exports, "FirebaseMessagingAdapter", { enumerable: true, get: function () { return FirebaseMessagingAdapter_1.FirebaseMessagingAdapter; } });

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@quatrain/messaging-firebase",
+  "version": "1.0.1",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/",
+    "README.md"
+  ],
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "peerDependencies": {
+    "@quatrain/core": "^1.1.19"
+  },
+  "dependencies": {
+    "@quatrain/messaging": "^1.0.0",
+    "firebase-admin": "^13.0.1"
+  },
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^22.10.1",
+    "jest": "^27.4.7",
+    "jest-node-exports-resolver": "^1.1.6",
+    "jest-serial-runner": "^1.2.1",
+    "trace-unhandled": "^2.0.1",
+    "ts-jest": "^27.1.2",
+    "typescript": "^5.1.5"
+  },
+  "scripts": {
+    "build": "tsc",
+    "wbuild": "tsc --watch",
+    "test": "jest",
+    "bump-to": "yarn version",
+    "hash": "node ../../bin/hashFolder.js",
+    "hash:persist": "yarn hash  > .hash_latest.txt",
+    "hash:compare": "yarn hash > .hash_newest.txt && cmp -s .hash_latest.txt .hash_newest.txt",
+    "publish": "yarn hash:compare || yarn publish:process",
+    "publish:process": "yarn version patch && yarn build && yarn npm publish --access public && yarn hash:persist"
+  }
+}