cojson 0.0.24 → 0.1.1

package/src/coValue.ts

@@ -27,7 +27,7 @@ import {
     determineValidTransactions,
     isKeyForKeyField,
 } from "./permissions.js";
-import { Team, expectTeamContent } from "./team.js";
+import { Group, expectGroupContent } from "./group.js";
 import { LocalNode } from "./node.js";
 import { CoValueKnownState, NewContentMessage } from "./sync.js";
 import { RawCoID, SessionID, TransactionID } from "./ids.js";
@@ -106,10 +106,10 @@ export class CoValue {
         this._sessions = internalInitSessions;
         this.node = node;
 
-        if (header.ruleset.type == "ownedByTeam") {
+        if (header.ruleset.type == "ownedByGroup") {
             this.node
-                .expectCoValueLoaded(header.ruleset.team)
-                .subscribe((_teamUpdate) => {
+                .expectCoValueLoaded(header.ruleset.group)
+                .subscribe((_groupUpdate) => {
                     this._cachedContent = undefined;
                     const newContent = this.getCurrentContent();
                     for (const listener of this.listeners) {
@@ -385,8 +385,8 @@ export class CoValue {
     }
 
     getCurrentReadKey(): { secret: KeySecret | undefined; id: KeyID } {
-        if (this.header.ruleset.type === "team") {
-            const content = expectTeamContent(this.getCurrentContent());
+        if (this.header.ruleset.type === "group") {
+            const content = expectGroupContent(this.getCurrentContent());
 
             const currentKeyId = content.get("readKey");
 
@@ -400,20 +400,20 @@ export class CoValue {
                 secret: secret,
                 id: currentKeyId,
             };
-        } else if (this.header.ruleset.type === "ownedByTeam") {
+        } else if (this.header.ruleset.type === "ownedByGroup") {
             return this.node
-                .expectCoValueLoaded(this.header.ruleset.team)
+                .expectCoValueLoaded(this.header.ruleset.group)
                 .getCurrentReadKey();
         } else {
             throw new Error(
-                "Only teams or values owned by teams have read secrets"
+                "Only groups or values owned by groups have read secrets"
             );
         }
     }
 
     getReadKey(keyID: KeyID): KeySecret | undefined {
-        if (this.header.ruleset.type === "team") {
-            const content = expectTeamContent(this.getCurrentContent());
+        if (this.header.ruleset.type === "group") {
+            const content = expectGroupContent(this.getCurrentContent());
 
             // Try to find key revelation for us
 
@@ -477,26 +477,26 @@ export class CoValue {
             }
 
             return undefined;
-        } else if (this.header.ruleset.type === "ownedByTeam") {
+        } else if (this.header.ruleset.type === "ownedByGroup") {
             return this.node
-                .expectCoValueLoaded(this.header.ruleset.team)
+                .expectCoValueLoaded(this.header.ruleset.group)
                 .getReadKey(keyID);
         } else {
             throw new Error(
-                "Only teams or values owned by teams have read secrets"
+                "Only groups or values owned by groups have read secrets"
             );
         }
     }
 
-    getTeam(): Team {
-        if (this.header.ruleset.type !== "ownedByTeam") {
-            throw new Error("Only values owned by teams have teams");
+    getGroup(): Group {
+        if (this.header.ruleset.type !== "ownedByGroup") {
+            throw new Error("Only values owned by groups have groups");
         }
 
-        return new Team(
-            expectTeamContent(
+        return new Group(
+            expectGroupContent(
                 this.node
-                    .expectCoValueLoaded(this.header.ruleset.team)
+                    .expectCoValueLoaded(this.header.ruleset.group)
                     .getCurrentContent()
             ),
             this.node
@@ -553,12 +553,12 @@ export class CoValue {
     }
 
     getDependedOnCoValues(): RawCoID[] {
-        return this.header.ruleset.type === "team"
-            ? expectTeamContent(this.getCurrentContent())
+        return this.header.ruleset.type === "group"
+            ? expectGroupContent(this.getCurrentContent())
                   .keys()
                   .filter((k): k is AccountID => k.startsWith("co_"))
-            : this.header.ruleset.type === "ownedByTeam"
-            ? [this.header.ruleset.team]
+            : this.header.ruleset.type === "ownedByGroup"
+            ? [this.header.ruleset.group]
             : [];
     }
 }

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

@@ -25,7 +25,7 @@ import {
 import { Role } from "./permissions.js";
 import { base58 } from "@scure/base";
 
-export type TeamContent = {
+export type GroupContent = {
     profile: CoID<Profile> | null;
     [key: AccountIDOrAgentID]: Role;
     readKey: KeyID;
@@ -36,34 +36,34 @@ export type TeamContent = {
     >;
 };
 
-export function expectTeamContent(
+export function expectGroupContent(
     content: ContentType
-): CoMap<TeamContent, JsonObject | null> {
+): CoMap<GroupContent, JsonObject | null> {
     if (content.type !== "comap") {
         throw new Error("Expected map");
     }
 
-    return content as CoMap<TeamContent, JsonObject | null>;
+    return content as CoMap<GroupContent, JsonObject | null>;
 }
 
-export class Team {
-    teamMap: CoMap<TeamContent, JsonObject | null>;
+export class Group {
+    groupMap: CoMap<GroupContent, JsonObject | null>;
     node: LocalNode;
 
     constructor(
-        teamMap: CoMap<TeamContent, JsonObject | null>,
+        groupMap: CoMap<GroupContent, JsonObject | null>,
         node: LocalNode
     ) {
-        this.teamMap = teamMap;
+        this.groupMap = groupMap;
         this.node = node;
     }
 
-    get id(): CoID<CoMap<TeamContent, JsonObject | null>> {
-        return this.teamMap.id;
+    get id(): CoID<CoMap<GroupContent, JsonObject | null>> {
+        return this.groupMap.id;
     }
 
     roleOf(accountID: AccountIDOrAgentID): Role | undefined {
-        return this.teamMap.get(accountID);
+        return this.groupMap.get(accountID);
     }
 
     myRole(): Role | undefined {
@@ -71,8 +71,8 @@ export class Team {
     }
 
     addMember(accountID: AccountIDOrAgentID, role: Role) {
-        this.teamMap = this.teamMap.edit((map) => {
-            const currentReadKey = this.teamMap.coValue.getCurrentReadKey();
+        this.groupMap = this.groupMap.edit((map) => {
+            const currentReadKey = this.groupMap.coValue.getCurrentReadKey();
 
             if (!currentReadKey.secret) {
                 throw new Error("Can't add member without read key secret");
@@ -80,7 +80,7 @@ export class Team {
 
             const agent = this.node.resolveAccountAgent(
                 accountID,
-                "Expected to know agent to add them to team"
+                "Expected to know agent to add them to group"
             );
 
             map.set(accountID, role, "trusting");
@@ -93,11 +93,11 @@ export class Team {
                 `${currentReadKey.id}_for_${accountID}`,
                 seal(
                     currentReadKey.secret,
-                    this.teamMap.coValue.node.account.currentSealerSecret(),
+                    this.groupMap.coValue.node.account.currentSealerSecret(),
                     getAgentSealerID(agent),
                     {
-                        in: this.teamMap.coValue.id,
-                        tx: this.teamMap.coValue.nextTransactionID(),
+                        in: this.groupMap.coValue.id,
+                        tx: this.groupMap.coValue.nextTransactionID(),
                     }
                 ),
                 "trusting"
@@ -117,9 +117,9 @@ export class Team {
     }
 
     rotateReadKey() {
-        const currentlyPermittedReaders = this.teamMap.keys().filter((key) => {
+        const currentlyPermittedReaders = this.groupMap.keys().filter((key) => {
             if (key.startsWith("co_") || isAgentID(key)) {
-                const role = this.teamMap.get(key);
+                const role = this.groupMap.get(key);
                 return (
                     role === "admin" || role === "writer" || role === "reader"
                 );
@@ -128,7 +128,7 @@ export class Team {
             }
         }) as AccountIDOrAgentID[];
 
-        const maybeCurrentReadKey = this.teamMap.coValue.getCurrentReadKey();
+        const maybeCurrentReadKey = this.groupMap.coValue.getCurrentReadKey();
 
         if (!maybeCurrentReadKey.secret) {
             throw new Error(
@@ -143,7 +143,7 @@ export class Team {
 
         const newReadKey = newRandomKeySecret();
 
-        this.teamMap = this.teamMap.edit((map) => {
+        this.groupMap = this.groupMap.edit((map) => {
             for (const readerID of currentlyPermittedReaders) {
                 const reader = this.node.resolveAccountAgent(
                     readerID,
@@ -154,11 +154,11 @@ export class Team {
                     `${newReadKey.id}_for_${readerID}`,
                     seal(
                         newReadKey.secret,
-                        this.teamMap.coValue.node.account.currentSealerSecret(),
+                        this.groupMap.coValue.node.account.currentSealerSecret(),
                         getAgentSealerID(reader),
                         {
-                            in: this.teamMap.coValue.id,
-                            tx: this.teamMap.coValue.nextTransactionID(),
+                            in: this.groupMap.coValue.id,
+                            tx: this.groupMap.coValue.nextTransactionID(),
                         }
                     ),
                     "trusting"
@@ -179,7 +179,7 @@ export class Team {
     }
 
     removeMember(accountID: AccountIDOrAgentID) {
-        this.teamMap = this.teamMap.edit((map) => {
+        this.groupMap = this.groupMap.edit((map) => {
             map.set(accountID, "revoked", "trusting");
         });
 
@@ -194,8 +194,8 @@ export class Team {
             .createCoValue({
                 type: "comap",
                 ruleset: {
-                    type: "ownedByTeam",
-                    team: this.teamMap.id,
+                    type: "ownedByGroup",
+                    group: this.groupMap.id,
                 },
                 meta: meta || null,
                 ...createdNowUnique(),
@@ -206,10 +206,10 @@ export class Team {
     testWithDifferentAccount(
         account: GeneralizedControlledAccount,
         sessionId: SessionID
-    ): Team {
-        return new Team(
-            expectTeamContent(
-                this.teamMap.coValue
+    ): Group {
+        return new Group(
+            expectGroupContent(
+                this.groupMap.coValue
                     .testWithDifferentAccount(account, sessionId)
                     .getCurrentContent()
             ),

package/src/index.ts

@@ -14,7 +14,7 @@ import {
 import { connectedPeers } from "./streamUtils.js";
 import { AnonymousControlledAccount, ControlledAccount } from "./account.js";
 import { rawCoIDtoBytes, rawCoIDfromBytes } from "./ids.js";
-import { Team, expectTeamContent } from "./team.js"
+import { Group, expectGroupContent } from "./group.js"
 
 import type { SessionID, AgentID } from "./ids.js";
 import type { CoID, ContentType } from "./contentType.js";
@@ -27,7 +27,7 @@ import type {
     ProfileContent,
     Profile,
 } from "./account.js";
-import type { InviteSecret } from "./team.js";
+import type { InviteSecret } from "./group.js";
 
 type Value = JsonValue | ContentType;
 
@@ -44,7 +44,7 @@ export const cojsonInternals = {
     agentSecretFromSecretSeed,
     secretSeedLength,
     shortHashLength,
-    expectTeamContent
+    expectGroupContent
 };
 
 export {
@@ -53,7 +53,7 @@ export {
     CoMap,
     AnonymousControlledAccount,
     ControlledAccount,
-    Team
+    Group
 };
 
 export type {

package/src/node.ts

@@ -12,11 +12,11 @@ import {
 import { CoValue, CoValueHeader, newRandomSessionID } from "./coValue.js";
 import {
     InviteSecret,
-    Team,
-    TeamContent,
-    expectTeamContent,
+    Group,
+    GroupContent,
+    expectGroupContent,
     secretSeedFromInviteSecret,
-} from "./team.js";
+} from "./group.js";
 import { Peer, SyncManager } from "./sync.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
 import { CoID, ContentType } from "./contentType.js";
@@ -151,32 +151,32 @@ export class LocalNode {
     }
 
     async acceptInvite<T extends ContentType>(
-        teamOrOwnedValueID: CoID<T>,
+        groupOrOwnedValueID: CoID<T>,
         inviteSecret: InviteSecret
     ): Promise<void> {
-        const teamOrOwnedValue = await this.load(teamOrOwnedValueID);
+        const groupOrOwnedValue = await this.load(groupOrOwnedValueID);
 
-        if (teamOrOwnedValue.coValue.header.ruleset.type === "ownedByTeam") {
+        if (groupOrOwnedValue.coValue.header.ruleset.type === "ownedByGroup") {
             return this.acceptInvite(
-                teamOrOwnedValue.coValue.header.ruleset.team as CoID<
-                    CoMap<TeamContent>
+                groupOrOwnedValue.coValue.header.ruleset.group as CoID<
+                    CoMap<GroupContent>
                 >,
                 inviteSecret
             );
-        } else if (teamOrOwnedValue.coValue.header.ruleset.type !== "team") {
-            throw new Error("Can only accept invites to teams");
+        } else if (groupOrOwnedValue.coValue.header.ruleset.type !== "group") {
+            throw new Error("Can only accept invites to groups");
         }
 
-        const team = new Team(expectTeamContent(teamOrOwnedValue), this);
+        const group = new Group(expectGroupContent(groupOrOwnedValue), this);
 
         const inviteAgentSecret = agentSecretFromSecretSeed(
             secretSeedFromInviteSecret(inviteSecret)
         );
         const inviteAgentID = getAgentID(inviteAgentSecret);
 
-        const invitationRole = await new Promise((resolve, reject) => {
-            team.teamMap.subscribe((teamMap) => {
-                const role = teamMap.get(inviteAgentID);
+        const inviteRole = await new Promise((resolve, reject) => {
+            group.groupMap.subscribe((groupMap) => {
+                const role = groupMap.get(inviteAgentID);
                 if (role) {
                     resolve(role);
                 }
@@ -184,45 +184,47 @@ export class LocalNode {
             setTimeout(
                 () =>
                     reject(
-                        new Error("Couldn't find invitation before timeout")
+                        new Error("Couldn't find invite before timeout")
                     ),
                 1000
             );
         });
 
-        if (!invitationRole) {
-            throw new Error("No invitation found");
+        if (!inviteRole) {
+            throw new Error("No invite found");
         }
 
-        const existingRole = team.teamMap.get(this.account.id);
+        const existingRole = group.groupMap.get(this.account.id);
 
         if (
             existingRole === "admin" ||
-            (existingRole === "writer" && invitationRole === "reader")
+            (existingRole === "writer" && inviteRole === "writerInvite") ||
+            (existingRole === "writer" && inviteRole === "reader") ||
+            (existingRole === "reader" && inviteRole === "readerInvite")
         ) {
-            console.debug("Not accepting invite that would downgrade role");
+            console.debug("Not accepting invite that would replace or downgrade role");
             return;
         }
 
-        const teamAsInvite = team.testWithDifferentAccount(
+        const groupAsInvite = group.testWithDifferentAccount(
             new AnonymousControlledAccount(inviteAgentSecret),
             newRandomSessionID(inviteAgentID)
         );
 
-        teamAsInvite.addMember(
+        groupAsInvite.addMember(
             this.account.id,
-            invitationRole === "adminInvite"
+            inviteRole === "adminInvite"
                 ? "admin"
-                : invitationRole === "writerInvite"
+                : inviteRole === "writerInvite"
                 ? "writer"
                 : "reader"
         );
 
-        team.teamMap.coValue._sessions = teamAsInvite.teamMap.coValue.sessions;
-        team.teamMap.coValue._cachedContent = undefined;
+        group.groupMap.coValue._sessions = groupAsInvite.groupMap.coValue.sessions;
+        group.groupMap.coValue._cachedContent = undefined;
 
-        for (const teamListener of team.teamMap.coValue.listeners) {
-            teamListener(team.teamMap.coValue.getCurrentContent());
+        for (const groupListener of group.groupMap.coValue.listeners) {
+            groupListener(group.groupMap.coValue.getCurrentContent());
         }
     }
 
@@ -245,7 +247,7 @@ export class LocalNode {
 
     expectProfileLoaded(id: AccountID, expectation?: string): Profile {
         const account = this.expectCoValueLoaded(id, expectation);
-        const profileID = expectTeamContent(account.getCurrentContent()).get(
+        const profileID = expectGroupContent(account.getCurrentContent()).get(
             "profile"
         );
         if (!profileID) {
@@ -272,12 +274,12 @@ export class LocalNode {
             newRandomSessionID(getAgentID(agentSecret))
         );
 
-        const accountAsTeam = new Team(
-            expectTeamContent(account.getCurrentContent()),
+        const accountAsGroup = new Group(
+            expectGroupContent(account.getCurrentContent()),
             account.node
         );
 
-        accountAsTeam.teamMap.edit((editable) => {
+        accountAsGroup.groupMap.edit((editable) => {
             editable.set(getAgentID(agentSecret), "admin", "trusting");
 
             const readKey = newRandomKeySecret();
@@ -305,7 +307,7 @@ export class LocalNode {
             account.node
         );
 
-        const profile = accountAsTeam.createMap<ProfileContent, ProfileMeta>({
+        const profile = accountAsGroup.createMap<ProfileContent, ProfileMeta>({
             type: "profile",
         });
 
@@ -313,13 +315,13 @@ export class LocalNode {
             editable.set("name", name, "trusting");
         });
 
-        accountAsTeam.teamMap.edit((editable) => {
+        accountAsGroup.groupMap.edit((editable) => {
             editable.set("profile", profile.id, "trusting");
         });
 
         const accountOnThisNode = this.expectCoValueLoaded(account.id);
 
-        accountOnThisNode._sessions = {...accountAsTeam.teamMap.coValue.sessions};
+        accountOnThisNode._sessions = {...accountAsGroup.groupMap.coValue.sessions};
         accountOnThisNode._cachedContent = undefined;
 
         return controlledAccount;
@@ -334,7 +336,7 @@ export class LocalNode {
 
         if (
             coValue.header.type !== "comap" ||
-            coValue.header.ruleset.type !== "team" ||
+            coValue.header.ruleset.type !== "group" ||
             !coValue.header.meta ||
             !("type" in coValue.header.meta) ||
             coValue.header.meta.type !== "account"
@@ -347,22 +349,22 @@ export class LocalNode {
         }
 
         return new Account(
-            coValue.getCurrentContent() as CoMap<TeamContent, AccountMeta>,
+            coValue.getCurrentContent() as CoMap<GroupContent, AccountMeta>,
             this
         ).getCurrentAgentID();
     }
 
-    createTeam(): Team {
-        const teamCoValue = this.createCoValue({
+    createGroup(): Group {
+        const groupCoValue = this.createCoValue({
             type: "comap",
-            ruleset: { type: "team", initialAdmin: this.account.id },
+            ruleset: { type: "group", initialAdmin: this.account.id },
             meta: null,
             ...createdNowUnique(),
         });
 
-        let teamContent = expectTeamContent(teamCoValue.getCurrentContent());
+        let groupContent = expectGroupContent(groupCoValue.getCurrentContent());
 
-        teamContent = teamContent.edit((editable) => {
+        groupContent = groupContent.edit((editable) => {
             editable.set(this.account.id, "admin", "trusting");
 
             const readKey = newRandomKeySecret();
@@ -374,8 +376,8 @@ export class LocalNode {
                     this.account.currentSealerSecret(),
                     this.account.currentSealerID(),
                     {
-                        in: teamCoValue.id,
-                        tx: teamCoValue.nextTransactionID(),
+                        in: groupCoValue.id,
+                        tx: groupCoValue.nextTransactionID(),
                     }
                 ),
                 "trusting"
@@ -384,7 +386,7 @@ export class LocalNode {
             editable.set("readKey", readKey.id, "trusting");
         });
 
-        return new Team(teamContent, this);
+        return new Group(groupContent, this);
     }
 
     testWithDifferentAccount(