app

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

product-request.ts (15324B)


      1 import { mount, unmount, tick } from 'svelte';
      2 import type { beforeNavigate as KitBeforeNavigate } from '$app/navigation';
      3 import {
      4   getPublicKey,
      5   finalizeEvent,
      6   type UnsignedEvent
      7 } from 'applesauce-core/helpers';
      8 import { nip44 } from 'applesauce-core/helpers/encryption';
      9 import Panel from './product-request-panel.svelte';
     10 import { validateRelayPolicy } from '../../../src/lib/config/relays.ts';
     11 import {
     12   createPublicRuntimeContext,
     13   mountPublicRuntime,
     14   createPublicView,
     15   beginPublicViewRun,
     16   disposePublicView,
     17   closePublicRuntime
     18 } from '../../../src/lib/runtime/public-runtime.ts';
     19 import {
     20   createIdentityViewContext,
     21   mountIdentityView,
     22   identityViewSnapshot,
     23   identityViewSession,
     24   disconnectIdentityView,
     25   closeIdentityView
     26 } from '../../../src/lib/runtime/view-context.ts';
     27 import {
     28   identityMessagingOwnership,
     29   type IdentitySession
     30 } from '../../../src/lib/runtime/identity-session.ts';
     31 import {
     32   createProductView,
     33   productViewSnapshot,
     34   closeProductView,
     35   acknowledgeProductViewUncertainty,
     36   productViewListingOwnership,
     37   type ProductView,
     38   type ProductStatusAcknowledgement,
     39   type ProductViewSnapshot
     40 } from '../../../src/lib/catalog/product-view.ts';
     41 import { encodeProductReference } from '../../../src/lib/nostr/references.ts';
     42 import {
     43   productEnquirySnapshot,
     44   productEnquiryMessage,
     45   captureProductEnquiry,
     46   updateProductEnquiry,
     47   type ProductEnquiry
     48 } from '../../../src/lib/messaging/product-enquiry.ts';
     49 import {
     50   createProductRequestController,
     51   productRequestSnapshot,
     52   productRequestText,
     53   updateProductRequestText,
     54   configureProductRequest,
     55   sendProductRequest,
     56   requestProductRequestNavigation,
     57   keepProductRequestEditing,
     58   discardProductRequestNavigation,
     59   closeProductRequestController,
     60   type ProductRequestController
     61 } from '../../../src/lib/messaging/product-request-controller.ts';
     62 import {
     63   createInboxSetupView,
     64   inboxSetupViewSnapshot,
     65   type InboxSetupView
     66 } from '../../../src/lib/messaging/inbox-setup-view.ts';
     67 import {
     68   resolveInboxPreference,
     69   settleInboxResolver
     70 } from '../../../src/lib/messaging/resolve-inbox.ts';
     71 import { resolveInboxReadback } from '../../../src/lib/nostr/inbox-readback.ts';
     72 import {
     73   openBrowserDatabase,
     74   closeBrowserDatabase,
     75   browserDatabaseTransaction
     76 } from '../../../src/lib/persistence/database.ts';
     77 import {
     78   browserExtensionScheduler,
     79   extensionSchedulerSnapshot
     80 } from '../../../src/lib/nostr/extension-scheduler.ts';
     81 
     82 type BeforeNavigate = Parameters<Parameters<typeof KitBeforeNavigate>[0]>[0];
     83 const navigation: ((event: BeforeNavigate) => void)[] = [];
     84 let destinations: string[] = [];
     85 export function beforeNavigate(callback: (event: BeforeNavigate) => void) {
     86   navigation.push(callback);
     87 }
     88 export function goto(destination: string | URL) {
     89   destinations = destinations.concat(String(destination));
     90   return Promise.resolve();
     91 }
     92 type Mode =
     93   | 'normal'
     94   | 'refused_key'
     95   | 'hold_key'
     96   | 'changed_key'
     97   | 'hold_encrypt'
     98   | 'declined_encrypt'
     99   | 'hold_seal';
    100 
    101 // Controlled disposable provider, actual SDK crypto/storage/DOM. No production
    102 // credential, extension, relay access or qualification is supplied by this test.
    103 export async function renderFixture(qualified = true) {
    104   navigation.length = 0;
    105   destinations = [];
    106   const secret = new Uint8Array(32).fill(83),
    107     peerSecret = new Uint8Array(32).fill(84),
    108     owner = getPublicKey(secret),
    109     peer = getPublicKey(peerSecret);
    110   let mode: Mode = 'normal',
    111     release: (() => void) | undefined,
    112     keys = 0,
    113     encrypts = 0,
    114     decrypts = 0,
    115     signs = 0,
    116     active = true,
    117     offset = 0,
    118     pending = false;
    119   const prior = Object.getOwnPropertyDescriptor(window, 'nostr');
    120   const held = async <T>(work: () => T): Promise<T> => {
    121     pending = true;
    122     return new Promise<T>((resolve) => {
    123       release = () => {
    124         pending = false;
    125         release = undefined;
    126         resolve(work());
    127       };
    128     });
    129   };
    130   const provider = {
    131     getPublicKey: () => {
    132       keys++;
    133       if (mode === 'refused_key')
    134         return Promise.reject(Error('controlled refusal'));
    135       const value = () => (mode === 'changed_key' ? peer : owner);
    136       return mode === 'hold_key' ? held(value) : Promise.resolve(value());
    137     },
    138     signEvent: (template: UnsignedEvent) => {
    139       signs++;
    140       const value = () => finalizeEvent(template, secret);
    141       return mode === 'hold_seal' && template.kind === 13
    142         ? held(value)
    143         : Promise.resolve(value());
    144     },
    145     nip44: {
    146       encrypt: (target: string, text: string) => {
    147         encrypts++;
    148         if (mode === 'declined_encrypt')
    149           return Promise.reject(Error('controlled encryption refusal'));
    150         const value = () => {
    151           const key = nip44.v2.utils.getConversationKey(secret, target);
    152           try {
    153             return nip44.v2.encrypt(text, key);
    154           } finally {
    155             key.fill(0);
    156           }
    157         };
    158         return mode === 'hold_encrypt' ? held(value) : Promise.resolve(value());
    159       },
    160       decrypt: (target: string, wire: string) => {
    161         decrypts++;
    162         const key = nip44.v2.utils.getConversationKey(secret, target);
    163         try {
    164           return Promise.resolve(nip44.v2.decrypt(wire, key));
    165         } finally {
    166           key.fill(0);
    167         }
    168       }
    169     }
    170   };
    171   Object.defineProperty(window, 'nostr', {
    172     configurable: true,
    173     value: provider
    174   });
    175   const policy = validateRelayPolicy(
    176     JSON.stringify({
    177       schemaVersion: 1,
    178       public: [
    179         {
    180           origin: 'wss://discovery.example.org',
    181           read: true,
    182           write: true,
    183           nip50: false
    184         }
    185       ],
    186       inbox: ['wss://archive.example.org', 'wss://peer.example.org'].map(
    187         (origin) => ({ origin, read: true, write: true })
    188       ),
    189       postingEnabled: true,
    190       messagingEnabled: true,
    191       operatorDenylist: []
    192     })
    193   );
    194   if (!policy) throw Error('invalid fixed test policy');
    195   const publicContext = createPublicRuntimeContext(),
    196     runtime = mountPublicRuntime(publicContext, policy, {
    197       now: () => offset,
    198       schedule: () => () => {}
    199     });
    200   if (!runtime) throw Error('original runtime unavailable');
    201   const context = createIdentityViewContext();
    202   mountIdentityView(context);
    203   const reference = encodeProductReference({
    204     kind: 30402,
    205     pubkey: peer,
    206     identifier: 'carrots'
    207   });
    208   if (!reference) throw Error('invalid coordinate');
    209   const observers = new Set<(value: ProductViewSnapshot) => void>();
    210   const view = createProductView(
    211     createPublicView(runtime),
    212     reference,
    213     { nowSeconds: () => 1700000200 },
    214     (value) => {
    215       for (const callback of observers) callback(value);
    216     }
    217   );
    218   let otherView: ProductView | undefined;
    219   let retainedConsent: ProductStatusAcknowledgement | undefined;
    220   const target = document.createElement('div');
    221   document.body.append(target);
    222   let draft: ProductEnquiry | undefined,
    223     controller: ProductRequestController | undefined,
    224     headless: ProductRequestController | undefined,
    225     setup: InboxSetupView | undefined;
    226   const mounted = mount(Panel, {
    227     target,
    228     props: {
    229       view,
    230       context,
    231       publicContext,
    232       observe(callback: (value: ProductViewSnapshot) => void) {
    233         observers.add(callback);
    234         callback(productViewSnapshot(view));
    235         return () => {
    236           observers.delete(callback);
    237         };
    238       },
    239       makeSetup(identity: IdentitySession) {
    240         const source = createPublicView(runtime);
    241         const made = createInboxSetupView({
    242           identity,
    243           policy,
    244           lookup: (current = () => true) =>
    245             settleInboxResolver(
    246               resolveInboxPreference(source, beginPublicViewRun(source), owner),
    247               () =>
    248                 active &&
    249                 !!identityMessagingOwnership(identity)?.current() &&
    250                 current()
    251             ),
    252           readback: (record, author, id) =>
    253             resolveInboxReadback(
    254               source,
    255               beginPublicViewRun(source),
    256               record,
    257               author,
    258               id,
    259               policy
    260             ),
    261           observeAccess: qualified
    262             ? (data) => ({
    263                 ...data,
    264                 receive: 'qualified_exercised',
    265                 archive: 'qualified_exercised',
    266                 current: () =>
    267                   active && !!identityMessagingOwnership(identity)?.current()
    268               })
    269             : undefined,
    270           close: () => disposePublicView(source)
    271         });
    272         if (!made) throw Error('genuine setup unavailable');
    273         setup = made;
    274         return made;
    275       },
    276       capture(value: ProductEnquiry) {
    277         draft = value;
    278       },
    279       request(value: ProductRequestController) {
    280         controller = value;
    281       }
    282     }
    283   });
    284   async function native() {
    285     const opened = await openBrowserDatabase();
    286     if (opened.state !== 'ready')
    287       throw Error('native browser inspection unavailable');
    288     try {
    289       const transaction = browserDatabaseTransaction(
    290         opened.owner,
    291         ['private_sends'],
    292         'readonly'
    293       );
    294       const sends = await new Promise<unknown[]>((resolve, reject) => {
    295         const store = transaction.objectStore('private_sends');
    296         const request = store.getAll();
    297         request.onsuccess = () => resolve(request.result);
    298         request.onerror = () =>
    299           reject(
    300             request.error ?? Error('controlled browser inspection failed')
    301           );
    302       });
    303       return { sends };
    304     } finally {
    305       closeBrowserDatabase(opened.owner);
    306     }
    307   }
    308   await tick();
    309   return {
    310     owner,
    311     peer,
    312     viewSnapshot: () => productViewSnapshot(view),
    313     captureUncertain(review: unknown) {
    314       const acknowledgement = acknowledgeProductViewUncertainty(view, review);
    315       return !!captureProductEnquiry(
    316         view,
    317         'reviewed_product_enquiry',
    318         acknowledgement
    319       );
    320     },
    321     createOtherView() {
    322       otherView = createProductView(
    323         createPublicView(runtime),
    324         reference,
    325         { nowSeconds: () => 1700000200 },
    326         () => {}
    327       );
    328     },
    329     otherViewSnapshot: () => otherView && productViewSnapshot(otherView),
    330     consentCases() {
    331       retainedConsent = acknowledgeProductViewUncertainty(
    332         view,
    333         'reviewed_last_known_listing'
    334       );
    335       return {
    336         genuine: !!retainedConsent,
    337         current: !!productViewListingOwnership(
    338           view,
    339           retainedConsent
    340         )?.current(),
    341         copied: !!productViewListingOwnership(view, {
    342           ...retainedConsent
    343         } as ProductStatusAcknowledgement),
    344         other:
    345           !!otherView &&
    346           !!productViewListingOwnership(otherView, retainedConsent),
    347         otherControl:
    348           !!otherView &&
    349           !!productViewListingOwnership(
    350             otherView,
    351             acknowledgeProductViewUncertainty(
    352               otherView,
    353               'reviewed_last_known_listing'
    354             )
    355           )?.current(),
    356         unreviewed: !!acknowledgeProductViewUncertainty(view, undefined)
    357       };
    358     },
    359     consentCurrent: () =>
    360       !!productViewListingOwnership(view, retainedConsent)?.current(),
    361     identity: () => identityViewSnapshot(context),
    362     setup: () => inboxSetupViewSnapshot(setup),
    363     snapshot: () => controller && productRequestSnapshot(controller),
    364     text: () => controller && productRequestText(controller),
    365     product: () => draft && productEnquirySnapshot(draft),
    366     message: () => draft && productEnquiryMessage(draft),
    367     native,
    368     counts: () => ({ keys, encrypts, decrypts, signs }),
    369     pending: () => pending,
    370     scheduler: () => {
    371       const scheduler = browserExtensionScheduler();
    372       return scheduler && extensionSchedulerSnapshot(scheduler);
    373     },
    374     mode(value: Mode) {
    375       mode = value;
    376     },
    377     settle() {
    378       mode = 'normal';
    379       release?.();
    380     },
    381     logout() {
    382       disconnectIdentityView(context);
    383     },
    384     update(value: string) {
    385       return (
    386         !!controller &&
    387         updateProductRequestText(controller, value, 'reviewed_private_text')
    388       );
    389     },
    390     directUpdate(value: string) {
    391       return (
    392         !!draft &&
    393         updateProductEnquiry(draft, value, 'reviewed_product_enquiry_edit')
    394       );
    395     },
    396     beginHeadless() {
    397       const original = captureProductEnquiry(view, 'reviewed_product_enquiry');
    398       const actor = identityViewSession(context);
    399       headless = original && createProductRequestController(original, runtime);
    400       if (
    401         !headless ||
    402         !actor ||
    403         !setup ||
    404         !configureProductRequest(
    405           headless,
    406           actor,
    407           setup,
    408           'reviewed_product_request_setup'
    409         )
    410       )
    411         throw Error('genuine headless test owner unavailable');
    412       return sendProductRequest(headless, 'reviewed_product_request_send');
    413     },
    414     headlessSnapshot: () => headless && productRequestSnapshot(headless),
    415     headlessText: () => headless && productRequestText(headless),
    416     revokeView() {
    417       closeProductView(view);
    418     },
    419     send: () =>
    420       controller &&
    421       sendProductRequest(controller, 'reviewed_product_request_send'),
    422     unreviewed: () => controller && sendProductRequest(controller, undefined),
    423     copied: async () => ({
    424       create: !!createProductRequestController({} as ProductEnquiry),
    425       snapshot: productRequestSnapshot({} as ProductRequestController),
    426       configure: configureProductRequest(
    427         {} as ProductRequestController,
    428         {} as IdentitySession,
    429         {} as InboxSetupView,
    430         'reviewed_product_request_setup'
    431       ),
    432       send: await sendProductRequest(
    433         {} as ProductRequestController,
    434         'reviewed_product_request_send'
    435       )
    436     }),
    437     request: () => controller && requestProductRequestNavigation(controller),
    438     keep: () => controller && keepProductRequestEditing(controller),
    439     discard: () =>
    440       controller &&
    441       discardProductRequestNavigation(
    442         controller,
    443         'reviewed_discard_private_text'
    444       ),
    445     async navigate() {
    446       let cancelled = false;
    447       const event = {
    448         cancel() {
    449           cancelled = true;
    450         },
    451         to: { url: new URL('/about', location.href) },
    452         willUnload: false
    453       } as BeforeNavigate;
    454       for (const callback of navigation) callback(event);
    455       await tick();
    456       return { cancelled, destinations: destinations.slice() };
    457     },
    458     destinations: () => destinations.slice(),
    459     persistentText: async () =>
    460       JSON.stringify({
    461         url: location.href,
    462         local: { ...localStorage },
    463         session: { ...sessionStorage },
    464         native: await native()
    465       }),
    466     advance() {
    467       offset += 15001;
    468     },
    469     async closeView() {
    470       closeProductView(view);
    471       if (headless) closeProductRequestController(headless);
    472       await tick();
    473     },
    474     async close() {
    475       active = false;
    476       mode = 'normal';
    477       release?.();
    478       closeProductView(view);
    479       if (otherView) closeProductView(otherView);
    480       await unmount(mounted);
    481       closeIdentityView(context);
    482       closePublicRuntime(publicContext);
    483       target.remove();
    484       if (prior) Object.defineProperty(window, 'nostr', prior);
    485       else Reflect.deleteProperty(window, 'nostr');
    486       secret.fill(0);
    487       peerSecret.fill(0);
    488     }
    489   };
    490 }