Changeset a9ede28 in Klonkt

Timestamp:

08/08/2026 07:56:50 AM (5 weeks ago)

Author:

roboburr <roboburr@…>

Branches:

main

Children:

66d97b8

Parents:

86e6a45

git-author:

Robin <roboburr@…> (08/08/2026 07:56:48 AM)

git-committer:

roboburr <roboburr@…> (08/08/2026 07:56:50 AM)

Message:

Open hulpvragen worden nooit afgekapt (shaer-6wt)

Ik vond dit zelf en zette het op P3: "vergt tientallen hulpvragen bij een
guardian". Bart: "precies de jeugdzorgmedewerker."

DAT IS GEEN RANDGEVAL MAAR EEN CASELOAD. Een professionele voogd heeft geen
handvol wards; voor hem zijn tientallen open hulpvragen een gewone dinsdag. De
gebruiker die deze machinerie het hardst nodig heeft was precies degene voor wie
hij brak, en ik had hem als uitzondering weggeschreven.

Wat er misging: de queue kapte op 50. Een oudere vraag zat er niet in, de app
vond geen staat, en toonde hem -- terecht, want bij twijfel OPEN -- alsof er nog
iemand op moest. Een allang afgehandelde hulpvraag die weer om aandacht vraagt.

De regel bij-twijfel-open blijft; die is goed. Wat verandert is dat de twijfel
verdwijnt: OPEN vragen worden nooit afgekapt, dus mag een app concluderen dat wat
er niet in staat ook niet open is. De geschiedenis mag wel afgekapt -- die vraagt
niets, en staat nog gewoon op de server.

shaer:openComplete op de collectie zegt dat die gevolgtrekking is toegestaan.
Ontbreekt de vlag (een oudere server), dan valt de app terug op bij-twijfel-open,
en dat is de veilige kant.

Toets met 120 open vragen. Suite 720/720; met de afkap terug valt er een om.

Files:

• src/services/guardianship/queues.js (modified) (3 diffs)
• test/activitypub-as2.test.js (modified) (1 diff)
• test/help-c2s.test.js (modified) (1 diff)

src/services/guardianship/queues.js

@@ -191 +191 @@
 // hetzelfde kind.
 
-/** De hulpvragen van deze guardian, met wie erop af is en of het dicht is. */
-export function helpItemsFor(slug, limit = 50) {
+/**
+ * De hulpvragen van deze guardian, met wie erop af is en of het dicht is.
+ *
+ * OPEN VRAGEN WORDEN NOOIT AFGEKAPT, en dat is geen ruimhartigheid maar de reden
+ * dat de app iets mag CONCLUDEREN uit afwezigheid (Barts punt, 8-8).
+ *
+ * Dit stond op 50, en ik noemde 'tientallen hulpvragen bij een guardian' een
+ * randgeval. Bart wees op de jeugdzorgmedewerker: die heeft geen handvol wards
+ * maar een caseload, en voor hem is dat een gewone dinsdag. De gebruiker die dit
+ * het hardst nodig heeft was precies degene voor wie het brak.
+ *
+ * Met een afkap op alles zag een app een oudere vraag niet in de queue, vond geen
+ * staat, en toonde hem -- terecht, want bij twijfel OPEN -- als openstaand. Een
+ * allang afgehandelde hulpvraag die weer om aandacht vraagt. Nu geldt: staat hij
+ * niet in de queue, dan is hij NIET open. Die gevolgtrekking klopt alleen zolang
+ * we open vragen volledig leveren.
+ *
+ * De geschiedenis mag wel afgekapt: die vraagt niets, en wat eraf valt is nog
+ * steeds op de server te vinden.
+ */
+export function helpItemsFor(slug, historyLimit = 50) {
   let rijen = [];
   try {
     rijen = db.prepare(
       `SELECT object_uri, actor_uri, actor_name, actor_handle, actor_icon, content, published, created_at
-       FROM ap_mentions WHERE slug = ? AND help_request = 1 ORDER BY created_at DESC LIMIT ?`,
-    ).all(slug, limit);
+       FROM ap_mentions WHERE slug = ? AND help_request = 1 ORDER BY created_at DESC`,
+    ).all(slug);
   } catch { return []; }
   const staat = help.statusFor(rijen.map((r) => r.object_uri));
   const mijn = new Set(relations.listWards(slug).map((w) => w.other_uri));
-  return rijen.map((r) => ({
+  const alles = rijen.map((r) => ({
     ...r,
     // Bij twijfel OPEN. Een hulpvraag die er afgehandeld uitziet terwijl hij dat
@@ -211 +230 @@
     ),
   }));
+  const open = alles.filter((h) => h.state.open);
+  const rest = alles.filter((h) => !h.state.open).slice(0, historyLimit);
+  return [...open, ...rest];
 }
 
@@ -231 +253 @@
     'shaer:formerWard': h.state.formerWard || undefined,
   }));
-  return collection(id, items);
-}
+  const coll = collection(id, items);
+  // Het teken dat de app mag concluderen uit afwezigheid: elke OPEN vraag zit
+  // hierin. Ontbreekt deze vlag (een oudere server), dan valt de app terug op
+  // bij-twijfel-open, en dat is de veilige kant.
+  coll['shaer:openComplete'] = true;
+  return coll;
+}

test/activitypub-as2.test.js

@@ -43 +43 @@
   // de feed en wisten niet of er al iemand op af was.
   'shaer:queues', 'offers', 'follows', 'outgoingFollows', 'wards', 'guardians', 'help',
+  // Elke OPEN hulpvraag zit in de collectie; daarom mag een app uit afwezigheid
+  // concluderen dat iets niet open is (shaer-6wt).
+  'shaer:openComplete',
   // ActivityPub §4.1 `endpoints` vocabulary (same category as sharedInbox), used for C2S.
   'oauthAuthorizationEndpoint', 'oauthTokenEndpoint', 'uploadMedia',

test/help-c2s.test.js

@@ -83 +83 @@
   assert.notEqual(uit.status, 400);
 });
+
+test('OPEN vragen worden nooit afgekapt, hoeveel het er ook zijn', () => {
+  // Barts punt (8-8): ik noemde tientallen hulpvragen bij een guardian een
+  // randgeval, maar voor een jeugdzorgmedewerker is dat een caseload en dus een
+  // gewone dinsdag. De gebruiker die dit het hardst nodig heeft was precies
+  // degene voor wie het brak.
+  //
+  // Zonder deze regel viel een oudere vraag buiten de queue, vond de app geen
+  // staat, en toonde hem -- terecht, want bij twijfel OPEN -- alsof er nog
+  // iemand op moest.
+  for (let i = 0; i < 120; i++) {
+    db.prepare(`INSERT INTO ap_mentions (slug, object_uri, actor_uri, actor_handle, content, help_request)
+                VALUES (?,?,?,?,?,1)`).run('oma', `https://elders.test/ap/notes/veel-${i}`, KIND, '@kind', '<p>help</p>');
+  }
+  const open = queues.helpItemsFor('oma').filter((h) => h.state.open);
+  assert.equal(open.length, 120, 'alle 120 open vragen komen mee');
+});
+
+test('de collectie zegt dat je uit afwezigheid mag concluderen', () => {
+  // Zonder die vlag mag een app niets afleiden uit een ontbrekende staat, en
+  // valt hij terug op bij-twijfel-open. Dat is de veilige kant, maar dan komt
+  // een afgehandelde vraag terug in het zicht.
+  const coll = queues.helpCollection('https://x/queues/help', 'oma');
+  assert.equal(coll['shaer:openComplete'], true);
+});