@voidhash/mimic-effect 0.0.4 → 0.0.5

package/src/MimicServer.ts

@@ -27,7 +27,9 @@ import { PathInput } from "@effect/platform/HttpRouter";
 /**
  * Options for creating a Mimic server layer.
  */
-export interface MimicLayerOptions<TSchema extends Primitive.AnyPrimitive> {
+export interface MimicLayerOptions<
+  TSchema extends Primitive.AnyPrimitive,
+> {
   /**
    * Base path for document routes (used for path matching).
    * @example "/mimic/todo" - documents accessed at "/mimic/todo/:documentId"
@@ -49,14 +51,19 @@ export interface MimicLayerOptions<TSchema extends Primitive.AnyPrimitive> {
   readonly presence?: Presence.AnyPresence;
   /**
    * Initial state for new documents.
-   * Used when a document is created and no existing state is found in storage.
+   * Can be either:
+   * - A plain object with the initial state values
+   * - A function that receives context (with documentId) and returns an Effect producing the initial state
+   *
+   * When using a function that requires Effect services (has R requirements),
+   * you must also provide `initialLayer` to supply those dependencies.
    *
    * Type-safe: required fields (without defaults) must be provided,
    * while optional fields and fields with defaults can be omitted.
    *
    * @default undefined (documents start empty or use schema defaults)
    */
-  readonly initial?: Primitive.InferSetInput<TSchema>;
+  readonly initial?: Primitive.InferSetInput<TSchema> | MimicConfig.InitialFn<TSchema>;
 }
 
 
@@ -124,6 +131,17 @@ const makeMimicHandler = Effect.gen(function* () {
 
 
 
+/**
+ * Options for layerHttpLayerRouter including optional custom layers.
+ */
+export interface MimicLayerRouterOptions<TSchema extends Primitive.AnyPrimitive>
+  extends MimicLayerOptions<TSchema> {
+  /** Custom auth layer. Defaults to NoAuth (all connections allowed). */
+  readonly authLayer?: Layer.Layer<MimicAuthServiceTag>;
+  /** Custom storage layer. Defaults to InMemoryDataStorage. */
+  readonly storageLayer?: Layer.Layer<MimicDataStorageTag>;
+}
+
 /**
  * Create a Mimic server layer that integrates with HttpLayerRouter.
  *
@@ -170,44 +188,52 @@ const makeMimicHandler = Effect.gen(function* () {
  * );
  * ```
  */
-export const layerHttpLayerRouter = <TSchema extends Primitive.AnyPrimitive>(
-  options: MimicLayerOptions<TSchema> & {
-    /** Custom auth layer. Defaults to NoAuth (all connections allowed). */
-    readonly authLayer?: Layer.Layer<MimicAuthServiceTag>;
-    /** Custom storage layer. Defaults to InMemoryDataStorage. */
-    readonly storageLayer?: Layer.Layer<MimicDataStorageTag>;
-  }
-) => {
-  // Build the base path pattern for WebSocket routes
-  // Append /doc/* to match /basePath/doc/{documentId}
-  const basePath = options.basePath ?? "/mimic";
-  const wsPath: PathInput = `${basePath}/doc/*` as PathInput;
-
-  // Create the config layer
-  const configLayer = MimicConfig.layer({
-    schema: options.schema,
-    maxTransactionHistory: options.maxTransactionHistory,
-    presence: options.presence,
-    initial: options.initial,
-  });
-
-  // Use provided layers or defaults
-  const authLayer = options.authLayer ?? NoAuth.layerDefault;
-  const storageLayer = options.storageLayer ?? InMemoryDataStorage.layerDefault;
-
-  // Create the route registration effect
-  const registerRoute = Effect.gen(function* () {
-    const router = yield* HttpLayerRouter.HttpRouter;
-    const handler = yield* makeMimicHandler;
-    yield* router.add("GET", wsPath, handler);
-  });
-
-  // Build the layer with all dependencies
-  return Layer.scopedDiscard(registerRoute).pipe(
-    Layer.provide(DocumentManager.layer),
-    Layer.provide(PresenceManager.layer),
-    Layer.provide(configLayer),
-    Layer.provide(storageLayer),
-    Layer.provide(authLayer)
+export const layerHttpLayerRouter = <
+  TSchema extends Primitive.AnyPrimitive,
+  TError,
+  TRequirements
+>(
+  optionsEf: Effect.Effect<MimicLayerRouterOptions<TSchema>, TError, TRequirements>
+): Layer.Layer<never, TError, TRequirements | HttpLayerRouter.HttpRouter> => {
+  return Layer.unwrapScoped(
+    Effect.gen(function* () {
+      const options = yield* optionsEf;
+
+      // Build the base path pattern for WebSocket routes
+      // Append /doc/* to match /basePath/doc/{documentId}
+      const basePath = options.basePath ?? "/mimic";
+      const wsPath: PathInput = `${basePath}/doc/*` as PathInput;
+
+      // Create the config layer with properly typed initial function
+      const configLayer = MimicConfig.layer<TSchema>({
+        schema: options.schema,
+        maxTransactionHistory: options.maxTransactionHistory,
+        presence: options.presence,
+        initial: options.initial,
+      });
+
+      // Use provided layers or defaults
+      const authLayer = options.authLayer ?? NoAuth.layerDefault;
+      const storageLayer = options.storageLayer ?? InMemoryDataStorage.layerDefault;
+
+      // Combine all dependency layers
+      const depsLayer = Layer.mergeAll(configLayer, authLayer, storageLayer);
+
+      // Create the route registration layer
+      const routeLayer = Layer.scopedDiscard(
+        Effect.gen(function* () {
+          const router = yield* HttpLayerRouter.HttpRouter;
+          const handler = yield* makeMimicHandler;
+          yield* router.add("GET", wsPath, handler);
+        })
+      );
+
+      // Build the complete layer with all dependencies provided
+      return routeLayer.pipe(
+        Layer.provide(DocumentManager.layer),
+        Layer.provide(PresenceManager.layer),
+        Layer.provide(depsLayer),
+      );
+    })
   );
 };

package/tests/DocumentManager.test.ts

@@ -352,6 +352,21 @@ describe("DocumentManager", () => {
       );
     };
 
+    const makeTestLayerWithInitialFn = (
+      initialFn: (ctx: { documentId: string }) => Effect.Effect<{ title?: string; count?: number }>
+    ) => {
+      const configLayer = MimicConfig.layer({
+        schema: TestSchema,
+        maxTransactionHistory: 100,
+        initial: initialFn,
+      });
+
+      return DocumentManager.layer.pipe(
+        Layer.provide(configLayer),
+        Layer.provide(InMemoryDataStorage.layer)
+      );
+    };
+
     it("should use initial state for new documents", async () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
@@ -397,5 +412,53 @@ describe("DocumentManager", () => {
       // count should still be 42 since we only modified title
       expect((result.state as any).count).toBe(42);
     });
+
+    it("should use initial state function with documentId for new documents", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          return yield* manager.getSnapshot("my-special-doc");
+        }).pipe(Effect.provide(makeTestLayerWithInitialFn(
+          ({ documentId }) => Effect.succeed({ title: `Doc: ${documentId}`, count: documentId.length })
+        )))
+      );
+
+      expect(result.type).toBe("snapshot");
+      expect(result.version).toBe(0);
+      expect(result.state).toEqual({ title: "Doc: my-special-doc", count: 14 });
+    });
+
+    it("should call initial function with different documentIds", async () => {
+      const layer = makeTestLayerWithInitialFn(
+        ({ documentId }) => Effect.succeed({ title: documentId, count: documentId.length })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          const snap1 = yield* manager.getSnapshot("short");
+          const snap2 = yield* manager.getSnapshot("longer-document-id");
+          return { snap1, snap2 };
+        }).pipe(Effect.provide(layer))
+      );
+
+      expect(result.snap1.state).toEqual({ title: "short", count: 5 });
+      expect(result.snap2.state).toEqual({ title: "longer-document-id", count: 18 });
+    });
+
+    it("should apply defaults to initial function result", async () => {
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const manager = yield* DocumentManager.DocumentManagerTag;
+          return yield* manager.getSnapshot("test-doc");
+        }).pipe(Effect.provide(makeTestLayerWithInitialFn(
+          ({ documentId }) => Effect.succeed({ title: documentId }) // count omitted
+        )))
+      );
+
+      expect(result.type).toBe("snapshot");
+      // count should be 0 (default)
+      expect(result.state).toEqual({ title: "test-doc", count: 0 });
+    });
   });
 });

