@platform-x/hep-push-notification-client 1.0.0

package/dist/src/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushNotificationManager = exports.getPushNotificationSecrets = exports.initPushNotificationSecrets = void 0;
+const PushNotificationManager_1 = require("./PushNotificationManager");
+Object.defineProperty(exports, "pushNotificationManager", { enumerable: true, get: function () { return PushNotificationManager_1.pushNotificationManager; } });
+let injectedSecretService;
+const initPushNotificationSecrets = (secretServiceIns) => {
+    injectedSecretService = secretServiceIns;
+};
+exports.initPushNotificationSecrets = initPushNotificationSecrets;
+const getPushNotificationSecrets = () => {
+    if (!injectedSecretService) {
+        throw new Error("Push Notification secrets not initialized");
+    }
+    return injectedSecretService.getSecretKeys(); // returns cached data
+    // return new SecretKeyServices().getSecretKeys(); // for localpackage test
+};
+exports.getPushNotificationSecrets = getPushNotificationSecrets;
+// for testing
+// export const testval = async () => {
+//         let id: any = new pushNotificationManager();
+// //         // .iamAuthenticator('kiwi', false);
+//         let client = await id.pushNotificationProvider('kiwi');
+// //         // getuserdetails
+//         let validate: any = await client.sendNotificationsToTopics(['articles'], {
+//           title: 'Test Title',
+//           body: 'Test Body',
+//           data: { key1: 'value1', key2: 'value2' }
+//         }
+//         );
+//         console.log('>>>>>>>>>>>>>idd>>>>', validate)
+//     }
+// testval()
+//# sourceMappingURL=index.js.map

package/dist/src/platform-x/constants/index.d.ts

@@ -0,0 +1,41 @@
+/** HTTP Request related constants */
+export declare const HTTP_CONTENT_TYPE_JSON = "application/json";
+export declare const TRACE_ID_HEADER_NAME = "Platform-X-Trace-Id";
+export declare const DEFAULT_APP_PORT = 8080;
+export declare const DEFAULT_APP_NAME = "api-gateway";
+export declare const DEFAULT_REALM_NAME = "platform-x";
+export declare const PROVIDERS: {
+    FCM: string;
+    SAP_EMARSYS: string;
+};
+export declare const CONFIG_KEYS: {
+    FIREBASETYPE: string;
+    FIREBASEPROJECTID: string;
+    FIREBASEPRIVATEKEYID: string;
+    FIREBASEPRIVATEKEY: string;
+    FIREBASECLIENTEMAIL: string;
+    FIREBASECLIENTID: string;
+    FIREBASECLIENTCERTURL: string;
+};
+export declare const DynamicValues: {
+    ANALYTICS_PASSWORD: string;
+    AUTH_TENANTS_INFO: string;
+    BRCMS_AUTH: string;
+    FCM_PRIVATE_KEY_ID: string;
+    FCM_PRIVATE_KEY: string;
+    FCM_CLIENT_EMAIL: string;
+    FCM_CLIENT_ID: string;
+    MONGO_PASS: string;
+    FCM_CLIENT_X509_CERT_URL: string;
+    DEFAULT: string;
+    Default_BRIGHTCOVE_userAccountId: string;
+    Default_BRIGHTCOVE_clientId: string;
+    Default_BRIGHTCOVE_clientSecret: string;
+    SECRETS_CRYPTO_KEY: string;
+    DEFAULT_FCM_FIREBASEPROJECTID: string;
+    DEFAULT_FCM_FIREBASEPRIVATEKEYID: string;
+    DEFAULT_FCM_FIREBASEPRIVATEKEY: string;
+    DEFAULT_FCM_FIREBASECLIENTEMAIL: string;
+    DEFAULT_FCM_FIREBASECLIENTID: string;
+    DEFAULT_FCM_FIREBASECLIENTCERTURL: string;
+};

