MIF_E31221222/sigap-website/src/repositories/users.repository.ts

import { createAdminClient } from "@/app/_utils/supabase/admin";
import { createClient } from "@/app/_utils/supabase/client";
import { CreateUserParams, InviteUserParams, UpdateUserParams, User, UserResponse } from "@/src/entities/models/users/users.model";
import db from "@/prisma/db";
import { DatabaseOperationError, NotFoundError, InputParseError, AuthenticationError, UnauthenticatedError, UnauthorizedError } from "@/path/to/custom/errors";

export class UsersRepository {
    private supabaseAdmin = createAdminClient();
    private supabaseClient = createClient();

    async fetchUsers(): Promise<User[]> {
        const users = await db.users.findMany({
            include: {
                profile: true,
            },
        });

        if (!users) {
            throw new NotFoundError("Users not found");
        }

        return users;
    }

    async getCurrentUser(): Promise<UserResponse> {
        const supabase = await this.supabaseClient;

        const {
            data: { user },
            error,
        } = await supabase.auth.getUser();

        if (error) {
            console.error("Error fetching current user:", error);
            throw new AuthenticationError(error.message);
        }

        const userDetail = await db.users.findUnique({
            where: {
                id: user?.id,
            },
            include: {
                profile: true,
            },
        });

        if (!userDetail) {
            throw new NotFoundError("User not found");
        }

        return {
            data: {
                user: userDetail,
            },
            error: null,
        };
    }

    async createUser(params: CreateUserParams): Promise<UserResponse> {
        const supabase = this.supabaseAdmin;

        const { data, error } = await supabase.auth.admin.createUser({
            email: params.email,
            password: params.password,
            phone: params.phone,
            email_confirm: params.email_confirm,
        });

        if (error) {
            console.error("Error creating user:", error);
            throw new DatabaseOperationError(error.message);
        }

        return {
            data: {
                user: data.user,
            },
            error: null,
        };
    }

    async uploadAvatar(userId: string, email: string, file: File) {
        try {
            const supabase = await this.supabaseClient;

            const fileExt = file.name.split(".").pop();
            const emailName = email.split("@")[0];
            const fileName = `AVR-${emailName}.${fileExt}`;

            const filePath = `${userId}/${fileName}`;

            const { error: uploadError } = await supabase.storage
                .from("avatars")
                .upload(filePath, file, {
                    upsert: true,
                    contentType: file.type,
                });

            if (uploadError) {
                console.error("Error uploading avatar:", uploadError);
                throw new DatabaseOperationError(uploadError.message);
            }

            const {
                data: { publicUrl },
            } = supabase.storage.from("avatars").getPublicUrl(filePath);

            await db.users.update({
                where: {
                    id: userId,
                },
                data: {
                    profile: {
                        update: {
                            avatar: publicUrl,
                        },
                    },
                },
            });

            return publicUrl;
        } catch (error) {
            console.error("Error uploading avatar:", error);
            throw new DatabaseOperationError(error.message);
        }
    }

    async updateUser(userId: string, params: UpdateUserParams): Promise<UserResponse> {
        const supabase = this.supabaseAdmin;

        const { data, error } = await supabase.auth.admin.updateUserById(userId, {
            email: params.email,
            email_confirm: params.email_confirmed_at,
            password: params.encrypted_password ?? undefined,
            password_hash: params.encrypted_password ?? undefined,
            phone: params.phone,
            phone_confirm: params.phone_confirmed_at,
            role: params.role,
            user_metadata: params.user_metadata,
            app_metadata: params.app_metadata,
        });

        if (error) {
            console.error("Error updating user:", error);
            throw new DatabaseOperationError(error.message);
        }

        const user = await db.users.findUnique({
            where: {
                id: userId,
            },
            include: {
                profile: true,
            },
        });

        if (!user) {
            throw new NotFoundError("User not found");
        }

        const updateUser = await db.users.update({
            where: {
                id: userId,
            },
            data: {
                role: params.role || user.role,
                invited_at: params.invited_at || user.invited_at,
                confirmed_at: params.confirmed_at || user.confirmed_at,
                last_sign_in_at: params.last_sign_in_at || user.last_sign_in_at,
                is_anonymous: params.is_anonymous || user.is_anonymous,
                created_at: params.created_at || user.created_at,
                updated_at: params.updated_at || user.updated_at,
                profile: {
                    update: {
                        avatar: params.profile?.avatar || user.profile?.avatar,
                        username: params.profile?.username || user.profile?.username,
                        first_name: params.profile?.first_name || user.profile?.first_name,
                        last_name: params.profile?.last_name || user.profile?.last_name,
                        bio: params.profile?.bio || user.profile?.bio,
                        address: params.profile?.address || user.profile?.address,
                        birth_date: params.profile?.birth_date || user.profile?.birth_date,
                    },
                },
            },
            include: {
                profile: true,
            },
        });

        return {
            data: {
                user: {
                    ...data.user,
                    role: params.role,
                    profile: {
                        user_id: userId,
                        ...updateUser.profile,
                    },
                },
            },
            error: null,
        };
    }

    async deleteUser(userId: string): Promise<void> {
        const supabase = this.supabaseAdmin;

        const { error } = await supabase.auth.admin.deleteUser(userId);

        if (error) {
            console.error("Error deleting user:", error);
            throw new DatabaseOperationError(error.message);
        }
    }

    async sendPasswordRecovery(email: string): Promise<void> {
        const supabase = this.supabaseAdmin;

        const { error } = await supabase.auth.resetPasswordForEmail(email, {
            redirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/reset-password`,
        });

        if (error) {
            console.error("Error sending password recovery:", error);
            throw new DatabaseOperationError(error.message);
        }
    }

    async sendMagicLink(email: string): Promise<void> {
        const supabase = this.supabaseAdmin;

        const { error } = await supabase.auth.signInWithOtp({
            email,
            options: {
                emailRedirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/auth/callback`,
            },
        });

        if (error) {
            console.error("Error sending magic link:", error);
            throw new DatabaseOperationError(error.message);
        }
    }

    async banUser(userId: string): Promise<UserResponse> {
        const supabase = this.supabaseAdmin;

        const banUntil = new Date();
        banUntil.setFullYear(banUntil.getFullYear() + 100);

        const { data, error } = await supabase.auth.admin.updateUserById(userId, {
            ban_duration: "100h",
        });

        if (error) {
            console.error("Error banning user:", error);
            throw new DatabaseOperationError(error.message);
        }

        return {
            data: {
                user: data.user,
            },
            error: null,
        };
    }

    async unbanUser(userId: string): Promise<UserResponse> {
        const supabase = this.supabaseAdmin;

        const { data, error } = await supabase.auth.admin.updateUserById(userId, {
            ban_duration: "none",
        });

        if (error) {
            console.error("Error unbanning user:", error);
            throw new DatabaseOperationError(error.message);
        }

        const user = await db.users.findUnique({
            where: {
                id: userId,
            },
            select: {
                banned_until: true,
            }
        });

        if (!user) {
            throw new NotFoundError("User not found");
        }

        return {
            data: {
                user: data.user,
            },
            error: null,
        };
    }

    async inviteUser(params: InviteUserParams): Promise<void> {
        const supabase = this.supabaseAdmin;

        const { error } = await supabase.auth.admin.inviteUserByEmail(params.email, {
            redirectTo: `${process.env.NEXT_PUBLIC_SITE_URL}/api/auth/callback`,
        });

        if (error) {
            console.error("Error inviting user:", error);
            throw new DatabaseOperationError(error.message);
        }
    }
}