@voidhash/mimic-effect 0.0.1-alpha.1

package/tests/DocumentProtocol.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from "vitest";
+import * as Schema from "effect/Schema";
+import * as Protocol from "../src/DocumentProtocol";
+
+// =============================================================================
+// Schema Tests
+// =============================================================================
+
+describe("DocumentProtocol", () => {
+  describe("TransactionSchema", () => {
+    it("should validate a valid transaction", () => {
+      const transaction = {
+        id: "tx-123",
+        ops: [
+          { kind: "string.set", path: { segments: ["title"] }, payload: "Hello" },
+        ],
+        timestamp: Date.now(),
+      };
+
+      const result = Schema.decodeUnknownSync(Protocol.TransactionSchema)(transaction);
+      expect(result.id).toBe("tx-123");
+      expect(result.ops).toHaveLength(1);
+    });
+
+    it("should reject invalid transaction", () => {
+      const invalid = {
+        id: 123, // should be string
+        ops: [],
+        timestamp: Date.now(),
+      };
+
+      expect(() =>
+        Schema.decodeUnknownSync(Protocol.TransactionSchema)(invalid)
+      ).toThrow();
+    });
+  });
+
+  describe("TransactionMessageSchema", () => {
+    it("should validate a transaction message", () => {
+      const message = {
+        type: "transaction",
+        transaction: {
+          id: "tx-456",
+          ops: [],
+          timestamp: Date.now(),
+        },
+        version: 1,
+      };
+
+      const result = Schema.decodeUnknownSync(Protocol.TransactionMessageSchema)(message);
+      expect(result.type).toBe("transaction");
+      expect(result.version).toBe(1);
+    });
+  });
+
+  describe("SnapshotMessageSchema", () => {
+    it("should validate a snapshot message", () => {
+      const message = {
+        type: "snapshot",
+        state: { title: "Test", count: 42 },
+        version: 5,
+      };
+
+      const result = Schema.decodeUnknownSync(Protocol.SnapshotMessageSchema)(message);
+      expect(result.type).toBe("snapshot");
+      expect(result.state).toEqual({ title: "Test", count: 42 });
+      expect(result.version).toBe(5);
+    });
+  });
+
+  describe("ErrorMessageSchema", () => {
+    it("should validate an error message", () => {
+      const message = {
+        type: "error",
+        transactionId: "tx-789",
+        reason: "Transaction is empty",
+      };
+
+      const result = Schema.decodeUnknownSync(Protocol.ErrorMessageSchema)(message);
+      expect(result.type).toBe("error");
+      expect(result.transactionId).toBe("tx-789");
+      expect(result.reason).toBe("Transaction is empty");
+    });
+  });
+
+  describe("SubmitResultSchema", () => {
+    it("should validate a success result", () => {
+      const result = {
+        success: true,
+        version: 10,
+      };
+
+      const decoded = Schema.decodeUnknownSync(Protocol.SubmitResultSchema)(result);
+      expect(decoded.success).toBe(true);
+      if (decoded.success) {
+        expect(decoded.version).toBe(10);
+      }
+    });
+
+    it("should validate a failure result", () => {
+      const result = {
+        success: false,
+        reason: "Invalid operation",
+      };
+
+      const decoded = Schema.decodeUnknownSync(Protocol.SubmitResultSchema)(result);
+      expect(decoded.success).toBe(false);
+      if (!decoded.success) {
+        expect(decoded.reason).toBe("Invalid operation");
+      }
+    });
+  });
+});

