@agentshouse/mdruntime 0.1.0-alpha.5 → 0.1.0-alpha.50

package/dist/store.js

@@ -1,14 +1,19 @@
-import { requestPersistentStorage } from './durability.js';
+import { sameChange } from './overlay.js';
 const DATABASE = 'mdruntime';
-const REPLICAS = 'replicas';
-const SYNCHRONIZATION = 'synchronization';
-const DISCOVERY = 'discovery';
-const QUEUES = 'queues';
-const DRAFTS = 'drafts';
-const LAST_COMPLETED = 'lastCompleted';
-const GENERATION = 'generation';
-const PROVIDER_LIMITS = 'providerLimits';
-const SCHEMA = 4;
+const ROOMS = 'rooms';
+const DOCUMENTS = 'documents';
+const BINARY_TARGETS = 'binaryTargets';
+const ATTACHMENTS = 'attachments';
+const PENDING_CHANGES = 'pendingChanges';
+const OUTCOMES = 'outcomes';
+const DECLARATIONS = 'declarations';
+const ROOM_DRAFTS = 'roomDrafts';
+const PRESENTATION = 'presentation';
+const CONVERSATIONS = 'conversations';
+const MESSAGES = 'messages';
+const CHAT_DRAFTS = 'chatDrafts';
+const CURRENT = 'current';
+const SCHEMA = 19;
 function settled(request) {
     return new Promise((resolve, reject)=>{
         request.onsuccess = ()=>resolve(request.result);
@@ -22,108 +27,528 @@ function completed(transaction) {
         transaction.onabort = ()=>reject(transaction.error);
     });
 }
-export async function openReplicaStore() {
-    await requestPersistentStorage();
+const EMPTY_DECLARATIONS = {
+    lastCompleted: null,
+    generation: null,
+    providerLimits: [],
+    capabilities: [],
+    slots: []
+};
+function declaration(database) {
+    const transaction = database.transaction(DECLARATIONS, 'readonly');
+    return settled(transaction.objectStore(DECLARATIONS).get(CURRENT)).then((record)=>record ?? EMPTY_DECLARATIONS);
+}
+function updateDeclaration(database, update) {
+    const transaction = database.transaction(DECLARATIONS, 'readwrite');
+    const store = transaction.objectStore(DECLARATIONS);
+    const prior = store.get(CURRENT);
+    prior.onsuccess = ()=>{
+        store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
+    };
+    return completed(transaction);
+}
+function amendPending(database, locator, id, amendment) {
+    const transaction = database.transaction(PENDING_CHANGES, 'readwrite');
+    const pending = transaction.objectStore(PENDING_CHANGES);
+    const request = pending.get([
+        locator,
+        id
+    ]);
+    request.onsuccess = ()=>{
+        const record = request.result;
+        if (record !== undefined) pending.put({
+            ...record,
+            ...amendment
+        });
+    };
+    return completed(transaction);
+}
+function roomRecord(record, queue) {
+    const { documents, binaryTargets, revisions, changes, written, attachments, ...room } = record;
+    return {
+        ...room,
+        order: queue.map((batch)=>batch.id)
+    };
+}
+function removeRoomEntries(store, locator) {
+    const keys = store.getAllKeys();
+    keys.onsuccess = ()=>{
+        for (const key of keys.result){
+            if (Array.isArray(key) && key[0] === locator) store.delete(key);
+        }
+    };
+}
+export function removeRuntimeStore() {
+    return new Promise((resolve, reject)=>{
+        const removal = indexedDB.deleteDatabase(DATABASE);
+        removal.onsuccess = ()=>resolve();
+        removal.onerror = ()=>reject(removal.error);
+    });
+}
+export async function openRuntimeStore() {
     const opening = indexedDB.open(DATABASE, SCHEMA);
     opening.onupgradeneeded = ()=>{
         const database = opening.result;
         for (const name of [
             ...database.objectStoreNames
         ])database.deleteObjectStore(name);
-        database.createObjectStore(REPLICAS, {
+        database.createObjectStore(ROOMS, {
             keyPath: 'locator'
         });
-        database.createObjectStore(SYNCHRONIZATION);
-        database.createObjectStore(DISCOVERY);
-        database.createObjectStore(QUEUES, {
-            keyPath: 'locator'
+        database.createObjectStore(DOCUMENTS, {
+            keyPath: [
+                'locator',
+                'path'
+            ]
         });
-        database.createObjectStore(DRAFTS, {
+        database.createObjectStore(BINARY_TARGETS, {
             keyPath: [
                 'locator',
                 'path'
             ]
         });
+        database.createObjectStore(ATTACHMENTS, {
+            keyPath: [
+                'locator',
+                'reference'
+            ]
+        });
+        database.createObjectStore(PENDING_CHANGES, {
+            keyPath: [
+                'locator',
+                'id'
+            ]
+        });
+        const outcomes = database.createObjectStore(OUTCOMES, {
+            keyPath: 'id'
+        });
+        outcomes.createIndex('locator', 'locator');
+        database.createObjectStore(DECLARATIONS);
+        database.createObjectStore(ROOM_DRAFTS, {
+            keyPath: [
+                'locator',
+                'path'
+            ]
+        });
+        database.createObjectStore(PRESENTATION, {
+            keyPath: 'app'
+        });
+        database.createObjectStore(CONVERSATIONS, {
+            keyPath: 'conversation'
+        });
+        const messages = database.createObjectStore(MESSAGES, {
+            keyPath: [
+                'conversation',
+                'identity'
+            ]
+        });
+        messages.createIndex('conversation', 'conversation');
+        database.createObjectStore(CHAT_DRAFTS, {
+            keyPath: 'conversation'
+        });
     };
     const database = await settled(opening);
     return {
         async all () {
-            const transaction = database.transaction(REPLICAS, 'readonly');
-            return settled(transaction.objectStore(REPLICAS).getAll());
+            const transaction = database.transaction([
+                ROOMS,
+                DOCUMENTS,
+                BINARY_TARGETS,
+                ATTACHMENTS
+            ], 'readonly');
+            const [rooms, documents, targets, attachments] = await Promise.all([
+                settled(transaction.objectStore(ROOMS).getAll()),
+                settled(transaction.objectStore(DOCUMENTS).getAll()),
+                settled(transaction.objectStore(BINARY_TARGETS).getAll()),
+                settled(transaction.objectStore(ATTACHMENTS).getAll())
+            ]);
+            const byRoom = new Map();
+            for (const { order, ...room } of rooms){
+                byRoom.set(room.locator, {
+                    ...room,
+                    documents: {},
+                    revisions: {},
+                    changes: {},
+                    written: {},
+                    binaryTargets: [],
+                    attachments: []
+                });
+            }
+            const head = (room, held)=>{
+                if (held.revision !== null) {
+                    room.revisions[held.path] = held.revision;
+                }
+                if (held.change !== null) {
+                    room.changes[held.path] = held.change;
+                }
+            };
+            for (const document of documents){
+                const room = byRoom.get(document.locator);
+                if (room === undefined) continue;
+                room.documents[document.path] = document.content;
+                if (document.written !== null) {
+                    room.written[document.path] = document.written;
+                }
+                head(room, document);
+            }
+            for (const target of targets){
+                const room = byRoom.get(target.locator);
+                if (room === undefined) continue;
+                room.binaryTargets.push(target.path);
+                head(room, target);
+            }
+            for (const { locator, ...attachment } of attachments){
+                const room = byRoom.get(locator);
+                if (room === undefined) continue;
+                room.attachments.push(attachment);
+            }
+            return [
+                ...byRoom.values()
+            ];
+        },
+        async write ({ next, previous, queue, previousQueue, saved, outcomes, roomDrafts, consumedRoomDrafts }) {
+            const transaction = database.transaction([
+                ROOMS,
+                DOCUMENTS,
+                BINARY_TARGETS,
+                ATTACHMENTS,
+                PENDING_CHANGES,
+                OUTCOMES,
+                ROOM_DRAFTS
+            ], 'readwrite');
+            transaction.objectStore(ROOMS).put(roomRecord(next, queue));
+            const documents = transaction.objectStore(DOCUMENTS);
+            for (const path of Object.keys(previous?.documents ?? {})){
+                if (next.documents[path] === undefined) documents.delete([
+                    next.locator,
+                    path
+                ]);
+            }
+            for (const [path, content] of Object.entries(next.documents)){
+                if (previous?.documents[path] === content && previous.revisions[path] === next.revisions[path] && previous.written[path] === next.written[path] && sameChange(previous.changes[path], next.changes[path])) continue;
+                documents.put({
+                    locator: next.locator,
+                    path,
+                    content,
+                    revision: next.revisions[path] ?? null,
+                    change: next.changes[path] ?? null,
+                    written: next.written[path] ?? null
+                });
+            }
+            const targets = transaction.objectStore(BINARY_TARGETS);
+            const beforeTargets = new Set(previous?.binaryTargets ?? []);
+            const afterTargets = new Set(next.binaryTargets);
+            for (const path of beforeTargets){
+                if (!afterTargets.has(path)) targets.delete([
+                    next.locator,
+                    path
+                ]);
+            }
+            for (const path of afterTargets){
+                if (!beforeTargets.has(path) || previous?.revisions[path] !== next.revisions[path] || !sameChange(previous?.changes[path], next.changes[path])) {
+                    targets.put({
+                        locator: next.locator,
+                        path,
+                        revision: next.revisions[path] ?? null,
+                        change: next.changes[path] ?? null
+                    });
+                }
+            }
+            const attachments = transaction.objectStore(ATTACHMENTS);
+            const held = new Map((previous?.attachments ?? []).map((attachment)=>[
+                    attachment.reference,
+                    attachment
+                ]));
+            const declared = new Set(next.attachments.map((attachment)=>attachment.reference));
+            for (const reference of held.keys()){
+                if (!declared.has(reference)) attachments.delete([
+                    next.locator,
+                    reference
+                ]);
+            }
+            for (const attachment of next.attachments){
+                if (held.get(attachment.reference) === attachment) continue;
+                attachments.put({
+                    ...attachment,
+                    locator: next.locator
+                });
+            }
+            if (previousQueue !== undefined) {
+                const pending = transaction.objectStore(PENDING_CHANGES);
+                const before = new Set(previousQueue.map((batch)=>batch.id));
+                const after = new Set(queue.map((batch)=>batch.id));
+                for (const id of before){
+                    if (!after.has(id)) pending.delete([
+                        next.locator,
+                        id
+                    ]);
+                }
+                for (const batch of queue){
+                    if (!before.has(batch.id)) {
+                        pending.put({
+                            locator: next.locator,
+                            id: batch.id,
+                            batch,
+                            drafts: saved ?? [],
+                            submission: {
+                                state: 'waiting'
+                            },
+                            lost: false
+                        });
+                    }
+                }
+            }
+            const outcomeStore = transaction.objectStore(OUTCOMES);
+            for (const entry of outcomes ?? []){
+                if (entry.outcome === null) outcomeStore.delete(entry.id);
+                else outcomeStore.put({
+                    locator: next.locator,
+                    id: entry.id,
+                    outcome: entry.outcome
+                });
+            }
+            const draftStore = transaction.objectStore(ROOM_DRAFTS);
+            for (const path of consumedRoomDrafts ?? [])draftStore.delete([
+                next.locator,
+                path
+            ]);
+            for (const record of roomDrafts ?? [])draftStore.put(record);
+            await completed(transaction);
         },
-        async publish (record) {
-            const transaction = database.transaction(REPLICAS, 'readwrite');
-            transaction.objectStore(REPLICAS).put(record);
+        async revokeModels (records) {
+            const transaction = database.transaction(ROOMS, 'readwrite');
+            const rooms = transaction.objectStore(ROOMS);
+            const revoked = {
+                status: 'unavailable',
+                reason: 'revoked'
+            };
+            for (const { record, queue } of records){
+                rooms.put(roomRecord({
+                    ...record,
+                    model: revoked,
+                    selectionModel: revoked
+                }, queue));
+            }
             await completed(transaction);
         },
         async lastCompleted () {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readonly');
-            const value = await settled(transaction.objectStore(SYNCHRONIZATION).get(LAST_COMPLETED));
-            return value ?? null;
+            return (await declaration(database)).lastCompleted;
         },
-        async complete (at) {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readwrite');
-            transaction.objectStore(SYNCHRONIZATION).put(at, LAST_COMPLETED);
-            await completed(transaction);
+        complete (at) {
+            return updateDeclaration(database, (record)=>({
+                    ...record,
+                    lastCompleted: at
+                }));
         },
         async providerLimits () {
-            const transaction = database.transaction(DISCOVERY, 'readonly');
-            const value = await settled(transaction.objectStore(DISCOVERY).get(PROVIDER_LIMITS));
-            return value ?? [];
+            return (await declaration(database)).providerLimits;
         },
-        async declare (limits) {
-            const transaction = database.transaction(DISCOVERY, 'readwrite');
-            transaction.objectStore(DISCOVERY).put(limits, PROVIDER_LIMITS);
-            await completed(transaction);
+        async capabilities () {
+            return (await declaration(database)).capabilities;
+        },
+        async slots () {
+            return (await declaration(database)).slots;
+        },
+        declare (limits, capabilities, slots) {
+            return updateDeclaration(database, (record)=>({
+                    ...record,
+                    providerLimits: limits,
+                    capabilities,
+                    slots
+                }));
         },
         async queues () {
-            const transaction = database.transaction(QUEUES, 'readonly');
-            return settled(transaction.objectStore(QUEUES).getAll());
+            const transaction = database.transaction([
+                ROOMS,
+                PENDING_CHANGES
+            ], 'readonly');
+            const [rooms, pending] = await Promise.all([
+                settled(transaction.objectStore(ROOMS).getAll()),
+                settled(transaction.objectStore(PENDING_CHANGES).getAll())
+            ]);
+            const byId = new Map(pending.map((record)=>[
+                    `${record.locator}\0${record.id}`,
+                    record
+                ]));
+            return rooms.map((room)=>({
+                    locator: room.locator,
+                    pending: room.order.map((id)=>{
+                        const record = byId.get(`${room.locator}\0${id}`);
+                        if (record === undefined) throw new Error(`Missing Pending Change ${room.locator}/${id}`);
+                        const { batch, drafts, submission, lost, upload } = record;
+                        return {
+                            batch,
+                            state: {
+                                drafts,
+                                submission,
+                                lost,
+                                upload
+                            }
+                        };
+                    })
+                }));
+        },
+        async outcomes () {
+            const transaction = database.transaction(OUTCOMES, 'readonly');
+            return settled(transaction.objectStore(OUTCOMES).getAll());
+        },
+        submit (locator, id, submission, lost) {
+            return amendPending(database, locator, id, {
+                submission,
+                lost
+            });
+        },
+        keepUpload (locator, id, upload) {
+            return amendPending(database, locator, id, {
+                upload
+            });
+        },
+        async roomDrafts () {
+            const transaction = database.transaction(ROOM_DRAFTS, 'readonly');
+            return settled(transaction.objectStore(ROOM_DRAFTS).getAll());
         },
-        async drafts () {
-            const transaction = database.transaction(DRAFTS, 'readonly');
-            return settled(transaction.objectStore(DRAFTS).getAll());
+        async presentation () {
+            const transaction = database.transaction(PRESENTATION, 'readonly');
+            return settled(transaction.objectStore(PRESENTATION).getAll());
         },
-        async keep (draft) {
-            const transaction = database.transaction(DRAFTS, 'readwrite');
-            transaction.objectStore(DRAFTS).put(draft);
+        async present (record) {
+            const transaction = database.transaction(PRESENTATION, 'readwrite');
+            transaction.objectStore(PRESENTATION).put(record);
             await completed(transaction);
         },
-        async discard (locator, path) {
-            const transaction = database.transaction(DRAFTS, 'readwrite');
-            transaction.objectStore(DRAFTS).delete([
-                locator,
-                path
+        async conversations () {
+            const transaction = database.transaction([
+                CONVERSATIONS,
+                MESSAGES
+            ], 'readonly');
+            const [reads, messages] = await Promise.all([
+                settled(transaction.objectStore(CONVERSATIONS).getAll()),
+                settled(transaction.objectStore(MESSAGES).getAll())
             ]);
+            const held = new Map();
+            for (const { conversation, read } of reads){
+                held.set(conversation, {
+                    conversation,
+                    read,
+                    messages: []
+                });
+            }
+            for (const { conversation, ...message } of messages){
+                const entry = held.get(conversation) ?? {
+                    conversation,
+                    read: undefined,
+                    messages: []
+                };
+                entry.messages.push(message);
+                held.set(conversation, entry);
+            }
+            return [
+                ...held.values()
+            ];
+        },
+        async keepMessages ({ conversation, messages, read, sealed }) {
+            const transaction = database.transaction([
+                CONVERSATIONS,
+                MESSAGES,
+                CHAT_DRAFTS
+            ], 'readwrite');
+            const stored = transaction.objectStore(MESSAGES);
+            for (const message of messages){
+                stored.put({
+                    ...message,
+                    conversation
+                });
+            }
+            if (read !== undefined) {
+                transaction.objectStore(CONVERSATIONS).put({
+                    conversation,
+                    read
+                });
+            }
+            if (sealed === true) transaction.objectStore(CHAT_DRAFTS).delete(conversation);
             await completed(transaction);
         },
-        async append (queue, consumed) {
+        async dropConversations (conversations) {
             const transaction = database.transaction([
-                QUEUES,
-                DRAFTS
+                CONVERSATIONS,
+                MESSAGES,
+                CHAT_DRAFTS
             ], 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
-            const drafts = transaction.objectStore(DRAFTS);
-            for (const path of consumed)drafts.delete([
-                queue.locator,
+            const messages = transaction.objectStore(MESSAGES);
+            for (const conversation of conversations){
+                transaction.objectStore(CONVERSATIONS).delete(conversation);
+                transaction.objectStore(CHAT_DRAFTS).delete(conversation);
+                const keys = messages.index('conversation').getAllKeys(conversation);
+                keys.onsuccess = ()=>{
+                    for (const key of keys.result)messages.delete(key);
+                };
+            }
+            await completed(transaction);
+        },
+        async chatDrafts () {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readonly');
+            return settled(transaction.objectStore(CHAT_DRAFTS).getAll());
+        },
+        async keepChatDraft (record) {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).put(record);
+            await completed(transaction);
+        },
+        async dropChatDraft (conversation) {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
+            await completed(transaction);
+        },
+        async keepRoomDraft (record) {
+            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
+            transaction.objectStore(ROOM_DRAFTS).put(record);
+            await completed(transaction);
+        },
+        async discardRoomDraft (locator, path) {
+            const transaction = database.transaction(ROOM_DRAFTS, 'readwrite');
+            transaction.objectStore(ROOM_DRAFTS).delete([
+                locator,
                 path
             ]);
             await completed(transaction);
         },
-        async writeQueue (queue) {
-            const transaction = database.transaction(QUEUES, 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
+        async dropRooms (locators) {
+            const transaction = database.transaction([
+                ROOMS,
+                DOCUMENTS,
+                BINARY_TARGETS,
+                ATTACHMENTS,
+                PENDING_CHANGES,
+                OUTCOMES,
+                ROOM_DRAFTS
+            ], 'readwrite');
+            for (const locator of locators){
+                transaction.objectStore(ROOMS).delete(locator);
+                for (const name of [
+                    DOCUMENTS,
+                    BINARY_TARGETS,
+                    ATTACHMENTS,
+                    PENDING_CHANGES,
+                    ROOM_DRAFTS
+                ]){
+                    removeRoomEntries(transaction.objectStore(name), locator);
+                }
+                const outcomes = transaction.objectStore(OUTCOMES);
+                const ids = outcomes.index('locator').getAllKeys(locator);
+                ids.onsuccess = ()=>{
+                    for (const id of ids.result)outcomes.delete(id);
+                };
+            }
             await completed(transaction);
         },
         async generation () {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readonly');
-            const value = await settled(transaction.objectStore(SYNCHRONIZATION).get(GENERATION));
-            return value ?? null;
+            return (await declaration(database)).generation;
         },
-        async rememberGeneration (value) {
-            const transaction = database.transaction(SYNCHRONIZATION, 'readwrite');
-            transaction.objectStore(SYNCHRONIZATION).put(value, GENERATION);
-            await completed(transaction);
+        rememberGeneration (value) {
+            return updateDeclaration(database, (record)=>({
+                    ...record,
+                    generation: value
+                }));
         },
         close () {
             database.close();