@agentshouse/mdruntime 0.1.0-c56daf494ecb4 → 0.1.0-c59a5a6bd2f31

package/dist/read-side.js

@@ -1,440 +0,0 @@
-import { and, BasicIndex, configureIndexDevMode, count, createCollection, createLiveQueryCollection, deepEquals, eq, inArray, or, toArray, } from '@tanstack/db';
-import { ARRAY_INDEX, pointerSegments } from '@agentshouse/mdmodel';
-import { rowsOf } from './observation.js';
-import { documentKey } from './rows.js';
-function every(expressions) {
-    const [first, second, ...rest] = expressions;
-    return second === undefined ? first : and(first, second, ...rest);
-}
-function same(held, value) {
-    return Array.isArray(held) ? held.includes(value) : held === value;
-}
-function ordered(held, [operator, bound]) {
-    if (typeof held !== typeof bound || held === null || typeof held === 'object')
-        return false;
-    const left = held;
-    const right = bound;
-    if (operator === 'gt')
-        return left > right;
-    if (operator === 'gte')
-        return left >= right;
-    if (operator === 'lt')
-        return left < right;
-    return left <= right;
-}
-function satisfied(test, held) {
-    if (test.op === 'eq')
-        return same(held, test.value);
-    if (test.op === 'ne')
-        return !same(held, test.value);
-    if (test.op === 'in')
-        return test.values.some((value) => same(held, value));
-    if (test.op === 'nin')
-        return !test.values.some((value) => same(held, value));
-    if (test.op === 'range')
-        return test.bounds.every((bound) => ordered(held, bound));
-    if (test.op === 'all')
-        return Array.isArray(held) && test.values.every((value) => same(held, value));
-    return Array.isArray(held) && held.length === test.size;
-}
-function tested(test, reached) {
-    if (test.op === 'exists')
-        return test.exists === (reached !== undefined);
-    if (reached === undefined)
-        return test.op === 'ne' || test.op === 'nin';
-    return reached.some((held) => satisfied(test, held));
-}
-function conditioned(condition, row) {
-    if ('every' in condition)
-        return condition.every.every((item) => conditioned(item, row));
-    if ('some' in condition)
-        return condition.some.some((item) => conditioned(item, row));
-    return tested(condition.test, row.reached[condition.field]);
-}
-function narrowed(query, where, alias) {
-    return where === null ? query : query.fn.where((row) => conditioned(where, row[alias]));
-}
-function reached(reach, room, document) {
-    return reach === null
-        ? []
-        : [or(inArray(room, [...reach.rooms]), inArray(document, [...reach.documents]))];
-}
-function scoped(scope, row, rooms, reach) {
-    return every([
-        eq(row.kind, 'document'),
-        ...(rooms === null ? [] : [inArray(row.room, [...rooms])]),
-        ...reached(reach, row.room, row.key),
-        ...(scope.types === null ? [] : [inArray(row.type, [...scope.types])]),
-        ...(scope.pathPrefix === null ? [] : [inArray(scope.pathPrefix, row.directories)]),
-    ]);
-}
-function keyed(key, row) {
-    return key.of === 'field' ? row.values[key.field] : row[key.of];
-}
-function live(query) {
-    return createLiveQueryCollection({
-        query: query,
-        startSync: true,
-    });
-}
-function related(q, rows, scope, field, kept, reach) {
-    const matched = kept === 'source' ? 'target' : 'source';
-    const from = q.from({ r: rows });
-    const joined = from
-        .where(({ r }) => every([eq(r.kind, 'reference'), ...(field === null ? [] : [inArray(field, r.forms)])]))
-        .innerJoin({ m: rows }, ({ r, m }) => eq(r[matched], m.key))
-        .where(({ m }) => scoped(scope, m, null, reach));
-    return narrowed(joined, scope.where, 'm')
-        .groupBy(({ r }) => r[kept])
-        .select(({ r }) => ({ key: r[kept] }));
-}
-function filtered(q, rows, plan) {
-    const from = q.from({ d: rows });
-    let query = narrowed(from.where(({ d }) => scoped(plan.root, d, plan.rooms, plan.reach)), plan.root.where, 'd');
-    if (plan.hop !== null) {
-        const hop = related(q, rows, plan.hop, plan.hop.field, 'source', plan.reach);
-        query = query.innerJoin({ h: hop }, ({ d, h }) => eq(d.key, h.key));
-    }
-    if (plan.backlinks !== null) {
-        const backlinks = related(q, rows, plan.backlinks, plan.backlinks.field, 'target', plan.reach);
-        query = query.innerJoin({ k: backlinks }, ({ d, k }) => eq(d.key, k.key));
-    }
-    return query;
-}
-function named(prefix, names, source) {
-    return Object.fromEntries(names.map((name, index) => [`${prefix}${index}`, source[name]]));
-}
-function documents(q, rows, plan, shape) {
-    let query = filtered(q, rows, plan);
-    if (shape.sections !== null || shape.preamble || shape.markdown) {
-        query = query.leftJoin({ b: rows }, ({ d, b }) => eq(d.body, b.key));
-    }
-    for (const { key, options } of shape.orderBy) {
-        query = query.orderBy(({ d }) => keyed(key, d), options);
-    }
-    if (shape.orderBy.length === 0 && plan.limit !== null) {
-        query = query.orderBy(({ d }) => d.key, { stringSort: 'lexical' });
-    }
-    if (plan.limit !== null)
-        query = query.limit(plan.limit);
-    return query.select(({ d, b }) => ({
-        room: d.room,
-        path: d.path,
-        type: d.type,
-        binary: d.binary,
-        ...(shape.fields === null ? {} : { fields: d.fields }),
-        ...(shape.sections === 'all' ? { sections: b.sections } : {}),
-        ...(Array.isArray(shape.sections) ? named('section', shape.sections, b.sections) : {}),
-        ...(shape.preamble ? { preamble: b.preamble } : {}),
-        ...(shape.markdown ? { markdown: b.markdown } : {}),
-        ...(shape.backlinks ? { backlinks: toArray(backlinked(q, rows, d, plan.reach)) } : {}),
-        ...(shape.change ? { change: d.change } : {}),
-    }));
-}
-function backlinked(q, rows, document, reach) {
-    const from = q.from({ r: rows });
-    return from
-        .where(({ r }) => every([eq(r.target, document.key), ...reached(reach, r.room, r.source)]))
-        .orderBy(({ r }) => r.path, { stringSort: 'lexical' })
-        .orderBy(({ r }) => r.field, { stringSort: 'lexical' })
-        .select(({ r }) => ({ path: r.path, type: r.type, field: r.field }));
-}
-function groups(q, stage, shape, limit) {
-    const keys = shape.groupBy.map((_, index) => `key${index}`);
-    const from = q.from({ m: stage });
-    let query = from.groupBy(({ m }) => keys.map((key) => m[key]));
-    for (const { by, direction } of shape.orderBy) {
-        query = query.orderBy(({ m }) => (by === 'count' ? count(m.key) : m[keys[by]]), direction);
-    }
-    if (limit !== null && shape.orderBy.length > 0)
-        query = query.limit(limit);
-    return query.select(({ m }) => ({
-        ...Object.fromEntries(keys.map((key) => [key, m[key]])),
-        count: count(m.key),
-    }));
-}
-function built(rows, plan) {
-    const shape = plan.shape;
-    if (shape.kind === 'documents') {
-        const collection = live((q) => documents(q, rows, plan, shape));
-        return { live: collection, dispose: () => void collection.cleanup() };
-    }
-    const stage = live((q) => filtered(q, rows, plan).select(({ d }) => ({
-        key: d.key,
-        ...Object.fromEntries(shape.groupBy.map((key, index) => [`key${index}`, keyed(key, d)])),
-    })));
-    const collection = live((q) => groups(q, stage, shape, plan.limit));
-    return {
-        live: collection,
-        dispose: () => {
-            void collection.cleanup();
-            void stage.cleanup();
-        },
-    };
-}
-function present(entries) {
-    return Object.fromEntries(entries.filter(([, value]) => value !== undefined));
-}
-function part(row, prefix, names, whole) {
-    if (names === 'all')
-        return whole;
-    return present(names.map((name, index) => [name, row[`${prefix}${index}`]]));
-}
-function masked(pointers) {
-    const root = { whole: false, members: new Map() };
-    for (const pointer of pointers) {
-        let mask = root;
-        for (const token of pointerSegments(pointer)) {
-            const next = mask.members.get(token) ?? { whole: false, members: new Map() };
-            mask.members.set(token, next);
-            mask = next;
-        }
-        mask.whole = true;
-    }
-    return root;
-}
-function merged(left, right) {
-    if (left === undefined)
-        return right;
-    const members = new Map(left.members);
-    for (const [token, mask] of right.members)
-        members.set(token, merged(members.get(token), mask));
-    return { whole: left.whole || right.whole, members };
-}
-function cut(value, mask) {
-    if (mask.whole)
-        return value;
-    if (Array.isArray(value)) {
-        const each = {
-            whole: false,
-            members: new Map([...mask.members].filter(([token]) => !ARRAY_INDEX.test(token))),
-        };
-        const kept = [];
-        value.forEach((item, index) => {
-            const part = cut(item, merged(mask.members.get(String(index)), each));
-            if (part !== undefined)
-                kept[index] = part;
-        });
-        return kept.length === 0 ? undefined : kept;
-    }
-    if (typeof value !== 'object' || value === null)
-        return undefined;
-    const kept = Object.entries(value).flatMap(([key, held]) => {
-        const member = mask.members.get(key);
-        const part = member === undefined ? undefined : cut(held, member);
-        return part === undefined ? [] : [[key, part]];
-    });
-    return kept.length === 0 ? undefined : Object.fromEntries(kept);
-}
-function selected(fields, pointers) {
-    return (cut(fields, masked(pointers)) ?? {});
-}
-function documentOf(row, shape) {
-    if (row.type === null) {
-        const binary = row.binary;
-        return {
-            room: row.room,
-            path: row.path,
-            ...(binary === null ? {} : { binaryFile: binary }),
-        };
-    }
-    return {
-        room: row.room,
-        path: row.path,
-        type: row.type,
-        ...(shape.fields === null
-            ? {}
-            : {
-                fields: shape.fields === 'all'
-                    ? row.fields
-                    : selected(row.fields, shape.fields),
-            }),
-        ...(shape.sections === null
-            ? {}
-            : {
-                sections: part(row, 'section', shape.sections, row.sections),
-            }),
-        ...(shape.preamble ? { preamble: row.preamble } : {}),
-        ...(shape.markdown ? { markdown: row.markdown } : {}),
-        ...(shape.backlinks
-            ? {
-                backlinks: row.backlinks.map(({ path, type, field }) => ({ path, type, field })),
-            }
-            : {}),
-        ...(shape.change ? { change: row.change } : {}),
-    };
-}
-function keyedOf(plan, entries) {
-    const shape = plan.shape;
-    if (shape.kind === 'documents') {
-        return {
-            result: structuredClone({ documents: entries.map(([, row]) => documentOf(row, shape)) }),
-            keys: entries.map(([key]) => key),
-        };
-    }
-    const bounded = shape.orderBy.length === 0 && plan.limit !== null ? entries.slice(0, plan.limit) : entries;
-    return {
-        result: structuredClone({
-            groups: bounded.map(([, row]) => ({
-                key: shape.groupBy.map((_, index) => row[`key${index}`]),
-                count: row.count,
-            })),
-        }),
-        keys: bounded.map(([key]) => key),
-    };
-}
-export function reconciled(previous, next) {
-    const before = rowsOf(previous.result);
-    const held = new Map(previous.keys.map((key, index) => [key, before[index]]));
-    const changed = [];
-    const rows = rowsOf(next.result).map((row, index) => {
-        const key = next.keys[index];
-        const kept = held.get(key);
-        if (kept !== undefined && deepEquals(kept, row))
-            return kept;
-        changed.push([key, row]);
-        return row;
-    });
-    const present = new Set(next.keys);
-    const survivors = previous.keys.filter((key) => present.has(key));
-    const removed = previous.keys.filter((key) => !present.has(key));
-    const moved = survivors.length !== next.keys.length ||
-        survivors.some((key, index) => key !== next.keys[index]);
-    if (changed.length === 0 && removed.length === 0 && !moved)
-        return null;
-    return {
-        keyed: {
-            result: 'groups' in next.result
-                ? { groups: rows }
-                : { documents: rows },
-            keys: next.keys,
-        },
-        change: { changed, removed, order: moved ? next.keys : null },
-    };
-}
-export function createReadSide() {
-    configureIndexDevMode({ enabled: false });
-    let sync;
-    const rows = createCollection({
-        getKey: (row) => row.key,
-        gcTime: 0,
-        startSync: true,
-        autoIndex: 'eager',
-        defaultIndexType: BasicIndex,
-        sync: {
-            rowUpdateMode: 'full',
-            sync: (params) => {
-                sync = params;
-                params.markReady();
-            },
-        },
-    });
-    const shared = new Map();
-    function searched(row) {
-        const body = rows.get(row.body);
-        return {
-            room: row.room,
-            path: row.path,
-            type: row.type,
-            fields: row.fields,
-            preamble: body.preamble,
-            sections: body.sections,
-        };
-    }
-    function publish(entry) {
-        const next = reconciled(entry.result, keyedOf(entry.plan, [...entry.built.live.entries()]));
-        if (next === null)
-            return;
-        entry.result = next.keyed;
-        for (const listener of entry.listeners)
-            listener(next.change);
-    }
-    return {
-        apply(set) {
-            const next = new Map();
-            for (const change of set.documents) {
-                for (const row of change.before)
-                    next.set(row.key, null);
-                for (const row of change.after)
-                    next.set(row.key, row);
-            }
-            if (next.size === 0)
-                return;
-            sync.begin();
-            for (const [key, row] of next) {
-                if (row === null) {
-                    if (rows.has(key))
-                        sync.write({ type: 'delete', key });
-                    continue;
-                }
-                sync.write({ type: rows.has(key) ? 'update' : 'insert', value: row });
-            }
-            sync.commit();
-        },
-        async query(plan) {
-            const { live: collection, dispose } = built(rows, plan);
-            try {
-                await collection.toArrayWhenReady();
-                return keyedOf(plan, [...collection.entries()]).result;
-            }
-            finally {
-                dispose();
-            }
-        },
-        watch(plan, identity, deliver) {
-            let entry = shared.get(identity);
-            if (entry === undefined) {
-                const created = {
-                    plan,
-                    built: built(rows, plan),
-                    result: undefined,
-                    listeners: new Set(),
-                    subscription: null,
-                };
-                created.built.live.on('status:change', ({ status }) => {
-                    if (status === 'cleaned-up' && created.listeners.size === 0)
-                        shared.delete(identity);
-                });
-                shared.set(identity, created);
-                entry = created;
-            }
-            const observed = entry;
-            observed.listeners.add(deliver);
-            observed.built.live.onFirstReady(() => {
-                if (!observed.listeners.has(deliver))
-                    return;
-                if (observed.subscription === null) {
-                    observed.result = keyedOf(observed.plan, [...observed.built.live.entries()]);
-                    observed.subscription = observed.built.live.subscribeChanges(() => {
-                        publish(observed);
-                    }, { includeInitialState: false });
-                }
-                deliver(observed.result);
-            });
-            return () => {
-                if (!observed.listeners.delete(deliver) || observed.listeners.size > 0)
-                    return;
-                observed.subscription?.unsubscribe();
-                observed.subscription = null;
-            };
-        },
-        documents() {
-            return rows.toArray
-                .filter((row) => row.kind === 'document' && row.type !== null)
-                .map(searched);
-        },
-        document(room, path) {
-            const row = rows.get(documentKey(room, path));
-            return row === undefined || row.type === null ? null : searched(row);
-        },
-        close() {
-            for (const entry of shared.values()) {
-                entry.listeners.clear();
-                entry.subscription?.unsubscribe();
-                entry.built.dispose();
-            }
-            shared.clear();
-            void rows.cleanup();
-        },
-    };
-}