package/dist/src/platform-x/constants/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicValues = exports.CONFIG_KEYS = exports.PROVIDERS = exports.DEFAULT_REALM_NAME = exports.DEFAULT_APP_NAME = exports.DEFAULT_APP_PORT = exports.TRACE_ID_HEADER_NAME = exports.HTTP_CONTENT_TYPE_JSON = void 0;
+/** HTTP Request related constants */
+exports.HTTP_CONTENT_TYPE_JSON = 'application/json';
+exports.TRACE_ID_HEADER_NAME = 'Platform-X-Trace-Id';
+exports.DEFAULT_APP_PORT = 8080;
+exports.DEFAULT_APP_NAME = 'api-gateway';
+exports.DEFAULT_REALM_NAME = 'platform-x';
+exports.PROVIDERS = {
+    FCM: 'fcm',
+    SAP_EMARSYS: 'SAP_EMARSYS',
+};
+exports.CONFIG_KEYS = {
+    FIREBASETYPE: 'FIREBASETYPE',
+    FIREBASEPROJECTID: 'FIREBASEPROJECTID',
+    FIREBASEPRIVATEKEYID: 'FIREBASEPRIVATEKEYID',
+    FIREBASEPRIVATEKEY: 'FIREBASEPRIVATEKEY',
+    FIREBASECLIENTEMAIL: 'FIREBASECLIENTEMAIL',
+    FIREBASECLIENTID: 'FIREBASECLIENTID',
+    FIREBASECLIENTCERTURL: 'FIREBASECLIENTCERTURL'
+};
+exports.DynamicValues = {
+    ANALYTICS_PASSWORD: 'ANALYTICS_PASSWORD',
+    AUTH_TENANTS_INFO: 'AUTH_TENANTS_INFO',
+    BRCMS_AUTH: 'BRCMS_AUTH',
+    FCM_PRIVATE_KEY_ID: 'FCM_PRIVATE_KEY_ID',
+    FCM_PRIVATE_KEY: 'FCM_PRIVATE_KEY',
+    FCM_CLIENT_EMAIL: 'FCM_CLIENT_EMAIL',
+    FCM_CLIENT_ID: 'FCM_CLIENT_ID',
+    MONGO_PASS: 'MONGO_PASS',
+    FCM_CLIENT_X509_CERT_URL: 'FCM_CLIENT_X509_CERT_URL',
+    DEFAULT: 'Default',
+    Default_BRIGHTCOVE_userAccountId: 'Default_BRIGHTCOVE_userAccountId',
+    Default_BRIGHTCOVE_clientId: 'Default_BRIGHTCOVE_clientId',
+    Default_BRIGHTCOVE_clientSecret: 'Default_BRIGHTCOVE_clientSecret',
+    SECRETS_CRYPTO_KEY: 'SECRETS_CRYPTO_KEY',
+    DEFAULT_FCM_FIREBASEPROJECTID: 'DEFAULT_FCM_FIREBASEPROJECTID',
+    DEFAULT_FCM_FIREBASEPRIVATEKEYID: 'DEFAULT_FCM_FIREBASEPRIVATEKEYID',
+    DEFAULT_FCM_FIREBASEPRIVATEKEY: 'DEFAULT_FCM_FIREBASEPRIVATEKEY',
+    DEFAULT_FCM_FIREBASECLIENTEMAIL: 'DEFAULT_FCM_FIREBASECLIENTEMAIL',
+    DEFAULT_FCM_FIREBASECLIENTID: 'DEFAULT_FCM_FIREBASECLIENTID',
+    DEFAULT_FCM_FIREBASECLIENTCERTURL: 'DEFAULT_FCM_FIREBASECLIENTCERTURL',
+};
+//# sourceMappingURL=index.js.map

package/dist/src/platform-x/database/connection.d.ts

@@ -0,0 +1,8 @@
+import mongoose from 'mongoose';
+declare const _default: {
+    database: mongoose.Connection;
+    mongoose: typeof mongoose;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+};
+export default _default;

package/dist/src/platform-x/database/connection.js

