cojson 0.2.2 → 0.3.0-alpha.0

package/src/queriedCoValues/queriedCoMap.ts

@@ -0,0 +1,180 @@
+import { MutableCoMap } from "../coValues/coMap.js";
+import { CoValueCore } from "../coValueCore.js";
+import { Group } from "../group.js";
+import { Account, AccountID, Profile, isAccountID } from "../account.js";
+import { AnyCoMap, CoID, CoValue } from "../coValue.js";
+import { TransactionID } from "../ids.js";
+import { ValueOrSubQueried, QueryContext } from "../queries.js";
+
+export type QueriedCoMap<M extends AnyCoMap> = {
+    [K in keyof M["_shape"] & string]: ValueOrSubQueried<M["_shape"][K]>;
+} & QueriedCoMapBase<M>;
+
+export type QueriedCoMapEdit<
+    M extends AnyCoMap,
+    K extends keyof M["_shape"]
+> = {
+    by?: QueriedAccountAndProfile;
+    tx: TransactionID;
+    at: Date;
+    value: M["_shape"][K] extends CoValue
+        ? CoID<M["_shape"][K]>
+        : Exclude<M["_shape"][K], CoValue>;
+};
+
+export class QueriedCoMapBase<M extends AnyCoMap> {
+    coMap!: M;
+    id!: CoID<M>;
+    type!: "comap";
+
+    /** @internal */
+    static newWithKVPairs<M extends AnyCoMap>(
+        coMap: M,
+        queryContext: QueryContext
+    ): QueriedCoMap<M> {
+        const kv = {} as {
+            [K in keyof M["_shape"] & string]: ValueOrSubQueried<
+                M["_shape"][K]
+            >;
+        };
+
+        if (coMap.meta?.type === "account") {
+            const profileID = coMap.get("profile");
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (kv as any).profile =
+                profileID && queryContext.resolveValue(profileID);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (kv as any).isMe =
+                (coMap as unknown as Account).id ===
+                queryContext.node.account.id;
+        } else {
+            for (const key of coMap.keys()) {
+                const value = coMap.get(key);
+
+                if (value === undefined) continue;
+
+                kv[key as keyof typeof kv] = queryContext.resolveValue(
+                    value
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ) as any;
+            }
+        }
+
+        return Object.assign(new QueriedCoMapBase(coMap, queryContext), kv);
+    }
+
+    /** @internal */
+    constructor(coMap: M, queryContext: QueryContext) {
+        Object.defineProperties(this, {
+            coMap: { value: coMap, enumerable: false },
+            id: { value: coMap.id, enumerable: false },
+            type: { value: "comap", enumerable: false },
+            edits: {
+                value: Object.fromEntries(
+                    coMap.keys().flatMap((key) => {
+                        const edits = [...coMap.editsAt(key)].map((edit) => ({
+                            by:
+                                edit.by && isAccountID(edit.by)
+                                    ? queryContext.resolveAccount(edit.by)
+                                    : undefined,
+                            tx: edit.tx,
+                            at: new Date(edit.at),
+                            value:
+                                edit.value &&
+                                queryContext.resolveValue(edit.value),
+                        }));
+                        const lastEdit = edits[edits.length - 1];
+                        if (!lastEdit) return [];
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const editsAtKey = {
+                            by: lastEdit.by,
+                            tx: lastEdit.tx,
+                            at: lastEdit.at,
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            value: lastEdit.value as any,
+                            all: edits,
+                        };
+
+                        return [[key, editsAtKey]];
+                    })
+                ),
+                enumerable: false,
+            },
+        });
+    }
+
+    edits!: {
+        [K in keyof M["_shape"] & string]:
+            | (QueriedCoMapEdit<M, K> & {
+                  all: QueriedCoMapEdit<M, K>[];
+              })
+            | undefined;
+    };
+
+    get meta(): M["meta"] {
+        return this.coMap.meta;
+    }
+
+    get group(): Group {
+        return this.coMap.group;
+    }
+
+    get core(): CoValueCore {
+        return this.coMap.core;
+    }
+
+    set<K extends keyof M["_shape"] & string>(
+        key: K,
+        value: M["_shape"][K] extends CoValue
+            ? M["_shape"][K] | CoID<M["_shape"][K]>
+            : M["_shape"][K],
+        privacy?: "private" | "trusting"
+    ): M;
+    set(
+        kv: {
+            [K in keyof M["_shape"] & string]?: M["_shape"][K] extends CoValue
+                ? M["_shape"][K] | CoID<M["_shape"][K]>
+                : M["_shape"][K];
+        },
+        privacy?: "private" | "trusting"
+    ): M;
+    set<K extends keyof M["_shape"] & string>(
+        ...args:
+            | [
+                  {
+                      [K in keyof M["_shape"] &
+                          string]?: M["_shape"][K] extends CoValue
+                          ? M["_shape"][K] | CoID<M["_shape"][K]>
+                          : M["_shape"][K];
+                  },
+                  ("private" | "trusting")?
+              ]
+            | [
+                  K,
+                  M["_shape"][K] extends CoValue
+                      ? M["_shape"][K] | CoID<M["_shape"][K]>
+                      : M["_shape"][K],
+                  ("private" | "trusting")?
+              ]
+    ): M {
+        // eslint-disable-next-line @typescript-eslint/ban-types
+        return (this.coMap.set as Function)(...args);
+    }
+    delete(
+        key: keyof M["_shape"] & string,
+        privacy?: "private" | "trusting"
+    ): M {
+        return this.coMap.delete(key, privacy);
+    }
+    mutate(
+        mutator: (mutable: MutableCoMap<M["_shape"], M["meta"]>) => void
+    ): M {
+        return this.coMap.mutate(mutator);
+    }
+}
+
+export type QueriedAccountAndProfile = {
+    profile?: { name?: string; id: CoID<Profile> };
+    isMe?: boolean;
+    id: AccountID;
+};

