@agentshouse/mdruntime 0.1.0-cb1f56e16291b → 0.1.0-cb3bb3b233fa1

package/dist/store.js

@@ -1,405 +1,181 @@
-import { composedOf } from './collection.js';
-import { binaryLocalId } from './identity.js';
-const FILE = '\u0000file';
-function batchFiles(batch) {
-    return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
-}
-function draftFiles(drafts) {
-    return drafts.flatMap(({ parts }) => (parts.file === undefined ? [] : [parts.file.localId]));
-}
-function roomDraftRow(record) {
-    return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
-}
-function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts }, held) {
-    return {
-        locator,
-        ...(queue === undefined
-            ? {}
-            : {
-                order: queue.map(({ id }) => id),
-                added: queue
-                    .filter(({ id }) => held?.has(id) !== true)
-                    .map((batch) => {
-                    const drafts = saved?.get(batch.id) ?? [];
-                    return {
-                        id: batch.id,
-                        batch: JSON.stringify(batch),
-                        state: JSON.stringify({
-                            drafts,
-                            submission: { state: 'waiting' },
-                            lost: false,
-                        }),
-                        files: [...batchFiles(batch), ...draftFiles(drafts)],
-                    };
-                }),
-            }),
-        ...(founded === undefined
-            ? {}
-            : {
-                founded: founded.map((batch) => ({
-                    id: batch.id,
-                    batch: JSON.stringify(batch),
-                    files: batchFiles(batch),
-                })),
-            }),
-        ...(roomDrafts === undefined ? {} : { roomDrafts: roomDrafts.map(roomDraftRow) }),
-        ...(consumedRoomDrafts === undefined ? {} : { consumedRoomDrafts }),
-    };
-}
-function marked(value) {
-    return typeof value === 'object' && value !== null && FILE in value;
-}
-function keyed(keys, value) {
-    const stored = [];
-    const files = [];
-    const record = JSON.stringify(value, (_name, held) => {
-        if (!(held instanceof Blob))
-            return held;
-        let key = keys.get(held);
-        if (key === undefined) {
-            key = binaryLocalId();
-            keys.set(held, key);
-        }
-        stored.push({ key, blob: held });
-        files.push(key);
-        return { [FILE]: key, type: held.type };
+import { schemaTypes } from './attached-model.js';
+import { createCell } from './cell.js';
+import { openedFiles } from './opened.js';
+import { compositionOf } from './replica.js';
+import { STARTING } from './status.js';
+import { createInstalls, NO_INSTALL } from './store/installs.js';
+import { openRuntimeStore, } from './store/records.js';
+import { createReadinessQueue } from './store/readiness.js';
+import { createRoomHeld } from './store/room-held.js';
+import { createRoomsShown } from './store/rooms-shown.js';
+import { createSpace } from './store/space.js';
+import { createWatchers } from './store/watchers.js';
+import { createWrites } from './store/writes.js';
+const OPENING = 'store';
+export function createStore(options) {
+    const writes = createWrites();
+    const watchers = createWatchers(options.unpublished);
+    const { lost } = options;
+    const installs = createInstalls();
+    const seeds = new Map();
+    const conflicted = createRoomHeld();
+    const attached = createRoomHeld();
+    const typesHeld = new Map();
+    const device = createCell({
+        persistence: options.persistence,
+        storageLoss: null,
+        heldWhenOpened: false,
+        preparing: false,
+        sweeping: false,
+        unpreparedDemand: new Set(),
+        unpreparable: new Set(),
+        establishing: new Set(),
+        status: STARTING,
     });
-    return { record, files, stored };
-}
-async function filed(value, read) {
-    if (Array.isArray(value))
-        return Promise.all(value.map((item) => filed(item, read)));
-    if (marked(value))
-        return read(value[FILE], value.type);
-    if (typeof value !== 'object' || value === null)
-        return value;
-    const restored = {};
-    for (const [name, item] of Object.entries(value))
-        restored[name] = await filed(item, read);
-    return restored;
-}
-function json(value, fallback) {
-    return value === undefined ? fallback : JSON.parse(value);
-}
-export function openRuntimeStore(fenced, authored) {
-    const keys = new WeakMap();
-    const read = async (key, type) => {
-        const blob = await authored.ask({ kind: 'authored.file', key, type });
-        keys.set(blob, key);
-        return blob;
-    };
-    const restored = async (records) => Promise.all(records.map(async (record) => (await filed(JSON.parse(record), read))));
-    const amend = async (locator, id, amendment) => {
-        if (fenced(locator))
-            return;
-        await authored.ask({
-            kind: 'authored.amend',
-            locator,
-            id,
-            amendment: JSON.stringify(amendment),
+    const space = createSpace(options.database, options.spaceFreed);
+    const readiness = createReadinessQueue(options.deliverReadiness, options.unpublished);
+    let opening;
+    function open() {
+        opening ??= options.opening(openRuntimeStore(options.database)).then((opened) => {
+            options.retries.succeeded('database', OPENING);
+            return opened;
+        }, (error) => {
+            opening = undefined;
+            options.retries.failed('database', OPENING, error);
+            throw error;
         });
-    };
-    const fact = (name) => authored.ask({ kind: 'authored.fact', name });
-    const queued = new Map();
-    const changed = new Map();
-    const change = (key) => changed.set(key, (changed.get(key) ?? 0) + 1);
-    const rows = (writes) => writes.map((write) => authoredRows(write, queued.get(write.locator)));
-    const noted = (writes) => {
-        for (const { locator, queue } of writes) {
-            if (queue !== undefined)
-                queued.set(locator, new Set(queue.map(({ id }) => id)));
-        }
-    };
+        return opening;
+    }
+    function prepareAgain(locator) {
+        const { unpreparable } = device.now();
+        device.set({
+            unpreparable: locator === undefined
+                ? new Set()
+                : new Set([...unpreparable].filter((held) => held !== locator)),
+        });
+    }
+    function typed(locator, persisted) {
+        if (persisted.status === 'unavailable')
+            return persisted;
+        const schema = persisted.snapshot.schema;
+        const held = typesHeld.get(locator);
+        if (held !== undefined && held.schema === schema)
+            return { ...persisted, types: held.types };
+        const types = schemaTypes(schema, options.roomTypes);
+        typesHeld.set(locator, { schema, types });
+        return { ...persisted, types };
+    }
+    function recordOf(stored) {
+        return { ...stored, model: typed(stored.locator, stored.model) };
+    }
+    async function rooms(locators) {
+        const held = await (await open()).rooms(locators);
+        return new Map(held
+            .filter(({ record }) => !lost(record.locator))
+            .map(({ record, indexed, documents }) => [
+            record.locator,
+            { record: recordOf(record), indexed, documents },
+        ]));
+    }
+    async function work(locator) {
+        if (lost(locator))
+            return { replica: undefined, queue: [], states: new Map() };
+        const { room, queue } = await (await open()).room(locator);
+        const batches = queue.map(({ batch }) => batch);
+        const states = new Map(queue.map(({ batch, state }) => [batch.id, state]));
+        return {
+            replica: room === null
+                ? undefined
+                : { record: recordOf(room.record), queue: batches, states, overlaid: room.overlaid },
+            queue: batches,
+            states,
+        };
+    }
+    async function drafts(locator, paths) {
+        const held = await (await open()).roomDrafts(locator, paths);
+        return held.filter((record) => !lost(record.locator));
+    }
     return {
-        async opened() {
-            const held = await authored.ask({ kind: 'replica.open' });
-            const unindexed = new Set(held.keys.flatMap(({ key, rederiving }) => (rederiving === null ? [] : [key])));
-            const overlaid = new Map();
-            for (const { key, path } of held.overlaid) {
-                const paths = overlaid.get(key) ?? new Set();
-                paths.add(path);
-                overlaid.set(key, paths);
-            }
+        device,
+        roomsShown: createRoomsShown(),
+        space,
+        readiness,
+        ask: options.database.ask,
+        changed: options.changed,
+        open,
+        durably: (work) => writes.exclusive(async () => {
+            const local = await open();
+            return work(local);
+        }),
+        exclusive: writes.exclusive,
+        gathered: writes.gathered,
+        written: writes.written,
+        startingWrite: writes.startingWrite,
+        finishingWrite: writes.finishingWrite,
+        ahead: writes.ahead,
+        rederive: writes.rederive,
+        refreshPage: writes.refreshPage,
+        stageBytes: writes.stageBytes,
+        deriveBytes: writes.deriveBytes,
+        rooms,
+        record: async (locator) => (await rooms([locator])).get(locator)?.record,
+        work,
+        replica: async (locator) => (await work(locator)).replica,
+        async covering() {
+            const held = await (await open()).covering();
+            if (!options.losing())
+                return held;
             return {
-                rooms: new Map(held.rooms
-                    .filter(({ locator }) => !fenced(locator))
-                    .map(({ locator, key, record }) => [
-                    locator,
-                    { ...JSON.parse(record), key },
-                ])),
-                unindexed,
-                overlaid,
-                erasing: held.erasing.length > 0,
-                orphans: held.orphans,
-                lastCompleted: json(held.facts.lastCompleted, null),
-                providerLimits: json(held.facts.providerLimits, []),
-                capabilities: json(held.facts.capabilities, []),
-                member: json(held.facts.member, null),
-                targets: json(held.facts.targets, {}),
-                presentation: held.presentation.map(({ app, value }) => ({
-                    app,
-                    value: JSON.parse(value),
-                })),
-                conversationList: json(held.facts.conversationList, null),
-                conversationCursor: json(held.facts.conversationCursor, null),
+                rooms: new Map([...held.rooms].filter(([locator]) => !lost(locator))),
+                locking: new Set([...held.locking].filter((locator) => !lost(locator))),
+                queues: new Map([...held.queues].filter(([locator]) => !lost(locator))),
             };
         },
-        counts(rooms) {
-            return authored.ask({ kind: 'replica.counts', rooms });
-        },
-        query(plan, rooms, budget) {
-            return authored.ask({ kind: 'replica.query', plan, rooms, budget });
-        },
-        changes(keys) {
-            return keys.reduce((total, key) => total + (changed.get(key) ?? 0), 0);
-        },
-        entries(key, view, paths) {
-            return authored.ask({ kind: 'replica.entries', key, view, paths });
-        },
-        typed(key, view, paths) {
-            return authored.ask({ kind: 'replica.typed', key, view, paths });
-        },
-        referrers(key, view, targets, kinds) {
-            return authored.ask({ kind: 'replica.referrers', key, view, targets, kinds });
-        },
-        files(key, view, after, limit) {
-            return authored.ask({ kind: 'replica.files', key, view, after, limit });
-        },
-        folders(key, view, paths) {
-            return authored.ask({ kind: 'replica.folders', key, view, paths });
-        },
-        typedWithin(key, view, roots, within) {
-            return authored.ask({ kind: 'replica.typedWithin', key, view, roots, within });
-        },
-        async stage(record, composition, page) {
-            if (fenced(record.locator))
-                return null;
-            return authored.ask({
-                kind: 'replica.stage',
-                locator: record.locator,
-                transfer: record.transfer,
-                key: record.key,
-                fingerprint: composedOf(composition).fingerprint,
-                entries: page.entries,
-                folders: page.folders,
-            });
-        },
-        async refresh(key, composition, page) {
-            await authored.ask({
-                kind: 'replica.refresh',
-                key,
-                composed: composedOf(composition),
-                entries: page.entries,
-                removals: page.removals,
-                folders: page.folders,
-                folderRemovals: page.folderRemovals,
-            });
-        },
-        async unrefresh(key) {
-            await authored.ask({ kind: 'replica.unrefresh', key });
-        },
-        async hold(locator, key, composition, texts) {
-            if (fenced(locator))
-                return [];
-            change(key);
-            return authored.ask({
-                kind: 'replica.hold',
-                key,
-                locator,
-                composed: composedOf(composition),
-                texts,
-            });
-        },
-        async unhold(locator, key, composition) {
-            if (fenced(locator))
-                return { paths: [], bytes: 0 };
-            change(key);
-            return authored.ask({
-                kind: 'replica.unhold',
-                key,
-                locator,
-                composed: composedOf(composition),
-            });
-        },
-        async wanted(locator, key) {
-            if (fenced(locator))
-                return [];
-            return authored.ask({ kind: 'replica.wanted', key, locator });
-        },
-        async remember(locator, key, paths) {
-            if (fenced(locator) || paths.length === 0)
-                return;
-            await authored.ask({ kind: 'replica.remember', key, locator, paths });
-        },
-        async commit({ rooms, writes = [], files = [], whole = false, discards = [] }) {
-            const kept = whole ? writes : writes.filter(({ locator }) => !fenced(locator));
-            const refused = whole ? kept.find(({ locator }) => fenced(locator)) : undefined;
-            if (refused !== undefined) {
-                return { fenced: refused.locator, counts: {}, changed: {}, indexed: {} };
-            }
-            for (const room of rooms)
-                change(room.key);
-            const committed = await authored.ask({
-                kind: 'replica.commit',
-                ...(kept.length === 0 && files.length === 0 && discards.length === 0
-                    ? {}
-                    : { authored: { writes: rows(kept), files, whole, discards } }),
-                rooms: rooms.filter(({ locator }) => !fenced(locator)),
-            });
-            if (committed.fenced === null || !whole)
-                noted(kept);
-            for (const locator of discards)
-                queued.delete(locator);
-            return committed;
-        },
-        async fence(locators) {
-            await authored.ask({ kind: 'replica.fence', locators });
-            for (const locator of locators)
-                queued.delete(locator);
-        },
-        async erase(locator, limit) {
-            return (await authored.ask({ kind: 'replica.erase', locator, limit })).remaining;
-        },
-        async abandon(locator) {
-            if (fenced(locator))
-                return;
-            await authored.ask({ kind: 'replica.abandon', locator });
-        },
-        async release(key) {
-            await authored.ask({ kind: 'replica.release', key });
-        },
-        async rederive(key, composition, bytes, ms, floor) {
-            change(key);
-            return authored.ask({
-                kind: 'replica.rederive',
-                key,
-                composed: composedOf(composition),
-                bytes,
-                ms,
-                floor,
-            });
-        },
-        async fact(name, value) {
-            await authored.ask({ kind: 'replica.fact', name, value: JSON.stringify(value) });
-        },
-        async queues() {
-            const { queues, pending } = await authored.ask({ kind: 'authored.queues' });
-            queued.clear();
-            for (const queue of queues)
-                queued.set(queue.locator, new Set(queue.ids));
-            const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
-            return queues
-                .filter((queue) => !fenced(queue.locator))
-                .map((queue) => ({
-                locator: queue.locator,
-                pending: queue.ids.map((id) => {
-                    const record = byId.get(`${queue.locator}\0${id}`);
-                    if (record === undefined)
-                        throw new Error(`Missing Pending Change ${queue.locator}/${id}`);
-                    return {
-                        batch: JSON.parse(record.batch),
-                        state: JSON.parse(record.state),
-                    };
-                }),
-            }));
-        },
-        submit(locator, id, submission, lost) {
-            return amend(locator, id, { submission, lost });
-        },
-        keepUpload(locator, id, upload) {
-            return amend(locator, id, { upload });
-        },
-        async roomDrafts() {
-            const held = await authored.ask({ kind: 'authored.roomDrafts' });
-            return held
-                .map((record) => JSON.parse(record))
-                .filter((record) => !fenced(record.locator));
-        },
-        async present(record) {
-            await authored.ask({
-                kind: 'replica.present',
-                app: record.app,
-                value: JSON.stringify(record.value ?? null),
-            });
-        },
-        conversations() {
-            return authored.ask({ kind: 'conversation.held' });
-        },
-        async keepMessages(write) {
-            await authored.ask({ kind: 'conversation.keep', ...write });
-        },
-        messageWindow(conversation, limit, before, phrase = null) {
-            return authored.ask({ kind: 'conversation.window', conversation, limit, before, phrase });
-        },
-        messageCount(conversation, phrase = null) {
-            return authored.ask({ kind: 'conversation.count', conversation, phrase });
-        },
-        turnArrived(conversation, turn) {
-            return authored.ask({ kind: 'conversation.turn', conversation, turn });
-        },
-        async dropConversations(conversations) {
-            await authored.ask({ kind: 'conversation.drop', conversations });
-        },
-        async chatDrafts() {
-            const records = await authored.ask({ kind: 'authored.chatDrafts' });
-            return records.map((record) => JSON.parse(record));
-        },
-        async keepChatDrafts(records) {
-            await authored.ask({
-                kind: 'authored.chatDraft',
-                kept: records.map((record) => ({
-                    conversation: record.conversation,
-                    record: JSON.stringify(record),
-                })),
-                dropped: [],
-            });
-        },
-        async dropChatDraft(conversation) {
-            await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: [conversation] });
-        },
-        async calls() {
-            return restored(await authored.ask({ kind: 'authored.calls' }));
-        },
-        async keepCall(record) {
-            const { stored, ...kept } = keyed(keys, record);
-            await authored.ask({
-                kind: 'authored.call',
-                operation: record.operation,
-                kept,
-                files: stored,
-            });
-        },
-        async dropCall(operation) {
-            await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
-        },
-        async keepRoomDraft(record, files) {
-            if (fenced(record.locator))
-                return;
-            const { path, ...kept } = roomDraftRow(record);
-            await authored.ask({
-                kind: 'authored.roomDraft',
-                locator: record.locator,
-                path,
-                kept,
-                files,
-            });
-        },
-        async discardRoomDraft(locator, path) {
-            if (fenced(locator))
-                return;
-            await authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
-        },
-        fences() {
-            return authored.ask({ kind: 'authored.fences' });
-        },
-        generation() {
-            return fact('generation');
-        },
-        async rememberGeneration(value) {
-            await authored.ask({ kind: 'authored.remember', name: 'generation', value });
+        async status() {
+            const held = await (await open()).status();
+            return {
+                queued: held.queued.filter((locator) => !lost(locator)),
+                lastCompleted: held.lastCompleted,
+                unsent: held.unsent.filter(({ room }) => !lost(room)),
+                resets: held.resets.filter(({ locator }) => !lost(locator)),
+                returned: held.returned.filter(({ locator }) => !lost(locator)),
+            };
         },
-        file(key, type) {
-            return authored.ask({ kind: 'authored.file', key, type });
+        queued: async () => (await (await open()).queued()).filter((locator) => !lost(locator)),
+        drafts,
+        draft: async (locator, path) => (await drafts(locator, [path]))[0],
+        composed: ({ model, declaration }) => compositionOf(model, declaration.typedSelection, options.builtIn, options.typedPaths),
+        publication: watchers.publication,
+        owing: watchers.owing,
+        watch: watchers.watch,
+        watching: watchers.watching,
+        tell: watchers.tell,
+        installs,
+        seeds: {
+            of: (key) => seeds.get(key),
+            keep(key, seed) {
+                seeds.set(key, seed);
+            },
+            drop(key) {
+                seeds.delete(key);
+            },
+        },
+        conflicted,
+        attached,
+        opened: openedFiles(options.database, lost),
+        prepareAgain,
+        part: (file, part) => options.database.ask({ kind: 'file.part', key: file, part }),
+        forget(locator) {
+            typesHeld.delete(locator);
+            conflicted.forget(locator);
+            attached.forget(locator);
+            installs.change(locator, ({ installing }) => ({ ...NO_INSTALL, installing }));
+            prepareAgain(locator);
+        },
+        close() {
+            space.stop();
+            readiness.close();
+            watchers.close();
         },
     };
 }