layercache 1.2.4 → 1.2.6

package/dist/{edge-Dw97n89L.d.cts → edge-DLstcDMn.d.ts}

@@ -66,6 +66,7 @@ interface CacheLayer {
     clear(): Promise<void>;
     deleteMany?(keys: string[]): Promise<void>;
     keys?(): Promise<string[]>;
+    forEachKey?(visitor: (key: string) => void | Promise<void>): Promise<void>;
     ping?(): Promise<boolean>;
     dispose?(): Promise<void>;
     /**
@@ -140,10 +141,13 @@ interface CacheTagIndex {
     track(key: string, tags: string[]): Promise<void>;
     remove(key: string): Promise<void>;
     keysForTag(tag: string): Promise<string[]>;
+    forEachKeyForTag?(tag: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
     keysForPrefix?(prefix: string): Promise<string[]>;
+    forEachKeyForPrefix?(prefix: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
     /** Returns the tags associated with a specific key, or an empty array. */
     tagsForKey?(key: string): Promise<string[]>;
     matchPattern(pattern: string): Promise<string[]>;
+    forEachKeyMatchingPattern?(pattern: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
     clear(): Promise<void>;
 }
 interface CacheLayerSetManyEntry {
@@ -203,6 +207,9 @@ interface CacheStackOptions {
     singleFlightPollMs?: number;
     singleFlightRenewIntervalMs?: number;
     snapshotBaseDir?: string | false;
+    snapshotMaxBytes?: number | false;
+    snapshotMaxEntries?: number | false;
+    invalidationMaxKeys?: number | false;
     /**
      * Maximum number of entries in `accessProfiles` and `circuitBreakers` maps
      * before the oldest entries are pruned. Prevents unbounded memory growth.
@@ -396,6 +403,7 @@ declare class MemoryLayer implements CacheLayer {
     ping(): Promise<boolean>;
     dispose(): Promise<void>;
     keys(): Promise<string[]>;
+    forEachKey(visitor: (key: string) => void | Promise<void>): Promise<void>;
     exportState(): MemoryLayerSnapshotEntry[];
     importState(entries: MemoryLayerSnapshotEntry[]): void;
     private evict;
@@ -437,14 +445,18 @@ declare class TagIndex implements CacheTagIndex {
     track(key: string, tags: string[]): Promise<void>;
     remove(key: string): Promise<void>;
     keysForTag(tag: string): Promise<string[]>;
+    forEachKeyForTag(tag: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
     keysForPrefix(prefix: string): Promise<string[]>;
+    forEachKeyForPrefix(prefix: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
     tagsForKey(key: string): Promise<string[]>;
     matchPattern(pattern: string): Promise<string[]>;
+    forEachKeyMatchingPattern(pattern: string, visitor: (key: string) => void | Promise<void>): Promise<void>;
     clear(): Promise<void>;
     private createTrieNode;
     private insertKnownKey;
     private findNode;
     private collectFromNode;
+    private visitFromNode;
     private collectPatternMatches;
     private pruneKnownKeysIfNeeded;
     private removeKey;
@@ -494,6 +506,10 @@ declare class CacheNamespace {
      */
     namespace(childPrefix: string): CacheNamespace;
     qualify(key: string): string;
+    private qualifyTag;
+    private qualifyGetOptions;
+    private qualifyWrapOptions;
+    private qualifyWriteOptions;
     private trackMetrics;
     private getMetricsMutex;
 }
@@ -523,6 +539,7 @@ declare class CacheStack extends EventEmitter {
     private readonly snapshotSerializer;
     private readonly backgroundRefreshes;
     private readonly layerDegradedUntil;
+    private readonly keyEpochs;
     private readonly ttlResolver;
     private readonly circuitBreakerManager;
     private currentGeneration?;
@@ -530,6 +547,7 @@ declare class CacheStack extends EventEmitter {
     private writeBehindTimer?;
     private writeBehindFlushPromise?;
     private generationCleanupPromise?;
+    private clearEpoch;
     private isDisconnecting;
     private disconnectPromise?;
     constructor(layers: CacheLayer[], options?: CacheStackOptions);
@@ -647,6 +665,10 @@ declare class CacheStack extends EventEmitter {
     private cleanupGeneration;
     private initializeWriteBehind;
     private shouldWriteBehind;
+    private beginClearEpoch;
+    private currentKeyEpoch;
+    private bumpKeyEpochs;
+    private isWriteOutdated;
     private enqueueWriteBehind;
     private flushWriteBehindQueue;
     private buildLayerSetEntry;
@@ -658,17 +680,8 @@ declare class CacheStack extends EventEmitter {
     private deleteKeysFromLayers;
     private validateConfiguration;
     private validateWriteOptions;
-    private validateLayerNumberOption;
-    private validatePositiveNumber;
-    private validateRateLimitOptions;
-    private validateNonNegativeNumber;
-    private validateCacheKey;
-    private validateTtlPolicy;
     private assertActive;
     private awaitStartup;
-    private serializeOptions;
-    private validateAdaptiveTtlOptions;
-    private validateCircuitBreakerOptions;
     private applyFreshReadPolicies;
     private shouldSkipLayer;
     private handleLayerFailure;
@@ -677,11 +690,14 @@ declare class CacheStack extends EventEmitter {
     private recordCircuitFailure;
     private isNegativeStoredValue;
     private emitError;
-    private serializeKeyPart;
     private isCacheSnapshotEntries;
     private sanitizeSnapshotValue;
-    private validateSnapshotFilePath;
-    private normalizeForSerialization;
+    private snapshotMaxBytes;
+    private snapshotMaxEntries;
+    private invalidationMaxKeys;
+    private collectKeysForTag;
+    private assertWithinInvalidationKeyLimit;
+    private visitExportEntries;
 }
 
 interface HonoLikeRequest {
@@ -689,6 +705,8 @@ interface HonoLikeRequest {
     url?: string;
     path?: string;
     query?: Record<string, unknown>;
+    headers?: Headers | Record<string, unknown>;
+    header?: (name: string) => string | undefined;
 }
 interface HonoLikeContext {
     req: HonoLikeRequest;
@@ -698,7 +716,8 @@ interface HonoLikeContext {
 interface HonoCacheMiddlewareOptions extends CacheGetOptions {
     keyResolver?: (request: HonoLikeRequest) => string;
     methods?: string[];
+    allowPrivateCaching?: boolean;
 }
-declare function createHonoCacheMiddleware(cache: CacheStack, options?: HonoCacheMiddlewareOptions): (context: HonoLikeContext, next: () => Promise<void>) => Promise<void>;
+declare function createHonoCacheMiddleware(cache: CacheStack, options?: HonoCacheMiddlewareOptions): (context: HonoLikeContext, next: () => Promise<void>) => Promise<unknown>;
 
 export { type CacheStatsSnapshot as A, type CacheTtlPolicy as B, type CacheLogger as C, type CacheTtlPolicyContext as D, type CacheWarmEntry as E, type CacheWarmOptions as F, type CacheWarmProgress as G, type CacheWriteBehindOptions as H, type InvalidationBus as I, type CacheWriteOptions as J, type EvictionPolicy as K, type LayerTtlMap as L, MemoryLayer as M, type MemoryLayerOptions as N, type MemoryLayerSnapshotEntry as O, PatternMatcher as P, createHonoCacheMiddleware as Q, TagIndex as T, type InvalidationMessage as a, type CacheTagIndex as b, CacheStack as c, type CacheWrapOptions as d, type CacheGetOptions as e, type CacheLayer as f, type CacheSerializer as g, type CacheLayerSetManyEntry as h, type CacheSingleFlightCoordinator as i, type CacheSingleFlightExecutionOptions as j, type CacheAdaptiveTtlOptions as k, type CacheCircuitBreakerOptions as l, type CacheDegradationOptions as m, type CacheHealthCheckResult as n, type CacheHitRateSnapshot as o, type CacheInspectResult as p, type CacheLayerLatency as q, type CacheMGetEntry as r, type CacheMSetEntry as s, type CacheMetricsSnapshot as t, CacheMissError as u, CacheNamespace as v, type CacheRateLimitOptions as w, type CacheSnapshotEntry as x, type CacheStackEvents as y, type CacheStackOptions as z };

package/dist/edge.cjs

@@ -39,19 +39,47 @@ function isStoredValueEnvelope(value) {
   if (v.kind !== "value" && v.kind !== "empty") {
     return false;
   }
-  if (v.freshUntil !== null && typeof v.freshUntil !== "number") {
+  if (v.freshUntil !== null && (!Number.isFinite(v.freshUntil) || typeof v.freshUntil !== "number")) {
     return false;
   }
-  if (v.staleUntil !== null && typeof v.staleUntil !== "number") {
+  if (v.staleUntil !== null && (!Number.isFinite(v.staleUntil) || typeof v.staleUntil !== "number")) {
     return false;
   }
-  if (v.errorUntil !== null && typeof v.errorUntil !== "number") {
+  if (v.errorUntil !== null && (!Number.isFinite(v.errorUntil) || typeof v.errorUntil !== "number")) {
     return false;
   }
   const maxTimestamp = Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3;
   if (typeof v.freshUntil === "number" && v.freshUntil > maxTimestamp) {
     return false;
   }
+  if (typeof v.staleUntil === "number" && v.staleUntil > maxTimestamp) {
+    return false;
+  }
+  if (typeof v.errorUntil === "number" && v.errorUntil > maxTimestamp) {
+    return false;
+  }
+  if (v.freshUntil === null && (v.staleUntil !== null || v.errorUntil !== null)) {
+    return false;
+  }
+  if (typeof v.freshUntil === "number" && typeof v.staleUntil === "number" && v.staleUntil < v.freshUntil) {
+    return false;
+  }
+  if (typeof v.freshUntil === "number" && typeof v.errorUntil === "number" && v.errorUntil < v.freshUntil) {
+    return false;
+  }
+  const maxTtlSeconds = 10 * 365 * 24 * 60 * 60;
+  if (!isValidEnvelopeTtlSeconds(v.freshTtlSeconds, maxTtlSeconds)) {
+    return false;
+  }
+  if (!isValidEnvelopeTtlSeconds(v.staleWhileRevalidateSeconds, maxTtlSeconds)) {
+    return false;
+  }
+  if (!isValidEnvelopeTtlSeconds(v.staleIfErrorSeconds, maxTtlSeconds)) {
+    return false;
+  }
+  if (v.freshTtlSeconds == null && (v.staleWhileRevalidateSeconds != null || v.staleIfErrorSeconds != null)) {
+    return false;
+  }
   return true;
 }
 function unwrapStoredValue(stored) {
@@ -63,6 +91,12 @@ function unwrapStoredValue(stored) {
   }
   return stored.value ?? null;
 }
+function isValidEnvelopeTtlSeconds(value, maxTtlSeconds) {
+  if (value == null) {
+    return true;
+  }
+  return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= maxTtlSeconds;
+}
 
 // src/layers/MemoryLayer.ts
 var MemoryLayer = class {
@@ -180,6 +214,12 @@ var MemoryLayer = class {
     this.pruneExpired();
     return [...this.entries.keys()];
   }
+  async forEachKey(visitor) {
+    this.pruneExpired();
+    for (const key of this.entries.keys()) {
+      await visitor(key);
+    }
+  }
   exportState() {
     this.pruneExpired();
     return [...this.entries.entries()].map(([key, entry]) => ({
@@ -295,6 +335,7 @@ var PatternMatcher = class _PatternMatcher {
 };
 
 // src/invalidation/TagIndex.ts
+var MAX_PATTERN_RECURSION_DEPTH = 500;
 var TagIndex = class {
   tagToKeys = /* @__PURE__ */ new Map();
   keyToTags = /* @__PURE__ */ new Map();
@@ -335,6 +376,11 @@ var TagIndex = class {
   async keysForTag(tag) {
     return [...this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()];
   }
+  async forEachKeyForTag(tag, visitor) {
+    for (const key of this.tagToKeys.get(tag) ?? /* @__PURE__ */ new Set()) {
+      await visitor(key);
+    }
+  }
   async keysForPrefix(prefix) {
     const node = this.findNode(prefix);
     if (!node) {
@@ -344,14 +390,27 @@ var TagIndex = class {
     this.collectFromNode(node, prefix, matches);
     return matches;
   }
+  async forEachKeyForPrefix(prefix, visitor) {
+    const node = this.findNode(prefix);
+    if (!node) {
+      return;
+    }
+    await this.visitFromNode(node, prefix, visitor);
+  }
   async tagsForKey(key) {
     return [...this.keyToTags.get(key) ?? /* @__PURE__ */ new Set()];
   }
   async matchPattern(pattern) {
     const matches = /* @__PURE__ */ new Set();
-    this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set());
+    this.collectPatternMatches(this.root, "", pattern, 0, matches, /* @__PURE__ */ new Set(), 0);
     return [...matches];
   }
+  async forEachKeyMatchingPattern(pattern, visitor) {
+    const matches = await this.matchPattern(pattern);
+    for (const key of matches) {
+      await visitor(key);
+    }
+  }
   async clear() {
     this.tagToKeys.clear();
     this.keyToTags.clear();
@@ -401,7 +460,18 @@ var TagIndex = class {
       this.collectFromNode(child, `${prefix}${character}`, matches);
     }
   }
-  collectPatternMatches(node, prefix, pattern, patternIndex, matches, visited) {
+  async visitFromNode(node, prefix, visitor) {
+    if (node.terminal) {
+      await visitor(prefix);
+    }
+    for (const [character, child] of node.children) {
+      await this.visitFromNode(child, `${prefix}${character}`, visitor);
+    }
+  }
+  collectPatternMatches(node, prefix, pattern, patternIndex, matches, visited, depth) {
+    if (depth > MAX_PATTERN_RECURSION_DEPTH) {
+      return;
+    }
     const stateKey = `${node.id}:${patternIndex}`;
     if (visited.has(stateKey)) {
       return;
@@ -418,21 +488,37 @@ var TagIndex = class {
       return;
     }
     if (patternChar === "*") {
-      this.collectPatternMatches(node, prefix, pattern, patternIndex + 1, matches, visited);
+      this.collectPatternMatches(node, prefix, pattern, patternIndex + 1, matches, visited, depth + 1);
       for (const [character, child2] of node.children) {
-        this.collectPatternMatches(child2, `${prefix}${character}`, pattern, patternIndex, matches, visited);
+        this.collectPatternMatches(child2, `${prefix}${character}`, pattern, patternIndex, matches, visited, depth + 1);
       }
       return;
     }
     if (patternChar === "?") {
       for (const [character, child2] of node.children) {
-        this.collectPatternMatches(child2, `${prefix}${character}`, pattern, patternIndex + 1, matches, visited);
+        this.collectPatternMatches(
+          child2,
+          `${prefix}${character}`,
+          pattern,
+          patternIndex + 1,
+          matches,
+          visited,
+          depth + 1
+        );
       }
       return;
     }
     const child = node.children.get(patternChar);
     if (child) {
-      this.collectPatternMatches(child, `${prefix}${patternChar}`, pattern, patternIndex + 1, matches, visited);
+      this.collectPatternMatches(
+        child,
+        `${prefix}${patternChar}`,
+        pattern,
+        patternIndex + 1,
+        matches,
+        visited,
+        depth + 1
+      );
     }
   }
   pruneKnownKeysIfNeeded() {
@@ -506,14 +592,17 @@ function createHonoCacheMiddleware(cache, options = {}) {
       await next();
       return;
     }
+    if (!options.keyResolver && options.allowPrivateCaching !== true) {
+      await next();
+      return;
+    }
     const rawPath = context.req.path ?? context.req.url ?? "/";
     const key = options.keyResolver ? options.keyResolver(context.req) : `${method}:${normalizeUrl(rawPath)}`;
     const cached = await cache.get(key, void 0, options);
     if (cached !== null) {
       context.header?.("x-cache", "HIT");
       context.header?.("content-type", "application/json; charset=utf-8");
-      context.json(cached);
-      return;
+      return context.json(cached);
     }
     const originalJson = context.json.bind(context);
     context.json = (body, status) => {
@@ -533,7 +622,7 @@ function normalizeUrl(url) {
   try {
     const parsed = new URL(url, "http://localhost");
     parsed.searchParams.sort();
-    return decodeURIComponent(parsed.pathname) + parsed.search;
+    return parsed.pathname + parsed.search;
   } catch {
     return url;
   }

package/dist/edge.d.cts

@@ -1,2 +1,2 @@
-export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-Dw97n89L.cjs';
+export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-DLstcDMn.cjs';
 import 'node:events';

package/dist/edge.d.ts

@@ -1,2 +1,2 @@
-export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-Dw97n89L.js';
+export { e as CacheGetOptions, f as CacheLayer, h as CacheLayerSetManyEntry, t as CacheMetricsSnapshot, w as CacheRateLimitOptions, B as CacheTtlPolicy, D as CacheTtlPolicyContext, J as CacheWriteOptions, K as EvictionPolicy, M as MemoryLayer, N as MemoryLayerOptions, O as MemoryLayerSnapshotEntry, P as PatternMatcher, T as TagIndex, Q as createHonoCacheMiddleware } from './edge-DLstcDMn.js';
 import 'node:events';

package/dist/edge.js

@@ -2,10 +2,10 @@ import {
   MemoryLayer,
   TagIndex,
   createHonoCacheMiddleware
-} from "./chunk-KOYGHLVP.js";
+} from "./chunk-GJBKCFE6.js";
 import {
   PatternMatcher
-} from "./chunk-7V7XAB74.js";
+} from "./chunk-4PPBOOXT.js";
 export {
   MemoryLayer,
   PatternMatcher,