Moved v3 code from NginxProxyManager/nginx-proxy-manager-3 to NginxProxyManager/nginx-proxy-manager

frontend/src/hooks/index.ts

@@ -0,0 +1,12 @@
+export * from "./useCertificateAuthorities";
+export * from "./useCertificateAuthority";
+export * from "./useCertificates";
+export * from "./useDNSProvider";
+export * from "./useDNSProviders";
+export * from "./useDNSProvidersAcmesh";
+export * from "./useHealth";
+export * from "./useHosts";
+export * from "./useHostTemplates";
+export * from "./useSettings";
+export * from "./useUser";
+export * from "./useUsers";

frontend/src/hooks/useCertificateAuthorities.ts

@@ -0,0 +1,41 @@
+import {
+	CertificateAuthoritiesResponse,
+	getCertificateAuthorities,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchCertificateAuthorities = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+) => {
+	return getCertificateAuthorities(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useCertificateAuthorities = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<CertificateAuthoritiesResponse, Error>(
+		["certificate-authorities", { offset, limit, sortBy, filters }],
+		() => fetchCertificateAuthorities(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { fetchCertificateAuthorities, useCertificateAuthorities };

frontend/src/hooks/useCertificateAuthority.ts

@@ -0,0 +1,62 @@
+import {
+	createCertificateAuthority,
+	getCertificateAuthority,
+	setCertificateAuthority,
+	CertificateAuthority,
+} from "api/npm";
+import { useMutation, useQuery, useQueryClient } from "react-query";
+
+const fetchCertificateAuthority = (id: any) => {
+	return getCertificateAuthority(id);
+};
+
+const useCertificateAuthority = (id: number, options = {}) => {
+	return useQuery<CertificateAuthority, Error>(
+		["certificate-authority", id],
+		() => fetchCertificateAuthority(id),
+		{
+			staleTime: 60 * 1000, // 1 minute
+			...options,
+		},
+	);
+};
+
+const useSetCertificateAuthority = () => {
+	const queryClient = useQueryClient();
+	return useMutation(
+		(values: CertificateAuthority) => {
+			return values.id
+				? setCertificateAuthority(values.id, values)
+				: createCertificateAuthority(values);
+		},
+		{
+			onMutate: (values) => {
+				const previousObject = queryClient.getQueryData([
+					"certificate-authority",
+					values.id,
+				]);
+
+				queryClient.setQueryData(
+					["certificate-authority", values.id],
+					(old: any) => ({
+						...old,
+						...values,
+					}),
+				);
+
+				return () =>
+					queryClient.setQueryData(
+						["certificate-authority", values.id],
+						previousObject,
+					);
+			},
+			onError: (error, values, rollback: any) => rollback(),
+			onSuccess: async ({ id }: CertificateAuthority) => {
+				queryClient.invalidateQueries(["certificate-authority", id]);
+				queryClient.invalidateQueries("certificate-authorities");
+			},
+		},
+	);
+};
+
+export { useCertificateAuthority, useSetCertificateAuthority };

frontend/src/hooks/useCertificates.ts

@@ -0,0 +1,41 @@
+import {
+	getCertificates,
+	CertificatesResponse,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchCertificates = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+) => {
+	return getCertificates(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useCertificates = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<CertificatesResponse, Error>(
+		["hosts", { offset, limit, sortBy, filters }],
+		() => fetchCertificates(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { fetchCertificates, useCertificates };

frontend/src/hooks/useDNSProvider.ts

@@ -0,0 +1,56 @@
+import {
+	createDNSProvider,
+	getDNSProvider,
+	setDNSProvider,
+	DNSProvider,
+} from "api/npm";
+import { useMutation, useQuery, useQueryClient } from "react-query";
+
+const fetchDNSProvider = (id: any) => {
+	return getDNSProvider(id);
+};
+
+const useDNSProvider = (id: number, options = {}) => {
+	return useQuery<DNSProvider, Error>(
+		["dns-provider", id],
+		() => fetchDNSProvider(id),
+		{
+			staleTime: 60 * 1000, // 1 minute
+			...options,
+		},
+	);
+};
+
+const useSetDNSProvider = () => {
+	const queryClient = useQueryClient();
+	return useMutation(
+		(values: DNSProvider) => {
+			return values.id
+				? setDNSProvider(values.id, values)
+				: createDNSProvider(values);
+		},
+		{
+			onMutate: (values) => {
+				const previousObject = queryClient.getQueryData([
+					"dns-provider",
+					values.id,
+				]);
+
+				queryClient.setQueryData(["dns-provider", values.id], (old: any) => ({
+					...old,
+					...values,
+				}));
+
+				return () =>
+					queryClient.setQueryData(["dns-provider", values.id], previousObject);
+			},
+			onError: (error, values, rollback: any) => rollback(),
+			onSuccess: async ({ id }: DNSProvider) => {
+				queryClient.invalidateQueries(["dns-provider", id]);
+				queryClient.invalidateQueries("dns-providers");
+			},
+		},
+	);
+};
+
+export { useDNSProvider, useSetDNSProvider };

frontend/src/hooks/useDNSProviders.ts

@@ -0,0 +1,41 @@
+import {
+	getDNSProviders,
+	DNSProvidersResponse,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchDNSProviders = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+) => {
+	return getDNSProviders(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useDNSProviders = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<DNSProvidersResponse, Error>(
+		["dns-providers", { offset, limit, sortBy, filters }],
+		() => fetchDNSProviders(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { useDNSProviders };

frontend/src/hooks/useDNSProvidersAcmesh.ts

@@ -0,0 +1,16 @@
+import { DNSProvidersAcmesh, getDNSProvidersAcmesh } from "api/npm";
+import { useQuery } from "react-query";
+
+const useDNSProvidersAcmesh = (options = {}) => {
+	return useQuery<DNSProvidersAcmesh[], Error>(
+		["dns-providers-acmesh"],
+		() => getDNSProvidersAcmesh(),
+		{
+			keepPreviousData: true,
+			staleTime: 60 * 60 * 1000, // 1 hour
+			...options,
+		},
+	);
+};
+
+export { useDNSProvidersAcmesh };

frontend/src/hooks/useHealth.ts

@@ -0,0 +1,16 @@
+import { getHealth, HealthResponse } from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchHealth = () => getHealth();
+
+const useHealth = (options = {}) => {
+	return useQuery<HealthResponse, Error>("health", fetchHealth, {
+		refetchOnWindowFocus: false,
+		retry: 5,
+		refetchInterval: 15 * 1000, // 15 seconds
+		staleTime: 14 * 1000, // 14 seconds
+		...options,
+	});
+};
+
+export { fetchHealth, useHealth };

frontend/src/hooks/useHostTemplates.ts

@@ -0,0 +1,41 @@
+import {
+	getHostTemplates,
+	HostTemplatesResponse,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchHostTemplates = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+) => {
+	return getHostTemplates(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useHostTemplates = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<HostTemplatesResponse, Error>(
+		["hosts", { offset, limit, sortBy, filters }],
+		() => fetchHostTemplates(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { fetchHostTemplates, useHostTemplates };

frontend/src/hooks/useHosts.ts

@@ -0,0 +1,36 @@
+import {
+	getHosts,
+	HostsResponse,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchHosts = (offset = 0, limit = 10, sortBy?: any, filters?: any) => {
+	return getHosts(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useHosts = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<HostsResponse, Error>(
+		["hosts", { offset, limit, sortBy, filters }],
+		() => fetchHosts(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { fetchHosts, useHosts };

frontend/src/hooks/useSettings.ts

@@ -0,0 +1,36 @@
+import {
+	getSettings,
+	SettingsResponse,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchSettings = (offset = 0, limit = 10, sortBy?: any, filters?: any) => {
+	return getSettings(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useSettings = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<SettingsResponse, Error>(
+		["settings", { offset, limit, sortBy, filters }],
+		() => fetchSettings(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { fetchSettings, useSettings };

frontend/src/hooks/useUser.ts

@@ -0,0 +1,37 @@
+import { getUser, setUser, User } from "api/npm";
+import { useMutation, useQuery, useQueryClient } from "react-query";
+
+const fetchUser = (id: any) => {
+	return getUser(id, { expand: "capabilities" });
+};
+
+const useUser = (id: string | number, options = {}) => {
+	return useQuery<User, Error>(["user", id], () => fetchUser(id), {
+		staleTime: 60 * 1000, // 1 minute
+		...options,
+	});
+};
+
+const useSetUser = () => {
+	const queryClient = useQueryClient();
+	return useMutation((values: User) => setUser(values.id, values), {
+		onMutate: (values) => {
+			const previousObject = queryClient.getQueryData(["user", values.id]);
+
+			queryClient.setQueryData(["user", values.id], (old: any) => ({
+				...old,
+				...values,
+			}));
+
+			return () =>
+				queryClient.setQueryData(["user", values.id], previousObject);
+		},
+		onError: (error, values, rollback: any) => rollback(),
+		onSuccess: async ({ id }: User) => {
+			queryClient.invalidateQueries(["user", id]);
+			queryClient.invalidateQueries("users");
+		},
+	});
+};
+
+export { useUser, useSetUser };

frontend/src/hooks/useUsers.ts

@@ -0,0 +1,36 @@
+import {
+	getUsers,
+	UsersResponse,
+	tableSortToAPI,
+	tableFiltersToAPI,
+} from "api/npm";
+import { useQuery } from "react-query";
+
+const fetchUsers = (offset = 0, limit = 10, sortBy?: any, filters?: any) => {
+	return getUsers(
+		offset,
+		limit,
+		tableSortToAPI(sortBy),
+		tableFiltersToAPI(filters),
+	);
+};
+
+const useUsers = (
+	offset = 0,
+	limit = 10,
+	sortBy?: any,
+	filters?: any,
+	options = {},
+) => {
+	return useQuery<UsersResponse, Error>(
+		["users", { offset, limit, sortBy, filters }],
+		() => fetchUsers(offset, limit, sortBy, filters),
+		{
+			keepPreviousData: true,
+			staleTime: 15 * 1000, // 15 seconds
+			...options,
+		},
+	);
+};
+
+export { fetchUsers, useUsers };