Fix/bad notif token + system push notifs (#925)

coodos · web-flow · commit 3d614121322f · 2026-03-16T16:09:31.000+05:30
* fix: push notification thing

* fix: push notification token cycling

* fix: system message title

* chore: add debug logs

* fix: remove bad error messges which can mess up token states
diff --git a/infrastructure/evault-core/src/controllers/NotificationController.ts b/infrastructure/evault-core/src/controllers/NotificationController.ts
@@ -11,7 +11,8 @@ export class NotificationController {
     constructor() {
         this.notificationService = new NotificationService(
             AppDataSource.getRepository("Verification"),
-            AppDataSource.getRepository("Notification")
+            AppDataSource.getRepository("Notification"),
+            AppDataSource.getRepository(DeviceToken),
         );
         this.deviceTokenService = new DeviceTokenService(
             AppDataSource.getRepository(DeviceToken)
@@ -76,8 +77,15 @@ export class NotificationController {
 
             const token = typeof pushToken === "string" ? pushToken.trim() : undefined;
 
+            // Look up old tokens for this device so we can clean them from DeviceToken table
             if (token) {
-                await this.deviceTokenService.register(eName, token);
+                const existing = await AppDataSource.getRepository("Verification").findOne({
+                    where: { linkedEName: eName, deviceId },
+                }) as { pushTokens?: string[] } | null;
+                const oldTokens = (existing?.pushTokens ?? []).filter((t) => t !== token);
+                for (const stale of oldTokens) {
+                    await this.deviceTokenService.unregister(eName, stale);
+                }
             }
 
             const verification = await this.notificationService.registerDevice({
@@ -88,6 +96,10 @@ export class NotificationController {
                 registrationTime: new Date(),
             });
 
+            if (token) {
+                await this.deviceTokenService.register(eName, token);
+            }
+
             res.json({
                 success: true,
                 message: "Device registered successfully",
diff --git a/infrastructure/evault-core/src/core/protocol/graphql-server.ts b/infrastructure/evault-core/src/core/protocol/graphql-server.ts
@@ -13,6 +13,7 @@ import { exampleQueries } from "./examples/examples";
 import { typeDefs } from "./typedefs";
 import { VaultAccessGuard, type VaultContext } from "./vault-access-guard";
 import { MessageNotificationService } from "../../services/MessageNotificationService";
+import { DeviceToken } from "../../entities/DeviceToken";
 import { AppDataSource } from "../../config/database";
 
 export class GraphQLServer {
@@ -54,6 +55,7 @@ export class GraphQLServer {
                 AppDataSource.getRepository("Verification"),
                 AppDataSource.getRepository("Notification"),
                 this.db,
+                AppDataSource.getRepository(DeviceToken),
             );
         }
         return this.messageNotificationService;
diff --git a/infrastructure/evault-core/src/services/MessageNotificationService.ts b/infrastructure/evault-core/src/services/MessageNotificationService.ts
@@ -1,6 +1,7 @@
 import { Repository } from "typeorm";
 import { Notification } from "../entities/Notification";
 import { Verification } from "../entities/Verification";
+import { DeviceToken } from "../entities/DeviceToken";
 import { NotificationService } from "./NotificationService";
 import type { DbService } from "../core/db/db.service";
 import { deserializeValue } from "../core/db/schema";
@@ -23,11 +24,13 @@ export class MessageNotificationService {
     constructor(
         verificationRepository: Repository<Verification>,
         notificationRepository: Repository<Notification>,
-        db: DbService
+        db: DbService,
+        deviceTokenRepository?: Repository<DeviceToken>,
     ) {
         this.notificationService = new NotificationService(
             verificationRepository,
-            notificationRepository
+            notificationRepository,
+            deviceTokenRepository,
         );
         this.db = db;
     }
@@ -74,7 +77,11 @@ export class MessageNotificationService {
         const recipients = [...allENames];
         if (recipients.length === 0) return;
 
-        const messageText = payload.content || payload.text || "";
+        const rawText: string = payload.content || payload.text || "";
+        const isSystemMessage = rawText.startsWith("$$system-message$$");
+        const messageText = isSystemMessage
+            ? rawText.replace("$$system-message$$", "").trim()
+            : rawText;
         const truncatedText =
             messageText.length > 100
                 ? messageText.substring(0, 100) + "..."
@@ -90,7 +97,11 @@ export class MessageNotificationService {
         let title: string;
         let body: string;
 
-        if (isDM) {
+        if (isSystemMessage) {
+            const groupName = chatData.name || "a chat";
+            title = `New system message in ${groupName}`;
+            body = truncatedText || "System update";
+        } else if (isDM) {
             title = `New message from ${senderDisplay}`;
             body = truncatedText || "Sent a message";
         } else {
diff --git a/infrastructure/evault-core/src/services/NotificationService.ts b/infrastructure/evault-core/src/services/NotificationService.ts
@@ -1,6 +1,7 @@
 import { Repository } from "typeorm";
 import { Verification } from "../entities/Verification";
 import { Notification } from "../entities/Notification";
+import { DeviceToken } from "../entities/DeviceToken";
 
 export interface DeviceRegistration {
     eName: string;
@@ -22,10 +23,24 @@ export interface SendNotificationRequest {
     sharedSecret: string;
 }
 
+const BAD_TOKEN_ERRORS = [
+    "messaging/registration-token-not-valid",
+    "messaging/invalid-registration-token",
+    "BadDeviceToken",
+    "Unregistered",
+    "DeviceTokenNotForTopic",
+];
+
+function isBadTokenError(error: unknown): boolean {
+    const msg = error instanceof Error ? error.message : String(error);
+    return BAD_TOKEN_ERRORS.some((e) => msg.includes(e));
+}
+
 export class NotificationService {
     constructor(
         private verificationRepository: Repository<Verification>,
-        private notificationRepository: Repository<Notification>
+        private notificationRepository: Repository<Notification>,
+        private deviceTokenRepository?: Repository<DeviceToken>,
     ) {}
 
     async registerDevice(registration: DeviceRegistration): Promise<Verification> {
@@ -56,10 +71,10 @@ export class NotificationService {
         if (verification) {
             verification.platform = registration.platform;
             if (token) {
-                const existing = verification.pushTokens ?? [];
-                if (!existing.includes(token)) {
-                    verification.pushTokens = [...existing, token];
-                }
+                // Replace all tokens for this device — the latest token from the
+                // OS is the only valid one. Appending caused stale tokens to
+                // accumulate and never get cleaned up.
+                verification.pushTokens = [token];
             }
             verification.deviceActive = true;
             verification.updatedAt = new Date();
@@ -118,6 +133,7 @@ export class NotificationService {
 
         // Send actual push notification via notification-trigger service
         const triggerUrl = process.env.NOTIFICATION_TRIGGER_URL || `http://localhost:${process.env.NOTIFICATION_TRIGGER_PORT || 3998}`;
+        console.log(`[NOTIF] Using trigger URL: ${triggerUrl}`);
         const pushPayload = {
             title: notification.title,
             body: notification.body,
@@ -152,8 +168,13 @@ export class NotificationService {
 
         console.log(`[NOTIF] Sending push to ${allTokens.length} token(s) for eName: ${eName}`);
 
-        const pushResults = await Promise.allSettled(
-            allTokens.map(async ({ token, platform }) => {
+        // Cycle through tokens sequentially: try each one, remove bad tokens
+        // inline, and keep going until at least one succeeds.
+        const badTokens: string[] = [];
+        let delivered = false;
+
+        for (const { token, platform } of allTokens) {
+            try {
                 const res = await fetch(`${triggerUrl}/api/send`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
@@ -165,27 +186,106 @@ export class NotificationService {
                     signal: AbortSignal.timeout(10000),
                 });
                 const data = await res.json();
-                if (!data.success) {
-                    throw new Error(data.error || "Push send failed");
+
+                if (data.success) {
+                    console.log(`[NOTIF] Push delivered via token ${token.slice(0, 8)}… for ${eName}`);
+                    delivered = true;
+                    // Keep sending to remaining tokens — user may have multiple
+                    // devices (phone + tablet) that should all receive the notif.
+                    continue;
                 }
-                return data;
-            })
-        );
-
-        const pushSucceeded = pushResults.filter(r => r.status === "fulfilled").length;
-        const pushFailed = pushResults.filter(r => r.status === "rejected").length;
-        if (pushFailed > 0) {
-            console.log(`[NOTIF] Push results for ${eName}: ${pushSucceeded} sent, ${pushFailed} failed`);
-            pushResults.forEach((r, i) => {
-                if (r.status === "rejected") {
-                    console.error(`[NOTIF] Push failed for token index ${i}:`, r.reason);
+
+                // Send returned an explicit failure
+                const error = data.error || "Push send failed";
+                console.error(
+                    `[NOTIF] Push rejected for token ${token.slice(0, 8)}…\n` +
+                    `  platform : ${platform ?? "auto-detect"}\n` +
+                    `  error    : ${error}`,
+                );
+
+                if (isBadTokenError(error)) {
+                    badTokens.push(token);
+                    console.log(`[NOTIF] Bad token ${token.slice(0, 8)}… queued for removal, trying next…`);
                 }
-            });
+            } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                const errObj = err as Record<string, unknown>;
+                const rawCause = errObj?.cause;
+                const cause = rawCause
+                    ? rawCause instanceof Error ? rawCause.message : String(rawCause)
+                    : null;
+                console.error(
+                    `[NOTIF] Push error for token ${token.slice(0, 8)}…\n` +
+                    `  platform : ${platform ?? "auto-detect"}\n` +
+                    `  url      : ${triggerUrl}/api/send\n` +
+                    `  error    : ${msg}\n` +
+                    (cause ? `  cause    : ${cause}\n` : "") +
+                    `  full     :`, err,
+                );
+
+                if (msg.includes("fetch failed") || msg.includes("ECONNREFUSED")) {
+                    console.error(`[NOTIF] notification-trigger service appears to be DOWN at ${triggerUrl} — skipping remaining tokens`);
+                    break;
+                }
+
+                if (isBadTokenError(err)) {
+                    badTokens.push(token);
+                    console.log(`[NOTIF] Bad token ${token.slice(0, 8)}… queued for removal, trying next…`);
+                }
+            }
+        }
+
+        // Purge bad tokens from both Verification and DeviceToken tables
+        if (badTokens.length > 0) {
+            console.log(`[NOTIF] Removing ${badTokens.length} bad token(s) for ${eName}`);
+            await this.removeBadTokens(eName, badTokens);
+        }
+
+        if (delivered) {
+            console.log(`[NOTIF] Push delivered for ${eName}`);
         } else {
-            console.log(`[NOTIF] Push sent successfully to ${pushSucceeded} token(s) for ${eName}`);
+            console.log(`[NOTIF] Push failed for all ${allTokens.length} token(s) for ${eName}`);
         }
 
-        return pushSucceeded > 0 || pushFailed === 0;
+        return delivered;
+    }
+
+    private async removeBadTokens(eName: string, badTokens: string[]): Promise<void> {
+        try {
+            // Clean Verification table
+            const verifications = await this.verificationRepository.find({
+                where: { linkedEName: eName },
+            });
+            for (const v of verifications) {
+                const before = v.pushTokens?.length ?? 0;
+                v.pushTokens = (v.pushTokens ?? []).filter((t) => !badTokens.includes(t));
+                if (v.pushTokens.length !== before) {
+                    v.updatedAt = new Date();
+                    await this.verificationRepository.save(v);
+                }
+            }
+
+            // Clean DeviceToken table
+            if (this.deviceTokenRepository) {
+                const normalized = eName.startsWith("@") ? eName : `@${eName}`;
+                const withoutAt = eName.replace(/^@/, "");
+                const rows = await this.deviceTokenRepository
+                    .createQueryBuilder("dt")
+                    .where("dt.eName = :e1 OR dt.eName = :e2", { e1: normalized, e2: withoutAt })
+                    .getMany();
+
+                for (const row of rows) {
+                    const before = row.tokens.length;
+                    row.tokens = row.tokens.filter((t) => !badTokens.includes(t));
+                    if (row.tokens.length !== before) {
+                        row.updatedAt = new Date();
+                        await this.deviceTokenRepository.save(row);
+                    }
+                }
+            }
+        } catch (err) {
+            console.error(`[NOTIF] Failed to remove bad tokens for ${eName}:`, err);
+        }
     }
 
     async getUndeliveredNotifications(eName: string): Promise<Notification[]> {
