fix: rename useAdmin to useApiServices

web/src/store/admin.ts

@@ -10,51 +10,51 @@ import {
 import type { ApiService, ApiServiceCredentials } from "@/types";
 import { create } from "zustand";
 
-interface IAdminState {
+interface IApiServicesState {
   apiServices: ApiService[];
-  loadingApiServices: boolean;
+  loading: boolean;
 
   createdCredentials: ApiServiceCredentials | null;
-  creatingApiService: boolean;
+  creating: boolean;
 
-  viewApiService: ApiService | null;
-  fetchingApiService: boolean;
+  view: ApiService | null;
+  fetching: boolean;
 
-  fetchApiServices: () => Promise<void>;
-  fetchApiService: (id: string) => Promise<void>;
-  createApiService: (req: CreateApiServiceRequest) => Promise<void>;
+  fetch: () => Promise<void>;
+  fetchSingle: (id: string) => Promise<void>;
+  create: (req: CreateApiServiceRequest) => Promise<void>;
   resetCredentials: () => void;
 
-  togglingApiService: boolean;
-  toggleApiService: () => Promise<void>;
+  toggling: boolean;
+  toggle: () => Promise<void>;
 
-  updateApiService: (req: UpdateApiServiceRequest) => Promise<void>;
-  updatingApiService: boolean;
-  updatedApiService: boolean;
+  update: (req: UpdateApiServiceRequest) => Promise<void>;
+  updating: boolean;
+  updated: boolean;
 
-  resetUpdatedApiService: () => void;
+  resetUpdated: () => void;
 }
 
-export const useAdmin = create<IAdminState>((set, get) => ({
+export const useApiServices = create<IApiServicesState>((set, get) => ({
   apiServices: [],
-  loadingApiServices: false,
+  loading: false,
 
   createdCredentials: null,
-  creatingApiService: false,
+  creating: false,
 
-  viewApiService: null,
-  fetchingApiService: false,
+  view: null,
+  fetching: false,
 
-  togglingApiService: false,
+  toggling: false,
 
-  updatingApiService: false,
-  updatedApiService: false,
-  resetUpdatedApiService: () => set({ updatedApiService: false }),
+  updating: false,
+  updated: false,
+  resetUpdated: () => set({ updated: false }),
 
   resetCredentials: () => set({ createdCredentials: null }),
 
-  fetchApiServices: async () => {
-    set({ loadingApiServices: true });
+  fetch: async () => {
+    set({ loading: true });
 
     try {
       const response = await getApiServices();
@@ -62,58 +62,58 @@ export const useAdmin = create<IAdminState>((set, get) => ({
     } catch (err) {
       console.log("ERR: Failed to fetch services:", err);
     } finally {
-      set({ loadingApiServices: false });
+      set({ loading: false });
     }
   },
 
-  fetchApiService: async (id: string) => {
-    set({ fetchingApiService: true });
+  fetchSingle: async (id: string) => {
+    set({ fetching: true });
 
     try {
       const response = await getApiService(id);
-      set({ viewApiService: response });
+      set({ view: response });
     } catch (err) {
       console.log("ERR: Failed to fetch services:", err);
     } finally {
-      set({ fetchingApiService: false });
+      set({ fetching: false });
     }
   },
 
-  updateApiService: async (req: UpdateApiServiceRequest) => {
-    const viewService = get().viewApiService;
+  update: async (req: UpdateApiServiceRequest) => {
+    const viewService = get().view;
     if (!viewService) return;
 
-    set({ updatingApiService: true });
+    set({ updating: true });
 
     try {
       await putApiService(viewService.id, req);
-      get().fetchApiService(viewService.id);
-      set({ updatedApiService: true });
+      get().fetchSingle(viewService.id);
+      set({ updated: true });
     } catch (err) {
       console.log("ERR: Failed to toggle service:", err);
     } finally {
-      set({ updatingApiService: false });
+      set({ updating: false });
     }
   },
 
-  toggleApiService: async () => {
-    const viewService = get().viewApiService;
+  toggle: async () => {
+    const viewService = get().view;
     if (!viewService) return;
 
-    set({ togglingApiService: true });
+    set({ toggling: true });
 
     try {
       await patchToggleApiService(viewService.id);
-      get().fetchApiService(viewService.id);
+      get().fetchSingle(viewService.id);
     } catch (err) {
       console.log("ERR: Failed to toggle service:", err);
     } finally {
-      set({ togglingApiService: false });
+      set({ toggling: false });
     }
   },
 
-  createApiService: async (req: CreateApiServiceRequest) => {
-    set({ creatingApiService: true });
+  create: async (req: CreateApiServiceRequest) => {
+    set({ creating: true });
 
     try {
       const response = await postApiService(req);
@@ -121,7 +121,7 @@ export const useAdmin = create<IAdminState>((set, get) => ({
     } catch (err) {
       console.log("ERR: Failed to fetch services:", err);
     } finally {
-      set({ creatingApiService: false });
+      set({ creating: false });
     }
   },
 }));