Merge remote-tracking branch 'origin/main' into announcements

Signed-off-by: marcin mikołajczak <git@mkljczk.pl>

src/api/hooks/admin/index.ts

@@ -1,6 +1,6 @@
-export { useCreateDomain, type CreateDomainParams } from './useCreateDomain';
-export { useDeleteDomain } from './useDeleteDomain';
 export { useDomains } from './useDomains';
+export { useModerationLog } from './useModerationLog';
+export { useRelays } from './useRelays';
+export { useRules } from './useRules';
 export { useSuggest } from './useSuggest';
-export { useUpdateDomain } from './useUpdateDomain';
 export { useVerify } from './useVerify';

src/api/hooks/admin/useDeleteDomain.ts

@@ -2,11 +2,6 @@ import { Entities } from 'soapbox/entity-store/entities';
 import { useDeleteEntity } from 'soapbox/entity-store/hooks';
 import { useApi } from 'soapbox/hooks';
 
-interface DeleteDomainParams {
-  domain: string;
-  public: boolean;
-}
-
 const useDeleteDomain = () => {
   const api = useApi();
 
@@ -23,4 +18,4 @@ const useDeleteDomain = () => {
   };
 };
 
-export { useDeleteDomain, type DeleteDomainParams };
+export { useDeleteDomain };

src/api/hooks/admin/useDomains.ts

@@ -1,8 +1,21 @@
-import { useQuery } from '@tanstack/react-query';
+import { useMutation, useQuery } from '@tanstack/react-query';
 
 import { useApi } from 'soapbox/hooks';
+import { queryClient } from 'soapbox/queries/client';
 import { domainSchema, type Domain } from 'soapbox/schemas';
 
+import type { AxiosResponse } from 'axios';
+
+interface CreateDomainParams {
+  domain: string;
+  public: boolean;
+}
+
+interface UpdateDomainParams {
+  id: string;
+  public: boolean;
+}
+
 const useDomains = () => {
   const api = useApi();
 
@@ -14,12 +27,56 @@ const useDomains = () => {
   };
 
   const result = useQuery<ReadonlyArray<Domain>>({
-    queryKey: ['domains'],
+    queryKey: ['admin', 'domains'],
     queryFn: getDomains,
     placeholderData: [],
   });
 
-  return result;
+  const {
+    mutate: createDomain,
+    isPending: isCreating,
+  } = useMutation({
+    mutationFn: (params: CreateDomainParams) => api.post('/api/v1/pleroma/admin/domains', params),
+    retry: false,
+    onSuccess: ({ data }: AxiosResponse) =>
+      queryClient.setQueryData(['admin', 'domains'], (prevResult: ReadonlyArray<Domain>) =>
+        [...prevResult, domainSchema.parse(data)],
+      ),
+  });
+
+  const {
+    mutate: updateDomain,
+    isPending: isUpdating,
+  } = useMutation({
+    mutationFn: ({ id, ...params }: UpdateDomainParams) => api.patch(`/api/v1/pleroma/admin/domains/${id}`, params),
+    retry: false,
+    onSuccess: ({ data }: AxiosResponse) =>
+      queryClient.setQueryData(['admin', 'domains'], (prevResult: ReadonlyArray<Domain>) =>
+        prevResult.map((domain) => domain.id === data.id ? domainSchema.parse(data) : domain),
+      ),
+  });
+
+  const {
+    mutate: deleteDomain,
+    isPending: isDeleting,
+  } = useMutation({
+    mutationFn: (id: string) => api.delete(`/api/v1/pleroma/admin/domains/${id}`),
+    retry: false,
+    onSuccess: (_, id) =>
+      queryClient.setQueryData(['admin', 'domains'], (prevResult: ReadonlyArray<Domain>) =>
+        prevResult.filter(({ id: domainId }) => domainId !== id),
+      ),
+  });
+
+  return {
+    ...result,
+    createDomain,
+    isCreating,
+    updateDomain,
+    isUpdating,
+    deleteDomain,
+    isDeleting,
+  };
 };
 
 export { useDomains };

src/api/hooks/admin/useModerationLog.ts

@@ -0,0 +1,42 @@
+import { useInfiniteQuery } from '@tanstack/react-query';
+
+import { useApi } from 'soapbox/hooks';
+import { moderationLogEntrySchema, type ModerationLogEntry } from 'soapbox/schemas';
+
+interface ModerationLogResult {
+  items: ModerationLogEntry[];
+  total: number;
+}
+
+const flattenPages = (pages?: ModerationLogResult[]): ModerationLogEntry[] => (pages || []).map(({ items }) => items).flat();
+
+const useModerationLog = () => {
+  const api = useApi();
+
+  const getModerationLog = async (page: number): Promise<ModerationLogResult> => {
+    const { data } = await api.get<ModerationLogResult>('/api/v1/pleroma/admin/moderation_log', { params: { page } });
+
+    const normalizedData = data.items.map((domain) => moderationLogEntrySchema.parse(domain));
+
+    return {
+      items: normalizedData,
+      total: data.total,
+    };
+  };
+
+  const queryInfo = useInfiniteQuery({
+    queryKey: ['admin', 'moderation_log'],
+    queryFn: ({ pageParam }) => getModerationLog(pageParam),
+    initialPageParam: 1,
+    getNextPageParam: (page, allPages) => flattenPages(allPages)!.length >= page.total ? undefined : allPages.length + 1,
+  });
+
+  const data = flattenPages(queryInfo.data?.pages);
+
+  return {
+    ...queryInfo,
+    data,
+  };
+};
+
+export { useModerationLog };

