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

package/README.md

@@ -0,0 +1,10 @@
+#@platform-x/hep-push-notification-client
+Provide module to push notifications to the users.
+
+How to install and use
+
+npm install @platform-x/hep-push-notification-client
+
+import the modules and implement.
+ const fcmClient: any = new pushNotificationProvider(sitename);
+ await fcmClient.fetchTopics(type);

package/dist/src/PushNotificationManager.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Push Notification Manager - supports multiple providers
+ * Currently implemented: FCM
+ * Future providers: SAP_EMARSYS
+ */
+export declare class pushNotificationManager {
+    private notificationProvider;
+    pushNotificationProvider(sitename: string): Promise<any>;
+}

package/dist/src/PushNotificationManager.js

@@ -0,0 +1,56 @@
+"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.pushNotificationManager = void 0;
+const logger_1 = require("./common/util/logger");
+const constants_1 = require("./platform-x/constants");
+const fcmservices_1 = require("./platform-x/services/fcmservices");
+const site_domain_dao_1 = __importDefault(require("./platform-x/database/dao/site_domain.dao"));
+/**
+ * Push Notification Manager - supports multiple providers
+ * Currently implemented: FCM
+ * Future providers: SAP_EMARSYS
+ */
+class pushNotificationManager {
+    pushNotificationProvider(sitename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            try {
+                logger_1.Logger.info('pushNotificationManager: Reached pushNotificationProvider', 'pushNotificationProvider');
+                let pushConfig = yield new site_domain_dao_1.default().details({ sitename });
+                let pushNotifyProvider = (_c = (_b = (_a = pushConfig === null || pushConfig === void 0 ? void 0 : pushConfig.providers) === null || _a === void 0 ? void 0 : _a.notification) === null || _b === void 0 ? void 0 : _b.active) !== null && _c !== void 0 ? _c : constants_1.PROVIDERS.FCM;
+                logger_1.Logger.info(`pushNotificationManager: Initializing the provider for client ${sitename}`, '');
+                switch (pushNotifyProvider) {
+                    case constants_1.PROVIDERS.FCM:
+                        this.notificationProvider = yield fcmservices_1.FcmClient.fcmClientObject(sitename);
+                        logger_1.Logger.info('pushNotificationManager: Initialized with FCM provider', 'constructor');
+                        break;
+                    case constants_1.PROVIDERS.SAP_EMARSYS:
+                        // Implement the SAP emarsys client initialization here
+                        logger_1.Logger.info('pushNotificationManager: Initialized with SAP_EMARSYS provider', 'constructor');
+                        break;
+                    default:
+                        throw new Error(`Unsupported provider: ${pushNotifyProvider}. Supported providers: ${Object.values(constants_1.PROVIDERS).join(', ')}`);
+                }
+                return this.notificationProvider;
+            }
+            catch (err) {
+                logger_1.Logger.error('pushNotificationManager: Error in pushNotificationManager', 'pushNotificationManager', err);
+                throw err;
+            }
+        });
+    }
+}
+exports.pushNotificationManager = pushNotificationManager;
+//# sourceMappingURL=PushNotificationManager.js.map

package/dist/src/common/util/commonUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * base64ToString - to convert base64 into string
+ * @param {string} toDecode- string base64 request
+ */
+export declare const base64ToString: (toDecode: string) => string;
+export declare function getDynamicSecretdata(sitename: any, providerName: any, secretKey: any): Promise<string>;

package/dist/src/common/util/commonUtil.js

