@voidhash/mimic-effect 0.0.1-alpha.1

package/src/auth/NoAuth.ts

@@ -0,0 +1,46 @@
+/**
+ * @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

@@ -0,0 +1,113 @@
+/**
+ * @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;
+}> {
+  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;
+}> {
+  get message(): string {
+    return `Document not found: ${this.documentId}`;
+  }
+}
+
+/**
+ * Error when authentication fails.
+ */
+export class AuthenticationError extends Data.TaggedError(
+  "AuthenticationError"
+)<{
+  readonly reason: string;
+}> {
+  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;
+}> {
+  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;
+}> {
+  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;
+}> {
+  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;
+}> {
+  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/index.ts

@@ -0,0 +1,48 @@
+/**
+ * @voidhash/mimic-server-effect
+ *
+ * Effect-based server implementation for Mimic sync engine.
+ *
+ * @since 0.0.1
+ */
+
+// =============================================================================
+// Main Server
+// =============================================================================
+
+export * as MimicServer from "./MimicServer.js";
+
+// =============================================================================
+// Service Interfaces
+// =============================================================================
+
+export * as MimicDataStorage from "./MimicDataStorage.js";
+export * as MimicAuthService from "./MimicAuthService.js";
+
+// =============================================================================
+// Default Implementations
+// =============================================================================
+
+export * as MimicInMemoryDataStorage from "./storage/InMemoryDataStorage.js";
+export * as MimicNoAuth from "./auth/NoAuth.js";
+
+// =============================================================================
+// Configuration
+// =============================================================================
+
+export * as MimicConfig from "./MimicConfig.js";
+
+// =============================================================================
+// Internal Components (for advanced usage)
+// =============================================================================
+
+export * as DocumentManager from "./DocumentManager.js";
+export * as PresenceManager from "./PresenceManager.js";
+export * as WebSocketHandler from "./WebSocketHandler.js";
+export * as DocumentProtocol from "./DocumentProtocol.js";
+
+// =============================================================================
+// Errors
+// =============================================================================
+
+export * from "./errors.js";

package/src/storage/InMemoryDataStorage.ts

@@ -0,0 +1,66 @@
+/**
+ * @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/DocumentManager.test.ts

@@ -0,0 +1,340 @@
+import { describe, it, expect } from "vitest";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Layer from "effect/Layer";
+import * as Fiber from "effect/Fiber";
+import { Primitive, OperationPath, Document, Transaction } from "@voidhash/mimic";
+import * as DocumentManager from "../src/DocumentManager";
+import * as MimicConfig from "../src/MimicConfig";
+import * as InMemoryDataStorage from "../src/storage/InMemoryDataStorage";
+
+// =============================================================================
+// Test Schema
+// =============================================================================
+
+const TestSchema = Primitive.Struct({
+  title: Primitive.String().default(""),
+  count: Primitive.Number().default(0),
+});
+
+// =============================================================================
+// Test Layer
+// =============================================================================
+
+const makeTestLayer = () => {
+  const configLayer = MimicConfig.layer({
+    schema: TestSchema,
+    maxTransactionHistory: 100,
+  });
+
+  return DocumentManager.layer.pipe(
+    Layer.provide(configLayer),
+    Layer.provide(InMemoryDataStorage.layer)
+  );
+};
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+/**
+ * Create a valid operation using the Document API
+ */
+const createValidTransaction = (id: string, title: string): Transaction.Transaction => {
+  const doc = Document.make(TestSchema);
+  doc.transaction((root) => {
+    root.title.set(title);
+  });
+  const tx = doc.flush();
+  // Override the ID to make it deterministic for tests
+  return {
+    ...tx,
+    id,
+  };
+};
+
+const createEmptyTransaction = (id: string): Transaction.Transaction => ({
+  id,
+  ops: [],
+  timestamp: Date.now(),
+});
+
+// =============================================================================
+// DocumentManager Tests
+// =============================================================================
+
+describe("DocumentManager", () => {
+  describe("submit", () => {
+    it("should accept valid transactions", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          const tx = createValidTransaction("tx-1", "Hello World");
+          return yield* manager.submit("doc-1", tx);
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.version).toBe(1);
+      }
+    });
+
+    it("should reject empty transactions", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          const tx = createEmptyTransaction("tx-empty");
+          return yield* manager.submit("doc-1", tx);
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.reason).toBe("Transaction is empty");
+      }
+    });
+
+    it("should reject duplicate transactions", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          const tx = createValidTransaction("tx-dup", "First");
+
+          // Submit first time
+          const first = yield* manager.submit("doc-1", tx);
+
+          // Submit same transaction again
+          const second = yield* manager.submit("doc-1", tx);
+
+          return { first, second };
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.first.success).toBe(true);
+      expect(result.second.success).toBe(false);
+      if (!result.second.success) {
+        expect(result.second.reason).toBe(
+          "Transaction has already been processed"
+        );
+      }
+    });
+
+    it("should increment version with each successful transaction", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          const tx1 = createValidTransaction("tx-1", "One");
+          const tx2 = createValidTransaction("tx-2", "Two");
+          const tx3 = createValidTransaction("tx-3", "Three");
+
+          const r1 = yield* manager.submit("doc-1", tx1);
+          const r2 = yield* manager.submit("doc-1", tx2);
+          const r3 = yield* manager.submit("doc-1", tx3);
+
+          return { r1, r2, r3 };
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.r1.success).toBe(true);
+      expect(result.r2.success).toBe(true);
+      expect(result.r3.success).toBe(true);
+
+      if (result.r1.success && result.r2.success && result.r3.success) {
+        expect(result.r1.version).toBe(1);
+        expect(result.r2.version).toBe(2);
+        expect(result.r3.version).toBe(3);
+      }
+    });
+
+    it("should handle different documents independently", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          const txDoc1 = createValidTransaction("tx-doc1", "Doc 1");
+          const txDoc2 = createValidTransaction("tx-doc2", "Doc 2");
+
+          const r1 = yield* manager.submit("doc-1", txDoc1);
+          const r2 = yield* manager.submit("doc-2", txDoc2);
+
+          return { r1, r2 };
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.r1.success).toBe(true);
+      expect(result.r2.success).toBe(true);
+
+      // Both should have version 1 since they are independent documents
+      if (result.r1.success && result.r2.success) {
+        expect(result.r1.version).toBe(1);
+        expect(result.r2.version).toBe(1);
+      }
+    });
+  });
+
+  describe("getSnapshot", () => {
+    it("should return initial snapshot for new document", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          return yield* manager.getSnapshot("new-doc");
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.type).toBe("snapshot");
+      expect(result.version).toBe(0);
+      // Initial state from schema defaults
+      expect(result.state).toEqual({ title: "", count: 0 });
+    });
+
+    it("should return current state after transactions", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          // Apply a transaction
+          const tx = createValidTransaction("tx-1", "Updated Title");
+          yield* manager.submit("doc-1", tx);
+
+          return yield* manager.getSnapshot("doc-1");
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.type).toBe("snapshot");
+      expect(result.version).toBe(1);
+      expect((result.state as any).title).toBe("Updated Title");
+    });
+
+    it("should return snapshot for specific document", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          // Apply transactions to different documents
+          const tx1 = createValidTransaction("tx-1", "Doc One");
+          const tx2 = createValidTransaction("tx-2", "Doc Two");
+
+          yield* manager.submit("doc-1", tx1);
+          yield* manager.submit("doc-2", tx2);
+
+          const snap1 = yield* manager.getSnapshot("doc-1");
+          const snap2 = yield* manager.getSnapshot("doc-2");
+
+          return { snap1, snap2 };
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect((result.snap1.state as any).title).toBe("Doc One");
+      expect((result.snap2.state as any).title).toBe("Doc Two");
+    });
+  });
+
+  describe("subscribe", () => {
+    it("should receive broadcasts for submitted transactions", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          // Subscribe to the document
+          const broadcastStream = yield* manager.subscribe("doc-1");
+
+          // Submit a transaction
+          const tx = createValidTransaction("tx-broadcast", "Broadcast Test");
+
+          // Start collecting broadcasts in parallel
+          const collectFiber = yield* Effect.fork(
+            broadcastStream.pipe(Stream.take(1), Stream.runCollect)
+          );
+
+          // Small delay to ensure subscription is ready
+          yield* Effect.sleep(50);
+
+          // Submit the transaction
+          yield* manager.submit("doc-1", tx);
+
+          // Wait for the broadcast with Fiber.join
+          const broadcasts = yield* Fiber.join(collectFiber).pipe(
+            Effect.timeout(2000)
+          );
+
+          return broadcasts;
+        }).pipe(Effect.scoped, Effect.provide(makeTestLayer()))
+      );
+
+      expect(result).toBeDefined();
+      if (result) {
+        const broadcasts = Array.from(result);
+        expect(broadcasts.length).toBe(1);
+        expect(broadcasts[0].type).toBe("transaction");
+      }
+    });
+
+    it("should broadcast to multiple subscribers", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+
+          // Subscribe twice to the same document
+          const stream1 = yield* manager.subscribe("doc-1");
+          const stream2 = yield* manager.subscribe("doc-1");
+
+          // Start collecting broadcasts in parallel
+          const collectFiber1 = yield* Effect.fork(
+            stream1.pipe(Stream.take(1), Stream.runCollect)
+          );
+          const collectFiber2 = yield* Effect.fork(
+            stream2.pipe(Stream.take(1), Stream.runCollect)
+          );
+
+          // Small delay to ensure subscriptions are ready
+          yield* Effect.sleep(50);
+
+          // Submit a transaction
+          const tx = createValidTransaction("tx-multi", "Multi Broadcast");
+          yield* manager.submit("doc-1", tx);
+
+          // Wait for both broadcasts with Fiber.join
+          const broadcasts1 = yield* Fiber.join(collectFiber1).pipe(
+            Effect.timeout(2000)
+          );
+          const broadcasts2 = yield* Fiber.join(collectFiber2).pipe(
+            Effect.timeout(2000)
+          );
+
+          return { broadcasts1, broadcasts2 };
+        }).pipe(Effect.scoped, Effect.provide(makeTestLayer()))
+      );
+
+      expect(result.broadcasts1).toBeDefined();
+      expect(result.broadcasts2).toBeDefined();
+      if (result.broadcasts1 && result.broadcasts2) {
+        expect(Array.from(result.broadcasts1).length).toBe(1);
+        expect(Array.from(result.broadcasts2).length).toBe(1);
+      }
+    });
+  });
+
+  describe("DocumentManagerTag", () => {
+    it("should have the correct tag identifier", () => {
+      expect(DocumentManager.DocumentManagerTag.key).toBe(
+        "@voidhash/mimic-server-effect/DocumentManager"
+      );
+    });
+  });
+
+  describe("layer", () => {
+    it("should require MimicServerConfigTag and MimicDataStorageTag", async () => {
+      // This test verifies the layer composition works correctly
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          return typeof manager.submit === "function";
+        }).pipe(Effect.provide(makeTestLayer()))
+      );
+
+      expect(result).toBe(true);
+    });
+  });
+});