@agentshouse/mdruntime 0.1.0-alpha.20 → 0.1.0-alpha.22

package/dist/store.js

@@ -1,18 +1,17 @@
 const DATABASE = 'mdruntime';
-const REPLICAS = 'replicas';
-const SYNCHRONIZATION = 'synchronization';
-const DISCOVERY = 'discovery';
-const QUEUES = 'queues';
+const ROOMS = 'rooms';
+const DOCUMENTS = 'documents';
+const BINARY_TARGETS = 'binaryTargets';
+const PENDING_CHANGES = 'pendingChanges';
+const OUTCOMES = 'outcomes';
+const DECLARATIONS = 'declarations';
 const DRAFTS = 'drafts';
 const PRESENTATION = 'presentation';
 const CONVERSATIONS = 'conversations';
-const INSTRUCTIONS = 'instructions';
-const LAST_COMPLETED = 'lastCompleted';
-const GENERATION = 'generation';
-const PROVIDER_LIMITS = 'providerLimits';
-const CAPABILITIES = 'capabilities';
-const SLOTS = 'slots';
-const SCHEMA = 9;
+const MESSAGES = 'messages';
+const CHAT_DRAFTS = 'chatDrafts';
+const CURRENT = 'current';
+const SCHEMA = 11;
 function settled(request) {
     return new Promise((resolve, reject)=>{
         request.onsuccess = ()=>resolve(request.result);
@@ -26,6 +25,41 @@ function completed(transaction) {
         transaction.onabort = ()=>reject(transaction.error);
     });
 }
+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 roomRecord(record, queue) {
+    const { documents, binaryTargets, revisions, ...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);
@@ -33,24 +67,39 @@ export function removeRuntimeStore() {
         removal.onerror = ()=>reject(removal.error);
     });
 }
