@voidhash/mimic-effect 0.0.1-alpha.1

package/tests/MimicDataStorage.test.ts

@@ -0,0 +1,190 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as MimicDataStorage from "../src/MimicDataStorage";
+
+// =============================================================================
+// Error Tests
+// =============================================================================
+
+describe("MimicDataStorage", () => {
+  describe("StorageLoadError", () => {
+    it("should have correct message", () => {
+      const error = new MimicDataStorage.StorageLoadError({
+        documentId: "doc-123",
+        cause: new Error("Connection failed"),
+      });
+      expect(error.message).toBe(
+        "Failed to load document doc-123: Error: Connection failed"
+      );
+      expect(error._tag).toBe("StorageLoadError");
+      expect(error.documentId).toBe("doc-123");
+    });
+  });
+
+  describe("StorageSaveError", () => {
+    it("should have correct message", () => {
+      const error = new MimicDataStorage.StorageSaveError({
+        documentId: "doc-456",
+        cause: new Error("Disk full"),
+      });
+      expect(error.message).toBe(
+        "Failed to save document doc-456: Error: Disk full"
+      );
+      expect(error._tag).toBe("StorageSaveError");
+      expect(error.documentId).toBe("doc-456");
+    });
+  });
+
+  describe("StorageDeleteError", () => {
+    it("should have correct message", () => {
+      const error = new MimicDataStorage.StorageDeleteError({
+        documentId: "doc-789",
+        cause: new Error("Permission denied"),
+      });
+      expect(error.message).toBe(
+        "Failed to delete document doc-789: Error: Permission denied"
+      );
+      expect(error._tag).toBe("StorageDeleteError");
+      expect(error.documentId).toBe("doc-789");
+    });
+  });
+
+  describe("make", () => {
+    it("should create storage with required functions", async () => {
+      const storage = MimicDataStorage.make({
+        load: (documentId) => Effect.succeed({ id: documentId, data: "test" }),
+        save: (_documentId, _state) => Effect.void,
+      });
+
+      const loaded = await Effect.runPromise(storage.load("doc-1"));
+      expect(loaded).toEqual({ id: "doc-1", data: "test" });
+
+      await Effect.runPromise(storage.save("doc-1", { data: "new" }));
+    });
+
+    it("should provide default delete implementation", async () => {
+      const storage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed(undefined),
+        save: (_documentId, _state) => Effect.void,
+      });
+
+      // Default delete should be a no-op
+      await Effect.runPromise(storage.delete("doc-1"));
+    });
+
+    it("should provide default onLoad implementation (pass-through)", async () => {
+      const storage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed(undefined),
+        save: (_documentId, _state) => Effect.void,
+      });
+
+      const state = { title: "Test" };
+      const result = await Effect.runPromise(storage.onLoad(state));
+      expect(result).toBe(state);
+    });
+
+    it("should provide default onSave implementation (pass-through)", async () => {
+      const storage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed(undefined),
+        save: (_documentId, _state) => Effect.void,
+      });
+
+      const state = { title: "Test" };
+      const result = await Effect.runPromise(storage.onSave(state));
+      expect(result).toBe(state);
+    });
+
+    it("should accept custom delete implementation", async () => {
+      let deletedId: string | null = null;
+      const storage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed(undefined),
+        save: (_documentId, _state) => Effect.void,
+        delete: (documentId) => {
+          deletedId = documentId;
+          return Effect.void;
+        },
+      });
+
+      await Effect.runPromise(storage.delete("doc-to-delete"));
+      expect(deletedId).toBe("doc-to-delete");
+    });
+
+    it("should accept custom onLoad implementation", async () => {
+      const storage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed(undefined),
+        save: (_documentId, _state) => Effect.void,
+        onLoad: (state) =>
+          Effect.succeed({ ...(state as object), loaded: true }),
+      });
+
+      const result = await Effect.runPromise(
+        storage.onLoad({ title: "Test" })
+      );
+      expect(result).toEqual({ title: "Test", loaded: true });
+    });
+
+    it("should accept custom onSave implementation", async () => {
+      const storage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed(undefined),
+        save: (_documentId, _state) => Effect.void,
+        onSave: (state) =>
+          Effect.succeed({ ...(state as object), savedAt: "now" }),
+      });
+
+      const result = await Effect.runPromise(
+        storage.onSave({ title: "Test" })
+      );
+      expect(result).toEqual({ title: "Test", savedAt: "now" });
+    });
+  });
+
+  describe("layer", () => {
+    it("should create a layer that provides MimicDataStorageTag", async () => {
+      const testStorage = MimicDataStorage.make({
+        load: (_documentId) => Effect.succeed({ test: true }),
+        save: (_documentId, _state) => Effect.void,
+      });
+
+      const testLayer = MimicDataStorage.layer(testStorage);
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorage.MimicDataStorageTag;
+          return yield* storage.load("doc-1");
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toEqual({ test: true });
+    });
+  });
+
+  describe("layerEffect", () => {
+    it("should create a layer from an Effect", async () => {
+      const testLayer = MimicDataStorage.layerEffect(
+        Effect.succeed(
+          MimicDataStorage.make({
+            load: (_documentId) => Effect.succeed({ fromEffect: true }),
+            save: (_documentId, _state) => Effect.void,
+          })
+        )
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const storage = yield* MimicDataStorage.MimicDataStorageTag;
+          return yield* storage.load("doc-1");
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toEqual({ fromEffect: true });
+    });
+  });
+
+  describe("MimicDataStorageTag", () => {
+    it("should have the correct tag identifier", () => {
+      expect(MimicDataStorage.MimicDataStorageTag.key).toBe(
+        "@voidhash/mimic-server-effect/MimicDataStorage"
+      );
+    });
+  });
+});

