cojson 0.6.7 → 0.7.0-alpha.0

package/src/coValues/coStream.ts

@@ -1,10 +1,10 @@
 import { JsonObject, JsonValue } from "../jsonValue.js";
-import { CoValue, CoID } from "../coValue.js";
+import { RawCoValue, CoID } from "../coValue.js";
 import { isAccountID } from "../typeUtils/isAccountID.js";
 import { isCoValue } from "../typeUtils/isCoValue.js";
 import { CoValueCore } from "../coValueCore.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
-import { Group } from "./group.js";
+import { RawGroup } from "./group.js";
 import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { base64URLtoBytes, bytesToBase64url } from "../base64url.js";
 import { AccountID } from "./account.js";
@@ -41,10 +41,10 @@ export type CoStreamItem<Item extends JsonValue> = {
     madeAt: number;
 };
 
-export class CoStreamView<
+export class RawCoStreamView<
     Item extends JsonValue = JsonValue,
     Meta extends JsonObject | null = JsonObject | null
-> implements CoValue
+> implements RawCoValue
 {
     id: CoID<this>;
     type = "costream" as const;
@@ -65,7 +65,7 @@ export class CoStreamView<
         return this.core.header.meta as Meta;
     }
 
-    get group(): Group {
+    get group(): RawGroup {
         return this.core.getGroup();
     }
 
@@ -95,9 +95,7 @@ export class CoStreamView<
         }
     }
 
