@lastshotlabs/bunshot 0.0.27 → 0.1.0

package/dist/src/framework/middleware/cacheResponse.d.ts

@@ -0,0 +1,35 @@
+import type { MiddlewareHandler } from 'hono';
+import type { Connection } from 'mongoose';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+import type { CacheStoreName } from '../../../packages/bunshot-core/src/index.js';
+interface CacheDoc {
+    key: string;
+    value: string;
+    expiresAt?: Date;
+}
+/**
+ * Get or create the Mongoose CacheEntry model on the given connection.
+ * Accepts connection and mongoose module as parameters — no module-level state.
+ */
+export declare function getCacheModel(conn?: Connection): import('mongoose').Model<CacheDoc>;
+type CacheStore = CacheStoreName;
+/**
+ * Delete a cached entry by exact key across ALL cache backends.
+ *
+ * Requires an app reference so cache invalidation uses the correct instance-owned adapters.
+ */
+export declare const bustCache: (key: string, app: object) => Promise<void>;
+/**
+ * Delete cached entries matching a glob pattern across ALL cache backends.
+ *
+ * Same defense-in-depth rationale as `bustCache` — see comment above.
+ */
+export declare const bustCachePattern: (pattern: string, app: object) => Promise<void>;
+type KeyFn = (c: Parameters<MiddlewareHandler<any>>[0]) => string;
+interface CacheOptions {
+    ttl?: number;
+    key: string | KeyFn;
+    store?: CacheStore;
+}
+export declare const cacheResponse: ({ ttl, key, store: storeOverride, }: CacheOptions) => MiddlewareHandler<AppEnv>;
+export {};

package/dist/src/framework/middleware/cacheResponse.js

