@tekir/cache 0.1.9 → 0.1.10

package/dist/http-cache.d.ts

@@ -83,8 +83,9 @@ export type HttpCacheCtx = {
     request: {
         url: string;
         method: string;
-        headers: Headers;
         raw?: Request;
+        header?: (name: string, defaultValue?: string) => string | undefined;
+        headers: Headers;
     };
     params?: Record<string, string>;
     query?: Record<string, string | string[]>;

package/dist/index.js

@@ -1,6 +1,538 @@
-export { MemoryCacheStore } from './stores/memory';
-export { RedisCacheStore } from './stores/redis';
-export { DatabaseCacheStore } from './stores/database';
-export { Cache, createCache } from './cache';
-export { CacheProvider } from './provider';
-export { cache, setDefaultCacheStore, getDefaultCacheStore } from './http-cache';
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/stores/memory.ts
+class MemoryCacheStore {
+  data = new Map;
+  maxEntries;
+  writes = 0;
+  constructor(options = {}) {
+    this.maxEntries = options.maxEntries ?? 1e4;
+  }
+  prune() {
+    const now = Date.now();
+    for (const [k, entry] of this.data) {
+      if (entry.expiresAt && now > entry.expiresAt)
+        this.data.delete(k);
+    }
+  }
+  async get(key) {
+    const entry = this.data.get(key);
+    if (!entry)
+      return null;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.data.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttlSeconds) {
+    this.data.set(key, {
+      value,
+      expiresAt: ttlSeconds ? Date.now() + ttlSeconds * 1000 : null
+    });
+    if (this.maxEntries > 0) {
+      if (++this.writes % 256 === 0)
+        this.prune();
+      while (this.data.size > this.maxEntries) {
+        const oldest = this.data.keys().next().value;
+        if (oldest === undefined)
+          break;
+        this.data.delete(oldest);
+      }
+    }
+  }
+  async has(key) {
+    const entry = this.data.get(key);
+    if (!entry)
+      return false;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.data.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async delete(key) {
+    return this.data.delete(key);
+  }
+  async flush() {
+    this.data.clear();
+  }
+}
+
+// src/stores/redis.ts
+var exports_redis = {};
+__export(exports_redis, {
+  RedisCacheStore: () => RedisCacheStore
+});
+
+class RedisCacheStore {
+  redis;
+  prefix;
+  constructor(redis, prefix = "cache:") {
+    this.redis = redis;
+    this.prefix = prefix;
+  }
+  async get(key) {
+    const val = await this.redis.get(this.prefix + key);
+    if (val === null)
+      return null;
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    const val = JSON.stringify(value);
+    const fullKey = this.prefix + key;
+    if (ttlSeconds) {
+      const sendable = this.redis;
+      if (typeof sendable.send === "function") {
+        await sendable.send("SET", [fullKey, val, "EX", String(Math.floor(ttlSeconds))]);
+      } else {
+        await this.redis.set(fullKey, val);
+        await this.redis.expire(fullKey, ttlSeconds);
+      }
+    } else {
+      await this.redis.set(fullKey, val);
+    }
+  }
+  async has(key) {
+    return !!await this.redis.exists(this.prefix + key);
+  }
+  async delete(key) {
+    await this.redis.del(this.prefix + key);
+    return true;
+  }
+  async flush() {
+    if (!this.prefix) {
+      throw new Error("[@tekir/cache] RedisCacheStore.flush() refused: an empty prefix would delete every key in the database. Configure a non-empty prefix.");
+    }
+    const client = this.redis;
+    const pattern = `${this.prefix}*`;
+    let cursor = "0";
+    do {
+      const reply = await client.send("SCAN", [cursor, "MATCH", pattern, "COUNT", "100"]);
+      const [next, batch] = reply;
+      cursor = next;
+      if (batch && batch.length)
+        await client.send("DEL", batch);
+    } while (cursor !== "0");
+  }
+}
+
+// src/stores/database.ts
+var exports_database = {};
+__export(exports_database, {
+  DatabaseCacheStore: () => DatabaseCacheStore
+});
+
+class DatabaseCacheStore {
+  db;
+  table;
+  _ready = false;
+  constructor(db, table = "cache") {
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table))
+      throw new Error(`Invalid table name: "${table}"`);
+    this.db = db;
+    this.table = table;
+  }
+  get driver() {
+    return this.db.driver || "sqlite";
+  }
+  get quotedTable() {
+    return this.driver === "mysql" ? `\`${this.table}\`` : `"${this.table}"`;
+  }
+  sql(statement) {
+    if (this.driver !== "postgres")
+      return statement;
+    let index = 0;
+    return statement.replace(/\?/g, () => `$${++index}`);
+  }
+  async _ensureTable() {
+    if (this._ready)
+      return;
+    try {
+      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) {
+      console.error(`[@tekir/cache] Failed to create cache table "${this.table}": ${e.message}`);
+      throw e;
+    }
+  }
+  async get(key) {
+    await this._ensureTable();
+    const row = await this.db.queryOne(this.sql(`SELECT value, expires_at FROM ${this.quotedTable} WHERE key = ?`), [key]);
+    if (!row)
+      return null;
+    if (row.expires_at && Date.now() > row.expires_at) {
+      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;
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    await this._ensureTable();
+    const val = JSON.stringify(value);
+    const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : null;
+    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]);
+  }
+  async has(key) {
+    await this._ensureTable();
+    const row = await this.db.queryOne(this.sql(`SELECT expires_at FROM ${this.quotedTable} WHERE key = ?`), [key]);
+    if (!row)
+      return false;
+    if (row.expires_at && Date.now() > row.expires_at) {
+      await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE key = ?`), [key]);
+      return false;
+    }
+    return true;
+  }
+  async delete(key) {
+    await this._ensureTable();
+    await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE key = ?`), [key]);
+    return true;
+  }
+  async prune() {
+    await this._ensureTable();
+    await this.db.run(this.sql(`DELETE FROM ${this.quotedTable} WHERE expires_at IS NOT NULL AND expires_at < ?`), [Date.now()]);
+  }
+  async flush() {
+    await this._ensureTable();
+    await this.db.run(`DELETE FROM ${this.quotedTable}`);
+  }
+}
+
+// src/cache.ts
+class Cache {
+  stores;
+  defaultStore;
+  defaultTtl;
+  inFlight = new Map;
+  constructor(config = {}) {
+    this.stores = config.stores || { memory: new MemoryCacheStore };
+    this.defaultStore = config.default || Object.keys(this.stores)[0];
+    this.defaultTtl = config.ttl || 3600;
+  }
+  store(name) {
+    const storeName = name || this.defaultStore;
+    const s = this.stores[storeName];
+    if (!s)
+      throw new Error(`Cache store "${storeName}" not configured`);
+    return s;
+  }
+  async get(key) {
+    return this.store().get(key);
+  }
+  async set(key, value, ttl) {
+    return this.store().set(key, value, ttl ?? this.defaultTtl);
+  }
+  async has(key) {
+    return this.store().has(key);
+  }
+  async delete(key) {
+    return this.store().delete(key);
+  }
+  async flush() {
+    return this.store().flush();
+  }
+  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;
+  }
+  async pull(key) {
+    const value = await this.get(key);
+    if (value !== null || await this.has(key))
+      await this.delete(key);
+    return value;
+  }
+}
+function createCache(config) {
+  return new Cache(config);
+}
+var init_cache = () => {};
+
+// src/http-cache.ts
+var exports_http_cache = {};
+__export(exports_http_cache, {
+  setDefaultCacheStore: () => setDefaultCacheStore,
+  getDefaultCacheStore: () => getDefaultCacheStore,
+  cache: () => cache
+});
+import { finalizeResponse, hasPendingResponseCookies } from "@tekir/core";
+function setDefaultCacheStore(s) {
+  _defaultStore = s;
+}
+function getDefaultCacheStore() {
+  return _defaultStore;
+}
+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";
+  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 = requestHeader(req, "cache-control") ?? "";
+    if (cacheControl.includes("no-store")) {
+      await next();
+      return;
+    }
+    if (authMode === "bypass" && !hasCustomKey && hasCredentials(req)) {
+      await next();
+      return;
+    }
+    let store = directStore;
+    if (!store)
+      store = resolveStore(_defaultStore);
+    if (!store) {
+      await next();
+      return;
+    }
+    const key = prefix + buildKey(ctx);
+    const cached = await store.get(key);
+    const ifNoneMatch = requestHeader(req, "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;
+    }
+    await next();
+    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 || 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);
+    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";
+    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 });
+  };
+}
+var CREDENTIAL_HEADERS, SAFE_METHODS, isStore = (s) => !!s && typeof s.get === "function" && typeof s.set === "function", _defaultStore = null, hash = (s) => {
+  let h = 2166136261;
+  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");
+}, defaultKey = (ctx, vary) => {
+  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 = requestHeader(ctx.request, h);
+    if (v)
+      parts.push(`${h}=${v}`);
+  }
+  return parts.join("|");
+}, requestHeader = (req, name) => {
+  if (typeof req.header === "function")
+    return req.header(name);
+  const rawValue = req.raw?.headers?.get(name);
+  if (rawValue != null)
+    return rawValue;
+  const headers = 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;
+}, resolveStore = (s) => {
+  if (!s)
+    return null;
+  if (s instanceof Cache)
+    return s.store();
+  if (isStore(s))
+    return s;
+  return null;
+}, responseToEntry = async (resp) => {
+  const bodyBase64 = Buffer.from(await resp.clone().arrayBuffer()).toString("base64");
+  const headers = {};
+  resp.headers.forEach((v, k) => {
+    if (k === "connection" || k === "keep-alive" || k === "transfer-encoding")
+      return;
+    headers[k] = v;
+  });
+  const etag = `W/"${hash(bodyBase64)}"`;
+  return { status: resp.status, headers, bodyBase64, etag, storedAt: Date.now() };
+}, 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";
+  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 });
+}, hasCredentials = (req) => {
+  for (const h of CREDENTIAL_HEADERS) {
+    if (requestHeader(req, h))
+      return true;
+  }
+  return false;
+};
+var init_http_cache = __esm(() => {
+  init_cache();
+  CREDENTIAL_HEADERS = ["authorization", "cookie"];
+  SAFE_METHODS = ["GET", "HEAD"];
+});
+
+// src/index.ts
+init_cache();
+
+// src/provider.ts
+init_cache();
+
+class CacheProvider {
+  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)) {
+      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) {
+          let Redis;
+          try {
+            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: RedisCacheStore2 } = await Promise.resolve().then(() => exports_redis);
+        stores[name] = new RedisCacheStore2(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: DatabaseCacheStore2 } = await Promise.resolve().then(() => exports_database);
+        stores[name] = new DatabaseCacheStore2(db, storeConfig?.table);
+      } else {
+        throw new Error(`[@tekir/cache] Unknown cache driver "${driver}" for store "${name}". Supported drivers: memory, redis, database`);
+      }
+    }
+    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);
+    const { setDefaultCacheStore: setDefaultCacheStore2 } = await Promise.resolve().then(() => (init_http_cache(), exports_http_cache));
+    setDefaultCacheStore2(cacheInstance);
+  }
+}
+
+// src/index.ts
+init_http_cache();
+export {
+  setDefaultCacheStore,
+  getDefaultCacheStore,
+  createCache,
+  cache,
+  RedisCacheStore,
+  MemoryCacheStore,
+  DatabaseCacheStore,
+  CacheProvider,
+  Cache
+};

package/dist/stores/database.d.ts

@@ -21,6 +21,9 @@ export declare class DatabaseCacheStore implements CacheStore {
      * @throws Error if the table name contains invalid characters.
      */
     constructor(db: any, table?: string);
+    private get driver();
+    private get quotedTable();
+    private sql;
     private _ensureTable;
     /**
      * Retrieve a cached value by key. Expired entries are deleted and `null` is returned.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekir/cache",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "In-memory, Redis, and database caching abstraction",
   "author": "dev@tekir.io",
   "license": "MIT",
@@ -50,7 +50,7 @@
     }
   },
   "scripts": {
-    "build": "rm -rf dist && tsc --noEmit false",
+    "build": "bun ../../scripts/build-package.ts",
     "prepublishOnly": "bun run build"
   },
   "exports": {