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 (7698B)


      1 import { makeFixture } from './approved-signing.ts';
      2 import { Relay } from 'applesauce-relay/relay';
      3 export {
      4   getPublicPool,
      5   closePublicPool
      6 } from '../../../src/lib/nostr/public-pool.ts';
      7 import { publicRecordSnapshot } from '../../../src/lib/persistence/records.ts';
      8 import {
      9   createIdentitySession,
     10   connectIdentity,
     11   probeIdentityMessaging,
     12   disconnectIdentity
     13 } from '../../../src/lib/runtime/identity-session.ts';
     14 import {
     15   createPublicScheduler,
     16   createPublicRun,
     17   openInboxRequest,
     18   closePublicScheduler
     19 } from '../../../src/lib/nostr/request-scope.ts';
     20 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts';
     21 import { fixturePolicy, discovery, setupInput } from './inbox-setup.ts';
     22 export { fixturePolicy, discovery, setupInput };
     23 export {
     24   createIdentitySession,
     25   connectIdentity,
     26   probeIdentityMessaging,
     27   disconnectIdentity
     28 };
     29 export {
     30   reviewInboxSetup,
     31   inboxSetupPreview
     32 } from '../../../src/lib/messaging/inbox-setup.ts';
     33 export { saveInboxPreferenceOperation } from '../../../src/lib/persistence/inbox-preference-operations.ts';
     34 export {
     35   beginInboxPreferenceOperation,
     36   resumeInboxPreferenceOperation,
     37   runInboxPreferenceOperation,
     38   stopInboxPreferenceOperation
     39 } from '../../../src/lib/messaging/inbox-setup-operation.ts';
     40 export {
     41   openBrowserDatabase,
     42   closeBrowserDatabase
     43 } from '../../../src/lib/persistence/database.ts';
     44 export {
     45   createPublicQuotaRepository,
     46   loadPreferenceOperation
     47 } from '../../../src/lib/persistence/quota.ts';
     48 export { publicRecordSnapshot };
     49 export async function makePublisherFixture(
     50   flags = { postingEnabled: true, messagingEnabled: true }
     51 ) {
     52   const fixture = makeFixture(10050),
     53     original = publicRecordSnapshot(fixture.record, fixture.owner, fixture.id)!;
     54   if (original.family !== 'preference_operation' || !original.source.wire)
     55     throw new Error('missing source');
     56   const source = JSON.parse(original.source.wire) as ReturnType<
     57     typeof fixture.sign
     58   >;
     59   const identity = createIdentitySession();
     60   let observedOwner = fixture.owner,
     61     signs = 0;
     62   let beforeSign: (() => Promise<void>) | undefined;
     63   const prior = Object.getOwnPropertyDescriptor(window, 'nostr');
     64   Object.defineProperty(window, 'nostr', {
     65     configurable: true,
     66     value: {
     67       getPublicKey: () => Promise.resolve(observedOwner),
     68       signEvent: async (input: Parameters<typeof fixture.sign>[0]) => {
     69         signs++;
     70         await beforeSign?.();
     71         return fixture.sign(input);
     72       },
     73       nip44: {
     74         encrypt: (_peer: string, text: string) =>
     75           Promise.resolve('fixture:' + text),
     76         decrypt: (_peer: string, text: string) => Promise.resolve(text.slice(8))
     77       }
     78     }
     79   });
     80   await connectIdentity(identity);
     81   await probeIdentityMessaging(identity, 'reviewed_self_copy');
     82   const policy = fixturePolicy(flags),
     83     schedulers: ReturnType<typeof createPublicScheduler>[] = [];
     84   function resolve(event = source, complete = true) {
     85     const scheduler = createPublicScheduler({
     86       now: () => 0,
     87       schedule: () => () => {}
     88     });
     89     schedulers.push(scheduler);
     90     const run = createPublicRun(scheduler, policy);
     91     return createInboxResolver(
     92       run,
     93       fixture.owner,
     94       (next) =>
     95         openInboxRequest(
     96           run,
     97           fixture.owner,
     98           (sink) => {
     99             sink({ type: 'EVENT', from: discovery, id: 'fixture', event });
    100             if (complete)
    101               sink({ type: 'EOSE', from: discovery, id: 'fixture' });
    102             return () => {};
    103           },
    104           next
    105         ),
    106       () => true
    107     );
    108   }
    109   return {
    110     identity,
    111     policy,
    112     owner: fixture.owner,
    113     resolve,
    114     signs: () => signs,
    115     beforeSign(callback: () => Promise<void>) {
    116       beforeSign = callback;
    117     },
    118     changeOwner() {
    119       const other = makeFixture(10050);
    120       try {
    121         observedOwner = other.owner;
    122       } finally {
    123         other.close();
    124       }
    125     },
    126     competing() {
    127       return fixture.sign({
    128         ...fixture.template,
    129         created_at: 102,
    130         content: 'concurrent preference'
    131       });
    132     },
    133     close() {
    134       disconnectIdentity(identity);
    135       for (const scheduler of schedulers) closePublicScheduler(scheduler);
    136       fixture.close();
    137       if (prior) Object.defineProperty(window, 'nostr', prior);
    138       else Reflect.deleteProperty(window, 'nostr');
    139     }
    140   };
    141 }
    142 // Test-only fault at the real IDB write boundary; no mock database/production port.
    143 export function failPreferenceWrite(revision: number) {
    144   const original = Reflect.get<IDBObjectStore, 'put'>(
    145     IDBObjectStore.prototype,
    146     'put'
    147   );
    148   IDBObjectStore.prototype.put = function (value: unknown, key?: IDBValidKey) {
    149     if (
    150       this.name === 'preference_operations' &&
    151       typeof value === 'object' &&
    152       value &&
    153       'wire' in value &&
    154       typeof value.wire === 'string'
    155     ) {
    156       const row = JSON.parse(value.wire) as { revision: number };
    157       if (row.revision === revision) {
    158         IDBObjectStore.prototype.put = original;
    159         this.transaction.abort();
    160         throw new Error('controlled IDB abort');
    161       }
    162     }
    163     return original.call(this, value, key);
    164   };
    165   return () => {
    166     IDBObjectStore.prototype.put = original;
    167   };
    168 }
    169 // Actual transaction-complete and native SDK transport-send ordering only.
    170 // Delegates both APIs unchanged; no delayed send or database substitute.
    171 export function installEffectTrace() {
    172   const events: string[] = [];
    173   const put = Reflect.get<IDBObjectStore, 'put'>(
    174     IDBObjectStore.prototype,
    175     'put'
    176   );
    177   const send = Reflect.get<WebSocket, 'send'>(WebSocket.prototype, 'send');
    178   IDBObjectStore.prototype.put = function (value: unknown, key?: IDBValidKey) {
    179     if (
    180       this.name === 'preference_operations' &&
    181       typeof value === 'object' &&
    182       value &&
    183       'wire' in value &&
    184       typeof value.wire === 'string'
    185     ) {
    186       const revision = (JSON.parse(value.wire) as { revision: number })
    187         .revision;
    188       this.transaction.addEventListener(
    189         'complete',
    190         () => events.push('ack:' + revision),
    191         { once: true }
    192       );
    193     }
    194     return put.call(this, value, key);
    195   };
    196   WebSocket.prototype.send = function (data: Parameters<WebSocket['send']>[0]) {
    197     if (
    198       typeof data === 'string' &&
    199       (JSON.parse(data) as unknown[])[0] === 'EVENT'
    200     )
    201       events.push('EVENT');
    202     return send.call(this, data);
    203   };
    204   return {
    205     events: () => [...events],
    206     restore() {
    207       IDBObjectStore.prototype.put = put;
    208       WebSocket.prototype.send = send;
    209     }
    210   };
    211 }
    212 // Retain the actual SDK observable/subscription; only its owned release is
    213 // faulted. No fake ACK, transport, signature, database or production option.
    214 export function installUnsubscribeFailure() {
    215   const event = Reflect.get<Relay, 'event'>(Relay.prototype, 'event');
    216   let fail = true;
    217   Relay.prototype.event = function (...args: Parameters<Relay['event']>) {
    218     const observable = event.call(this, ...args);
    219     observable.subscribe = new Proxy(observable.subscribe.bind(observable), {
    220       apply(subscribe, receiver, argumentsList) {
    221         const subscription = Reflect.apply(
    222           subscribe,
    223           receiver,
    224           argumentsList
    225         ) as ReturnType<typeof subscribe>;
    226         const release = subscription.unsubscribe.bind(subscription);
    227         subscription.unsubscribe = () => {
    228           if (fail) throw new Error('controlled owned release failure');
    229           release();
    230         };
    231         return subscription;
    232       }
    233     });
    234     return observable;
    235   };
    236   return {
    237     allowRelease() {
    238       fail = false;
    239     },
    240     restore() {
    241       fail = false;
    242       Relay.prototype.event = event;
    243     }
    244   };
    245 }