Merge pull request #68 from coder13/codex/integrate-notifycomp-push

[codex] Integrate NotifyComp assignment push

Author: coder13

netlify/functions/notify-comp-token.js

@@ -0,0 +1,96 @@
+const crypto = require('crypto');
+
+const headers = {
+  'Access-Control-Allow-Headers': 'Content-Type',
+  'Access-Control-Allow-Methods': 'POST, OPTIONS',
+  'Access-Control-Allow-Origin': '*',
+  'Content-Type': 'application/json',
+};
+
+const base64Url = (value) => Buffer.from(value).toString('base64url');
+
+const signJwt = (claims, secret) => {
+  const encodedHeader = base64Url(JSON.stringify({ alg: 'HS256', typ: 'JWT' }));
+  const encodedPayload = base64Url(JSON.stringify(claims));
+  const signature = crypto
+    .createHmac('sha256', secret)
+    .update(`${encodedHeader}.${encodedPayload}`)
+    .digest('base64url');
+
+  return `${encodedHeader}.${encodedPayload}.${signature}`;
+};
+
+exports.handler = async (event) => {
+  if (event.httpMethod === 'OPTIONS') {
+    return { statusCode: 204, headers };
+  }
+
+  if (event.httpMethod !== 'POST') {
+    return {
+      statusCode: 405,
+      headers,
+      body: JSON.stringify({ message: 'Method not allowed' }),
+    };
+  }
+
+  const secret = process.env.COMPETITION_GROUPS_JWT_SECRET;
+  if (!secret) {
+    return {
+      statusCode: 500,
+      headers,
+      body: JSON.stringify({ message: 'Notification token secret is not configured' }),
+    };
+  }
+
+  const { accessToken } = JSON.parse(event.body || '{}');
+  if (!accessToken) {
+    return {
+      statusCode: 400,
+      headers,
+      body: JSON.stringify({ message: 'Missing WCA access token' }),
+    };
+  }
+
+  const wcaOrigin = process.env.WCA_ORIGIN || 'https://www.worldcubeassociation.org';
+  const meResponse = await fetch(`${wcaOrigin}/api/v0/me`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+    },
+  });
+
+  if (!meResponse.ok) {
+    return {
+      statusCode: 401,
+      headers,
+      body: JSON.stringify({ message: 'Invalid WCA access token' }),
+    };
+  }
+
+  const { me } = await meResponse.json();
+  if (!me?.id) {
+    return {
+      statusCode: 401,
+      headers,
+      body: JSON.stringify({ message: 'Unable to resolve WCA user' }),
+    };
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const token = signJwt(
+    {
+      aud: process.env.COMPETITION_GROUPS_JWT_AUDIENCE || 'notifycomp',
+      exp: now + 10 * 60,
+      iat: now,
+      iss: process.env.COMPETITION_GROUPS_JWT_ISSUER || 'competitiongroups.com',
+      sub: `wca:${me.id}`,
+      wcaUserIds: [me.id],
+    },
+    secret,
+  );
+
+  return {
+    statusCode: 200,
+    headers,
+    body: JSON.stringify({ token }),
+  };
+};

public/notification-sw.js

@@ -0,0 +1,34 @@
+self.addEventListener('push', (event) => {
+  if (!event.data) {
+    return;
+  }
+
+  const payload = event.data.json();
+  const title = payload.title || 'Assignment update';
+  const options = {
+    body: payload.body,
+    data: payload,
+    tag: payload.dedupeKey || 'assignment-change',
+  };
+
+  event.waitUntil(self.registration.showNotification(title, options));
+});
+
+self.addEventListener('notificationclick', (event) => {
+  event.notification.close();
+
+  const targetUrl = event.notification.data?.url || '/settings';
+  const url = new URL(targetUrl, self.location.origin).href;
+
+  event.waitUntil(
+    self.clients.matchAll({ includeUncontrolled: true, type: 'window' }).then((clients) => {
+      const existingClient = clients.find((client) => client.url === url);
+
+      if (existingClient) {
+        return existingClient.focus();
+      }
+
+      return self.clients.openWindow(url);
+    }),
+  );
+});

src/apolloClient.ts

@@ -4,12 +4,12 @@ import { getMainDefinition } from '@apollo/client/utilities';
 import { createClient } from 'graphql-ws';
 
 const httpLink = createHttpLink({
-  uri: import.meta.env.VITE_NOTIFYCOMP_API_ORIGIN || 'https://admin.notifycomp.com/graphql',
+  uri: import.meta.env.VITE_NOTIFYCOMP_API_ORIGIN || 'https://api.notifycomp.com/api/graphql',
 });
 
 const wsLink = new GraphQLWsLink(
   createClient({
-    url: import.meta.env.VITE_NOTIFYCOMP_WS_ORIGIN || 'wss://admin.notifycomp.com/graphql',
+    url: import.meta.env.VITE_NOTIFYCOMP_WS_ORIGIN || 'wss://api.notifycomp.com/api/graphql',
   }),
 );
 

src/hooks/useAssignmentNotifications/index.ts

@@ -0,0 +1 @@
+export * from './useAssignmentNotifications';

src/hooks/useAssignmentNotifications/useAssignmentNotifications.ts

@@ -0,0 +1,85 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  AssignmentNotificationStatus,
+  disableAssignmentNotifications,
+  enableAssignmentNotifications,
+  getAssignmentNotificationStatus,
+  isAssignmentNotificationsEnabled,
+} from '@/lib/notifications/assignmentNotifications';
+
+interface UseAssignmentNotificationsParams {
+  competitions: ApiCompetition[];
+  user: User | null;
+}
+
+export function useAssignmentNotifications({
+  competitions,
+  user,
+}: UseAssignmentNotificationsParams) {
+  const [status, setStatus] = useState<AssignmentNotificationStatus>(
+    getAssignmentNotificationStatus,
+  );
+  const [isSaving, setIsSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [isEnabled, setIsEnabled] = useState(isAssignmentNotificationsEnabled);
+
+  useEffect(() => {
+    setStatus(getAssignmentNotificationStatus());
+    setIsEnabled(isAssignmentNotificationsEnabled());
+  }, [user]);
+
+  const watches = useMemo(
+    () =>
+      user
+        ? competitions.map((competition) => ({
+            competitionId: competition.id,
+            wcaUserId: user.id,
+          }))
+        : [],
+    [competitions, user],
+  );
+
+  const enable = useCallback(async () => {
+    setIsSaving(true);
+    setError(null);
+
+    try {
+      const nextStatus = await enableAssignmentNotifications(watches);
+      setStatus(nextStatus);
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unable to enable assignment notifications.');
+      setStatus(getAssignmentNotificationStatus());
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } finally {
+      setIsSaving(false);
+    }
+  }, [watches]);
+
+  const disable = useCallback(async () => {
+    setIsSaving(true);
+    setError(null);
+
+    try {
+      await disableAssignmentNotifications();
+      setStatus(getAssignmentNotificationStatus());
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unable to disable assignment notifications.');
+      setIsEnabled(isAssignmentNotificationsEnabled());
+    } finally {
+      setIsSaving(false);
+    }
+  }, []);
+
+  return {
+    canEnable: (status === 'default' || status === 'granted') && !isEnabled && watches.length > 0,
+    canDisable: status === 'granted' && isEnabled,
+    enable,
+    disable,
+    error,
+    isSaving,
+    status,
+    watchCount: watches.length,
+  };
+}