domma-cms 0.116.0 → 0.116.1

package/plugins/support/plugin.json

@@ -1,9 +1,9 @@
 {
   "name": "support",
   "displayName": "Support",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "tier": "free",
-  "description": "Get help from Domma straight from your admin: our email, phone and hours always to hand, and a conversation with the Domma team for anything you need - urgent requests first.",
+  "description": "Get help from Domma straight from your admin: our email, phone and hours always to hand, and a conversation with the Domma team for anything you need - urgent requests first. Right-click a request to archive, resolve or remove it.",
   "author": "Domma CMS",
   "date": "2026-10-04",
   "icon": "headphones",

package/plugins/support/tests/api.test.js

@@ -285,3 +285,97 @@ test('replies go to the address a site was bought with; a hand-made site falls b
     await call(manager, 'POST', `/api/plugins/support/tickets/${tb.id}/reply`, {body: 'hi Bob'});
     assert.ok(mails.some(m => m.to === 'bob@beta.test'));
 });
+
+test('the inbox archive: out of the badge, back when the customer writes; the site never knows', async () => {
+    const acme = await site({token: 'tok-acme'});
+    const {body: s} = await call(acme, 'POST', '/tickets', {subject: 'Archive me', body: 'x', priority: 'urgent'});
+    const t = (await call(manager, 'GET', '/api/plugins/support/tickets')).body.tickets.find(x => x.ref === s.ref);
+    const before = (await call(manager, 'GET', '/api/plugins/support/count')).body;
+    const put = await call(manager, 'PUT', `/api/plugins/support/tickets/${t.id}`, {archived: true});
+    assert.equal(put.status, 200);
+    assert.equal(put.body.archived, true);
+    assert.equal(put.body.history.at(-1).what, 'Archived');
+    const after = (await call(manager, 'GET', '/api/plugins/support/count')).body;
+    assert.equal((after.count ?? 0) < (before.count ?? 0) || after.inventory === true, true, 'an archived request is not waiting');
+    assert.ok(!(after.details.items || []).some(i => i.text === 'Archive me'));
+    assert.equal((await call(manager, 'PUT', `/api/plugins/support/tickets/${t.id}`, {archived: 'no'})).status, 400);
+    // The site sees nothing of Domma's filing.
+    const mine = (await call(acme, 'GET', '/tickets')).body.tickets.find(x => x.ref === s.ref);
+    assert.equal(mine.archived, false);
+    // The customer writes again: it is back in the inbox.
+    await call(acme, 'POST', `/tickets/${s.ref}/messages`, {body: 'still there?'});
+    assert.equal((await call(manager, 'GET', `/api/plugins/support/tickets/${t.id}`)).body.archived, false);
+});
+
+test('a site archives and removes its own requests; Domma keeps them, and a reply brings them back', async () => {
+    const acme = await site({token: 'tok-acme'});
+    const a = (await call(acme, 'POST', '/tickets', {subject: 'Keep me', body: 'x'})).body;
+    const b = (await call(acme, 'POST', '/tickets', {subject: 'Lose me', body: 'y'})).body;
+    // A sync: the site knows both. Earlier tests' replies are read, so the badge counts open requests.
+    for (const t of (await call(acme, 'GET', '/tickets')).body.tickets.filter(x => x.unread)) {
+        await call(acme, 'PUT', `/tickets/${t.ref}/seen`, {at: t.messages.filter(m => m.from === 'domma').at(-1).at});
+    }
+    assert.equal((await call(acme, 'GET', '/count')).body.inventory, true);
+    const openBefore = (await call(acme, 'GET', '/count')).body.count;
+    assert.equal((await call(acme, 'PUT', `/tickets/${a.ref}/shelf`, {state: 'archived'})).body.state, 'archived');
+    assert.equal((await call(acme, 'PUT', `/tickets/${b.ref}/shelf`, {state: 'removed'})).body.state, 'removed');
+    assert.equal((await call(acme, 'PUT', `/tickets/${b.ref}/shelf`, {state: 'binned'})).status, 400);
+    assert.equal((await call(acme, 'PUT', '/tickets/nope/shelf', {state: 'archived'})).status, 404);
+    let list = (await call(acme, 'GET', '/tickets')).body.tickets;
+    assert.equal(list.find(x => x.ref === a.ref).archived, true);
+    assert.ok(!list.some(x => x.ref === b.ref), 'removed from the list');
+    // Neither counts on the badge.
+    assert.equal((await call(acme, 'GET', '/count')).body.count, openBefore - 2);
+    // Domma still has both.
+    const inbox = (await call(manager, 'GET', '/api/plugins/support/tickets')).body.tickets;
+    const tb = inbox.find(x => x.ref === b.ref);
+    assert.ok(tb && inbox.some(x => x.ref === a.ref));
+    // Domma replies to the removed one: it comes back, unread.
+    await call(manager, 'POST', `/api/plugins/support/tickets/${tb.id}/reply`, {body: 'We fixed it.'});
+    list = (await call(acme, 'GET', '/tickets')).body.tickets;
+    const back = list.find(x => x.ref === b.ref);
+    assert.ok(back, 'a new reply brings it back');
+    assert.equal(back.archived, false);
+    assert.equal(back.unread, true);
+    // Put back by hand.
+    await call(acme, 'PUT', `/tickets/${a.ref}/shelf`, {state: null});
+    assert.equal((await call(acme, 'GET', '/tickets')).body.tickets.find(x => x.ref === a.ref).archived, false);
+    // Writing to an archived one brings it back too.
+    await call(acme, 'PUT', `/tickets/${a.ref}/shelf`, {state: 'archived'});
+    await call(acme, 'POST', `/tickets/${a.ref}/messages`, {body: 'one more thing'});
+    assert.equal((await call(acme, 'GET', '/tickets')).body.tickets.find(x => x.ref === a.ref).archived, false);
+});
+
+test('removing a request that never reached Domma cancels it - it is never sent', async () => {
+    const acme = await site({token: 'tok-acme'});
+    managerUp = false;
+    let s;
+    try {
+        s = (await call(acme, 'POST', '/tickets', {subject: 'Never mind', body: 'x'})).body;
+        await call(acme, 'POST', `/tickets/${s.ref}/messages`, {body: 'follow-up'});
+        assert.equal(s.state, 'waiting');
+        const r = await call(acme, 'PUT', `/tickets/${s.ref}/shelf`, {state: 'removed'});
+        assert.equal(r.body.state, 'discarded');
+    } finally { managerUp = true; }
+    const list = (await call(acme, 'GET', '/tickets')).body.tickets;
+    assert.ok(!list.some(x => x.ref === s.ref));
+    const inbox = (await call(manager, 'GET', '/api/plugins/support/tickets')).body.tickets;
+    assert.ok(!inbox.some(x => x.ref === s.ref), 'Domma never got it');
+});
+
+test('review: archiving measures against the reply the customer SAW - a newer one is not put away unread', async () => {
+    const acme = await site({token: 'tok-acme'});
+    const s = (await call(acme, 'POST', '/tickets', {subject: 'Seen vs newer', body: 'x'})).body;
+    const t = (await call(manager, 'GET', '/api/plugins/support/tickets')).body.tickets.find(x => x.ref === s.ref);
+    await call(manager, 'POST', `/api/plugins/support/tickets/${t.id}/reply`, {body: 'first'});
+    const shown = (await call(acme, 'GET', '/tickets')).body.tickets.find(x => x.ref === s.ref);
+    const seenAt = shown.messages.at(-1).at;
+    await new Promise(r => setTimeout(r, 5));
+    await call(manager, 'POST', `/api/plugins/support/tickets/${t.id}/reply`, {body: 'second - not on their screen'});
+    await call(acme, 'GET', '/count');                       // a background sync hears of it
+    await call(acme, 'GET', '/tickets');
+    await call(acme, 'PUT', `/tickets/${s.ref}/shelf`, {state: 'archived', at: seenAt});
+    const now = (await call(acme, 'GET', '/tickets')).body.tickets.find(x => x.ref === s.ref);
+    assert.equal(now.archived, false, 'the newer reply keeps it in the list');
+    assert.equal(now.unread, true);
+});

