@janiscommerce/app-push-notification 0.0.1-beta.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+[Unreleased]
+
+### Added
+
+- Added NotificationProvider (HOC) to receive notifications at background and foreground.\
+- Added github actions to deploy to npm

package/README.md

@@ -0,0 +1,118 @@
+# @janiscommerce/app-push-notification
+
+![janis-logo](brand-logo.png)
+
+Library for receiving notifications issued from firebase/janis.
+
+
+## PeerDependencies installation:
+
+In order to receive notifications it is necessary to include the dependency
+
+
+```javascript
+    npm install @react-native-firebase/messaging
+```
+
+## Installation:
+
+
+```javascript
+    npm install @janis-commerce/app-push-notification
+```
+
+
+## What is received from firebase?
+
+What is received is an object called RemoteMessage, which contains the data emitted from Firebase and is what triggers the notification listeners.
+Inside remoteMessage you get the notifications object that contains the information that we could use to render a component with the application in the foreground
+
+For more information about this, read https://rnfirebase.io/reference/messaging/remotemessage
+
+This library provides the following components and methods:
+
+## Functions
+
+<dl>
+<dt><a href="#useNotification">useNotification()</a> ⇒ <code>object</code></dt>
+<dd><p>is a hook, which returns the elements contained within the notifications context. Returns an object containing:</p>
+<table>
+<thead>
+<tr>
+<th>name</th>
+<th>description</th>
+</tr>
+</thead>
+<tbody><tr>
+<td>deviceToken</td>
+<td>is the token linked to the device, which we use to subscribe it to notifications.</td>
+</tr>
+</tbody></table>
+</dd>
+<dt><a href="#NotificationProvider">NotificationProvider(children, foregroundCallback, backgroundCallback, config, events, environment)</a> ⇒ <code>null</code> | <code>React.element</code></dt>
+<dd><p>It is the main component of the package, it is a HOC that is responsible for handling the logic of subscribing to notifications and receiving messages from the Firebase console. The HOC contains listeners to listen to notifications in the foreground and background, so (unless we cancel the subscription), we will receive notifications from the app even when it is closed.</p>
+</dd>
+</dl>
+
+<a name="useNotification"></a>
+
+## useNotification() ⇒ <code>object</code>
+is a hook, which returns the elements contained within the notifications context. Returns an object containing:
+| name | description |
+ |----------|----------|
+ | deviceToken  | is the token linked to the device, which we use to subscribe it to notifications. |
+
+**Kind**: global function  
+**Example**  
+```js
+import {useNotification} from '@janiscommerce/app-push-notification'
+
+const {} = useNotification()
+```
+<a name="NotificationProvider"></a>
+
+## NotificationProvider(children, foregroundCallback, backgroundCallback, config, events, environment) ⇒ <code>null</code> \| <code>React.element</code>
+It is the main component of the package, it is a HOC that is responsible for handling the logic of subscribing to notifications and receiving messages from the Firebase console. The HOC contains listeners to listen to notifications in the foreground and background, so (unless we cancel the subscription), we will receive notifications from the app even when it is closed.
+
+**Kind**: global function  
+**Throws**:
+
+- null when not receive a children argument
+
+
+| Param | Type | Description |
+| --- | --- | --- |
+| children | <code>React.element</code> | Component that will be rendered within the HOC, and about which the notification will be displayed |
+| foregroundCallback | <code>function</code> | function that will be executed when a foreground notification is received. |
+| backgroundCallback | <code>function</code> | function that will be executed when a background notification is received. |
+| config | <code>object</code> | It is an object that contains the user's data, which will be used to subscribe the user to notifications. |
+| config.appName | <code>string</code> | name of the aplication |
+| config.accessToken | <code>string</code> | accessToken provided by janis |
+| config.client | <code>string</code> | client provided by janis |
+| events | <code>Array.&lt;string&gt;</code> | is an array that will contain the events to which the user wants to subscribe |
+| environment | <code>string</code> | The environment is necessary for the API that we are going to use to subscribe the device to notifications. |
+
+**Example**  
+```js
+import NotificationProvider from '@janiscommerce/app-push-notification'
+
+
+//...
+
+const foregroundCallback = (remoteMessage) => console.log('a new FCM:',remoteMessage)
+const backgrounCallback = (remoteMessage) => {
+ console.log('a new FCM was received in background', remoteMessage)
+}
+
+return (
+ <NotificationProvider 
+   foregroundCallback={foregroundCallback}
+   backgroundCallback={backgroundCallback}
+   config={client:'fizzmod', accessToken:'access_token_push', appName:'janisAppName'}
+   events={['Notification','events','janis']}
+   environment='beta'
+   >
+   <MyComponent/>
+ </NotificationProvider>
+)
+```