src/api/hooks/admin/useRelays.ts

@@ -0,0 +1,60 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+
+import { useApi } from 'soapbox/hooks';
+import { queryClient } from 'soapbox/queries/client';
+import { relaySchema, type Relay } from 'soapbox/schemas';
+
+import type { AxiosResponse } from 'axios';
+
+const useRelays = () => {
+  const api = useApi();
+
+  const getRelays = async () => {
+    const { data } = await api.get<{ relays: Relay[] }>('/api/v1/pleroma/admin/relay');
+
+    const normalizedData = data.relays?.map((relay) => relaySchema.parse(relay));
+    return normalizedData;
+  };
+
+  const result = useQuery<ReadonlyArray<Relay>>({
+    queryKey: ['admin', 'relays'],
+    queryFn: getRelays,
+    placeholderData: [],
+  });
+
+  const {
+    mutate: followRelay,
+    isPending: isPendingFollow,
+  } = useMutation({
+    mutationFn: (relayUrl: string) => api.post('/api/v1/pleroma/admin/relays', { relay_url: relayUrl }),
+    retry: false,
+    onSuccess: ({ data }: AxiosResponse) =>
+      queryClient.setQueryData(['admin', 'relays'], (prevResult: ReadonlyArray<Relay>) =>
+        [...prevResult, relaySchema.parse(data)],
+      ),
+  });
+
+  const {
+    mutate: unfollowRelay,
+    isPending: isPendingUnfollow,
+  } = useMutation({
+    mutationFn: (relayUrl: string) => api.delete('/api/v1/pleroma/admin/relays', {
+      data: { relay_url: relayUrl },
+    }),
+    retry: false,
+    onSuccess: (_, relayUrl) =>
+      queryClient.setQueryData(['admin', 'relays'], (prevResult: ReadonlyArray<Relay>) =>
+        prevResult.filter(({ actor }) => actor !== relayUrl),
+      ),
+  });
+
+  return {
+    ...result,
+    followRelay,
+    isPendingFollow,
+    unfollowRelay,
+    isPendingUnfollow,
+  };
+};
+
+export { useRelays };

src/api/hooks/admin/useRules.ts

@@ -0,0 +1,85 @@
+import { useMutation, useQuery } from '@tanstack/react-query';
+
+import { useApi } from 'soapbox/hooks';
+import { queryClient } from 'soapbox/queries/client';
+import { adminRuleSchema, type AdminRule } from 'soapbox/schemas';
+
+import type { AxiosResponse } from 'axios';
+
+interface CreateRuleParams {
+  priority?: number;
+  text: string;
+  hint?: string;
+}
+
+interface UpdateRuleParams {
+  id: string;
+  priority?: number;
+  text?: string;
+  hint?: string;
+}
+
+const useRules = () => {
+  const api = useApi();
+
+  const getRules = async () => {
+    const { data } = await api.get<AdminRule[]>('/api/v1/pleroma/admin/rules');
+
+    const normalizedData = data.map((rule) => adminRuleSchema.parse(rule));
+    return normalizedData;
+  };
+
+  const result = useQuery<ReadonlyArray<AdminRule>>({
+    queryKey: ['admin', 'rules'],
+    queryFn: getRules,
+    placeholderData: [],
+  });
+
+  const {
+    mutate: createRule,
+    isPending: isCreating,
+  } = useMutation({
+    mutationFn: (params: CreateRuleParams) => api.post('/api/v1/pleroma/admin/rules', params),
+    retry: false,
+    onSuccess: ({ data }: AxiosResponse) =>
+      queryClient.setQueryData(['admin', 'rules'], (prevResult: ReadonlyArray<AdminRule>) =>
+        [...prevResult, adminRuleSchema.parse(data)],
+      ),
+  });
+
+  const {
+    mutate: updateRule,
+    isPending: isUpdating,
+  } = useMutation({
+    mutationFn: ({ id, ...params }: UpdateRuleParams) => api.patch(`/api/v1/pleroma/admin/rules/${id}`, params),
+    retry: false,
+    onSuccess: ({ data }: AxiosResponse) =>
+      queryClient.setQueryData(['admin', 'rules'], (prevResult: ReadonlyArray<AdminRule>) =>
+        prevResult.map((rule) => rule.id === data.id ? adminRuleSchema.parse(data) : rule),
+      ),
+  });
+
+  const {
+    mutate: deleteRule,
+    isPending: isDeleting,
+  } = useMutation({
+    mutationFn: (id: string) => api.delete(`/api/v1/pleroma/admin/rules/${id}`),
+    retry: false,
+    onSuccess: (_, id) =>
+      queryClient.setQueryData(['admin', 'rules'], (prevResult: ReadonlyArray<AdminRule>) =>
+        prevResult.filter(({ id: ruleId }) => ruleId !== id),
+      ),
+  });
+
+  return {
+    ...result,
+    createRule,
+    isCreating,
+    updateRule,
+    isUpdating,
+    deleteRule,
+    isDeleting,
+  };
+};
+
+export { useRules };

src/api/index.ts

@@ -4,7 +4,7 @@
  * @module soapbox/api
  */
 
-import axios, { AxiosInstance, AxiosResponse } from 'axios';
+import axios, { type AxiosInstance, type AxiosResponse } from 'axios';
 import LinkHeader from 'http-link-header';
 import { createSelector } from 'reselect';