package/plugins/support/tests/shape.test.js

@@ -5,7 +5,10 @@ import {
     addTurn, buildMessagePayload, buildTicketPayload, cleanRequest, cleanUpdate, contactCard, createThrottle, lastDommaAt,
     receivedTicket, senderView, telHref, toCustomerEmail, toDommaEmail
 } from '../lib/shape.js';
-import {mergeTickets} from '../lib/sender.js';
+import {applyShelf, createOutbox, flush, mergeTickets} from '../lib/sender.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 const T0 = '2026-10-04T10:00:00.000Z';
 const T1 = '2026-10-04T11:00:00.000Z';
@@ -120,3 +123,67 @@ test('the site\'s list: the manager\'s view, plus what is still waiting here', (
     assert.equal(offline[0].stale, true);
     assert.equal(offline[0].unread, true);
 });
+
+test('the inbox archive: a yes/no, and a customer writing again takes a request out of it', () => {
+    assert.deepEqual(cleanUpdate({archived: true}), {patch: {archived: true}});
+    assert.deepEqual(cleanUpdate({archived: false}), {patch: {archived: false}});
+    assert.equal(cleanUpdate({archived: 'yes'}).error, 'Archived is yes or no.');
+    const {data} = receivedTicket({ref: 'r1', subject: 'S', body: 'B'}, 'acme', T0);
+    const archived = {...data, archived: true};
+    // Domma writing to it leaves it where Domma put it.
+    assert.equal(addTurn(archived, {from: 'domma', name: 'D', body: 'hi', id: 'd1', at: T1}).data.archived, true);
+    // The customer closing it does too.
+    assert.equal(addTurn(archived, {from: 'customer', name: 'Ann', id: 'c0', at: T1, close: true}).data.archived, true);
+    const back = addTurn(archived, {from: 'customer', name: 'Ann', body: 'still broken', id: 'c1', at: T2}).data;
+    assert.equal(back.archived, false);
+    assert.equal(back.status, 'open');
+    assert.ok(back.history.some(h => h.what === 'Back from the archive'));
+});
+
+test('the site shelf: removed ones go, archived ones are marked, a new Domma reply brings either back', () => {
+    const t = (ref, dommaAt) => ({ref, subject: ref, messages: dommaAt ? [{from: 'customer', at: T0}, {from: 'domma', at: dommaAt}] : [{from: 'customer', at: T0}]});
+    const list = [t('a', T1), t('b', T1), t('c', ''), t('d', T2)];
+    const shelf = {
+        a: {state: 'archived', dommaAt: T1},
+        b: {state: 'removed', dommaAt: T1},
+        c: {state: 'removed', dommaAt: ''},
+        d: {state: 'archived', dommaAt: T1}          // Domma has written since (T2)
+    };
+    const out = applyShelf(list, shelf);
+    assert.deepEqual(out.map(x => [x.ref, x.archived]), [['a', true], ['d', false]]);
+    // Nothing shelved: all there, none archived.
+    assert.deepEqual(applyShelf(list, {}).map(x => x.archived), [false, false, false, false]);
+    // An offline copy has no messages to compare - the shelf is trusted.
+    assert.deepEqual(applyShelf([{ref: 'a', stale: true, messages: []}], shelf).map(x => x.archived), [true]);
+});
+
+test('review: a request removed while a send is in flight is not half-deleted, and a cancelled item is never sent', async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'support-outbox-'));
+    try {
+        const outbox = createOutbox(dir);
+        outbox.add('ticket', {ref: 'T1', subject: 's', body: 'b'});
+        outbox.add('message', {ticketRef: 'T1', ref: 'M1', body: 'more'}, 'T1');
+        outbox.add('ticket', {ref: 'T2', subject: 's2', body: 'b2'});
+        const posted = [];
+        let release;
+        const gate = new Promise(r => { release = r; });
+        const api = {
+            open: async (p) => { posted.push(p.ref); if (p.ref === 'T1') await gate; return {ok: true}; },
+            message: async (p) => { posted.push(p.ref); return {ok: true}; }
+        };
+        const run = flush(outbox, api);
+        await new Promise(r => setImmediate(r));
+        // T1 is on the wire: discarding it now would be a promise we cannot keep.
+        assert.equal(outbox.discard('T1'), false);
+        assert.ok(outbox.all().some(i => i.ref === 'T1'));
+        release();
+        await run;
+        assert.deepEqual(posted, ['T1', 'M1', 'T2']);
+        // Nothing in flight: a waiting request is cancelled, follow-ups and all.
+        outbox.add('ticket', {ref: 'T3', subject: 's3', body: 'b3'});
+        outbox.add('message', {ticketRef: 'T3', ref: 'M3', body: 'x'}, 'T3');
+        assert.equal(outbox.discard('T3'), true);
+        await flush(outbox, api);
+        assert.ok(!posted.includes('T3') && !posted.includes('M3'));
+    } finally { fs.rmSync(dir, {recursive: true, force: true}); }
+});