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 }