Changeset f3a2556 in Klonkt

Timestamp:

08/08/2026 06:35:21 AM (5 weeks ago)

Author:

roboburr <roboburr@…>

Branches:

main

Children:

2bfe26c

Parents:

cf5073b

git-author:

Robin <roboburr@…> (08/08/2026 06:35:19 AM)

git-committer:

roboburr <roboburr@…> (08/08/2026 06:35:21 AM)

Message:

De apps kunnen nu zien wat er voor een ward gated is (shaer-ahy.1)

Bart: iOS en Android op hetzelfde plan als de PWA. Dit is het blokkerende stuk --
zonder dit kan geen app een poort tonen.

wardsCollection gaf {id, handle, since}. Een app kon een ward dus wel TONEN maar
niets over hem zeggen, en dat is precies de helft van het antwoord op "wat mag
dit kind". Er zit nu shaer:gates bij: dezelfde rijen als het PWA-paneel, met
soort, drempel, lopend voorstel en omkeerbaarheid.

UIT DEZELFDE FUNCTIE, en dat is de kern. wardGates stond in routes/guardian.js
en daar kon alleen de PWA erbij. Een tweede berekening ernaast zou vroeg of laat
een ander antwoord geven op dezelfde vraag -- geen schoonheidsfoutje, maar twee
guardians die een verschillend beeld van hetzelfde kind krijgen. Verplaatst naar
queues.js; beide schermen lezen er nu uit, en een toets vergelijkt de twee
uitkomsten letterlijk met deepEqual.

Suite 688/688; zonder de nieuwe regel vallen er twee om.

Files:

• src/routes/guardian.js (modified) (5 diffs)
• src/services/guardianship/index.js (modified) (1 diff)
• src/services/guardianship/queues.js (modified) (3 diffs)
• test/guardian-gate-panel.test.js (modified) (1 diff)

src/routes/guardian.js

@@ -123 +123 @@
       embeds: wardEmbedSetting(w.other_uri),
       playback: wardPlaybackSetting(w.other_uri),
-      guardians: wardGuardianStatuses(w.other_uri),
+      guardians: Guardianship.queues.wardGuardianStatuses(w.other_uri),
       // What THIS guardian proposed for this ward and how it stands (5.6):
       // open, accepted, rejected, or expired when the window ran out and the
@@ -135 +135 @@
       // de drempel (shaer-ahy.1). Losse knoppen lieten een guardian zelf
       // uitzoeken wat er allemaal geldt; wat niet verstelbaar is stond nergens.
-      gates: wardGates(site.slug, w.other_uri),
+      gates: Guardianship.queues.wardGates(site.slug, w.other_uri),
     })),
     offers: Guardianship.offersCollection(`${me}/queues/offers`, site.slug, me).orderedItems,
@@ -155 +155 @@
 }
 
-/** The guardians of a ward WE host, with availability (3.6.1: owner-only in
- *  spirit; the co-guardians are among the owners of the relationship). Null
- *  for a remote ward: its server tracks availability, not us. */
-function wardGuardianStatuses(wardUri) {
-  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
-  if (!base || !String(wardUri || '').startsWith(`${base}/`)) return null;
-  const slug = String(wardUri).trim().replace(/\/+$/, '').split('/').pop();
-  try {
-    const uris = Guardianship.listGuardians(slug).map((g) => ({ uri: g.other_uri, handle: g.other_handle }));
-    const st = Object.fromEntries(
-      Guardianship.availability.statusesFor(slug, uris.map((u) => u.uri), Date.now()).map((s) => [s.id, s]),
-    );
-    return uris.map((u) => ({
-      uri: u.uri,
-      handle: u.handle,
-      availability: (st[u.uri] || {})['shaer:availability'] || 'active',
-      awayUntil: (st[u.uri] || {})['shaer:awayUntil'] || null,
-      lapse: (st[u.uri] || {})['shaer:lapse'] || null,
-    }));
-  } catch { return null; }
-}
 
 // ── The PWA page ─────────────────────────────────────────────────────────
@@ -578 +557 @@
     return res.status(403).json({ error: 'not_my_ward' });
   }
-  const local = wardGuardianStatuses(uri);
+  const local = Guardianship.queues.wardGuardianStatuses(uri);
   if (local) return res.json({ local: true, guardians: local });
   const doc = await AP.fetchActor(uri).catch(() => null);
@@ -613 +592 @@
 /** The playback gate of a ward we host (5.6): the heavier sibling. */
 function wardPlaybackSetting(uri) { return wardGateSetting(uri, 'external_playback'); }