package/src/queriedCoValues/queriedCoStream.ts

@@ -0,0 +1,125 @@
+import { JsonValue } from "../jsonValue.js";
+import { MutableCoStream } from "../coValues/coStream.js";
+import { CoValueCore } from "../coValueCore.js";
+import { Group } from "../group.js";
+import { AccountID, isAccountID } from "../account.js";
+import { AnyCoStream, CoID, CoValue } from "../coValue.js";
+import { SessionID, TransactionID } from "../ids.js";
+import { QueriedAccountAndProfile } from "./queriedCoMap.js";
+import { ValueOrSubQueried, QueryContext } from "../queries.js";
+
+
+export type QueriedCoStreamItems<Item extends JsonValue | CoValue> = {
+    last?: ValueOrSubQueried<Item>;
+    by?: QueriedAccountAndProfile;
+    tx?: TransactionID;
+    at?: Date;
+    all: {
+        value: ValueOrSubQueried<Item>;
+        by?: QueriedAccountAndProfile;
+        tx: TransactionID;
+        at: Date;
+    }[];
+};
+
+export class QueriedCoStream<S extends AnyCoStream> {
+    coStream: S;
+    id: CoID<S>;
+    type = "costream" as const;
+
+    /** @internal */
+    constructor(coStream: S, queryContext: QueryContext) {
+        this.coStream = coStream;
+        this.id = coStream.id;
+
+        this.perSession = Object.fromEntries(
+            coStream.sessions().map((sessionID) => {
+                const items = [...coStream.itemsIn(sessionID)].map((item) => ({
+                    by: item.by && isAccountID(item.by)
+                        ? queryContext.resolveAccount(item.by)
+                        : undefined,
+                    tx: item.tx,
+                    at: new Date(item.at),
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    value: queryContext.resolveValue(item.value) as any,
+                }));
+
+                const lastItem = items[items.length - 1];
+
+                return [
+                    sessionID,
+                    {
+                        last: lastItem?.value,
+                        by: lastItem?.by,
+                        tx: lastItem?.tx,
+                        at: lastItem?.at,
+                        all: items,
+                    } satisfies QueriedCoStreamItems<S["_item"]>,
+                ];
+            })
+        );
+
+        this.perAccount = Object.fromEntries(
+            [...coStream.accounts()].map((accountID) => {
+                const items = [...coStream.itemsBy(accountID)].map((item) => ({
+                    by: item.by && isAccountID(item.by)
+                        ? queryContext.resolveAccount(item.by)
+                        : undefined,
+                    tx: item.tx,
+                    at: new Date(item.at),
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    value: queryContext.resolveValue(item.value) as any,
+                }));
+
+                const lastItem = items[items.length - 1];
+
+                return [
+                    accountID,
+                    {
+                        last: lastItem?.value,
+                        by: lastItem?.by,
+                        tx: lastItem?.tx,
+                        at: lastItem?.at,
+                        all: items,
+                    } satisfies QueriedCoStreamItems<S["_item"]>,
+                ];
+            })
+        );
+
+        this.me = isAccountID(queryContext.node.account.id)
+            ? this.perAccount[queryContext.node.account.id]
+            : undefined;
+    }
+
+    get meta(): S["meta"] {
+        return this.coStream.meta;
+    }
+
+    get group(): Group {
+        return this.coStream.group;
+    }
+
+    get core(): CoValueCore {
+        return this.coStream.core;
+    }
+
+    me?: QueriedCoStreamItems<S["_item"]>;
+    perAccount: {
+        [account: AccountID]: QueriedCoStreamItems<S["_item"]>;
+    };
+    perSession: {
+        [session: SessionID]: QueriedCoStreamItems<S["_item"]>;
+    };
+
+    push(
+        item: S["_item"] extends CoValue ? S["_item"] | CoID<S["_item"]> : S["_item"],
+        privacy?: "private" | "trusting"
+    ): S {
+        return this.coStream.push(item, privacy);
+    }
+    mutate(
+        mutator: (mutable: MutableCoStream<S["_item"], S["meta"]>) => void
+    ): S {
+        return this.coStream.mutate(mutator);
+    }
+}

