cojson 0.2.3 → 0.3.0-alpha.0

package/src/coValueCore.ts

@@ -1,6 +1,5 @@
 import { randomBytes } from "@noble/hashes/utils";
-import { AnyCoValue } from "./coValue.js";
-import { Static } from "./coValues/static.js";
+import { AnyCoValue, CoValue } from "./coValue.js";
 import { BinaryCoStream, CoStream } from "./coValues/coStream.js";
 import { CoMap } from "./coValues/coMap.js";
 import {
@@ -28,7 +27,7 @@ import {
     isKeyForKeyField,
 } from "./permissions.js";
 import { Group, expectGroupContent } from "./group.js";
-import { LocalNode } from "./node.js";
+import { LocalNode } from "./localNode.js";
 import { CoValueKnownState, NewContentMessage } from "./sync.js";
 import { AgentID, RawCoID, SessionID, TransactionID } from "./ids.js";
 import { CoList } from "./coValues/coList.js";
@@ -99,8 +98,8 @@ export class CoValueCore {
     node: LocalNode;
     header: CoValueHeader;
     _sessions: { [key: SessionID]: SessionLog };
-    _cachedContent?: AnyCoValue;
-    listeners: Set<(content?: AnyCoValue) => void> = new Set();
+    _cachedContent?: CoValue;
+    listeners: Set<(content?: CoValue) => void> = new Set();
     _decryptionCache: {
         [key: Encrypted<JsonValue[], JsonValue>]:
             | Stringified<JsonValue[]>
@@ -376,7 +375,7 @@ export class CoValueCore {
         }
     }
 
-    subscribe(listener: (content?: AnyCoValue) => void): () => void {
+    subscribe(listener: (content?: CoValue) => void): () => void {
         this.listeners.add(listener);
         listener(this.getCurrentContent());
 
@@ -487,13 +486,13 @@ export class CoValueCore {
         );
 
         if (success) {
-            void this.node.sync.syncCoValue(this);
+            void this.node.syncManager.syncCoValue(this);
         }
 
         return success;
     }
 
-    getCurrentContent(): AnyCoValue {
+    getCurrentContent(): CoValue {
         if (this._cachedContent) {
             return this._cachedContent;
         }
@@ -508,8 +507,6 @@ export class CoValueCore {
             } else {
                 this._cachedContent = new CoStream(this);
             }
-        } else if (this.header.type === "static") {
-            this._cachedContent = new Static(this);
         } else {
             throw new Error(`Unknown coValue type ${this.header.type}`);
         }
@@ -611,26 +608,24 @@ export class CoValueCore {
 
             // Try to find key revelation for us
 
-            const readKeyEntry = content.getLastEntry(
+            const lastReadyKeyEdit = content.lastEditAt(
                 `${keyID}_for_${this.node.account.id}`
             );
 
-            if (readKeyEntry) {
-                const revealer = accountOrAgentIDfromSessionID(
-                    readKeyEntry.txID.sessionID
-                );
+            if (lastReadyKeyEdit?.value) {
+                const revealer = lastReadyKeyEdit.by;
                 const revealerAgent = this.node.resolveAccountAgent(
                     revealer,
                     "Expected to know revealer"
                 );
 
                 const secret = unseal(
-                    readKeyEntry.value,
+                    lastReadyKeyEdit.value,
                     this.node.account.currentSealerSecret(),
                     getAgentSealerID(revealerAgent),
                     {
                         in: this.id,
-                        tx: readKeyEntry.txID,
+                        tx: lastReadyKeyEdit.tx,
                     }
                 );
 
@@ -784,15 +779,16 @@ export class CoValueCore {
                     sessionEntry = {
                         after: sentState[sessionID] ?? 0,
                         newTransactions: [],
-                        lastSignature: "WILL_BE_REPLACED" as Signature
+                        lastSignature: "WILL_BE_REPLACED" as Signature,
                     };
                     currentPiece.new[sessionID] = sessionEntry;
                 }
 
                 sessionEntry.newTransactions.push(...txsToAdd);
-                sessionEntry.lastSignature = nextKnownSignatureIdx === undefined
-                ? log.lastSignature!
-                : log.signatureAfter[nextKnownSignatureIdx]!
+                sessionEntry.lastSignature =
+                    nextKnownSignatureIdx === undefined
+                        ? log.lastSignature!
+                        : log.signatureAfter[nextKnownSignatureIdx]!;
 
                 sentState[sessionID] =
                     (sentState[sessionID] || 0) + txsToAdd.length;

package/src/coValues/coList.ts

@@ -1,9 +1,9 @@
 import { JsonObject, JsonValue } from "../jsonValue.js";
 import { CoID, CoValue, isCoValue } from "../coValue.js";
 import { CoValueCore, accountOrAgentIDfromSessionID } from "../coValueCore.js";
-import { SessionID, TransactionID } from "../ids.js";
+import { AgentID, SessionID, TransactionID } from "../ids.js";
 import { Group } from "../group.js";
-import { AccountID, isAccountID } from "../account.js";
+import { AccountID } from "../account.js";
 import { parseJSON } from "../jsonStringify.js";
 
 type OpID = TransactionID & { changeIdx: number };
@@ -40,13 +40,16 @@ type DeletionEntry = {
     deletionID: OpID;
 } & DeletionOpPayload;
 
-export class CoList<
-    T extends JsonValue | CoValue,
+export class CoListView<
+    Item extends JsonValue | CoValue,
     Meta extends JsonObject | null = null
 > implements CoValue
 {
+    /** @category 6. Meta */
     id: CoID<this>;
+    /** @category 6. Meta */
     type = "colist" as const;
+    /** @category 6. Meta */
     core: CoValueCore;
     /** @internal */
     afterStart: OpID[];
@@ -56,7 +59,7 @@ export class CoList<
     insertions: {
         [sessionID: SessionID]: {
             [txIdx: number]: {
-                [changeIdx: number]: InsertionEntry<T>;
+                [changeIdx: number]: InsertionEntry<Item>;
             };
         };
     };
@@ -68,6 +71,8 @@ export class CoList<
             };
         };
     };
+    /** @category 6. Meta */
+    readonly _item!: Item;
 
     /** @internal */
     constructor(core: CoValueCore) {
@@ -78,19 +83,6 @@ export class CoList<
         this.insertions = {};
         this.deletionsByInsertion = {};
 
-        this.fillOpsFromCoValue();
-    }
-
-    get meta(): Meta {
-        return this.core.header.meta as Meta;
-    }
-
-    get group(): Group {
-        return this.core.getGroup();
-    }
-
-    /** @internal */
-    protected fillOpsFromCoValue() {
         this.insertions = {};
         this.deletionsByInsertion = {};
         this.afterStart = [];
@@ -104,7 +96,7 @@ export class CoList<
             for (const [changeIdx, changeUntyped] of parseJSON(
                 changes
             ).entries()) {
-                const change = changeUntyped as ListOpPayload<T>;
+                const change = changeUntyped as ListOpPayload<Item>;
 
                 if (change.op === "pre" || change.op === "app") {
                     let sessionEntry = this.insertions[txID.sessionID];
@@ -204,10 +196,35 @@ export class CoList<
         }
     }
 
-    /** Get the item currently at `idx`. */
+    /** @category 6. Meta */
+    get meta(): Meta {
+        return this.core.header.meta as Meta;
+    }
+
+    /** @category 6. Meta */
+    get group(): Group {
+        return this.core.getGroup();
+    }
+
+    /**
+     * Not yet implemented
+     *
+     * @category 4. Time travel
+     */
+    atTime(_time: number): this {
+        throw new Error("Not yet implemented");
+    }
+
+    /**
+     * Get the item currently at `idx`.
+     *
+     * @category 1. Reading
+     */
     get(
         idx: number
-    ): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>) | undefined {
+    ):
+        | (Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>)
+        | undefined {
         const entry = this.entries()[idx];
         if (!entry) {
             return undefined;
@@ -215,18 +232,23 @@ export class CoList<
         return entry.value;
     }
 
-    /** Returns the current items in the CoList as an array. */
-    asArray(): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[] {
+    /**
+     * Returns the current items in the CoList as an array.
+     *
+     * @category 1. Reading
+     **/
+    asArray(): (Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>)[] {
         return this.entries().map((entry) => entry.value);
     }
 
-    entries(): {
-        value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+    /** @internal */
+     entries(): {
+        value: Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>;
         madeAt: number;
         opID: OpID;
     }[] {
         const arr: {
-            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+            value: Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>;
             madeAt: number;
             opID: OpID;
         }[] = [];
@@ -243,7 +265,7 @@ export class CoList<
     private fillArrayFromOpID(
         opID: OpID,
         arr: {
-            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>;
+            value: Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>;
             madeAt: number;
             opID: OpID;
         }[]
@@ -272,101 +294,115 @@ export class CoList<
         }
     }
 
-    /** Returns the accountID of the account that inserted value at the given index. */
-    whoInserted(idx: number): AccountID | undefined {
+    /**
+     * Returns the current items in the CoList as an array. (alias of `asArray`)
+     *
+     * @category 1. Reading
+     */
+    toJSON(): (Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>)[] {
+        return this.asArray();
+    }
+
+    /** @category 5. Edit history */
+    editAt(idx: number):
+        | {
+              by: AccountID | AgentID;
+              tx: TransactionID;
+              at: Date;
+              value: Item extends CoValue ? CoID<Item> : Exclude<Item, CoValue>;
+          }
+        | undefined {
         const entry = this.entries()[idx];
         if (!entry) {
             return undefined;
         }
-        const accountID = accountOrAgentIDfromSessionID(entry.opID.sessionID);
-        if (isAccountID(accountID)) {
-            return accountID;
-        } else {
-            return undefined;
-        }
-    }
-
-    /** Returns the current items in the CoList as an array. (alias of `asArray`) */
-    toJSON(): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[] {
-        return this.asArray();
+        const madeAt = new Date(entry.madeAt);
+        const by = accountOrAgentIDfromSessionID(entry.opID.sessionID);
+        const value = entry.value;
+        return {
+            by,
+            tx: {
+                sessionID: entry.opID.sessionID,
+                txIndex: entry.opID.txIndex,
+            },
+            at: madeAt,
+            value,
+        };
     }
 
-    map<U>(
-        mapper: (
-            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
-            idx: number
-        ) => U
-    ): U[] {
-        return this.entries().map((entry, idx) => mapper(entry.value, idx));
-    }
+    /** @category 5. Edit history */
+    deletionEdits(): {
+        by: AccountID | AgentID;
+        tx: TransactionID;
+        at: Date;
+        // TODO: add indices that are now before and after the deleted item
+    }[] {
+        const edits: {
+            by: AccountID | AgentID;
+            tx: TransactionID;
+            at: Date;
+        }[] = [];
 
-    filter<U extends T extends CoValue ? CoID<T> : Exclude<T, CoValue>>(
-        predicate: (
-            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
-            idx: number
-        ) => value is U
-    ): U[];
-    filter(
-        predicate: (
-            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
-            idx: number
-        ) => boolean
-    ): (T extends CoValue ? CoID<T> : Exclude<T, CoValue>)[] {
-        return this.entries()
-            .filter((entry, idx) => predicate(entry.value, idx))
-            .map((entry) => entry.value);
-    }
+        for (const sessionID in this.deletionsByInsertion) {
+            const sessionEntry =
+                this.deletionsByInsertion[sessionID as SessionID];
+            for (const txIdx in sessionEntry) {
+                const txEntry = sessionEntry[Number(txIdx)];
+                for (const changeIdx in txEntry) {
+                    const changeEntry = txEntry[Number(changeIdx)];
+                    for (const deletion of changeEntry || []) {
+                        const madeAt = new Date(deletion.madeAt);
+                        const by = accountOrAgentIDfromSessionID(
+                            deletion.deletionID.sessionID
+                        );
+                        edits.push({
+                            by,
+                            tx: deletion.deletionID,
+                            at: madeAt,
+                        });
+                    }
+                }
+            }
+        }
 
-    reduce<U>(
-        reducer: (
-            accumulator: U,
-            value: T extends CoValue ? CoID<T> : Exclude<T, CoValue>,
-            idx: number
-        ) => U,
-        initialValue: U
-    ): U {
-        return this.entries().reduce(
-            (accumulator, entry, idx) => reducer(accumulator, entry.value, idx),
-            initialValue
-        );
+        return edits;
     }
 
+    /** @category 3. Subscription */
     subscribe(listener: (coList: this) => void): () => void {
         return this.core.subscribe((content) => {
             listener(content as this);
         });
     }
-
-    edit(changer: (editable: WriteableCoList<T, Meta>) => void): this {
-        const editable = new WriteableCoList<T, Meta>(this.core);
-        changer(editable);
-        return new CoList(this.core) as this;
-    }
 }
 
-export class WriteableCoList<
-        T extends JsonValue | CoValue,
+export class CoList<
+        Item extends JsonValue | CoValue,
         Meta extends JsonObject | null = null
     >
-    extends CoList<T, Meta>
+    extends CoListView<Item, Meta>
     implements CoValue
 {
-    /** @internal */
-    edit(_changer: (editable: WriteableCoList<T, Meta>) => void): this {
-        throw new Error("Already editing.");
-    }
-
-    /** Appends a new item after index `after`.
+    /** Returns a new version of this CoList with `item` appended after the item currently at index `after`.
      *
-     * If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+     * If `privacy` is `"private"` **(default)**, `item` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
      *
-     * If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
+     * If `privacy` is `"trusting"`, `item` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     *
+     * @category 2. Editing
+     **/
     append(
-        after: number,
-        value: T extends CoValue ? T | CoID<T> : T,
+        item: Item extends CoValue ? Item | CoID<Item> : Item,
+        after?: number,
         privacy: "private" | "trusting" = "private"
-    ): void {
+    ): this {
         const entries = this.entries();
+        after =
+            after === undefined
+                ? entries.length > 0
+                    ? entries.length - 1
+                    : 0
+                : 0;
         let opIDBefore;
         if (entries.length > 0) {
             const entryBefore = entries[after];
@@ -384,47 +420,32 @@ export class WriteableCoList<
             [
                 {
                     op: "app",
-                    value: isCoValue(value) ? value.id : value,
+                    value: isCoValue(item) ? item.id : item,
                     after: opIDBefore,
                 },
             ],
             privacy
         );
 
-        this.fillOpsFromCoValue();
-    }
-
-    /** Pushes a new item to the end of the list.
-     *
-     * If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
-     *
-     * If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
-    push(
-        value: T extends CoValue ? T | CoID<T> : T,
-        privacy: "private" | "trusting" = "private"
-    ): void {
-        // TODO: optimize
-        const entries = this.entries();
-        this.append(
-            entries.length > 0 ? entries.length - 1 : 0,
-            value,
-            privacy
-        );
+        return new CoList(this.core) as this;
     }
 
     /**
-     * Prepends a new item before index `before`.
+     * Returns a new version of this CoList with `item` prepended before the item currently at index `before`.
      *
-     * If `privacy` is `"private"` **(default)**, both `value` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+     * If `privacy` is `"private"` **(default)**, `item` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
      *
-     * If `privacy` is `"trusting"`, both `value` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     * If `privacy` is `"trusting"`, `item` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     *
+     * @category 2. Editing
      */
     prepend(
-        before: number,
-        value: T extends CoValue ? T | CoID<T> : T,
+        item: Item extends CoValue ? Item | CoID<Item> : Item,
+        before?: number,
         privacy: "private" | "trusting" = "private"
-    ): void {
+    ): this {
         const entries = this.entries();
+        before = before === undefined ? 0 : before;
         let opIDAfter;
         if (entries.length > 0) {
             const entryAfter = entries[before];
@@ -446,22 +467,25 @@ export class WriteableCoList<
             [
                 {
                     op: "pre",
-                    value: isCoValue(value) ? value.id : value,
+                    value: isCoValue(item) ? item.id : item,
                     before: opIDAfter,
                 },
             ],
             privacy
         );
 
-        this.fillOpsFromCoValue();
+        return new CoList(this.core) as this;
     }
 
-    /** Deletes the item at index `at` from the list.
+    /** Returns a new version of this CoList with the item at index `at` deleted from the list.
      *
      * If `privacy` is `"private"` **(default)**, the fact of this deletion is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
      *
-     * If `privacy` is `"trusting"`, the fact of this deletion is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers. */
-    delete(at: number, privacy: "private" | "trusting" = "private"): void {
+     * If `privacy` is `"trusting"`, the fact of this deletion is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     *
+     * @category 2. Editing
+     **/
+    delete(at: number, privacy: "private" | "trusting" = "private"): this {
         const entries = this.entries();
         const entry = entries[at];
         if (!entry) {
@@ -477,6 +501,96 @@ export class WriteableCoList<
             privacy
         );
 
-        this.fillOpsFromCoValue();
+        return new CoList(this.core) as this;
+    }
+
+    /** @category 2. Editing */
+    mutate(mutator: (mutable: MutableCoList<Item, Meta>) => void): this {
+        const mutable = new MutableCoList<Item, Meta>(this.core);
+        mutator(mutable);
+        return new CoList(this.core) as this;
+    }
+
+    /** @deprecated Use `mutate` instead. */
+    edit(mutator: (mutable: MutableCoList<Item, Meta>) => void): this {
+        return this.mutate(mutator);
+    }
+}
+
+export class MutableCoList<
+        Item extends JsonValue | CoValue,
+        Meta extends JsonObject | null = null
+    >
+    extends CoListView<Item, Meta>
+    implements CoValue
+{
+    /** Appends `item` after the item currently at index `after`.
+     *
+     * If `privacy` is `"private"` **(default)**, `item` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+     *
+     * If `privacy` is `"trusting"`, `item` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     *
+     * @category 2. Mutating
+     **/
+    append(
+        item: Item extends CoValue ? Item | CoID<Item> : Item,
+        after?: number,
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        const listAfter = CoList.prototype.append.call(
+            this,
+            item,
+            after,
+            privacy
+        ) as CoList<Item, Meta>;
+        this.afterStart = listAfter.afterStart;
+        this.beforeEnd = listAfter.beforeEnd;
+        this.insertions = listAfter.insertions;
+        this.deletionsByInsertion = listAfter.deletionsByInsertion;
+    }
+
+    /** Prepends `item` before the item currently at index `before`.
+     *
+     * If `privacy` is `"private"` **(default)**, `item` is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+     *
+     * If `privacy` is `"trusting"`, `item` is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     *
+     * * @category 2. Mutating
+     **/
+    prepend(
+        item: Item extends CoValue ? Item | CoID<Item> : Item,
+        before?: number,
+        privacy: "private" | "trusting" = "private"
+    ): void {
+        const listAfter = CoList.prototype.prepend.call(
+            this,
+            item,
+            before,
+            privacy
+        ) as CoList<Item, Meta>;
+        this.afterStart = listAfter.afterStart;
+        this.beforeEnd = listAfter.beforeEnd;
+        this.insertions = listAfter.insertions;
+        this.deletionsByInsertion = listAfter.deletionsByInsertion;
+    }
+
+    /** Deletes the item at index `at` from the list.
+     *
+     * If `privacy` is `"private"` **(default)**, the fact of this deletion is encrypted in the transaction, only readable by other members of the group this `CoList` belongs to. Not even sync servers can see the content in plaintext.
+     *
+     * If `privacy` is `"trusting"`, the fact of this deletion is stored in plaintext in the transaction, visible to everyone who gets a hold of it, including sync servers.
+     *
+     * * @category 2. Mutating
+     **/
+    delete(at: number, privacy: "private" | "trusting" = "private"): void {
+        const listAfter = CoList.prototype.delete.call(
+            this,
+            at,
+            privacy
+        ) as CoList<Item, Meta>;
+        this.afterStart = listAfter.afterStart;
+        this.beforeEnd = listAfter.beforeEnd;
+        this.insertions = listAfter.insertions;
+        this.deletionsByInsertion = listAfter.deletionsByInsertion;
     }
 }