-/**
- * De gate-rijen van een ward voor het paneel.
- *
- * De standen komen uit onze eigen kolommen als we het kind hosten; bij een ward
- * elders weten we ze niet en blijft het NULL -- onbekend, niet uit. Het aantal
- * guardians idem: dat wordt op de server van die ward bijgehouden, en zonder dat
- * getal wordt er geen drempel verzonnen.
- */
-function wardGates(mySlug, wardUri) {
-  const statuses = wardGuardianStatuses(wardUri);
-  const wachtend = Guardianship.follows.listReviewsByDirection(mySlug, 'incoming')
-    .filter((r) => r.ward_uri === wardUri).length;
-  return Guardianship.gated.gateRows({
-    // Uit de BESLUITEN, niet uit onze eigen kolom. Er zijn geen lokale accounts:
-    // elke ward woont elders, dus wardEmbedSetting() gaf voor iedere ward null en
-    // stond er in het paneel overal "onbekend". Wat een guardian wel heeft is de
-    // uitslag van wat hij voorstelde.
-    settings: Object.fromEntries(Guardianship.gated.GATE_CATALOGUE
-      .filter((g) => g.available !== false && Guardianship.gated.featureColumn(g.feature))
-      .map((g) => [g.feature, Guardianship.gated.knownSetting(mySlug, wardUri, g.feature)])),
-    guardianCount: statuses ? statuses.length : null,
-    proposals: Guardianship.gated.listSent(mySlug, wardUri).map((p) => ({
-      feature: p.feature, value: !!p.value, status: Guardianship.gated.sentStatus(p, Date.now()),
-    })),
-    waiting: { 'shaer:follows': wachtend || undefined },
-  });
-}
 
 function wardGateSetting(uri, column) {

src/services/guardianship/index.js

@@ -32 +32 @@
 // §5.6 gated settings (decided by the guardians, enforced by the ward's server)
 export * as gated from './gated.js';
+export * as queues from './queues.js';
 // 5.2.1: wie er op een hulpvraag af is en wanneer hij is afgesloten (shaer-lgo)
 export * as help from './help.js';

src/services/guardianship/queues.js

@@ -14 +14 @@
 import * as outgoing from './outgoing.js';
 import * as follows from './follows.js';
+import * as gated from './gated.js';
 import * as handshake from './handshake.js';
 
@@ -94 +95 @@
 export function wardsCollection(id, slug) {
   const items = relations.listWards(slug)
-    .map((r) => ({ id: r.other_uri, 'shaer:handle': r.other_handle || undefined, since: r.created_at }));
+    .map((r) => ({
+      id: r.other_uri,
+      'shaer:handle': r.other_handle || undefined,
+      since: r.created_at,
+      // Alles wat voor dit kind gated is, met soort, drempel en lopend voorstel
+      // (shaer-ahy.1). Zonder dit kon een app wel een ward TONEN maar niets over
+      // hem zeggen -- en dat is precies de helft van het antwoord op "wat mag
+      // dit kind". Dezelfde rijen als het PWA-paneel, uit dezelfde functie.
+      'shaer:gates': wardGates(slug, r.other_uri),
+    }));
   return collection(id, items);
 }
@@ -105 +115 @@
 }
 
