@voidhash/mimic-effect 0.0.8 → 1.0.0-beta.1

package/tests/HotStorage.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect } from "vitest";
+import { Effect } from "effect";
+import { HotStorage, HotStorageTag } from "../src/HotStorage";
+import type { WalEntry } from "../src/Types";
+import { Transaction } from "@voidhash/mimic";
+
+describe("HotStorage", () => {
+  describe("InMemory", () => {
+    const layer = HotStorage.InMemory.make();
+
+    const makeEntry = (version: number): WalEntry => ({
+      transaction: Transaction.make([]),
+      version,
+      timestamp: Date.now(),
+    });
+
+    it("should return empty array for missing document", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* HotStorageTag;
+          return yield* storage.getEntries("non-existent", 0);
+        }).pipe(Effect.provide(layer))
+      );
+
+      expect(result).toEqual([]);
+    });
+
+    it("should append and retrieve entries", async () => {
+      const entry1 = makeEntry(1);
+      const entry2 = makeEntry(2);
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* HotStorageTag;
+          yield* storage.append("doc-1", entry1);
+          yield* storage.append("doc-1", entry2);
+          return yield* storage.getEntries("doc-1", 0);
+        }).pipe(Effect.provide(layer))
+      );
+
+      expect(result.length).toBe(2);
+      expect(result[0]!.version).toBe(1);
+      expect(result[1]!.version).toBe(2);
+    });
+
+    it("should filter entries by sinceVersion", async () => {
+      const entries = [makeEntry(1), makeEntry(2), makeEntry(3), makeEntry(4)];
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* HotStorageTag;
+          for (const entry of entries) {
+            yield* storage.append("doc-1", entry);
+          }
+          return yield* storage.getEntries("doc-1", 2);
+        }).pipe(Effect.provide(layer))
+      );
+
+      expect(result.length).toBe(2);
+      expect(result[0]!.version).toBe(3);
+      expect(result[1]!.version).toBe(4);
+    });
+
+    it("should truncate entries up to version", async () => {
+      const entries = [makeEntry(1), makeEntry(2), makeEntry(3), makeEntry(4)];
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* HotStorageTag;
+          for (const entry of entries) {
+            yield* storage.append("doc-1", entry);
+          }
+          yield* storage.truncate("doc-1", 2);
+          return yield* storage.getEntries("doc-1", 0);
+        }).pipe(Effect.provide(layer))
+      );
+
+      expect(result.length).toBe(2);
+      expect(result[0]!.version).toBe(3);
+      expect(result[1]!.version).toBe(4);
+    });
+
+    it("should maintain order after append", async () => {
+      const entries = [makeEntry(3), makeEntry(1), makeEntry(2)];
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* HotStorageTag;
+          for (const entry of entries) {
+            yield* storage.append("doc-1", entry);
+          }
+          return yield* storage.getEntries("doc-1", 0);
+        }).pipe(Effect.provide(layer))
+      );
+
+      // Should be sorted by version
+      expect(result.length).toBe(3);
+      expect(result[0]!.version).toBe(1);
+      expect(result[1]!.version).toBe(2);
+      expect(result[2]!.version).toBe(3);
+    });
+
+    it("should isolate documents", async () => {
+      const entry1 = makeEntry(1);
+      const entry2 = makeEntry(2);
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* HotStorageTag;
+          yield* storage.append("doc-1", entry1);
+          yield* storage.append("doc-2", entry2);
+
+          const entries1 = yield* storage.getEntries("doc-1", 0);
+          const entries2 = yield* storage.getEntries("doc-2", 0);
+
+          return { entries1, entries2 };
+        }).pipe(Effect.provide(layer))
+      );
+
+      expect(result.entries1.length).toBe(1);
+      expect(result.entries1[0]!.version).toBe(1);
+      expect(result.entries2.length).toBe(1);
+      expect(result.entries2[0]!.version).toBe(2);
+    });
+
+    it("should not error when truncating non-existent document", async () => {
+      await expect(
+        Effect.runPromise(
+          Effect.gen(function* () {
+            const storage = yield* HotStorageTag;
+            yield* storage.truncate("non-existent", 5);
+          }).pipe(Effect.provide(layer))
+        )
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("Tag", () => {
+    it("should have correct identifier", () => {
+      expect(HotStorageTag.key).toBe("@voidhash/mimic-effect/HotStorage");
+    });
+  });
+});

package/tests/MimicAuthService.test.ts

@@ -1,184 +1,152 @@
 import { describe, it, expect } from "vitest";
-import * as Effect from "effect/Effect";
-import * as MimicAuthService from "../src/MimicAuthService";
-
-// =============================================================================
-// MimicAuthService Tests
-// =============================================================================
+import { Effect, Layer, Context } from "effect";
+import {
+  MimicAuthService,
+  MimicAuthServiceTag,
+} from "../src/MimicAuthService";
+import { AuthenticationError } from "../src/Errors";
 
 describe("MimicAuthService", () => {
-  describe("make", () => {
-    it("should create auth service with sync handler", async () => {
-      const authService = MimicAuthService.make((token) => ({
-        success: true,
-        userId: `user-${token}`,
-      }));
-
-      const result = await Effect.runPromise(
-        authService.authenticate("test-token")
-      );
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("user-test-token");
-      }
-    });
-
-    it("should create auth service with async handler", async () => {
-      const authService = MimicAuthService.make(async (token) => {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        return { success: true, userId: `async-${token}` };
-      });
-
-      const result = await Effect.runPromise(
-        authService.authenticate("async-token")
-      );
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("async-async-token");
-      }
-    });
-
-    it("should handle auth failure", async () => {
-      const authService = MimicAuthService.make((_token) => ({
-        success: false,
-        error: "Invalid token",
-      }));
+  describe("NoAuth", () => {
+    const layer = MimicAuthService.NoAuth.make();
 
+    it("should authenticate any token with write permission", async () => {
       const result = await Effect.runPromise(
-        authService.authenticate("bad-token")
+        Effect.gen(function* () {
+          const auth = yield* MimicAuthServiceTag;
+          return yield* auth.authenticate("any-token", "any-doc");
+        }).pipe(Effect.provide(layer))
       );
 
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error).toBe("Invalid token");
-      }
+      expect(result.userId).toBe("anonymous");
+      expect(result.permission).toBe("write");
     });
 
-    it("should handle success without userId", async () => {
-      const authService = MimicAuthService.make((_token) => ({
-        success: true,
-      }));
-
+    it("should work with empty token", async () => {
       const result = await Effect.runPromise(
-        authService.authenticate("token")
+        Effect.gen(function* () {
+          const auth = yield* MimicAuthServiceTag;
+          return yield* auth.authenticate("", "doc-1");
+        }).pipe(Effect.provide(layer))
       );
 
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBeUndefined();
-      }
+      expect(result.userId).toBe("anonymous");
+      expect(result.permission).toBe("write");
     });
   });
 
-  describe("makeEffect", () => {
-    it("should create auth service from Effect-based authenticate function", async () => {
-      const authService = MimicAuthService.makeEffect((token) =>
-        Effect.succeed({ success: true as const, userId: `effect-${token}` })
-      );
+  describe("Static", () => {
+    it("should return configured permissions", async () => {
+      const layer = MimicAuthService.Static.make({
+        permissions: {
+          "user-1": "write",
+          "user-2": "read",
+        },
+      });
 
       const result = await Effect.runPromise(
-        authService.authenticate("effect-token")
-      );
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("effect-effect-token");
-      }
-    });
-
-    it("should support Effect operations in authenticate", async () => {
-      const authService = MimicAuthService.makeEffect((token) =>
         Effect.gen(function* () {
-          yield* Effect.sleep(10);
-          return { success: true as const, userId: `delayed-${token}` };
-        })
+          const auth = yield* MimicAuthServiceTag;
+          const result1 = yield* auth.authenticate("user-1", "doc-1");
+          const result2 = yield* auth.authenticate("user-2", "doc-1");
+          return { result1, result2 };
+        }).pipe(Effect.provide(layer))
       );
 
-      const result = await Effect.runPromise(
-        authService.authenticate("delay-token")
-      );
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("delayed-delay-token");
-      }
+      expect(result.result1.userId).toBe("user-1");
+      expect(result.result1.permission).toBe("write");
+      expect(result.result2.userId).toBe("user-2");
+      expect(result.result2.permission).toBe("read");
     });
-  });
 
-  describe("layer", () => {
-    it("should create a layer from auth handler", async () => {
-      const testLayer = MimicAuthService.layer({
-        authHandler: (token) => ({ success: true, userId: `layer-${token}` }),
+    it("should use default permission for unknown users", async () => {
+      const layer = MimicAuthService.Static.make({
+        permissions: {
+          "user-1": "write",
+        },
+        defaultPermission: "read",
       });
 
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const authService = yield* MimicAuthService.MimicAuthServiceTag;
-          return yield* authService.authenticate("layer-token");
-        }).pipe(Effect.provide(testLayer))
+          const auth = yield* MimicAuthServiceTag;
+          return yield* auth.authenticate("unknown-user", "doc-1");
+        }).pipe(Effect.provide(layer))
       );
 
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("layer-layer-token");
-      }
+      expect(result.userId).toBe("unknown-user");
+      expect(result.permission).toBe("read");
     });
-  });
 
-  describe("layerService", () => {
-    it("should create a layer from service implementation", async () => {
-      const service = MimicAuthService.make((token) => ({
-        success: true,
-        userId: `service-${token}`,
-      }));
-
-      const testLayer = MimicAuthService.layerService(service);
+    it("should fail for unknown users without default permission", async () => {
+      const layer = MimicAuthService.Static.make({
+        permissions: {
+          "user-1": "write",
+        },
+      });
 
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const authService = yield* MimicAuthService.MimicAuthServiceTag;
-          return yield* authService.authenticate("service-token");
-        }).pipe(Effect.provide(testLayer))
+          const auth = yield* MimicAuthServiceTag;
+          return yield* Effect.either(
+            auth.authenticate("unknown-user", "doc-1")
+          );
+        }).pipe(Effect.provide(layer))
       );
 
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("service-service-token");
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left).toBeInstanceOf(AuthenticationError);
+        expect(result.left.reason).toBe("Unknown user");
       }
     });
   });
 
