fix: send same-day meteo alert updates, not only tomorrow's forecast

The meteo-alerts task only queried the next-day view of the bulletin, so an
escalation for the current day was never delivered: the same bulletin can be
green tomorrow yet orange today (e.g. zona D1 upgraded from yellow to orange
for temporali).

Now both today and tomorrow are evaluated each tick. De-dup keys on
(bulletin, referenced date) rather than the bulletin number alone, so each
(bulletin, day) is sent once and an escalation (a new bulletin number for the
same date) re-sends. Today's message uses an "Aggiornamento allerta di oggi"
heading; tomorrow's is unchanged.

Author: nicomontanari

src/services/meteo-alerts.ts

@@ -57,6 +57,12 @@ export type MeteoAlertZoneData = {
 
 export type MeteoAlert = BaseMeteoAlert & MeteoAlertZoneData
 
+export const getTodayMeteoAlert = async (): Promise<MeteoAlert | undefined> => {
+    const today = customMoment().format('YYYY-MM-DD HH:mm')
+
+    return getMeteoAlert(today)
+}
+
 export const getTomorrowMeteoAlert = async (): Promise<MeteoAlert | undefined> => {
     const tomorrow = customMoment().add(1, 'day').format('YYYY-MM-DD HH:mm')
 

src/tasks/meteo-alerts.ts

@@ -1,36 +1,32 @@
-import { sendNewTomorrowAlertMessage } from '../utilities/telegram'
+import { AlertDay, sendMeteoAlertMessage } from '../utilities/telegram'
 import { createAlertReport, getAlertReportByNumber } from '../models/alert-report'
-import { getTomorrowMeteoAlert } from '../services/meteo-alerts'
+import { getTodayMeteoAlert, getTomorrowMeteoAlert, MeteoAlert } from '../services/meteo-alerts'
 import { parseMeteoAlert, ParsedMeteoAlert } from '../utilities/meteo-alerts'
+import customMoment from '../custom-components/custom-moment'
 import { config } from '../config/config'
 import logger from '../logger'
 
 const log = logger.child({ task: 'meteo-alerts' })
 
-export const runMeteoAlertCheck = async (): Promise<ParsedMeteoAlert | undefined> => {
-    const tomorrowAlert = await getTomorrowMeteoAlert()
-
-    if (!tomorrowAlert) {
-        log.info({ event: 'no-tomorrow-alert' }, 'No alert published for tomorrow')
-        return undefined
-    }
+// A bulletin covers a multi-day window and carries a FIXED criticality per day, so the same
+// document (e.g. allerta075/2026) is green tomorrow yet orange today. De-dup therefore has to key
+// on (bulletin, referenced date), not the bulletin number alone. An escalation arrives as a NEW
+// bulletin number for the same date, so it re-sends; re-observing the same bulletin does not.
+const reportKey = (id: string, date: string): string => `${id}@${date}`
 
-    const parsedAlert = parseMeteoAlert(tomorrowAlert, config.alert_zone)
+const handleDayAlert = async (raw: MeteoAlert, day: AlertDay, date: string): Promise<ParsedMeteoAlert> => {
+    const parsedAlert = parseMeteoAlert(raw, config.alert_zone)
+    const key = reportKey(parsedAlert.id, date)
 
-    // We already handled this bulletin: its report row exists. The existence check (instead of an
-    // INSERT ... ON CONFLICT) makes the de-dup independent of any unique constraint on the table.
-    const existing = await getAlertReportByNumber(parsedAlert.id)
+    const existing = await getAlertReportByNumber(key)
 
     if (existing) {
-        log.info(
-            { event: 'already-handled', reportNumber: parsedAlert.id, critic: parsedAlert.isCritic },
-            'Bulletin already handled'
-        )
+        log.info({ event: 'already-handled', reportNumber: key, critic: parsedAlert.isCritic }, 'Bulletin already handled')
         return parsedAlert
     }
 
     const report = {
-        report_number: parsedAlert.id,
+        report_number: key,
         is_critic: parsedAlert.isCritic,
         estofex_sent: false,
         pretemp_sent: false,
@@ -43,21 +39,40 @@ export const runMeteoAlertCheck = async (): Promise<ParsedMeteoAlert | undefined
     // Non-critical bulletin: just record it (so pretemp/estofex see the latest report); no message.
     if (!parsedAlert.isCritic) {
         await createAlertReport(report)
-        log.info({ event: 'recorded-non-critical', reportNumber: parsedAlert.id }, 'Recorded non-critical bulletin')
+        log.info({ event: 'recorded-non-critical', reportNumber: key }, 'Recorded non-critical bulletin')
         return parsedAlert
     }
 
-    // Critical bulletin: send the message FIRST and record it only once the send succeeds. This way
-    // a failed send is logged AND retried on the next tick, instead of being silently de-duplicated
-    // forever (the report row would otherwise mark the bulletin as "seen" even though nothing was
-    // delivered).
+    // Critical bulletin: send FIRST and record only once the send succeeds, so a failed send is
+    // retried on the next tick instead of being silently de-duplicated forever.
     try {
-        await sendNewTomorrowAlertMessage(parsedAlert)
+        await sendMeteoAlertMessage(parsedAlert, day)
         await createAlertReport(report)
-        log.info({ event: 'sent', reportNumber: parsedAlert.id }, 'Meteo alert sent')
+        log.info({ event: 'sent', reportNumber: key, day }, 'Meteo alert sent')
     } catch (err) {
-        log.error({ err, alertId: parsedAlert.id }, 'Failed to send meteo alert; will retry next tick')
+        log.error({ err, alertId: key }, 'Failed to send meteo alert; will retry next tick')
     }
 
     return parsedAlert
 }
+
+export const runMeteoAlertCheck = async (): Promise<ParsedMeteoAlert | undefined> => {
+    const todayDate = customMoment().format('YYYY-MM-DD')
+    const tomorrowDate = customMoment().add(1, 'day').format('YYYY-MM-DD')
+
+    // Process today first so the tomorrow row is the most recent alert_reports row: pretemp/estofex
+    // key off getLastAlertReport and are inherently next-day outlooks.
+    const todayRaw = await getTodayMeteoAlert()
+    const todayAlert = todayRaw ? await handleDayAlert(todayRaw, 'today', todayDate) : undefined
+    if (!todayRaw) {
+        log.info({ event: 'no-today-alert' }, 'No alert published for today')
+    }
+
+    const tomorrowRaw = await getTomorrowMeteoAlert()
+    const tomorrowAlert = tomorrowRaw ? await handleDayAlert(tomorrowRaw, 'tomorrow', tomorrowDate) : undefined
+    if (!tomorrowRaw) {
+        log.info({ event: 'no-tomorrow-alert' }, 'No alert published for tomorrow')
+    }
+
+    return tomorrowAlert ?? todayAlert
+}

src/utilities/telegram.ts

@@ -14,7 +14,9 @@ const thresholdLabel: Record<ThresholdCrossing['threshold']['key'], string> = {
     soglia3: 'soglia 3',
 }
 
-export const sendNewTomorrowAlertMessage = async (alert: ParsedMeteoAlert) => {
+export type AlertDay = 'today' | 'tomorrow'
+
+export const sendMeteoAlertMessage = async (alert: ParsedMeteoAlert, day: AlertDay = 'tomorrow') => {
     const criticDataMessage = Object.keys(alert.criticZoneData)
         .map((key) => {
             const color = alert.criticZoneData[key]
@@ -30,7 +32,10 @@ export const sendNewTomorrowAlertMessage = async (alert: ParsedMeteoAlert) => {
         })
         .join('\n')
 
-    const textMessage = `⚠️ Nuova allerta meteo per domani!
+    const heading =
+        day === 'today' ? '⚠️ Aggiornamento allerta meteo di oggi!' : '⚠️ Nuova allerta meteo per domani!'
+
+    const textMessage = `${heading}
 📅 Data inizio: ${alert.dataInizio}
 📅 Data fine: ${alert.dataFine}
 ${separator}

tests/tasks/meteo-alerts.ts

@@ -24,30 +24,47 @@ const parsed = (overrides: Partial<ParsedMeteoAlert> = {}): ParsedMeteoAlert =>
     }) as ParsedMeteoAlert
 
 describe('tests/tasks/meteo-alerts', () => {
+    let getToday: SinonStub
     let getTomorrow: SinonStub
     let parse: SinonStub
     let getByNumber: SinonStub
     let create: SinonStub
     let send: SinonStub
 
     beforeEach(() => {
+        getToday = sinon.stub(alertService, 'getTodayMeteoAlert').resolves({} as never)
         getTomorrow = sinon.stub(alertService, 'getTomorrowMeteoAlert').resolves({} as never)
         parse = sinon.stub(alertUtil, 'parseMeteoAlert')
         getByNumber = sinon.stub(alertModel, 'getAlertReportByNumber').resolves(undefined)
         create = sinon.stub(alertModel, 'createAlertReport').resolves({} as never)
-        send = sinon.stub(telegram, 'sendNewTomorrowAlertMessage').resolves()
+        send = sinon.stub(telegram, 'sendMeteoAlertMessage').resolves()
     })
 
     afterEach(() => sinon.restore())
 
-    it('sends a new critical bulletin and records it only after a successful send', async () => {
+    it('sends today AND tomorrow when both are critical, recording each only after its send', async () => {
         parse.returns(parsed({ isCritic: true }))
 
         await runMeteoAlertCheck()
 
-        expect(send.calledOnce).to.equal(true)
-        expect(create.calledOnce).to.equal(true)
+        // One send + one record per day.
+        expect(send.calledTwice).to.equal(true)
+        expect(create.calledTwice).to.equal(true)
         expect(send.calledBefore(create)).to.equal(true)
+        // Today is passed 'today', tomorrow 'tomorrow'.
+        expect(send.getCall(0).args[1]).to.equal('today')
+        expect(send.getCall(1).args[1]).to.equal('tomorrow')
+    })
+
+    it('de-dups per (bulletin, date): the same bulletin keyed by today vs tomorrow yields distinct keys', async () => {
+        parse.returns(parsed({ isCritic: true }))
+
+        await runMeteoAlertCheck()
+
+        const keys = getByNumber.getCalls().map((c) => c.args[0])
+        expect(keys.length).to.equal(2)
+        expect(keys[0]).to.not.equal(keys[1])
+        expect(keys.every((k) => k.startsWith('065/2026@'))).to.equal(true)
     })
 
     it('does not resend a bulletin whose report row already exists', async () => {
@@ -66,7 +83,7 @@ describe('tests/tasks/meteo-alerts', () => {
         await runMeteoAlertCheck()
 
         expect(send.called).to.equal(false)
-        expect(create.calledOnce).to.equal(true)
+        expect(create.calledTwice).to.equal(true)
     })
 
     it('does NOT record the report when the send fails, so it retries on the next tick', async () => {
@@ -75,11 +92,11 @@ describe('tests/tasks/meteo-alerts', () => {
 
         await runMeteoAlertCheck() // must not throw
 
-        expect(send.calledOnce).to.equal(true)
         expect(create.called).to.equal(false)
     })
 
-    it('does nothing when there is no alert for tomorrow', async () => {
+    it('does nothing when neither today nor tomorrow has an alert', async () => {
+        getToday.resolves(undefined)
         getTomorrow.resolves(undefined)
 
         await runMeteoAlertCheck()