cojson 0.3.7 → 0.4.1

package/src/queriedCoValues/queriedCoList.ts

@@ -1,13 +1,12 @@
 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 { Group } from "../coValues/group.js";
+import { CoID, CoValue } from "../coValue.js";
 import { TransactionID } from "../ids.js";
-import { QueriedAccountAndProfile } from "./queriedCoMap.js";
 import { ValueOrSubQueried, QueryContext } from "../queries.js";
+import { QueriedAccount } from "./queriedAccount.js";
 
-export class QueriedCoList<L extends AnyCoList> extends Array<
+export class QueriedCoList<L extends CoList> extends Array<
     ValueOrSubQueried<L["_item"]>
 > {
     coList!: L;
@@ -27,40 +26,37 @@ export class QueriedCoList<L extends AnyCoList> extends Array<
                 .asArray()
                 .map(
                     (item) =>
-                        queryContext.resolveValue(item) as ValueOrSubQueried<
+                        queryContext.queryIfCoID(item, [coList.id]) as ValueOrSubQueried<
                             L["_item"]
                         >
                 )
         );
 
         Object.defineProperties(this, {
-            coList: { value: coList },
+            coList: { get() {return 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,
+                    return queryContext.defineSubqueryPropertiesIn({
+
                         tx: edit.tx,
                         at: new Date(edit.at),
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        value: queryContext.resolveValue(edit.value) as any,
-                    };
+                    }, {
+                        by: {value: edit.by, enumerable: true},
+                        value: {value: edit.value, enumerable: true},
+                    }, [coList.id]);
                 }),
             },
             deletions: {
-                value: coList.deletionEdits().map((deletion) => ({
-                    by:
-                        deletion.by && isAccountID(deletion.by)
-                            ? queryContext.resolveAccount(deletion.by)
-                            : undefined,
+                value: coList.deletionEdits().map((deletion) => queryContext.defineSubqueryPropertiesIn({
+
                     tx: deletion.tx,
                     at: new Date(deletion.at),
-                })),
+                }, {
+                    by: {value: deletion.by, enumerable: true},
+                }, [coList.id])),
             },
         });
     }
@@ -78,9 +74,7 @@ export class QueriedCoList<L extends AnyCoList> extends Array<
     }
 
     append(
-        item: L["_item"] extends CoValue
-            ? L["_item"] | CoID<L["_item"]>
-            : L["_item"],
+        item: L["_item"],
         after?: number,
         privacy?: "private" | "trusting"
     ): L {
@@ -88,16 +82,14 @@ export class QueriedCoList<L extends AnyCoList> extends Array<
     }
 
     prepend(
-        item: L["_item"] extends CoValue
-            ? L["_item"] | CoID<L["_item"]>
-            : L["_item"],
+        item: L["_item"],
         before?: number,
         privacy?: "private" | "trusting"
     ): L {
         return this.coList.prepend(item, before, privacy);
     }
 
-    delete(at: number, privacy: "private" | "trusting"): L {
+    delete(at: number, privacy?: "private" | "trusting"): L {
         return this.coList.delete(at, privacy);
     }
 
@@ -108,7 +100,7 @@ export class QueriedCoList<L extends AnyCoList> extends Array<
     }
 
     edits!: {
-        by?: QueriedAccountAndProfile;
+        by?: QueriedAccount;
         tx: TransactionID;
         at: Date;
         value: L["_item"] extends CoValue
@@ -117,7 +109,7 @@ export class QueriedCoList<L extends AnyCoList> extends Array<
     }[];
 
     deletions!: {
-        by?: QueriedAccountAndProfile;
+        by?: QueriedAccount;
         tx: TransactionID;
         at: Date;
     }[];

package/src/queriedCoValues/queriedCoMap.ts