package/src/queries.ts

@@ -0,0 +1,142 @@
+import { JsonValue } from "./jsonValue.js";
+import { CoMap } from "./coValues/coMap.js";
+import { CoStream } from "./coValues/coStream.js";
+import { CoList } from "./coValues/coList.js";
+import { AccountID } from "./account.js";
+import { AnyCoList, AnyCoMap, AnyCoStream, CoID, CoValue } from "./coValue.js";
+import { LocalNode } from "./localNode.js";
+import {
+    QueriedAccountAndProfile,
+    QueriedCoMap,
+    QueriedCoMapBase,
+} from "./queriedCoValues/queriedCoMap.js";
+import { QueriedCoList } from "./queriedCoValues/queriedCoList.js";
+import { QueriedCoStream } from "./queriedCoValues/queriedCoStream.js";
+
+export type Queried<T extends CoValue> = T extends AnyCoMap
+    ? QueriedCoMap<T>
+    : T extends AnyCoList
+    ? QueriedCoList<T>
+    : T extends AnyCoStream
+    ? T["meta"] extends { type: "binary" }
+        ? never
+        : QueriedCoStream<T>
+    : never;
+
+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 class QueryContext {
+    values: {
+        [id: CoID<CoValue>]: {
+            lastQueried: Queried<CoValue> | undefined;
+            unsubscribe: () => void;
+        };
+    } = {};
+    node: LocalNode;
+    onUpdate: () => void;
+
+    constructor(node: LocalNode, onUpdate: () => void) {
+        this.node = node;
+        this.onUpdate = onUpdate;
+    }
+
+    getChildLastQueriedOrSubscribe<T extends CoValue>(valueID: CoID<T>) {
+        let value = this.values[valueID];
+        if (!value) {
+            value = {
+                lastQueried: undefined,
+                unsubscribe: query(valueID, this.node, (childQueried) => {
+                    value!.lastQueried = childQueried as Queried<CoValue>;
+                    this.onUpdate();
+                }),
+            };
+            this.values[valueID] = value;
+        }
+        return value.lastQueried as Queried<T> | undefined;
+    }
+
+    resolveAccount(accountID: AccountID) {
+        return this.getChildLastQueriedOrSubscribe(
+            accountID
+        ) as QueriedAccountAndProfile;
+    }
+
+    resolveValue<T extends JsonValue>(
+        value: T
+    ): T extends CoID<infer C> ? Queried<C> | undefined : T {
+        return (
+            typeof value === "string" && value.startsWith("co_")
+                ? this.getChildLastQueriedOrSubscribe(value as CoID<CoValue>)
+                : value
+        ) as T extends CoID<infer C> ? Queried<C> | undefined : T;
+    }
+
+    cleanup() {
+        for (const child of Object.values(this.values)) {
+            child.unsubscribe();
+        }
+    }
+}
+
+export function query<T extends CoValue>(
+    id: CoID<T>,
+    node: LocalNode,
+    callback: (queried: Queried<T> | undefined) => void,
+    parentContext?: QueryContext
+): CleanupCallbackAndUsable {
+    console.log("querying", id);
+
+    const context = parentContext || new QueryContext(node, onUpdate);
+
+    const unsubscribe = node.subscribe(id, (update) => {
+        lastRootValue = update;
+        onUpdate();
+    });
+
+    let lastRootValue: T | undefined;
+
+    function onUpdate() {
+        const rootValue = lastRootValue;
+
+        if (rootValue === undefined) {
+            return undefined;
+        }
+
+        if (rootValue instanceof CoMap) {
+            callback(
+                QueriedCoMapBase.newWithKVPairs(
+                    rootValue,
+                    context
+                ) as Queried<T>
+            );
+        } else if (rootValue instanceof CoList) {
+            callback(new QueriedCoList(rootValue, context) as Queried<T>);
+        } else if (rootValue instanceof CoStream) {
+            if (rootValue.meta?.type === "binary") {
+                // Querying binary string not yet implemented
+                return {};
+            } else {
+                callback(new QueriedCoStream(rootValue, context) as Queried<T>);
+            }
+        }
+    }
+
+    const cleanup = function cleanup() {
+        context.cleanup();
+        unsubscribe();
+    } as CleanupCallbackAndUsable;
+    cleanup[Symbol.dispose] = cleanup;
+
+    return cleanup;
+}

