Skip to content

A self-hostable bookmark-everything app (links, notes and images) with AI-based automatic tagging and full text search

feat: redis based ratelimiting plugin (#2535)

Mohamed Bassemb68ac513f651
diff --git a/apps/workers/workers/crawlerWorker.ts b/apps/workers/workers/crawlerWorker.ts
index df23196e..f6f2af83 100644
--- a/apps/workers/workers/crawlerWorker.ts
+++ b/apps/workers/workers/crawlerWorker.ts
@@ -2001,7 +2001,7 @@ async function checkDomainRateLimit(url: string, jobId: string): Promise<void> {
}
const hostname = new URL(url).hostname;
- const rateLimitResult = rateLimitClient.checkRateLimit(
+ const rateLimitResult = await rateLimitClient.checkRateLimit(
{
name: "domain-ratelimit",
maxRequests: crawlerDomainRateLimitConfig.maxRequests,
diff --git a/packages/plugins/package.json b/packages/plugins/package.json
index 06aafbfa..15a183a9 100644
--- a/packages/plugins/package.json
+++ b/packages/plugins/package.json
@@ -8,6 +8,7 @@
"./queue-liteque": "./queue-liteque/index.ts",
"./queue-restate": "./queue-restate/index.ts",
"./ratelimit-memory": "./ratelimit-memory/index.ts",
+ "./ratelimit-redis": "./ratelimit-redis/index.ts",
"./search-meilisearch": "./search-meilisearch/index.ts"
},
"scripts": {
@@ -23,6 +24,7 @@
"@restatedev/restate-sdk": "^1.10.3",
"@restatedev/restate-sdk-clients": "^1.10.3",
"async-mutex": "^0.4.1",
+ "ioredis": "^5.4.2",
"liteque": "^0.7.0",
"meilisearch": "^0.45.0"
},
diff --git a/packages/plugins/ratelimit-redis/index.ts b/packages/plugins/ratelimit-redis/index.ts
new file mode 100644
index 00000000..86a55c83
--- /dev/null
+++ b/packages/plugins/ratelimit-redis/index.ts
@@ -0,0 +1,19 @@
+// Auto-register the RateLimit plugin when this package is imported
+import serverConfig from "@karakeep/shared/config";
+import { PluginManager, PluginType } from "@karakeep/shared/plugins";
+
+import { RedisRateLimitProvider } from "./src";
+
+// Only register if Redis configuration is provided
+if (serverConfig.redis?.url) {
+ PluginManager.register({
+ type: PluginType.RateLimit,
+ name: "Redis Rate Limiter",
+ provider: new RedisRateLimitProvider({
+ url: serverConfig.redis.url,
+ }),
+ });
+}
+
+// Export the provider and rate limiter class for advanced usage
+export { RedisRateLimiter, RedisRateLimitProvider } from "./src";
diff --git a/packages/plugins/ratelimit-redis/src/index.ts b/packages/plugins/ratelimit-redis/src/index.ts
new file mode 100644
index 00000000..5a1bdd63
--- /dev/null
+++ b/packages/plugins/ratelimit-redis/src/index.ts
@@ -0,0 +1,200 @@
+import Redis from "ioredis";
+
+import type {
+ RateLimitClient,
+ RateLimitConfig,
+ RateLimitResult,
+} from "@karakeep/shared/ratelimiting";
+import { PluginProvider } from "@karakeep/shared/plugins";
+
+const KEY_PREFIX = "ratelimit:v1";
+
+export class RedisRateLimiter implements RateLimitClient {
+ private redis: Redis;
+
+ constructor(redis: Redis) {
+ this.redis = redis;
+ }
+
+ async checkRateLimit(
+ config: RateLimitConfig,
+ key: string,
+ ): Promise<RateLimitResult> {
+ if (!key) {
+ return { allowed: true };
+ }
+
+ const rateLimitKey = `${KEY_PREFIX}:${config.name}:${key}`;
+ const rateLimitSequenceKey = `${rateLimitKey}:seq`;
+ const now = Date.now();
+
+ try {
+ // Use a Lua script to ensure atomicity
+ // This script:
+ // 1. Removes old entries outside the time window
+ // 2. Counts current entries
+ // 3. Adds new entry if under limit
+ // 4. Sets expiration on the key
+ const luaScript = `
+ local key = KEYS[1]
+ local sequenceKey = KEYS[2]
+ local now = tonumber(ARGV[1])
+ local window = tonumber(ARGV[2])
+ local maxRequests = tonumber(ARGV[3])
+ local windowStart = now - window
+
+ -- Remove old entries
+ redis.call('ZREMRANGEBYSCORE', key, '-inf', windowStart)
+
+ -- Count current requests
+ local current = redis.call('ZCARD', key)
+
+ if current < maxRequests then
+ -- Add new request
+ local seq = redis.call('INCR', sequenceKey)
+ redis.call('ZADD', key, now, now .. ':' .. seq)
+ -- Set expiration (window in milliseconds converted to seconds, plus 1 for safety)
+ redis.call('EXPIRE', key, math.ceil(window / 1000) + 1)
+ redis.call('EXPIRE', sequenceKey, math.ceil(window / 1000) + 1)
+ return {1, 0} -- allowed, resetInSeconds
+ else
+ -- Get the oldest entry to calculate reset time
+ local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')
+ local resetTime = tonumber(oldest[2]) + window
+ local resetInSeconds = math.ceil((resetTime - now) / 1000)
+ return {0, resetInSeconds} -- not allowed, resetInSeconds
+ end
+ `;
+
+ const result = (await this.redis.eval(
+ luaScript,
+ 2,
+ rateLimitKey,
+ rateLimitSequenceKey,
+ now.toString(),
+ config.windowMs.toString(),
+ config.maxRequests.toString(),
+ )) as [number, number];
+
+ const [allowed, resetInSeconds] = result;
+
+ if (allowed === 1) {
+ return { allowed: true };
+ } else {
+ return {
+ allowed: false,
+ resetInSeconds: resetInSeconds,
+ };
+ }
+ } catch (error) {
+ // On Redis error, fail open (allow the request)
+ console.error("Redis rate limit error:", error);
+ return { allowed: true };
+ }
+ }
+
+ async reset(config: RateLimitConfig, key: string) {
+ const rateLimitKey = `${KEY_PREFIX}:${config.name}:${key}`;
+ const rateLimitSequenceKey = `${rateLimitKey}:seq`;
+ try {
+ await this.redis.del(rateLimitKey, rateLimitSequenceKey);
+ } catch (error) {
+ console.error("Redis rate limit reset error:", error);
+ }
+ }
+
+ async clear() {
+ try {
+ let cursor = "0";
+ do {
+ const [nextCursor, keys] = await this.redis.scan(
+ cursor,
+ "MATCH",
+ `${KEY_PREFIX}:*`,
+ "COUNT",
+ 100,
+ );
+ cursor = nextCursor;
+ if (keys.length > 0) {
+ await this.redis.del(...keys);
+ }
+ } while (cursor !== "0");
+ } catch (error) {
+ console.error("Redis rate limit clear error:", error);
+ }
+ }
+
+ async disconnect() {
+ await this.redis.quit();
+ }
+}
+
+export interface RedisRateLimiterOptions {
+ url: string;
+}
+
+export class RedisRateLimitProvider implements PluginProvider<RateLimitClient> {
+ private client: RedisRateLimiter | null = null;
+ private clientInitPromise: Promise<RedisRateLimiter | null> | null = null;
+ private nextRetryAt = 0;
+ private options: RedisRateLimiterOptions;
+ private static readonly RETRY_BACKOFF_MS = 5_000;
+
+ constructor(options: RedisRateLimiterOptions) {
+ this.options = options;
+ }
+
+ private createRedisClient(): Redis {
+ return new Redis(this.options.url, {
+ lazyConnect: true,
+ maxRetriesPerRequest: 0,
+ retryStrategy: () => 3_000,
+ });
+ }
+
+ private async initializeClient(): Promise<RedisRateLimiter | null> {
+ const redis = this.createRedisClient();
+
+ try {
+ // Test connection
+ await redis.connect();
+ await redis.ping();
+
+ this.nextRetryAt = 0;
+ console.log("Redis rate limiter connected successfully");
+ return new RedisRateLimiter(redis);
+ } catch (error) {
+ this.nextRetryAt = Date.now() + RedisRateLimitProvider.RETRY_BACKOFF_MS;
+ redis.disconnect();
+ console.error("Failed to connect to Redis for rate limiting:", error);
+ return null;
+ }
+ }
+
+ async getClient(): Promise<RateLimitClient | null> {
+ if (this.client) {
+ return this.client;
+ }
+
+ if (this.clientInitPromise) {
+ return await this.clientInitPromise;
+ }
+
+ if (this.nextRetryAt > Date.now()) {
+ return null;
+ }
+
+ const initPromise = this.initializeClient();
+ this.clientInitPromise = initPromise;
+
+ try {
+ const client = await initPromise;
+ this.client = client;
+ return client;
+ } finally {
+ if (this.clientInitPromise === initPromise) {
+ this.clientInitPromise = null;
+ }
+ }
+ }
+}
diff --git a/packages/plugins/ratelimit-redis/src/tests/docker-compose.yml b/packages/plugins/ratelimit-redis/src/tests/docker-compose.yml
new file mode 100644
index 00000000..27f8d250
--- /dev/null
+++ b/packages/plugins/ratelimit-redis/src/tests/docker-compose.yml
@@ -0,0 +1,5 @@
+services:
+ redis:
+ image: redis:7-alpine
+ ports:
+ - "${REDIS_PORT:-6379}:6379"
diff --git a/packages/plugins/ratelimit-redis/src/tests/ratelimit-redis.test.ts b/packages/plugins/ratelimit-redis/src/tests/ratelimit-redis.test.ts
new file mode 100644
index 00000000..ba7f360f
--- /dev/null
+++ b/packages/plugins/ratelimit-redis/src/tests/ratelimit-redis.test.ts
@@ -0,0 +1,213 @@
+import assert from "assert";
+import {
+ afterAll,
+ beforeAll,
+ beforeEach,
+ describe,
+ expect,
+ inject,
+ it,
+} from "vitest";
+
+import { RedisRateLimiter, RedisRateLimitProvider } from "../index";
+
+describe("RedisRateLimiter", () => {
+ let rateLimiter: RedisRateLimiter;
+
+ beforeAll(async () => {
+ const redisPort = inject("redisPort");
+ const provider = new RedisRateLimitProvider({
+ url: `redis://localhost:${redisPort}`,
+ });
+ const client = await provider.getClient();
+ assert(client, "Failed to connect to Redis");
+ rateLimiter = client as RedisRateLimiter;
+ });
+
+ beforeEach(async () => {
+ await rateLimiter.clear();
+ });
+
+ afterAll(async () => {
+ if (rateLimiter) {
+ await rateLimiter.disconnect();
+ }
+ });
+
+ describe("checkRateLimit", () => {
+ it("should allow requests within rate limit", async () => {
+ const config = {
+ name: "test-allow",
+ windowMs: 60000,
+ maxRequests: 3,
+ };
+
+ const result1 = await rateLimiter.checkRateLimit(config, "user1");
+ const result2 = await rateLimiter.checkRateLimit(config, "user1");
+ const result3 = await rateLimiter.checkRateLimit(config, "user1");
+
+ expect(result1.allowed).toBe(true);
+ expect(result2.allowed).toBe(true);
+ expect(result3.allowed).toBe(true);
+ });
+
+ it("should block requests exceeding rate limit", async () => {
+ const config = {
+ name: "test-block",
+ windowMs: 60000,
+ maxRequests: 2,
+ };
+
+ const result1 = await rateLimiter.checkRateLimit(config, "user1");
+ const result2 = await rateLimiter.checkRateLimit(config, "user1");
+ const result3 = await rateLimiter.checkRateLimit(config, "user1");
+
+ expect(result1.allowed).toBe(true);
+ expect(result2.allowed).toBe(true);
+ expect(result3.allowed).toBe(false);
+ assert(!result3.allowed);
+ expect(result3.resetInSeconds).toBeGreaterThan(0);
+ });
+
+ it("should reset after window expires", async () => {
+ const config = {
+ name: "test-window",
+ windowMs: 2000, // 2 second window for faster test
+ maxRequests: 1,
+ };
+
+ const result1 = await rateLimiter.checkRateLimit(config, "user1");
+ expect(result1.allowed).toBe(true);
+
+ const result2 = await rateLimiter.checkRateLimit(config, "user1");
+ expect(result2.allowed).toBe(false);
+
+ // Wait for the window to expire
+ await new Promise((resolve) => setTimeout(resolve, 2500));
+
+ const result3 = await rateLimiter.checkRateLimit(config, "user1");
+ expect(result3.allowed).toBe(true);
+ });
+
+ it("should isolate rate limits by key", async () => {
+ const config = {
+ name: "test-isolate-key",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+
+ const result1 = await rateLimiter.checkRateLimit(config, "user1:/api/v1");
+ const result2 = await rateLimiter.checkRateLimit(config, "user1:/api/v2");
+
+ expect(result1.allowed).toBe(true);
+ expect(result2.allowed).toBe(true);
+ });
+
+ it("should isolate rate limits by config name", async () => {
+ const config1 = {
+ name: "api-isolate",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+ const config2 = {
+ name: "auth-isolate",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+
+ const result1 = await rateLimiter.checkRateLimit(config1, "user1");
+ const result2 = await rateLimiter.checkRateLimit(config2, "user1");
+
+ expect(result1.allowed).toBe(true);
+ expect(result2.allowed).toBe(true);
+ });
+
+ it("should calculate correct resetInSeconds", async () => {
+ const config = {
+ name: "test-reset-calc",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+
+ await rateLimiter.checkRateLimit(config, "user1");
+ const result = await rateLimiter.checkRateLimit(config, "user1");
+
+ expect(result.allowed).toBe(false);
+ assert(!result.allowed);
+ expect(result.resetInSeconds).toBeGreaterThan(0);
+ expect(result.resetInSeconds).toBeLessThanOrEqual(60);
+ });
+
+ it("should allow empty key", async () => {
+ const config = {
+ name: "test-empty-key",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+
+ const result = await rateLimiter.checkRateLimit(config, "");
+ expect(result.allowed).toBe(true);
+ });
+ });
+
+ describe("reset", () => {
+ it("should reset rate limit for specific identifier", async () => {
+ const config = {
+ name: "test-reset",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+
+ await rateLimiter.checkRateLimit(config, "user1");
+ const result1 = await rateLimiter.checkRateLimit(config, "user1");
+ expect(result1.allowed).toBe(false);
+
+ await rateLimiter.reset(config, "user1");
+
+ const result2 = await rateLimiter.checkRateLimit(config, "user1");
+ expect(result2.allowed).toBe(true);
+ });
+
+ it("should not affect other identifiers", async () => {
+ const config = {
+ name: "test-reset-isolation",
+ windowMs: 60000,
+ maxRequests: 1,
+ };
+
+ await rateLimiter.checkRateLimit(config, "user1");
+ await rateLimiter.checkRateLimit(config, "user2");
+
+ await rateLimiter.reset(config, "user1");
+
+ const result1 = await rateLimiter.checkRateLimit(config, "user1");
+ const result2 = await rateLimiter.checkRateLimit(config, "user2");
+
+ expect(result1.allowed).toBe(true);
+ expect(result2.allowed).toBe(false);
+ });
+ });
+
+ describe("concurrent access", () => {
+ it("should handle concurrent requests atomically", async () => {
+ const config = {
+ name: "test-concurrent",
+ windowMs: 60000,
+ maxRequests: 5,
+ };
+
+ // Fire 10 requests concurrently
+ const results = await Promise.all(
+ Array.from({ length: 10 }, () =>
+ rateLimiter.checkRateLimit(config, "user1"),
+ ),
+ );
+
+ const allowed = results.filter((r) => r.allowed).length;
+ const blocked = results.filter((r) => !r.allowed).length;
+
+ expect(allowed).toBe(5);
+ expect(blocked).toBe(5);
+ });
+ });
+});
diff --git a/packages/plugins/ratelimit-redis/src/tests/setup/startContainers.ts b/packages/plugins/ratelimit-redis/src/tests/setup/startContainers.ts
new file mode 100644
index 00000000..691bc923
--- /dev/null
+++ b/packages/plugins/ratelimit-redis/src/tests/setup/startContainers.ts
@@ -0,0 +1,90 @@
+import { execSync } from "child_process";
+import net from "net";
+import path from "path";
+import { fileURLToPath } from "url";
+import type { GlobalSetupContext } from "vitest/node";
+
+import { waitUntil } from "../utils.js";
+
+async function getRandomPort(): Promise<number> {
+ const server = net.createServer();
+ return new Promise<number>((resolve, reject) => {
+ server.unref();
+ server.on("error", reject);
+ server.listen(0, () => {
+ const port = (server.address() as net.AddressInfo).port;
+ server.close(() => resolve(port));
+ });
+ });
+}
+
+async function waitForHealthy(port: number, timeout = 30000): Promise<void> {
+ await waitUntil(
+ async () => {
+ const socket = net.createConnection({ port, host: "localhost" });
+ return new Promise<boolean>((resolve) => {
+ socket.on("connect", () => {
+ socket.destroy();
+ resolve(true);
+ });
+ socket.on("error", () => {
+ socket.destroy();
+ resolve(false);
+ });
+ });
+ },
+ "Redis is healthy",
+ timeout,
+ );
+}
+
+export default async function ({ provide }: GlobalSetupContext) {
+ const __dirname = path.dirname(fileURLToPath(import.meta.url));
+ const redisPort = await getRandomPort();
+
+ console.log(`Starting Redis on port ${redisPort}...`);
+ try {
+ execSync(`docker compose up -d`, {
+ cwd: path.join(__dirname, ".."),
+ stdio: ["ignore", "pipe", "pipe"],
+ env: {
+ ...process.env,
+ REDIS_PORT: redisPort.toString(),
+ },
+ });
+ } catch (error) {
+ const execError = error as {
+ stdout?: Buffer;
+ stderr?: Buffer;
+ message?: string;
+ };
+ console.error("Failed to start Redis container");
+ if (execError.stdout) {
+ console.error(execError.stdout.toString());
+ }
+ if (execError.stderr) {
+ console.error(execError.stderr.toString());
+ }
+ console.error(execError.message ?? error);
+ throw error;
+ }
+
+ console.log("Waiting for Redis to become healthy...");
+ await waitForHealthy(redisPort);
+
+ provide("redisPort", redisPort);
+
+ return async () => {
+ console.log("Stopping Redis...");
+ execSync("docker compose down", {
+ cwd: path.join(__dirname, ".."),
+ stdio: "ignore",
+ });
+ };
+}
+
+declare module "vitest" {
+ export interface ProvidedContext {
+ redisPort: number;
+ }
+}
diff --git a/packages/plugins/ratelimit-redis/src/tests/utils.ts b/packages/plugins/ratelimit-redis/src/tests/utils.ts
new file mode 100644
index 00000000..e02d2dee
--- /dev/null
+++ b/packages/plugins/ratelimit-redis/src/tests/utils.ts
@@ -0,0 +1,23 @@
+export async function waitUntil(
+ f: () => Promise<boolean>,
+ description: string,
+ timeoutMs = 60000,
+): Promise<void> {
+ const startTime = Date.now();
+
+ while (Date.now() - startTime < timeoutMs) {
+ console.log(`Waiting for ${description}...`);
+ try {
+ const res = await f();
+ if (res) {
+ console.log(`${description}: success`);
+ return;
+ }
+ } catch (error) {
+ console.log(`${description}: error, retrying...: ${error}`);
+ }
+ await new Promise((resolve) => setTimeout(resolve, 1000));
+ }
+
+ throw new Error(`${description}: timeout after ${timeoutMs}ms`);
+}
diff --git a/packages/plugins/vitest.config.ts b/packages/plugins/vitest.config.ts
index 3d5f33f7..df18bfa8 100644
--- a/packages/plugins/vitest.config.ts
+++ b/packages/plugins/vitest.config.ts
@@ -6,7 +6,10 @@ import { defineConfig } from "vitest/config";
export default defineConfig({
plugins: [tsconfigPaths()],
test: {
- globalSetup: ["./queue-restate/src/tests/setup/startContainers.ts"],
+ globalSetup: [
+ "./queue-restate/src/tests/setup/startContainers.ts",
+ "./ratelimit-redis/src/tests/setup/startContainers.ts",
+ ],
teardownTimeout: 30000,
include: ["**/src/tests/**/*.test.ts"],
testTimeout: 60000,
diff --git a/packages/shared-server/src/plugins.ts b/packages/shared-server/src/plugins.ts
index 9e78bedb..e5231a7b 100644
--- a/packages/shared-server/src/plugins.ts
+++ b/packages/shared-server/src/plugins.ts
@@ -10,7 +10,9 @@ export async function loadAllPlugins() {
await import("@karakeep/plugins/queue-liteque");
await import("@karakeep/plugins/queue-restate");
await import("@karakeep/plugins/search-meilisearch");
+ // Rate limiters (order matters - last one wins)
await import("@karakeep/plugins/ratelimit-memory");
+ await import("@karakeep/plugins/ratelimit-redis");
PluginManager.logAllPlugins();
pluginsLoaded = true;
}
diff --git a/packages/shared/config.ts b/packages/shared/config.ts
index d4333af6..173b87fd 100644
--- a/packages/shared/config.ts
+++ b/packages/shared/config.ts
@@ -167,6 +167,9 @@ const allEnv = z.object({
// Rate limiting configuration
RATE_LIMITING_ENABLED: stringBool("false"),
+ // Redis configuration
+ REDIS_URL: z.string().url().optional(),
+
// Stripe configuration
STRIPE_SECRET_KEY: z.string().optional(),
STRIPE_PUBLISHABLE_KEY: z.string().optional(),
@@ -415,6 +418,9 @@ const serverConfigSchema = allEnv.transform((val, ctx) => {
rateLimiting: {
enabled: val.RATE_LIMITING_ENABLED,
},
+ redis: {
+ url: val.REDIS_URL,
+ },
stripe: {
secretKey: val.STRIPE_SECRET_KEY,
publishableKey: val.STRIPE_PUBLISHABLE_KEY,
diff --git a/packages/shared/ratelimiting.ts b/packages/shared/ratelimiting.ts
index ee5988b4..183720ac 100644
--- a/packages/shared/ratelimiting.ts
+++ b/packages/shared/ratelimiting.ts
@@ -17,19 +17,22 @@ export interface RateLimitClient {
* @param key Unique rate limiting key (e.g., "ip:127.0.0.1:path:/api/v1")
* @returns Result indicating if the request is allowed and reset time if not
*/
- checkRateLimit(config: RateLimitConfig, key: string): RateLimitResult;
+ checkRateLimit(
+ config: RateLimitConfig,
+ key: string,
+ ): RateLimitResult | Promise<RateLimitResult>;
/**
* Reset rate limit for a specific key
* @param config Rate limit configuration
* @param key Unique rate limiting key
*/
- reset(config: RateLimitConfig, key: string): void;
+ reset(config: RateLimitConfig, key: string): void | Promise<void>;
/**
* Clear all rate limit entries
*/
- clear(): void;
+ clear(): void | Promise<void>;
}
export async function getRateLimitClient(): Promise<RateLimitClient | null> {
diff --git a/packages/trpc/lib/rateLimit.ts b/packages/trpc/lib/rateLimit.ts
index bf8a8e8b..90576789 100644
--- a/packages/trpc/lib/rateLimit.ts
+++ b/packages/trpc/lib/rateLimit.ts
@@ -34,7 +34,7 @@ export function createRateLimitMiddleware<T>(config: RateLimitConfig) {
// Build the rate limiting key from IP and path
const key = `${ip}:${opts.path}`;
- const result = client.checkRateLimit(config, key);
+ const result = await client.checkRateLimit(config, key);
if (!result.allowed) {
throw new TRPCError({
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7dbb40b2..1cfcd846 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1283,6 +1283,9 @@ importers:
async-mutex:
specifier: ^0.4.1
version: 0.4.1
+ ioredis:
+ specifier: ^5.4.2
+ version: 5.10.0
liteque:
specifier: ^0.7.0
@@ -4052,6 +4055,9 @@ packages:
cpu: [x64]
os: [win32]
+ '@ioredis/[email protected]':
+ resolution: {integrity: sha512-JH8ZL/ywcJyR9MmJ5BNqZllXNZQqQbnVZOqpPQqE1vHiFgAw4NHbvE0FOduNU8IX9babitBT46571OnPTT0Zcw==}
+
'@isaacs/[email protected]':
resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}
engines: {node: 20 || >=22}
@@ -7542,6 +7548,10 @@ packages:
resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
engines: {node: '>=6'}
+ resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==}
+ engines: {node: '>=0.10.0'}
+
resolution: {integrity: sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==}
peerDependencies:
@@ -8124,6 +8134,10 @@ packages:
resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}
engines: {node: '>=0.4.0'}
+ resolution: {integrity: sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==}
+ engines: {node: '>=0.10'}
+
resolution: {integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==}
engines: {node: '>= 0.6'}
@@ -9876,6 +9890,10 @@ packages:
resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==}
+ resolution: {integrity: sha512-HVBe9OFuqs+Z6n64q09PQvP1/R4Bm+30PAyyD4wIEqssh3v9L21QjCVk4kRLucMBcDokJTcLjsGeVRlq/nH6DA==}
+ engines: {node: '>=12.22.0'}
+
resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
engines: {node: '>= 12'}
@@ -10663,6 +10681,12 @@ packages:
resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==}
+ resolution: {integrity: sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==}
+
+ resolution: {integrity: sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==}
+
resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
@@ -13475,6 +13499,14 @@ packages:
resolution: {integrity: sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==}
+ resolution: {integrity: sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w==}
+ engines: {node: '>=4'}
+
+ resolution: {integrity: sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A==}
+ engines: {node: '>=4'}
+
resolution: {integrity: sha512-+P3TjtnP0k/FEjcBL5FZpoovtvrTNT/UXd4/sluaSyrURlSlhLSzEdfsTBW7WsKB6yPvgd7q/iZPICFjW4o57Q==}
peerDependencies:
@@ -14277,6 +14309,9 @@ packages:
resolution: {integrity: sha512-WjlahMgHmCJpqzU8bIBy4qtsZdU9lRlcZE3Lvyej6t4tuOuv1vk57OW3MBrj6hXBFx/nNoC9MPMTcr5YA7NQbg==}
engines: {node: '>=6'}
+ resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==}
+
resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==}
engines: {node: '>= 0.6'}
@@ -19720,6 +19755,8 @@ snapshots:
optional: true
+ '@ioredis/[email protected]': {}
+
'@isaacs/[email protected]': {}
'@isaacs/[email protected]':
@@ -23256,7 +23293,7 @@ snapshots:
dependencies:
- '@babel/runtime': 7.28.4
+ '@babel/runtime': 7.28.6
cosmiconfig: 7.1.0
resolve: 1.22.10
@@ -23858,6 +23895,8 @@ snapshots:
+
dependencies:
'@radix-ui/react-compose-refs': 1.1.2(@types/[email protected])([email protected])
@@ -24486,6 +24525,8 @@ snapshots:
+
@@ -26486,6 +26527,20 @@ snapshots:
dependencies:
loose-envify: 1.4.0
+ dependencies:
+ '@ioredis/commands': 1.5.1
+ cluster-key-slot: 1.1.2
+ debug: 4.4.3
+ denque: 2.1.0
+ lodash.defaults: 4.2.0
+ lodash.isarguments: 3.1.0
+ redis-errors: 1.2.0
+ redis-parser: 3.0.0
+ standard-as-callback: 2.1.0
+ transitivePeerDependencies:
+ - supports-color
+
dependencies:
jsbn: 1.1.0
@@ -27304,6 +27359,10 @@ snapshots:
+
+
@@ -31200,6 +31259,12 @@ snapshots:
unified: 11.0.5
vfile: 6.0.3
+
+ dependencies:
+ redis-errors: 1.2.0
+
dependencies:
redux: 4.2.1
@@ -32211,6 +32276,8 @@ snapshots:
dependencies:
type-fest: 0.7.1
+