package/tests/InMemoryDataStorage.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as InMemoryDataStorage from "../src/storage/InMemoryDataStorage";
+import { MimicDataStorageTag } from "../src/MimicDataStorage";
+
+// =============================================================================
+// InMemoryDataStorage Tests
+// =============================================================================
+
+describe("InMemoryDataStorage", () => {
+  describe("load", () => {
+    it("should return undefined for non-existent documents", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          return yield* storage.load("non-existent-doc");
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("save and load", () => {
+    it("should save and load document state", async () => {
+      const testState = { title: "Test Document", count: 42 };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.save("doc-1", testState);
+          return yield* storage.load("doc-1");
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result).toEqual(testState);
+    });
+
+    it("should update existing document", async () => {
+      const initialState = { title: "Initial", count: 0 };
+      const updatedState = { title: "Updated", count: 100 };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.save("doc-1", initialState);
+          yield* storage.save("doc-1", updatedState);
+          return yield* storage.load("doc-1");
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result).toEqual(updatedState);
+    });
+
+    it("should store multiple documents independently", async () => {
+      const state1 = { title: "Doc 1" };
+      const state2 = { title: "Doc 2" };
+      const state3 = { title: "Doc 3" };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.save("doc-1", state1);
+          yield* storage.save("doc-2", state2);
+          yield* storage.save("doc-3", state3);
+          return {
+            doc1: yield* storage.load("doc-1"),
+            doc2: yield* storage.load("doc-2"),
+            doc3: yield* storage.load("doc-3"),
+          };
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result.doc1).toEqual(state1);
+      expect(result.doc2).toEqual(state2);
+      expect(result.doc3).toEqual(state3);
+    });
+  });
+
+  describe("delete", () => {
+    it("should delete existing document", async () => {
+      const testState = { title: "To be deleted" };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.save("doc-1", testState);
+          const beforeDelete = yield* storage.load("doc-1");
+          yield* storage.delete("doc-1");
+          const afterDelete = yield* storage.load("doc-1");
+          return { beforeDelete, afterDelete };
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result.beforeDelete).toEqual(testState);
+      expect(result.afterDelete).toBeUndefined();
+    });
+
+    it("should handle deleting non-existent document gracefully", async () => {
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.delete("non-existent-doc");
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+      // Should not throw
+    });
+
+    it("should not affect other documents when deleting", async () => {
+      const state1 = { title: "Doc 1" };
+      const state2 = { title: "Doc 2" };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.save("doc-1", state1);
+          yield* storage.save("doc-2", state2);
+          yield* storage.delete("doc-1");
+          return {
+            doc1: yield* storage.load("doc-1"),
+            doc2: yield* storage.load("doc-2"),
+          };
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result.doc1).toBeUndefined();
+      expect(result.doc2).toEqual(state2);
+    });
+  });
+
+  describe("onLoad", () => {
+    it("should pass through state unchanged", async () => {
+      const testState = { title: "Test", nested: { value: 123 } };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          return yield* storage.onLoad(testState);
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result).toBe(testState);
+    });
+  });
+
+  describe("onSave", () => {
+    it("should pass through state unchanged", async () => {
+      const testState = { title: "Test", nested: { value: 456 } };
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          return yield* storage.onSave(testState);
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result).toBe(testState);
+    });
+  });
+
+  describe("layer aliases", () => {
+    it("should have layerDefault as an alias for layer", () => {
+      expect(InMemoryDataStorage.layerDefault).toBe(InMemoryDataStorage.layer);
+    });
+  });
+
+  describe("isolation", () => {
+    it("should have independent storage per layer instance", async () => {
+      const testState = { title: "Isolated" };
+
+      // Save in one layer
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          yield* storage.save("doc-1", testState);
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      // Load in a new layer instance - should not find the document
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorageTag;
+          return yield* storage.load("doc-1");
+        }).pipe(Effect.provide(InMemoryDataStorage.layer))
+      );
+
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/tests/MimicAuthService.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as MimicAuthService from "../src/MimicAuthService";
+
+// =============================================================================
+// MimicAuthService Tests
+// =============================================================================
+
+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",
+      }));
+
+      const result = await Effect.runPromise(
+        authService.authenticate("bad-token")
+      );
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toBe("Invalid token");
+      }
+    });
+
+    it("should handle success without userId", async () => {
+      const authService = MimicAuthService.make((_token) => ({
+        success: true,
+      }));
+
+      const result = await Effect.runPromise(
+        authService.authenticate("token")
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.userId).toBeUndefined();
+      }
+    });
+  });
+
+  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}` })
+      );
+
+      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 result = await Effect.runPromise(
+        authService.authenticate("delay-token")
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.userId).toBe("delayed-delay-token");
+      }
+    });
+  });
+
+  describe("layer", () => {
+    it("should create a layer from auth handler", async () => {
+      const testLayer = MimicAuthService.layer({
+        authHandler: (token) => ({ success: true, userId: `layer-${token}` }),
+      });
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthService.MimicAuthServiceTag;
+          return yield* authService.authenticate("layer-token");
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.userId).toBe("layer-layer-token");
+      }
+    });
+  });
+
+  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);
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthService.MimicAuthServiceTag;
+          return yield* authService.authenticate("service-token");
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.userId).toBe("service-service-token");
+      }
+    });
+  });
+
+  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}`,
+          }))
+        )
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthService.MimicAuthServiceTag;
+          return yield* authService.authenticate("effect-layer-token");
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.userId).toBe("effect-layer-effect-layer-token");
+      }
+    });
+  });
+
+  describe("MimicAuthServiceTag", () => {
+    it("should have the correct tag identifier", () => {
+      expect(MimicAuthService.MimicAuthServiceTag.key).toBe(
+        "@voidhash/mimic-server-effect/MimicAuthService"
+      );
+    });
+  });
+});

