shelflife-react-hooks 1.0.0

package/src/context/RunningLowContext.tsx

@@ -0,0 +1,100 @@
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useMemo,
+    useState
+} from 'react';
+
+import type { RunningLowSetting } from '../type/models.js';
+import type { CreateSettingRequest, EditSettingRequest } from '../type/requests.js';
+import { useAuth } from './AuthContext.js';
+import {
+    createSettingRequest,
+    deleteSettingRequest,
+    editSettingRequest,
+    fetchSettingsRequest
+} from './api/runningLowApi.js';
+
+type RunningLowContextValue = {
+    settings: RunningLowSetting[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    fetchSettings: (storageId: number) => Promise<RunningLowSetting[]>;
+    createSetting: (storageId: number, dto: CreateSettingRequest) => Promise<RunningLowSetting>;
+    editSetting: (storageId: number, id: number, dto: EditSettingRequest) => Promise<RunningLowSetting>;
+    deleteSetting: (storageId: number, id: number) => Promise<void>;
+};
+
+type RunningLowProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+
+const RunningLowContext = createContext<RunningLowContextValue | undefined>(undefined);
+
+export const RunningLowProvider = ({ baseUrl, children }: RunningLowProviderProps) => {
+    const { token } = useAuth();
+    const [settings, setSettings] = useState<RunningLowSetting[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setSettings,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const fetchSettings = useCallback(
+        (storageId: number) => fetchSettingsRequest(apiConfig, storageId),
+        [apiConfig]
+    );
+    const createSetting = useCallback(
+        (storageId: number, dto: CreateSettingRequest) => createSettingRequest(apiConfig, storageId, dto),
+        [apiConfig]
+    );
+    const editSetting = useCallback(
+        (storageId: number, id: number, dto: EditSettingRequest) => editSettingRequest(apiConfig, storageId, id, dto),
+        [apiConfig]
+    );
+    const deleteSetting = useCallback(
+        (storageId: number, id: number) => deleteSettingRequest(apiConfig, storageId, id),
+        [apiConfig]
+    );
+
+    const value = useMemo<RunningLowContextValue>(() => ({
+        settings,
+        isLoading,
+        isError,
+        error,
+        fetchSettings,
+        createSetting,
+        editSetting,
+        deleteSetting
+    }), [
+        createSetting,
+        deleteSetting,
+        editSetting,
+        error,
+        fetchSettings,
+        isError,
+        isLoading,
+        settings
+    ]);
+
+    return <RunningLowContext.Provider value={value}>{children}</RunningLowContext.Provider>;
+};
+
+export const useRunningLow = (): RunningLowContextValue => {
+    const context = useContext(RunningLowContext);
+    if (!context) {
+        throw new Error('useRunningLow must be used within a RunningLowProvider');
+    }
+
+    return context;
+};

package/src/context/StorageContext.tsx

@@ -0,0 +1,104 @@
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useMemo,
+    useState
+} from 'react';
+
+import type { Storage } from '../type/models.js';
+import type { ChangeStorageNameRequest, CreateStorageRequest } from '../type/requests.js';
+import { useAuth } from './AuthContext.js';
+import {
+    changeStorageNameRequest,
+    createStorageRequest,
+    deleteStorageRequest,
+    fetchStorageRequest,
+    fetchStoragesRequest
+} from './api/storageApi.js';
+
+type StorageContextValue = {
+    storages: Storage[];
+    storage: Storage | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    fetchStorages: () => Promise<Storage[]>;
+    fetchStorage: (id: number) => Promise<Storage | null>;
+    createStorage: (dto: CreateStorageRequest) => Promise<Storage>;
+    changeStorageName: (id: number, dto: ChangeStorageNameRequest) => Promise<Storage>;
+    deleteStorage: (id: number) => Promise<void>;
+};
+
+type StorageProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+
+const StorageContext = createContext<StorageContextValue | undefined>(undefined);
+
+export const StorageProvider = ({ baseUrl, children }: StorageProviderProps) => {
+    const { token } = useAuth();
+    const [storages, setStorages] = useState<Storage[]>([]);
+    const [storage, setStorage] = useState<Storage | null>(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setStorages,
+        setStorage,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const fetchStorages = useCallback(() => fetchStoragesRequest(apiConfig), [apiConfig]);
+    const fetchStorage = useCallback((id: number) => fetchStorageRequest(apiConfig, id), [apiConfig]);
+    const createStorage = useCallback(
+        (dto: CreateStorageRequest) => createStorageRequest(apiConfig, dto),
+        [apiConfig]
+    );
+    const changeStorageName = useCallback(
+        (id: number, dto: ChangeStorageNameRequest) => changeStorageNameRequest(apiConfig, id, dto),
+        [apiConfig]
+    );
+    const deleteStorage = useCallback((id: number) => deleteStorageRequest(apiConfig, id), [apiConfig]);
+
+    const value = useMemo<StorageContextValue>(() => ({
+        storages,
+        storage,
+        isLoading,
+        isError,
+        error,
+        fetchStorages,
+        fetchStorage,
+        createStorage,
+        changeStorageName,
+        deleteStorage
+    }), [
+        changeStorageName,
+        createStorage,
+        deleteStorage,
+        error,
+        fetchStorage,
+        fetchStorages,
+        isError,
+        isLoading,
+        storage,
+        storages
+    ]);
+
+    return <StorageContext.Provider value={value}>{children}</StorageContext.Provider>;
+};
+
+export const useStorages = (): StorageContextValue => {
+    const context = useContext(StorageContext);
+    if (!context) {
+        throw new Error('useStorages must be used within a StorageProvider');
+    }
+
+    return context;
+};

package/src/context/StorageItemContext.tsx

@@ -0,0 +1,136 @@
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useMemo,
+    useState
+} from 'react';
+
+import type { RunningLowNotification, StorageItem } from '../type/models.js';
+import type { AddItemRequest, EditItemRequest } from '../type/requests.js';
+import { useAuth } from './AuthContext.js';
+import {
+    addItemRequest,
+    deleteItemRequest,
+    editItemRequest,
+    fetchAboutToExpireRequest,
+    fetchExpiredRequest,
+    fetchItemsRequest,
+    fetchRunningLowRequest
+} from './api/storageItemApi.js';
+
+type StorageItemContextValue = {
+    items: StorageItem[];
+    expiredItems: StorageItem[];
+    aboutToExpireItems: StorageItem[];
+    runningLow: RunningLowNotification[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    fetchItems: (storageId: number) => Promise<StorageItem[]>;
+    addItem: (storageId: number, dto: AddItemRequest) => Promise<StorageItem>;
+    editItem: (storageId: number, itemId: number, dto: EditItemRequest) => Promise<StorageItem>;
+    deleteItem: (storageId: number, itemId: number) => Promise<void>;
+    fetchExpired: (storageId: number) => Promise<StorageItem[]>;
+    fetchAboutToExpire: (storageId: number) => Promise<StorageItem[]>;
+    fetchRunningLow: (storageId: number) => Promise<RunningLowNotification[]>;
+};
+
+type StorageItemProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+
+const StorageItemContext = createContext<StorageItemContextValue | undefined>(undefined);
+
+export const StorageItemProvider = ({ baseUrl, children }: StorageItemProviderProps) => {
+    const { token } = useAuth();
+    const [items, setItems] = useState<StorageItem[]>([]);
+    const [expiredItems, setExpiredItems] = useState<StorageItem[]>([]);
+    const [aboutToExpireItems, setAboutToExpireItems] = useState<StorageItem[]>([]);
+    const [runningLow, setRunningLow] = useState<RunningLowNotification[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setItems,
+        setExpiredItems,
+        setAboutToExpireItems,
+        setRunningLow,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const fetchItems = useCallback((storageId: number) => fetchItemsRequest(apiConfig, storageId), [apiConfig]);
+    const addItem = useCallback(
+        (storageId: number, dto: AddItemRequest) => addItemRequest(apiConfig, storageId, dto),
+        [apiConfig]
+    );
+    const editItem = useCallback(
+        (storageId: number, itemId: number, dto: EditItemRequest) => editItemRequest(apiConfig, storageId, itemId, dto),
+        [apiConfig]
+    );
+    const deleteItem = useCallback(
+        (storageId: number, itemId: number) => deleteItemRequest(apiConfig, storageId, itemId),
+        [apiConfig]
+    );
+    const fetchExpired = useCallback(
+        (storageId: number) => fetchExpiredRequest(apiConfig, storageId),
+        [apiConfig]
+    );
+    const fetchAboutToExpire = useCallback(
+        (storageId: number) => fetchAboutToExpireRequest(apiConfig, storageId),
+        [apiConfig]
+    );
+    const fetchRunningLow = useCallback(
+        (storageId: number) => fetchRunningLowRequest(apiConfig, storageId),
+        [apiConfig]
+    );
+
+    const value = useMemo<StorageItemContextValue>(() => ({
+        items,
+        expiredItems,
+        aboutToExpireItems,
+        runningLow,
+        isLoading,
+        isError,
+        error,
+        fetchItems,
+        addItem,
+        editItem,
+        deleteItem,
+        fetchExpired,
+        fetchAboutToExpire,
+        fetchRunningLow
+    }), [
+        aboutToExpireItems,
+        addItem,
+        deleteItem,
+        editItem,
+        error,
+        expiredItems,
+        fetchAboutToExpire,
+        fetchExpired,
+        fetchItems,
+        fetchRunningLow,
+        isError,
+        isLoading,
+        items,
+        runningLow
+    ]);
+
+    return <StorageItemContext.Provider value={value}>{children}</StorageItemContext.Provider>;
+};
+
+export const useStorageItems = (): StorageItemContextValue => {
+    const context = useContext(StorageItemContext);
+    if (!context) {
+        throw new Error('useStorageItems must be used within a StorageItemProvider');
+    }
+
+    return context;
+};

package/src/context/StorageMemberContext.tsx

@@ -0,0 +1,84 @@
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useMemo,
+    useState
+} from 'react';
+
+import type { StorageMember } from '../type/models.js';
+import type { InviteMemberRequest } from '../type/requests.js';
+import { useAuth } from './AuthContext.js';
+import {
+    fetchMembersRequest,
+    inviteMemberRequest,
+    removeMemberRequest
+} from './api/storageMemberApi.js';
+
+type StorageMemberContextValue = {
+    members: StorageMember[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    fetchMembers: (storageId: number) => Promise<StorageMember[]>;
+    inviteMember: (storageId: number, dto: InviteMemberRequest) => Promise<StorageMember>;
+    removeMember: (storageId: number, userId: number) => Promise<void>;
+};
+
+type StorageMemberProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+
+const StorageMemberContext = createContext<StorageMemberContextValue | undefined>(undefined);
+
+export const StorageMemberProvider = ({ baseUrl, children }: StorageMemberProviderProps) => {
+    const { token } = useAuth();
+    const [members, setMembers] = useState<StorageMember[]>([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setMembers,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const fetchMembers = useCallback(
+        (storageId: number) => fetchMembersRequest(apiConfig, storageId),
+        [apiConfig]
+    );
+    const inviteMember = useCallback(
+        (storageId: number, dto: InviteMemberRequest) => inviteMemberRequest(apiConfig, storageId, dto),
+        [apiConfig]
+    );
+    const removeMember = useCallback(
+        (storageId: number, userId: number) => removeMemberRequest(apiConfig, storageId, userId),
+        [apiConfig]
+    );
+
+    const value = useMemo<StorageMemberContextValue>(() => ({
+        members,
+        isLoading,
+        isError,
+        error,
+        fetchMembers,
+        inviteMember,
+        removeMember
+    }), [error, fetchMembers, inviteMember, isError, isLoading, members, removeMember]);
+
+    return <StorageMemberContext.Provider value={value}>{children}</StorageMemberContext.Provider>;
+};
+
+export const useStorageMembers = (): StorageMemberContextValue => {
+    const context = useContext(StorageMemberContext);
+    if (!context) {
+        throw new Error('useStorageMembers must be used within a StorageMemberProvider');
+    }
+
+    return context;
+};

package/src/context/UserContext.tsx

@@ -0,0 +1,109 @@
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useMemo,
+    useState
+} from 'react';
+
+import type { User } from '../type/models.js';
+import type { ChangeUserDataRequest } from '../type/requests.js';
+import { useAuth } from './AuthContext.js';
+import {
+    deleteUserRequest,
+    fetchUserRequest,
+    fetchUsersRequest,
+    getUserPfpRequest,
+    updateUserRequest,
+    uploadUserPfpRequest
+} from './api/userApi.js';
+
+type UserContextValue = {
+    users: User[];
+    user: User | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    fetchUsers: () => Promise<User[]>;
+    fetchUser: (id: number) => Promise<User | null>;
+    updateUser: (id: number, dto: ChangeUserDataRequest) => Promise<User>;
+    deleteUser: (id: number) => Promise<void>;
+    getUserPfp: (id: number) => Promise<ArrayBuffer>;
+    uploadUserPfp: (id: number, file: Blob) => Promise<void>;
+};
+
+type UserProviderProps = {
+    baseUrl: string;
+    children: React.ReactNode;
+};
+
+const UserContext = createContext<UserContextValue | undefined>(undefined);
+
+export const UserProvider = ({ baseUrl, children }: UserProviderProps) => {
+    const { token } = useAuth();
+    const [users, setUsers] = useState<User[]>([]);
+    const [user, setUser] = useState<User | null>(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isError, setIsError] = useState(false);
+    const [error, setError] = useState<Error | null>(null);
+
+    const apiConfig = useMemo(() => ({
+        baseUrl,
+        token,
+        setUsers,
+        setUser,
+        setIsLoading,
+        setIsError,
+        setError
+    }), [baseUrl, token]);
+
+    const fetchUsers = useCallback(() => fetchUsersRequest(apiConfig), [apiConfig]);
+    const fetchUser = useCallback((id: number) => fetchUserRequest(apiConfig, id), [apiConfig]);
+    const updateUser = useCallback(
+        (id: number, dto: ChangeUserDataRequest) => updateUserRequest(apiConfig, id, dto),
+        [apiConfig]
+    );
+    const deleteUser = useCallback((id: number) => deleteUserRequest(apiConfig, id), [apiConfig]);
+    const getUserPfp = useCallback((id: number) => getUserPfpRequest(apiConfig, id), [apiConfig]);
+    const uploadUserPfp = useCallback(
+        (id: number, file: Blob) => uploadUserPfpRequest(apiConfig, id, file),
+        [apiConfig]
+    );
+
+    const value = useMemo<UserContextValue>(() => ({
+        users,
+        user,
+        isLoading,
+        isError,
+        error,
+        fetchUsers,
+        fetchUser,
+        updateUser,
+        deleteUser,
+        getUserPfp,
+        uploadUserPfp
+    }), [
+        deleteUser,
+        error,
+        fetchUser,
+        fetchUsers,
+        getUserPfp,
+        isError,
+        isLoading,
+        updateUser,
+        uploadUserPfp,
+        user,
+        users
+    ]);
+
+    return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
+};
+
+export const useUsers = (): UserContextValue => {
+    const context = useContext(UserContext);
+    if (!context) {
+        throw new Error('useUsers must be used within a UserProvider');
+    }
+
+    return context;
+};