@@ -0,0 +1,126 @@
+import { getMongooseModule } from '../../lib/mongo';
+import { getBunshotCtx, getCacheAdapter, getCacheAdapterOrNull } from '../../../packages/bunshot-core/src/index.js';
+/**
+ * Get or create the Mongoose CacheEntry model on the given connection.
+ * Accepts connection and mongoose module as parameters — no module-level state.
+ */
+export function getCacheModel(conn) {
+    // When called without args (from registerBoundaryAdapters), the model
+    // must already be registered on the connection from a prior call.
+    // This is a lazy model that gets created on first use with a connection.
+    if (!conn) {
+        // Fallback: the model must have been registered already on some connection.
+        // This path is only hit from registerBoundaryAdapters where appConnection is passed
+        // through the closure. We need to accept the connection as parameter.
+        throw new Error('getCacheModel requires a connection parameter');
+    }
+    if (conn.models['CacheEntry'])
+        return conn.models['CacheEntry'];
+    const mg = getMongooseModule();
+    const { Schema } = mg;
+    const cacheSchema = new Schema({
+        key: { type: String, required: true, unique: true },
+        value: { type: String, required: true },
+        expiresAt: { type: Date, index: { expireAfterSeconds: 0 } },
+    }, { collection: 'cache_entries' });
+    return conn.model('CacheEntry', cacheSchema);
+}
+async function storeGet(ctx, store, cacheKey) {
+    const adapter = getCacheAdapter(ctx, store);
+    if (!adapter.isReady()) {
+        throw new Error(`cacheResponse: store "${store}" is not ready.`);
+    }
+    return adapter.get(cacheKey);
+}
+async function storeSet(ctx, store, cacheKey, value, ttl) {
+    const adapter = getCacheAdapter(ctx, store);
+    if (!adapter.isReady()) {
+        throw new Error(`cacheResponse: store "${store}" is not ready.`);
+    }
+    await adapter.set(cacheKey, value, ttl);
+}
+async function storeDel(app, store, cacheKey) {
+    const adapter = getCacheAdapterOrNull(app, store);
+    if (!adapter?.isReady())
+        return;
+    await adapter.del(cacheKey);
+}
+async function storeDelPattern(app, store, fullPattern) {
+    const adapter = getCacheAdapterOrNull(app, store);
+    if (!adapter?.isReady())
+        return;
+    await adapter.delPattern(fullPattern);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Delete a cached entry by exact key across ALL cache backends.
+ *
+ * Requires an app reference so cache invalidation uses the correct instance-owned adapters.
+ */
+export const bustCache = async (key, app) => {
+    const { getContext } = await import('../../../packages/bunshot-core/src/index.js');
+    const ctx = getContext(app);
+    const appName = ctx.config.appName;
+    const cacheKey = `cache:${appName}:${key}`;
+    const stores = [...ctx.cacheAdapters.keys()];
+    await Promise.all(stores.map(store => storeDel(app, store, cacheKey)));
+};
+/**
+ * Delete cached entries matching a glob pattern across ALL cache backends.
+ *
+ * Same defense-in-depth rationale as `bustCache` — see comment above.
+ */
+export const bustCachePattern = async (pattern, app) => {
+    const { getContext } = await import('../../../packages/bunshot-core/src/index.js');
+    const ctx = getContext(app);
+    const appName = ctx.config.appName;
+    const fullPattern = `cache:${appName}:${pattern}`;
+    const stores = [...ctx.cacheAdapters.keys()];
+    await Promise.all(stores.map(store => storeDelPattern(app, store, fullPattern)));
+};
+/** Headers that must never be cached — storing these can cause session fixation or auth bypass. */
+const UNCACHEABLE_HEADERS = new Set([
+    'set-cookie',
+    'www-authenticate',
+    'authorization',
+    'x-csrf-token',
+    'proxy-authenticate',
+]);
+export const cacheResponse = ({ ttl, key, store: storeOverride, }) => {
+    return async (c, next) => {
+        const ctx = getBunshotCtx(c);
+        const store = storeOverride ?? ctx.config.resolvedStores.cache ?? 'redis';
+        const appName = ctx.config.appName;
+        const rawKey = typeof key === 'function' ? key(c) : key;
+        // Per-tenant namespacing: prevents two tenants caching the same key from colliding
+        const tenantId = c.get('tenantId');
+        const tenantSegment = tenantId ? `${tenantId}:` : '';
+        const cacheKey = `cache:${appName}:${tenantSegment}${rawKey}`;
+        const cached = await storeGet(ctx, store, cacheKey);
+        if (cached) {
+            const { status, headers, body } = JSON.parse(cached);
+            return new Response(body, {
+                status,
+                headers: { ...headers, 'x-cache': 'HIT' },
+            });
+        }
+        await next();
+        const res = c.res;
+        if (res.status >= 200 && res.status < 300) {
+            const body = await res.text();
+            const headers = {};
+            res.headers.forEach((value, name) => {
+                if (!UNCACHEABLE_HEADERS.has(name.toLowerCase())) {
+                    headers[name] = value;
+                }
+            });
+            await storeSet(ctx, store, cacheKey, JSON.stringify({ status: res.status, headers, body }), ttl);
+            c.res = new Response(body, {
+                status: res.status,
+                headers: { ...headers, 'x-cache': 'MISS' },
+            });
+        }
+    };
+};

package/dist/{middleware → src/framework/middleware}/captcha.d.ts

@@ -1,6 +1,5 @@
-import type { MiddlewareHandler } from "hono";
-import type { AppEnv } from "../lib/context";
-import { type CaptchaConfig } from "../lib/captcha";
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv, CaptchaConfig } from '../../../packages/bunshot-core/src/index.js';
 /**
  * Middleware factory that verifies a CAPTCHA token from the request body.
  *

package/dist/src/framework/middleware/captcha.js

@@ -0,0 +1,37 @@
+import { verifyCaptcha } from '../lib/captcha';
+import { HttpError, getContextOrNull } from '../../../packages/bunshot-core/src/index.js';
+import { getClientIp } from '../../../packages/bunshot-core/src/index.js';
+/**
+ * Middleware factory that verifies a CAPTCHA token from the request body.
+ *
+ * @example
+ * router.post("/contact", requireCaptcha({ provider: "turnstile", secretKey: "..." }), handler);
+ */
+export const requireCaptcha = (config) => async (c, next) => {
+    // Get effective config: param takes precedence, then context config
+    const app = c.get('bunshotCtx')?.app;
+    const ctx = app ? getContextOrNull(app) : null;
+    const effectiveConfig = config ?? ctx?.config?.captcha ?? undefined;
+    if (!effectiveConfig) {
+        await next();
+        return;
+    }
+    const tokenField = effectiveConfig.tokenField ?? 'captcha-token';
+    let body;
+    try {
+        body = await c.req.json();
+    }
+    catch {
+        body = {};
+    }
+    const token = body[tokenField];
+    if (!token) {
+        throw new HttpError(400, 'CAPTCHA token is required', 'CAPTCHA_MISSING');
+    }
+    const ip = getClientIp(c) ?? undefined;
+    const result = await verifyCaptcha(token, effectiveConfig, ip);
+    if (!result.success) {
+        throw new HttpError(400, 'CAPTCHA verification failed', 'CAPTCHA_FAILED');
+    }
+    await next();
+};

