hey-pharmacist-ecommerce 1.1.29 → 1.1.31

package/src/hooks/useReviews.ts

@@ -0,0 +1,230 @@
+import { useState, useEffect, useCallback } from 'react';
+import { ReviewApi } from '@/lib/Apis/apis/review-api';
+import { getApiConfiguration } from '@/lib/api-adapter';
+import { Review, CreateReviewDto } from '@/lib/Apis/models';
+import { useAuth } from '@/providers/AuthProvider';
+
+export function useProductReviews(productId: string) {
+  const [reviews, setReviews] = useState<Review[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchReviews = useCallback(async () => {
+    if (!productId) {
+      setIsLoading(false);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await new ReviewApi(getApiConfiguration()).getReviewsByProduct(productId);
+      setReviews(response.data || []);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [productId]);
+
+  useEffect(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+
+  return {
+    reviews,
+    isLoading,
+    error,
+    refetch: fetchReviews,
+  };
+}
+
+export function useUserReviews(userId?: string) {
+  const [reviews, setReviews] = useState<Review[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  const { user } = useAuth();
+  const resolvedUserId = userId || (user as any)?._id || (user as any)?.id;
+
+  const fetchReviews = useCallback(async () => {
+    if (!resolvedUserId) {
+      setIsLoading(false);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await new ReviewApi(getApiConfiguration()).getReviewsByUser(resolvedUserId);
+      setReviews(response.data || []);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [resolvedUserId]);
+
+  useEffect(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+
+  return {
+    reviews,
+    isLoading,
+    error,
+    refetch: fetchReviews,
+  };
+}
+
+export function useReviewsByRating(rating: number) {
+  const [reviews, setReviews] = useState<Review[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchReviews = useCallback(async () => {
+    if (!rating || rating < 1 || rating > 5) {
+      setIsLoading(false);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await new ReviewApi(getApiConfiguration()).getReviewsByRating(rating);
+      setReviews(response.data || []);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [rating]);
+
+  useEffect(() => {
+    fetchReviews();
+  }, [fetchReviews]);
+
+  return {
+    reviews,
+    isLoading,
+    error,
+    refetch: fetchReviews,
+  };
+}
+
+export function useCreateReview() {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [success, setSuccess] = useState(false);
+
+  const createReview = useCallback(async (orderId: string, reviewData: CreateReviewDto) => {
+    setIsLoading(true);
+    setError(null);
+    setSuccess(false);
+
+    try {
+      const response = await new ReviewApi(getApiConfiguration()).createReview(reviewData, orderId);
+      setSuccess(true);
+      return response.data;
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  const reset = useCallback(() => {
+    setError(null);
+    setSuccess(false);
+    setIsLoading(false);
+  }, []);
+
+  return {
+    createReview,
+    isLoading,
+    error,
+    success,
+    reset,
+  };
+}
+
+export function useUpdateReview() {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const updateReview = useCallback(async (reviewId: string, reviewData: any) => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const response = await new ReviewApi(getApiConfiguration()).updateReview(reviewData, reviewId);
+      return response.data;
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  return {
+    updateReview,
+    isLoading,
+    error,
+  };
+}
+
+export function useDeleteReview() {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const deleteReview = useCallback(async (reviewId: string) => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      await new ReviewApi(getApiConfiguration()).removeReview(reviewId);
+    } catch (err) {
+      setError(err as Error);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  return {
+    deleteReview,
+    isLoading,
+    error,
+  };
+}
+
+export function useReviewStats() {
+  const [count, setCount] = useState(0);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const fetchCount = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await new ReviewApi(getApiConfiguration()).getReviewCount();
+      setCount(response.data || 0);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchCount();
+  }, [fetchCount]);
+
+  return {
+    count,
+    isLoading,
+    error,
+    refetch: fetchCount,
+  };
+}

package/src/hooks/useStoreCapabilities.ts

@@ -0,0 +1,87 @@
+'use client';
+
+import { useCallback, useEffect, useState } from 'react';
+import { StoreCapabilitiesDto, StoresApi } from '@/lib/Apis';
+import { AXIOS_CONFIG } from '@/lib/Apis/wrapper';
+import { getCurrentConfig } from '@/lib/api-adapter/config';
+
+interface UseStoreCapabilitiesReturn {
+    capabilities: StoreCapabilitiesDto | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+    // Computed convenience properties
+    showCardPayment: boolean;
+    showShippoDelivery: boolean;
+    showCustomDelivery: boolean;
+}
+
+// Cache to avoid redundant API calls across components
+let cachedCapabilities: StoreCapabilitiesDto | null = null;
+let cacheStoreId: string | null = null;
+
+export function useStoreCapabilities(): UseStoreCapabilitiesReturn {
+    const [capabilities, setCapabilities] = useState<StoreCapabilitiesDto | null>(cachedCapabilities);
+    const [isLoading, setIsLoading] = useState<boolean>(!cachedCapabilities);
+    const [error, setError] = useState<Error | null>(null);
+
+    const fetchCapabilities = useCallback(async (forceRefresh = false) => {
+        try {
+            const config = getCurrentConfig();
+            const storeId = config?.storeId;
+
+            if (!storeId) {
+                setError(new Error('Store ID not configured'));
+                setIsLoading(false);
+                return;
+            }
+
+            // Use cache if available and for the same store
+            if (!forceRefresh && cachedCapabilities && cacheStoreId === storeId) {
+                setCapabilities(cachedCapabilities);
+                setIsLoading(false);
+                return;
+            }
+
+            setIsLoading(true);
+            setError(null);
+
+            const api = new StoresApi(AXIOS_CONFIG);
+            const response = await api.getStoreCapabilities(storeId);
+
+            // Update cache
+            cachedCapabilities = response.data;
+            cacheStoreId = storeId;
+
+            setCapabilities(response.data);
+        } catch (err) {
+            console.error('Failed to fetch store capabilities:', err);
+            setError(err instanceof Error ? err : new Error('Failed to fetch store capabilities'));
+        } finally {
+            setIsLoading(false);
+        }
+    }, []);
+
+    const refresh = useCallback(async () => {
+        await fetchCapabilities(true);
+    }, [fetchCapabilities]);
+
+    useEffect(() => {
+        fetchCapabilities();
+    }, [fetchCapabilities]);
+
+    // Computed convenience properties based on the logic from the API guide
+    const showCardPayment = Boolean(capabilities?.hasStripeKey && capabilities?.cardPaymentEnabled);
+    const showShippoDelivery = Boolean(capabilities?.hasShippoKey && capabilities?.shippoDeliveryEnabled);
+    const showCustomDelivery = Boolean(capabilities?.customDeliveryEnabled);
+
+    return {
+        capabilities,
+        isLoading,
+        error,
+        refresh,
+        showCardPayment,
+        showShippoDelivery,
+        showCustomDelivery,
+    };
+}

package/src/index.ts

@@ -7,6 +7,7 @@ export { AuthProvider, useAuth } from './providers/AuthProvider';
 export { CartProvider, useCart } from './providers/CartProvider';
 export { WishlistProvider, useWishlist } from './providers/WishlistProvider';
 export { useBasePath } from './providers/BasePathProvider';
+export { NotificationCenterProvider, useNotificationCenter } from './providers/NotificationCenterProvider';
 
 // Screens
 export { ShopScreen } from './screens/ShopScreen';
@@ -25,6 +26,8 @@ export { default as WishlistScreen } from './screens/WishlistScreen';
 export { default as SearchResultsScreen } from './screens/SearchResultsScreen';
 export { default as NewAddressScreen } from './screens/NewAddressScreen';
 export { EditProfileScreen } from './screens/EditProfileScreen';
+export { OrderReviewsScreen } from './screens/OrderReviewsScreen';
+export { NotificationSettingsScreen } from './screens/NotificationSettingsScreen';
 
 // Components
 export { Header } from './components/Header';
@@ -33,6 +36,19 @@ export { ProductCard } from './components/ProductCard';
 export { CartItem } from './components/CartItem';
 export { OrderCard } from './components/OrderCard';
 export { EmptyState } from './components/EmptyState';
+export { NotificationBell } from './components/NotificationBell';
+export { NotificationDrawer } from './components/NotificationDrawer';
+export { NotificationCard } from './components/NotificationCard';
+
+// Review Components
+export { StarRating } from './components/StarRating';
+export { ReviewCard } from './components/ReviewCard';
+export { ReviewForm } from './components/ReviewForm';
+export { RatingDistribution } from './components/RatingDistribution';
+export { ReviewsList } from './components/ReviewsList';
+export { ProductReviewsSection } from './components/ProductReviewsSection';
+export { ReviewPromptBanner } from './components/ReviewPromptBanner';
+export { AccountReviewsTab } from './components/AccountReviewsTab';
 
 // UI Components
 export { Button } from './components/ui/Button';
@@ -45,6 +61,16 @@ export { Skeleton, ProductCardSkeleton, OrderCardSkeleton } from './components/u
 export { useProducts, useProduct, useCategories } from './hooks/useProducts';
 export { useOrders, useOrder, useCurrentOrders } from './hooks/useOrders';
 export { useAddresses } from './hooks/useAddresses';
+export { useStoreCapabilities } from './hooks/useStoreCapabilities';
+export {
+  useProductReviews,
+  useUserReviews,
+  useReviewsByRating,
+  useCreateReview,
+  useUpdateReview,
+  useDeleteReview,
+  useReviewStats,
+} from './hooks/useReviews';
 
 
 // API Adapter (for advanced usage)
@@ -58,6 +84,9 @@ export type {
   OrderStatus,
 } from './lib/types';
 
+// Export all API types (generated from Swagger)
+export * from './lib/Apis/models';
+
 // Utils
 export { formatPrice, formatDate, truncate, getInitials } from './lib/utils/format';
 export { generateColorShades, hexToRgb } from './lib/utils/colors';

package/src/lib/Apis/apis/auth-api.ts

@@ -189,10 +189,11 @@ export const AuthApiAxiosParamCreator = function (configuration?: Configuration)
          * @summary Reset user password
          * @param {string} newPassword 
          * @param {string} token 
+         * @param {string} xStoreKey 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        resetPassword: async (newPassword: string, token: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+        resetPassword: async (newPassword: string, token: string, xStoreKey: string, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'newPassword' is not null or undefined
             if (newPassword === null || newPassword === undefined) {
                 throw new RequiredError('newPassword','Required parameter newPassword was null or undefined when calling resetPassword.');
@@ -201,6 +202,10 @@ export const AuthApiAxiosParamCreator = function (configuration?: Configuration)
             if (token === null || token === undefined) {
                 throw new RequiredError('token','Required parameter token was null or undefined when calling resetPassword.');
             }
+            // verify required parameter 'xStoreKey' is not null or undefined
+            if (xStoreKey === null || xStoreKey === undefined) {
+                throw new RequiredError('xStoreKey','Required parameter xStoreKey was null or undefined when calling resetPassword.');
+            }
             const localVarPath = `/auth/reset-password`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, 'https://example.com');
@@ -228,6 +233,10 @@ export const AuthApiAxiosParamCreator = function (configuration?: Configuration)
                 localVarHeaderParameter['token'] = String(token);
             }
 
+            if (xStoreKey !== undefined && xStoreKey !== null) {
+                localVarHeaderParameter['x-store-key'] = String(xStoreKey);
+            }
+
             const query = new URLSearchParams(localVarUrlObj.search);
             for (const key in localVarQueryParameter) {
                 query.set(key, localVarQueryParameter[key]);
@@ -606,11 +615,12 @@ export const AuthApiFp = function(configuration?: Configuration) {
          * @summary Reset user password
          * @param {string} newPassword 
          * @param {string} token 
+         * @param {string} xStoreKey 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async resetPassword(newPassword: string, token: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => Promise<AxiosResponse<void>>> {
-            const localVarAxiosArgs = await AuthApiAxiosParamCreator(configuration).resetPassword(newPassword, token, options);
+        async resetPassword(newPassword: string, token: string, xStoreKey: string, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => Promise<AxiosResponse<void>>> {
+            const localVarAxiosArgs = await AuthApiAxiosParamCreator(configuration).resetPassword(newPassword, token, xStoreKey, options);
             return (axios: AxiosInstance = globalAxios, basePath: string = BASE_PATH) => {
                 const axiosRequestArgs :AxiosRequestConfig = {...localVarAxiosArgs.options, url: basePath + localVarAxiosArgs.url};
                 return axios.request(axiosRequestArgs);
@@ -744,11 +754,12 @@ export const AuthApiFactory = function (configuration?: Configuration, basePath?
          * @summary Reset user password
          * @param {string} newPassword 
          * @param {string} token 
+         * @param {string} xStoreKey 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async resetPassword(newPassword: string, token: string, options?: AxiosRequestConfig): Promise<AxiosResponse<void>> {
-            return AuthApiFp(configuration).resetPassword(newPassword, token, options).then((request) => request(axios, basePath));
+        async resetPassword(newPassword: string, token: string, xStoreKey: string, options?: AxiosRequestConfig): Promise<AxiosResponse<void>> {
+            return AuthApiFp(configuration).resetPassword(newPassword, token, xStoreKey, options).then((request) => request(axios, basePath));
         },
         /**
          * 
@@ -858,12 +869,13 @@ export class AuthApi extends BaseAPI {
      * @summary Reset user password
      * @param {string} newPassword 
      * @param {string} token 
+     * @param {string} xStoreKey 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof AuthApi
      */
-    public async resetPassword(newPassword: string, token: string, options?: AxiosRequestConfig) : Promise<AxiosResponse<void>> {
-        return AuthApiFp(this.configuration).resetPassword(newPassword, token, options).then((request) => request(this.axios, this.basePath));
+    public async resetPassword(newPassword: string, token: string, xStoreKey: string, options?: AxiosRequestConfig) : Promise<AxiosResponse<void>> {
+        return AuthApiFp(this.configuration).resetPassword(newPassword, token, xStoreKey, options).then((request) => request(this.axios, this.basePath));
     }
     /**
      * 

package/src/lib/Apis/apis/categories-api.ts

@@ -22,6 +22,8 @@ import { CategoryFilters } from '../models';
 import { CategoryPopulated } from '../models';
 import { CategorysHeadlinesResponseDTO } from '../models';
 import { CreateCategoryDto } from '../models';
+import { ReorderCategoriesDto } from '../models';
+import { ReorderSuccessResponseDto } from '../models';
 import { UpdateCategoryDto } from '../models';
 /**
  * CategoriesApi - axios parameter creator
@@ -377,6 +379,66 @@ export const CategoriesApiAxiosParamCreator = function (configuration?: Configur
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * 
+         * @summary Reorder categories
+         * @param {ReorderCategoriesDto} body 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        reorderCategories: async (body: ReorderCategoriesDto, options: AxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new RequiredError('body','Required parameter body was null or undefined when calling reorderCategories.');
+            }
+            const localVarPath = `/categories/reorder`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, 'https://example.com');
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions :AxiosRequestConfig = { method: 'PATCH', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication bearer required
+            // http bearer authentication required
+            if (configuration && configuration.accessToken) {
+                const accessToken = typeof configuration.accessToken === 'function'
+                    ? await configuration.accessToken()
+                    : await configuration.accessToken;
+                localVarHeaderParameter["Authorization"] = "Bearer " + accessToken;
+            }
+
+            // authentication x-store-key required
+            if (configuration && configuration.apiKey) {
+                const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+                    ? await configuration.apiKey("x-store-key")
+                    : await configuration.apiKey;
+                localVarHeaderParameter["x-store-key"] = localVarApiKeyValue;
+            }
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            const query = new URLSearchParams(localVarUrlObj.search);
+            for (const key in localVarQueryParameter) {
+                query.set(key, localVarQueryParameter[key]);
+            }
+            for (const key in options.params) {
+                query.set(key, options.params[key]);
+            }
+            localVarUrlObj.search = (new URLSearchParams(query)).toString();
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            const needsSerialization = (typeof body !== "string") || (localVarRequestOptions.headers ||= {})['Content-Type'] === 'application/json';
+            localVarRequestOptions.data =  needsSerialization ? JSON.stringify(body !== undefined ? body : {}) : (body || "");
+
+            return {
+                url: localVarUrlObj.pathname + localVarUrlObj.search + localVarUrlObj.hash,
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * 
          * @summary Update category by id
@@ -537,6 +599,20 @@ export const CategoriesApiFp = function(configuration?: Configuration) {
                 return axios.request(axiosRequestArgs);
             };
         },
+        /**
+         * 
+         * @summary Reorder categories
+         * @param {ReorderCategoriesDto} body 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async reorderCategories(body: ReorderCategoriesDto, options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => Promise<AxiosResponse<ReorderSuccessResponseDto>>> {
+            const localVarAxiosArgs = await CategoriesApiAxiosParamCreator(configuration).reorderCategories(body, options);
+            return (axios: AxiosInstance = globalAxios, basePath: string = BASE_PATH) => {
+                const axiosRequestArgs :AxiosRequestConfig = {...localVarAxiosArgs.options, url: basePath + localVarAxiosArgs.url};
+                return axios.request(axiosRequestArgs);
+            };
+        },
         /**
          * 
          * @summary Update category by id
@@ -622,6 +698,16 @@ export const CategoriesApiFactory = function (configuration?: Configuration, bas
         async getSingleCategory(id: string, options?: AxiosRequestConfig): Promise<AxiosResponse<CategoryPopulated>> {
             return CategoriesApiFp(configuration).getSingleCategory(id, options).then((request) => request(axios, basePath));
         },
+        /**
+         * 
+         * @summary Reorder categories
+         * @param {ReorderCategoriesDto} body 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async reorderCategories(body: ReorderCategoriesDto, options?: AxiosRequestConfig): Promise<AxiosResponse<ReorderSuccessResponseDto>> {
+            return CategoriesApiFp(configuration).reorderCategories(body, options).then((request) => request(axios, basePath));
+        },
         /**
          * 
          * @summary Update category by id
@@ -710,6 +796,17 @@ export class CategoriesApi extends BaseAPI {
     public async getSingleCategory(id: string, options?: AxiosRequestConfig) : Promise<AxiosResponse<CategoryPopulated>> {
         return CategoriesApiFp(this.configuration).getSingleCategory(id, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * 
+     * @summary Reorder categories
+     * @param {ReorderCategoriesDto} body 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof CategoriesApi
+     */
+    public async reorderCategories(body: ReorderCategoriesDto, options?: AxiosRequestConfig) : Promise<AxiosResponse<ReorderSuccessResponseDto>> {
+        return CategoriesApiFp(this.configuration).reorderCategories(body, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * 
      * @summary Update category by id