@bongos/core 1.21.57 → 1.21.59

package/tests/applicant_profile_boundary.mjs

@@ -248,9 +248,18 @@ function activityScope(sql, params) {
 const CLIENT = { client_id: 'client-alpha', secret_hash: null, name: 'Alpha', redirect_uris: [], origin: 'https://alpha.example', owner_github_id: '1', status: 'active' };
 const OTHER_CLIENT = { client_id: 'client-beta', secret_hash: null, name: 'Beta', redirect_uris: [], origin: 'https://beta.example', owner_github_id: '2', status: 'active' };
 // (github_id, client_id) pairs the HUB witnessed, and whether they are inside
-// the read-time window. Only PUB and PRIVOUT applied to alpha.
+// the read-time window. Only PUB and PRIVOUT applied to alpha. An echo may carry
+// the guild the application was made with (task 1002303, ADR 0365 D5).
 let ECHOES = [];
 
+// The guilds an echo can name, and who is (still) in them.
+const GUILDS = [
+  { id: '81', slug: 'open-guild', name: 'Open Guild', visibility: 'public' },
+  { id: '82', slug: 'quiet-guild', name: 'Quiet Guild', visibility: 'unlisted' },
+];
+let GUILD_MEMBERS = [];
+let labelFails = false;
+
 let calls = [];
 const pool = {
   query: async (text, params = []) => {
@@ -262,6 +271,28 @@ const pool = {
       return { rows: hit ? [{ ...hit }] : [], rowCount: hit ? 1 : 0 };
     }
 
+    // THE GUILD LABEL (guild-engagements.js echoGuildLabel). Its membership
+    // requirement is a JOIN, so the join is read rather than assumed: drop it
+    // and an applicant who LEFT the guild genuinely keeps the label here.
+    if (/^SELECT g\.slug, g\.name, g\.visibility FROM platform_identity_application_echoes ae /.test(sql)) {
+      if (labelFails) throw new Error('the guild tables are on fire');
+      const m = /^SELECT g\.slug, g\.name, g\.visibility FROM platform_identity_application_echoes ae (.+?) WHERE (.+?) LIMIT 1$/.exec(sql);
+      if (!m) throw new Error(`fake pool: the label read moved — ${sql}`);
+      if (!/^JOIN platform_identity_guilds g ON g\.id = ae\.guild_id\b/.test(m[1])) throw new Error(`fake pool: the label join moved — ${m[1]}`);
+      const rest = m[1].replace(/^JOIN platform_identity_guilds g ON g\.id = ae\.guild_id/, '').trim();
+      const mustBeMember = rest === 'JOIN platform_identity_guild_members m ON m.guild_id = ae.guild_id AND m.github_id = ae.github_id';
+      if (rest && !mustBeMember) throw new Error(`fake pool: unmodelled label join — ${rest}`);
+      assert.equal(m[2], 'ae.github_id = $1::bigint AND ae.client_id = $2 AND ae.applied_at > now() - make_interval(days => $3::int)',
+        'the label reads ONE echo — this account, this client, inside the 30-day window');
+      assert.equal(params[2], 30);
+      const rows = ECHOES
+        .filter((e) => String(e.github_id) === String(params[0]) && e.client_id === params[1] && e.in_window && e.guild_id)
+        .filter((e) => !mustBeMember || GUILD_MEMBERS.some((gm) => gm.guild_id === e.guild_id && gm.github_id === String(e.github_id)))
+        .map((e) => GUILDS.find((g) => g.id === e.guild_id))
+        .map((g) => ({ slug: g.slug, name: g.name, visibility: g.visibility, id: g.id }));
+      return { rows: rows.slice(0, 1), rowCount: Math.min(rows.length, 1) };
+    }
+
     // The GATE's own read. The window term is modelled explicitly rather than
     // waved through: an echo outside it must stop working, and a fake that
     // ignored `applied_at` would make that untestable.
@@ -584,6 +615,78 @@ test('a real applicant resolves, uncacheable, through the gate', async () => {
     'a cached applicant view is a snapshot, which is the one thing "live at review time" forbids');
 });
 
+// ---------------------------------------------------------------------------
+// The guild label (task 1002303, ADR 0365 D5): { profile, guild }
+// ---------------------------------------------------------------------------
+
+const labelReads = () => calls.filter((c) => /FROM platform_identity_application_echoes ae /.test(c.sql));
+
+test('the guild label: { slug, name } beside the profile while the applicant is still in the guild', async () => {
+  ECHOES = [{ github_id: PUB, client_id: CLIENT.client_id, in_window: true, guild_id: '81' }];
+  GUILD_MEMBERS = [{ guild_id: '81', github_id: PUB }];
+  labelFails = false;
+  const r = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PUB });
+  assert.equal(r.status, 200);
+  assert.deepEqual(Object.keys(r.json).sort(), ['guild', 'profile'], 'the label sits BESIDE the profile, never inside it');
+  assert.equal(r.json.profile.view, VIEW_PUBLIC);
+  assert.deepEqual(r.json.guild, { slug: 'open-guild', name: 'Open Guild' }, 'a slug and a name — no guild id, no visibility');
+  assert.equal(labelReads()[0].params[1], CLIENT.client_id, 'asked about the AUTHENTICATED client');
+});
+
+test('the guild label: an UNLISTED guild is named with slug null — it has no public page to open', async () => {
+  ECHOES = [{ github_id: PRIVOUT, client_id: CLIENT.client_id, in_window: true, guild_id: '82' }];
+  GUILD_MEMBERS = [{ guild_id: '82', github_id: PRIVOUT }];
+  labelFails = false;
+  const r = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PRIVOUT });
+  assert.equal(r.json.profile.view, VIEW_SLIVER);
+  assert.deepEqual(r.json.guild, { slug: null, name: 'Quiet Guild' });
+});
+
+test('the guild label: null once the applicant LEFT the guild, and null for a solo application', async () => {
+  ECHOES = [{ github_id: PUB, client_id: CLIENT.client_id, in_window: true, guild_id: '81' }];
+  GUILD_MEMBERS = [];
+  labelFails = false;
+  const left = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PUB });
+  assert.equal(left.json.profile.view, VIEW_PUBLIC);
+  assert.equal(left.json.guild, null, 'a guild they are no longer in does not vouch for them');
+
+  ECHOES = [{ github_id: PUB, client_id: CLIENT.client_id, in_window: true, guild_id: null }];
+  GUILD_MEMBERS = [{ guild_id: '81', github_id: PUB }];
+  const solo = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PUB });
+  assert.equal(solo.json.guild, null);
+});
+
+test('the guild label: null whenever the profile is null — and then not even read', async () => {
+  ECHOES = [{ github_id: PROV, client_id: CLIENT.client_id, in_window: true, guild_id: '81' }];
+  GUILD_MEMBERS = [{ guild_id: '81', github_id: PROV }];
+  labelFails = false;
+  const r = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PROV });
+  assert.equal(r.status, 200);
+  assert.equal(r.json.profile, null);
+  assert.equal(r.json.guild, null, 'an applicant who discloses nothing discloses no guild either');
+  assert.deepEqual(labelReads(), [], 'the label is read only beside a profile');
+});
+
+test('the guild label is BEST-EFFORT: a failed read answers guild null and never costs the profile', async () => {
+  ECHOES = [{ github_id: PUB, client_id: CLIENT.client_id, in_window: true, guild_id: '81' }];
+  GUILD_MEMBERS = [{ guild_id: '81', github_id: PUB }];
+  labelFails = true;
+  try {
+    const r = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PUB });
+    assert.equal(r.status, 200);
+    assert.equal(r.json.profile.view, VIEW_PUBLIC);
+    assert.equal(r.json.guild, null);
+  } finally { labelFails = false; }
+});
+
+test('the guild label waits behind the echo gate: no application, no label read', async () => {
+  ECHOES = [{ github_id: PUB, client_id: OTHER_CLIENT.client_id, in_window: true, guild_id: '81' }];
+  GUILD_MEMBERS = [{ guild_id: '81', github_id: PUB }];
+  const r = await post('/api/bongos/sso/applicant-profile', { ...creds, github_id: PUB });
+  assert.equal(r.status, 404);
+  assert.deepEqual(labelReads(), []);
+});
+
 test('bad credentials are refused before anything is read', async () => {
   ECHOES = [{ github_id: PUB, client_id: CLIENT.client_id, in_window: true }];
   const r = await post('/api/bongos/sso/applicant-profile', { client_id: CLIENT.client_id, client_secret: 'wrong', github_id: PUB });

package/tests/application_echo.mjs

@@ -75,7 +75,17 @@ test('the write is an upsert on the pair, refreshing the date (D1.4)', async ()
   const [{ sql, params }] = pool.calls;
   assert.match(sql, /ON CONFLICT \(github_id, client_id\) DO UPDATE SET applied_at = now\(\)/,
     're-applying is a success, so a second ask refreshes rather than erroring or piling up a row');
-  assert.deepEqual(params, [String(ME), 'proj-a']);
+  assert.deepEqual(params, [String(ME), 'proj-a', null], 'a solo application binds NO guild');
+});
+
+test('the write carries the guild the application was made with, and every upsert rewrites it (task 1002303, ADR 0365 D1)', async () => {
+  const pool = recorder();
+  await recordApplication({ githubId: ME, clientId: 'proj-a', guildId: 71 }, { pool });
+  const [{ sql, params }] = pool.calls;
+  assert.match(sql, /INSERT INTO platform_identity_application_echoes \(github_id, client_id, applied_at, guild_id\) VALUES \(\$1::bigint, \$2, now\(\), \$3::bigint\)/);
+  assert.match(sql, /DO UPDATE SET applied_at = now\(\), guild_id = EXCLUDED\.guild_id$/,
+    'the most recent application decides the label: a later solo one writes NULL over it');
+  assert.deepEqual(params, [String(ME), 'proj-a', '71']);
 });
 
 test('neither function carries a status, because the table holds none', async () => {
@@ -106,6 +116,10 @@ let echoFails = false;
 let statements = [];
 let account = null;
 let accountFails = false;
+// (session, guild slug, client) triples that resolve to an engagement for the
+// join's `guild` field (task 1002303).
+const ENGAGED = [{ github_id: ME, slug: 'guild-a', client_id: 'proj-open', guild_id: '71' }];
+let engagementFails = false;
 
 function seed() {
   const now = Date.now();
@@ -128,6 +142,7 @@ function seed() {
     { client_id: 'proj-invited', membership_kind: 'pending', joined_at: now - DAY, last_active: null, project_name: 'Invited', project_origin: 'https://invited.example', owner_github_id: null },
   ];
   echoFails = false;
+  engagementFails = false;
   statements = [];
   // An account that has cleared the consent floor: active, and the platform
   // terms accepted (account-visibility.js isAccountActive).
@@ -238,13 +253,28 @@ const pool = {
 
     if (/^INSERT INTO platform_identity_application_echoes/.test(sql)) {
       if (echoFails) throw new Error('echo table is on fire');
-      const [githubId, clientId] = params;
+      const [githubId, clientId, guildId = null] = params;
+      // The conflict branch is READ from the statement, so dropping the guild_id
+      // rewrite from it genuinely leaves a stale label behind (task 1002303).
+      const rewritesGuild = /DO UPDATE SET .*\bguild_id = EXCLUDED\.guild_id\b/.test(sql);
       const existing = echoes.find((e) => String(e.github_id) === String(githubId) && e.client_id === clientId);
-      if (existing) existing.applied_at = Date.now();
-      else echoes.push({ github_id: Number(githubId), client_id: clientId, applied_at: Date.now() });
+      if (existing) {
+        existing.applied_at = Date.now();
+        if (rewritesGuild) existing.guild_id = guildId;
+      } else echoes.push({ github_id: Number(githubId), client_id: clientId, applied_at: Date.now(), guild_id: guildId });
       return { rows: [] };
     }
 
+    // The join's guild check (guild-engagements.js engagementFor) — the rule
+    // itself is interpreted in tests/guild_engagement.mjs; here only WHICH guild
+    // resolves for whom matters, keyed on the bound session, slug and client.
+    if (/^SELECT g\.id, g\.slug, g\.name FROM platform_identity_guild_members m /.test(sql)) {
+      if (engagementFails) throw new Error('engagement table is on fire');
+      assert.match(sql, /lower\(g\.slug\) = \$2 AND e\.client_id = \$3 LIMIT 1$/);
+      const hit = ENGAGED.find((x) => String(params[0]) === String(x.github_id) && params[1] === x.slug && params[2] === x.client_id);
+      return { rows: hit ? [{ id: hit.guild_id, slug: hit.slug, name: hit.slug }] : [] };
+    }
+
     if (/FROM platform_identity_application_echoes e/.test(sql)) {
       if (echoFails) throw new Error('echo table is on fire');
       m = /WHERE (.+?) ORDER BY/.exec(sql);
@@ -342,7 +372,7 @@ function call(method, pathname, body) {
     req.end(payload);
   });
 }
-const join = (note) => call('POST', '/api/bongos/my-projects/join', { origin: 'https://target.example', note });
+const join = (note, guild) => call('POST', '/api/bongos/my-projects/join', { origin: 'https://target.example', note, ...(guild === undefined ? {} : { guild }) });
 
 test('the interpreter refuses a predicate it cannot read — parameterised or not', () => {
   assert.throws(() => predicateFor('github_id = $1::bigint AND something = $2', [1, 2]), /unread predicate on \$2/);
@@ -414,6 +444,62 @@ test('a failed echo write never turns a filed application into a reported failur
   assert.equal(r.json.status, 'requested');
 });
 
+// ── applying WITH a guild (task 1002303, ADR 0365 D2) ─────────────────────────
+// The guild is resolved for the SESSION before anything is relayed; one that
+// no longer resolves relays nothing and echoes nothing, and one that does is the
+// label the echo carries until the next application rewrites it.
+
+test('a `guild` that no longer resolves is a 409 guild_engagement_gone, with nothing relayed and no echo', async () => {
+  for (const guild of ['other-guild', 'Not A Slug!', '']) {
+    seed();
+    echoes = echoes.filter((e) => e.client_id !== 'proj-open');
+    relay = { status: 201, body: { ok: true } };
+    const r = await join('please', guild);
+    assert.equal(r.status, 409, `guild ${JSON.stringify(guild)}`);
+    assert.equal(r.json.error.code, 'guild_engagement_gone');
+    assert.equal(relayed, null, 'the project never heard of it — the applicant chose to apply WITH the guild');
+    assert.equal(echo('proj-open'), undefined);
+  }
+});
+
+test('a guild that resolves is checked for the SESSION, relayed as an ordinary application, and lands on the echo', async () => {
+  seed();
+  echoes = echoes.filter((e) => e.client_id !== 'proj-open');
+  relay = { status: 201, body: { ok: true } };
+  const r = await join('please', 'Guild-A');
+  assert.equal(r.status, 200);
+  assert.equal(r.json.status, 'requested');
+  assert.ok(relayed, 'relayed');
+  assert.deepEqual(Object.keys(JSON.parse(relayed.init.body)).sort(), ['display_name', 'github_login', 'note'],
+    'no new field reaches the project: the label travels on the applicant-profile read (ADR 0365 D5)');
+  const check = statements.find((x) => /^SELECT g\.id, g\.slug, g\.name FROM platform_identity_guild_members/.test(x.sql));
+  assert.deepEqual(check.params.slice(0, 3), [String(ME), 'guild-a', 'proj-open'], 'the session, the canonical slug, the resolved client');
+  assert.equal(echo('proj-open').guild_id, '71');
+});
+
+test('a later solo application clears the guild label — the most recent application decides', async () => {
+  seed();
+  relay = { status: 201, body: { ok: true } };
+  await join('with them', 'guild-a');
+  assert.equal(echo('proj-open').guild_id, '71');
+  await join('on my own');
+  assert.equal(echo('proj-open').guild_id, null);
+});
+
+test('a refused application leaves no echo even with a guild, and a broken guild check relays nothing', async () => {
+  seed();
+  echoes = echoes.filter((e) => e.client_id !== 'proj-open');
+  relay = { status: 403, body: { error: { code: 'invite_only' } } };
+  assert.equal((await join(undefined, 'guild-a')).json.status, 'invite_only');
+  assert.equal(echo('proj-open'), undefined);
+
+  seed();
+  engagementFails = true;
+  const r = await join(undefined, 'guild-a');
+  assert.equal(r.status, 500, 'a label the hub cannot verify is never attached by guesswork');
+  assert.equal(relayed, null);
+});
+
 // ── the vouch the relay carries (R09, task 1002285; ADR 0201 D2) ─────────────
 // The ECHO above is what authorizes the project's later profile read
 // (applicationBacksProfileRead); the VOUCH is what tells the project whose

package/tests/focus_version_filter_default.mjs

@@ -0,0 +1,47 @@
+// tests/focus_version_filter_default.mjs — the Goals page and Tasks board open their
+// Version filter on the project's focus version (task 1004552). The decision is the
+// pure task-lib helper; the two pages are pinned to calling it after their options fill.
+//
+// Run:  node --test tests/focus_version_filter_default.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { focusVersionDefault } = require('../modules/hall-ui/public/task-lib.js');
+const src = (rel) => readFileSync(new URL('../' + rel, import.meta.url), 'utf8');
+const opts = ['', 'BONGOS-V1', 'BONGOS-V2'];
+
+test('a starred version is the default the filter opens on', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V2', optionValues: opts, current: '' }), 'BONGOS-V2');
+});
+
+test('no focus leaves the filter on any — nothing is guessed', () => {
+  for (const focusId of [null, undefined, '']) {
+    assert.equal(focusVersionDefault({ focusId, optionValues: opts, current: '' }), null);
+  }
+});
+
+test('a URL filter wins over the focus default', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V2', optionValues: opts, current: '', urlValue: 'BONGOS-V1' }), null);
+});
+
+test('a choice the builder already made wins over the focus default', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V2', optionValues: opts, current: 'BONGOS-V1' }), null);
+});
+
+test('a focus the select has no option for is left alone, not selected as a blank', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V9', optionValues: opts, current: '' }), null);
+});
+
+test('both pages read the focus and apply it after their version options fill', () => {
+  const work = src('modules/hall-ui/public/work.js');
+  assert.match(work, /\/versions\/focus/);
+  assert.match(work, /populateVersionFilter\(taskState\.versions\);\s*restoreUrlFilter\('f-version'\);\s*if \(applyFocusVersion\(focusResp\)\)/);
+  const goals = src('modules/hall-ui/public/goals-page.js');
+  assert.match(goals, /\/versions\/focus/);
+  assert.match(goals, /populateVersionFilter\(\);\s*applyFocusVersion\(focusResp\);/);
+  for (const page of [work, goals]) assert.match(page, /OTBTaskLib\.focusVersionDefault\(/);
+});