@warlock.js/cache 4.0.171 → 4.1.1

package/skills/use-cache-utils/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: use-cache-utils
+description: 'Low-level cache utilities re-exported from @warlock.js/cache — parseTtl, expiresAtToTtl, resolveTtl, normalizeToOptions, normalizeToRememberOptions, parseCacheKey, mergeTagSets, injectTags, cosineSimilarity, and the CACHE_FOR TTL enum. Triggers: `parseTtl`, `parseCacheKey`, `resolveTtl`, `expiresAtToTtl`, `cosineSimilarity`, `mergeTagSets`, `injectTags`, `CACHE_FOR`; "parse a duration to seconds", "build a cache key from an object", "score two vectors", "common TTL constant"; typical import `import { parseTtl, CACHE_FOR } from "@warlock.js/cache"`. Skip: building a whole custom driver — `@warlock.js/cache/pick-cache-driver/SKILL.md`; the high-level set API — `@warlock.js/cache/configure-set-options/SKILL.md`.'
+---
+
+# Cache utilities
+
+The helpers the drivers are built from, all re-exported from
+`@warlock.js/cache`. You rarely need them at the call site — `cache.set("k", v,
+"1h")` parses the duration for you. They earn their keep when you write a custom
+driver or do cache-adjacent work outside the manager.
+
+## TTL helpers
+
+```ts
+import { parseTtl, expiresAtToTtl, resolveTtl } from "@warlock.js/cache";
+
+parseTtl(3600);        // 3600
+parseTtl("1h");        // 3600  (duration string via `ms`)
+parseTtl(Infinity);    // Infinity (no expiry)
+parseTtl(-5);          // throws CacheConfigurationError
+
+expiresAtToTtl(new Date(Date.now() + 60_000)); // ~60 (absolute → relative seconds)
+expiresAtToTtl(Date.now() - 1000);             // throws — deadline in the past
+
+// caller ttl > expiresAt > fallback; ttl+expiresAt together throws
+resolveTtl("1h", undefined, Infinity);         // 3600
+resolveTtl(undefined, undefined, 1800);        // 1800 (fallback)
+```
+
+## Option normalizers
+
+Coerce the polymorphic 2nd/3rd argument of `set`/`remember` into a uniform shape
+— what `BaseCacheDriver` uses internally:
+
+```ts
+import { normalizeToOptions, normalizeToRememberOptions } from "@warlock.js/cache";
+
+normalizeToOptions(60);                 // { ttl: 60 }
+normalizeToOptions("1h");               // { ttl: "1h" }
+normalizeToOptions({ tags: ["x"] });    // returned as-is
+normalizeToRememberOptions("1h");       // { ttl: "1h" }   (no expiresAt/onConflict)
+```
+
+## Key + tag helpers
+
+```ts
+import { parseCacheKey, mergeTagSets, injectTags } from "@warlock.js/cache";
+
+parseCacheKey("users:1");                       // "users.1"
+parseCacheKey({ page: 1, q: "John" });          // "page.1.q.John"
+parseCacheKey("user:1", { globalPrefix: "app" }); // "app.user.1"
+
+mergeTagSets(["a", "b"], ["b", "c"]);           // ["a","b","c"] (deduped union)
+mergeTagSets(undefined, undefined);             // undefined
+
+injectTags({ ttl: "1h" }, ["unread"]);          // { ttl: "1h", tags: ["unread"] } (pure, no mutation)
+```
+
+## Vector scoring
+
+```ts
+import { cosineSimilarity } from "@warlock.js/cache";
+
+cosineSimilarity([1, 0, 0], [1, 0, 0]); // 1
+cosineSimilarity([1, 0, 0], [0, 1, 0]); // 0
+cosineSimilarity([1, 2, 3], [1, 2]);    // throws — dimension mismatch
+```
+
+Powers the brute-force `cache.similar()` on the memory drivers — reach for it
+directly only when scoring vectors outside the cache.
+
+## TTL constants — `CACHE_FOR`
+
+```ts
+import { cache, CACHE_FOR } from "@warlock.js/cache";
+
+await cache.set("report", data, CACHE_FOR.ONE_WEEK);
+```
+
+Members: `HALF_HOUR`, `ONE_HOUR`, `HALF_DAY`, `ONE_DAY`, `ONE_WEEK`,
+`HALF_MONTH`, `ONE_MONTH`, `TWO_MONTHS`, `SIX_MONTHS`, `ONE_YEAR` (all seconds).
+For most call sites the duration string (`"1h"`, `"7d"`) reads better.
+
+## See also
+
+- [`@warlock.js/cache/configure-set-options/SKILL.md`](@warlock.js/cache/configure-set-options/SKILL.md) — the high-level `set` options these normalize
+- [`@warlock.js/cache/use-cache-similarity/SKILL.md`](@warlock.js/cache/use-cache-similarity/SKILL.md) — `cache.similar()`, which uses `cosineSimilarity`
+- [`@warlock.js/cache/pick-cache-driver/SKILL.md`](@warlock.js/cache/pick-cache-driver/SKILL.md) — building a custom driver where these help

