cojson 0.2.2 → 0.3.0-alpha.0

package/src/{node.ts → localNode.ts}

@@ -9,7 +9,11 @@ import {
     newRandomKeySecret,
     seal,
 } from "./crypto.js";
-import { CoValueCore, CoValueHeader, newRandomSessionID } from "./coValueCore.js";
+import {
+    CoValueCore,
+    CoValueHeader,
+    newRandomSessionID,
+} from "./coValueCore.js";
 import {
     InviteSecret,
     Group,
@@ -19,9 +23,10 @@ import {
 } from "./group.js";
 import { Peer, SyncManager } from "./sync.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
-import { CoID, CoValueImpl } from "./coValue.js";
+import { CoID } from "./coValue.js";
+import { Queried, query } from "./queries.js";
 import {
-    Account,
+    AccountGroup,
     AccountMeta,
     accountHeaderForInitialAgentSecret,
     GeneralizedControlledAccount,
@@ -30,9 +35,9 @@ import {
     AccountID,
     Profile,
     AccountContent,
-    AccountMap,
 } from "./account.js";
 import { CoMap } from "./coValues/coMap.js";
+import { CoValue } from "./index.js";
 
 /** A `LocalNode` represents a local view of a set of loaded `CoValue`s, from the perspective of a particular account (or primitive cryptographic agent).
 
@@ -48,11 +53,14 @@ const { localNode } = useJazz();
 export class LocalNode {
     /** @internal */
     coValues: { [key: RawCoID]: CoValueState } = {};
-    /** @internal */
+    /** @category 3. Low-level */
     account: GeneralizedControlledAccount;
+    /** @category 3. Low-level */
     currentSessionID: SessionID;
-    sync = new SyncManager(this);
+    /** @category 3. Low-level */
+    syncManager = new SyncManager(this);
 
+    /** @category 3. Low-level */
     constructor(
         account: GeneralizedControlledAccount,
         currentSessionID: SessionID
@@ -61,6 +69,7 @@ export class LocalNode {
         this.currentSessionID = currentSessionID;
     }
 
+    /** @category 2. Node Creation */
     static withNewlyCreatedAccount(
         name: string,
         initialAgentSecret = newRandomAgentSecret()
@@ -91,6 +100,7 @@ export class LocalNode {
         };
     }
 
+    /** @category 2. Node Creation */
     static async withLoadedAccount(
         accountID: AccountID,
         accountSecret: AgentSecret,
@@ -105,7 +115,7 @@ export class LocalNode {
         const accountPromise = loadingNode.load(accountID);
 
         for (const peer of peersToLoadFrom) {
-            loadingNode.sync.addPeer(peer);
+            loadingNode.syncManager.addPeer(peer);
         }
 
         const account = await accountPromise;
@@ -115,8 +125,8 @@ export class LocalNode {
             new ControlledAccount(accountSecret, account, loadingNode),
             sessionID
         );
-        node.sync = loadingNode.sync;
-        node.sync.local = node;
+        node.syncManager = loadingNode.syncManager;
+        node.syncManager.local = node;
 
         return node;
     }
@@ -126,7 +136,7 @@ export class LocalNode {
         const coValue = new CoValueCore(header, this);
         this.coValues[coValue.id] = { state: "loaded", coValue: coValue };
 
-        void this.sync.syncCoValue(coValue);
+        void this.syncManager.syncCoValue(coValue);
 
         return coValue;
     }
@@ -139,7 +149,7 @@ export class LocalNode {
 
             this.coValues[id] = entry;
 
-            this.sync.loadFromPeers(id);
+            this.syncManager.loadFromPeers(id);
         }
         if (entry.state === "loaded") {
             return Promise.resolve(entry.coValue);
@@ -151,28 +161,51 @@ export class LocalNode {
      * Loads a CoValue's content, syncing from peers as necessary and resolving the returned
      * promise once a first version has been loaded. See `coValue.subscribe()` and `node.useTelepathicData()`
      * for listening to subsequent updates to the CoValue.
+     *
+     * @category 3. Low-level
      */
-    async load<T extends CoValueImpl>(id: CoID<T>): Promise<T> {
+    async load<T extends CoValue>(id: CoID<T>): Promise<T> {
         return (await this.loadCoValue(id)).getCurrentContent() as T;
     }
 
-    /**
-     * Loads a profile associated with an account. `Profile` is at least a `CoMap<{string: name}>`,
-     * but might contain other, app-specific properties.
-     */
-    async loadProfile(id: AccountID): Promise<Profile> {
-        const account = await this.load<AccountMap>(id);
-        const profileID = account.get("profile");
+    /** @category 3. Low-level */
+    subscribe<T extends CoValue>(
+        id: CoID<T>,
+        callback: (update: T) => void
+    ): () => void {
+        let stopped = false;
+        let unsubscribe!: () => void;
 
-        if (!profileID) {
-            throw new Error(`Account ${id} has no profile`);
-        }
-        return (
-            await this.loadCoValue(profileID)
-        ).getCurrentContent() as Profile;
+        console.log("Subscribing to " + id);
+
+        this.load(id)
+            .then((coValue) => {
+                if (stopped) {
+                    return;
+                }
+                unsubscribe = coValue.subscribe(callback);
+            })
+            .catch((e) => {
+                console.error("Error subscribing to ", id, e);
+            });
+
+        return () => {
+            console.log("Unsubscribing from " + id);
+            stopped = true;
+            unsubscribe?.();
+        };
+    }
+
+    /** @category 1. High-level */
+    query<T extends CoValue>(
+        id: CoID<T>,
+        callback: (update: Queried<T> | undefined) => void
+    ): () => void {
+        return query(id, this, callback);
     }
 
-    async acceptInvite<T extends CoValueImpl>(
+    /** @category 1. High-level */
+    async acceptInvite<T extends CoValue>(
         groupOrOwnedValueID: CoID<T>,
         inviteSecret: InviteSecret
     ): Promise<void> {
@@ -204,10 +237,7 @@ export class LocalNode {
                 }
             });
             setTimeout(
-                () =>
-                    reject(
-                        new Error("Couldn't find invite before timeout")
-                    ),
+                () => reject(new Error("Couldn't find invite before timeout")),
                 2000
             );
         });
@@ -224,7 +254,9 @@ export class LocalNode {
             (existingRole === "writer" && inviteRole === "reader") ||
             (existingRole === "reader" && inviteRole === "readerInvite")
         ) {
-            console.debug("Not accepting invite that would replace or downgrade role");
+            console.debug(
+                "Not accepting invite that would replace or downgrade role"
+            );
             return;
         }
 
@@ -242,7 +274,8 @@ export class LocalNode {
                 : "reader"
         );
 
-        group.underlyingMap.core._sessions = groupAsInvite.underlyingMap.core.sessions;
+        group.underlyingMap.core._sessions =
+            groupAsInvite.underlyingMap.core.sessions;
         group.underlyingMap.core._cachedContent = undefined;
 
         for (const groupListener of group.underlyingMap.core.listeners) {
@@ -292,11 +325,12 @@ export class LocalNode {
         name: string,
         agentSecret = newRandomAgentSecret()
     ): ControlledAccount {
+        const accountAgentID = getAgentID(agentSecret);
         const account = this.createCoValue(
             accountHeaderForInitialAgentSecret(agentSecret)
         ).testWithDifferentAccount(
             new AnonymousControlledAccount(agentSecret),
-            newRandomSessionID(getAgentID(agentSecret))
+            newRandomSessionID(accountAgentID)
         );
 
         const accountAsGroup = new Group(
@@ -304,22 +338,22 @@ export class LocalNode {
             account.node
         );
 
-        accountAsGroup.underlyingMap.edit((editable) => {
-            editable.set(getAgentID(agentSecret), "admin", "trusting");
+        accountAsGroup.underlyingMap.mutate((editable) => {
+            editable.set(accountAgentID, "admin", "trusting");
 
             const readKey = newRandomKeySecret();
 
             editable.set(
-                `${readKey.id}_for_${getAgentID(agentSecret)}`,
-                seal(
-                    readKey.secret,
-                    getAgentSealerSecret(agentSecret),
-                    getAgentSealerID(getAgentID(agentSecret)),
-                    {
+                `${readKey.id}_for_${accountAgentID}`,
+                seal({
+                    message: readKey.secret,
+                    from: getAgentSealerSecret(agentSecret),
+                    to: getAgentSealerID(accountAgentID),
+                    nOnceMaterial: {
                         in: account.id,
                         tx: account.nextTransactionID(),
-                    }
-                ),
+                    },
+                }),
                 "trusting"
             );
 
@@ -332,28 +366,38 @@ export class LocalNode {
             account.node
         );
 
-        const profile = accountAsGroup.createMap<Profile>({
-            type: "profile",
-        });
-
-        profile.edit((editable) => {
-            editable.set("name", name, "trusting");
-        });
+        const profile = accountAsGroup.createMap<Profile>(
+            { name },
+            {
+                type: "profile",
+            },
+            "trusting"
+        );
 
-        accountAsGroup.underlyingMap.edit((editable) => {
-            editable.set("profile", profile.id, "trusting");
-        });
+        accountAsGroup.underlyingMap.set("profile", profile.id, "trusting");
 
         const accountOnThisNode = this.expectCoValueLoaded(account.id);
 
-        accountOnThisNode._sessions = {...accountAsGroup.underlyingMap.core.sessions};
+        accountOnThisNode._sessions = {
+            ...accountAsGroup.underlyingMap.core.sessions,
+        };
         accountOnThisNode._cachedContent = undefined;
 
+        const profileOnThisNode = this.createCoValue(profile.core.header);
+
+        profileOnThisNode._sessions = {
+            ...profile.core.sessions,
+        };
+        profileOnThisNode._cachedContent = undefined;
+
         return controlledAccount;
     }
 
     /** @internal */
-    resolveAccountAgent(id: AccountID | AgentID, expectation?: string): AgentID {
+    resolveAccountAgent(
+        id: AccountID | AgentID,
+        expectation?: string
+    ): AgentID {
         if (isAgentID(id)) {
             return id;
         }
@@ -374,13 +418,16 @@ export class LocalNode {
             );
         }
 
-        return new Account(
+        return new AccountGroup(
             coValue.getCurrentContent() as CoMap<GroupContent, AccountMeta>,
             this
         ).getCurrentAgentID();
     }
 
-    /** Creates a new group (with the current account as the group's first admin). */
+    /**
+     * Creates a new group (with the current account as the group's first admin).
+     * @category 1. High-level
+     */
     createGroup(): Group {
         const groupCoValue = this.createCoValue({
             type: "comap",
@@ -391,22 +438,22 @@ export class LocalNode {
 
         let groupContent = expectGroupContent(groupCoValue.getCurrentContent());
 
-        groupContent = groupContent.edit((editable) => {
+        groupContent = groupContent.mutate((editable) => {
             editable.set(this.account.id, "admin", "trusting");
 
             const readKey = newRandomKeySecret();
 
             editable.set(
                 `${readKey.id}_for_${this.account.id}`,
-                seal(
-                    readKey.secret,
-                    this.account.currentSealerSecret(),
-                    this.account.currentSealerID(),
-                    {
+                seal({
+                    message: readKey.secret,
+                    from: this.account.currentSealerSecret(),
+                    to: this.account.currentSealerID(),
+                    nOnceMaterial: {
                         in: groupCoValue.id,
                         tx: groupCoValue.nextTransactionID(),
-                    }
-                ),
+                    },
+                }),
                 "trusting"
             );
 
@@ -443,7 +490,11 @@ export class LocalNode {
                     continue;
                 }
 
-                const newCoValue = new CoValueCore(entry.coValue.header, newNode, {...entry.coValue.sessions});
+                const newCoValue = new CoValueCore(
+                    entry.coValue.header,
+                    newNode,
+                    { ...entry.coValue.sessions }
+                );
 
                 newNode.coValues[coValueID as RawCoID] = {
                     state: "loaded",

package/src/media.ts

@@ -1,9 +1,8 @@
 import { CoMap } from './coValues/coMap.js'
-import { CoID } from './coValue.js'
 import { BinaryCoStream } from './coValues/coStream.js'
 
 export type ImageDefinition = CoMap<{
     originalSize: [number, number];
     placeholderDataURL?: string;
-    [res: `${number}x${number}`]: CoID<BinaryCoStream>;
+    [res: `${number}x${number}`]: BinaryCoStream;
 }>;

package/src/permissions.ts

@@ -1,9 +1,7 @@
 import { CoID } from "./coValue.js";
 import { MapOpPayload } from "./coValues/coMap.js";
 import { JsonValue } from "./jsonValue.js";
-import {
-    KeyID,
-} from "./crypto.js";
+import { KeyID } from "./crypto.js";
 import {
     CoValueCore,
     Transaction,
@@ -11,11 +9,9 @@ import {
     accountOrAgentIDfromSessionID,
 } from "./coValueCore.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
-import {
-    AccountID,
-    Profile,
-} from "./account.js";
+import { AccountID, Profile } from "./account.js";
 import { parseJSON } from "./jsonStringify.js";
+import { expectGroupContent } from "./group.js";
 
 export type PermissionsDef =
     | { type: "group"; initialAdmin: AccountID | AgentID }
@@ -77,7 +73,7 @@ export function determineValidTransactions(
             // console.log("before", { memberState, validTransactions });
             const transactor = accountOrAgentIDfromSessionID(sessionID);
 
-            const changes = parseJSON(tx.changes)
+            const changes = parseJSON(tx.changes);
 
             const change = changes[0] as
                 | MapOpPayload<AccountID | AgentID, Role>
@@ -193,12 +189,14 @@ export function determineValidTransactions(
 
         return validTransactions;
     } else if (coValue.header.ruleset.type === "ownedByGroup") {
-        const groupContent = coValue.node
-            .expectCoValueLoaded(
-                coValue.header.ruleset.group,
-                "Determining valid transaction in owned object but its group wasn't loaded"
-            )
-            .getCurrentContent();
+        const groupContent = expectGroupContent(
+            coValue.node
+                .expectCoValueLoaded(
+                    coValue.header.ruleset.group,
+                    "Determining valid transaction in owned object but its group wasn't loaded"
+                )
+                .getCurrentContent()
+        );
 
         if (groupContent.type !== "comap") {
             throw new Error("Group must be a map");
@@ -211,10 +209,9 @@ export function determineValidTransactions(
                 );
                 return sessionLog.transactions
                     .filter((tx) => {
-                        const transactorRoleAtTxTime = groupContent.getAtTime(
-                            transactor,
-                            tx.madeAt
-                        );
+                        const transactorRoleAtTxTime = groupContent
+                            .atTime(tx.madeAt)
+                            .get(transactor);
 
                         return (
                             transactorRoleAtTxTime === "admin" ||

package/src/queriedCoValues/queriedCoList.ts

@@ -0,0 +1,248 @@
+import { CoList, MutableCoList } from "../coValues/coList.js";
+import { CoValueCore } from "../coValueCore.js";
+import { Group } from "../group.js";
+import { isAccountID } from "../account.js";
+import { AnyCoList, CoID, CoValue } from "../coValue.js";
+import { TransactionID } from "../ids.js";
+import { QueriedAccountAndProfile } from "./queriedCoMap.js";
+import { ValueOrSubQueried, QueryContext } from "../queries.js";
+
+export class QueriedCoList<L extends AnyCoList> extends Array<
+    ValueOrSubQueried<L["_item"]>
+> {
+    coList!: L;
+    id!: CoID<L>;
+    type!: "colist";
+
+    /** @internal */
+    constructor(coList: L, queryContext: QueryContext) {
+        if (!(coList instanceof CoList)) {
+            // this might be called from an intrinsic, like map, trying to create an empty array
+            // passing `0` as the only parameter
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return new Array(coList) as any;
+        }
+        super(
+            ...coList
+                .asArray()
+                .map(
+                    (item) =>
+                        queryContext.resolveValue(item) as ValueOrSubQueried<
+                            L["_item"]
+                        >
+                )
+        );
+
+        Object.defineProperties(this, {
+            coList: { value: coList },
+            id: { value: coList.id },
+            type: { value: "colist" },
+            edits: {
+                value: [...this.keys()].map((i) => {
+                    const edit = coList.editAt(i)!;
+                    return {
+                        by:
+                            edit.by && isAccountID(edit.by)
+                                ? queryContext.resolveAccount(edit.by)
+                                : undefined,
+                        tx: edit.tx,
+                        at: new Date(edit.at),
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        value: queryContext.resolveValue(edit.value) as any,
+                    };
+                }),
+            },
+            deletions: {
+                value: coList.deletionEdits().map((deletion) => ({
+                    by:
+                        deletion.by && isAccountID(deletion.by)
+                            ? queryContext.resolveAccount(deletion.by)
+                            : undefined,
+                    tx: deletion.tx,
+                    at: new Date(deletion.at),
+                })),
+            },
+        });
+    }
+
+    get meta(): L["meta"] {
+        return this.coList.meta;
+    }
+
+    get group(): Group {
+        return this.coList.group;
+    }
+
+    get core(): CoValueCore {
+        return this.coList.core;
+    }
+
+    append(
+        item: L["_item"] extends CoValue
+            ? L["_item"] | CoID<L["_item"]>
+            : L["_item"],
+        after?: number,
+        privacy?: "private" | "trusting"
+    ): L {
+        return this.coList.append(item, after, privacy);
+    }
+
+    prepend(
+        item: L["_item"] extends CoValue
+            ? L["_item"] | CoID<L["_item"]>
+            : L["_item"],
+        before?: number,
+        privacy?: "private" | "trusting"
+    ): L {
+        return this.coList.prepend(item, before, privacy);
+    }
+
+    delete(at: number, privacy: "private" | "trusting"): L {
+        return this.coList.delete(at, privacy);
+    }
+
+    mutate(
+        mutator: (mutable: MutableCoList<L["_item"], L["meta"]>) => void
+    ): L {
+        return this.coList.mutate(mutator);
+    }
+
+    edits!: {
+        by?: QueriedAccountAndProfile;
+        tx: TransactionID;
+        at: Date;
+        value: L["_item"] extends CoValue
+            ? CoID<L["_item"]>
+            : Exclude<L["_item"], CoValue>;
+    }[];
+
+    deletions!: {
+        by?: QueriedAccountAndProfile;
+        tx: TransactionID;
+        at: Date;
+    }[];
+
+    /** @internal */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isArray(arg: any): arg is any[] {
+        return Array.isArray(arg);
+    }
+
+    /** @internal */
+    static from<T>(arrayLike: ArrayLike<T>): T[];
+    /** @internal */
+    static from<T, U>(
+        arrayLike: ArrayLike<T>,
+        mapfn: (v: T, k: number) => U,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        thisArg?: any
+    ): U[];
+    /** @internal */
+    static from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    /** @internal */
+    static from<T, U>(
+        iterable: Iterable<T> | ArrayLike<T>,
+        mapfn: (v: T, k: number) => U,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        thisArg?: any
+    ): U[];
+    /** @internal */
+    static from<T, U>(
+        _iterable: unknown,
+        _mapfn?: unknown,
+        _thisArg?: unknown
+    ): T[] | U[] | T[] | U[] {
+        throw new Error("Array method 'from' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    static of<T>(..._items: T[]): T[] {
+        throw new Error("Array method 'of' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    pop(): ValueOrSubQueried<L["_item"]> | undefined {
+        throw new Error("Array method 'pop' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    push(..._items: ValueOrSubQueried<L["_item"]>[]): number {
+        throw new Error("Array method 'push' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    concat(
+        ..._items: ConcatArray<ValueOrSubQueried<L["_item"]>>[]
+    ): ValueOrSubQueried<L["_item"]>[];
+    /** @internal */
+    concat(
+        ..._items: (
+            | ValueOrSubQueried<L["_item"]>
+            | ConcatArray<ValueOrSubQueried<L["_item"]>>
+        )[]
+    ): ValueOrSubQueried<L["_item"]>[];
+    /** @internal */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    concat(..._items: any[]): ValueOrSubQueried<L["_item"]>[] {
+        throw new Error("Array method 'concat' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    reverse(): ValueOrSubQueried<L["_item"]>[] {
+        throw new Error(
+            "Array method 'reverse' not supported on QueriedCoList"
+        );
+    }
+
+    /** @internal */
+    shift(): ValueOrSubQueried<L["_item"]> | undefined {
+        throw new Error("Array method 'shift' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    sort(
+        _compareFn?:
+            | ((
+                  a: ValueOrSubQueried<L["_item"]>,
+                  b: ValueOrSubQueried<L["_item"]>
+              ) => number)
+            | undefined
+    ): this {
+        throw new Error("Array method 'sort' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    splice(
+        _start: number,
+        _deleteCount?: number | undefined
+    ): ValueOrSubQueried<L["_item"]>[] {
+        throw new Error("Array method 'splice' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    unshift(..._items: ValueOrSubQueried<L["_item"]>[]): number {
+        throw new Error(
+            "Array method 'unshift' not supported on QueriedCoList"
+        );
+    }
+
+    /** @internal */
+    fill(
+        _value: ValueOrSubQueried<L["_item"]>,
+        _start?: number | undefined,
+        _end?: number | undefined
+    ): this {
+        throw new Error("Array method 'fill' not supported on QueriedCoList");
+    }
+
+    /** @internal */
+    copyWithin(
+        _target: number,
+        _start: number,
+        _end?: number | undefined
+    ): this {
+        throw new Error(
+            "Array method 'copyWithin' not supported on QueriedCoList"
+        );
+    }
+}