-export default { offersCollection, followsCollection, outgoingFollowsCollection, wardsCollection, guardiansCollection };
+export default { offersCollection, followsCollection, outgoingFollowsCollection, wardsCollection, guardiansCollection, wardGates, wardGuardianStatuses };
+
+// ── Wat er voor een ward gated is (shaer-ahy.1) ─────────────────────────
+//
+// STOND IN routes/guardian.js, en daar kon alleen de PWA erbij. De Shaer-apps
+// lezen dezelfde toestand via de wards-queue, en een tweede berekening naast
+// deze zou vroeg of laat een ander antwoord geven op dezelfde vraag -- dat is
+// hier geen schoonheidsfoutje maar twee guardians die een verschillend beeld
+// van hetzelfde kind krijgen. Een plek dus, en beide schermen lezen eruit.
+/** The guardians of a ward WE host, with availability (3.6.1: owner-only in
+ *  spirit; the co-guardians are among the owners of the relationship). Null
+ *  for a remote ward: its server tracks availability, not us. */
+export function wardGuardianStatuses(wardUri) {
+  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
+  if (!base || !String(wardUri || '').startsWith(`${base}/`)) return null;
+  const slug = String(wardUri).trim().replace(/\/+$/, '').split('/').pop();
+  try {
+    const uris = relations.listGuardians(slug).map((g) => ({ uri: g.other_uri, handle: g.other_handle }));
+    const st = Object.fromEntries(
+      availability.statusesFor(slug, uris.map((u) => u.uri), Date.now()).map((s) => [s.id, s]),
+    );
+    return uris.map((u) => ({
+      uri: u.uri,
+      handle: u.handle,
+      availability: (st[u.uri] || {})['shaer:availability'] || 'active',
+      awayUntil: (st[u.uri] || {})['shaer:awayUntil'] || null,
+      lapse: (st[u.uri] || {})['shaer:lapse'] || null,
+    }));
+  } catch { return null; }
+}
+/**
+ * De gate-rijen van een ward voor het paneel.
+ *
+ * De standen komen uit onze eigen kolommen als we het kind hosten; bij een ward
+ * elders weten we ze niet en blijft het NULL -- onbekend, niet uit. Het aantal
+ * guardians idem: dat wordt op de server van die ward bijgehouden, en zonder dat
+ * getal wordt er geen drempel verzonnen.
+ */
+export function wardGates(mySlug, wardUri) {
+  const statuses = wardGuardianStatuses(wardUri);
+  const wachtend = follows.listReviewsByDirection(mySlug, 'incoming')
+    .filter((r) => r.ward_uri === wardUri).length;
+  return gated.gateRows({
+    // Uit de BESLUITEN, niet uit onze eigen kolom. Er zijn geen lokale accounts:
+    // elke ward woont elders, dus wardEmbedSetting() gaf voor iedere ward null en
+    // stond er in het paneel overal "onbekend". Wat een guardian wel heeft is de
+    // uitslag van wat hij voorstelde.
+    settings: Object.fromEntries(gated.GATE_CATALOGUE
+      .filter((g) => g.available !== false && gated.featureColumn(g.feature))
+      .map((g) => [g.feature, gated.knownSetting(mySlug, wardUri, g.feature)])),
+    guardianCount: statuses ? statuses.length : null,
+    proposals: gated.listSent(mySlug, wardUri).map((p) => ({
+      feature: p.feature, value: !!p.value, status: gated.sentStatus(p, Date.now()),
+    })),
+    waiting: { 'shaer:follows': wachtend || undefined },
+  });
+}

test/guardian-gate-panel.test.js

@@ -145 +145 @@
   }
 });
+
+// ── Dezelfde poorten voor het paneel en voor de apps (shaer-ahy.1) ───────
+
+test('de wards-queue draagt de poorten mee', async () => {
+  // Zonder dit kon een app een ward wel TONEN maar niets over hem zeggen. De
+  // apps lezen deze collectie; het PWA-paneel leest wardGates rechtstreeks.
+  const q = await import('../src/services/guardianship/queues.js');
+  const rel = await import('../src/services/guardianship/relations.js');
+  const dbm = await import('../src/config/database.js');
+  dbm.initializeDatabase();
+  dbm.default.prepare('INSERT OR IGNORE INTO users (id, username, email, password_hash, role) VALUES (?,?,?,?,?)')
+    .run('gu', 'gu', 'gu@t', 'x', 'god');
+  dbm.default.prepare('INSERT OR IGNORE INTO sites (id, slug, title, owner_id) VALUES (?,?,?,?)').run('gs', 'oma', 'Oma', 'gu');
+  rel.commitWardForGuardian('oma', 'https://elders/ap/users/kind', { handle: '@kind' });
+
+  const coll = q.wardsCollection('https://x/queues/wards', 'oma');
+  const ward = coll.orderedItems.find((w) => w.id === 'https://elders/ap/users/kind');
+  assert.ok(ward, 'de ward staat in de collectie');
+  assert.ok(Array.isArray(ward['shaer:gates']), 'en draagt zijn poorten');
+  assert.equal(ward['shaer:gates'].length, gated.GATE_CATALOGUE.length);
+});
+
+test('de app krijgt PRECIES dezelfde rijen als het paneel', async () => {
+  // Twee berekeningen naast elkaar geven vroeg of laat een ander antwoord op
+  // dezelfde vraag, en dat is hier geen schoonheidsfoutje: dan krijgen twee
+  // guardians een verschillend beeld van hetzelfde kind.
+  const q = await import('../src/services/guardianship/queues.js');
+  const coll = q.wardsCollection('https://x/queues/wards', 'oma');
+  const uitQueue = coll.orderedItems.find((w) => w.id === 'https://elders/ap/users/kind')['shaer:gates'];
+  const uitPaneel = q.wardGates('oma', 'https://elders/ap/users/kind');
+  assert.deepEqual(uitQueue, uitPaneel);
+});