package/tests/MimicConfig.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Duration from "effect/Duration";
+import * as Schema from "effect/Schema";
+import { Primitive, Presence } from "@voidhash/mimic";
+import * as MimicConfig from "../src/MimicConfig";
+
+// =============================================================================
+// Test Schema
+// =============================================================================
+
+const TestSchema = Primitive.Struct({
+  title: Primitive.String().default(""),
+  count: Primitive.Number().default(0),
+});
+
+// =============================================================================
+// MimicConfig Tests
+// =============================================================================
+
+describe("MimicConfig", () => {
+  describe("make", () => {
+    it("should create config with default values", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+      });
+
+      expect(config.schema).toBe(TestSchema);
+      expect(Duration.toMillis(config.maxIdleTime)).toBe(5 * 60 * 1000); // 5 minutes
+      expect(config.maxTransactionHistory).toBe(1000);
+      expect(Duration.toMillis(config.heartbeatInterval)).toBe(30 * 1000); // 30 seconds
+      expect(Duration.toMillis(config.heartbeatTimeout)).toBe(10 * 1000); // 10 seconds
+    });
+
+    it("should accept custom maxIdleTime", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        maxIdleTime: "10 minutes",
+      });
+
+      expect(Duration.toMillis(config.maxIdleTime)).toBe(10 * 60 * 1000);
+    });
+
+    it("should accept custom maxTransactionHistory", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        maxTransactionHistory: 500,
+      });
+
+      expect(config.maxTransactionHistory).toBe(500);
+    });
+
+    it("should accept custom heartbeatInterval", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        heartbeatInterval: "1 minute",
+      });
+
+      expect(Duration.toMillis(config.heartbeatInterval)).toBe(60 * 1000);
+    });
+
+    it("should accept custom heartbeatTimeout", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        heartbeatTimeout: "30 seconds",
+      });
+
+      expect(Duration.toMillis(config.heartbeatTimeout)).toBe(30 * 1000);
+    });
+
+    it("should accept all custom values", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        maxIdleTime: "15 minutes",
+        maxTransactionHistory: 2000,
+        heartbeatInterval: "45 seconds",
+        heartbeatTimeout: "15 seconds",
+      });
+
+      expect(config.schema).toBe(TestSchema);
+      expect(Duration.toMillis(config.maxIdleTime)).toBe(15 * 60 * 1000);
+      expect(config.maxTransactionHistory).toBe(2000);
+      expect(Duration.toMillis(config.heartbeatInterval)).toBe(45 * 1000);
+      expect(Duration.toMillis(config.heartbeatTimeout)).toBe(15 * 1000);
+    });
+  });
+
+  describe("layer", () => {
+    it("should create a layer that provides MimicServerConfigTag", async () => {
+      const testLayer = MimicConfig.layer({
+        schema: TestSchema,
+        maxTransactionHistory: 100,
+      });
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const config = yield* MimicConfig.MimicServerConfigTag;
+          return config;
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result.schema).toBe(TestSchema);
+      expect(result.maxTransactionHistory).toBe(100);
+    });
+  });
+
+  describe("MimicServerConfigTag", () => {
+    it("should have the correct tag identifier", () => {
+      expect(MimicConfig.MimicServerConfigTag.key).toBe(
+        "@voidhash/mimic-server-effect/MimicServerConfig"
+      );
+    });
+  });
+
+  describe("presence configuration", () => {
+    const CursorPresence = Presence.make({
+      schema: Schema.Struct({
+        x: Schema.Number,
+        y: Schema.Number,
+        name: Schema.optional(Schema.String),
+      }),
+    });
+
+    it("should have undefined presence by default", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+      });
+
+      expect(config.presence).toBeUndefined();
+    });
+
+    it("should accept presence schema option", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        presence: CursorPresence,
+      });
+
+      expect(config.presence).toBe(CursorPresence);
+    });
+
+    it("should provide presence through layer", async () => {
+      const testLayer = MimicConfig.layer({
+        schema: TestSchema,
+        presence: CursorPresence,
+      });
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const config = yield* MimicConfig.MimicServerConfigTag;
+          return config.presence;
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toBe(CursorPresence);
+    });
+
+    it("should work with all options including presence", () => {
+      const config = MimicConfig.make({
+        schema: TestSchema,
+        maxIdleTime: "10 minutes",
+        maxTransactionHistory: 500,
+        heartbeatInterval: "1 minute",
+        heartbeatTimeout: "20 seconds",
+        presence: CursorPresence,
+      });
+
+      expect(config.schema).toBe(TestSchema);
+      expect(Duration.toMillis(config.maxIdleTime)).toBe(10 * 60 * 1000);
+      expect(config.maxTransactionHistory).toBe(500);
+      expect(Duration.toMillis(config.heartbeatInterval)).toBe(60 * 1000);
+      expect(Duration.toMillis(config.heartbeatTimeout)).toBe(20 * 1000);
+      expect(config.presence).toBe(CursorPresence);
+    });
+  });
+});