@uploadista/event-broadcaster-redis 0.0.13-beta.4 → 0.0.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/event-broadcaster-redis",
   "type": "module",
-  "version": "0.0.13-beta.4",
+  "version": "0.0.13",
   "description": "Redis event broadcaster for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -14,19 +14,27 @@
     }
   },
   "dependencies": {
-    "@redis/client": "5.9.0",
-    "effect": "3.19.2",
-    "@uploadista/core": "0.0.13-beta.4"
+    "effect": "3.19.3",
+    "@uploadista/core": "0.0.13"
+  },
+  "peerDependencies": {
+    "@redis/client": ">=5.8.0 <6.0.0"
   },
   "devDependencies": {
-    "@types/node": "24.10.0",
-    "tsdown": "0.16.0",
-    "@uploadista/typescript-config": "0.0.13-beta.4"
+    "@effect/vitest": "0.27.0",
+    "@redis/client": "5.9.0",
+    "@types/node": "24.10.1",
+    "tsdown": "0.16.3",
+    "vitest": "4.0.8",
+    "@uploadista/typescript-config": "0.0.13"
   },
   "scripts": {
     "build": "tsdown",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
-    "check": "biome check --write ./src"
+    "check": "biome check --write ./src",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:watch": "vitest watch"
   }
 }

package/tests/redis-event-broadcaster.test.ts

@@ -0,0 +1,322 @@
+import { Effect } from "effect";
+import { describe, expect, it, vi } from "vitest";
+import { createRedisEventBroadcaster } from "../src/redis-event-broadcaster";
+import {
+  createMockRedisClient,
+  mockRedisClientAsType,
+} from "./utils/mock-redis";
+
+describe("Redis Event Broadcaster", () => {
+  describe("Basic Operations", () => {
+    it("should call redis.publish with correct channel and message", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* broadcaster.publish("test-channel", "test-message");
+
+          expect(mockRedis.publish).toHaveBeenCalledWith(
+            "test-channel",
+            "test-message",
+          );
+          expect(mockRedis.publish).toHaveBeenCalledTimes(1);
+        }),
+      );
+    });
+
+    it("should return void on successful publish", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* broadcaster.publish("channel", "message");
+          expect(result).toBeUndefined();
+        }),
+      );
+    });
+
+    it("should call subscriberRedis.subscribe with correct parameters", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = vi.fn();
+          yield* broadcaster.subscribe("my-channel", handler);
+
+          expect(mockSubscriber.subscribe).toHaveBeenCalledTimes(1);
+          expect(mockSubscriber.subscribe).toHaveBeenCalledWith(
+            "my-channel",
+            expect.any(Function),
+          );
+        }),
+      );
+    });
+
+    it("should invoke handler when message arrives", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = vi.fn();
+          yield* broadcaster.subscribe("events", handler);
+
+          // Simulate Redis message
+          mockSubscriber.triggerMessage("events", "incoming-message");
+
+          expect(handler).toHaveBeenCalledWith("incoming-message");
+          expect(handler).toHaveBeenCalledTimes(1);
+        }),
+      );
+    });
+
+    it("should call subscriberRedis.unsubscribe", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* broadcaster.unsubscribe!("channel-1");
+
+          expect(mockSubscriber.unsubscribe).toHaveBeenCalledWith("channel-1");
+          expect(mockSubscriber.unsubscribe).toHaveBeenCalledTimes(1);
+        }),
+      );
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should return UploadistaError when publish fails", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      mockRedis.publish.mockRejectedValueOnce(new Error("Connection failed"));
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(
+            broadcaster.publish("channel", "message"),
+          );
+
+          expect(result._tag).toBe("Left");
+          if (result._tag === "Left") {
+            expect(result.left.code).toBe("UNKNOWN_ERROR");
+          }
+        }),
+      );
+    });
+
+    it("should return UploadistaError when subscribe fails", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      mockSubscriber.subscribe.mockRejectedValueOnce(
+        new Error("Subscribe failed"),
+      );
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(
+            broadcaster.subscribe("channel", vi.fn()),
+          );
+
+          expect(result._tag).toBe("Left");
+          if (result._tag === "Left") {
+            expect(result.left.code).toBe("UNKNOWN_ERROR");
+          }
+        }),
+      );
+    });
+
+    it("should return UploadistaError when unsubscribe fails", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      mockSubscriber.unsubscribe.mockRejectedValueOnce(
+        new Error("Unsubscribe failed"),
+      );
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(broadcaster.unsubscribe!("channel"));
+
+          expect(result._tag).toBe("Left");
+          if (result._tag === "Left") {
+            expect(result.left.code).toBe("UNKNOWN_ERROR");
+          }
+        }),
+      );
+    });
+
+    it("should register error handler for redis client", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      expect(mockRedis.on).toHaveBeenCalledWith("error", expect.any(Function));
+
+      // Trigger error
+      mockRedis.triggerError(new Error("Redis error"));
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "[Redis] Error:",
+        expect.any(Error),
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it("should register error handler for subscriber client", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+      const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      expect(mockSubscriber.on).toHaveBeenCalledWith(
+        "error",
+        expect.any(Function),
+      );
+
+      // Trigger error
+      mockSubscriber.triggerError(new Error("Subscriber error"));
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "[Redis] Subscriber Error:",
+        expect.any(Error),
+      );
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe("Redis-Specific Behavior", () => {
+    it("should use separate redis and subscriberRedis clients", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* broadcaster.publish("channel", "message");
+          yield* broadcaster.subscribe("channel", vi.fn());
+
+          // Publish uses redis client
+          expect(mockRedis.publish).toHaveBeenCalledTimes(1);
+          expect(mockSubscriber.publish).not.toHaveBeenCalled();
+
+          // Subscribe uses subscriberRedis client
+          expect(mockSubscriber.subscribe).toHaveBeenCalledTimes(1);
+          expect(mockRedis.subscribe).not.toHaveBeenCalled();
+        }),
+      );
+    });
+
+    it("should support multiple subscribe calls with different handlers", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler1 = vi.fn();
+          const handler2 = vi.fn();
+
+          yield* broadcaster.subscribe("channel-1", handler1);
+          yield* broadcaster.subscribe("channel-2", handler2);
+
+          expect(mockSubscriber.subscribe).toHaveBeenCalledTimes(2);
+          expect(mockSubscriber.subscribe).toHaveBeenNthCalledWith(
+            1,
+            "channel-1",
+            expect.any(Function),
+          );
+          expect(mockSubscriber.subscribe).toHaveBeenNthCalledWith(
+            2,
+            "channel-2",
+            expect.any(Function),
+          );
+        }),
+      );
+    });
+
+    it("should pass correct channel and message to callback", async () => {
+      const mockRedis = createMockRedisClient();
+      const mockSubscriber = createMockRedisClient();
+
+      const broadcaster = createRedisEventBroadcaster({
+        redis: mockRedisClientAsType(mockRedis),
+        subscriberRedis: mockRedisClientAsType(mockSubscriber),
+      });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const handler = vi.fn();
+          yield* broadcaster.subscribe("test-channel", handler);
+
+          // Simulate Redis delivering message with channel info
+          mockSubscriber.triggerMessage("test-channel", "test-payload");
+
+          expect(handler).toHaveBeenCalledWith("test-payload");
+        }),
+      );
+    });
+  });
+});

