app

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

inbox-preference-publisher.ts (3704B)


      1 import { PUBLIC_PUBLICATION_BUDGETS } from '../config/budgets.ts';
      2 import type { RelayPolicy } from '../config/relays.ts';
      3 import {
      4   publishPublicPreferenceAttempt,
      5   type PublicPool
      6 } from './public-pool.ts';
      7 import type { PreferencePublication } from './inbox-preference-publication.ts';
      8 import { canonicalLocalId } from '../private-handles.ts';
      9 import {
     10   loadPreferenceOperation,
     11   commitPublicOperationTransition,
     12   type PublicQuotaRepository
     13 } from '../persistence/quota.ts';
     14 import { preparePublicReceiptTransition } from '../persistence/artifact-records.ts';
     15 import { publicRecordSnapshot } from '../persistence/records.ts';
     16 export type PreferencePublicationResult = Readonly<{
     17   status:
     18     'completed' | 'stopped' | 'storage_failed' | 'invalid' | 'needs_action';
     19 }>;
     20 // One explicitly resumed finite action. Caller owns the real current identity,
     21 // known-base lookup and opaque authorization, never arbitrary event templates.
     22 export async function publishInboxPreference(
     23   repository: PublicQuotaRepository,
     24   owner: string,
     25   id: string,
     26   actionId: string,
     27   pool: PublicPool,
     28   policy: RelayPolicy,
     29   signal: AbortSignal,
     30   authorize: () => Promise<PreferencePublication | undefined>
     31 ): Promise<PreferencePublicationResult> {
     32   if (!canonicalLocalId(actionId)) return { status: 'invalid' };
     33   const started = performance.now();
     34   const initial = await loadPreferenceOperation(repository, id);
     35   if (!initial.ok) return { status: 'storage_failed' };
     36   const row = publicRecordSnapshot(initial.value, owner, id);
     37   if (
     38     row?.family !== 'preference_operation' ||
     39     !row.artifact ||
     40     row.revision < 2
     41   )
     42     return { status: 'invalid' };
     43   for (const origin of row.capture.targets) {
     44     if (
     45       row.receipts.some(
     46         (fact) =>
     47           fact.origin === origin &&
     48           fact.eventId === row.artifact!.eventId &&
     49           fact.status === 'accepted'
     50       )
     51     )
     52       continue;
     53     for (
     54       let attempt = 1;
     55       attempt <= PUBLIC_PUBLICATION_BUDGETS.attemptsPerTargetAction;
     56       attempt++
     57     ) {
     58       if (
     59         signal.aborted ||
     60         performance.now() - started >=
     61           PUBLIC_PUBLICATION_BUDGETS.networkActionMilliseconds
     62       )
     63         return { status: 'stopped' };
     64       const permission = await authorize();
     65       const remaining =
     66         PUBLIC_PUBLICATION_BUDGETS.networkActionMilliseconds -
     67         (performance.now() - started);
     68       if (!permission || signal.aborted || remaining <= 0)
     69         return { status: 'stopped' };
     70       const result = await publishPublicPreferenceAttempt(
     71         pool,
     72         permission,
     73         policy,
     74         origin,
     75         signal,
     76         remaining
     77       );
     78       const read = await loadPreferenceOperation(repository, id);
     79       if (!read.ok) return { status: 'storage_failed' };
     80       const transition = preparePublicReceiptTransition(
     81         read.value,
     82         owner,
     83         id,
     84         JSON.stringify({
     85           actionId,
     86           origin,
     87           role: 'preference',
     88           attempt,
     89           eventId: row.artifact.eventId,
     90           status: result.status,
     91           observedAtMilliseconds: Date.now(),
     92           readbackWire: null
     93         })
     94       );
     95       if (
     96         !transition.ok ||
     97         !(await commitPublicOperationTransition(repository, transition.value))
     98           .ok
     99       )
    100         return { status: 'storage_failed' };
    101       if (result.status === 'accepted') break;
    102       if (result.status !== 'timed_out')
    103         return {
    104           status: result.status === 'stopped' ? 'stopped' : 'needs_action'
    105         };
    106       if (attempt === PUBLIC_PUBLICATION_BUDGETS.attemptsPerTargetAction)
    107         return { status: 'needs_action' };
    108     }
    109   }
    110   return { status: 'completed' };
    111 }