app

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

local-data-review.ts (20385B)


      1 import {
      2   identityViewSession,
      3   subscribeIdentityView,
      4   type IdentityViewContext
      5 } from '../runtime/view-context.ts';
      6 import {
      7   identityLocalOwnership,
      8   identitySessionSnapshot,
      9   subscribeIdentityInvalidation
     10 } from '../runtime/identity-session.ts';
     11 import { createPrivateSession } from '../runtime/private-session.ts';
     12 import {
     13   openBrowserDatabase,
     14   closeBrowserDatabase,
     15   type BrowserDatabase
     16 } from './database.ts';
     17 import {
     18   createPublicQuotaRepository,
     19   inspectPublicStorage,
     20   publicInventorySnapshot,
     21   reviewPublicCleanup,
     22   commitPublicCleanup,
     23   type PublicQuotaRepository,
     24   type PublicInventory,
     25   type PublicCleanup
     26 } from './quota.ts';
     27 import {
     28   createPrivateStorageRepository,
     29   listPrivateSendRecords,
     30   listPrivateReceivedRecords,
     31   type PrivateStorageRepository
     32 } from './private-storage.ts';
     33 import {
     34   privateRecordIdentity,
     35   privateRecordWire,
     36   privateRecordSnapshot,
     37   type PrivateRecordHandle
     38 } from './private-records.ts';
     39 import {
     40   capturePrivateOutboxCleanup,
     41   deleteReviewedSettledSends,
     42   stopPrivateOutboxCleanup,
     43   type PrivateOutboxCleanup
     44 } from './private-outbox-cleanup.ts';
     45 import {
     46   captureReceivedCleanup,
     47   deleteReviewedReceivedCopies,
     48   stopReceivedCleanup,
     49   type ReceivedCleanup
     50 } from './inbox-retention.ts';
     51 import {
     52   PUBLIC_CLEANUP_CONSEQUENCES,
     53   PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES,
     54   privateInventoryRow,
     55   type PublicInventoryRow,
     56   type PrivateInventoryRow
     57 } from './local-inventory.ts';
     58 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';
     59 
     60 declare const reviewBrand: unique symbol;
     61 export type LocalDataReview = Readonly<{ [reviewBrand]: true }>;
     62 type Category = 'public' | 'received' | 'outbox';
     63 type Preview = Readonly<{
     64   category: Category;
     65   selected: number;
     66   consequences: string;
     67 }>;
     68 type Inventory = Readonly<{
     69   owner: string;
     70   publicRows: readonly PublicInventoryRow[];
     71   received: readonly Readonly<{ id: string; logicalBytes: number }>[];
     72   outbox: Readonly<{ count: number; bytes: number }>;
     73   outboxRows: readonly PrivateInventoryRow[];
     74   receivedRemoval: boolean;
     75 }>;
     76 export type LocalDataReviewSnapshot =
     77   | Readonly<{ state: 'guest' | 'closed' }>
     78   | Readonly<{ state: 'loading' }>
     79   | Readonly<{ state: 'unavailable'; notice: string }>
     80   | (Inventory &
     81       Readonly<{
     82         state: 'ready';
     83         busy: boolean;
     84         preview?: Preview;
     85         notice?: string;
     86       }>);
     87 type Controller = {
     88   snapshot(): LocalDataReviewSnapshot;
     89   review(consent: unknown): Promise<void>;
     90   preview(category: unknown, selection: unknown): Promise<boolean>;
     91   confirm(consent: unknown): Promise<boolean>;
     92   cancel(): void;
     93   close(): void;
     94   subscribe(listener: () => void): () => void;
     95 };
     96 const reviews = new WeakMap<LocalDataReview, Controller>();
     97 const receivedConsequences =
     98   'Removing selected encrypted copies loses those local messages. Relay recovery is not guaranteed. Other participants and relays may retain copies. Outbox recovery records stay unchanged. Browser-local storage is not a backup.';
     99 const unavailable =
    100   'Local inventory or removal was not confirmed. Existing local data has not been reset. You can still browse public food. Review current data before trying again; an unknown completion may have changed selected local copies.';
    101 
    102 function outboxInventory(
    103   handles: readonly PrivateRecordHandle[],
    104   owner: string
    105 ): PrivateInventoryRow[] {
    106   return handles.map((handle) => {
    107     const identity = privateRecordIdentity(handle),
    108       record = identity && privateRecordSnapshot(handle, owner, identity.id),
    109       wire = identity && privateRecordWire(handle, owner, identity.id);
    110     if (!record || !wire) throw Error('outbox inventory unavailable');
    111     return privateInventoryRow(
    112       record,
    113       new TextEncoder().encode(JSON.stringify({ owner, id: record.id, wire }))
    114         .length
    115     );
    116   });
    117 }
    118 
    119 function selection(value: unknown, maximum: number): string[] | undefined {
    120   if (
    121     typeof value !== 'string' ||
    122     new TextEncoder().encode(value).length > 160000
    123   )
    124     return;
    125   try {
    126     const parsed: unknown = JSON.parse(value);
    127     if (
    128       !Array.isArray(parsed) ||
    129       !parsed.length ||
    130       parsed.length > maximum ||
    131       !parsed.every((id: unknown) => typeof id === 'string') ||
    132       new Set(parsed).size !== parsed.length
    133     )
    134       return;
    135     return parsed.slice();
    136   } catch {
    137     return;
    138   }
    139 }
    140 
    141 // Pure per-view construction. Merely visiting Privacy never opens the inventory,
    142 // acquires an extension permission, probes messaging or creates a private socket.
    143 export function createLocalDataReview(
    144   context: IdentityViewContext
    145 ): LocalDataReview {
    146   const token = Object.freeze({}) as LocalDataReview;
    147   const listeners = new Map<symbol, () => void>();
    148   let closed = false,
    149     generation = Symbol(),
    150     busy = false;
    151   // Whole immutable snapshots are replaced; no caller object is mutated.
    152   let state: LocalDataReviewSnapshot;
    153   state = { state: 'guest' };
    154   let ownership: ReturnType<typeof identityLocalOwnership>;
    155   let database: BrowserDatabase | undefined,
    156     cancellation: AbortController | undefined;
    157   let publicRepository: PublicQuotaRepository | undefined,
    158     inventory: PublicInventory | undefined;
    159   let privateRepository: PrivateStorageRepository | undefined;
    160   let publicCleanup: PublicCleanup | undefined,
    161     receivedCleanup: ReceivedCleanup | undefined;
    162   let outboxCleanup: PrivateOutboxCleanup | undefined;
    163   let offIdentity = () => {};
    164   function notify() {
    165     for (const listener of listeners.values()) {
    166       try {
    167         listener();
    168       } catch {
    169         /* Presentation cannot interrupt storage settlement. */
    170       }
    171     }
    172   }
    173   function cancelPreview() {
    174     publicCleanup = undefined;
    175     if (receivedCleanup) stopReceivedCleanup(receivedCleanup);
    176     receivedCleanup = undefined;
    177     if (outboxCleanup) stopPrivateOutboxCleanup(outboxCleanup);
    178     outboxCleanup = undefined;
    179     if (state.state === 'ready') state = { ...state, preview: undefined };
    180   }
    181   function retire() {
    182     generation = Symbol();
    183     cancellation?.abort();
    184     cancellation = undefined;
    185     cancelPreview();
    186     if (database) closeBrowserDatabase(database);
    187     database = undefined;
    188     publicRepository = undefined;
    189     privateRepository = undefined;
    190     inventory = undefined;
    191     ownership = undefined;
    192     busy = false;
    193     offIdentity();
    194     offIdentity = () => {};
    195     state = closed ? { state: 'closed' } : { state: 'guest' };
    196   }
    197   function current(original: symbol) {
    198     return !closed && generation === original && ownership?.current() === true;
    199   }
    200   function observe() {
    201     if (ownership && !ownership.current()) {
    202       retire();
    203       notify();
    204     }
    205   }
    206   const offView = subscribeIdentityView(context, observe);
    207   async function review(consent: unknown) {
    208     if (closed || busy || consent !== 'reviewed_local_inventory') return;
    209     retire();
    210     const identity = identityViewSession(context);
    211     const captured = identity && identityLocalOwnership(identity);
    212     if (!identity || !captured?.current() || typeof window === 'undefined') {
    213       notify();
    214       return;
    215     }
    216     ownership = captured;
    217     busy = true;
    218     cancellation = new AbortController();
    219     const original = generation;
    220     offIdentity = subscribeIdentityInvalidation(identity, observe);
    221     state = { state: 'loading' };
    222     notify();
    223     try {
    224       const opened = await openBrowserDatabase(cancellation.signal);
    225       if (!current(original)) {
    226         if (opened.state === 'ready') closeBrowserDatabase(opened.owner);
    227         return;
    228       }
    229       if (opened.state !== 'ready') throw Error('local storage unavailable');
    230       database = opened.owner;
    231       const pub = createPublicQuotaRepository(database, captured.owner),
    232         priv = createPrivateStorageRepository(database, captured.owner);
    233       if (!pub || !priv) throw Error('local owner namespace unavailable');
    234       const scan = await inspectPublicStorage(pub);
    235       if (!current(original)) return;
    236       if (!scan.ok) throw Error('public inventory unavailable');
    237       const publicState = publicInventorySnapshot(pub, scan.value);
    238       const received = await listPrivateReceivedRecords(priv);
    239       if (!current(original)) return;
    240       const outbox = await listPrivateSendRecords(priv);
    241       if (!current(original)) return;
    242       if (!publicState || !received.ok || !outbox.ok)
    243         throw Error('private inventory unavailable');
    244       const copies = received.value.map((handle) => {
    245         const row = privateRecordIdentity(handle),
    246           wire = row && privateRecordWire(handle, captured.owner, row.id);
    247         if (!row || row.owner !== captured.owner || !wire)
    248           throw Error('received inventory unavailable');
    249         return {
    250           id: row.id,
    251           logicalBytes: new TextEncoder().encode(
    252             JSON.stringify({ owner: captured.owner, id: row.id, wire })
    253           ).length
    254         };
    255       });
    256       const outboxRows = outboxInventory(outbox.value, captured.owner);
    257       publicRepository = pub;
    258       privateRepository = priv;
    259       inventory = scan.value;
    260       state = {
    261         state: 'ready',
    262         busy: false,
    263         owner: captured.owner,
    264         publicRows: publicState.rows,
    265         received: copies,
    266         outbox: {
    267           count: outboxRows.length,
    268           bytes: outboxRows.reduce((sum, row) => sum + row.logicalBytes, 0)
    269         },
    270         outboxRows,
    271         receivedRemoval:
    272           identitySessionSnapshot(identity).state === 'messaging_capable'
    273       };
    274     } catch {
    275       if (current(original)) {
    276         retire();
    277         state = { state: 'unavailable', notice: unavailable };
    278       }
    279     } finally {
    280       if (generation === original) busy = false;
    281       notify();
    282     }
    283   }
    284   reviews.set(token, {
    285     snapshot() {
    286       observe();
    287       return state.state === 'ready'
    288         ? {
    289             ...state,
    290             publicRows: state.publicRows.map((row) => ({ ...row })),
    291             received: state.received.map((row) => ({ ...row })),
    292             outbox: { ...state.outbox },
    293             outboxRows: state.outboxRows.map((row) => ({ ...row })),
    294             preview: state.preview && { ...state.preview }
    295           }
    296         : { ...state };
    297     },
    298     review,
    299     async preview(category, serialized) {
    300       observe();
    301       if (closed || busy || state.state !== 'ready' || !ownership?.current())
    302         return false;
    303       const ids = selection(
    304         serialized,
    305         category === 'public'
    306           ? LOCAL_PERSISTENCE_BUDGETS.publicDrafts +
    307               LOCAL_PERSISTENCE_BUDGETS.publicOperations
    308           : category === 'outbox'
    309             ? LOCAL_PERSISTENCE_BUDGETS.unfinishedPrivateSends
    310             : LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes
    311       );
    312       cancelPreview();
    313       if (!ids) {
    314         notify();
    315         return false;
    316       }
    317       const original = generation;
    318       if (category === 'public' && publicRepository && inventory) {
    319         const captured = reviewPublicCleanup(publicRepository, inventory, ids);
    320         if (!captured.ok) {
    321           notify();
    322           return false;
    323         }
    324         publicCleanup = captured.value;
    325         state = {
    326           ...state,
    327           preview: {
    328             category,
    329             selected: ids.length,
    330             consequences: PUBLIC_CLEANUP_CONSEQUENCES
    331           },
    332           notice: undefined
    333         };
    334         notify();
    335         return true;
    336       }
    337       if (
    338         (category !== 'received' && category !== 'outbox') ||
    339         !privateRepository ||
    340         !state.receivedRemoval ||
    341         !ids.every(
    342           (id) =>
    343             state.state === 'ready' &&
    344             (category === 'received'
    345               ? state.received.some((row) => row.id === id)
    346               : state.outboxRows.some(
    347                   (row) => row.id === id && row.state === 'settled'
    348                 ))
    349         )
    350       ) {
    351         notify();
    352         return false;
    353       }
    354       const identity = identityViewSession(context);
    355       if (!identity) return false;
    356       busy = true;
    357       state = { ...state, busy: true };
    358       notify();
    359       try {
    360         const session = await createPrivateSession(
    361           identity,
    362           'reviewed_private_session'
    363         );
    364         if (!session || !current(original)) return false;
    365         if (category === 'outbox') {
    366           const cleanup = await capturePrivateOutboxCleanup(
    367             privateRepository,
    368             session,
    369             ids,
    370             'reviewed_settled_outbox_selection'
    371           );
    372           if (!current(original)) {
    373             if (cleanup) stopPrivateOutboxCleanup(cleanup);
    374             return false;
    375           }
    376           if (!cleanup || state.state !== 'ready') return false;
    377           outboxCleanup = cleanup;
    378           state = {
    379             ...state,
    380             preview: {
    381               category: 'outbox',
    382               selected: ids.length,
    383               consequences: PRIVATE_OUTBOX_CLEANUP_CONSEQUENCES
    384             },
    385             notice: undefined
    386           };
    387           return true;
    388         }
    389         const cleanup = await captureReceivedCleanup(
    390           privateRepository,
    391           session,
    392           ids,
    393           'reviewed_received_cleanup_selection'
    394         );
    395         if (!current(original)) {
    396           if (cleanup) stopReceivedCleanup(cleanup);
    397           return false;
    398         }
    399         if (!cleanup || state.state !== 'ready') return false;
    400         receivedCleanup = cleanup;
    401         state = {
    402           ...state,
    403           preview: {
    404             category: 'received',
    405             selected: ids.length,
    406             consequences: receivedConsequences
    407           },
    408           notice: undefined
    409         };
    410         return true;
    411       } catch {
    412         return false;
    413       } finally {
    414         if (generation === original) {
    415           busy = false;
    416           if (state.state === 'ready') state = { ...state, busy: false };
    417         }
    418         notify();
    419       }
    420     },
    421     async confirm(consent) {
    422       observe();
    423       if (
    424         closed ||
    425         busy ||
    426         consent !== 'reviewed_local_removal' ||
    427         state.state !== 'ready' ||
    428         !state.preview ||
    429         !ownership?.current() ||
    430         !cancellation
    431       )
    432         return false;
    433       const original = generation,
    434         preview = state.preview,
    435         owner = ownership.owner;
    436       const pub = publicCleanup,
    437         received = receivedCleanup,
    438         outbox = outboxCleanup,
    439         repo = publicRepository,
    440         signal = cancellation.signal;
    441       publicCleanup = undefined;
    442       receivedCleanup = undefined;
    443       outboxCleanup = undefined;
    444       busy = true;
    445       state = { ...state, busy: true, preview: undefined };
    446       notify();
    447       let confirmed = false;
    448       try {
    449         if (
    450           preview.category === 'public' &&
    451           pub &&
    452           repo &&
    453           navigator.locks?.request
    454         ) {
    455           confirmed = await navigator.locks.request(
    456             'harvestcircle:owner:' + owner,
    457             { mode: 'exclusive', ifAvailable: true },
    458             async (lock) => {
    459               if (!lock || !current(original)) return false;
    460               const committed = await commitPublicCleanup(repo, pub, signal);
    461               if (!committed.ok || !current(original)) return false;
    462               const checked = await inspectPublicStorage(repo);
    463               if (!checked.ok || !current(original)) return false;
    464               const remaining = publicInventorySnapshot(repo, checked.value);
    465               if (
    466                 !remaining ||
    467                 committed.value.some((key) =>
    468                   remaining.rows.some((row) => row.key === key)
    469                 )
    470               )
    471                 return false;
    472               inventory = checked.value;
    473               if (state.state === 'ready')
    474                 state = { ...state, publicRows: remaining.rows };
    475               return true;
    476             }
    477           );
    478         } else if (preview.category === 'outbox' && outbox) {
    479           outboxCleanup = outbox;
    480           const result = await deleteReviewedSettledSends(
    481             outbox,
    482             'reviewed_delete_local_settled_sends'
    483           );
    484           if (
    485             result.status === 'removed' &&
    486             current(original) &&
    487             privateRepository
    488           ) {
    489             const scan = await listPrivateSendRecords(privateRepository);
    490             if (scan.ok && current(original) && state.state === 'ready') {
    491               const remaining = outboxInventory(scan.value, owner);
    492               state = {
    493                 ...state,
    494                 outboxRows: remaining,
    495                 outbox: {
    496                   count: remaining.length,
    497                   bytes: remaining.reduce(
    498                     (sum, row) => sum + row.logicalBytes,
    499                     0
    500                   )
    501                 }
    502               };
    503               confirmed = true;
    504             }
    505           }
    506         } else if (preview.category === 'received' && received) {
    507           // Keep the owned action available to synchronous retirement while running.
    508           receivedCleanup = received;
    509           const result = await deleteReviewedReceivedCopies(
    510             received,
    511             'reviewed_delete_local_received_copies'
    512           );
    513           if (
    514             result.status === 'removed' &&
    515             current(original) &&
    516             privateRepository
    517           ) {
    518             const scan = await listPrivateReceivedRecords(privateRepository);
    519             if (scan.ok && current(original) && state.state === 'ready') {
    520               state = {
    521                 ...state,
    522                 received: state.received.filter((row) =>
    523                   scan.value.some(
    524                     (handle) => privateRecordIdentity(handle)?.id === row.id
    525                   )
    526                 )
    527               };
    528               confirmed = true;
    529             }
    530           }
    531         }
    532       } catch {
    533         confirmed = false;
    534       } finally {
    535         if (received) stopReceivedCleanup(received);
    536         if (receivedCleanup === received) receivedCleanup = undefined;
    537         if (outbox) stopPrivateOutboxCleanup(outbox);
    538         if (outboxCleanup === outbox) outboxCleanup = undefined;
    539         if (generation === original) {
    540           busy = false;
    541           if (state.state === 'ready')
    542             state = {
    543               ...state,
    544               busy: false,
    545               notice: confirmed
    546                 ? 'Removed ' +
    547                   preview.selected +
    548                   (preview.category === 'public'
    549                     ? ' selected public record'
    550                     : preview.category === 'outbox'
    551                       ? ' selected settled send record'
    552                       : ' selected received encrypted copy') +
    553                   (preview.selected === 1 ? '.' : ' entries.') +
    554                   ' Other local categories and remote copies are unchanged.'
    555                 : unavailable
    556             };
    557         }
    558         notify();
    559       }
    560       return confirmed;
    561     },
    562     cancel() {
    563       if (busy) return;
    564       cancelPreview();
    565       notify();
    566     },
    567     close() {
    568       if (closed) return;
    569       closed = true;
    570       retire();
    571       offView();
    572       notify();
    573       listeners.clear();
    574     },
    575     subscribe(listener) {
    576       if (closed) return () => {};
    577       const id = Symbol();
    578       listeners.set(id, listener);
    579       return () => {
    580         listeners.delete(id);
    581       };
    582     }
    583   });
    584   return token;
    585 }
    586 export function localDataReviewSnapshot(
    587   token: LocalDataReview
    588 ): LocalDataReviewSnapshot {
    589   return reviews.get(token)?.snapshot() ?? { state: 'closed' };
    590 }
    591 export async function reviewLocalData(
    592   token: LocalDataReview,
    593   consent: unknown
    594 ): Promise<void> {
    595   await reviews.get(token)?.review(consent);
    596 }
    597 export function previewLocalDataRemoval(
    598   token: LocalDataReview,
    599   category: unknown,
    600   selection: unknown
    601 ): Promise<boolean> {
    602   return (
    603     reviews.get(token)?.preview(category, selection) ?? Promise.resolve(false)
    604   );
    605 }
    606 export function confirmLocalDataRemoval(
    607   token: LocalDataReview,
    608   consent: unknown
    609 ): Promise<boolean> {
    610   return reviews.get(token)?.confirm(consent) ?? Promise.resolve(false);
    611 }
    612 export function cancelLocalDataRemoval(token: LocalDataReview): void {
    613   reviews.get(token)?.cancel();
    614 }
    615 export function closeLocalDataReview(token: LocalDataReview): void {
    616   reviews.get(token)?.close();
    617 }
    618 export function subscribeLocalDataReview(
    619   token: LocalDataReview,
    620   listener: () => void
    621 ): () => void {
    622   return reviews.get(token)?.subscribe(listener) ?? (() => {});
    623 }