package/tests/utils/mock-redis.ts

@@ -0,0 +1,58 @@
+import type { RedisClientType } from "@redis/client";
+import { vi } from "vitest";
+
+type MessageCallback = (message: string, channel: string) => void;
+
+export interface MockRedisClient {
+  publish: ReturnType<typeof vi.fn>;
+  subscribe: ReturnType<typeof vi.fn>;
+  unsubscribe: ReturnType<typeof vi.fn>;
+  on: ReturnType<typeof vi.fn>;
+  triggerMessage: (channel: string, message: string) => void;
+  triggerError: (error: Error) => void;
+}
+
+export function createMockRedisClient(): MockRedisClient {
+  const subscribers = new Map<string, Set<MessageCallback>>();
+  let errorHandler: ((error: Error) => void) | null = null;
+
+  return {
+    publish: vi.fn().mockResolvedValue(1),
+
+    subscribe: vi.fn().mockImplementation(
+      async (channel: string, callback: MessageCallback) => {
+        if (!subscribers.has(channel)) {
+          subscribers.set(channel, new Set());
+        }
+        subscribers.get(channel)?.add(callback);
+      },
+    ),
+
+    unsubscribe: vi.fn().mockResolvedValue(undefined),
+
+    on: vi.fn().mockImplementation((event: string, handler: (error: Error) => void) => {
+      if (event === "error") {
+        errorHandler = handler;
+      }
+    }),
+
+    triggerMessage: (channel: string, message: string) => {
+      const channelSubs = subscribers.get(channel);
+      if (channelSubs) {
+        for (const callback of channelSubs) {
+          callback(message, channel);
+        }
+      }
+    },
+
+    triggerError: (error: Error) => {
+      if (errorHandler) {
+        errorHandler(error);
+      }
+    },
+  };
+}
+
+export function mockRedisClientAsType(mock: MockRedisClient): RedisClientType {
+  return mock as unknown as RedisClientType;
+}

package/vitest.config.ts

@@ -0,0 +1,39 @@
+import { defineConfig } from "vitest/config";
+
+/**
+ * Shared vitest configuration template for uploadista-sdk packages
+ *
+ * This template should be used by all SDK packages to ensure consistent
+ * testing configuration across the monorepo.
+ *
+ * Key features:
+ * - Tests in dedicated `tests/` directories (not colocated with src)
+ * - Node environment for server-side code
+ * - V8 coverage provider
+ * - Global test functions available
+ * - Effect testing support via @effect/vitest
+ *
+ * Usage:
+ * Copy this file to your package root as `vitest.config.ts` and customize
+ * if needed (though most packages should use this as-is).
+ */
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    exclude: ["node_modules", "dist"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: [
+        "node_modules/",
+        "dist/",
+        "**/*.d.ts",
+        "**/*.test.ts",
+        "**/*.spec.ts",
+        "tests/",
+      ],
+    },
+  },
+});