package/skills/use-cached-hof/SKILL.md

@@ -0,0 +1,102 @@
+---
+name: use-cached-hof
+description: 'Wrap an async function with cached(fn, options) — declare the caching strategy once, call from many sites, get a bound .invalidate(...args) helper. Triggers: `cached`, `invalidate`, `key`, `ttl`, `tags`, `driver`; "wrap a DB lookup with caching", "memoize a function and invalidate by args", "one declaration many call sites", "auto-derive cache key from args"; typical import `import { cached } from "@warlock.js/cache"`. Skip: one-shot memoization — `@warlock.js/cache/apply-cache-patterns/SKILL.md` (`cache.remember`); tag bulk drop — `@warlock.js/cache/use-cache-tags/SKILL.md`; competing libs `p-memoize`, `mem`, `lodash.memoize`.'
+---
+
+# `cached()` — function-memoization wrapper
+
+`cached()` turns any async function into a memoized version. One declaration, many call sites, with a bound `.invalidate()` helper.
+
+## When to use
+
+Reach for `cached()` instead of `cache.remember()` when:
+- You have a function you'll call from many places.
+- You want the caching strategy declared once, not repeated at every call site.
+- You want `.invalidate()` available without manually deriving keys.
+
+Stick with `cache.remember()` for one-shot "get-or-compute" calls.
+
+## The three shapes — `fn` always first
+
+```ts
+import { cached } from "@warlock.js/cache";
+
+// 1. Prefix shorthand — driver default TTL; key auto-derived from args
+cached(fn, "user");
+
+// 2. Prefix + TTL
+cached(fn, "user", "1h");
+
+// 3. Options form — custom key fn, tags, per-call driver
+cached(fn, {
+  key: (id: number) => `user.${id}`,
+  ttl: "1h",
+  tags: ["users"],
+  driver: "redis",
+});
+```
+
+## Auto-key rules (shorthand only)
+
+| Args | Key |
+|------|-----|
+| None | `prefix` |
+| All primitives (incl. `null` / `undefined` / `bigint`) | `prefix.` + args joined with dots |
+| Any object / array arg | `prefix.` + `JSON.stringify(args)` |
+| Unserializable (circular / `BigInt` nested in object) | throws `CacheConfigurationError` |
+
+Footguns: order matters (`fn(1, 2)` and `fn(2, 1)` differ), `Date` → ISO string, `Map` / `Set` → `{}` (use the options form). When auto-key fails, use the options form with a custom `key` fn.
+
+## Return shape
+
+```ts
+type CachedFn<Args, R> = ((...args: Args) => Promise<R>) & {
+  invalidate(...args: Args): Promise<void>;
+};
+```
+
+`.refresh()` and `.peek()` are deferred to v2.1 — file demand in `backlog.md` if you need them.
+
+## Recipes
+
+### Cached DB lookup with write-side invalidation
+
+```ts
+const getUser = cached((id: number) => db.users.find(id), "user", "1h");
+
+// On update
+await db.users.update(42, patch);
+await getUser.invalidate(42);
+```
+
+### Tag-based bulk invalidation across wrappers
+
+```ts
+const getUser = cached(fn, { key: (id) => `user.${id}`, ttl: "1h", tags: ["users"] });
+const getPosts = cached(fn, { key: (u) => `posts.by.${u}`, ttl: "30m", tags: ["users", "posts"] });
+
+await cache.tags(["users"]).invalidate();   // drops both wrappers' caches
+```
+
+See [`@warlock.js/cache/use-cache-tags/SKILL.md`](@warlock.js/cache/use-cache-tags/SKILL.md).
+
+### Project a subset of args into the key
+
+```ts
+const getCategoryMeta = cached(
+  (filters: Filters) => db.categories.meta(filters.category),
+  { key: (f) => `category.meta.${f.category}`, ttl: "1h" },   // ignores `sort`, `page`
+);
+```
+
+## Interaction with the rest of the API
+
+- Uses `cache.remember()` internally → inherits stampede protection within a single Node process.
+- Forwards `tags` and `driver` through the (extended) `RememberOptions` shape on `remember`.
+- `.invalidate()` calls `cache.remove()` — no side effects beyond the single entry.
+
+## Things NOT to do
+
+- Don't wrap a function that has non-JSON-serializable args with the shorthand form. Use the options form and project a stable subset into the key.
+- Don't rely on cross-process stampede safety. `cached` inherits `remember`'s in-process lock; cross-process needs a distributed lock via `onConflict: "create"`.
+- Don't include secrets in args — they'd land in cache keys. Project only the identifying fields into the key.

