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

package/src/auth/NoAuth.ts

@@ -1,46 +0,0 @@
-/**
- * @since 0.0.1
- * No authentication implementation for Mimic connections.
- * All connections are automatically authenticated (open access).
- */
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-
-import {
-  MimicAuthServiceTag,
-  type MimicAuthService,
-} from "../MimicAuthService.js";
-
-// =============================================================================
-// No-Auth Implementation
-// =============================================================================
-
-/**
- * Authentication service that auto-succeeds all authentication requests.
- * Use this for development or when authentication is handled externally.
- */
-const noAuthService: MimicAuthService = {
-  authenticate: (_token: string) =>
-    Effect.succeed({ success: true as const }),
-};
-
-// =============================================================================
-// Layer
-// =============================================================================
-
-/**
- * Layer that provides no authentication (open access).
- * All connections are automatically authenticated.
- * 
- * WARNING: Only use this for development or when authentication
- * is handled at a different layer (e.g., API gateway, reverse proxy).
- */
-export const layer: Layer.Layer<MimicAuthServiceTag> = Layer.succeed(
-  MimicAuthServiceTag,
-  noAuthService
-);
-
-/**
- * Default layer alias for convenience.
- */
-export const layerDefault = layer;

package/src/errors.ts

@@ -1,113 +0,0 @@
-/**
- * @since 0.0.1
- * Error types for the Mimic server.
- */
-import * as Data from "effect/Data";
-
-// =============================================================================
-// Error Types
-// =============================================================================
-
-/**
- * Error when a document type is not found in the schema registry.
- */
-export class DocumentTypeNotFoundError extends Data.TaggedError(
-  "DocumentTypeNotFoundError"
-)<{
-  readonly documentType: string;
-}> {
-  override get message(): string {
-    return `Document type not found: ${this.documentType}`;
-  }
-}
-
-/**
- * Error when a document is not found.
- */
-export class DocumentNotFoundError extends Data.TaggedError(
-  "DocumentNotFoundError"
-)<{
-  readonly documentId: string;
-}> {
-  override get message(): string {
-    return `Document not found: ${this.documentId}`;
-  }
-}
-
-/**
- * Error when authentication fails.
- */
-export class AuthenticationError extends Data.TaggedError(
-  "AuthenticationError"
-)<{
-  readonly reason: string;
-}> {
-  override get message(): string {
-    return `Authentication failed: ${this.reason}`;
-  }
-}
-
-/**
- * Error when a transaction is rejected.
- */
-export class TransactionRejectedError extends Data.TaggedError(
-  "TransactionRejectedError"
-)<{
-  readonly transactionId: string;
-  readonly reason: string;
-}> {
-  override get message(): string {
-    return `Transaction ${this.transactionId} rejected: ${this.reason}`;
-  }
-}
-
-/**
- * Error when parsing a client message fails.
- */
-export class MessageParseError extends Data.TaggedError("MessageParseError")<{
-  readonly cause: unknown;
-}> {
-  override get message(): string {
-    return `Failed to parse message: ${String(this.cause)}`;
-  }
-}
-
-/**
- * Error when the WebSocket connection is invalid.
- */
-export class InvalidConnectionError extends Data.TaggedError(
-  "InvalidConnectionError"
-)<{
-  readonly reason: string;
-}> {
-  override get message(): string {
-    return `Invalid connection: ${this.reason}`;
-  }
-}
-
-/**
- * Error when the document ID is missing from the URL path.
- */
-export class MissingDocumentIdError extends Data.TaggedError(
-  "MissingDocumentIdError"
-)<{
-  readonly path?: string;
-}> {
-  override get message(): string {
-    return this.path 
-      ? `Document ID is required in the URL path: ${this.path}`
-      : "Document ID is required in the URL path";
-  }
-}
-
-/**
- * Union of all Mimic server errors.
- */
-export type MimicServerError =
-  | DocumentTypeNotFoundError
-  | DocumentNotFoundError
-  | AuthenticationError
-  | TransactionRejectedError
-  | MessageParseError
-  | InvalidConnectionError
-  | MissingDocumentIdError;

package/src/storage/InMemoryDataStorage.ts

@@ -1,66 +0,0 @@
-/**
- * @since 0.0.1
- * In-memory data storage implementation for Mimic documents.
- * Provides ephemeral storage - data is lost when the server restarts.
- */
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Ref from "effect/Ref";
-import * as HashMap from "effect/HashMap";
-
-import {
-  MimicDataStorageTag,
-  type MimicDataStorage,
-} from "../MimicDataStorage.js";
-
-// =============================================================================
-// In-Memory Storage Implementation
-// =============================================================================
-
-/**
- * Create an in-memory storage service.
- * Uses a HashMap to store documents in memory.
- */
-const makeInMemoryStorage = Effect.gen(function* () {
-  // Create a mutable reference to a HashMap for storing documents
-  const store = yield* Ref.make(HashMap.empty<string, unknown>());
-
-  const storage: MimicDataStorage = {
-    load: (documentId: string) =>
-      Effect.gen(function* () {
-        const current = yield* Ref.get(store);
-        const result = HashMap.get(current, documentId);
-        return result._tag === "Some" ? result.value : undefined;
-      }),
-
-    save: (documentId: string, state: unknown) =>
-      Ref.update(store, (map) => HashMap.set(map, documentId, state)),
-
-    delete: (documentId: string) =>
-      Ref.update(store, (map) => HashMap.remove(map, documentId)),
-
-    onLoad: (state: unknown) => Effect.succeed(state),
-
-    onSave: (state: unknown) => Effect.succeed(state),
-  };
-
-  return storage;
-});
-
-// =============================================================================
-// Layer
-// =============================================================================
-
-/**
- * Layer that provides in-memory data storage.
- * This is the default storage implementation - ephemeral and non-persistent.
- */
-export const layer: Layer.Layer<MimicDataStorageTag> = Layer.effect(
-  MimicDataStorageTag,
-  makeInMemoryStorage
-);
-
-/**
- * Default layer alias for convenience.
- */
-export const layerDefault = layer;

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