@janiscommerce/app-push-notification 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.0.7] - 2025-07-23
+
+### Fixed
+
+- The subscription request is only made when the user is not subscribed.
+
+## [0.0.6] - 2025-07-13
+
+### Added
+
+- cancelNotificationSuscription method
+
 ## [0.0.5] - 2025-06-17
 
 ### Added

package/README.md

@@ -92,7 +92,7 @@ To use a custom sound on Android, you must:
 </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>
+<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. <em>⚠️ Deprecated: Use cancelNotificationsSubscription instead.</em></td>
 </tr>
 <tr>
 <td>updateSuscription</td>

package/lib/NotificationProvider/index.js

@@ -1,12 +1,14 @@
-import React, {useEffect, useRef} from 'react';
+import React, {useEffect} from 'react';
 import messaging from '@react-native-firebase/messaging';
 import {NotificationContext} from '../NotificationContext';
 import {
   isString,
   isArray,
+  isFunction,
   setupForegroundMessageHandler,
   setupNotificationOpenedHandler,
   isObject,
+  prepareEventsToSubscribe,
 } from '../utils';
 import usePushNotification from '../usePushNotification';
 import {
@@ -14,6 +16,7 @@ import {
   makeNotificationChannels,
   parseNotificationChannel,
 } from '../utils/channel';
+import {getFCMToken, getStoredToken} from '../utils/token';
 
 /**
  * @function NotificationProvider
@@ -25,6 +28,7 @@ import {
  * @param {object} additionalInfo fields to be sent as part of the body of the subscription request
  * @param {Array<string | object>} channelConfigs is the configuration that will be used to create new notification channels
  * @param {string} backgroundNotificationSound is the sound that will be played when the app is in the background
+ * @param {function} onSubscriptionError is a callback that will be called when the subscription fails
  * @throws null when not receive a children argument
  * @returns {null | React.element}
  * @example
@@ -44,66 +48,50 @@ import {
 
 const NotificationProvider = ({
   children,
-  appName,
+  appName = '',
   events,
-  environment,
+  environment = '',
   additionalInfo,
   channelConfigs = [],
   backgroundNotificationSound,
+  onSubscriptionError,
 }) => {
   if (!children) return null;
 
-  const validAppName = !!appName && isString(appName) ? appName : '';
-  const validEnvironment =
-    !!environment && isString(environment) ? environment : '';
-  const validEvents = !!events && isArray(events) ? events : [];
-  const validChannelConfigs =
-    !!channelConfigs && isArray(channelConfigs) ? channelConfigs : [];
-
-  const safeBackgroundSound =
-    isString(backgroundNotificationSound) && backgroundNotificationSound?.trim()
-      ? backgroundNotificationSound.trim()
-      : 'default';
-
-  const isRegistered = useRef(false);
+  const parsedEvents = prepareEventsToSubscribe(events);
+  const hasChannelConfigs = isArray(channelConfigs) && channelConfigs.length;
   const {
     registerDeviceToNotifications,
     updateNotificationState,
     pushEvents,
     ...rest
-  } = usePushNotification(
-    validEnvironment,
-    validEvents,
-    validAppName,
-    isRegistered,
-    additionalInfo,
-  );
+  } = usePushNotification(String(environment), parsedEvents, String(appName));
 
-  // @function handlerForegroundData
+  // @function foregroundDataHandler
   // @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) => {
+  const foregroundDataHandler = (data) => {
     if (!data || !isObject(data)) return null;
 
     return updateNotificationState({foregroundNotification: data});
   };
 
-  // @function handlerBackgroundData
+  // @function backgroundDataHandler
   // @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) => {
+  const backgroundDataHandler = (data) => {
     if (!data || !isObject(data)) return null;
 
     return updateNotificationState({backgroundNotification: data});
   };
 
-  // @function handleAppOpeningByNotification
+  // @function handleOpeningByNotification
   // @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 handleOpeningByNotification = async () => {
     const data = await messaging().getInitialNotification();
 
     if (!data || !isObject(data)) return null;
@@ -113,22 +101,41 @@ const NotificationProvider = ({
 
   const createNotificationChannels = async () => {
     /* istanbul ignore else */
-    if (validChannelConfigs) {
-      const parsedChannelConfigs = validChannelConfigs
+    if (hasChannelConfigs) {
+      const parsedChannelConfigs = channelConfigs
         ?.map((config) => parseNotificationChannel(config))
         .filter(Boolean);
 
       await makeNotificationChannels(parsedChannelConfigs);
     }
-    await makeDefaultChannel({sound: safeBackgroundSound});
+
+    await makeDefaultChannel({
+      sound: isString(backgroundNotificationSound)
+        ? backgroundNotificationSound.trim()
+        : 'default',
+    });
+  };
+
+  const SubscribeToNotifications = async () => {
+    try {
+      const storedToken = await getStoredToken();
+      const fcmToken = await getFCMToken();
+      const isSameToken = storedToken === fcmToken;
+
+      if (Boolean(storedToken) && isSameToken) return;
+
+      await registerDeviceToNotifications({token: fcmToken, additionalInfo});
+    } catch (error) {
+      if (onSubscriptionError && isFunction(onSubscriptionError))
+        onSubscriptionError(error);
+    }
   };
 
   useEffect(() => {
-    const alreadySuscribed = isRegistered.current;
-    if (environment && appName && !!pushEvents.length && !alreadySuscribed) {
-      registerDeviceToNotifications();
+    if (environment && appName && !!pushEvents.length) {
+      SubscribeToNotifications();
     }
-  }, [pushEvents]);
+  }, []);
 
   useEffect(() => {
     createNotificationChannels();
@@ -137,12 +144,13 @@ const NotificationProvider = ({
   /* istanbul ignore next */
   useEffect(() => {
     const foregroundMessageHandler = setupForegroundMessageHandler(
-      handlerForegroundData,
+      foregroundDataHandler,
     );
     const backgroundMessageHandler = setupNotificationOpenedHandler(
-      handlerBackgroundData,
+      backgroundDataHandler,
     );
-    handleAppOpeningByNotification();
+
+    handleOpeningByNotification();
 
     return () => {
       foregroundMessageHandler();

package/lib/index.js

@@ -1,6 +1,13 @@
 import NotificationProvider from './NotificationProvider';
 import {usePushNotification} from './NotificationContext';
 import {setupBackgroundMessageHandler} from './utils';
+import cancelNotificationsSubscription from './utils/api/cancelNotificationsSubscription';
+import setUpdateSubscriptionByTokenRefresh from './utils/api/setUpdateSubscriptionByTokenRefresh';
 
-export {usePushNotification, setupBackgroundMessageHandler};
+export {
+  usePushNotification,
+  setupBackgroundMessageHandler,
+  cancelNotificationsSubscription,
+  setUpdateSubscriptionByTokenRefresh,
+};
 export default NotificationProvider;

package/lib/usePushNotification.js

@@ -1,18 +1,12 @@
-import {useCallback, useState} from 'react';
+import {useState} from 'react';
 import RequestInstance from '@janiscommerce/app-request';
-import {getFCMToken, isArray, isString} from './utils';
+import {isArray, isString, promiseWrapper} from './utils';
 import SubscribeNotifications from './utils/api/SubscribeNotifications';
-import UnSubscribeNotifications from './utils/api/UnSubscribeNotifications';
-
-const usePushNotification = (
-  environment,
-  events,
-  appName,
-  isRegistered,
-  additionalInfo,
-) => {
+import {getStoredToken, getFCMToken, updateStoredToken} from './utils/token';
+import cancelNotificationsSubscription from './utils/api/cancelNotificationsSubscription';
+
+const usePushNotification = (environment, events, appName) => {
   const [notificationState, setNotificationState] = useState({
-    deviceToken: null,
     foregroundNotification: {},
     backgroundNotification: {},
     pushEvents: events,
@@ -20,7 +14,6 @@ const usePushNotification = (
   });
 
   const {
-    deviceToken,
     foregroundNotification,
     backgroundNotification,
     pushEvents,
@@ -29,18 +22,25 @@ const usePushNotification = (
 
   const Request = new RequestInstance({JANIS_ENV: environment});
 
-  const updateNotificationState = (state) =>
-    setNotificationState({...notificationState, ...state});
+  // istanbul ignore next line
+  const updateNotificationState = (updateState) =>
+    setNotificationState((prevState) => ({...prevState, ...updateState}));
 
   const getSubscribedEvents = () => pushEvents;
 
+  // istanbul ignore next line
   const getDeviceToken = async () => {
-    if (deviceToken) return deviceToken;
+    try {
+      const [storedToken] = await promiseWrapper(getStoredToken());
 
-    const fcmToken = await getFCMToken();
-    if (!fcmToken || !isString(fcmToken)) return null;
+      if (storedToken) return storedToken;
 
-    return fcmToken;
+      const fcmToken = await getFCMToken();
+
+      return fcmToken;
+    } catch (error) {
+      return null;
+    }
   };
 
   /**
@@ -49,47 +49,39 @@ const usePushNotification = (
    * @returns {null}
    */
 
-  const registerDeviceToNotifications = useCallback(async () => {
-    const token = await getDeviceToken();
-
-    if (!token) return null;
-
+  const registerDeviceToNotifications = async (params) => {
+    const {token = '', additionalInfo = null} = params;
     try {
-      await SubscribeNotifications({
-        appName,
-        events: pushEvents,
-        deviceToken: token,
-        request: Request,
-        additionalInfo,
-      });
-
-      isRegistered.current = true;
-      return updateNotificationState({deviceToken: token, pushEvents});
+      await SubscribeNotifications(
+        {token, events: pushEvents, appName, additionalInfo},
+        Request,
+      );
+
+      await updateStoredToken(token);
+      return updateNotificationState({pushEvents});
     } catch (error) {
-      return updateNotificationState({pushEvents: [], subscribeError: error});
+      updateNotificationState({pushEvents: [], subscribeError: error});
+      return Promise.reject(error);
     }
-  }, [pushEvents]);
+  };
 
   /**
    * @function updateSuscription
    * @description This function is responsible for updating the subscription to the notification service
-   * @param {object} props all properties that will be sent as additional data in the subscription
+   * @param {object} additionalInfo all properties that will be sent as additional data in the subscription
    * @returns {Promise}
    */
 
-  const updateSuscription = async (props = {}) => {
+  const updateSuscription = async (additionalInfo) => {
     try {
       const token = await getDeviceToken();
 
-      const response = await SubscribeNotifications({
-        appName,
-        events: pushEvents,
-        deviceToken: token,
-        request: Request,
-        additionalInfo: props,
-      });
+      await SubscribeNotifications(
+        {token, events: pushEvents, appName, additionalInfo},
+        Request,
+      );
 
-      return response;
+      return Promise.resolve();
     } catch (error) {
       return Promise.reject(error);
     }
@@ -100,6 +92,7 @@ const usePushNotification = (
    * @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}
+   * @deprecated Use cancelNotificationsSubscription from the main export instead
    *
    * @example
    *
@@ -109,24 +102,23 @@ const usePushNotification = (
    */
 
   const cancelNotifications = async (cancelEvents) => {
+    console.warn(
+      '⚠️ cancelNotifications is deprecated. Use cancelNotificationsSubscription instead.',
+    );
+
     const eventsAreValid = cancelEvents && isArray(cancelEvents);
     const eventsToCancel = eventsAreValid ? cancelEvents : pushEvents;
     try {
-      await UnSubscribeNotifications({
-        events: eventsToCancel,
-        request: Request,
-      });
+      await cancelNotificationsSubscription({events: eventsToCancel}, 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);
@@ -171,18 +163,14 @@ const usePushNotification = (
    */
 
   const addNewEvent = (event) => {
-    if (!event || !isString(event)) return null;
-    if (pushEvents.includes(event)) {
-      return null;
-    }
+    if (!event || !isString(event)) return;
+    if (pushEvents.includes(event)) return;
 
     const updatedEvents = [...pushEvents, event];
-    isRegistered.current = false;
-    return updateNotificationState({pushEvents: updatedEvents});
+    updateNotificationState({pushEvents: updatedEvents});
   };
 
   return {
-    deviceToken,
     foregroundNotification,
     backgroundNotification,
     subscribeError,

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

@@ -1,46 +1,49 @@
-import {isString, isArray, isObject} from '../../index';
+import RequestInstance from '@janiscommerce/app-request';
+import {prepareEventsToSubscribe} from '../../index';
+
+/**
+ * @function SubscribeNotifications
+ * @description This function is responsible for subscribing to the notification service
+ * @param {object} params - The parameters object
+ * @param {string} params.token - The token to subscribe to
+ * @param {Array<string>} params.events - The events to subscribe to
+ * @param {string} params.appName - The name of the app
+ * @param {object} params.additionalInfo - The additional information to subscribe to
+ * @param {string} params.env - The environment of the app. It is used to make subscribe request in case of request instance is not provided
+ * @param {object} requestInstance - The request instance to make subscribe request
+ * @returns {Promise<void>} The response from the subscribe request
+ * @throws {Error} When the request fails
+ */
+
+const SubscribeNotifications = async (params, requestInstance = null) => {
+  const {
+    token = '',
+    events = [],
+    appName = '',
+    additionalInfo = null,
+    env = '',
+  } = params || {};
+  const Request = requestInstance || new RequestInstance({JANIS_ENV: env});
+  const parsedEvents = prepareEventsToSubscribe(events);
 
-const SubscribeNotifications = async (params = {}) => {
   try {
-    if (!params || !Object.keys(params).length)
-      throw new Error('params is not a valid object');
-
-    const {deviceToken, events, appName, request, additionalInfo} = params;
-
-    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 (!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 validAdditionalInfo =
-      isObject(additionalInfo) && !!Object.keys(additionalInfo).length;
-
-    const body = {
-      token: deviceToken,
-      events: parsedEvents,
-      platformApplicationName: appName,
-      ...(validAdditionalInfo && {
-        additionalInfo,
-      }),
-    };
-
-    const response = await request.post({
+    await Request.post({
       service: 'notification',
       namespace: 'subscribe',
       pathParams: ['push'],
-      body,
+      body: {
+        token,
+        events: parsedEvents,
+        platformApplicationName: appName,
+        ...(additionalInfo && {
+          additionalInfo,
+        }),
+      },
     });
 
-    return response;
+    return Promise.resolve();
   } catch (error) {
-    return Promise.reject(error?.result || error);
+    return Promise.reject(error);
   }
 };
 

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

@@ -0,0 +1,45 @@
+import RequestInstance from '@janiscommerce/app-request';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+/**
+ * Cancels push notification subscriptions for specified events
+ * @param {Object} params - The parameters object
+ * @param {string[]} [params.events=[]] - Array of event names to unsubscribe from
+ * @param {string} params.env - Environment identifier (required)
+ * @returns {Promise<Object>} Promise that resolves with the API response
+ * @throws {Error} When environment is not provided or API request fails
+ * @example
+ * // Cancel subscription for specific events
+ * await cancelNotificationsSubscription({
+ *   events: ['user.login', 'order.created'],
+ *   env: 'janisdev'
+ * });
+ */
+
+const cancelNotificationsSubscription = async (
+  params = {},
+  requestInstance = null,
+) => {
+  const {events = [], env = ''} = params;
+  const Request =
+    requestInstance || new RequestInstance({JANIS_ENV: String(env)});
+
+  try {
+    await Request.post({
+      service: 'notification',
+      namespace: 'unsubscribe',
+      pathParams: ['push'],
+      body: {
+        events,
+      },
+    });
+
+    await AsyncStorage.removeItem('currentToken');
+
+    return Promise.resolve();
+  } catch (error) {
+    return Promise.reject(error);
+  }
+};
+
+export default cancelNotificationsSubscription;

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

@@ -0,0 +1,47 @@
+/* istanbul ignore file */
+import messaging from '@react-native-firebase/messaging';
+import cancelNotificationsSubscription from '../cancelNotificationsSubscription';
+import SubscribeNotifications from '../SubscribeNotifications';
+import {promiseWrapper} from '../..';
+import {updateStoredToken} from '../../token';
+
+/**
+ * @function setUpdateSubscriptionByTokenRefresh
+ * @description This function is responsible for updating the subscription to the notification service when the token is refreshed
+ * @param {object} params - The parameters object
+ * @param {Array<string>} params.events - The events to subscribe to
+ * @param {string} params.appName - The name of the app
+ * @param {string} params.env - The environment of the app. It is used to make unsubscribe and subscribe requests in case of request instance is not provided
+ * @param {object} requestInstance - The request instance to make unsubscribe and subscribe requests
+ * @param {function} onSubscriptionError - The function to be called when the subscription fails
+ * @returns {null}
+ */
+
+const setUpdateSubscriptionByTokenRefresh = async (
+  params,
+  requestInstance,
+  onSubscriptionError = null,
+) => {
+  await messaging().registerDeviceForRemoteMessages();
+
+  const unsubscribe = messaging().onTokenRefresh(async (token) => {
+    try {
+      const {events, appName, env} = params || {};
+      await promiseWrapper(
+        cancelNotificationsSubscription({events, env}, requestInstance),
+      );
+      await SubscribeNotifications(
+        {token, events, appName, env},
+        requestInstance,
+      );
+
+      await updateStoredToken(token);
+    } catch (error) {
+      if (onSubscriptionError) onSubscriptionError(error);
+    }
+  });
+
+  return unsubscribe;
+};
+
+export default setUpdateSubscriptionByTokenRefresh;

package/lib/utils/index.js

@@ -1,5 +1,4 @@
 import messaging from '@react-native-firebase/messaging';
-import AsyncStorage from '@react-native-async-storage/async-storage';
 
 // Helpers
 
@@ -87,37 +86,27 @@ export const promiseWrapper = (promise) =>
     .then((data) => [data, null])
     .catch((error) => Promise.resolve([null, error]));
 
-// 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>}
+ * @function prepareEventsToSubscribe
+ * @param {array} events
+ * @description parse events to subscribe
+ * @returns {array}
  * @example
- *
- * getFCMToken() => 'JDF6GJS364uhaGGe384gJHIQs23nbRNFG2859gJSD9gBivajeSJD'
+ * prepareEventsToSubscribe(['event1', 'event2', 3, null]) // ['event1', 'event2']
+ * prepareEventsToSubscribe(null) // []
+ * prepareEventsToSubscribe('event1') // ['event1']
  */
 
-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;
-      }
-    }
+export const prepareEventsToSubscribe = (events = []) => {
+  if (!isArray(events)) {
+    events = [events].filter(Boolean);
+  }
 
-    return fcmToken || '';
-  } catch (error) {
-    console.error('error', error.message);
+  if (!events.length) return [];
 
-    return '';
-  }
+  return events.filter((event) => !!event && isString(event));
 };
+// MESSAGING UTILS
 
 // 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.

package/lib/utils/token/index.js

@@ -0,0 +1,48 @@
+import messaging from '@react-native-firebase/messaging';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+/**
+ * @function getFCMToken
+ * @description This function is responsible for getting the FCM token
+ * @returns {Promise<string>} The FCM token
+ */
+
+export const getFCMToken = async () => {
+  try {
+    const fcmToken = await messaging().getToken();
+    return fcmToken;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * @function getStoredToken
+ * @description This function is responsible for getting the stored token from AsyncStorage
+ * @returns {Promise<string>} The stored token
+ */
+
+export const getStoredToken = async () => {
+  try {
+    const storedToken = await AsyncStorage.getItem('currentToken');
+    return storedToken;
+  } catch (error) {
+    return null;
+  }
+};
+
+/**
+ * @function updateStoredToken
+ * @description This function is responsible for updating the stored token in AsyncStorage
+ * @param {string} token - The token to be stored
+ * @returns {Promise<string>} The stored token
+ */
+
+export const updateStoredToken = async (token) => {
+  try {
+    await AsyncStorage.setItem('currentToken', token);
+    return token;
+  } catch (error) {
+    return null;
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@janiscommerce/app-push-notification",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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",

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

@@ -1,35 +0,0 @@
-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;