app

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

listing-editor.ts (19010B)


      1 // HC_TEST_ONLY_QUALIFICATION_PORT: original production owners and actual native
      2 // IndexedDB. Controlled installed provider is not extension/operator/live Q.
      3 import { mount, unmount, type ComponentProps } from 'svelte';
      4 import ListingEditor from '../../../src/lib/components/ListingEditor.svelte';
      5 import { makeFixture } from './approved-signing.ts';
      6 import { createFixture as createOperationFixture } from './listing-operation-view.ts';
      7 import {
      8   createIdentityViewContext,
      9   mountIdentityView,
     10   connectIdentityView,
     11   disconnectIdentityView,
     12   closeIdentityView,
     13   identityViewSnapshot,
     14   IDENTITY_VIEW_CONTEXT
     15 } from '../../../src/lib/runtime/view-context.ts';
     16 import {
     17   openListingEditor,
     18   listingEditorSnapshot,
     19   editListingEditor,
     20   flushListingEditor,
     21   closeListingEditor,
     22   subscribeListingEditor,
     23   type ListingEditor as Editor,
     24   type ListingEditorRoute
     25 } from '../../../src/lib/publishing/listing-editor.ts';
     26 import {
     27   browserDatabaseName,
     28   browserSchemaVersion
     29 } from '../../../src/lib/persistence/schema.ts';
     30 import {
     31   openBrowserDatabase,
     32   closeBrowserDatabase,
     33   browserDatabaseTransaction
     34 } from '../../../src/lib/persistence/database.ts';
     35 import {
     36   createPublicPublicationRepository,
     37   publicPublicationDraftRepository
     38 } from '../../../src/lib/persistence/public-publications.ts';
     39 import {
     40   readPublicDraft,
     41   capturePublicDraftSave,
     42   commitPublicDraftWrite
     43 } from '../../../src/lib/persistence/drafts.ts';
     44 import { inspectLocalTemplate } from '../../../src/lib/nostr/local-template.ts';
     45 import { projectFoodParts } from '../../../src/lib/contracts/food-availability-v1/read.ts';
     46 import { encodeProductReference } from '../../../src/lib/nostr/references.ts';
     47 import type { PublicDraftForm } from '../../../src/lib/contracts/local-records.ts';
     48 export const reference = (
     49   identifier: string,
     50   owner = makeFixture(30402).owner
     51 ) => encodeProductReference({ kind: 30402, pubkey: owner, identifier });
     52 export const blank = (): PublicDraftForm => ({
     53   title: '',
     54   description: '',
     55   location: '',
     56   amount: '',
     57   currency: '',
     58   unit: '',
     59   quantity: '',
     60   contactType: '',
     61   contactValue: ''
     62 });
     63 export function installProvider() {
     64   const signer = makeFixture(30402);
     65   let signs = 0,
     66     keys = 0;
     67   Object.defineProperty(window, 'nostr', {
     68     configurable: true,
     69     value: {
     70       getPublicKey: () => {
     71         keys++;
     72         return Promise.resolve(signer.owner);
     73       },
     74       signEvent: (value: Parameters<typeof signer.sign>[0]) => {
     75         signs++;
     76         return Promise.resolve(signer.sign(value));
     77       }
     78     }
     79   });
     80   return { owner: signer.owner, counts: () => ({ signs, keys }) };
     81 }
     82 export async function createFixture(guest = false) {
     83   const prior = Object.getOwnPropertyDescriptor(window, 'nostr'),
     84     provider = installProvider(),
     85     context = createIdentityViewContext();
     86   let activeOwner = provider.owner;
     87   mountIdentityView(context);
     88   if (!guest) await connectIdentityView(context);
     89   let editor: Editor | undefined,
     90     mounted: ReturnType<typeof mount> | undefined,
     91     target: HTMLElement | undefined;
     92   let operation: Awaited<ReturnType<typeof createOperationFixture>> | undefined;
     93   const cancel = new AbortController();
     94   async function database() {
     95     const opened = await openBrowserDatabase();
     96     if (opened.state !== 'ready') throw Error(opened.reason);
     97     return opened.owner;
     98   }
     99   async function inspect() {
    100     const db = await database();
    101     try {
    102       const transaction = browserDatabaseTransaction(
    103         db,
    104         ['public_drafts', 'public_operations'],
    105         'readonly'
    106       );
    107       const result = await new Promise<{
    108         drafts: unknown[];
    109         operations: unknown[];
    110       }>((resolve, reject) => {
    111         const a = transaction.objectStore('public_drafts').getAll(),
    112           b = transaction.objectStore('public_operations').getAll();
    113         transaction.addEventListener('complete', () =>
    114           resolve({ drafts: a.result, operations: b.result })
    115         );
    116         transaction.addEventListener('abort', () =>
    117           reject(Error('native inspection aborted'))
    118         );
    119       });
    120       return result;
    121     } finally {
    122       closeBrowserDatabase(db);
    123     }
    124   }
    125   return {
    126     get owner() {
    127       return activeOwner;
    128     },
    129     counts: () => (operation ? operation.counts() : provider.counts()),
    130     identity: () => identityViewSnapshot(context),
    131     inspect,
    132     async open(route: ListingEditorRoute, forged = false) {
    133       const result = await openListingEditor(
    134         forged ? { ...context } : context,
    135         route,
    136         cancel.signal
    137       );
    138       if (result.status === 'ready') editor = result.editor;
    139       return result.status === 'ready'
    140         ? { status: 'ready', snapshot: listingEditorSnapshot(result.editor) }
    141         : result;
    142     },
    143     snapshot: () => editor && listingEditorSnapshot(editor),
    144     async edit(form: PublicDraftForm, copied = false) {
    145       return editor
    146         ? await editListingEditor(copied ? { ...editor } : editor, form)
    147         : false;
    148     },
    149     async flush(copied = false) {
    150       return editor
    151         ? await flushListingEditor(copied ? { ...editor } : editor)
    152         : false;
    153     },
    154     copiedClose() {
    155       if (editor) closeListingEditor({ ...editor });
    156     },
    157     copiedSubscribe() {
    158       let calls = 0;
    159       const off = editor
    160         ? subscribeListingEditor({ ...editor }, () => {
    161             calls++;
    162           })
    163         : () => {};
    164       off();
    165       return calls;
    166     },
    167     cancel() {
    168       cancel.abort();
    169     },
    170     disconnect() {
    171       disconnectIdentityView(context);
    172     },
    173     async render(route: ListingEditorRoute) {
    174       if (mounted) await unmount(mounted);
    175       target?.remove();
    176       target = document.createElement('div');
    177       target.id = 'hcp115-editor';
    178       document.body.append(target);
    179       mounted = mount(ListingEditor, {
    180         target,
    181         props: { route } as ComponentProps<typeof ListingEditor>,
    182         context: new Map([[IDENTITY_VIEW_CONTEXT, context]])
    183       });
    184     },
    185     async unmount() {
    186       if (mounted) await unmount(mounted);
    187       mounted = undefined;
    188       target?.remove();
    189       target = undefined;
    190     },
    191     async prototype() {
    192       operation = await createOperationFixture();
    193       if ((await operation.signed()) !== 'prepared')
    194         throw Error('genuine original signature did not settle');
    195       const row = await operation.row();
    196       disconnectIdentityView(context);
    197       await connectIdentityView(context);
    198       const observed = identityViewSnapshot(context).identity;
    199       if (
    200         observed.state === 'guest' ||
    201         observed.state === 'pending' ||
    202         observed.publicKey !== row.owner
    203       )
    204         throw Error('actual original prototype author admission failed');
    205       if (row.source.type !== 'draft')
    206         throw Error('original source unavailable');
    207       const template = inspectLocalTemplate(row.capture.wire, row.owner, 30402),
    208         projection = template && projectFoodParts(template);
    209       if (!projection || projection.outcome !== 'focused')
    210         throw Error('actual prototype unavailable');
    211       activeOwner = row.owner;
    212       const naddr = encodeProductReference({
    213         kind: 30402,
    214         pubkey: row.owner,
    215         identifier: projection.projection.identifier
    216       });
    217       if (!naddr) throw Error('actual coordinate unavailable');
    218       return {
    219         naddr,
    220         draftId: row.source.id,
    221         sourceRevision: row.source.revision,
    222         eventId: row.artifact?.eventId
    223       };
    224     },
    225     async advanceDraft(id: string) {
    226       const db = await database();
    227       try {
    228         const publications = createPublicPublicationRepository(db, activeOwner),
    229           repository =
    230             publications && publicPublicationDraftRepository(publications);
    231         if (!repository) throw Error('original draft repo unavailable');
    232         const read = await readPublicDraft(repository, id);
    233         if (!read.ok) throw Error(read.reason);
    234         const captured = capturePublicDraftSave(
    235           repository,
    236           id,
    237           read.value.revision,
    238           {
    239             ...read.value.form,
    240             description: read.value.form.description + ' changed'
    241           }
    242         );
    243         if (!captured.ok) throw Error(captured.reason);
    244         const saved = await commitPublicDraftWrite(repository, captured.value);
    245         if (!saved.ok) throw Error(saved.reason);
    246         return saved.value;
    247       } finally {
    248         closeBrowserDatabase(db);
    249       }
    250     },
    251     async deleteDraft(id: string) {
    252       const db = await database();
    253       try {
    254         const transaction = browserDatabaseTransaction(
    255           db,
    256           ['public_drafts'],
    257           'readwrite'
    258         );
    259         const done = new Promise<void>((resolve, reject) => {
    260           transaction.addEventListener('complete', () => resolve());
    261           transaction.addEventListener('abort', () =>
    262             reject(Error('controlled native deletion aborted'))
    263           );
    264         });
    265         transaction.objectStore('public_drafts').delete([activeOwner, id]);
    266         await done;
    267       } finally {
    268         closeBrowserDatabase(db);
    269       }
    270     },
    271     async damageSource(
    272       mode: 'advanced' | 'deleted' | 'mismatched' | 'ambiguous' | 'external',
    273       id: string
    274     ) {
    275       if (mode === 'advanced') return await this.advanceDraft(id);
    276       if (mode === 'deleted') return await this.deleteDraft(id);
    277       if (!operation) throw Error('actual original prototype missing');
    278       if (mode === 'external') {
    279         await operation.externalSource();
    280         return;
    281       }
    282       const db = await database();
    283       try {
    284         if (mode === 'ambiguous') {
    285           const row = await operation.row(),
    286             id = crypto.randomUUID();
    287           const transaction = browserDatabaseTransaction(
    288             db,
    289             ['public_operations'],
    290             'readwrite'
    291           );
    292           const done = new Promise<void>((resolve, reject) => {
    293             transaction.addEventListener('complete', () => resolve());
    294             transaction.addEventListener('abort', () =>
    295               reject(Error('controlled ambiguity abort'))
    296             );
    297           });
    298           transaction.objectStore('public_operations').put({
    299             owner: row.owner,
    300             id,
    301             wire: JSON.stringify({ ...row, id })
    302           });
    303           await done;
    304           return;
    305         }
    306         const publications = createPublicPublicationRepository(db, activeOwner),
    307           repository =
    308             publications && publicPublicationDraftRepository(publications);
    309         if (!repository) throw Error('actual repository missing');
    310         const read = await readPublicDraft(repository, id);
    311         if (!read.ok) throw Error(read.reason);
    312         const row = {
    313           ...read.value,
    314           form: {
    315             ...read.value.form,
    316             title: 'Different actual bounded draft value'
    317           }
    318         };
    319         const transaction = browserDatabaseTransaction(
    320           db,
    321           ['public_drafts'],
    322           'readwrite'
    323         );
    324         const done = new Promise<void>((resolve, reject) => {
    325           transaction.addEventListener('complete', () => resolve());
    326           transaction.addEventListener('abort', () =>
    327             reject(Error('controlled original source mismatch abort'))
    328           );
    329         });
    330         transaction
    331           .objectStore('public_drafts')
    332           .put({ owner: activeOwner, id, wire: JSON.stringify(row) });
    333         await done;
    334       } finally {
    335         closeBrowserDatabase(db);
    336       }
    337     },
    338     async close() {
    339       cancel.abort();
    340       if (editor) closeListingEditor(editor);
    341       if (mounted) await unmount(mounted);
    342       target?.remove();
    343       closeIdentityView(context);
    344       operation?.close();
    345       if (prior) Object.defineProperty(window, 'nostr', prior);
    346       else delete window.nostr;
    347     }
    348   };
    349 }
    350 // Observe actual native calls. Holds defer original application listeners only;
    351 // native completion remains genuine. No synthetic request/transaction/result.
    352 export function nativeObservation() {
    353   const requestDescriptor = Object.getOwnPropertyDescriptor(
    354       IDBRequest.prototype,
    355       'addEventListener'
    356     ),
    357     transactionDescriptor = Object.getOwnPropertyDescriptor(
    358       IDBTransaction.prototype,
    359       'addEventListener'
    360     );
    361   const get = Object.getOwnPropertyDescriptor(IDBObjectStore.prototype, 'get')!
    362     .value as IDBObjectStore['get'];
    363   const put = Object.getOwnPropertyDescriptor(IDBObjectStore.prototype, 'put')!
    364     .value as IDBObjectStore['put'];
    365   const open = Object.getOwnPropertyDescriptor(IDBFactory.prototype, 'open')!
    366     .value as IDBFactory['open'];
    367   const close = Object.getOwnPropertyDescriptor(IDBDatabase.prototype, 'close')!
    368     .value as IDBDatabase['close'];
    369   const inherited = Object.getOwnPropertyDescriptor(
    370     EventTarget.prototype,
    371     'addEventListener'
    372   );
    373   if (!inherited) throw Error('actual native registration unavailable');
    374   const requestAdd = (requestDescriptor ?? inherited)
    375     .value as IDBRequest['addEventListener'];
    376   const transactionAdd = (transactionDescriptor ?? inherited)
    377     .value as IDBTransaction['addEventListener'];
    378   let opens = 0,
    379     closes = 0,
    380     completions = 0,
    381     gets = 0,
    382     puts = 0,
    383     mode: 'none' | 'open-hold' | 'draft-hold' | 'save-hold' | 'open-after' =
    384       'none',
    385     held: (() => void) | undefined,
    386     after: (() => void) | undefined;
    387   IDBObjectStore.prototype.get = function (...args: Parameters<typeof get>) {
    388     if (this.name === 'public_drafts' || this.name === 'public_operations')
    389       gets++;
    390     return get.call(this, ...args);
    391   };
    392   IDBObjectStore.prototype.put = function (...args: Parameters<typeof put>) {
    393     if (this.name === 'public_drafts' || this.name === 'public_operations')
    394       puts++;
    395     return put.call(this, ...args);
    396   };
    397   IDBFactory.prototype.open = function (...args: Parameters<typeof open>) {
    398     opens++;
    399     return open.call(this, ...args);
    400   };
    401   IDBDatabase.prototype.close = function () {
    402     closes++;
    403     return close.call(this);
    404   };
    405   IDBRequest.prototype.addEventListener = function (
    406     type: string,
    407     listener: EventListenerOrEventListenerObject | null,
    408     options?: boolean | AddEventListenerOptions
    409   ) {
    410     if (!listener) return;
    411     if (
    412       this instanceof IDBOpenDBRequest &&
    413       type === 'success' &&
    414       listener &&
    415       (mode === 'open-hold' || mode === 'open-after')
    416     ) {
    417       const chosen = mode;
    418       mode = 'none';
    419       return requestAdd.call(
    420         this,
    421         type,
    422         (event: Event) => {
    423           const original = event.currentTarget;
    424           if (!(original instanceof EventTarget))
    425             throw Error('actual native completion target unavailable');
    426           completions++;
    427           const invoke = () =>
    428             typeof listener === 'function'
    429               ? listener.call(original, event)
    430               : listener.handleEvent(event);
    431           if (chosen === 'open-hold') held = invoke;
    432           else {
    433             invoke();
    434             after?.();
    435           }
    436         },
    437         options
    438       );
    439     }
    440     return requestAdd.call(this, type, listener, options);
    441   };
    442   IDBTransaction.prototype.addEventListener = function (
    443     type: string,
    444     listener: EventListenerOrEventListenerObject | null,
    445     options?: boolean | AddEventListenerOptions
    446   ) {
    447     if (!listener) return;
    448     if (
    449       type === 'complete' &&
    450       listener &&
    451       this.objectStoreNames.contains('public_drafts') &&
    452       ((mode === 'draft-hold' && this.mode === 'readonly') ||
    453         (mode === 'save-hold' && this.mode === 'readwrite'))
    454     ) {
    455       mode = 'none';
    456       return transactionAdd.call(
    457         this,
    458         type,
    459         (event: Event) => {
    460           const original = event.currentTarget;
    461           if (!(original instanceof EventTarget))
    462             throw Error('actual native completion target unavailable');
    463           completions++;
    464           held = () =>
    465             typeof listener === 'function'
    466               ? listener.call(original, event)
    467               : listener.handleEvent(event);
    468         },
    469         options
    470       );
    471     }
    472     return transactionAdd.call(this, type, listener, options);
    473   };
    474   return {
    475     holdOpen() {
    476       mode = 'open-hold';
    477     },
    478     holdDraft() {
    479       mode = 'draft-hold';
    480     },
    481     holdSave() {
    482       mode = 'save-hold';
    483     },
    484     afterOpen(callback: () => void) {
    485       mode = 'open-after';
    486       after = callback;
    487     },
    488     state: () => ({ opens, closes, completions, gets, puts, held: !!held }),
    489     release() {
    490       const callback = held;
    491       held = undefined;
    492       callback?.();
    493     },
    494     restore() {
    495       IDBObjectStore.prototype.get = get;
    496       IDBObjectStore.prototype.put = put;
    497       IDBFactory.prototype.open = open;
    498       IDBDatabase.prototype.close = close;
    499       if (requestDescriptor)
    500         Object.defineProperty(
    501           IDBRequest.prototype,
    502           'addEventListener',
    503           requestDescriptor
    504         );
    505       else Reflect.deleteProperty(IDBRequest.prototype, 'addEventListener');
    506       if (transactionDescriptor)
    507         Object.defineProperty(
    508           IDBTransaction.prototype,
    509           'addEventListener',
    510           transactionDescriptor
    511         );
    512       else Reflect.deleteProperty(IDBTransaction.prototype, 'addEventListener');
    513     }
    514   };
    515 }
    516 
    517 export async function inspectNative() {
    518   const opened = await openBrowserDatabase();
    519   if (opened.state !== 'ready') throw Error(opened.reason);
    520   try {
    521     const transaction = browserDatabaseTransaction(
    522       opened.owner,
    523       ['public_drafts', 'public_operations'],
    524       'readonly'
    525     );
    526     return await new Promise<{ drafts: unknown[]; operations: unknown[] }>(
    527       (resolve, reject) => {
    528         const drafts = transaction.objectStore('public_drafts').getAll(),
    529           operations = transaction.objectStore('public_operations').getAll();
    530         transaction.addEventListener('complete', () =>
    531           resolve({ drafts: drafts.result, operations: operations.result })
    532         );
    533         transaction.addEventListener('abort', () =>
    534           reject(Error('actual native inspection aborted'))
    535         );
    536       }
    537     );
    538   } finally {
    539     closeBrowserDatabase(opened.owner);
    540   }
    541 }
    542 
    543 export async function nativeVersionChange() {
    544   const request = indexedDB.open(browserDatabaseName, browserSchemaVersion + 1);
    545   return await new Promise<{ drafts: unknown[] }>((resolve, reject) => {
    546     request.addEventListener('success', () => {
    547       const database = request.result,
    548         transaction = database.transaction(['public_drafts'], 'readonly'),
    549         drafts = transaction.objectStore('public_drafts').getAll();
    550       transaction.addEventListener('complete', () => {
    551         database.close();
    552         resolve({ drafts: drafts.result });
    553       });
    554       transaction.addEventListener('abort', () => {
    555         database.close();
    556         reject(Error('controlled upgraded read aborted'));
    557       });
    558     });
    559     request.addEventListener('error', () =>
    560       reject(request.error ?? Error('native upgrade failed'))
    561     );
    562   });
    563 }