@bongos/core 1.24.8 → 1.24.9

package/tests/module_store_listing.mjs

@@ -347,11 +347,27 @@ test('the criterion: two modules with the same overall score read differently',
 // the ranking: quality first, price breaks ties, optional max price (task 1003808)
 // ---------------------------------------------------------------------------
 
-test('priceOf: no price row is free; 0 in either currency is free; null is not offered', () => {
-  assert.deepEqual(priceOf(null), { cents: null, credits: null, free: true });
-  assert.deepEqual(priceOf({ price_cents: 0, price_credits: null }), { cents: 0, credits: null, free: true });
-  assert.deepEqual(priceOf({ price_cents: 500, price_credits: 0 }), { cents: 500, credits: 0, free: true });
-  assert.deepEqual(priceOf({ price_cents: 500, price_credits: null }), { cents: 500, credits: null, free: false });
+test('priceOf: no price row is free; a cash price of 0 is free; never a credit amount', () => {
+  assert.deepEqual(priceOf(null), { cents: null, free: true, coming: false });
+  assert.deepEqual(priceOf({ price_cents: 0, price_credits: null }), { cents: 0, free: true, coming: false });
+  assert.deepEqual(priceOf({ price_cents: 500, price_credits: null }), { cents: 500, free: false, coming: false });
+});
+
+// Task 1004989 (ADR 0385 decision 2; owner, 2026-10-29): OLD rows may carry a
+// credit price. They are read, never shown as a credit price, and never buyable
+// with credits.
+test('priceOf on old credit rows: credit-only is "price coming", 0 credits stays free, cash wins', () => {
+  assert.deepEqual(priceOf({ price_cents: null, price_credits: 40 }), { cents: null, free: false, coming: true },
+    'a module priced only in credits is still listed, with its cash price coming');
+  assert.deepEqual(priceOf({ price_cents: null, price_credits: 0 }), { cents: null, free: true, coming: false },
+    'an old 0-credit offer stays free: no credit moves to have it');
+  assert.deepEqual(priceOf({ price_cents: 500, price_credits: 0 }), { cents: 500, free: true, coming: false },
+    'an old row offered at 0 credits stays free, as it was');
+  assert.deepEqual(priceOf({ price_cents: 500, price_credits: 40 }), { cents: 500, free: false, coming: false },
+    'with a cash price the credit amount is ignored');
+  for (const row of [{ price_credits: 40 }, { price_cents: 500, price_credits: 40 }]) {
+    assert.equal('credits' in priceOf(row), false, 'no credit amount leaves priceOf');
+  }
 });
 
 test('rankListed: a higher score always wins, whatever it costs — price never buys a place', () => {
@@ -362,7 +378,7 @@ test('rankListed: a higher score always wins, whatever it costs — price never
   assert.deepEqual(ranked.map((e) => e.key), ['dear', 'cheap']);
 });
 
-test('rankListed: between equal scores, free first, then lowest cash, then lowest credits, then key', () => {
+test('rankListed: between equal scores, free first, then lowest cash, a price still coming last, then key', () => {
   const input = [
     { key: 'z-credits', overall: 80, price: priceOf({ price_credits: 5 }) },
     { key: 'cents-900', overall: 80, price: priceOf({ price_cents: 900 }) },
@@ -374,14 +390,14 @@ test('rankListed: between equal scores, free first, then lowest cash, then lowes
   assert.equal(input[0].key, 'z-credits', 'the input is untouched');
 });
 
-test('withinMaxPrice: free always passes; a priced module must be offered at or under a cap the buyer set', () => {
+test('withinMaxPrice: free always passes; a priced module must cost at or under the cash cap', () => {
   const p = priceOf({ price_cents: 500, price_credits: 7 });
   assert.equal(withinMaxPrice(p, null), true, 'no cap, no filter');
-  assert.equal(withinMaxPrice(p, { cents: 500, credits: null }), true, 'at the cap is in');
-  assert.equal(withinMaxPrice(p, { cents: 499, credits: null }), false);
-  assert.equal(withinMaxPrice(p, { cents: 1, credits: 7 }), true, 'either currency under its cap is enough');
-  assert.equal(withinMaxPrice(priceOf({ price_cents: 500 }), { cents: null, credits: 100 }), false, 'not offered in credits, so a credit cap cannot let it in');
-  assert.equal(withinMaxPrice(priceOf(null), { cents: 0, credits: null }), true);
+  assert.equal(withinMaxPrice(p, { cents: 500 }), true, 'at the cap is in');
+  assert.equal(withinMaxPrice(p, { cents: 499 }), false);
+  assert.equal(withinMaxPrice(p, { cents: 1, credits: 7 }), false, 'a credit cap is ignored: credits never price a module');
+  assert.equal(withinMaxPrice(priceOf({ price_credits: 7 }), { cents: 100000 }), false, 'a price still coming has no cash price to compare');
+  assert.equal(withinMaxPrice(priceOf(null), { cents: 0 }), true);
 });
 
 test('GET /store/modules: ranks by score then price, and ?max_cents= leaves out what costs more', async () => {
@@ -416,7 +432,7 @@ test('GET /store/modules: ranks by score then price, and ?max_cents= leaves out
   assert.equal(all.body.max_price, null);
 
   const capped = await invoke(handle, { query: { max_cents: '1000' } });
-  assert.deepEqual(capped.body.max_price, { cents: 1000, credits: null });
+  assert.deepEqual(capped.body.max_price, { cents: 1000 });
   assert.deepEqual(capped.body.listed.map((m) => m.key), ['tie-free', 'tie-paid']);
   assert.deepEqual(capped.body.new, [], 'the cap applies to New modules too');
 
@@ -427,13 +443,48 @@ test('GET /store/modules: ranks by score then price, and ?max_cents= leaves out
 
 test('GET /store/modules: a maximum price that is not a whole number of 0 or more is refused', async () => {
   const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules');
-  for (const query of [{ max_cents: '-1' }, { max_cents: '5.5' }, { max_credits: 'ten' }, { max_cents: ['1', '2'] }]) {
+  for (const query of [{ max_cents: '-1' }, { max_cents: '5.5' }, { max_cents: ['1', '2'] }]) {
     const res = await invoke(handle, { query });
     assert.equal(res.statusCode, 400, JSON.stringify(query));
     assert.match(res.body.message, /maximum price/);
   }
 });
 
+test('GET /store/modules: there is no maximum in credits (task 1004989)', async () => {
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules');
+  for (const query of [{ max_credits: '100' }, { max_credits: 'ten' }, { max_cents: '500', max_credits: '1' }]) {
+    const res = await invoke(handle, { query });
+    assert.equal(res.statusCode, 400, JSON.stringify(query));
+    assert.match(res.body.message, /Credits do not price modules/);
+  }
+});
+
+test('GET /store/modules: an old credit-only price is listed as "price coming", never as credits, and not buyable', async () => {
+  state.modules = { legacy: { status: 'listed', title: 'Legacy' }, cash: { status: 'listed', title: 'Cash' } };
+  state.versions = [
+    { id: 41, module_key: 'legacy', version: '1.0.0', published_at: 't' },
+    { id: 42, module_key: 'cash', version: '1.0.0', published_at: 't' },
+  ];
+  state.scores = [
+    { id: 41, version_id: 41, computed_at: 1, ...score({ overall: 80 }) },
+    { id: 42, version_id: 42, computed_at: 1, ...score({ overall: 80 }) },
+  ];
+  state.signals = [];
+  state.prices = [
+    { module_key: 'legacy', price_cents: null, price_credits: 40, set_at: 1 },
+    { module_key: 'cash', price_cents: 900, price_credits: null, set_at: 1 },
+  ];
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules');
+  const res = await invoke(handle, { query: {} });
+  const legacy = res.body.listed.find((m) => m.key === 'legacy');
+  assert.ok(legacy, 'a credit-priced module stays visible (owner, 2026-10-29)');
+  assert.deepEqual(legacy.price, { cents: null, free: false, coming: true });
+  assert.equal(legacy.buyable, false, 'credits never buy it');
+  assert.doesNotMatch(JSON.stringify(res.body), /credits/, 'no credit price appears anywhere in the catalog');
+  assert.deepEqual(res.body.listed.map((m) => m.key), ['cash', 'legacy'], 'between equal scores a price still coming sorts after a cash price');
+  state.prices = [];
+});
+
 // ---------------------------------------------------------------------------
 // why a module is or is not listed (task 1003810)
 // ---------------------------------------------------------------------------

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\]\+\$'\)/);