package/dist/{middleware → src/framework/middleware}/errorHandler.d.ts

@@ -1,2 +1,2 @@
-import type { Middleware } from ".";
+import type { Middleware } from '.';
 export declare const errorHandler: Middleware;

package/dist/{middleware → src/framework/middleware}/errorHandler.js

@@ -1,4 +1,4 @@
-import { HttpError } from "../lib/HttpError";
+import { HttpError } from '../../../packages/bunshot-core/src/index.js';
 export const errorHandler = async (req, next) => {
     try {
         return await next(req);
@@ -11,6 +11,6 @@ export const errorHandler = async (req, next) => {
                 body.code = err.code;
             return Response.json(body, { status: err.status });
         }
-        return Response.json({ error: "Internal Server Error" }, { status: 500 });
+        return Response.json({ error: 'Internal Server Error' }, { status: 500 });
     }
 };

package/dist/src/framework/middleware/index.js

@@ -0,0 +1 @@
+export const applyMiddleware = (handler, ...middleware) => middleware.reduceRight((next, mw) => req => mw(req, next), handler);

package/dist/{middleware → src/framework/middleware}/logger.d.ts

@@ -1,2 +1,2 @@
-import type { Middleware } from ".";
+import type { Middleware } from '.';
 export declare const logger: Middleware;

package/dist/src/framework/middleware/metrics.d.ts

@@ -0,0 +1,12 @@
+import type { MetricsState } from '../lib/metrics';
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+export interface MetricsMiddlewareOptions {
+    /** Instance-owned metrics registry. */
+    state: MetricsState;
+    /** Paths to exclude from metrics collection. Strings use prefix matching. */
+    excludePaths?: (string | RegExp)[];
+    /** Custom path normalizer to prevent cardinality explosion. */
+    normalizePath?: (path: string) => string;
+}
+export declare const metricsCollector: (options: MetricsMiddlewareOptions) => MiddlewareHandler<AppEnv>;

package/dist/src/framework/middleware/metrics.js

@@ -0,0 +1,26 @@
+import { defaultNormalizePath, incrementCounter, observeHistogram } from '../lib/metrics';
+const DEFAULT_EXCLUDE = ['/metrics', '/health', '/docs', '/openapi.json'];
+export const metricsCollector = (options) => {
+    const { state, excludePaths = DEFAULT_EXCLUDE, normalizePath = defaultNormalizePath } = options;
+    return async (c, next) => {
+        const rawPath = c.req.path;
+        const excluded = excludePaths.some(p => typeof p === 'string' ? rawPath.startsWith(p) : p.test(rawPath));
+        if (excluded)
+            return next();
+        const start = performance.now();
+        await next();
+        const duration = (performance.now() - start) / 1000; // seconds
+        const method = c.req.method;
+        const path = normalizePath(rawPath);
+        const status = String(c.res.status);
+        const tenantId = c.get('tenantId') ?? undefined;
+        const labels = { method, path, status };
+        const durationLabels = { method, path };
+        if (tenantId) {
+            labels.tenant = tenantId;
+            durationLabels.tenant = tenantId;
+        }
+        incrementCounter(state, 'http_requests_total', labels);
+        observeHistogram(state, 'http_request_duration_seconds', durationLabels, duration);
+    };
+};

package/dist/{middleware → src/framework/middleware}/rateLimit.d.ts

