hono-crud 0.13.10 → 0.13.11

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.13.11
+
+### Patch Changes
+
+- 97e92f5: Dedup batch: the edge-safe in-memory TTL machinery, the cache entry wire format, and the relation-batching control flow each now live in exactly one place.
+
+  - New internal `MemoryTtlStore` in core (exported via `hono-crud/internal`) owns lazy cleanup-on-access, expiry-on-read, and insertion-order capacity eviction. The cache, rate-limit, and idempotency memory storages compose it, supplying only their entry shapes and domain indices (cache tag index via an eviction hook, idempotency locks as a second store). Public constructor options are unchanged. The logging memory storage intentionally stays standalone — its newest-first ordering is a different structure, not drift.
+  - New cache entry codec (`packages/cache/src/entry.ts`, internal): `buildCacheEntry` / `normalizeStoredEntry` / `isCacheEntryExpired` shared by the memory, Redis, and Cloudflare KV backends — including the single canonical legacy-Date migration guard, so already-persisted entries keep reading identically.
+  - New relation-batching orchestrator in core (exported via `hono-crud/internal`): the ORM-agnostic control flow (key collection, grouping, map-back, lookup-map dispatch over hasOne/hasMany/belongsTo) is shared; drizzle, prisma, and memory supply only their query adapters. N+1 batching fixes now land in one place.
+  - Two deliberate behavior fixes that the dedup surfaced: (1) single-item relation reads in the memory and drizzle adapters now always set the relation key (`null` / `[]` instead of absent), matching the batch path and prisma — this also fixes memory's belongsTo gating on the row's own `id` instead of the foreign key; (2) the rate-limit fixed window no longer slides its stored expiry on within-window increments — the window keeps its original `windowStart + windowMs` end.
+  - Internal-only removals (never publicly exported): memory's `loadRelation`, prisma's `loadPrismaRelation`.
+
 ## 0.13.10
 
 ### Patch Changes

package/dist/audit/index.d.ts

@@ -1,8 +1,8 @@
 import { Context } from 'hono';
-import { A as AuditConfig, f as AuditLogEntry, g as AuditAction } from '../types-BpA6OtSX.js';
+import { A as AuditConfig, f as AuditLogEntry, g as AuditAction } from '../types-C_OAPSsu.js';
 import { S as StorageRegistry } from '../registry-3p4qTDGZ.js';
 import 'zod';
-import '../types-DcRAcexC.js';
+import '../types-B5wq2iKZ.js';
 import '../types-Drjma4gp.js';
 import '@hono/zod-openapi';
 

package/dist/auth/index.d.ts

@@ -1,9 +1,9 @@
-export { l as APIKeyConfig, m as APIKeyEntry, n as APIKeyLookupResult, o as ActionSource, w as ApprovalConfig, x as ApprovalStorage, y as AuthConfig, z as AuthEnv, B as AuthType, C as AuthUser, D as AuthorizationCheck, Q as EndpointAuthConfig, X as Guard, a4 as JWTAlgorithm, a5 as JWTClaims, a6 as JWTClaimsSchema, a7 as JWTConfig, a8 as JWT_ALGORITHMS, an as OwnershipExtractor, aV as PathPattern, aq as PendingAction, ar as PendingActionStatus, aL as ValidatedJWTClaims, aR as parseJWTClaims, aS as safeParseJWTClaims } from '../types-BpA6OtSX.js';
-export { A as AuthEndpointMethods, a as AuthenticatedEndpoint, J as JWTClaimsValidationOptions, M as MemoryAPIKeyStorage, b as MemoryApprovalStorage, P as POLICIES_CONTEXT_KEY, c as allOf, d as allowAll, e as anyOf, f as createAPIKeyMiddleware, g as createAuthMiddleware, h as createJWTMiddleware, i as decodeJWT, j as defaultHashAPIKey, k as denyAll, m as generateAPIKey, n as getAPIKeyStorage, o as hashAPIKey, p as isValidAPIKeyFormat, q as optionalAuth, r as parseIso8601Duration, s as requireAllRoles, t as requireAnyPermission, u as requireApproval, v as requireAuth, w as requireAuthenticated, x as requireAuthentication, y as requireOwnership, z as requireOwnershipOrRole, B as requirePermissions, C as requirePolicy, D as requireRoles, E as setAPIKeyStorage, F as validateAPIKey, G as validateAPIKeyEntry, H as validateJWTClaims, I as verifyJWT, K as withAuth } from '../index-DS6aUfcl.js';
+export { n as APIKeyConfig, o as APIKeyEntry, p as APIKeyLookupResult, q as ActionSource, y as ApprovalConfig, z as ApprovalStorage, B as AuthConfig, C as AuthEnv, D as AuthType, E as AuthUser, G as AuthorizationCheck, U as EndpointAuthConfig, Z as Guard, a5 as JWTAlgorithm, a6 as JWTClaims, a7 as JWTClaimsSchema, a8 as JWTConfig, a9 as JWT_ALGORITHMS, ao as OwnershipExtractor, aW as PathPattern, ar as PendingAction, as as PendingActionStatus, aL as ValidatedJWTClaims, aR as parseJWTClaims, aS as safeParseJWTClaims } from '../types-C_OAPSsu.js';
+export { A as AuthEndpointMethods, a as AuthenticatedEndpoint, J as JWTClaimsValidationOptions, M as MemoryAPIKeyStorage, b as MemoryApprovalStorage, P as POLICIES_CONTEXT_KEY, c as allOf, d as allowAll, e as anyOf, f as createAPIKeyMiddleware, g as createAuthMiddleware, h as createJWTMiddleware, i as decodeJWT, j as defaultHashAPIKey, k as denyAll, m as generateAPIKey, n as getAPIKeyStorage, o as hashAPIKey, p as isValidAPIKeyFormat, q as optionalAuth, r as parseIso8601Duration, s as requireAllRoles, t as requireAnyPermission, u as requireApproval, v as requireAuth, w as requireAuthenticated, x as requireAuthentication, y as requireOwnership, z as requireOwnershipOrRole, B as requirePermissions, C as requirePolicy, D as requireRoles, E as setAPIKeyStorage, F as validateAPIKey, G as validateAPIKeyEntry, H as validateJWTClaims, I as verifyJWT, K as withAuth } from '../index-CZZ12W3j.js';
 import 'hono';
 import 'zod';
