davideandClaude Opus 5
d8f334007b
Il testo della notifica viaggia ora cifrato dentro la push (aes128gcm, RFC
8188/8291) invece di essere recuperato dal service worker con una fetch al
risveglio. Era quella fetch a non chiudersi in tempo: ad app chiusa il browser
tiene vivo il worker pochi secondi, showNotification non veniva mai chiamata e
non compariva niente, mentre ad app aperta con la rete calda sembrava tutto a
posto. La POST porta anche Urgency: high, che chiede la consegna immediata
invece di far accumulare i messaggi fino al risveglio del dispositivo.
Cadono i pezzi che esistevano solo per rimediare al payload vuoto: la route
push-messaggio, la coda promemoria_push con la sua scadenza a 12 ore,
messaggioPalloniOggi() e il timeout nel worker. Tutti e tre i mittenti avevano
gia il testo pronto prima di inviare.
Il worker si aggiorna da solo all'avvio e a ogni ritorno in primo piano
(mantieniWorkerPushAggiornato): nella webapp installata quello vecchio puo
sopravvivere a lungo, e senza questo un dispositivo resterebbe fermo alla
versione che va a cercare il testo in rete.
Profilo -> Opzioni ha "Mandami una notifica di prova", visibile solo a notifiche
attive: manda una push a questo dispositivo e riporta stato HTTP, corpo della
risposta e se l'endpoint risulta davvero in push_subscriptions. Senza, "non
arriva" era cieco: ogni prova richiedeva un admin, un evento nello stato giusto
e una seconda persona, e la risposta del servizio push veniva buttata via.
inviaPush torna { stato, corpo } e logga il corpo sui rifiuti.
Dalle prove sul campo: a parita di server, iPhone installato da Home riceve ad
app chiusa. Su Android installato come webapp resta da verificare: il WebAPK e
un'app Android a se, con permesso notifiche (Android 13+) e voce batteria
distinti da quelli di Chrome. Annotato nei limiti noti.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
83 lines
3.1 KiB
TypeScript
83 lines
3.1 KiB
TypeScript
/** Esegue il worker reale senza pagina, DOM, rete o stato lasciato dall'app. */
|
|
import assert from "node:assert/strict";
|
|
import { readFileSync } from "node:fs";
|
|
import { runInNewContext } from "node:vm";
|
|
|
|
const codice = readFileSync(new URL("../../public/push-sw.js", import.meta.url), "utf8");
|
|
type Evento = { data?: { json: () => unknown } | null; waitUntil: (p: Promise<unknown>) => void };
|
|
|
|
function avviaWorker() {
|
|
const listener = new Map<string, (event: Evento) => void>();
|
|
const notifiche: Array<{ titolo: string; opzioni: NotificationOptions }> = [];
|
|
let completa: (() => void) | undefined;
|
|
const mostrata = new Promise<void>((resolve) => (completa = resolve));
|
|
const installata = Promise.resolve();
|
|
const attivata = Promise.resolve();
|
|
runInNewContext(codice, {
|
|
self: {
|
|
addEventListener: (nome: string, callback: (event: Evento) => void) =>
|
|
listener.set(nome, callback),
|
|
skipWaiting: () => installata,
|
|
clients: {
|
|
claim: () => attivata,
|
|
matchAll: () => assert.fail("la push deve funzionare senza consultare finestre aperte"),
|
|
},
|
|
registration: {
|
|
showNotification(titolo: string, opzioni: NotificationOptions) {
|
|
notifiche.push({ titolo, opzioni });
|
|
return mostrata;
|
|
},
|
|
},
|
|
},
|
|
fetch: () => assert.fail("nessuna rete per mostrare la notifica"),
|
|
});
|
|
return { listener, notifiche, mostrata, completa: completa!, installata, attivata };
|
|
}
|
|
|
|
// L'installazione e l'attivazione tengono vivo il worker fino al completamento.
|
|
const avvio = avviaWorker();
|
|
for (const [nome, promessa] of [
|
|
["install", avvio.installata],
|
|
["activate", avvio.attivata],
|
|
] as const) {
|
|
let attesa: Promise<unknown> | undefined;
|
|
avvio.listener.get(nome)!({ waitUntil: (p) => (attesa = p) });
|
|
assert.equal(attesa, promessa, `${nome}: la promessa è collegata a waitUntil`);
|
|
await attesa;
|
|
}
|
|
|
|
const casi: Array<{ data: Evento["data"]; titolo: string; testo: string }> = [
|
|
{
|
|
data: { json: () => ({ title: "🏐 Palloni", body: "Sabato tocca a te." }) },
|
|
titolo: "🏐 Palloni",
|
|
testo: "Sabato tocca a te.",
|
|
},
|
|
{ data: null, titolo: "CrAPP", testo: "Apri l'app per i dettagli." },
|
|
{
|
|
data: {
|
|
json: () => {
|
|
throw new SyntaxError("payload non JSON");
|
|
},
|
|
},
|
|
titolo: "CrAPP",
|
|
testo: "Apri l'app per i dettagli.",
|
|
},
|
|
];
|
|
for (const { data, titolo, testo } of casi) {
|
|
// Nuovo contesto a ogni consegna: simula il risveglio dopo la terminazione del worker.
|
|
const worker = avviaWorker();
|
|
let attesa: Promise<unknown> | undefined;
|
|
worker.listener.get("push")!({ data, waitUntil: (p) => (attesa = p) });
|
|
assert.equal(worker.notifiche.length, 1, "mostra subito una notifica anche senza l'app");
|
|
assert.equal(attesa, worker.mostrata, "waitUntil copre tutta showNotification");
|
|
const notifica = worker.notifiche[0]!;
|
|
assert.equal(notifica.titolo, titolo);
|
|
assert.equal(notifica.opzioni.body, testo);
|
|
assert.ok(notifica.opzioni.tag, "il tag permette di sostituire la notifica precedente");
|
|
assert.equal(notifica.opzioni.renotify, true, "anche una sostituzione avvisa l'utente");
|
|
worker.completa();
|
|
await attesa;
|
|
}
|
|
|
|
console.log("push-sw: ok");
|