@ammarahmed/notifee-react-native 7.3.0

package/src/validators/validateIOSCategoryAction.ts

@@ -0,0 +1,65 @@
+import { IOSNotificationCategoryAction } from '../types/NotificationIOS';
+import { objectHasProperty, isBoolean, isObject, isString, isUndefined } from '../utils';
+import validateIOSInput from './validateIOSInput';
+
+export default function validateIOSCategoryAction(
+  action: IOSNotificationCategoryAction,
+): IOSNotificationCategoryAction {
+  if (!isObject(action)) {
+    throw new Error('"action" expected an object value');
+  }
+
+  if (!isString(action.id) || action.id.length === 0) {
+    throw new Error('"action.id" expected a valid string value.');
+  }
+
+  if (!isString(action.title) || action.title.length === 0) {
+    throw new Error('"action.title" expected a valid string value.');
+  }
+
+  const out: IOSNotificationCategoryAction = {
+    id: action.id,
+    title: action.title,
+    destructive: false,
+    foreground: false,
+    authenticationRequired: false,
+  };
+
+  if (objectHasProperty(action, 'input') && !isUndefined(action.input)) {
+    if (action.input === true) {
+      out.input = true;
+    } else {
+      try {
+        out.input = validateIOSInput(action.input);
+      } catch (e: any) {
+        throw new Error(`'action' ${e.message}.`);
+      }
+    }
+  }
+
+  if (objectHasProperty(action, 'destructive')) {
+    if (!isBoolean(action.destructive)) {
+      throw new Error("'destructive' expected a boolean value.");
+    }
+
+    out.destructive = action.destructive;
+  }
+
+  if (objectHasProperty(action, 'foreground')) {
+    if (!isBoolean(action.foreground)) {
+      throw new Error("'foreground' expected a boolean value.");
+    }
+
+    out.foreground = action.foreground;
+  }
+
+  if (objectHasProperty(action, 'authenticationRequired')) {
+    if (!isBoolean(action.authenticationRequired)) {
+      throw new Error("'authenticationRequired' expected a boolean value.");
+    }
+
+    out.authenticationRequired = action.authenticationRequired;
+  }
+
+  return out;
+}

package/src/validators/validateIOSInput.ts

@@ -0,0 +1,38 @@
+import { IOSInput } from '../types/NotificationIOS';
+import { objectHasProperty, isBoolean, isObject, isString, isUndefined } from '../utils';
+
+export default function validateIOSInput(input?: IOSInput): IOSInput {
+  const out: IOSInput = {};
+
+  // default value
+  if (!input) {
+    return out;
+  }
+
+  // if true, empty object
+  if (isBoolean(input)) {
+    return out;
+  }
+
+  if (!isObject(input)) {
+    throw new Error('expected an object value.');
+  }
+
+  if (objectHasProperty(input, 'buttonText') && !isUndefined(input.buttonText)) {
+    if (!isString(input.buttonText)) {
+      throw new Error("'buttonText' expected a string value.");
+    }
+
+    out.buttonText = input.buttonText;
+  }
+
+  if (objectHasProperty(input, 'placeholderText') && !isUndefined(input.placeholderText)) {
+    if (!isString(input.placeholderText)) {
+      throw new Error("'placeholderText' expected a string value.");
+    }
+
+    out.placeholderText = input.placeholderText;
+  }
+
+  return out;
+}

package/src/validators/validateIOSNotification.ts

