app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

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 }