@@ -0,0 +1,43 @@
+"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.base64ToString = void 0;
+exports.getDynamicSecretdata = getDynamicSecretdata;
+const __1 = require("../..");
+const constants_1 = require("../../platform-x/constants");
+const logger_1 = require("./logger");
+/**
+ * base64ToString - to convert base64 into string
+ * @param {string} toDecode- string base64 request
+ */
+const base64ToString = (toDecode) => {
+    return Buffer.from(toDecode, 'base64').toString('ascii');
+};
+exports.base64ToString = base64ToString;
+function getDynamicSecretdata(sitename, providerName, secretKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.Logger.info(`commonUtils.ts : getDynamicSecretdata reached  ${{ sitename, providerName, secretKey }}`, 'getDynamicSecretdata');
+        const secretValue = yield (0, __1.getPushNotificationSecrets)();
+        const defaultData = constants_1.DynamicValues === null || constants_1.DynamicValues === void 0 ? void 0 : constants_1.DynamicValues.DEFAULT;
+        const targetKey = `${sitename}_${providerName}_${secretKey}`.toUpperCase();
+        const fallbackKey = `${defaultData}_${providerName}_${secretKey}`.toUpperCase();
+        logger_1.Logger.info('Target Key: ', 'getDynamicSecretdata');
+        logger_1.Logger.info('Fallback Key: ', 'getDynamicSecretdata');
+        let finalValue = secretValue.hasOwnProperty(targetKey) ? secretValue[targetKey] : secretValue[fallbackKey];
+        if (!finalValue || finalValue == '') {
+            logger_1.Logger.info(`Target Key not found, using fallback key: ${fallbackKey}`, 'getDynamicSecretdata');
+            finalValue = secretValue[fallbackKey];
+        }
+        logger_1.Logger.info('Final Value fetched', 'getDynamicSecretdata');
+        return finalValue;
+    });
+}
+//# sourceMappingURL=commonUtil.js.map

package/dist/src/common/util/errorHandler.d.ts

@@ -0,0 +1,41 @@
+export declare const enum HTTP_STATUS_CODE {
+    INTERNAL_SERVER_ERROR = 500
+}
+export declare const HTTP_STATUS_MAP: Map<number, string>;
+export declare const enum HTTP_STATUS_TYPE {
+    INTERNAL_SERVER_ERROR = "Internal Server Error"
+}
+export declare class CommonErrorTemplate extends Error {
+    code: number;
+    type: string;
+    constructor(msg: string, code?: number);
+    toJSON(): {
+        code: number;
+        type: string;
+        message: string;
+    };
+}
+export declare class ApiError extends CommonErrorTemplate {
+    constructor(msg: string, code?: number);
+}
+export declare class CustomError {
+    code: number | undefined;
+    type: string | undefined;
+    message: string | undefined;
+    stack: string | undefined;
+    errorObj: Error | undefined | null;
+    constructor(errObj?: any, code?: number, type?: string, message?: string, stack?: string);
+    toJSON(): {
+        code: number | undefined;
+        type: string | undefined;
+        message: string | undefined;
+    };
+}
+/**
+ * errorMapper - to map error object to custom error
+ */
+export declare const errorMapper: (err: any, statusCode?: number, type?: string) => any;
+/**
+ * throwError - to throw custome error
+ */
+export declare const throwError: (err: any, statusCode?: number, type?: string) => never;

package/dist/src/common/util/errorHandler.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = exports.errorMapper = exports.CustomError = exports.ApiError = exports.CommonErrorTemplate = exports.HTTP_STATUS_MAP = void 0;
+exports.HTTP_STATUS_MAP = new Map([
+    [500, 'Internal Server Error']
+]);
+class CommonErrorTemplate extends Error {
+    constructor(msg, code) {
+        super(msg);
+        this.code = code || 500 /* HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR */;
+        this.type =
+            exports.HTTP_STATUS_MAP.get(this.code) || "Internal Server Error" /* HTTP_STATUS_TYPE.INTERNAL_SERVER_ERROR */;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            type: this.type,
+            message: this.message,
+        };
+    }
+}
+exports.CommonErrorTemplate = CommonErrorTemplate;
+class ApiError extends CommonErrorTemplate {
+    constructor(msg, code) {
+        super(msg, code);
+        this.name = 'ApiError';
+        Error.captureStackTrace(this, ApiError);
+    }
+}
+exports.ApiError = ApiError;
+class CustomError {
+    constructor(errObj, code, type, message, stack) {
+        this.code = code;
+        this.type = type;
+        this.message = message;
+        this.stack = stack;
+        this.errorObj = errObj;
+    }
+    toJSON() {
+        // NOSONAR
+        return {
+            code: this.code,
+            type: this.type,
+            message: this.message,
+        };
+    }
+}
+exports.CustomError = CustomError;
+/**
+ * errorMapper - to map error object to custom error
+ */
+const errorMapper = (err, statusCode, type) => {
+    let error;
+    let customError;
+    let code = statusCode || 500 /* HTTP_STATUS_CODE.INTERNAL_SERVER_ERROR */;
+    let errorType = type || exports.HTTP_STATUS_MAP.get(code) || "Internal Server Error" /* HTTP_STATUS_TYPE.INTERNAL_SERVER_ERROR */;
+    if (typeof err === 'string') {
+        error = new Error(err);
+        customError = new CustomError(null, code, errorType, error.message, error.stack);
+        return customError;
+    }
+    else if (err.stack &&
+        err.message &&
+        !(err instanceof CustomError) &&
+        !err.toJSON) {
+        customError = new CustomError(null, code, errorType, err.message, err.stack);
+        return customError;
+    }
+    else {
+        return err;
+    }
+};
+exports.errorMapper = errorMapper;
+/**
+ * throwError - to throw custome error
+ */
+const throwError = (err, statusCode, type) => {
+    throw (0, exports.errorMapper)(err, statusCode, type);
+};
+exports.throwError = throwError;
+//# sourceMappingURL=errorHandler.js.map

