fix: push notification thing

Author: coodos

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",

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;

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;
     }

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,27 @@ export interface SendNotificationRequest {
     sharedSecret: string;
 }
 
+const BAD_TOKEN_ERRORS = [
+    "messaging/registration-token-not-valid",
+    "messaging/invalid-registration-token",
+    "messaging/mismatched-credential",
+    "BadDeviceToken",
+    "Unregistered",
+    "DeviceTokenNotForTopic",
+    "ExpiredProviderToken",
+    "InvalidProviderToken",
+];
+
+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 +74,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();
@@ -174,20 +192,71 @@ export class NotificationService {
 
         const pushSucceeded = pushResults.filter(r => r.status === "fulfilled").length;
         const pushFailed = pushResults.filter(r => r.status === "rejected").length;
+
+        // Collect tokens that returned a known "bad token" error so we can purge them
+        const badTokens: string[] = [];
+        pushResults.forEach((r, i) => {
+            if (r.status === "rejected") {
+                console.error(`[NOTIF] Push failed for token index ${i}:`, r.reason);
+                if (isBadTokenError(r.reason)) {
+                    badTokens.push(allTokens[i].token);
+                }
+            }
+        });
+
         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);
-                }
-            });
         } else {
             console.log(`[NOTIF] Push sent successfully to ${pushSucceeded} token(s) for ${eName}`);
         }
 
+        // 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);
+        }
+
         return pushSucceeded > 0 || pushFailed === 0;
     }
 
+    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[]> {
         return await this.notificationRepository.find({
             where: { eName, delivered: false },