@voidhash/mimic-effect 0.0.3 → 0.0.5

package/tests/MimicServer.test.ts

@@ -21,84 +21,6 @@ const TestSchema = Primitive.Struct({
 // =============================================================================
 
 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 () => {
@@ -187,14 +109,6 @@ describe("MimicServer", () => {
     });
   });
 
-  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
@@ -229,82 +143,6 @@ describe("MimicServer", () => {
       }),
     });
 
-    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({
@@ -382,4 +220,59 @@ describe("MimicServer", () => {
       });
     });
   });
+
+  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" });
+      });
+    });
+  });
 });