@voidhash/mimic-effect 1.0.0-beta.16 → 1.0.0-beta.18

package/tests/PresenceManager.test.ts

@@ -1,380 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Effect, Stream, Chunk, Fiber } from "effect";
-import { PresenceManager, PresenceManagerTag } from "../src/PresenceManager";
-
-describe("PresenceManager", () => {
-  describe("getSnapshot", () => {
-    it("should return empty snapshot for unknown document", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-          return yield* pm.getSnapshot("unknown-doc");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.presences).toEqual({});
-    });
-
-    it("should return presences after set", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", {
-            data: { x: 10, y: 20 },
-            userId: "user-1",
-          });
-
-          return yield* pm.getSnapshot("doc-1");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.presences).toEqual({
-        "conn-1": { data: { x: 10, y: 20 }, userId: "user-1" },
-      });
-    });
-
-    it("should return multiple presences", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
-          yield* pm.set("doc-1", "conn-2", {
-            data: { x: 30, y: 40 },
-            userId: "user-2",
-          });
-          yield* pm.set("doc-1", "conn-3", { data: { x: 50, y: 60 } });
-
-          return yield* pm.getSnapshot("doc-1");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(Object.keys(result.presences).length).toBe(3);
-      expect(result.presences["conn-1"]).toEqual({ data: { x: 10, y: 20 } });
-      expect(result.presences["conn-2"]).toEqual({
-        data: { x: 30, y: 40 },
-        userId: "user-2",
-      });
-      expect(result.presences["conn-3"]).toEqual({ data: { x: 50, y: 60 } });
-    });
-  });
-
-  describe("set", () => {
-    it("should store presence entry", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", {
-            data: { cursor: { x: 100, y: 200 } },
-          });
-
-          return yield* pm.getSnapshot("doc-1");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.presences["conn-1"]).toEqual({
-        data: { cursor: { x: 100, y: 200 } },
-      });
-    });
-
-    it("should update existing presence entry", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
-          yield* pm.set("doc-1", "conn-1", { data: { x: 100, y: 200 } });
-
-          return yield* pm.getSnapshot("doc-1");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.presences["conn-1"]).toEqual({ data: { x: 100, y: 200 } });
-    });
-
-    it("should broadcast presence_update event", async () => {
-      const result = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-
-            // Subscribe first
-            const eventStream = yield* pm.subscribe("doc-1");
-
-            // Collect events in background
-            const eventsFiber = yield* Effect.fork(
-              Stream.runCollect(Stream.take(eventStream, 1))
-            );
-
-            // Small delay to ensure subscription is ready
-            yield* Effect.sleep("10 millis");
-
-            // Set presence
-            yield* pm.set("doc-1", "conn-1", {
-              data: { x: 10, y: 20 },
-              userId: "user-1",
-            });
-
-            // Wait for events
-            const events = yield* Fiber.join(eventsFiber);
-
-            return Chunk.toArray(events);
-          })
-        ).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.length).toBe(1);
-      expect(result[0]!.type).toBe("presence_update");
-      if (result[0]!.type === "presence_update") {
-        expect(result[0]!.id).toBe("conn-1");
-        expect(result[0]!.data).toEqual({ x: 10, y: 20 });
-        expect(result[0]!.userId).toBe("user-1");
-      }
-    });
-  });
-
-  describe("remove", () => {
-    it("should remove presence entry", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
-          yield* pm.remove("doc-1", "conn-1");
-
-          return yield* pm.getSnapshot("doc-1");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.presences).toEqual({});
-    });
-
-    it("should not error when removing non-existent connection", async () => {
-      await expect(
-        Effect.runPromise(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-            yield* pm.remove("doc-1", "non-existent-conn");
-          }).pipe(Effect.provide(PresenceManager.layer))
-        )
-      ).resolves.toBeUndefined();
-    });
-
-    it("should not error when removing from non-existent document", async () => {
-      await expect(
-        Effect.runPromise(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-            yield* pm.remove("non-existent-doc", "conn-1");
-          }).pipe(Effect.provide(PresenceManager.layer))
-        )
-      ).resolves.toBeUndefined();
-    });
-
-    it("should broadcast presence_remove event", async () => {
-      const result = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-
-            // Set presence first
-            yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
-
-            // Subscribe
-            const eventStream = yield* pm.subscribe("doc-1");
-
-            // Collect events in background
-            const eventsFiber = yield* Effect.fork(
-              Stream.runCollect(Stream.take(eventStream, 1))
-            );
-
-            // Small delay to ensure subscription is ready
-            yield* Effect.sleep("10 millis");
-
-            // Remove presence
-            yield* pm.remove("doc-1", "conn-1");
-
-            // Wait for events
-            const events = yield* Fiber.join(eventsFiber);
-
-            return Chunk.toArray(events);
-          })
-        ).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.length).toBe(1);
-      expect(result[0]!.type).toBe("presence_remove");
-      if (result[0]!.type === "presence_remove") {
-        expect(result[0]!.id).toBe("conn-1");
-      }
-    });
-
-    it("should not broadcast event when removing non-existent presence", async () => {
-      const result = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-
-            // Subscribe to doc that has no presences
-            const eventStream = yield* pm.subscribe("doc-1");
-
-            // Collect events in background with a timeout
-            const eventsFiber = yield* Effect.fork(
-              Stream.runCollect(
-                Stream.take(eventStream, 1).pipe(Stream.timeout("50 millis"))
-              )
-            );
-
-            // Small delay to ensure subscription is ready
-            yield* Effect.sleep("10 millis");
-
-            // Remove non-existent presence
-            yield* pm.remove("doc-1", "non-existent-conn");
-
-            // Wait for events (should timeout with no events)
-            const events = yield* Fiber.join(eventsFiber);
-
-            return Chunk.toArray(events);
-          })
-        ).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.length).toBe(0);
-    });
-  });
-
-  describe("subscribe", () => {
-    it("should receive update events from stream", async () => {
-      const result = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-
-            const eventStream = yield* pm.subscribe("doc-1");
-
-            const eventsFiber = yield* Effect.fork(
-              Stream.runCollect(Stream.take(eventStream, 2))
-            );
-
-            yield* Effect.sleep("10 millis");
-
-            yield* pm.set("doc-1", "conn-1", { data: { x: 10 } });
-            yield* pm.set("doc-1", "conn-2", { data: { x: 20 } });
-
-            const events = yield* Fiber.join(eventsFiber);
-            return Chunk.toArray(events);
-          })
-        ).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.length).toBe(2);
-      expect(result[0]!.type).toBe("presence_update");
-      expect(result[1]!.type).toBe("presence_update");
-    });
-
-    it("should receive mixed update and remove events", async () => {
-      const result = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-
-            // Set up initial presence
-            yield* pm.set("doc-1", "conn-1", { data: { x: 10 } });
-
-            const eventStream = yield* pm.subscribe("doc-1");
-
-            const eventsFiber = yield* Effect.fork(
-              Stream.runCollect(Stream.take(eventStream, 3))
-            );
-
-            yield* Effect.sleep("10 millis");
-
-            yield* pm.set("doc-1", "conn-2", { data: { x: 20 } });
-            yield* pm.remove("doc-1", "conn-1");
-            yield* pm.set("doc-1", "conn-3", { data: { x: 30 } });
-
-            const events = yield* Fiber.join(eventsFiber);
-            return Chunk.toArray(events);
-          })
-        ).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.length).toBe(3);
-      expect(result[0]!.type).toBe("presence_update");
-      expect(result[1]!.type).toBe("presence_remove");
-      expect(result[2]!.type).toBe("presence_update");
-    });
-  });
-
-  describe("document isolation", () => {
-    it("should isolate presences between documents", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", { data: { x: 10 } });
-          yield* pm.set("doc-2", "conn-2", { data: { x: 20 } });
-
-          const snapshot1 = yield* pm.getSnapshot("doc-1");
-          const snapshot2 = yield* pm.getSnapshot("doc-2");
-
-          return { snapshot1, snapshot2 };
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(Object.keys(result.snapshot1.presences).length).toBe(1);
-      expect(result.snapshot1.presences["conn-1"]).toEqual({ data: { x: 10 } });
-      expect(result.snapshot1.presences["conn-2"]).toBeUndefined();
-
-      expect(Object.keys(result.snapshot2.presences).length).toBe(1);
-      expect(result.snapshot2.presences["conn-2"]).toEqual({ data: { x: 20 } });
-      expect(result.snapshot2.presences["conn-1"]).toBeUndefined();
-    });
-
-    it("should isolate events between documents", async () => {
-      const result = await Effect.runPromise(
-        Effect.scoped(
-          Effect.gen(function* () {
-            const pm = yield* PresenceManagerTag;
-
-            // Subscribe to doc-1 only
-            const eventStream = yield* pm.subscribe("doc-1");
-
-            const eventsFiber = yield* Effect.fork(
-              Stream.runCollect(
-                Stream.take(eventStream, 1).pipe(Stream.timeout("100 millis"))
-              )
-            );
-
-            yield* Effect.sleep("10 millis");
-
-            // Set presence on doc-2 (should NOT trigger doc-1 event)
-            yield* pm.set("doc-2", "conn-1", { data: { x: 10 } });
-
-            // Set presence on doc-1 (should trigger event)
-            yield* pm.set("doc-1", "conn-2", { data: { x: 20 } });
-
-            const events = yield* Fiber.join(eventsFiber);
-            return Chunk.toArray(events);
-          })
-        ).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(result.length).toBe(1);
-      if (result[0]!.type === "presence_update") {
-        expect(result[0]!.id).toBe("conn-2");
-        expect(result[0]!.data).toEqual({ x: 20 });
-      }
-    });
-  });
-
-  describe("Tag", () => {
-    it("should have correct identifier", () => {
-      expect(PresenceManagerTag.key).toBe(
-        "@voidhash/mimic-effect/PresenceManager"
-      );
-    });
-  });
-});

