app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

drafts.spec.ts (18252B)


      1 import { expect, test, type Page } from '@playwright/test';
      2 import { build } from 'vite';
      3 import { createHash } from 'node:crypto';
      4 import { fileURLToPath } from 'node:url';
      5 import { createStaticHarness } from '../integration/harness/static.ts';
      6 import type * as Database from '../../src/lib/persistence/database.ts';
      7 import type * as Drafts from '../../src/lib/persistence/drafts.ts';
      8 declare global {
      9   interface Window {
     10     hcp047: typeof Database & typeof Drafts;
     11     hcp047Database: Database.BrowserDatabase;
     12     hcp047Repository: Drafts.PublicDraftRepository;
     13   }
     14 }
     15 const owner =
     16   '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
     17 const peer = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5';
     18 const form = {
     19   title: '',
     20   description: 'unfinished',
     21   location: '',
     22   amount: '.',
     23   currency: '',
     24   unit: '',
     25   quantity: '',
     26   contactType: '' as const,
     27   contactValue: ''
     28 };
     29 let server: Awaited<ReturnType<typeof createStaticHarness>>;
     30 let bundle: string;
     31 test.beforeAll(async () => {
     32   server = await createStaticHarness();
     33   const source = (name: string) =>
     34     fileURLToPath(
     35       new URL('../../src/lib/persistence/' + name, import.meta.url)
     36     );
     37   // Compile the exact current production modules together so both use the same
     38   // genuine WeakMap database ownership. This virtual entry is test-only.
     39   const result = await build({
     40     configFile: false,
     41     logLevel: 'silent',
     42     plugins: [
     43       {
     44         name: 'hcp047-test-entry',
     45         resolveId(id) {
     46           if (id === 'virtual:hcp047') return '\0hcp047';
     47         },
     48         load(id) {
     49           if (id === '\0hcp047')
     50             return `export * from ${JSON.stringify(source('database.ts'))};export * from ${JSON.stringify(source('drafts.ts'))};`;
     51         }
     52       }
     53     ],
     54     build: {
     55       write: false,
     56       minify: false,
     57       rolldownOptions: { input: 'virtual:hcp047' },
     58       lib: { entry: 'virtual:hcp047', name: 'hcp047', formats: ['iife'] }
     59     }
     60   });
     61   const output = Array.isArray(result) ? result[0] : result;
     62   if (!('output' in output)) throw new Error('missing test bundle');
     63   const chunks = output.output.filter((item) => item.type === 'chunk');
     64   expect(chunks).toHaveLength(1);
     65   bundle = chunks[0].code;
     66   console.log(
     67     JSON.stringify({
     68       fixture: 'HCP047_ACTUAL_MODULES_REAL_IDB',
     69       bundleSha256: createHash('sha256').update(bundle).digest('hex'),
     70       exposure: 'test-only virtual entry, no production route or dependency'
     71     })
     72   );
     73 });
     74 test.afterAll(async () => server.close());
     75 async function load(page: Page, selectedOwner = owner) {
     76   await page.goto(server.url + '/search');
     77   await page.addScriptTag({ content: bundle });
     78   await page.evaluate(async (expectedOwner) => {
     79     const api = window.hcp047;
     80     const opened = await api.openBrowserDatabase();
     81     if (opened.state !== 'ready') throw new Error(opened.reason);
     82     const repository = api.createPublicDraftRepository(
     83       opened.owner,
     84       expectedOwner
     85     );
     86     if (!repository) throw new Error('missing repository');
     87     window.hcp047Database = opened.owner;
     88     window.hcp047Repository = repository;
     89   }, selectedOwner);
     90 }
     91 test('guest GET and module initialization create no database; explicit create retains partial strings and detached snapshots', async ({
     92   page
     93 }) => {
     94   await page.goto(server.url + '/search');
     95   await page.addScriptTag({ content: bundle });
     96   expect(
     97     await page.evaluate(async () => (await indexedDB.databases()).length)
     98   ).toBe(0);
     99   await load(page);
    100   const result = await page.evaluate(async (input) => {
    101     const api = window.hcp047,
    102       repository = window.hcp047Repository;
    103     const created = await api.createPublicDraft(repository, input);
    104     if (!created.ok) throw new Error(created.reason);
    105     const id = created.value.id;
    106     const original = JSON.stringify(created.value);
    107     // Detached output mutation never edits the actual committed wire.
    108     const mutable = created.value as { form: { amount: string } };
    109     mutable.form.amount = 'other';
    110     const read = await api.readPublicDraft(repository, id);
    111     const listed = await api.listPublicDrafts(repository);
    112     api.closeBrowserDatabase(window.hcp047Database);
    113     const reopened = await api.openBrowserDatabase();
    114     if (reopened.state !== 'ready') throw new Error(reopened.reason);
    115     const next = api.createPublicDraftRepository(
    116       reopened.owner,
    117       created.value.owner
    118     );
    119     if (!next) throw new Error('missing reopened scope');
    120     const retained = await api.readPublicDraft(next, id);
    121     api.closeBrowserDatabase(reopened.owner);
    122     return {
    123       created: {
    124         ok: true as const,
    125         value: JSON.parse(original) as typeof created.value
    126       },
    127       read,
    128       listed,
    129       retained
    130     };
    131   }, form);
    132   expect(result.created.ok).toBe(true);
    133   expect(result.created.value.form).toEqual(form);
    134   expect(result.created.value.revision).toBe(0);
    135   expect(result.created.value.id).toMatch(
    136     /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
    137   );
    138   expect(result.read).toEqual(result.created);
    139   expect(result.retained).toEqual(result.created);
    140   expect(result.listed).toEqual({ ok: true, value: [result.created.value] });
    141 });
    142 test('two actual tabs serialize competing revision CAS and preserve the winning incomplete form', async ({
    143   page,
    144   context
    145 }) => {
    146   await load(page);
    147   const second = await context.newPage();
    148   await load(second);
    149   const created = await page.evaluate(
    150     async (input) =>
    151       window.hcp047.createPublicDraft(window.hcp047Repository, input),
    152     form
    153   );
    154   if (!created.ok) throw new Error(created.reason);
    155   const id = created.value.id;
    156   const saves = await Promise.all(
    157     [page, second].map((tab, index) =>
    158       tab.evaluate(
    159         async ({ id, form }) =>
    160           window.hcp047.savePublicDraft(window.hcp047Repository, id, 0, form),
    161         {
    162           id,
    163           form: {
    164             ...form,
    165             location: index === 0 ? 'unfinished north' : 'unfinished south',
    166             amount: '1.'
    167           }
    168         }
    169       )
    170     )
    171   );
    172   expect(saves.filter((save) => save.ok)).toHaveLength(1);
    173   expect(saves.filter((save) => !save.ok)).toEqual([
    174     { ok: false, reason: 'conflict' }
    175   ]);
    176   const winner = saves.find((save) => save.ok);
    177   const read = await second.evaluate(
    178     async (id) => window.hcp047.readPublicDraft(window.hcp047Repository, id),
    179     id
    180   );
    181   expect(read).toEqual(winner);
    182   if (!read.ok) throw new Error(read.reason);
    183   expect(read.value.revision).toBe(1);
    184   expect(read.value.form.amount).toBe('1.');
    185   await second.close();
    186 });
    187 test('two tabs race the last owner slot and cap refusal preserves every existing draft', async ({
    188   page,
    189   context
    190 }) => {
    191   await load(page);
    192   const initial = await page.evaluate(async (form) => {
    193     const rows = [];
    194     for (let i = 0; i < 19; i++)
    195       rows.push(
    196         await window.hcp047.createPublicDraft(window.hcp047Repository, form)
    197       );
    198     return rows;
    199   }, form);
    200   expect(initial.every((row) => row.ok)).toBe(true);
    201   const second = await context.newPage();
    202   await load(second);
    203   const raced = await Promise.all(
    204     [page, second].map((tab) =>
    205       tab.evaluate(
    206         async (form) =>
    207           window.hcp047.createPublicDraft(window.hcp047Repository, form),
    208         form
    209       )
    210     )
    211   );
    212   expect(raced.filter((row) => row.ok)).toHaveLength(1);
    213   expect(raced.filter((row) => !row.ok)).toEqual([
    214     { ok: false, reason: 'cap_reached' }
    215   ]);
    216   const after = await page.evaluate(async () =>
    217     window.hcp047.listPublicDrafts(window.hcp047Repository)
    218   );
    219   if (!after.ok) throw new Error(after.reason);
    220   expect(after.value).toHaveLength(20);
    221   for (const row of initial) {
    222     if (!row.ok) throw new Error(row.reason);
    223     expect(after.value.find((stored) => stored.id === row.value.id)).toEqual(
    224       row.value
    225     );
    226   }
    227   const separate = await second.evaluate(
    228     async ({ peer, form }) => {
    229       const repo = window.hcp047.createPublicDraftRepository(
    230         window.hcp047Database,
    231         peer
    232       );
    233       if (!repo) throw new Error('missing peer namespace');
    234       return window.hcp047.createPublicDraft(repo, form);
    235     },
    236     { peer, form }
    237   );
    238   expect(separate.ok).toBe(true);
    239   await second.close();
    240 });
    241 test('16KiB composed UTF8 inclusive admission, malformed getters and oversized update preserve the previous draft', async ({
    242   page
    243 }) => {
    244   await load(page);
    245   const result = await page.evaluate(async (input) => {
    246     const api = window.hcp047,
    247       repository = window.hcp047Repository;
    248     const bounded = { ...input, description: '菜'.repeat(5461), amount: 'x' };
    249     const created = await api.createPublicDraft(repository, bounded);
    250     if (!created.ok) throw new Error(created.reason);
    251     const overflow = await api.savePublicDraft(
    252       repository,
    253       created.value.id,
    254       0,
    255       { ...bounded, title: 'x' }
    256     );
    257     const getter = await api.savePublicDraft(repository, created.value.id, 0, {
    258       ...bounded,
    259       get title() {
    260         throw new Error('must not acquire getter');
    261       }
    262     });
    263     const badRevision = await api.savePublicDraft(
    264       repository,
    265       created.value.id,
    266       Number.MAX_SAFE_INTEGER,
    267       input
    268     );
    269     const proxy = await api.savePublicDraft(
    270       repository,
    271       created.value.id,
    272       0,
    273       new Proxy(input, {
    274         ownKeys() {
    275           throw new Error('hostile proxy');
    276         }
    277       })
    278     );
    279     let titleReads = 0,
    280       coercions = 0;
    281     const changingCreated = await api.createPublicDraft(
    282       repository,
    283       new Proxy(input, {
    284         get(target, property, receiver): unknown {
    285           if (property === 'title') {
    286             titleReads++;
    287             if (titleReads === 1) return 'captured-once';
    288             return {
    289               length: 0,
    290               isWellFormed() {
    291                 coercions++;
    292                 return true;
    293               },
    294               toString() {
    295                 coercions++;
    296                 return '';
    297               },
    298               toJSON() {
    299                 coercions++;
    300                 return '';
    301               }
    302             };
    303           }
    304           return Reflect.get(target, property, receiver);
    305         }
    306       })
    307     );
    308     const read = await api.readPublicDraft(repository, created.value.id);
    309     return {
    310       created,
    311       overflow,
    312       getter,
    313       badRevision,
    314       proxy,
    315       changingCreated,
    316       titleReads,
    317       coercions,
    318       read
    319     };
    320   }, form);
    321   expect(result.overflow).toEqual({ ok: false, reason: 'invalid_form' });
    322   expect(result.getter).toEqual({ ok: false, reason: 'invalid_form' });
    323   expect(result.badRevision).toEqual({ ok: false, reason: 'invalid_revision' });
    324   expect(result.proxy).toEqual({ ok: false, reason: 'invalid_form' });
    325   expect(result.titleReads).toBe(1);
    326   expect(result.coercions).toBe(0);
    327   if (!result.changingCreated.ok)
    328     throw new Error(result.changingCreated.reason);
    329   expect(result.changingCreated.value.form.title).toBe('captured-once');
    330   expect(result.read).toEqual(result.created);
    331 });
    332 test('foreign owner cannot read/update/list a draft, and its own cap is independent', async ({
    333   page,
    334   context
    335 }) => {
    336   await load(page);
    337   const created = await page.evaluate(
    338     async (form) =>
    339       window.hcp047.createPublicDraft(window.hcp047Repository, form),
    340     form
    341   );
    342   if (!created.ok) throw new Error(created.reason);
    343   const second = await context.newPage();
    344   await load(second, peer);
    345   const foreign = await second.evaluate(
    346     async ({ id, form }) => ({
    347       read: await window.hcp047.readPublicDraft(window.hcp047Repository, id),
    348       save: await window.hcp047.savePublicDraft(
    349         window.hcp047Repository,
    350         id,
    351         0,
    352         form
    353       ),
    354       list: await window.hcp047.listPublicDrafts(window.hcp047Repository),
    355       create: await window.hcp047.createPublicDraft(
    356         window.hcp047Repository,
    357         form
    358       )
    359     }),
    360     { id: created.value.id, form }
    361   );
    362   expect(foreign.read).toEqual({ ok: false, reason: 'not_found' });
    363   expect(foreign.save).toEqual({ ok: false, reason: 'not_found' });
    364   expect(foreign.list).toEqual({ ok: true, value: [] });
    365   expect(foreign.create.ok).toBe(true);
    366   expect(
    367     await page.evaluate(
    368       async (id) => window.hcp047.readPublicDraft(window.hcp047Repository, id),
    369       created.value.id
    370     )
    371   ).toEqual(created);
    372   await second.close();
    373 });
    374 test('malformed persisted schema aborts reads and updates without overwriting its bytes', async ({
    375   page
    376 }) => {
    377   await load(page);
    378   const result = await page.evaluate(async (form) => {
    379     const api = window.hcp047,
    380       repo = window.hcp047Repository;
    381     const created = await api.createPublicDraft(repo, form);
    382     if (!created.ok) throw new Error(created.reason);
    383     const corruptWire = JSON.stringify({ ...created.value, schema: 2 });
    384     const tx = api.browserDatabaseTransaction(
    385       window.hcp047Database,
    386       ['public_drafts'],
    387       'readwrite'
    388     );
    389     tx.objectStore('public_drafts').put({
    390       owner: created.value.owner,
    391       id: created.value.id,
    392       wire: corruptWire
    393     });
    394     await new Promise<void>((resolve, reject) => {
    395       tx.addEventListener('complete', () => resolve());
    396       tx.addEventListener('abort', () => reject(new Error('fixture abort')));
    397     });
    398     const read = await api.readPublicDraft(repo, created.value.id);
    399     const save = await api.savePublicDraft(repo, created.value.id, 0, form);
    400     const list = await api.listPublicDrafts(repo);
    401     const check = api.browserDatabaseTransaction(
    402       window.hcp047Database,
    403       ['public_drafts'],
    404       'readonly'
    405     );
    406     const request = check
    407       .objectStore('public_drafts')
    408       .get([created.value.owner, created.value.id]);
    409     const wire = await new Promise<unknown>((resolve) =>
    410       request.addEventListener('success', () => {
    411         const value: unknown = request.result;
    412         resolve(
    413           typeof value === 'object' && value !== null && 'wire' in value
    414             ? value.wire
    415             : undefined
    416         );
    417       })
    418     );
    419     return { read, save, list, wire, corruptWire };
    420   }, form);
    421   expect(result.read).toEqual({ ok: false, reason: 'corrupt_record' });
    422   expect(result.save).toEqual(result.read);
    423   expect(result.list).toEqual(result.read);
    424   expect(result.wire).toBe(result.corruptWire);
    425 });
    426 test('actual transaction abort after successful put never acknowledges or retains a draft', async ({
    427   page
    428 }) => {
    429   await load(page);
    430   const result = await page.evaluate(async (form) => {
    431     const api = window.hcp047,
    432       repo = window.hcp047Repository;
    433     const descriptor = Object.getOwnPropertyDescriptor(
    434       IDBObjectStore.prototype,
    435       'put'
    436     );
    437     if (!descriptor) throw new Error('missing put descriptor');
    438     const original = descriptor.value as IDBObjectStore['put'];
    439     IDBObjectStore.prototype.put = function (...args) {
    440       const request = original.apply(this, args);
    441       const transaction = this.transaction;
    442       request.addEventListener('success', () => transaction.abort());
    443       return request;
    444     };
    445     try {
    446       const create = await api.createPublicDraft(repo, form);
    447       const list = await api.listPublicDrafts(repo);
    448       return { create, list };
    449     } finally {
    450       IDBObjectStore.prototype.put = original;
    451     }
    452   }, form);
    453   expect(result.create).toEqual({ ok: false, reason: 'aborted' });
    454   expect(result.list).toEqual({ ok: true, value: [] });
    455 });
    456 test('closed database scope rejects later writes and never silently reopens', async ({
    457   page
    458 }) => {
    459   await load(page);
    460   const result = await page.evaluate(async (form) => {
    461     window.hcp047.closeBrowserDatabase(window.hcp047Database);
    462     return window.hcp047.createPublicDraft(window.hcp047Repository, form);
    463   }, form);
    464   expect(result).toEqual({ ok: false, reason: 'invalid_scope' });
    465 });
    466 
    467 test('explicit draft changes acquire only the public draft store and make no fetch or socket attempt', async ({
    468   page
    469 }) => {
    470   await load(page);
    471   const result = await page.evaluate(async (form) => {
    472     const transactionDescriptor = Object.getOwnPropertyDescriptor(
    473       IDBDatabase.prototype,
    474       'transaction'
    475     );
    476     const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch');
    477     const socketDescriptor = Object.getOwnPropertyDescriptor(
    478       window,
    479       'WebSocket'
    480     );
    481     if (!transactionDescriptor || !fetchDescriptor || !socketDescriptor)
    482       throw new Error('missing native descriptors');
    483     const transaction =
    484       transactionDescriptor.value as IDBDatabase['transaction'];
    485     const selected: string[][] = [];
    486     let effects = 0;
    487     IDBDatabase.prototype.transaction = function (...args) {
    488       selected.push(
    489         typeof args[0] === 'string' ? [args[0]] : Array.from(args[0])
    490       );
    491       return transaction.apply(this, args);
    492     };
    493     Object.defineProperty(window, 'fetch', {
    494       configurable: true,
    495       value: () => {
    496         effects++;
    497         throw new Error('unexpected fetch');
    498       }
    499     });
    500     Object.defineProperty(window, 'WebSocket', {
    501       configurable: true,
    502       value: class {
    503         constructor() {
    504           effects++;
    505           throw new Error('unexpected socket');
    506         }
    507       }
    508     });
    509     try {
    510       const api = window.hcp047,
    511         repo = window.hcp047Repository;
    512       const created = await api.createPublicDraft(repo, form);
    513       if (!created.ok) throw new Error(created.reason);
    514       const saved = await api.savePublicDraft(repo, created.value.id, 0, {
    515         ...form,
    516         amount: '1.'
    517       });
    518       if (!saved.ok) throw new Error(saved.reason);
    519       const read = await api.readPublicDraft(repo, created.value.id);
    520       const list = await api.listPublicDrafts(repo);
    521       return { saved, read, list, selected, effects };
    522     } finally {
    523       Object.defineProperty(
    524         IDBDatabase.prototype,
    525         'transaction',
    526         transactionDescriptor
    527       );
    528       Object.defineProperty(window, 'fetch', fetchDescriptor);
    529       Object.defineProperty(window, 'WebSocket', socketDescriptor);
    530     }
    531   }, form);
    532   expect(result.read).toEqual(result.saved);
    533   expect(result.list.ok).toBe(true);
    534   expect(result.effects).toBe(0);
    535   expect(result.selected).toEqual(
    536     Array.from({ length: 4 }, () => ['public_drafts'])
    537   );
    538 });