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

package/tests/MimicServer.test.ts

@@ -1,11 +1,12 @@
 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 { Effect, Layer } from "effect";
+import { Schema } from "effect";
 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";
+import { MimicServer } from "../src/MimicServer";
+import { MimicServerEngine } from "../src/MimicServerEngine";
+import { ColdStorage } from "../src/ColdStorage";
+import { HotStorage } from "../src/HotStorage";
+import { MimicAuthService } from "../src/MimicAuthService";
 
 // =============================================================================
 // Test Schema
@@ -13,7 +14,15 @@ import * as InMemoryDataStorage from "../src/storage/InMemoryDataStorage";
 
 const TestSchema = Primitive.Struct({
   title: Primitive.String().default(""),
-  completed: Primitive.Boolean().default(false),
+  count: Primitive.Number().default(0),
+});
+
+const CursorPresence = Presence.make({
+  schema: Schema.Struct({
+    x: Schema.Number,
+    y: Schema.Number,
+    name: Schema.optional(Schema.String),
+  }),
 });
 
 // =============================================================================
@@ -21,258 +30,113 @@ const TestSchema = Primitive.Struct({
 // =============================================================================
 
 describe("MimicServer", () => {
-
-  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 create route layer with default config", () => {
+      const route = MimicServer.layerHttpLayerRouter();
+      
+      // Should return a Layer
+      expect(route).toBeDefined();
+      // Layer should have the proper structure
+      expect(typeof route).toBe("object");
     });
 
-    it("should accept custom authLayer option", () => {
-      const customAuthLayer = MimicAuthService.layer({
-        authHandler: (token) => ({ success: true, userId: token }),
+    it("should create route layer with custom path", () => {
+      const route = MimicServer.layerHttpLayerRouter({
+        path: "/custom-mimic",
       });
+      
+      expect(route).toBeDefined();
+    });
 
-      const routeLayer = MimicServer.layerHttpLayerRouter({
-        basePath: "/mimic/test",
-        schema: TestSchema,
-        authLayer: customAuthLayer,
+    it("should create route layer with custom heartbeat config", () => {
+      const route = MimicServer.layerHttpLayerRouter({
+        path: "/mimic",
+        heartbeatInterval: "15 seconds",
+        heartbeatTimeout: "5 seconds",
       });
-
-      expect(routeLayer).toBeDefined();
+      
+      expect(route).toBeDefined();
     });
 
-    it("should accept custom storageLayer option", () => {
-      const routeLayer = MimicServer.layerHttpLayerRouter({
-        basePath: "/mimic/test",
+    it("should compose with engine layer", () => {
+      // Create the engine
+      const Engine = MimicServerEngine.make({
         schema: TestSchema,
-        storageLayer: InMemoryDataStorage.layer,
+        initial: { title: "Untitled" },
       });
 
-      expect(routeLayer).toBeDefined();
-    });
-
-    it("should accept both custom authLayer and storageLayer", () => {
-      const customAuthLayer = MimicAuthService.layer({
-        authHandler: (token) => ({ success: true, userId: token }),
+      // Create the route layer
+      const MimicRoute = MimicServer.layerHttpLayerRouter({
+        path: "/mimic",
       });
 
-      const routeLayer = MimicServer.layerHttpLayerRouter({
-        basePath: "/mimic/test",
-        schema: TestSchema,
-        authLayer: customAuthLayer,
-        storageLayer: InMemoryDataStorage.layer,
-      });
+      // Wire together - this should type-check
+      const MimicLive = MimicRoute.pipe(
+        Layer.provide(Engine),
+        Layer.provide(ColdStorage.InMemory.make()),
+        Layer.provide(HotStorage.InMemory.make()),
+        Layer.provide(MimicAuthService.NoAuth.make())
+      );
 
-      expect(routeLayer).toBeDefined();
+      expect(MimicLive).toBeDefined();
     });
 
-    it("should use default basePath when not provided", () => {
-      const routeLayer = MimicServer.layerHttpLayerRouter({
+    it("should compose with presence-enabled engine", () => {
+      // Create the engine with presence
+      const Engine = MimicServerEngine.make({
         schema: TestSchema,
+        initial: { title: "Untitled" },
+        presence: CursorPresence,
       });
 
-      expect(routeLayer).toBeDefined();
-    });
-
-    it("should support maxTransactionHistory option", () => {
-      const routeLayer = MimicServer.layerHttpLayerRouter({
-        basePath: "/mimic/test",
-        schema: TestSchema,
-        maxTransactionHistory: 500,
+      // Create the route layer
+      const MimicRoute = MimicServer.layerHttpLayerRouter({
+        path: "/mimic",
       });
 
-      expect(routeLayer).toBeDefined();
-    });
-  });
-
-  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,
-      };
+      // Wire together
+      const MimicLive = MimicRoute.pipe(
+        Layer.provide(Engine),
+        Layer.provide(ColdStorage.InMemory.make()),
+        Layer.provide(HotStorage.InMemory.make()),
+        Layer.provide(MimicAuthService.NoAuth.make())
+      );
 
-      expect(options.schema).toBe(TestSchema);
-      expect(options.basePath).toBe("/custom/path");
-      expect(options.maxTransactionHistory).toBe(1000);
+      expect(MimicLive).toBeDefined();
     });
 
-    it("should work with only required properties", () => {
-      const options: MimicServer.MimicLayerOptions<typeof TestSchema> = {
+    it("should compose with static auth", () => {
+      // Create the engine
+      const Engine = MimicServerEngine.make({
         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("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();
+        initial: { title: "Untitled" },
       });
 
-      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();
+      // Create the route layer
+      const MimicRoute = MimicServer.layerHttpLayerRouter({
+        path: "/mimic",
       });
-    });
 
-    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,
-        };
+      // Wire together with static auth
+      const MimicLive = MimicRoute.pipe(
+        Layer.provide(Engine),
+        Layer.provide(ColdStorage.InMemory.make()),
+        Layer.provide(HotStorage.InMemory.make()),
+        Layer.provide(
+          MimicAuthService.Static.make({
+            permissions: { admin: "write", user: "read" },
+            defaultPermission: "read",
+          })
+        )
+      );
 
-        expect(options.schema).toBe(TestSchema);
-        expect(options.basePath).toBe("/custom/path");
-        expect(options.maxTransactionHistory).toBe(1000);
-        expect(options.presence).toBe(CursorPresence);
-      });
+      expect(MimicLive).toBeDefined();
     });
   });
 
-  describe("initial state support", () => {
-    describe("layerHttpLayerRouter", () => {
-      it("should accept initial option", () => {
-        const routeLayer = MimicServer.layerHttpLayerRouter({
-          basePath: "/mimic/test",
-          schema: TestSchema,
-          initial: { title: "My Document", completed: true },
-        });
-
-        expect(routeLayer).toBeDefined();
-      });
-
-      it("should work with initial and all other options", () => {
-        const customAuthLayer = MimicAuthService.layer({
-          authHandler: (token) => ({ success: true, userId: token }),
-        });
-
-        const routeLayer = MimicServer.layerHttpLayerRouter({
-          basePath: "/mimic/test",
-          schema: TestSchema,
-          initial: { title: "Full Options" },
-          maxTransactionHistory: 500,
-          authLayer: customAuthLayer,
-          storageLayer: InMemoryDataStorage.layer,
-        });
-
-        expect(routeLayer).toBeDefined();
-      });
-    });
-
-    describe("MimicLayerOptions with initial", () => {
-      it("should accept initial in options", () => {
-        const options: MimicServer.MimicLayerOptions<typeof TestSchema> = {
-          schema: TestSchema,
-          basePath: "/custom/path",
-          initial: { title: "Initial State", completed: true },
-        };
-
-        expect(options.schema).toBe(TestSchema);
-        expect(options.basePath).toBe("/custom/path");
-        expect(options.initial).toEqual({ title: "Initial State", completed: true });
-      });
-
-      it("should allow omitting optional fields in initial (type safety)", () => {
-        // This test verifies that TypeScript allows omitting fields with defaults
-        const options: MimicServer.MimicLayerOptions<typeof TestSchema> = {
-          schema: TestSchema,
-          initial: { title: "Only Title" }, // completed is optional because it has a default
-        };
-
-        expect(options.initial).toEqual({ title: "Only Title" });
-      });
+  describe("namespace", () => {
+    it("should export layerHttpLayerRouter function", () => {
+      expect(typeof MimicServer.layerHttpLayerRouter).toBe("function");
     });
   });
 });