nandi.uk
This repository has no description
refactor: make auth logging conditional with ENABLE_AUTH_LOGGING constant
Co-authored-by: aider (anthropic/claude-sonnet-4-20250514) <aider@aider.chat>
author
Wesley Finck
co-author
aider (anthropic/claude-sonnet-4-20250514)
date
(Nov 11, 2025, 9:31 AM -0500)
commit
972cc987
972cc987deea34f7cc7767d0c318109f4c326594
parent
5acb0d6b
5acb0d6b5a76b9b66116225974976bae582712c3
+102
-57
+6
-6
src/modules/user/application/use-cases/RefreshAccessTokenUseCase.ts
+6
-6
src/modules/user/application/use-cases/RefreshAccessTokenUseCase.ts
···
5
5
import { TokenPair } from '@semble/types';
6
6
import { RefreshAccessTokenErrors } from './errors/RefreshAccessTokenErrors';
7
7
8
-
const ENABLE_REFRESH_LOGGING = true;
8
+
const ENABLE_AUTH_LOGGING = true;
9
9
10
10
export interface RefreshAccessTokenDTO {
11
11
refreshToken: string;
···
25
25
request: RefreshAccessTokenDTO,
26
26
): Promise<RefreshAccessTokenResponse> {
27
27
try {
28
-
if (ENABLE_REFRESH_LOGGING) {
28
+
if (ENABLE_AUTH_LOGGING) {
29
29
const tokenPreview = '...' + request.refreshToken.slice(-8);
30
30
console.log(
31
31
`[RefreshAccessTokenUseCase] Attempting token refresh with token: ${tokenPreview}`,
···
37
37
);
38
38
39
39
if (tokenResult.isErr()) {
40
-
if (ENABLE_REFRESH_LOGGING) {
40
+
if (ENABLE_AUTH_LOGGING) {
41
41
console.log(
42
42
`[RefreshAccessTokenUseCase] Token refresh failed: ${tokenResult.error.message}`,
43
43
);
···
46
46
}
47
47
48
48
if (!tokenResult.value) {
49
-
if (ENABLE_REFRESH_LOGGING) {
49
+
if (ENABLE_AUTH_LOGGING) {
50
50
console.log(
51
51
`[RefreshAccessTokenUseCase] Token refresh returned null - invalid refresh token`,
52
52
);
···
54
54
return err(new RefreshAccessTokenErrors.InvalidRefreshTokenError());
55
55
}
56
56
57
-
if (ENABLE_REFRESH_LOGGING) {
57
+
if (ENABLE_AUTH_LOGGING) {
58
58
// Extract user ID from the new access token for logging
59
59
try {
60
60
const payload = JSON.parse(atob(tokenResult.value.accessToken.split('.')[1]));
···
67
67
68
68
return ok(tokenResult.value);
69
69
} catch (error: any) {
70
-
if (ENABLE_REFRESH_LOGGING) {
70
+
if (ENABLE_AUTH_LOGGING) {
71
71
console.log(
72
72
`[RefreshAccessTokenUseCase] Token refresh error: ${error.message}`,
73
73
);
+61
-32
src/modules/user/infrastructure/services/JwtTokenService.ts
+61
-32
src/modules/user/infrastructure/services/JwtTokenService.ts
···
5
5
import { TokenPair } from '@semble/types';
6
6
import { ITokenRepository } from '../../domain/repositories/ITokenRepository';
7
7
8
+
const ENABLE_AUTH_LOGGING = true;
9
+
8
10
export class JwtTokenService implements ITokenService {
9
11
constructor(
10
12
private tokenRepository: ITokenRepository,
···
57
59
async validateToken(token: string): Promise<Result<string | null>> {
58
60
try {
59
61
const decoded = jwt.verify(token, this.jwtSecret) as { did: string };
60
-
console.log(`[JwtTokenService] Token validation successful for user: ${decoded.did}`);
62
+
if (ENABLE_AUTH_LOGGING) {
63
+
console.log(`[JwtTokenService] Token validation successful for user: ${decoded.did}`);
64
+
}
61
65
return ok(decoded.did);
62
66
} catch (error: any) {
63
-
console.log(`[JwtTokenService] Token validation failed: ${error.message}`);
67
+
if (ENABLE_AUTH_LOGGING) {
68
+
console.log(`[JwtTokenService] Token validation failed: ${error.message}`);
69
+
}
64
70
return ok(null); // Token is invalid or expired
65
71
}
66
72
}
67
73
68
74
async refreshToken(refreshToken: string): Promise<Result<TokenPair | null>> {
69
75
try {
70
-
const tokenPreview = '...' + refreshToken.slice(-8);
71
-
console.log(
72
-
`[JwtTokenService] Starting refresh for token: ${tokenPreview}`,
73
-
);
76
+
if (ENABLE_AUTH_LOGGING) {
77
+
const tokenPreview = '...' + refreshToken.slice(-8);
78
+
console.log(
79
+
`[JwtTokenService] Starting refresh for token: ${tokenPreview}`,
80
+
);
81
+
}
74
82
75
83
// Find the refresh token
76
84
const findResult =
77
85
await this.tokenRepository.findRefreshToken(refreshToken);
78
86
79
87
if (findResult.isErr()) {
80
-
console.log(
81
-
`[JwtTokenService] Database error finding token: ${findResult.error.message}`,
82
-
);
88
+
if (ENABLE_AUTH_LOGGING) {
89
+
console.log(
90
+
`[JwtTokenService] Database error finding token: ${findResult.error.message}`,
91
+
);
92
+
}
83
93
return err(findResult.error);
84
94
}
85
95
86
96
const tokenData = findResult.unwrap();
87
97
if (!tokenData) {
98
+
if (ENABLE_AUTH_LOGGING) {
99
+
const tokenPreview = '...' + refreshToken.slice(-8);
100
+
console.log(
101
+
`[JwtTokenService] Token not found in database: ${tokenPreview}`,
102
+
);
103
+
}
104
+
return ok(null);
105
+
}
106
+
107
+
if (ENABLE_AUTH_LOGGING) {
88
108
console.log(
89
-
`[JwtTokenService] Token not found in database: ${tokenPreview}`,
109
+
`[JwtTokenService] Token found - userDid: ${tokenData.userDid}, issuedAt: ${tokenData.issuedAt.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}, revoked: ${tokenData.revoked}`,
90
110
);
91
-
return ok(null);
92
111
}
93
112
94
-
console.log(
95
-
`[JwtTokenService] Token found - userDid: ${tokenData.userDid}, issuedAt: ${tokenData.issuedAt.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}, revoked: ${tokenData.revoked}`,
96
-
);
97
-
98
113
// Check if token is expired
99
114
const now = new Date();
100
115
if (now > tokenData.expiresAt) {
101
-
console.log(
102
-
`[JwtTokenService] Token expired - now: ${now.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}`,
103
-
);
116
+
if (ENABLE_AUTH_LOGGING) {
117
+
console.log(
118
+
`[JwtTokenService] Token expired - now: ${now.toISOString()}, expiresAt: ${tokenData.expiresAt.toISOString()}`,
119
+
);
120
+
}
104
121
await this.revokeToken(refreshToken);
105
122
return ok(null);
106
123
}
107
124
108
-
console.log(
109
-
`[JwtTokenService] Token is valid, generating new tokens for user: ${tokenData.userDid}`,
110
-
);
125
+
if (ENABLE_AUTH_LOGGING) {
126
+
console.log(
127
+
`[JwtTokenService] Token is valid, generating new tokens for user: ${tokenData.userDid}`,
128
+
);
129
+
}
111
130
112
131
// Generate new tokens
113
132
const newTokens = await this.generateToken(tokenData.userDid);
114
133
115
134
if (newTokens.isErr()) {
116
-
console.log(
117
-
`[JwtTokenService] Failed to generate new tokens: ${newTokens.error.message}`,
118
-
);
135
+
if (ENABLE_AUTH_LOGGING) {
136
+
console.log(
137
+
`[JwtTokenService] Failed to generate new tokens: ${newTokens.error.message}`,
138
+
);
139
+
}
119
140
return newTokens;
120
141
}
121
142
122
-
console.log(`[JwtTokenService] New tokens generated successfully`);
143
+
if (ENABLE_AUTH_LOGGING) {
144
+
console.log(`[JwtTokenService] New tokens generated successfully`);
145
+
}
123
146
124
147
// Revoke old token
125
148
const revokeResult = await this.revokeToken(refreshToken);
126
149
if (revokeResult.isErr()) {
127
-
console.log(
128
-
`[JwtTokenService] Warning: Failed to revoke old token: ${revokeResult.error.message}`,
129
-
);
150
+
if (ENABLE_AUTH_LOGGING) {
151
+
console.log(
152
+
`[JwtTokenService] Warning: Failed to revoke old token: ${revokeResult.error.message}`,
153
+
);
154
+
}
130
155
} else {
131
-
console.log(`[JwtTokenService] Old token revoked successfully`);
156
+
if (ENABLE_AUTH_LOGGING) {
157
+
console.log(`[JwtTokenService] Old token revoked successfully`);
158
+
}
132
159
}
133
160
134
161
return newTokens;
135
162
} catch (error: any) {
136
-
console.log(
137
-
`[JwtTokenService] Unexpected error during refresh: ${error.message}`,
138
-
);
163
+
if (ENABLE_AUTH_LOGGING) {
164
+
console.log(
165
+
`[JwtTokenService] Unexpected error during refresh: ${error.message}`,
166
+
);
167
+
}
139
168
return err(error);
140
169
}
141
170
}
+11
-11
src/webapp/app/api/auth/me/route.ts
+11
-11
src/webapp/app/api/auth/me/route.ts
···
3
3
import { cookies } from 'next/headers';
4
4
import { isTokenExpiringSoon } from '@/lib/auth/token';
5
5
6
-
const ENABLE_REFRESH_LOGGING = true;
6
+
const ENABLE_AUTH_LOGGING = true;
7
7
8
8
const backendUrl =
9
9
process.env.NEXT_PUBLIC_API_BASE_URL || 'http://127.0.0.1:3000';
···
24
24
25
25
// No tokens at all - not authenticated
26
26
if (!accessToken && !refreshToken) {
27
-
if (ENABLE_REFRESH_LOGGING) {
27
+
if (ENABLE_AUTH_LOGGING) {
28
28
console.log('[auth/me] No tokens found - user not authenticated');
29
29
}
30
30
return NextResponse.json<AuthResult>({ isAuth: false }, { status: 401 });
···
32
32
33
33
// Check if accessToken is expired/missing or expiring soon
34
34
if ((!accessToken || isTokenExpiringSoon(accessToken)) && refreshToken) {
35
-
if (ENABLE_REFRESH_LOGGING) {
35
+
if (ENABLE_AUTH_LOGGING) {
36
36
const tokenPreview = '...' + refreshToken.slice(-8);
37
37
const accessTokenStatus = !accessToken ? 'missing' : 'expiring soon';
38
38
···
60
60
61
61
try {
62
62
const result = await refreshPromise;
63
-
if (ENABLE_REFRESH_LOGGING) {
63
+
if (ENABLE_AUTH_LOGGING) {
64
64
console.log(`[auth/me] Token refresh completed successfully`);
65
65
}
66
66
return result;
67
67
} catch (error: any) {
68
-
if (ENABLE_REFRESH_LOGGING) {
68
+
if (ENABLE_AUTH_LOGGING) {
69
69
console.log(`[auth/me] Token refresh error: ${error}`);
70
70
}
71
71
console.error('Token refresh error:', error);
···
103
103
// AccessToken is valid - fetch profile
104
104
try {
105
105
// Log user context from valid access token
106
-
if (ENABLE_REFRESH_LOGGING && accessToken) {
106
+
if (ENABLE_AUTH_LOGGING && accessToken) {
107
107
try {
108
108
const payload = JSON.parse(atob(accessToken.split('.')[1]));
109
109
const userDid = payload.did || 'unknown';
···
124
124
});
125
125
126
126
if (!profileResponse.ok) {
127
-
if (ENABLE_REFRESH_LOGGING) {
127
+
if (ENABLE_AUTH_LOGGING) {
128
128
console.log(`[auth/me] Profile fetch failed with status: ${profileResponse.status}`);
129
129
}
130
130
// Clear cookies on auth failure
···
138
138
}
139
139
140
140
const user = await profileResponse.json();
141
-
if (ENABLE_REFRESH_LOGGING) {
141
+
if (ENABLE_AUTH_LOGGING) {
142
142
console.log(`[auth/me] Profile fetched successfully for user: ${user.handle} (${user.id})`);
143
143
}
144
144
return NextResponse.json<AuthResult>({ isAuth: true, user });
···
164
164
refreshToken: string,
165
165
request: NextRequest,
166
166
): Promise<Response> {
167
-
if (ENABLE_REFRESH_LOGGING) {
167
+
if (ENABLE_AUTH_LOGGING) {
168
168
console.log(`[auth/me] Sending refresh request to backend`);
169
169
}
170
170
···
179
179
});
180
180
181
181
if (!refreshResponse.ok) {
182
-
if (ENABLE_REFRESH_LOGGING) {
182
+
if (ENABLE_AUTH_LOGGING) {
183
183
console.log(
184
184
`[auth/me] Backend refresh failed with status: ${refreshResponse.status}. Message: ${await refreshResponse.text()}`,
185
185
);
···
208
208
}
209
209
210
210
const user = await profileResponse.json();
211
-
if (ENABLE_REFRESH_LOGGING) {
211
+
if (ENABLE_AUTH_LOGGING) {
212
212
console.log(`[auth/me] Token refresh and profile fetch successful for user: ${user.handle} (${user.id})`);
213
213
}
214
214
// Return user profile with backend's Set-Cookie headers
+3
-1
src/webapp/lib/auth/token.ts
+3
-1
src/webapp/lib/auth/token.ts
···
1
+
const ENABLE_AUTH_LOGGING = true;
2
+
1
3
export const isTokenExpiringSoon = (
2
4
token: string | null | undefined,
3
5
): boolean => {
···
23
25
const bufferTime = bufferSeconds * 1000;
24
26
const isExpiring = Date.now() >= expiry - bufferTime;
25
27
26
-
if (isExpiring) {
28
+
if (isExpiring && ENABLE_AUTH_LOGGING) {
27
29
console.log(`[isTokenExpiringSoon] Token expiring soon for user: ${userDid}`);
28
30
}
29
31
+15
-5
src/webapp/lib/serverAuth.ts
+15
-5
src/webapp/lib/serverAuth.ts
···
1
1
import { ServerCookieAuthService } from '@/services/auth/CookieAuthService.server';
2
2
import type { GetProfileResponse } from '@/api-client/ApiClient';
3
3
4
+
const ENABLE_AUTH_LOGGING = true;
5
+
4
6
type UserProfile = GetProfileResponse;
5
7
6
8
export async function getServerAuthStatus(): Promise<{
···
12
14
const { accessToken } = await ServerCookieAuthService.getTokens();
13
15
14
16
if (!accessToken || ServerCookieAuthService.isTokenExpired(accessToken)) {
15
-
const reason = !accessToken ? 'No access token' : 'Access token expired';
16
-
console.log(`[serverAuth] Authentication failed: ${reason}`);
17
+
if (ENABLE_AUTH_LOGGING) {
18
+
const reason = !accessToken ? 'No access token' : 'Access token expired';
19
+
console.log(`[serverAuth] Authentication failed: ${reason}`);
20
+
}
17
21
return {
18
22
isAuthenticated: false,
19
23
user: null,
···
34
38
});
35
39
36
40
if (!response.ok) {
37
-
console.log(`[serverAuth] Profile API request failed with status: ${response.status}`);
41
+
if (ENABLE_AUTH_LOGGING) {
42
+
console.log(`[serverAuth] Profile API request failed with status: ${response.status}`);
43
+
}
38
44
return {
39
45
isAuthenticated: false,
40
46
user: null,
···
43
49
}
44
50
45
51
const user: UserProfile = await response.json();
46
-
console.log(`[serverAuth] Server-side authentication successful for user: ${user.handle} (${user.id})`);
52
+
if (ENABLE_AUTH_LOGGING) {
53
+
console.log(`[serverAuth] Server-side authentication successful for user: ${user.handle} (${user.id})`);
54
+
}
47
55
48
56
return {
49
57
isAuthenticated: true,
···
51
59
error: null,
52
60
};
53
61
} catch (error: any) {
54
-
console.log(`[serverAuth] Authentication error: ${error.message || 'Unknown error'}`);
62
+
if (ENABLE_AUTH_LOGGING) {
63
+
console.log(`[serverAuth] Authentication error: ${error.message || 'Unknown error'}`);
64
+
}
55
65
return {
56
66
isAuthenticated: false,
57
67
user: null,
+6
-2
src/webapp/services/auth/CookieAuthService.server.ts
+6
-2
src/webapp/services/auth/CookieAuthService.server.ts
···
1
1
import { cookies } from 'next/headers';
2
2
3
+
const ENABLE_AUTH_LOGGING = true;
4
+
3
5
export interface AuthTokens {
4
6
accessToken: string | null;
5
7
refreshToken: string | null;
···
29
31
const bufferTime = bufferMinutes * 60 * 1000;
30
32
const isExpired = Date.now() >= expiry - bufferTime;
31
33
32
-
if (isExpired) {
34
+
if (isExpired && ENABLE_AUTH_LOGGING) {
33
35
console.log(`[ServerCookieAuthService] Token expired for user: ${userDid}`);
34
36
}
35
37
36
38
return isExpired;
37
39
} catch {
38
-
console.log(`[ServerCookieAuthService] Invalid token format`);
40
+
if (ENABLE_AUTH_LOGGING) {
41
+
console.log(`[ServerCookieAuthService] Invalid token format`);
42
+
}
39
43
return true;
40
44
}
41
45
}