cojson 0.4.0 → 0.4.5

package/src/queries.ts

@@ -1,263 +0,0 @@
-import { JsonValue } from "./jsonValue.js";
-import { CoMap } from "./coValues/coMap.js";
-import { CoStream } from "./coValues/coStream.js";
-import { CoList } from "./coValues/coList.js";
-import { Account, AccountID } from "./coValues/account.js";
-import { CoID, CoValue } from "./coValue.js";
-import { LocalNode } from "./localNode.js";
-import {
-    QueriedCoMap,
-    QueriedCoMapBase,
-} from "./queriedCoValues/queriedCoMap.js";
-import { QueriedCoList } from "./queriedCoValues/queriedCoList.js";
-import { QueriedCoStream } from "./queriedCoValues/queriedCoStream.js";
-import { Group } from "./coValues/group.js";
-import { QueriedAccount } from "./queriedCoValues/queriedAccount.js";
-import { QueriedGroup } from "./queriedCoValues/queriedGroup.js";
-
-export type Queried<T extends CoValue> = T extends CoMap
-    ? T extends Account
-        ? QueriedAccount<T>
-        : T extends Group
-        ? QueriedGroup<T>
-        : QueriedCoMap<T>
-    : T extends CoList
-    ? QueriedCoList<T>
-    : T extends CoStream
-    ? T["meta"] extends { type: "binary" }
-        ? never
-        : QueriedCoStream<T>
-    :
-          | QueriedAccount
-          | QueriedGroup
-          | QueriedCoMap<CoMap>
-          | QueriedCoList<CoList>
-          | QueriedCoStream<CoStream>;
-
-export type ValueOrSubQueried<
-    V extends JsonValue | CoValue | CoID<CoValue> | undefined
-> = V extends CoID<infer C>
-    ? Queried<C> | undefined
-    : V extends CoValue
-    ? Queried<V> | undefined
-    : V;
-
-export interface CleanupCallbackAndUsable {
-    (): void;
-    [Symbol.dispose]: () => void;
-}
-
-export interface QueryExtension<T extends CoValue, O> {
-    id: string;
-    query(
-        base: T,
-        queryContext: QueryContext,
-        onUpdate: (value: O) => void
-    ): () => void;
-}
-
-export class QueryContext {
-    values: {
-        [id: CoID<CoValue>]: {
-            lastUpdate: CoValue | undefined;
-            lastQueried: Queried<CoValue> | undefined;
-            render: () => void;
-            unsubscribe: () => void;
-        };
-    } = {};
-    extensions: {
-        [id: `${CoID<CoValue>}_${string}`]: {
-            lastOutput: unknown;
-            unsubscribe: () => void;
-        };
-    } = {};
-    node: LocalNode;
-    onUpdate: () => void;
-
-    constructor(node: LocalNode, onUpdate: () => void) {
-        this.node = node;
-        this.onUpdate = onUpdate;
-    }
-
-    query<T extends CoValue>(valueID: CoID<T>, alsoRender: CoID<CoValue>[]) {
-        let value = this.values[valueID];
-        if (!value) {
-            const render = () => {
-                let newQueried;
-                const lastUpdate = value!.lastUpdate;
-
-                if (lastUpdate instanceof CoMap) {
-                    if (lastUpdate instanceof Account) {
-                        newQueried = new QueriedAccount(
-                            lastUpdate,
-                            this
-                        ) as Queried<T>;
-                    } else if (lastUpdate instanceof Group) {
-                        newQueried = new QueriedGroup(
-                            lastUpdate,
-                            this
-                        ) as Queried<T>;
-                    } else {
-                        newQueried = QueriedCoMapBase.newWithKVPairs(
-                            lastUpdate,
-                            this
-                        ) as Queried<T>;
-                    }
-                } else if (lastUpdate instanceof CoList) {
-                    newQueried = new QueriedCoList(
-                        lastUpdate,
-                        this
-                    ) as Queried<T>;
-                } else if (lastUpdate instanceof CoStream) {
-                    if (lastUpdate.meta?.type === "binary") {
-                        // Querying binary string not yet implemented
-                    } else {
-                        newQueried = new QueriedCoStream(
-                            lastUpdate,
-                            this
-                        ) as Queried<T>;
-                    }
-                }
-
-                // console.log(
-                //     "Rendered ",
-                //     valueID,
-                //     lastUpdate?.constructor.name,
-                //     newQueried
-                // );
-
-                value!.lastQueried = newQueried;
-
-                for (const alsoRenderID of alsoRender) {
-                    // console.log("Also rendering", alsoRenderID);
-                    this.values[alsoRenderID]?.render();
-                }
-            };
-
-            value = {
-                lastQueried: undefined,
-                lastUpdate: undefined,
-                render,
-                unsubscribe: this.node.subscribe(valueID, (valueUpdate) => {
-                    value!.lastUpdate = valueUpdate;
-                    value!.render();
-                    this.onUpdate();
-                }),
-            };
-            this.values[valueID] = value;
-        }
-        return value.lastQueried as Queried<T> | undefined;
-    }
-
-    queryIfCoID<T extends JsonValue | undefined>(value: T, alsoRender: CoID<CoValue>[]): T extends CoID<infer C> ? Queried<C> | undefined : T {
-        if (typeof value === "string" && value.startsWith("co_")) {
-            return this.query(value as CoID<CoValue>, alsoRender) as T extends CoID<infer C> ? Queried<C> | undefined : never;
-        } else {
-            return value as T extends CoID<infer C> ? Queried<C> | undefined : T;
-        }
-    }
-
-    valueOrSubQueryPropertyDescriptor<T extends JsonValue | undefined>(
-        value: T,
-        alsoRender: CoID<CoValue>[]
-    ): T extends CoID<infer C>
-        ? { get(): Queried<C> | undefined }
-        : { value: T } {
-        if (typeof value === "string" && value.startsWith("co_")) {
-            // TODO: when we track render dirty status, we can actually return the queried value without a getter if it's up to date
-            return {
-                get: () => this.query(value as CoID<CoValue>, alsoRender),
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            } as any;
-        } else {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return { value: value } as any;
-        }
-    }
-
-    defineSubqueryPropertiesIn<
-        O extends object,
-        P extends {
-            [key: string]: { value: JsonValue | undefined; enumerable: boolean };
-        }
-    >(
-        obj: O,
-        subqueryProps: P,
-        alsoRender: CoID<CoValue>[]
-    ): O & {
-        [Key in keyof P]: ValueOrSubQueried<P[Key]["value"]>;
-    } {
-        for (const [key, descriptor] of Object.entries(subqueryProps)) {
-            Object.defineProperty(
-                obj,
-                key,
-                {
-                    ...this.valueOrSubQueryPropertyDescriptor(descriptor.value, alsoRender),
-                    enumerable: descriptor.enumerable,
-                }
-            );
-        }
-        return obj as O & {
-            [Key in keyof P]: ValueOrSubQueried<P[Key]["value"]>
-        };
-    }
-
-    getOrCreateExtension<T extends CoValue, O>(
-        valueID: CoID<T>,
-        extension: QueryExtension<T, O>
-    ): O | undefined {
-        const id = `${valueID}_${extension.id}`;
-        let ext = this.extensions[id as keyof typeof this.extensions];
-        if (!ext) {
-            ext = {
-                lastOutput: undefined,
-                unsubscribe: extension.query(
-                    this.node
-                        .expectCoValueLoaded(valueID)
-                        .getCurrentContent() as T,
-                    this,
-                    (output) => {
-                        ext!.lastOutput = output;
-                        this.values[valueID]?.render();
-                        this.onUpdate();
-                    }
-                ),
-            };
-            this.extensions[id as keyof typeof this.extensions] = ext;
-        }
-        return ext.lastOutput as O | undefined;
-    }
-
-    cleanup() {
-        for (const child of Object.values(this.values)) {
-            child.unsubscribe?.();
-        }
-        for (const extension of Object.values(this.extensions)) {
-            extension.unsubscribe();
-        }
-    }
-}
-
-export function query<T extends CoValue>(
-    id: CoID<T>,
-    node: LocalNode,
-    callback: (queried: Queried<T> | undefined) => void
-): CleanupCallbackAndUsable {
-    // console.log("querying", id);
-
-    const context = new QueryContext(node, () => {
-        const rootQueried = context.values[id]?.lastQueried as
-            | Queried<T>
-            | undefined;
-        callback(rootQueried);
-    });
-
-    context.query(id, []);
-
-    const cleanup = function cleanup() {
-        context.cleanup();
-    } as CleanupCallbackAndUsable;
-    cleanup[Symbol.dispose] = cleanup;
-
-    return cleanup;
-}