package/tests/MimicServer.test.ts

@@ -0,0 +1,385 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { Primitive, Presence } from "@voidhash/mimic";
+import * as MimicServer from "../src/MimicServer";
+import * as MimicAuthService from "../src/MimicAuthService";
+import * as InMemoryDataStorage from "../src/storage/InMemoryDataStorage";
+
+// =============================================================================
+// Test Schema
+// =============================================================================
+
+const TestSchema = Primitive.Struct({
+  title: Primitive.String().default(""),
+  completed: Primitive.Boolean().default(false),
+});
+
+// =============================================================================
+// MimicServer Tests
+// =============================================================================
+
+describe("MimicServer", () => {
+  describe("layer", () => {
+    it("should create a layer with default auth and storage", async () => {
+      const testLayer = MimicServer.layer({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+      });
+
+      // Verify the layer provides the expected services
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = yield* MimicServer.MimicWebSocketHandler;
+          return typeof handler === "function";
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toBe(true);
+    });
+
+    it("should allow custom auth layer to be provided", async () => {
+      let authCalled = false;
+
+      const customAuthLayer = MimicAuthService.layer({
+        authHandler: (token) => {
+          authCalled = true;
+          return { success: true, userId: token };
+        },
+      });
+
+      const testLayer = MimicServer.layer({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+      }).pipe(Layer.provideMerge(customAuthLayer));
+
+      // Verify the layer compiles with custom auth
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = yield* MimicServer.MimicWebSocketHandler;
+          return typeof handler === "function";
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toBe(true);
+    });
+
+    it("should support maxTransactionHistory option", async () => {
+      const testLayer = MimicServer.layer({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+        maxTransactionHistory: 500,
+      });
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = yield* MimicServer.MimicWebSocketHandler;
+          return typeof handler === "function";
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("handlerLayer", () => {
+    it("should create a layer that provides MimicWebSocketHandler", async () => {
+      const testLayer = MimicServer.handlerLayer({
+        schema: TestSchema,
+      });
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = yield* MimicServer.MimicWebSocketHandler;
+          return typeof handler === "function";
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("documentManagerLayer", () => {
+    it("should create a layer that provides DocumentManager", async () => {
+      const testLayer = MimicServer.documentManagerLayer({
+        schema: TestSchema,
+      });
+
+      // Just verify the layer compiles and provides the service
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          // DocumentManager is provided by the layer
+          return true;
+        }).pipe(Effect.provide(testLayer))
+      );
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("layerHttpLayerRouter", () => {
+    it("should create a layer with default auth and storage", () => {
+      // Verify the function returns a layer without throwing
+      const routeLayer = MimicServer.layerHttpLayerRouter({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+      });
+
+      expect(routeLayer).toBeDefined();
+    });
+
+    it("should accept custom authLayer option", () => {
+      const customAuthLayer = MimicAuthService.layer({
+        authHandler: (token) => ({ success: true, userId: token }),
+      });
+
+      const routeLayer = MimicServer.layerHttpLayerRouter({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+        authLayer: customAuthLayer,
+      });
+
+      expect(routeLayer).toBeDefined();
+    });
+
+    it("should accept custom storageLayer option", () => {
+      const routeLayer = MimicServer.layerHttpLayerRouter({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+        storageLayer: InMemoryDataStorage.layer,
+      });
+
+      expect(routeLayer).toBeDefined();
+    });
+
+    it("should accept both custom authLayer and storageLayer", () => {
+      const customAuthLayer = MimicAuthService.layer({
+        authHandler: (token) => ({ success: true, userId: token }),
+      });
+
+      const routeLayer = MimicServer.layerHttpLayerRouter({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+        authLayer: customAuthLayer,
+        storageLayer: InMemoryDataStorage.layer,
+      });
+
+      expect(routeLayer).toBeDefined();
+    });
+
+    it("should use default basePath when not provided", () => {
+      const routeLayer = MimicServer.layerHttpLayerRouter({
+        schema: TestSchema,
+      });
+
+      expect(routeLayer).toBeDefined();
+    });
+
+    it("should support maxTransactionHistory option", () => {
+      const routeLayer = MimicServer.layerHttpLayerRouter({
+        basePath: "/mimic/test",
+        schema: TestSchema,
+        maxTransactionHistory: 500,
+      });
+
+      expect(routeLayer).toBeDefined();
+    });
+  });
+
+  describe("MimicWebSocketHandler tag", () => {
+    it("should have the correct tag identifier", () => {
+      expect(MimicServer.MimicWebSocketHandler.key).toBe(
+        "@voidhash/mimic-server-effect/MimicWebSocketHandler"
+      );
+    });
+  });
+
+  describe("MimicLayerOptions", () => {
+    it("should accept all optional properties", () => {
+      // TypeScript compile-time check - if this compiles, the interface is correct
+      const options: MimicServer.MimicLayerOptions<typeof TestSchema> = {
+        schema: TestSchema,
+        basePath: "/custom/path",
+        maxTransactionHistory: 1000,
+      };
+
+      expect(options.schema).toBe(TestSchema);
+      expect(options.basePath).toBe("/custom/path");
+      expect(options.maxTransactionHistory).toBe(1000);
+    });
+
+    it("should work with only required properties", () => {
+      const options: MimicServer.MimicLayerOptions<typeof TestSchema> = {
+        schema: TestSchema,
+      };
+
+      expect(options.schema).toBe(TestSchema);
+      expect(options.basePath).toBeUndefined();
+      expect(options.maxTransactionHistory).toBeUndefined();
+    });
+  });
+
+  describe("presence support", () => {
+    const CursorPresence = Presence.make({
+      schema: Schema.Struct({
+        x: Schema.Number,
+        y: Schema.Number,
+        name: Schema.optional(Schema.String),
+      }),
+    });
+
+    describe("layer", () => {
+      it("should accept presence option", async () => {
+        const testLayer = MimicServer.layer({
+          basePath: "/mimic/test",
+          schema: TestSchema,
+          presence: CursorPresence,
+        });
+
+        const result = await Effect.runPromise(
+          Effect.gen(function* () {
+            const handler = yield* MimicServer.MimicWebSocketHandler;
+            return typeof handler === "function";
+          }).pipe(Effect.provide(testLayer))
+        );
+
+        expect(result).toBe(true);
+      });
+
+      it("should work with presence and custom auth", async () => {
+        const customAuthLayer = MimicAuthService.layer({
+          authHandler: (token) => ({ success: true, userId: token }),
+        });
+
+        const testLayer = MimicServer.layer({
+          basePath: "/mimic/test",
+          schema: TestSchema,
+          presence: CursorPresence,
+        }).pipe(Layer.provideMerge(customAuthLayer));
+
+        const result = await Effect.runPromise(
+          Effect.gen(function* () {
+            const handler = yield* MimicServer.MimicWebSocketHandler;
+            return typeof handler === "function";
+          }).pipe(Effect.provide(testLayer))
+        );
+
+        expect(result).toBe(true);
+      });
+
+      it("should work with presence and maxTransactionHistory", async () => {
+        const testLayer = MimicServer.layer({
+          basePath: "/mimic/test",
+          schema: TestSchema,
+          presence: CursorPresence,
+          maxTransactionHistory: 500,
+        });
+
+        const result = await Effect.runPromise(
+          Effect.gen(function* () {
+            const handler = yield* MimicServer.MimicWebSocketHandler;
+            return typeof handler === "function";
+          }).pipe(Effect.provide(testLayer))
+        );
+
+        expect(result).toBe(true);
+      });
+    });
+
+    describe("handlerLayer", () => {
+      it("should accept presence option", async () => {
+        const testLayer = MimicServer.handlerLayer({
+          schema: TestSchema,
+          presence: CursorPresence,
+        });
+
+        const result = await Effect.runPromise(
+          Effect.gen(function* () {
+            const handler = yield* MimicServer.MimicWebSocketHandler;
+            return typeof handler === "function";
+          }).pipe(Effect.provide(testLayer))
+        );
+
+        expect(result).toBe(true);
+      });
+    });
+
+    describe("documentManagerLayer", () => {
+      it("should accept presence option", async () => {
+        const testLayer = MimicServer.documentManagerLayer({
+          schema: TestSchema,
+          presence: CursorPresence,
+        });
+
+        const result = await Effect.runPromise(
+          Effect.gen(function* () {
+            return true;
+          }).pipe(Effect.provide(testLayer))
+        );
+
+        expect(result).toBe(true);
+      });
+    });
+
+    describe("layerHttpLayerRouter", () => {
+      it("should accept presence option", () => {
+        const routeLayer = MimicServer.layerHttpLayerRouter({
+          basePath: "/mimic/test",
+          schema: TestSchema,
+          presence: CursorPresence,
+        });
+
+        expect(routeLayer).toBeDefined();
+      });
+
+      it("should work with presence and custom authLayer", () => {
+        const customAuthLayer = MimicAuthService.layer({
+          authHandler: (token) => ({ success: true, userId: token }),
+        });
+
+        const routeLayer = MimicServer.layerHttpLayerRouter({
+          basePath: "/mimic/test",
+          schema: TestSchema,
+          presence: CursorPresence,
+          authLayer: customAuthLayer,
+        });
+
+        expect(routeLayer).toBeDefined();
+      });
+
+      it("should work with presence and all options", () => {
+        const customAuthLayer = MimicAuthService.layer({
+          authHandler: (token) => ({ success: true, userId: token }),
+        });
+
+        const routeLayer = MimicServer.layerHttpLayerRouter({
+          basePath: "/mimic/test",
+          schema: TestSchema,
+          presence: CursorPresence,
+          maxTransactionHistory: 500,
+          authLayer: customAuthLayer,
+          storageLayer: InMemoryDataStorage.layer,
+        });
+
+        expect(routeLayer).toBeDefined();
+      });
+    });
+
+    describe("MimicLayerOptions with presence", () => {
+      it("should accept presence in options", () => {
+        const options: MimicServer.MimicLayerOptions<typeof TestSchema> = {
+          schema: TestSchema,
+          basePath: "/custom/path",
+          maxTransactionHistory: 1000,
+          presence: CursorPresence,
+        };
+
+        expect(options.schema).toBe(TestSchema);
+        expect(options.basePath).toBe("/custom/path");
+        expect(options.maxTransactionHistory).toBe(1000);
+        expect(options.presence).toBe(CursorPresence);
+      });
+    });
+  });
+});

package/tests/NoAuth.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as NoAuth from "../src/auth/NoAuth";
+import { MimicAuthServiceTag } from "../src/MimicAuthService";
+
+// =============================================================================
+// NoAuth Tests
+// =============================================================================
+
+describe("NoAuth", () => {
+  describe("authenticate", () => {
+    it("should always return success: true", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthServiceTag;
+          return yield* authService.authenticate("any-token");
+        }).pipe(Effect.provide(NoAuth.layer))
+      );
+
+      expect(result).toEqual({ success: true });
+    });
+
+    it("should succeed with empty token", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthServiceTag;
+          return yield* authService.authenticate("");
+        }).pipe(Effect.provide(NoAuth.layer))
+      );
+
+      expect(result.success).toBe(true);
+    });
+
+    it("should succeed with any arbitrary token", async () => {
+      const tokens = [
+        "valid-token-123",
+        "invalid-token",
+        "abc123xyz",
+        "special!@#$%^&*()",
+        "very-long-token-" + "x".repeat(1000),
+      ];
+
+      for (const token of tokens) {
+        const result = await Effect.runPromise(
+          Effect.gen(function* () {
+            const authService = yield* MimicAuthServiceTag;
+            return yield* authService.authenticate(token);
+          }).pipe(Effect.provide(NoAuth.layer))
+        );
+
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it("should not include userId in result", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthServiceTag;
+          return yield* authService.authenticate("test-token");
+        }).pipe(Effect.provide(NoAuth.layer))
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.userId).toBeUndefined();
+      }
+    });
+  });
+
+  describe("layer aliases", () => {
+    it("should have layerDefault as an alias for layer", () => {
+      expect(NoAuth.layerDefault).toBe(NoAuth.layer);
+    });
+  });
+
+  describe("multiple authentications", () => {
+    it("should handle multiple sequential authentications", async () => {
+      const results = await Effect.runPromise(
+        Effect.gen(function* () {
+          const authService = yield* MimicAuthServiceTag;
+          const result1 = yield* authService.authenticate("token-1");
+          const result2 = yield* authService.authenticate("token-2");
+          const result3 = yield* authService.authenticate("token-3");
+          return [result1, result2, result3];
+        }).pipe(Effect.provide(NoAuth.layer))
+      );
+
+      expect(results).toHaveLength(3);
+      for (const result of results) {
+        expect(result.success).toBe(true);
+      }
+    });
+  });
+});