-import '../types-DcRAcexC.js';
+import '../types-B5wq2iKZ.js';
 import '../types-Drjma4gp.js';
 import '@hono/zod-openapi';
-import '../route-DF4Y3iR0.js';
+import '../route-BULuf1Xl.js';
 import 'hono/utils/http-status';

package/dist/chunk-JEOLCWK3.js

@@ -0,0 +1 @@
+import {a}from'./chunk-6GO5LUOZ.js';var l={loggingStorage:a.loggingStorage,auditStorage:a.auditStorage,versioningStorage:a.versioningStorage,apiKeyStorage:a.apiKeyStorage,cacheStorage:a.cacheStorage,rateLimitStorage:a.rateLimitStorage,idempotencyStorage:a.idempotencyStorage,eventEmitter:a.eventEmitter};function o(t){return async(e,r)=>{for(let[a,i]of Object.entries(l)){let d=t[a];d&&e.set(i,d);}await r();}}function s(t){return o({loggingStorage:t})}function u(t){return o({auditStorage:t})}function S(t){return o({versioningStorage:t})}function p(t){return o({apiKeyStorage:t})}function c(t){return o({cacheStorage:t})}function v(t){return o({rateLimitStorage:t})}function m(t){return o({idempotencyStorage:t})}var g=class{map=new Map;isExpired;cleanupInterval;maxEntries;onEvict;lastCleanup=0;constructor(e){this.isExpired=e.isExpired,this.cleanupInterval=e.cleanupInterval??0,this.maxEntries=e.maxEntries??0,this.onEvict=e.onEvict;}maybeCleanup(e=Date.now()){this.cleanupInterval<=0||e-this.lastCleanup>=this.cleanupInterval&&(this.lastCleanup=e,this.cleanup(e));}get(e,r=Date.now()){let a=this.map.get(e);if(a!==void 0){if(this.isExpired(a,r)){this.delete(e);return}return a}}peek(e){return this.map.get(e)}has(e,r=Date.now()){return this.get(e,r)!==void 0}set(e,r,a=false){let i=this.map.has(e);if(this.maxEntries>0&&this.map.size>=this.maxEntries&&!i&&this.evictOldest(),i&&a){let d=this.map.get(e);this.map.delete(e),this.onEvict?.(e,d);}this.map.set(e,r);}delete(e){let r=this.map.get(e);return r===void 0?false:(this.map.delete(e),this.onEvict?.(e,r),true)}evictOldest(){let e=this.map.keys().next().value;e!==void 0&&this.delete(e);}cleanup(e=Date.now()){let r=0,a=[];for(let[i,d]of this.map.entries())this.isExpired(d,e)&&a.push(i);for(let i of a)this.delete(i)&&r++;return r}clear(){this.map.clear();}get size(){return this.map.size}getKeys(){return Array.from(this.map.keys())}entries(){return this.map.entries()}};export{o as a,s as b,u as c,S as d,p as e,c as f,v as g,m as h,g as i};

package/dist/config/index.d.ts

@@ -1,10 +1,10 @@
 import 'hono';
 import 'zod';