package/lib/NotificationContext.js

@@ -0,0 +1,18 @@
+import React from 'react';
+
+export const NotificationContext = React.createContext(null);
+
+/**
+ * @function useNotification
+ * @description is a hook, which returns the elements contained within the notifications context. Returns an object containing:
+ * | name | description |
+ *  |----------|----------|
+ *  | deviceToken  | is the token linked to the device, which we use to subscribe it to notifications. |
+ * @returns {object}
+ * @example
+ * import {useNotification} from '@janiscommerce/app-push-notification'
+ * 
+ * const {} = useNotification()
+ */
+
+export const useNotification = () => React.useContext(NotificationContext);

package/lib/NotificationProvider/index.js

@@ -0,0 +1,116 @@
+import React, {useEffect, useState} from 'react';
+import {NotificationContext} from '../NotificationContext';
+import {
+  getFCMToken,
+  setupBackgroundMessageHandler,
+  setupForegroundMessageHandler,
+  DefaultAlert,
+  isFunction,
+  isString,
+  isObject,
+  isArray,
+  topicsSubscription,
+} from '../utils';
+
+/**
+ * @function NotificationProvider
+ * @description It is the main component of the package, it is a HOC that is responsible for handling the logic of subscribing to notifications and receiving messages from the Firebase console. The HOC contains listeners to listen to notifications in the foreground and background, so (unless we cancel the subscription), we will receive notifications from the app even when it is closed. 
+ * @param {React.element} children Component that will be rendered within the HOC, and about which the notification will be displayed
+ * @param {function} foregroundCallback function that will be executed when a foreground notification is received.
+ * @param {function} backgroundCallback function that will be executed when a background notification is received.
+ * @param {object} config It is an object that contains the user's data, which will be used to subscribe the user to notifications.
+ * @param {string} config.appName name of the aplication
+ * @param {string} config.accessToken accessToken provided by janis
+ * @param {string} config.client client provided by janis
+ * @param {Array<string>} events is an array that will contain the events to which the user wants to subscribe
+ * @param {string} environment The environment is necessary for the API that we are going to use to subscribe the device to notifications.
+ * @throws null when not receive a children argument
+ * @returns {null | React.element}
+ * @example
+ * 
+ * import NotificationProvider from '@janiscommerce/app-push-notification'
+ * 
+ * 
+ * //...
+ * 
+ * const foregroundCallback = (remoteMessage) => console.log('a new FCM:',remoteMessage)
+ * const backgrounCallback = (remoteMessage) => {
+ *  console.log('a new FCM was received in background', remoteMessage)
+ * }
+ * 
+ * return (
+ *  <NotificationProvider 
+ *    foregroundCallback={foregroundCallback}
+ *    backgroundCallback={backgroundCallback}
+ *    config={client:'fizzmod', accessToken:'access_token_push', appName:'janisAppName'}
+ *    events={['Notification','events','janis']}
+ *    environment='beta'
+ *    >
+ *    <MyComponent/>
+ *  </NotificationProvider>
+ * )
+ */
+
+const NotificationProvider = ({
+  children,
+  foregroundCallback,
+  backgroundCallback,
+  config,
+  events,
+  environment,
+}) => {
+  if (!children) return null;
+
+  const [deviceToken, setDeviceToken] = useState(null);
+  const validForegroundCallback = isFunction(foregroundCallback)
+    ? foregroundCallback
+    : DefaultAlert;
+  const validBackgroundCallback = isFunction(backgroundCallback)
+    ? backgroundCallback
+    : /* istanbul ignore next */ (remoteMessage) => remoteMessage;
+  const validConfig = config && isObject(config) ? config : {};
+  const validEvents = events && isArray(events) ? events : [];
+
+  // eslint-disable-next-line no-unused-vars
+  const parsedConfig = {...validConfig, environment, events: validEvents};
+
+  const getDeviceToken = async () => {
+    const fcmToken = await getFCMToken();
+    if (!fcmToken || !isString(fcmToken)) return null;
+
+    setDeviceToken(fcmToken)
+    return fcmToken;
+  };
+
+  // eslint-disable-next-line
+  const registerDevice = async () => {
+    const newDeviceToken = await getDeviceToken();
+
+    if (!newDeviceToken) return null;
+    // eslint-disable-next-line
+    validEvents.forEach(async (event) => {
+      if (!event || !isString(event)) return null;
+      await topicsSubscription(event);
+    });
+  };
+
+  useEffect(() => {
+    registerDevice();
+    const foregroundMessageHandler = setupForegroundMessageHandler(
+      validForegroundCallback,
+    );
+
+    return () => {
+      foregroundMessageHandler();
+      setupBackgroundMessageHandler(validBackgroundCallback);
+    };
+  }, []);
+
+  return (
+    <NotificationContext.Provider value={{deviceToken}}>
+      {children}
+    </NotificationContext.Provider>
+  );
+};
+
+export default NotificationProvider;

