fix: send meteo alert before recording it; de-dup by existence not insert

The bulletin report row was created BEFORE the Telegram message was sent, and the
'was it newly inserted' result was used as the send gate. Whenever the row existed
without a message actually going out, the alert was de-duplicated and never sent
again - and the failure was invisible (caught+logged, tick still ended 'ok').

- meteo-alerts task: look up the report by number (existence check, independent of
  any UNIQUE constraint), send the message FIRST, and record the report only after
  a successful send -> a failed send is logged and retried next tick instead of
  being permanently de-duplicated. Non-critical bulletins are still recorded.
- alert-report model: add getAlertReportByNumber.
- tests: send-then-record, dedup-skip, non-critical record, send-failure retry,
  no-alert cases.

Author: nicomontanari

src/models/alert-report.ts

@@ -28,6 +28,14 @@ export const getLastAlertReport = async (): Promise<AlertReport> => {
     return reports[0]
 }
 
+export const getAlertReportByNumber = async (reportNumber: string): Promise<AlertReport | undefined> => {
+    const query = `SELECT * FROM ${tableName} WHERE report_number = $1 ORDER BY id DESC LIMIT 1`
+
+    const rows = await database.query<AlertReport>(query, [reportNumber])
+
+    return rows[0]
+}
+
 export const createAlertReport = async (report: EditableAlertReport): Promise<AlertReport> => {
     return database.create<AlertReport>(tableName, report)
 }

src/tasks/meteo-alerts.ts

@@ -1,5 +1,5 @@
 import { sendNewTomorrowAlertMessage } from '../utilities/telegram'
-import { createAlertReportIfNew } from '../models/alert-report'
+import { createAlertReport, getAlertReportByNumber } from '../models/alert-report'
 import { getTomorrowMeteoAlert } from '../services/meteo-alerts'
 import { parseMeteoAlert, ParsedMeteoAlert } from '../utilities/meteo-alerts'
 import { config } from '../config/config'
@@ -16,7 +16,15 @@ export const runMeteoAlertCheck = async (): Promise<ParsedMeteoAlert | undefined
 
     const parsedAlert = parseMeteoAlert(tomorrowAlert, config.alert_zone)
 
-    const insertedReport = await createAlertReportIfNew({
+    // 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)
+
+    if (existing) {
+        return parsedAlert
+    }
+
+    const report = {
         report_number: parsedAlert.id,
         is_critic: parsedAlert.isCritic,
         estofex_sent: false,
@@ -25,14 +33,23 @@ export const runMeteoAlertCheck = async (): Promise<ParsedMeteoAlert | undefined
         starts_on: parsedAlert.dataInizio,
         ends_on: parsedAlert.dataFine,
         emitted_on: parsedAlert.dataEmissione,
-    })
-
-    if (insertedReport && parsedAlert.isCritic) {
-        try {
-            await sendNewTomorrowAlertMessage(parsedAlert)
-        } catch (err) {
-            log.error({ err, alertId: parsedAlert.id }, 'Failed to send Telegram alert')
-        }
+    }
+
+    // Non-critical bulletin: just record it (so pretemp/estofex see the latest report); no message.
+    if (!parsedAlert.isCritic) {
+        await createAlertReport(report)
+        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).
+    try {
+        await sendNewTomorrowAlertMessage(parsedAlert)
+        await createAlertReport(report)
+    } catch (err) {
+        log.error({ err, alertId: parsedAlert.id }, 'Failed to send meteo alert; will retry next tick')
     }
 
     return parsedAlert

tests/tasks/meteo-alerts.ts

@@ -0,0 +1,91 @@
+import { expect } from 'chai'
+import { afterEach, beforeEach, describe, it } from 'mocha'
+import sinon, { SinonStub } from 'sinon'
+import * as alertService from '../../src/services/meteo-alerts'
+import * as alertUtil from '../../src/utilities/meteo-alerts'
+import * as alertModel from '../../src/models/alert-report'
+import * as telegram from '../../src/utilities/telegram'
+import { ParsedMeteoAlert } from '../../src/utilities/meteo-alerts'
+import { runMeteoAlertCheck } from '../../src/tasks/meteo-alerts'
+
+const parsed = (overrides: Partial<ParsedMeteoAlert> = {}): ParsedMeteoAlert =>
+    ({
+        id: '065/2026',
+        isCritic: true,
+        dataEmissione: 'Jun 25, 2026 11:45:30 AM',
+        titolo: 'Allerta',
+        link: 'https://example/allerta065_2026.pdf',
+        dataInizio: 'Jun 26, 2026 12:00:00 AM',
+        dataFine: 'Jun 27, 2026 12:00:00 AM',
+        descrizionemeteo: 'caldo',
+        zoneData: {} as ParsedMeteoAlert['zoneData'],
+        criticZoneData: {},
+        ...overrides,
+    }) as ParsedMeteoAlert
+
+describe('tests/tasks/meteo-alerts', () => {
+    let getTomorrow: SinonStub
+    let parse: SinonStub
+    let getByNumber: SinonStub
+    let create: SinonStub
+    let send: SinonStub
+
+    beforeEach(() => {
+        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()
+    })
+
+    afterEach(() => sinon.restore())
+
+    it('sends a new critical bulletin and records it only after a successful send', async () => {
+        parse.returns(parsed({ isCritic: true }))
+
+        await runMeteoAlertCheck()
+
+        expect(send.calledOnce).to.equal(true)
+        expect(create.calledOnce).to.equal(true)
+        expect(send.calledBefore(create)).to.equal(true)
+    })
+
+    it('does not resend a bulletin whose report row already exists', async () => {
+        parse.returns(parsed({ isCritic: true }))
+        getByNumber.resolves({ id: 1 } as never)
+
+        await runMeteoAlertCheck()
+
+        expect(send.called).to.equal(false)
+        expect(create.called).to.equal(false)
+    })
+
+    it('records a non-critical bulletin without sending a message', async () => {
+        parse.returns(parsed({ isCritic: false }))
+
+        await runMeteoAlertCheck()
+
+        expect(send.called).to.equal(false)
+        expect(create.calledOnce).to.equal(true)
+    })
+
+    it('does NOT record the report when the send fails, so it retries on the next tick', async () => {
+        parse.returns(parsed({ isCritic: true }))
+        send.rejects(new Error('telegram down'))
+
+        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 () => {
+        getTomorrow.resolves(undefined)
+
+        await runMeteoAlertCheck()
+
+        expect(parse.called).to.equal(false)
+        expect(send.called).to.equal(false)
+        expect(create.called).to.equal(false)
+    })
+})