Split multi-hook frontend modules into single-hook files
This commit is contained in:
@@ -1,513 +1,5 @@
|
||||
/**
|
||||
* Jail management hooks.
|
||||
*
|
||||
* Provides data-fetching and mutation hooks for all jail-related views,
|
||||
* following the same patterns established by `useBans.ts` and
|
||||
* `useServerStatus.ts`.
|
||||
*/
|
||||
|
||||
import { useCallback, useEffect, useRef, useState } from "react";
|
||||
import { handleFetchError } from "../utils/fetchError";
|
||||
import {
|
||||
addIgnoreIp,
|
||||
banIp,
|
||||
delIgnoreIp,
|
||||
fetchActiveBans,
|
||||
fetchJail,
|
||||
fetchJailBannedIps,
|
||||
fetchJails,
|
||||
lookupIp,
|
||||
reloadAllJails,
|
||||
reloadJail,
|
||||
setJailIdle,
|
||||
startJail,
|
||||
stopJail,
|
||||
toggleIgnoreSelf as toggleIgnoreSelfApi,
|
||||
unbanAllBans,
|
||||
unbanIp,
|
||||
} from "../api/jails";
|
||||
import type {
|
||||
ActiveBan,
|
||||
IpLookupResponse,
|
||||
Jail,
|
||||
JailSummary,
|
||||
UnbanAllResponse,
|
||||
} from "../types/jail";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// useJails — overview list
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Return value for {@link useJails}. */
|
||||
export interface UseJailsResult {
|
||||
/** All known jails. */
|
||||
jails: JailSummary[];
|
||||
/** Total count returned by the backend. */
|
||||
total: number;
|
||||
/** `true` while a fetch is in progress. */
|
||||
loading: boolean;
|
||||
/** Error message from the last failed fetch, or `null`. */
|
||||
error: string | null;
|
||||
/** Re-fetch the jail list from the backend. */
|
||||
refresh: () => void;
|
||||
/** Start a specific jail (returns a promise for error handling). */
|
||||
startJail: (name: string) => Promise<void>;
|
||||
/** Stop a specific jail. */
|
||||
stopJail: (name: string) => Promise<void>;
|
||||
/** Toggle idle mode for a jail. */
|
||||
setIdle: (name: string, on: boolean) => Promise<void>;
|
||||
/** Reload a specific jail. */
|
||||
reloadJail: (name: string) => Promise<void>;
|
||||
/** Reload all jails at once. */
|
||||
reloadAll: () => Promise<void>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch and manage the jail overview list.
|
||||
*
|
||||
* Automatically loads on mount and exposes control mutations that refresh
|
||||
* the list after each operation.
|
||||
*
|
||||
* @returns Current jail list, loading/error state, and control callbacks.
|
||||
*/
|
||||
export function useJails(): UseJailsResult {
|
||||
const [jails, setJails] = useState<JailSummary[]>([]);
|
||||
const [total, setTotal] = useState(0);
|
||||
const [loading, setLoading] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const abortRef = useRef<AbortController | null>(null);
|
||||
|
||||
const load = useCallback(() => {
|
||||
abortRef.current?.abort();
|
||||
const ctrl = new AbortController();
|
||||
abortRef.current = ctrl;
|
||||
setLoading(true);
|
||||
setError(null);
|
||||
|
||||
fetchJails()
|
||||
.then((res) => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
setJails(res.jails);
|
||||
setTotal(res.total);
|
||||
}
|
||||
})
|
||||
.catch((err: unknown) => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
handleFetchError(err, setError, "Failed to load jails");
|
||||
}
|
||||
})
|
||||
.finally(() => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
setLoading(false);
|
||||
}
|
||||
});
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
load();
|
||||
return (): void => {
|
||||
abortRef.current?.abort();
|
||||
};
|
||||
}, [load]);
|
||||
|
||||
const withRefresh =
|
||||
(fn: (name: string) => Promise<unknown>) =>
|
||||
async (name: string): Promise<void> => {
|
||||
await fn(name);
|
||||
load();
|
||||
};
|
||||
|
||||
return {
|
||||
jails,
|
||||
total,
|
||||
loading,
|
||||
error,
|
||||
refresh: load,
|
||||
startJail: withRefresh(startJail),
|
||||
stopJail: withRefresh(stopJail),
|
||||
setIdle: (name, on) => setJailIdle(name, on).then((): void => { load(); }),
|
||||
reloadJail: withRefresh(reloadJail),
|
||||
reloadAll: () => reloadAllJails().then((): void => { load(); }),
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// useJailDetail — single jail
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Return value for {@link useJailDetail}. */
|
||||
export interface UseJailDetailResult {
|
||||
/** Full jail configuration, or `null` while loading. */
|
||||
jail: Jail | null;
|
||||
/** Current ignore list. */
|
||||
ignoreList: string[];
|
||||
/** Whether `ignoreself` is enabled. */
|
||||
ignoreSelf: boolean;
|
||||
/** `true` while a fetch is in progress. */
|
||||
loading: boolean;
|
||||
/** Error message or `null`. */
|
||||
error: string | null;
|
||||
/** Re-fetch from the backend. */
|
||||
refresh: () => void;
|
||||
/** Add an IP to the ignore list. */
|
||||
addIp: (ip: string) => Promise<void>;
|
||||
/** Remove an IP from the ignore list. */
|
||||
removeIp: (ip: string) => Promise<void>;
|
||||
/** Enable or disable the ignoreself option for this jail. */
|
||||
toggleIgnoreSelf: (on: boolean) => Promise<void>;
|
||||
/** Start the jail. */
|
||||
start: () => Promise<void>;
|
||||
/** Stop the jail. */
|
||||
stop: () => Promise<void>;
|
||||
/** Reload jail configuration. */
|
||||
reload: () => Promise<void>;
|
||||
/** Toggle idle mode on/off for the jail. */
|
||||
setIdle: (on: boolean) => Promise<void>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch and manage the detail view for a single jail.
|
||||
*
|
||||
* @param name - Jail name to load.
|
||||
* @returns Jail detail, ignore list management helpers, and fetch state.
|
||||
*/
|
||||
export function useJailDetail(name: string): UseJailDetailResult {
|
||||
const [jail, setJail] = useState<Jail | null>(null);
|
||||
const [ignoreList, setIgnoreList] = useState<string[]>([]);
|
||||
const [ignoreSelf, setIgnoreSelf] = useState(false);
|
||||
const [loading, setLoading] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const abortRef = useRef<AbortController | null>(null);
|
||||
|
||||
const load = useCallback(() => {
|
||||
abortRef.current?.abort();
|
||||
const ctrl = new AbortController();
|
||||
abortRef.current = ctrl;
|
||||
setLoading(true);
|
||||
setError(null);
|
||||
|
||||
fetchJail(name)
|
||||
.then((res) => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
setJail(res.jail);
|
||||
setIgnoreList(res.ignore_list);
|
||||
setIgnoreSelf(res.ignore_self);
|
||||
}
|
||||
})
|
||||
.catch((err: unknown) => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
handleFetchError(err, setError, "Failed to fetch jail detail");
|
||||
}
|
||||
})
|
||||
.finally(() => {
|
||||
if (!ctrl.signal.aborted) setLoading(false);
|
||||
});
|
||||
}, [name]);
|
||||
|
||||
useEffect(() => {
|
||||
load();
|
||||
return (): void => {
|
||||
abortRef.current?.abort();
|
||||
};
|
||||
}, [load]);
|
||||
|
||||
const addIp = async (ip: string): Promise<void> => {
|
||||
await addIgnoreIp(name, ip);
|
||||
load();
|
||||
};
|
||||
|
||||
const removeIp = async (ip: string): Promise<void> => {
|
||||
await delIgnoreIp(name, ip);
|
||||
load();
|
||||
};
|
||||
|
||||
const toggleIgnoreSelf = async (on: boolean): Promise<void> => {
|
||||
await toggleIgnoreSelfApi(name, on);
|
||||
load();
|
||||
};
|
||||
|
||||
const doStart = async (): Promise<void> => {
|
||||
await startJail(name);
|
||||
load();
|
||||
};
|
||||
|
||||
const doStop = async (): Promise<void> => {
|
||||
await stopJail(name);
|
||||
load();
|
||||
};
|
||||
|
||||
const doReload = async (): Promise<void> => {
|
||||
await reloadJail(name);
|
||||
load();
|
||||
};
|
||||
|
||||
const doSetIdle = async (on: boolean): Promise<void> => {
|
||||
await setJailIdle(name, on);
|
||||
load();
|
||||
};
|
||||
|
||||
return {
|
||||
jail,
|
||||
ignoreList,
|
||||
ignoreSelf,
|
||||
loading,
|
||||
error,
|
||||
refresh: load,
|
||||
addIp,
|
||||
removeIp,
|
||||
toggleIgnoreSelf,
|
||||
start: doStart,
|
||||
stop: doStop,
|
||||
reload: doReload,
|
||||
setIdle: doSetIdle,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// useJailBannedIps
|
||||
|
||||
export interface UseJailBannedIpsResult {
|
||||
items: ActiveBan[];
|
||||
total: number;
|
||||
page: number;
|
||||
pageSize: number;
|
||||
search: string;
|
||||
loading: boolean;
|
||||
error: string | null;
|
||||
opError: string | null;
|
||||
refresh: () => Promise<void>;
|
||||
setPage: (page: number) => void;
|
||||
setPageSize: (size: number) => void;
|
||||
setSearch: (term: string) => void;
|
||||
unban: (ip: string) => Promise<void>;
|
||||
}
|
||||
|
||||
export function useJailBannedIps(jailName: string): UseJailBannedIpsResult {
|
||||
const [items, setItems] = useState<ActiveBan[]>([]);
|
||||
const [total, setTotal] = useState(0);
|
||||
const [page, setPage] = useState(1);
|
||||
const [pageSize, setPageSize] = useState(25);
|
||||
const [search, setSearch] = useState("");
|
||||
const [debouncedSearch, setDebouncedSearch] = useState("");
|
||||
const [loading, setLoading] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [opError, setOpError] = useState<string | null>(null);
|
||||
const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
|
||||
|
||||
const load = useCallback(async (): Promise<void> => {
|
||||
if (!jailName) {
|
||||
setItems([]);
|
||||
setTotal(0);
|
||||
setLoading(false);
|
||||
return;
|
||||
}
|
||||
|
||||
setLoading(true);
|
||||
setError(null);
|
||||
|
||||
try {
|
||||
const resp = await fetchJailBannedIps(jailName, page, pageSize, debouncedSearch || undefined);
|
||||
setItems(resp.items);
|
||||
setTotal(resp.total);
|
||||
} catch (err: unknown) {
|
||||
handleFetchError(err, setError, "Failed to fetch jailed IPs");
|
||||
} finally {
|
||||
setLoading(false);
|
||||
}
|
||||
}, [jailName, page, pageSize, debouncedSearch]);
|
||||
|
||||
useEffect(() => {
|
||||
if (debounceRef.current !== null) {
|
||||
clearTimeout(debounceRef.current);
|
||||
}
|
||||
debounceRef.current = setTimeout(() => {
|
||||
setDebouncedSearch(search);
|
||||
setPage(1);
|
||||
}, 300);
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
|
||||
return () => {
|
||||
if (debounceRef.current !== null) {
|
||||
clearTimeout(debounceRef.current);
|
||||
}
|
||||
};
|
||||
}, [search]);
|
||||
|
||||
useEffect(() => {
|
||||
void load();
|
||||
}, [load]);
|
||||
|
||||
const unban = useCallback(async (ip: string): Promise<void> => {
|
||||
setOpError(null);
|
||||
try {
|
||||
await unbanIp(ip, jailName);
|
||||
await load();
|
||||
} catch (err: unknown) {
|
||||
setOpError(err instanceof Error ? err.message : String(err));
|
||||
}
|
||||
}, [jailName, load]);
|
||||
|
||||
return {
|
||||
items,
|
||||
total,
|
||||
page,
|
||||
pageSize,
|
||||
search,
|
||||
loading,
|
||||
error,
|
||||
opError,
|
||||
refresh: load,
|
||||
setPage,
|
||||
setPageSize,
|
||||
setSearch,
|
||||
unban,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// useActiveBans — live ban list
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Return value for {@link useActiveBans}. */
|
||||
export interface UseActiveBansResult {
|
||||
/** All currently active bans. */
|
||||
bans: ActiveBan[];
|
||||
/** Total ban count. */
|
||||
total: number;
|
||||
/** `true` while fetching. */
|
||||
loading: boolean;
|
||||
/** Error message or `null`. */
|
||||
error: string | null;
|
||||
/** Re-fetch the active bans. */
|
||||
refresh: () => void;
|
||||
/** Ban an IP in a specific jail. */
|
||||
banIp: (jail: string, ip: string) => Promise<void>;
|
||||
/** Unban an IP from a jail (or all jails when `jail` is omitted). */
|
||||
unbanIp: (ip: string, jail?: string) => Promise<void>;
|
||||
/** Unban every currently banned IP across all jails. */
|
||||
unbanAll: () => Promise<UnbanAllResponse>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fetch and manage the currently-active ban list.
|
||||
*
|
||||
* @returns Active ban list, mutation callbacks, and fetch state.
|
||||
*/
|
||||
export function useActiveBans(): UseActiveBansResult {
|
||||
const [bans, setBans] = useState<ActiveBan[]>([]);
|
||||
const [total, setTotal] = useState(0);
|
||||
const [loading, setLoading] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const abortRef = useRef<AbortController | null>(null);
|
||||
|
||||
const load = useCallback(() => {
|
||||
abortRef.current?.abort();
|
||||
const ctrl = new AbortController();
|
||||
abortRef.current = ctrl;
|
||||
setLoading(true);
|
||||
setError(null);
|
||||
|
||||
fetchActiveBans()
|
||||
.then((res) => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
setBans(res.bans);
|
||||
setTotal(res.total);
|
||||
}
|
||||
})
|
||||
.catch((err: unknown) => {
|
||||
if (!ctrl.signal.aborted) {
|
||||
handleFetchError(err, setError, "Failed to fetch active bans");
|
||||
}
|
||||
})
|
||||
.finally(() => {
|
||||
if (!ctrl.signal.aborted) setLoading(false);
|
||||
});
|
||||
}, []);
|
||||
|
||||
useEffect(() => {
|
||||
load();
|
||||
return (): void => {
|
||||
abortRef.current?.abort();
|
||||
};
|
||||
}, [load]);
|
||||
|
||||
const doBan = async (jail: string, ip: string): Promise<void> => {
|
||||
await banIp(jail, ip);
|
||||
load();
|
||||
};
|
||||
|
||||
const doUnban = async (ip: string, jail?: string): Promise<void> => {
|
||||
await unbanIp(ip, jail);
|
||||
load();
|
||||
};
|
||||
|
||||
const doUnbanAll = async (): Promise<UnbanAllResponse> => {
|
||||
const result = await unbanAllBans();
|
||||
load();
|
||||
return result;
|
||||
};
|
||||
|
||||
return {
|
||||
bans,
|
||||
total,
|
||||
loading,
|
||||
error,
|
||||
refresh: load,
|
||||
banIp: doBan,
|
||||
unbanIp: doUnban,
|
||||
unbanAll: doUnbanAll,
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// useIpLookup — single IP lookup
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Return value for {@link useIpLookup}. */
|
||||
export interface UseIpLookupResult {
|
||||
/** Lookup result, or `null` when no lookup has been performed yet. */
|
||||
result: IpLookupResponse | null;
|
||||
/** `true` while a lookup is in progress. */
|
||||
loading: boolean;
|
||||
/** Error message or `null`. */
|
||||
error: string | null;
|
||||
/** Trigger an IP lookup. */
|
||||
lookup: (ip: string) => void;
|
||||
/** Clear the result and error state. */
|
||||
clear: () => void;
|
||||
}
|
||||
|
||||
/**
|
||||
* Manage IP lookup state (lazy — no fetch on mount).
|
||||
*
|
||||
* @returns Lookup result, state flags, and a `lookup` trigger callback.
|
||||
*/
|
||||
export function useIpLookup(): UseIpLookupResult {
|
||||
const [result, setResult] = useState<IpLookupResponse | null>(null);
|
||||
const [loading, setLoading] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
|
||||
const lookup = useCallback((ip: string) => {
|
||||
setLoading(true);
|
||||
setError(null);
|
||||
setResult(null);
|
||||
|
||||
lookupIp(ip)
|
||||
.then((res) => {
|
||||
setResult(res);
|
||||
})
|
||||
.catch((err: unknown) => {
|
||||
handleFetchError(err, setError, "Failed to lookup IP");
|
||||
})
|
||||
.finally(() => {
|
||||
setLoading(false);
|
||||
});
|
||||
}, []);
|
||||
|
||||
const clear = useCallback(() => {
|
||||
setResult(null);
|
||||
setError(null);
|
||||
}, []);
|
||||
|
||||
return { result, loading, error, lookup, clear };
|
||||
}
|
||||
export { useJails, type UseJailsResult } from "./useJailList";
|
||||
export { useJailDetail, type UseJailDetailResult } from "./useJailDetail";
|
||||
export { useJailBannedIps, type UseJailBannedIpsResult } from "./useJailBannedIps";
|
||||
export { useActiveBans, type UseActiveBansResult } from "./useActiveBans";
|
||||
export { useIpLookup, type UseIpLookupResult } from "./useIpLookup";
|
||||
|
||||
Reference in New Issue
Block a user