-export { A as AdapterBundle, a as AggregateEndpointConfig, B as BatchCreateEndpointConfig, b as BatchDeleteEndpointConfig, c as BatchRestoreEndpointConfig, d as BatchUpdateEndpointConfig, e as BatchUpsertEndpointConfig, f as CloneEndpointConfig, g as CreateEndpointConfig, D as DeleteEndpointConfig, m as EndpointsConfig, E as ExportEndpointConfig, G as GeneratedEndpoints, I as ImportEndpointConfig, L as ListEndpointConfig, R as ReadEndpointConfig, h as RestoreEndpointConfig, S as SearchEndpointConfig, U as UpdateEndpointConfig, i as UpsertEndpointConfig, s as defineEndpoints } from '../index-CNFFLae5.js';
-import '../route-DF4Y3iR0.js';
-import '../types-BpA6OtSX.js';
-import '../types-BQkdX9O0.js';
+export { A as AdapterBundle, a as AggregateEndpointConfig, B as BatchCreateEndpointConfig, b as BatchDeleteEndpointConfig, c as BatchRestoreEndpointConfig, d as BatchUpdateEndpointConfig, e as BatchUpsertEndpointConfig, f as CloneEndpointConfig, g as CreateEndpointConfig, D as DeleteEndpointConfig, m as EndpointsConfig, E as ExportEndpointConfig, G as GeneratedEndpoints, I as ImportEndpointConfig, L as ListEndpointConfig, R as ReadEndpointConfig, h as RestoreEndpointConfig, S as SearchEndpointConfig, U as UpdateEndpointConfig, i as UpsertEndpointConfig, s as defineEndpoints } from '../index-BWwvlRfM.js';
+import '../route-BULuf1Xl.js';
+import '../types-C_OAPSsu.js';
+import '../types-DXVXRfuq.js';
 import '@hono/zod-openapi';
 import 'hono/utils/http-status';
-import '../types-DcRAcexC.js';
+import '../types-B5wq2iKZ.js';
 import '../types-Drjma4gp.js';

package/dist/functional/index.d.ts

@@ -1,8 +1,8 @@
 import { Env, MiddlewareHandler } from 'hono';
-import { M as MetaInput, O as OpenAPIRouteSchema, H as HookMode, F as FilterConfig, S as SortSpec, c as SortDirection } from '../types-BpA6OtSX.js';
-import { M as ModelObject } from '../types-BQkdX9O0.js';
+import { M as MetaInput, O as OpenAPIRouteSchema, H as HookMode, F as FilterConfig, S as SortSpec, c as SortDirection } from '../types-C_OAPSsu.js';
+import { M as ModelObject } from '../types-DXVXRfuq.js';
 import 'zod';
-import '../types-DcRAcexC.js';
+import '../types-B5wq2iKZ.js';
 import '../types-Drjma4gp.js';
 import '@hono/zod-openapi';
 

package/dist/helpers-C3xy6C9u.d.ts

