app

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

history-pagination.ts (12380B)


      1 import {
      2   inboxSyncHistoryOwnership,
      3   type InboxSync,
      4   type InboxHistoryOwnership
      5 } from './inbox-sync.ts';
      6 import {
      7   initialOuterCursor,
      8   advanceOuterPage,
      9   type OuterCursor
     10 } from './inbox-state.ts';
     11 import {
     12   readRetainedOuterMetadata,
     13   type RetainedOuterMetadata
     14 } from '../persistence/history-metadata-repository.ts';
     15 import { LOCAL_PERSISTENCE_BUDGETS } from '../config/budgets.ts';
     16 import {
     17   createPrivateHistoryRun,
     18   subscribePrivateSourcePage,
     19   type PrivatePageMessage
     20 } from '../nostr/private-pool.ts';
     21 import {
     22   admitInboxEnvelope,
     23   inboxEnvelopeOuterMetadata,
     24   retainInboxEnvelope
     25 } from '../persistence/inbox-envelope-repository.ts';
     26 import {
     27   subscribePrivateSessionClose,
     28   privateSessionOwnership
     29 } from '../runtime/private-session.ts';
     30 declare const olderBrand: unique symbol;
     31 export type OlderInbox = Readonly<{ [olderBrand]: true }>;
     32 type View = Readonly<{
     33   ownerGenerationScoped: true;
     34   state: string;
     35   reason: string | null;
     36   historyComplete: false;
     37   cleanupRequired: boolean;
     38   sources: readonly OuterCursor[];
     39 }>;
     40 type Controller = {
     41   start(review: unknown): Promise<boolean>;
     42   stop(): void;
     43   snapshot(): View;
     44 };
     45 const controllers = new WeakMap<OlderInbox, Controller>(),
     46   syncs = new WeakMap<InboxSync, OlderInbox>();
     47 export function captureOlderInbox(
     48   sync: InboxSync,
     49   review: unknown
     50 ): OlderInbox | undefined {
     51   if (review !== 'reviewed_load_older' || syncs.has(sync)) return undefined;
     52   const ownership = inboxSyncHistoryOwnership(sync);
     53   if (!ownership?.current()) return undefined;
     54   const original: InboxHistoryOwnership = ownership;
     55   const token = Object.freeze({}) as OlderInbox;
     56   const cancellation = new AbortController();
     57   let stopped = false,
     58     busy = false,
     59     cleanupRequired = false,
     60     state = 'ready',
     61     reason: string | null = null;
     62   let cursors = Array.from<OuterCursor>([]),
     63     release = () => {},
     64     off = () => {};
     65   // Genuine excluded deliveries still have signed outer cursor facts. They
     66   // are bounded observed-page memory, never retained rows or exclusion proof.
     67   const excludedOuter = new Map<string, RetainedOuterMetadata>();
     68   let retainedOuter: readonly RetainedOuterMetadata[] =
     69     Array.from<RetainedOuterMetadata>([]);
     70   function mergedOuter(
     71     retained: readonly RetainedOuterMetadata[],
     72     extra?: RetainedOuterMetadata
     73   ): RetainedOuterMetadata[] | undefined {
     74     const rows = new Map<string, RetainedOuterMetadata>(),
     75       ids = new Map<string, true>();
     76     for (const row of [
     77       ...retained,
     78       ...excludedOuter.values(),
     79       ...(extra ? [extra] : [])
     80     ]) {
     81       ids.set(row.outerId, true);
     82       if (ids.size > LOCAL_PERSISTENCE_BUDGETS.receivedEnvelopes)
     83         return undefined;
     84       const key = JSON.stringify([row.source, row.outerId]),
     85         previous = rows.get(key);
     86       if (previous && previous.outerTime !== row.outerTime) return undefined;
     87       if (!previous) rows.set(key, row);
     88     }
     89     return Array.from(rows.values());
     90   }
     91   const current = () => {
     92     const valid = !stopped && original.current();
     93     if (!valid) {
     94       // These are only transient cursor facts. Observed generation loss must
     95       // discard them even when the next explicit action is refused at entry.
     96       excludedOuter.clear();
     97       retainedOuter = [];
     98       cursors = [];
     99     }
    100     return valid;
    101   };
    102   function stop() {
    103     stopped = true;
    104     cancellation.abort();
    105     state = 'stopped';
    106     let failure = false;
    107     try {
    108       off();
    109     } catch {
    110       failure = true;
    111     }
    112     try {
    113       release();
    114     } catch {
    115       failure = true;
    116     }
    117     cursors = [];
    118     excludedOuter.clear();
    119     retainedOuter = [];
    120     cleanupRequired = failure;
    121     if (!failure && syncs.get(sync) === token) syncs.delete(sync);
    122     if (failure) throw Error('private_history_cleanup_required');
    123   }
    124   async function page(
    125     source: string,
    126     until: number | undefined,
    127     run: ReturnType<typeof createPrivateHistoryRun>
    128   ): Promise<{ reason: string; deliveries: number; ids: readonly string[] }> {
    129     return await new Promise((resolve) => {
    130       let queue = Promise.resolve(),
    131         finished = false,
    132         failure: string | undefined;
    133       const ids = new Map<string, true>();
    134       const pageRetained = new Map<string, RetainedOuterMetadata>();
    135       let acceptedDeliveries = 0;
    136       function receive(message: PrivatePageMessage) {
    137         if (finished) return;
    138         if (message.type === 'end') {
    139           finished = true;
    140           void queue.then(() =>
    141             resolve({
    142               reason:
    143                 failure ??
    144                 (message.reason === 'complete' &&
    145                 acceptedDeliveries < (message.deliveries ?? acceptedDeliveries)
    146                   ? 'unsupported'
    147                   : message.reason),
    148               deliveries: message.deliveries ?? ids.size,
    149               ids: Array.from(ids.keys())
    150             })
    151           );
    152           return;
    153         }
    154         if (!current()) {
    155           stop();
    156           return;
    157         }
    158         const origin = message.from.endsWith('/')
    159           ? message.from.slice(0, -1)
    160           : message.from;
    161         // Obtain original admitted owner's namespace from the genuine sync session,
    162         // never the random outer author. The actual repository enforces it too.
    163         queue = queue
    164           .then(async () => {
    165             if (!current()) return;
    166             if (failure === 'capacity') return;
    167             const owner = privateOwner();
    168             const admitted =
    169               owner &&
    170               admitInboxEnvelope(message.wire, owner, origin, Date.now());
    171             if (!admitted || origin !== source) {
    172               failure = 'unsupported';
    173               return;
    174             }
    175             const retained = await retainInboxEnvelope(
    176               original.repository,
    177               original.session,
    178               admitted,
    179               cancellation.signal
    180             );
    181             if (!current()) return;
    182             if (retained.status === 'probe_excluded') {
    183               const signed = inboxEnvelopeOuterMetadata(admitted);
    184               if (!signed) {
    185                 failure = 'unsupported';
    186                 return;
    187               }
    188               const fact = {
    189                 source,
    190                 outerId: signed.id,
    191                 outerTime: signed.createdAt
    192               };
    193               if (
    194                 !mergedOuter([...retainedOuter, ...pageRetained.values()], fact)
    195               ) {
    196                 failure = 'capacity';
    197                 return;
    198               }
    199               const key = JSON.stringify([source, signed.id]);
    200               if (!excludedOuter.has(key)) excludedOuter.set(key, fact);
    201               acceptedDeliveries++;
    202               ids.set(signed.id, true);
    203               return;
    204             }
    205             if (
    206               retained.status !== 'retained' &&
    207               retained.status !== 'duplicate'
    208             ) {
    209               failure = retained.status;
    210               return;
    211             }
    212             const signed = inboxEnvelopeOuterMetadata(admitted);
    213             if (!signed) {
    214               failure = 'unsupported';
    215               return;
    216             }
    217             const fact = {
    218               source,
    219               outerId: signed.id,
    220               outerTime: signed.createdAt
    221             };
    222             if (
    223               !mergedOuter([...retainedOuter, ...pageRetained.values()], fact)
    224             ) {
    225               failure = 'capacity';
    226               return;
    227             }
    228             pageRetained.set(signed.id, fact);
    229             acceptedDeliveries++;
    230             ids.set(signed.id, true);
    231           })
    232           .catch(() => {
    233             failure = 'unknown_completion';
    234           });
    235       }
    236       try {
    237         release = subscribePrivateSourcePage(
    238           original.pool,
    239           run,
    240           source,
    241           until,
    242           receive
    243         );
    244       } catch {
    245         resolve({ reason: 'error', deliveries: 0, ids: [] });
    246       }
    247     });
    248   }
    249   function privateOwner() {
    250     return privateSessionOwnership(original.session)?.owner;
    251   }
    252   controllers.set(token, {
    253     snapshot: () => {
    254       current();
    255       return {
    256         ownerGenerationScoped: true,
    257         state,
    258         reason,
    259         historyComplete: false,
    260         cleanupRequired,
    261         sources: cursors.map((cursor) => ({
    262           ...cursor,
    263           seen: cursor.seen.slice()
    264         }))
    265       };
    266     },
    267     stop,
    268     async start(reviewed) {
    269       if (
    270         reviewed !== 'reviewed_load_older' ||
    271         busy ||
    272         !current() ||
    273         cleanupRequired
    274       )
    275         return false;
    276       busy = true;
    277       state = 'loading';
    278       reason = null;
    279       try {
    280         const initial = await readRetainedOuterMetadata(
    281           original.repository,
    282           original.session
    283         );
    284         if (!current()) {
    285           stop();
    286           return false;
    287         }
    288         if (!initial.ok) {
    289           state = 'needs_action';
    290           reason = initial.reason;
    291           return false;
    292         }
    293         const observed = mergedOuter(initial.rows);
    294         if (!observed) {
    295           state = 'needs_action';
    296           reason = 'capacity';
    297           return false;
    298         }
    299         retainedOuter = initial.rows;
    300         cursors = original.targets.map((source) => {
    301           const fresh = initialOuterCursor(
    302             source,
    303             observed.filter((row) => row.source === source)
    304           );
    305           const previous = cursors.find((cursor) => cursor.source === source);
    306           return previous && previous.until === fresh.until
    307             ? { ...fresh, state: previous.state, partial: previous.partial }
    308             : fresh;
    309         });
    310         const run = createPrivateHistoryRun(original.pool);
    311         let next = Array.from<OuterCursor>([]);
    312         for (const cursor of cursors) {
    313           if (!current()) {
    314             stop();
    315             break;
    316           }
    317           if (cursor.state === 'saturated') {
    318             next = next.concat(cursor);
    319             continue;
    320           }
    321           const result = await page(cursor.source, cursor.until, run);
    322           if (!current()) {
    323             stop();
    324             break;
    325           }
    326           const stored = await readRetainedOuterMetadata(
    327             original.repository,
    328             original.session
    329           );
    330           if (!current()) {
    331             stop();
    332             break;
    333           }
    334           if (!stored.ok) {
    335             state = 'needs_action';
    336             reason = stored.reason;
    337             next = next.concat(cursor);
    338             break;
    339           }
    340           const observed = mergedOuter(stored.rows);
    341           if (!observed) {
    342             state = 'needs_action';
    343             reason = 'capacity';
    344             next = next.concat(cursor);
    345             break;
    346           }
    347           retainedOuter = stored.rows;
    348           const rows = observed.filter(
    349             (row) =>
    350               row.source === cursor.source && result.ids.includes(row.outerId)
    351           );
    352           next = next.concat(
    353             advanceOuterPage(cursor, rows, result.deliveries, result.reason)
    354           );
    355           if (
    356             result.reason === 'budget' ||
    357             result.reason === 'elapsed' ||
    358             result.reason === 'capacity'
    359           ) {
    360             state = 'needs_action';
    361             reason = result.reason;
    362             break;
    363           }
    364         }
    365         if (!stopped) {
    366           cursors = next.concat(
    367             cursors.filter(
    368               (cursor) => !next.some((row) => row.source === cursor.source)
    369             )
    370           );
    371           if (state !== 'needs_action')
    372             state = cursors.some((cursor) => cursor.partial)
    373               ? 'partial'
    374               : 'older_available';
    375         }
    376         return current();
    377       } catch {
    378         if (!stopped) {
    379           state = 'needs_action';
    380           reason = 'unknown_completion';
    381         }
    382         return false;
    383       } finally {
    384         busy = false;
    385       }
    386     }
    387   });
    388   off = subscribePrivateSessionClose(original.session, stop);
    389   syncs.set(sync, token);
    390   return token;
    391 }
    392 export function loadOlderInbox(
    393   token: OlderInbox,
    394   review: unknown
    395 ): Promise<boolean> {
    396   return controllers.get(token)?.start(review) ?? Promise.resolve(false);
    397 }
    398 export function stopOlderInbox(token: OlderInbox): void {
    399   controllers.get(token)?.stop();
    400 }
    401 export function olderInboxSnapshot(token: OlderInbox): View | undefined {
    402   return controllers.get(token)?.snapshot();
    403 }