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

package/CHANGELOG.md

@@ -2,7 +2,10 @@
 
 [Unreleased]
 
+## [0.0.1] - 2024-05-03
+
 ### Added
 
-- Added NotificationProvider (HOC) to receive notifications at background and foreground.\
-- Added github actions to deploy to npm
+- NotificationProvider (HOC) to receive notifications at background and foreground
+- Github actions to deploy to npm
+- Callback to handle notification

package/README.md

@@ -29,12 +29,18 @@ Inside remoteMessage you get the notifications object that contains the informat
 
 For more information about this, read https://rnfirebase.io/reference/messaging/remotemessage
 
-This library provides the following components and methods:
+# This library provides the following components and methods:
 
 ## Functions
 
 <dl>
-<dt><a href="#useNotification">useNotification()</a> ⇒ <code>object</code></dt>
+<dt><a href="#NotificationProvider">NotificationProvider(children, appName, 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>
+<dt><a href="#setupBackgroundMessageHandler">setupBackgroundMessageHandler(callback)</a></dt>
+<dd><p>This function is responsible for handling any callbacks from Firebase cloud messaging in the background or with the application closed</p>
+</dd>
+<dt><a href="#usePushNotification">usePushNotification()</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>
@@ -45,33 +51,43 @@ This library provides the following components and methods:
 </thead>
 <tbody><tr>
 <td>deviceToken</td>
-<td>is the token linked to the device, which we use to subscribe it to notifications.</td>
+<td>Is the token linked to the device, which we use to subscribe it to notifications.</td>
+</tr>
+<tr>
+<td>foregroundNotification</td>
+<td>An object containing all data received when a foreground push notification is triggered.</td>
+</tr>
+<tr>
+<td>backgroundNotification</td>
+<td>An object containing all data received when a background push notification is triggered.</td>
+</tr>
+<tr>
+<td>subscribeError</td>
+<td>An object containing all data received from a notification service subscription failure.</td>
+</tr>
+<tr>
+<td>cancelNotifications</td>
+<td>This util is responsible for making the request to unsubscribe from all notification events. If no arguments are received, the request will be made with the previously registered events.</td>
+</tr>
+<tr>
+<td>addNewEvent</td>
+<td>This function allows you to add a new event to receive notifications.</td>
+</tr>
+<tr>
+<td>deleteReceivedNotification</td>
+<td>An util that clears the foreground or background notification state to the depending on the type it receives by parameter</td>
+</tr>
+<tr>
+<td>getSubscribedEvents</td>
+<td>This function returns an array with the events to which the user is subscribed.</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>
+## NotificationProvider(children, appName, 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  
@@ -83,12 +99,7 @@ It is the main component of the package, it is a HOC that is responsible for han
 | 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 |
+| appName | <code>string</code> | name of the aplication |
 | 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. |
 
@@ -96,23 +107,46 @@ It is the main component of the package, it is a HOC that is responsible for han
 ```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']}
+ <NotificationProvider
+   appName='pickingApp'
+   events={["picking:session:created","picking:session:assigned"]}
    environment='beta'
    >
    <MyComponent/>
  </NotificationProvider>
 )
 ```
+<a name="setupBackgroundMessageHandler"></a>
+
+## setupBackgroundMessageHandler(callback)
+This function is responsible for handling any callbacks from Firebase cloud messaging in the background or with the application closed
+
+**Kind**: global function  
+
+| Param | Type | Description |
+| --- | --- | --- |
+| callback | <code>function</code> | is the function that will receive the payload and render it as appropriate |
+
+<a name="usePushNotification"></a>
+
+## usePushNotification() ⇒ <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. |
+ | foregroundNotification | An object containing all data received when a foreground push notification is triggered. |
+ | backgroundNotification | An object containing all data received when a background push notification is triggered. |
+ | subscribeError | An object containing all data received from a notification service subscription failure. |
+ | cancelNotifications | This util is responsible for making the request to unsubscribe from all notification events. If no arguments are received, the request will be made with the previously registered events. |
+ | addNewEvent | This function allows you to add a new event to receive notifications. |
+ | deleteReceivedNotification | An util that clears the foreground or background notification state to the depending on the type it receives by parameter
+ | getSubscribedEvents | This function returns an array with the events to which the user is subscribed. |
+
+**Kind**: global function  
+**Example**  
+```js
+import {usePushNotification} from '@janiscommerce/app-push-notification'
+
+const { deviceToken, foregroundNotification, backgroundNotification} = usePushNotification()
+```

package/lib/NotificationContext.js

@@ -2,17 +2,30 @@ import React from 'react';
 
 export const NotificationContext = React.createContext(null);
 
+/** *
+ * @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
+ */
+
 /**
- * @function useNotification
+ * @function usePushNotification
  * @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. |
+ *  | deviceToken | Is the token linked to the device, which we use to subscribe it to notifications. |
+ *  | foregroundNotification | An object containing all data received when a foreground push notification is triggered. |
+ *  | backgroundNotification | An object containing all data received when a background push notification is triggered. |
+ *  | subscribeError | An object containing all data received from a notification service subscription failure. |
+ *  | cancelNotifications | This util is responsible for making the request to unsubscribe from all notification events. If no arguments are received, the request will be made with the previously registered events. |
+ *  | addNewEvent | This function allows you to add a new event to receive notifications. |
+ *  | deleteReceivedNotification | An util that clears the foreground or background notification state to the depending on the type it receives by parameter
+ *  | getSubscribedEvents | This function returns an array with the events to which the user is subscribed. |
  * @returns {object}
  * @example
- * import {useNotification} from '@janiscommerce/app-push-notification'
- * 
- * const {} = useNotification()
+ * import {usePushNotification} from '@janiscommerce/app-push-notification'
+ *
+ * const { deviceToken, foregroundNotification, backgroundNotification} = usePushNotification()
  */
 
-export const useNotification = () => React.useContext(NotificationContext);
+export const usePushNotification = () => React.useContext(NotificationContext);

package/lib/NotificationProvider/index.js

@@ -1,49 +1,32 @@
-import React, {useEffect, useState} from 'react';
+import React, {useEffect, useRef} from 'react';
+import messaging from '@react-native-firebase/messaging';
 import {NotificationContext} from '../NotificationContext';
 import {
-  getFCMToken,
-  setupBackgroundMessageHandler,
-  setupForegroundMessageHandler,
-  DefaultAlert,
-  isFunction,
   isString,
-  isObject,
   isArray,
-  topicsSubscription,
+  setupForegroundMessageHandler,
+  setupNotificationOpenedHandler,
+  isObject,
 } from '../utils';
+import usePushNotification from '../usePushNotification';
 
 /**
  * @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. 
+ * @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 {string} appName name of the aplication
  * @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']}
+ *  <NotificationProvider
+ *    appName='pickingApp'
+ *    events={["picking:session:created","picking:session:assigned"]}
  *    environment='beta'
  *    >
  *    <MyComponent/>
@@ -51,63 +34,88 @@ import {
  * )
  */
 
-const NotificationProvider = ({
-  children,
-  foregroundCallback,
-  backgroundCallback,
-  config,
-  events,
-  environment,
-}) => {
+const NotificationProvider = ({children, appName, 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;
+  const validAppName = !!appName && isString(appName) ? appName : '';
+  const validEnvironment =
+    !!environment && isString(environment) ? environment : '';
+  const validEvents = !!events && isArray(events) ? events : [];
+
+  const isRegistered = useRef(false);
+  const {
+    registerDeviceToNotifications,
+    updateNotificationState,
+    pushEvents,
+    ...rest
+  } = usePushNotification(
+    validEnvironment,
+    validEvents,
+    validAppName,
+    isRegistered,
+  );
+
+  // @function handlerForegroundData
+  // @description This function is responsible for updating the state corresponding to 'foregroundNotification' with the data it receives as an argument
+
+  /* istanbul ignore next */
+  const handlerForegroundData = (data) => {
+    if (!data || !isObject(data)) return null;
+
+    return updateNotificationState({foregroundNotification: data});
+  };
+
+  // @function handlerBackgroundData
+  // @description This function is responsible for updating the state corresponding to 'backgroundNotification' with the data it receives as an argument
+
+  /* istanbul ignore next */
+  const handlerBackgroundData = (data) => {
+    if (!data || !isObject(data)) return null;
+
+    return updateNotificationState({backgroundNotification: data});
   };
 
-  // eslint-disable-next-line
-  const registerDevice = async () => {
-    const newDeviceToken = await getDeviceToken();
+  // @function handleAppOpeningByNotification
+  // @description This function is responsible for saving the information of the notification that forced the opening of the app in the 'backgroundNotification' state
+
+  /* istanbul ignore next */
+  const handleAppOpeningByNotification = async () => {
+    const data = await messaging().getInitialNotification();
+
+    if (!data || !isObject(data)) return null;
 
-    if (!newDeviceToken) return null;
-    // eslint-disable-next-line
-    validEvents.forEach(async (event) => {
-      if (!event || !isString(event)) return null;
-      await topicsSubscription(event);
-    });
+    return updateNotificationState({backgroundNotification: data});
   };
 
   useEffect(() => {
-    registerDevice();
+    const alreadySuscribed = isRegistered.current;
+    if (environment && appName && !!pushEvents.length && !alreadySuscribed) {
+      registerDeviceToNotifications();
+    }
+  }, [pushEvents]);
+
+  /* istanbul ignore next */
+  useEffect(() => {
     const foregroundMessageHandler = setupForegroundMessageHandler(
-      validForegroundCallback,
+      handlerForegroundData,
+    );
+    const backgroundMessageHandler = setupNotificationOpenedHandler(
+      handlerBackgroundData,
     );
+    handleAppOpeningByNotification();
 
     return () => {
       foregroundMessageHandler();
-      setupBackgroundMessageHandler(validBackgroundCallback);
+      backgroundMessageHandler();
     };
   }, []);
 
+  const contextValues = {
+    ...rest,
+  };
+
   return (
-    <NotificationContext.Provider value={{deviceToken}}>
+    <NotificationContext.Provider value={contextValues}>
       {children}
     </NotificationContext.Provider>
   );

package/lib/index.js

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

package/lib/usePushNotification.js

@@ -0,0 +1,167 @@
+import {useCallback, useState} from 'react';
+import RequestInstance from '@janiscommerce/app-request';
+import {getFCMToken, isArray, isString} from './utils';
+import SubscribeNotifications from './utils/api/SubscribeNotifications';
+import UnSubscribeNotifications from './utils/api/UnSubscribeNotifications';
+
+const usePushNotification = (environment, events, appName, isRegistered) => {
+  const [notificationState, setNotificationState] = useState({
+    deviceToken: null,
+    foregroundNotification: {},
+    backgroundNotification: {},
+    pushEvents: events,
+    subscribeError: {},
+  });
+
+  const {
+    deviceToken,
+    foregroundNotification,
+    backgroundNotification,
+    pushEvents,
+    subscribeError,
+  } = notificationState;
+
+  const Request = new RequestInstance({JANIS_ENV: environment});
+
+  const updateNotificationState = (state) =>
+    setNotificationState({...notificationState, ...state});
+
+  const getSubscribedEvents = () => pushEvents;
+
+  const getDeviceToken = async () => {
+    if (deviceToken) return deviceToken;
+
+    const fcmToken = await getFCMToken();
+    if (!fcmToken || !isString(fcmToken)) return null;
+
+    return fcmToken;
+  };
+
+  /**
+   * @function registerDeviceToNotifications
+   * @description This function is responsible for registering the device to the notification microservice.
+   * @returns {null}
+   */
+
+  const registerDeviceToNotifications = useCallback(async () => {
+    const token = await getDeviceToken();
+
+    if (!token) return null;
+
+    try {
+      await SubscribeNotifications({
+        appName,
+        events: pushEvents,
+        deviceToken: token,
+        request: Request,
+      });
+
+      isRegistered.current = true;
+      return updateNotificationState({deviceToken: token, pushEvents});
+    } catch (error) {
+      return updateNotificationState({pushEvents: [], subscribeError: error});
+    }
+  }, [pushEvents]);
+
+  /**
+   * @function cancelNotifications
+   * @description This util is responsible for making the request to unsubscribe from all notification events. If no arguments are received, the request will be made with the previously registered events.
+   * @param {Array<string>} events is the list of events to which I want to unsubscribe the device
+   * @returns {Promise}
+   *
+   * @example
+   *
+   * import {usePushNotification} from '@janiscommerce/app-push-notification
+   *
+   * const {cancelNotifications} = usePushNotification()
+   */
+
+  const cancelNotifications = async (cancelEvents) => {
+    const eventsAreValid = cancelEvents && isArray(cancelEvents);
+    const eventsToCancel = eventsAreValid ? cancelEvents : pushEvents;
+    try {
+      await UnSubscribeNotifications({
+        events: eventsToCancel,
+        request: Request,
+      });
+
+      if (eventsAreValid) {
+        const updatedEvents = pushEvents.filter(
+          (e) => !eventsToCancel.includes(e),
+        );
+
+        isRegistered.current = true;
+        return updateNotificationState({pushEvents: updatedEvents});
+      }
+
+      isRegistered.current = false;
+      return updateNotificationState({pushEvents: []});
+    } catch (unsubscribeError) {
+      return Promise.reject(unsubscribeError);
+    }
+  };
+
+  /**
+   * @function deleteReceivedNotification
+   * @description This utility allows you to reset the state corresponding to the type of notification received as an argument.
+   * @param {string} notificationType the type of notification you want to delete, it can be a foreground or background notification
+   * @returns {null}
+   *
+   * @example
+   * import {usePushNotification} from '@janiscommerce/app-push-notification
+   *
+   * const {deleteReceivedNotification} = usePushNotification()
+   *
+   * const resetForegroundNotification = () => {
+   *  deleteReceivedNotification('foreground')
+   * }
+   */
+
+  const deleteReceivedNotification = (params = {}) => {
+    const {type = ''} = params;
+    const allowTypes = ['foreground', 'background'];
+    const deleteNotification = {
+      foreground: () => updateNotificationState({foregroundNotification: {}}),
+      background: () => updateNotificationState({backgroundNotification: {}}),
+    };
+
+    if (!type || !allowTypes.includes(type)) return null;
+
+    const restartNotification = deleteNotification[type];
+
+    return restartNotification();
+  };
+
+  /**
+   * @function addNewEvent
+   * @description This function allows you to add a new event to receive notifications
+   * @param {string} event
+   */
+
+  const addNewEvent = (event) => {
+    if (!event || !isString(event)) return null;
+    if (pushEvents.includes(event)) {
+      return null;
+    }
+
+    const updatedEvents = [...pushEvents, event];
+    isRegistered.current = false;
+    return updateNotificationState({pushEvents: updatedEvents});
+  };
+
+  return {
+    deviceToken,
+    foregroundNotification,
+    backgroundNotification,
+    subscribeError,
+    cancelNotifications,
+    addNewEvent,
+    pushEvents,
+    registerDeviceToNotifications,
+    updateNotificationState,
+    getSubscribedEvents,
+    deleteReceivedNotification,
+  };
+};
+
+export default usePushNotification;

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

@@ -1,42 +1,40 @@
-import axios from 'axios';
-import {isString, isArray, validateOauthData, getHeaders} from '../../index';
+import {isString, isArray} 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;
+    const {deviceToken, events, appName, request} = 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');
+    if (!request) throw new Error('Request is not available');
 
     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,
+      token: deviceToken,
       events: parsedEvents,
       platformApplicationName: appName,
     };
 
-    const {data} = await axios.post(validUrl, body, {headers});
+    const response = await request.post({
+      service: 'notification',
+      namespace: 'subscribe',
+      pathParams: ['push'],
+      body,
+    });
 
-    return data;
+    return response;
   } catch (error) {
-    return Promise.reject(error?.response?.data?.message || error);
+    return Promise.reject(error?.result || error);
   }
 };
 

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

@@ -0,0 +1,35 @@
+import {isString, isArray} from '../../index';
+
+const UnSubscribeNotifications = async (params = {}) => {
+  try {
+    if (!params || !Object.keys(params).length)
+      throw new Error('params is not a valid object');
+
+    const {events, request} = params;
+
+    if (!events || !isArray(events))
+      throw new Error('events to be subscribed to are null');
+    if (!request) throw new Error('Request is not available');
+
+    const parsedEvents = events.filter((event) => !!event && isString(event));
+    if (!parsedEvents.length)
+      throw new Error('events to be suscribed are invalids');
+
+    const body = {
+      events: parsedEvents,
+    };
+
+    const response = await request.post({
+      service: 'notification',
+      namespace: 'unsubscribe',
+      pathParams: ['push'],
+      body,
+    });
+
+    return response;
+  } catch (error) {
+    return Promise.reject(error?.result || error);
+  }
+};
+
+export default UnSubscribeNotifications;

package/lib/utils/index.js

@@ -1,7 +1,5 @@
-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
 
@@ -75,180 +73,19 @@ export const isBoolean = (bool) => typeof bool === 'boolean';
 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}
+ * @function promiseWrapper
+ * @param {function} fn
+ * @description wrapper to execute promise and return tuple with data and error
+ * @returns {array<data, error>}
  * @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'
- * // }
+ * import {promiseWrapper} from '@janiscommerce/apps-helpers'
+ * const [data, error] = await promiseWrapper(promise())
  */
 
-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}),
-  };
-};
+export const promiseWrapper = (promise) =>
+  promise
+    .then((data) => [data, null])
+    .catch((error) => Promise.resolve([null, error]));
 
 // MESSAGING UTILS
 
