@bigbinary/neeto-commons-rn 1.8.4 → 2.0.2

package/src/config/axios/index.ts

@@ -0,0 +1,291 @@
+import { Platform } from "react-native";
+
+import { Toast } from "@bigbinary/neetoui-rn";
+import Bugsnag from "@bugsnag/react-native";
+import axios, {
+  type AxiosError,
+  type AxiosResponse,
+  type InternalAxiosRequestConfig,
+} from "axios";
+import Config from "react-native-config";
+import DeviceInfo from "react-native-device-info";
+
+import { convertRequestKeys, convertResponseKeys } from "./caseConversion";
+import { handleNetworkError } from "./networkErrorHandler";
+import setParamsSerializer from "./paramsSerializer";
+
+import { STORAGE_KEYS } from "../../constants";
+import { removeItem } from "../../helpers/asyncStore";
+import { getSecureValue, removeSecureValue } from "../../helpers/keychain";
+import { strings } from "../../localization";
+import { reset } from "../../navigation/navigationService";
+import { SCREEN_NAMES } from "../../navigation/screenNames";
+import { logoutUserAction } from "../../slices/auth";
+import { Store } from "../../store";
+
+// The error bodies neeto services return: a single message, a field-keyed map
+// of messages, or a list.
+export interface ApiErrorData {
+  error?: string | Record<string, string>;
+  errors?: string[];
+}
+
+const filterSensitiveData = (data: unknown) => {
+  if (!data) return null;
+
+  const sensitiveKeys = [
+    "x-auth-token",
+    "x-auth-email",
+    "password",
+    "password_confirmation",
+    "current_password",
+    "token",
+    "access_token",
+    "refresh_token",
+  ];
+
+  const filteredData = { ...(data as Record<string, unknown>) };
+
+  const filterNestedData = (obj: Record<string, unknown>) => {
+    Object.keys(obj).forEach(key => {
+      if (sensitiveKeys.includes(key)) {
+        delete obj[key];
+      } else if (obj[key] && typeof obj[key] === "object") {
+        filterNestedData(obj[key] as Record<string, unknown>);
+      }
+    });
+  };
+
+  filterNestedData(filteredData);
+
+  return filteredData;
+};
+
+const isAuthEndpoint = (url: string) =>
+  url.includes("/api/mobile/v1/verify_otp") ||
+  url.includes("/api/mobile/v1/generate_otp") ||
+  url.includes("/api/mobile/v1/google_login") ||
+  url.includes("/api/mobile/v1/apple_login");
+
+axios.defaults.headers.common = {
+  accept: "application/json",
+};
+
+export const rootUrlCreator = ({ subdomain }: { subdomain: string }) =>
+  `http${Config.IS_DEV ? "" : "s"}://${subdomain}${Config.URL_SUFFIX}`;
+
+const getUnauthorizedErrorMessage = (error: AxiosError<ApiErrorData>) => {
+  if (error.config?.url?.includes("/api/mobile/v1/generate_otp")) {
+    return strings.en.errors.axios.spamLimit;
+  }
+
+  const rawError = error.response?.data?.error;
+
+  if (typeof rawError === "object" && rawError !== null) {
+    return Object.values(rawError)[0] || strings.en.errors.axios.unauthorized;
+  }
+
+  return (rawError ||
+    error.response?.data?.errors?.join(", ") ||
+    strings.en.errors.axios.unauthorized) as string;
+};
+
+const handleUnauthorizedAccess = async (errorMessage: string) => {
+  Toast.show({
+    type: "error",
+    text2: Store.getState().auth.name
+      ? strings.en.errors.axios.sessionExpired
+      : errorMessage,
+  });
+  removeItem(STORAGE_KEYS.DEVICE_TOKEN);
+  await removeSecureValue("userAuth");
+  Store.dispatch(logoutUserAction());
+
+  reset({ name: SCREEN_NAMES.Login });
+};
+
+export const getErrorMessage = (
+  data: ApiErrorData | undefined,
+  error: AxiosError
+): string => {
+  if (typeof data?.error === "object" && data.error !== null) {
+    return Object.values(data.error)[0] || strings.en.errors.axios.generic;
+  }
+
+  return data?.error || error.message || strings.en.errors.axios.generic;
+};
+
+interface UserAuthData {
+  authToken: string;
+  email: string;
+}
+
+const getUserAuthData = async (): Promise<UserAuthData | null> => {
+  const authValue = await getSecureValue("userAuth");
+
+  return authValue ? (JSON.parse(authValue) as UserAuthData) : null;
+};
+
+const handleSuccessResponse = (response: AxiosResponse) => {
+  // Convert response data keys from snake_case to camelCase
+  if (response.data) {
+    response.data = convertResponseKeys(
+      response.data,
+      response.config?.caseConversionOptions
+    );
+  }
+
+  return response;
+};
+
+// eslint-disable-next-line no-console
+const handleErrorRequest = (error: unknown) => console.error(error);
+
+const handleErrorResponse = async (error: AxiosError<ApiErrorData>) => {
+  const { response } = error;
+  const status = response?.status;
+  const data = response?.data;
+
+  if (handleNetworkError(error)) {
+    return Promise.reject(error);
+  }
+
+  if (status === 401) {
+    if (isAuthEndpoint(error.config?.url || "")) return Promise.reject(error);
+
+    // Handle unauthorized access
+    const errorMessage = getUnauthorizedErrorMessage(error);
+    await handleUnauthorizedAccess(errorMessage);
+  } else if (data?.errors) {
+    // Handle multiple errors
+    data.errors.forEach(errorMessage => {
+      Toast.show({ type: "error", text2: errorMessage });
+    });
+  } else {
+    // Handle general errors
+    const errorMessage = getErrorMessage(data, error);
+    Toast.show({ type: "error", text2: errorMessage });
+  }
+
+  return Promise.reject(error);
+};
+
+let responseInterceptorId: number | null = null;
+let requestInterceptorId: number | null = null;
+
+const registerResponseIntercept = () => {
+  if (responseInterceptorId !== null) {
+    axios.interceptors.response.eject(responseInterceptorId);
+  }
+
+  responseInterceptorId = axios.interceptors.response.use(
+    response => handleSuccessResponse(response),
+    // eslint-disable-next-line require-await, promise/prefer-await-to-callbacks
+    async (error: AxiosError<ApiErrorData>) => {
+      const { config, response, message, name, code } = error;
+      const status = response?.status;
+
+      // Only report non-network errors to Bugsnag
+      if (!__DEV__ && status !== 401 && !handleNetworkError(error, false)) {
+        try {
+          Bugsnag.notify(new Error(`Axios Error: ${message}`), report => {
+            report.addMetadata("axios_error_details", {
+              message,
+              name,
+              code,
+              requestUrl: config?.url,
+              requestMethod: config?.method?.toUpperCase(),
+              baseURL: config?.baseURL,
+              requestHeaders: filterSensitiveData(config?.headers),
+              requestParams: filterSensitiveData(config?.params),
+              responseStatus: status,
+              responseStatusText: response?.statusText,
+              responseData: filterSensitiveData(response?.data),
+            });
+
+            report.context = `Axios Request Failed: ${config?.method?.toUpperCase()} ${
+              config?.url
+            }`;
+            report.groupingHash = `axios-${config?.method}-${config?.url}`;
+          });
+        } catch (bugsnagError) {
+          // eslint-disable-next-line no-console
+          console.error(
+            "Error reporting Axios error to Bugsnag:",
+            bugsnagError
+          );
+        }
+      }
+
+      return handleErrorResponse(error);
+    }
+  );
+};
+
+const registerRequestIntercept = () => {
+  if (requestInterceptorId !== null) {
+    axios.interceptors.request.eject(requestInterceptorId);
+  }
+
+  requestInterceptorId = axios.interceptors.request.use(async request => {
+    const config = await configureAxiosHeaders(request);
+
+    const store = Store.getState();
+    const subdomain = store?.auth?.subdomain || "app";
+    config.baseURL = rootUrlCreator({ subdomain });
+
+    // Convert request data keys from camelCase to snake_case
+    if (config.data) {
+      config.data = convertRequestKeys(
+        config.data,
+        config.caseConversionOptions
+      );
+    }
+
+    // Convert request params keys from camelCase to snake_case
+    if (config.params) {
+      config.params = convertRequestKeys(
+        config.params,
+        config.caseConversionOptions
+      );
+    }
+
+    return config;
+  }, handleErrorRequest);
+};
+
+export const cleanupAxiosInterceptors = () => {
+  if (responseInterceptorId !== null) {
+    axios.interceptors.response.eject(responseInterceptorId);
+    responseInterceptorId = null;
+  }
+
+  if (requestInterceptorId !== null) {
+    axios.interceptors.request.eject(requestInterceptorId);
+    requestInterceptorId = null;
+  }
+};
+
+export const configureAxiosHeaders = async (
+  request: InternalAxiosRequestConfig
+) => {
+  const userAuthData = await getUserAuthData();
+  if (userAuthData) {
+    const { authToken, email } = userAuthData;
+    const headers = {
+      "x-auth-token": authToken,
+      "x-auth-email": email,
+      "x-client-version": DeviceInfo.getVersion(),
+      "x-client-name": `${Platform.OS} ${Config.APP_DISPLAY_NAME}`,
+    };
+    Object.assign(request.headers, headers);
+  }
+
+  return request;
+};
+
+export const configureAxios = () => {
+  registerResponseIntercept();
+  registerRequestIntercept();
+  setParamsSerializer();
+};

