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 }