cojson 0.7.23 → 0.7.28

package/src/streamUtils.ts

@@ -1,5 +1,6 @@
-import { Console, Effect, Queue, Stream } from "effect";
 import { Peer, PeerID, SyncMessage } from "./sync.js";
+import { Channel } from "queueable";
+export { Channel } from "queueable";
 
 export function connectedPeers(
     peer1id: PeerID,
@@ -13,60 +14,57 @@ export function connectedPeers(
         peer1role?: Peer["role"];
         peer2role?: Peer["role"];
     } = {},
-): Effect.Effect<[Peer, Peer]> {
-    return Effect.gen(function* () {
-        const [from1to2Rx, from1to2Tx] = yield* newQueuePair(
-            trace ? { traceAs: `${peer1id} -> ${peer2id}` } : undefined,
-        );
-        const [from2to1Rx, from2to1Tx] = yield* newQueuePair(
-            trace ? { traceAs: `${peer2id} -> ${peer1id}` } : undefined,
-        );
+): [Peer, Peer] {
+    const [from1to2Rx, from1to2Tx] = newQueuePair(
+        trace ? { traceAs: `${peer1id} -> ${peer2id}` } : undefined,
+    );
+    const [from2to1Rx, from2to1Tx] = newQueuePair(
+        trace ? { traceAs: `${peer2id} -> ${peer1id}` } : undefined,
+    );
 
-        const peer2AsPeer: Peer = {
-            id: peer2id,
-            incoming: from2to1Rx,
-            outgoing: from1to2Tx,
-            role: peer2role,
-        };
+    const peer2AsPeer: Peer = {
+        id: peer2id,
+        incoming: from2to1Rx,
+        outgoing: from1to2Tx,
+        role: peer2role,
+    };
 
-        const peer1AsPeer: Peer = {
-            id: peer1id,
-            incoming: from1to2Rx,
-            outgoing: from2to1Tx,
-            role: peer1role,
-        };
+    const peer1AsPeer: Peer = {
+        id: peer1id,
+        incoming: from1to2Rx,
+        outgoing: from2to1Tx,
+        role: peer1role,
+    };
 
-        return [peer1AsPeer, peer2AsPeer];
-    });
+    return [peer1AsPeer, peer2AsPeer];
 }
 
 export function newQueuePair(
     options: { traceAs?: string } = {},
-): Effect.Effect<[Stream.Stream<SyncMessage>, Queue.Enqueue<SyncMessage>]> {
-    return Effect.gen(function* () {
-        const queue = yield* Queue.unbounded<SyncMessage>();
+): [AsyncIterable<SyncMessage>, Channel<SyncMessage>] {
+    const channel = new Channel<SyncMessage>();
 
-        if (options.traceAs) {
-            return [
-                Stream.fromQueue(queue).pipe(
-                    Stream.tap((msg) =>
-                        Console.debug(
-                            options.traceAs,
-                            JSON.stringify(
-                                msg,
-                                (k, v) =>
-                                    k === "changes" || k === "encryptedChanges"
-                                        ? v.slice(0, 20) + "..."
-                                        : v,
-                                2,
-                            ),
+    if (options.traceAs) {
+        return [
+            (async function* () {
+                for await (const msg of channel) {
+                    console.debug(
+                        options.traceAs,
+                        JSON.stringify(
+                            msg,
+                            (k, v) =>
+                                k === "changes" || k === "encryptedChanges"
+                                    ? v.slice(0, 20) + "..."
+                                    : v,
+                            2,
                         ),
-                    ),
-                ),
-                queue,
-            ];
-        } else {
-            return [Stream.fromQueue(queue), queue];
-        }
-    });
+                    );
+                    yield msg;
+                }
+            })(),
+            channel,
+        ];
+    } else {
+        return [channel.wrap(), channel];
+    }
 }

package/src/sync.ts

@@ -3,7 +3,6 @@ import { CoValueHeader, Transaction } from "./coValueCore.js";
 import { CoValueCore } from "./coValueCore.js";
 import { LocalNode, newLoadingState } from "./localNode.js";
 import { RawCoID, SessionID } from "./ids.js";
-import { Data, Effect, Queue, Stream } from "effect";
 
 export type CoValueKnownState = {
     id: RawCoID;
@@ -56,19 +55,17 @@ export type DoneMessage = {
 
 export type PeerID = string;
 
-export class DisconnectedError extends Data.TaggedError("DisconnectedError")<{
-    message: string;
-}> {}
+export type DisconnectedError = "Disconnected";
 
-export class PingTimeoutError extends Error {
-    readonly _tag = "PingTimeoutError";
-}
+export type PingTimeoutError = "PingTimeout";
 
-export type IncomingSyncStream = Stream.Stream<
-    SyncMessage,
-    DisconnectedError | PingTimeoutError
+export type IncomingSyncStream = AsyncIterable<
+    SyncMessage | DisconnectedError | PingTimeoutError
 >;
-export type OutgoingSyncQueue = Queue.Enqueue<SyncMessage>;
+export type OutgoingSyncQueue = {
+    push: (msg: SyncMessage) => Promise<unknown>;
+    close: () => void;
+};
 
 export interface Peer {
     id: PeerID;
@@ -144,15 +141,11 @@ export class SyncManager {
 
         for (const peer of eligiblePeers) {
             // console.log("loading", id, "from", peer.id);
-            Effect.runPromise(
-                Queue.offer(peer.outgoing, {
-                    action: "load",
-                    id: id,
-                    header: false,
-                    sessions: {},
-                }),
-            ).catch((e) => {
-                console.error("Error writing to peer", e);
+            await peer.outgoing.push({
+                action: "load",
+                id: id,
+                header: false,
+                sessions: {},
             });
 
             const coValueEntry = this.local.coValues[id];
@@ -229,11 +222,13 @@ export class SyncManager {
         }
 
         if (entry.state === "loading") {
-            await this.trySendToPeer(peer, {
+            this.trySendToPeer(peer, {
                 action: "load",
                 id,
                 header: false,
                 sessions: {},
+            }).catch((e) => {
+                console.error("Error sending load", e);
             });
             return;
         }
@@ -246,9 +241,11 @@ export class SyncManager {
 
         if (!peer.toldKnownState.has(id)) {
             peer.toldKnownState.add(id);
-            await this.trySendToPeer(peer, {
+            this.trySendToPeer(peer, {
                 action: "load",
                 ...coValue.knownState(),
+            }).catch((e) => {
+                console.error("Error sending load", e);
             });
         }
     }
@@ -273,10 +270,12 @@ export class SyncManager {
         );
 
         if (!peer.toldKnownState.has(id)) {
-            await this.trySendToPeer(peer, {
+            this.trySendToPeer(peer, {
                 action: "known",
                 asDependencyOf,
                 ...coValue.knownState(),
+            }).catch((e) => {
+                console.error("Error sending known state", e);
             });
 
             peer.toldKnownState.add(id);
@@ -311,7 +310,9 @@ export class SyncManager {
                     //     } header: ${!!piece.header}`,
                     //     // Object.values(piece.new).map((s) => s.newTransactions)
                     // );
-                    await this.trySendToPeer(peer, piece);
+                    this.trySendToPeer(peer, piece).catch((e) => {
+                        console.error("Error sending content piece", e);
+                    });
                     if (performance.now() - lastYield > 10) {
                         await new Promise<void>((resolve) => {
                             setTimeout(resolve, 0);
@@ -365,55 +366,39 @@ export class SyncManager {
             void initialSync();
         }
 
-        void Effect.runPromise(
-            peerState.incoming.pipe(
-                Stream.ensuring(
-                    Effect.sync(() => {
-                        console.log("Peer disconnected:", peer.id);
-                        delete this.peers[peer.id];
-                    }),
-                ),
-                Stream.runForEach((msg) =>
-                    Effect.tryPromise({
-                        try: () => this.handleSyncMessage(msg, peerState),
-                        catch: (e) =>
-                            new Error(
-                                `Error reading from peer ${
-                                    peer.id
-                                }, handling msg\n\n${JSON.stringify(
-                                    msg,
-                                    (k, v) =>
-                                        k === "changes" ||
-                                        k === "encryptedChanges"
-                                            ? v.slice(0, 20) + "..."
-                                            : v,
-                                )}`,
-                                { cause: e },
-                            ),
-                    }).pipe(
-                        Effect.timeoutFail({
-                            duration: 10000,
-                            onTimeout: () =>
-                                new Error("Took >10s to process message"),
-                        }),
-                    ),
-                ),
-                Effect.catchAll((e) =>
-                    Effect.logError(
-                        "Error in peer",
-                        peer.id,
-                        e.message,
-                        typeof e.cause === "object" &&
-                            e.cause instanceof Error &&
-                            e.cause.message,
-                    ),
-                ),
-            ),
-        );
+        const processMessages = async () => {
+            for await (const msg of peerState.incoming) {
+                if (msg === "Disconnected") {
+                    return;
+                }
+                if (msg === "PingTimeout") {
+                    console.error("Ping timeout from peer", peer.id);
+                    return;
+                }
+                try {
+                    await this.handleSyncMessage(msg, peerState);
+                } catch (e) {
+                    throw new Error(
+                        `Error reading from peer ${
+                            peer.id
+                        }, handling msg\n\n${JSON.stringify(msg, (k, v) =>
+                            k === "changes" || k === "encryptedChanges"
+                                ? v.slice(0, 20) + "..."
+                                : v,
+                        )}`,
+                        { cause: e },
+                    );
+                }
+            }
+        };
+
+        processMessages().catch((e) => {
+            console.error("Error processing messages from peer", peer.id, e);
+        });
     }
 
     trySendToPeer(peer: PeerState, msg: SyncMessage) {
-        return Effect.runPromise(Queue.offer(peer.outgoing, msg));
+        return peer.outgoing.push(msg);
     }
 
     async handleLoad(msg: LoadMessage, peer: PeerState) {
@@ -426,7 +411,7 @@ export class SyncManager {
             // special case: we should be able to solve this much more neatly
             // with an explicit state machine in the future
             const eligiblePeers = this.peersInPriorityOrder().filter(
-                (other) => other.id !== peer.id && peer.role === "server",
+                (other) => other.id !== peer.id && other.role === "server",
             );
             if (eligiblePeers.length === 0) {
                 if (msg.header || Object.keys(msg.sessions).length > 0) {
@@ -439,7 +424,7 @@ export class SyncManager {
                         header: false,
                         sessions: {},
                     }).catch((e) => {
-                        console.error("Error sending known state back", e);
+                        console.error("Error sending known state", e);
                     });
                 }
                 return;
@@ -470,11 +455,13 @@ export class SyncManager {
                 peer.optimisticKnownStates[msg.id] = knownStateIn(msg);
                 peer.toldKnownState.add(msg.id);
 
-                await this.trySendToPeer(peer, {
+                this.trySendToPeer(peer, {
                     action: "known",
                     id: msg.id,
                     header: false,
                     sessions: {},
+                }).catch((e) => {
+                    console.error("Error sending known state back", e);
                 });
 
                 return;
@@ -684,10 +671,12 @@ export class SyncManager {
         await this.syncCoValue(coValue);
 
         if (invalidStateAssumed) {
-            await this.trySendToPeer(peer, {
+            this.trySendToPeer(peer, {
                 action: "known",
                 isCorrection: true,
                 ...coValue.knownState(),
+            }).catch((e) => {
+                console.error("Error sending known state correction", e);
             });
         }
     }
@@ -755,6 +744,12 @@ export class SyncManager {
             }
         }
     }
+
+    gracefulShutdown() {
+        for (const peer of Object.values(this.peers)) {
+            peer.outgoing.close();
+        }
+    }
 }
 
 function knownStateIn(msg: LoadMessage | KnownStateMessage) {

package/src/tests/account.test.ts

@@ -3,7 +3,6 @@ import { newRandomSessionID } from "../coValueCore.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { Effect } from "effect";
 
 const Crypto = await WasmCrypto.create();
 
@@ -53,13 +52,11 @@ test("Can create account with one node, and then load it on another", async () =
     map.set("foo", "bar", "private");
     expect(map.get("foo")).toEqual("bar");
 
-    const [node1asPeer, node2asPeer] = await Effect.runPromise(
-        connectedPeers("node1", "node2", {
-            trace: true,
-            peer1role: "server",
-            peer2role: "client",
-        }),
-    );
+    const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {
+        trace: true,
+        peer1role: "server",
+        peer2role: "client",
+    })
 
     console.log("After connected peers");