shelflife-react-hooks 1.0.8 → 1.0.9

package/src/context/ToPurchaseContext.tsx

@@ -0,0 +1,43 @@
+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/shoppingListApi.ts

@@ -0,0 +1,111 @@
+import type { ShoppingListItem } from '../../type/models.js';
+import type { CreateShoppingItemRequest, EditShoppingItemRequest } from '../../type/requests.js';
+import { buildAuthHeaders, normalizeBaseUrl, readJson } from '../http.js';
+import { runWithRequestState, type RequestStateHandlers } from './requestState.js';
+
+type ShoppingListApiConfig = RequestStateHandlers & {
+    baseUrl: string;
+    token: string | null;
+    setItems: (value: ShoppingListItem[] | ((items: ShoppingListItem[]) => ShoppingListItem[])) => void;
+};
+
+const updateById = (items: ShoppingListItem[], updated: ShoppingListItem): ShoppingListItem[] => {
+    const index = items.findIndex((i) => i.id === updated.id);
+    if (index === -1) return [updated, ...items];
+    const next = [...items];
+    next[index] = updated;
+    return next;
+};
+
+export const fetchShoppingListRequest = async (
+    config: ShoppingListApiConfig,
+    storageId: number
+): Promise<ShoppingListItem[]> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/shoppinglist`, {
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch shopping list items');
+    }
+
+    const payload = await readJson<ShoppingListItem[]>(response);
+    if (payload) {
+        config.setItems(payload);
+        return payload;
+    }
+
+    return [];
+});
+
+export const createShoppingItemRequest = async (
+    config: ShoppingListApiConfig,
+    storageId: number,
+    dto: CreateShoppingItemRequest
+): Promise<ShoppingListItem> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/shoppinglist`, {
+        method: 'POST',
+        headers: {
+            ...buildAuthHeaders(config.token),
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(dto)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to create shopping list item');
+    }
+
+    const payload = await readJson<ShoppingListItem>(response);
+    if (!payload) throw new Error('Create shopping item response missing data');
+
+    config.setItems((previous) => [payload, ...previous]);
+    return payload;
+});
+
+export const editShoppingItemRequest = async (
+    config: ShoppingListApiConfig,
+    storageId: number,
+    itemId: number,
+    dto: EditShoppingItemRequest
+): Promise<ShoppingListItem> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/shoppinglist/${itemId}`, {
+        method: 'PUT',
+        headers: {
+            ...buildAuthHeaders(config.token),
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(dto)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to edit shopping list item');
+    }
+
+    const payload = await readJson<ShoppingListItem>(response);
+    if (!payload) throw new Error('Edit shopping item response missing data');
+
+    config.setItems((previous) => updateById(previous, payload));
+    return payload;
+});
+
+export const deleteShoppingItemRequest = async (
+    config: ShoppingListApiConfig,
+    storageId: number,
+    itemId: number
+): Promise<void> => runWithRequestState(config, async () => {
+    const normalizedBaseUrl = normalizeBaseUrl(config.baseUrl);
+    const response = await fetch(`${normalizedBaseUrl}/api/storages/${storageId}/shoppinglist/${itemId}`, {
+        method: 'DELETE',
+        headers: buildAuthHeaders(config.token)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to delete shopping list item');
+    }
+
+    config.setItems((previous) => previous.filter((i) => i.id !== itemId));
+});

package/src/context/api/toPurchaseApi.ts

@@ -0,0 +1,30 @@
+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 [];
+});

package/src/index.ts

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

package/src/type/models.ts

@@ -46,3 +46,16 @@ export type RunningLowNotification = {
     runningLowAt: number;
     amount: number;
 };
+
+export type ShoppingListItem = {
+    id: number;
+    storage: Storage;
+    product: Product;
+    amountToBuy: number;
+};
+
+export type ToPurchaseItem = {
+    productId: number;
+    productName: string;
+    amountToBuy: number;
+};

package/src/type/requests.ts

@@ -30,6 +30,15 @@ export type EditItemRequest = {
     expiresAt?: string;
 };
 
+export type CreateShoppingItemRequest = {
+    productId: number;
+    amountToBuy: number;
+};
+
+export type EditShoppingItemRequest = {
+    amountToBuy: number;
+};
+
 export type CreateStorageRequest = {
     name: string;
 };