app

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

inbox-sync.ts (6902B)


      1 import {
      2   captureUnlockedSession,
      3   closeUnlockedSession
      4 } from '../../../src/lib/messaging/unlocked-session.ts';
      5 import { identitySessionSnapshot } from '../../../src/lib/runtime/identity-session.ts';
      6 import {
      7   browserExtensionScheduler,
      8   extensionSchedulerSnapshot
      9 } from '../../../src/lib/nostr/extension-scheduler.ts';
     10 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts';
     11 import {
     12   validateRelayPolicy,
     13   readRelayPolicy
     14 } from '../../../src/lib/config/relays.ts';
     15 import {
     16   createPrivateSession,
     17   closePrivateSession,
     18   privateSessionOwnership
     19 } from '../../../src/lib/runtime/private-session.ts';
     20 import {
     21   captureInboxSync,
     22   startInboxSync,
     23   stopInboxSync,
     24   inboxSyncSnapshot,
     25   type InboxSync
     26 } from '../../../src/lib/messaging/inbox-sync.ts';
     27 import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts';
     28 import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts';
     29 import {
     30   getPublicStore,
     31   publicStoreEnvelope
     32 } from '../../../src/lib/nostr/public-store.ts';
     33 export async function makeFixture() {
     34   const f = await makeRecoveryFixture();
     35   const policy = validateRelayPolicy(
     36     JSON.stringify({
     37       ...readRelayPolicy(f.context.policy),
     38       messagingEnabled: true
     39     })
     40   );
     41   if (!policy) throw Error('fixture policy unavailable');
     42   const session = await createPrivateSession(
     43     f.identity,
     44     'reviewed_private_session'
     45   );
     46   if (!session) throw Error('missing genuine session');
     47   const capturedSession = session;
     48   const capture = privateSessionOwnership(session)!;
     49   const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock');
     50   if (!unlocked) throw Error('missing genuine unlock');
     51   const publicStore = getPublicStore()!;
     52   const self = (await f.row())!.record.self;
     53   let ingress: InboxSync | undefined;
     54   async function retireOriginalSync() {
     55     for (;;) {
     56       let incomplete = false;
     57       try {
     58         if (ingress) stopInboxSync(ingress);
     59       } catch (error) {
     60         if (
     61           !(error instanceof Error) ||
     62           error.message !== 'private_inbox_cleanup_required'
     63         )
     64           throw error;
     65         incomplete = true;
     66       }
     67       const sessionClean = closePrivateSession(capturedSession);
     68       if (!incomplete && sessionClean) {
     69         if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired)
     70           throw Error('actual original sync cleanup remains incomplete');
     71         return;
     72       }
     73       // Retry exact original disposal after its actual SDK close observers;
     74       // this wait starts no retrieval, permission or replacement session.
     75       await new Promise<void>((resolve) => setTimeout(resolve, 0));
     76     }
     77   }
     78 
     79   let authorized = true;
     80   let restoreFault = () => {};
     81   let releaseKey: (() => void) | undefined;
     82   let restoreKey = () => {};
     83   return {
     84     ...f,
     85     outer: self.wire,
     86     outerId: self.eventId,
     87     capture(access = true, review: unknown = 'reviewed_foreground_inbox') {
     88       const candidate = captureInboxSync(
     89         f.repository,
     90         session,
     91         policy,
     92         f.context.own,
     93         unlocked,
     94         access
     95           ? (context) => ({
     96               ...context,
     97               receive: 'qualified_exercised',
     98               archive: 'qualified_exercised',
     99               current: () => authorized && capture.current()
    100             })
    101           : undefined,
    102         review
    103       );
    104       if (candidate) ingress = candidate;
    105       return !!candidate;
    106     },
    107     start(review: unknown = 'reviewed_foreground_inbox') {
    108       if (!ingress) return false;
    109       return startInboxSync(ingress, review);
    110     },
    111     stop: retireOriginalSync,
    112     snapshot: () => ingress && inboxSyncSnapshot(ingress),
    113     async stored(id = self.eventId) {
    114       const row = await loadPrivateRecord(
    115         f.repository,
    116         'received_envelopes',
    117         id
    118       );
    119       return row.ok ? privateRecordSnapshot(row.value, f.owner, id) : undefined;
    120     },
    121     publicContains: (id = self.eventId) =>
    122       !!publicStoreEnvelope(publicStore, id),
    123     countsValue: () => f.counts(),
    124     closeUnlock() {
    125       closeUnlockedSession(unlocked);
    126     },
    127     navigateAway: retireOriginalSync,
    128     changeKey() {
    129       f.mode('changed_key');
    130     },
    131     holdNextKey() {
    132       const provider = window.nostr as
    133         { getPublicKey: () => Promise<string> } | undefined;
    134       if (!provider) throw Error('missing genuine fixture provider');
    135       const original = provider.getPublicKey;
    136       provider.getPublicKey = async () => {
    137         const owner = await original.call(provider);
    138         return await new Promise<string>((resolve) => {
    139           releaseKey = () => resolve(owner);
    140         });
    141       };
    142       restoreKey = () => {
    143         provider.getPublicKey = original;
    144       };
    145     },
    146     pendingKey: () => !!releaseKey,
    147     keyJobOccupied() {
    148       const scheduler = browserExtensionScheduler();
    149       const slot = scheduler && extensionSchedulerSnapshot(scheduler);
    150       return slot?.state === 'active' && slot.pending === 'key';
    151     },
    152     identityState: () => identitySessionSnapshot(f.identity).state,
    153     settleKey() {
    154       const release = releaseKey;
    155       releaseKey = undefined;
    156       restoreKey();
    157       release?.();
    158     },
    159     revokeAccess() {
    160       authorized = false;
    161     },
    162     logout() {
    163       closePrivateSession(session);
    164     },
    165     logoutIdentity() {
    166       f.disconnect();
    167       closePrivateSession(session);
    168     },
    169     restoreFault() {
    170       restoreFault();
    171     },
    172     faultRetention(kind: 'abort' | 'readback') {
    173       const put = Reflect.get<IDBObjectStore, 'put'>(
    174         IDBObjectStore.prototype,
    175         'put'
    176       );
    177       const cursor = Reflect.get<IDBIndex, 'openCursor'>(
    178         IDBIndex.prototype,
    179         'openCursor'
    180       );
    181       let written = false;
    182       IDBObjectStore.prototype.put = function (
    183         ...args: Parameters<IDBObjectStore['put']>
    184       ) {
    185         const request = put.apply(this, args);
    186         if (this.name === 'received_envelopes') {
    187           written = true;
    188           if (kind === 'abort') this.transaction.abort();
    189         }
    190         return request;
    191       };
    192       IDBIndex.prototype.openCursor = function (
    193         ...args: Parameters<IDBIndex['openCursor']>
    194       ) {
    195         if (
    196           kind === 'readback' &&
    197           written &&
    198           this.objectStore.name === 'received_envelopes' &&
    199           this.objectStore.transaction.mode === 'readonly'
    200         )
    201           throw Error('actual post-put inbox readback failure');
    202         return cursor.apply(this, args);
    203       };
    204       restoreFault = () => {
    205         IDBObjectStore.prototype.put = put;
    206         IDBIndex.prototype.openCursor = cursor;
    207       };
    208     },
    209     async close() {
    210       const release = releaseKey;
    211       releaseKey = undefined;
    212       restoreKey();
    213       release?.();
    214       restoreFault();
    215       await retireOriginalSync();
    216       closePrivateSession(session);
    217       f.close();
    218     }
    219   };
    220 }