@@ -258,7 +95,7 @@ export const getHeaders = (params = {}, customHeaders = {}) => {
  * @returns {Promise<string>}
  * @example
  *
- * getFCMToken() => JDF6GJS364uhaGGe384gJHIQs23nbRNFG2859gJSD9gBivajeSJD
+ * getFCMToken() => 'JDF6GJS364uhaGGe384gJHIQs23nbRNFG2859gJSD9gBivajeSJD'
  */
 
 export const getFCMToken = async () => {
@@ -309,58 +146,18 @@ export const setupForegroundMessageHandler = (callback) =>
  * @param {Function} callback is the function that will receive the payload and render it as appropriate
  */
 
-export const setupBackgroundMessageHandler = (callback) =>
+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
- *
+ * @function setupNotificationOpenedHandler
+ * @description This function is responsible for handling any Firebase Cloud Messaging callbacks that the app will have from the background
+ * @param {Function} callback is the function that will receive the payload and render it as appropriate
  */
 
-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);
-  }
-};
+export const setupNotificationOpenedHandler = (callback) =>
+  messaging().onNotificationOpenedApp(async (remoteMessage) => {
+    callback(remoteMessage);
+  });

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@janiscommerce/app-push-notification",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.2",
   "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",
+    "build-docs": "jsdoc2md --template template-readme.hbs --files lib/NotificationProvider/index.js lib/NotificationContext.js > README.md",
     "test:coverage": "jest --collectCoverage",
     "validate:code": "npm run lint -- --fix  && jest --collectCoverage"
   },
@@ -27,30 +27,33 @@
   "author": "Janis",
   "license": "ISC",
   "dependencies": {
+    "@janiscommerce/app-request": "^2.2.0",
     "@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"
+    "react-native-device-info": "^8.5.0"
   },
   "peerDependencies": {
     "react": ">=17.0.2 <=18.2.0",
     "react-native": ">=0.67.5 <=0.72.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.23.6",
+    "@babel/core": "^7.22.10",
     "@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",
+    "@janiscommerce/app-request": "^2.2.0",
     "@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-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
     "babel-loader": "8.2.4",
-    "eslint": "^8.56.0",
+    "eslint": "7.14.0",
     "eslint-config-airbnb": "^18.2.1",
     "eslint-config-prettier": "^8.1.0",
     "eslint-plugin-import": "^2.22.1",
@@ -68,6 +71,7 @@
     "prettier": "^2.4.1",
     "react": "^17.0.2",
     "react-native": "^0.67.5",
+    "react-native-device-info": "^8.5.0",
     "react-test-renderer": "^17.0.2"
   },
   "bugs": {