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

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 });
-    });
-  });
-});

package/tests/MimicDataStorage.test.ts

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

@@ -1,94 +0,0 @@
-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);
-      }
-    });
-  });
-});