package/src/config/axios/networkErrorHandler.ts

@@ -0,0 +1,47 @@
+import { Toast } from "@bigbinary/neetoui-rn";
+import { type Event } from "@bugsnag/react-native";
+
+import { strings } from "../../localization";
+
+// Callers pass axios errors, Bugsnag's NotifiableError (which may be a bare
+// string) and plain `{ message }` shims, so the check stays structural.
+export const isNetworkError = (error: unknown) => {
+  const networkErrorPatterns = [
+    /network\s*error/i, //"network error"
+    /network\s*request\s*failed/i, //"network request failed"
+    /no\s*internet\s*connection/i, //"no internet connection"
+    /timeout/i, //"timeout"
+    /econnrefused/i, //"econnrefused" - connection refused
+    /econnreset/i, //"econnreset" - connection reset
+    /enetdown/i, //"enetdown" - network down
+    /enetunreach/i, //"enetunreach" - network unreachable
+    /ehostdown/i, //"ehostdown" - host down
+    /ehostunreach/i, //"ehostunreach" - host unreachable
+  ];
+
+  const message = (error as { message?: unknown })?.message;
+
+  return networkErrorPatterns.some(
+    pattern => pattern.test(String(message)) || pattern.test(String(error))
+  );
+};
+
+export const isEventErrorsNetworkRelated = (event: Event) =>
+  event.errors.some(error => isNetworkError({ message: error.errorMessage }));
+
+export const handleNetworkError = (error: unknown, showToast = true) => {
+  if (isNetworkError(error)) {
+    if (showToast) {
+      Toast.show({
+        type: "error",
+        text2:
+          strings.en.errors.axios.networkError ||
+          "Please check your internet connection and try again",
+      });
+    }
+
+    return true;
+  }
+
+  return false;
+};