@@ -0,0 +1,54 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importDefault(require("mongoose"));
+const logger_1 = require("../../common/util/logger");
+const index_1 = __importDefault(require("../../config/index"));
+const constants_1 = require("../constants");
+const __1 = require("../..");
+let database = mongoose_1.default.connection;
+// Exit on error
+mongoose_1.default.connection.on('error', (err) => {
+    logger_1.Logger.info(`MongoDB connection error: ${err}`, 'mongoose');
+    process.exit(-1);
+});
+const connect = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (database.readyState) {
+        return;
+    }
+    const secrets = yield (0, __1.getPushNotificationSecrets)();
+    mongoose_1.default.connect(`mongodb://${index_1.default.MONGO.USER}:${secrets === null || secrets === void 0 ? void 0 : secrets[constants_1.DynamicValues === null || constants_1.DynamicValues === void 0 ? void 0 : constants_1.DynamicValues.MONGO_PASS]}@${index_1.default.MONGO.HOST}:${index_1.default.MONGO.PORT}/${index_1.default.MONGO.DB_NAME}?directConnection=true&authMechanism=DEFAULT&authSource=${index_1.default.MONGO.DB_NAME}`);
+    database = mongoose_1.default.connection;
+    database.once('open', () => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.info(`[Server] connected to MongoDB`, 'connect');
+    }));
+    database.on('error', (err = {}) => {
+        logger_1.Logger.error(`[Server] error connecting to MongoDB`, 'connect', err);
+        process.exit(-1);
+    });
+});
+const disconnect = () => {
+    if (!database) {
+        return;
+    }
+    logger_1.Logger.info(`Disconnected to MongoDB`, 'disconnect');
+    mongoose_1.default.disconnect();
+};
+exports.default = {
+    database,
+    mongoose: mongoose_1.default,
+    connect,
+    disconnect,
+};
+//# sourceMappingURL=connection.js.map

package/dist/src/platform-x/database/dao/site_domain.dao.d.ts

@@ -0,0 +1,10 @@
+export default class SiteDomainDao {
+    /**
+     * get domain details
+     * @param request
+     * @returns
+     */
+    details(filter: any, condition?: any): Promise<(import("mongoose").Document<unknown, {}, import("../interfaces/site_domain.interface").SiteDomain> & Omit<import("../interfaces/site_domain.interface").SiteDomain & {
+        _id: import("mongoose").Types.ObjectId;
+    }, never>) | null>;
+}

package/dist/src/platform-x/database/dao/site_domain.dao.js

@@ -0,0 +1,45 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../../../common/util/logger");
+const index_1 = __importDefault(require("../index"));
+const { SiteDomainModel } = index_1.default;
+class SiteDomainDao {
+    /**
+     * get domain details
+     * @param request
+     * @returns
+     */
+    details(filter, condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('SiteDomainDao: Reached details', 'details');
+                if (!filter || Object.keys(filter).length === 0) {
+                    throw new Error('Condition for details cannot be empty');
+                }
+                if (condition) {
+                    filter = Object.assign(Object.assign({}, condition), filter);
+                }
+                logger_1.Logger.debug('SiteDomainDao: details', 'details', filter);
+                return yield SiteDomainModel.findOne(filter).exec();
+            }
+            catch (err) {
+                logger_1.Logger.error('SiteDomainDao: Error in details', 'details', err);
+                throw err;
+            }
+        });
+    }
+}
+exports.default = SiteDomainDao;
+//# sourceMappingURL=site_domain.dao.js.map

package/dist/src/platform-x/database/index.d.ts

