@bongos/core 1.24.23 → 1.24.24

package/tests/user_balances.mjs

@@ -0,0 +1,241 @@
+// tests/user_balances.mjs — user balances and fee-free transfers, isolated per project
+// (task 1004907, goal 1000092 N3; ADR 0385, ADR 0397). Behaviour of
+// modules/economy/user-balances.js and its routes:
+//   - a balance is the processor's figure, never a sum of our record;
+//   - an instruction is carried out once, with no platform fee, and funding books the
+//     project-account movement;
+//   - with no processor nothing moves and the instruction is held, not lost;
+//   - only a person's own web session may pay;
+//   - TWO PROJECTS: neither can read, link or spend the other's accounts.
+// The SQL itself is proven against real Postgres in tests/user_balances_db.mjs.
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const U = require('../modules/economy/user-balances.js');
+
+// A stand-in for one project's database: the three tables and the project-account record,
+// answering the statements user-balances.js and project-account.js send.
+function fakeProjectDb() {
+  const t = { accounts: [], transfers: [], attempts: [], movements: [] };
+  let id = 0;
+  const db = {
+    t,
+    async query(sql, p = []) {
+      const s = sql.replace(/\s+/g, ' ').trim();
+      if (s.startsWith('SELECT pg_advisory_xact_lock')) return { rows: [] };
+      if (s.startsWith('SELECT processor_account FROM economy_member_accounts')) {
+        const r = t.accounts.filter((a) => a.builder_id === String(p[0])).at(-1);
+        return { rows: r ? [r] : [] };
+      }
+      if (s.startsWith('SELECT builder_id FROM economy_member_accounts')) return { rows: t.accounts.filter((a) => a.processor_account === p[0]).slice(0, 1) };
+      if (s.startsWith('INSERT INTO economy_member_accounts')) {
+        t.accounts.push({ id: ++id, builder_id: String(p[0]), processor_account: p[1] }); return { rows: [] };
+      }
+      if (s.startsWith('INSERT INTO economy_user_transfers')) {
+        if (!t.transfers.some((x) => x.from_builder_id === p[1] && x.instruction_id === p[7])) {
+          t.transfers.push({ id: ++id, kind: p[0], from_builder_id: p[1], to_builder_id: p[2], from_account: p[3], to_account: p[4],
+            amount_cents: p[5], currency: p[6], instruction_id: p[7], note: p[8], platform_fee_cents: 0 });
+        }
+        return { rows: [] };
+      }
+      if (s.startsWith('SELECT * FROM economy_user_transfers')) return { rows: t.transfers.filter((x) => x.from_builder_id === String(p[0]) && x.instruction_id === p[1]) };
+      if (s.startsWith('SELECT processor_ref FROM economy_user_transfer_attempts')) return { rows: t.attempts.filter((a) => a.transfer_id === String(p[0]) && a.outcome === 'sent') };
+      if (s.startsWith('INSERT INTO economy_user_transfer_attempts')) {
+        t.attempts.push({ id: ++id, transfer_id: String(p[0]), outcome: p[1], processor_ref: p[2], reason: p[3] }); return { rows: [] };
+      }
+      if (s.startsWith('INSERT INTO economy_project_account_movements')) {
+        const row = { id: ++id, kind: p[0], amount_micro: p[2], builder_id: p[3], processor_ref: p[6] };
+        t.movements.push(row); return { rows: [row] };
+      }
+      if (s.startsWith('SELECT t.id, t.kind')) {
+        const who = String(p[0]);
+        const rows = t.transfers.filter((x) => x.from_builder_id === who || x.to_builder_id === who).reverse().map((x) => {
+          const mine = t.attempts.filter((a) => a.transfer_id === String(x.id));
+          const sent = mine.find((a) => a.outcome === 'sent');
+          const last = mine.at(-1);
+          return { ...x, sent_ref: sent ? sent.processor_ref : null, last_outcome: last && last.outcome, last_reason: last && last.reason };
+        });
+        return { rows };
+      }
+      throw new Error(`unexpected SQL: ${s.slice(0, 80)}`);
+    },
+  };
+  return db;
+}
+
+// A stand-in for one project's processor connection: it knows only the accounts it opened.
+function fakeProcessor(name, { opened = {}, balances = {}, projectMicro = 0 } = {}) {
+  const calls = [];
+  let n = 0;
+  const byKey = new Map();
+  return {
+    calls,
+    async balanceMicro() { return projectMicro; },
+    async memberBalanceMicro(ref) {
+      if (!(ref in balances)) throw new Error(`${name} has no account ${ref}`);
+      return balances[ref];
+    },
+    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 Object.assign(new Error(`${name} does not hold ${acc}`), { code: 'unknown_account' });
+      }
+      if (!byKey.has(req.idempotencyKey)) byKey.set(req.idempotencyKey, `tr_${name}_${++n}`);
+      return { ref: byKey.get(req.idempotencyKey) };
+    },
+  };
+}
+
+async function project(name, members) {
+  const db = fakeProjectDb();
+  const opened = {}; const balances = {};
+  for (const [builderId, ref, micro] of members) { opened[ref] = builderId; balances[ref] = micro; }
+  const processor = fakeProcessor(name, { opened, balances, projectMicro: 9_000_000 });
+  for (const [builderId, ref] of members) await U.linkMemberAccount(db, { builderId, accountRef: ref }, { processor });
+  return { db, processor };
+}
+
+const code = async (p) => { try { await p; } catch (e) { return e.code; } return null; };
+
+test('a balance is the processor figure; our record is never summed into one', async () => {
+  const a = await project('A', [['1', 'acct_a1', 4_200_000]]);
+  const me = await U.readMyBalance(a.db, '1', { processor: a.processor });
+  assert.equal(me.balance_micro, 4_200_000);
+  assert.equal(me.holds_money, false);
+  assert.equal(me.source, 'processor');
+  assert.equal((await U.readProjectBalance({ processor: a.processor })).balance_micro, 9_000_000);
+  const none = await U.readMyBalance(a.db, '2', { processor: a.processor });
+  assert.equal(none.connected, false);
+  assert.equal(none.balance_micro, null);
+  const broken = { memberBalanceMicro: async () => { throw new Error('acct_secret down'); } };
+  const r = await U.readMyBalance(a.db, '1', { processor: broken });
+  assert.equal(r.balance_micro, null);
+  assert.ok(r.processor_error && !r.processor_error.includes('acct_secret'), 'the processor error text never reaches the person');
+});
+
+test('a person pays another member once, with no platform fee', async () => {
+  const a = await project('A', [['1', 'acct_a1', 0], ['2', 'acct_a2', 0]]);
+  const pay = { kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 2500, instructionId: 'pay-0001-abc' };
+  const out = await U.transfer(pay, { pool: a.db, processor: a.processor });
+  assert.equal(out.status, 'sent');
+  assert.equal(out.platform_fee_cents, 0);
+  assert.deepEqual(a.processor.calls[0], {
+    idempotencyKey: `bongos-user-transfer-${out.transfer_id}`, amountCents: 2500, currency: 'USD',
+    fromAccount: 'acct_a1', toAccount: 'acct_a2', toProject: false,
+  });
+  const again = await U.transfer(pay, { pool: a.db, processor: a.processor });
+  assert.equal(again.status, 'sent');
+  assert.equal(again.already, true);
+  assert.equal(a.processor.calls.length, 1, 'a second press sends nothing');
+  assert.equal(a.db.t.movements.length, 0, 'a payment between people never touches the project account');
+  assert.equal(await code(U.transfer({ ...pay, amountCents: 9999 }, { pool: a.db, processor: a.processor })), 'instruction_reused');
+  const seen = await U.readMyBalance(a.db, '2', { processor: a.processor });
+  assert.equal(seen.transfers[0].direction, 'in');
+  assert.equal(seen.transfers[0].status, 'sent');
+});
+
+test('funding the project books one funding movement naming the funder', async () => {
+  const a = await project('A', [['1', 'acct_a1', 0]]);
+  const out = await U.transfer({ kind: 'fund_project', fromBuilderId: '1', amountCents: 1000, instructionId: 'fund-0001-xy' },
+    { pool: a.db, processor: a.processor });
+  assert.equal(out.status, 'sent');
+  assert.equal(a.processor.calls[0].toProject, true);
+  assert.equal(a.processor.calls[0].toAccount, null);
+  assert.equal(a.db.t.movements.length, 1);
+  assert.equal(a.db.t.movements[0].kind, 'funding');
+  assert.equal(a.db.t.movements[0].amount_micro, 10_000_000);
+  assert.equal(a.db.t.movements[0].builder_id, '1');
+});
+
+test('with no processor connected the instruction is recorded and held, nothing moves', async () => {
+  const a = await project('A', [['1', 'acct_a1', 0], ['2', 'acct_a2', 0]]);
+  const out = await U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 5, instructionId: 'held-0001-q' },
+    { pool: a.db, processor: null });
+  assert.equal(out.status, 'held');
+  assert.equal(out.reason, 'no_processor');
+  assert.equal(a.db.t.transfers.length, 1);
+  assert.equal(a.db.t.attempts[0].outcome, 'held');
+});
+
+test('a failed transfer is recorded with its reason and not re-sent on its own', async () => {
+  const a = await project('A', [['1', 'acct_a1', 0], ['2', 'acct_a2', 0]]);
+  const flaky = { memberTransfer: async () => { throw Object.assign(new Error('insufficient funds'), { code: 'balance_insufficient' }); } };
+  const out = await U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 5, instructionId: 'fail-0001-q' },
+    { pool: a.db, processor: flaky });
+  assert.equal(out.status, 'failed');
+  assert.match(out.reason, /insufficient funds/);
+  assert.equal(a.db.t.attempts.filter((x) => x.outcome === 'sent').length, 0);
+});
+
+test('malformed instructions are refused before anything is recorded', async () => {
+  const a = await project('A', [['1', 'acct_a1', 0], ['2', 'acct_a2', 0]]);
+  const base = { kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 5, instructionId: 'okok-0001-q' };
+  const opts = { pool: a.db, processor: a.processor };
+  assert.equal(await code(U.transfer({ ...base, amountCents: 0 }, opts)), 'bad_amount');
+  assert.equal(await code(U.transfer({ ...base, amountCents: 1.5 }, opts)), 'bad_amount');
+  assert.equal(await code(U.transfer({ ...base, toBuilderId: '1' }, opts)), 'self_payment');
+  assert.equal(await code(U.transfer({ ...base, instructionId: 'x' }, opts)), 'bad_instruction_id');
+  assert.equal(await code(U.transfer({ ...base, kind: 'withdraw' }, opts)), 'bad_kind');
+  assert.equal(await code(U.transfer({ ...base, fromBuilderId: '7' }, opts)), 'no_account');
+  assert.equal(await code(U.transfer({ ...base, toBuilderId: '7' }, opts)), 'recipient_has_no_account');
+  assert.equal(a.db.t.transfers.length, 0);
+});
+
+test('TWO PROJECTS: neither can read, link or spend the other balance', async () => {
+  const a = await project('A', [['1', 'acct_a1', 100], ['2', 'acct_a2', 200]]);
+  // project B has its own builders 1 and 3 (ids are per project database)
+  const b = await project('B', [['1', 'acct_b1', 700], ['3', 'acct_b3', 300]]);
+
+  // A cannot link B's account to one of its people: A's processor did not open it
+  assert.equal(await code(U.linkMemberAccount(a.db, { builderId: '1', accountRef: 'acct_b1' }, { processor: a.processor })), 'not_this_projects_account');
+  assert.equal(await code(U.linkMemberAccount(a.db, { builderId: '2', accountRef: 'acct_a1' }, { processor: a.processor })), 'not_this_projects_account');
+
+  // the same builder id reads its OWN project's balance in each project
+  assert.equal((await U.readMyBalance(a.db, '1', { processor: a.processor })).balance_micro, 100);
+  assert.equal((await U.readMyBalance(b.db, '1', { processor: b.processor })).balance_micro, 700);
+  assert.equal((await U.readMyBalance(a.db, '3', { processor: a.processor })).connected, false, "B's member is not a member of A");
+
+  // A's member cannot pay B's member: B's people have no account in A
+  assert.equal(await code(U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '3', amountCents: 50, instructionId: 'cross-0001' },
+    { pool: a.db, processor: a.processor })), 'recipient_has_no_account');
+
+  // a payment in A only ever names A's accounts and only ever reaches A's processor
+  await U.transfer({ kind: 'pay_user', fromBuilderId: '1', toBuilderId: '2', amountCents: 50, instructionId: 'insideA-001' }, { pool: a.db, processor: a.processor });
+  await U.transfer({ kind: 'fund_project', fromBuilderId: '1', amountCents: 50, instructionId: 'fundB-0001' }, { pool: b.db, processor: b.processor });
+  assert.deepEqual(a.processor.calls.map((c) => [c.fromAccount, c.toAccount]), [['acct_a1', 'acct_a2']]);
+  assert.deepEqual(b.processor.calls.map((c) => [c.fromAccount, c.toAccount]), [['acct_b1', null]]);
+  assert.equal(a.db.t.movements.length, 0, "B's funding is not on A's account");
+  assert.equal(b.db.t.movements.length, 1);
+});
+
+// ── the routes ──────────────────────────────────────────────────────────────
+
+test('the payment routes need the person on their own web session', async () => {
+  const api = require('../src/module-api');
+  const build = require('../modules/economy/routes/balances.js');
+  const router = build({ processor: null });
+  const layer = router.stack.find((l) => l.route && l.route.path === '/balances/pay');
+  const handler = layer.route.stack.at(-1).handle;
+  const run = async (req) => {
+    const res = { code: 200, body: null, status(c) { this.code = c; return this; }, json(b) { this.body = b; return this; },
+      fail(c, o) { this.code = o.status; this.body = { error: c }; return this; } };
+    await handler(req, res);
+    return res;
+  };
+  const body = { to_builder_id: '2', amount_cents: 5, instruction_id: 'route-0001' };
+  for (const [what, req] of [
+    ['a CLI session', { builder: { id: '1' }, gdsSession: { source: 'cli', session_id: 1 }, body }],
+    ['a machine principal', { builder: { id: '1', system_role: 'bot' }, gdsSession: { source: 'web', session_id: 1 }, body }],
+    ['no session', { builder: { id: '1' }, body }],
+  ]) {
+    const r = await run(req);
+    assert.equal(r.code, 403, `${what} is refused`);
+    assert.equal(r.body.error, 'personal_session_required');
+  }
+  assert.ok(api.requireBuilder, 'the routes mount requireBuilder from the doorway');
+  assert.ok(layer.route.stack.some((s) => s.handle === api.requireBuilder), 'POST /balances/pay is behind requireBuilder');
+});

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();
+}