122 lines
4.0 KiB
TypeScript
122 lines
4.0 KiB
TypeScript
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';
|
|
import { TypedResult, wrap } from '@/utils/types/results';
|
|
|
|
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<TypedResult<UserModel | null>>} The user model if found, otherwise null.
|
|
*/
|
|
export const getUserByEmail = wrap(
|
|
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<TypedResult<UserModel>>} The saved user model.
|
|
*/
|
|
export const saveUser = wrap(
|
|
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<TypedResult<UserModel>>} The updated user model.
|
|
*/
|
|
export const updateUser = wrap(
|
|
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, updates it; if not, creates a new record.
|
|
* @param sessionClaims Session Claims from the Auth Provider
|
|
* @returns {Promise<TypedResult<UserModel>>} The synchronized user model.
|
|
*/
|
|
export const syncUser = wrap(
|
|
async (sessionClaims: SessionClaims): Promise<UserModel> => {
|
|
const { full_name, email } = sessionClaims.user;
|
|
const role = sessionClaims.user.public_metadata.role;
|
|
|
|
const existingUserResult = await getUserByEmail(email);
|
|
if (!existingUserResult.ok || !existingUserResult.value) {
|
|
const saveResult = await saveUser({
|
|
name: full_name,
|
|
email: email,
|
|
role: role,
|
|
});
|
|
if (!saveResult.ok) {
|
|
throw new Error(`User with email ${email} already exists`);
|
|
}
|
|
return saveResult.value;
|
|
}
|
|
const existingUser = existingUserResult.value;
|
|
|
|
const updateResult = await updateUser(existingUser.id, {
|
|
name: full_name,
|
|
email: existingUser.email,
|
|
role: role,
|
|
});
|
|
if (!updateResult.ok) {
|
|
throw new Error(
|
|
`Failed to update user with email ${email}: ${updateResult.error}`
|
|
);
|
|
}
|
|
return updateResult.value;
|
|
}
|
|
);
|
|
|
|
// Explicit re-export for TypeScript consumers who need the result type
|
|
export type { TypedResult };
|