package/tests/MimicConfig.test.ts

@@ -182,25 +182,50 @@ describe("MimicConfig", () => {
       expect(config.initial).toBeUndefined();
     });
 
-    it("should accept initial state option", () => {
+    it("should accept initial state object and convert to function", async () => {
       const config = MimicConfig.make({
         schema: TestSchema,
         initial: { title: "My Document", count: 42 },
       });
 
-      expect(config.initial).toEqual({ 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", () => {
+    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
       });
 
-      expect(config.initial).toEqual({ title: "My Document", count: 0 });
+      const result = await Effect.runPromise(config.initial!({ documentId: "test-doc" }));
+      expect(result).toEqual({ title: "My Document", count: 0 });
     });
 
-    it("should provide initial state through layer", async () => {
+    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 },
@@ -209,14 +234,14 @@ describe("MimicConfig", () => {
       const result = await Effect.runPromise(
         Effect.gen(function* () {
           const config = yield* MimicConfig.MimicServerConfigTag;
-          return config.initial;
+          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", () => {
+    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"),
@@ -227,10 +252,11 @@ describe("MimicConfig", () => {
         initial: { name: "Required Name" },
       });
 
-      expect(config.initial).toEqual({ name: "Required Name", optional: "default" });
+      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", () => {
+    it("should work with all options including initial object", async () => {
       const config = MimicConfig.make({
         schema: TestSchema,
         maxIdleTime: "10 minutes",
@@ -241,7 +267,24 @@ describe("MimicConfig", () => {
       expect(config.schema).toBe(TestSchema);
       expect(Duration.toMillis(config.maxIdleTime)).toBe(10 * 60 * 1000);
       expect(config.maxTransactionHistory).toBe(500);
-      expect(config.initial).toEqual({ title: "Full Options", count: 999 });
+      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 });
     });
   });
 });