Update hivegrid-cloud reference to latest main
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
1 parent
e98d38e716
commit
7b21524c86
3781 files changed
+373484
-225607
No files matched your search
@@ -42,7 +42,7 @@ const defaultJsonSerializer = <T>(): CacheSerializer<T> => ({
|
||||
/**
|
||||
* JSON-cached values keyed under `cache:<prefix>:<key>`. The cache is
|
||||
* paired with a pub/sub channel so peer replicas can be notified when
|
||||
* an entry must be invalidated (e.g. after a Stripe webhook or admin
|
||||
* an entry must be invalidated (e.g. after a Mollie webhook or admin
|
||||
* edit). Cache misses cost one Redis round-trip; invalidation is a
|
||||
* single PUBLISH.
|
||||
*/
|
||||
|
||||
+4
-4
@@ -6,7 +6,7 @@ import { createIdempotencyStore } from "./idempotency.js";
|
||||
function build(opts: { ttlSeconds?: number; now?: () => number } = {}) {
|
||||
const adapter = new MemoryAdapter({ now: opts.now });
|
||||
const store = createSharedStore({ namespace: "idemp", adapter });
|
||||
const idempotency = createIdempotencyStore({ store, prefix: "stripe", ttlSeconds: opts.ttlSeconds ?? 60 });
|
||||
const idempotency = createIdempotencyStore({ store, prefix: "mollie", ttlSeconds: opts.ttlSeconds ?? 60 });
|
||||
return { store, idempotency };
|
||||
}
|
||||
|
||||
@@ -65,10 +65,10 @@ describe("createIdempotencyStore", () => {
|
||||
test("corrupt completed payload is evicted on read", async () => {
|
||||
const adapter = new MemoryAdapter();
|
||||
const store = createSharedStore({ namespace: "idemp", adapter });
|
||||
const idempotency = createIdempotencyStore({ store, prefix: "stripe", ttlSeconds: 60 });
|
||||
await store.set("idempotency:stripe:k", "not-json");
|
||||
const idempotency = createIdempotencyStore({ store, prefix: "mollie", ttlSeconds: 60 });
|
||||
await store.set("idempotency:mollie:k", "not-json");
|
||||
expect(await idempotency.get("k")).toBeNull();
|
||||
expect(await store.get("idempotency:stripe:k")).toBeNull();
|
||||
expect(await store.get("idempotency:mollie:k")).toBeNull();
|
||||
await store.close();
|
||||
});
|
||||
|
||||
|
||||
+66
@@ -0,0 +1,66 @@
|
||||
import { describe, expect, test } from "vitest";
|
||||
import { MemoryAdapter } from "../adapters/memory.js";
|
||||
import { createSharedStore, type SharedStore } from "../factory.js";
|
||||
import { createFixedWindowRateLimiter } from "./rate-limit-fixed.js";
|
||||
|
||||
/**
|
||||
* Build a SharedStore whose `adapter.eval` is replaced with a stub that
|
||||
* returns a fixed value, so the consume() result-parsing branches can be
|
||||
* driven directly (undefined result, zero TTL, etc.).
|
||||
*/
|
||||
function buildStoreWithEval(evalResult: unknown): SharedStore {
|
||||
const memoryAdapter = new MemoryAdapter();
|
||||
const proxyAdapter = new Proxy(memoryAdapter, {
|
||||
get(target, prop, receiver) {
|
||||
if (prop === "eval") {
|
||||
return async () => evalResult;
|
||||
}
|
||||
const value = Reflect.get(target, prop, receiver);
|
||||
return typeof value === "function" ? value.bind(target) : value;
|
||||
},
|
||||
});
|
||||
return createSharedStore({ namespace: "rl-fixed-edge", adapter: proxyAdapter });
|
||||
}
|
||||
|
||||
describe("createFixedWindowRateLimiter — result parsing edge cases", () => {
|
||||
test("treats an undefined eval result as a fresh window (current 0)", async () => {
|
||||
const store = buildStoreWithEval(undefined);
|
||||
const limiter = createFixedWindowRateLimiter({ store, prefix: "ip", windowSeconds: 30, max: 5 });
|
||||
const decision = await limiter.consume("k");
|
||||
expect(decision.allowed).toBe(true);
|
||||
// current defaults to 0 → all 5 actions remain.
|
||||
expect(decision.remaining).toBe(5);
|
||||
// ttl defaults to windowSeconds when the eval result is missing.
|
||||
const delta = decision.resetAt.getTime() - Date.now();
|
||||
expect(delta).toBeGreaterThan(20_000);
|
||||
expect(delta).toBeLessThanOrEqual(30_000);
|
||||
await store.close();
|
||||
});
|
||||
|
||||
test("falls back to windowSeconds when the reported ttl is non-positive", async () => {
|
||||
// Redis returns a TTL of -1/-2 for keys without an expiry or that vanished
|
||||
// between INCR and TTL; the helper must not produce a resetAt in the past.
|
||||
const store = buildStoreWithEval([3, 0]);
|
||||
const limiter = createFixedWindowRateLimiter({ store, prefix: "ip", windowSeconds: 30, max: 5 });
|
||||
const decision = await limiter.consume("k");
|
||||
expect(decision.allowed).toBe(true);
|
||||
expect(decision.remaining).toBe(2);
|
||||
const delta = decision.resetAt.getTime() - Date.now();
|
||||
expect(delta).toBeGreaterThan(20_000);
|
||||
expect(delta).toBeLessThanOrEqual(30_000);
|
||||
await store.close();
|
||||
});
|
||||
|
||||
test("uses a positive reported ttl verbatim and blocks once over the cap", async () => {
|
||||
const store = buildStoreWithEval([6, 10]);
|
||||
const limiter = createFixedWindowRateLimiter({ store, prefix: "ip", windowSeconds: 30, max: 5 });
|
||||
const decision = await limiter.consume("k");
|
||||
expect(decision.allowed).toBe(false);
|
||||
expect(decision.remaining).toBe(0);
|
||||
const delta = decision.resetAt.getTime() - Date.now();
|
||||
// ttl of 10s is honoured instead of the 30s window.
|
||||
expect(delta).toBeGreaterThan(5_000);
|
||||
expect(delta).toBeLessThanOrEqual(10_000);
|
||||
await store.close();
|
||||
});
|
||||
});
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
import { describe, expect, test } from "vitest";
|
||||
import { MemoryAdapter } from "../adapters/memory.js";
|
||||
import { createSharedStore, type SharedStore } from "../factory.js";
|
||||
import { createSlidingWindowRateLimiter } from "./rate-limit-sliding.js";
|
||||
|
||||
/**
|
||||
* Build a SharedStore whose `adapter.eval` returns a fixed value so the
|
||||
* oldest-entry parsing branches in consume() can be exercised directly.
|
||||
* The real Redis script surfaces the oldest score as a string; the memory
|
||||
* adapter returns "" and falls back to `now`.
|
||||
*/
|
||||
function buildStoreWithEval(evalResult: unknown): SharedStore {
|
||||
const memoryAdapter = new MemoryAdapter();
|
||||
const proxyAdapter = new Proxy(memoryAdapter, {
|
||||
get(target, prop, receiver) {
|
||||
if (prop === "eval") {
|
||||
return async () => evalResult;
|
||||
}
|
||||
const value = Reflect.get(target, prop, receiver);
|
||||
return typeof value === "function" ? value.bind(target) : value;
|
||||
},
|
||||
});
|
||||
return createSharedStore({ namespace: "rl-sliding-edge", adapter: proxyAdapter });
|
||||
}
|
||||
|
||||
describe("createSlidingWindowRateLimiter — oldest-entry parsing", () => {
|
||||
test("parses a finite oldest score into a Date", async () => {
|
||||
const store = buildStoreWithEval([2, "1500"]);
|
||||
const limiter = createSlidingWindowRateLimiter({
|
||||
store,
|
||||
prefix: "ip",
|
||||
windowSeconds: 60,
|
||||
max: 5,
|
||||
now: () => 9_000,
|
||||
});
|
||||
const decision = await limiter.consume("k");
|
||||
expect(decision.allowed).toBe(true);
|
||||
expect(decision.remaining).toBe(3);
|
||||
expect(decision.oldestAt).toEqual(new Date(1500));
|
||||
await store.close();
|
||||
});
|
||||
|
||||
test("falls back to the current timestamp when the oldest score is non-numeric", async () => {
|
||||
const store = buildStoreWithEval([2, "not-a-timestamp"]);
|
||||
const limiter = createSlidingWindowRateLimiter({
|
||||
store,
|
||||
prefix: "ip",
|
||||
windowSeconds: 60,
|
||||
max: 5,
|
||||
now: () => 9_000,
|
||||
});
|
||||
const decision = await limiter.consume("k");
|
||||
// Number("not-a-timestamp") is NaN → not finite → conservative fallback to now.
|
||||
expect(decision.oldestAt).toEqual(new Date(9_000));
|
||||
await store.close();
|
||||
});
|
||||
|
||||
test("treats an undefined eval result as an empty window", async () => {
|
||||
const store = buildStoreWithEval(undefined);
|
||||
const limiter = createSlidingWindowRateLimiter({
|
||||
store,
|
||||
prefix: "ip",
|
||||
windowSeconds: 60,
|
||||
max: 5,
|
||||
now: () => 7_000,
|
||||
});
|
||||
const decision = await limiter.consume("k");
|
||||
expect(decision.allowed).toBe(true);
|
||||
// count defaults to 0 → full quota remains.
|
||||
expect(decision.remaining).toBe(5);
|
||||
// oldestRaw defaults to "" (falsy) → conservative fallback to now.
|
||||
expect(decision.oldestAt).toEqual(new Date(7_000));
|
||||
await store.close();
|
||||
});
|
||||
|
||||
test("blocks once the count exceeds the cap", async () => {
|
||||
const store = buildStoreWithEval([6, "1000"]);
|
||||
const limiter = createSlidingWindowRateLimiter({
|
||||
store,
|
||||
prefix: "ip",
|
||||
windowSeconds: 60,
|
||||
max: 5,
|
||||
now: () => 9_000,
|
||||
});
|
||||
const decision = await limiter.consume("k");
|
||||
expect(decision.allowed).toBe(false);
|
||||
expect(decision.remaining).toBe(0);
|
||||
expect(decision.oldestAt).toEqual(new Date(1000));
|
||||
await store.close();
|
||||
});
|
||||
});
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
import { describe, expect, test, vi } from "vitest";
|
||||
import { MemoryAdapter } from "../adapters/memory.js";
|
||||
import { createSharedStore } from "../factory.js";
|
||||
import { createTwoTierCache, type TwoTierL1Cache } from "./two-tier-cache.js";
|
||||
|
||||
interface Value {
|
||||
id: string;
|
||||
name: string;
|
||||
}
|
||||
|
||||
async function flushPubSubMicrotasks() {
|
||||
await Promise.resolve();
|
||||
await Promise.resolve();
|
||||
await new Promise((resolve) => setTimeout(resolve, 0));
|
||||
}
|
||||
|
||||
describe("createTwoTierCache — subscriber handler error path", () => {
|
||||
test("logs (and swallows) errors thrown by the extra handler", async () => {
|
||||
const adapter = new MemoryAdapter();
|
||||
const storeA = createSharedStore({ namespace: "ns", adapter });
|
||||
const storeB = createSharedStore({ namespace: "ns", adapter });
|
||||
const logger = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
|
||||
|
||||
const a = createTwoTierCache<Value>({ store: storeA, namespace: "subscription", ttlSeconds: 60 });
|
||||
const b = createTwoTierCache<Value>({ store: storeB, namespace: "subscription", ttlSeconds: 60, logger });
|
||||
|
||||
await b.set("t1", { id: "t1", name: "x" });
|
||||
await b.subscribe(() => {
|
||||
throw new Error("extra handler boom");
|
||||
});
|
||||
|
||||
// Peer publishes an invalidation → b's subscriber runs, extra handler throws.
|
||||
await a.invalidate("t1");
|
||||
await flushPubSubMicrotasks();
|
||||
|
||||
// Local L1 of b still purged despite the handler throwing.
|
||||
expect(b.l1.get("t1")).toBeUndefined();
|
||||
expect(logger.error).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ component: "two-tier-cache", namespace: "subscription" }),
|
||||
expect.stringMatching(/subscriber handler threw/),
|
||||
);
|
||||
await storeA.close();
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* Build a SharedStore whose adapter `publish` and/or `del` throw, to drive
|
||||
* the L2 invalidate/delete failure branches in two-tier-cache.
|
||||
*/
|
||||
function buildStoreWithFailingOps(overrides: { publish?: boolean; del?: boolean }) {
|
||||
const memoryAdapter = new MemoryAdapter();
|
||||
const proxyAdapter = new Proxy(memoryAdapter, {
|
||||
get(target, prop, receiver) {
|
||||
if (prop === "publish" && overrides.publish) {
|
||||
return async () => {
|
||||
throw new Error("publish failed");
|
||||
};
|
||||
}
|
||||
if (prop === "del" && overrides.del) {
|
||||
return async () => {
|
||||
throw new Error("del failed");
|
||||
};
|
||||
}
|
||||
const value = Reflect.get(target, prop, receiver);
|
||||
return typeof value === "function" ? value.bind(target) : value;
|
||||
},
|
||||
});
|
||||
return createSharedStore({ namespace: "ns", adapter: proxyAdapter });
|
||||
}
|
||||
|
||||
describe("createTwoTierCache — L2 failure paths", () => {
|
||||
test("logs when the L2 invalidate (publish) throws", async () => {
|
||||
const store = buildStoreWithFailingOps({ publish: true });
|
||||
const logger = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
|
||||
const cache = createTwoTierCache<Value>({ store, namespace: "subscription", ttlSeconds: 60, logger });
|
||||
|
||||
// pubsubEnabled (default) + not localOnly → goes through l2.invalidate, which publishes.
|
||||
await cache.invalidate("t1");
|
||||
|
||||
expect(logger.error).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ component: "two-tier-cache", namespace: "subscription" }),
|
||||
expect.stringMatching(/l2 invalidate failed/),
|
||||
);
|
||||
await store.close();
|
||||
});
|
||||
|
||||
test("logs when the best-effort L2 delete throws on a localOnly invalidate", async () => {
|
||||
const store = buildStoreWithFailingOps({ del: true });
|
||||
const logger = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
|
||||
const cache = createTwoTierCache<Value>({ store, namespace: "subscription", ttlSeconds: 60, logger });
|
||||
|
||||
await cache.invalidate("t1", { localOnly: true });
|
||||
|
||||
expect(logger.error).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ component: "two-tier-cache", namespace: "subscription" }),
|
||||
expect.stringMatching(/l2 delete failed/),
|
||||
);
|
||||
await store.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe("createTwoTierCache — pubsub disabled with logger", () => {
|
||||
test("warns that the subscriber is not started and returns a noop disposer", async () => {
|
||||
const adapter = new MemoryAdapter();
|
||||
const store = createSharedStore({ namespace: "ns", adapter });
|
||||
const logger = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
|
||||
const cache = createTwoTierCache<Value>({
|
||||
store,
|
||||
namespace: "subscription",
|
||||
ttlSeconds: 60,
|
||||
pubsubEnabled: false,
|
||||
logger,
|
||||
});
|
||||
|
||||
const dispose = await cache.subscribe();
|
||||
expect(logger.warn).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ component: "two-tier-cache", namespace: "subscription" }),
|
||||
expect.stringMatching(/pubsub disabled/),
|
||||
);
|
||||
await expect(dispose()).resolves.toBeUndefined();
|
||||
await store.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe("createTwoTierCache — reconnect-flush success logging", () => {
|
||||
test("flushes L1 and logs an info line on a successful reconnect", async () => {
|
||||
const memoryAdapter = new MemoryAdapter();
|
||||
const reconnectHandlers = new Set<() => void | Promise<void>>();
|
||||
const proxyAdapter = new Proxy(memoryAdapter, {
|
||||
get(target, prop, receiver) {
|
||||
if (prop === "onReconnect") {
|
||||
return (handler: () => void | Promise<void>) => {
|
||||
reconnectHandlers.add(handler);
|
||||
return () => {
|
||||
reconnectHandlers.delete(handler);
|
||||
};
|
||||
};
|
||||
}
|
||||
const value = Reflect.get(target, prop, receiver);
|
||||
return typeof value === "function" ? value.bind(target) : value;
|
||||
},
|
||||
});
|
||||
const store = createSharedStore({ namespace: "ns", adapter: proxyAdapter });
|
||||
const logger = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
|
||||
const cache = createTwoTierCache<Value>({ store, namespace: "subscription", ttlSeconds: 60, logger });
|
||||
|
||||
const dispose = await cache.subscribe();
|
||||
await cache.set("t1", { id: "t1", name: "x" });
|
||||
expect(cache.l1.get("t1")).toEqual({ id: "t1", name: "x" });
|
||||
|
||||
for (const handler of reconnectHandlers) await handler();
|
||||
|
||||
expect(cache.l1.get("t1")).toBeUndefined();
|
||||
expect(logger.info).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ component: "two-tier-cache", namespace: "subscription" }),
|
||||
expect.stringMatching(/redis reconnected, L1 flushed/),
|
||||
);
|
||||
expect(logger.error).not.toHaveBeenCalled();
|
||||
|
||||
await dispose();
|
||||
await store.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe("createTwoTierCache — reconnect-flush error path", () => {
|
||||
test("logs (and swallows) errors thrown while flushing L1 on reconnect", async () => {
|
||||
const memoryAdapter = new MemoryAdapter();
|
||||
const reconnectHandlers = new Set<() => void | Promise<void>>();
|
||||
const proxyAdapter = new Proxy(memoryAdapter, {
|
||||
get(target, prop, receiver) {
|
||||
if (prop === "onReconnect") {
|
||||
return (handler: () => void | Promise<void>) => {
|
||||
reconnectHandlers.add(handler);
|
||||
return () => {
|
||||
reconnectHandlers.delete(handler);
|
||||
};
|
||||
};
|
||||
}
|
||||
const value = Reflect.get(target, prop, receiver);
|
||||
return typeof value === "function" ? value.bind(target) : value;
|
||||
},
|
||||
});
|
||||
const store = createSharedStore({ namespace: "ns", adapter: proxyAdapter });
|
||||
|
||||
const empty = new Map<string, Value>();
|
||||
const throwingL1: TwoTierL1Cache<Value> = {
|
||||
get: () => undefined,
|
||||
set: () => undefined,
|
||||
delete: () => false,
|
||||
clear: () => {
|
||||
throw new Error("l1 clear boom");
|
||||
},
|
||||
keys: () => empty.keys(),
|
||||
};
|
||||
|
||||
const logger = { warn: vi.fn(), info: vi.fn(), error: vi.fn() };
|
||||
const cache = createTwoTierCache<Value>({
|
||||
store,
|
||||
namespace: "subscription",
|
||||
ttlSeconds: 60,
|
||||
l1Cache: throwingL1,
|
||||
logger,
|
||||
});
|
||||
const dispose = await cache.subscribe();
|
||||
|
||||
// Fire the reconnect event → debounced flush → l1.clear() throws → logged.
|
||||
for (const handler of reconnectHandlers) await handler();
|
||||
|
||||
expect(logger.error).toHaveBeenCalledWith(
|
||||
expect.objectContaining({ component: "two-tier-cache", namespace: "subscription" }),
|
||||
expect.stringMatching(/reconnect-flush handler threw/),
|
||||
);
|
||||
|
||||
await dispose();
|
||||
expect(reconnectHandlers.size).toBe(0);
|
||||
await store.close();
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user