@@ -0,0 +1,515 @@
+import { Env, MiddlewareHandler, Context } from 'hono';
+import { S as StorageRegistry } from './registry-3p4qTDGZ.js';
+import { AuditLogStorage } from './audit/index.js';
+import { aV as APIKeyStorage } from './types-C_OAPSsu.js';
+import { e as LoggingStorage } from './middleware-DBIpdsJ1.js';
+import { VersioningStorage } from './versioning/index.js';
+import { a as CrudEventEmitter } from './emitter-B6dLhiMF.js';
+
+/**
+ * Cross-package storage contracts owned by core.
+ *
+ * Core owns the three storage interfaces (`CacheStorage`, `RateLimitStorage`,
+ * `IdempotencyStorage`) that first-party `@hono-crud/*` plugins implement and
+ * that `storage/types.ts` references. Plugins re-export these from
+ * `hono-crud/internal` rather than re-declaring them, keeping the dependency
+ * graph plugin → core (the only sanctioned cross-package bridge).
+ *
+ * Storage-boundary convention: durations crossing the storage boundary are
+ * milliseconds (`ttlMs`); user-facing config types (e.g. `CacheConfig.ttl`)
+ * stay in seconds and live in the plugins.
+ */
+/**
+ * Cache entry stored in the cache storage.
+ */
+interface CacheEntry<T = unknown> {
+    data: T;
+    /** Epoch milliseconds when the entry was created. */
+    createdAt: number;
+    /** Epoch milliseconds when the entry expires, or null for no expiration. */
+    expiresAt: number | null;
+    tags?: string[];
+}
+/**
+ * Options for setting cache entries.
+ */
+interface CacheSetOptions {
+    /** Time-to-live in milliseconds. */
+    ttlMs?: number;
+    /** Tags for group invalidation. */
+    tags?: string[];
+}
+/**
+ * Cache storage interface.
+ * Implement this interface for custom storage backends.
+ */
+interface CacheStorage {
+    /**
+     * Get a cached entry by key.
+     * @returns The cached entry or null if not found/expired.
+     */
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    /**
+     * Set a cache entry.
+     * @param key - The cache key.
+     * @param data - The data to cache.
+     * @param options - Cache options (ttlMs, tags).
+     */
+    set<T>(key: string, data: T, options?: CacheSetOptions): Promise<void>;
+    /**
+     * Delete a cache entry by key.
+     * @returns True if the entry was deleted.
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Delete entries matching a glob-style pattern.
+     * @param pattern - Glob pattern (e.g., "users:*").
+     * @returns Number of deleted entries.
+     */
+    deletePattern(pattern: string): Promise<number>;
+    /**
+     * Delete all entries with a specific tag.
+     * @param tag - The tag to match.
+     * @returns Number of deleted entries.
+     */
+    deleteByTag?(tag: string): Promise<number>;
+    /**
+     * Check if a key exists in the cache.
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries.
+     */
+    clear(): Promise<void>;
+    /**
+     * Get cache statistics (optional).
+     */
+    getStats?(): CacheStats;
+    /**
+     * Remove expired entries. Optional, edge-safe (no background timers).
+     * @returns Number of entries removed.
+     */
+    cleanup?(): Promise<number>;
+    /** Release resources (timers, connections). Optional, edge-safe. */
+    destroy?(): void;
+}
+/**
+ * Cache statistics.
+ */
+interface CacheStats {
+    hits: number;
+    misses: number;
+    size: number;
+}
+/**
+ * Entry for fixed window rate limiting.
+ * Stores the count and window start time.
+ */
+interface FixedWindowEntry {
+    /** Number of requests in current window */
+    count: number;
+    /** Unix timestamp when the window started (ms) */
+    windowStart: number;
+}
+/**
+ * Entry for sliding window rate limiting.
+ * Stores timestamps of requests within the window.
+ */
+interface SlidingWindowEntry {
+    /** Timestamps of requests within the window (ms) */
+    timestamps: number[];
+}
+/**
+ * Combined entry type for storage.
+ */
+type RateLimitEntry = FixedWindowEntry | SlidingWindowEntry;
+/**
+ * Storage interface for rate limiting.
+ * Separate from CacheStorage due to different requirements:
+ * - Needs atomic increment operations
+ * - No need for tags or complex queries
+ * - Different data structure (counts/timestamps vs cached data)
+ */
+interface RateLimitStorage {
+    /**
+     * Increment the request count for a key (fixed window).
+     * Creates the entry if it doesn't exist.
+     * @param key - The rate limit key
+     * @param windowMs - Window duration in milliseconds
+     * @returns The updated entry with count and window start
+     */
+    increment(key: string, windowMs: number): Promise<FixedWindowEntry>;
+    /**
+     * Add a timestamp to the sliding window for a key.
+     * Removes timestamps outside the window.
+     * @param key - The rate limit key
+     * @param windowMs - Window duration in milliseconds
+     * @param now - Current timestamp (optional, defaults to Date.now())
+     * @returns The updated entry with all timestamps in window
+     */
+    addTimestamp(key: string, windowMs: number, now?: number): Promise<SlidingWindowEntry>;
+    /**
+     * Get the current entry for a key.
+     * @param key - The rate limit key
+     * @returns The entry or null if not found
+     */
+    get(key: string): Promise<RateLimitEntry | null>;
+    /**
+     * Reset the rate limit for a key.
+     * @param key - The rate limit key
+     */
+    reset(key: string): Promise<void>;
+    /**
+     * Clean up expired entries.
+     * @returns Number of entries removed
+     */
+    cleanup(): Promise<number>;
+    /**
+     * Destroy the storage (cleanup intervals, connections, etc.).
+     */
+    destroy?(): void;
+}
+/**
+ * Stored idempotency response entry.
+ */
+interface IdempotencyEntry {
+    /** The idempotency key */
+    key: string;
+    /** HTTP status code of the cached response */
+    statusCode: number;
+    /** Serialized response body */
+    body: string;
+    /** Response headers to replay */
+    headers: Record<string, string>;
+    /** Timestamp when the entry was created */
+    createdAt: number;
+}
+/**
+ * Storage interface for idempotency keys.
+ */
+interface IdempotencyStorage {
+    /**
+     * Get a stored idempotency entry.
+     * Returns null if the key doesn't exist or has expired.
+     */
+    get(key: string): Promise<IdempotencyEntry | null>;
+    /**
+     * Store an idempotency entry with a TTL.
+     * @param key - The idempotency key
+     * @param entry - The response entry to store
+     * @param ttlMs - Time-to-live in milliseconds
+     */
+    set(key: string, entry: IdempotencyEntry, ttlMs: number): Promise<void>;
+    /**
+     * Check if a key is currently being processed (in-flight lock).
+     * Used to prevent concurrent requests with the same key.
+     */
+    isLocked(key: string): Promise<boolean>;
+    /**
+     * Acquire a lock for a key being processed.
+     * Returns true if the lock was acquired, false if already locked.
+     */
+    lock(key: string, ttlMs: number): Promise<boolean>;
+    /**
+     * Release a lock for a key.
+     */
+    unlock(key: string): Promise<void>;
+    /**
+     * Remove expired entries and locks. Optional, edge-safe.
+     * @returns Number of entries removed.
+     */
+    cleanup?(): Promise<number>;
+    /** Release resources and clear all data. Optional, edge-safe. */
+    destroy?(): void;
+}
+
+/**
+ * Extended Hono environment with storage context variables.
+ * Use this type when you want access to context-based storage.
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { StorageEnv, createStorageMiddleware } from 'hono-crud';
+ *
+ * const app = new Hono<StorageEnv>();
+ *
+ * app.use('/*', createStorageMiddleware({
+ *   rateLimitStorage: new MemoryRateLimitStorage(),
+ * }));
+ *
+ * app.get('/test', (ctx) => {
+ *   const storage = ctx.var.rateLimitStorage; // Typed!
+ *   return ctx.text('ok');
+ * });
+ * ```
+ */
+interface StorageEnv extends Env {
+    Variables: {
+        loggingStorage?: LoggingStorage;
+        auditStorage?: AuditLogStorage;
+        versioningStorage?: VersioningStorage;
+        apiKeyStorage?: APIKeyStorage;
+        cacheStorage?: CacheStorage;
+        rateLimitStorage?: RateLimitStorage;
+        idempotencyStorage?: IdempotencyStorage;
+        eventEmitter?: CrudEventEmitter;
+    };
+}
+/**
+ * Configuration for the storage middleware.
+ * Provide any storage instances you want injected into the Hono context.
+ *
+ * @example
+ * ```ts
+ * const config: StorageMiddlewareConfig = {
+ *   rateLimitStorage: new MemoryRateLimitStorage(),
+ *   cacheStorage: new MemoryCacheStorage(),
+ * };
+ * ```
+ */
+interface StorageMiddlewareConfig {
+    /**
+     * Logging storage instance.
+     * If provided, will be available as `ctx.var.loggingStorage`.
+     */
+    loggingStorage?: LoggingStorage;
+    /**
+     * Audit log storage instance.
+     * If provided, will be available as `ctx.var.auditStorage`.
+     */
+    auditStorage?: AuditLogStorage;
+    /**
+     * Versioning storage instance.
+     * If provided, will be available as `ctx.var.versioningStorage`.
+     */
+    versioningStorage?: VersioningStorage;
+    /**
+     * API key storage instance.
+     * If provided, will be available as `ctx.var.apiKeyStorage`.
+     */
+    apiKeyStorage?: APIKeyStorage;
+    /**
+     * Cache storage instance.
+     * If provided, will be available as `ctx.var.cacheStorage`.
+     */
+    cacheStorage?: CacheStorage;
+    /**
+     * Rate limit storage instance.
+     * If provided, will be available as `ctx.var.rateLimitStorage`.
+     */
+    rateLimitStorage?: RateLimitStorage;
+    /**
+     * Idempotency storage instance.
+     * If provided, will be available as `ctx.var.idempotencyStorage`.
+     */
+    idempotencyStorage?: IdempotencyStorage;
+    /**
+     * CRUD event emitter instance.
+     * If provided, will be available as `ctx.var.eventEmitter`.
+     */
+    eventEmitter?: CrudEventEmitter;
+}
+
+/**
+ * Creates middleware that injects storage instances into Hono context.
+ * This is the recommended approach for serverless environments where
+ * global storage can cause issues with cold starts and state persistence.
+ *
+ * @param config - Storage instances to inject
+ * @returns Middleware handler
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono';
+ * import { createStorageMiddleware, MemoryCacheStorage } from 'hono-crud';
+ * import { MemoryRateLimitStorage } from '@hono-crud/rate-limit';
+ *
+ * const app = new Hono();
+ *
+ * // Inject storage instances into context
+ * app.use('/*', createStorageMiddleware({
+ *   rateLimitStorage: new MemoryRateLimitStorage(),
+ *   cacheStorage: new MemoryCacheStorage(),
+ * }));
+ *
+ * // Storage is now available to all downstream middleware and routes
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Multi-tenant setup with per-tenant storage
+ * app.use('/:tenantId/*', async (ctx, next) => {
+ *   const tenantId = ctx.req.param('tenantId');
+ *
+ *   // Get or create tenant-specific storage
+ *   const storage = getTenantStorage(tenantId);
+ *
+ *   // Create middleware dynamically
+ *   const middleware = createStorageMiddleware({
+ *     rateLimitStorage: storage.rateLimit,
+ *     cacheStorage: storage.cache,
+ *   });
+ *
+ *   return middleware(ctx, next);
+ * });
+ * ```
+ */
+declare function createStorageMiddleware<E extends Env = Env>(config: StorageMiddlewareConfig): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only logging storage.
+ *
+ * @param storage - Logging storage instance
+ * @returns Middleware handler
+ */
+declare function createLoggingStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['loggingStorage']>): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only audit storage.
+ *
+ * @param storage - Audit storage instance
+ * @returns Middleware handler
+ */
+declare function createAuditStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['auditStorage']>): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only versioning storage.
+ *
+ * @param storage - Versioning storage instance
+ * @returns Middleware handler
+ */
+declare function createVersioningStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['versioningStorage']>): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only API key storage.
+ *
+ * @param storage - API key storage instance
+ * @returns Middleware handler
+ */
+declare function createAPIKeyStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['apiKeyStorage']>): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only cache storage.
+ *
+ * @param storage - Cache storage instance
+ * @returns Middleware handler
+ */
+declare function createCacheStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['cacheStorage']>): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only rate limit storage.
+ *
+ * @param storage - Rate limit storage instance
+ * @returns Middleware handler
+ */
+declare function createRateLimitStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['rateLimitStorage']>): MiddlewareHandler<E & StorageEnv>;
+/**
+ * Creates middleware that injects only idempotency storage.
+ *
+ * @param storage - Idempotency storage instance
+ * @returns Middleware handler
+ */
+declare function createIdempotencyStorageMiddleware<E extends Env = Env>(storage: NonNullable<StorageMiddlewareConfig['idempotencyStorage']>): MiddlewareHandler<E & StorageEnv>;
+
+/**
+ * The set/get/getRequired/resolve quartet every first-party storage feature
+ * exposes. `getX(): T | null` returns only explicitly-configured storage and
+ * never throws; `getXRequired(): T` throws (or lazy-creates a default when one
+ * was configured AND lazyDefaultOnGet is set). `resolveX` applies the
+ * explicit > context > global priority chain and NEVER creates a default.
+ */
+interface StorageFeature<T> {
+    /** The backing registry (exported for advanced use / tests). */
+    registry: StorageRegistry<T>;
+    /** Set the global storage instance. */
+    set(storage: T): void;
+    /**
+     * Get the explicitly-configured global storage, or null. Never throws.
+     * When the feature was created with `lazyDefaultOnGet: true`, this may
+     * lazy-create the default (legacy never-null path; cache only).
+     */
+    get(): T | null;
+    /**
+     * Get the global storage, throwing if unset. When a defaultFactory was
+     * configured, lazy-creates and returns the default (never throws).
+     */
+    getRequired(): T;
+    /** Resolve with priority explicit > context > global. Returns null if none. */
+    resolve<E extends Env>(ctx?: Context<E>, explicit?: T): T | null;
+    /** Resolve with priority, throwing if none. */
+    resolveRequired<E extends Env>(ctx?: Context<E>, explicit?: T): T;
+}
+interface StorageFeatureOptions<T> {
+    /** Context-var key (must equal a CONTEXT_KEYS value). */
+    contextKey: string;
+    /**
+     * Optional lazy default factory. When provided, `getRequired()` materializes
+     * the default on first access. `resolve*` still never creates hidden state
+     * (edge-safe).
+     */
+    defaultFactory?: () => T;
+    /**
+     * When true (and a defaultFactory exists), `get()` ALSO lazy-creates the
+     * default, preserving a legacy never-null getter. When false/omitted, `get()`
+     * returns only explicitly-configured storage (honest `T | null`). Default: false.
+     * Only cache sets this true; audit/versioning leave it false.
+     */
+    lazyDefaultOnGet?: boolean;
+}
+declare function createStorageFeature<T>(options: StorageFeatureOptions<T>): StorageFeature<T>;
+
+/**
+ * Storage variable keys that can be accessed from context.
+ */
+type StorageKey = keyof StorageEnv['Variables'];
+/**
+ * Get a storage variable from context using Hono's typed pattern.
+ * This is a type-safe alternative to the old getContextVar helper.
+ *
+ * @param ctx - The Hono context (must be typed with StorageEnv or compatible)
+ * @param key - The storage key to retrieve
+ * @returns The storage instance or undefined
+ *
+ * @example
+ * ```ts
+ * const app = new Hono<StorageEnv>();
+ *
+ * app.get('/test', (ctx) => {
+ *   // Option 1: Direct typed access via c.var
+ *   const storage1 = ctx.var.rateLimitStorage;
+ *
+ *   // Option 2: Using the helper (for generic contexts)
+ *   const storage2 = getStorage(ctx, 'rateLimitStorage');
+ * });
+ * ```
+ */
+declare function getStorage<K extends StorageKey>(ctx: Context<StorageEnv>, key: K): StorageEnv['Variables'][K];
+/**
+ * Resolves logging storage with priority: explicit param > context > global.
+ *
+ * @param ctx - Optional Hono context
+ * @param explicitStorage - Optional explicit storage instance
+ * @returns The resolved storage or null if none available
+ */
+declare function resolveLoggingStorage<E extends Env>(ctx?: Context<E>, explicitStorage?: LoggingStorage): LoggingStorage | null;
+/**
+ * Resolves audit storage with priority: explicit param > context > global.
+ *
+ * @param ctx - Optional Hono context
+ * @param explicitStorage - Optional explicit storage instance
+ * @returns The resolved storage, or null when no storage was configured
+ */
+declare function resolveAuditStorage<E extends Env>(ctx?: Context<E>, explicitStorage?: AuditLogStorage): AuditLogStorage | null;
+/**
+ * Resolves versioning storage with priority: explicit param > context > global.
+ *
+ * @param ctx - Optional Hono context
+ * @param explicitStorage - Optional explicit storage instance
+ * @returns The resolved storage, or null when no storage was configured
+ */
+declare function resolveVersioningStorage<E extends Env>(ctx?: Context<E>, explicitStorage?: VersioningStorage): VersioningStorage | null;
+/**
+ * Resolves API key storage with priority: explicit param > context > global.
+ *
+ * @param ctx - Optional Hono context
+ * @param explicitStorage - Optional explicit storage instance
+ * @returns The resolved storage, or null when no storage was configured
+ */
+declare function resolveAPIKeyStorage<E extends Env>(ctx?: Context<E>, explicitStorage?: APIKeyStorage): APIKeyStorage | null;
+
+export { type CacheEntry as C, type FixedWindowEntry as F, type IdempotencyEntry as I, type RateLimitEntry as R, type SlidingWindowEntry as S, type CacheSetOptions as a, type CacheStats as b, type CacheStorage as c, type IdempotencyStorage as d, type RateLimitStorage as e, type StorageEnv as f, type StorageFeature as g, type StorageFeatureOptions as h, type StorageMiddlewareConfig as i, createAPIKeyStorageMiddleware as j, createAuditStorageMiddleware as k, createCacheStorageMiddleware as l, createIdempotencyStorageMiddleware as m, createLoggingStorageMiddleware as n, createRateLimitStorageMiddleware as o, createStorageFeature as p, createStorageMiddleware as q, createVersioningStorageMiddleware as r, getStorage as s, resolveAPIKeyStorage as t, resolveAuditStorage as u, resolveLoggingStorage as v, resolveVersioningStorage as w };