package/src/tests/queries.test.ts

@@ -1,337 +0,0 @@
-import {
-    BinaryCoStream,
-    CoList,
-    CoMap,
-    CoStream,
-    Group,
-    LocalNode,
-    cojsonReady,
-} from "..";
-
-beforeEach(async () => {
-    await cojsonReady;
-});
-
-test("Queries with maps work", async () => {
-    const { node, accountID } =
-        LocalNode.withNewlyCreatedAccount({name: "Hermes Puggington"});
-
-    const group = node.createGroup();
-
-    let map = group.createMap<
-        CoMap<{
-            hello: "world";
-            subMap: CoMap<{
-                hello: "world" | "moon" | "sun";
-                id: string;
-            }>["id"];
-        }>
-    >();
-
-    const done = new Promise<void>((resolve) => {
-        const unsubQuery = node.query(map.id, (queriedMap) => {
-            // console.log("update", update);
-            if (queriedMap) {
-                expect(queriedMap.type).toBe("comap");
-                expect(queriedMap.id).toEqual(map.id);
-                expect(queriedMap.core).toEqual(map.core);
-                expect(queriedMap.group).toBeInstanceOf(Group);
-                expect(queriedMap.group.id).toBe(group.id);
-                expect(queriedMap.meta).toBe(null);
-                expect(queriedMap.hello).toBe("world");
-                expect(Object.keys(queriedMap)).toEqual(["hello", "subMap"]);
-                if (queriedMap.edits.hello?.by?.profile?.name) {
-                    expect(queriedMap.edits.hello.by.id).toEqual(accountID);
-                    expect(queriedMap.edits.hello.by.profile.id).toEqual(
-                        node.expectProfileLoaded(accountID).id
-                    );
-                    expect(queriedMap.edits.hello.by.profile.name).toEqual(
-                        "Hermes Puggington"
-                    );
-                    expect(queriedMap.edits.hello.by.isMe).toBe(true);
-                    expect(queriedMap.edits.hello.tx).toEqual(
-                        map.lastEditAt("hello")!.tx
-                    );
-                    expect(queriedMap.edits.hello.at).toEqual(
-                        new Date(map.lastEditAt("hello")!.at)
-                    );
-                    if (queriedMap.subMap) {
-                        expect(queriedMap.subMap.type).toBe("comap");
-                        expect(queriedMap.subMap.id).toEqual("foreignID");
-                        expect(queriedMap.subMap.core).toEqual(subMap.core);
-                        expect(queriedMap.subMap.group).toBeInstanceOf(Group);
-                        expect(queriedMap.subMap.group.id).toBe(group.id);
-                        expect(queriedMap.subMap.meta).toBe(null);
-                        if (queriedMap.subMap.hello === "moon") {
-                            // console.log("got to 'moon'");
-                            queriedMap.subMap.set("hello", "sun");
-                        } else if (
-                            queriedMap.subMap.hello === "sun" &&
-                            queriedMap.subMap.edits.hello?.by?.profile?.name ===
-                                "Hermes Puggington"
-                        ) {
-                            // console.log("final update", queriedMap);
-                            resolve();
-                            unsubQuery();
-                        }
-                    }
-                }
-            }
-        });
-    });
-
-    map = map.set("hello", "world");
-
-    let subMap = group.createMap<
-        CoMap<{
-            hello: "world" | "moon" | "sun";
-            id: string;
-        }>
-    >();
-
-    map = map.set("subMap", subMap.id);
-
-    subMap = subMap.mutate((subMap) => {
-        subMap.set("hello", "world");
-        subMap.set("id", "foreignID");
-    });
-
-    subMap = subMap.set("hello", "moon");
-
-    await done;
-});
-
-test("Queries with lists work", () => {
-    const { node, accountID } =
-        LocalNode.withNewlyCreatedAccount({name: "Hermes Puggington"});
-
-    const group = node.createGroup();
-
-    let list = group.createList<CoList<string>>();
-
-    const done = new Promise<void>((resolve) => {
-        const unsubQuery = node.query(list.id, (queriedList) => {
-            if (queriedList) {
-                // console.log("update", queriedList, queriedList.edits);
-                expect(queriedList.type).toBe("colist");
-                expect(queriedList.id).toEqual(list.id);
-                expect(queriedList.core).toEqual(list.core);
-                expect(queriedList.group).toBeInstanceOf(Group);
-                expect(queriedList.group.id).toBe(group.id);
-                expect(queriedList.meta).toBe(null);
-                expect(queriedList[0]).toBe("hello");
-                expect(queriedList[1]).toBe("world");
-                expect(queriedList[2]).toBe("moon");
-                if (queriedList.edits[2]?.by?.profile?.name) {
-                    expect(queriedList.edits[2].by.id).toEqual(accountID);
-                    expect(queriedList.edits[2].by.profile.id).toEqual(
-                        node.expectProfileLoaded(accountID).id
-                    );
-                    expect(queriedList.edits[2].by.profile.name).toEqual(
-                        "Hermes Puggington"
-                    );
-                    expect(queriedList.edits[2].by.isMe).toBe(true);
-                    expect(queriedList.edits[2].at).toBeInstanceOf(Date);
-                    if (queriedList.length === 3) {
-                        queriedList.append("sun");
-                    } else if (
-                        queriedList.length === 4 &&
-                        queriedList.edits[3]?.by?.profile?.name ===
-                            "Hermes Puggington"
-                    ) {
-                        expect(queriedList[3]).toBe("sun");
-                        // console.log("final update", queriedList);
-                        resolve();
-                        unsubQuery();
-                    }
-                }
-            }
-        });
-    });
-
-    list = list.mutate((list) => {
-        list.append("hello");
-        list.append("world");
-        list.append("moon");
-    });
-
-    return done;
-});
-
-test("List of nested maps works", () => {
-    const { node } = LocalNode.withNewlyCreatedAccount({name: "Hermes Puggington"});
-
-    const group = node.createGroup();
-
-    let list = group.createList<CoList<CoMap<{ hello: "world" }>["id"]>>();
-
-    const done = new Promise<void>((resolve) => {
-        const unsubQuery = node.query(list.id, (queriedList) => {
-            if (queriedList && queriedList[0]) {
-                // console.log("update", queriedList);
-                expect(queriedList[0]).toMatchObject({
-                    hello: "world",
-                    id: list.get(0)!,
-                });
-                // console.log("final update", queriedList);
-                resolve();
-                unsubQuery();
-            }
-        });
-    });
-
-    list = list.append(
-        group.createMap<CoMap<{ hello: "world" }>>({
-            hello: "world",
-        }).id
-    );
-
-    return done;
-});
-
-test("Can call .map on a quieried coList", async () => {
-    const { node } = LocalNode.withNewlyCreatedAccount({name: "Hermes Puggington"});
-
-    const group = node.createGroup();
-
-    let list = group.createList<CoList<string>>();
-
-    const done = new Promise<void>((resolve) => {
-        const unsubQuery = node.query(list.id, (queriedList) => {
-            if (queriedList && queriedList[0]) {
-                // console.log("update", queriedList);
-                expect(queriedList.map((item) => item + "!!!")).toEqual([
-                    "hello!!!",
-                    "world!!!",
-                ]);
-                // console.log("final update", queriedList);
-                resolve();
-                unsubQuery();
-            }
-        });
-    });
-
-    list = list.mutate((list) => {
-        list.append("hello");
-        list.append("world");
-    });
-
-    await done;
-});
-
-test("Queries with streams work", () => {
-    const { node, accountID } =
-        LocalNode.withNewlyCreatedAccount({name: "Hermes Puggington"});
-
-    const group = node.createGroup();
-
-    let stream = group.createStream<CoStream<string>>();
-
-    const done = new Promise<void>((resolve) => {
-        const unsubQuery = node.query(stream.id, (queriedStream) => {
-            if (queriedStream) {
-                // console.log("update", queriedStream);
-                if (queriedStream.me?.by?.profile?.name) {
-                    expect(queriedStream.type).toBe("costream");
-                    expect(queriedStream.id).toEqual(stream.id);
-                    expect(queriedStream.core).toEqual(stream.core);
-                    expect(queriedStream.group).toBeInstanceOf(Group);
-                    expect(queriedStream.group.id).toBe(group.id);
-                    expect(queriedStream.meta).toBe(null);
-
-                    expect(queriedStream.perSession[node.currentSessionID].last).toEqual(
-                        "world"
-                    );
-                    expect(queriedStream.perSession[node.currentSessionID].all[0].value).toEqual("hello");
-                    expect(queriedStream.perSession[node.currentSessionID].all[0].at).toEqual(new Date(
-                        stream.items[
-                            node.currentSessionID
-                        ][0].madeAt
-                    ));
-                    expect(queriedStream.perSession[node.currentSessionID].all[1].value).toEqual("world");
-                    expect(queriedStream.perSession[node.currentSessionID].all[1].at).toEqual(new Date(
-                        stream.items[
-                            node.currentSessionID
-                        ][1].madeAt
-                    ));
-                    expect(queriedStream.perSession[node.currentSessionID].by?.id).toEqual(accountID);
-                    expect(queriedStream.perSession[node.currentSessionID].by?.profile?.id).toEqual(
-                        node.expectProfileLoaded(accountID).id
-                    );
-                    expect(queriedStream.perSession[node.currentSessionID].by?.profile?.name).toEqual(
-                        "Hermes Puggington"
-                    );
-                    expect(queriedStream.perSession[node.currentSessionID].by?.isMe).toBe(true);
-                    expect(queriedStream.perSession[node.currentSessionID].at).toBeInstanceOf(Date);
-
-                    expect(queriedStream.perAccount[accountID].last).toEqual(
-                        "world"
-                    );
-                    expect(queriedStream.perAccount[accountID].all[0].value).toEqual("hello");
-                    expect(queriedStream.perAccount[accountID].all[0].at).toEqual(new Date(
-                        stream.items[
-                            node.currentSessionID
-                        ][0].madeAt
-                    ));
-                    expect(queriedStream.perAccount[accountID].all[1].value).toEqual("world");
-                    expect(queriedStream.perAccount[accountID].all[1].at).toEqual(new Date(
-                        stream.items[
-                            node.currentSessionID
-                        ][1].madeAt
-                    ));
-                    expect(queriedStream.perAccount[accountID].by?.id).toEqual(accountID);
-                    expect(queriedStream.perAccount[accountID].by?.profile?.id).toEqual(
-                        node.expectProfileLoaded(accountID).id
-                    );
-                    expect(queriedStream.perAccount[accountID].by?.profile?.name).toEqual(
-                        "Hermes Puggington"
-                    );
-                    expect(queriedStream.perAccount[accountID].by?.isMe).toBe(true);
-                    expect(queriedStream.perAccount[accountID].at).toBeInstanceOf(Date);
-
-                    expect(queriedStream.me).toEqual(queriedStream.perAccount[accountID]);
-                    // console.log("final update", queriedStream);
-                    resolve();
-                    unsubQuery();
-                }
-            }
-        });
-    });
-
-    stream = stream.push("hello");
-    stream = stream.push("world");
-
-    return done;
-});
-
-test("Streams of nested maps work", () => {
-    const { node } = LocalNode.withNewlyCreatedAccount({name:"Hermes Puggington"});
-
-    const group = node.createGroup();
-
-    let stream =
-        group.createStream<CoStream<CoMap<{ hello: "world" }>["id"]>>();
-
-    const done = new Promise<void>((resolve) => {
-        const unsubQuery = node.query(stream.id, (queriedStream) => {
-            if (queriedStream && queriedStream.me?.last) {
-                // console.log("update", queriedList);
-                expect(queriedStream.me.last).toMatchObject({
-                    hello: "world",
-                    id: map.id,
-                });
-                // console.log("final update", queriedList);
-                resolve();
-                unsubQuery();
-            }
-        });
-    });
-
-    const map = group.createMap<CoMap<{ hello: "world" }>>({
-        hello: "world",
-    });
-
-    stream = stream.push(map.id);
-
-    return done;
-});