Add durable NotifyComp push sessions

coder13 · coder13 · commit 434ceba21623 · 2026-05-27T21:14:38.000-07:00
diff --git a/src/containers/MyCompetitions/MyCompetitions.query.ts b/src/containers/MyCompetitions/MyCompetitions.query.ts
@@ -25,12 +25,18 @@ export const useMyCompetitionsQuery = (userId?: number, options: { enabled?: boo
         return undefined;
       }
 
-      const upcoming_competitions = JSON.parse(
-        getLocalStorage('my.upcoming_competitions') || '[]',
-      ) as ApiCompetition[];
-      const ongoing_competitions = JSON.parse(
-        getLocalStorage('my.ongoing_competitions') || '[]',
-      ) as ApiCompetition[];
+      const rawUpcomingCompetitions = getLocalStorage('my.upcoming_competitions');
+      const rawOngoingCompetitions = getLocalStorage('my.ongoing_competitions');
+      if (!rawUpcomingCompetitions && !rawOngoingCompetitions) {
+        return undefined;
+      }
+
+      const upcoming_competitions = JSON.parse(rawUpcomingCompetitions || '[]') as ApiCompetition[];
+      const ongoing_competitions = JSON.parse(rawOngoingCompetitions || '[]') as ApiCompetition[];
+
+      if (!upcoming_competitions.length && !ongoing_competitions.length) {
+        return undefined;
+      }
 
       return { user: user, upcoming_competitions, ongoing_competitions };
     },
diff --git a/src/lib/notifications/assignmentNotifications.ts b/src/lib/notifications/assignmentNotifications.ts
@@ -1,5 +1,10 @@
 import { deleteLocalStorage, getLocalStorage, setLocalStorage } from '@/lib/localStorage';
 import { getStoredWcaAccessToken } from '@/lib/wcaAccessToken';
+import {
+  clearNotifyCompPushSessionToken,
+  getNotifyCompPushSessionToken,
+  setNotifyCompPushSessionToken,
+} from './notifyCompPushSession';
 
 const NOTIFY_COMP_ORIGIN =
   import.meta.env.VITE_NOTIFY_COMP_ORIGIN ?? 'https://api.notifycomp.com/api';
@@ -15,6 +20,17 @@ interface PushSubscriptionJson {
   };
 }
 
