monorepo/apps/api/src/server/auth/service.ts

import type { User } from '@prisma/client';

import db from '@/libs/db/prismaClient';
import { hashPassword, verifyPassword } from '@/libs/password';
import { isNil, omit } from 'lodash';

import type { createUserType } from './type';

export async function getUserByEmail(
    email: string,
): Promise<Pick<User, 'id' | 'email' | 'username' | 'password'> | null> {
    const user = await db.user.findFirst({
        where: { email },
        select: {
            id: true,
            email: true,
            username: true,
            password: true,
        },
    });
    if (isNil(user)) return null;
    return user;
}
export async function getUserById(id: string): Promise<User | null> {
    const user = await db.user.findUnique({ where: { id } });

    return user;
}
export async function getUserByusername(username: string): Promise<User | null> {
    return await db.user.findFirst({ where: { username } });
}

export async function createUser(data: createUserType): Promise<Omit<User, 'password'>> {
    const { username, email, password } = data;

    const user = await db.user.create({
        data: {
            email,
            password: hashPassword(password),
            username,
        },
    });
    return omit(user, ['password']);
}

export async function ValidateUser(
    credential: string,
    password: string,
): Promise<
    | { success: false; message: string; user: null }
    | {
          success: true;
          message: string;
          user: {
              id: string;
              email: string;
              username: string;
              role: 'ADMIN' | 'USER';
              createdAt: Date;
              updatedAt: Date;
          };
      }
> {
    const user = await db.user.findFirst({
        where: {
            OR: [{ email: credential }, { username: credential }],
        },
        select: {
            id: true,
            email: true,
            username: true,
            role: true,
            password: true,
            createdAt: true,
            updatedAt: true,
        },
    });
    if (isNil(user)) {
        return {
            success: false,
            message: '用戶不存在',
            user: null,
        };
    }

    const ispasswordValid = verifyPassword(password, user.password);
    if (!ispasswordValid) {
        return {
            success: false,
            message: '密碼錯誤',
            user: null,
        };
    }

    return {
        success: true,
        message: '登入成功',
        user: omit(user, ['password']),
    };
}
export async function uniqueEmailValidator(email: string): Promise<boolean> {
    if (isNil(email)) return true;
    const user = await getUserByEmail(email);
    if (isNil(user)) return true;
    return false;
}
export async function uniqueUsernameValidator(username: string): Promise<boolean> {
    if (isNil(username)) return true;
    const user = await getUserByusername(username);
    if (isNil(user)) return true;
    return false;
}