cojson 0.6.7 → 0.7.0-alpha.1

package/src/index.ts

@@ -6,15 +6,10 @@ import {
 } from "./coValueCore.js";
 import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
 import { LocalNode } from "./localNode.js";
-import type { CoValue } from "./coValue.js";
-import { CoMap, MutableCoMap } from "./coValues/coMap.js";
-import { CoList, MutableCoList } from "./coValues/coList.js";
-import {
-    CoStream,
-    MutableCoStream,
-    BinaryCoStream,
-    MutableBinaryCoStream,
-} from "./coValues/coStream.js";
+import type { RawCoValue } from "./coValue.js";
+import { RawCoMap } from "./coValues/coMap.js";
+import { RawCoList } from "./coValues/coList.js";
+import { RawCoStream, RawBinaryCoStream } from "./coValues/coStream.js";
 import {
     agentSecretFromBytes,
     agentSecretToBytes,
@@ -27,22 +22,23 @@ import {
     cryptoReady,
 } from "./crypto.js";
 import { connectedPeers } from "./streamUtils.js";
-import {
-    ControlledAgent,
-    ControlledAccount,
-} from "./coValues/account.js";
+import { ControlledAgent, RawControlledAccount } from "./coValues/account.js";
 import type { Role } from "./permissions.js";
-import { rawCoIDtoBytes, rawCoIDfromBytes } from "./ids.js";
-import { Group, EVERYONE } from "./coValues/group.js";
+import { rawCoIDtoBytes, rawCoIDfromBytes, isRawCoID } from "./ids.js";
+import { RawGroup, EVERYONE } from "./coValues/group.js";
 import type { Everyone } from "./coValues/group.js";
 import { base64URLtoBytes, bytesToBase64url } from "./base64url.js";
 import { parseJSON } from "./jsonStringify.js";
-import { Account, Profile, accountHeaderForInitialAgentSecret } from "./coValues/account.js";
+import {
+    RawAccount,
+    RawProfile,
+    accountHeaderForInitialAgentSecret,
+} from "./coValues/account.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
 import { isAccountID } from "./typeUtils/isAccountID.js";
 
 import type { SessionID, AgentID } from "./ids.js";
-import type { CoID, AnyCoValue } from "./coValue.js";
+import type { CoID, AnyRawCoValue } from "./coValue.js";
 import type {
     BinaryStreamInfo,
     BinaryCoStreamMeta,
@@ -53,13 +49,13 @@ import type { AgentSecret } from "./crypto.js";
 import type {
     AccountID,
     AccountMeta,
-    AccountMigration,
+    RawAccountMigration,
     ProfileMeta,
 } from "./coValues/account.js";
 import type { InviteSecret } from "./coValues/group.js";
 import type * as Media from "./media.js";
 
-type Value = JsonValue | AnyCoValue;
+type Value = JsonValue | AnyRawCoValue;
 
 /** @hidden */
 export const cojsonInternals = {
@@ -82,37 +78,33 @@ export const cojsonInternals = {
     accountOrAgentIDfromSessionID,
     isAccountID,
     accountHeaderForInitialAgentSecret,
-    idforHeader
+    idforHeader,
 };
 
 export {
     LocalNode,
-    Group,
+    RawGroup,
     Role,
     EVERYONE,
     Everyone,
-    CoMap,
-    MutableCoMap,
-    CoList,
-    MutableCoList,
-    CoStream,
-    MutableCoStream,
-    BinaryCoStream,
-    MutableBinaryCoStream,
-    CoValue,
+    RawCoMap,
+    RawCoList,
+    RawCoStream,
+    RawBinaryCoStream,
+    RawCoValue,
     CoID,
-    AnyCoValue,
-    Account,
+    AnyRawCoValue,
+    RawAccount,
     AccountID,
     AccountMeta,
-    AccountMigration,
-    Profile,
+    RawAccountMigration,
+    RawProfile as Profile,
     ProfileMeta,
     SessionID,
     Media,
     CoValueCore,
     ControlledAgent,
-    ControlledAccount,
+    RawControlledAccount,
     cryptoReady as cojsonReady,
     MAX_RECOMMENDED_TX_SIZE,
     JsonValue,
@@ -123,11 +115,10 @@ export {
     AgentSecret,
     InviteSecret,
     SyncMessage,
+    isRawCoID
 };
 
-export type {
-    Value,
-}
+export type { Value };
 
 // eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace CojsonInternalTypes {
@@ -145,4 +136,5 @@ export namespace CojsonInternalTypes {
     export type ProfileMeta = import("./coValues/account.js").ProfileMeta;
     export type SealerSecret = import("./crypto.js").SealerSecret;
     export type SignerSecret = import("./crypto.js").SignerSecret;
+    export type JsonObject = import("./jsonValue.js").JsonObject;
 }

package/src/jsonValue.ts

@@ -2,5 +2,5 @@ import { RawCoID } from './ids.js';
 
 export type JsonAtom = string | number | boolean | null;
 export type JsonValue = JsonAtom | JsonArray | JsonObject | RawCoID;
-export type JsonArray = JsonValue[];
+export type JsonArray = JsonValue[] | readonly JsonValue[];
 export type JsonObject = { [key: string]: JsonValue | undefined; };

package/src/localNode.ts

@@ -16,25 +16,25 @@ import {
 } from "./coValueCore.js";
 import {
     InviteSecret,
-    Group,
+    RawGroup,
     secretSeedFromInviteSecret,
 } from "./coValues/group.js";
 import { Peer, PeerID, SyncManager } from "./sync.js";
 import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
 import { CoID } from "./coValue.js";
 import {
-    Account,
+    RawAccount,
     AccountMeta,
     accountHeaderForInitialAgentSecret,
     ControlledAccountOrAgent,
-    ControlledAccount,
+    RawControlledAccount,
     ControlledAgent,
     AccountID,
-    Profile,
-    AccountMigration,
+    RawProfile,
+    RawAccountMigration,
 } from "./coValues/account.js";
-import { CoMap } from "./coValues/coMap.js";
-import { CoValue } from "./index.js";
+import { RawCoMap } from "./coValues/coMap.js";
+import { RawCoValue } from "./index.js";
 import { expectGroup } from "./typeUtils/expectGroup.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).
@@ -69,8 +69,6 @@ export class LocalNode {
 
     /** @category 2. Node Creation */
     static async withNewlyCreatedAccount<
-        P extends Profile = Profile,
-        R extends CoMap = CoMap,
         Meta extends AccountMeta = AccountMeta
     >({
         name,
@@ -80,7 +78,7 @@ export class LocalNode {
     }: {
         name: string;
         peersToLoadFrom?: Peer[];
-        migration?: AccountMigration<P, R, Meta>;
+        migration?: RawAccountMigration<Meta>;
         initialAgentSecret?: AgentSecret;
     }): Promise<{
         node: LocalNode;
@@ -102,7 +100,7 @@ export class LocalNode {
         );
 
         const accountOnNodeWithAccount =
-            nodeWithAccount.account as ControlledAccount<P, R, Meta>;
+            nodeWithAccount.account as RawControlledAccount<Meta>;
 
         const profile = nodeWithAccount.expectProfileLoaded(
             accountOnNodeWithAccount.id,
@@ -116,19 +114,30 @@ export class LocalNode {
         }
 
         if (migration) {
-            await migration(accountOnNodeWithAccount, profile as P, nodeWithAccount);
+            await migration(accountOnNodeWithAccount, profile, nodeWithAccount);
         }
 
-        nodeWithAccount.account = new ControlledAccount(
+        const controlledAccount = new RawControlledAccount(
             accountOnNodeWithAccount.core,
             accountOnNodeWithAccount.agentSecret
         );
 
+        nodeWithAccount.account = controlledAccount
+        nodeWithAccount.coValues[controlledAccount.id] = {
+            state: "loaded",
+            coValue: controlledAccount.core,
+        };
+        controlledAccount.core._cachedContent = undefined;
+
         // we shouldn't need this, but it fixes account data not syncing for new accounts
         function syncAllCoValuesAfterCreateAccount() {
-            for (const coValueEntry of Object.values(nodeWithAccount.coValues)) {
+            for (const coValueEntry of Object.values(
+                nodeWithAccount.coValues
+            )) {
                 if (coValueEntry.state === "loaded") {
-                    void nodeWithAccount.syncManager.syncCoValue(coValueEntry.coValue);
+                    void nodeWithAccount.syncManager.syncCoValue(
+                        coValueEntry.coValue
+                    );
                 }
             }
         }
@@ -146,11 +155,7 @@ export class LocalNode {
     }
 
     /** @category 2. Node Creation */
-    static async withLoadedAccount<
-        P extends Profile = Profile,
-        R extends CoMap = CoMap,
-        Meta extends AccountMeta = AccountMeta
-    >({
+    static async withLoadedAccount<Meta extends AccountMeta = AccountMeta>({
         accountID,
         accountSecret,
         sessionID,
@@ -161,7 +166,7 @@ export class LocalNode {
         accountSecret: AgentSecret;
         sessionID: SessionID;
         peersToLoadFrom: Peer[];
-        migration?: AccountMigration<P, R, Meta>;
+        migration?: RawAccountMigration<Meta>;
     }): Promise<LocalNode> {
         const loadingNode = new LocalNode(
             new ControlledAgent(accountSecret),
@@ -180,7 +185,7 @@ export class LocalNode {
             throw new Error("Account unavailable from all peers");
         }
 
-        const controlledAccount = new ControlledAccount(
+        const controlledAccount = new RawControlledAccount(
             account.core,
             accountSecret
         );
@@ -198,6 +203,7 @@ export class LocalNode {
             state: "loaded",
             coValue: controlledAccount.core,
         };
+        controlledAccount.core._cachedContent = undefined;
 
         const profileID = account.get("profile");
         if (!profileID) {
@@ -205,13 +211,17 @@ export class LocalNode {
         }
         const profile = await node.load(profileID);
 
+        if (profile === "unavailable") {
+            throw new Error("Profile unavailable from all peers");
+        }
+
         if (migration) {
             await migration(
-                controlledAccount as ControlledAccount<P, R, Meta>,
-                profile as P,
+                controlledAccount as RawControlledAccount<Meta>,
+                profile,
                 node
             );
-            node.account = new ControlledAccount(
+            node.account = new RawControlledAccount(
                 controlledAccount.core,
                 controlledAccount.agentSecret
             );
@@ -275,7 +285,7 @@ export class LocalNode {
      *
      * @category 3. Low-level
      */
-    async load<T extends CoValue>(
+    async load<T extends RawCoValue>(
         id: CoID<T>,
         onProgress?: (progress: number) => void
     ): Promise<T | "unavailable"> {
@@ -288,8 +298,19 @@ export class LocalNode {
         return core.getCurrentContent() as T;
     }
 
+    getLoaded<T extends RawCoValue>(id: CoID<T>): T | undefined {
+        const entry = this.coValues[id];
+        if (!entry) {
+            return undefined;
+        }
+        if (entry.state === "loaded") {
+            return entry.coValue.getCurrentContent() as T;
+        }
+        return undefined;
+    }
+
     /** @category 3. Low-level */
-    subscribe<T extends CoValue>(
+    subscribe<T extends RawCoValue>(
         id: CoID<T>,
         callback: (update: T | "unavailable") => void
     ): () => void {
@@ -321,7 +342,7 @@ export class LocalNode {
     }
 
     /** @deprecated Use Account.acceptInvite instead */
-    async acceptInvite<T extends CoValue>(
+    async acceptInvite<T extends RawCoValue>(
         groupOrOwnedValueID: CoID<T>,
         inviteSecret: InviteSecret
     ): Promise<void> {
@@ -335,7 +356,7 @@ export class LocalNode {
 
         if (groupOrOwnedValue.core.header.ruleset.type === "ownedByGroup") {
             return this.acceptInvite(
-                groupOrOwnedValue.core.header.ruleset.group as CoID<Group>,
+                groupOrOwnedValue.core.header.ruleset.group as CoID<RawGroup>,
                 inviteSecret
             );
         } else if (groupOrOwnedValue.core.header.ruleset.type !== "group") {
@@ -425,7 +446,7 @@ export class LocalNode {
     }
 
     /** @internal */
-    expectProfileLoaded(id: AccountID, expectation?: string): Profile {
+    expectProfileLoaded(id: AccountID, expectation?: string): RawProfile {
         const account = this.expectCoValueLoaded(id, expectation);
         const profileID = expectGroup(account.getCurrentContent()).get(
             "profile"
@@ -440,14 +461,14 @@ export class LocalNode {
         return this.expectCoValueLoaded(
             profileID,
             expectation
-        ).getCurrentContent() as Profile;
+        ).getCurrentContent() as RawProfile;
     }
 
     /** @internal */
     createAccount(
         name: string,
         agentSecret = newRandomAgentSecret()
-    ): ControlledAccount {
+    ): RawControlledAccount {
         const accountAgentID = getAgentID(agentSecret);
         let account = expectGroup(
             this.createCoValue(accountHeaderForInitialAgentSecret(agentSecret))
@@ -458,31 +479,25 @@ export class LocalNode {
                 .getCurrentContent()
         );
 
-        account = account.mutate((editable) => {
-            editable.set(accountAgentID, "admin", "trusting");
+        account.set(accountAgentID, "admin", "trusting");
 
-            const readKey = newRandomKeySecret();
+        const readKey = newRandomKeySecret();
 
-            const sealed = seal({
-                message: readKey.secret,
-                from: getAgentSealerSecret(agentSecret),
-                to: getAgentSealerID(accountAgentID),
-                nOnceMaterial: {
-                    in: account.id,
-                    tx: account.core.nextTransactionID(),
-                },
-            });
+        const sealed = seal({
+            message: readKey.secret,
+            from: getAgentSealerSecret(agentSecret),
+            to: getAgentSealerID(accountAgentID),
+            nOnceMaterial: {
+                in: account.id,
+                tx: account.core.nextTransactionID(),
+            },
+        });
 
-            editable.set(
-                `${readKey.id}_for_${accountAgentID}`,
-                sealed,
-                "trusting"
-            );
+        account.set(`${readKey.id}_for_${accountAgentID}`, sealed, "trusting");
 
-            editable.set("readKey", readKey.id, "trusting");
-        });
+        account.set("readKey", readKey.id, "trusting");
 
-        const profile = account.createMap<Profile>(
+        const profile = account.createMap<RawProfile>(
             { name },
             {
                 type: "profile",
@@ -490,7 +505,7 @@ export class LocalNode {
             "trusting"
         );
 
-        account = account.set("profile", profile.id, "trusting");
+        account.set("profile", profile.id, "trusting");
 
         const accountOnThisNode = this.expectCoValueLoaded(account.id);
 
@@ -503,7 +518,7 @@ export class LocalNode {
         profileOnThisNode._sessionLogs = new Map(profile.core.sessionLogs);
         profileOnThisNode._cachedContent = undefined;
 
-        return new ControlledAccount(accountOnThisNode, agentSecret);
+        return new RawControlledAccount(accountOnThisNode, agentSecret);
     }
 
     /** @internal */
@@ -531,7 +546,7 @@ export class LocalNode {
             );
         }
 
-        return new Account(coValue).currentAgentID();
+        return new RawAccount(coValue).currentAgentID();
     }
 
     async resolveAccountAgentAsync(
@@ -566,13 +581,13 @@ export class LocalNode {
             );
         }
 
-        return new Account(coValue).currentAgentID();
+        return new RawAccount(coValue).currentAgentID();
     }
 
     /**
      * @deprecated use Account.createGroup() instead
      */
-    createGroup(): Group {
+    createGroup(): RawGroup {
         const groupCoValue = this.createCoValue({
             type: "comap",
             ruleset: { type: "group", initialAdmin: this.account.id },
@@ -582,27 +597,25 @@ export class LocalNode {
 
         let group = expectGroup(groupCoValue.getCurrentContent());
 
-        group = group.mutate((editable) => {
-            editable.set(this.account.id, "admin", "trusting");
-
-            const readKey = newRandomKeySecret();
-
-            editable.set(
-                `${readKey.id}_for_${this.account.id}`,
-                seal({
-                    message: readKey.secret,
-                    from: this.account.currentSealerSecret(),
-                    to: this.account.currentSealerID(),
-                    nOnceMaterial: {
-                        in: groupCoValue.id,
-                        tx: groupCoValue.nextTransactionID(),
-                    },
-                }),
-                "trusting"
-            );
+        group.set(this.account.id, "admin", "trusting");
 
-            editable.set("readKey", readKey.id, "trusting");
-        });
+        const readKey = newRandomKeySecret();
+
+        group.set(
+            `${readKey.id}_for_${this.account.id}`,
+            seal({
+                message: readKey.secret,
+                from: this.account.currentSealerSecret(),
+                to: this.account.currentSealerID(),
+                nOnceMaterial: {
+                    in: groupCoValue.id,
+                    tx: groupCoValue.nextTransactionID(),
+                },
+            }),
+            "trusting"
+        );
+
+        group.set("readKey", readKey.id, "trusting");
 
         return group;
     }
@@ -649,9 +662,9 @@ export class LocalNode {
             }
         }
 
-        if (account instanceof ControlledAccount) {
+        if (account instanceof RawControlledAccount) {
             // To make sure that when we edit the account, we're modifying the correct sessions
-            const accountInNode = new ControlledAccount(
+            const accountInNode = new RawControlledAccount(
                 newNode.expectCoValueLoaded(account.id),
                 account.agentSecret
             );

package/src/media.ts

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

package/src/permissions.ts

@@ -5,7 +5,7 @@ import { KeyID } from "./crypto.js";
 import { CoValueCore, Transaction } from "./coValueCore.js";
 import { accountOrAgentIDfromSessionID } from "./typeUtils/accountOrAgentIDfromSessionID.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
-import { Account, AccountID, Profile } from "./coValues/account.js";
+import { RawAccount, AccountID, RawProfile } from "./coValues/account.js";
 import { parseJSON } from "./jsonStringify.js";
 import { EVERYONE, Everyone } from "./coValues/group.js";
 import { expectGroup } from "./typeUtils/expectGroup.js";
@@ -101,7 +101,7 @@ export function determineValidTransactions(
             const change = changes[0] as
                 | MapOpPayload<AccountID | AgentID | Everyone, Role>
                 | MapOpPayload<"readKey", JsonValue>
-                | MapOpPayload<"profile", CoID<Profile>>;
+                | MapOpPayload<"profile", CoID<RawProfile>>;
             if (changes.length !== 1) {
                 console.warn("Group transaction must have exactly one change");
                 continue;
@@ -248,7 +248,7 @@ export function determineValidTransactions(
                         const groupAtTime = groupContent.atTime(tx.madeAt);
                         const effectiveTransactor =
                             transactor === groupContent.id &&
-                            groupAtTime instanceof Account
+                            groupAtTime instanceof RawAccount
                                 ? groupAtTime.currentAgentID()
                                 : transactor;
                         const transactorRoleAtTxTime =

package/src/tests/account.test.ts

@@ -1,8 +1,15 @@
+import { expect, test, beforeEach } from "vitest";
 import { newRandomSessionID } from "../coValueCore.js";
 import { cojsonReady } from "../index.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
 
+import { webcrypto } from "node:crypto";
+if (!("crypto" in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).crypto = webcrypto;
+}
+
 beforeEach(async () => {
     await cojsonReady;
 });
@@ -29,14 +36,9 @@ test("A node with an account can create groups and and objects within them", asy
     const group = await node.createGroup();
     expect(group).not.toBeNull();
 
-    let map = group.createMap();
-    map = map.edit((edit) => {
-        edit.set("foo", "bar", "private");
-        expect(edit.get("foo")).toEqual("bar");
-    });
-
+    const map = group.createMap();
+    map.set("foo", "bar", "private");
     expect(map.get("foo")).toEqual("bar");
-
     expect(map.lastEditAt("foo")?.by).toEqual(accountID);
 });
 
@@ -47,11 +49,9 @@ test("Can create account with one node, and then load it on another", async () =
     const group = await node.createGroup();
     expect(group).not.toBeNull();
 
-    let map = group.createMap();
-    map = map.edit((edit) => {
-        edit.set("foo", "bar", "private");
-        expect(edit.get("foo")).toEqual("bar");
-    });
+    const map = group.createMap();
+    map.set("foo", "bar", "private");
+    expect(map.get("foo")).toEqual("bar");
 
     const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {
         trace: true,