package/skills/use-swr/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: use-swr
+description: 'Stale-while-revalidate via cache.swr(key, {freshTtl, staleTtl}, fn) — returns cached instantly when fresh, returns cached + background refresh when stale, blocks only when fully expired. Triggers: `cache.swr`, `freshTtl`, `staleTtl`, `tags`, `driver`, `stale_at`; "serve stale while refreshing", "degrade when upstream is down", "never block on cache miss"; typical import `import { cache } from "@warlock.js/cache"`. Skip: block-until-fresh memoization — `@warlock.js/cache/apply-cache-patterns/SKILL.md`; observing refresh failures — `@warlock.js/cache/observe-cache/SKILL.md`; competing libs `swr` (React, client-side).'
+---
+
+# Stale-while-revalidate — `cache.swr(key, options, fn)`
+
+Returns the cached value immediately when it can; refreshes in the background when the value is getting old; only blocks when the entry is fully expired. The single biggest production-reliability win in the package — every cache miss past `freshTtl` becomes invisible to callers.
+
+## When to reach for it
+
+Use `cache.swr()` when **slightly-stale data is acceptable** and **the upstream is slow / occasionally fails**. That's most product-detail pages, dashboards, third-party API responses, expensive aggregations.
+
+Use `cache.remember()` when freshness is non-negotiable — auth, balances, billing, anything where the user must see the latest. Remember blocks every miss; SWR doesn't. See [`@warlock.js/cache/apply-cache-patterns/SKILL.md`](@warlock.js/cache/apply-cache-patterns/SKILL.md).
+
+## Three windows
+
+```
+   write              freshTtl              staleTtl
+     │                    │                    │
+     ▼                    ▼                    ▼
+─────┬──── fresh ─────────┬──── stale ─────────┬──── expired ──→
+     │  return cached     │  return cached +   │  block, refetch
+     │  no upstream call  │  bg refresh        │  like a miss
+```
+
+| Window | Behavior |
+|---|---|
+| `now < freshTtl` | Return cached. No upstream call. |
+| `freshTtl ≤ now < staleTtl` | Return cached immediately. Run `fn()` in background; next read sees the refreshed value. |
+| `now ≥ staleTtl` | Block on `fn()`. Same as `remember()`. |
+
+## API
+
+```ts
+await cache.swr(
+  "product.42",
+  {
+    freshTtl: "1m",          // CacheTtl — within this, no upstream call
+    staleTtl: "1h",          // CacheTtl — past this, block-and-refetch
+    tags?: string[],         // applied on first miss + every successful refresh
+    driver?: string,         // per-call driver override, like remember()
+  },
+  () => db.products.find(42),
+);
+```
+
+`staleTtl` MUST be greater than `freshTtl` — otherwise throws.
+
+## Key invariants
+
+1. **Concurrent stale-window callers share one refresh.** Per-key dedupe via the driver's existing locks map — no thundering herd on background refresh.
+2. **Failed background refreshes preserve the stale entry.** No retry storm; the next stale-window read tries again. Failures emit `error` events for observability.
+3. **The caller never sees a refresh failure.** If you returned the stale value, you got your data — failures only show up via `cache.on("error", ...)`. See [`@warlock.js/cache/observe-cache/SKILL.md`](@warlock.js/cache/observe-cache/SKILL.md).
+4. **Tags compose.** Per-call tags + scope tags (when via `cache.namespace().swr(...)`) merge additively.
+5. **Scope `ttl` defaults are NOT applied to SWR.** `freshTtl` / `staleTtl` always come from the call site.
+
+## Driver support
+
+| Driver | Background refresh |
+|---|---|
+| memory / memoryExtended / lru / file / mock | ✅ Full |
+| redis | ✅ Full (sidecar key for staleAt — backwards-compatible) |
+| pg | ✅ Full (`stale_at TIMESTAMPTZ` column — provision via `driver.schema()`) |
+| null | ❌ Always-fetch (null caches nothing) |
+
+## Common shapes
+
+```ts
+// Product detail — slightly stale OK, never want to block on DB
+await cache.swr(`product.${id}`, { freshTtl: "1m", staleTtl: "1h" }, () =>
+  db.products.findById(id),
+);
+
+// Dashboard — expensive aggregation, OK to be 5min stale
+await cache.swr(`dashboard.${tenantId}`, { freshTtl: "5m", staleTtl: "1h" }, () =>
+  computeKPIs(tenantId),
+);
+
+// Third-party API — degrade gracefully when upstream is down
+await cache.swr("exchange.rates", { freshTtl: "10m", staleTtl: "24h" }, () =>
+  fetchFromForexAPI(),
+);
+```
+
+## Through scoped caches
+
+```ts
+const feed = cache.namespace(`feed.${userId}`, { tags: [`user.${userId}`] });
+
+await feed.swr(
+  "home",
+  { freshTtl: "30s", staleTtl: "10m", tags: ["computed"] },
+  () => buildHomeFeed(userId),
+);
+// stored at feed.<userId>.home, tagged [user.<userId>, computed]
+```
+
+## Things NOT to do
+
+- Don't use SWR when the user must see the latest data (auth, billing). Use `remember()` instead — block-until-fresh is the right semantic there.
+- Don't pick `freshTtl` to be the *same* as `staleTtl` thinking it disables the stale window — that throws. Pick a tight `freshTtl` and wider `staleTtl` that reflects how stale your product can tolerate being.
+- Don't ignore `error` events. A persistent stream of refresh failures means upstream is broken and the cache is masking it.
+- Don't reach for SWR on the null driver — it caches nothing, so SWR always blocks.

