Update hivegrid-cloud reference to latest main

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
davidandClaude Fable 5 committed 2026-07-08 16:15:37 +02:00
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.
*/
@@ -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();
});
@@ -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();
});
});
@@ -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();
});
});
@@ -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();
});
});