fix: treatments endpoint needs a created_at cursor, not date

Investigated the "only ~4 days of treatments" report via direct
MongoDB access (issue #13): the collection has 123k+ documents, no
capping, no TTL index — the full year of history is in the database.

The actual cause: /api/v1/treatments.json filters/sorts on the string
field `created_at`, not the numeric `date` field /api/v1/entries uses.
Paginating with find[date][$lte] (or no filter at all) silently caps
treatments to an internal ~4-day window even though every document has
a valid `date` field; find[created_at][$lte] correctly walks back
through the full history.

_paginated_get() now takes an explicit cursor_field per endpoint and
always sends the cursor from the first request (never omitted), so
that hidden default window can't trigger. Verified against the real
instance: a 92-day treatments fetch now returns 39,403 rows (was ~700).

nightscout_client.py

@@ -38,12 +38,31 @@ _REQUEST_TIMEOUT = 10
 # meest recente ~1150 metingen terug — nog geen 4 dagen — terwijl er wel
 # degelijk weken oudere data in Nightscout beschikbaar bleek te zijn). Eén
 # verzoek is dus niet genoeg voor meerdaagse rapportages; _paginated_get()
-# loopt terug in de tijd met `find[date][$lte]`-cursors tot de gevraagde
+# loopt terug in de tijd met `find[...][$lte]`-cursors tot de gevraagde
 # `since`-grens bereikt is of de server minder dan een volle pagina teruggeeft
 # (= geen oudere data meer beschikbaar, wat verschilt van "afgeknipt").
+#
+# De twee endpoints filteren op een ANDER veld, en /treatments heeft nog een
+# addertje: entries filtert/sorteert op het numerieke `date` (epoch ms) en
+# geeft zonder filter gewoon de meest recente `count` terug. treatments
+# filtert/sorteert op het string-veld `created_at` (ISO 8601) — filteren op
+# `date` levert daar stil een lege pagina op zodra je voorbij een intern
+# venster van ~4 dagen gaat, ook al bevatten de documenten prima een geldig
+# `date`-veld (geverifieerd rechtstreeks in MongoDB: alle 123k+ treatments
+# hebben een numeriek `date`, en zonder enig filter geeft het endpoint alsnog
+# stilzwijgend niet meer dan ~4 dagen terug). Zodra je expliciet op
+# `created_at` filtert — zelfs met "nu" als bovengrens op de eerste pagina —
+# werkt paginering wél correct en is de volledige geschiedenis (maanden,
+# geverifieerd in de database) gewoon opvraagbaar. Vandaar: de cursor wordt
+# nooit weggelaten (ook niet op de allereerste pagina), en welk veld
+# gebruikt wordt is per endpoint expliciet ("date" voor entries,
+# "created_at" voor treatments) — zie ENTRIES_CURSOR_FIELD/TREATMENTS_CURSOR_FIELD.
 _PAGE_SIZE = 1000
 _MAX_PAGES = 150  # 150 000 documenten; ruim boven wat een 90-dagenrapport nodig heeft
 
+ENTRIES_CURSOR_FIELD = "date"
+TREATMENTS_CURSOR_FIELD = "created_at"
+
 
 class NightscoutConfigError(RuntimeError):
     """NIGHTSCOUT_URL ontbreekt of is ongeldig."""
@@ -88,44 +107,62 @@ def _get(path: str, params: dict) -> list:
     return response.json()
 
 
-def _paginated_get(path: str, since: datetime, until: datetime | None = None) -> list:
+def _format_cursor(cursor_dt: datetime, cursor_field: str) -> int | str:
+    """Zet een cursor-datetime om naar de vorm die het gekozen veld verwacht."""
+    if cursor_field == ENTRIES_CURSOR_FIELD:
+        return int(cursor_dt.timestamp() * 1000)
+    # created_at: milliseconde-precisie ISO 8601 met Z-suffix, exact het
+    # formaat dat Nightscout zelf in created_at opslaat.
+    return cursor_dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+
+def _parse_item_time(item: dict, cursor_field: str) -> datetime | None:
+    """Lees het tijdstip van een document uit het veld waar dit endpoint op filtert."""
+    if cursor_field not in item:
+        return None
+    if cursor_field == ENTRIES_CURSOR_FIELD:
+        return datetime.fromtimestamp(item[cursor_field] / 1000, tz=timezone.utc)
+    return datetime.fromisoformat(item[cursor_field].replace("Z", "+00:00"))
+
+
+def _paginated_get(
+    path: str, since: datetime, until: datetime | None, cursor_field: str
+) -> list:
     """Haal alle documenten op tussen `since` en `until` (of tot nu), pagina voor pagina.
 
     Zie de toelichting bij _PAGE_SIZE hierboven voor waarom dit niet één
-    verzoek met een groot `count` kan zijn (BUG: dat leverde bij een
-    meerdaags rapport stilzwijgend alleen de laatste ~3-4 dagen op, ongeacht
-    de gekozen periode). Elke pagina wordt opgevraagd met `find[date][$lte]`
-    net onder de oudste timestamp van de vorige pagina, zodat elk document
-    precies één keer terugkomt. Stopt zodra de oudste timestamp in een pagina
-    op of voorbij `since` ligt, of zodra de server minder dan een volle
-    pagina teruggeeft (dan is er geen oudere data meer, punt).
+    verzoek met een groot `count` kan zijn, en waarom `cursor_field` per
+    endpoint verschilt en nooit wordt weggelaten (BUG, zowel de originele
+    count-truncatie als treatments' verborgen ~4-dagenvenster zonder
+    expliciet find[created_at]-filter). Elke pagina wordt opgevraagd met een
+    cursor net onder de oudste timestamp van de vorige pagina, zodat elk
+    document precies één keer terugkomt. Stopt zodra de oudste timestamp in
+    een pagina op of voorbij `since` ligt, of zodra de server minder dan een
+    volle pagina teruggeeft (dan is er geen oudere data meer, punt).
     """
-    since_ms = int(since.timestamp() * 1000)
-    cursor_ms = int(until.timestamp() * 1000) if until is not None else None
+    cursor_dt = until if until is not None else datetime.now(timezone.utc)
 
     results: list = []
     for _ in range(_MAX_PAGES):
-        params = {"count": _PAGE_SIZE}
-        if cursor_ms is not None:
-            params["find[date][$lte]"] = cursor_ms
+        params = {"count": _PAGE_SIZE, f"find[{cursor_field}][$lte]": _format_cursor(cursor_dt, cursor_field)}
         page = _get(path, params)
         if not page:
             break
         results.extend(page)
 
-        dates = [item["date"] for item in page if "date" in item]
-        if not dates:
+        item_times = [t for t in (_parse_item_time(item, cursor_field) for item in page) if t is not None]
+        if not item_times:
             break
-        oldest_ms = min(dates)
-        if oldest_ms <= since_ms or len(page) < _PAGE_SIZE:
+        oldest_dt = min(item_times)
+        if oldest_dt <= since or len(page) < _PAGE_SIZE:
             break
-        cursor_ms = oldest_ms - 1
+        cursor_dt = oldest_dt - timedelta(milliseconds=1)
     return results
 
 
 def _entries_since(since: datetime, until: datetime | None = None) -> pd.DataFrame:
     """Haal entries op sinds `since` (en optioneel tot `until`), lokaal gefilterd."""
-    data = _paginated_get("/api/v1/entries/sgv.json", since, until)
+    data = _paginated_get("/api/v1/entries/sgv.json", since, until, ENTRIES_CURSOR_FIELD)
 
     if not data:
         return pd.DataFrame(columns=["timestamp", "mmol"])
@@ -141,7 +178,7 @@ def _entries_since(since: datetime, until: datetime | None = None) -> pd.DataFra
 
 def _treatments_since(since: datetime, until: datetime | None = None) -> pd.DataFrame:
     """Haal treatments op sinds `since` (en optioneel tot `until`), lokaal gefilterd."""
-    data = _paginated_get("/api/v1/treatments.json", since, until)
+    data = _paginated_get("/api/v1/treatments.json", since, until, TREATMENTS_CURSOR_FIELD)
 
     if not data:
         return pd.DataFrame(columns=["timestamp", "eventType", "insulin", "carbs"])