+interface PushSessionResponse {
+  sessionToken?: string;
+  token?: string;
+}
+
+interface PushSubscriptionPayload {
+  endpoint: string;
+  p256dh: string;
+  auth: string;
+}
+
 export interface AssignmentNotificationWatch {
   competitionId: string;
   wcaUserId: number;
@@ -25,7 +41,7 @@ export type AssignmentNotificationStatus = NotificationPermission | 'reauthorize
 const notifyCompUrl = (path: string) => `${NOTIFY_COMP_ORIGIN}${path}`;
 
 export const isAssignmentNotificationsEnabled = () =>
-  getLocalStorage(ENABLED_STORAGE_KEY) === 'true';
+  Boolean(getNotifyCompPushSessionToken()) || getLocalStorage(ENABLED_STORAGE_KEY) === 'true';
 
 const toUint8Array = (base64: string) => {
   const padding = '='.repeat((4 - (base64.length % 4)) % 4);
@@ -49,7 +65,7 @@ export const getAssignmentNotificationStatus = (): AssignmentNotificationStatus
     return 'unsupported';
   }
 
-  if (!getStoredWcaAccessToken()) {
+  if (!getNotifyCompPushSessionToken() && !getStoredWcaAccessToken()) {
     return 'reauthorize';
   }
 
@@ -105,6 +121,9 @@ const fetchNotifyCompToken = async () => {
   return payload.token;
 };
 
+const canFallbackToLegacySubscriptions = (response: Response) =>
+  response.status === 404 || response.status === 405;
+
 const fetchVapidPublicKey = async () => {
   const response = await fetch(notifyCompUrl('/v0/external/push/vapid-public-key'));
 
@@ -153,30 +172,33 @@ const getPushSubscription = async () => {
   });
 };
 
-export const enableAssignmentNotifications = async (watches: AssignmentNotificationWatch[]) => {
-  const permission = await requestAssignmentNotificationPermission();
-  if (permission !== 'granted') {
-    return permission;
-  }
-
-  const token = await fetchNotifyCompToken();
-  const subscription = await getPushSubscription();
+const pushSubscriptionPayload = (subscription: PushSubscription): PushSubscriptionPayload => {
   const payload = subscription.toJSON() as PushSubscriptionJson;
 
   if (!payload.endpoint || !payload.keys?.p256dh || !payload.keys.auth) {
     throw new Error('Browser push subscription is missing required keys.');
   }
 
+  return {
+    auth: payload.keys.auth,
+    endpoint: payload.endpoint,
+    p256dh: payload.keys.p256dh,
+  };
+};
+
+const registerLegacySubscription = async (
+  authToken: string,
+  payload: PushSubscriptionPayload,
+  watches: AssignmentNotificationWatch[],
+) => {
   const response = await fetch(notifyCompUrl('/v0/external/push/subscriptions'), {
     method: 'POST',
     headers: {
-      Authorization: `Bearer ${token}`,
+      Authorization: `Bearer ${authToken}`,
       'Content-Type': 'application/json',
     },
     body: JSON.stringify({
-      endpoint: payload.endpoint,
-      p256dh: payload.keys.p256dh,
-      auth: payload.keys.auth,
+      ...payload,
       watches,
     }),
   });
@@ -185,34 +207,150 @@ export const enableAssignmentNotifications = async (watches: AssignmentNotificat
     deleteLocalStorage(ENABLED_STORAGE_KEY);
     throw new Error(await readErrorMessage(response));
   }
+};
+
+const createPushSession = async (
+  authToken: string,
+  payload: PushSubscriptionPayload,
+  watches: AssignmentNotificationWatch[],
+) => {
+  const response = await fetch(notifyCompUrl('/v0/external/push/sessions'), {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      ...payload,
+      watches,
+    }),
+  });
+
+  if (canFallbackToLegacySubscriptions(response)) {
+    await registerLegacySubscription(authToken, payload, watches);
+    return;
+  }
+
+  if (!response.ok) {
+    clearNotifyCompPushSessionToken();
+    deleteLocalStorage(ENABLED_STORAGE_KEY);
+    throw new Error(await readErrorMessage(response));
+  }
+
+  const session = (await response.json()) as PushSessionResponse;
+  const sessionToken = session.sessionToken || session.token;
+  if (!sessionToken) {
+    clearNotifyCompPushSessionToken();
+    deleteLocalStorage(ENABLED_STORAGE_KEY);
+    throw new Error('NotifyComp push session response was missing a session token.');
+  }
+
+  setNotifyCompPushSessionToken(sessionToken);
+};
+
+const updatePushSession = async (
+  sessionToken: string,
+  payload: PushSubscriptionPayload,
+  watches: AssignmentNotificationWatch[],
+) => {
+  const response = await fetch(notifyCompUrl('/v0/external/push/sessions/current'), {
+    method: 'PUT',
+    headers: {
+      Authorization: `Bearer ${sessionToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      ...payload,
+      watches,
+    }),
+  });
+
+  if (response.status === 401 || response.status === 403) {
+    clearNotifyCompPushSessionToken();
+    return false;
+  }
+
+  if (!response.ok) {
+    throw new Error(await readErrorMessage(response));
+  }
+
+  return true;
+};
+
+export const enableAssignmentNotifications = async (watches: AssignmentNotificationWatch[]) => {
+  const permission = await requestAssignmentNotificationPermission();
+  if (permission !== 'granted') {
+    return permission;
+  }
+
+  const subscription = await getPushSubscription();
+  const payload = pushSubscriptionPayload(subscription);
+  const sessionToken = getNotifyCompPushSessionToken();
+
+  if (sessionToken && (await updatePushSession(sessionToken, payload, watches))) {
+    setLocalStorage(ENABLED_STORAGE_KEY, 'true');
+    return permission;
+  }
+
+  await createPushSession(await fetchNotifyCompToken(), payload, watches);
 
   setLocalStorage(ENABLED_STORAGE_KEY, 'true');
   return permission;
 };
 
+const deletePushSession = async (sessionToken: string, endpoint?: string) => {
+  const response = await fetch(notifyCompUrl('/v0/external/push/sessions/current'), {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${sessionToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ endpoint }),
+  });
+
+  if (
+    !response.ok &&
+    response.status !== 401 &&
+    response.status !== 403 &&
+    response.status !== 404
+  ) {
+    throw new Error(await readErrorMessage(response));
+  }
+};
+
+const deleteLegacySubscription = async (endpoint: string) => {
+  const token = await fetchNotifyCompToken();
+
+  await fetch(notifyCompUrl('/v0/external/push/subscriptions'), {
+    method: 'DELETE',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ endpoint }),
+  });
+};
+
 export const disableAssignmentNotifications = async () => {
   const registration = await getServiceWorkerRegistration();
   const subscription = await registration.pushManager.getSubscription();
+  const sessionToken = getNotifyCompPushSessionToken();
 
   if (!subscription) {
+    clearNotifyCompPushSessionToken();
     deleteLocalStorage(ENABLED_STORAGE_KEY);
     return;
   }
 
-  const token = await fetchNotifyCompToken();
   const payload = subscription.toJSON() as PushSubscriptionJson;
 
-  if (payload.endpoint) {
-    await fetch(notifyCompUrl('/v0/external/push/subscriptions'), {
-      method: 'DELETE',
-      headers: {
-        Authorization: `Bearer ${token}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ endpoint: payload.endpoint }),
-    });
+  if (sessionToken) {
+    await deletePushSession(sessionToken, payload.endpoint);
+  } else if (payload.endpoint) {
+    await deleteLegacySubscription(payload.endpoint);
   }
 
   await subscription.unsubscribe();
