shelflife-react-hooks 1.0.16 → 1.0.18

package/src/context/ShoppingListContext.tsx

@@ -6,7 +6,9 @@ import {
     fetchShoppingListRequest,
     createShoppingItemRequest,
     editShoppingItemRequest,
-    deleteShoppingItemRequest
+    deleteShoppingItemRequest,
+    createStorageItemsWithShoppingListItemRequest,
+    fetchAggregatedShoppingListRequest
 } from './api/shoppingListApi.js';
 
 type ShoppingListContextValue = {
@@ -14,6 +16,8 @@ type ShoppingListContextValue = {
     isLoading: boolean;
     isError: boolean;
     error: Error | null;
+    createStorageItemsWithShoppingListItem: (storageId: number, itemId: number) => Promise<void>;
+    fetchAggregated: () => Promise<ShoppingListItem[]>;
     fetchItems: (storageId: number) => Promise<ShoppingListItem[]>;
     createItem: (storageId: number, dto: CreateShoppingItemRequest) => Promise<ShoppingListItem>;
     editItem: (storageId: number, itemId: number, dto: EditShoppingItemRequest) => Promise<ShoppingListItem>;
@@ -40,6 +44,10 @@ export const ShoppingListProvider = ({ baseUrl, children }: ShoppingListProvider
         return fetchShoppingListRequest(apiConfig, storageId);
     }, [apiConfig]);
 
+    const createStorageItemsWithShoppingListItem = useCallback(async (storageId: number, itemId: number) => {
+        return createStorageItemsWithShoppingListItemRequest(apiConfig, storageId, itemId);
+    }, [apiConfig]);
+
     const createItem = useCallback(async (storageId: number, dto: CreateShoppingItemRequest) => {
         return createShoppingItemRequest(apiConfig, storageId, dto);
     }, [apiConfig]);
@@ -52,7 +60,11 @@ export const ShoppingListProvider = ({ baseUrl, children }: ShoppingListProvider
         return deleteShoppingItemRequest(apiConfig, storageId, itemId);
     }, [apiConfig]);
 
-    const value = useMemo(() => ({ items, isLoading, isError, error, fetchItems, createItem, editItem, deleteItem }), [items, isLoading, isError, error, fetchItems, createItem, editItem, deleteItem]);
+    const fetchAggregated = useCallback(async () => {
+        return fetchAggregatedShoppingListRequest(apiConfig);
+    }, [apiConfig]);
+
+    const value = useMemo(() => ({ items, isLoading, isError, error, fetchItems, createItem, editItem, deleteItem, createStorageItemsWithShoppingListItem, fetchAggregated }), [items, isLoading, isError, error, fetchItems, createItem, editItem, deleteItem, createStorageItemsWithShoppingListItem, fetchAggregated]);
 
     return <ShoppingListContext.Provider value={value}>{children}</ShoppingListContext.Provider>;
 };

package/src/context/StorageItemContext.tsx