package/src/config/axios/paramsSerializer.ts

@@ -0,0 +1,9 @@
+import axios from "axios";
+import qs from "qs";
+
+const setParamsSerializer = () => {
+  axios.defaults.paramsSerializer = (params: Record<string, unknown>) =>
+    qs.stringify(params, { arrayFormat: "brackets" });
+};
+
+export default setParamsSerializer;

package/src/config/axios/types.ts

@@ -0,0 +1,13 @@
+import "axios";
+
+export interface CaseConversionOptions {
+  enableCaseConversion?: boolean;
+}
+
+// Requests may opt in or out of the snake_case/camelCase conversion the
+// interceptors apply, so the option travels on the axios config itself.
+declare module "axios" {
+  interface AxiosRequestConfig {
+    caseConversionOptions?: CaseConversionOptions;
+  }
+}

package/src/config/bugsnag.ts

@@ -0,0 +1,48 @@
+import BugsnagPluginReactNavigation from "@bugsnag/plugin-react-navigation";
+import Bugsnag, { type NotifiableError } from "@bugsnag/react-native";
+
+import {
+  isEventErrorsNetworkRelated,
+  isNetworkError,
+} from "./axios/networkErrorHandler";
+
+import { Store } from "../store";
+
+export const bugsnagErrorHandler = (err: NotifiableError, origin: string) => {
+  if (!__DEV__) {
+    Bugsnag.notify(err, event => {
+      if (isNetworkError(err)) {
+        return false;
+      }
+
+      event.severity = "warning";
+      event.context = origin;
+
+      return true;
+    });
+  }
+};
+
+export const configureBugsnag = () => {
+  if (!__DEV__) {
+    Bugsnag.start({
+      onError: event => {
+        const auth = Store.getState().auth;
+        if (auth.email) {
+          event.setUser(auth.userId, auth.email, auth.name);
+        }
+
+        if (event.device?.emulator) {
+          return false;
+        }
+
+        if (isEventErrorsNetworkRelated(event)) {
+          return false;
+        }
+
+        return true;
+      },
+      plugins: [new BugsnagPluginReactNavigation()],
+    });
+  }
+};

package/src/config/dayjs.ts