@@ -0,0 +1,14 @@
+declare const db: {
+    SiteDomainModel: import("mongoose").Model<import("./interfaces/site_domain.interface").SiteDomain, {}, {}, {}, import("mongoose").Document<unknown, {}, import("./interfaces/site_domain.interface").SiteDomain> & Omit<import("./interfaces/site_domain.interface").SiteDomain & {
+        _id: import("mongoose").Types.ObjectId;
+    }, never>, import("mongoose").Schema<import("./interfaces/site_domain.interface").SiteDomain, import("mongoose").Model<import("./interfaces/site_domain.interface").SiteDomain, any, any, any, import("mongoose").Document<unknown, any, import("./interfaces/site_domain.interface").SiteDomain> & Omit<import("./interfaces/site_domain.interface").SiteDomain & {
+        _id: import("mongoose").Types.ObjectId;
+    }, never>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, import("./interfaces/site_domain.interface").SiteDomain, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<import("./interfaces/site_domain.interface").SiteDomain>> & Omit<import("mongoose").FlatRecord<import("./interfaces/site_domain.interface").SiteDomain> & {
+        _id: import("mongoose").Types.ObjectId;
+    }, never>>>;
+    database: import("mongoose").Connection;
+    mongoose: typeof import("mongoose");
+    connect: () => Promise<void>;
+    disconnect: () => void;
+};
+export default db;

package/dist/src/platform-x/database/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connection_1 = __importDefault(require("./connection"));
+const site_domain_model_1 = __importDefault(require("./models/site_domain.model"));
+const db = Object.assign(Object.assign({}, connection_1.default), { SiteDomainModel: site_domain_model_1.default });
+exports.default = db;
+//# sourceMappingURL=index.js.map

package/dist/src/platform-x/database/interfaces/site_domain.interface.d.ts

@@ -0,0 +1,33 @@
+export interface EmailTemplate {
+    default_email_template: string;
+    site_email_template: string;
+}
+type ProviderKeys = Record<string, {
+    name: string;
+    mask?: boolean;
+}>;
+export interface ProviderConfig {
+    is_enabled?: boolean;
+    keys?: ProviderKeys;
+}
+export interface ProvidersByType {
+    [providerType: string]: {
+        active?: string;
+        [providerName: string]: ProviderConfig | string | boolean | undefined;
+    };
+}
+export interface SiteDomain {
+    id?: string;
+    domain?: string;
+    sitename?: string;
+    olTenantId?: string;
+    olTenantName?: string;
+    staticSiteStatus: string;
+    isBackupRestored: boolean;
+    isStaticSiteBackup: boolean;
+    supportMail: string;
+    userInfo?: any;
+    emailTemplates?: EmailTemplate[];
+    providers?: ProvidersByType;
+}
+export {};

package/dist/src/platform-x/database/interfaces/site_domain.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=site_domain.interface.js.map

package/dist/src/platform-x/database/models/site_domain.model.d.ts

@@ -0,0 +1,9 @@
+import { SiteDomain } from '../interfaces/site_domain.interface';
+declare const _default: import("mongoose").Model<SiteDomain, {}, {}, {}, import("mongoose").Document<unknown, {}, SiteDomain> & Omit<SiteDomain & {
+    _id: import("mongoose").Types.ObjectId;
+}, never>, import("mongoose").Schema<SiteDomain, import("mongoose").Model<SiteDomain, any, any, any, import("mongoose").Document<unknown, any, SiteDomain> & Omit<SiteDomain & {
+    _id: import("mongoose").Types.ObjectId;
+}, never>, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, SiteDomain, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<SiteDomain>> & Omit<import("mongoose").FlatRecord<SiteDomain> & {
+    _id: import("mongoose").Types.ObjectId;
+}, never>>>;
+export default _default;

package/dist/src/platform-x/database/models/site_domain.model.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connection_1 = __importDefault(require("../connection"));
+const { mongoose } = connection_1.default;
+const { Schema, model } = mongoose;
+const siteDomainSchema = new Schema({
+    id: Schema.Types.ObjectId,
+    domain: String,
+    sitename: String,
+    olTenantId: String,
+    olTenantName: String,
+    userInfo: {
+        type: Schema.Types.Mixed,
+        default: {},
+    },
+    staticSiteStatus: {
+        type: String,
+        enum: ['NOT_CREATED', 'INPROGRESS', 'SUCCESS', 'FAILED'],
+        default: 'NOT_CREATED',
+    },
+    isBackupRestored: {
+        type: Boolean,
+        default: false,
+    },
+    isStaticSiteBackup: {
+        type: Boolean,
+        default: false,
+    },
+    supportMail: String,
+    emailTemplates: [
+        {
+            default_email_template: String,
+            site_email_template: String,
+        },
+    ],
+    providers: {
+        type: Schema.Types.Mixed,
+        default: {}
+    }
+}, {
+    timestamps: true,
+    minimize: false,
+});
+exports.default = model('site_domains', siteDomainSchema);
+//# sourceMappingURL=site_domain.model.js.map