package/src/sync.ts

@@ -1,8 +1,8 @@
 import { Signature } from "./crypto.js";
 import { CoValueHeader, Transaction } from "./coValueCore.js";
 import { CoValueCore } from "./coValueCore.js";
-import { LocalNode } from "./node.js";
-import { newLoadingState } from "./node.js";
+import { LocalNode } from "./localNode.js";
+import { newLoadingState } from "./localNode.js";
 import {
     ReadableStream,
     WritableStream,

package/src/{account.test.ts → tests/account.test.ts}

@@ -1,7 +1,7 @@
-import { newRandomSessionID } from "./coValueCore.js";
-import { cojsonReady } from "./index.js";
-import { LocalNode } from "./node.js";
-import { connectedPeers } from "./streamUtils.js";
+import { newRandomSessionID } from "../coValueCore.js";
+import { cojsonReady } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { connectedPeers } from "../streamUtils.js";
 
 beforeEach(async () => {
     await cojsonReady;
@@ -19,9 +19,6 @@ test("Can create a node while creating a new account with profile", async () =>
     expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
         "Hermes Puggington"
     );
-    expect((await node.loadProfile(accountID)).get("name")).toEqual(
-        "Hermes Puggington"
-    );
 });
 
 test("A node with an account can create groups and and objects within them", async () => {
@@ -39,7 +36,7 @@ test("A node with an account can create groups and and objects within them", asy
 
     expect(map.get("foo")).toEqual("bar");
 
-    expect(map.whoEdited("foo")).toEqual(accountID);
+    expect(map.lastEditAt("foo")?.by).toEqual(accountID);
 });
 
 test("Can create account with one node, and then load it on another", async () => {
@@ -57,7 +54,7 @@ test("Can create account with one node, and then load it on another", async () =
 
     const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {trace: true, peer1role: "server", peer2role: "client"});
 
-    node.sync.addPeer(node2asPeer);
+    node.syncManager.addPeer(node2asPeer);
 
     const node2 = await LocalNode.withLoadedAccount(
         accountID,