93 lines
3.5 KiB
TypeScript
93 lines
3.5 KiB
TypeScript
import * as admin from 'firebase-admin'
|
|
|
|
/**
|
|
* FCM error codes that mean a token is *permanently* dead and safe to delete.
|
|
*
|
|
* Deliberately narrow. We only prune on errors that unambiguously blame the TOKEN:
|
|
* - `registration-token-not-registered` — the app was uninstalled / data-cleared / token rotated.
|
|
* - `invalid-registration-token` — the token string itself is malformed.
|
|
* We intentionally do NOT include `messaging/invalid-argument` or any transient/server error
|
|
* (`unavailable`, `internal`, `quota-exceeded`, auth issues): those can be caused by a bad *payload*
|
|
* or a temporary outage, and treating them as dead would let one bug wipe every user's tokens.
|
|
*/
|
|
const DEAD_TOKEN_CODES = new Set<string>([
|
|
'messaging/registration-token-not-registered',
|
|
'messaging/invalid-registration-token',
|
|
])
|
|
|
|
/** Extract the `messaging/*` code from a firebase-admin messaging rejection, wherever it lives. */
|
|
function messagingErrorCode(reason: unknown): string | undefined {
|
|
const r = reason as { errorInfo?: { code?: unknown }; code?: unknown } | null | undefined
|
|
const code = r?.errorInfo?.code ?? r?.code
|
|
return typeof code === 'string' ? code : undefined
|
|
}
|
|
|
|
/** True only when an FCM send rejection means the token is permanently invalid (safe to delete). */
|
|
export function isDeadTokenError(reason: unknown): boolean {
|
|
const code = messagingErrorCode(reason)
|
|
return code !== undefined && DEAD_TOKEN_CODES.has(code)
|
|
}
|
|
|
|
/**
|
|
* Pure: given the same `tokens` array and `Promise.allSettled` results a caller already has, return the
|
|
* distinct token strings that FCM reported as permanently dead. Index `i` in results maps to `tokens[i]`.
|
|
*/
|
|
export function selectDeadTokens(
|
|
tokens: string[],
|
|
results: PromiseSettledResult<unknown>[]
|
|
): string[] {
|
|
const dead = new Set<string>()
|
|
results.forEach((r, i) => {
|
|
const token = tokens[i]
|
|
if (r.status === 'rejected' && token && isDeadTokenError(r.reason)) dead.add(token)
|
|
})
|
|
return [...dead]
|
|
}
|
|
|
|
/**
|
|
* Best-effort removal of tokens FCM reported as permanently dead. Pass the `tokens` array and the
|
|
* `Promise.allSettled` results from the send you just performed; any dead token is deleted from the
|
|
* user's `fcmTokens` subcollection and cleared from the legacy `fcmToken` field if it matches.
|
|
*
|
|
* Never throws — pruning is housekeeping and must never fail the notification path it runs after.
|
|
* Returns the number of token records removed.
|
|
*/
|
|
export async function pruneDeadTokens(
|
|
db: admin.firestore.Firestore,
|
|
uid: string,
|
|
tokens: string[],
|
|
results: PromiseSettledResult<unknown>[]
|
|
): Promise<number> {
|
|
const dead = new Set(selectDeadTokens(tokens, results))
|
|
if (dead.size === 0) return 0
|
|
try {
|
|
const userRef = db.collection('users').doc(uid)
|
|
const [tokenSnap, userDoc] = await Promise.all([
|
|
userRef.collection('fcmTokens').get(),
|
|
userRef.get(),
|
|
])
|
|
const batch = db.batch()
|
|
let removed = 0
|
|
tokenSnap.docs.forEach((d) => {
|
|
const t = d.data()?.token
|
|
if (typeof t === 'string' && dead.has(t)) {
|
|
batch.delete(d.ref)
|
|
removed++
|
|
}
|
|
})
|
|
const legacy = userDoc.data()?.fcmToken
|
|
if (typeof legacy === 'string' && dead.has(legacy)) {
|
|
batch.update(userRef, { fcmToken: admin.firestore.FieldValue.delete() })
|
|
removed++
|
|
}
|
|
if (removed > 0) {
|
|
await batch.commit()
|
|
console.log(`[pruneDeadTokens] uid=${uid} removed ${removed} dead token(s)`)
|
|
}
|
|
return removed
|
|
} catch (e) {
|
|
console.warn(`[pruneDeadTokens] uid=${uid} prune failed (ignored):`, e)
|
|
return 0
|
|
}
|
|
}
|