package/dist/src/platform-x/interface/interface.d.ts

@@ -0,0 +1,4 @@
+export interface PushNotifyProvider {
+    fetchTopics(): Promise<any>;
+    sendNotificationsToTopics(topics: string[], notification: any): Promise<any>;
+}

package/dist/src/platform-x/interface/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/src/platform-x/services/fcmservices.d.ts

@@ -0,0 +1,18 @@
+import { PushNotifyProvider } from '../interface/interface';
+export declare class FcmClient implements PushNotifyProvider {
+    readonly authorizedClient: any;
+    private constructor();
+    static fcmClientObject(sitename: string): Promise<FcmClient>;
+    sendPushNotifications(token: string, notificationMessage: any): Promise<any>;
+    sendPushNotification(token: string, notificationMessage: any): Promise<any>;
+    sendChunkedPushNotification(tokens: string[], notificationMessage: string): Promise<unknown>;
+    chunkTokens(tokens: string[], chunkSize: number): Promise<any>;
+    fetchTopics(): Promise<any>;
+    /**
+     * Method to send notification based on topics
+     * @param topics
+     * @param notification
+     * @returns
+     */
+    sendNotificationsToTopics(topics: string[], notification: any): Promise<any>;
+}

package/dist/src/platform-x/services/fcmservices.js

