fix: remove logging from utils

db/auth.go

@@ -2,8 +2,8 @@ package db
 
 import (
 	"log/slog"
+	"me-fit/log"
 	"me-fit/types"
-	"me-fit/utils"
 
 	"database/sql"
 	"errors"
@@ -116,7 +116,7 @@ func (db AuthDbSqlite) InsertUser(user *User) error {
 			return ErrUserExists
 		}
 
-		utils.LogError("SQL error InsertUser", err)
+		log.Error("SQL error InsertUser", err)
 		return types.ErrInternal
 	}
 
@@ -131,7 +131,7 @@ func (db AuthDbSqlite) UpdateUser(user *User) error {
 		user.EmailVerified, user.EmailVerifiedAt, user.Password, user.Id)
 
 	if err != nil {
-		utils.LogError("SQL error UpdateUser", err)
+		log.Error("SQL error UpdateUser", err)
 		return types.ErrInternal
 	}
 
@@ -157,7 +157,7 @@ func (db AuthDbSqlite) GetUserByEmail(email string) (*User, error) {
 		if err == sql.ErrNoRows {
 			return nil, ErrNotFound
 		} else {
-			utils.LogError("SQL error GetUser", err)
+			log.Error("SQL error GetUser", err)
 			return nil, types.ErrInternal
 		}
 	}
@@ -184,7 +184,7 @@ func (db AuthDbSqlite) GetUser(userId uuid.UUID) (*User, error) {
 		if err == sql.ErrNoRows {
 			return nil, ErrNotFound
 		} else {
-			utils.LogError("SQL error GetUser", err)
+			log.Error("SQL error GetUser", err)
 			return nil, types.ErrInternal
 		}
 	}
