@voidhash/mimic-effect 0.0.9 → 1.0.0-beta.2

package/tests/PresenceManager.test.ts

@@ -1,20 +1,13 @@
 import { describe, it, expect } from "vitest";
-import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
-import * as Chunk from "effect/Chunk";
-import * as Fiber from "effect/Fiber";
-import * as PresenceManager from "../src/PresenceManager";
-
-// =============================================================================
-// PresenceManager Tests
-// =============================================================================
+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* PresenceManager.PresenceManagerTag;
+          const pm = yield* PresenceManagerTag;
           return yield* pm.getSnapshot("unknown-doc");
         }).pipe(Effect.provide(PresenceManager.layer))
       );
@@ -22,10 +15,10 @@ describe("PresenceManager", () => {
       expect(result.presences).toEqual({});
     });
 
-    it("should return existing presences after set", async () => {
+    it("should return presences after set", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
+          const pm = yield* PresenceManagerTag;
 
           yield* pm.set("doc-1", "conn-1", {
             data: { x: 10, y: 20 },
@@ -44,7 +37,7 @@ describe("PresenceManager", () => {
     it("should return multiple presences", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
+          const pm = yield* PresenceManagerTag;
 
           yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
           yield* pm.set("doc-1", "conn-2", {
@@ -71,7 +64,7 @@ describe("PresenceManager", () => {
     it("should store presence entry", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
+          const pm = yield* PresenceManagerTag;
 
           yield* pm.set("doc-1", "conn-1", {
             data: { cursor: { x: 100, y: 200 } },
@@ -89,7 +82,7 @@ describe("PresenceManager", () => {
     it("should update existing presence entry", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
+          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 } });
@@ -105,7 +98,7 @@ describe("PresenceManager", () => {
       const result = await Effect.runPromise(
         Effect.scoped(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
 
             // Subscribe first
             const eventStream = yield* pm.subscribe("doc-1");
@@ -146,7 +139,7 @@ describe("PresenceManager", () => {
     it("should remove presence entry", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
+          const pm = yield* PresenceManagerTag;
 
           yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
           yield* pm.remove("doc-1", "conn-1");
@@ -162,7 +155,7 @@ describe("PresenceManager", () => {
       await expect(
         Effect.runPromise(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
             yield* pm.remove("doc-1", "non-existent-conn");
           }).pipe(Effect.provide(PresenceManager.layer))
         )
@@ -173,7 +166,7 @@ describe("PresenceManager", () => {
       await expect(
         Effect.runPromise(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
             yield* pm.remove("non-existent-doc", "conn-1");
           }).pipe(Effect.provide(PresenceManager.layer))
         )
@@ -184,7 +177,7 @@ describe("PresenceManager", () => {
       const result = await Effect.runPromise(
         Effect.scoped(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
 
             // Set presence first
             yield* pm.set("doc-1", "conn-1", { data: { x: 10, y: 20 } });
@@ -222,7 +215,7 @@ describe("PresenceManager", () => {
       const result = await Effect.runPromise(
         Effect.scoped(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
 
             // Subscribe to doc that has no presences
             const eventStream = yield* pm.subscribe("doc-1");
@@ -257,7 +250,7 @@ describe("PresenceManager", () => {
       const result = await Effect.runPromise(
         Effect.scoped(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
 
             const eventStream = yield* pm.subscribe("doc-1");
 
@@ -285,7 +278,7 @@ describe("PresenceManager", () => {
       const result = await Effect.runPromise(
         Effect.scoped(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
 
             // Set up initial presence
             yield* pm.set("doc-1", "conn-1", { data: { x: 10 } });
@@ -319,7 +312,7 @@ describe("PresenceManager", () => {
     it("should isolate presences between documents", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
+          const pm = yield* PresenceManagerTag;
 
           yield* pm.set("doc-1", "conn-1", { data: { x: 10 } });
           yield* pm.set("doc-2", "conn-2", { data: { x: 20 } });
@@ -344,7 +337,7 @@ describe("PresenceManager", () => {
       const result = await Effect.runPromise(
         Effect.scoped(
           Effect.gen(function* () {
-            const pm = yield* PresenceManager.PresenceManagerTag;
+            const pm = yield* PresenceManagerTag;
 
             // Subscribe to doc-1 only
             const eventStream = yield* pm.subscribe("doc-1");
@@ -377,45 +370,11 @@ describe("PresenceManager", () => {
     });
   });
 
-  describe("multiple connections per document", () => {
-    it("should handle multiple connections setting presence independently", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const pm = yield* PresenceManager.PresenceManagerTag;
-
-          yield* pm.set("doc-1", "conn-1", { data: { x: 10 }, userId: "user-1" });
-          yield* pm.set("doc-1", "conn-2", { data: { x: 20 }, userId: "user-2" });
-          yield* pm.set("doc-1", "conn-3", { data: { x: 30 }, userId: "user-3" });
-
-          // Update one connection
-          yield* pm.set("doc-1", "conn-2", { data: { x: 200 }, userId: "user-2" });
-
-          // Remove one connection
-          yield* pm.remove("doc-1", "conn-1");
-
-          return yield* pm.getSnapshot("doc-1");
-        }).pipe(Effect.provide(PresenceManager.layer))
-      );
-
-      expect(Object.keys(result.presences).length).toBe(2);
-      expect(result.presences["conn-1"]).toBeUndefined();
-      expect(result.presences["conn-2"]).toEqual({
-        data: { x: 200 },
-        userId: "user-2",
-      });
-      expect(result.presences["conn-3"]).toEqual({
-        data: { x: 30 },
-        userId: "user-3",
-      });
-    });
-  });
-
-  describe("PresenceManagerTag", () => {
-    it("should have correct tag identifier", () => {
-      expect(PresenceManager.PresenceManagerTag.key).toBe(
-        "@voidhash/mimic-server-effect/PresenceManager"
+  describe("Tag", () => {
+    it("should have correct identifier", () => {
+      expect(PresenceManagerTag.key).toBe(
+        "@voidhash/mimic-effect/PresenceManager"
       );
     });
   });
 });
-

package/tests/Protocol.test.ts

@@ -0,0 +1,190 @@
+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);
+    });
+  });
+});

package/tests/StorageIntegration.test.ts

@@ -0,0 +1,259 @@
+import { describe, it, expect } from "vitest";
+import { Effect, Layer } from "effect";
+import { StorageIntegrationTestSuite } from "../src/testing/StorageIntegrationTestSuite";
+import { FailingStorage } from "../src/testing/FailingStorage";
+import { ColdStorage, ColdStorageTag } from "../src/ColdStorage";
+import { HotStorage, HotStorageTag } from "../src/HotStorage";
+
+// =============================================================================
+// Storage Integration Tests
+// =============================================================================
+
+describe("Storage Integration", () => {
+  const layer = Layer.mergeAll(
+    ColdStorage.InMemory.make(),
+    HotStorage.InMemory.make()
+  );
+
+  for (const test of StorageIntegrationTestSuite.makeTests()) {
+    it(test.name, () =>
+      Effect.runPromise(test.run.pipe(Effect.provide(layer)))
+    );
+  }
+});
+
+// =============================================================================
+// Failure Scenario Tests
+// =============================================================================
+
+describe("Storage Failure Scenarios", () => {
+  describe("ColdStorage Failures", () => {
+    it("load failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({ failLoad: true }),
+        HotStorage.InMemory.make()
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+          return yield* Effect.either(cold.load("test-doc"));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("ColdStorageError");
+      }
+    });
+
+    it("save failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({ failSave: true }),
+        HotStorage.InMemory.make()
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+          return yield* Effect.either(
+            cold.save("test-doc", {
+              state: { data: "test" },
+              version: 1,
+              schemaVersion: 1,
+              savedAt: Date.now(),
+            })
+          );
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("ColdStorageError");
+      }
+    });
+
+    it("failAfterN allows first N operations then fails", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({ failAfterN: 2, failLoad: true }),
+        HotStorage.InMemory.make()
+      );
+
+      const results = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+
+          // First 2 operations succeed
+          const r1 = yield* Effect.either(cold.load("doc-1"));
+          const r2 = yield* Effect.either(cold.load("doc-2"));
+
+          // Third operation fails
+          const r3 = yield* Effect.either(cold.load("doc-3"));
+
+          return { r1, r2, r3 };
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(results.r1._tag).toBe("Right");
+      expect(results.r2._tag).toBe("Right");
+      expect(results.r3._tag).toBe("Left");
+    });
+  });
+
+  describe("HotStorage Failures", () => {
+    it("append failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failAppend: true })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(
+            hot.append("test-doc", {
+              transaction: { id: "tx-1", ops: [], timestamp: Date.now() },
+              version: 1,
+              timestamp: Date.now(),
+            })
+          );
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("HotStorageError");
+      }
+    });
+
+    it("getEntries failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failGetEntries: true })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(hot.getEntries("test-doc", 0));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("HotStorageError");
+      }
+    });
+
+    it("truncate failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failTruncate: true })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(hot.truncate("test-doc", 5));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("HotStorageError");
+      }
+    });
+
+    it("failAfterN allows first N operations then fails", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failAfterN: 3, failAppend: true })
+      );
+
+      const results = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+
+          const makeEntry = (v: number) => ({
+            transaction: { id: `tx-${v}`, ops: [], timestamp: Date.now() },
+            version: v,
+            timestamp: Date.now(),
+          });
+
+          // First 3 appends succeed
+          const r1 = yield* Effect.either(hot.append("doc", makeEntry(1)));
+          const r2 = yield* Effect.either(hot.append("doc", makeEntry(2)));
+          const r3 = yield* Effect.either(hot.append("doc", makeEntry(3)));
+
+          // Fourth append fails
+          const r4 = yield* Effect.either(hot.append("doc", makeEntry(4)));
+
+          return { r1, r2, r3, r4 };
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(results.r1._tag).toBe("Right");
+      expect(results.r2._tag).toBe("Right");
+      expect(results.r3._tag).toBe("Right");
+      expect(results.r4._tag).toBe("Left");
+    });
+  });
+
+  describe("Custom Error Messages", () => {
+    it("ColdStorage uses custom error message", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({
+          failLoad: true,
+          errorMessage: "Database connection timeout",
+        }),
+        HotStorage.InMemory.make()
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+          return yield* Effect.either(cold.load("test-doc"));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left.cause).toBeInstanceOf(Error);
+        expect((result.left.cause as Error).message).toBe(
+          "Database connection timeout"
+        );
+      }
+    });
+
+    it("HotStorage uses custom error message", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({
+          failAppend: true,
+          errorMessage: "Redis cluster unavailable",
+        })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(
+            hot.append("test-doc", {
+              transaction: { id: "tx", ops: [], timestamp: Date.now() },
+              version: 1,
+              timestamp: Date.now(),
+            })
+          );
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left.cause).toBeInstanceOf(Error);
+        expect((result.left.cause as Error).message).toBe(
+          "Redis cluster unavailable"
+        );
+      }
+    });
+  });
+});

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "extends": "./tsconfig.build.json",
-  "include": ["src", "test"],
+  "include": ["src", "tests"],
   "compilerOptions": {
     "allowJs": false,
     "strictNullChecks": true

package/tsdown.config.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from "tsdown";
 
-export const input = ["./src/index.ts"];
+export const input = ["./src/index.ts", "./src/testing/index.ts"];
 
 export default defineConfig({
 	target: ["es2017"],