@@ -0,0 +1,188 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FcmClient = void 0;
+/* eslint-disable max-len */
+const commonUtil_1 = require("../../common/util/commonUtil");
+const logger_1 = require("../../common/util/logger");
+const config_1 = __importDefault(require("../../config"));
+const constants_1 = require("../constants");
+const admin = require('firebase-admin');
+class FcmClient {
+    constructor(credentials) {
+        this.authorizedClient = {};
+        if (!admin.apps.length) {
+            // Initialize default app
+            admin.initializeApp({
+                credential: admin.credential.cert(credentials),
+                databaseURL: `https://${credentials.project_id}.firebaseio.com`, // For Realtime DB, remove if not using
+            });
+        }
+        else {
+            // If default app already exists, skip initializing again
+            logger_1.Logger.info('FCM Client', 'Firebase app already initialized, skipping initialization');
+        }
+    }
+    static fcmClientObject(sitename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            logger_1.Logger.info('FCM-Client>FCMClient: Reached fcmClientObject', 'fcmClientObject');
+            const credentials = {
+                type: config_1.default.FCM.TYPE,
+                project_id: ((_a = yield (0, commonUtil_1.getDynamicSecretdata)(sitename, constants_1.PROVIDERS.FCM, constants_1.CONFIG_KEYS === null || constants_1.CONFIG_KEYS === void 0 ? void 0 : constants_1.CONFIG_KEYS.FIREBASEPROJECTID)) !== null && _a !== void 0 ? _a : ''),
+                private_key_id: ((_b = yield (0, commonUtil_1.getDynamicSecretdata)(sitename, constants_1.PROVIDERS.FCM, constants_1.CONFIG_KEYS === null || constants_1.CONFIG_KEYS === void 0 ? void 0 : constants_1.CONFIG_KEYS.FIREBASEPRIVATEKEY)) !== null && _b !== void 0 ? _b : ''),
+                client_email: ((_c = yield (0, commonUtil_1.getDynamicSecretdata)(sitename, constants_1.PROVIDERS.FCM, constants_1.CONFIG_KEYS === null || constants_1.CONFIG_KEYS === void 0 ? void 0 : constants_1.CONFIG_KEYS.FIREBASECLIENTEMAIL)) !== null && _c !== void 0 ? _c : ''),
+                client_id: ((_d = yield (0, commonUtil_1.getDynamicSecretdata)(sitename, constants_1.PROVIDERS.FCM, constants_1.CONFIG_KEYS === null || constants_1.CONFIG_KEYS === void 0 ? void 0 : constants_1.CONFIG_KEYS.FIREBASECLIENTID)) !== null && _d !== void 0 ? _d : ''),
+                auth_uri: config_1.default.FCM.AUTH_URI,
+                token_uri: config_1.default.FCM.TOKEN_URI,
+                auth_provider_x509_cert_url: config_1.default.FCM.AUTH_PROVIDER_X509_CERT_URL,
+                client_x509_cert_url: ((_e = yield (0, commonUtil_1.getDynamicSecretdata)(sitename, constants_1.PROVIDERS.FCM, constants_1.CONFIG_KEYS === null || constants_1.CONFIG_KEYS === void 0 ? void 0 : constants_1.CONFIG_KEYS.FIREBASECLIENTCERTURL)) !== null && _e !== void 0 ? _e : ''),
+                universe_domain: config_1.default.FCM.UNIVERSE_DOMAIN,
+                private_key: `-----BEGIN PRIVATE KEY-----\n${(yield (0, commonUtil_1.getDynamicSecretdata)(sitename, constants_1.PROVIDERS.FCM, constants_1.CONFIG_KEYS === null || constants_1.CONFIG_KEYS === void 0 ? void 0 : constants_1.CONFIG_KEYS.FIREBASEPRIVATEKEY))}\n-----END PRIVATE KEY-----\n`, // pragma: allowlist secret
+            };
+            logger_1.Logger.info('FCM-Client>FCMClient: FCM Client Credentials fetched', 'fcmClientObject');
+            return new FcmClient(credentials);
+        });
+    }
+    sendPushNotifications(token, notificationMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('FCM-Client>FCMClient: Reached authorize', 'sendPushNotifications');
+                const pushnotificationRes = yield this.sendPushNotification(token, notificationMessage);
+                return pushnotificationRes;
+            }
+            catch (err) {
+                logger_1.Logger.error('FCM-Client>FCMClient: Error in sendPushNotifications', 'sendPushNotifications', err);
+                return err;
+            }
+        });
+    }
+    sendPushNotification(token, notificationMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('FCM-Client>FCMClient: Reached sendPushNotification', 'sendPushNotification');
+                const message = {
+                    notification: {
+                        title: notificationMessage.title,
+                        body: notificationMessage.body,
+                    },
+                    token,
+                };
+                logger_1.Logger.info('FCM-Client>FCMClient: Reached sendPushNotification', 'sendPushNotification');
+                let notificationRes = yield admin.messaging().send(message);
+                logger_1.Logger.info('FCM-Client>FCMClient: Reached sendPushNotification', 'sendPushNotification');
+                return notificationRes;
+            }
+            catch (err) {
+                logger_1.Logger.error('FCM-Client>FCMClient: Error in sendPushNotifications', 'sendPushNotifications', err);
+                return err;
+            }
+        });
+    }
+    sendChunkedPushNotification(tokens, notificationMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('FCM-Client>FCMClient: Reached sendPushNotification', 'sendPushNotification');
+                // Get the FCM tokens for this segment and chunk them
+                const CHUNK_SIZE = 1000;
+                const chunkedTokens = this.chunkTokens(tokens, CHUNK_SIZE);
+                // Send the notification to each chunk
+                for (const chunk of chunkedTokens) {
+                    // Send notifications for the current chunk
+                    for (const token of chunk) {
+                        yield this.sendPushNotifications(token, notificationMessage);
+                    }
+                }
+                return true;
+            }
+            catch (err) {
+                logger_1.Logger.error('FCM-Client>FCMClient: Error in sendPushNotifications', 'sendPushNotifications', err);
+                return err;
+            }
+        });
+    }
+    chunkTokens(tokens, chunkSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.Logger.info('FCM-Client>FCMClient: Reached chunkTokens', 'chunkTokens');
+                // Maximum number of tokens to send in one chunk (FCM allows a max of 1000 tokens per request)
+                const chunks = [];
+                for (let i = 0; i < tokens.length; i += chunkSize) {
+                    chunks.push(tokens.slice(i, i + chunkSize));
+                }
+                return chunks;
+            }
+            catch (err) {
+                logger_1.Logger.error('FCM-Client>FCMClient: Error in chunkTokens', 'chunkTokens', err);
+                return err;
+            }
+        });
+    }
+    fetchTopics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const db = admin.firestore(); // Use Firestore// Firebase Realtime Database reference
+                const snapshot = yield db.collection('topics').get(); // Correct method for Firestore
+                if (snapshot.empty) {
+                    logger_1.Logger.debug('FCM client', 'fetchTopics', 'No Topics Found');
+                    return;
+                }
+                const topics = [];
+                snapshot.forEach((doc) => {
+                    topics.push({ name: doc.data().name }); // Assuming each topic has a 'name' field
+                });
+                return topics;
+            }
+            catch (error) {
+                logger_1.Logger.error('FCM-Client>FCMClient: Error in fetchTopics', 'fetchTopics', error);
+                return error;
+            }
+        });
+    }
+    /**
+     * Method to send notification based on topics
+     * @param topics
+     * @param notification
+     * @returns
+     */
+    sendNotificationsToTopics(topics, notification) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (Array.isArray(topics) && topics.length > 0) {
+                    const topicsStr = topics.map(t => `'${t}' in topics`).join(' || ');
+                    logger_1.Logger.debug('FCM-Client>FCMClient: Reached sendNotificationsToTopics', 'sendNotificationsToTopics', { topicsStr });
+                    const message = {
+                        notification: {
+                            title: notification.title,
+                            body: notification.body,
+                        },
+                        data: notification.data,
+                        // Using the "condition" field to target multiple topics
+                        condition: `${topicsStr}`,
+                    };
+                    logger_1.Logger.debug('FCM-Client>FCMClient: Reached sendNotificationsToTopics', 'sendNotificationsToTopics', message);
+                    const response = yield admin.messaging().send(message);
+                    logger_1.Logger.debug('FCM-Client>FCMClient: Reached  after sendNotificationsToTopics', 'sendNotificationsToTopics', { response });
+                    return response;
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error('FCM-Client>FCMClient: Error in sendNotificationsToTopics', 'sendNotificationsToTopics', error);
+                return error;
+            }
+        });
+    }
+}
+exports.FcmClient = FcmClient;
+//# sourceMappingURL=fcmservices.js.map

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@platform-x/hep-push-notification-client",
+  "version": "1.0.0",
+  "description": "@platform-x/hep-push-notification-client",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "devstart": "npm run build && tsc-watch --onSuccess \"node ./dist/src/index.js\"",
+    "start": "node ./dist/src/index.js"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "@types/uuid": "^10.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@alloc/quick-lru": "^5.2.0",
+    "@sendgrid/helpers": "7.7.0",
+    "@types/bunyan": "^1.8.6",
+    "@types/bunyan-format": "^0.2.3",
+    "@types/cls-hooked": "^4.3.3",
+    "@types/express": "^4.17.12",
+    "@types/lodash": "^4.14.171",
+    "@types/node": "^15.12.2",
+    "apollo-server-caching": "^3.3.0",
+    "axios": "0.21.4",
+    "bunyan": "^1.8.15",
+    "bunyan-format": "^0.2.1",
+    "cls-hooked": "^4.2.2",
+    "dataloader": "^2.0.0",
+    "dotenv": "^10.0.0",
+    "express": "^4.17.1",
+    "firebase-admin": "^13.5.0",
+    "hep-secret-access": "1.3.4",
+    "lodash": "4.17.21",
+    "mongodb": "5.9.2",
+    "mongoose": "7.0.3",
+    "mysql2": "2.3.3",
+    "node-html-parser": "5.1.0",
+    "request-ip": "2.1.3",
+    "uuid": "8.3.2"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}