Terminplaner: Aufbewahrungs-Loeschung seitenweise (Grundlagen, verfallen/abgesagt/abgelehnt)

loeschKandidaten liest eine Seite (Standard 100, aelteste Bezugszeit zuerst, optional je Funktion) ohne Gastfelder; die Frist steht in der Abfrage. arbeiteSeiten (Seite lesen, bearbeiten, neu lesen) endet bei leerer Seite, am Deckel (config.termine.loeschDeckel, 2000 je Status und Lauf, Rest an den Folgetagen, gezaehlt als gedeckelt) oder bei einer Seite ohne Fortschritt. verfallen, abgesagt und abgelehnt laufen darueber, unter der Buchungssperre werden Status und Bezugszeit frisch geprueft. taeglicherJob liefert gedeckelt getrennt vom Loeschzaehler. Neue Indizes idx_status_ends und idx_status_updated auf termineBookings (scripts/termine-setup.mjs legt sie an). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-04 08:55:32 +00:00
1 parent 2dd9c0dec7
commit 5c95dfc322
@@ -31,6 +31,10 @@ const LOESCH_BEZUG = {
  nichterschienen: 'endsAt',
 }

+/** Eine Seite von loeschKandidaten und die Felder, die sie liest (nie Gastfelder). */
+const LOESCH_SEITE = 100
+const LOESCH_FELDER = ['$id', 'featureId', 'status', 'endsAt', 'updatedAt', 'heldUntil']
+
 const iso = (wert) => new Date(wert).toISOString()
 const kleinGetrimmt = (email) => (typeof email === 'string' ? email.trim().toLowerCase() : '')

@@ -181,16 +185,31 @@ export async function vergangeneAnfragen(now) {
 }

 /**
- * Buchungen eines Status (alle Funktionen), deren Bezugszeit vor `vor` liegt. Bezugszeit je Status: verfallen =
- * heldUntil, erledigt und nichterschienen = endsAt (Terminende), abgesagt und abgelehnt = updatedAt (letzte
- * Aenderung, also der Zeitpunkt der Absage; endgueltige Status werden danach nicht mehr geaendert). Die Frist je
- * Funktion (aufbewahrungTage) wendet der Aufrufer auf das Ergebnis an. Andere Status: TypeError.
+ * Buchungen eines Status, deren Bezugszeit vor `vor` liegt (die Frist steht in der Abfrage, nie nachtraeglich im Code):
+ * hoechstens `limit` (Standard 100, eine Seite), die mit der aeltesten Bezugszeit zuerst. Bezugszeit je Status: verfallen =
+ * heldUntil, erledigt und nichterschienen = endsAt (Terminende), abgesagt und abgelehnt = updatedAt (letzte Aenderung, also
+ * der Zeitpunkt der Absage; endgueltige Status werden danach nicht mehr geaendert). Mit featureId nur diese Funktion, sonst alle.
+ * Ohne Cursor: wer loescht, liest die Liste danach neu (Geloeschtes fehlt). Die Treffer tragen nur $id, featureId, status,
+ * endsAt, updatedAt und heldUntil, nie Gastfelder (Name, Adresse). Die Frist je Funktion (aufbewahrungTage) wendet der
+ * Aufrufer auf das Ergebnis an. Andere Status: TypeError.
 */