+  clearNotifyCompPushSessionToken();
   deleteLocalStorage(ENABLED_STORAGE_KEY);
 };
diff --git a/src/lib/notifications/notifyCompPushSession.test.ts b/src/lib/notifications/notifyCompPushSession.test.ts
@@ -0,0 +1,53 @@
+import {
+  clearNotifyCompPushSessionToken,
+  getNotifyCompPushSessionToken,
+  setNotifyCompPushSessionToken,
+} from './notifyCompPushSession';
+
+jest.mock('@/lib/localStorage', () => ({
+  deleteLocalStorage: (key: string) => localStorage.removeItem(key),
+  getLocalStorage: (key: string) => localStorage.getItem(key),
+  setLocalStorage: (key: string, value: string) => localStorage.setItem(key, value),
+}));
+
+const base64Url = (value: unknown) =>
+  Buffer.from(JSON.stringify(value)).toString('base64url').replace(/=/g, '');
+
+const jwtWithClaims = (claims: Record<string, unknown>) =>
+  `${base64Url({ alg: 'HS256', typ: 'JWT' })}.${base64Url(claims)}.signature`;
+
+describe('notifyCompPushSession', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  afterEach(() => {
+    clearNotifyCompPushSessionToken();
+  });
+
+  it('stores opaque NotifyComp push session tokens', () => {
+    setNotifyCompPushSessionToken('opaque-session-token');
+
+    expect(getNotifyCompPushSessionToken()).toBe('opaque-session-token');
+  });
+
+  it('reads unpadded JWT push session tokens', () => {
+    const token = jwtWithClaims({
+      exp: Math.floor(Date.now() / 1000) + 60,
+    });
+
+    setNotifyCompPushSessionToken(token);
+
+    expect(getNotifyCompPushSessionToken()).toBe(token);
+  });
+
+  it('clears expired JWT push session tokens', () => {
+    setNotifyCompPushSessionToken(
+      jwtWithClaims({
+        exp: Math.floor(Date.now() / 1000) - 60,
+      }),
+    );
+
+    expect(getNotifyCompPushSessionToken()).toBe(null);
+  });
+});
diff --git a/src/lib/notifications/notifyCompPushSession.ts b/src/lib/notifications/notifyCompPushSession.ts
@@ -0,0 +1,45 @@
+import { deleteLocalStorage, getLocalStorage, setLocalStorage } from '@/lib/localStorage';
+
+const PUSH_SESSION_TOKEN_KEY = 'notifyComp.pushSessionToken';
+
+interface JwtClaims {
+  exp?: number;
+}
+
+const decodeJwtPayload = (token: string): JwtClaims | null => {
+  try {
+    const payload = token.split('.')[1];
+    if (!payload) {
+      return null;
+    }
+
+    const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+    const normalized = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+    return JSON.parse(window.atob(normalized)) as JwtClaims;
+  } catch {
+    return null;
+  }
+};
+
+export const getNotifyCompPushSessionToken = () => {
+  const token = getLocalStorage(PUSH_SESSION_TOKEN_KEY);
+  if (!token) {
+    return null;
+  }
+
+  const claims = decodeJwtPayload(token);
+  if (claims?.exp && claims.exp * 1000 <= Date.now()) {
+    deleteLocalStorage(PUSH_SESSION_TOKEN_KEY);
+    return null;
+  }
+
+  return token;
+};
+
+export const setNotifyCompPushSessionToken = (token: string) => {
+  setLocalStorage(PUSH_SESSION_TOKEN_KEY, token);
+};
+
+export const clearNotifyCompPushSessionToken = () => {
+  deleteLocalStorage(PUSH_SESSION_TOKEN_KEY);
+};
diff --git a/src/providers/AuthProvider/AuthProvider.tsx b/src/providers/AuthProvider/AuthProvider.tsx