package/tests/Protocol.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Effect } from "effect";
-import * as Protocol from "../src/Protocol";
-import { Transaction, Document, Primitive } from "@voidhash/mimic";
-
-describe("Protocol", () => {
-  describe("parseClientMessage", () => {
-    it("should parse auth message", async () => {
-      const data = JSON.stringify({ type: "auth", token: "test-token" });
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("auth");
-      expect((result as Protocol.AuthMessage).token).toBe("test-token");
-    });
-
-    it("should parse ping message", async () => {
-      const data = JSON.stringify({ type: "ping" });
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("ping");
-    });
-
-    it("should parse request_snapshot message", async () => {
-      const data = JSON.stringify({ type: "request_snapshot" });
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("request_snapshot");
-    });
-
-    it("should parse presence_set message", async () => {
-      const data = JSON.stringify({
-        type: "presence_set",
-        data: { cursor: { x: 10, y: 20 } },
-      });
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("presence_set");
-      expect((result as Protocol.PresenceSetMessage).data).toEqual({
-        cursor: { x: 10, y: 20 },
-      });
-    });
-
-    it("should parse presence_clear message", async () => {
-      const data = JSON.stringify({ type: "presence_clear" });
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("presence_clear");
-    });
-
-    it("should parse submit message with transaction", async () => {
-      // Create a real transaction using the Document API
-      const schema = Primitive.Struct({
-        title: Primitive.String().default(""),
-      });
-      const doc = Document.make(schema);
-      doc.transaction((root) => root.title.set("Test"));
-      const tx = doc.flush();
-      const encodedTx = Transaction.encode(tx);
-
-      const data = JSON.stringify({
-        type: "submit",
-        transaction: encodedTx,
-      });
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("submit");
-      const submitResult = result as Protocol.SubmitMessage;
-      expect(submitResult.transaction.id).toBe(tx.id);
-    });
-
-    it("should fail on invalid JSON", async () => {
-      const result = await Effect.runPromise(
-        Effect.either(Protocol.parseClientMessage("not json"))
-      );
-
-      expect(result._tag).toBe("Left");
-    });
-
-    it("should handle Uint8Array input", async () => {
-      const data = new TextEncoder().encode(
-        JSON.stringify({ type: "ping" })
-      );
-
-      const result = await Effect.runPromise(Protocol.parseClientMessage(data));
-
-      expect(result.type).toBe("ping");
-    });
-  });
-
-  describe("encodeServerMessage", () => {
-    it("should encode auth_result success", () => {
-      const message = Protocol.authResultSuccess("user-1", "write");
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("auth_result");
-      expect(parsed.success).toBe(true);
-      expect(parsed.userId).toBe("user-1");
-      expect(parsed.permission).toBe("write");
-    });
-
-    it("should encode auth_result failure", () => {
-      const message = Protocol.authResultFailure("Invalid token");
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("auth_result");
-      expect(parsed.success).toBe(false);
-      expect(parsed.error).toBe("Invalid token");
-    });
-
-    it("should encode pong", () => {
-      const message = Protocol.pong();
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("pong");
-    });
-
-    it("should encode snapshot", () => {
-      const message = Protocol.snapshotMessage({ title: "Test" }, 5);
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("snapshot");
-      expect(parsed.state).toEqual({ title: "Test" });
-      expect(parsed.version).toBe(5);
-    });
-
-    it("should encode error", () => {
-      const message = Protocol.errorMessage("tx-1", "Transaction rejected");
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("error");
-      expect(parsed.transactionId).toBe("tx-1");
-      expect(parsed.reason).toBe("Transaction rejected");
-    });
-
-    it("should encode presence_update", () => {
-      const message = Protocol.presenceUpdateMessage("conn-1", { x: 10 }, "user-1");
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("presence_update");
-      expect(parsed.id).toBe("conn-1");
-      expect(parsed.data).toEqual({ x: 10 });
-      expect(parsed.userId).toBe("user-1");
-    });
-
-    it("should encode presence_remove", () => {
-      const message = Protocol.presenceRemoveMessage("conn-1");
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("presence_remove");
-      expect(parsed.id).toBe("conn-1");
-    });
-
-    it("should encode presence_snapshot", () => {
-      const message = Protocol.presenceSnapshotMessage("self-id", {
-        "conn-1": { data: { x: 10 } },
-      });
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("presence_snapshot");
-      expect(parsed.selfId).toBe("self-id");
-      expect(parsed.presences["conn-1"].data).toEqual({ x: 10 });
-    });
-
-    it("should encode transaction with encoded transaction", () => {
-      const tx = Transaction.make([]);
-      const message = Protocol.transactionMessage(tx, 3);
-      const encoded = Protocol.encodeServerMessage(message);
-      const parsed = JSON.parse(encoded);
-
-      expect(parsed.type).toBe("transaction");
-      expect(parsed.version).toBe(3);
-      expect(parsed.transaction).toBeDefined();
-      expect(parsed.transaction.id).toBe(tx.id);
-    });
-  });
-});