@@ -0,0 +1,42 @@
+import dayjs from "dayjs";
+import calendar from "dayjs/plugin/calendar";
+import isToday from "dayjs/plugin/isToday";
+import isYesterday from "dayjs/plugin/isYesterday";
+import relativeTime from "dayjs/plugin/relativeTime";
+import updateLocale from "dayjs/plugin/updateLocale";
+
+export const configureDayJS = () => {
+  dayjs.extend(isYesterday);
+  dayjs.extend(isToday);
+  dayjs.extend(calendar);
+  dayjs.extend(relativeTime);
+  dayjs.extend(updateLocale);
+};
+
+export const dateTimeFormats = Object.freeze({
+  time: "h:mm A",
+  date: "MMM D, YYYY",
+  dateWeek: "MMM D, YYYY ddd",
+  dateWeekWithoutYear: "MMM D, ddd",
+  dateTime: "MMM D, YYYY h:mm A",
+  dateWeekTime: "MMM D, YYYY ddd h:mm A",
+});
+
+type DateInput = dayjs.ConfigType;
+
+export const formatDateTime = Object.freeze({
+  fromNow: (time: DateInput) => dayjs(time).fromNow(),
+  time: (time: DateInput) => dayjs(time).format("h:mm A"),
+  date: (time: DateInput) => dayjs(time).format("MMM D, YYYY"),
+  dateWeek: (time: DateInput) => dayjs(time).format("MMM D, YYYY ddd"),
+  dateWeekWithoutYear: (time: DateInput) => dayjs(time).format("MMM D, ddd"),
+  dateTime: (time: DateInput) => dayjs(time).format("MMM D, YYYY h:mm A"),
+  dateWeekTime: (time: DateInput) =>
+    dayjs(time).format("MMM D, YYYY ddd h:mm A"),
+  extended: (time: DateInput) => {
+    const dateTime = dayjs(time).format("ddd, MMM D YYYY h:mm A");
+    const fromNow = dayjs(time).fromNow();
+
+    return `${dateTime} (${fromNow})`;
+  },
+});

package/src/config/googleSignin.ts

@@ -0,0 +1,36 @@
+import Bugsnag from "@bugsnag/react-native";
+import { GoogleSignin } from "@react-native-google-signin/google-signin";
+import Config from "react-native-config";
+
+const { GOOGLE_WEB_CLIENT_ID, IOS_CLIENT_ID } = Config;
+
+export const configureGoogleSignin = () => {
+  if (GOOGLE_WEB_CLIENT_ID && typeof GOOGLE_WEB_CLIENT_ID === "string") {
+    GoogleSignin.configure({
+      webClientId: GOOGLE_WEB_CLIENT_ID,
+      iosClientId: IOS_CLIENT_ID,
+      offlineAccess: true,
+    });
+  } else {
+    if (!__DEV__) {
+      Bugsnag.notify(
+        new Error(
+          "Google Sign-In Configuration Error: GOOGLE_WEB_CLIENT_ID is missing or invalid in environment configuration (.env). Please ensure it is set correctly in the consuming application."
+        ),
+        event => {
+          event.severity = "error";
+          event.context = "google_signin_configuration";
+          event.addMetadata("configuration", {
+            feature: "google_signin",
+            configuration: "web_client_id",
+          });
+        }
+      );
+    } else {
+      // eslint-disable-next-line no-console
+      console.error(
+        "Google Sign-In Configuration Error: GOOGLE_WEB_CLIENT_ID is missing or invalid in environment configuration (.env). Please ensure it is set correctly in the consuming application."
+      );
+    }
+  }
+};

package/src/config/index.ts

@@ -0,0 +1,11 @@
+import { configureAxios } from "./axios";
+import { configureDayJS } from "./dayjs";
+import { configureGoogleSignin } from "./googleSignin";
+import { configureValidationsLocales } from "./validations";
+
+export const initializeConfigs = () => {
+  configureAxios();
+  configureGoogleSignin();
+  configureValidationsLocales();
+  configureDayJS();
+};

package/src/config/validations.ts

@@ -0,0 +1,15 @@
+import * as Yup from "yup";
+
+import { toTitleCase } from "../helpers/utils";
+
+export const configureValidationsLocales = () => {
+  Yup.setLocale({
+    mixed: {
+      required: ({ path }: { path: string }) =>
+        `${toTitleCase(path)} is a required field.`,
+    },
+    string: {
+      email: "Please enter valid email address.",
+    },
+  });
+};

package/src/constants/index.ts

@@ -0,0 +1,9 @@
+export { dateTimeFormats } from "../config/dayjs";
+
+export const STORAGE_KEYS = {
+  DEVICE_TOKEN: "devicetoken",
+  IS_VISITED: "isVisited",
+  NOTIFICATION_PERMISSION_REQUESTED: "notificationPermissionRequested",
+} as const;
+
+export const DEFAULT_PAGE_SIZE = 30;

package/src/contexts/index.ts

@@ -0,0 +1,4 @@
+// Contexts are imported from their own modules (e.g.
+// "@bigbinary/neeto-commons-rn/contexts/localization"). This barrel is
+// intentionally empty; the export keeps it a module rather than a script.
+export {};