Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

refactor: simplify refresh token design with frontend coordination (#18733)

p0nyddd3b4bf4ba1
diff --git a/backend/api/v1/auth_service.go b/backend/api/v1/auth_service.go
index c5e8cdce31..747c3a1d91 100644
--- a/backend/api/v1/auth_service.go
+++ b/backend/api/v1/auth_service.go
@@ -55,8 +55,6 @@ const (
errMsgInvalidRecoveryCode = "invalid recovery code"
errMsgTooManyPassword = "too many failed login attempts, please try again later" // Will be used for password rate limiting
errMsgTooManyMFA = "too many failed MFA attempts, please try again later"
-
- refreshTokenGracePeriod = 30 * time.Second
)
var (
@@ -186,9 +184,9 @@ func (s *AuthService) Refresh(ctx context.Context, req *connect.Request[v1pb.Ref
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("refresh token not found"))
}
- // 2. Look up in database
+ // 2. Look up and delete atomically
tokenHash := auth.HashToken(refreshToken)
- stored, err := s.store.GetWebRefreshToken(ctx, tokenHash)
+ stored, err := s.store.GetAndDeleteWebRefreshToken(ctx, tokenHash)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get refresh token"))
}
@@ -198,25 +196,10 @@ func (s *AuthService) Refresh(ctx context.Context, req *connect.Request[v1pb.Ref
// 3. Check expiration
if time.Now().After(stored.ExpiresAt) {
- if err := s.store.DeleteWebRefreshToken(ctx, tokenHash); err != nil {
- slog.Error("failed to delete expired refresh token", log.BBError(err))
- }
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("refresh token expired"))
}
- // 4. Check if already rotated (grace period)
- if stored.RotatedAt != nil {
- if time.Since(*stored.RotatedAt) > refreshTokenGracePeriod {
- if err := s.store.DeleteWebRefreshToken(ctx, tokenHash); err != nil {
- slog.Error("failed to delete rotated refresh token", log.BBError(err))
- }
- return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("refresh token already used"))
- }
- // Within grace period - return success but don't issue new tokens
- return connect.NewResponse(&v1pb.RefreshResponse{}), nil
- }
-
- // 5. Get user
+ // 4. Get user
user, err := s.store.GetUserByEmail(ctx, stored.UserEmail)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to get user"))
@@ -225,19 +208,7 @@ func (s *AuthService) Refresh(ctx context.Context, req *connect.Request[v1pb.Ref
return nil, connect.NewError(connect.CodeUnauthenticated, errors.New("user not found"))
}
- // 6. Atomically mark old token as rotated (grace period starts)
- // If another request already rotated it, we're in a race - return success without new tokens
- rotated, err := s.store.MarkWebRefreshTokenRotated(ctx, tokenHash)
- if err != nil {
- return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to rotate refresh token"))
- }
- if !rotated {
- // Another request already rotated this token - we're within grace period
- // Return success but don't issue new tokens (the other request already did)
- return connect.NewResponse(&v1pb.RefreshResponse{}), nil
- }
-
- // 7. Issue new tokens
+ // 5. Issue new tokens
accessTokenDuration := auth.GetAccessTokenDuration(ctx, s.store, s.licenseService)
accessToken, err := auth.GenerateAccessToken(user.Email, s.secret, accessTokenDuration)
if err != nil {
@@ -258,7 +229,7 @@ func (s *AuthService) Refresh(ctx context.Context, req *connect.Request[v1pb.Ref
return nil, connect.NewError(connect.CodeInternal, errors.Wrap(err, "failed to create refresh token"))
}
- // 8. Set cookies and return
+ // 6. Set cookies and return
resp := connect.NewResponse(&v1pb.RefreshResponse{})
origin := req.Header().Get("Origin")
resp.Header().Add("Set-Cookie", auth.GetTokenCookie(ctx, s.store, s.licenseService, origin, accessToken).String())
diff --git a/backend/migrator/migration/3.14/0011##web_refresh_token.sql b/backend/migrator/migration/3.14/0011##web_refresh_token.sql
index 322e79eabc..646a9cf09a 100644
--- a/backend/migrator/migration/3.14/0011##web_refresh_token.sql
+++ b/backend/migrator/migration/3.14/0011##web_refresh_token.sql
@@ -1,10 +1,8 @@
CREATE TABLE web_refresh_token (
token_hash TEXT PRIMARY KEY,
user_email TEXT NOT NULL REFERENCES principal(email) ON UPDATE CASCADE,
- expires_at TIMESTAMPTZ NOT NULL,
- rotated_at TIMESTAMPTZ
+ expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX idx_web_refresh_token_user_email ON web_refresh_token(user_email);
CREATE INDEX idx_web_refresh_token_expires_at ON web_refresh_token(expires_at);
-CREATE INDEX idx_web_refresh_token_rotated_at ON web_refresh_token(rotated_at) WHERE rotated_at IS NOT NULL;
diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sql
index fe59f513e4..fdbd37341b 100644
--- a/backend/migrator/migration/LATEST.sql
+++ b/backend/migrator/migration/LATEST.sql
@@ -565,13 +565,11 @@ CREATE INDEX idx_oauth2_client_last_active_at ON oauth2_client(last_active_at);
CREATE TABLE web_refresh_token (
token_hash TEXT PRIMARY KEY,
user_email TEXT NOT NULL REFERENCES principal(email) ON UPDATE CASCADE,
- expires_at TIMESTAMPTZ NOT NULL,
- rotated_at TIMESTAMPTZ
+ expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX idx_web_refresh_token_user_email ON web_refresh_token(user_email);
CREATE INDEX idx_web_refresh_token_expires_at ON web_refresh_token(expires_at);
-CREATE INDEX idx_web_refresh_token_rotated_at ON web_refresh_token(rotated_at) WHERE rotated_at IS NOT NULL;
-- Default bytebase system account id is 1.
INSERT INTO principal (id, type, name, email, password_hash) VALUES (1, 'SYSTEM_BOT', 'Bytebase', '[email protected]', '');
diff --git a/backend/runner/cleaner/data_cleaner.go b/backend/runner/cleaner/data_cleaner.go
index 070b814fb1..0710b938ff 100644
--- a/backend/runner/cleaner/data_cleaner.go
+++ b/backend/runner/cleaner/data_cleaner.go
@@ -15,7 +15,6 @@ const (
cleanupInterval = 1 * time.Hour
exportArchiveRetentionPeriod = 24 * time.Hour
oauth2ClientRetentionPeriod = 30 * 24 * time.Hour // 30 days of inactivity
- refreshTokenGracePeriod = 30 * time.Second // Grace period for rotated refresh tokens
)
// DataCleaner periodically cleans up expired data from the database.
@@ -92,17 +91,9 @@ func (c *DataCleaner) cleanupOAuth2Data(ctx context.Context) {
}
func (c *DataCleaner) cleanupWebRefreshTokens(ctx context.Context) {
- // Clean up expired web refresh tokens
if rowsAffected, err := c.store.DeleteExpiredWebRefreshTokens(ctx); err != nil {
slog.Error("Failed to clean up expired web refresh tokens", log.BBError(err))
} else if rowsAffected > 0 {
slog.Info("Cleaned up expired web refresh tokens", slog.Int64("count", rowsAffected))
}
-
- // Clean up rotated tokens past grace period
- if rowsAffected, err := c.store.DeleteRotatedWebRefreshTokens(ctx, refreshTokenGracePeriod); err != nil {
- slog.Error("Failed to clean up rotated web refresh tokens", log.BBError(err))
- } else if rowsAffected > 0 {
- slog.Info("Cleaned up rotated web refresh tokens", slog.Int64("count", rowsAffected))
- }
}
diff --git a/backend/store/web_refresh_token.go b/backend/store/web_refresh_token.go
index 2ba8027278..764353fb01 100644
--- a/backend/store/web_refresh_token.go
+++ b/backend/store/web_refresh_token.go
@@ -14,7 +14,6 @@ type WebRefreshTokenMessage struct {
TokenHash string
UserEmail string
ExpiresAt time.Time
- RotatedAt *time.Time
}
func (s *Store) CreateWebRefreshToken(ctx context.Context, create *WebRefreshTokenMessage) error {
@@ -36,7 +35,7 @@ func (s *Store) CreateWebRefreshToken(ctx context.Context, create *WebRefreshTok
func (s *Store) GetWebRefreshToken(ctx context.Context, tokenHash string) (*WebRefreshTokenMessage, error) {
q := qb.Q().Space(`
- SELECT token_hash, user_email, expires_at, rotated_at
+ SELECT token_hash, user_email, expires_at
FROM web_refresh_token
WHERE token_hash = ?
`, tokenHash)
@@ -47,47 +46,41 @@ func (s *Store) GetWebRefreshToken(ctx context.Context, tokenHash string) (*WebR
}
msg := &WebRefreshTokenMessage{}
- var rotatedAt sql.NullTime
if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(
- &msg.TokenHash, &msg.UserEmail, &msg.ExpiresAt, &rotatedAt,
+ &msg.TokenHash, &msg.UserEmail, &msg.ExpiresAt,
); err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
return nil, errors.Wrap(err, "failed to get web refresh token")
}
- if rotatedAt.Valid {
- msg.RotatedAt = &rotatedAt.Time
- }
return msg, nil
}
-// MarkWebRefreshTokenRotated atomically marks a token as rotated.
-// Returns true if the token was rotated (rotated_at was null), false if already rotated.
-// This prevents race conditions when multiple requests try to rotate the same token.
-func (s *Store) MarkWebRefreshTokenRotated(ctx context.Context, tokenHash string) (bool, error) {
+// GetAndDeleteWebRefreshToken atomically retrieves and deletes a refresh token.
+// Returns the token if found and deleted, nil if not found.
+func (s *Store) GetAndDeleteWebRefreshToken(ctx context.Context, tokenHash string) (*WebRefreshTokenMessage, error) {
q := qb.Q().Space(`
- UPDATE web_refresh_token
- SET rotated_at = NOW()
- WHERE token_hash = ? AND rotated_at IS NULL
+ DELETE FROM web_refresh_token
+ WHERE token_hash = ?
+ RETURNING token_hash, user_email, expires_at
`, tokenHash)
query, args, err := q.ToSQL()
if err != nil {
- return false, err
- }
-
- result, err := s.GetDB().ExecContext(ctx, query, args...)
- if err != nil {
- return false, errors.Wrap(err, "failed to mark web refresh token as rotated")
+ return nil, err
}
- rowsAffected, err := result.RowsAffected()
- if err != nil {
- return false, errors.Wrap(err, "failed to get rows affected")
+ msg := &WebRefreshTokenMessage{}
+ if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(
+ &msg.TokenHash, &msg.UserEmail, &msg.ExpiresAt,
+ ); err != nil {
+ if errors.Is(err, sql.ErrNoRows) {
+ return nil, nil
+ }
+ return nil, errors.Wrap(err, "failed to get and delete web refresh token")
}
-
- return rowsAffected > 0, nil
+ return msg, nil
}
func (s *Store) DeleteWebRefreshToken(ctx context.Context, tokenHash string) error {
@@ -141,21 +134,3 @@ func (s *Store) DeleteExpiredWebRefreshTokens(ctx context.Context) (int64, error
}
return result.RowsAffected()
}
-
-func (s *Store) DeleteRotatedWebRefreshTokens(ctx context.Context, gracePeriod time.Duration) (int64, error) {
- q := qb.Q().Space(`
- DELETE FROM web_refresh_token
- WHERE rotated_at IS NOT NULL AND rotated_at < ?
- `, time.Now().Add(-gracePeriod))
-
- query, args, err := q.ToSQL()
- if err != nil {
- return 0, err
- }
-
- result, err := s.GetDB().ExecContext(ctx, query, args...)
- if err != nil {
- return 0, errors.Wrap(err, "failed to delete rotated web refresh tokens")
- }
- return result.RowsAffected()
-}
diff --git a/frontend/src/grpcweb/refreshToken.ts b/frontend/src/grpcweb/refreshToken.ts
index d24e29bebd..6ea018d826 100644
--- a/frontend/src/grpcweb/refreshToken.ts
+++ b/frontend/src/grpcweb/refreshToken.ts
@@ -1,23 +1,90 @@
import { authServiceClientConnect } from "@/grpcweb";
-let refreshPromise: Promise<void> | null = null;
+const LOCK_KEY = "bb_refresh_lock";
+const LOCK_TIMEOUT_MS = 10000; // 10 seconds max lock hold time
+const POLL_INTERVAL_MS = 50;
+
+let localPromise: Promise<void> | null = null;
/**
* Refresh the access token using the refresh token cookie.
- * Uses singleton pattern to prevent concurrent refresh calls within the same tab.
- * Cross-tab races are handled by server-side grace period (30 seconds).
+ * Uses localStorage lock for cross-tab coordination.
+ * Only one tab performs the refresh; others wait for completion.
*/
export async function refreshTokens(): Promise<void> {
- if (refreshPromise) {
- return refreshPromise;
+ // Same-tab deduplication
+ if (localPromise) {
+ return localPromise;
+ }
+
+ localPromise = doRefresh().finally(() => {
+ localPromise = null;
+ });
+
+ return localPromise;
+}
+
+async function doRefresh(): Promise<void> {
+ // Try to acquire lock
+ if (!tryAcquireLock()) {
+ // Another tab is refreshing - wait for it to complete
+ await waitForLockRelease();
+ return;
}
- refreshPromise = authServiceClientConnect
- .refresh({})
- .then(() => {})
- .finally(() => {
- refreshPromise = null;
- });
+ try {
+ await authServiceClientConnect.refresh({});
+ } finally {
+ releaseLock();
+ }
+}
+
+function tryAcquireLock(): boolean {
+ const now = Date.now();
+ const existing = localStorage.getItem(LOCK_KEY);
+
+ if (existing) {
+ const lockTime = parseInt(existing, 10);
+ // Lock is still valid (not expired)
+ if (now - lockTime < LOCK_TIMEOUT_MS) {
+ return false;
+ }
+ // Lock expired - we can take over
+ }
+
+ localStorage.setItem(LOCK_KEY, now.toString());
+
+ // Double-check we got the lock (handles near-simultaneous writes)
+ const check = localStorage.getItem(LOCK_KEY);
+ return check === now.toString();
+}
+
+function releaseLock(): void {
+ localStorage.removeItem(LOCK_KEY);
+}
+
+async function waitForLockRelease(): Promise<void> {
+ const startTime = Date.now();
+
+ return new Promise((resolve) => {
+ const checkLock = () => {
+ const existing = localStorage.getItem(LOCK_KEY);
+
+ // Lock released or expired
+ if (!existing || Date.now() - parseInt(existing, 10) >= LOCK_TIMEOUT_MS) {
+ resolve();
+ return;
+ }
+
+ // Safety timeout - don't wait forever
+ if (Date.now() - startTime >= LOCK_TIMEOUT_MS) {
+ resolve();
+ return;
+ }
+
+ setTimeout(checkLock, POLL_INTERVAL_MS);
+ };
- return refreshPromise;
+ checkLock();
+ });
}