@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import {
+  NotificationIOS,
+  IOSForegroundPresentationOptions,
+  IOSNotificationAttachment,
+} from '../types/NotificationIOS';
+import {
+  objectHasProperty,
+  isBoolean,
+  isNumber,
+  isString,
+  isUndefined,
+  isObject,
+  isArray,
+  isAndroid,
+} from '../utils';
+import validateIOSCommunicationInfo from './iosCommunicationInfo/validateIOSCommunicationInfo';
+import validateIOSAttachment from './validateIOSAttachment';
+
+export default function validateIOSNotification(ios?: NotificationIOS): NotificationIOS {
+  const out: NotificationIOS & {
+    foregroundPresentationOptions: IOSForegroundPresentationOptions;
+  } = {
+    foregroundPresentationOptions: {
+      alert: true,
+      badge: true,
+      sound: true,
+      banner: true,
+      list: true,
+    },
+  };
+
+  if (isUndefined(ios)) {
+    return out;
+  }
+
+  /* Skip validating if Android in release */
+  if (isAndroid && !__DEV__) return out;
+
+  /**
+   * attachments
+   */
+  if (objectHasProperty(ios, 'attachments')) {
+    if (!isArray(ios.attachments)) {
+      throw new Error("'notification.ios.attachments' expected an array value.");
+    }
+
+    const attachments: IOSNotificationAttachment[] = [];
+
+    for (let i = 0; i < ios.attachments.length; i++) {
+      try {
+        attachments.push(validateIOSAttachment(ios.attachments[i]));
+      } catch (e: any) {
+        throw new Error(
+          `'notification.ios.attachments' invalid IOSNotificationAttachment. ${e.message}.`,
+        );
+      }
+    }
+
+    if (attachments.length) {
+      out.attachments = attachments;
+    }
+  }
+
+  /**
+   * communicationInfo
+   */
+  if (objectHasProperty(ios, 'communicationInfo') && !isUndefined(ios.communicationInfo)) {
+    try {
+      out.communicationInfo = validateIOSCommunicationInfo(ios.communicationInfo);
+    } catch (e: any) {
+      throw new Error(`'ios.communicationInfo' ${e.message}`);
+    }
+  }
+
+  /**
+   * interruptionLevel
+   */
+  if (objectHasProperty(ios, 'interruptionLevel')) {
+    if (
+      isString(ios.interruptionLevel) &&
+      ['active', 'critical', 'passive', 'timeSensitive'].includes(ios.interruptionLevel)
+    ) {
+      out.interruptionLevel = ios.interruptionLevel;
+    } else {
+      throw new Error(
+        "'notification.ios.interruptionLevel' must be a string value: 'active','critical','passive','timeSensitive'.",
+      );
+    }
+  }
+
+  /**
+   * critical
+   */
+  if (objectHasProperty(ios, 'critical')) {
+    if (!isBoolean(ios.critical)) {
+      throw new Error("'notification.ios.critical' must be a boolean value if specified.");
+    } else {
+      out.critical = ios.critical;
+    }
+  }
+
+  /**
+   * criticalVolume
+   */
+  if (objectHasProperty(ios, 'criticalVolume')) {
+    if (!isNumber(ios.criticalVolume)) {
+      throw new Error("'notification.ios.criticalVolume' must be a number value if specified.");
+    } else {
+      if (ios.criticalVolume < 0 || ios.criticalVolume > 1) {
+        throw new Error(
+          "'notification.ios.criticalVolume' must be a float value between 0.0 and 1.0.",
+        );
+      }
+      out.criticalVolume = ios.criticalVolume;
+    }
+  }
+
+  /**
+   * sound
+   */
+  if (objectHasProperty(ios, 'sound')) {
+    if (isString(ios.sound)) {
+      out.sound = ios.sound;
+    } else {
+      throw new Error("'notification.sound' must be a string value if specified.");
+    }
+  }
+
+  /**
+   * badgeCount
+   */
+  if (objectHasProperty(ios, 'badgeCount')) {
+    if (!isNumber(ios.badgeCount) || ios.badgeCount < 0) {
+      throw new Error("'notification.ios.badgeCount' expected a number value >=0.");
+    }
+
+    out.badgeCount = ios.badgeCount;
+  }
+
+  /**
+   * categoryId
+   */
+  if (objectHasProperty(ios, 'categoryId')) {
+    if (!isString(ios.categoryId)) {
+      throw new Error("'notification.ios.categoryId' expected a of string value");
+    }
+
+    out.categoryId = ios.categoryId;
+  }
+
+  /**
+   * groupId
+   */
+  if (objectHasProperty(ios, 'threadId')) {
+    if (!isString(ios.threadId)) {
+      throw new Error("'notification.ios.threadId' expected a string value.");
+    }
+
+    out.threadId = ios.threadId;
+  }
+
+  /**
+   * summaryArgument
+   */
+  if (objectHasProperty(ios, 'summaryArgument')) {
+    if (!isString(ios.summaryArgument)) {
+      throw new Error("'notification.ios.summaryArgument' expected a string value.");
+    }
+
+    out.summaryArgument = ios.summaryArgument;
+  }
+
+  /**
+   * summaryArgumentCount
+   */
+  if (objectHasProperty(ios, 'summaryArgumentCount')) {
+    if (!isNumber(ios.summaryArgumentCount) || ios.summaryArgumentCount <= 0) {
+      throw new Error(
+        "'notification.ios.summaryArgumentCount' expected a positive number greater than 0.",
+      );
+    }
+
+    out.summaryArgumentCount = ios.summaryArgumentCount;
+  }
+
+  /**
+   * launchImageName
+   */
+  if (objectHasProperty(ios, 'launchImageName')) {
+    if (!isString(ios.launchImageName)) {
+      throw new Error("'notification.ios.launchImageName' expected a string value.");
+    }
+
+    out.launchImageName = ios.launchImageName;
+  }
+
+  /**
+   * sound
+   */
+  if (objectHasProperty(ios, 'sound')) {
+    if (!isString(ios.sound)) {
+      throw new Error("'notification.ios.sound' expected a string value.");
+    }
+
+    out.sound = ios.sound;
+  }
+
+  /**
+   * ForegroundPresentationOptions
+   */
+  if (objectHasProperty(ios, 'foregroundPresentationOptions')) {
+    if (!isObject(ios.foregroundPresentationOptions)) {
+      throw new Error(
+        "'notification.ios.foregroundPresentationOptions' expected a valid IOSForegroundPresentationOptions object.",
+      );
+    }
+
+    if (
+      objectHasProperty<IOSForegroundPresentationOptions>(
+        ios.foregroundPresentationOptions,
+        'alert',
+      )
+    ) {
+      if (!isBoolean(ios.foregroundPresentationOptions.alert)) {
+        throw new Error(
+          "'notification.ios.foregroundPresentationOptions.alert' expected a boolean value.",
+        );
+      }
+
+      out.foregroundPresentationOptions.alert = ios.foregroundPresentationOptions.alert;
+    }
+
+    if (
+      objectHasProperty<IOSForegroundPresentationOptions>(
+        ios.foregroundPresentationOptions,
+        'sound',
+      )
+    ) {
+      if (!isBoolean(ios.foregroundPresentationOptions.sound)) {
+        throw new Error(
+          "'notification.ios.foregroundPresentationOptions.sound' expected a boolean value.",
+        );
+      }
+
+      out.foregroundPresentationOptions.sound = ios.foregroundPresentationOptions.sound;
+    }
+
+    if (
+      objectHasProperty<IOSForegroundPresentationOptions>(
+        ios.foregroundPresentationOptions,
+        'badge',
+      )
+    ) {
+      if (!isBoolean(ios.foregroundPresentationOptions.badge)) {
+        throw new Error(
+          "'notification.ios.foregroundPresentationOptions.badge' expected a boolean value.",
+        );
+      }
+
+      out.foregroundPresentationOptions.badge = ios.foregroundPresentationOptions.badge;
+    }
+
+    if (
+      objectHasProperty<IOSForegroundPresentationOptions>(
+        ios.foregroundPresentationOptions,
+        'banner',
+      )
+    ) {
+      if (!isBoolean(ios.foregroundPresentationOptions.banner)) {
+        throw new Error(
+          "'notification.ios.foregroundPresentationOptions.banner' expected a boolean value.",
+        );
+      }
+
+      out.foregroundPresentationOptions.banner = ios.foregroundPresentationOptions.banner;
+    }
+
+    if (
+      objectHasProperty<IOSForegroundPresentationOptions>(ios.foregroundPresentationOptions, 'list')
+    ) {
+      if (!isBoolean(ios.foregroundPresentationOptions.list)) {
+        throw new Error(
+          "'notification.ios.foregroundPresentationOptions.list' expected a boolean value.",
+        );
+      }
+
+      out.foregroundPresentationOptions.list = ios.foregroundPresentationOptions.list;
+    }
+  }
+
+  return out;
+}