package/dist/src/common/util/logger.d.ts

@@ -0,0 +1,68 @@
+export interface payLoadInterface {
+    statusCode?: number;
+    data?: any;
+}
+export interface LoggerInterface {
+    info(message: string, method: string): void;
+    warn(message: string, method: string, payload?: object): void;
+    error(message: string, method: string, payload?: object): void;
+    debug(message: string, method: string, payload?: object): void;
+}
+export declare class LoggerClass implements LoggerInterface {
+    private logger;
+    private infoLevel;
+    private debugLevel;
+    private errorLevel;
+    private warnLevel;
+    private blockedKeywords;
+    constructor();
+    /**
+     * It's written to handle JSON.circular error
+     * @param obj
+     * @returns
+     */
+    customstringify(obj: any): string;
+    /**
+     * for info log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    info(message: string, method: string): void;
+    /**
+     * for warn log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    warn(message: string, method: string, payload?: any): void;
+    /**
+     * for error log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    error(message: string, method: string, payload?: any): void;
+    /**
+     * for debug log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    debug(message: string, method: string, payload?: any): void;
+    /**
+     * to map log levels and handle from config
+     */
+    private mapLogLevels;
+    /**
+     * to sanitize logs from unwanted fields to be shown
+     * @param request
+     * @returns
+     */
+    private sanitizeLog;
+}
+export declare const Logger: LoggerClass;

