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

package/tests/DocumentProtocol.test.ts

@@ -1,113 +0,0 @@
-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

@@ -1,190 +0,0 @@
-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/MimicConfig.test.ts

@@ -1,290 +0,0 @@
-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);
-    });
-  });
-
-  describe("initial state configuration", () => {
-    it("should have undefined initial state by default", () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-      });
-
-      expect(config.initial).toBeUndefined();
-    });
-
-    it("should accept initial state object and convert to function", async () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-        initial: { title: "My Document", count: 42 },
-      });
-
-      expect(typeof config.initial).toBe("function");
-      // The function should return the initial state when called
-      const result = await Effect.runPromise(config.initial!({ documentId: "test-doc" }));
-      expect(result).toEqual({ title: "My Document", count: 42 });
-    });
-
-    it("should apply defaults for omitted fields in initial state object", async () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-        initial: { title: "My Document" }, // count has default of 0
-      });
-
-      const result = await Effect.runPromise(config.initial!({ documentId: "test-doc" }));
-      expect(result).toEqual({ title: "My Document", count: 0 });
-    });
-
-    it("should accept initial state function", async () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-        initial: ({ documentId }) => Effect.succeed({ title: `Doc ${documentId}`, count: 123 }),
-      });
-
-      expect(typeof config.initial).toBe("function");
-      const result = await Effect.runPromise(config.initial!({ documentId: "my-doc-id" }));
-      expect(result).toEqual({ title: "Doc my-doc-id", count: 123 });
-    });
-
-    it("should apply defaults to initial state function result", async () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-        initial: ({ documentId }) => Effect.succeed({ title: documentId }), // count omitted
-      });
-
-      const result = await Effect.runPromise(config.initial!({ documentId: "test" }));
-      expect(result).toEqual({ title: "test", count: 0 });
-    });
-
-    it("should provide initial function through layer", async () => {
-      const testLayer = MimicConfig.layer({
-        schema: TestSchema,
-        initial: { title: "From Layer", count: 100 },
-      });
-
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const config = yield* MimicConfig.MimicServerConfigTag;
-          return yield* config.initial!({ documentId: "layer-doc" });
-        }).pipe(Effect.provide(testLayer))
-      );
-
-      expect(result).toEqual({ title: "From Layer", count: 100 });
-    });
-
-    it("should work with schema that has required fields without defaults", async () => {
-      const SchemaWithRequired = Primitive.Struct({
-        name: Primitive.String().required(),
-        optional: Primitive.String().default("default"),
-      });
-
-      const config = MimicConfig.make({
-        schema: SchemaWithRequired,
-        initial: { name: "Required Name" },
-      });
-
-      const result = await Effect.runPromise(config.initial!({ documentId: "test" }));
-      expect(result).toEqual({ name: "Required Name", optional: "default" });
-    });
-
-    it("should work with all options including initial object", async () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-        maxIdleTime: "10 minutes",
-        maxTransactionHistory: 500,
-        initial: { title: "Full Options", count: 999 },
-      });
-
-      expect(config.schema).toBe(TestSchema);
-      expect(Duration.toMillis(config.maxIdleTime)).toBe(10 * 60 * 1000);
-      expect(config.maxTransactionHistory).toBe(500);
-      const result = await Effect.runPromise(config.initial!({ documentId: "test" }));
-      expect(result).toEqual({ title: "Full Options", count: 999 });
-    });
-
-    it("should work with initial function that uses documentId", async () => {
-      const config = MimicConfig.make({
-        schema: TestSchema,
-        initial: ({ documentId }) => Effect.succeed({
-          title: `Document: ${documentId}`,
-          count: documentId.length,
-        }),
-      });
-
-      const result1 = await Effect.runPromise(config.initial!({ documentId: "short" }));
-      expect(result1).toEqual({ title: "Document: short", count: 5 });
-
-      const result2 = await Effect.runPromise(config.initial!({ documentId: "longer-id" }));
-      expect(result2).toEqual({ title: "Document: longer-id", count: 9 });
-    });
-  });
-});