app

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

commit 7c22a771f5c267fa5d92673cc2f072d1ba4367b8
parent 034c9f224be72f2d17f2cb882fbc90a65d7c22fb
Author: triesap <tyson@radroots.org>
Date:   Tue,  6 Oct 2026 21:55:02 +0000

storage: implement incomplete public drafts and compare-and-set saves (HCP-047)

- Persist explicit public drafts in owner-scoped browser storage
- Serialize revision CAS and twenty-draft admission with native transactions
- Bound composed UTF8 before serialization and revalidate stored records
- Verify genuine two-tab races, aborts and cross-owner refusal

Diffstat:
Aweb/src/lib/persistence/drafts.ts | 345+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/e2e/drafts.spec.ts | 538+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Aweb/tests/integration/drafts.test.ts | 34++++++++++++++++++++++++++++++++++
Aweb/tests/unit/drafts.test.ts | 43+++++++++++++++++++++++++++++++++++++++++++
4 files changed, 960 insertions(+), 0 deletions(-)

diff --git a/web/src/lib/persistence/drafts.ts b/web/src/lib/persistence/drafts.ts @@ -0,0 +1,345 @@ +import { boundedUtf8 } from '../contracts/food-availability-v1/text.ts'; +import { canonicalPublicKey } from '../contracts/public-key.ts'; +import { + exactLocalFields, + type PublicDraftRecord +} from '../contracts/local-records.ts'; +import { canonicalLocalId, newLocalId } from '../private-handles.ts'; +import { safeUnsignedInteger } from '../nostr/envelope-bounds.ts'; +import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts'; +import { + browserDatabaseState, + browserDatabaseTransaction, + type BrowserDatabase +} from './database.ts'; +import { decodePublicRecord, publicRecordSnapshot } from './records.ts'; + +declare const repositoryBrand: unique symbol; +export type PublicDraftRepository = Readonly<{ [repositoryBrand]: true }>; +type Scope = Readonly<{ database: BrowserDatabase; owner: string }>; +const repositories = new WeakMap<PublicDraftRepository, Scope>(); +export type DraftFailure = + | 'invalid_scope' + | 'invalid_id' + | 'invalid_form' + | 'invalid_revision' + | 'unavailable' + | 'not_found' + | 'conflict' + | 'cap_reached' + | 'corrupt_record' + | 'aborted' + | 'unknown_completion'; +export type DraftResult<T> = + | Readonly<{ ok: true; value: T }> + | Readonly<{ ok: false; reason: DraftFailure }>; +function failed(reason: DraftFailure): DraftResult<never> { + return { ok: false, reason }; +} +function scopeOf(repository: PublicDraftRepository): Scope | undefined { + const scope = repositories.get(repository); + try { + return scope && browserDatabaseState(scope.database).state === 'ready' + ? scope + : undefined; + } catch { + return undefined; + } +} +// Explicit acquisition only. A canonical owner is a namespace, not proof of +// installed identity; account workflows retain that separate authority. +export function createPublicDraftRepository( + database: BrowserDatabase, + expectedOwner: unknown +): PublicDraftRepository | undefined { + const owner = canonicalPublicKey(expectedOwner); + try { + if (!owner || browserDatabaseState(database).state !== 'ready') + return undefined; + const handle = Object.freeze({}) as PublicDraftRepository; + repositories.set(handle, { database, owner }); + return handle; + } catch { + return undefined; + } +} +function proposed( + owner: string, + id: string, + revision: number, + form: unknown +): PublicDraftRecord | undefined { + try { + if ( + !exactLocalFields(form, [ + 'title', + 'description', + 'location', + 'amount', + 'currency', + 'unit', + 'quantity', + 'contactType', + 'contactValue' + ]) + ) + return undefined; + // Capture each caller field once before validating that captured value. + // Even a changing Proxy cannot substitute a coercible object after a check. + const captured = { + title: form.title, + description: form.description, + location: form.location, + amount: form.amount, + currency: form.currency, + unit: form.unit, + quantity: form.quantity, + contactType: form.contactType, + contactValue: form.contactValue + }; + if ( + captured.contactType !== '' && + captured.contactType !== 'email' && + captured.contactType !== 'phone' && + captured.contactType !== 'https' + ) + return undefined; + let composedBytes = 0; + for (const text of [ + captured.title, + captured.description, + captured.location, + captured.amount, + captured.currency, + captured.unit, + captured.quantity, + captured.contactType, + captured.contactValue + ]) { + if ( + typeof text !== 'string' || + !boundedUtf8(text, LOCAL_PERSISTENCE_BUDGETS.draftComposedBytes) + ) + return undefined; + composedBytes += new TextEncoder().encode(text).length; + if (composedBytes > LOCAL_PERSISTENCE_BUDGETS.draftComposedBytes) + return undefined; + } + const row = { + schema: 1, + family: 'public_draft', + owner, + id, + revision, + savedAtMilliseconds: Date.now(), + form: captured + }; + const admitted = decodePublicRecord(JSON.stringify(row), owner, id); + if (!admitted.ok) return undefined; + const snapshot = publicRecordSnapshot(admitted.value, owner, id); + return snapshot?.family === 'public_draft' ? snapshot : undefined; + } catch { + return undefined; + } +} +function stored( + value: unknown, + owner: string, + id: string +): PublicDraftRecord | undefined { + if ( + !exactLocalFields(value, ['owner', 'id', 'wire']) || + value.owner !== owner || + value.id !== id + ) + return undefined; + const admitted = decodePublicRecord(value.wire, owner, id); + if (!admitted.ok) return undefined; + const snapshot = publicRecordSnapshot(admitted.value, owner, id); + return snapshot?.family === 'public_draft' ? snapshot : undefined; +} +function transaction<T>( + scope: Scope, + mode: 'readonly' | 'readwrite', + run: ( + store: IDBObjectStore, + decide: (result: DraftResult<T>) => void, + refuse: (reason: DraftFailure) => void + ) => void +): Promise<DraftResult<T>> { + let active: IDBTransaction; + try { + active = browserDatabaseTransaction( + scope.database, + ['public_drafts'], + mode + ); + } catch { + return Promise.resolve(failed('unavailable')); + } + return new Promise((resolve) => { + let decision: DraftResult<T> | undefined; + function refuse(reason: DraftFailure): void { + decision = failed(reason); + try { + active.abort(); + } catch { + decision = failed('unknown_completion'); + } + } + active.addEventListener('complete', () => + resolve(decision ?? failed('unknown_completion')) + ); + active.addEventListener('abort', () => + resolve(decision && !decision.ok ? decision : failed('aborted')) + ); + // A request success never acknowledges a save. Only the transaction's + // complete event returns its captured payload; abort overrides any success. + try { + run( + active.objectStore('public_drafts'), + (result) => { + decision = result; + }, + refuse + ); + } catch { + refuse('aborted'); + } + }); +} +export function createPublicDraft( + repository: PublicDraftRepository, + form: unknown +): Promise<DraftResult<PublicDraftRecord>> { + const scope = scopeOf(repository); + if (!scope) return Promise.resolve(failed('invalid_scope')); + const id = newLocalId(); + if (!id) return Promise.resolve(failed('invalid_id')); + const row = proposed(scope.owner, id, 0, form); + if (!row) return Promise.resolve(failed('invalid_form')); + return transaction(scope, 'readwrite', (store, decide, refuse) => { + const collision = store.get([scope.owner, id]); + collision.addEventListener('success', () => { + if (collision.result !== undefined) { + refuse('conflict'); + return; + } + const count = store + .index('by_owner') + .count(IDBKeyRange.only(scope.owner)); + count.addEventListener('success', () => { + if (count.result >= LOCAL_PERSISTENCE_BUDGETS.publicDrafts) { + refuse('cap_reached'); + return; + } + const put = store.put({ + owner: scope.owner, + id, + wire: JSON.stringify(row) + }); + put.addEventListener('success', () => decide({ ok: true, value: row })); + }); + }); + }); +} +export function readPublicDraft( + repository: PublicDraftRepository, + expectedId: unknown +): Promise<DraftResult<PublicDraftRecord>> { + const scope = scopeOf(repository), + id = canonicalLocalId(expectedId); + if (!scope) return Promise.resolve(failed('invalid_scope')); + if (!id) return Promise.resolve(failed('invalid_id')); + return transaction(scope, 'readonly', (store, decide, refuse) => { + const request = store.get([scope.owner, id]); + request.addEventListener('success', () => { + if (request.result === undefined) { + decide(failed('not_found')); + return; + } + const row = stored(request.result, scope.owner, id); + if (!row) { + refuse('corrupt_record'); + return; + } + decide({ ok: true, value: row }); + }); + }); +} +export function savePublicDraft( + repository: PublicDraftRepository, + expectedId: unknown, + expectedRevision: unknown, + form: unknown +): Promise<DraftResult<PublicDraftRecord>> { + const scope = scopeOf(repository), + id = canonicalLocalId(expectedId); + if (!scope) return Promise.resolve(failed('invalid_scope')); + if (!id) return Promise.resolve(failed('invalid_id')); + const revision = safeUnsignedInteger(expectedRevision); + if (revision === undefined || revision === Number.MAX_SAFE_INTEGER) + return Promise.resolve(failed('invalid_revision')); + const row = proposed(scope.owner, id, revision + 1, form); + if (!row) return Promise.resolve(failed('invalid_form')); + return transaction(scope, 'readwrite', (store, decide, refuse) => { + const request = store.get([scope.owner, id]); + request.addEventListener('success', () => { + if (request.result === undefined) { + refuse('not_found'); + return; + } + const previous = stored(request.result, scope.owner, id); + if (!previous) { + refuse('corrupt_record'); + return; + } + if (previous.revision !== revision) { + refuse('conflict'); + return; + } + const put = store.put({ + owner: scope.owner, + id, + wire: JSON.stringify(row) + }); + put.addEventListener('success', () => decide({ ok: true, value: row })); + }); + }); +} +export function listPublicDrafts( + repository: PublicDraftRepository +): Promise<DraftResult<readonly PublicDraftRecord[]>> { + const scope = scopeOf(repository); + if (!scope) return Promise.resolve(failed('invalid_scope')); + return transaction(scope, 'readonly', (store, decide, refuse) => { + let rows = Array.from<PublicDraftRecord>([]); + const request = store + .index('by_owner') + .openCursor(IDBKeyRange.only(scope.owner)); + request.addEventListener('success', () => { + const cursor = request.result; + if (!cursor) { + decide({ ok: true, value: rows }); + return; + } + if (rows.length >= LOCAL_PERSISTENCE_BUDGETS.publicDrafts) { + refuse('cap_reached'); + return; + } + const key = cursor.primaryKey; + if (!Array.isArray(key) || key.length !== 2 || key[0] !== scope.owner) { + refuse('corrupt_record'); + return; + } + const id = canonicalLocalId(key[1]); + const row = id && stored(cursor.value, scope.owner, id); + if (!row) { + refuse('corrupt_record'); + return; + } + rows = rows.concat(row); + cursor.continue(); + }); + }); +} diff --git a/web/tests/e2e/drafts.spec.ts b/web/tests/e2e/drafts.spec.ts @@ -0,0 +1,538 @@ +import { expect, test, type Page } from '@playwright/test'; +import { build } from 'vite'; +import { createHash } from 'node:crypto'; +import { fileURLToPath } from 'node:url'; +import { createStaticHarness } from '../integration/harness/static.ts'; +import type * as Database from '../../src/lib/persistence/database.ts'; +import type * as Drafts from '../../src/lib/persistence/drafts.ts'; +declare global { + interface Window { + hcp047: typeof Database & typeof Drafts; + hcp047Database: Database.BrowserDatabase; + hcp047Repository: Drafts.PublicDraftRepository; + } +} +const owner = + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'; +const peer = 'c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5'; +const form = { + title: '', + description: 'unfinished', + location: '', + amount: '.', + currency: '', + unit: '', + quantity: '', + contactType: '' as const, + contactValue: '' +}; +let server: Awaited<ReturnType<typeof createStaticHarness>>; +let bundle: string; +test.beforeAll(async () => { + server = await createStaticHarness(); + const source = (name: string) => + fileURLToPath( + new URL('../../src/lib/persistence/' + name, import.meta.url) + ); + // Compile the exact current production modules together so both use the same + // genuine WeakMap database ownership. This virtual entry is test-only. + const result = await build({ + configFile: false, + logLevel: 'silent', + plugins: [ + { + name: 'hcp047-test-entry', + resolveId(id) { + if (id === 'virtual:hcp047') return '\0hcp047'; + }, + load(id) { + if (id === '\0hcp047') + return `export * from ${JSON.stringify(source('database.ts'))};export * from ${JSON.stringify(source('drafts.ts'))};`; + } + } + ], + build: { + write: false, + minify: false, + rolldownOptions: { input: 'virtual:hcp047' }, + lib: { entry: 'virtual:hcp047', name: 'hcp047', formats: ['iife'] } + } + }); + const output = Array.isArray(result) ? result[0] : result; + if (!('output' in output)) throw new Error('missing test bundle'); + const chunks = output.output.filter((item) => item.type === 'chunk'); + expect(chunks).toHaveLength(1); + bundle = chunks[0].code; + console.log( + JSON.stringify({ + fixture: 'HCP047_ACTUAL_MODULES_REAL_IDB', + bundleSha256: createHash('sha256').update(bundle).digest('hex'), + exposure: 'test-only virtual entry, no production route or dependency' + }) + ); +}); +test.afterAll(async () => server.close()); +async function load(page: Page, selectedOwner = owner) { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + await page.evaluate(async (expectedOwner) => { + const api = window.hcp047; + const opened = await api.openBrowserDatabase(); + if (opened.state !== 'ready') throw new Error(opened.reason); + const repository = api.createPublicDraftRepository( + opened.owner, + expectedOwner + ); + if (!repository) throw new Error('missing repository'); + window.hcp047Database = opened.owner; + window.hcp047Repository = repository; + }, selectedOwner); +} +test('guest GET and module initialization create no database; explicit create retains partial strings and detached snapshots', async ({ + page +}) => { + await page.goto(server.url + '/search'); + await page.addScriptTag({ content: bundle }); + expect( + await page.evaluate(async () => (await indexedDB.databases()).length) + ).toBe(0); + await load(page); + const result = await page.evaluate(async (input) => { + const api = window.hcp047, + repository = window.hcp047Repository; + const created = await api.createPublicDraft(repository, input); + if (!created.ok) throw new Error(created.reason); + const id = created.value.id; + const original = JSON.stringify(created.value); + // Detached output mutation never edits the actual committed wire. + const mutable = created.value as { form: { amount: string } }; + mutable.form.amount = 'other'; + const read = await api.readPublicDraft(repository, id); + const listed = await api.listPublicDrafts(repository); + api.closeBrowserDatabase(window.hcp047Database); + const reopened = await api.openBrowserDatabase(); + if (reopened.state !== 'ready') throw new Error(reopened.reason); + const next = api.createPublicDraftRepository( + reopened.owner, + created.value.owner + ); + if (!next) throw new Error('missing reopened scope'); + const retained = await api.readPublicDraft(next, id); + api.closeBrowserDatabase(reopened.owner); + return { + created: { + ok: true as const, + value: JSON.parse(original) as typeof created.value + }, + read, + listed, + retained + }; + }, form); + expect(result.created.ok).toBe(true); + expect(result.created.value.form).toEqual(form); + expect(result.created.value.revision).toBe(0); + expect(result.created.value.id).toMatch( + /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/ + ); + expect(result.read).toEqual(result.created); + expect(result.retained).toEqual(result.created); + expect(result.listed).toEqual({ ok: true, value: [result.created.value] }); +}); +test('two actual tabs serialize competing revision CAS and preserve the winning incomplete form', async ({ + page, + context +}) => { + await load(page); + const second = await context.newPage(); + await load(second); + const created = await page.evaluate( + async (input) => + window.hcp047.createPublicDraft(window.hcp047Repository, input), + form + ); + if (!created.ok) throw new Error(created.reason); + const id = created.value.id; + const saves = await Promise.all( + [page, second].map((tab, index) => + tab.evaluate( + async ({ id, form }) => + window.hcp047.savePublicDraft(window.hcp047Repository, id, 0, form), + { + id, + form: { + ...form, + location: index === 0 ? 'unfinished north' : 'unfinished south', + amount: '1.' + } + } + ) + ) + ); + expect(saves.filter((save) => save.ok)).toHaveLength(1); + expect(saves.filter((save) => !save.ok)).toEqual([ + { ok: false, reason: 'conflict' } + ]); + const winner = saves.find((save) => save.ok); + const read = await second.evaluate( + async (id) => window.hcp047.readPublicDraft(window.hcp047Repository, id), + id + ); + expect(read).toEqual(winner); + if (!read.ok) throw new Error(read.reason); + expect(read.value.revision).toBe(1); + expect(read.value.form.amount).toBe('1.'); + await second.close(); +}); +test('two tabs race the last owner slot and cap refusal preserves every existing draft', async ({ + page, + context +}) => { + await load(page); + const initial = await page.evaluate(async (form) => { + const rows = []; + for (let i = 0; i < 19; i++) + rows.push( + await window.hcp047.createPublicDraft(window.hcp047Repository, form) + ); + return rows; + }, form); + expect(initial.every((row) => row.ok)).toBe(true); + const second = await context.newPage(); + await load(second); + const raced = await Promise.all( + [page, second].map((tab) => + tab.evaluate( + async (form) => + window.hcp047.createPublicDraft(window.hcp047Repository, form), + form + ) + ) + ); + expect(raced.filter((row) => row.ok)).toHaveLength(1); + expect(raced.filter((row) => !row.ok)).toEqual([ + { ok: false, reason: 'cap_reached' } + ]); + const after = await page.evaluate(async () => + window.hcp047.listPublicDrafts(window.hcp047Repository) + ); + if (!after.ok) throw new Error(after.reason); + expect(after.value).toHaveLength(20); + for (const row of initial) { + if (!row.ok) throw new Error(row.reason); + expect(after.value.find((stored) => stored.id === row.value.id)).toEqual( + row.value + ); + } + const separate = await second.evaluate( + async ({ peer, form }) => { + const repo = window.hcp047.createPublicDraftRepository( + window.hcp047Database, + peer + ); + if (!repo) throw new Error('missing peer namespace'); + return window.hcp047.createPublicDraft(repo, form); + }, + { peer, form } + ); + expect(separate.ok).toBe(true); + await second.close(); +}); +test('16KiB composed UTF8 inclusive admission, malformed getters and oversized update preserve the previous draft', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async (input) => { + const api = window.hcp047, + repository = window.hcp047Repository; + const bounded = { ...input, description: '菜'.repeat(5461), amount: 'x' }; + const created = await api.createPublicDraft(repository, bounded); + if (!created.ok) throw new Error(created.reason); + const overflow = await api.savePublicDraft( + repository, + created.value.id, + 0, + { ...bounded, title: 'x' } + ); + const getter = await api.savePublicDraft(repository, created.value.id, 0, { + ...bounded, + get title() { + throw new Error('must not acquire getter'); + } + }); + const badRevision = await api.savePublicDraft( + repository, + created.value.id, + Number.MAX_SAFE_INTEGER, + input + ); + const proxy = await api.savePublicDraft( + repository, + created.value.id, + 0, + new Proxy(input, { + ownKeys() { + throw new Error('hostile proxy'); + } + }) + ); + let titleReads = 0, + coercions = 0; + const changingCreated = await api.createPublicDraft( + repository, + new Proxy(input, { + get(target, property, receiver): unknown { + if (property === 'title') { + titleReads++; + if (titleReads === 1) return 'captured-once'; + return { + length: 0, + isWellFormed() { + coercions++; + return true; + }, + toString() { + coercions++; + return ''; + }, + toJSON() { + coercions++; + return ''; + } + }; + } + return Reflect.get(target, property, receiver); + } + }) + ); + const read = await api.readPublicDraft(repository, created.value.id); + return { + created, + overflow, + getter, + badRevision, + proxy, + changingCreated, + titleReads, + coercions, + read + }; + }, form); + expect(result.overflow).toEqual({ ok: false, reason: 'invalid_form' }); + expect(result.getter).toEqual({ ok: false, reason: 'invalid_form' }); + expect(result.badRevision).toEqual({ ok: false, reason: 'invalid_revision' }); + expect(result.proxy).toEqual({ ok: false, reason: 'invalid_form' }); + expect(result.titleReads).toBe(1); + expect(result.coercions).toBe(0); + if (!result.changingCreated.ok) + throw new Error(result.changingCreated.reason); + expect(result.changingCreated.value.form.title).toBe('captured-once'); + expect(result.read).toEqual(result.created); +}); +test('foreign owner cannot read/update/list a draft, and its own cap is independent', async ({ + page, + context +}) => { + await load(page); + const created = await page.evaluate( + async (form) => + window.hcp047.createPublicDraft(window.hcp047Repository, form), + form + ); + if (!created.ok) throw new Error(created.reason); + const second = await context.newPage(); + await load(second, peer); + const foreign = await second.evaluate( + async ({ id, form }) => ({ + read: await window.hcp047.readPublicDraft(window.hcp047Repository, id), + save: await window.hcp047.savePublicDraft( + window.hcp047Repository, + id, + 0, + form + ), + list: await window.hcp047.listPublicDrafts(window.hcp047Repository), + create: await window.hcp047.createPublicDraft( + window.hcp047Repository, + form + ) + }), + { id: created.value.id, form } + ); + expect(foreign.read).toEqual({ ok: false, reason: 'not_found' }); + expect(foreign.save).toEqual({ ok: false, reason: 'not_found' }); + expect(foreign.list).toEqual({ ok: true, value: [] }); + expect(foreign.create.ok).toBe(true); + expect( + await page.evaluate( + async (id) => window.hcp047.readPublicDraft(window.hcp047Repository, id), + created.value.id + ) + ).toEqual(created); + await second.close(); +}); +test('malformed persisted schema aborts reads and updates without overwriting its bytes', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async (form) => { + const api = window.hcp047, + repo = window.hcp047Repository; + const created = await api.createPublicDraft(repo, form); + if (!created.ok) throw new Error(created.reason); + const corruptWire = JSON.stringify({ ...created.value, schema: 2 }); + const tx = api.browserDatabaseTransaction( + window.hcp047Database, + ['public_drafts'], + 'readwrite' + ); + tx.objectStore('public_drafts').put({ + owner: created.value.owner, + id: created.value.id, + wire: corruptWire + }); + await new Promise<void>((resolve, reject) => { + tx.addEventListener('complete', () => resolve()); + tx.addEventListener('abort', () => reject(new Error('fixture abort'))); + }); + const read = await api.readPublicDraft(repo, created.value.id); + const save = await api.savePublicDraft(repo, created.value.id, 0, form); + const list = await api.listPublicDrafts(repo); + const check = api.browserDatabaseTransaction( + window.hcp047Database, + ['public_drafts'], + 'readonly' + ); + const request = check + .objectStore('public_drafts') + .get([created.value.owner, created.value.id]); + const wire = await new Promise<unknown>((resolve) => + request.addEventListener('success', () => { + const value: unknown = request.result; + resolve( + typeof value === 'object' && value !== null && 'wire' in value + ? value.wire + : undefined + ); + }) + ); + return { read, save, list, wire, corruptWire }; + }, form); + expect(result.read).toEqual({ ok: false, reason: 'corrupt_record' }); + expect(result.save).toEqual(result.read); + expect(result.list).toEqual(result.read); + expect(result.wire).toBe(result.corruptWire); +}); +test('actual transaction abort after successful put never acknowledges or retains a draft', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async (form) => { + const api = window.hcp047, + repo = window.hcp047Repository; + const descriptor = Object.getOwnPropertyDescriptor( + IDBObjectStore.prototype, + 'put' + ); + if (!descriptor) throw new Error('missing put descriptor'); + const original = descriptor.value as IDBObjectStore['put']; + IDBObjectStore.prototype.put = function (...args) { + const request = original.apply(this, args); + const transaction = this.transaction; + request.addEventListener('success', () => transaction.abort()); + return request; + }; + try { + const create = await api.createPublicDraft(repo, form); + const list = await api.listPublicDrafts(repo); + return { create, list }; + } finally { + IDBObjectStore.prototype.put = original; + } + }, form); + expect(result.create).toEqual({ ok: false, reason: 'aborted' }); + expect(result.list).toEqual({ ok: true, value: [] }); +}); +test('closed database scope rejects later writes and never silently reopens', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async (form) => { + window.hcp047.closeBrowserDatabase(window.hcp047Database); + return window.hcp047.createPublicDraft(window.hcp047Repository, form); + }, form); + expect(result).toEqual({ ok: false, reason: 'invalid_scope' }); +}); + +test('explicit draft changes acquire only the public draft store and make no fetch or socket attempt', async ({ + page +}) => { + await load(page); + const result = await page.evaluate(async (form) => { + const transactionDescriptor = Object.getOwnPropertyDescriptor( + IDBDatabase.prototype, + 'transaction' + ); + const fetchDescriptor = Object.getOwnPropertyDescriptor(window, 'fetch'); + const socketDescriptor = Object.getOwnPropertyDescriptor( + window, + 'WebSocket' + ); + if (!transactionDescriptor || !fetchDescriptor || !socketDescriptor) + throw new Error('missing native descriptors'); + const transaction = + transactionDescriptor.value as IDBDatabase['transaction']; + const selected: string[][] = []; + let effects = 0; + IDBDatabase.prototype.transaction = function (...args) { + selected.push( + typeof args[0] === 'string' ? [args[0]] : Array.from(args[0]) + ); + return transaction.apply(this, args); + }; + Object.defineProperty(window, 'fetch', { + configurable: true, + value: () => { + effects++; + throw new Error('unexpected fetch'); + } + }); + Object.defineProperty(window, 'WebSocket', { + configurable: true, + value: class { + constructor() { + effects++; + throw new Error('unexpected socket'); + } + } + }); + try { + const api = window.hcp047, + repo = window.hcp047Repository; + const created = await api.createPublicDraft(repo, form); + if (!created.ok) throw new Error(created.reason); + const saved = await api.savePublicDraft(repo, created.value.id, 0, { + ...form, + amount: '1.' + }); + if (!saved.ok) throw new Error(saved.reason); + const read = await api.readPublicDraft(repo, created.value.id); + const list = await api.listPublicDrafts(repo); + return { saved, read, list, selected, effects }; + } finally { + Object.defineProperty( + IDBDatabase.prototype, + 'transaction', + transactionDescriptor + ); + Object.defineProperty(window, 'fetch', fetchDescriptor); + Object.defineProperty(window, 'WebSocket', socketDescriptor); + } + }, form); + expect(result.read).toEqual(result.saved); + expect(result.list.ok).toBe(true); + expect(result.effects).toBe(0); + expect(result.selected).toEqual( + Array.from({ length: 4 }, () => ['public_drafts']) + ); +}); diff --git a/web/tests/integration/drafts.test.ts b/web/tests/integration/drafts.test.ts @@ -0,0 +1,34 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +await test('actual draft module import and fabricated-owner rejection never acquire IndexedDB during SSR', async () => { + const before = Object.getOwnPropertyDescriptor(globalThis, 'indexedDB'); + Object.defineProperty(globalThis, 'indexedDB', { + configurable: true, + get() { + throw new Error('SSR cannot acquire IndexedDB'); + } + }); + try { + const api = await import('../../src/lib/persistence/drafts.ts'); + const database = { + kind: 'browser_database' + } as import('../../src/lib/persistence/database.ts').BrowserDatabase; + assert.equal( + api.createPublicDraftRepository( + database, + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' + ), + undefined + ); + const fake = Object.freeze( + {} + ) as import('../../src/lib/persistence/drafts.ts').PublicDraftRepository; + assert.deepEqual(await api.listPublicDrafts(fake), { + ok: false, + reason: 'invalid_scope' + }); + } finally { + if (before) Object.defineProperty(globalThis, 'indexedDB', before); + else Reflect.deleteProperty(globalThis, 'indexedDB'); + } +}); diff --git a/web/tests/unit/drafts.test.ts b/web/tests/unit/drafts.test.ts @@ -0,0 +1,43 @@ +import { describe, expect, it } from 'vitest'; +import { + createPublicDraftRepository, + createPublicDraft, + readPublicDraft, + savePublicDraft, + listPublicDrafts, + type PublicDraftRepository +} from '../../src/lib/persistence/drafts.ts'; + +describe('public draft repository capability admission', () => { + it('a fabricated database cannot mint a repository for a valid owner', () => { + expect( + createPublicDraftRepository( + { kind: 'browser_database' }, + '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' + ) + ).toBeUndefined(); + }); + it('foreign or fabricated repository objects cannot acquire storage or form getters', async () => { + const fake = Object.freeze({}) as PublicDraftRepository; + const form = { + get title() { + throw new Error('must not acquire caller data'); + } + }; + const outcomes = await Promise.all([ + createPublicDraft(fake, form), + readPublicDraft(fake, 'not-an-id'), + savePublicDraft(fake, 'not-an-id', 0, form), + listPublicDrafts(fake) + ]); + expect(outcomes).toEqual( + Array(4).fill({ ok: false, reason: 'invalid_scope' }) + ); + }); + it('unknown owners cannot open an implicit database', () => { + for (const owner of [undefined, null, '', '0'.repeat(64), 'npub1invalid']) + expect( + createPublicDraftRepository({ kind: 'browser_database' }, owner) + ).toBeUndefined(); + }); +});