@bongos/core 1.24.22 → 1.24.24

package/tests/user_balances_db.mjs

@@ -0,0 +1,137 @@
+// tests/user_balances_db.mjs — task 1004907 (goal 1000092 N3). Real DB, TWO PROJECTS.
+//
+// Applies the REAL economy_002 and economy_003 migrations into two schemas, one per project
+// (each project runs its own database, ADR 0100; a schema is that database's stand-in), and
+// proves what Postgres itself refuses: a platform fee, a payment to yourself, one account
+// owned by two people, a second instruction under one id, a second `sent` attempt, and any
+// UPDATE or DELETE. Then the real transfer() moves money inside each project, and neither
+// project's tables, accounts or processor ever see the other's.
+//
+// Self-skips without a reachable Postgres.
+// Run:  DATABASE_URL=... node tests/user_balances_db.mjs
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const U = require('../modules/economy/user-balances.js');
+const here = dirname(fileURLToPath(import.meta.url));
+const mig = (f) => readFileSync(join(here, '..', 'modules', 'economy', 'migrations', f), 'utf8');
+const MIGRATIONS = [mig('economy_002_project_account.sql'), mig('economy_003_user_balances.sql'), mig('economy_004_module_share_payouts.sql')];
+
+const pgPool = new Pool({ connectionString: process.env.DATABASE_URL || undefined, max: 2 });
+let probe;
+try { probe = await pgPool.connect(); } catch (e) {
+  console.log(`user_balances_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pgPool.end().catch(() => {});
+  process.exit(0);
+}
+probe.release();
+
+let pass = 0;
+const ok = (c, m) => { assert.ok(c, m); pass++; console.log(`  ok - ${m}`); };
+const SCHEMAS = { A: `t1004907a_${process.pid}`, B: `t1004907b_${process.pid}` };
+const clients = {};
+
+// one connection per project, pinned to that project's schema
+async function openProject(name) {
+  const c = await pgPool.connect();
+  const schema = SCHEMAS[name];
+  await c.query(`CREATE SCHEMA ${schema}`);
+  await c.query(`SET search_path TO ${schema}`);
+  await c.query('CREATE TABLE builders (id bigserial PRIMARY KEY, display_name text)');
+  await c.query('CREATE TABLE tasks (id bigserial PRIMARY KEY, title text)');
+  await c.query('CREATE TABLE schema_migrations (version text PRIMARY KEY)');
+  await c.query(`INSERT INTO builders (display_name) VALUES ('${name}-one'), ('${name}-two'), ('${name}-three')`);
+  for (const m of MIGRATIONS) await c.query(m);
+  clients[name] = c;
+  return c;
+}
+
+function processorFor(name, opened) {
+  const calls = [];
+  let n = 0;
+  return {
+    calls,
+    async confirmMemberAccount({ accountRef, builderId }) { return opened[accountRef] === builderId; },
+    async memberTransfer(req) {
+      calls.push(req);
+      for (const acc of [req.fromAccount, req.toAccount].filter(Boolean)) if (!(acc in opened)) throw new Error(`${name} does not hold ${acc}`);
+      return { ref: `tr_${name}_${++n}` };
+    },
+  };
+}
+
+const rejects = async (c, sql, params) => {
+  await c.query('BEGIN');
+  let err = null;
+  try { await c.query(sql, params); } catch (e) { err = e; }
+  await c.query('ROLLBACK');
+  return err;
+};
+const codeOf = async (p) => { try { await p; } catch (e) { return e.code; } return null; };
+
+try {
+  const a = await openProject('A');
+  const b = await openProject('B');
+  const pa = processorFor('A', { acct_a1: '1', acct_a2: '2' });
+  const pb = processorFor('B', { acct_b1: '1', acct_b3: '3' });
+  await U.linkMemberAccount(a, { builderId: '1', accountRef: 'acct_a1' }, { processor: pa });
+  await U.linkMemberAccount(a, { builderId: '2', accountRef: 'acct_a2' }, { processor: pa });
+  await U.linkMemberAccount(b, { builderId: '1', accountRef: 'acct_b1' }, { processor: pb });
+  await U.linkMemberAccount(b, { builderId: '3', accountRef: 'acct_b3' }, { processor: pb });
+
+  const TI = `INSERT INTO economy_user_transfers (kind, from_builder_id, to_builder_id, from_account, to_account, amount_cents, instruction_id, platform_fee_cents)
+              VALUES ($1,$2,$3,$4,$5,$6,$7,$8)`;
+  ok((await rejects(a, TI, ['pay_user', 1, 2, 'acct_a1', 'acct_a2', 100, 'fee-00001', 1]))?.code === '23514', 'a platform fee is refused by the database');
+  ok((await rejects(a, TI, ['pay_user', 1, 1, 'acct_a1', 'acct_a1', 100, 'self-0001', 0]))?.code === '23514', 'a payment to yourself is refused');
+  ok((await rejects(a, TI, ['fund_project', 1, 2, 'acct_a1', 'acct_a2', 100, 'fund-0001', 0]))?.code === '23514', 'funding that names a person is refused');
+  ok((await rejects(a, TI, ['pay_user', 1, 2, 'acct_a1', 'acct_a2', 0, 'zero-0001', 0]))?.code === '23514', 'a zero amount is refused');
+  ok((await rejects(a, 'INSERT INTO economy_member_accounts (builder_id, processor_account) VALUES (3, $1)', ['acct_a1']))?.code === '23505',
+    'one account cannot belong to two people');
+  ok(await codeOf(U.linkMemberAccount(a, { builderId: '3', accountRef: 'acct_b3' }, { processor: pa })) === 'not_this_projects_account',
+    "project A cannot link an account project B opened");
+
+  const paid = await U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 2500, instructionId: 'pay-a-0001' }, { pool: a, processor: pa });
+  ok(paid.status === 'sent' && paid.platform_fee_cents === 0, 'a member pays another member in project A, fee-free');
+  const again = await U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 2500, instructionId: 'pay-a-0001' }, { pool: a, processor: pa });
+  ok(again.already === true && pa.calls.length === 1, 'the same instruction is carried out once');
+  ok((await rejects(a, TI, ['pay_user', 1, 2, 'acct_a1', 'acct_a2', 9, 'pay-a-0001', 0]))?.code === '23505', 'a second instruction under one id is refused');
+  ok((await rejects(a, "INSERT INTO economy_user_transfer_attempts (transfer_id, outcome, processor_ref) VALUES ($1, 'sent', 'tr_dup')", [paid.transfer_id]))?.code === '23505',
+    'a second sent attempt is refused');
+
+  const funded = await U.transfer({ kind: 'fund_project', fromBuilderId: '1', amountCents: 1000, instructionId: 'fund-b-0001' }, { pool: b, processor: pb });
+  ok(funded.status === 'sent', 'a member funds project B');
+
+  for (const table of ['economy_member_accounts', 'economy_user_transfers', 'economy_user_transfer_attempts']) {
+    ok(/append-only/.test((await rejects(a, `UPDATE ${table} SET created_at = now()`))?.message || ''), `${table} refuses an UPDATE`);
+    ok(/append-only/.test((await rejects(a, `DELETE FROM ${table}`))?.message || ''), `${table} refuses a DELETE`);
+  }
+
+  // ISOLATION — each project's tables hold only its own movements
+  const count = async (c, sql, params) => Number((await c.query(sql, params)).rows[0].n);
+  ok(await count(a, 'SELECT count(*) AS n FROM economy_user_transfers') === 1 && await count(b, 'SELECT count(*) AS n FROM economy_user_transfers') === 1,
+    'each project records only its own instruction');
+  ok(await count(a, 'SELECT count(*) AS n FROM economy_project_account_movements') === 0, "project B's funding is not on project A's account");
+  ok(await count(b, "SELECT count(*) AS n FROM economy_project_account_movements WHERE kind = 'funding' AND builder_id = $1", ['1']) === 1,
+    "project B's funding is on project B's account, naming the funder");
+  ok(await codeOf(U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '3', amountCents: 5, instructionId: 'cross-0001' }, { pool: a, processor: pa })) === 'recipient_has_no_account',
+    "project A cannot pay project B's member");
+  ok(pa.calls.every((c) => c.fromAccount.startsWith('acct_a') && (!c.toAccount || c.toAccount.startsWith('acct_a'))) &&
+     pb.calls.every((c) => c.fromAccount.startsWith('acct_b') && (!c.toAccount || c.toAccount.startsWith('acct_b'))),
+    "each project's processor is only ever asked to move that project's accounts");
+  const meA = await U.readMyBalance(a, '1', {});
+  const meB = await U.readMyBalance(b, '1', {});
+  ok(meA.transfers.length === 1 && meA.transfers[0].kind === 'pay_user' && meB.transfers.length === 1 && meB.transfers[0].kind === 'fund_project',
+    "the same person sees only that project's payments in each project");
+
+  console.log(`user_balances_db.mjs: ${pass} passed`);
+} finally {
+  for (const [name, c] of Object.entries(clients)) {
+    await c.query(`DROP SCHEMA IF EXISTS ${SCHEMAS[name]} CASCADE`).catch(() => {});
+    c.release();
+  }
+  await pgPool.end();
+}