formatting

src/modules/user/infrastructure/repositories/DrizzleTokenRepository.ts

···
   async saveRefreshToken(token: RefreshToken): Promise<Result<void>> {
     try {
       const tokenPreview = '...' + token.refreshToken.slice(-8);
-      console.log(`[DrizzleTokenRepository] Saving new refresh token: ${tokenPreview} for user: ${token.userDid}, expiresAt: ${token.expiresAt.toISOString()}`);
+      console.log(
+        `[DrizzleTokenRepository] Saving new refresh token: ${tokenPreview} for user: ${token.userDid}, expiresAt: ${token.expiresAt.toISOString()}`,
+      );
 
       await this.db.insert(authRefreshTokens).values({
         tokenId: token.tokenId,
···
         revoked: token.revoked,
       });
 
-      console.log(`[DrizzleTokenRepository] Successfully saved refresh token: ${tokenPreview}`);
+      console.log(
+        `[DrizzleTokenRepository] Successfully saved refresh token: ${tokenPreview}`,
+      );
       return ok(undefined);
     } catch (error: any) {
-      console.log(`[DrizzleTokenRepository] Failed to save refresh token: ${error.message}`);
+      console.log(
+        `[DrizzleTokenRepository] Failed to save refresh token: ${error.message}`,
+      );
       return err(error);
     }
   }
