139 lines
4.3 KiB
TypeScript
139 lines
4.3 KiB
TypeScript
import { useMutation, useQuery } from "@tanstack/react-query";
|
|
import {
|
|
banUser,
|
|
getCurrentUser,
|
|
getUserByEmail,
|
|
getUserById,
|
|
getUsers,
|
|
unbanUser,
|
|
inviteUser,
|
|
createUser,
|
|
updateUser,
|
|
deleteUser,
|
|
getUserByUsername
|
|
} from "./action";
|
|
import { IUserSchema } from "@/src/entities/models/users/users.model";
|
|
import { IBanUserSchema, ICredentialsBanUserSchema } from "@/src/entities/models/users/ban-user.model";
|
|
import { IUnbanUserSchema } from "@/src/entities/models/users/unban-user.model";
|
|
import { ICreateUserSchema } from "@/src/entities/models/users/create-user.model";
|
|
import { IUpdateUserSchema } from "@/src/entities/models/users/update-user.model";
|
|
import { ICredentialsInviteUserSchema } from "@/src/entities/models/users/invite-user.model";
|
|
|
|
const useUsersAction = () => {
|
|
|
|
// For all users (no parameters needed)
|
|
const getUsersQuery = useQuery<IUserSchema[]>({
|
|
queryKey: ["users"],
|
|
queryFn: async () => await getUsers()
|
|
});
|
|
|
|
// Current user query doesn't need parameters
|
|
const getCurrentUserQuery = useQuery({
|
|
queryKey: ["user", "current"],
|
|
queryFn: async () => await getCurrentUser()
|
|
});
|
|
|
|
const getUserByIdQuery = (id: string) => ({
|
|
queryKey: ["user", id],
|
|
queryFn: async () => await getUserById(id)
|
|
});
|
|
|
|
const getUserByEmailQuery = (email: string) => ({
|
|
queryKey: ["user", "email", email],
|
|
queryFn: async () => await getUserByEmail({ email })
|
|
});
|
|
|
|
const getUserByUsernameQuery = (username: string) => ({
|
|
queryKey: ["user", "username", username],
|
|
queryFn: async () => await getUserByUsername(username)
|
|
});
|
|
|
|
// Mutations that don't need dynamic parameters
|
|
const banUserMutation = useMutation({
|
|
mutationKey: ["banUser"],
|
|
mutationFn: async ({ credential, params }: { credential: ICredentialsBanUserSchema; params: IBanUserSchema }) => await banUser(credential.id, params.ban_duration)
|
|
});
|
|
|
|
const unbanUserMutation = useMutation({
|
|
mutationKey: ["unbanUser"],
|
|
mutationFn: async (params: IUnbanUserSchema) => await unbanUser(params.id)
|
|
});
|
|
|
|
// Create functions that return configured hooks
|
|
const inviteUserMutation = useMutation({
|
|
mutationKey: ["inviteUser"],
|
|
mutationFn: async (credential: ICredentialsInviteUserSchema) => await inviteUser(credential)
|
|
});
|
|
|
|
const createUserMutation = useMutation({
|
|
mutationKey: ["createUser"],
|
|
mutationFn: async (data: ICreateUserSchema) => await createUser(data)
|
|
});
|
|
|
|
const updateUserMutation = useMutation({
|
|
mutationKey: ["updateUser"],
|
|
mutationFn: async (params: { id: string; data: IUpdateUserSchema }) => updateUser(params.id, params.data)
|
|
});
|
|
|
|
const deleteUserMutation = useMutation({
|
|
mutationKey: ["deleteUser"],
|
|
mutationFn: async (id: string) => await deleteUser(id)
|
|
});
|
|
|
|
return {
|
|
getUsers: getUsersQuery,
|
|
getCurrentUser: getCurrentUserQuery,
|
|
getUserById: getUserByIdQuery,
|
|
getUserByEmailQuery,
|
|
getUserByUsernameQuery,
|
|
banUser: banUserMutation,
|
|
unbanUser: unbanUserMutation,
|
|
inviteUser: inviteUserMutation,
|
|
createUser: createUserMutation,
|
|
updateUser: updateUserMutation,
|
|
deleteUser: deleteUserMutation
|
|
};
|
|
}
|
|
|
|
export const useGetUsersQuery = () => {
|
|
const { getUsers } = useUsersAction();
|
|
|
|
return {
|
|
data: getUsers.data,
|
|
isPending: getUsers.isPending,
|
|
error: getUsers.error,
|
|
refetch: getUsers.refetch,
|
|
};
|
|
}
|
|
|
|
export const useGetCurrentUserQuery = () => {
|
|
const { getCurrentUser } = useUsersAction();
|
|
|
|
return {
|
|
data: getCurrentUser.data,
|
|
isPending: getCurrentUser.isPending,
|
|
error: getCurrentUser.error,
|
|
refetch: getCurrentUser.refetch,
|
|
};
|
|
}
|
|
|
|
export const useCreateUserMutation = () => {
|
|
const { createUser } = useUsersAction();
|
|
|
|
return {
|
|
createUser: createUser.mutateAsync,
|
|
isPending: createUser.isPending,
|
|
errors: createUser.error,
|
|
}
|
|
}
|
|
|
|
export const useInviteUserMutation = () => {
|
|
const { inviteUser } = useUsersAction();
|
|
|
|
return {
|
|
inviteUser: inviteUser.mutateAsync,
|
|
isPending: inviteUser.isPending,
|
|
errors: inviteUser.error,
|
|
}
|
|
}
|