package/src/validators/validateIOSPermissions.ts

@@ -0,0 +1,78 @@
+import { IOSNotificationPermissions } from '../types/NotificationIOS';
+import { objectHasProperty, isBoolean } from '../utils';
+
+export default function validateIOSPermissions(
+  permissions: IOSNotificationPermissions,
+): IOSNotificationPermissions {
+  const out: IOSNotificationPermissions = {
+    alert: true,
+    badge: true,
+    sound: true,
+    carPlay: true,
+    provisional: false,
+    announcement: false,
+    criticalAlert: false,
+  };
+
+  if (!permissions) {
+    return out;
+  }
+
+  if (objectHasProperty(permissions, 'alert')) {
+    if (!isBoolean(permissions.alert)) {
+      throw new Error("'alert' expected a boolean value.");
+    }
+
+    out.alert = permissions.alert;
+  }
+
+  if (objectHasProperty(permissions, 'badge')) {
+    if (!isBoolean(permissions.badge)) {
+      throw new Error("'alert' badge a boolean value.");
+    }
+
+    out.badge = permissions.badge;
+  }
+
+  if (objectHasProperty(permissions, 'sound')) {
+    if (!isBoolean(permissions.sound)) {
+      throw new Error("'sound' expected a boolean value.");
+    }
+
+    out.sound = permissions.sound;
+  }
+
+  if (objectHasProperty(permissions, 'carPlay')) {
+    if (!isBoolean(permissions.carPlay)) {
+      throw new Error("'carPlay' expected a boolean value.");
+    }
+
+    out.carPlay = permissions.carPlay;
+  }
+
+  if (objectHasProperty(permissions, 'provisional')) {
+    if (!isBoolean(permissions.provisional)) {
+      throw new Error("'provisional' expected a boolean value.");
+    }
+
+    out.provisional = permissions.provisional;
+  }
+
+  if (objectHasProperty(permissions, 'announcement')) {
+    if (!isBoolean(permissions.announcement)) {
+      throw new Error("'announcement' expected a boolean value.");
+    }
+
+    out.announcement = permissions.announcement;
+  }
+
+  if (objectHasProperty(permissions, 'criticalAlert')) {
+    if (!isBoolean(permissions.criticalAlert)) {
+      throw new Error("'criticalAlert' expected a boolean value.");
+    }
+
+    out.criticalAlert = permissions.criticalAlert;
+  }
+
+  return out;
+}

