concord/concord-server/src/services/userService.ts

import {
  Message,
  MessagePing,
  PrismaClient,
  Role,
  UserAuth,
} from "@prisma/client";
import { CreateUserInput } from "../validators/userValidator";
import shaHash from "../helper/hashing";

const prisma = new PrismaClient();

export async function createUser(data: CreateUserInput): Promise<{
  username: string;
  nickname: string | null;
  bio: string | null;
  picture: string | null;
  banner: string | null;
  status: string;
  admin: boolean;
} | null> {
  const requestingUser = await getUserInformation(data.requestingUserId);
  const requestingUserCredentials = await getUserCredentials(
    data.requestingUserId,
  );
  if (
    !requestingUser ||
    !requestingUserCredentials ||
    !requestingUser.admin ||
    requestingUserCredentials.token == null ||
    data.requestingUserToken != requestingUserCredentials.token
  ) {
    return null;
  }

  if ((await prisma.user.count({ where: { username: data.username } })) >= 1) {
    return null;
  }

  const userData = await prisma.user.create({
    data: {
      username: data.username,
      nickname: data.nickname,
      bio: data.bio,
      picture: data.picture,
      banner: data.banner,
      status: data.status,
      admin: data.admin,
    },
  });

  if (
    !(await prisma.userAuth.create({
      data: {
        userId: userData.id,
        password: shaHash(data.passwordhash, userData.id),
        token: null,
      },
    }))
  ) {
    return null;
  }

  return userData;
}

export async function getUserCredentials(userId: string): Promise<{
  userId: string;
  password: string;
  token: string | null;
} | null> {
  try {
    if (!userId) {
      throw new Error("missing userId");
    }

    const userAuth = await prisma.userAuth.findUnique({
      where: {
        userId: userId,
      },
    });

    if (!userAuth) {
      throw new Error("could not find user credentials");
    }

    return {
      userId: userAuth.userId,
      password: userAuth.password,
      token: userAuth.token,
    };
  } catch (err) {
    const errMessage = err as Error;

    if (errMessage.message === "missing userId") {
      console.log("services::actions::getUserCredentials - missing userId");
      return null;
    }

    if (errMessage.message === "could not find user credentials") {
      console.log(
        "services::actions::getUserCredentials - unable to find user credentials",
      );
      return null;
    }

    console.log(
      "services::actions::getUserCredentials - unknown error",
      errMessage,
    );
    return null;
  }
}

export async function getUserInformation(userId: string): Promise<{
  id: string;
  userName: string;
  nickName: string | null;
  bio: string | null;
  picture: string | null;
  banner: string | null;
  admin: boolean;
  status: "online" | "offline" | "dnd" | "idle" | "invis";
  role: Role[];
} | null> {
  try {
    if (!userId) {
      throw new Error("missing userId");
    }

    const user = await prisma.user.findUnique({
      where: {
        id: userId,
      },
    });

    if (!user) {
      throw new Error("could not find user");
    }

    const userRoles = await prisma.role.findMany({
      where: {
        userId: userId,
      },
    });

    return {
      id: userId,
      userName: user.username,
      nickName: user.nickname,
      bio: user.bio,
      picture: user.picture,
      banner: user.banner,
      admin: user.admin,
      status: (["online", "offline", "dnd", "idle", "invis"] as const).includes(
        user.status as any,
      )
        ? (user.status as "online" | "offline" | "dnd" | "idle" | "invis")
        : "offline",
      role: userRoles,
    };
  } catch (err) {
    const errMessage = err as Error;

    if (errMessage.message === "missing userId") {
      console.log("services::actions::getUserInformation - missing userId");
      return null;
    }

    if (errMessage.message === "could not find user") {
      console.log(
        "services::actions::getUserInformation - unable to find user",
      );
      return null;
    }

    console.log(
      "services::actions::getUserInformation - unknown error",
      errMessage,
    );
    return null;
  }
}

export async function getAllUsersFrom(instanceId: string): Promise<
  | {
      id: string;
      userName: string;
      nickName: string | null;
      bio: string | null;
      picture: string | null;
      banner: string | null;
      admin: boolean;
      status: "online" | "offline" | "dnd" | "idle" | "invis";
      role: {
        userId: string;
        instanceId: string;
      }[];
    }[]
  | null
> {
  try {
    const instances = await prisma.instance.count({
      where: {
        id: instanceId,
      },
    });
    if (instances < 1) {
      throw new Error("could not find given instance id");
    }

    const users = await prisma.user.findMany({
      where: {
        Role: {
          some: {
            instanceId: instanceId,
          },
        },
      },
    });
    if (!users) {
      throw new Error("could not get all users in instance");
    }

    const admins = await prisma.user.findMany({
      where: {
        admin: true,
      },
    });
    if (!admins) {
      throw new Error("could not get all admins");
    }
    const adminData = await Promise.all(
      admins.map(async (u) => {
        const adminRoles = await prisma.role.findMany({
          where: {
            userId: u.id,
          },
        });

        if (!adminRoles) {
          throw new Error("could not get admin roles for admin " + u.id);
        }

        return {
          id: u.id,
          userName: u.username,
          nickName: u.nickname,
          bio: u.bio,
          picture: u.picture,
          banner: u.banner,
          admin: u.admin,
          status: (
            ["online", "offline", "dnd", "idle", "invis"] as const
          ).includes(u.status as any)
            ? (u.status as "online" | "offline" | "dnd" | "idle" | "invis")
            : "offline",
          role: adminRoles.map((r) => ({
            userId: r.userId,
            instanceId: r.instanceId,
          })),
        };
      }),
    );

    const userData = await Promise.all(
      users.map(async (u) => {
        const userRoles = await prisma.role.findMany({
          where: {
            userId: u.id,
          },
        });
        if (!userRoles) {
          throw new Error("could not get user roles for user " + u.id);
        }

        return {
          id: u.id,
          userName: u.username,
          nickName: u.nickname,
          bio: u.bio,
          picture: u.picture,
          banner: u.banner,
          admin: u.admin,
          status: (
            ["online", "offline", "dnd", "idle", "invis"] as const
          ).includes(u.status as any)
            ? (u.status as "online" | "offline" | "dnd" | "idle" | "invis")
            : "offline",
          role: userRoles,
        };
      }),
    );

    return userData.concat(adminData);
  } catch (err) {
    console.log(err);
    return null;
  }
}