Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(queue-worker): restore mobile push delivery (#804)

Gener011e8ed5be38
diff --git a/src/queue-worker/src/mobile-push.test.ts b/src/queue-worker/src/mobile-push.test.ts
index 5883bb162..c50b7dbae 100644
--- a/src/queue-worker/src/mobile-push.test.ts
+++ b/src/queue-worker/src/mobile-push.test.ts
@@ -19,6 +19,10 @@ vi.mock("@alook/shared", async (importOriginal) => {
})
import { processMobilePush } from "./mobile-push"
+import {
+ PushProviderError,
+ type PushProviderStage,
+} from "./providers/diagnostics"
const task = {
version: 1 as const,
@@ -151,7 +155,12 @@ describe("mobile-push processing", () => {
it("continues siblings and returns a caught failure without logging content or tokens", async () => {
const deps = dependencies()
- deps.sendApns.mockRejectedValue(new Error("provider unavailable"))
+ deps.sendApns.mockRejectedValue(new PushProviderError(
+ "apns",
+ "provider_send",
+ 503,
+ "sensitive-provider-reason",
+ ))
await expect(processMobilePush({} as never, env, task, deps)).resolves.toMatchObject({
outcome: "processed",
@@ -161,6 +170,24 @@ describe("mobile-push processing", () => {
failed: 1,
})
expect(deps.sendFcm).toHaveBeenCalledTimes(1)
+ expect(mockLogWarn).toHaveBeenCalledWith("mobile_push_device_failed", {
+ messageId: "message-1",
+ deviceId: "device-ios",
+ provider: "apns",
+ stage: "provider_send",
+ errorName: "PushProviderError",
+ httpStatus: 503,
+ durationMs: expect.any(Number),
+ })
+ expect(Object.keys(mockLogWarn.mock.calls[0]![1]).sort()).toEqual([
+ "deviceId",
+ "durationMs",
+ "errorName",
+ "httpStatus",
+ "messageId",
+ "provider",
+ "stage",
+ ])
const logged = JSON.stringify([
...mockLogInfo.mock.calls,
...mockLogWarn.mock.calls,
@@ -168,8 +195,137 @@ describe("mobile-push processing", () => {
expect(logged).not.toContain("private message body")
expect(logged).not.toContain("plain-ciphertext")
expect(logged).not.toContain("encryption-key")
+ expect(logged).not.toContain("sensitive-provider-reason")
+ })
+
+ it("classifies decrypt failures without logging ciphertext or raw error details", async () => {
+ const deps = dependencies()
+ deps.listDevices.mockResolvedValue([{
+ id: "device-ios",
+ installationId: "installation-ios",
+ platform: "ios" as const,
+ providerEnvironment: "sandbox" as const,
+ providerTokenEncrypted: "sensitive-ciphertext",
+ }])
+ const rawError = new Error("sensitive-decrypt-message")
+ rawError.name = "TypeError"
+ rawError.stack = "sensitive-decrypt-stack"
+ deps.decrypt.mockImplementation(() => { throw rawError })
+
+ await expect(processMobilePush({} as never, env, task, deps)).resolves.toEqual({
+ outcome: "processed",
+ attempted: 1,
+ sent: 0,
+ invalidated: 0,
+ failed: 1,
+ })
+ expect(mockLogWarn).toHaveBeenCalledWith("mobile_push_device_failed", {
+ messageId: "message-1",
+ deviceId: "device-ios",
+ provider: "apns",
+ stage: "decrypt",
+ errorName: "TypeError",
+ durationMs: expect.any(Number),
+ })
+ const logged = JSON.stringify(mockLogWarn.mock.calls)
+ for (const sentinel of [
+ "sensitive-ciphertext",
+ "sensitive-decrypt-message",
+ "sensitive-decrypt-stack",
+ ]) {
+ expect(logged).not.toContain(sentinel)
+ }
})
+ it("drops unapproved HTTP statuses and error names from failure logs", async () => {
+ const deps = dependencies()
+ deps.listDevices.mockResolvedValue([{
+ id: "device-android",
+ installationId: "installation-android",
+ platform: "android" as const,
+ providerEnvironment: "production" as const,
+ providerTokenEncrypted: "ciphertext-android",
+ }])
+ deps.sendFcm.mockRejectedValue(new PushProviderError(
+ "fcm",
+ "provider_send",
+ 418,
+ "sensitive-provider-reason",
+ "SensitiveInternalError",
+ ))
+
+ await processMobilePush({} as never, env, task, deps)
+
+ expect(mockLogWarn).toHaveBeenCalledWith("mobile_push_device_failed", {
+ messageId: "message-1",
+ deviceId: "device-android",
+ provider: "fcm",
+ stage: "provider_send",
+ errorName: "unknown",
+ durationMs: expect.any(Number),
+ })
+ const logged = JSON.stringify(mockLogWarn.mock.calls)
+ expect(logged).not.toContain("418")
+ expect(logged).not.toContain("sensitive-provider-reason")
+ expect(logged).not.toContain("SensitiveInternalError")
+ })
+
+ it.each([
+ ["apns", "credential_fingerprint", "sendApns", undefined],
+ ["apns", "key_import", "sendApns", undefined],
+ ["apns", "sign", "sendApns", undefined],
+ ["apns", "provider_send", "sendApns", 503],
+ ["fcm", "key_import", "createFcmAccessToken", undefined],
+ ["fcm", "sign", "createFcmAccessToken", undefined],
+ ["fcm", "oauth_fetch", "createFcmAccessToken", 503],
+ ["fcm", "provider_send", "sendFcm", 503],
+ ] as const)(
+ "logs only approved keys for %s/%s failures",
+ async (provider, stage, dependency, httpStatus) => {
+ const deps = dependencies()
+ const listedDevices = await deps.listDevices()
+ deps.listDevices.mockResolvedValue(listedDevices.filter(
+ (device) => device.platform === (provider === "apns" ? "ios" : "android"),
+ ))
+ const failure = new PushProviderError(
+ provider,
+ stage as PushProviderStage,
+ httpStatus,
+ "sensitive-stage-reason",
+ )
+ deps[dependency].mockRejectedValue(failure)
+
+ await expect(processMobilePush({} as never, env, task, deps)).resolves.toMatchObject({
+ outcome: "processed",
+ attempted: 1,
+ failed: 1,
+ })
+
+ const expectedDetails = {
+ messageId: "message-1",
+ deviceId: provider === "apns" ? "device-ios" : "device-android",
+ provider,
+ stage,
+ errorName: "PushProviderError",
+ ...(httpStatus === undefined ? {} : { httpStatus }),
+ durationMs: expect.any(Number),
+ }
+ expect(mockLogWarn).toHaveBeenCalledWith("mobile_push_device_failed", expectedDetails)
+ expect(Object.keys(mockLogWarn.mock.calls[0]![1]).sort())
+ .toEqual(Object.keys(expectedDetails).sort())
+ const logged = JSON.stringify(mockLogWarn.mock.calls)
+ for (const sentinel of [
+ "sensitive-stage-reason",
+ "private message body",
+ "plain-ciphertext",
+ "encryption-key",
+ "access-token",
+ ]) {
+ expect(logged).not.toContain(sentinel)
+ }
+ },
+ )
+
it("skips when no active devices remain", async () => {
const deps = dependencies()
deps.listDevices.mockResolvedValue([])
diff --git a/src/queue-worker/src/mobile-push.ts b/src/queue-worker/src/mobile-push.ts
index 129ec1997..6c8ec2fe2 100644
--- a/src/queue-worker/src/mobile-push.ts
+++ b/src/queue-worker/src/mobile-push.ts
@@ -6,6 +6,11 @@ import {
createFcmAccessToken,
sendFcmNotification,
} from "./providers/fcm"
+import {
+ getPushProviderDiagnostic,
+ type PushProvider,
+ type PushProviderStage,
+} from "./providers/diagnostics"
const log = createLogger({ service: "queue-worker-mobile-push" })
@@ -93,11 +98,14 @@ export async function processMobilePush(
let fcmAccessToken: Promise<string> | undefined
const results = await Promise.all(devices.map(async (device) => {
const startedAt = Date.now()
+ const provider: PushProvider = device.platform === "ios" ? "apns" : "fcm"
+ let stage: PushProviderStage = "decrypt"
try {
const providerToken = dependencies.decrypt(
device.providerTokenEncrypted,
required(env.ENCRYPTION_KEY, "ENCRYPTION_KEY"),
)
+ stage = provider === "apns" ? "credential_fingerprint" : "key_import"
const providerResult = device.platform === "ios"
? await dependencies.sendApns({
providerToken,
@@ -141,13 +149,11 @@ export async function processMobilePush(
})
return providerResult.outcome
} catch (error) {
+ const diagnostic = getPushProviderDiagnostic(error, provider, stage)
log.warn("mobile_push_device_failed", {
- kind: task.kind,
messageId: task.messageId,
- userId: task.userId,
deviceId: device.id,
- platform: device.platform,
- errorName: error instanceof Error ? error.name : "unknown",
+ ...diagnostic,
durationMs: Date.now() - startedAt,
})
return "failed" as const
diff --git a/src/queue-worker/src/providers/apns.test.ts b/src/queue-worker/src/providers/apns.test.ts
index cc7a5905d..82ec81da1 100644
--- a/src/queue-worker/src/providers/apns.test.ts
+++ b/src/queue-worker/src/providers/apns.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from "vitest"
+import { afterEach, describe, expect, it, vi } from "vitest"
import {
createApnsProviderTokenProvider,
PushProviderError,
@@ -52,11 +52,15 @@ async function createEcPrivateKeyPem(): Promise<string> {
}
describe("APNs adapter", () => {
+ afterEach(() => vi.restoreAllMocks())
+
it("signs a real provider JWT and uses the default send dependencies", async () => {
const originalFetch = globalThis.fetch
- const fetchMock = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => (
- new Response(null, { status: 200 })
- ))
+ let fetchReceiver: unknown = Symbol("unset")
+ const fetchMock = vi.fn(function (this: unknown, _input: RequestInfo | URL, _init?: RequestInit) {
+ fetchReceiver = this
+ return Promise.resolve(new Response(null, { status: 200 }))
+ })
globalThis.fetch = fetchMock as typeof fetch
vi.resetModules()
@@ -79,6 +83,7 @@ describe("APNs adapter", () => {
iat: expect.any(Number),
})
expect(signaturePart).not.toBe("")
+ expect(fetchReceiver).toBeUndefined()
} finally {
globalThis.fetch = originalFetch
vi.resetModules()
@@ -137,12 +142,77 @@ describe("APNs adapter", () => {
})
await expect(result).rejects.toEqual(expect.objectContaining<Partial<PushProviderError>>({
provider: "apns",
+ stage: "provider_send",
status: 429,
reason: "TooManyRequests",
}))
await expect(result).rejects.not.toThrow(/provider-token|Hello/)
})
+ it("classifies credential fingerprint failures without retaining the raw error", async () => {
+ const getProviderToken = createApnsProviderTokenProvider()
+ const result = sendApnsNotification({
+ ...input(),
+ config: { ...input().config, privateKey: "sensitive-invalid-***" },
+ }, {
+ fetch: vi.fn() as typeof fetch,
+ getProviderToken,
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "apns",
+ stage: "credential_fingerprint",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-invalid/)
+ })
+
+ it("classifies provider key import failures", async () => {
+ const getProviderToken = createApnsProviderTokenProvider()
+ const result = sendApnsNotification(input(), {
+ fetch: vi.fn() as typeof fetch,
+ getProviderToken,
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "apns",
+ stage: "key_import",
+ })
+ })
+
+ it("classifies provider signing failures", async () => {
+ const privateKey = await createEcPrivateKeyPem()
+ vi.spyOn(crypto.subtle, "sign").mockRejectedValueOnce(new TypeError("sensitive-sign"))
+ const getProviderToken = createApnsProviderTokenProvider()
+ const result = sendApnsNotification({
+ ...input(),
+ config: { ...input().config, privateKey },
+ }, {
+ fetch: vi.fn() as typeof fetch,
+ getProviderToken,
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "apns",
+ stage: "sign",
+ errorName: "TypeError",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-sign/)
+ })
+
+ it("classifies provider transport failures", async () => {
+ const result = sendApnsNotification(input(), {
+ fetch: vi.fn(async () => { throw new TypeError("sensitive-send") }) as typeof fetch,
+ getProviderToken: vi.fn(async () => "signed-token"),
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "apns",
+ stage: "provider_send",
+ errorName: "TypeError",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-send/)
+ })
+
it("reuses one provider token across device/topic/environment sends until refresh", async () => {
let now = 1_700_000_000_000
const createProviderToken = vi.fn(async (_config, issuedAt = 0) => (
diff --git a/src/queue-worker/src/providers/apns.ts b/src/queue-worker/src/providers/apns.ts
index c35f22a5e..4427c6ddb 100644
--- a/src/queue-worker/src/providers/apns.ts
+++ b/src/queue-worker/src/providers/apns.ts
@@ -1,4 +1,10 @@
import type { PushNotificationPayload } from "../notification-payload"
+import {
+ PushProviderError,
+ runPushProviderStage,
+} from "./diagnostics"
+
+export { PushProviderError } from "./diagnostics"
interface ApnsConfig {
teamId: string
@@ -21,17 +27,6 @@ export interface ApnsSendInput {
export type PushProviderResult = { outcome: "sent" | "invalid-token" }
-export class PushProviderError extends Error {
- constructor(
- readonly provider: "apns" | "fcm",
- readonly status: number,
- readonly reason: string,
- ) {
- super(`${provider} request failed (${status}:${reason})`)
- this.name = "PushProviderError"
- }
-}
-
function base64Url(value: string | ArrayBuffer | Uint8Array): string {
const bytes = typeof value === "string"
? new TextEncoder().encode(value)
@@ -61,28 +56,34 @@ async function createApnsProviderToken(
iat: Math.floor(now / 1000),
}))
const signingInput = `${header}.${claims}`
- const key = await crypto.subtle.importKey(
- "pkcs8",
- pemToBytes(config.privateKey),
- { name: "ECDSA", namedCurve: "P-256" },
- false,
- ["sign"],
- )
- const signature = await crypto.subtle.sign(
- { name: "ECDSA", hash: "SHA-256" },
- key,
- new TextEncoder().encode(signingInput),
- )
+ const key = await runPushProviderStage("apns", "key_import", async () => (
+ crypto.subtle.importKey(
+ "pkcs8",
+ pemToBytes(config.privateKey),
+ { name: "ECDSA", namedCurve: "P-256" },
+ false,
+ ["sign"],
+ )
+ ))
+ const signature = await runPushProviderStage("apns", "sign", async () => (
+ crypto.subtle.sign(
+ { name: "ECDSA", hash: "SHA-256" },
+ key,
+ new TextEncoder().encode(signingInput),
+ )
+ ))
return `${signingInput}.${base64Url(signature)}`
}
async function createCredentialFingerprint(config: ApnsTokenConfig): Promise<string> {
- const encoded = new TextEncoder().encode(JSON.stringify([
- config.teamId,
- config.keyId,
- base64Url(pemToBytes(config.privateKey)),
- ]))
- return base64Url(await crypto.subtle.digest("SHA-256", encoded))
+ return runPushProviderStage("apns", "credential_fingerprint", async () => {
+ const encoded = new TextEncoder().encode(JSON.stringify([
+ config.teamId,
+ config.keyId,
+ base64Url(pemToBytes(config.privateKey)),
+ ]))
+ return base64Url(await crypto.subtle.digest("SHA-256", encoded))
+ })
}
type ApnsProviderTokenDependencies = {
@@ -213,7 +214,7 @@ type ApnsDependencies = {
}
const defaultDependencies: ApnsDependencies = {
- fetch,
+ fetch: (...args) => fetch(...args),
getProviderToken: getApnsProviderToken,
}
@@ -225,32 +226,34 @@ export async function sendApnsNotification(
const host = input.providerEnvironment === "sandbox"
? "https://api.sandbox.push.apple.com"
: "https://api.push.apple.com"
- const response = await dependencies.fetch(
- `${host}/3/device/${encodeURIComponent(input.providerToken)}`,
- {
- method: "POST",
- headers: {
- authorization: `bearer ${authorization}`,
- "content-type": "application/json",
- "apns-topic": input.config.topic,
- "apns-push-type": "alert",
- "apns-priority": "10",
- "apns-id": input.payload.notificationId,
- "apns-collapse-id": input.payload.notificationId,
- },
- body: JSON.stringify({
- aps: {
- alert: {
- title: input.payload.title,
- body: input.payload.body,
- },
- sound: "default",
- "thread-id": input.payload.route.targetId,
+ const response = await runPushProviderStage("apns", "provider_send", async () => (
+ dependencies.fetch(
+ `${host}/3/device/${encodeURIComponent(input.providerToken)}`,
+ {
+ method: "POST",
+ headers: {
+ authorization: `bearer ${authorization}`,
+ "content-type": "application/json",
+ "apns-topic": input.config.topic,
+ "apns-push-type": "alert",
+ "apns-priority": "10",
+ "apns-id": input.payload.notificationId,
+ "apns-collapse-id": input.payload.notificationId,
},
- ...input.payload.route,
- }),
- },
- )
+ body: JSON.stringify({
+ aps: {
+ alert: {
+ title: input.payload.title,
+ body: input.payload.body,
+ },
+ sound: "default",
+ "thread-id": input.payload.route.targetId,
+ },
+ ...input.payload.route,
+ }),
+ },
+ )
+ ))
if (response.ok) return { outcome: "sent" }
const body = await response.json().catch(() => null) as { reason?: unknown } | null
@@ -258,5 +261,5 @@ export async function sendApnsNotification(
if (["BadDeviceToken", "DeviceTokenNotForTopic", "Unregistered"].includes(reason)) {
return { outcome: "invalid-token" }
}
- throw new PushProviderError("apns", response.status, reason)
+ throw new PushProviderError("apns", "provider_send", response.status, reason)
}
diff --git a/src/queue-worker/src/providers/diagnostics.ts b/src/queue-worker/src/providers/diagnostics.ts
new file mode 100644
index 000000000..ee6e27546
--- /dev/null
+++ b/src/queue-worker/src/providers/diagnostics.ts
@@ -0,0 +1,104 @@
+export type PushProvider = "apns" | "fcm"
+
+export type PushProviderStage =
+ | "decrypt"
+ | "credential_fingerprint"
+ | "key_import"
+ | "sign"
+ | "oauth_fetch"
+ | "provider_send"
+
+const SAFE_ERROR_NAMES = new Set([
+ "AbortError",
+ "DataError",
+ "DOMException",
+ "Error",
+ "InvalidAccessError",
+ "NetworkError",
+ "NotSupportedError",
+ "OperationError",
+ "PushProviderError",
+ "RangeError",
+ "SyntaxError",
+ "TypeError",
+])
+
+const SAFE_HTTP_STATUSES = new Set([
+ 400,
+ 401,
+ 403,
+ 404,
+ 405,
+ 408,
+ 409,
+ 410,
+ 413,
+ 429,
+ 500,
+ 502,
+ 503,
+ 504,
+])
+
+const HTTP_STAGES = new Set<PushProviderStage>(["oauth_fetch", "provider_send"])
+
+function safeErrorName(error: unknown): string {
+ if (!(error instanceof Error)) return "unknown"
+ return SAFE_ERROR_NAMES.has(error.name) ? error.name : "unknown"
+}
+
+export class PushProviderError extends Error {
+ readonly errorName: string
+
+ constructor(
+ readonly provider: PushProvider,
+ readonly stage: PushProviderStage,
+ readonly status?: number,
+ readonly reason?: string,
+ errorName = "PushProviderError",
+ ) {
+ super(`${provider} failed at ${stage}`)
+ this.name = "PushProviderError"
+ this.errorName = SAFE_ERROR_NAMES.has(errorName) ? errorName : "unknown"
+ }
+}
+
+export async function runPushProviderStage<T>(
+ provider: PushProvider,
+ stage: PushProviderStage,
+ operation: () => Promise<T>,
+): Promise<T> {
+ try {
+ return await operation()
+ } catch (error) {
+ if (error instanceof PushProviderError) throw error
+ throw new PushProviderError(provider, stage, undefined, undefined, safeErrorName(error))
+ }
+}
+
+export function getPushProviderDiagnostic(
+ error: unknown,
+ fallbackProvider: PushProvider,
+ fallbackStage: PushProviderStage,
+): {
+ provider: PushProvider
+ stage: PushProviderStage
+ errorName: string
+ httpStatus?: number
+} {
+ const providerError = error instanceof PushProviderError ? error : undefined
+ const status = providerError?.status
+ const stage = providerError?.stage ?? fallbackStage
+ return {
+ provider: providerError?.provider ?? fallbackProvider,
+ stage,
+ errorName: providerError?.errorName ?? safeErrorName(error),
+ ...(
+ status !== undefined
+ && HTTP_STAGES.has(stage)
+ && SAFE_HTTP_STATUSES.has(status)
+ ? { httpStatus: status }
+ : {}
+ ),
+ }
+}
diff --git a/src/queue-worker/src/providers/fcm.test.ts b/src/queue-worker/src/providers/fcm.test.ts
index 543c53c5c..16ee4969b 100644
--- a/src/queue-worker/src/providers/fcm.test.ts
+++ b/src/queue-worker/src/providers/fcm.test.ts
@@ -26,12 +26,17 @@ async function createRsaPrivateKeyPem(): Promise<string> {
}
describe("FCM HTTP v1 adapter", () => {
- afterEach(() => vi.unstubAllGlobals())
+ afterEach(() => {
+ vi.restoreAllMocks()
+ vi.unstubAllGlobals()
+ })
it("signs a real service-account JWT and uses the default fetch dependency", async () => {
- const fetchMock = vi.fn(async (_input: RequestInfo | URL, _init?: RequestInit) => (
- Response.json({ access_token: "access-token" })
- ))
+ let fetchReceiver: unknown = Symbol("unset")
+ const fetchMock = vi.fn(function (this: unknown, _input: RequestInfo | URL, _init?: RequestInit) {
+ fetchReceiver = this
+ return Promise.resolve(Response.json({ access_token: "access-token" }))
+ })
vi.stubGlobal("fetch", fetchMock)
const before = Math.floor(Date.now() / 1000)
@@ -62,6 +67,7 @@ describe("FCM HTTP v1 adapter", () => {
expect(claims.iat).toBeGreaterThanOrEqual(before)
expect(claims.exp).toBe(claims.iat + 3600)
expect(signaturePart).not.toBe("")
+ expect(fetchReceiver).toBeUndefined()
})
it("exchanges a service-account assertion for a short-lived access token", async () => {
@@ -92,7 +98,61 @@ describe("FCM HTTP v1 adapter", () => {
}, {
fetch: vi.fn(async () => new Response("not json", { status: 503 })) as typeof fetch,
createAssertion: vi.fn(async () => "signed-assertion"),
- })).rejects.toMatchObject({ provider: "fcm", status: 503, reason: "oauth" })
+ })).rejects.toMatchObject({
+ provider: "fcm",
+ stage: "oauth_fetch",
+ status: 503,
+ reason: "oauth",
+ })
+ })
+
+ it("classifies service-account key import failures", async () => {
+ const result = createFcmAccessToken({
+ projectId: "test-project",
+ clientEmail: "[email protected]",
+ privateKey: "sensitive-invalid-key",
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "fcm",
+ stage: "key_import",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-invalid-key/)
+ })
+
+ it("classifies service-account signing failures", async () => {
+ const privateKey = await createRsaPrivateKeyPem()
+ vi.spyOn(crypto.subtle, "sign").mockRejectedValueOnce(new TypeError("sensitive-sign"))
+ const result = createFcmAccessToken({
+ projectId: "test-project",
+ clientEmail: "[email protected]",
+ privateKey,
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "fcm",
+ stage: "sign",
+ errorName: "TypeError",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-sign/)
+ })
+
+ it("classifies OAuth transport failures", async () => {
+ const result = createFcmAccessToken({
+ projectId: "test-project",
+ clientEmail: "[email protected]",
+ privateKey: "unused",
+ }, {
+ fetch: vi.fn(async () => { throw new TypeError("sensitive-oauth") }) as typeof fetch,
+ createAssertion: vi.fn(async () => "signed-assertion"),
+ })
+
+ await expect(result).rejects.toMatchObject({
+ provider: "fcm",
+ stage: "oauth_fetch",
+ errorName: "TypeError",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-oauth/)
})
it("sends notification/data payloads with deterministic collapse semantics", async () => {
@@ -169,10 +229,31 @@ describe("FCM HTTP v1 adapter", () => {
payload,
config: { projectId: "test-project" },
}, fetchMock as typeof fetch)
- await expect(result).rejects.toMatchObject({ provider: "fcm", status: 503, reason: "UNAVAILABLE" })
+ await expect(result).rejects.toMatchObject({
+ provider: "fcm",
+ stage: "provider_send",
+ status: 503,
+ reason: "UNAVAILABLE",
+ })
await expect(result).rejects.not.toThrow(/provider-token|Hello/)
})
+ it("classifies provider transport failures", async () => {
+ const result = sendFcmNotification({
+ providerToken: "provider-token",
+ accessToken: "access-token",
+ payload,
+ config: { projectId: "test-project" },
+ }, vi.fn(async () => { throw new TypeError("sensitive-send") }) as typeof fetch)
+
+ await expect(result).rejects.toMatchObject({
+ provider: "fcm",
+ stage: "provider_send",
+ errorName: "TypeError",
+ })
+ await expect(result).rejects.not.toThrow(/sensitive-send/)
+ })
+
it("uses an unknown reason for a malformed provider error", async () => {
const fetchMock = vi.fn(async () => new Response("not json", { status: 418 }))
@@ -183,6 +264,7 @@ describe("FCM HTTP v1 adapter", () => {
config: { projectId: "test-project" },
}, fetchMock as typeof fetch)).rejects.toMatchObject({
provider: "fcm",
+ stage: "provider_send",
status: 418,
reason: "unknown",
})
diff --git a/src/queue-worker/src/providers/fcm.ts b/src/queue-worker/src/providers/fcm.ts
index e4387391b..479c8747d 100644
--- a/src/queue-worker/src/providers/fcm.ts
+++ b/src/queue-worker/src/providers/fcm.ts
@@ -1,5 +1,9 @@
import type { PushNotificationPayload } from "../notification-payload"
-import { PushProviderError, type PushProviderResult } from "./apns"
+import type { PushProviderResult } from "./apns"
+import {
+ PushProviderError,
+ runPushProviderStage,
+} from "./diagnostics"
export interface FcmConfig {
projectId: string
@@ -40,18 +44,22 @@ async function createFcmServiceAccountAssertion(
exp: issuedAt + 3600,
}))
const signingInput = `${header}.${claims}`
- const key = await crypto.subtle.importKey(
- "pkcs8",
- pemToBytes(config.privateKey),
- { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
- false,
- ["sign"],
- )
- const signature = await crypto.subtle.sign(
- "RSASSA-PKCS1-v1_5",
- key,
- new TextEncoder().encode(signingInput),
- )
+ const key = await runPushProviderStage("fcm", "key_import", async () => (
+ crypto.subtle.importKey(
+ "pkcs8",
+ pemToBytes(config.privateKey),
+ { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+ false,
+ ["sign"],
+ )
+ ))
+ const signature = await runPushProviderStage("fcm", "sign", async () => (
+ crypto.subtle.sign(
+ "RSASSA-PKCS1-v1_5",
+ key,
+ new TextEncoder().encode(signingInput),
+ )
+ ))
return `${signingInput}.${base64Url(signature)}`
}
@@ -63,22 +71,26 @@ type FcmTokenDependencies = {
export async function createFcmAccessToken(
config: FcmConfig,
dependencies: FcmTokenDependencies = {
- fetch,
+ fetch: (...args) => fetch(...args),
createAssertion: createFcmServiceAccountAssertion,
},
): Promise<string> {
- const assertion = await dependencies.createAssertion(config)
- const response = await dependencies.fetch("https://oauth2.googleapis.com/token", {
- method: "POST",
- headers: { "content-type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({
- grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
- assertion,
- }),
- })
+ const assertion = await runPushProviderStage("fcm", "sign", async () => (
+ dependencies.createAssertion(config)
+ ))
+ const response = await runPushProviderStage("fcm", "oauth_fetch", async () => (
+ dependencies.fetch("https://oauth2.googleapis.com/token", {
+ method: "POST",
+ headers: { "content-type": "application/x-www-form-urlencoded" },
+ body: new URLSearchParams({
+ grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+ assertion,
+ }),
+ })
+ ))
const body = await response.json().catch(() => null) as { access_token?: unknown } | null
if (!response.ok || typeof body?.access_token !== "string" || !body.access_token) {
- throw new PushProviderError("fcm", response.status, "oauth")
+ throw new PushProviderError("fcm", "oauth_fetch", response.status, "oauth")
}
return body.access_token
}
@@ -92,7 +104,7 @@ export async function sendFcmNotification(
},
fetchImpl: typeof fetch = fetch,
): Promise<PushProviderResult> {
- const response = await fetchImpl(
+ const response = await runPushProviderStage("fcm", "provider_send", async () => fetchImpl(
`https://fcm.googleapis.com/v1/projects/${encodeURIComponent(input.config.projectId)}/messages:send`,
{
method: "POST",
@@ -118,7 +130,7 @@ export async function sendFcmNotification(
},
}),
},
- )
+ ))
if (response.ok) return { outcome: "sent" }
const body = await response.json().catch(() => null) as {
@@ -141,5 +153,5 @@ export async function sendFcmNotification(
) {
return { outcome: "invalid-token" }
}
- throw new PushProviderError("fcm", response.status, reason)
+ throw new PushProviderError("fcm", "provider_send", response.status, reason)
}