app

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

revise-listing.ts (5381B)


      1 // HC_TEST_ONLY_RELAY/QUALIFICATION_PORT: actual signed retained source,
      2 // original mounted editor and native operation rows. No live/operator Q.
      3 import { createFixture as sourceFixture } from './edit-source.ts';
      4 import {
      5   openBrowserDatabase,
      6   closeBrowserDatabase,
      7   browserDatabaseTransaction
      8 } from '../../../src/lib/persistence/database.ts';
      9 import type { PublicOperationRecord } from '../../../src/lib/contracts/local-records.ts';
     10 import { nextOwnedRevisionTime } from '../../../src/lib/publishing/revise-listing.ts';
     11 import { mount, unmount } from 'svelte';
     12 import ListingEditor from '../../../src/lib/components/ListingEditor.svelte';
     13 import {
     14   createIdentityViewContext,
     15   mountIdentityView,
     16   connectIdentityView,
     17   closeIdentityView,
     18   IDENTITY_VIEW_CONTEXT
     19 } from '../../../src/lib/runtime/view-context.ts';
     20 import {
     21   createPublicRuntimeContext,
     22   mountPublicRuntime,
     23   closePublicRuntime,
     24   PUBLIC_RUNTIME_CONTEXT
     25 } from '../../../src/lib/runtime/public-runtime.ts';
     26 import { fixturePolicy } from './inbox-setup.ts';
     27 import { makeFixture } from './approved-signing.ts';
     28 export type ControlledSignInput = Parameters<
     29   ReturnType<typeof makeFixture>['sign']
     30 >[0];
     31 
     32 export async function createFixture() {
     33   const original = await sourceFixture();
     34   const opened = await openBrowserDatabase();
     35   if (opened.state !== 'ready') throw Error(opened.reason);
     36   const database = opened.owner;
     37   let release = () => {},
     38     restore = () => {},
     39     signRequests = 0;
     40   return {
     41     ...original,
     42     clock: nextOwnedRevisionTime,
     43     async signOriginal(input: ControlledSignInput) {
     44       const provider = window.nostr as
     45         | {
     46             signEvent(
     47               input: ControlledSignInput
     48             ): Promise<ReturnType<ReturnType<typeof makeFixture>['sign']>>;
     49           }
     50         | undefined;
     51       if (!provider) throw Error('original provider missing');
     52       return await provider.signEvent(input);
     53     },
     54     holdNextSignature() {
     55       const provider = window.nostr as
     56         | {
     57             signEvent(
     58               input: Parameters<ReturnType<typeof makeFixture>['sign']>[0]
     59             ): Promise<ReturnType<ReturnType<typeof makeFixture>['sign']>>;
     60           }
     61         | undefined;
     62       if (!provider) throw Error('original provider missing');
     63       const sign = provider.signEvent.bind(provider);
     64       const held = new Promise<void>((resolve) => {
     65         release = resolve;
     66       });
     67       provider.signEvent = async (input) => {
     68         signRequests++;
     69         await held;
     70         return sign(input);
     71       };
     72       restore = () => {
     73         provider.signEvent = sign;
     74       };
     75     },
     76     refuseNextSignature() {
     77       const provider = window.nostr as
     78         | {
     79             signEvent(
     80               input: Parameters<ReturnType<typeof makeFixture>['sign']>[0]
     81             ): Promise<ReturnType<ReturnType<typeof makeFixture>['sign']>>;
     82           }
     83         | undefined;
     84       if (!provider) throw Error('original provider missing');
     85       const sign = provider.signEvent.bind(provider);
     86       let refused = false;
     87       provider.signEvent = async (input) => {
     88         signRequests++;
     89         if (!refused) {
     90           refused = true;
     91           throw Error('controlled refusal after actual durable signing marker');
     92         }
     93         return sign(input);
     94       };
     95       restore = () => {
     96         provider.signEvent = sign;
     97       };
     98     },
     99     signRequests: () => signRequests,
    100     releaseSignature() {
    101       release();
    102     },
    103     async operations() {
    104       const transaction = browserDatabaseTransaction(
    105         database,
    106         ['public_operations'],
    107         'readonly'
    108       );
    109       const request = transaction.objectStore('public_operations').getAll();
    110       return await new Promise<PublicOperationRecord[]>((resolve, reject) => {
    111         transaction.addEventListener('complete', () =>
    112           resolve(
    113             (request.result as { owner: string; wire: string }[])
    114               .filter((row) => row.owner === original.owner)
    115               .map((row) => JSON.parse(row.wire) as PublicOperationRecord)
    116           )
    117         );
    118         transaction.addEventListener('abort', () =>
    119           reject(Error('actual native operation read failed'))
    120         );
    121       });
    122     },
    123     async close() {
    124       release();
    125       restore();
    126       closeBrowserDatabase(database);
    127       await original.close();
    128     }
    129   };
    130 }
    131 
    132 export async function openSecondEditor(owner: string, naddr: string) {
    133   const context = createIdentityViewContext();
    134   mountIdentityView(context);
    135   const connected = await connectIdentityView(context);
    136   if (
    137     connected.identity.state === 'guest' ||
    138     connected.identity.state === 'pending' ||
    139     connected.identity.publicKey !== owner
    140   )
    141     throw Error('actual second-tab owner mismatch');
    142   const publicContext = createPublicRuntimeContext();
    143   mountPublicRuntime(publicContext, fixturePolicy());
    144   const target = document.createElement('div');
    145   target.id = 'hcp119-second';
    146   document.body.append(target);
    147   const editor = mount(ListingEditor, {
    148     target,
    149     props: { route: { mode: 'edit', naddr } },
    150     context: new Map<string, unknown>([
    151       [IDENTITY_VIEW_CONTEXT, context],
    152       [PUBLIC_RUNTIME_CONTEXT, publicContext]
    153     ])
    154   });
    155   return {
    156     async close() {
    157       await unmount(editor);
    158       target.remove();
    159       closePublicRuntime(publicContext);
    160       closeIdentityView(context);
    161     }
    162   };
    163 }