package/dist/{index-CNFFLae5.d.ts → index-BWwvlRfM.d.ts}

@@ -1,9 +1,9 @@
 import { Env, Context, MiddlewareHandler, Hono } from 'hono';
 import { ZodObject, ZodRawShape } from 'zod';
 import { OpenAPIHono } from '@hono/zod-openapi';
-import { O as OpenAPIRoute } from './route-DF4Y3iR0.js';
-import { O as OpenAPIRouteSchema, a as ResponseEnvelope, M as MetaInput, H as HookMode, F as FilterConfig, c as SortDirection } from './types-BpA6OtSX.js';
-import { M as ModelObject } from './types-BQkdX9O0.js';
+import { O as OpenAPIRoute } from './route-BULuf1Xl.js';
+import { O as OpenAPIRouteSchema, a as ResponseEnvelope, M as MetaInput, H as HookMode, F as FilterConfig, c as SortDirection } from './types-C_OAPSsu.js';
+import { M as ModelObject } from './types-DXVXRfuq.js';
 
 interface OpenAPIConfig$1 {
     openapi?: string;

package/dist/{index-DS6aUfcl.d.ts → index-CZZ12W3j.d.ts}

@@ -1,6 +1,6 @@
-import { z as AuthEnv, a7 as JWTConfig, a5 as JWTClaims, l as APIKeyConfig, m as APIKeyEntry, y as AuthConfig, X as Guard, w as ApprovalConfig, D as AuthorizationCheck, an as OwnershipExtractor, aa as ModelPolicies, x as ApprovalStorage, aq as PendingAction, C as AuthUser, M as MetaInput, O as OpenAPIRouteSchema, P as Constructor, Q as EndpointAuthConfig, aW as APIKeyStorage, n as APIKeyLookupResult } from './types-BpA6OtSX.js';
+import { C as AuthEnv, a8 as JWTConfig, a6 as JWTClaims, n as APIKeyConfig, o as APIKeyEntry, B as AuthConfig, Z as Guard, y as ApprovalConfig, G as AuthorizationCheck, ao as OwnershipExtractor, ab as ModelPolicies, z as ApprovalStorage, ar as PendingAction, E as AuthUser, M as MetaInput, O as OpenAPIRouteSchema, T as Constructor, U as EndpointAuthConfig, aV as APIKeyStorage, p as APIKeyLookupResult } from './types-C_OAPSsu.js';
 import { MiddlewareHandler, Context } from 'hono';
-import { O as OpenAPIRoute } from './route-DF4Y3iR0.js';
+import { O as OpenAPIRoute } from './route-BULuf1Xl.js';
 
 /**
  * Default function to extract a Bearer token from the `Authorization` header.

package/dist/{index-Bcf6jyfI.d.ts → index-DHJ4DeUp.d.ts}

@@ -1,8 +1,8 @@
-import { aB as SchemaResolveContext, T as ErrorResponse, a as ResponseEnvelope, d as Model, N as ComputedFieldsConfig, s as AggregateField, u as AggregateOptions, aI as SoftDeleteConfig, al as NormalizedSoftDeleteConfig, j as AuditFieldChange, A as AuditConfig, aj as NormalizedAuditConfig, h as VersioningConfig, am as NormalizedVersioningConfig, ak as NormalizedMultiTenantConfig, ac as MultiTenantConfig, aD as SearchFieldConfig, aE as SearchMode, M as MetaInput, aa as ModelPolicies, as as PolicyContext, W as FilterCondition, _ as HookContext, V as ValidatedData, H as HookMode, O as OpenAPIRouteSchema, au as RelationConfig, a1 as IncludeOptions, af as NestedUpdateInput, ah as NestedWriteResult, E as CascadeAction, F as FilterConfig, S as SortSpec, L as ListFilters, ao as PaginatedResult, r as AggregateConfig, v as AggregateResult, aF as SearchOptions, aH as SearchResultItem, aG as SearchResult, c as SortDirection, z as AuthEnv } from './types-BpA6OtSX.js';
+import { aB as SchemaResolveContext, W as ErrorResponse, a as ResponseEnvelope, d as Model, Q as ComputedFieldsConfig, u as AggregateField, w as AggregateOptions, aI as SoftDeleteConfig, am as NormalizedSoftDeleteConfig, j as AuditFieldChange, A as AuditConfig, ak as NormalizedAuditConfig, h as VersioningConfig, an as NormalizedVersioningConfig, al as NormalizedMultiTenantConfig, ad as MultiTenantConfig, aD as SearchFieldConfig, aE as SearchMode, M as MetaInput, ab as ModelPolicies, at as PolicyContext, Y as FilterCondition, a0 as HookContext, V as ValidatedData, H as HookMode, O as OpenAPIRouteSchema, k as RelationConfig, l as IncludeOptions, ag as NestedUpdateInput, ai as NestedWriteResult, J as CascadeAction, F as FilterConfig, S as SortSpec, L as ListFilters, ap as PaginatedResult, t as AggregateConfig, x as AggregateResult, aF as SearchOptions, aH as SearchResultItem, aG as SearchResult, c as SortDirection, C as AuthEnv } from './types-C_OAPSsu.js';
 import { d as LoggingEnv } from './middleware-DBIpdsJ1.js';
-import { StorageEnv } from './storage/index.js';
-import { O as OpenAPIRoute } from './route-DF4Y3iR0.js';
-import { H as HonoOpenAPIApp, G as GeneratedEndpoints } from './index-CNFFLae5.js';
+import { f as StorageEnv } from './helpers-C3xy6C9u.js';
+import { O as OpenAPIRoute } from './route-BULuf1Xl.js';
+import { H as HonoOpenAPIApp, G as GeneratedEndpoints } from './index-BWwvlRfM.js';
 import { HTTPException } from 'hono/http-exception';
 import { ContentfulStatusCode } from 'hono/utils/http-status';
 import { ZodError, z, ZodObject, ZodRawShape } from 'zod';
@@ -11,14 +11,14 @@ import { AuditLogger } from './audit/index.js';
 import { VersionManager } from './versioning/index.js';
 import './multi-tenant/index.js';
 import { d as CrudEventType, a as CrudEventEmitter, c as CrudEventPayload } from './emitter-B6dLhiMF.js';
-import { M as ModelObject, F as FieldSelection } from './types-BQkdX9O0.js';
+import { M as ModelObject, F as FieldSelection } from './types-DXVXRfuq.js';
 import { Hook } from '@hono/zod-openapi';
-import './index-DS6aUfcl.js';
+import './index-CZZ12W3j.js';
 import './logging/index.js';
 import './registry-3p4qTDGZ.js';
 import './events/index.js';
 import './serialization/index.js';
-import './types-DcRAcexC.js';
+import './types-B5wq2iKZ.js';
 import './encryption/index.js';
 import './types-Drjma4gp.js';
 import './api-version/index.js';