cojson 0.3.7 → 0.4.0

package/src/{group.ts → coValues/group.ts}

@@ -1,6 +1,8 @@
-import { CoID, CoValue, AnyCoValue, AnyCoMap, AnyCoList } from "./coValue.js";
-import { CoMap } from "./coValues/coMap.js";
-import { JsonObject, JsonValue } from "./jsonValue.js";
+import { CoID, CoValue, expectMap } from "../coValue.js";
+import { CoMap } from "./coMap.js";
+import { CoList } from "./coList.js";
+import { JsonObject } from "../jsonValue.js";
+import { BinaryCoStream, CoStream } from "./coStream.js";
 import {
     Encrypted,
     KeyID,
@@ -14,37 +16,40 @@ import {
     newRandomSecretSeed,
     agentSecretFromSecretSeed,
     getAgentID,
-} from "./crypto.js";
-import { LocalNode } from "./localNode.js";
-import { AgentID, SessionID, isAgentID } from "./ids.js";
-import { AccountID, GeneralizedControlledAccount, Profile } from "./account.js";
-import { Role } from "./permissions.js";
+} from "../crypto.js";
+import { AgentID, isAgentID } from "../ids.js";
+import { AccountID, Profile } from "./account.js";
+import { Role } from "../permissions.js";
 import { base58 } from "@scure/base";
-import {
-    BinaryCoStream,
-    BinaryCoStreamMeta,
-    CoStream,
-} from "./coValues/coStream.js";
 