-function discardEveryEarlierStore(database) {
-    for (const name of [
-        ...database.objectStoreNames
-    ])database.deleteObjectStore(name);
-}
 export async function openRuntimeStore() {
     const opening = indexedDB.open(DATABASE, SCHEMA);
     opening.onupgradeneeded = ()=>{
         const database = opening.result;
-        discardEveryEarlierStore(database);
-        database.createObjectStore(REPLICAS, {
+        for (const name of [
+            ...database.objectStoreNames
+        ])database.deleteObjectStore(name);
+        database.createObjectStore(ROOMS, {
             keyPath: 'locator'
         });
-        database.createObjectStore(SYNCHRONIZATION);
-        database.createObjectStore(DISCOVERY);
-        database.createObjectStore(QUEUES, {
-            keyPath: 'locator'
+        database.createObjectStore(DOCUMENTS, {
+            keyPath: [
+                'locator',
+                'path'
+            ]
+        });
+        database.createObjectStore(BINARY_TARGETS, {
+            keyPath: [
+                'locator',
+                'path'
+            ]
+        });
+        database.createObjectStore(PENDING_CHANGES, {
+            keyPath: [
+                'locator',
+                'id'
+            ]
+        });
+        const outcomes = database.createObjectStore(OUTCOMES, {
+            keyPath: 'id'
         });
+        outcomes.createIndex('locator', 'locator');
+        database.createObjectStore(DECLARATIONS);
         database.createObjectStore(DRAFTS, {
             keyPath: [
                 'locator',
@@ -63,56 +112,228 @@ export async function openRuntimeStore() {
         database.createObjectStore(CONVERSATIONS, {
             keyPath: 'conversation'
         });
-        database.createObjectStore(INSTRUCTIONS, {
+        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
+            ], 'readonly');
+            const [rooms, documents, targets] = await Promise.all([
+                settled(transaction.objectStore(ROOMS).getAll()),
+                settled(transaction.objectStore(DOCUMENTS).getAll()),
+                settled(transaction.objectStore(BINARY_TARGETS).getAll())
+            ]);
+            const byRoom = new Map();
+            for (const { order, ...room } of rooms){
+                byRoom.set(room.locator, {
+                    ...room,
+                    documents: {},
+                    revisions: {},
+                    binaryTargets: []
+                });
+            }
+            for (const document of documents){
+                const room = byRoom.get(document.locator);
+                if (room === undefined) continue;
+                room.documents[document.path] = document.content;
+                if (document.revision !== null) {
+                    room.revisions[document.path] = document.revision;
+                }
+            }
+            for (const target of targets){
+                const room = byRoom.get(target.locator);
+                if (room === undefined) continue;
+                room.binaryTargets.push(target.path);
+                if (target.revision !== null) {
+                    room.revisions[target.path] = target.revision;
+                }
+            }
+            return [
+                ...byRoom.values()
+            ];
+        },
+        async write ({ next, previous, queue, previousQueue, outcomes, consumedDrafts }) {
+            const transaction = database.transaction([
+                ROOMS,
+                DOCUMENTS,
+                BINARY_TARGETS,
+                PENDING_CHANGES,
+                OUTCOMES,
+                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]) continue;
+                documents.put({
+                    locator: next.locator,
+                    path,
+                    content,
+                    revision: next.revisions[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]) {
+                    targets.put({
+                        locator: next.locator,
+                        path,
+                        revision: next.revisions[path] ?? null
+                    });
+                }
+            }
+            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,
+                            submitted: 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(DRAFTS);
+            for (const path of consumedDrafts ?? [])draftStore.delete([
+                next.locator,
+                path
+            ]);
+            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 capabilities () {
-            const transaction = database.transaction(DISCOVERY, 'readonly');
-            const value = await settled(transaction.objectStore(DISCOVERY).get(CAPABILITIES));
-            return value ?? [];
+            return (await declaration(database)).capabilities;
         },
         async slots () {
-            const transaction = database.transaction(DISCOVERY, 'readonly');
-            const value = await settled(transaction.objectStore(DISCOVERY).get(SLOTS));
-            return value ?? [];
-        },
-        async declare (limits, capabilities, slots) {
-            const transaction = database.transaction(DISCOVERY, 'readwrite');
-            transaction.objectStore(DISCOVERY).put(limits, PROVIDER_LIMITS);
-            transaction.objectStore(DISCOVERY).put(capabilities, CAPABILITIES);
-            transaction.objectStore(DISCOVERY).put(slots, SLOTS);
-            await completed(transaction);
+            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.batch
+                ]));
+            return rooms.map((room)=>({
+                    locator: room.locator,
+                    batches: room.order.map((id)=>{
+                        const batch = byId.get(`${room.locator}\0${id}`);
+                        if (batch === undefined) throw new Error(`Missing Pending Change ${room.locator}/${id}`);
+                        return batch;
+                    })
+                }));
+        },
+        async outcomes () {
+            const transaction = database.transaction(OUTCOMES, 'readonly');
+            return settled(transaction.objectStore(OUTCOMES).getAll());
+        },
+        async markSubmitted (locator, id) {
+            const transaction = database.transaction(PENDING_CHANGES, 'readwrite');
+            const pending = transaction.objectStore(PENDING_CHANGES);
+            let marked = false;
+            const request = pending.get([
+                locator,
+                id
+            ]);
+            request.onsuccess = ()=>{
+                const record = request.result;
+                if (record !== undefined && !record.submitted) {
+                    pending.put({
+                        ...record,
+                        submitted: true
+                    });
+                    marked = true;
+                }
+            };
+            await completed(transaction);
+            return marked;
         },
         async drafts () {
             const transaction = database.transaction(DRAFTS, 'readonly');
@@ -128,31 +349,86 @@ export async function openRuntimeStore() {
             await completed(transaction);
         },
         async conversations () {
-            const transaction = database.transaction(CONVERSATIONS, 'readonly');
-            return settled(transaction.objectStore(CONVERSATIONS).getAll());
+            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 keepConversation (record) {
-            const transaction = database.transaction(CONVERSATIONS, 'readwrite');
-            transaction.objectStore(CONVERSATIONS).put(record);
+        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 dropConversation (conversation) {
-            const transaction = database.transaction(CONVERSATIONS, 'readwrite');
-            transaction.objectStore(CONVERSATIONS).delete(conversation);
+        async dropConversations (conversations) {
+            const transaction = database.transaction([
+                CONVERSATIONS,
+                MESSAGES,
+                CHAT_DRAFTS
+            ], 'readwrite');
+            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 instructions () {
-            const transaction = database.transaction(INSTRUCTIONS, 'readonly');
-            return settled(transaction.objectStore(INSTRUCTIONS).getAll());
+        async chatDrafts () {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readonly');
+            return settled(transaction.objectStore(CHAT_DRAFTS).getAll());
         },
-        async keepInstruction (record) {
-            const transaction = database.transaction(INSTRUCTIONS, 'readwrite');
-            transaction.objectStore(INSTRUCTIONS).put(record);
+        async keepChatDraft (record) {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).put(record);
             await completed(transaction);
         },
-        async dropInstruction (conversation) {
-            const transaction = database.transaction(INSTRUCTIONS, 'readwrite');
-            transaction.objectStore(INSTRUCTIONS).delete(conversation);
+        async dropChatDraft (conversation) {
+            const transaction = database.transaction(CHAT_DRAFTS, 'readwrite');
+            transaction.objectStore(CHAT_DRAFTS).delete(conversation);
             await completed(transaction);
         },
         async keep (draft) {
@@ -168,52 +444,41 @@ export async function openRuntimeStore() {
             ]);
             await completed(transaction);
         },
-        async append (queue, consumed) {
-            const transaction = database.transaction([
-                QUEUES,
-                DRAFTS
-            ], 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
-            const drafts = transaction.objectStore(DRAFTS);
-            for (const path of consumed)drafts.delete([
-                queue.locator,
-                path
-            ]);
-            await completed(transaction);
-        },
-        async writeQueue (queue) {
-            const transaction = database.transaction(QUEUES, 'readwrite');
-            transaction.objectStore(QUEUES).put(queue);
-            await completed(transaction);
-        },
         async dropRooms (locators) {
             const transaction = database.transaction([
-                REPLICAS,
-                QUEUES,
+                ROOMS,
+                DOCUMENTS,
+                BINARY_TARGETS,
+                PENDING_CHANGES,
+                OUTCOMES,
                 DRAFTS
             ], 'readwrite');
             for (const locator of locators){
-                transaction.objectStore(REPLICAS).delete(locator);
-                transaction.objectStore(QUEUES).delete(locator);
-            }
-            const drafts = transaction.objectStore(DRAFTS);
-            const keys = drafts.getAllKeys();
-            keys.onsuccess = ()=>{
-                for (const key of keys.result){
-                    if (locators.includes(key[0])) drafts.delete(key);
+                transaction.objectStore(ROOMS).delete(locator);
+                for (const name of [
+                    DOCUMENTS,
+                    BINARY_TARGETS,
+                    PENDING_CHANGES,
+                    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();