app

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

product-request-controller.ts (22334B)


      1 import {
      2   productEnquirySnapshot,
      3   productEnquirySendOwnership,
      4   updateProductEnquiry,
      5   closeProductEnquiry,
      6   type ProductEnquiry
      7 } from './product-enquiry.ts';
      8 import {
      9   identityMessagingOwnership,
     10   subscribeIdentityInvalidation,
     11   type IdentitySession
     12 } from '../runtime/identity-session.ts';
     13 import {
     14   inboxSetupViewOwnership,
     15   type InboxSetupView
     16 } from './inbox-setup-view.ts';
     17 import { messagingReadinessSnapshot } from './readiness.ts';
     18 import { operationEnabled } from '../config/operation-flags.ts';
     19 import {
     20   sellerInboxStatus,
     21   sellerInboxCopy,
     22   type SellerInboxStatus
     23 } from './enquiry-readiness.ts';
     24 import {
     25   createInboxRoutePlan,
     26   inboxRoutePlanSnapshot
     27 } from './inbox-routing.ts';
     28 import {
     29   resolveInboxPreference,
     30   settleInboxResolver,
     31   closeInboxResolver,
     32   type InboxResolver
     33 } from './resolve-inbox.ts';
     34 import {
     35   createPublicView,
     36   beginPublicViewRun,
     37   disposePublicView,
     38   type PublicRuntime
     39 } from '../runtime/public-runtime.ts';
     40 import {
     41   openBrowserDatabase,
     42   closeBrowserDatabase,
     43   type BrowserDatabase
     44 } from '../persistence/database.ts';
     45 import { createPrivateStorageRepository } from '../persistence/private-storage.ts';
     46 import { createPrivateSendReservationRepository } from '../persistence/private-send-reservations.ts';
     47 import {
     48   createPrivateComposer,
     49   updatePrivateComposerText,
     50   privateComposerSnapshot,
     51   bindPrivateComposerPreparation,
     52   closePrivateComposer,
     53   type PrivateComposer
     54 } from './composer-state.ts';
     55 import {
     56   captureEnquiryRumor,
     57   stopRumorPlan,
     58   type RumorPlan
     59 } from './rumor-plan.ts';
     60 import { reserveSendIdentity } from './send-identity.ts';
     61 import {
     62   captureSelfRecoveryPreparation,
     63   prepareSelfRecovery,
     64   preparedSelfRecovery,
     65   preparePairedDelivery,
     66   preparedPairedDelivery,
     67   selfRecoveryPreparationSnapshot,
     68   type SelfRecoveryPreparation
     69 } from './prepare-send.ts';
     70 import {
     71   getPrivatePool,
     72   closePrivatePool,
     73   privatePoolCleanupRequired,
     74   type PrivatePool
     75 } from '../nostr/private-pool.ts';
     76 import {
     77   capturePrivateRetry,
     78   runPrivateRetry,
     79   stopPrivateRetry,
     80   type PrivateRetry
     81 } from './retry-send.ts';
     82 import { newLocalId } from '../private-handles.ts';
     83 import {
     84   privateSessionOwnership,
     85   subscribePrivateSessionClose
     86 } from '../runtime/private-session.ts';
     87 
     88 declare const requestBrand: unique symbol;
     89 export type ProductRequestController = Readonly<{ [requestBrand]: true }>;
     90 type Result = Readonly<{
     91   status: 'invalid' | 'busy' | 'stopped' | 'needs_action' | 'completed';
     92 }>;
     93 type NavigationResult =
     94   'invalid' | 'allowed' | 'confirmation_required' | 'review_required';
     95 type State =
     96   | 'idle'
     97   | 'checking'
     98   | 'preparing'
     99   | 'publishing'
    100   | 'needs_action'
    101   | 'completed';
    102 type Snapshot = Readonly<{
    103   state: State;
    104   busy: boolean;
    105   dirty: boolean;
    106   revision: number;
    107   readyToSend: boolean;
    108   sellerInbox: SellerInboxStatus;
    109   copy: string;
    110   saveCopy: string;
    111   pairCopy: string;
    112   navigation: 'idle' | 'confirmation_required';
    113 }>;
    114 type Controller = {
    115   snapshot(): Snapshot | undefined;
    116   text(): string | undefined;
    117   update(text: unknown, review: unknown): boolean;
    118   configure(
    119     identity: IdentitySession,
    120     setup: InboxSetupView,
    121     review: unknown
    122   ): boolean;
    123   send(review: unknown): Promise<Result>;
    124   request(): NavigationResult;
    125   keep(): boolean;
    126   discard(review: unknown): NavigationResult;
    127   unload(event: BeforeUnloadEvent): boolean;
    128   close(): void;
    129   stop(review: unknown): boolean;
    130 };
    131 const controllers = new WeakMap<ProductRequestController, Controller>();
    132 
    133 // Guest allocation and configuration preserve the original enquiry memory.
    134 // Only the reviewed Send command acquires storage, crypto or publication.
    135 export function createProductRequestController(
    136   enquiry: ProductEnquiry,
    137   runtime?: PublicRuntime
    138 ): ProductRequestController | undefined {
    139   if (typeof window === 'undefined' || !productEnquirySnapshot(enquiry)) return;
    140   let active = true,
    141     busy = false,
    142     attempted = false;
    143   let state: State = 'idle',
    144     copy = '',
    145     requestedRevision: number | undefined,
    146     sentRevision: number | undefined;
    147   let identity: IdentitySession | undefined, setup: InboxSetupView | undefined;
    148   let composer: PrivateComposer | undefined,
    149     database: BrowserDatabase | undefined;
    150   let plan: RumorPlan | undefined,
    151     preparation: SelfRecoveryPreparation | undefined,
    152     retry: PrivateRetry | undefined;
    153   let privateOff = () => {};
    154   let identityOff = () => {},
    155     generation = 0;
    156   const source = runtime && createPublicView(runtime);
    157   let resolver: InboxResolver | undefined;
    158   function stopWork(preserveComposer = false) {
    159     generation++;
    160     if (preserveComposer && composer) privateComposerSnapshot(composer);
    161     if (retry) stopPrivateRetry(retry);
    162     if (plan) stopRumorPlan(plan);
    163     releasePool();
    164     if (!preserveComposer) {
    165       if (composer) closePrivateComposer(composer);
    166       composer = undefined;
    167     }
    168   }
    169   let pool: PrivatePool | undefined;
    170   let poolCleanupFailed = false;
    171   function releasePool() {
    172     if (!pool) return true;
    173     try {
    174       poolCleanupFailed = false;
    175       closePrivatePool(pool);
    176       if (privatePoolCleanupRequired(pool)) return false;
    177       pool = undefined;
    178       return true;
    179     } catch {
    180       poolCleanupFailed = true;
    181       return false;
    182     }
    183   }
    184   function close(sessionCleanup = false) {
    185     if (!active && !pool) return;
    186     active = false;
    187     stopWork();
    188     identityOff();
    189     closeProductEnquiry(enquiry);
    190     if (resolver) closeInboxResolver(resolver);
    191     if (source) disposePublicView(source);
    192     if (database) closeBrowserDatabase(database);
    193     if (!releasePool()) {
    194       if (poolCleanupFailed || sessionCleanup)
    195         throw Error('private_delivery_cleanup_required');
    196       return;
    197     }
    198     privateOff();
    199   }
    200   function current() {
    201     if (!active || !productEnquirySnapshot(enquiry)) {
    202       try {
    203         close();
    204       } catch {
    205         /* Exact original disposal stays retryable. */
    206       }
    207       return false;
    208     }
    209     return true;
    210   }
    211   function ownership() {
    212     const actor = identity && identityMessagingOwnership(identity);
    213     const own = inboxSetupViewOwnership(setup);
    214     const product = productEnquirySendOwnership(enquiry);
    215     const data = productEnquirySnapshot(enquiry);
    216     return current() &&
    217       actor?.current() &&
    218       own?.current() &&
    219       own.identity === identity &&
    220       own.session &&
    221       product?.current() &&
    222       data &&
    223       data.peer !== actor.owner
    224       ? { actor, own, product, data }
    225       : undefined;
    226   }
    227   function ready() {
    228     const scope = ownership();
    229     return (
    230       !!scope &&
    231       !!source &&
    232       operationEnabled(scope.own.policy, 'messaging') &&
    233       messagingReadinessSnapshot(
    234         identity!,
    235         scope.own.session,
    236         scope.own.policy,
    237         scope.own.resolver,
    238         undefined,
    239         scope.own.observeAccess
    240       ).newListingReady
    241     );
    242   }
    243   function snapshot(): Snapshot | undefined {
    244     if (!current()) return;
    245     const actual = productEnquirySnapshot(enquiry);
    246     const draft =
    247       actual?.revision === sentRevision &&
    248       composer &&
    249       privateComposerSnapshot(composer);
    250     const workflow =
    251       preparation && selfRecoveryPreparationSnapshot(preparation);
    252     return {
    253       state,
    254       busy,
    255       dirty: draft
    256         ? draft.dirty
    257         : !!productEnquirySnapshot(enquiry)?.text.trim(),
    258       revision: actual?.revision ?? 0,
    259       readyToSend: !attempted && state !== 'needs_action' && ready(),
    260       sellerInbox: sellerInboxStatus(
    261         resolver,
    262         actual!.peer,
    263         inboxSetupViewOwnership(setup)?.policy
    264       ),
    265       copy:
    266         copy ||
    267         (inboxSetupViewOwnership(setup)?.policy &&
    268         !operationEnabled(inboxSetupViewOwnership(setup)?.policy, 'messaging')
    269           ? 'Messaging is disabled in this build. Keep your unsent draft and review existing encrypted work separately.'
    270           : state === 'preparing'
    271             ? 'Preparing encryption. The extension may ask for several approvals.'
    272             : state === 'publishing'
    273               ? 'Publishing encrypted copies to the reviewed inbox relays.'
    274               : ''),
    275       saveCopy: draft
    276         ? draft.copy
    277         : attempted
    278           ? 'Encrypted work needs review in this browser.'
    279           : 'Not yet saved.',
    280       pairCopy: workflow?.pairCopy ?? '',
    281       navigation:
    282         requestedRevision === undefined ? 'idle' : 'confirmation_required'
    283     };
    284   }
    285   async function send(review: unknown): Promise<Result> {
    286     if (review !== 'reviewed_product_request_send')
    287       return { status: 'invalid' };
    288     if (!current()) return { status: 'stopped' };
    289     if (busy) return { status: 'busy' };
    290     if (attempted) return { status: 'needs_action' };
    291     const requestedPolicy = inboxSetupViewOwnership(setup)?.policy;
    292     if (requestedPolicy && !operationEnabled(requestedPolicy, 'messaging')) {
    293       state = 'needs_action';
    294       copy =
    295         'Messaging is disabled in this build. Your unsent text remains in memory; existing encrypted work needs its own recovery review.';
    296       return { status: 'needs_action' };
    297     }
    298     const captured = ownership();
    299     if (
    300       !captured ||
    301       !ready() ||
    302       !identity ||
    303       !source ||
    304       !captured.data.text.trim()
    305     )
    306       return { status: 'invalid' };
    307     const actor = identity,
    308       originalSetup = setup,
    309       originalGeneration = generation;
    310     const privateOwner = privateSessionOwnership(captured.own.session!);
    311     if (
    312       !privateOwner?.current() ||
    313       privateOwner.owner !== captured.actor.owner ||
    314       privateOwner.session !== captured.actor.session
    315     )
    316       return { status: 'invalid' };
    317     const admitted = () =>
    318       current() &&
    319       generation === originalGeneration &&
    320       identity === actor &&
    321       setup === originalSetup &&
    322       captured.actor.current() &&
    323       captured.own.current() &&
    324       captured.product.current() &&
    325       privateOwner.current() &&
    326       productEnquirySnapshot(enquiry)?.revision === captured.data.revision &&
    327       inboxSetupViewOwnership(originalSetup)?.session === captured.own.session;
    328     function needsAction(definitePreEffect = false): Result {
    329       state = attempted || !definitePreEffect ? 'needs_action' : 'idle';
    330       if (!attempted) {
    331         sentRevision = undefined;
    332         if (plan) stopRumorPlan(plan);
    333         plan = undefined;
    334         if (composer) closePrivateComposer(composer);
    335         composer = undefined;
    336         if (database) closeBrowserDatabase(database);
    337         database = undefined;
    338       }
    339       copy = attempted
    340         ? 'Send needs review. Your unsent text stays in memory. Existing encrypted work requires its own recovery review.'
    341         : 'No private send was reserved. Your text stays in memory. Review inbox setup or storage, then explicitly try Send again.';
    342       return { status: 'needs_action' };
    343     }
    344     busy = true;
    345     state = 'checking';
    346     copy =
    347       'Checking the intended publisher inbox. Your text remains in memory.';
    348     try {
    349       if (resolver) closeInboxResolver(resolver);
    350       resolver = resolveInboxPreference(
    351         source,
    352         beginPublicViewRun(source),
    353         captured.data.peer
    354       );
    355       const other = resolver;
    356       // Resolver observations are asynchronous; sample their original bounded
    357       // result through the existing readiness projection, without guessing.
    358       await settleInboxResolver(other, admitted);
    359       if (!admitted()) {
    360         const unavailable = sellerInboxCopy(
    361           sellerInboxStatus(other, captured.data.peer, captured.own.policy)
    362         );
    363         if (
    364           unavailable &&
    365           current() &&
    366           generation === originalGeneration &&
    367           identity === actor &&
    368           setup === originalSetup &&
    369           captured.actor.current() &&
    370           captured.own.current() &&
    371           privateOwner.current() &&
    372           productEnquirySnapshot(enquiry)?.revision === captured.data.revision
    373         ) {
    374           state = 'needs_action';
    375           copy =
    376             (captured.product.current()
    377               ? ''
    378               : 'Listing status changed or could not be confirmed. Review the current listing before sending. ') +
    379             unavailable +
    380             ' Your unsent text stays in memory.';
    381         }
    382         return { status: 'stopped' };
    383       }
    384       if (
    385         !messagingReadinessSnapshot(
    386           actor,
    387           captured.own.session,
    388           captured.own.policy,
    389           captured.own.resolver,
    390           { author: captured.data.peer, resolver: other },
    391           captured.own.observeAccess
    392         ).sendReady
    393       ) {
    394         const result = needsAction();
    395         const unavailable = sellerInboxCopy(
    396           sellerInboxStatus(other, captured.data.peer, captured.own.policy)
    397         );
    398         if (unavailable)
    399           copy =
    400             unavailable +
    401             ' Your unsent text stays in memory. Optional other contact details may be available on the listing.';
    402         return result;
    403       }
    404       const routes = createInboxRoutePlan(
    405         captured.own.policy,
    406         captured.actor.owner,
    407         captured.data.peer,
    408         captured.own.resolver!,
    409         other
    410       );
    411       const routeData = routes && inboxRoutePlanSnapshot(routes);
    412       if (!routes || !routeData || !admitted()) return needsAction();
    413       const opened = await openBrowserDatabase();
    414       if (opened.state !== 'ready') return needsAction(true);
    415       database = opened.owner;
    416       if (!admitted()) return { status: 'stopped' };
    417       const repository = createPrivateStorageRepository(
    418         database,
    419         captured.actor.owner
    420       );
    421       const reservations = createPrivateSendReservationRepository(
    422         database,
    423         captured.actor.owner
    424       );
    425       composer = createPrivateComposer(actor, 'reviewed_private_composer');
    426       sentRevision = captured.data.revision;
    427       if (
    428         !repository ||
    429         !reservations ||
    430         !composer ||
    431         !updatePrivateComposerText(
    432           composer,
    433           captured.data.text,
    434           'reviewed_private_text'
    435         )
    436       )
    437         return needsAction(true);
    438       plan = captureEnquiryRumor(
    439         actor,
    440         captured.product.context,
    441         captured.data.text,
    442         Math.floor(Date.now() / 1000),
    443         admitted
    444       );
    445       const command = newLocalId();
    446       if (!plan || !command || !admitted()) return needsAction(true);
    447       attempted = true;
    448       const reserved = await reserveSendIdentity(
    449         reservations,
    450         actor,
    451         command,
    452         plan,
    453         'reviewed_private_intent'
    454       );
    455       if (!('identity' in reserved)) {
    456         // Stop can revoke this run while its original draft remains mounted.
    457         // A confirmed no-row result releases only that draft's latch; stale
    458         // key/account/body observations cannot restore or retarget another one.
    459         if (
    460           reserved.disposition === 'not_created' &&
    461           current() &&
    462           identity === actor &&
    463           setup === originalSetup &&
    464           captured.actor.current() &&
    465           privateOwner.current() &&
    466           productEnquirySnapshot(enquiry)?.revision === captured.data.revision
    467         ) {
    468           attempted = false;
    469           return needsAction(true);
    470         }
    471         return admitted() ? needsAction() : { status: 'stopped' };
    472       }
    473       if (!admitted()) return { status: 'stopped' };
    474       preparation = captureSelfRecoveryPreparation(
    475         repository,
    476         actor,
    477         reserved.identity,
    478         'reviewed_self_recovery'
    479       );
    480       if (
    481         !preparation ||
    482         !bindPrivateComposerPreparation(
    483           composer,
    484           reserved.identity,
    485           preparation,
    486           captured.product.context,
    487           'reviewed_composer_preparation'
    488         )
    489       )
    490         return needsAction();
    491       state = 'preparing';
    492       copy = '';
    493       const self = await prepareSelfRecovery(
    494         preparation,
    495         'reviewed_self_recovery'
    496       );
    497       if (!admitted()) return { status: 'stopped' };
    498       if (
    499         !['saved', 'existing', 'reconciled'].includes(self.status) ||
    500         !preparedSelfRecovery(preparation)
    501       )
    502         return needsAction();
    503       const context = {
    504         plan: routes,
    505         policy: captured.own.policy,
    506         own: captured.own.resolver!,
    507         other
    508       };
    509       const paired = await preparePairedDelivery(
    510         preparation,
    511         context,
    512         'reviewed_pair_preparation'
    513       );
    514       if (!admitted()) return { status: 'stopped' };
    515       const receipt = preparedPairedDelivery(preparation);
    516       if (
    517         !['prepared', 'existing', 'reconciled'].includes(paired.status) ||
    518         !receipt
    519       )
    520         return needsAction();
    521       if (!releasePool()) return needsAction();
    522       pool = getPrivatePool(
    523         captured.own.session!,
    524         captured.own.policy,
    525         Array.from(
    526           new Set([...routeData.peer.targets, ...routeData.archive.targets])
    527         ),
    528         token,
    529         'delivery',
    530         admitted
    531       );
    532       if (!pool || !admitted()) return needsAction();
    533       privateOff();
    534       privateOff = subscribePrivateSessionClose(captured.own.session!, () =>
    535         close(true)
    536       );
    537       retry = capturePrivateRetry(
    538         repository,
    539         captured.own.session!,
    540         receipt,
    541         context,
    542         pool,
    543         'reviewed_private_retry'
    544       );
    545       if (!retry || !admitted()) return needsAction();
    546       state = 'publishing';
    547       const delivered = await runPrivateRetry(retry, 'reviewed_private_retry');
    548       if (!admitted()) return { status: 'stopped' };
    549       if (delivered.status !== 'completed') return needsAction();
    550       state = 'completed';
    551       copy =
    552         'Accepted by recipient inbox relay. This does not confirm that the person read the message.';
    553       return { status: 'completed' };
    554     } catch {
    555       return admitted() ? needsAction() : { status: 'stopped' };
    556     } finally {
    557       busy = false;
    558       releasePool();
    559     }
    560   }
    561   const token = Object.freeze({}) as ProductRequestController;
    562   controllers.set(token, {
    563     snapshot,
    564     text: () => (current() ? productEnquirySnapshot(enquiry)?.text : undefined),
    565     update(text, review) {
    566       if (
    567         review !== 'reviewed_private_text' ||
    568         !current() ||
    569         busy ||
    570         attempted ||
    571         !updateProductEnquiry(enquiry, text, 'reviewed_product_enquiry_edit')
    572       )
    573         return false;
    574       return true;
    575     },
    576     configure(nextIdentity, nextSetup, review) {
    577       if (
    578         review !== 'reviewed_product_request_setup' ||
    579         !current() ||
    580         attempted ||
    581         busy
    582       )
    583         return false;
    584       const actor = identityMessagingOwnership(nextIdentity),
    585         own = inboxSetupViewOwnership(nextSetup);
    586       if (!actor?.current() || !own?.current() || own.identity !== nextIdentity)
    587         return false;
    588       if (identity === nextIdentity && setup === nextSetup) return true;
    589       stopWork();
    590       identityOff();
    591       identity = nextIdentity;
    592       setup = nextSetup;
    593       identityOff = subscribeIdentityInvalidation(nextIdentity, () => {
    594         if (!actor.current()) {
    595           stopWork();
    596           copy = 'Connection changed. Your unsent text stays in memory.';
    597         }
    598       });
    599       return true;
    600     },
    601     send,
    602     stop(review) {
    603       if (review !== 'reviewed_product_request_cancel' || !current())
    604         return false;
    605       stopWork(true);
    606       if (state !== 'completed') {
    607         state = attempted ? 'needs_action' : 'idle';
    608         copy =
    609           'Sending is paused. Your unsent text stays in this page; existing encrypted work requires its own recovery review.';
    610       }
    611       return true;
    612     },
    613     request() {
    614       if (!current()) return 'invalid';
    615       if (!snapshot()?.dirty) return 'allowed';
    616       requestedRevision = productEnquirySnapshot(enquiry)?.revision;
    617       return 'confirmation_required';
    618     },
    619     keep() {
    620       if (!current()) return false;
    621       requestedRevision = undefined;
    622       return true;
    623     },
    624     discard(review) {
    625       if (
    626         !current() ||
    627         review !== 'reviewed_discard_private_text' ||
    628         requestedRevision === undefined
    629       )
    630         return 'invalid';
    631       const expected = requestedRevision;
    632       requestedRevision = undefined;
    633       if (expected !== productEnquirySnapshot(enquiry)?.revision)
    634         return 'review_required';
    635       close();
    636       return 'allowed';
    637     },
    638     unload(event) {
    639       if (!current() || !snapshot()?.dirty) return false;
    640       event.preventDefault();
    641       return true;
    642     },
    643     close
    644   });
    645   return token;
    646 }
    647 export function productRequestSnapshot(token: ProductRequestController) {
    648   return controllers.get(token)?.snapshot();
    649 }
    650 export function productRequestText(token: ProductRequestController) {
    651   return controllers.get(token)?.text();
    652 }
    653 export function updateProductRequestText(
    654   token: ProductRequestController,
    655   text: unknown,
    656   review: unknown
    657 ) {
    658   return controllers.get(token)?.update(text, review) ?? false;
    659 }
    660 export function configureProductRequest(
    661   token: ProductRequestController,
    662   identity: IdentitySession,
    663   setup: InboxSetupView,
    664   review: unknown
    665 ) {
    666   return controllers.get(token)?.configure(identity, setup, review) ?? false;
    667 }
    668 export function sendProductRequest(
    669   token: ProductRequestController,
    670   review: unknown
    671 ): Promise<Result> {
    672   return (
    673     controllers.get(token)?.send(review) ??
    674     Promise.resolve({ status: 'invalid' })
    675   );
    676 }
    677 export function requestProductRequestNavigation(
    678   token: ProductRequestController
    679 ): NavigationResult {
    680   return controllers.get(token)?.request() ?? 'invalid';
    681 }
    682 export function keepProductRequestEditing(token: ProductRequestController) {
    683   return controllers.get(token)?.keep() ?? false;
    684 }
    685 export function discardProductRequestNavigation(
    686   token: ProductRequestController,
    687   review: unknown
    688 ): NavigationResult {
    689   return controllers.get(token)?.discard(review) ?? 'invalid';
    690 }
    691 export function productRequestBeforeUnload(
    692   token: ProductRequestController,
    693   event: BeforeUnloadEvent
    694 ) {
    695   return controllers.get(token)?.unload(event) ?? false;
    696 }
    697 export function closeProductRequestController(token: ProductRequestController) {
    698   controllers.get(token)?.close();
    699 }
    700 export function stopProductRequestWork(
    701   token: ProductRequestController,
    702   review: unknown
    703 ) {
    704   return controllers.get(token)?.stop(review) ?? false;
    705 }