@@ -1,5 +1,5 @@
-import type { MiddlewareHandler } from "hono";
-import type { AppEnv } from "../lib/context";
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
 export interface RateLimitOptions {
     windowMs: number;
     max: number;

package/dist/src/framework/middleware/rateLimit.js

@@ -0,0 +1,22 @@
+import { getBunshotCtx, getClientIp, getFingerprintBuilder, getRateLimitAdapter, } from '../../../packages/bunshot-core/src/index.js';
+export const rateLimit = ({ windowMs, max, fingerprintLimit = false, }) => {
+    const opts = { windowMs, max };
+    return async (c, next) => {
+        const ctx = getBunshotCtx(c);
+        const adapter = getRateLimitAdapter(ctx);
+        const ip = getClientIp(c);
+        // Per-tenant namespacing: each tenant gets independent rate limit buckets
+        const tenantId = c.get('tenantId');
+        const prefix = tenantId ? `t:${tenantId}:` : '';
+        if (await adapter.trackAttempt(`${prefix}ip:${ip}`, opts)) {
+            return c.json({ error: 'Too Many Requests' }, 429);
+        }
+        if (fingerprintLimit) {
+            const fp = await getFingerprintBuilder(ctx).buildFingerprint(c.req.raw);
+            if (await adapter.trackAttempt(`${prefix}fp:${fp}`, opts)) {
+                return c.json({ error: 'Too Many Requests' }, 429);
+            }
+        }
+        await next();
+    };
+};

package/dist/src/framework/middleware/requestId.d.ts

@@ -0,0 +1,3 @@
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+export declare const requestId: MiddlewareHandler<AppEnv>;

package/dist/{middleware → src/framework/middleware}/requestId.js

@@ -1,7 +1,7 @@
-import { HEADER_REQUEST_ID } from "../lib/constants";
+import { HEADER_REQUEST_ID } from '../../../packages/bunshot-core/src/index.js';
 export const requestId = async (c, next) => {
     const id = c.req.header(HEADER_REQUEST_ID) ?? crypto.randomUUID();
-    c.set("requestId", id);
+    c.set('requestId', id);
     await next();
     c.res.headers.set(HEADER_REQUEST_ID, id);
 };

package/dist/{middleware → src/framework/middleware}/requestLogger.d.ts

@@ -1,6 +1,6 @@
-import type { MiddlewareHandler } from "hono";
-import type { AppEnv } from "../lib/context";
-export type LogLevel = "info" | "warn" | "error";
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+export type LogLevel = 'info' | 'warn' | 'error';
 export interface RequestLogEntry {
     level: LogLevel;
     time: number;

package/dist/{middleware → src/framework/middleware}/requestLogger.js

@@ -1,13 +1,18 @@
-import { getClientIp } from "../lib/clientIp";
+import { getClientIp } from '../../../packages/bunshot-core/src/index.js';
 const LEVEL_ORDER = { info: 0, warn: 1, error: 2 };
 function statusToLevel(status) {
     if (status >= 500)
-        return "error";
+        return 'error';
     if (status >= 400)
-        return "warn";
-    return "info";
+        return 'warn';
+    return 'info';
 }
-const DEFAULT_EXCLUDE_PATHS = ["/health", "/docs", "/openapi.json", "/metrics"];
+const DEFAULT_EXCLUDE_PATHS = [
+    '/health',
+    '/docs',
+    '/openapi.json',
+    '/metrics',
+];
 export const requestLogger = (options = {}) => {
     const { onLog = (entry) => console.log(JSON.stringify(entry)), level: minLevel, excludePaths = DEFAULT_EXCLUDE_PATHS, excludeMethods, } = options;
     return async (c, next) => {
@@ -16,7 +21,7 @@ export const requestLogger = (options = {}) => {
             return next();
         }
         const path = c.req.path;
-        const excluded = excludePaths.some(p => typeof p === "string" ? path.startsWith(p) : p.test(path));
+        const excluded = excludePaths.some(p => typeof p === 'string' ? path.startsWith(p) : p.test(path));
         if (excluded) {
             return next();
         }
@@ -38,17 +43,17 @@ export const requestLogger = (options = {}) => {
         const entry = {
             level,
             time: Date.now(),
-            msg: `${method} ${path} ${error ? "ERROR" : statusCode}`,
-            requestId: c.get("requestId") ?? "unknown",
+            msg: `${method} ${path} ${error ? 'ERROR' : statusCode}`,
+            requestId: c.get('requestId') ?? 'unknown',
             method,
             path,
             statusCode,
             responseTime: Math.round((performance.now() - start) * 100) / 100,
             ip: getClientIp(c),
-            userAgent: c.req.header("user-agent") ?? null,
-            userId: c.get("authUserId") ?? null,
-            sessionId: c.get("sessionId") ?? null,
-            tenantId: c.get("tenantId") ?? null,
+            userAgent: c.req.header('user-agent') ?? null,
+            userId: c.get('authUserId') ?? null,
+            sessionId: c.get('sessionId') ?? null,
+            tenantId: c.get('tenantId') ?? null,
         };
         if (error) {
             entry.err = {

package/dist/{middleware → src/framework/middleware}/requestSigning.d.ts

@@ -1,5 +1,5 @@
-import type { MiddlewareHandler } from "hono";
-import type { AppEnv } from "../lib/context";
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
 export interface RequestSigningOptions {
     /** Allowed age of the timestamp in milliseconds. Default: 300_000 (5 min). */
     tolerance?: number;

package/dist/{middleware → src/framework/middleware}/requestSigning.js

@@ -1,7 +1,5 @@
-import { getSigningConfig, getSigningSecret } from "../lib/appConfig";
-import { hmacVerify } from "../lib/signing";
-import { HEADER_SIGNATURE, HEADER_TIMESTAMP } from "../lib/constants";
-import { HttpError } from "../lib/HttpError";
+import { hmacVerify } from '../../lib/signing';
+import { HEADER_SIGNATURE, HEADER_TIMESTAMP, HttpError } from '../../../packages/bunshot-core/src/index.js';
 /**
  * Canonicalize the query string for signing.
  *
@@ -14,19 +12,19 @@ import { HttpError } from "../lib/HttpError";
  */
 function canonicalizeQuery(search) {
     // Remove leading "?"
-    const qs = search.startsWith("?") ? search.slice(1) : search;
+    const qs = search.startsWith('?') ? search.slice(1) : search;
     if (!qs)
-        return "";
+        return '';
     const pairs = [];
-    for (const part of qs.split("&")) {
+    for (const part of qs.split('&')) {
         if (!part)
             continue;
-        const eqIdx = part.indexOf("=");
+        const eqIdx = part.indexOf('=');
         const rawKey = eqIdx === -1 ? part : part.slice(0, eqIdx);
-        const rawVal = eqIdx === -1 ? "" : part.slice(eqIdx + 1);
+        const rawVal = eqIdx === -1 ? '' : part.slice(eqIdx + 1);
         // Normalize encoding: decode then re-encode
-        const key = encodeURIComponent(decodeURIComponent(rawKey.replace(/\+/g, " ")));
-        const val = encodeURIComponent(decodeURIComponent(rawVal.replace(/\+/g, " ")));
+        const key = encodeURIComponent(decodeURIComponent(rawKey.replace(/\+/g, ' ')));
+        const val = encodeURIComponent(decodeURIComponent(rawVal.replace(/\+/g, ' ')));
         pairs.push([key, val]);
     }
     // Sort by key, then by value for repeated keys
@@ -35,7 +33,7 @@ function canonicalizeQuery(search) {
             return a[0] < b[0] ? -1 : 1;
         return a[1] < b[1] ? -1 : 1;
     });
-    return pairs.map(([k, v]) => `${k}=${v}`).join("&");
+    return pairs.map(([k, v]) => `${k}=${v}`).join('&');
 }
 /**
  * Middleware that verifies the client has HMAC-signed the canonical request.
@@ -47,13 +45,13 @@ function canonicalizeQuery(search) {
  * is a no-op pass-through.
  */
 export const requireSignedRequest = (opts) => async (c, next) => {
-    const cfg = getSigningConfig();
+    const cfg = c.get('bunshotCtx')?.signing;
     // No-op when request signing is not enabled
     if (!cfg?.requestSigning) {
         await next();
         return;
     }
-    const signingOpts = typeof cfg.requestSigning === "object" ? cfg.requestSigning : {};
+    const signingOpts = typeof cfg.requestSigning === 'object' ? cfg.requestSigning : {};
     const tolerance = opts?.tolerance ?? signingOpts.tolerance ?? 300_000;
     const sigHeader = opts?.header ?? signingOpts.header ?? HEADER_SIGNATURE;
     const tsHeader = opts?.timestampHeader ?? signingOpts.timestampHeader ?? HEADER_TIMESTAMP;
@@ -61,22 +59,22 @@ export const requireSignedRequest = (opts) => async (c, next) => {
     const rawTs = c.req.header(tsHeader);
     const tsNum = rawTs !== undefined ? parseInt(rawTs, 10) : NaN;
     if (isNaN(tsNum)) {
-        throw new HttpError(401, "Unauthorized", "EXPIRED_TIMESTAMP");
+        throw new HttpError(401, 'Unauthorized', 'EXPIRED_TIMESTAMP');
     }
     // Auto-detect Unix seconds (< 1e10) vs milliseconds
     const tsMs = tsNum < 1e10 ? tsNum * 1000 : tsNum;
     if (Math.abs(Date.now() - tsMs) > tolerance) {
-        throw new HttpError(401, "Unauthorized", "EXPIRED_TIMESTAMP");
+        throw new HttpError(401, 'Unauthorized', 'EXPIRED_TIMESTAMP');
     }
     // --- Signature header ---
     const sig = c.req.header(sigHeader);
     if (!sig) {
-        throw new HttpError(401, "Unauthorized", "INVALID_SIGNATURE");
+        throw new HttpError(401, 'Unauthorized', 'INVALID_SIGNATURE');
     }
     // --- Secret resolution ---
-    const secret = getSigningSecret();
+    const secret = cfg.secret ?? null;
     if (!secret) {
-        throw new HttpError(500, "Internal Server Error", "SIGNING_SECRET_MISSING");
+        throw new HttpError(500, 'Internal Server Error', 'SIGNING_SECRET_MISSING');
     }
     // --- Build canonical string ---
     const method = c.req.method.toUpperCase();
@@ -94,7 +92,7 @@ export const requireSignedRequest = (opts) => async (c, next) => {
         valid = false;
     }
     if (!valid) {
-        throw new HttpError(401, "Unauthorized", "INVALID_SIGNATURE");
+        throw new HttpError(401, 'Unauthorized', 'INVALID_SIGNATURE');
     }
     await next();
 };

package/dist/src/framework/middleware/tenant.d.ts

@@ -0,0 +1,14 @@
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+import type { TenancyConfig, TenantConfig } from '../../app';
+export interface TenantResolutionCache {
+    get(key: string): TenantConfig | null | undefined;
+    set(key: string, value: TenantConfig | null): void;
+    delete(key: string): void;
+}
+export interface TenantCacheCarrier {
+    cache: TenantResolutionCache | null;
+}
+export declare const invalidateTenantCache: (cache: TenantResolutionCache | null | undefined, tenantId: string) => void;
+export declare function getTenantCacheFromApp(app: object): TenantResolutionCache | null;
+export declare const createTenantMiddleware: (config: TenancyConfig, carrier?: TenantCacheCarrier) => MiddlewareHandler<AppEnv>;

package/dist/{middleware → src/framework/middleware}/tenant.js

@@ -1,3 +1,4 @@
+import { getContext } from '../../../packages/bunshot-core/src/index.js';
 class LruCache {
     _map = new Map();
     _maxSize;
@@ -37,79 +38,82 @@ class LruCache {
 // ---------------------------------------------------------------------------
 // Exported cache invalidation (used by tenant provisioning helpers)
 // ---------------------------------------------------------------------------
-let _cache = null;
-export const invalidateTenantCache = (tenantId) => {
-    _cache?.delete(tenantId);
+export const invalidateTenantCache = (cache, tenantId) => {
+    cache?.delete(tenantId);
 };
+export function getTenantCacheFromApp(app) {
+    const ctx = getContext(app);
+    return (ctx.pluginState.get('tenantResolutionCache') ??
+        null);
+}
 // ---------------------------------------------------------------------------
 // Tenant resolution middleware
 // ---------------------------------------------------------------------------
-const DEFAULT_EXEMPT = ["/health", "/docs", "/openapi.json", "/auth/"];
+const DEFAULT_EXEMPT = ['/health', '/docs', '/openapi.json', '/auth/'];
 function extractTenantId(c, config) {
-    if (config.resolution === "header") {
-        const headerName = config.headerName ?? "x-tenant-id";
+    if (config.resolution === 'header') {
+        const headerName = config.headerName ?? 'x-tenant-id';
         return c.req.header(headerName) ?? null;
     }
-    if (config.resolution === "subdomain") {
-        const host = c.req.header("host") ?? "";
+    if (config.resolution === 'subdomain') {
+        const host = c.req.header('host') ?? '';
         // Extract first subdomain: "acme.myapp.com" → "acme"
-        const parts = host.split(".");
+        const parts = host.split('.');
         if (parts.length < 3)
             return null; // no subdomain
         return parts[0] || null;
     }
-    if (config.resolution === "path") {
+    if (config.resolution === 'path') {
         const segmentIndex = config.pathSegment ?? 0;
         // Path: "/acme/api/users" → segments after split: ["", "acme", "api", "users"]
-        const segments = c.req.path.split("/").filter(Boolean);
+        const segments = c.req.path.split('/').filter(Boolean);
         return segments[segmentIndex] ?? null;
     }
     return null;
 }
-export const createTenantMiddleware = (config) => {
+export const createTenantMiddleware = (config, carrier) => {
     const exemptPaths = [...DEFAULT_EXEMPT, ...(config.exemptPaths ?? [])];
     const rejectionStatus = config.rejectionStatus ?? 403;
     const cacheTtlMs = config.cacheTtlMs ?? 60_000;
     const cacheMaxSize = config.cacheMaxSize ?? 500;
-    // Initialize LRU cache if caching is enabled and onResolve is provided
-    if (config.onResolve && cacheTtlMs > 0) {
-        _cache = new LruCache(cacheMaxSize, cacheTtlMs);
-    }
+    const cache = config.onResolve && cacheTtlMs > 0 ? new LruCache(cacheMaxSize, cacheTtlMs) : null;
+    if (carrier)
+        carrier.cache = cache;
     return async (c, next) => {
         const path = c.req.path;
         // Check exempt paths using startsWith
         for (const exempt of exemptPaths) {
             if (path === exempt || path.startsWith(exempt)) {
-                c.set("tenantId", null);
-                c.set("tenantConfig", null);
+                c.set('tenantId', null);
+                c.set('tenantConfig', null);
                 return next();
             }
         }
         const tenantId = extractTenantId(c, config);
         if (!tenantId) {
-            return c.json({ error: "Tenant ID required" }, 400);
+            return c.json({ error: 'Tenant ID required' }, 400);
         }
         // Validate via onResolve (with caching)
         if (config.onResolve) {
             let tenantConfig;
-            if (_cache) {
-                tenantConfig = _cache.get(tenantId);
+            if (cache) {
+                tenantConfig = cache.get(tenantId);
             }
             // undefined = cache miss, null = onResolve returned null (rejected)
             if (tenantConfig === undefined) {
                 tenantConfig = await config.onResolve(tenantId);
-                _cache?.set(tenantId, tenantConfig);
+                cache?.set(tenantId, tenantConfig);
             }
             if (tenantConfig === null) {
-                return c.json({ error: "Access denied" }, rejectionStatus);
+                return c.json({ error: 'Access denied' }, rejectionStatus);
             }
-            c.set("tenantId", tenantId);
-            c.set("tenantConfig", tenantConfig);
+            c.set('tenantId', tenantId);
+            c.set('tenantConfig', tenantConfig);
         }
         else {
             // No onResolve — trust the tenant ID
-            c.set("tenantId", tenantId);
-            c.set("tenantConfig", null);
+            c.set('tenantId', tenantId);
+            c.set('tenantConfig', null);
         }
         return next();
     };

package/dist/src/framework/middleware/upload.d.ts

@@ -0,0 +1,5 @@
+import type { UploadOpts } from '../lib/upload';
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+export type UploadMiddlewareOptions = UploadOpts;
+export declare const handleUpload: (opts?: UploadMiddlewareOptions) => MiddlewareHandler<AppEnv>;