@lmnto/h-mall-shared 1.0.1

package/shared/hooks/useAddressForm.ts

@@ -0,0 +1,169 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { useEffect } from "react";
+
+import { ADDRESS_TYPES } from "../constants/app";
+import { QueryKeys } from "../constants/query-keys";
+import {
+  proceedGetCitiesAsync,
+  proceedGetStatesAsync,
+} from "../services/addresses.service";
+import {
+  AddressesService,
+  StoresService,
+  UpdateUserAddressDto,
+} from "../services/api";
+import { useCartStore } from "../stores/cartStore";
+import { countriesStore } from "../stores/countriesStore";
+import { notification } from "../utils/notifications.util";
+import { useShippingAddressForm } from "./useShippingAddressForm";
+
+export function useAddressForm() {
+  //
+  const {
+    setStates,
+    setShippingStates,
+    setCities,
+    setShippingCities,
+    setLoading,
+    setLoadingCities,
+    setShippingLoadingCities,
+    setStores,
+  } = countriesStore();
+  const { userBillingAddress, setUserBillingAddress } = useCartStore();
+
+  const { getShippingAddress } = useShippingAddressForm();
+
+  const getCityByStateAndCountry = useMutation({
+    mutationKey: [QueryKeys.users.GET_SHIPPING_STATE_BY_COUNTRY],
+    mutationFn: ({
+      countryId,
+      stateId,
+    }: {
+      countryId: number;
+      stateId?: number;
+    }) => proceedGetCitiesAsync(countryId, stateId),
+    onSuccess: (data) => {
+      setCities(data);
+      setLoadingCities(false);
+    },
+    onError: () => {},
+  });
+  const getShippingCityByStateAndCountry = useMutation({
+    mutationKey: [QueryKeys.users.GET_SHIPPING_CITY_BY_STATE_AND_COUNTRY],
+    mutationFn: ({
+      countryId,
+      stateId,
+    }: {
+      countryId: number;
+      stateId?: number;
+    }) => proceedGetCitiesAsync(countryId, stateId),
+    onSuccess: (data) => {
+      setShippingCities(data);
+      setShippingLoadingCities(false);
+    },
+    onError: () => {},
+  });
+
+  const getStatesByCountry = useMutation({
+    mutationKey: [QueryKeys.users.GET_STATE_BY_COUNTRY],
+    mutationFn: proceedGetStatesAsync,
+    onSuccess: async (data: any[]) => {
+      setStates(data);
+      setLoading(false);
+    },
+    onError: () => {},
+  });
+  const getShippingStatesByCountry = useMutation({
+    mutationKey: [QueryKeys.users.GET_SHIPPING_STATE_BY_COUNTRY],
+    mutationFn: proceedGetStatesAsync,
+    onSuccess: async (data: any[]) => {
+      setShippingStates(data);
+      setLoading(false);
+    },
+    onError: () => {},
+  });
+
+  const getStoreByCountry = useMutation({
+    mutationKey: [QueryKeys.users.GET_STORE_BY_COUNTRY],
+    mutationFn: StoresService.storesControllerFindAll,
+    onSuccess: async (data: any[]) => {
+      setStores(data);
+      setLoading(false);
+    },
+    onError: () => {},
+  });
+
+  const addNewAddress = useMutation({
+    mutationKey: [QueryKeys.users.ADD_NEW_ADDRESS],
+    mutationFn: AddressesService.userAddressesControllerAddNewAddress,
+    onSuccess: () => {
+      setStates([]);
+      setShippingStates([]);
+      setCities([]);
+      setShippingCities([]);
+      getAddress();
+    },
+    onError: () => {},
+  });
+
+  const updateAddress = useMutation({
+    mutationKey: [QueryKeys.users.UPDATE_ADDRESS],
+    mutationFn: ({
+      id,
+      requestBody,
+    }: {
+      id: number;
+      requestBody: UpdateUserAddressDto;
+    }) =>
+      AddressesService.userAddressesControllerUpdateAddress(id, requestBody),
+    onSuccess: () => {
+      notification.notifySuccess("Your address has been updated successfully");
+      getAddress();
+      getShippingAddress();
+    },
+    onError: () => {},
+  });
+
+  const deleteAddress = useMutation({
+    mutationKey: [QueryKeys.users.DELETE_ADDRESS],
+    mutationFn: ({ id }: { id: number }) =>
+      AddressesService.userAddressesControllerDeleteAddress(id),
+    onSuccess: () => {
+      notification.notifySuccess("Your address has been deleted successfully");
+      getAddress();
+      getShippingAddress();
+    },
+    onError: () => {},
+  });
+
+  const {
+    data: userBilling,
+    isLoading: isLoadingAddresses,
+    refetch: getAddress,
+  } = useQuery({
+    queryKey: [QueryKeys.users.GET_ADDRESSES],
+    queryFn: () =>
+      AddressesService.userAddressesControllerGetAllActiveUserAddresses(
+        ADDRESS_TYPES.billing.value,
+      ),
+    enabled: !userBillingAddress,
+  });
+
+  useEffect(() => {
+    setUserBillingAddress(userBilling);
+  }, [userBilling, setUserBillingAddress]);
+
+  return {
+    getStatesByCountry,
+    getShippingStatesByCountry,
+    getStoreByCountry,
+    getCityByStateAndCountry,
+    getShippingCityByStateAndCountry,
+    addNewAddress,
+    updateAddress,
+    deleteAddress,
+    billingAddress: userBillingAddress,
+    isLoadingAddresses,
+    getAddress,
+  };
+}