package/dist/src/common/util/logger.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LoggerClass = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+const index_1 = __importDefault(require("../../config/index"));
+const bunyan_format_1 = __importDefault(require("bunyan-format"));
+const requestTracer_1 = require("./requestTracer");
+class LoggerClass {
+    constructor() {
+        this.infoLevel = false;
+        this.debugLevel = false;
+        this.errorLevel = false;
+        this.warnLevel = false;
+        this.blockedKeywords = ['currentPassword', 'clientSecret', 'newPassword'];
+        this.mapLogLevels();
+        this.logger = bunyan_1.default.createLogger({
+            name: index_1.default.APP_NAME,
+            level: 'trace', // by default enabling all levels, controlled through env separately
+            stream: (0, bunyan_format_1.default)({
+                outputMode: index_1.default.NODE_ENV === 'development' ? 'short' : 'bunyan',
+                levelInString: true,
+                color: true,
+            }),
+        });
+    }
+    /**
+     * It's written to handle JSON.circular error
+     * @param obj
+     * @returns
+     */
+    customstringify(obj) {
+        let cache = [];
+        let str = JSON.stringify(obj, (key, value) => {
+            {
+                if (typeof value === 'object' && value !== null) {
+                    if (cache.indexOf(value) !== -1) {
+                        // Circular reference found, discard key
+                        return;
+                    }
+                    // Store value in our collection
+                    cache.push(value);
+                }
+                return value;
+            }
+        });
+        cache = null; // reset the cache
+        return str;
+    }
+    /**
+     * for info log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    info(message, method) {
+        if (!this.infoLevel) {
+            return;
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+        };
+        this.logger.info(` start ${JSON.stringify(loggerParams)} ==end`);
+    }
+    /**
+     * for warn log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    warn(message, method, payload) {
+        if (!this.warnLevel) {
+            return;
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+            statusCode: payload === null || payload === void 0 ? void 0 : payload.statusCode,
+        };
+        let finalPayload = payload !== undefined ? payload : {};
+        this.logger.warn(` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(this.sanitizeLog(finalPayload))}==end`);
+    }
+    /**
+     * for error log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    error(message, method, payload) {
+        if (!this.errorLevel) {
+            return;
+        }
+        if (payload instanceof Error) {
+            payload = {
+                message,
+                method,
+                traceId: (0, requestTracer_1.getTraceId)(),
+                stack: payload === null || payload === void 0 ? void 0 : payload.stack,
+            };
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+            spanId: (0, requestTracer_1.getSpanId)(),
+            statusCode: payload === null || payload === void 0 ? void 0 : payload.statusCode,
+        };
+        let finalPayload = payload !== undefined ? payload : {};
+        this.logger.error(` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(this.sanitizeLog(finalPayload))}==end`);
+    }
+    /**
+     * for debug log
+     * @param message
+     * @param payload
+     * @param method
+     * @returns
+     */
+    debug(message, method, payload) {
+        if (!this.debugLevel) {
+            return;
+        }
+        let loggerParams = {
+            message,
+            method,
+            traceId: (0, requestTracer_1.getTraceId)(),
+            statusCode: payload === null || payload === void 0 ? void 0 : payload.statusCode,
+        };
+        let finalPayload = payload !== undefined ? payload : {};
+        this.logger.debug(` start ${JSON.stringify(loggerParams)} payload: ${this.customstringify(this.sanitizeLog(finalPayload))}==end`);
+    }
+    /**
+     * to map log levels and handle from config
+     */
+    mapLogLevels() {
+        if (index_1.default.LOG_LEVELS.length) {
+            index_1.default.LOG_LEVELS.forEach((element) => {
+                const logLevel = element.trim();
+                if (logLevel === 'info') {
+                    this.infoLevel = true;
+                }
+                else if (logLevel === 'debug') {
+                    this.debugLevel = true;
+                }
+                else if (logLevel === 'error') {
+                    this.errorLevel = true;
+                }
+                else if (logLevel === 'warn') {
+                    this.warnLevel = true;
+                }
+            });
+        }
+    }
+    /**
+     * to sanitize logs from unwanted fields to be shown
+     * @param request
+     * @returns
+     */
+    sanitizeLog(request) {
+        try {
+            if (request) {
+                Object.keys(request).forEach((key) => {
+                    let value = request[key];
+                    if (request[key] === 'options') {
+                        delete request.options;
+                    }
+                    else {
+                        if (this.blockedKeywords.find((blockedKey) => key.toLowerCase() === blockedKey.toLowerCase())) {
+                            request[key] = 'XXXXXXXXXX';
+                        }
+                        else {
+                            request[key] = value;
+                        }
+                    }
+                });
+                return request;
+            }
+        }
+        catch (err) {
+            this.error('Logger sanitize error', err);
+        }
+    }
+}
+exports.LoggerClass = LoggerClass;
+exports.Logger = new LoggerClass();
+//# sourceMappingURL=logger.js.map

package/dist/src/common/util/requestTracer.d.ts

@@ -0,0 +1,2 @@
+export declare const getTraceId: () => any;
+export declare const getSpanId: () => any;

package/dist/src/common/util/requestTracer.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpanId = exports.getTraceId = void 0;
+const cls_hooked_1 = __importDefault(require("cls-hooked"));
+const uuid_1 = require("uuid");
+const nsid = `rtracer:${(0, uuid_1.v4)()}`;
+const ns = cls_hooked_1.default.createNamespace(nsid);
+const traceIdKey = 'traceId';
+const spanIdKey = 'spanId';
+const getTraceId = () => ns.get(traceIdKey);
+exports.getTraceId = getTraceId;
+const getSpanId = () => ns.get(spanIdKey);
+exports.getSpanId = getSpanId;
+//# sourceMappingURL=requestTracer.js.map

package/dist/src/common/util/secretKeyManager.d.ts

