@bongos/core 1.24.8 → 1.24.10

package/tests/module_store_price.mjs

@@ -30,8 +30,11 @@ let state = fresh();
 const newestPrice = (key) => state.prices.filter((p) => p.module_key === key).at(-1) || null;
 const query = async (sql, params = []) => {
   if (/^INSERT INTO store_module_prices/.test(sql)) {
-    const [module_key, price_cents, price_credits, set_by] = params;
-    state.prices.push({ module_key, price_cents, price_credits, set_by, set_at: ++state.setAt });
+    // Reads the column list rather than assuming it, so a writer that still sent
+    // price_credits would be recorded as such and fail the cash-only cases below.
+    const cols = sql.match(/\(([^)]*)\)/)[1].split(',').map((c) => c.trim());
+    const row = Object.fromEntries(cols.map((c, i) => [c, params[i]]));
+    state.prices.push({ price_credits: null, ...row, set_at: ++state.setAt });
     return { rows: [] };
   }
   if (/FROM store_module_prices\s+WHERE module_key = \$1/.test(sql)) {
@@ -105,9 +108,9 @@ test('only the author may set the price; a stranger and a delisted module are re
   assert.equal(state.prices.length, 0, 'nothing was written');
 });
 
-test('a price must be whole numbers of 0 or more, and name at least one currency', async () => {
+test('a price must be a whole number of cents, 0 or more', async () => {
   state = fresh();
-  for (const body of [{}, { cents: null, credits: null }, { cents: -1 }, { cents: 1.5 }, { credits: '10' }, { cents: 1e12 }]) {
+  for (const body of [{}, { cents: null }, { cents: -1 }, { cents: 1.5 }, { cents: '10' }, { cents: 1e12 }]) {
     const r = await setPrice(body);
     assert.equal(r.statusCode, 400, JSON.stringify(body));
     assert.ok(['bad_price', 'validation_failed'].includes(r.body.error.code), r.body.error.code);
@@ -115,21 +118,34 @@ test('a price must be whole numbers of 0 or more, and name at least one currency
   assert.equal(state.prices.length, 0);
 });
 
-test('each change appends a row naming who set it, and the newest is what acquire reads', async () => {
+// Task 1004989 (ADR 0385 decision 2): credits never price or buy a module.
+test('a credit price is refused by name, with or without cents, and nothing is written', async () => {
+  state = fresh();
+  for (const body of [{ credits: 40 }, { credits: 0 }, { cents: 500, credits: 40 }, { credits: '10' }]) {
+    const r = await setPrice(body);
+    assert.equal(r.statusCode, 400, JSON.stringify(body));
+    assert.equal(r.body.error.code, 'credit_price_refused', JSON.stringify(body));
+    assert.match(r.body.error.message, /Credits cannot price a module/);
+  }
+  assert.equal(state.prices.length, 0, 'no row, not even the cash half');
+});
+
+test('each change appends a cash-only row naming who set it, and the newest is what acquire reads', async () => {
   state = fresh();
   const first = await setPrice({ cents: 900 });
   assert.equal(first.statusCode, 200);
-  assert.deepEqual(first.body, { ok: true, module_key: 'weather', previous: null, price: { cents: 900, credits: null } });
-  const second = await setPrice({ cents: 500, credits: 40 });
-  assert.deepEqual(second.body.previous, { cents: 900, credits: null });
+  assert.deepEqual(first.body, { ok: true, module_key: 'weather', previous: null, price: { cents: 900 } });
+  const second = await setPrice({ cents: 500 });
+  assert.deepEqual(second.body.previous, { cents: 900, coming: false });
   assert.equal(state.prices.length, 2, 'the history is kept');
   assert.equal(state.prices[1].set_by, 42);
+  assert.ok(state.prices.every((p) => p.price_credits == null), 'no new row carries a credit price');
   const acq = await store.resolveAcquirable('weather', {});
   assert.equal(acq.ok, true);
-  assert.deepEqual([acq.price.price_cents, acq.price.price_credits], [500, 40]);
+  assert.equal(acq.price.price_cents, 500);
   assert.equal(acq.free, false);
-  await setPrice({ credits: 0 });
-  assert.equal((await store.resolveAcquirable('weather', {})).free, true, '0 in either currency is free');
+  await setPrice({ cents: 0 });
+  assert.equal((await store.resolveAcquirable('weather', {})).free, true, 'a cash price of 0 is free');
 });
 
 test('the catalog shows the price, and marks a paid module not yet buyable until buying opens', async () => {
@@ -139,26 +155,79 @@ test('the catalog shows the price, and marks a paid module not yet buyable until
   assert.equal(cat.listed[0].buyable, true, 'a free module can be had today');
   await setPrice({ cents: 900 });
   cat = await listing.listCatalog({});
-  assert.deepEqual(cat.listed[0].price, { cents: 900, credits: null, free: false });
+  assert.deepEqual(cat.listed[0].price, { cents: 900, free: false, coming: false });
   assert.equal(cat.listed[0].buyable, false, 'buying arrives with task 1003788');
 });
 
-test('bongos module price: sends the price, says what it was and now is, and that paid is not yet buyable', async () => {
+test('an OLD credit-only row: listed as price coming, never free, acquire refuses with no credit path, the author is asked', async () => {
+  state = fresh();
+  state.prices.push({ module_key: 'weather', price_cents: null, price_credits: 40, set_by: 42, set_at: ++state.setAt });
+  const cat = await listing.listCatalog({});
+  assert.deepEqual(cat.listed[0].price, { cents: null, free: false, coming: true });
+  assert.equal(cat.listed[0].buyable, false);
+  const acq = await store.resolveAcquirable('weather', {});
+  assert.equal(acq.free, false, 'credits never make it free or buyable');
+  // The author's listing read carries the ask; a stranger's does not.
+  const mine = await listing.readListing('weather', { viewerId: 42 });
+  assert.equal(mine.price_prompt, listing.PRICE_COMING_PROMPT);
+  assert.match(mine.price_prompt, /set a cash price/);
+  const theirs = await listing.readListing('weather', { viewerId: 7 });
+  assert.equal(theirs.price_prompt, null);
+  assert.deepEqual(theirs.price, { cents: null, free: false, coming: true });
+  // Setting a cash price replaces it; the reply says what it was.
+  const set = await setPrice({ cents: 300 });
+  assert.deepEqual(set.body.previous, { cents: null, coming: true });
+  assert.equal((await listing.readListing('weather', { viewerId: 42 })).price_prompt, null, 'the ask goes away');
+  // An old 0-credit offer stays free, as it was.
+  state = fresh();
+  state.prices.push({ module_key: 'weather', price_cents: null, price_credits: 0, set_by: 42, set_at: ++state.setAt });
+  assert.equal((await store.resolveAcquirable('weather', {})).free, true);
+});
+
+// The hall store row: the real storeFacts lifted out of modules.js and run over a
+// real catalog entry, so the page and the read cannot disagree about the flag.
+test('the hall store row marks a price-coming module, and nothing else', async () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/modules.js'), 'utf8');
+  const start = src.indexOf('  function storeFacts(m) {');
+  const end = src.indexOf('\n  }\n', start);
+  assert.ok(start > 0 && end > start, 'storeFacts is in modules.js');
+  const storeFacts = new Function('escapeHtml', 'sortedPartFact', 'partsList',
+    `${src.slice(start, end + 4)}; return storeFacts;`)((s) => String(s), () => '', () => '');
+  state = fresh();
+  state.prices.push({ module_key: 'weather', price_cents: null, price_credits: 40, set_by: 42, set_at: ++state.setAt });
+  const coming = (await listing.listCatalog({})).listed[0];
+  assert.match(storeFacts(coming), /price coming/);
+  assert.doesNotMatch(storeFacts(coming), /40/, 'the credit amount is never drawn');
+  state = fresh();
+  await setPrice({ cents: 900 });
+  assert.doesNotMatch(storeFacts((await listing.listCatalog({})).listed[0]), /price coming/);
+});
+
+test('the acquire refusal never offers credits as a way to pay', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  const at = src.indexOf("'payment_required'");
+  const block = src.slice(at, at + 600);
+  assert.ok(at > 0);
+  assert.doesNotMatch(block, /credit economy/);
+  assert.match(block, /has no cash price yet/);
+});
+
+test('bongos module price: sends the cash price, says what it was and now is, and that paid is not yet buyable', async () => {
   const sent = [];
   const request = async (method, url, opts) => {
     sent.push({ method, url, json: opts && opts.json });
-    return { ok: true, status: 200, data: { ok: true, previous: { cents: 0, credits: null }, price: { cents: 900, credits: 40 } } };
+    return { ok: true, status: 200, data: { ok: true, previous: { cents: null, coming: true }, price: { cents: 900 } } };
   };
   const out = [];
-  assert.equal(await mod.cmdPrice(['weather', '--cents', '900', '--credits', '40'], { log: (l) => out.push(l), errlog: () => {}, request }), 0);
-  assert.deepEqual(sent, [{ method: 'POST', url: '/store/modules/weather/price', json: { cents: 900, credits: 40 } }]);
-  assert.match(out.join('\n'), /"weather" now costs \$9\.00 or 40 credits \(was free\)/);
+  assert.equal(await mod.cmdPrice(['weather', '--cents', '900'], { log: (l) => out.push(l), errlog: () => {}, request }), 0);
+  assert.deepEqual(sent, [{ method: 'POST', url: '/store/modules/weather/price', json: { cents: 900 } }]);
+  assert.match(out.join('\n'), /"weather" now costs \$9\.00 \(was price coming\)/);
   assert.match(out.join('\n'), /not yet buyable/);
 });
 
-test('bongos module price: refuses no key, no amount and a non-number before asking the store', async () => {
+test('bongos module price: refuses no key, no amount, a non-number and any credit price before asking the store', async () => {
   const request = async () => { throw new Error('must not be called'); };
-  for (const args of [[], ['--cents', '5'], ['weather'], ['weather', '--cents', 'five'], ['weather', '--credits', '-3']]) {
+  for (const args of [[], ['--cents', '5'], ['weather'], ['weather', '--cents', 'five'], ['weather', '--credits', '40'], ['weather', '--cents', '5', '--credits', '1']]) {
     const errs = [];
     assert.equal(await mod.cmdPrice(args, { log: () => {}, errlog: (l) => errs.push(l), request }), 2, args.join(' '));
     assert.match(errs.join('\n'), /usage: bongos module price/);
@@ -183,7 +252,7 @@ test('the price history is the audit: who set each price and when, and what it r
   assert.match(src, /FROM store_modules WHERE module_key = \$1 FOR UPDATE/, 'one transaction, the module row locked');
 });
 
-test('bongos module publish --cents/--credits sets the price after the upload, and checks it before packing', async () => {
+test('bongos module publish --cents sets the price after the upload, and checks it (credits refused) before packing', async () => {
   const packed = { tgz: Buffer.from('x'), sidecar: { module_version: '1.0.0', core_version: '^1.0.0', file_count: 1, tree_sha256: 'a'.repeat(64), tarball: { name: 'x.tgz' } } };
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'publish-price-'));
   fs.mkdirSync(path.join(dir, 'weather'));
@@ -195,13 +264,15 @@ test('bongos module publish --cents/--credits sets the price after the upload, a
   const out = [];
   const code = await mod.cmdPublish(['--cents', '900', 'weather'], { log: (l) => out.push(l), errlog: (l) => out.push(l), modulesDir: dir, pack: () => packed, upload, priceRequest });
   assert.equal(code, 0, out.join('\n'));
-  assert.deepEqual(sent, [['POST', '/store/modules/weather/price', { cents: 900, credits: null }]], 'the key is found even after a valued flag');
+  assert.deepEqual(sent, [['POST', '/store/modules/weather/price', { cents: 900 }]], 'the key is found even after a valued flag');
   let packedAtAll = false;
-  const bad = await mod.cmdPublish(['weather', '--cents', 'nine'], { log: () => {}, errlog: () => {}, modulesDir: dir, pack: () => { packedAtAll = true; return packed; }, upload, priceRequest });
-  assert.equal(bad, 2);
-  assert.equal(packedAtAll, false, 'a bad price refuses before anything is packed or sent');
+  for (const flags of [['--cents', 'nine'], ['--credits', '40']]) {
+    const bad = await mod.cmdPublish(['weather', ...flags], { log: () => {}, errlog: () => {}, modulesDir: dir, pack: () => { packedAtAll = true; return packed; }, upload, priceRequest });
+    assert.equal(bad, 2, flags.join(' '));
+  }
+  assert.equal(packedAtAll, false, 'a bad or credit price refuses before anything is packed or sent');
   const failing = async () => ({ ok: false, status: 403, data: { error: { message: 'Only the author' } } });
   const errs = [];
-  assert.equal(await mod.cmdPublish(['weather', '--credits', '40'], { log: () => {}, errlog: (l) => errs.push(l), modulesDir: dir, pack: () => packed, upload, priceRequest: failing }), 1);
-  assert.match(errs.join('\n'), /The version is published, but its price was not set\. Run `bongos module price weather --credits 40`/);
+  assert.equal(await mod.cmdPublish(['weather', '--cents', '40'], { log: () => {}, errlog: (l) => errs.push(l), modulesDir: dir, pack: () => packed, upload, priceRequest: failing }), 1);
+  assert.match(errs.join('\n'), /The version is published, but its price was not set\. Run `bongos module price weather --cents 40`/);
 });

package/tests/module_store_registry_migration.mjs

@@ -43,6 +43,17 @@ test('a price of zero is allowed in both currencies — free modules are first-c
   assert.match(t, /CHECK \(price_cents IS NOT NULL OR price_credits IS NOT NULL\)/);
 });
 
+// Task 1004989 (ADR 0385 decision 2): a NEW price row may not carry credits, and
+// the old rows stay readable — so the CHECK is NOT VALID and must stay that way.
+test('core_287: new price rows are cash only; old credit rows are kept, not re-checked', () => {
+  const sql = readFileSync(path.join(ROOT, 'migrations', 'core_287_module_prices_cash_only.sql'), 'utf8')
+    .replace(/--[^\n]*/g, '');
+  assert.match(sql, /ADD CONSTRAINT store_module_prices_no_new_credit_price CHECK \(price_credits IS NULL\) NOT VALID;/);
+  assert.match(sql, /DROP CONSTRAINT IF EXISTS store_module_prices_no_new_credit_price;/, 'idempotent on a re-run');
+  assert.doesNotMatch(sql, /VALIDATE CONSTRAINT|UPDATE store_module_prices|DELETE FROM store_module_prices/,
+    'no old row is validated, rewritten or deleted');
+});
+
 test('a version is exact semver and can be published only once per module', () => {
   const t = table('store_module_versions');
   assert.match(t, /version\s+text NOT NULL\s+CHECK \(version ~ '\^\[0-9\]\+\\\.\[0-9\]\+\\\.\[0-9\]\+\$'\)/);

package/tests/nav_permission_atoms.mjs

@@ -92,8 +92,9 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // the seats read from /me's server-resolved positions block; task 1004730: the banner
 // says a held core version was tried and rolled back; task 1004731: the one-time
 // "Upgraded to core X" notice after a move; task 1004826: Standing is Accomplishments;
-// task 1004846: the new logo (its bump landed late, in task 1004852).
-const SHELL_SHA = 'cea38eeab6b234cc';
+// task 1004846: the new logo (its bump landed late, in task 1004852); task 1004938: the
+// Market Watch settings nav item and its fuel glyph.
+const SHELL_SHA = '4022e01fbb4045ad';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);