@uploadista/kv-store-redis 0.0.13-beta.4 → 0.0.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/kv-store-redis",
   "type": "module",
-  "version": "0.0.13-beta.4",
+  "version": "0.0.13",
   "description": "Redis KV store for Uploadista",
   "license": "MIT",
   "author": "Uploadista",
@@ -14,18 +14,26 @@
     }
   },
   "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": {
-    "tsdown": "0.16.0",
-    "@uploadista/typescript-config": "0.0.13-beta.4"
+    "@effect/vitest": "0.27.0",
+    "@redis/client": "5.9.0",
+    "tsdown": "0.16.3",
+    "vitest": "4.0.8",
+    "@uploadista/typescript-config": "0.0.13"
   },
   "scripts": {
     "build": "tsdown",
+    "check": "biome check --write ./src",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
-    "check": "biome check --write ./src"
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:watch": "vitest --watch"
   }
 }

package/tests/redis-kv-store.test.ts

@@ -0,0 +1,369 @@
+import type { RedisClientType } from "@redis/client";
+import { Effect } from "effect";
+import { describe, expect, it, vi } from "vitest";
+import { makeRedisBaseKvStore } from "../src/redis-kv-store";
+
+describe("Redis KV Store", () => {
+  describe("Basic Operations", () => {
+    it("should store and retrieve values", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue("value1"),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn().mockResolvedValue(1),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* store.set("key1", "value1");
+          const value = yield* store.get("key1");
+          expect(value).toBe("value1");
+          expect(mockRedis.set).toHaveBeenCalledWith("key1", "value1");
+          expect(mockRedis.get).toHaveBeenCalledWith("key1");
+        }),
+      );
+    });
+
+    it("should return null for non-existent keys", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue(null),
+        set: vi.fn(),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const value = yield* store.get("non-existent");
+          expect(value).toBeNull();
+          expect(mockRedis.get).toHaveBeenCalledWith("non-existent");
+        }),
+      );
+    });
+
+    it("should delete values", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue("value1"),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn().mockResolvedValue(1),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* store.set("key1", "value1");
+          yield* store.delete("key1");
+          expect(mockRedis.del).toHaveBeenCalledWith("key1");
+        }),
+      );
+    });
+  });
+
+  describe("List Operations", () => {
+    it("should list all keys with prefix", async () => {
+      const mockRedis = {
+        get: vi.fn(),
+        set: vi.fn(),
+        del: vi.fn(),
+        scan: vi
+          .fn()
+          .mockResolvedValueOnce({
+            cursor: "5",
+            keys: ["user:1", "user:2"],
+          })
+          .mockResolvedValueOnce({
+            cursor: "0",
+            keys: ["user:3"],
+          }),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const keys = yield* store.list!("user:");
+          expect(keys).toHaveLength(3);
+          expect(keys).toContain("1");
+          expect(keys).toContain("2");
+          expect(keys).toContain("3");
+          expect(mockRedis.scan).toHaveBeenCalledWith("0", {
+            MATCH: "user:*",
+            COUNT: 20,
+          });
+        }),
+      );
+    });
+
+    it("should handle empty list results", async () => {
+      const mockRedis = {
+        get: vi.fn(),
+        set: vi.fn(),
+        del: vi.fn(),
+        scan: vi.fn().mockResolvedValue({
+          cursor: "0",
+          keys: [],
+        }),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const keys = yield* store.list!("nonexistent:");
+          expect(keys).toHaveLength(0);
+        }),
+      );
+    });
+
+    it("should handle paginated scan results", async () => {
+      const mockRedis = {
+        get: vi.fn(),
+        set: vi.fn(),
+        del: vi.fn(),
+        scan: vi
+          .fn()
+          .mockResolvedValueOnce({
+            cursor: "10",
+            keys: ["prefix:a", "prefix:b"],
+          })
+          .mockResolvedValueOnce({
+            cursor: "20",
+            keys: ["prefix:c", "prefix:d"],
+          })
+          .mockResolvedValueOnce({
+            cursor: "0",
+            keys: ["prefix:e"],
+          }),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const keys = yield* store.list!("prefix:");
+          expect(keys).toHaveLength(5);
+          expect(mockRedis.scan).toHaveBeenCalledTimes(3);
+        }),
+      );
+    });
+  });
+
+  describe("Complex Data Types", () => {
+    it("should store and retrieve JSON strings", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue('{"name":"John","age":30}'),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const obj = { name: "John", age: 30 };
+          yield* store.set("user1", JSON.stringify(obj));
+          const retrieved = yield* store.get("user1");
+          expect(JSON.parse(retrieved!)).toEqual(obj);
+        }),
+      );
+    });
+
+    it("should handle empty strings", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue(""),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* store.set("key1", "");
+          const value = yield* store.get("key1");
+          expect(value).toBe("");
+        }),
+      );
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle get errors", async () => {
+      const mockRedis = {
+        get: vi.fn().mockRejectedValue(new Error("Connection failed")),
+        set: vi.fn(),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(store.get("key1"));
+          expect(result._tag).toBe("Left");
+        }),
+      );
+    });
+
+    it("should handle set errors", async () => {
+      const mockRedis = {
+        get: vi.fn(),
+        set: vi.fn().mockRejectedValue(new Error("Write failed")),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(store.set("key1", "value1"));
+          expect(result._tag).toBe("Left");
+        }),
+      );
+    });
+
+    it("should handle delete errors", async () => {
+      const mockRedis = {
+        get: vi.fn(),
+        set: vi.fn(),
+        del: vi.fn().mockRejectedValue(new Error("Delete failed")),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(store.delete("key1"));
+          expect(result._tag).toBe("Left");
+        }),
+      );
+    });
+
+    it("should handle scan errors", async () => {
+      const mockRedis = {
+        get: vi.fn(),
+        set: vi.fn(),
+        del: vi.fn(),
+        scan: vi.fn().mockRejectedValue(new Error("Scan failed")),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const result = yield* Effect.either(store.list!("prefix:"));
+          expect(result._tag).toBe("Left");
+        }),
+      );
+    });
+  });
+
+  describe("Update Operations", () => {
+    it("should update existing values", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue("value2"),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* store.set("key1", "value1");
+          yield* store.set("key1", "value2");
+          const value = yield* store.get("key1");
+          expect(value).toBe("value2");
+          expect(mockRedis.set).toHaveBeenCalledTimes(2);
+        }),
+      );
+    });
+  });
+
+  describe("Isolation", () => {
+    it("should maintain separate store instances", async () => {
+      const mockRedis1 = {
+        get: vi.fn().mockResolvedValue("store1-value"),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const mockRedis2 = {
+        get: vi.fn().mockResolvedValue("store2-value"),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store1 = makeRedisBaseKvStore({ redis: mockRedis1 });
+      const store2 = makeRedisBaseKvStore({ redis: mockRedis2 });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* store1.set("key1", "store1-value");
+          yield* store2.set("key1", "store2-value");
+
+          const value1 = yield* store1.get("key1");
+          const value2 = yield* store2.get("key1");
+
+          expect(value1).toBe("store1-value");
+          expect(value2).toBe("store2-value");
+        }),
+      );
+    });
+  });
+
+  describe("Performance", () => {
+    it("should handle large values", async () => {
+      const largeValue = "x".repeat(10000);
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue(largeValue),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          yield* store.set("large", largeValue);
+          const value = yield* store.get("large");
+          expect(value?.length).toBe(10000);
+        }),
+      );
+    });
+
+    it("should handle special characters in keys", async () => {
+      const mockRedis = {
+        get: vi.fn().mockResolvedValue("value"),
+        set: vi.fn().mockResolvedValue("OK"),
+        del: vi.fn(),
+        scan: vi.fn(),
+      } as unknown as RedisClientType;
+
+      const store = makeRedisBaseKvStore({ redis: mockRedis });
+
+      await Effect.runPromise(
+        Effect.gen(function* () {
+          const specialKey = "user:123:profile:@email";
+          yield* store.set(specialKey, "value");
+          expect(mockRedis.set).toHaveBeenCalledWith(specialKey, "value");
+        }),
+      );
+    });
+  });
+});

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/",
+      ],
+    },
+  },
+});