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 }