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>

test/termineJobs.test.js

@@ -49,6 +49,7 @@ const R1 = 'r_aaaaaaa1'
 const S1 = 's_bbbbbbb1'
 const ABSENDER_VORHER = config.smtp.from
 const MODUS_VORHER = config.termine.mode
+const DECKEL_VORHER = config.termine.loeschDeckel
 const BASIS_VORHER = config.publicBaseUrl
 
 const iso = (wert) => new Date(wert).toISOString()
@@ -114,6 +115,7 @@ beforeEach(async () => {
   resetKontextForTests()
   resetOutboxForTests()
   resetJobsForTests()
+  aw.resetListCalls()
   config.termine.mode = 'pilot'
   config.smtp.from = 'noreply@webklar.com'
   config.publicBaseUrl = 'https://project.webklar.com'
@@ -129,6 +131,7 @@ afterEach(async () => {
   const text = [...log.error.mock.calls, ...log.warn.mock.calls].map((aufruf) => aufruf.arguments.map(String).join(' ')).join('\n')
   mock.restoreAll()
   config.termine.mode = MODUS_VORHER
+  config.termine.loeschDeckel = DECKEL_VORHER
   config.smtp.from = ABSENDER_VORHER
   config.publicBaseUrl = BASIS_VORHER
   assert.doesNotMatch(text, /Mustermann|max@example\.com/i, 'kein Gastname und keine Gastadresse im Log')
@@ -678,7 +681,7 @@ test('wendeLoeschfristenAn: verfallen 48 Stunden nach heldUntil, abgesagt/abgele
   await legeBuchung('b_l_jung', { status: 'abgelehnt', updatedAt: iso(plus(JETZT, -29 * TAG)) })
 
   const erg = await wendeLoeschfristenAn(JETZT)
-  assert.deepEqual(erg, { verfallen: 1, abgesagt: 1, abgelehnt: 1, erledigt: 0, nichterschienen: 0 })
+  assert.deepEqual(erg, { verfallen: 1, abgesagt: 1, abgelehnt: 1, erledigt: 0, nichterschienen: 0, gedeckelt: 0 })
   for (const id of ['b_v_alt', 'b_s_alt', 'b_l_alt']) {
     assert.equal(buchung(id), undefined, `${id} gelöscht`)
     assert.equal(claims(id).length, 0, `${id}: Zellen mit der Buchung gelöscht`)
@@ -741,15 +744,263 @@ test('wendeLoeschfristenAn: Fehler beim Lesen der Einstellung ⇒ diese Funktion
 
 test('wendeLoeschfristenAn: wird die Buchung zwischen Auflisten und Sperre geändert, bleibt sie', async () => {
   const doc = await legeBuchung('b_race', { status: 'abgesagt', updatedAt: iso(plus(JETZT, -40 * TAG)) })
+  let eingeworfen = false
+  // gezielt auf die Liste des Schritts abgesagt (die Abfrage nennt "abgesagt"); das select der Listen enthaelt jetzt auch updatedAt
   await mitEinwurf(
-    listeVonBuchungen(/updatedAt/),
-    async () => aw.seed('termineBookings', { ...doc, status: 'bestaetigt' }),
+    listeVonBuchungen(/"abgesagt"/),
+    async () => {
+      eingeworfen = true
+      aw.seed('termineBookings', { ...doc, status: 'bestaetigt' })
+    },
     () => wendeLoeschfristenAn(JETZT),
   )
+  assert.ok(eingeworfen, 'die Änderung kam nach der Liste und vor der Sperre')
   assert.equal(status('b_race'), 'bestaetigt')
   assert.ok(claims('b_race').length > 0)
 })
 
+// Hilfen der seitenweisen Löschläufe: Bezugszeit und Frist je Status
+const BEZUGSFELD = { verfallen: 'heldUntil', abgesagt: 'updatedAt', abgelehnt: 'updatedAt' }
+const BEHALTEN = { verfallen: 48 * STUNDE, abgesagt: 30 * TAG, abgelehnt: 30 * TAG }
+const ARTEN = ['verfallen', 'abgesagt', 'abgelehnt']
+const KUERZEL = { verfallen: 'ver', abgesagt: 'abs', abgelehnt: 'abl' }
+const nr = (i) => String(i).padStart(3, '0')
+/** Buchung eines Status, deren Bezugszeit `ueber` Millisekunden hinter der Löschgrenze liegt: > 0 fällig (1 = knapp), < 0 zu jung (-1 = eine Millisekunde). */
+const legeLoeschFall = (id, art, ueber, over = {}) => legeBuchung(id, { status: art, [BEZUGSFELD[art]]: iso(plus(JETZT, -BEHALTEN[art] - ueber)), ...over })
+
+/** Die Listenabfragen der Aufbewahrungs-Löschung (Abfrage nach einem ihrer fünf Status) an termineBookings. */
+const loeschListen = () =>
+  aw.listCalls('termineBookings').filter(({ queries }) => queries.some((q) => q.method === 'equal' && q.attribute === 'status' && ['verfallen', 'abgesagt', 'abgelehnt', 'erledigt', 'nichterschienen'].includes(q.values[0])))
+
+/** Alle Listenabfragen der Löschläufe (`aufrufe`, Standard: alle an termineBookings): limit höchstens 100, ein select ohne Gastfelder, kein $id-Seitenlauf. => Zahl der Abfragen */
+function pruefeSeitenabfragen(aufrufe = aw.listCalls('termineBookings')) {
+  for (const { queries } of aufrufe) {
+    const limit = queries.find((q) => q.method === 'limit')?.values[0]
+    assert.ok(Number.isInteger(limit) && limit <= 100, `limit ${limit}`)
+    const select = queries.find((q) => q.method === 'select')?.values
+    assert.ok(select, 'select vorhanden')
+    assert.deepEqual(select.filter((feld) => /^gast/.test(feld)), [], 'keine Gastfelder')
+    assert.equal(queries.some((q) => q.method === 'orderAsc' && q.attribute === '$id'), false, 'kein $id-Seitenlauf')
+  }
+  return aufrufe.length
+}
+/** Zahl der Listenabfragen an termineBookings für einen Status. */
+const listenFuer = (art) => aw.listCalls('termineBookings').filter(({ queries }) => queries.some((q) => q.method === 'equal' && q.attribute === 'status' && q.values[0] === art)).length
+/**
+ * Alle DELETE auf termineBookings, für die passt(id) gilt, scheitern wie bei einem kaputten Appwrite. => Zähler der Versuche.
+ * Ein Lauf, der mehr als 50 Listen liest, bekäme ab da Fehler (eine Endlosschleife soll den Test scheitern lassen, nicht aufhängen).
+ */
+async function mitScheiternderLoeschung(passt, fn) {
+  const echt = globalThis.fetch
+  const zaehler = { versuche: 0, listen: 0 }
+  const kaputt = () => new Response(JSON.stringify({ message: 'Nachbau kaputt', code: 500 }), { status: 500, headers: { 'content-type': 'application/json' } })
+  globalThis.fetch = async (url, optionen) => {
+    const methode = optionen?.method ?? 'GET'
+    const treffer = /\/collections\/termineBookings\/documents\/([^/?]+)$/.exec(String(url))
+    if (methode === 'DELETE' && treffer && passt(treffer[1])) {
+      zaehler.versuche += 1
+      return kaputt()
+    }
+    if (methode === 'GET' && /\/collections\/termineBookings\/documents\?/.test(String(url)) && (zaehler.listen += 1) > 50) return kaputt()
+    return echt(url, optionen)
+  }
+  try {
+    await fn()
+  } finally {
+    globalThis.fetch = echt
+  }
+  return zaehler
+}
+
+test('wendeLoeschfristenAn: 250 verfallen/abgesagt/abgelehnt ⇒ genau die 210 fälligen samt Zellen, seitenweise (limit ≤ 100, ohne Gastfelder)', async () => {
+  assert.ok(config.termine.loeschDeckel > 210, 'der Standard-Deckel liegt über den fälligen Buchungen, der Test setzt ihn nicht')
+  const faellig = { verfallen: [], abgesagt: [], abgelehnt: [] }
+  const jung = []
+  for (let i = 0; i < 250; i += 1) {
+    const art = ARTEN[i % 3]
+    const id = `b_${KUERZEL[art]}${nr(i)}`
+    const zuJung = i % 25 < 4 // 40 von 250: eine Millisekunde zu jung
+    await legeLoeschFall(id, art, zuJung ? -1 : 1 + i * 1000)
+    ;(zuJung ? jung : faellig[art]).push(id)
+  }
+  assert.equal(jung.length, 40)
+  // andere Status und eine Buchung der Gegenwart bleiben unberührt
+  await legeLoeschFall('b_fest', 'abgesagt', 5 * TAG, { status: 'bestaetigt' })
+  await legeBuchung('b_zukunft', { start: plus(JETZT, 5 * TAG) })
+  const zellenProBuchung = claims('b_zukunft').length
+  assert.ok(zellenProBuchung > 0)
+
+  const erg = await wendeLoeschfristenAn(JETZT)
+  const alleFaelligen = [...faellig.verfallen, ...faellig.abgesagt, ...faellig.abgelehnt]
+  assert.equal(alleFaelligen.length, 210)
+  assert.deepEqual(erg, {
+    verfallen: faellig.verfallen.length,
+    abgesagt: faellig.abgesagt.length,
+    abgelehnt: faellig.abgelehnt.length,
+    erledigt: 0,
+    nichterschienen: 0,
+    gedeckelt: 0,
+  })
+  for (const id of alleFaelligen) {
+    assert.equal(buchung(id), undefined, `${id} gelöscht`)
+    assert.equal(claims(id).length, 0, `${id}: Zellen gelöscht`)
+  }
+  for (const id of jung) {
+    assert.ok(buchung(id), `${id}: eine Millisekunde zu jung, bleibt`)
+    assert.equal(claims(id).length, zellenProBuchung, `${id}: Zellen bleiben`)
+  }
+  assert.deepEqual(buchungen().map((b) => b.$id).sort(), [...jung, 'b_fest', 'b_zukunft'].sort())
+  assert.ok(pruefeSeitenabfragen() >= 3, 'jede Listenabfrage ist kurz und ohne Gastfelder')
+  for (const art of ARTEN) assert.equal(listenFuer(art), 2, `${art}: eine Seite mit allem Fälligen, danach leer`)
+  assert.equal(fehlerLog().length, 0)
+})
+
+test('wendeLoeschfristenAn: mehr als eine Seite fälliger Buchungen eines Status ⇒ Seite für Seite (100, 100, 30), danach neu gelesen bis leer', async () => {
+  for (let i = 0; i < 230; i += 1) await legeLoeschFall(`b_ver${nr(i)}`, 'verfallen', 1 + i * 1000)
+  for (let i = 0; i < 5; i += 1) await legeLoeschFall(`b_vju${nr(i)}`, 'verfallen', -1)
+
+  const erg = await wendeLoeschfristenAn(JETZT)
+  assert.equal(erg.verfallen, 230)
+  assert.equal(erg.gedeckelt, 0)
+  assert.deepEqual(buchungen().map((b) => b.$id).sort(), Array.from({ length: 5 }, (_, i) => `b_vju${nr(i)}`))
+  assert.equal(aw.docs('termineClaims').size, 5 * claims('b_vju000').length)
+  assert.equal(listenFuer('verfallen'), 4, 'drei Seiten mit Fälligen, eine leere')
+  pruefeSeitenabfragen()
+})
+
+test('wendeLoeschfristenAn: Deckel loeschDeckel je Status – Rest an den Folgetagen, gedeckelt zählt die Schritte, Warnung ohne Kennungen', async () => {
+  config.termine.loeschDeckel = 7
+  // i = 19 ist am längsten fällig: die ältesten gehen zuerst
+  for (let i = 0; i < 20; i += 1) await legeLoeschFall(`b_ver${nr(i)}`, 'verfallen', 1 + i * 1000)
+  await legeLoeschFall('b_ver_jung', 'verfallen', -1)
+  const zellenProBuchung = claims('b_ver000').length
+  const uebrig = () => buchungen().map((b) => b.$id).filter((id) => id !== 'b_ver_jung').sort()
+  const deckelWarnungen = () => warnLog().filter((zeile) => /Deckel/.test(zeile))
+  const stimmt = () => {
+    assert.ok(buchung('b_ver_jung'), 'nie eine junge Buchung')
+    assert.equal(aw.docs('termineClaims').size, buchungen().length * zellenProBuchung, 'Zellen passen zum Rest')
+  }
+
+  let erg = await wendeLoeschfristenAn(JETZT)
+  assert.deepEqual(erg, { verfallen: 7, abgesagt: 0, abgelehnt: 0, erledigt: 0, nichterschienen: 0, gedeckelt: 1 })
+  assert.deepEqual(uebrig(), Array.from({ length: 13 }, (_, i) => `b_ver${nr(i)}`), 'die sieben ältesten sind weg')
+  assert.equal(deckelWarnungen().length, 1)
+  assert.doesNotMatch(deckelWarnungen()[0], /\bb_|f_p_|c_kunde|Müller|Mustermann/, 'keine ID, kein Name in der Warnung')
+  stimmt()
+
+  log.warn.mock.resetCalls()
+  erg = await wendeLoeschfristenAn(JETZT)
+  assert.equal(erg.verfallen, 7)
+  assert.equal(erg.gedeckelt, 1)
+  assert.equal(uebrig().length, 6)
+  assert.equal(deckelWarnungen().length, 1)
+  stimmt()
+
+  log.warn.mock.resetCalls()
+  erg = await wendeLoeschfristenAn(JETZT)
+  assert.equal(erg.verfallen, 6)
+  assert.equal(erg.gedeckelt, 0, 'die letzten sechs passen unter den Deckel')
+  assert.deepEqual(uebrig(), [])
+  assert.equal(deckelWarnungen().length, 0)
+  stimmt()
+  assert.equal(fehlerLog().length, 0)
+})
+
+test('wendeLoeschfristenAn: der Deckel gilt je Status; genau so viele fällige wie der Deckel ⇒ nicht gedeckelt', async () => {
+  config.termine.loeschDeckel = 7
+  for (let i = 0; i < 10; i += 1) await legeLoeschFall(`b_ver${nr(i)}`, 'verfallen', 1 + i)
+  for (let i = 0; i < 10; i += 1) await legeLoeschFall(`b_abs${nr(i)}`, 'abgesagt', 1 + i)
+  for (let i = 0; i < 7; i += 1) await legeLoeschFall(`b_abl${nr(i)}`, 'abgelehnt', 1 + i) // genau der Deckel
+
+  const erg = await wendeLoeschfristenAn(JETZT)
+  assert.deepEqual(erg, { verfallen: 7, abgesagt: 7, abgelehnt: 7, erledigt: 0, nichterschienen: 0, gedeckelt: 2 })
+  assert.equal(buchungen().filter((b) => b.status === 'verfallen').length, 3)
+  assert.equal(buchungen().filter((b) => b.status === 'abgesagt').length, 3)
+  assert.equal(buchungen().filter((b) => b.status === 'abgelehnt').length, 0)
+  assert.equal(warnLog().filter((zeile) => /Deckel/.test(zeile)).length, 2)
+})
+
+test('wendeLoeschfristenAn: scheitert jedes Löschen, endet der Lauf nach einer Seite je Schritt, zählt die Fehler, lässt die anderen Schritte laufen; der nächste Lauf holt alles nach', async () => {
+  for (const art of ARTEN) for (let i = 0; i < 30; i += 1) await legeLoeschFall(`b_${KUERZEL[art]}${nr(i)}`, art, 1 + i * 1000)
+  await legeLoeschFall('b_ver_jung', 'verfallen', -1)
+  // andere Schritte des Tagesjobs: eine alte, versandte Mail und eine verwaiste Zelle
+  legeEintrag('o_gesendet', { status: 'gesendet', an: '', html: '', text: '', naechsterVersuch: iso(plus(JETZT, -MIN)) })
+  await belegeZellen({ featureId: F1, ressourceId: 'r_geist', bookingId: 'b_geist', start: plus(JETZT, 2 * TAG), blockEnde: plus(JETZT, 2 * TAG + 30 * MIN), now: JETZT })
+
+  let erg
+  const zaehler = await mitScheiternderLoeschung(
+    () => true,
+    async () => {
+      erg = await taeglicherJob(JETZT)
+    },
+  )
+  assert.deepEqual(erg.loeschfristen, { verfallen: 0, abgesagt: 0, abgelehnt: 0, erledigt: 0, nichterschienen: 0 })
+  assert.deepEqual(erg.gedeckelt, { loeschfristen: 0, abgeschaltet: 0, zellen: 0 })
+  assert.equal(erg.fehler, 90, 'ein Fehler je Buchung, im Log')
+  assert.equal(fehlerLog().length, 90)
+  assert.equal(zaehler.versuche, 90, 'jede Buchung genau einmal versucht')
+  for (const art of ARTEN) assert.equal(listenFuer(art), 1, `${art}: eine Seite, dann Schluss`)
+  assert.equal(pruefeSeitenabfragen(loeschListen()), 5, 'drei Status plus die beiden unveränderten Schritte, je eine Seite')
+  assert.equal(erg.aufgeraeumt, 1, 'Warteschlange wurde trotzdem aufgeräumt')
+  assert.ok(erg.zellen >= 1, 'verwaiste Zellen wurden trotzdem geräumt')
+  assert.equal(claims('b_geist').length, 0)
+  assert.equal(buchungen().length, 91)
+
+  // nächster Lauf, Löschen geht wieder: alles Fällige weg, die junge bleibt
+  log.error.mock.resetCalls()
+  aw.resetListCalls()
+  const zweiter = await taeglicherJob(JETZT)
+  assert.deepEqual(zweiter.loeschfristen, { verfallen: 30, abgesagt: 30, abgelehnt: 30, erledigt: 0, nichterschienen: 0 })
+  assert.equal(zweiter.fehler, 0)
+  assert.deepEqual(buchungen().map((b) => b.$id), ['b_ver_jung'])
+  assert.equal(aw.docs('termineClaims').size, claims('b_ver_jung').length)
+})
+
+test('wendeLoeschfristenAn: einzelne Buchungen, die sich nicht löschen lassen, halten den Rest nicht auf und führen nicht in eine Endlosschleife', async () => {
+  // die drei ältesten stehen in jeder Liste vorn und scheitern immer
+  const kaputt = new Set(['b_ver027', 'b_ver028', 'b_ver029'])
+  for (let i = 0; i < 30; i += 1) await legeLoeschFall(`b_ver${nr(i)}`, 'verfallen', 1 + i * 1000)
+
+  const zaehler = await mitScheiternderLoeschung((id) => kaputt.has(id), async () => {
+    const erg = await wendeLoeschfristenAn(JETZT)
+    assert.equal(erg.verfallen, 27)
+  })
+  assert.deepEqual(buchungen().map((b) => b.$id).sort(), [...kaputt])
+  assert.equal(zaehler.versuche, 3, 'jede kaputte Buchung nur einmal versucht')
+  assert.equal(fehlerLog().length, 3)
+  assert.ok(listenFuer('verfallen') <= 3, 'eine Seite mit allem, eine mit dem Rest (nichts Neues darauf ⇒ Schluss)')
+})
+
+test('wendeLoeschfristenAn: ändert sich die Bezugszeit zwischen Liste und Sperre (abgesagt wird erneut geändert), bleibt die Buchung', async () => {
+  const doc = await legeLoeschFall('b_spaet', 'abgesagt', 1000)
+  await legeLoeschFall('b_alt', 'abgesagt', 2000)
+  let eingeworfen = false
+  await mitEinwurf(
+    listeVonBuchungen(/"abgesagt"/),
+    async () => {
+      eingeworfen = true
+      aw.seed('termineBookings', { ...doc, updatedAt: iso(JETZT) }) // Status bleibt abgesagt, die letzte Änderung ist neu
+    },
+    () => wendeLoeschfristenAn(JETZT),
+  )
+  assert.ok(eingeworfen)
+  assert.ok(buchung('b_spaet'), 'die 30 Tage laufen ab der neuen Änderung')
+  assert.ok(claims('b_spaet').length > 0)
+  assert.equal(buchung('b_alt'), undefined)
+})
+
+test('taeglicherJob: gedeckelt zählt je Schritt und verfälscht den Löschzähler im Tagesbericht nicht', async () => {
+  config.termine.loeschDeckel = 2
+  for (let i = 0; i < 5; i += 1) await legeLoeschFall(`b_ver${nr(i)}`, 'verfallen', 1 + i)
+  for (let i = 0; i < 5; i += 1) await legeLoeschFall(`b_abs${nr(i)}`, 'abgesagt', 1 + i)
+  await legeLoeschFall('b_abl000', 'abgelehnt', 1)
+
+  const erg = await taeglicherJob(JETZT)
+  assert.deepEqual(erg.loeschfristen, { verfallen: 2, abgesagt: 2, abgelehnt: 1, erledigt: 0, nichterschienen: 0 }, 'nur Löschzähler')
+  assert.deepEqual(erg.gedeckelt, { loeschfristen: 2, abgeschaltet: 0, zellen: 0 })
+  assert.match(tagesbericht(erg), /^\[termine\] Tagesjob: 5 Buchungen gelöscht \(verfallen 2, abgesagt 2, abgelehnt 1, erledigt 0, nichterschienen 0, abgeschaltete Funktionen 0\)/)
+})
+
 test('loescheAbgeschalteteFunktionen: disabled länger als 30 Tage ⇒ Buchungen, Zellen und Einstellung weg; alles andere bleibt', async () => {
   const seit = (tage, zusatz = 0) => iso(plus(JETZT, -tage * TAG + zusatz))
   await richteFunktionEin(F1, { state: 'disabled', disabledAt: seit(31) })
@@ -881,6 +1132,8 @@ test('taeglicherJob: Löschfristen, Warteschlange, festgefahrene Mails, verwaist
   assert.equal(erg.festgefahren, 1)
   assert.equal(erg.loeschfristen.verfallen, 1)
   assert.equal(erg.loeschfristen.erledigt, 1)
+  assert.equal('gedeckelt' in erg.loeschfristen, false, 'gedeckelt steht neben den Löschzählern, nicht darin')
+  assert.deepEqual(erg.gedeckelt, { loeschfristen: 0, abgeschaltet: 0, zellen: 0 })
   assert.deepEqual(erg.abgeschaltet, { funktionen: 1, buchungen: 1 })
   assert.equal(erg.aufgeraeumt, 1)
   assert.ok(erg.zellen >= 1)

test/termineSchalter.test.js

@@ -47,6 +47,7 @@ test('Konfiguration: Vorgaben ohne Umgebungsvariablen', async () => {
     holdMinutes: 30,
     zelleMin: 5,
     mailsProStunde: 200,
+    loeschDeckel: 2000,
     formMinSekunden: 3,
     minAntwortMs: 300,
   })

test/termineSetup.test.js

@@ -152,6 +152,8 @@ test('Schema: Indizes wie in der Spezifikation und nur auf vorhandenen Attribute
     ['idx_verify', 'verifyHash'],
     ['idx_manage', 'manageHash'],
     ['idx_status_start', 'status', 'startsAt'],
+    ['idx_status_ends', 'status', 'endsAt'],
+    ['idx_status_updated', 'status', 'updatedAt'],
   ])
   assert.deepEqual(indexes('termineClaims'), [['idx_booking', 'bookingId'], ['idx_bis', 'bis']])
   assert.deepEqual(indexes('termineOutbox'), [['idx_status_next', 'status', 'naechsterVersuch']])
@@ -230,6 +232,9 @@ test('main legt auf leerer Datenbank 4 Collections, alle Attribute und Indizes a
   assert.deepEqual(client.calls.collections, NAMES.map((id) => ({ id, name: id })))
   assert.deepEqual([...client.calls.attrs].sort(), [...expectedAttrs].sort())
   assert.deepEqual([...client.calls.indexes].sort(), [...expectedIndexes].sort())
+  // die Loeschfristen (Tagesjob) lesen ueber Status + Bezugszeit: beide Indizes werden angelegt
+  assert.ok(client.calls.indexes.includes('termineBookings.idx_status_ends'))
+  assert.ok(client.calls.indexes.includes('termineBookings.idx_status_updated'))
   assert.equal(result.missing.length, expectedAttrs.length)
   assert.deepEqual(result.missingCollections, NAMES)
   assert.equal(result.missingIndexes.length, expectedIndexes.length)
@@ -267,6 +272,29 @@ test('main: legt nur fehlende Attribute und Indizes einer vorhandenen Collection
   assert.equal(client.calls.collections.length, 3)
 })
 
+test('main: eine vorhandene termineBookings-Collection bekommt nur die beiden Loesch-Indizes nachgezogen (--check meldet sie)', async () => {
+  const vorhanden = {
+    termineBookings: {
+      attrs: keysOf('termineBookings'),
+      indexes: ['idx_feature_start', 'idx_status_held', 'idx_feature_email', 'idx_verify', 'idx_manage', 'idx_status_start'],
+    },
+  }
+  const lines = []
+  const pruefung = fakeClient(vorhanden)
+  const offen = await main({ check: true, client: pruefung, log: (line) => lines.push(line) })
+  assert.deepEqual(offen.missingIndexes.filter((i) => i.collection === 'termineBookings').map((i) => i.key), ['idx_status_ends', 'idx_status_updated'])
+  assert.ok(lines.some((line) => line.includes('Index termineBookings.idx_status_ends FEHLT')))
+  assert.ok(lines.some((line) => line.includes('Index termineBookings.idx_status_updated FEHLT')))
+
+  const client = fakeClient(vorhanden)
+  await main({ client, log: quiet })
+  assert.deepEqual(
+    client.calls.indexes.filter((k) => k.startsWith('termineBookings.')),
+    ['termineBookings.idx_status_ends', 'termineBookings.idx_status_updated'],
+  )
+  assert.deepEqual(client.calls.attrs.filter((k) => k.startsWith('termineBookings.')), [])
+})
+
 test('main --check legt nichts an und meldet Fehlendes', async () => {
   const client = fakeClient()
   const lines = []

test/termineZellen.test.js

@@ -958,6 +958,59 @@ test('loeschKandidaten: Bezugszeit je Status (verfallen heldUntil, erledigt Term
   await assert.rejects(B.loeschKandidaten('gehalten', neunzig), TypeError)
 })
 
+test('loeschKandidaten: hoechstens limit (Standard 100), aelteste Bezugszeit zuerst, nach Funktion filterbar, ohne Gastfelder', async () => {
+  const mit = (ms) => iso(new Date(JETZT.getTime() + ms))
+  const neunzig = new Date(JETZT.getTime() - 90 * TAG)
+  const nr = (i) => String(i).padStart(3, '0')
+  // 150 alte erledigt; je groesser i, desto spaeter das Terminende; in umgekehrter Reihenfolge angelegt, jede dritte in der Funktion 2
+  for (let i = 149; i >= 0; i -= 1) {
+    seedBuchung(`b_e${nr(i)}`, { status: 'erledigt', endsAt: mit(-91 * TAG + i * MIN), featureId: i % 3 === 0 ? 'f_feature02' : F })
+  }
+  seedBuchung('b_jung', { status: 'erledigt', endsAt: mit(-89 * TAG) })
+  const ids = (liste) => liste.map((doc) => doc.$id)
+  const alle = Array.from({ length: 150 }, (_, i) => `b_e${nr(i)}`)
+
+  aw.resetListCalls()
+  const standard = await B.loeschKandidaten('erledigt', neunzig)
+  assert.deepEqual(ids(standard), alle.slice(0, 100), 'Standard 100, aelteste zuerst')
+  assert.deepEqual(ids(await B.loeschKandidaten('erledigt', neunzig, { limit: 10 })), alle.slice(0, 10))
+  assert.deepEqual(ids(await B.loeschKandidaten('erledigt', neunzig, { limit: 1 })), [alle[0]])
+  const zwei = await B.loeschKandidaten('erledigt', neunzig, { featureId: 'f_feature02' })
+  assert.deepEqual(ids(zwei), alle.filter((_, i) => i % 3 === 0), 'nur die Funktion 2, aelteste zuerst')
+  assert.deepEqual(ids(await B.loeschKandidaten('erledigt', neunzig, { featureId: 'f_feature02', limit: 5 })), alle.filter((_, i) => i % 3 === 0).slice(0, 5))
+  assert.deepEqual(await B.loeschKandidaten('erledigt', neunzig, { featureId: 'f_gibt_es_nicht' }), [])
+
+  // keine Gastfelder: weder Name noch Adresse, nur Kennung, Funktion, Status und die drei Bezugszeiten
+  const erlaubt = new Set(['featureId', 'status', 'endsAt', 'updatedAt', 'heldUntil'])
+  for (const doc of standard) {
+    assert.ok(doc.$id)
+    assert.equal(doc.status, 'erledigt')
+    assert.deepEqual(Object.keys(doc).filter((key) => !key.startsWith('$') && !erlaubt.has(key)), [], `${doc.$id}: nur erlaubte Felder`)
+    assert.equal('gastName' in doc, false)
+    assert.equal('gastEmail' in doc, false)
+  }
+  // die Abfrage sagt es selbst: select ohne Gastfelder, limit, Reihenfolge nach der Bezugszeit
+  const abfrage = aw.listCalls('termineBookings')[0].queries
+  assert.deepEqual(abfrage.find((q) => q.method === 'select').values, ['$id', 'featureId', 'status', 'endsAt', 'updatedAt', 'heldUntil'])
+  assert.deepEqual(abfrage.find((q) => q.method === 'limit').values, [100])
+  assert.deepEqual(abfrage.find((q) => q.method === 'orderAsc'), { method: 'orderAsc', attribute: 'endsAt' })
+  assert.deepEqual(abfrage.find((q) => q.method === 'lessThan'), { method: 'lessThan', attribute: 'endsAt', values: [iso(neunzig)] })
+
+  // Reihenfolge nach der Bezugszeit des Status: verfallen heldUntil, abgesagt updatedAt (Einfuegereihenfolge ist egal)
+  seedBuchung('b_v2', { status: 'verfallen', heldUntil: mit(-60 * STUNDE) })
+  seedBuchung('b_v1', { status: 'verfallen', heldUntil: mit(-70 * STUNDE) })
+  seedBuchung('b_v3', { status: 'verfallen', heldUntil: mit(-50 * STUNDE) })
+  assert.deepEqual(ids(await B.loeschKandidaten('verfallen', new Date(JETZT.getTime() - 48 * STUNDE))), ['b_v1', 'b_v2', 'b_v3'])
+  seedBuchung('b_a2', { status: 'abgesagt', updatedAt: mit(-40 * TAG) })
+  seedBuchung('b_a1', { status: 'abgesagt', updatedAt: mit(-50 * TAG) })
+  assert.deepEqual(ids(await B.loeschKandidaten('abgesagt', new Date(JETZT.getTime() - 30 * TAG))), ['b_a1', 'b_a2'])
+
+  // wie bisher: nicht loeschbare Status und ungueltige limit
+  await assert.rejects(B.loeschKandidaten('bestaetigt', neunzig, { limit: 10 }), TypeError)
+  await assert.rejects(B.loeschKandidaten('gehalten', neunzig), TypeError)
+  for (const limit of [0, -1, 1.5, NaN, '10']) await assert.rejects(B.loeschKandidaten('erledigt', neunzig, { limit }), TypeError, `limit ${limit}`)
+})
+
 test('zaehleAnfragen: offene Anfragen einer Funktion (auch ueber 25)', async () => {
   for (let i = 0; i < 27; i += 1) seedBuchung(`b_anf${String(i).padStart(2, '0')}`, { status: 'angefragt' })
   seedBuchung('b_best', { status: 'bestaetigt' })