package/shared/hooks/useAddresses.ts

@@ -0,0 +1,28 @@
+import { useRef } from "react";
+
+import { AddressSchema } from "../constants/address.schema";
+import useAppForm from "../hooks/useAppForm";
+
+export default function useAddresses() {
+  const formId = useRef("billingAddress");
+
+  const { handleSubmit, reset, setValue } = useAppForm({
+    schema: AddressSchema(),
+    defaultValues: {
+      firstName: "",
+      lastName: "",
+      address: "",
+      type: "",
+      countryId: null,
+      state: "",
+      city: "",
+      postalCode: "",
+      phone: "",
+      zipCodeRegex: "",
+      zipCodeExample: [],
+      minPhoneLength: "5",
+    },
+    id: formId.current,
+  });
+  return { formId, handleSubmit, resetForm: reset, setFormValue: setValue };
+}

package/shared/hooks/useAppForm.ts

@@ -0,0 +1,39 @@
+import { yupResolver } from "@hookform/resolvers/yup";
+import { useLayoutEffect } from "react";
+import { DefaultValues, useForm, UseFormReturn } from "react-hook-form";
+
+import { useFormStore } from "../stores/formStore";
+
+type FormValues = { [key: string]: any }; // Dynamic type for form values
+
+interface UseFormProps<T extends FormValues> {
+  schema: any; // Yup schema for validation
+  defaultValues?: T | DefaultValues<T> | undefined; // Optional default values for the form
+  id: string;
+}
+
+const useAppForm = <T extends FormValues>({
+  schema,
+  defaultValues,
+  id,
+}: UseFormProps<T>): UseFormReturn<T> => {
+  const { setReactHookUseForm } = useFormStore();
+
+  const hookForm = useForm({
+    // mode: "all",
+    resolver: yupResolver(schema) as any, // Integrate Yup for validation
+    defaultValues: defaultValues as DefaultValues<T> | undefined,
+    reValidateMode: "onChange",
+  });
+
+  useLayoutEffect(() => {
+    setReactHookUseForm({
+      [id]: hookForm,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [id, setReactHookUseForm]);
+
+  return hookForm;
+};
+
+export default useAppForm;

package/shared/hooks/useCart.ts

@@ -0,0 +1,207 @@
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { useCallback, useEffect, useState } from "react";
+
+import { QueryKeys } from "../constants/query-keys";
+import { useMainContext } from "../contexts/MainWrapperContext";
+import { CartsService } from "../services/api";
+import { ShippingMethodsService } from "../services/api";
+import { useCartStore } from "../stores/cartStore";
+import { countriesStore } from "../stores/countriesStore";
+import { withTimeout } from "../utils/app.util";
+
+export function useCart() {
+  const [revalidateCartSuccess, setRevalidateCartSuccess] = useState(false);
+  const { triggerInvalidDialog } = useMainContext();
+  const { setShippingCountries } = countriesStore();
+
+  //
+  const { cart, commissionNonEligibleFound, setLoading, setCart } =
+    useCartStore();
+
+  const { data: cartData, refetch: getCart } = useQuery({
+    queryKey: [QueryKeys.cart.GET_CART],
+    queryFn: CartsService.cartsControllerGetCart,
+    enabled: true,
+  });
+
+  useEffect(() => {
+    // Update cart store whenever cartData changes, including when it's null (empty cart)
+    if (cartData !== undefined && revalidateCartSuccess) {
+      setCart(cartData);
+    }
+  }, [cartData, setCart, revalidateCartSuccess]);
+
+  const revalidateCart = useCallback(async () => {
+    await setRevalidateCartSuccess(false);
+    const result = await getCart();
+    await setRevalidateCartSuccess(result.status === "success");
+  }, [getCart]);
+
+  const addToCart = useMutation({
+    mutationKey: [QueryKeys.cart.ADD_TO_CART],
+    mutationFn: CartsService.cartsControllerAddCartProduct,
+    onMutate: () => setLoading(true),
+    onSuccess: () => {
+      //
+      revalidateCart();
+    },
+    onError: (error: any) => {
+      setLoading(false);
+      if (error?.status === 404) {
+        triggerInvalidDialog();
+        return;
+      }
+    },
+  });
+
+  const removeProductFromCart = useMutation({
+    mutationKey: [QueryKeys.cart.REMOVE_FROM_CART],
+    mutationFn: CartsService.cartsControllerRemoveCartProduct,
+    onMutate: () => setLoading(true),
+    onSuccess: () => {
+      revalidateCart();
+    },
+    onError: () => setLoading(false),
+  });
+
+  const removeProductsFromCart = useMutation({
+    mutationKey: [QueryKeys.cart.REMOVE_PRODUCT_FROM_CART],
+    mutationFn: CartsService.cartsControllerDeleteCartProducts,
+    onMutate: () => setLoading(true),
+    onSuccess: () => {
+      revalidateCart();
+    },
+    onError: () => setLoading(false),
+  });
+
+  const updateCartState = useMutation({
+    mutationKey: [QueryKeys.cart.UPDATE_CART_STATE],
+    mutationFn: CartsService.cartsControllerUpdateCartState,
+    onMutate: () => setLoading(true),
+    onSuccess: async () => {
+      revalidateCart();
+    },
+    onError: () => setLoading(false),
+  });
+
+  const updateCartAddresses = useMutation({
+    mutationKey: [QueryKeys.cart.UPDATE_ADDRESSES],
+    mutationFn: CartsService.cartsControllerUpdateAddresses,
+    onMutate: () => setLoading(true),
+    onSuccess: () => revalidateCart(),
+    onError: () => setLoading(false),
+  });
+
+  //#TODO Update with the Update shipping address API
+  const updateCartShippingAddresses = useMutation({
+    mutationKey: [QueryKeys.cart.UPDATE_SHIPPING_ADDRESSES],
+    mutationFn: CartsService.cartsControllerShippingAddresses,
+    onMutate: () => setLoading(true),
+    onSuccess: () => revalidateCart(),
+    onError: () => setLoading(false),
+  });
+
+  const updatePaymentMethod = useMutation({
+    mutationKey: [QueryKeys.cart.UPDATE_PAYMENT_METHOD],
+    mutationFn: ({
+      paymentMethodId,
+      paymentOptionId,
+      fromAssetSelectedPercentage,
+    }: {
+      paymentMethodId: number;
+      paymentOptionId: number;
+      fromAssetSelectedPercentage: number;
+    }) =>
+      CartsService.cartsControllerUpdatePaymentMethod({
+        paymentMethodId: paymentMethodId,
+        paymentOptionId: paymentOptionId,
+        fromAssetSelectedPercentage: fromAssetSelectedPercentage,
+      }),
+    onMutate: () => setLoading(true),
+    onSuccess: () => revalidateCart(),
+    onError: () => setLoading(false),
+  });
+
+  const deleteCart = useMutation({
+    mutationKey: [QueryKeys.cart.DELETE_CART],
+    mutationFn: CartsService.cartsControllerDeleteCart,
+    onMutate: () => setLoading(true),
+    onSuccess: () => {
+      revalidateCart();
+    },
+    onError: () => setLoading(false),
+  });
+
+  const refreshCart = useMutation({
+    mutationKey: [QueryKeys.cart.REFRESH_CART],
+    mutationFn: async (mode: string) => {
+      try {
+        await CartsService.cartsControllerValidateCart(mode);
+        return true;
+      } catch (error) {
+        console.log("🚀 ~ useCart ~ error:", error);
+        return false;
+      }
+    },
+    onMutate: () => setLoading(true),
+    onSuccess: () => revalidateCart(),
+    onError: () => setLoading(false),
+  });
+
+  const getShippingMethods = useMutation({
+    mutationKey: [QueryKeys.shippingCart.GET_SHIPPING_METHODS],
+    //#TODO Update with the Get shipping methods API for the new cart flow
+    mutationFn: () => ShippingMethodsService.shippingMethodControllerFindAll(),
+    onSuccess: async () => {},
+    onError: () => setLoading(false),
+  });
+
+  const getCountriesByShippingMethodId = useMutation({
+    mutationKey: [QueryKeys.upgradeCart.GET_COUNTRIES_BY_SHIPPING_METHOD],
+    retry: 5,
+    retryDelay: 1000,
+    mutationFn: ({ shippingMethodId }: { shippingMethodId: number }) =>
+      // proceedGetShippingCountriesAsync(shippingMethodId),
+      withTimeout(
+        CartsService.getCountriesByShippingMethod(shippingMethodId),
+        3000, // 3 seconds timeout
+      ),
+
+    onSuccess: (data: any) => {
+      setShippingCountries(data);
+    },
+    onError: (error: any) => {
+      console.log("🚀 ~ useMigrationCart ~ error:", error);
+    },
+  });
+
+  const resetCartAddress = useMutation({
+    mutationKey: [QueryKeys.cart.RESET_CART_ADDRESS],
+    mutationFn: (type: string) => CartsService.resetCartAddresses(type),
+    onMutate: () => setLoading(true),
+    onSuccess: async () => {
+      revalidateCart();
+    },
+
+    onError: () => setLoading(false),
+  });
+
+  return {
+    cart,
+    getCart,
+    addToCart,
+    deleteCart,
+    updateCartState,
+    // deleteFromCart,
+    updateCartAddresses: updateCartAddresses,
+    updateCartShippingAddresses: updateCartShippingAddresses,
+    resetCartAddress: resetCartAddress,
+    updatePaymentMethod,
+    removeProductFromCart,
+    commissionNonEligibleFound,
+    removeProductsFromCart,
+    refreshCart,
+    getShippingMethods,
+    getCountriesByShippingMethodId,
+  };
+}

package/shared/hooks/useCopy.ts

@@ -0,0 +1,45 @@
+import { useCallback } from "react";
+
+import { notification } from "../utils/notifications.util";
+
+const useCopy = () => {
+  const handleCopy = useCallback((text: string) => {
+    if (
+      typeof window !== "undefined" &&
+      navigator.clipboard &&
+      navigator.clipboard.writeText
+    ) {
+      navigator.clipboard
+        .writeText(text)
+        .then(() => {
+          notification.notifySuccess("Copied to clipboard!");
+        })
+        .catch(() => {
+          notification.notifyError("Failed to copy text");
+        });
+    } else {
+      // Fallback for environments without clipboard API
+      try {
+        const textArea = document.createElement("textarea");
+        textArea.value = text;
+        textArea.style.position = "fixed"; // Prevent scrolling to bottom of page
+        textArea.style.opacity = "0"; // Hide the element
+        document.body.appendChild(textArea);
+        textArea.select();
+        document.execCommand("copy");
+        document.body.removeChild(textArea);
+
+        notification.notifySuccess("Copied to clipboard!");
+      } catch (err) {
+        console.log("🚀 ~ useCopy ~ err:", err);
+        notification.notifyError("Failed to copy text");
+      }
+    }
+  }, []);
+
+  return {
+    handleCopy,
+  };
+};
+
+export default useCopy;

package/shared/hooks/useCountries.ts

@@ -0,0 +1,27 @@
+import { useQuery } from "@tanstack/react-query";
+import { useEffect } from "react";
+
+import { QueryKeys } from "../constants/query-keys";
+import { AddressesService } from "../services/api";
+import { countriesStore } from "../stores/countriesStore";
+
+export function useCountries() {
+  //
+  const { countries, setCountries, setLoading } = countriesStore();
+
+  const { data: countriesData, refetch: getCountries } = useQuery({
+    queryKey: [QueryKeys.users.GET_COUNTRIES],
+    queryFn: AddressesService.addressesControllerGetCountries,
+    enabled: !countries,
+  });
+
+  useEffect(() => {
+    setCountries(countriesData);
+    setLoading(false);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [countriesData, setCountries]);
+
+  return {
+    getCountries,
+  };
+}

package/shared/hooks/useCustomRouter.ts

@@ -0,0 +1,51 @@
+import { NavigateOptions } from "next/dist/shared/lib/app-router-context.shared-runtime";
+import { usePathname, useRouter } from "next/navigation";
+import { useCallback } from "react";
+
+import { useLoadingStore } from "../stores/loadingStore";
+
+const useCustomRouter = () => {
+  //
+  const { setLoading } = useLoadingStore();
+  const { push, replace, refresh } = useRouter();
+  const pathname = usePathname();
+
+  const customPush = useCallback(
+    (link: string, options?: NavigateOptions | undefined) => {
+      if (pathname != link && !link.startsWith("http")) {
+        setLoading(true);
+
+        setTimeout(() => {
+          setLoading(false);
+        }, 5000);
+      }
+      push(link, options);
+    },
+    [push, pathname, setLoading],
+  );
+
+  const customReplace = useCallback(
+    (link: string, options?: NavigateOptions | undefined) => {
+      if (pathname != link && !link.startsWith("http")) {
+        setLoading(true);
+
+        setTimeout(() => {
+          setLoading(false);
+        }, 5000);
+      }
+      replace(link, options);
+    },
+    [replace, pathname, setLoading],
+  );
+
+  const customRouter = {
+    push: customPush,
+    replace: customReplace,
+    refresh,
+    pathname,
+  };
+
+  return customRouter;
+};
+
+export default useCustomRouter;

package/shared/hooks/useDebounce.ts

@@ -0,0 +1,21 @@
+export default function useDebounce(func: any, delay: number) {
+  let timeoutId: NodeJS.Timeout | undefined = undefined;
+
+  return function (...args: any) {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => {
+      func.apply(this, args);
+    }, delay);
+  };
+}
+
+let timeoutGlobalId: NodeJS.Timeout | undefined = undefined;
+
+export function useGlobalDebounce(func: any, delay: number) {
+  return function (...args: any) {
+    clearTimeout(timeoutGlobalId);
+    timeoutGlobalId = setTimeout(() => {
+      func.apply(this, args);
+    }, delay);
+  };
+}

package/shared/hooks/useInvoice.ts

@@ -0,0 +1,41 @@
+import { useMutation } from "@tanstack/react-query";
+
+import { QueryKeys } from "../constants/query-keys";
+import { OrdersService, ShipmentOrdersService } from "../services/api";
+
+export function useInvoice() {
+  //
+
+  const generateOrderInvoiceAPI = useMutation({
+    mutationKey: [QueryKeys.invoices.GENERATE_INVOICES],
+    mutationFn: ({ orderId }: { orderId: string }) =>
+      OrdersService.ordersControllerGetOrderInvoice(orderId),
+    // onMutate: () => setLoading(true),
+    onSuccess: async () => {},
+    onError: () => {},
+  });
+
+  const generateCreditNoteInvoiceAPI = useMutation({
+    mutationKey: [QueryKeys.invoices.GENERATE_INVOICES],
+    mutationFn: ({ creditNote, type }: { creditNote: string; type: string }) =>
+      OrdersService.ordersControllerGetCreditNoteInvoice(creditNote, type),
+    // onMutate: () => setLoading(true),
+    onSuccess: async () => {},
+    onError: () => {},
+  });
+
+  const generateShippingOrderInvoiceAPI = useMutation({
+    mutationKey: [QueryKeys.invoices.GENERATE_SHIPPING_INVOICES],
+    mutationFn: ({ orderId }: { orderId: string }) =>
+      ShipmentOrdersService.shippingOrdersControllerGetOrderInvoice(orderId),
+    // onMutate: () => setLoading(true),
+    onSuccess: async () => {},
+    onError: () => {},
+  });
+
+  return {
+    generateOrderInvoiceAPI,
+    generateShippingOrderInvoiceAPI,
+    generateCreditNoteInvoiceAPI,
+  };
+}

package/shared/hooks/useOnlineUser.ts

@@ -0,0 +1,38 @@
+import { useQuery } from "@tanstack/react-query";
+import { useEffect, useState } from "react";
+
+import { QueryKeys } from "../constants/query-keys";
+import { UsersService } from "../services/api";
+import { IUserProfile } from "../types/user";
+
+const useOnlineUser = () => {
+  const [onlineUser, setOnlineUser] = useState<IUserProfile>();
+
+  const { data: onlineData, refetch: getUser } = useQuery({
+    queryKey: [QueryKeys.users.GET_USER],
+    queryFn: () => UsersService.usersControllerGetProfile(),
+    enabled: true,
+  });
+
+  const { refetch: getAletaAuth } = useQuery({
+    queryKey: ["ALETA_AUTH"],
+    queryFn: () => UsersService.paymentGatewayControllerGetProfile(),
+    enabled: false,
+  });
+
+  useEffect(() => {
+    (async () => await setOnlineUser(onlineData))();
+  }, [setOnlineUser, onlineData]);
+
+  useEffect(() => {
+    getUser();
+  }, [getUser]);
+
+  return {
+    onlineUser,
+    getUser,
+    getAletaAuth,
+  };
+};
+
+export default useOnlineUser;