@bongos/core 1.19.237 → 1.19.239

package/tests/goal_membership_requests.mjs

@@ -1,6 +1,6 @@
 // tests/goal_membership_requests.mjs — private goals: the visibility flag + the
 // invite / join-request queue db layer (task 1951 / ADR 0112). DB-free: the
-// SQL-aware fake pool (the goal_member_roles.mjs precedent) pins each helper's
+// SQL-aware fake pool (the goal_member_kinds.mjs precedent) pins each helper's
 // SQL contract + return shaping. The route authorization gates are task 1952's
 // tests; this file pins the query layer under them.
 //
@@ -139,7 +139,7 @@ await test('resolveMembershipRequest: a lost race (nothing pending) → null', a
 // without a membership.
 await test('acceptMembershipRequestAndAddMember: one atomic CTE; returns { request, member }', async () => {
   const REQ = { ...REQUEST_ROW, status: 'accepted' };
-  const MEMBER = { goal_id: 1, builder_id: 2, role: 'member', joined_at: 'T2' };
+  const MEMBER = { goal_id: 1, builder_id: 2, membership_kind: 'member', joined_at: 'T2' };
   const pool = fakePool((s) => (/WITH resolved AS/.test(s) ? { rows: [{ request: REQ, member: MEMBER }] } : null));
   const out = await acceptMembershipRequestAndAddMember({ id: 10, resolvedBy: 5 }, { pool });
   assert.deepEqual(out, { request: REQ, member: MEMBER });
@@ -179,7 +179,7 @@ await test('listInboxFor: shapes {invitations, joinRequests, myPendingRequests}'
 await test('listInboxFor: joinRequests gates on owner (created_by) OR manager (lead)', async () => {
   const pool = fakePool(() => ({ rows: [] }));
   await listInboxFor(95, { pool });
-  const jq = find(pool.queries, /r\.kind = 'request'.*g\.created_by = \$1.*role = 'lead'/);
+  const jq = find(pool.queries, /r\.kind = 'request'.*g\.created_by = \$1.*membership_kind = 'lead'/);
   assert.ok(jq, 'a join-request only reaches an owner or a manager of the goal');
   // and it must not leak: the same $1 builder id feeds every bucket.
   for (const q of pool.queries) assert.deepEqual(q.params, [95]);
@@ -207,30 +207,30 @@ await test('listPendingRequestsForGoal: pending both-kinds for one goal', async
 // stamped 'rejected' on someone who is in fact a member.
 // =========================================================================
 
-const ADD_MEMBER_ROW = { goal_id: 7, builder_id: 42, role: 'member', joined_at: 'T0' };
+const ADD_MEMBER_ROW = { goal_id: 7, builder_id: 42, membership_kind: 'member', joined_at: 'T0' };
 const addMemberPool = () => fakePool((s) => (/^WITH added AS/.test(s) ? { rows: [ADD_MEMBER_ROW] } : null));
 
 // join-cancels-request: the joiner arrives under their own steam.
 await test('addGoalMember: a join cancels the joiner\'s pending ask in ONE statement', async () => {
   const pool = addMemberPool();
-  const out = await addGoalMember({ goalId: 7, builderId: 42, role: 'member', resolvedBy: 42 }, { pool });
+  const out = await addGoalMember({ goalId: 7, builderId: 42, membershipKind: 'member', resolvedBy: 42 }, { pool });
   assert.deepEqual(out, ADD_MEMBER_ROW, 'still returns the member row — the route response shape is unchanged');
   assert.equal(pool.queries.length, 1, 'ONE statement: the cancel commits with the membership write or not at all');
   const q = find(pool.queries, /^WITH added AS/);
-  assert.ok(/INSERT INTO goal_members[\s\S]*ON CONFLICT \(goal_id, builder_id\) DO UPDATE SET role = goal_members\.role/.test(norm(q.sql)),
-    'the membership upsert is the first arm, role still preserved (task 1002689)');
+  assert.ok(/INSERT INTO goal_members[\s\S]*ON CONFLICT \(goal_id, builder_id\) DO UPDATE SET membership_kind = goal_members\.membership_kind/.test(norm(q.sql)),
+    'the membership upsert is the first arm, membership_kind still preserved (task 1002689)');
   assert.ok(/UPDATE goal_membership_requests[\s\S]*SET status = 'cancelled', resolved_by = \$4/.test(norm(q.sql)),
     'the second arm closes the ask as cancelled, attributed to the actor');
   assert.ok(/WHERE goal_id = \$1 AND builder_id = \$2 AND status = 'pending'/.test(norm(q.sql)),
     'scoped to THIS goal+builder, and only a pending row');
-  assert.deepEqual(q.params, [7, 42, 'member', 42], 'goal, builder, role, resolvedBy — in that order');
+  assert.deepEqual(q.params, [7, 42, 'member', 42], 'goal, builder, membership_kind, resolvedBy — in that order');
 });
 
 // add-cancels-request: an owner/manager/Archon admits them directly. Same
 // statement; resolvedBy is the ADDER, so the audit trail names who admitted them.
 await test('addGoalMember: a direct member-add cancels the target\'s pending ask, attributed to the adder', async () => {
   const pool = addMemberPool();
-  await addGoalMember({ goalId: 7, builderId: 42, role: 'lead', resolvedBy: 99 }, { pool });
+  await addGoalMember({ goalId: 7, builderId: 42, membershipKind: 'lead', resolvedBy: 99 }, { pool });
   const q = find(pool.queries, /^WITH added AS/);
   assert.deepEqual(q.params, [7, 42, 'lead', 99],
     'resolved_by is the ADDER (99), not the target (42) — who admitted them is the audit fact');
@@ -425,7 +425,7 @@ await test('routes: invitation-respond declines before the goal-state gate', ()
 // authorizeJoinRequestResponse — owner|manager|Archon resolves a join-request.
 const OWNER_GOAL = { id: 5, status: 'open', created_by: '1', visibility: 'private' };
 const REQUEST = { id: 8, goal_id: '5', builder_id: '2', kind: 'request', status: 'pending' };
-const mgr = (bid) => ({ goal_id: 5, builder_id: bid, role: 'lead' });
+const mgr = (bid) => ({ goal_id: 5, builder_id: bid, membership_kind: 'lead' });
 await test('authorizeJoinRequestResponse: non-authority actor → 403 (before any request lookup — no leak)', () => {
   const d = authorizeJoinRequestResponse({ goal: OWNER_GOAL, actorId: 7, actorRank: 'metic', actorMembership: null, request: REQUEST, goalId: 5 });
   assert.equal(d.status, 403); assert.equal(d.body.error, 'not_owner_or_manager');

package/tests/goal_routes.mjs

@@ -42,10 +42,10 @@ const POST_GOALS_SCHEMA = {
   scope_modules: { type: 'array', maxItems: 64, itemsType: 'string' },
   succeeds_goal_id: { type: 'integer', min: 1 }, // BV1.R64 rescope carry-forward
 };
-// /members validates only `role` declaratively; builder_id is coerced in-handler
+// /members validates only `membership_kind` declaratively; builder_id is coerced in-handler
 // (accepts a number OR a numeric string — ids round-trip through JSON as strings).
 const POST_MEMBERS_SCHEMA = {
-  role: { type: 'string' },
+  membership_kind: { type: 'string' },
 };
 // POST /goals/:id/scope (BV1.R64 ask-to-widen) — `add` is the module list; the
 // empty-array, unknown-key, and protected-module checks are in-handler.
@@ -122,15 +122,15 @@ await test('POST /goals/:id/scope: a non-string add item is rejected', () => {
 // ---- POST /goals/:id/members schema ----
 // builder_id is coerced via Number() + Number.isInteger in-handler (a number or a
 // numeric string passes; a non-numeric string → 400 bad_builder_id), verified
-// live against Postgres. Here we pin the declarative half (role).
-await test('POST /members: role optional, valid when present', () => {
+// live against Postgres. Here we pin the declarative half (membership_kind).
+await test('POST /members: membership_kind optional, valid when present', () => {
   assert.equal(validate({}, POST_MEMBERS_SCHEMA), null);
-  assert.equal(validate({ role: 'lead' }, POST_MEMBERS_SCHEMA), null);
+  assert.equal(validate({ membership_kind: 'lead' }, POST_MEMBERS_SCHEMA), null);
 });
 
-await test('POST /members: non-string role → wrong_type', () => {
-  const r = validate({ role: 42 }, POST_MEMBERS_SCHEMA);
-  assert.ok(r && r.details.some((d) => d.field === 'role' && d.reason === 'wrong_type'));
+await test('POST /members: non-string membership_kind → wrong_type', () => {
+  const r = validate({ membership_kind: 42 }, POST_MEMBERS_SCHEMA);
+  assert.ok(r && r.details.some((d) => d.field === 'membership_kind' && d.reason === 'wrong_type'));
 });
 
 await test('builder_id coercion contract: Number() accepts int + numeric string, rejects junk', () => {

package/tests/goal_tier.mjs

@@ -49,7 +49,7 @@ const GOAL_ROW = {
   scope_modules: ['gds-core'], status: 'open', created_by: 42,
   succeeded_by_goal_id: null, sort_order: 0, created_at: 'T0', updated_at: 'T0',
 };
-const MEMBER_ROW = { goal_id: 7, builder_id: 42, role: 'member', joined_at: 'T0' };
+const MEMBER_ROW = { goal_id: 7, builder_id: 42, membership_kind: 'member', joined_at: 'T0' };
 
 // =========================================================================
 // createGoal
@@ -76,7 +76,7 @@ await test('createGoal: the creator becomes the first lead in the same statement
   const pool = fakePool((s) => (/INSERT INTO goals/.test(s) ? { rows: [GOAL_ROW] } : null));
   await createGoal({ versionId: 'V1', title: 'g', createdBy: 42 }, { pool });
   const ins = find(pool.queries, /INSERT INTO goals/);
-  assert.match(ins.sql, /INSERT INTO goal_members \(goal_id, builder_id, role\)/,
+  assert.match(ins.sql, /INSERT INTO goal_members \(goal_id, builder_id, membership_kind\)/,
     'the member insert is part of the createGoal statement');
   assert.match(ins.sql, /'lead'/, 'the creator is inserted as lead, not member');
   assert.match(ins.sql, /WHERE \$6::bigint IS NOT NULL/,
@@ -157,19 +157,19 @@ await test('setGoalStatus: unknown goal returns null', async () => {
 // task 1002888 wrapped the bare upsert in a CTE that also cancels any pending
 // membership request, so the statement now STARTS with `WITH added AS (` — the
 // INSERT is the first arm. The pending-ask cancellation itself is pinned in
-// tests/goal_membership_requests.mjs; here we only re-anchor the role contract.
-await test('addGoalMember: upsert PRESERVES the existing role (re-join cannot demote a lead)', async () => {
-  const pool = fakePool((s) => (/^WITH added AS/.test(s) ? { rows: [{ ...MEMBER_ROW, role: 'lead' }] } : null));
-  const out = await addGoalMember({ goalId: 7, builderId: 42, role: 'member' }, { pool });
-  assert.equal(out.role, 'lead', 'an existing lead row survives a role:member re-add');
+// tests/goal_membership_requests.mjs; here we only re-anchor the membership contract.
+await test('addGoalMember: upsert PRESERVES the existing membership_kind (re-join cannot demote a lead)', async () => {
+  const pool = fakePool((s) => (/^WITH added AS/.test(s) ? { rows: [{ ...MEMBER_ROW, membership_kind: 'lead' }] } : null));
+  const out = await addGoalMember({ goalId: 7, builderId: 42, membershipKind: 'member' }, { pool });
+  assert.equal(out.membership_kind, 'lead', 'an existing lead row survives a membership_kind:member re-add');
   const ins = find(pool.queries, /^WITH added AS/);
   assert.deepEqual(ins.params, [7, 42, 'member', null], 'resolvedBy defaults to null when no actor is supplied');
   assert.match(ins.sql, /INSERT INTO goal_members/, 'the membership write is the first CTE arm');
-  assert.match(ins.sql, /ON CONFLICT \(goal_id, builder_id\) DO UPDATE SET role = goal_members\.role/,
-    'conflict keeps the stored role — role changes go through PATCH /goals/:id/members/:builderId only (task 1002689)');
+  assert.match(ins.sql, /ON CONFLICT \(goal_id, builder_id\) DO UPDATE SET membership_kind = goal_members\.membership_kind/,
+    'conflict keeps the stored membership_kind — changes go through PATCH /goals/:id/members/:builderId only (task 1002689)');
 });
 
-await test('addGoalMember: role defaults to member', async () => {
+await test('addGoalMember: membershipKind defaults to member', async () => {
   const pool = fakePool((s) => (/^WITH added AS/.test(s) ? { rows: [MEMBER_ROW] } : null));
   await addGoalMember({ goalId: 7, builderId: 42 }, { pool });
   assert.equal(find(pool.queries, /^WITH added AS/).params[2], 'member');