@@ -0,0 +1,7 @@
+export declare class SecretKeyServices {
+    private ruleCache;
+    /**
+     * Fetches all the secret keys
+     */
+    getSecretKeys(): Promise<any>;
+}

package/dist/src/common/util/secretKeyManager.js

@@ -0,0 +1,58 @@
+"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.SecretKeyServices = void 0;
+const hep_secret_access_1 = require("hep-secret-access");
+const constants_1 = require("../../platform-x/constants");
+const config_1 = __importDefault(require("../../config"));
+class SecretKeyServices {
+    constructor() {
+        this.ruleCache = new Map();
+    }
+    /**
+     * Fetches all the secret keys
+     */
+    getSecretKeys() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Initialize secret manager object
+                if (this.ruleCache.has('secret_data')) {
+                    return this.ruleCache.get('secret_data');
+                }
+                const secretObject = (0, hep_secret_access_1.secretManager)();
+                // If secret mode is ENV – read one by one
+                // for local testing
+                if ((config_1.default === null || config_1.default === void 0 ? void 0 : config_1.default.SECRET_MODE) === 'env') {
+                    const keyConfig = {};
+                    for (const key of Object.values(constants_1.DynamicValues)) {
+                        // Fetch individual value (existing read() method)
+                        const value = yield secretObject.read(key);
+                        keyConfig[key] = value;
+                    }
+                    this.ruleCache.set('secret_data', keyConfig);
+                    return keyConfig;
+                }
+                // else – fetch all secrets from GSM
+                const data = yield secretObject.readAllSecrets();
+                this.ruleCache.set('secret_data', data);
+                return data;
+            }
+            catch (err) {
+                return {};
+            }
+        });
+    }
+}
+exports.SecretKeyServices = SecretKeyServices;
+//# sourceMappingURL=secretKeyManager.js.map

package/dist/src/config/index.d.ts

@@ -0,0 +1,22 @@
+declare const _default: {
+    LOG_LEVELS: string[];
+    APP_NAME: string;
+    NODE_ENV: string | undefined;
+    MONGO: {
+        HOST: string | undefined;
+        PORT: string | undefined;
+        DB_NAME: string | undefined;
+        USER: string | undefined;
+        PASS: string | undefined;
+    };
+    FCM: {
+        PROJECT: string | undefined;
+        TYPE: string | undefined;
+        AUTH_URI: string | undefined;
+        TOKEN_URI: string | undefined;
+        AUTH_PROVIDER_X509_CERT_URL: string | undefined;
+        UNIVERSE_DOMAIN: string | undefined;
+    };
+    SECRET_MODE: string;
+};
+export default _default;

package/dist/src/config/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const constants_1 = require("../platform-x/constants");
+dotenv_1.default.config();
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+exports.default = {
+    LOG_LEVELS: ((_a = process.env.LOG_LEVELS) === null || _a === void 0 ? void 0 : _a.split(',')) || [],
+    APP_NAME: process.env.npm_package_name || constants_1.DEFAULT_APP_NAME,
+    NODE_ENV: process.env.NODE_ENV,
+    MONGO: {
+        HOST: process.env.MONGO_HOST,
+        PORT: process.env.MONGO_PORT,
+        DB_NAME: process.env.MONGO_DB,
+        USER: process.env.MONGO_USER,
+        PASS: process.env.MONGO_PASS,
+    },
+    FCM: {
+        PROJECT: process.env.FCM_PROJECT,
+        TYPE: process.env.FCM_TYPE,
+        AUTH_URI: process.env.FCM_AUTH_URI,
+        TOKEN_URI: process.env.FCM_TOKEN_URI,
+        AUTH_PROVIDER_X509_CERT_URL: process.env.FCM_AUTH_PROVIDER_X509_CERT_URL,
+        UNIVERSE_DOMAIN: process.env.FCM_UNIVERSE_DOMAIN,
+    },
+    SECRET_MODE: process.env.SECRET_MODE || 'gsm',
+};
+//# sourceMappingURL=index.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+import { pushNotificationManager } from "./PushNotificationManager";
+export declare const initPushNotificationSecrets: (secretServiceIns: any) => void;
+export declare const getPushNotificationSecrets: () => any;
+export { pushNotificationManager };