-    getSingleStream():
-        | (Item)[]
-        | undefined {
+    getSingleStream(): Item[] | undefined {
         if (Object.keys(this.items).length === 0) {
             return undefined;
         } else if (Object.keys(this.items).length !== 1) {
@@ -114,7 +112,11 @@ export class CoStreamView<
     }
 
     accounts(): Set<AccountID> {
-        return new Set(this.sessions().map(accountOrAgentIDfromSessionID).filter(isAccountID));
+        return new Set(
+            this.sessions()
+                .map(accountOrAgentIDfromSessionID)
+                .filter(isAccountID)
+        );
     }
 
     nthItemIn(
@@ -224,7 +226,7 @@ export class CoStreamView<
     }
 
     toJSON(): {
-        [key: SessionID]: (Item )[];
+        [key: SessionID]: Item[];
     } {
         return Object.fromEntries(
             Object.entries(this.items).map(([sessionID, items]) => [
@@ -241,44 +243,14 @@ export class CoStreamView<
     }
 }
 
-export class CoStream<
+export class RawCoStream<
         Item extends JsonValue = JsonValue,
         Meta extends JsonObject | null = JsonObject | null
     >
-    extends CoStreamView<Item, Meta>
-    implements CoValue
+    extends RawCoStreamView<Item, Meta>
+    implements RawCoValue
 {
-    push(
-        item: Item,
-        privacy: "private" | "trusting" = "private"
-    ): this {
-        this.core.makeTransaction([isCoValue(item) ? item.id : item], privacy);
-        return new CoStream(this.core) as this;
-    }
-
-    mutate(mutator: (mutable: MutableCoStream<Item, Meta>) => void): this {
-        const mutable = new MutableCoStream<Item, Meta>(this.core);
-        mutator(mutable);
-        return new CoStream(this.core) as this;
-    }
-
-    /** @deprecated Use `mutate` instead. */
-    edit(mutator: (mutable: MutableCoStream<Item, Meta>) => void): this {
-        return this.mutate(mutator);
-    }
-}
-
-export class MutableCoStream<
-        Item extends JsonValue,
-        Meta extends JsonObject | null = JsonObject | null
-    >
-    extends CoStreamView<Item, Meta>
-    implements CoValue
-{
-    push(
-        item: Item,
-        privacy: "private" | "trusting" = "private"
-    ) {
+    push(item: Item, privacy: "private" | "trusting" = "private"): void {
         this.core.makeTransaction([isCoValue(item) ? item.id : item], privacy);
         this.fillFromCoValue();
     }
@@ -286,14 +258,14 @@ export class MutableCoStream<
 
 const binary_U_prefixLength = 8; // "binary_U".length;
 
-export class BinaryCoStreamView<
+export class RawBinaryCoStreamView<
         Meta extends BinaryCoStreamMeta = { type: "binary" }
     >
-    extends CoStreamView<BinaryStreamItem, Meta>
-    implements CoValue
+    extends RawCoStreamView<BinaryStreamItem, Meta>
+    implements RawCoValue
 {
     getBinaryChunks(
-        allowUnfinished?: boolean,
+        allowUnfinished?: boolean
     ):
         | (BinaryStreamInfo & { chunks: Uint8Array[]; finished: boolean })
         | undefined {
@@ -358,35 +330,21 @@ export class BinaryCoStreamView<
     }
 }
 
-export class BinaryCoStream<
+export class RawBinaryCoStream<
         Meta extends BinaryCoStreamMeta = { type: "binary" }
     >
-    extends BinaryCoStreamView<Meta>
-    implements CoValue
+    extends RawBinaryCoStreamView<Meta>
+    implements RawCoValue
 {
     /** @internal */
-    push(
-        item: BinaryStreamItem,
-        privacy?: "private" | "trusting",
-    ): this
-    push(
-        item: BinaryStreamItem,
-        privacy: "private" | "trusting",
-        returnNewStream: true
-    ): this
-    push(
-        item: BinaryStreamItem,
-        privacy: "private" | "trusting",
-        returnNewStream: false
-    ): void
     push(
         item: BinaryStreamItem,
         privacy: "private" | "trusting" = "private",
-        returnNewStream: boolean = true
-    ): this | void {
+        updateView: boolean = true
+    ): void {
         this.core.makeTransaction([item], privacy);
-        if (returnNewStream) {
-            return new BinaryCoStream(this.core) as this;
+        if (updateView) {
+            this.fillFromCoValue();
         }
     }
 
@@ -394,7 +352,7 @@ export class BinaryCoStream<
         settings: BinaryStreamInfo,
         privacy: "private" | "trusting" = "private"
     ): void {
-        return this.push(
+        this.push(
             {
                 type: "start",
                 ...settings,
@@ -409,7 +367,7 @@ export class BinaryCoStream<
         privacy: "private" | "trusting" = "private"
     ): void {
         // const before = performance.now();
-        return this.push(
+        this.push(
             {
                 type: "chunk",
                 chunk: `binary_U${bytesToBase64url(chunk)}`,
@@ -424,77 +382,13 @@ export class BinaryCoStream<
         // );
     }
 
-    endBinaryStream(privacy: "private" | "trusting" = "private"): this {
-        return this.push(
-            {
-                type: "end",
-            } satisfies BinaryStreamEnd,
-            privacy,
-            true
-        );
-    }
-
-    mutate(mutator: (mutable: MutableBinaryCoStream<Meta>) => void): this {
-        const mutable = new MutableBinaryCoStream<Meta>(this.core);
-        mutator(mutable);
-        return new BinaryCoStream(this.core) as this;
-    }
-
-    /** @deprecated Use `mutate` instead. */
-    edit(mutator: (mutable: MutableBinaryCoStream<Meta>) => void): this {
-        return this.mutate(mutator);
-    }
-}
-
-export class MutableBinaryCoStream<
-        Meta extends BinaryCoStreamMeta = { type: "binary" }
-    >
-    extends BinaryCoStreamView<Meta>
-    implements CoValue
-{
-    /** @internal */
-    push(item: BinaryStreamItem, privacy: "private" | "trusting" = "private") {
-        MutableCoStream.prototype.push.call(this, item, privacy);
-    }
-
-    startBinaryStream(
-        settings: BinaryStreamInfo,
-        privacy: "private" | "trusting" = "private"
-    ) {
-        this.push(
-            {
-                type: "start",
-                ...settings,
-            } satisfies BinaryStreamStart,
-            privacy
-        );
-    }
-
-    pushBinaryStreamChunk(
-        chunk: Uint8Array,
-        privacy: "private" | "trusting" = "private"
-    ) {
-        // const before = performance.now();
-        this.push(
-            {
-                type: "chunk",
-                chunk: `binary_U${bytesToBase64url(chunk)}`,
-            } satisfies BinaryStreamChunk,
-            privacy
-        );
-        // const after = performance.now();
-        // console.log(
-        //     "pushBinaryStreamChunk bandwidth in MB/s",
-        //     (1000 * chunk.length) / (after - before) / (1024 * 1024)
-        // );
-    }
-
     endBinaryStream(privacy: "private" | "trusting" = "private") {
         this.push(
             {
                 type: "end",
             } satisfies BinaryStreamEnd,
-            privacy
+            privacy,
+            true
         );
     }
 }

package/src/coValues/group.ts

@@ -1,8 +1,8 @@
 import { CoID } from "../coValue.js";
-import { CoMap } from "./coMap.js";
-import { CoList } from "./coList.js";
+import { RawCoMap } from "./coMap.js";
+import { RawCoList } from "./coList.js";
 import { JsonObject } from "../jsonValue.js";
-import { BinaryCoStream, CoStream } from "./coStream.js";
+import { RawBinaryCoStream, RawCoStream } from "./coStream.js";
 import {
     Encrypted,
     KeyID,
@@ -18,16 +18,20 @@ import {
     getAgentID,
 } from "../crypto.js";
 import { AgentID, isAgentID } from "../ids.js";
-import { Account, AccountID, ControlledAccountOrAgent, Profile } from "./account.js";
+import {
+    RawAccount,
+    AccountID,
+    ControlledAccountOrAgent,
+} from "./account.js";
 import { Role } from "../permissions.js";
 import { base58 } from "@scure/base";
 
 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;
+export type GroupShape = {
+    profile: CoID<RawCoMap> | null;
+    root: CoID<RawCoMap> | null;
     [key: AccountID | AgentID]: Role;
     [EVERYONE]?: Role;
     readKey?: KeyID;
@@ -60,11 +64,9 @@ export type GroupShape<P extends Profile, R extends CoMap> = {
  *  const localNode.createGroup();
  *  ```
  * */
-export class Group<
-    P extends Profile = Profile,
-    R extends CoMap = CoMap,
+export class RawGroup<
     Meta extends JsonObject | null = JsonObject | null
-> extends CoMap<GroupShape<P, R>, Meta> {
+> extends RawCoMap<GroupShape, Meta> {
     /**
      * Returns the current role of a given account.
      *
@@ -94,16 +96,18 @@ export class Group<
      *
      * @category 2. Role changing
      */
-    addMember(account: Account | ControlledAccountOrAgent | Everyone, role: Role): this {
-        return this.addMemberInternal(account, role);
+    addMember(
+        account: RawAccount | ControlledAccountOrAgent | Everyone,
+        role: Role
+    ) {
+        this.addMemberInternal(account, role);
     }
 
     /** @internal */
     addMemberInternal(
-        account: Account | ControlledAccountOrAgent | AgentID | Everyone,
+        account: RawAccount | ControlledAccountOrAgent | AgentID | Everyone,
         role: Role
-    ): this {
-        return this.mutate((mutable) => {
+    ) {
             const currentReadKey = this.core.getCurrentReadKey();
 
             if (!currentReadKey.secret) {
@@ -116,27 +120,31 @@ export class Group<
                         "Can't make everyone something other than reader or writer"
                     );
                 }
-                mutable.set(account, role, "trusting");
+                this.set(account, role, "trusting");
 
-                if (mutable.get(account) !== role) {
+                if (this.get(account) !== role) {
                     throw new Error("Failed to set role");
                 }
 
-                mutable.set(
+                this.set(
                     `${currentReadKey.id}_for_${EVERYONE}`,
                     currentReadKey.secret,
                     "trusting"
                 );
             } else {
-                const memberKey = typeof account === "string" ? account : account.id;
-                const agent = typeof account === "string" ? account : account.currentAgentID();
-                mutable.set(memberKey, role, "trusting");
-
-                if (mutable.get(memberKey) !== role) {
+                const memberKey =
+                    typeof account === "string" ? account : account.id;
+                const agent =
+                    typeof account === "string"
+                        ? account
+                        : account.currentAgentID();
+                this.set(memberKey, role, "trusting");
+
+                if (this.get(memberKey) !== role) {
                     throw new Error("Failed to set role");
                 }
 
-                mutable.set(
+                this.set(
                     `${currentReadKey.id}_for_${memberKey}`,
                     seal({
                         message: currentReadKey.secret,
@@ -150,11 +158,10 @@ export class Group<
                     "trusting"
                 );
             }
-        });
     }
 
     /** @internal */
-    rotateReadKey(): this {
+    rotateReadKey() {
         const currentlyPermittedReaders = this.keys().filter((key) => {
             if (key.startsWith("co_") || isAgentID(key)) {
                 const role = this.get(key);
@@ -181,14 +188,13 @@ export class Group<
 
         const newReadKey = newRandomKeySecret();
 
-        return this.mutate((mutable) => {
             for (const readerID of currentlyPermittedReaders) {
                 const reader = this.core.node.resolveAccountAgent(
                     readerID,
                     "Expected to know currently permitted reader"
                 );
 
-                mutable.set(
+                this.set(
                     `${newReadKey.id}_for_${readerID}`,
                     seal({
                         message: newReadKey.secret,
@@ -203,7 +209,7 @@ export class Group<
                 );
             }
 
-            mutable.set(
+            this.set(
                 `${currentReadKey.id}_for_${newReadKey.id}`,
                 encryptKeySecret({
                     encrypting: newReadKey,
@@ -212,8 +218,7 @@ export class Group<
                 "trusting"
             );
 
-            mutable.set("readKey", newReadKey.id, "trusting");
-        });
+            this.set("readKey", newReadKey.id, "trusting");
     }
 
     /**
@@ -223,16 +228,17 @@ export class Group<
      *
      * @category 2. Role changing
      */
-    removeMember(account: Account | ControlledAccountOrAgent | Everyone): this {
-        return this.removeMemberInternal(account);
+    removeMember(account: RawAccount | ControlledAccountOrAgent | Everyone) {
+        this.removeMemberInternal(account);
     }
 
     /** @internal */
-    removeMemberInternal(account: Account | ControlledAccountOrAgent | AgentID | Everyone): this {
+    removeMemberInternal(
+        account: RawAccount | ControlledAccountOrAgent | AgentID | Everyone
+    ) {
         const memberKey = typeof account === "string" ? account : account.id;
-        const afterRevoke = this.set(memberKey, "revoked", "trusting");
-
-        return afterRevoke.rotateReadKey();
+         this.set(memberKey, "revoked", "trusting");
+        this.rotateReadKey();
     }
 
     /**
@@ -259,12 +265,12 @@ export class Group<
      *
      * @category 3. Value creation
      */
-    createMap<M extends CoMap>(
+    createMap<M extends RawCoMap>(
         init?: M["_shape"],
         meta?: M["headerMeta"],
         initPrivacy: "trusting" | "private" = "private"
     ): M {
-        let map = this.core.node
+        const map = this.core.node
             .createCoValue({
                 type: "comap",
                 ruleset: {
@@ -278,7 +284,7 @@ export class Group<
 
         if (init) {
             for (const [key, value] of Object.entries(init)) {
-                map = map.set(key, value, initPrivacy);
+                map.set(key, value, initPrivacy);
             }
         }
 
@@ -291,12 +297,12 @@ export class Group<
      *
      * @category 3. Value creation
      */
-    createList<L extends CoList>(
+    createList<L extends RawCoList>(
         init?: L["_item"][],
         meta?: L["headerMeta"],
         initPrivacy: "trusting" | "private" = "private"
     ): L {
-        let list = this.core.node
+        const list = this.core.node
             .createCoValue({
                 type: "colist",
                 ruleset: {
@@ -310,7 +316,7 @@ export class Group<
 
         if (init) {
             for (const item of init) {
-                list = list.append(item, undefined, initPrivacy);
+                list.append(item, undefined, initPrivacy);
             }
         }
 
@@ -318,7 +324,7 @@ export class Group<
     }
 
     /** @category 3. Value creation */
-    createStream<C extends CoStream>(meta?: C["headerMeta"]): C {
+    createStream<C extends RawCoStream>(meta?: C["headerMeta"]): C {
         return this.core.node
             .createCoValue({
                 type: "costream",
@@ -333,7 +339,7 @@ export class Group<
     }
 
     /** @category 3. Value creation */
-    createBinaryStream<C extends BinaryCoStream>(
+    createBinaryStream<C extends RawBinaryCoStream>(
         meta: C["headerMeta"] = { type: "binary" }
     ): C {
         return this.core.node

package/src/coreToCoValue.ts

@@ -1,10 +1,10 @@
 import type { CoValueCore } from "./coValueCore.js";
-import { Account } from "./coValues/account.js";
-import { Group } from "./coValues/group.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";
+import { RawAccount, RawControlledAccount } from "./coValues/account.js";
+import { RawGroup } from "./coValues/group.js";
+import { RawCoMap } from "./coValues/coMap.js";
+import { RawCoList } from "./coValues/coList.js";
+import { RawCoStream } from "./coValues/coStream.js";
+import { RawBinaryCoStream } from "./coValues/coStream.js";
 
 export function coreToCoValue(
     core: CoValueCore,
@@ -16,20 +16,24 @@ export function coreToCoValue(
                 core.header.meta?.type === "account" &&
                 !options?.ignorePrivateTransactions
             ) {
-                return new Account(core);
+                if (core.id === core.node.account.id) {
+                    return new RawControlledAccount(core, core.node.account.agentSecret);
+                } else {
+                    return new RawAccount(core);
+                }
             } else {
-                return new Group(core, options);
+                return new RawGroup(core, options);
             }
         } else {
-            return new CoMap(core);
+            return new RawCoMap(core);
         }
     } else if (core.header.type === "colist") {
-        return new CoList(core);
+        return new RawCoList(core);
     } else if (core.header.type === "costream") {
         if (core.header.meta && core.header.meta.type === "binary") {
-            return new BinaryCoStream(core);
+            return new RawBinaryCoStream(core);
         } else {
-            return new CoStream(core);
+            return new RawCoStream(core);
         }
     } else {
         throw new Error(`Unknown coValue type ${core.header.type}`);