package/lib/index.js

@@ -0,0 +1,6 @@
+import NotificationProvider from './NotificationProvider';
+import {useNotification} from './NotificationContext';
+import {topicsSubscription, topicsUnsubscription} from './utils';
+
+export {useNotification, topicsSubscription, topicsUnsubscription};
+export default NotificationProvider;

package/lib/utils/api/SubscribeNotifications/index.js

@@ -0,0 +1,43 @@
+import axios from 'axios';
+import {isString, isArray, validateOauthData, getHeaders} from '../../index';
+
+const SubscribeNotifications = async (params = {}) => {
+  try {
+    if (!params || !Object.keys(params).length)
+      throw new Error('params is not a valid object');
+
+    const {client, accessToken, deviceToken, events, appName, environment} =
+      params;
+
+    if (!validateOauthData(accessToken, client))
+      throw new Error('accessToken and client are required');
+    if (!deviceToken || !isString(deviceToken))
+      throw new Error('device token is invalid or null');
+    if (!events || !isArray(events))
+      throw new Error('events to be subscribed to are null');
+    if (!appName || !isString(appName))
+      throw new Error('application name are invalid or null');
+    if (!environment || !isString(environment))
+      throw new Error('environment is invalid or null');
+
+    const parsedEvents = events.filter((event) => !!event && isString(event));
+    if (!parsedEvents.length)
+      throw new Error('events to be suscribed are invalids');
+
+    const headers = getHeaders({client, accessToken});
+    const validUrl = `https://notifications.${environment}.in/api/push/register`;
+    const body = {
+      deviceToken,
+      events: parsedEvents,
+      platformApplicationName: appName,
+    };
+
+    const {data} = await axios.post(validUrl, body, {headers});
+
+    return data;
+  } catch (error) {
+    return Promise.reject(error?.response?.data?.message || error);
+  }
+};
+
+export default SubscribeNotifications;

package/lib/utils/index.js