-  describe("layerEffect", () => {
-    it("should create a layer from an Effect", async () => {
-      const testLayer = MimicAuthService.layerEffect(
-        Effect.succeed(
-          MimicAuthService.make((token) => ({
-            success: true,
-            userId: `effect-layer-${token}`,
-          }))
-        )
-      );
+  describe("make (custom)", () => {
+    it("should allow custom implementation with service access", async () => {
+      // Create a mock service
+      class MockDatabaseTag extends Context.Tag("MockDatabase")<
+        MockDatabaseTag,
+        { getPermission: (userId: string) => Effect.Effect<"read" | "write"> }
+      >() {}
+
+      const mockDbLayer = Layer.succeed(MockDatabaseTag, {
+        getPermission: (userId: string) =>
+          Effect.succeed(userId === "admin" ? "write" : "read"),
+      });
+
+      const authLayer = MimicAuthService.make(
+        Effect.gen(function* () {
+          const db = yield* MockDatabaseTag;
+
+          return {
+            authenticate: (token: string, _documentId: string) =>
+              Effect.gen(function* () {
+                const permission = yield* db.getPermission(token);
+                return { userId: token, permission };
+              }),
+          };
+        })
+      ).pipe(Layer.provide(mockDbLayer));
 
       const result = await Effect.runPromise(
         Effect.gen(function* () {
-          const authService = yield* MimicAuthService.MimicAuthServiceTag;
-          return yield* authService.authenticate("effect-layer-token");
-        }).pipe(Effect.provide(testLayer))
+          const auth = yield* MimicAuthServiceTag;
+          const admin = yield* auth.authenticate("admin", "doc-1");
+          const user = yield* auth.authenticate("user", "doc-1");
+          return { admin, user };
+        }).pipe(Effect.provide(authLayer))
       );
 
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.userId).toBe("effect-layer-effect-layer-token");
-      }
+      expect(result.admin.permission).toBe("write");
+      expect(result.user.permission).toBe("read");
     });
   });
 
-  describe("MimicAuthServiceTag", () => {
-    it("should have the correct tag identifier", () => {
-      expect(MimicAuthService.MimicAuthServiceTag.key).toBe(
-        "@voidhash/mimic-server-effect/MimicAuthService"
+  describe("Tag", () => {
+    it("should have correct identifier", () => {
+      expect(MimicAuthServiceTag.key).toBe(
+        "@voidhash/mimic-effect/MimicAuthService"
       );
     });
   });