···
   ): Promise<Result<RefreshToken | null>> {
     try {
       const tokenPreview = '...' + refreshToken.slice(-8);
-      console.log(`[DrizzleTokenRepository] Searching for token: ${tokenPreview}`);
+      console.log(
+        `[DrizzleTokenRepository] Searching for token: ${tokenPreview}`,
+      );
 
       const result = await this.db
         .select()
···
         )
         .limit(1);
 
-      console.log(`[DrizzleTokenRepository] Query returned ${result.length} results`);
+      console.log(
+        `[DrizzleTokenRepository] Query returned ${result.length} results`,
+      );
 
       if (result.length === 0) {
         // Check if token exists but is revoked
···
           .limit(1);
 
         if (revokedResult.length > 0) {
-          console.log(`[DrizzleTokenRepository] Token exists but is revoked: ${tokenPreview}`);
+          console.log(
+            `[DrizzleTokenRepository] Token exists but is revoked: ${tokenPreview}`,
+          );
         } else {
-          console.log(`[DrizzleTokenRepository] Token does not exist in database: ${tokenPreview}`);
+          console.log(
+            `[DrizzleTokenRepository] Token does not exist in database: ${tokenPreview}`,
+          );
         }
 
         return ok(null);
       }
 
       const token = result[0]!;
-      console.log(`[DrizzleTokenRepository] Token found - userDid: ${token.userDid}, revoked: ${token.revoked}, expiresAt: ${token.expiresAt.toISOString()}`);
+      console.log(
+        `[DrizzleTokenRepository] Token found - userDid: ${token.userDid}, revoked: ${token.revoked}, expiresAt: ${token.expiresAt.toISOString()}`,
+      );
 
       return ok({ ...token, revoked: token.revoked === true });
     } catch (error: any) {
···
   async revokeRefreshToken(refreshToken: string): Promise<Result<void>> {
     try {
       const tokenPreview = '...' + refreshToken.slice(-8);
-      console.log(`[DrizzleTokenRepository] Revoking refresh token: ${tokenPreview}`);
+      console.log(
+        `[DrizzleTokenRepository] Revoking refresh token: ${tokenPreview}`,
+      );
 
       const result = await this.db
         .update(authRefreshTokens)
         .set({ revoked: true })
         .where(eq(authRefreshTokens.refreshToken, refreshToken));
 
-      console.log(`[DrizzleTokenRepository] Successfully revoked refresh token: ${tokenPreview}`);
+      console.log(
+        `[DrizzleTokenRepository] Successfully revoked refresh token: ${tokenPreview}`,
+      );
       return ok(undefined);
     } catch (error: any) {
-      console.log(`[DrizzleTokenRepository] Failed to revoke refresh token: ${error.message}`);
+      console.log(
+        `[DrizzleTokenRepository] Failed to revoke refresh token: ${error.message}`,
+      );
       return err(error);
     }
   }

src/modules/user/infrastructure/services/JwtTokenService.ts

···
   async refreshToken(refreshToken: string): Promise<Result<TokenPair | null>> {
     try {
       const tokenPreview = '...' + refreshToken.slice(-8);
-      console.log(`[JwtTokenService] Starting refresh for token: ${tokenPreview}`);
+      console.log(
+        `[JwtTokenService] Starting refresh for token: ${tokenPreview}`,
+      );
 
       // Find the refresh token
       const findResult =
         await this.tokenRepository.findRefreshToken(refreshToken);
 
       if (findResult.isErr()) {
-        console.log(`[JwtTokenService] Database error finding token: ${findResult.error.message}`);
+        console.log(
+          `[JwtTokenService] Database error finding token: ${findResult.error.message}`,
+        );
         return err(findResult.error);
       }
 
       const tokenData = findResult.unwrap();
       if (!tokenData) {
-        console.log(`[JwtTokenService] Token not found in database: ${tokenPreview}`);
+        console.log(
+          `[JwtTokenService] Token not found in database: ${tokenPreview}`,
+        );
         return ok(null);
       }
 
-      console.log(`[JwtTokenService] Token found - userDid: ${tokenData.userDid}, issuedAt: ${tokenData.issuedAt.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}, revoked: ${tokenData.revoked}`);
+      console.log(
+        `[JwtTokenService] Token found - userDid: ${tokenData.userDid}, issuedAt: ${tokenData.issuedAt.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}, revoked: ${tokenData.revoked}`,
+      );
 
       // Check if token is expired
       const now = new Date();
       if (now > tokenData.expiresAt) {
-        console.log(`[JwtTokenService] Token expired - now: ${now.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}`);
+        console.log(
+          `[JwtTokenService] Token expired - now: ${now.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}`,
+        );
         await this.revokeToken(refreshToken);
         return ok(null);
       }
 
-      console.log(`[JwtTokenService] Token is valid, generating new tokens for user: ${tokenData.userDid}`);
+      console.log(
+        `[JwtTokenService] Token is valid, generating new tokens for user: ${tokenData.userDid}`,
+      );
 
       // Generate new tokens
       const newTokens = await this.generateToken(tokenData.userDid);
 
       if (newTokens.isErr()) {
-        console.log(`[JwtTokenService] Failed to generate new tokens: ${newTokens.error.message}`);
+        console.log(
+          `[JwtTokenService] Failed to generate new tokens: ${newTokens.error.message}`,
+        );
         return newTokens;
       }
 
···
       // Revoke old token
       const revokeResult = await this.revokeToken(refreshToken);
       if (revokeResult.isErr()) {
-        console.log(`[JwtTokenService] Warning: Failed to revoke old token: ${revokeResult.error.message}`);
+        console.log(
+          `[JwtTokenService] Warning: Failed to revoke old token: ${revokeResult.error.message}`,
+        );
       } else {
         console.log(`[JwtTokenService] Old token revoked successfully`);
       }
 
       return newTokens;
     } catch (error: any) {
-      console.log(`[JwtTokenService] Unexpected error during refresh: ${error.message}`);
+      console.log(
+        `[JwtTokenService] Unexpected error during refresh: ${error.message}`,
+      );
       return err(error);
     }
   }

src/webapp/lib/auth/dal.ts

···
       console.log('Auth refresh already in progress, waiting...');
       return refreshPromise;
     }
-    
+
     isRefreshing = true;
     refreshPromise = (async () => {
       try {
···
         refreshPromise = null;
       }
     })();
-    
+
     return refreshPromise;
   },
 );