@@ -0,0 +1,366 @@
+import {Alert} from 'react-native';
+import messaging from '@react-native-firebase/messaging';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import DeviceInfo from 'react-native-device-info';
+
+// Helpers
+
+/**
+ * @function isFunction
+ * @param {function} fn
+ * @description return true or false if arg is a valid function
+ * @returns {bool}
+ * @example
+ * import {isFunction} from '@janiscommerce/apps-helpers'
+ * isFunction(() => true) // true
+ */
+export const isFunction = (fn) =>
+  !!({}.toString.call(fn) === '[object Function]');
+
+/**
+ * @function isString
+ * @param {string} str - String to validate.
+ * @description If the type of the argument is a string, return true, otherwise return false.
+ * @returns {bool}
+ * @example
+ * import {isString} from '@janiscommerce/apps-helpers'
+ * isString('Janis') // true
+ */
+
+export const isString = (str) => !!(typeof str === 'string');
+
+/**
+ * @function isObject
+ * @param {object} obj
+ * @description return true or false if arg is a valid object
+ * @returns {bool}
+ * @example
+ * import {isObject} from '@janiscommerce/apps-helpers'
+ * isObject('Janis') // false
+ */
+export const isObject = (obj) => !!(obj && obj.constructor === Object);
+
+/**
+ * @function isNumber
+ * @param {number} num
+ * @description return true or false if arg is a valid number
+ * @returns {bool}
+ * @example
+ * import {isNumber} from '@janiscommerce/apps-helpers'
+ * isNumber('Janis') // false
+ */
+export const isNumber = (num) =>
+  typeof num === 'number' && !Number.isNaN(Number(num));
+
+/**
+ * @function isBoolean
+ * @param {boolean} fn
+ * @description return true or false if arg is a valid boolean
+ * @returns {bool}
+ * @example
+ * import {isBoolean} from '@janiscommerce/apps-helpers'
+ * isBoolean((true) // true
+ */
+export const isBoolean = (bool) => typeof bool === 'boolean';
+
+/**
+ * @function isArray
+ * @param {array} arr
+ * @description return true or false if arg is a valid array
+ * @returns {bool}
+ * @example
+ * import {isArray} from '@janiscommerce/apps-helpers'
+ * isArray(['Janis']) // true
+ */
+export const isArray = (arr) => !!(arr instanceof Array);
+
+/**
+ * @function validateOauthData
+ * @param {string} accessToken
+ * @param {string} client
+ * @returns {boolean} - true or false
+ * @example validateOauthData([], 'fizzmodarg') => false
+ * @example validateOauthData('34234sdfrdf', 'fizzmodarg') => true
+ */
+export const validateOauthData = (accessToken, client) => {
+  if (!accessToken || !client) return false;
+  if (!isString(accessToken) || !isString(client)) return false;
+  return true;
+};
+
+export const formatDeviceDataForUserAgent = (deviceData) => {
+  if (!isObject(deviceData) || !Object.keys(deviceData).length) return {};
+
+  const keysToCheck = [
+    'janis-app-package-name',
+    'janis-app-version',
+    'janis-app-name',
+    'janis-app-build',
+    'janis-app-device-os-name',
+    'janis-app-device-os-version',
+    'janis-app-device-id',
+    'janis-app-device-name',
+  ];
+
+  const hasSomeValidValues = keysToCheck.some(
+    (key) => isString(deviceData[key]) && !!deviceData[key],
+  );
+
+  if (!hasSomeValidValues) return {};
+
+  const userAgentParts = [];
+
+  keysToCheck.forEach((key) => {
+    const value =
+      !deviceData[key] || !isString(deviceData[key])
+        ? `unknown ${key}`
+        : deviceData[key];
+    userAgentParts.push(value);
+  });
+
+  return {
+    'user-agent': `${userAgentParts[0]}/${userAgentParts[1]} (${userAgentParts[2]}; ${userAgentParts[3]}) ${userAgentParts[4]}/${userAgentParts[5]} (${userAgentParts[6]}; ${userAgentParts[7]})`,
+  };
+};
+
+/**
+ * @function getDeviceData
+ * @description return data from device user
+ * @returns {{
+ * 'application-name': string,
+ * 'build-number': string,
+ * 'app-version': string,
+ * 'bundle-id': string,
+ * 'os-name': string,
+ * 'device-id': string,
+ * 'device-name': string
+ * }} - Object with device data
+ * @example getDeviceData() => {applicationName: 'AppName', buildNumber: '434', appVersion: '1.5.0', bundleId: 'com.janis.appname', osName: 'android', osVersion: '11', deviceId: '34hf83hf89ahfjo', deviceName: 'Pixel 2'}
+ */
+
+export const getDeviceData = () => {
+  const applicationName = DeviceInfo.getApplicationName() || '';
+  const buildNumber = DeviceInfo.getBuildNumber() || '';
+  const appVersion = DeviceInfo.getVersion() || '';
+  const bundleId = DeviceInfo.getBundleId() || '';
+  const osName = DeviceInfo.getSystemName() || '';
+  const osVersion = DeviceInfo.getSystemVersion() || '';
+  const deviceId = DeviceInfo.getUniqueId() || '';
+  const deviceName = DeviceInfo.getModel() || '';
+
+  return {
+    'janis-app-name': applicationName,
+    'janis-app-build': buildNumber,
+    'janis-app-version': appVersion,
+    'janis-app-package-name': bundleId,
+    'janis-app-device-os-name': osName,
+    'janis-app-device-os-version': osVersion,
+    'janis-app-device-id': deviceId,
+    'janis-app-device-name': deviceName,
+  };
+};
+
+const filterValidHeaders = (headers) => {
+  if (!headers || !isObject(headers) || !Object.keys(headers).length) return {};
+
+  return Object.fromEntries(
+    Object.entries(headers).filter(([, value]) => !!value && !!isString(value)),
+  );
+};
+
+/**
+ * @function getHeaders
+ * @param {object} [params={}] - object with params
+ * @param {object} [deviceDataHeaders={}] - headers with the device info
+ * @param {object} [customHeaders={}] - extra custom headers
+ * @param {string} params.client - client name for janis api
+ * @param {string} params.accessToken - access token for janis api
+ * @param {number} params.page - number of page
+ * @param {number} params.pageSize - quantity per page
+ * @param {boolean} params.getTotals - request api totals
+ * @param {boolean} params.getOnlyTotals - request api totals without body response
+ * @description get correct headers for janis api
+ * @returns {object}
+ * @example
+ * const params = {
+ *   client: 'my-client',
+ *   accessToken: 'my-access-token',
+ *   page: 1,
+ *   pageSize: 10,
+ *   getTotals: true,
+ *   getOnlyTotals: false
+ * };
+ * const deviceDataHeaders = {
+ *   'janis-app-name': 'MyApp',
+ *   'janis-app-version': '1.0.0',
+ *   'janis-app-device-os-name': 'iOS',
+ *   'janis-app-device-os-version': '14.5',
+ *   'janis-app-device-name': 'iPhone 12',
+ *   'janis-app-device-id': '123456789'
+ * };
+ * const customHeaders = {
+ *   'custom-header': 'custom-value'
+ * };
+ * const headers = getHeaders(params, deviceDataHeaders, customHeaders);
+ * // {
+ * //   'content-Type': 'application/json',
+ * //   'janis-api-key': 'Bearer',
+ * //   'janis-client': 'my-client',
+ * //   'janis-api-secret': 'my-access-token',
+ * //   'x-janis-page': 1,
+ * //   'x-janis-page-size': 10,
+ * //   'x-janis-totals': true,
+ * //   'x-janis-only-totals': false,
+ * //   'user-agent': 'MyApp/1.0.0 (iOS 14.5; iPhone 12; 123456789)',
+ * //   'custom-header': 'custom-value'
+ * // }
+ */
+
+export const getHeaders = (params = {}, customHeaders = {}) => {
+  const deviceDataHeaders = getDeviceData();
+
+  const validCustomHeaders = filterValidHeaders(customHeaders);
+  const validDeviceDataHeaders = filterValidHeaders(deviceDataHeaders);
+  const validUserAgentHeader = formatDeviceDataForUserAgent(
+    validDeviceDataHeaders,
+  );
+
+  const baseHeaders = {
+    'content-Type': 'application/json',
+    'janis-api-key': 'Bearer',
+    ...validUserAgentHeader,
+    ...validDeviceDataHeaders,
+    ...validCustomHeaders,
+  };
+
+  if (!isObject(params)) return baseHeaders;
+  const {client, accessToken, page, pageSize, getTotals, getOnlyTotals} =
+    params;
+
+  return {
+    ...baseHeaders,
+    ...(isString(client) && client && {'janis-client': client}),
+    ...(isString(accessToken) &&
+      accessToken && {'janis-api-secret': accessToken}),
+    ...(isNumber(page) && page && {'x-janis-page': page}),
+    ...(isNumber(pageSize) && pageSize && {'x-janis-page-size': pageSize}),
+    ...(isBoolean(getTotals) && getTotals && {'x-janis-totals': getTotals}),
+    ...(isBoolean(getOnlyTotals) &&
+      getOnlyTotals && {'x-janis-only-totals': getOnlyTotals}),
+  };
+};
+
+// MESSAGING UTILS
+
+/**
+ * @function getFCMToken
+ * @description This function is responsible for generating an fmc token or obtaining it from storage if one already exists. If it cannot be obtained, it will return an empty string
+ * @returns {Promise<string>}
+ * @example
+ *
+ * getFCMToken() => JDF6GJS364uhaGGe384gJHIQs23nbRNFG2859gJSD9gBivajeSJD
+ */
+
+export const getFCMToken = async () => {
+  try {
+    const fcmToken = await AsyncStorage.getItem('fcmtoken');
+
+    if (!fcmToken) {
+      const newFcmToken = await messaging().getToken();
+
+      if (newFcmToken) {
+        await AsyncStorage.setItem('fcmtoken', newFcmToken);
+        return newFcmToken;
+      }
+    }
+
+    return fcmToken || '';
+  } catch (error) {
+    console.error('error', error.message);
+
+    return '';
+  }
+};
+
+// esto actualmente no funciona con la versión RN de picking. Pero será necesario eventualemnte.
+// A partir de la versión 13 (api >= 33 ) de android el usuario tiene que otorgar los permisos manualmente.
+// por lo que deberemos agregarlo dentro del package futuro y sumarlo a picking una vez que esté actualizado.
+
+// export const requestUserPermission = async () => {
+//   const permission = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+
+//   return permission;
+// };
+
+/** *
+ * @function setupForegroundMessageHandler
+ * @description This function is responsible for handling any callbacks from Firebase cloud messaging in the foreground and rendering them using a callback
+ * @param {Function} callback is the function that will receive the payload and render it as appropriate
+ */
+
+export const setupForegroundMessageHandler = (callback) =>
+  messaging().onMessage(async (remoteMessage) => {
+    callback(remoteMessage);
+  });
+
+/** *
+ * @function setupBackgroundMessageHandler
+ * @description This function is responsible for handling any callbacks from Firebase cloud messaging in the background or with the application closed
+ * @param {Function} callback is the function that will receive the payload and render it as appropriate
+ */
+
+export const setupBackgroundMessageHandler = (callback) =>
+  messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+    callback(remoteMessage);
+  });
+
+/** *
+ * @name DefaultAlert
+ * @description a default alert component to be used when a foregroundCallback function is not passed by parameters
+ * @param {object} remoteMessage the object that was received from fcm
+ * @throws null when not receive a valid object as remoteMessage
+ * @returns an alert with title and body received from FCM remoteMessage
+ *
+ */
+
+export const DefaultAlert = (remoteMessage = {}) => {
+  if (!remoteMessage || !Object.keys(remoteMessage).length) return null;
+
+  const {notification = {}} = remoteMessage;
+  const {title, body} = notification;
+
+  const validTitle = isString(title) ? title : 'A new FCM message arrived!';
+  const validateBody = isString(body) ? body : undefined;
+
+  return Alert.alert(validTitle, validateBody);
+};
+
+/* istanbul ignore next */
+export const topicsSubscription = async (topics) => {
+  try {
+    if (!topics || !isString(topics)) return null;
+
+    await messaging().subscribeToTopic(topics);
+
+    return {message: `suscribed to ${topics} topic!`};
+  } catch (reason) {
+    console.error(reason?.message);
+
+    return Promise.reject(reason?.message);
+  }
+};
+
+/* istanbul ignore next */
+export const topicsUnsubscription = async (topic) => {
+  try {
+    if (!topic || !isString(topic)) return null;
+
+    await messaging().unsubscribeFromTopic(topic);
+
+    return {message: `unsuscribed to ${topic} topic!`};
+  } catch (reason) {
+    console.error(reason?.message);
+
+    return Promise.reject(reason?.message);
+  }
+};

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@janiscommerce/app-push-notification",
+  "version": "0.0.1-beta.1",
+  "type": "commonjs",
+  "description": "This package will take care of performing the main actions for registration to receive notifications in the foreground and background.",
+  "main": "lib/index.js",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint .",
+    "build-docs": "jsdoc2md --template template-readme.hbs --files lib/*.js  lib/NotificationProvider/*.js > README.md",
+    "test:coverage": "jest --collectCoverage",
+    "validate:code": "npm run lint -- --fix  && jest --collectCoverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/janis-commerce/app-push-notification.git"
+  },
+  "files": [
+    "lib/"
+  ],
+  "keywords": [
+    "janis",
+    "janiscommerce",
+    "app",
+    "pushnotification"
+  ],
+  "author": "Janis",
+  "license": "ISC",
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.18.1",
+    "@react-native-firebase/app": "^18.3.1",
+    "@react-native-firebase/messaging": "^18.3.1",
+    "axios": "^1.3.6",
+    "react-native-device-info": "^10.12.0"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.2 <=18.2.0",
+    "react-native": ">=0.67.5 <=0.72.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.23.6",
+    "@babel/eslint-parser": "^7.5.4",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+    "@babel/preset-env": "^7.22.10",
+    "@babel/runtime": "^7.12.5",
+    "@react-native-community/eslint-config": "^2.0.0",
+    "@react-native-firebase/app": "^18.3.1",
+    "@react-native-firebase/messaging": "^18.3.1",
+    "@testing-library/react-native": "^12.0.1",
+    "babel-jest": "^28.0.0",
+    "babel-loader": "8.2.4",
+    "eslint": "^8.56.0",
+    "eslint-config-airbnb": "^18.2.1",
+    "eslint-config-prettier": "^8.1.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jsx-a11y": "^6.4.1",
+    "eslint-plugin-prettier": "^3.3.1",
+    "eslint-plugin-react": "^7.22.0",
+    "eslint-plugin-react-hooks": "^4.2.0",
+    "husky": "^4.3.8",
+    "jest": "^28.0.0",
+    "jsdoc-babel": "^0.5.0",
+    "jsdoc-to-markdown": "^8.0.0",
+    "lint-staged": "^10.5.4",
+    "metro-react-native-babel-preset": "^0.66.2",
+    "nock": "^13.0.11",
+    "prettier": "^2.4.1",
+    "react": "^17.0.2",
+    "react-native": "^0.67.5",
+    "react-test-renderer": "^17.0.2"
+  },
+  "bugs": {
+    "url": "https://github.com/janis-commerce/app-push-notification/issues"
+  },
+  "homepage": "https://github.com/janis-commerce/app-push-notification#readme"
+}