Refacto/clean user service

package.json

@@ -15,7 +15,8 @@
         "@supabase/supabase-js": "^2.49.4",
         "bearer": "^0.0.20",
         "elysia": "^1.2.25",
-        "elysia-http-error": "^1.3.0"
+        "elysia-http-error": "^1.3.0",
+        "winston": "^3.18.3"
     },
     "devDependencies": {
         "bun-types": "latest"

src/data/relations.ts

@@ -1,4 +1,8 @@
 import { HttpError } from 'elysia-http-error';
+import { getLogger } from '../services/logger';
+import { Logger } from 'winston';
+
+const logger: Logger = getLogger('relationData');
 
 export async function createUserNode(bearer: string): Promise<void> {
     const userUrl = (process.env.LIKE_URL || 'http://localhost:3000') + '/userNode';
@@ -12,12 +16,12 @@ export async function createUserNode(bearer: string): Promise<void> {
     try {
         await fetch(request);
     } catch (error) {
-        console.error('Error creating user node:', error);
+        logger.error(`Error creating user node: ${error}`);
         throw new HttpError('Error creating user node', 500);
     }
 }
 
-export async function fetchRecommendedCollocs(bearer: string): Promise<{userIds: string[]}> {
+export async function fetchRecommendedCollocs(bearer: string): Promise<string[]> {
     const userUrl = (process.env.LIKE_URL || 'http://localhost:3000') + '/recommendedColloc';
     const request = new Request(userUrl, {
         method: 'get',
@@ -29,7 +33,7 @@ export async function fetchRecommendedCollocs(bearer: string): Promise<{userIds:
     try {
         return await (await fetch(request)).json();
     } catch (error) {
-        console.error('Error getting recommended Collocs:', error);
+        logger.error(`Error getting recommended Collocs: ${error}`);
         throw new HttpError('Error getting recommended Collocs', 500);
     }
 }

src/data/user.ts

@@ -2,134 +2,123 @@ import { Session } from '@supabase/supabase-js';
 import { supabase } from '../libs/supabase';
 import User from '../models/user';
 import RegisterResponse from '../routes/responses/register';
+import { getLogger } from '../services/logger';
+import { Logger } from 'winston';
 
-async function authenticateUser(email: string, password: string): Promise<string> {
+const logger: Logger = getLogger('UserData')
+
+export async function authenticateUser(email: string, password: string): Promise<string> {
     const { data, error } = await supabase.auth.signUp({
         email: email,
         password: password,
     });
     if (error) {
-        console.error('authenticateUse: Error creating user:', error);
+        logger.error(`authenticateUse: Error creating user: ${error}`);
         throw error;
     }
     return data.user!.id;
 }
 
-async function refreshUser(bearer: string): Promise<Session | null> {
+export async function refreshUser(bearer: string): Promise<Session | null> {
     const { data, error } = await supabase.auth.refreshSession({ refresh_token: bearer });
     if (error) {
-        console.error('Error refreshing user session:', error);
+        logger.error(`Error refreshing user session: ${error}`);
         throw error;
     }
     return data.session;
 }
 
-async function loginUser(email: string, password: string): Promise<Session> {
-    console.log('Loggin in user: ', email);
+export async function loginUser(email: string, password: string): Promise<Session> {
+    logger.info(`Loggin in user: ${email}`);
     const { data, error } = await supabase.auth.signInWithPassword({
         email: email,
         password: password,
     });
     if (error) {
-        console.error('Error logging in user:', error);
+        logger.error(`Error logging in user: ${error}`);
         throw error;
     }
-    console.log('Login data: ', data);
+    logger.info(`Login data: ${data}`);
     return data.session;
 }
 
-async function createUser(user: User): Promise<void> {
-    console.log('Creating user: ', user);
+export async function createUser(user: User): Promise<void> {
+    logger.info(`Creating user: ${user}`);
     const { error } = await supabase.from('users').insert([user]);
     if (error) {
-        console.error('creatingUser: Error creating user:', error);
+        logger.error(`Error creating user: ${error}`);
         throw error;
     }
 }
 
-async function createprofilePictureSignedUploadUrl(userId: string): Promise<RegisterResponse> {
+export async function createprofilePictureSignedUploadUrl(userId: string): Promise<RegisterResponse> {
     const { data, error } = await supabase.storage
         .from('user-pictures')
-        .createSignedUploadUrl(`${userId}.png`);
+        .createSignedUploadUrl(`${userId}.jpeg`);
 
     if (error) {
-        console.error('creatingUser: Error creating user:', error);
+        logger.error(`creatingUser: Error creating user: ${error}`);
         throw error;
     }
 
-    console.log(data);
     return new RegisterResponse(data.path, data.token);
 }
 
-async function resendEmail(email: string): Promise<void> {
+export async function resendEmail(email: string): Promise<void> {
     const { error } = await supabase.auth.resend({
         email: email,
         type: 'signup',
     });
     if (error) {
-        console.error('Error resending verification email:', error);
+        logger.error(`Error resending verification email: ${error}`);
         throw error;
     }
 }
 
-async function sendResetPassword(email: string): Promise<void> {
+export async function sendResetPassword(email: string): Promise<void> {
     const { error } = await supabase.auth.resetPasswordForEmail(email);
     if (error) {
-        console.error('Error sending password reset email:', error);
+        logger.error(`Error sending password reset email: ${error}`);
         throw error;
     }
 }
 
-async function getUserById(id: string): Promise<User> {
+export async function getUserById(id: string): Promise<User> {
     const { data, error } = await supabase.from('users').select('*').eq('id', id);
     if (error) {
-        console.error('Error getting user:', error);
+        logger.error(`Error getting user: ${error}`);
         throw error;
     }
     return data[0];
 }
 
-async function getAllUsers(): Promise<User[]> {
+export async function getAllUsers(): Promise<User[]> {
     const { data, error } = await supabase.from('users').select('*');
     if (error) {
-        console.error('Error getting all users:', error);
+        logger.error(`Error getting all users: ${error}`);
         throw error;
     }
     return data;
 }
 
-async function checkUser(bearer: string): Promise<string> {
+export async function checkUser(bearer: string): Promise<string> {
     const { data, error } = await supabase.auth.getUser(bearer);
     if (error) {
-        console.error('Error checking user:', error);
+        logger.error(`Error checking user: ${error}`);
         throw error;
     }
     return data.user.id;
 }
 
-async function emailExist(email: string): Promise<boolean> {
+export async function emailExist(email: string): Promise<boolean> {
     const {
         data: { users },
         error,
     } = await supabase.auth.admin.listUsers();
     if (error) {
-        console.error('Error checking user:', error);
+        logger.error(`Error checking user: ${error}`);
         throw error;
     }
 
     return users.some((user) => user.email === email);
 }
-
-export {
-    authenticateUser,
-    refreshUser,
-    loginUser,
-    createUser,
-    resendEmail,
-    sendResetPassword,
-    emailExist,
-    getAllUsers,
-    getUserById,
-    checkUser,
-    createprofilePictureSignedUploadUrl,
-};