@tekir/cache 0.1.8 → 0.1.10

package/src/http-cache.ts

@@ -24,6 +24,7 @@
  */
 import { Cache } from "./cache"
 import type { CacheStore } from "./types"
+import { finalizeResponse, hasPendingResponseCookies } from "@tekir/core"
 
 export type HttpCacheOptions = {
   /**
@@ -85,7 +86,13 @@ export type HttpCacheOptions = {
 const CREDENTIAL_HEADERS = ["authorization", "cookie"]
 
 export type HttpCacheCtx = {
-  request: { url: string; method: string; headers: Headers; raw?: Request }
+  request: {
+    url: string
+    method: string
+    raw?: Request
+    header?: (name: string, defaultValue?: string) => string | undefined
+    headers: Headers
+  }
   params?: Record<string, string>
   query?: Record<string, string | string[]>
 }
@@ -93,7 +100,7 @@ export type HttpCacheCtx = {
 type CachedEntry = {
   status: number
   headers: Record<string, string>
-  body: string
+  bodyBase64: string
   etag: string
   storedAt: number
 }
@@ -146,14 +153,33 @@ const hash = (s: string): string => {
 }
 
 const defaultKey = (ctx: HttpCacheCtx, vary: string[]): string => {
-  const parts = [ctx.request.method, ctx.request.url]
+  let host = requestHeader(ctx.request, "host")
+  if (!host) {
+    try { host = new URL(ctx.request.url).host } catch {}
+  }
+  const parts = [ctx.request.method, host ? `host=${host.toLowerCase()}` : "", ctx.request.url]
   for (const h of vary) {
-    const v = ctx.request.headers.get(h)
+    const v = requestHeader(ctx.request, h)
     if (v) parts.push(`${h}=${v}`)
   }
   return parts.join("|")
 }
 
+const requestHeader = (req: HttpCacheCtx["request"], name: string): string | undefined => {
+  if (typeof req.header === "function") return req.header(name)
+  const rawValue = req.raw?.headers?.get(name)
+  if (rawValue != null) return rawValue
+  const headers: any = req.headers
+  if (headers && typeof headers !== "function" && typeof headers.get === "function") {
+    return headers.get(name) ?? undefined
+  }
+  if (typeof headers === "function") {
+    const values = headers()
+    return values[name.toLowerCase()] ?? values[name]
+  }
+  return undefined
+}
+
 const resolveStore = (
   s: HttpCacheOptions["store"] | null | undefined,
 ): CacheStore | null => {
@@ -164,15 +190,15 @@ const resolveStore = (
 }
 
 const responseToEntry = async (resp: Response): Promise<CachedEntry> => {
-  const body = await resp.clone().text()
+  const bodyBase64 = Buffer.from(await resp.clone().arrayBuffer()).toString("base64")
   const headers: Record<string, string> = {}
   resp.headers.forEach((v, k) => {
     // Skip hop-by-hop and connection-specific headers
     if (k === "connection" || k === "keep-alive" || k === "transfer-encoding") return
     headers[k] = v
   })
-  const etag = `W/"${hash(body)}"`
-  return { status: resp.status, headers, body, etag, storedAt: Date.now() }
+  const etag = `W/"${hash(bodyBase64)}"`
+  return { status: resp.status, headers, bodyBase64, etag, storedAt: Date.now() }
 }
 
 const entryToResponse = (e: CachedEntry, opts: HttpCacheOptions): Response => {
@@ -181,13 +207,16 @@ const entryToResponse = (e: CachedEntry, opts: HttpCacheOptions): Response => {
     headers["cache-control"] = `public, max-age=${opts.ttl ?? 60}`
   }
   headers["x-tekir-cache"] = "HIT"
-  return new Response(e.body, { status: e.status, headers })
+  const body = e.status === 204 || e.status === 205 || e.status === 304
+    ? null
+    : Buffer.from(e.bodyBase64, "base64")
+  return new Response(body, { status: e.status, headers })
 }
 
 /** True if the request carries an Authorization or Cookie header. */
 const hasCredentials = (req: HttpCacheCtx["request"]): boolean => {
   for (const h of CREDENTIAL_HEADERS) {
-    if (req.headers?.get?.(h)) return true
+    if (requestHeader(req, h)) return true
   }
   return false
 }
@@ -218,7 +247,7 @@ export function cache(opts: HttpCacheOptions = {}) {
       return
     }
 
-    const cacheControl = req.headers?.get?.("cache-control") ?? ""
+    const cacheControl = requestHeader(req, "cache-control") ?? ""
     if (cacheControl.includes("no-store")) {
       await next()
       return
@@ -247,7 +276,7 @@ export function cache(opts: HttpCacheOptions = {}) {
     const cached = await store.get<CachedEntry>(key)
 
     // Conditional request: client sent If-None-Match
-    const ifNoneMatch = req.headers?.get?.("if-none-match") ?? ""
+    const ifNoneMatch = requestHeader(req, "if-none-match") ?? ""
     if (cached) {
       if (ifNoneMatch && ifNoneMatch === cached.etag) {
         ctx.$result = new Response(null, {
@@ -262,12 +291,18 @@ export function cache(opts: HttpCacheOptions = {}) {
 
     // Miss: run the handler chain, capture, store.
     await next()
-    const result = ctx.$result
+    let result = ctx.$result
+    if (!(result instanceof Response) && result !== null && typeof result === "object" && typeof result.next !== "function") {
+      result = new Response(JSON.stringify(result), { headers: { "Content-Type": "application/json" } })
+    }
+    if (result instanceof Response && ctx.response) result = finalizeResponse(ctx.response, result)
+    if (result instanceof Response) ctx.$result = result
     if (!(result instanceof Response)) return
-    if (result.status >= 500 || result.status === 204) return // don't cache errors / empty
+    if (result.status >= 500 || result.status === 204 || result.status === 304) return
     if (cacheControl.includes("no-cache")) return
     const respCacheControl = result.headers.get("cache-control") ?? ""
     if (respCacheControl.includes("private") || respCacheControl.includes("no-store")) return
+    if (ctx.$willSetCookie || result.headers.has("set-cookie") || (ctx.response && hasPendingResponseCookies(ctx.response))) return
 
     const entry = await responseToEntry(result)
     await store.set(key, entry, ttl)
@@ -280,6 +315,9 @@ export function cache(opts: HttpCacheOptions = {}) {
       out["cache-control"] = `public, max-age=${ttl}`
     }
     out["x-tekir-cache"] = "MISS"
-    ctx.$result = new Response(entry.body, { status: result.status, headers: out })
+    const body = result.status === 204 || result.status === 205 || result.status === 304
+      ? null
+      : Buffer.from(entry.bodyBase64, "base64")
+    ctx.$result = new Response(body, { status: result.status, headers: out })
   }
 }

package/src/stores/database.ts

@@ -30,10 +30,19 @@ export class DatabaseCacheStore implements CacheStore {
     this.table = table
   }
 
+  private get driver(): string { return this.db.driver || 'sqlite' }
+  private get quotedTable(): string { return this.driver === 'mysql' ? `\`${this.table}\`` : `"${this.table}"` }
+  private sql(statement: string): string {
+    if (this.driver !== 'postgres') return statement
+    let index = 0
+    return statement.replace(/\?/g, () => `$${++index}`)
+  }
+
   private async _ensureTable() {
     if (this._ready) return
     try {
-      await this.db.exec(`CREATE TABLE IF NOT EXISTS "${this.table}" (key TEXT PRIMARY KEY, value TEXT, expires_at INTEGER)`)
+      const expiresType = this.driver === 'sqlite' ? 'INTEGER' : 'BIGINT'
+      await this.db.exec(`CREATE TABLE IF NOT EXISTS ${this.quotedTable} (key ${this.driver === 'mysql' ? 'VARCHAR(255)' : 'TEXT'} PRIMARY KEY, value TEXT, expires_at ${expiresType})`)
       this._ready = true
     } catch (e) {
       // Don't silently swallow: an unset _ready means every later get/set blows
@@ -52,10 +61,10 @@ export class DatabaseCacheStore implements CacheStore {
    */
   async get<T = any>(key: string): Promise<T | null> {
     await this._ensureTable()
-    const row = await this.db.queryOne(`SELECT value, expires_at FROM "${this.table}" WHERE key = ?`, [key]) as CacheDbRow | null
+    const row = await this.db.queryOne(this.sql(`SELECT value, expires_at FROM ${this.quotedTable} WHERE key = ?`), [key]) as CacheDbRow | null
     if (!row) return null
     if (row.expires_at && Date.now() > row.expires_at) {
-      await this.db.run(`DELETE FROM "${this.table}" WHERE key = ?`, [key])
+      await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE key = ?`), [key])
       return null
     }
     try { return JSON.parse(row.value) } catch { return row.value as T }
@@ -72,10 +81,10 @@ export class DatabaseCacheStore implements CacheStore {
     await this._ensureTable()
     const val = JSON.stringify(value)
     const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : null
-    await this.db.run(
-      `INSERT OR REPLACE INTO "${this.table}" (key, value, expires_at) VALUES (?, ?, ?)`,
-      [key, val, expiresAt]
-    )
+    const insert = this.driver === 'mysql'
+      ? `INSERT INTO ${this.quotedTable} (key, value, expires_at) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE value = VALUES(value), expires_at = VALUES(expires_at)`
+      : `INSERT INTO ${this.quotedTable} (key, value, expires_at) VALUES (?, ?, ?) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, expires_at = EXCLUDED.expires_at`
+    await this.db.run(this.sql(insert), [key, val, expiresAt])
   }
 
   /**
@@ -86,10 +95,10 @@ export class DatabaseCacheStore implements CacheStore {
    */
   async has(key: string): Promise<boolean> {
     await this._ensureTable()
-    const row = await this.db.queryOne(`SELECT expires_at FROM "${this.table}" WHERE key = ?`, [key]) as { expires_at: number | null } | null
+    const row = await this.db.queryOne(this.sql(`SELECT expires_at FROM ${this.quotedTable} WHERE key = ?`), [key]) as { expires_at: number | null } | null
     if (!row) return false
     if (row.expires_at && Date.now() > row.expires_at) {
-      await this.db.run(`DELETE FROM "${this.table}" WHERE key = ?`, [key])
+      await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE key = ?`), [key])
       return false
     }
     // Present even if the stored value is `null` (negative caching).
@@ -104,7 +113,7 @@ export class DatabaseCacheStore implements CacheStore {
    */
   async delete(key: string): Promise<boolean> {
     await this._ensureTable()
-    await this.db.run(`DELETE FROM "${this.table}" WHERE key = ?`, [key])
+    await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE key = ?`), [key])
     return true
   }
 
@@ -116,7 +125,7 @@ export class DatabaseCacheStore implements CacheStore {
    */
   async prune(): Promise<void> {
     await this._ensureTable()
-    await this.db.run(`DELETE FROM "${this.table}" WHERE expires_at IS NOT NULL AND expires_at < ?`, [Date.now()])
+    await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE expires_at IS NOT NULL AND expires_at < ?`), [Date.now()])
   }
 
   /**
@@ -129,6 +138,6 @@ export class DatabaseCacheStore implements CacheStore {
    */
   async flush(): Promise<void> {
     await this._ensureTable()
-    await this.db.run(`DELETE FROM "${this.table}"`)
+    await this.db.run(`DELETE FROM ${this.quotedTable}`)
   }
 }

package/dist/cache.js

@@ -1,151 +0,0 @@
-import { MemoryCacheStore } from './stores/memory';
-/**
- * Multi-store cache manager that delegates to configured {@link CacheStore}
- * implementations. Supports named stores, a default TTL, and convenience
- * methods like {@link getOrSet} and {@link pull}.
- *
- * @example
- * ```ts
- * const cache = new Cache({ stores: { memory: new MemoryCacheStore() }, ttl: 60 })
- * await cache.set('key', 'value')
- * const val = await cache.get<string>('key')
- * ```
- */
-export class Cache {
-    stores;
-    defaultStore;
-    defaultTtl;
-    // In-flight factory promises keyed by `<store>:<key>` for single-flight
-    // stampede protection in getOrSet.
-    inFlight = new Map();
-    /**
-     * Create a new Cache instance.
-     *
-     * @param config - Cache configuration including stores, default store name, and TTL.
-     */
-    constructor(config = {}) {
-        this.stores = config.stores || { memory: new MemoryCacheStore() };
-        this.defaultStore = config.default || Object.keys(this.stores)[0];
-        this.defaultTtl = config.ttl || 3600;
-    }
-    /**
-     * Retrieve a specific named store, or the default store if no name is given.
-     *
-     * @param name - The store name. Omit to use the default store.
-     * @returns The resolved {@link CacheStore} instance.
-     * @throws Error if the requested store is not configured.
-     *
-     * @example
-     * ```ts
-     * const redis = cache.store('redis')
-     * await redis.get('key')
-     * ```
-     */
-    store(name) {
-        const storeName = name || this.defaultStore;
-        const s = this.stores[storeName];
-        if (!s)
-            throw new Error(`Cache store "${storeName}" not configured`);
-        return s;
-    }
-    /**
-     * Get a value from the default store.
-     *
-     * @param key - The cache key.
-     * @returns The cached value, or `null` if not found or expired.
-     */
-    async get(key) { return this.store().get(key); }
-    /**
-     * Set a value in the default store.
-     *
-     * @param key - The cache key.
-     * @param value - The value to store.
-     * @param ttl - Time-to-live in seconds. Falls back to the default TTL.
-     */
-    async set(key, value, ttl) { return this.store().set(key, value, ttl ?? this.defaultTtl); }
-    /**
-     * Check whether a key exists (and is not expired) in the default store.
-     *
-     * @param key - The cache key.
-     * @returns `true` if the key exists.
-     */
-    async has(key) { return this.store().has(key); }
-    /**
-     * Delete a key from the default store.
-     *
-     * @param key - The cache key.
-     * @returns `true` if the key was deleted.
-     */
-    async delete(key) { return this.store().delete(key); }
-    /**
-     * Flush all entries from the default store.
-     */
-    async flush() { return this.store().flush(); }
-    /**
-     * Get a cached value or compute and store it if missing. Inspired by AdonisJS.
-     *
-     * @param key - The cache key.
-     * @param ttl - Time-to-live in seconds for the computed value.
-     * @param factory - An async function that produces the value when not cached.
-     * @returns The cached or freshly-computed value.
-     *
-     * Concurrent misses for the same key share a single `factory()` execution
-     * (single-flight) so a popular key expiring does not trigger a stampede
-     * (thundering herd) against the backend.
-     *
-     * @example
-     * ```ts
-     * const users = await cache.getOrSet('users', 300, () => db.query('SELECT * FROM users'))
-     * ```
-     */
-    async getOrSet(key, ttl, factory) {
-        const cached = await this.get(key);
-        if (cached !== null)
-            return cached;
-        const flightKey = `${this.defaultStore}:${key}`;
-        const existing = this.inFlight.get(flightKey);
-        if (existing)
-            return existing;
-        const promise = (async () => {
-            const value = await factory();
-            await this.set(key, value, ttl);
-            return value;
-        })().finally(() => this.inFlight.delete(flightKey));
-        this.inFlight.set(flightKey, promise);
-        return promise;
-    }
-    /**
-     * Get a value and immediately delete it from the cache (atomic get-and-remove).
-     *
-     * @param key - The cache key.
-     * @returns The cached value, or `null` if not found.
-     *
-     * @example
-     * ```ts
-     * const token = await cache.pull<string>('one-time-token')
-     * ```
-     */
-    async pull(key) {
-        const value = await this.get(key);
-        // Use has() rather than a null-check so that an explicitly cached `null`
-        // value is still evicted (get() alone cannot distinguish "absent" from
-        // "stored null").
-        if (value !== null || (await this.has(key)))
-            await this.delete(key);
-        return value;
-    }
-}
-/**
- * Create a new {@link Cache} instance with the given configuration.
- *
- * @param config - Optional cache configuration.
- * @returns A new Cache instance.
- *
- * @example
- * ```ts
- * const cache = createCache({ ttl: 120 })
- * ```
- */
-export function createCache(config) {
-    return new Cache(config);
-}

package/dist/http-cache.js

@@ -1,198 +0,0 @@
-/**
- * HTTP response cache middleware.
- *
- * Caches the full Response (status + headers + body) under a key derived
- * from the request. On hit: short-circuits the handler chain and returns
- * the cached payload, also producing `304 Not Modified` when the client
- * sends a matching `If-None-Match`.
- *
- * Storage is delegated to any `CacheStore` (memory, redis, database).
- * Only safe methods (GET, HEAD) are cached by default.
- *
- * @example
- * ```ts
- * import { Cache, cache, MemoryCacheStore } from '@tekir/cache'
- *
- * const store = new Cache({ stores: { memory: new MemoryCacheStore() } })
- *
- * router.get(
- *   '/api/posts',
- *   cache({ store, ttl: 60 }),
- *   async () => Post.all(),
- * )
- * ```
- */
-import { Cache } from "./cache";
-/** Request headers that indicate a credentialed/per-user request. */
-const CREDENTIAL_HEADERS = ["authorization", "cookie"];
-const SAFE_METHODS = ["GET", "HEAD"];
-const isStore = (s) => !!s &&
-    typeof s.get === "function" &&
-    typeof s.set === "function";
-/**
- * Module-level default store. CacheProvider sets this at register time so
- * `cache({ ttl: 60 })` works without an explicit `store` option once the
- * provider is wired into the app. Stays null if the provider isn't used,
- * in which case the middleware no-ops (passes through).
- */
-let _defaultStore = null;
-/**
- * Register the default backing store for the `cache()` middleware. Called
- * by `CacheProvider` after it builds the Cache manager from config.
- *
- * Users can also call this directly if they don't use providers:
- *
- * ```ts
- * import { setDefaultCacheStore, Cache, MemoryCacheStore } from '@tekir/cache'
- * setDefaultCacheStore(new Cache({ stores: { memory: new MemoryCacheStore() } }))
- * ```
- */
-export function setDefaultCacheStore(s) {
-    _defaultStore = s;
-}
-/**
- * Returns the currently registered default store, or null if none.
- */
-export function getDefaultCacheStore() {
-    return _defaultStore;
-}
-const hash = (s) => {
-    // FNV-1a 32-bit. Good enough for ETags; not crypto.
-    let h = 0x811c9dc5;
-    for (let i = 0; i < s.length; i++) {
-        h ^= s.charCodeAt(i);
-        h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
-    }
-    return h.toString(16).padStart(8, "0");
-};
-const defaultKey = (ctx, vary) => {
-    const parts = [ctx.request.method, ctx.request.url];
-    for (const h of vary) {
-        const v = ctx.request.headers.get(h);
-        if (v)
-            parts.push(`${h}=${v}`);
-    }
-    return parts.join("|");
-};
-const resolveStore = (s) => {
-    if (!s)
-        return null;
-    if (s instanceof Cache)
-        return s.store();
-    if (isStore(s))
-        return s;
-    return null;
-};
-const responseToEntry = async (resp) => {
-    const body = await resp.clone().text();
-    const headers = {};
-    resp.headers.forEach((v, k) => {
-        // Skip hop-by-hop and connection-specific headers
-        if (k === "connection" || k === "keep-alive" || k === "transfer-encoding")
-            return;
-        headers[k] = v;
-    });
-    const etag = `W/"${hash(body)}"`;
-    return { status: resp.status, headers, body, etag, storedAt: Date.now() };
-};
-const entryToResponse = (e, opts) => {
-    const headers = { ...e.headers, etag: e.etag };
-    if (opts.setCacheControl !== false && !headers["cache-control"]) {
-        headers["cache-control"] = `public, max-age=${opts.ttl ?? 60}`;
-    }
-    headers["x-tekir-cache"] = "HIT";
-    return new Response(e.body, { status: e.status, headers });
-};
-/** True if the request carries an Authorization or Cookie header. */
-const hasCredentials = (req) => {
-    for (const h of CREDENTIAL_HEADERS) {
-        if (req.headers?.get?.(h))
-            return true;
-    }
-    return false;
-};
-export function cache(opts = {}) {
-    const ttl = opts.ttl ?? 60;
-    const methods = new Set((opts.methods ?? SAFE_METHODS).map((m) => m.toUpperCase()));
-    const vary = opts.vary ?? [];
-    const prefix = opts.prefix ?? "http:";
-    const hasCustomKey = typeof opts.key === "function";
-    const authMode = opts.authenticated ?? "bypass";
-    // When varying by credentials, fold the credential headers into the key so
-    // each identity gets a private entry.
-    const effectiveVary = authMode === "vary" ? [...vary, ...CREDENTIAL_HEADERS] : vary;
-    const buildKey = opts.key ?? ((ctx) => defaultKey(ctx, effectiveVary));
-    const directStore = resolveStore(opts.store);
-    return async function cacheMiddleware(ctx, next) {
-        const req = ctx.request;
-        if (!req || !methods.has(String(req.method ?? "GET").toUpperCase())) {
-            await next();
-            return;
-        }
-        if (opts.skip && (await opts.skip(ctx))) {
-            await next();
-            return;
-        }
-        const cacheControl = req.headers?.get?.("cache-control") ?? "";
-        if (cacheControl.includes("no-store")) {
-            await next();
-            return;
-        }
-        // Secure-by-default: a credentialed (Authorization/Cookie) request usually
-        // produces a per-user response. Caching it under a shared key would leak it
-        // to other users. Unless the caller opted into 'vary'/'allow' or supplied a
-        // custom identity-aware key, bypass the cache for such requests.
-        if (authMode === "bypass" && !hasCustomKey && hasCredentials(req)) {
-            await next();
-            return;
-        }
-        // Resolve store: option > module-level default (set by CacheProvider).
-        // No store anywhere → middleware acts as a transparent no-op so the
-        // route still works without a registered cache backend.
-        let store = directStore;
-        if (!store)
-            store = resolveStore(_defaultStore);
-        if (!store) {
-            await next();
-            return;
-        }
-        const key = prefix + buildKey(ctx);
-        const cached = await store.get(key);
-        // Conditional request: client sent If-None-Match
-        const ifNoneMatch = req.headers?.get?.("if-none-match") ?? "";
-        if (cached) {
-            if (ifNoneMatch && ifNoneMatch === cached.etag) {
-                ctx.$result = new Response(null, {
-                    status: 304,
-                    headers: { etag: cached.etag, "x-tekir-cache": "REVALIDATED" },
-                });
-                return;
-            }
-            ctx.$result = entryToResponse(cached, opts);
-            return;
-        }
-        // Miss: run the handler chain, capture, store.
-        await next();
-        const result = ctx.$result;
-        if (!(result instanceof Response))
-            return;
-        if (result.status >= 500 || result.status === 204)
-            return; // don't cache errors / empty
-        if (cacheControl.includes("no-cache"))
-            return;
-        const respCacheControl = result.headers.get("cache-control") ?? "";
-        if (respCacheControl.includes("private") || respCacheControl.includes("no-store"))
-            return;
-        const entry = await responseToEntry(result);
-        await store.set(key, entry, ttl);
-        // Re-emit with x-tekir-cache: MISS so the client can see it
-        const out = {};
-        result.headers.forEach((v, k) => (out[k] = v));
-        out["etag"] = entry.etag;
-        if (opts.setCacheControl !== false && !out["cache-control"]) {
-            out["cache-control"] = `public, max-age=${ttl}`;
-        }
-        out["x-tekir-cache"] = "MISS";
-        ctx.$result = new Response(entry.body, { status: result.status, headers: out });
-    };
-}

package/dist/provider.js

@@ -1,94 +0,0 @@
-import { Cache } from './cache';
-import { MemoryCacheStore } from './stores/memory';
-/**
- * Service provider that registers a {@link Cache} instance into the application
- * container. Reads the `cache` configuration to create stores for each configured
- * driver (`memory`, `redis`, or `database`).
- *
- * @example
- * ```ts
- * // In your kernel:
- * app.register(new CacheProvider())
- * ```
- */
-export class CacheProvider {
-    /**
-     * Register the cache service with the application. Reads `cache.stores`,
-     * `cache.ttl`, and `cache.default` from the application config.
-     *
-     * @param app - The application instance.
-     */
-    async register(app) {
-        const config = app.use('config');
-        if (!config('cache'))
-            return;
-        const storesConfig = config('cache.stores', {});
-        const stores = {};
-        for (const [name, storeConfig] of Object.entries(storesConfig)) {
-            // Already a CacheStore instance (backwards compat)
-            if (storeConfig && typeof storeConfig.get === 'function') {
-                stores[name] = storeConfig;
-                continue;
-            }
-            const driver = storeConfig?.driver || name;
-            if (driver === 'memory') {
-                stores[name] = new MemoryCacheStore();
-            }
-            else if (driver === 'redis') {
-                let redis;
-                try {
-                    redis = app.use('redis');
-                }
-                catch { }
-                if (!redis) {
-                    // Fallback: create instance from config
-                    let Redis;
-                    try {
-                        // @ts-ignore optional peer; resolved at runtime, falls through
-                        // to the catch below if not installed.
-                        Redis = (await import('@tekir/redis')).Redis;
-                    }
-                    catch {
-                        throw new Error(`[@tekir/cache] Store "${name}" uses the redis driver but @tekir/redis is not installed. ` +
-                            'Run: bun add @tekir/redis and register RedisProvider before CacheProvider.');
-                    }
-                    redis = new Redis({ ...config('redis', {}), ...storeConfig });
-                }
-                const { RedisCacheStore } = await import('./stores/redis');
-                stores[name] = new RedisCacheStore(redis, storeConfig?.prefix);
-            }
-            else if (driver === 'database') {
-                let db;
-                try {
-                    db = app.use('db');
-                }
-                catch { }
-                if (!db) {
-                    throw new Error(`[@tekir/cache] Store "${name}" uses the database driver but no database service is registered. ` +
-                        'Add DatabaseProvider to your kernel before CacheProvider.');
-                }
-                const { DatabaseCacheStore } = await import('./stores/database');
-                stores[name] = new DatabaseCacheStore(db, storeConfig?.table);
-            }
-            else {
-                throw new Error(`[@tekir/cache] Unknown cache driver "${driver}" for store "${name}". ` +
-                    'Supported drivers: memory, redis, database');
-            }
-        }
-        // Fallback to memory if no stores configured
-        if (Object.keys(stores).length === 0) {
-            stores.memory = new MemoryCacheStore();
-        }
-        const cacheInstance = new Cache({
-            stores,
-            ttl: config('cache.ttl', 60),
-            default: config('cache.default', Object.keys(stores)[0]),
-        });
-        app.instance('cache', cacheInstance);
-        // Wire the cache() HTTP middleware so route-level `cache({ ttl: 60 })`
-        // works without an explicit `store` option once this provider is
-        // registered.
-        const { setDefaultCacheStore } = await import('./http-cache');
-        setDefaultCacheStore(cacheInstance);
-    }
-}