@@ -196,41 +196,41 @@ func (db AuthDbSqlite) DeleteUser(userId uuid.UUID) error {
 
 	tx, err := db.db.Begin()
 	if err != nil {
-		utils.LogError("Could not start transaction", err)
+		log.Error("Could not start transaction", err)
 		return types.ErrInternal
 	}
 
 	_, err = tx.Exec("DELETE FROM workout WHERE user_id = ?", userId)
 	if err != nil {
 		_ = tx.Rollback()
-		utils.LogError("Could not delete workouts", err)
+		log.Error("Could not delete workouts", err)
 		return types.ErrInternal
 	}
 
 	_, err = tx.Exec("DELETE FROM user_token WHERE user_uuid = ?", userId)
 	if err != nil {
 		_ = tx.Rollback()
-		utils.LogError("Could not delete user tokens", err)
+		log.Error("Could not delete user tokens", err)
 		return types.ErrInternal
 	}
 
 	_, err = tx.Exec("DELETE FROM session WHERE user_uuid = ?", userId)
 	if err != nil {
 		_ = tx.Rollback()
-		utils.LogError("Could not delete sessions", err)
+		log.Error("Could not delete sessions", err)
 		return types.ErrInternal
 	}
 
 	_, err = tx.Exec("DELETE FROM user WHERE user_uuid = ?", userId)
 	if err != nil {
 		_ = tx.Rollback()
-		utils.LogError("Could not delete user", err)
+		log.Error("Could not delete user", err)
 		return types.ErrInternal
 	}
 
 	err = tx.Commit()
 	if err != nil {
-		utils.LogError("Could not commit transaction", err)
+		log.Error("Could not commit transaction", err)
 		return types.ErrInternal
 	}
 
@@ -243,7 +243,7 @@ func (db AuthDbSqlite) InsertToken(token *Token) error {
 		VALUES (?, ?, ?, ?, ?)`, token.UserId, token.Type, token.Token, token.CreatedAt, token.ExpiresAt)
 
 	if err != nil {
-		utils.LogError("Could not insert token", err)
+		log.Error("Could not insert token", err)
 		return types.ErrInternal
 	}
 
@@ -271,20 +271,20 @@ func (db AuthDbSqlite) GetToken(token string) (*Token, error) {
 			slog.Info("Token '" + token + "' not found")
 			return nil, ErrNotFound
 		} else {
-			utils.LogError("Could not get token", err)
+			log.Error("Could not get token", err)
 			return nil, types.ErrInternal
 		}
 	}
 
 	createdAt, err = time.Parse(time.RFC3339, createdAtStr)
 	if err != nil {
-		utils.LogError("Could not parse token.created_at", err)
+		log.Error("Could not parse token.created_at", err)
 		return nil, types.ErrInternal
 	}
 
 	expiresAt, err = time.Parse(time.RFC3339, expiresAtStr)
 	if err != nil {
-		utils.LogError("Could not parse token.expires_at", err)
+		log.Error("Could not parse token.expires_at", err)
 		return nil, types.ErrInternal
 	}
 
@@ -300,7 +300,7 @@ func (db AuthDbSqlite) GetTokensByUserIdAndType(userId uuid.UUID, tokenType stri
 		AND type = ?`, userId, tokenType)
 
 	if err != nil {
-		utils.LogError("Could not get token", err)
+		log.Error("Could not get token", err)
 		return nil, types.ErrInternal
 	}
 
@@ -317,19 +317,19 @@ func (db AuthDbSqlite) GetTokensByUserIdAndType(userId uuid.UUID, tokenType stri
 
 		err := query.Scan(&token, &createdAtStr, &expiresAtStr)
 		if err != nil {
-			utils.LogError("Could not scan token", err)
+			log.Error("Could not scan token", err)
 			return nil, types.ErrInternal
 		}
 
 		createdAt, err = time.Parse(time.RFC3339, createdAtStr)
 		if err != nil {
-			utils.LogError("Could not parse token.created_at", err)
+			log.Error("Could not parse token.created_at", err)
 			return nil, types.ErrInternal
 		}
 
 		expiresAt, err = time.Parse(time.RFC3339, expiresAtStr)
 		if err != nil {
-			utils.LogError("Could not parse token.expires_at", err)
+			log.Error("Could not parse token.expires_at", err)
 			return nil, types.ErrInternal
 		}
 
@@ -342,7 +342,7 @@ func (db AuthDbSqlite) GetTokensByUserIdAndType(userId uuid.UUID, tokenType stri
 func (db AuthDbSqlite) DeleteToken(token string) error {
 	_, err := db.db.Exec("DELETE FROM user_token WHERE token = ?", token)
 	if err != nil {
-		utils.LogError("Could not delete token", err)
+		log.Error("Could not delete token", err)
 		return types.ErrInternal
 	}
 	return nil
@@ -355,7 +355,7 @@ func (db AuthDbSqlite) InsertSession(session *Session) error {
 		VALUES (?, ?, ?)`, session.Id, session.UserId, session.CreatedAt)
 
 	if err != nil {
-		utils.LogError("Could not insert new session", err)
+		log.Error("Could not insert new session", err)
 		return types.ErrInternal
 	}
 
@@ -386,7 +386,7 @@ func (db AuthDbSqlite) DeleteOldSessions(userId uuid.UUID) error {
 	// Delete old inactive sessions
 	_, err := db.db.Exec("DELETE FROM session WHERE created_at < datetime('now','-8 hours') AND user_uuid = ?", userId)
 	if err != nil {
-		utils.LogError("Could not delete old sessions", err)
+		log.Error("Could not delete old sessions", err)
 		return types.ErrInternal
 	}
 	return nil
@@ -397,7 +397,7 @@ func (db AuthDbSqlite) DeleteSession(sessionId string) error {
 
 		_, err := db.db.Exec("DELETE FROM session WHERE session_id = ?", sessionId)
 		if err != nil {
-			utils.LogError("Could not delete session", err)
+			log.Error("Could not delete session", err)
 			return types.ErrInternal
 		}
 	}

db/workout.go

@@ -1,8 +1,8 @@
 package db
 
 import (
+	"me-fit/log"
 	"me-fit/types"
-	"me-fit/utils"
 
 	"database/sql"
 	"errors"
@@ -59,7 +59,7 @@ func (db WorkoutDbSqlite) InsertWorkout(userId uuid.UUID, workout *WorkoutInsert
 		VALUES (?, ?, ?, ?, ?) 
 		RETURNING rowid`, userId, workout.Date, workout.Type, workout.Sets, workout.Reps).Scan(&rowId)
 	if err != nil {
-		utils.LogError("Error inserting workout", err)
+		log.Error("Error inserting workout", err)
 		return nil, types.ErrInternal
 	}
 
@@ -70,7 +70,7 @@ func (db WorkoutDbSqlite) GetWorkouts(userId uuid.UUID) ([]Workout, error) {
 
 	rows, err := db.db.Query("SELECT rowid, date, type, sets, reps FROM workout WHERE user_id = ? ORDER BY date desc", userId)
 	if err != nil {
-		utils.LogError("Could not get workouts", err)
+		log.Error("Could not get workouts", err)
 		return nil, types.ErrInternal
 	}
 
@@ -83,13 +83,13 @@ func (db WorkoutDbSqlite) GetWorkouts(userId uuid.UUID) ([]Workout, error) {
 
 		err = rows.Scan(&workout.RowId, &date, &workout.Type, &workout.Sets, &workout.Reps)
 		if err != nil {
-			utils.LogError("Could not scan workout", err)
+			log.Error("Could not scan workout", err)
 			return nil, types.ErrInternal
 		}
 
 		workout.Date, err = time.Parse("2006-01-02 15:04:05-07:00", date)
 		if err != nil {
-			utils.LogError("Could not parse date", err)
+			log.Error("Could not parse date", err)
 			return nil, types.ErrInternal
 		}