public-publications.ts (8113B)
1 import type { PublicDraftRecord } from '../contracts/local-records.ts'; 2 import { canonicalLocalId } from '../private-handles.ts'; 3 import { 4 createPublicDraftRepository, 5 publicDraftRepositoryOwner, 6 type PublicDraftRepository 7 } from './drafts.ts'; 8 import { 9 browserDatabaseTransaction, 10 type BrowserDatabase 11 } from './database.ts'; 12 import { 13 createPublicQuotaRepository, 14 publicQuotaOwner, 15 claimPublicDraftOperation, 16 type PublicQuotaRepository, 17 type PublicQuotaFailure 18 } from './quota.ts'; 19 import { 20 decodePublicRecord, 21 publicRecordSnapshot, 22 type PublicRecordHandle 23 } from './records.ts'; 24 import { 25 publicDraftControllerOwnership, 26 type PublicDraftController 27 } from '../publishing/draft-controller.ts'; 28 import { exactLocalFields } from '../contracts/local-records.ts'; 29 30 declare const repositoryBrand: unique symbol; 31 export type PublicPublicationRepository = Readonly<{ [repositoryBrand]: true }>; 32 type Scope = Readonly<{ 33 database: BrowserDatabase; 34 drafts: PublicDraftRepository; 35 quota: PublicQuotaRepository; 36 owner: string; 37 }>; 38 const repositories = new WeakMap<PublicPublicationRepository, Scope>(); 39 function scopeOf(repository: PublicPublicationRepository): Scope | undefined { 40 const scope = repositories.get(repository); 41 return scope && 42 publicDraftRepositoryOwner(scope.drafts) === scope.owner && 43 publicQuotaOwner(scope.quota) === scope.owner 44 ? scope 45 : undefined; 46 } 47 export function createPublicPublicationRepository( 48 database: BrowserDatabase, 49 owner: unknown 50 ): PublicPublicationRepository | undefined { 51 const drafts = createPublicDraftRepository(database, owner), 52 quota = createPublicQuotaRepository(database, owner); 53 const admittedOwner = drafts && publicDraftRepositoryOwner(drafts); 54 if ( 55 !drafts || 56 !quota || 57 !admittedOwner || 58 publicQuotaOwner(quota) !== admittedOwner 59 ) 60 return undefined; 61 const handle = Object.freeze({}) as PublicPublicationRepository; 62 repositories.set(handle, { database, drafts, quota, owner: admittedOwner }); 63 return handle; 64 } 65 export function publicPublicationDraftRepository( 66 repository: PublicPublicationRepository 67 ): PublicDraftRepository | undefined { 68 return scopeOf(repository)?.drafts; 69 } 70 export function publicPublicationOwner( 71 repository: PublicPublicationRepository 72 ): string | undefined { 73 return scopeOf(repository)?.owner; 74 } 75 // Original same-database quota custody only; it does not mint an identity, 76 // extension approval, lock lease or public network capability. 77 export function publicPublicationQuotaRepository( 78 repository: PublicPublicationRepository 79 ): PublicQuotaRepository | undefined { 80 return scopeOf(repository)?.quota; 81 } 82 export type PublicListingSave = 83 | Readonly<{ status: 'saved' | 'existing'; record: PublicRecordHandle }> 84 | Readonly<{ status: PublicQuotaFailure | 'busy' }>; 85 export type PublicListingRead = 86 | Readonly<{ status: 'found'; record: PublicRecordHandle }> 87 | Readonly<{ status: 'missing' | 'unavailable' | 'corrupt_record' }>; 88 // Readback is exact local observation, never global absence or relay receipt. 89 export function readPublicListingIntent( 90 repository: PublicPublicationRepository, 91 command: unknown 92 ): Promise<PublicListingRead> { 93 const scope = scopeOf(repository), 94 id = canonicalLocalId(command); 95 if (!scope || !id) return Promise.resolve({ status: 'unavailable' }); 96 let transaction: IDBTransaction; 97 try { 98 transaction = browserDatabaseTransaction( 99 scope.database, 100 ['public_operations'], 101 'readonly' 102 ); 103 } catch { 104 return Promise.resolve({ status: 'unavailable' }); 105 } 106 return new Promise((resolve) => { 107 let decision: PublicListingRead | undefined; 108 transaction.addEventListener('complete', () => 109 resolve( 110 scopeOf(repository) 111 ? (decision ?? { status: 'unavailable' }) 112 : { status: 'unavailable' } 113 ) 114 ); 115 transaction.addEventListener('abort', () => 116 resolve({ status: 'unavailable' }) 117 ); 118 try { 119 const request = transaction 120 .objectStore('public_operations') 121 .get([scope.owner, id]); 122 request.addEventListener('success', () => { 123 const value: unknown = request.result; 124 if (value === undefined) { 125 decision = { status: 'missing' }; 126 return; 127 } 128 if ( 129 !exactLocalFields(value, ['owner', 'id', 'wire']) || 130 value.owner !== scope.owner || 131 value.id !== id 132 ) { 133 decision = { status: 'corrupt_record' }; 134 return; 135 } 136 const decoded = decodePublicRecord(value.wire, scope.owner, id); 137 const row = 138 decoded.ok && publicRecordSnapshot(decoded.value, scope.owner, id); 139 decision = 140 decoded.ok && row && row.family === 'public_operation' 141 ? { status: 'found', record: decoded.value } 142 : { status: 'corrupt_record' }; 143 }); 144 } catch { 145 decision = { status: 'unavailable' }; 146 try { 147 transaction.abort(); 148 } catch { 149 resolve({ status: 'unavailable' }); 150 } 151 } 152 }); 153 } 154 // Only a short local transaction is held. Extension/relay effects are later 155 // checkpoint owners and are absent from this repository. 156 export async function savePublicListingIntent( 157 repository: PublicPublicationRepository, 158 controller: PublicDraftController, 159 record: PublicRecordHandle, 160 expected: PublicDraftRecord, 161 editVersion: number, 162 command: string, 163 current: (this: void) => boolean, 164 revisionBase?: Readonly<{ command: string; record: PublicRecordHandle }> 165 ): Promise<PublicListingSave> { 166 try { 167 const scope = scopeOf(repository), 168 custody = publicDraftControllerOwnership(controller); 169 const row = scope && publicRecordSnapshot(record, scope.owner, command); 170 if ( 171 !scope || 172 !custody || 173 custody.repository !== scope.drafts || 174 !row || 175 row.family !== 'public_operation' || 176 (row.source.type !== 'draft' && 177 !( 178 row.capture.kind === 5 && 179 row.source.type === 'public_head' && 180 revisionBase 181 )) 182 ) 183 return { status: 'invalid_scope' }; 184 if ( 185 !current() || 186 typeof window === 'undefined' || 187 !navigator.locks?.request 188 ) 189 return { status: 'unavailable' }; 190 return await navigator.locks.request( 191 'harvestcircle:owner:' + scope.owner, 192 { mode: 'exclusive', ifAvailable: true }, 193 async (lock): Promise<PublicListingSave> => { 194 if (!lock) return { status: 'busy' }; 195 const fresh = (): boolean => scopeOf(repository) === scope && current(); 196 if (!fresh()) return { status: 'unavailable' }; 197 const claimed = await claimPublicDraftOperation( 198 scope.quota, 199 row.id, 200 record, 201 { 202 expected, 203 current: fresh, 204 ...(revisionBase ? { revisionBase } : {}), 205 draftCurrent: () => 206 custody.current(JSON.stringify(expected), editVersion) 207 } 208 ); 209 if (!fresh()) return { status: 'unavailable' }; 210 if (claimed.ok) 211 return { 212 status: claimed.value.state === 'created' ? 'saved' : 'existing', 213 record: claimed.value.record 214 }; 215 if (claimed.reason === 'unknown_completion') { 216 const observed = await readPublicListingIntent(repository, row.id); 217 const original = 218 observed.status === 'found' && 219 publicRecordSnapshot(observed.record, scope.owner, row.id); 220 if (!fresh()) return { status: 'unavailable' }; 221 if ( 222 observed.status === 'found' && 223 original && 224 original.family === 'public_operation' && 225 JSON.stringify(original.source) === JSON.stringify(row.source) && 226 JSON.stringify(original.capture) === JSON.stringify(row.capture) 227 ) 228 return { status: 'existing', record: observed.record }; 229 if (original) return { status: 'conflict' }; 230 } 231 return { status: claimed.reason }; 232 } 233 ); 234 } catch { 235 return { status: 'unavailable' }; 236 } 237 }