-export type GroupContent = {
-    profile?: CoID<Profile> | null;
+export const EVERYONE = "everyone" as const;
+export type Everyone = "everyone";
+
+export type GroupShape<P extends Profile, R extends CoMap> = {
+    profile?: CoID<P> | null;
+    root?: CoID<R> | null;
     [key: AccountID | AgentID]: Role;
+    [EVERYONE]?: Role;
     readKey?: KeyID;
     [revelationFor: `${KeyID}_for_${AccountID | AgentID}`]: Sealed<KeySecret>;
+    [revelationFor: `${KeyID}_for_${Everyone}`]: KeySecret;
     [oldKeyForNewKey: `${KeyID}_for_${KeyID}`]: Encrypted<
         KeySecret,
         { encryptedID: KeyID; encryptingID: KeyID }
     >;
 };
 
-export function expectGroupContent(
-    content: CoValue
-): CoMap<GroupContent, JsonObject | null> {
-    if (content.type !== "comap") {
-        throw new Error("Expected map");
+export function expectGroup(content: CoValue): Group {
+    const map = expectMap(content);
+    if (map.core.header.ruleset.type !== "group") {
+        throw new Error("Expected group ruleset in group");
+    }
+
+    if (!(map instanceof Group)) {
+        throw new Error("Expected group");
     }
 
-    return content as CoMap<GroupContent, JsonObject | null>;
+    return map;
 }
 
 /** A `Group` is a scope for permissions of its members (`"reader" | "writer" | "admin"`), applying to objects owned by that group.
@@ -68,30 +73,11 @@ export function expectGroupContent(
  *  const localNode.createGroup();
  *  ```
  * */
-export class Group {
-    /** @category 4. Underlying CoMap */
-    underlyingMap: CoMap<GroupContent, JsonObject | null>;
-    /** @internal */
-    node: LocalNode;
-
-    /** @internal */
-    constructor(
-        underlyingMap: CoMap<GroupContent, JsonObject | null>,
-        node: LocalNode
-    ) {
-        this.underlyingMap = underlyingMap;
-        this.node = node;
-    }
-
-    /**
-     * Returns the `CoID` of the `Group`.
-     *
-     * @category 4. Underlying CoMap
-     */
-    get id(): CoID<CoMap<GroupContent, JsonObject | null>> {
-        return this.underlyingMap.id;
-    }
-
+export class Group<
+    P extends Profile = Profile,
+    R extends CoMap = CoMap,
+    Meta extends JsonObject | null = JsonObject | null
+> extends CoMap<GroupShape<P, R>, Meta> {
     /**
      * Returns the current role of a given account.
      *
@@ -103,7 +89,7 @@ export class Group {
 
     /** @internal */
     roleOfInternal(accountID: AccountID | AgentID): Role | undefined {
-        return this.underlyingMap.get(accountID);
+        return this.get(accountID);
     }
 
     /**
@@ -112,7 +98,7 @@ export class Group {
      * @category 1. Role reading
      */
     myRole(): Role | undefined {
-        return this.roleOfInternal(this.node.account.id);
+        return this.roleOfInternal(this.core.node.account.id);
     }
 
     /**
@@ -121,64 +107,81 @@ export class Group {
      *
      * @category 2. Role changing
      */
-    addMember(accountID: AccountID, role: Role) {
-        this.addMemberInternal(accountID, role);
+    addMember(accountID: AccountID | Everyone, role: Role): this {
+        return this.addMemberInternal(accountID, role);
     }
 
     /** @internal */
-    addMemberInternal(accountID: AccountID | AgentID, role: Role) {
-        this.underlyingMap = this.underlyingMap.mutate((map) => {
-            const currentReadKey = this.underlyingMap.core.getCurrentReadKey();
+    addMemberInternal(
+        accountID: AccountID | AgentID | Everyone,
+        role: Role
+    ): this {
+        return this.mutate((mutable) => {
+            const currentReadKey = this.core.getCurrentReadKey();
 
             if (!currentReadKey.secret) {
                 throw new Error("Can't add member without read key secret");
             }
 
-            const agent = this.node.resolveAccountAgent(
-                accountID,
-                "Expected to know agent to add them to group"
-            );
+            if (accountID === EVERYONE) {
+                if (!(role === "reader" || role === "writer")) {
+                    throw new Error(
+                        "Can't make everyone something other than reader or writer"
+                    );
+                }
+                mutable.set(accountID, role, "trusting");
 
-            map.set(accountID, role, "trusting");
+                if (mutable.get(accountID) !== role) {
+                    throw new Error("Failed to set role");
+                }
 
-            if (map.get(accountID) !== role) {
-                throw new Error("Failed to set role");
-            }
+                mutable.set(
+                    `${currentReadKey.id}_for_${EVERYONE}`,
+                    currentReadKey.secret,
+                    "trusting"
+                );
+            } else {
+                const agent = this.core.node.resolveAccountAgent(
+                    accountID,
+                    "Expected to know agent to add them to group"
+                );
+                mutable.set(accountID, role, "trusting");
 
-            map.set(
-                `${currentReadKey.id}_for_${accountID}`,
-                seal({
-                    message: currentReadKey.secret,
-                    from: this.underlyingMap.core.node.account.currentSealerSecret(),
-                    to: getAgentSealerID(agent),
-                    nOnceMaterial: {
-                        in: this.underlyingMap.core.id,
-                        tx: this.underlyingMap.core.nextTransactionID(),
-                    },
-                }),
-                "trusting"
-            );
+                if (mutable.get(accountID) !== role) {
+                    throw new Error("Failed to set role");
+                }
+
+                mutable.set(
+                    `${currentReadKey.id}_for_${accountID}`,
+                    seal({
+                        message: currentReadKey.secret,
+                        from: this.core.node.account.currentSealerSecret(),
+                        to: getAgentSealerID(agent),
+                        nOnceMaterial: {
+                            in: this.id,
+                            tx: this.core.nextTransactionID(),
+                        },
+                    }),
+                    "trusting"
+                );
+            }
         });
     }
 
     /** @internal */
-    rotateReadKey() {
-        const currentlyPermittedReaders = this.underlyingMap
-            .keys()
-            .filter((key) => {
-                if (key.startsWith("co_") || isAgentID(key)) {
-                    const role = this.underlyingMap.get(key);
-                    return (
-                        role === "admin" ||
-                        role === "writer" ||
-                        role === "reader"
-                    );
-                } else {
-                    return false;
-                }
-            }) as (AccountID | AgentID)[];
+    rotateReadKey(): this {
+        const currentlyPermittedReaders = this.keys().filter((key) => {
+            if (key.startsWith("co_") || isAgentID(key)) {
+                const role = this.get(key);
+                return (
+                    role === "admin" || role === "writer" || role === "reader"
+                );
+            } else {
+                return false;
+            }
+        }) as (AccountID | AgentID)[];
 
-        const maybeCurrentReadKey = this.underlyingMap.core.getCurrentReadKey();
+        const maybeCurrentReadKey = this.core.getCurrentReadKey();
 
         if (!maybeCurrentReadKey.secret) {
             throw new Error(
@@ -193,29 +196,29 @@ export class Group {
 
         const newReadKey = newRandomKeySecret();
 
-        this.underlyingMap = this.underlyingMap.mutate((map) => {
+        return this.mutate((mutable) => {
             for (const readerID of currentlyPermittedReaders) {
-                const reader = this.node.resolveAccountAgent(
+                const reader = this.core.node.resolveAccountAgent(
                     readerID,
                     "Expected to know currently permitted reader"
                 );
 
-                map.set(
+                mutable.set(
                     `${newReadKey.id}_for_${readerID}`,
                     seal({
                         message: newReadKey.secret,
-                        from: this.underlyingMap.core.node.account.currentSealerSecret(),
+                        from: this.core.node.account.currentSealerSecret(),
                         to: getAgentSealerID(reader),
                         nOnceMaterial: {
-                            in: this.underlyingMap.core.id,
-                            tx: this.underlyingMap.core.nextTransactionID(),
+                            in: this.id,
+                            tx: this.core.nextTransactionID(),
                         },
                     }),
                     "trusting"
                 );
             }
 
-            map.set(
+            mutable.set(
                 `${currentReadKey.id}_for_${newReadKey.id}`,
                 encryptKeySecret({
                     encrypting: newReadKey,
@@ -224,7 +227,7 @@ export class Group {
                 "trusting"
             );
 
-            map.set("readKey", newReadKey.id, "trusting");
+            mutable.set("readKey", newReadKey.id, "trusting");
         });
     }
 
@@ -235,17 +238,17 @@ export class Group {
      *
      * @category 2. Role changing
      */
-    removeMember(accountID: AccountID) {
-        this.removeMemberInternal(accountID);
+    removeMember(accountID: AccountID): this {
+        return this.removeMemberInternal(accountID);
     }
 
     /** @internal */
-    removeMemberInternal(accountID: AccountID | AgentID) {
-        this.underlyingMap = this.underlyingMap.mutate((map) => {
+    removeMemberInternal(accountID: AccountID | AgentID): this {
+        const afterRevoke = this.mutate((map) => {
             map.set(accountID, "revoked", "trusting");
         });
 
-        this.rotateReadKey();
+        return afterRevoke.rotateReadKey();
     }
 
     /**
@@ -272,21 +275,17 @@ export class Group {
      *
      * @category 3. Value creation
      */
-    createMap<M extends AnyCoMap>(
-        init?: {
-            [K in keyof M["_shape"]]: M["_shape"][K] extends AnyCoValue
-                ? M["_shape"][K] | CoID<M["_shape"][K]>
-                : M["_shape"][K];
-        },
+    createMap<M extends CoMap>(
+        init?: M["_shape"],
         meta?: M["meta"],
-        initPrivacy: "trusting" | "private" = "trusting"
+        initPrivacy: "trusting" | "private" = "private"
     ): M {
-        let map = this.node
+        let map = this.core.node
             .createCoValue({
                 type: "comap",
                 ruleset: {
                     type: "ownedByGroup",
-                    group: this.underlyingMap.id,
+                    group: this.id,
                 },
                 meta: meta || null,
                 ...createdNowUnique(),
@@ -308,19 +307,17 @@ export class Group {
      *
      * @category 3. Value creation
      */
-    createList<L extends AnyCoList>(
-        init?: (L["_item"] extends CoValue
-            ? CoID<L["_item"]> | L["_item"]
-            : L["_item"])[],
+    createList<L extends CoList>(
+        init?: L["_item"][],
         meta?: L["meta"],
-        initPrivacy: "trusting" | "private" = "trusting"
+        initPrivacy: "trusting" | "private" = "private"
     ): L {
-        let list = this.node
+        let list = this.core.node
             .createCoValue({
                 type: "colist",
                 ruleset: {
                     type: "ownedByGroup",
-                    group: this.underlyingMap.id,
+                    group: this.id,
                 },
                 meta: meta || null,
                 ...createdNowUnique(),
@@ -337,15 +334,13 @@ export class Group {
     }
 
     /** @category 3. Value creation */
-    createStream<C extends CoStream<JsonValue | CoValue, JsonObject | null>>(
-        meta?: C["meta"]
-    ): C {
-        return this.node
+    createStream<C extends CoStream>(meta?: C["meta"]): C {
+        return this.core.node
             .createCoValue({
                 type: "costream",
                 ruleset: {
                     type: "ownedByGroup",
-                    group: this.underlyingMap.id,
+                    group: this.id,
                 },
                 meta: meta || null,
                 ...createdNowUnique(),
@@ -354,36 +349,21 @@ export class Group {
     }
 
     /** @category 3. Value creation */
-    createBinaryStream<C extends BinaryCoStream<BinaryCoStreamMeta>>(
+    createBinaryStream<C extends BinaryCoStream>(
         meta: C["meta"] = { type: "binary" }
     ): C {
-        return this.node
+        return this.core.node
             .createCoValue({
                 type: "costream",
                 ruleset: {
                     type: "ownedByGroup",
-                    group: this.underlyingMap.id,
+                    group: this.id,
                 },
                 meta: meta,
                 ...createdNowUnique(),
             })
             .getCurrentContent() as C;
     }
-
-    /** @internal */
-    testWithDifferentAccount(
-        account: GeneralizedControlledAccount,
-        sessionId: SessionID
-    ): Group {
-        return new Group(
-            expectGroupContent(
-                this.underlyingMap.core
-                    .testWithDifferentAccount(account, sessionId)
-                    .getCurrentContent()
-            ),
-            this.node
-        );
-    }
 }
 
 export type InviteSecret = `inviteSecret_z${string}`;

package/src/ids.ts

@@ -1,4 +1,4 @@
-import { AccountID } from './account.js';
+import { AccountID } from './coValues/account.js';
 import { base58 } from "@scure/base";
 import { shortHashLength } from './crypto.js';
 

package/src/index.ts

@@ -2,6 +2,7 @@ import {
     CoValueCore,
     newRandomSessionID,
     MAX_RECOMMENDED_TX_SIZE,
+    accountOrAgentIDfromSessionID
 } from "./coValueCore.js";
 import { LocalNode } from "./localNode.js";
 import type { CoValue } from "./coValue.js";
@@ -25,18 +26,24 @@ import {
     cryptoReady,
 } from "./crypto.js";
 import { connectedPeers } from "./streamUtils.js";
-import { AnonymousControlledAccount, ControlledAccount } from "./account.js";
+import {
+    AnonymousControlledAccount,
+    ControlledAccount,
+} from "./coValues/account.js";
 import { rawCoIDtoBytes, rawCoIDfromBytes } from "./ids.js";
-import { Group, expectGroupContent } from "./group.js";
+import { Group, expectGroup, EVERYONE } from "./coValues/group.js";
 import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
 import { parseJSON } from "./jsonStringify.js";
+import { Account, Profile, isAccountID } from "./coValues/account.js";
 
 import type { SessionID, AgentID } from "./ids.js";
 import type { CoID, AnyCoValue } from "./coValue.js";
-import type { Queried } from "./queries.js";
+import type { Queried, QueryExtension } from "./queries.js";
 import type { QueriedCoStream } from "./queriedCoValues/queriedCoStream.js";
 import type { QueriedCoList } from "./queriedCoValues/queriedCoList.js";
 import type { QueriedCoMap } from "./queriedCoValues/queriedCoMap.js";
+import { QueriedAccount } from "./queriedCoValues/queriedAccount.js";
+import { QueriedGroup } from "./queriedCoValues/queriedGroup.js";
 import type {
     BinaryStreamInfo,
     BinaryCoStreamMeta,
@@ -44,8 +51,8 @@ import type {
 import type { JsonValue } from "./jsonValue.js";
 import type { SyncMessage, Peer } from "./sync.js";
 import type { AgentSecret } from "./crypto.js";
-import type { AccountID, Account, Profile } from "./account.js";
-import type { InviteSecret } from "./group.js";
+import type { AccountID, AccountMeta, AccountMigration, ProfileMeta } from "./coValues/account.js";
+import type { InviteSecret } from "./coValues/group.js";
 import type * as Media from "./media.js";
 
 type Value = JsonValue | AnyCoValue;
@@ -64,15 +71,18 @@ export const cojsonInternals = {
     agentSecretFromSecretSeed,
     secretSeedLength,
     shortHashLength,
-    expectGroupContent,
+    expectGroup,
     base64URLtoBytes,
     bytesToBase64url,
     parseJSON,
+    accountOrAgentIDfromSessionID,
+    isAccountID,
 };
 
 export {
     LocalNode,
     Group,
+    EVERYONE,
     CoMap,
     MutableCoMap,
     CoList,
@@ -88,9 +98,14 @@ export {
     QueriedCoMap,
     QueriedCoList,
     QueriedCoStream,
-    AccountID,
+    QueriedGroup,
+    QueriedAccount,
     Account,
+    AccountID,
+    AccountMeta,
+    AccountMigration,
     Profile,
+    ProfileMeta,
     SessionID,
     Media,
     CoValueCore,
@@ -107,6 +122,7 @@ export {
     AgentSecret,
     InviteSecret,
     SyncMessage,
+    QueryExtension,
 };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
@@ -120,9 +136,8 @@ export namespace CojsonInternalTypes {
     export type Transaction = import("./coValueCore.js").Transaction;
     export type Signature = import("./crypto.js").Signature;
     export type RawCoID = import("./ids.js").RawCoID;
-    export type AccountContent = import("./account.js").AccountContent;
-    export type ProfileContent = import("./account.js").ProfileContent;
-    export type ProfileMeta = import("./account.js").ProfileMeta;
+    export type ProfileShape = import("./coValues/account.js").ProfileShape;
+    export type ProfileMeta = import("./coValues/account.js").ProfileMeta;
     export type SealerSecret = import("./crypto.js").SealerSecret;
     export type SignerSecret = import("./crypto.js").SignerSecret;
 }