@@ -14,6 +14,9 @@ import {
     deleteItemRequest,
     editItemRequest,
     fetchAboutToExpireRequest,
+    fetchAggregatedAboutToExpireRequest,
+    fetchAggregatedExpiredRequest,
+    fetchAggregatedRunningLowRequest,
     fetchExpiredRequest,
     fetchItemsRequest,
     fetchRunningLowRequest
@@ -32,8 +35,11 @@ type StorageItemContextValue = {
     editItem: (storageId: number, itemId: number, dto: EditItemRequest) => Promise<StorageItem>;
     deleteItem: (storageId: number, itemId: number) => Promise<void>;
     fetchExpired: (storageId: number) => Promise<StorageItem[]>;
+    fetchExpiredAggregated: () => Promise<StorageItem[]>;
     fetchAboutToExpire: (storageId: number) => Promise<StorageItem[]>;
+    fetchAboutToExpireAggregated: () => Promise<StorageItem[]>;
     fetchRunningLow: (storageId: number) => Promise<RunningLowNotification[]>;
+    fetchRunningLowAggregated: () => Promise<RunningLowNotification[]>;
 };
 
 type StorageItemProviderProps = {
@@ -82,14 +88,26 @@ export const StorageItemProvider = ({ baseUrl, children }: StorageItemProviderPr
         (storageId: number) => fetchExpiredRequest(apiConfig, storageId),
         [apiConfig]
     );
+    const fetchExpiredAggregated = useCallback(
+        () => fetchAggregatedExpiredRequest(apiConfig),
+        [apiConfig]
+    );
     const fetchAboutToExpire = useCallback(
         (storageId: number) => fetchAboutToExpireRequest(apiConfig, storageId),
         [apiConfig]
     );
+    const fetchAboutToExpireAggregated = useCallback(
+        () => fetchAggregatedAboutToExpireRequest(apiConfig),
+        [apiConfig]
+    );
     const fetchRunningLow = useCallback(
         (storageId: number) => fetchRunningLowRequest(apiConfig, storageId),
         [apiConfig]
     );
+    const fetchRunningLowAggregated = useCallback(
+        () => fetchAggregatedRunningLowRequest(apiConfig),
+        [apiConfig]
+    );
 
     const value = useMemo<StorageItemContextValue>(() => ({
         items,
@@ -104,8 +122,11 @@ export const StorageItemProvider = ({ baseUrl, children }: StorageItemProviderPr
         editItem,
         deleteItem,
         fetchExpired,
+        fetchExpiredAggregated,
         fetchAboutToExpire,
-        fetchRunningLow
+        fetchAboutToExpireAggregated,
+        fetchRunningLow,
+        fetchRunningLowAggregated
     }), [
         aboutToExpireItems,
         addItem,

package/src/context/api/shoppingListApi.ts

@@ -40,6 +40,43 @@ export const fetchShoppingListRequest = async (
     return [];
 });
 
+export const fetchAggregatedShoppingListRequest = async (
+    config: ShoppingListApiConfig
+): Promise<ShoppingListItem[]> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/shoppinglist`, {
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch aggregated shopping list');
+    }
+
+    const payload = await readJson<ShoppingListItem[]>(response);
+    if (payload) {
+        config.setItems(payload);
+        return payload;
+    }
+
+    return [];
+});
+
+export const createStorageItemsWithShoppingListItemRequest = async (
+    config: ShoppingListApiConfig,
+    storageId: number,
+    itemId: number
+) => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/shoppinglist/${itemId}`, {
+        method: 'POST',
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to add items');
+    }
+});
+
 export const createShoppingItemRequest = async (
     config: ShoppingListApiConfig,
     storageId: number,
@@ -92,7 +129,7 @@ export const editShoppingItemRequest = async (
 
         if (err?.productId || err?.amountToBuy)
             throw err;
-        
+
         throw new Error('Failed to edit shopping list item');
     }
 

package/src/context/api/storageItemApi.ts

@@ -175,6 +175,48 @@ export const fetchAboutToExpireRequest = async (
     return [];
 });
 
+export const fetchAggregatedExpiredRequest = async (
+    config: StorageItemApiConfig
+): Promise<StorageItem[]> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/expired`, {
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch expired items');
+    }
+
+    const payload = await readJson<StorageItem[]>(response);
+    if (payload) {
+        config.setExpiredItems(payload);
+        return payload;
+    }
+
+    return [];
+});
+
+export const fetchAggregatedAboutToExpireRequest = async (
+    config: StorageItemApiConfig
+): Promise<StorageItem[]> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/abouttoexpire`, {
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch items about to expire');
+    }
+
+    const payload = await readJson<StorageItem[]>(response);
+    if (payload) {
+        config.setAboutToExpireItems(payload);
+        return payload;
+    }
+
+    return [];
+});
+
 export const fetchRunningLowRequest = async (
     config: StorageItemApiConfig,
     storageId: number
@@ -196,3 +238,24 @@ export const fetchRunningLowRequest = async (
 
     return [];
 });