@@ -1,34 +1,29 @@
-import { MutableCoMap } from "../coValues/coMap.js";
+import { CoMap, 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 { Group } from "../coValues/group.js";
+import { CoID } from "../coValue.js";
 import { TransactionID } from "../ids.js";
-import { ValueOrSubQueried, QueryContext } from "../queries.js";
+import { ValueOrSubQueried, QueryContext, QueryExtension } from "../queries.js";
+import { QueriedAccount } from "./queriedAccount.js";
 
-export type QueriedCoMap<M extends AnyCoMap> = {
+export type QueriedCoMap<M extends CoMap> = {
     [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;
+export type QueriedCoMapEdit<M extends CoMap, K extends keyof M["_shape"]> = {
+    by?: QueriedAccount;
     tx: TransactionID;
     at: Date;
-    value: M["_shape"][K] extends CoValue
-        ? CoID<M["_shape"][K]>
-        : Exclude<M["_shape"][K], CoValue>;
+    value: M["_shape"][K];
 };
 
-export class QueriedCoMapBase<M extends AnyCoMap> {
+export class QueriedCoMapBase<M extends CoMap> {
     coMap!: M;
     id!: CoID<M>;
     type!: "comap";
 
     /** @internal */
-    static newWithKVPairs<M extends AnyCoMap>(
+    static newWithKVPairs<M extends CoMap>(
         coMap: M,
         queryContext: QueryContext
     ): QueriedCoMap<M> {
@@ -37,27 +32,18 @@ export class QueriedCoMapBase<M extends AnyCoMap> {
                 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;
-            }
+        for (const key of coMap.keys()) {
+            const value = coMap.get(key);
+
+            if (value === undefined) continue;
+
+            queryContext.defineSubqueryPropertiesIn(
+                kv,
+                {
+                    [key]: { value, enumerable: true },
+                },
+                [coMap.id]
+            );
         }
 
         return Object.assign(new QueriedCoMapBase(coMap, queryContext), kv);
@@ -66,23 +52,33 @@ export class QueriedCoMapBase<M extends AnyCoMap> {
     /** @internal */
     constructor(coMap: M, queryContext: QueryContext) {
         Object.defineProperties(this, {
-            coMap: { value: coMap, enumerable: false },
+            coMap: {
+                get() {
+                    return 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 edits = [...coMap.editsAt(key)].map((edit) =>
+                            queryContext.defineSubqueryPropertiesIn(
+                                {
+                                    tx: edit.tx,
+                                    at: new Date(edit.at),
+                                },
+                                {
+                                    by: { value: edit.by, enumerable: true },
+                                    value: {
+                                        value: edit.value,
+                                        enumerable: true,
+                                    },
+                                },
+                                [coMap.id]
+                            )
+                        );
                         const lastEdit = edits[edits.length - 1];
                         if (!lastEdit) return [];
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -100,6 +96,15 @@ export class QueriedCoMapBase<M extends AnyCoMap> {
                 ),
                 enumerable: false,
             },
+            as: {
+                value: <O>(extension: QueryExtension<M, O>) => {
+                    return queryContext.getOrCreateExtension(
+                        coMap.id,
+                        extension
+                    );
+                },
+                enumerable: false,
+            },
         });
     }
 
@@ -125,16 +130,12 @@ export class QueriedCoMapBase<M extends AnyCoMap> {
 
     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],
+        value: 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];
+            [K in keyof M["_shape"] & string]?: M["_shape"][K];
         },
         privacy?: "private" | "trusting"
     ): M;
@@ -142,20 +143,11 @@ export class QueriedCoMapBase<M extends AnyCoMap> {
         ...args:
             | [
                   {
-                      [K in keyof M["_shape"] &
-                          string]?: M["_shape"][K] extends CoValue
-                          ? M["_shape"][K] | CoID<M["_shape"][K]>
-                          : M["_shape"][K];
+                      [K in keyof M["_shape"] & string]?: M["_shape"][K];
                   },
                   ("private" | "trusting")?
               ]
-            | [
-                  K,
-                  M["_shape"][K] extends CoValue
-                      ? M["_shape"][K] | CoID<M["_shape"][K]>
-                      : M["_shape"][K],
-                  ("private" | "trusting")?
-              ]
+            | [K, M["_shape"][K], ("private" | "trusting")?]
     ): M {
         // eslint-disable-next-line @typescript-eslint/ban-types
         return (this.coMap.set as Function)(...args);
@@ -171,10 +163,6 @@ export class QueriedCoMapBase<M extends AnyCoMap> {
     ): M {
         return this.coMap.mutate(mutator);
     }
-}
 
-export type QueriedAccountAndProfile = {
-    profile?: { name?: string; id: CoID<Profile> };
-    isMe?: boolean;
-    id: AccountID;
-};
+    as!: <O>(extension: QueryExtension<M, O>) => O | undefined;
+}

package/src/queriedCoValues/queriedCoStream.ts

@@ -1,94 +1,127 @@
 import { JsonValue } from "../jsonValue.js";
-import { MutableCoStream } from "../coValues/coStream.js";
+import { CoStream, 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 { Group } from "../coValues/group.js";
+import { AccountID, isAccountID } from "../coValues/account.js";
+import { CoID, CoValue } from "../coValue.js";
 import { SessionID, TransactionID } from "../ids.js";
-import { QueriedAccountAndProfile } from "./queriedCoMap.js";
 import { ValueOrSubQueried, QueryContext } from "../queries.js";
+import { QueriedAccount } from "./queriedAccount.js";
 
-
-export type QueriedCoStreamItems<Item extends JsonValue | CoValue> = {
+export type QueriedCoStreamEntry<Item extends JsonValue | CoValue> = {
     last?: ValueOrSubQueried<Item>;
-    by?: QueriedAccountAndProfile;
+    by?: QueriedAccount;
     tx?: TransactionID;
     at?: Date;
     all: {
         value: ValueOrSubQueried<Item>;
-        by?: QueriedAccountAndProfile;
+        by?: QueriedAccount;
         tx: TransactionID;
         at: Date;
     }[];
 };
 
-export class QueriedCoStream<S extends AnyCoStream> {
-    coStream: S;
+export class QueriedCoStream<S extends CoStream> {
+    coStream!: S;
     id: CoID<S>;
     type = "costream" as const;
 
     /** @internal */
     constructor(coStream: S, queryContext: QueryContext) {
-        this.coStream = coStream;
+        Object.defineProperty(this, "coStream", {
+            get() {
+                return 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,
+        this.perSession = coStream.sessions().map((sessionID) => {
+            const items = [...coStream.itemsIn(sessionID)].map((item) =>
+                queryContext.defineSubqueryPropertiesIn(
+                    {
+                        tx: item.tx,
+                        at: new Date(item.at),
+                    },
+                    {
+                        by: {
+                            value: isAccountID(item.by)
+                                ? item.by
+                                : (undefined as never),
+                            enumerable: true,
+                        },
+                        value: {
+                            value: item.value as S["_item"],
+                            enumerable: true,
+                        },
+                    },
+                    [coStream.id]
+                )
+            );
+
+            const lastItem = items[items.length - 1];
+
+            return [
+                sessionID,
+                {
+                    get last() {
+                        return lastItem?.value;
+                    },
+                    get by() {
+                        return lastItem?.by;
+                    },
+                    tx: lastItem?.tx,
+                    at: lastItem?.at,
+                    all: items,
+                } satisfies QueriedCoStreamEntry<S["_item"]>,
+            ];
+        });
+
+        this.perAccount = [...coStream.accounts()].map((accountID) => {
+            const items = [...coStream.itemsBy(accountID)].map((item) =>
+                queryContext.defineSubqueryPropertiesIn(
                     {
-                        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,
+                        tx: item.tx,
+                        at: new Date(item.at),
+                    },
                     {
-                        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;
+                        by: {
+                            value: isAccountID(item.by)
+                                ? item.by
+                                : (undefined as never),
+                            enumerable: true,
+                        },
+                        value: {
+                            value: item.value as S["_item"],
+                            enumerable: true,
+                        },
+                    },
+                    [coStream.id]
+                )
+            );
+
+            const lastItem = items[items.length - 1];
+
+            const entry = {
+                get last() {
+                    return lastItem?.value;
+                },
+                get by() {
+                    return lastItem?.by;
+                },
+                tx: lastItem?.tx,
+                at: lastItem?.at,
+                all: items,
+            } satisfies QueriedCoStreamEntry<S["_item"]>;
+
+            if (accountID === queryContext.node.account.id) {
+                this.me = entry;
+            }
+
+            return [
+                accountID,
+                entry
+            ];
+        });
     }
 
     get meta(): S["meta"] {
@@ -103,18 +136,11 @@ export class QueriedCoStream<S extends AnyCoStream> {
         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 {
+    me?: QueriedCoStreamEntry<S["_item"]>;
+    perAccount: [account: AccountID, items: QueriedCoStreamEntry<S["_item"]>][];
+    perSession: [session: SessionID, items: QueriedCoStreamEntry<S["_item"]>][];
+
+    push(item: S["_item"], privacy?: "private" | "trusting"): S {
         return this.coStream.push(item, privacy);
     }
     mutate(

package/src/queriedCoValues/queriedGroup.ts

@@ -0,0 +1,90 @@
+import { Everyone, Group, InviteSecret } from "../coValues/group.js";
+import { CoID } from "../coValue.js";
+import { QueryContext, ValueOrSubQueried } from "../queries.js";
+import { CoValueCore } from "../coValueCore.js";
+import { Role } from "../permissions.js";
+import { AccountID } from "../coValues/account.js";
+import { CoMap } from "../coValues/coMap.js";
+import { CoList } from "../coValues/coList.js";
+import { CoStream } from "../coValues/coStream.js";
+import { BinaryCoStream } from "../coValues/coStream.js";
+
+export class QueriedGroup<G extends Group = Group> {
+    group!: G;
+    id!: CoID<G>;
+    type = "group" as const;
+    profile?: ValueOrSubQueried<G["_shape"]["profile"]>;
+    root?: ValueOrSubQueried<G["_shape"]["root"]>;
+
+    constructor(group: G, queryContext: QueryContext) {
+        const profileID = group.get("profile");
+        const rootID = group.get("root");
+        queryContext.defineSubqueryPropertiesIn(Object.defineProperties(this, {
+            group: {
+                get() {
+                    return group;
+                },
+                enumerable: false,
+            },
+            id: { value: group.id, enumerable: false },
+            type: { value: "group", enumerable: false },
+        }), {
+            profile: {
+                value: profileID,
+                enumerable: false,
+            },
+            root: {
+                value: rootID,
+                enumerable: false,
+            },
+        }, [group.id]);
+    }
+
+    get meta(): G["meta"] {
+        return this.group.meta;
+    }
+
+    get core(): CoValueCore {
+        return this.group.core;
+    }
+
+    addMember(accountID: AccountID | Everyone, role: Role): G {
+        return this.group.addMember(accountID, role);
+    }
+
+    removeMember(accountID: AccountID): G {
+        return this.group.removeMember(accountID);
+    }
+
+    createInvite(role: "reader" | "writer" | "admin"): InviteSecret {
+        return this.group.createInvite(role);
+    }
+
+    createMap<M extends CoMap>(
+        init?: {
+            [K in keyof M["_shape"]]: M["_shape"][K];
+        },
+        meta?: M["meta"],
+        initPrivacy: "trusting" | "private" = "private"
+    ): M {
+        return this.group.createMap(init, meta, initPrivacy);
+    }
+
+    createList<L extends CoList>(
+        init?: L["_item"][],
+        meta?: L["meta"],
+        initPrivacy: "trusting" | "private" = "private"
+    ): L {
+        return this.group.createList(init, meta, initPrivacy);
+    }
+
+    createStream<C extends CoStream>(meta?: C["meta"]): C {
+        return this.group.createStream(meta);
+    }
+
+    createBinaryStream<C extends BinaryCoStream>(
+        meta: C["meta"] = { type: "binary" }
+    ): C {
+        return this.group.createBinaryStream(meta);
+    }
+}