app

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

conversation-directory.ts (4840B)


      1 import { messageMetadataOwnership } from '../../../src/lib/persistence/message-metadata.ts';
      2 import { privateSessionOwnership } from '../../../src/lib/runtime/private-session.ts';
      3 import { makeFixture as makeMetadataFixture } from './message-metadata.ts';
      4 import {
      5   captureConversationDirectory,
      6   resolveLocalConversation,
      7   rememberAdmittedConversation,
      8   closeConversationDirectory,
      9   type ConversationDirectory
     10 } from '../../../src/lib/messaging/conversation-directory.ts';
     11 import type { AdmittedConversation } from '../../../src/lib/messaging/admit-conversation.ts';
     12 export async function makeFixture(initialise = true) {
     13   const f = await makeMetadataFixture('inbound', initialise);
     14   let directory: ConversationDirectory | undefined;
     15   let otherDirectory: ConversationDirectory | undefined;
     16   return {
     17     ...f,
     18     async ready() {
     19       if ((await f.unlock()) !== 'authenticated')
     20         throw Error('no genuine nested admission');
     21       if (
     22         !f.admit('inbound') ||
     23         !f.captureCache() ||
     24         f.cache() !== 'added' ||
     25         !(await f.captureMetadata())
     26       )
     27         throw Error('no genuine original room/cache/metadata');
     28     },
     29     capture(review: unknown = 'reviewed_conversation_directory') {
     30       const { privateSession, metadata } = f.navigationInputs();
     31       directory =
     32         metadata &&
     33         captureConversationDirectory(privateSession, metadata, review);
     34       return !!directory;
     35     },
     36     resolve(id: unknown) {
     37       return directory
     38         ? resolveLocalConversation(directory, id)
     39         : Promise.resolve({ status: 'unavailable' });
     40     },
     41     remember(review: unknown = 'reviewed_admitted_conversation_navigation') {
     42       const { room } = f.navigationInputs();
     43       return directory && room
     44         ? rememberAdmittedConversation(directory, room, review)
     45         : Promise.resolve({ status: 'unavailable' });
     46     },
     47     forgedRoom() {
     48       return directory
     49         ? rememberAdmittedConversation(
     50             directory,
     51             {} as AdmittedConversation,
     52             'reviewed_admitted_conversation_navigation'
     53           )
     54         : Promise.resolve({ status: 'unavailable' });
     55     },
     56     copied(id: unknown) {
     57       return directory
     58         ? resolveLocalConversation({ ...directory }, id)
     59         : Promise.resolve({ status: 'unavailable' });
     60     },
     61     async otherOwner(id: unknown) {
     62       const input = await f.otherNavigationInputs();
     63       if (!input.privateSession || !input.metadata)
     64         throw Error('no genuine other owner metadata');
     65       otherDirectory = captureConversationDirectory(
     66         input.privateSession,
     67         input.metadata,
     68         'reviewed_conversation_directory'
     69       );
     70       if (!otherDirectory) throw Error('no genuine other directory');
     71       return await resolveLocalConversation(otherDirectory, id);
     72     },
     73     async mutatedGenerationObservation() {
     74       const input = f.navigationInputs();
     75       if (!input.metadata || !input.room)
     76         throw Error('no genuine original metadata/room');
     77       await f.otherGeneration();
     78       const foreign = f.foreignNavigationSession();
     79       if (!foreign) throw Error('no genuine second live same-owner session');
     80       const local = messageMetadataOwnership(input.metadata),
     81         peer = privateSessionOwnership(foreign);
     82       if (!local || !peer || !peer.current() || !local.current())
     83         throw Error('no genuine current observations');
     84       const sameOwner = local.owner === peer.owner,
     85         differentGeneration = local.session !== peer.session;
     86       Reflect.set(local, 'session', peer.session);
     87       Reflect.set(local, 'current', () => true);
     88       const imported = captureConversationDirectory(
     89         foreign,
     90         input.metadata,
     91         'reviewed_conversation_directory'
     92       );
     93       const original = captureConversationDirectory(
     94         input.privateSession,
     95         input.metadata,
     96         'reviewed_conversation_directory'
     97       );
     98       const remembered = imported
     99         ? await rememberAdmittedConversation(
    100             imported,
    101             input.room,
    102             'reviewed_admitted_conversation_navigation'
    103           )
    104         : { status: 'unavailable' };
    105       if (imported) closeConversationDirectory(imported);
    106       if (original) closeConversationDirectory(original);
    107       return {
    108         sameOwner,
    109         differentGeneration,
    110         foreignAccepted: !!imported,
    111         originalAccepted: !!original,
    112         remembered,
    113         raw: await f.rawMetadata()
    114       };
    115     },
    116     async product(text: string) {
    117       await f.anotherWrap(true, text);
    118       if (f.cache() !== 'added') throw Error('no genuine second product rumor');
    119       return await this.remember();
    120     },
    121     close() {
    122       if (directory) closeConversationDirectory(directory);
    123       if (otherDirectory) closeConversationDirectory(otherDirectory);
    124       f.close();
    125     }
    126   };
    127 }