+
+export const fetchAggregatedRunningLowRequest = async (
+    config: StorageItemApiConfig
+): Promise<RunningLowNotification[]> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/runninglow`, {
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch running low items');
+    }
+
+    const payload = await readJson<RunningLowNotification[]>(response);
+    if (payload) {
+        config.setRunningLow(payload);
+        return payload;
+    }
+
+    return [];
+});

package/src/index.ts

@@ -19,5 +19,4 @@ export * from './context/StorageContext.js';
 export * from './context/StorageItemContext.js';
 export * from './context/StorageMemberContext.js';
 export * from './context/UserContext.js';
-export * from './context/ShoppingListContext.js';
-export * from './context/ToPurchaseContext.js';
+export * from './context/ShoppingListContext.js';

package/src/type/models.ts

@@ -22,6 +22,7 @@ export type Product = {
 
 export type StorageItem = {
     id: number;
+    storage: Storage;
     product: Product;
     expiresAt: string;
     createdAt: string;
@@ -53,10 +54,4 @@ export type ShoppingListItem = {
     storage: Storage;
     product: Product;
     amountToBuy: number;
-};
-
-export type ToPurchaseItem = {
-    productId: number;
-    productName: string;
-    amountToBuy: number;
-};
+};

package/src/context/ToPurchaseContext.tsx

@@ -1,43 +0,0 @@
-import React, { createContext, useCallback, useContext, useMemo, useState } from 'react';
-import type { ToPurchaseItem } from '../type/models.js';
-import { useAuth } from './AuthContext.js';
-import { fetchAggregatedShoppingRequest } from './api/toPurchaseApi.js';
-
-type ToPurchaseContextValue = {
-    items: ToPurchaseItem[];
-    isLoading: boolean;
-    isError: boolean;
-    error: Error | null;
-    fetchAggregated: () => Promise<ToPurchaseItem[]>;
-};
-
-type ToPurchaseProviderProps = {
-    baseUrl: string;
-    children: React.ReactNode;
-};
-
-const ToPurchaseContext = createContext<ToPurchaseContextValue | undefined>(undefined);
-
-export const ToPurchaseProvider = ({ baseUrl, children }: ToPurchaseProviderProps) => {
-    const { token } = useAuth();
-    const [items, setItems] = useState<ToPurchaseItem[]>([]);
-    const [isLoading, setIsLoading] = useState(false);
-    const [isError, setIsError] = useState(false);
-    const [error, setError] = useState<Error | null>(null);
-
-    const apiConfig = { baseUrl, token, setToPurchase: setItems, setIsLoading, setIsError, setError };
-
-    const fetchAggregated = useCallback(async () => {
-        return fetchAggregatedShoppingRequest(apiConfig);
-    }, [apiConfig]);
-
-    const value = useMemo(() => ({ items, isLoading, isError, error, fetchAggregated }), [items, isLoading, isError, error, fetchAggregated]);
-
-    return <ToPurchaseContext.Provider value={value}>{children}</ToPurchaseContext.Provider>;
-};
-
-export const useToPurchase = (): ToPurchaseContextValue => {
-    const context = useContext(ToPurchaseContext);
-    if (!context) throw new Error('useToPurchase must be used within a ToPurchaseProvider');
-    return context;
-};

package/src/context/api/toPurchaseApi.ts

@@ -1,30 +0,0 @@
-import type { ToPurchaseItem } from '../../type/models.js';
-import { buildAuthHeaders, normalizeBaseUrl, readJson } from '../http.js';
-import { runWithRequestState, type RequestStateHandlers } from './requestState.js';
-
-type ToPurchaseApiConfig = RequestStateHandlers & {
-    baseUrl: string;
-    token: string | null;
-    setToPurchase: (value: ToPurchaseItem[] | ((items: ToPurchaseItem[]) => ToPurchaseItem[])) => void;
-};
-
-export const fetchAggregatedShoppingRequest = async (
-    config: ToPurchaseApiConfig
-): Promise<ToPurchaseItem[]> => runWithRequestState(config, async () => {
-    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
-    const response = await fetch(`${normalizedBaseUrl}/api/tobuy/shopping`, {
-        headers: buildAuthHeaders(config.token)
-    });
-
-    if (!response.ok) {
-        throw new Error('Failed to fetch aggregated shopping list');
-    }
-
-    const payload = await readJson<ToPurchaseItem[]>(response);
-    if (payload) {
-        config.setToPurchase(payload);
-        return payload;
-    }
-
-    return [];
-});