package/cjs/cache-manager.d.ts

@@ -1,163 +0,0 @@
-import type { CacheConfigurations, CacheDriver, CacheEventHandler, CacheEventType, CacheKey, DriverClass, TaggedCacheDriver } from "./types";
-export declare class CacheManager implements CacheDriver<any, any> {
-    /**
-     * Cache Driver
-     */
-    currentDriver?: CacheDriver<any, any>;
-    /**
-     * Loaded drivers
-     */
-    loadedDrivers: Record<string, CacheDriver<any, any>>;
-    /**
-     * Configurations list
-     */
-    protected configurations: CacheConfigurations;
-    /**
-     * Global event listeners
-     */
-    protected globalEventListeners: Map<CacheEventType, Set<CacheEventHandler>>;
-    /**
-     * {@inheritdoc}
-     */
-    name: string;
-    /**
-     * {@inheritdoc}
-     */
-    get client(): any;
-    /**
-     * Set the cache configurations
-     */
-    setCacheConfigurations(configurations: CacheConfigurations): void;
-    /**
-     * Set logging state
-     */
-    setLoggingState(loggingState: boolean): void;
-    /**
-     * Use the given driver
-     */
-    use(driver: string | CacheDriver<any, any>): Promise<this>;
-    /**
-     * Ensure driver is initialized before operations
-     */
-    protected ensureDriverInitialized(): void;
-    /**
-     * {@inheritdoc}
-     */
-    get<T = any>(key: CacheKey): Promise<T | null>;
-    /**
-     * Set a value in the cache
-     *
-     * @param key The cache key, could be an object or string
-     * @param value The value to be stored in the cache
-     * @param ttl The time to live in seconds
-     */
-    set(key: CacheKey, value: any, ttl?: number): Promise<any>;
-    /**
-     * {@inheritdoc}
-     */
-    remove(key: CacheKey): Promise<void>;
-    /**
-     * {@inheritdoc}
-     */
-    removeNamespace(namespace: string): Promise<any>;
-    /**
-     * {@inheritdoc}
-     */
-    flush(): Promise<void>;
-    /**
-     * {@inheritdoc}
-     */
-    connect(): Promise<any>;
-    /**
-     * {@inheritdoc}
-     */
-    parseKey(key: CacheKey): string;
-    /**
-     * {@inheritdoc}
-     */
-    get options(): any;
-    /**
-     * {@inheritdoc}
-     */
-    setOptions(options: Record<string, any>): any;
-    /**
-     * Get an instance of the cache driver
-     */
-    driver(driverName: string): Promise<CacheDriver<any, any>>;
-    /**
-     * Initialize the cache manager and pick the default driver
-     */
-    init(): Promise<void>;
-    /**
-     * Load the given cache driver name
-     */
-    load(driver: string): Promise<CacheDriver<any, any>>;
-    /**
-     * Register and bind a driver
-     */
-    registerDriver(driverName: string, driverClass: DriverClass): void;
-    /**
-     * Disconnect the cache manager
-     */
-    disconnect(): Promise<void>;
-    /**
-     * {@inheritdoc}
-     */
-    has(key: CacheKey): Promise<boolean>;
-    /**
-     * {@inheritdoc}
-     */
-    remember(key: CacheKey, ttl: number, callback: () => Promise<any>): Promise<any>;
-    /**
-     * {@inheritdoc}
-     */
-    pull(key: CacheKey): Promise<any | null>;
-    /**
-     * {@inheritdoc}
-     */
-    forever(key: CacheKey, value: any): Promise<any>;
-    /**
-     * {@inheritdoc}
-     */
-    increment(key: CacheKey, value?: number): Promise<number>;
-    /**
-     * {@inheritdoc}
-     */
-    decrement(key: CacheKey, value?: number): Promise<number>;
-    /**
-     * {@inheritdoc}
-     */
-    many(keys: CacheKey[]): Promise<any[]>;
-    /**
-     * {@inheritdoc}
-     */
-    setMany(items: Record<string, any>, ttl?: number): Promise<void>;
-    /**
-     * Register a global event listener (applies to all drivers)
-     */
-    on(event: CacheEventType, handler: CacheEventHandler): this;
-    /**
-     * Remove a global event listener
-     */
-    off(event: CacheEventType, handler: CacheEventHandler): this;
-    /**
-     * Register a one-time global event listener
-     */
-    once(event: CacheEventType, handler: CacheEventHandler): this;
-    /**
-     * Attach global listeners to a driver
-     */
-    protected attachGlobalListeners(driver: CacheDriver<any, any>): void;
-    /**
-     * Set if not exists (atomic operation)
-     * Returns true if key was set, false if key already existed
-     * Note: Only supported by drivers that implement setNX (e.g., Redis)
-     */
-    setNX(key: CacheKey, value: any, ttl?: number): Promise<boolean>;
-    /**
-     * Create a tagged cache instance for the given tags
-     */
-    tags(tags: string[]): TaggedCacheDriver;
-}
-export declare const cache: CacheManager;
-//# sourceMappingURL=cache-manager.d.ts.map

package/cjs/cache-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache-manager.d.ts","sourceRoot":"","sources":["../src/cache-manager.ts"],"names":[],"mappings":"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"}