cojson 0.2.3 → 0.3.0-alpha.0

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"
+        );
+    }
+}

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);
+    }
+}