package/src/validators/validateNotification.ts

@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited
+ */
+
+import {
+  generateId,
+  objectHasProperty,
+  isObject,
+  isString,
+  isAndroid,
+  isIOS,
+  isNumber,
+} from '../utils';
+
+import validateAndroidNotification from './validateAndroidNotification';
+import validateIOSNotification from './validateIOSNotification';
+import { Notification } from '../types/Notification';
+import { Platform } from 'react-native';
+import { NotificationAndroid } from '../types/NotificationAndroid';
+import { NotificationIOS } from '..';
+
+/**
+ * Validate platform-specific notification
+ *
+ * Only throws a validation error if the device is on the same platform
+ * Otherwise, will show a debug log in the console
+ */
+export const validatePlatformSpecificNotification = (
+  out: Notification,
+  specifiedPlatform: string,
+): NotificationAndroid | NotificationIOS => {
+  try {
+    if (specifiedPlatform === 'ios') {
+      return validateIOSNotification(out.ios);
+    } else {
+      return validateAndroidNotification(out.android);
+    }
+  } catch (error) {
+    const isRunningOnSamePlatform = specifiedPlatform === Platform.OS;
+    if (isRunningOnSamePlatform) {
+      throw error;
+    } else {
+      console.debug(`Invalid ${specifiedPlatform} notification ->`, error);
+      return {};
+    }
+  }
+};
+
+export default function validateNotification(notification: Notification): Notification {
+  if (!isObject(notification)) {
+    throw new Error("'notification' expected an object value.");
+  }
+
+  // Defaults
+  const out: Notification = {
+    id: '',
+    data: {},
+  };
+
+  if (isAndroid) {
+    /* istanbul ignore next */
+    out.android = {};
+  } else if (isIOS) {
+    out.ios = {};
+  }
+
+  /**
+   * id
+   */
+  if (objectHasProperty(notification, 'id')) {
+    if (!isString(notification.id) || !notification.id) {
+      throw new Error("'notification.id' invalid notification ID, expected a unique string value.");
+    }
+
+    out.id = notification.id;
+  } else {
+    out.id = generateId();
+  }
+
+  /**
+   * title
+   */
+  if (objectHasProperty(notification, 'title')) {
+    if (notification.title !== undefined && !isString(notification.title)) {
+      throw new Error("'notification.title' expected a string value or undefined.");
+    }
+
+    out.title = notification.title;
+  }
+
+  /**
+   * body
+   */
+  if (objectHasProperty(notification, 'body')) {
+    if (notification.body !== undefined && !isString(notification.body)) {
+      throw new Error("'notification.body' expected a string value or undefined.");
+    }
+
+    out.body = notification.body;
+  }
+
+  /**
+   * subtitle
+   */
+  if (objectHasProperty(notification, 'subtitle')) {
+    if (notification.subtitle !== undefined && !isString(notification.subtitle)) {
+      throw new Error("'notification.subtitle' expected a string value or undefined.");
+    }
+
+    out.subtitle = notification.subtitle;
+  }
+
+  /**
+   * data
+   */
+  if (objectHasProperty(notification, 'data') && notification.data !== undefined) {
+    if (!isObject(notification.data)) {
+      throw new Error("'notification.data' expected an object value containing key/value pairs.");
+    }
+
+    const entries = Object.entries(notification.data);
+
+    for (let i = 0; i < entries.length; i++) {
+      const [key, value] = entries[i];
+      if (!isString(value) && !isNumber(value) && !isObject(value)) {
+        throw new Error(
+          `'notification.data' value for key "${key}" is invalid, expected a string value.`,
+        );
+      }
+    }
+
+    out.data = notification.data;
+  }
+
+  /**
+   * android
+   */
+  const validatedAndroid = validatePlatformSpecificNotification(
+    notification,
+    'android',
+  ) as NotificationAndroid;
+
+  if (isAndroid) {
+    out.android = validatedAndroid;
+  }
+
+  /**
+   * ios
+   */
+  const validatedIOS = validatePlatformSpecificNotification(notification, 'ios') as NotificationIOS;
+  if (isIOS) {
+    out.ios = validatedIOS;
+  }
+
+  return out;
+}