feat: initial commit

src/lib/feature/user/user.service.ts

@@ -0,0 +1,110 @@
+import { getRepository } from '@/lib/db/client';
+import { SessionClaims } from '@/lib/feature/user/clerk.model';
+import { UserEntity } from '@/lib/feature/user/user.entity';
+import {
+    CreateUserModel,
+    UpdateUserModel,
+    UserModel,
+} from '@/lib/feature/user/user.model';
+
+export const userEntityToModel = (userEntity: UserEntity): UserModel => {
+    return {
+        id: userEntity.id,
+        name: userEntity.name,
+        email: userEntity.email,
+        role: userEntity.role,
+        externalId: userEntity.externalId,
+    };
+};
+
+/**
+ * Retrieves a user by their email address.
+ * @param email - The email address of the user to retrieve.
+ * @returns {Promise<UserModel | null>} The user model if found, otherwise null.
+ */
+export const getUserByEmail = async (
+    email: string
+): Promise<UserModel | null> => {
+    const userRepository = await getRepository(UserEntity);
+
+    const userEntity = await userRepository.findOneBy({ email });
+
+    if (!userEntity) {
+        return null;
+    }
+
+    return userEntityToModel(userEntity);
+};
+
+/**
+ * Saves a new user to the database.
+ * @param user - The user data to save.
+ * @returns {Promise<UserModel>} The saved user model.
+ * @throws {Error} If a user with the same email already exists.
+ */
+export const saveUser = async (user: CreateUserModel): Promise<UserModel> => {
+    const userRepository = await getRepository(UserEntity);
+
+    if (!!(await userRepository.findOneBy({ email: user.email }))) {
+        throw new Error(`User with email ${user.email} already exists`);
+    }
+
+    const newUser = userRepository.create(user);
+    return userEntityToModel(await userRepository.save(newUser));
+};
+
+/**
+ * Updates an existing user in the database.
+ * @param userId - The ID of the user to update.
+ * @param user - The new user data.
+ * @returns {Promise<UserModel>} The updated user model.
+ * @throws {Error} If the user with the given ID does not exist.
+ */
+export const updateUser = async (
+    userId: string,
+    user: UpdateUserModel
+): Promise<UserModel> => {
+    const userRepository = await getRepository(UserEntity);
+
+    const existingUser = await userRepository.findOneBy({ id: userId });
+    if (!existingUser) {
+        throw new Error(`User with ID ${userId} not found`);
+    }
+
+    if (!!user.email) existingUser.email = user.email;
+    if (!!user.name) existingUser.name = user.name;
+    if (!!user.role) existingUser.role = user.role;
+
+    return userEntityToModel(await userRepository.save(existingUser));
+};
+
+/**
+ * Synchronizes a user with the database.
+ * If the user already exists, it skips saving and returns the existing user.
+ * If the user does not exist, it creates a new user record.
+ * @returns {Promise<UserModel>} The synchronized user model.
+ * @throws {Error} If the user email is not provided or if there is an issue
+ *                saving the user.
+ * @param sessionClaims Session Claims from the Auth Provider
+ */
+export const syncUser = async (
+    sessionClaims: SessionClaims
+): Promise<UserModel> => {
+    const { full_name, email } = sessionClaims.user;
+    const role = sessionClaims.user.public_metadata.role;
+
+    const existingUser = await getUserByEmail(email);
+    if (!existingUser) {
+        return await saveUser({
+            name: full_name,
+            email: email,
+            role: role,
+        });
+    }
+
+    return await updateUser(existingUser.id, {
+        name: full_name,
+        email: existingUser.email,
+        role: role,
+    });
+};