-export async function loeschKandidaten(status, vor) {
+export async function loeschKandidaten(status, vor, { featureId = null, limit = LOESCH_SEITE } = {}) {
  if (!Object.hasOwn(LOESCH_BEZUG, status)) throw new TypeError(`loeschKandidaten: Status ${status} wird nicht automatisch geloescht`)
-  return listAllDocuments(col(), [Query.equal('status', status), Query.lessThan(LOESCH_BEZUG[status], iso(vor))])
+  if (!Number.isInteger(limit) || limit < 1) throw new TypeError(`loeschKandidaten: limit muss eine ganze Zahl ab 1 sein, nicht ${limit}`)
+  const bezug = LOESCH_BEZUG[status]
+  return listDocuments(col(), [
+    Query.equal('status', status),
+    Query.lessThan(bezug, iso(vor)),
+    ...(featureId === null ? [] : [Query.equal('featureId', featureId)]),
+    Query.orderAsc(bezug),
+    Query.limit(limit),
+    Query.select(LOESCH_FELDER),
+  ])
 }

+/** Feld der Bezugszeit einer Loeschfrist (siehe loeschKandidaten); undefined fuer Status, die nicht automatisch geloescht werden. */
+export const loeschBezugsfeld = (status) => (Object.hasOwn(LOESCH_BEZUG, status) ? LOESCH_BEZUG[status] : undefined)
+
 /** Zahl der offenen Anfragen (Status angefragt) einer Funktion. */
 export async function zaehleAnfragen(featureId) {
  return (await listAllDocuments(col(), [Query.equal('featureId', featureId), Query.equal('status', 'angefragt')])).length
@@ -8,6 +8,7 @@ import {
  erinnerungsKandidaten,
  hole,
  loesche,
+  loeschBezugsfeld,
  loeschKandidaten,
  vergangeneAnfragen,
  zuErledigen,
@@ -40,6 +41,9 @@ import { gibZellenFrei, raeumeVerwaisteZellen } from './zellen.js'
 *   Bedingung (Verfall nur, solange noch `gehalten` mit heldUntil <= jetzt usw.): ein Gast, der gerade bestaetigt, und der Job
 *   ergeben genau einen Endzustand. Mails gehen erst nach der Aenderung und ausserhalb der Sperre in die Warteschlange.
 * - Zellen gibt nur zellen.js frei (gibZellenFrei / raeumeVerwaisteZellen, jeweils unter der Ressourcensperre).
+ * - Loeschlaeufe (Aufbewahrung) arbeiten seitenweise (arbeiteSeiten): eine Seite hoechstens 100 Buchungen ohne Gastfelder,
+ *   Frist in der Abfrage, danach neu lesen. Ein Schritt loescht hoechstens config.termine.loeschDeckel Buchungen je Lauf; der
+ *   Rest folgt am naechsten Tag und wird gezaehlt (`gedeckelt`), nie still uebersprungen.
 */

 const MIN_MS = 60 * 1000
@@ -100,7 +104,7 @@ async function fuehreAus(job, now, arbeit) {
  }
  laufend.add(job)
  try {
-    return await arbeit({ job, nowMs, fehler: 0 })
+    return await arbeit({ job, nowMs, fehler: 0, gedeckelt: 0 })
  } finally {
    laufend.delete(job)
    ueberlappGemeldet.delete(job)
@@ -108,7 +112,7 @@ async function fuehreAus(job, now, arbeit) {
 }

 /** Laufdaten fuer einen Baustein, der ohne Job-Rahmen aufgerufen wird (Tests). */
-const einzelLauf = (job, now) => ({ job, nowMs: pruefeNow(now, job), fehler: 0 })
+const einzelLauf = (job, now) => ({ job, nowMs: pruefeNow(now, job), fehler: 0, gedeckelt: 0 })

 /**
 * Eine Buchung unter ihrer Sperre, frisch gelesen: fn(frisch) laeuft nur, wenn es sie noch gibt.
@@ -126,6 +130,62 @@ async function mitFrischer(lauf, was, id, fn) {
  }
 }

+/**
+ * Seitenweise Arbeit ohne Cursor: Seite lesen (holeSeite), jeden Eintrag bearbeiten (bearbeite), Liste neu lesen – was bearbeitet
+ * ist, fehlt dann. Gedacht fuer Loeschlaeufe (Aufbewahrung, abgeschaltete Funktionen, Zellen), die wegen der Zahl der Betriebe nie
+ * alles auf einmal lesen duerfen. Der Lauf endet
+ *  - bei einer leeren Seite (alles erledigt),
+ *  - am Deckel: sind `deckel` Eintraege geloescht und es kommt noch einer, zaehlt lauf.gedeckelt, eine Warnung ohne Kennungen
+ *    steht im Log und der Rest folgt im naechsten Lauf,
+ *  - bei einer Seite ohne einen bearbeiteten Eintrag (alle gescheitert oder schon versucht): die Fehler stehen im Log; eine Menge
+ *    merkt die versuchten IDs, damit ein Eintrag, der sich nicht bearbeiten laesst, keinen Endlosdurchlauf ausloest.
+ * holeSeite() => Eintraege mit $id (hoechstens eine Seite); bearbeite(eintrag) => true (geloescht, zaehlt zum Deckel) | false (nichts
+ * zu tun, z. B. inzwischen anders oder weg: kein Fehler) | undefined (Fehler, schon gemeldet). Wirft holeSeite, steht der Fehler im
+ * Log und der Lauf endet unvollstaendig.
+ * => { geloescht, gedeckelt (am Deckel beendet), vollstaendig (leere Seite erreicht und kein Fehler in diesem Lauf) }
+ */
+async function arbeiteSeiten(lauf, { holeSeite, bearbeite, deckel, was = 'Löschung' }) {
+  if (!Number.isInteger(deckel) || deckel < 1) throw new TypeError(`arbeiteSeiten: deckel muss eine ganze Zahl ab 1 sein, nicht ${deckel}`)
+  const versucht = new Set()
+  let geloescht = 0
+  let fehlerBeiEintrag = false
+  for (;;) {
+    let seite
+    try {
+      seite = await holeSeite()
+    } catch (err) {
+      melde(lauf, `${was}: Liste nicht gelesen`, err)
+      return { geloescht, gedeckelt: false, vollstaendig: false }
+    }
+    if (seite.length === 0) return { geloescht, gedeckelt: false, vollstaendig: !fehlerBeiEintrag }
+
+    let bearbeitet = 0
+    for (const eintrag of seite) {
+      if (versucht.has(eintrag.$id)) continue
+      if (geloescht >= deckel) {
+        lauf.gedeckelt += 1
+        console.warn(`[termine-jobs] ${lauf.job}: ${was} endet am Deckel von ${deckel} je Lauf, der Rest folgt an den nächsten Tagen`)
+        return { geloescht, gedeckelt: true, vollstaendig: false }
+      }
+      versucht.add(eintrag.$id)
+      let ergebnis
+      try {
+        ergebnis = await bearbeite(eintrag)
+      } catch (err) {
+        melde(lauf, was, err)
+        ergebnis = undefined
+      }
+      if (ergebnis === undefined) {
+        fehlerBeiEintrag = true
+        continue
+      }
+      bearbeitet += 1
+      if (ergebnis) geloescht += 1
+    }
+    if (bearbeitet === 0) return { geloescht, gedeckelt: false, vollstaendig: false }
+  }
+}
+
 // ---------------------------------------------------------------- Minutenjob

 /** Abgelaufene Haltungen: verfallen und Zellen frei – nur, wenn die Buchung unter der Sperre noch `gehalten` und abgelaufen ist. */
@@ -275,43 +335,71 @@ async function aufbewahrungTage(lauf, featureId) {
  }
 }

-/** Buchung samt Zellen loeschen, wenn sie unter der Sperre noch im erwarteten Status ist (status: null = jeder). => true | false | undefined (Fehler) */
-function loescheMitZellen(lauf, id, status) {
+/**
+ * Buchung samt Zellen loeschen, wenn sie unter der Sperre noch im erwarteten Status ist (status: null = jeder). Mit `frist`
+ * ({ feld, vor } in ms) muss ausserdem die frisch gelesene Bezugszeit noch vor `vor` liegen (zweiter Boden gegen eine Liste, die
+ * seit dem Lesen veraltet ist). => true | false | undefined (Fehler)
+ */
+function loescheMitZellen(lauf, id, status, frist = null) {
  return mitFrischer(lauf, 'Buchung nicht gelöscht', id, async (frisch) => {
    if (status !== null && frisch.status !== status) return false
+    if (frist !== null && !(zeitMs(frisch[frist.feld]) < frist.vor)) return false
    await gibZellenFrei(id)
    await loesche(id)
    return true
  })
 }

+/**
+ * Aufbewahrungs-Loeschung (Spezifikation 11) fuer Buchungen. Durchgang (1): verfallen (48 Stunden nach heldUntil), abgesagt und
+ * abgelehnt (30 Tage nach der letzten Aenderung) ueber alle Funktionen, je Status seitenweise (arbeiteSeiten) bis zum Deckel
+ * config.termine.loeschDeckel. Die Frist steht in der Abfrage; unter der Buchungssperre wird Status und Bezugszeit noch einmal
+ * frisch geprueft. erledigt/nichterschienen laufen bis zum Umbau je Funktion noch ueber den bisherigen Weg (eine Liste, die Frist
+ * der Funktion am Kandidaten).
+ * => Loeschzaehler je Status und `gedeckelt` = Zahl der Schritte, die am Deckel endeten
+ */
 async function loeschfristen(lauf, now) {
  const geloescht = { verfallen: 0, abgesagt: 0, abgelehnt: 0, erledigt: 0, nichterschienen: 0 }
+  let gedeckelt = 0
  const tage = new Map()
  const tageFuer = (featureId) => {
    if (!tage.has(featureId)) tage.set(featureId, aufbewahrungTage(lauf, featureId))
    return tage.get(featureId)
  }
-  // Je Status: Kandidaten ab der fruehesten moeglichen Frist; bei erledigt/nichterschienen entscheidet die Frist der Funktion
-  const fristen = [
-    ['verfallen', VERFALLEN_BEHALTEN_MS, false],
-    ['abgesagt', ABGESAGT_BEHALTEN_MS, false],
-    ['abgelehnt', ABGESAGT_BEHALTEN_MS, false],
-    ['erledigt', AUFBEWAHRUNG_MIN * TAG_MS, true],
-    ['nichterschienen', AUFBEWAHRUNG_MIN * TAG_MS, true],
-  ]
-  for (const [status, behalten, jeFunktion] of fristen) {
+
+  for (const [status, behalten] of [
+    ['verfallen', VERFALLEN_BEHALTEN_MS],
+    ['abgesagt', ABGESAGT_BEHALTEN_MS],
+    ['abgelehnt', ABGESAGT_BEHALTEN_MS],
+  ]) {
    await schritt(lauf, `Löschfrist ${status}`, async () => {
-      for (const kandidat of await loeschKandidaten(status, new Date(lauf.nowMs - behalten))) {
-        if (jeFunktion) {
-          const t = await tageFuer(kandidat.featureId)
-          if (t === null || !(zeitMs(kandidat.endsAt) < lauf.nowMs - t * TAG_MS)) continue
-        }
+      const vor = lauf.nowMs - behalten
+      const frist = { feld: loeschBezugsfeld(status), vor }
+      const erg = await arbeiteSeiten(lauf, {
+        was: `Löschfrist ${status}`,
+        deckel: config.termine.loeschDeckel,
+        holeSeite: () => loeschKandidaten(status, new Date(vor)),
+        bearbeite: async (kandidat) => {
+          const weg = await loescheMitZellen(lauf, kandidat.$id, status, frist)
+          if (weg) geloescht[status] += 1
+          return weg
+        },
+      })
+      if (erg.gedeckelt) gedeckelt += 1
+    })
+  }
+
+  // Bisheriger Weg fuer erledigt/nichterschienen: Kandidaten ab der fruehesten moeglichen Frist, dann entscheidet die Frist der Funktion
+  for (const status of ['erledigt', 'nichterschienen']) {
+    await schritt(lauf, `Löschfrist ${status}`, async () => {
+      for (const kandidat of await loeschKandidaten(status, new Date(lauf.nowMs - AUFBEWAHRUNG_MIN * TAG_MS))) {
+        const t = await tageFuer(kandidat.featureId)
+        if (t === null || !(zeitMs(kandidat.endsAt) < lauf.nowMs - t * TAG_MS)) continue
        if (await loescheMitZellen(lauf, kandidat.$id, status)) geloescht[status] += 1
      }
    })
  }
-  return geloescht
+  return { ...geloescht, gedeckelt }
 }

 /** So viele Buchungen einer abgeschalteten Funktion hoechstens, bevor ihr Zustand erneut gelesen wird. */
@@ -392,10 +480,12 @@ async function loescheAbgeschaltete(lauf) {

 /**
 * Loeschfristen (Spezifikation 11) fuer Buchungen: verfallen 48 Stunden nach heldUntil, abgesagt/abgelehnt 30 Tage nach der letzten
- * Aenderung, erledigt/nichterschienen aufbewahrungTage der Funktion (Vorgabe 90) nach Terminende; jeweils samt Zellen. Baustein des
- * Tagesjobs, ohne Schalter- und Ueberlappungspruefung (fuer Tests).
+ * Aenderung, erledigt/nichterschienen aufbewahrungTage der Funktion (Vorgabe 90) nach Terminende; jeweils samt Zellen, je Schritt
+ * hoechstens config.termine.loeschDeckel (der Rest folgt im naechsten Lauf). Baustein des Tagesjobs, ohne Schalter- und
+ * Ueberlappungspruefung (fuer Tests).
 * @param {Date} now
- * @returns {Promise<{ verfallen: number, abgesagt: number, abgelehnt: number, erledigt: number, nichterschienen: number }>}
+ * @returns {Promise<{ verfallen: number, abgesagt: number, abgelehnt: number, erledigt: number, nichterschienen: number, gedeckelt: number }>}
+ *   gedeckelt = Zahl der Schritte, die am Deckel endeten
 */
 export function wendeLoeschfristenAn(now) {
  return loeschfristen(einzelLauf('loeschfristen', now), now)
@@ -420,11 +510,13 @@ export function loescheAbgeschalteteFunktionen(now) {
 export async function taeglicherJob(now) {
  return fuehreAus('taeglicherJob', now, async (lauf) => {
    const festgefahren = await schritt(lauf, 'Festgefahrene Mails', () => beendeFestgefahrene(now), 0)
-    const loeschung = await loeschfristen(lauf, now)
+    const { gedeckelt: loeschfristenGedeckelt, ...loeschung } = await loeschfristen(lauf, now)
    const abgeschaltet = await schritt(lauf, 'Abgeschaltete Funktionen', () => loescheAbgeschaltete(lauf), { funktionen: 0, buchungen: 0 })
    const aufgeraeumt = await schritt(lauf, 'Warteschlange aufräumen', () => raeumeAuf(now), 0)
    const zellen = await schritt(lauf, 'Verwaiste Zellen', () => raeumeVerwaisteZellen(now), 0)
-    return { festgefahren, loeschfristen: loeschung, abgeschaltet, aufgeraeumt, zellen, fehler: lauf.fehler }
+    // gedeckelt: Schritte, die am Deckel endeten (abgeschaltet und zellen fuellen spaetere Tasks); getrennt vom Loeschzaehler, damit die Summe im Tagesbericht stimmt
+    const gedeckelt = { loeschfristen: loeschfristenGedeckelt, abgeschaltet: 0, zellen: 0 }
+    return { festgefahren, loeschfristen: loeschung, gedeckelt, abgeschaltet, aufgeraeumt, zellen, fehler: lauf.fehler }
  })
 }

@@ -81,6 +81,9 @@ export const TERMINE_COLLECTIONS = {
      index('idx_verify', 'verifyHash'),
      index('idx_manage', 'manageHash'),
      index('idx_status_start', 'status', 'startsAt'),
+      // Aufbewahrungs-Loeschung (Tagesjob): Status + Bezugszeit, verfallen laeuft ueber idx_status_held
+      index('idx_status_ends', 'status', 'endsAt'),
+      index('idx_status_updated', 'status', 'updatedAt'),
    ],
  },