hono-crud 0.13.13 → 0.13.15

package/CHANGELOG.md

@@ -1,5 +1,160 @@
 # Changelog
 
+## 0.13.15
+
+### Patch Changes
+
+- 4ba4a85: Owner-scope relation includes (`?include=`) — security fix for cross-tenant exposure.
+
+  Previously, loading a relation via `?include=` fetched the related rows by foreign key alone, ignoring the **related** model's access scope. A caller who could read a parent row could therefore read a related row in another tenant (or a soft-deleted one) through the include — a cross-tenant data leak.
+
+  Relations can now declare a `scope` naming the related table's owner and soft-delete columns:
+
+  ```ts
+  relations: {
+    post: {
+      type: 'belongsTo', model: 'posts', table: posts,
+      foreignKey: 'postId', localKey: 'id',
+      scope: { tenantField: 'authorId', softDeleteField: 'deletedAt' },
+    },
+  }
+  ```
+
+  When set, included related rows are filtered to the request's resolved tenant id and exclude soft-deleted rows (unless `?withDeleted=true`), so a foreign key pointing at another tenant's row resolves to `null` (belongsTo/hasOne) or is omitted (hasMany). The filtering lives in the core orchestrator (`batchLoadRelations` / `loadRelationsForItem`), so it applies identically across the drizzle, memory, and prisma adapters; the endpoint threads the parent request's tenant id + `withDeleted` into `IncludeOptions.scope` (Read via core; List via each adapter).
+
+  New public types: `RelationScopeConfig`, `RelationRequestScope`; new fields `RelationConfig.scope` and `IncludeOptions.scope`; new protected `getRelationScope()` on the endpoint base class.
+
+  Backward-compatible and opt-in: relations without `scope` (or requests that resolve no tenant) behave exactly as before. Declare `scope` on any relation whose related model is access-scoped to close the leak.
+
+  Note: scoping is applied as a post-fetch filter in the orchestrator (related rows are fetched, then filtered before being mapped back onto the parent — they never reach the response), not yet pushed down to the adapter `WHERE`/`where`. Correct and leak-free; pushing the predicate into the query is a performance follow-up.
+
+## 0.13.14
+
+### Patch Changes
+
+- 376d8d8: Adapter correctness batch:
+
+  - **Prisma soft-delete**: `read` and `update` now exclude soft-deleted rows (previously deleted data stayed readable and updatable on Prisma only), and `PrismaUpdateEndpoint` implements `findExisting` — restoring write policies, ETag If-Match, versioning, and audit prior-state capture that silently no-oped.
+  - **Prisma wiring parity**: new `getPrismaClient` resolver (`_tx` → class field → `CONTEXT_KEYS.prismaClient` context slot) and `createPrismaCrud(prisma, meta)` factory mirroring the Drizzle adapter; the `prisma` class field is now optional.
+  - **Upsert match-and-restore**: upsert/import/batchUpsert now match soft-deleted rows and clear the soft-delete field on update, identically across all three adapters (previously single upsert skipped soft-deleted rows — unique-constraint errors on SQL — while batch upsert overwrote them without restoring). Drizzle native ON CONFLICT paths document their divergence.
+  - **BatchDelete** responses go through the full finalize pipeline (computed fields, serialization profile, transform) instead of serializer-only.
+  - **like/ilike contract**: one cross-adapter definition — literal substring needle (`%` stripped, `_` inert), `like` follows database collation case behavior, `ilike` always case-insensitive. Drizzle no longer passes live user wildcards into SQL LIKE and no longer emits PostgreSQL-only `ILIKE` on sqlite/mysql.
+  - **Workers waitUntil**: logging flush, cache invalidation (`withCacheInvalidation`), api-key `updateLastUsed`, and error-handler hooks now register through `waitUntil` so they survive the response on Cloudflare Workers. `emitAsync` removed (zero call sites). One exported `WaitUntil` type (`WaitUntilFn` removed).
+  - **Prisma LIKE wildcard leak**: Prisma's `contains` compiles to SQL LIKE without escaping, so user-supplied `_` acted as a live single-char wildcard in like/ilike filters and search (verified against Postgres). Needles are now escaped via `escapeLikeWildcards`.
+  - **Prisma `useTransaction` honored**: Create/Update/Delete now wrap `handle()` in `$transaction` when `useTransaction = true` (mirroring Drizzle) — previously the flag existed but did nothing on single-record verbs, so hooks saw no transaction and an after-hook throw did not roll back the write.
+
+- a50d497: Core structure consolidation (internal — public import surface unchanged except three dead exports):
+
+  - One canonical CRUD route table (`CRUD_ROUTES`, exported via `hono-crud/internal`): all 22 endpoint slots as ordered `[name, verb, subPath]` rows with the registration-order invariants documented in one place. `registerCrud`'s 125-line if-chain is now a loop over it; the OpenAPI paths emitter's private duplicate table is gone; `CrudEndpointName` is derived from the table so it can never drift.
+  - Health is now a core subpath: `hono-crud/health` replaces the retired `@hono-crud/health` package (same API; zero deps and zero core coupling made a separate package pure overhead).
+  - New `hono-crud/cloudflare` module home (merges the former `types/` and `shared/` single-file directories).
+  - "Phase E" finished: auth context accessors live in `auth/context.ts` (also exported from `hono-crud/auth`), the back-compat shim `core/context-helpers.ts` is gone, and context reads use `CONTEXT_KEYS` constants instead of string literals.
+  - One canonical helper each: `getClientIp` (the `trustProxy` knob is now honored, library-wide default `true` — edge-first; logging middleware previously discarded `trustProxy: false`), one `PathPattern` (auth/logging/rate-limit re-export it), logging's pure delegation shims deleted.
+  - Removed dead exports: `createNullableRegistry`, `createRegistryWithDefault`, `PerTenantOpenApiConfig` (use `OpenAPIConfig`).
+
+- e121270: Docs truth sweep — every shipped code sample now typechecks against the real API, plus the type-level fixes that pass surfaced:
+
+  - `withCache` / `withCacheInvalidation` / `withAuth` now accept abstract base classes and return an extendable constructor type. The documented `class X extends withCache(MemoryReadEndpoint)` pattern previously failed to compile for consumers (adapter endpoint classes are abstract, and the old `TBase & Constructor<...>` return type could not be extended — TS2510). Behavior unchanged; types only (`AbstractConstructor` is exported from `hono-crud/internal`).
+  - `PendingActionSchema` is now exported from `hono-crud/auth` — its JSDoc already directed storage-adapter authors to validate rows with it, but it was never re-exported.
+  - `PrismaClient` (the structural client constraint) is now exported from `@hono-crud/prisma` so consumers can name the type that `prisma = ...` and `createPrismaCrud(...)` accept.
+  - Corrected shipped JSDoc: the `withCache` and `AuthenticatedEndpoint` examples no longer show a `handle(ctx)` override (the registrar injects context; `handle()` is parameterless), and the lifecycle-hook docs no longer claim `fire-and-forget` is the default `afterHookMode` (the default is `sequential`).
+
+- 55577a9: BREAKING: export-surface rewrite — the root barrel owns only the CRUD core; every feature family is importable only from its subpath.
+
+  The rule: each `hono-crud/<feature>` subpath barrel is the complete canonical surface of its feature family; the root `'hono-crud'` barrel owns only the CRUD core (model/meta, router/registrar, endpoint classes + result types, exceptions/error-handler, generic context helpers, core infra utils, OpenAPI utilities) and never exports renamed aliases; `hono-crud/internal` is now an explicit curated list (no `export *`).
+
+  Evicted from the root barrel (import from the subpath instead):
+
+  - `hono-crud/auth` — all middleware/guards/storage/validators/JWT-claims plus the auth context accessors (`getUser`, `getUserId`, `hasRole`, …) and types (`AuthEnv`, `JWTClaims`, `ApprovalStorage`, …).
+  - `hono-crud/logging` — `createLoggingMiddleware`, storage setters/getters, redact/extract/truncate utilities, `MemoryLoggingStorage`, `getRequestStartTime`, logging types. (`getRequestId`/`generateRequestId` remain on the root as generic context helpers.)
+  - `hono-crud/storage` — `createStorageMiddleware` + per-feature storage middlewares, `getStorage(ctx, key)` and resolvers, `StorageRegistry`, `StorageEnv`, storage contracts.
+  - `hono-crud/events` — `CrudEventEmitter`, emitter setters/getters, `registerWebhooks`, `CRUD_EVENT_TYPES`, event/webhook types.
+  - `hono-crud/serialization` — `applyProfile` family, `SerializationProfile`/`SerializationConfig`.
+  - `hono-crud/encryption` — encrypt/decrypt helpers, `StaticKeyProvider`, `encryptedValueSchema`, encryption types.
+  - `hono-crud/api-version` — `apiVersion`, `getApiVersion`, `getApiVersionConfig`, `apiVersionedResponse`, versioning-strategy types.
+  - `hono-crud/audit` — `AuditLogger`, `MemoryAuditLogStorage`, `createAuditLogger`, audit storage setters/getters, and (newly on the barrel) `getAuditConfig` + `calculateChanges`.
+  - `hono-crud/versioning` — `VersionManager`, `MemoryVersioningStorage`, `createVersionManager`, versioning storage setters/getters, and (newly on the barrel) `getVersioningConfig`.
+  - `hono-crud/multi-tenant` — `multiTenant`, `TenantEnv`, `MultiTenantMiddlewareConfig`, and (newly on the barrel) `getMultiTenantConfig` + `extractTenantId`.
+  - `hono-crud/functional` — `createCreate`/`createList`/`createRead`/`createUpdate`/`createDelete` and their config types.
+  - `hono-crud/builder` (new subpath) — `crud` and the `*Builder` classes.
+  - `hono-crud/config` — the endpoint-config types (`CreateEndpointConfig`, …, `EndpointsConfig`, `AdapterBundle`, `GeneratedEndpoints`). `defineEndpoints` (the function) stays on the root.
+
+  Deleted outright (no new home):
+
+  - The rename aliases `getContextRequestId`, `matchLoggingPath`, `extractLoggingUserId`, `LoggingPathPattern` — use `getRequestId` (root), `matchPath`, `extractUserId`, `PathPattern` (all on `hono-crud/logging`).
+  - The 17 `Config*Endpoint` type aliases (`ConfigCreateEndpoint`, …) — use the original `*EndpointConfig` names from `hono-crud/config`.
+  - `getHandlerForApp` is no longer on the public barrel (it remains module-level in core).
+
+  `@hono-crud/memory`: the `getStorage` export alias is removed — use `getStore`.
+
+  `@hono-crud/mcp`: now imports exclusively from `hono-crud/internal` (no behavior change).
+
+  The model-meta contract types (`AuditConfig`, `VersioningConfig`, `MultiTenantConfig`, `SoftDeleteConfig`, `AuditLogEntry`, `VersionHistoryEntry`, …) stay on the root barrel — they are fields of the model meta, distinct from the feature runtime.
+
+  (Published as a patch per this repo's pre-1.0 versioning policy.)
+
+- fd3895f: Cursor pagination is now real on all three adapters. Previously core advertised cursor query params and `next_cursor`/`prev_cursor` response fields, but only the memory adapter implemented them — Drizzle and Prisma silently fell back to offset pagination.
+
+  - **Drizzle**: keyset via `WHERE cursorField > decoded ORDER BY cursorField LIMIT n+1`; **Prisma**: native `cursor` + `skip: 1` + `take: n+1`. All three adapters build the cursor-mode `result_info` envelope through one shared core helper, so the shape is byte-identical.
+  - **`prev_cursor` removed** (breaking): cursor walks are next-only (Stripe-style) — SQL keyset "previous" requires a reversed query and was only ever implemented in memory.
+  - **`order_by` is forced to the cursor field during cursor walks** (documented on the query param) — previously the three adapters could diverge on sort semantics mid-walk.
+  - **No silent degradation**: cursor query params and `next_cursor` only appear in the OpenAPI schema when the endpoint enables cursor pagination AND the adapter supports it; enabling it on an unsupporting adapter throws `ConfigurationException` instead of quietly serving offset pages.
+  - List-query logic deduplicated per adapter (`executeDrizzleListQuery` / memory store query helper, mirroring Prisma's existing `executePrismaQuery`) and batch OpenAPI scaffolding shared by the three id-keyed batch verbs.
+
+- 08e7e95: Naming & config-shape unification (breaking renames, no aliases).
+
+  **Model feature enablement idiom.** `Model.audit` and `Model.versioning` are now `boolean | Config` like their `softDelete`/`multiTenant` siblings; the required `enabled` field is removed from `AuditConfig` and `VersioningConfig`. Write `audit: true` / `versioning: true` (or a config object — presence enables); `getAuditConfig`/`getVersioningConfig` and the `AuditLogger`/`VersionManager`/`createAuditLogger`/`createVersionManager` config params accept the union. `NormalizedAuditConfig`/`NormalizedVersioningConfig` still carry `enabled`. `fieldEncryption` stays presence-enabled (it has required members).
+
+  **Path-filter and message vocabulary.** `excludePaths` is the one name for "paths this middleware bypasses": `AuthConfig.skipPaths` → `excludePaths`, `RateLimitConfig.skipPaths` → `excludePaths`, and mcp `AutoOptions.include`/`exclude` → `includePaths`/`excludePaths` (they match `registerCrud` mount paths with the same shared matcher). `AuthConfig.unauthorizedMessage` → `errorMessage`, matching rate-limit and multiTenant.
+
+  **Duration unit suffixes (renames only — no field changed its unit).**
+
+  | Old                                                                      | New                              | Unit    |
+  | ------------------------------------------------------------------------ | -------------------------------- | ------- |
+  | `CacheConfig.ttl`                                                        | `ttlSeconds`                     | seconds |
+  | `IdempotencyConfig.ttl`                                                  | `ttlSeconds`                     | seconds |
+  | `IdempotencyConfig.lockTimeout`                                          | `lockTimeoutSeconds`             | seconds |
+  | `JWTConfig.clockTolerance` / `JWTClaimsValidationOptions.clockTolerance` | `clockToleranceSeconds`          | seconds |
+  | `SubscribeEndpointConfig.heartbeatInterval`                              | `heartbeatIntervalMs`            | ms      |
+  | `SubscribeEndpointConfig.connectionTimeout`                              | `connectionTimeoutMs`            | ms      |
+  | `HealthCheck.timeout`                                                    | `timeoutMs`                      | ms      |
+  | `HealthConfig.defaultTimeout`                                            | `defaultTimeoutMs`               | ms      |
+  | `WebhookEndpoint.timeout`                                                | `timeoutMs`                      | ms      |
+  | `MemoryTtlStoreOptions.cleanupInterval`                                  | `cleanupIntervalMs`              | ms      |
+  | `MemoryLoggingStorageOptions.maxAge` / `.cleanupInterval`                | `maxAgeMs` / `cleanupIntervalMs` | ms      |
+  | `MemoryIdempotencyStorageOptions.cleanupInterval`                        | `cleanupIntervalMs`              | ms      |
+  | `MemoryRateLimitStorageOptions.cleanupInterval`                          | `cleanupIntervalMs`              | ms      |
+
+  Documented exception: `RateLimitResult.retryAfter` keeps its name (mirrors the HTTP Retry-After header, seconds by RFC).
+
+  **Env types.** `TenantEnv` now types its tenant variable optional (`string | undefined` until the middleware runs), matching every other `*Env`. `HonoCrudEnv` now folds in `TenantEnv & ApiVersionEnv`, making its "all core context variables" claim true.
+
+  **Rate-limit extractor nullability.** `extractUserId` and `extractAPIKey` return `string | undefined` (was `string | null`); `KeyExtractor` is `(ctx) => string | undefined` — custom extractors returning `null` must return `undefined`. `extractIP` keeps its `'unknown'` fail-closed sentinel: a falsy key would skip rate limiting entirely, and limits must not fail open when no IP is derivable.
+
+- 90ef0da: Storage & middleware-family unification:
+
+  - **RedisIdempotencyStorage** (`@hono-crud/idempotency`): production idempotency backend whose lock acquisition is ONE atomic `SET key value NX PX ttl` round-trip; compatible with `@upstash/redis` (edge-safe) out of the box. Deliberately no Cloudflare KV backend — KV lacks compare-and-swap, so a KV lock would be advisory only (documented in the package README and the `IdempotencyStorage.lock` contract).
+  - **Breaking — idempotency error shape**: the middleware now throws `IdempotencyKeyRequiredException` (400 `IDEMPOTENCY_KEY_REQUIRED`) and `IdempotencyConflictException` (409 `IDEMPOTENCY_CONFLICT`) instead of hand-returning `ctx.json` envelopes, so idempotency errors flow through `createErrorHandler` (ErrorMappers / ErrorHooks / custom `responseEnvelope` / requestId injection) like every sibling middleware. Bodies are unchanged under the default envelope on bare Hono apps; with `createErrorHandler` they now honor your envelope and gain `error.requestId`.
+  - **Breaking — Prisma model-mapping registry removed**: `registerPrismaModelMapping` / `registerPrismaModelMappings` / `clearPrismaModelMappings` (module-global mutable state, per-isolate on Workers) are deleted. Set the delegate name statically instead: `defineModel({ tableName: 'people', table: 'person', ... })` or `RelationConfig.table` for relations; the camelCase+singularize derivation remains the fallback.
+  - **Missing-storage posture unified**: cache mixins and the idempotency middleware now log a once-per-isolate warning when no storage resolves (rate-limit's existing warning gained the same once-guard); idempotency with `required: true` and no storage throws `ConfigurationException` instead of silently voiding replay protection.
+  - **Cache default removed**: `getCacheStorage()` no longer lazily installs a global `MemoryCacheStorage` on read (`lazyDefaultOnGet` retired for cache) — it returns honest `null` until storage is configured. Docs no longer claim a memory default exists.
+  - **Approval storage joins the unified injection system**: `CONTEXT_KEYS.approvalStorage` slot, `createStorageMiddleware({ approvalStorage })` / `createApprovalStorageMiddleware()`, and the `setApprovalStorage` / `getApprovalStorage` / `getApprovalStorageRequired` / `resolveApprovalStorage` quartet on `hono-crud/auth`. `requireApproval` resolves storage per request (explicit > context > global > warned in-memory default). **Breaking**: `ApprovalConfig.approvalStorage` renamed to `storage` (matching every sibling config).
+  - **Quartet uniformity**: every storage feature now exports its full set/get/getRequired/resolve quartet plus registry from its package/subpath barrel (`resolveRateLimitStorage`, `resolveCacheStorage`, `cacheStorageRegistry`, `rateLimitStorageRegistry`, `idempotencyStorageRegistry`, `eventEmitterRegistry`, `getAPIKeyStorageRequired`, `resolveAPIKeyStorage`, logging's Required/resolve pair on `hono-crud/logging`, …).
+  - **ConfigurationException sweep**: request-time misconfiguration (audit/versioning manager without storage, `getDrizzleDb` / `getPrismaClient` resolution, `resetRateLimit`, Prisma `$transaction` capability check, `StorageRegistry.getRequired` / `resolveRequired`) now throws `ConfigurationException` (500 `CONFIGURATION_ERROR`) instead of plain `Error`.
+  - `MemoryCacheStorageOptions` and `MemoryIdempotencyStorageOptions` are exported; docs now lead every storage-backed feature with `createStorageMiddleware` (the in-code recommended path) and present `set*Storage` as the long-lived-server option.
+
+- 7a7808d: Verb & sugar-surface parity batch:
+
+  - **Config API verb parity**: `defineEndpoints` gains the 5 missing verbs — `bulkPatch`, `versionHistory`, `versionRead`, `versionCompare`, `versionRollback` — completing all 22 `registerCrud` slots. `AdapterBundle` gains the matching optional slots, and all three first-party bundles (Memory/Drizzle/Prisma) now fill every slot. `GeneratedEndpoints` is derived as a `Pick` over `CrudEndpoints`, so the two types can never drift again.
+  - **Loud config failure (BREAKING)**: configuring a verb whose adapter bundle lacks the matching base class now throws a plain `Error` at definition time instead of silently skipping the route. Correct configurations are unaffected.
+  - **BulkPatch on every adapter**: new `DrizzleBulkPatchEndpoint` (single `UPDATE ... WHERE` + RETURNING) and `PrismaBulkPatchEndpoint` (`updateMany`; count-only, `returnRecords` unsupported). `MemoryBulkPatchEndpoint` now respects soft-delete visibility (soft-deleted rows are never patched) and bumps managed `updatedAt` — previously it patched deleted rows and skipped the timestamp bump. Core `BulkPatchEndpoint` ships a default `getUpdateSchema()` (model schema minus managed fields, partial) so it works from the config API without subclassing. New conformance cell pins the contract on all three adapters.
+  - **OpenAPI schema overrides now actually merge (fix)**: user-supplied `responses`/`request`/`security`/`operationId` previously type-checked but were clobbered by the generated blocks on every surface. A shared `mergeRouteSchema` seam (exported from `hono-crud`) now merges user blocks over the generated schema in every endpoint `getSchema()`. Config `openapi` widened to `Partial<OpenAPIRouteSchema>` and the builder gains `.openapi(schema)`.
+  - **`searchFieldName` → `searchParamName` (BREAKING)**: the list-endpoint inline-search query-param knob is renamed everywhere (`ListEndpoint`, `ListFilterParseOptions`, functional `ListConfig`, `NormalizedEndpointConfig`); it names a query parameter, not a model field. Builder `.searchParam()` and config `search.paramName` spellings are unchanged. The default divergence is deliberate and now documented: inline list search defaults to `'search'`, the dedicated `/search` route to `'q'`.
+  - **Builder alias removal (BREAKING)**: pre-1.0 back-compat aliases `orderBy()` and `defaultOrder()` are deleted — `.sortable()` / `.defaultSort()` are the only spellings. The builder also no longer hardcodes its own copy of factory defaults (20/100/'search'/'id'/'sequential'/false); unset knobs pass `undefined` through so `generateEndpointClass` is the single source of defaults (behavior identical).
+  - **`bodySchema` parity**: functional `CreateConfig`/`UpdateConfig` gain `bodySchema` and the Create/Update builders gain `.bodySchema(schema)`, matching the class and config APIs. Fixed a factory bug where the generated `getBodySchema` override crashed body-schema-less verbs.
+  - **Honest hook typing**: the core create/update/delete trio across functional/builder/config now types the hook context as the exported `HookContext` (previously the actively-wrong `tx?: unknown`) and reuses the exported `AfterUpdateHook`/`AfterDeleteHook` aliases. Extended-verb config hook bags are retyped to what is actually passed (upsert gets `isCreate: boolean`, batch-create gets per-item `(item, index)`, batch-update gets `(id, data)`, import gets `(row, rowNumber, mode, tx?)`, clone's `before` gets the prepared clone payload; phantom `tx` params that were never passed are dropped). Previously-dead config hooks now fire: `search.hooks.after` is wired to `afterSearch`, `batchUpsert.hooks.before/after` to `beforeBatch`/`afterBatch`, and `AggregateEndpoint` gains an `after(result)` lifecycle hook so `aggregate.hooks.after` works.
+  - **Env-generic config middlewares**: `EndpointsConfig<M, E>` threads `E` so per-endpoint `middlewares` are `MiddlewareHandler<E>[]`, matching the functional and builder surfaces.
+
 ## 0.13.13
 
 ### Patch Changes

package/README.md

@@ -29,20 +29,21 @@ You will also want a storage adapter, e.g. `@hono-crud/memory`, `@hono-crud/driz
 ## Usage
 
 ```ts
+import { Hono } from 'hono';
+import { defineMeta, defineModel, fromHono, registerCrud } from 'hono-crud';
+import { MemoryCreateEndpoint, MemoryListEndpoint, MemoryReadEndpoint } from '@hono-crud/memory';
 import { z } from 'zod';
-import { fromHono, registerCrud, defineModel, defineMeta } from 'hono-crud';
-import { MemoryCreateEndpoint, MemoryReadEndpoint, MemoryListEndpoint } from '@hono-crud/memory';
 
-const UserSchema = z.object({ id: z.string(), name: z.string() });
-const model = defineModel({ schema: UserSchema, primaryKey: 'id' });
-const meta = defineMeta({ tableName: 'users' });
+const UserSchema = z.object({ id: z.uuid(), name: z.string() });
+const UserModel = defineModel({ tableName: 'users', schema: UserSchema, primaryKeys: ['id'] });
+const userMeta = defineMeta({ model: UserModel });
+
+class UserCreate extends MemoryCreateEndpoint { _meta = userMeta; }
+class UserRead extends MemoryReadEndpoint { _meta = userMeta; }
+class UserList extends MemoryListEndpoint { _meta = userMeta; }
 
 const app = fromHono(new Hono());
-registerCrud(app, '/users', {
-  model,
-  meta,
-  endpoints: { create: MemoryCreateEndpoint, read: MemoryReadEndpoint, list: MemoryListEndpoint },
-});
+registerCrud(app, '/users', { create: UserCreate, read: UserRead, list: UserList });
 ```
 
 See the [repository README](https://github.com/kshdotdev/hono-crud) for the full guide.

package/dist/api-version/index.d.ts

@@ -1,68 +1,6 @@
-import { MiddlewareHandler, Env, Context } from 'hono';
-
-/**
- * Strategy for extracting the API version from requests.
- */
-type ApiVersionStrategy = 'url' | 'header' | 'query';
-/**
- * A version transformer function that converts request/response data
- * between API versions.
- */
-type ApiVersionTransformer = (data: Record<string, unknown>) => Record<string, unknown>;
-/**
- * One version entry consumed by apiVersion() via {@link ApiVersioningConfig}.versions
- * — not the record-history config in core/types.
- */
-interface ApiVersionConfig {
-    /** Version identifier (e.g. '1', '2', '2024-01-15') */
-    version: string;
-    /** Optional middleware to apply for this version */
-    middleware?: MiddlewareHandler[];
-    /** Transform incoming request body from this version to latest */
-    requestTransformer?: ApiVersionTransformer;
-    /** Transform outgoing response data from latest to this version */
-    responseTransformer?: ApiVersionTransformer;
-    /** ISO date string when this version was deprecated */
-    deprecated?: string;
-    /** ISO date string when this version will be removed */
-    sunset?: string;
-}
-/**
- * Top-level bag for the apiVersion() middleware.
- * NOT to be confused with {@link ApiVersionConfig}, which describes ONE version entry
- * inside `versions`. (Unrelated to the record-history feature's config in core/types,
- * which governs stored record versions, not HTTP API negotiation.)
- */
-interface ApiVersioningConfig {
-    /** Available API versions. First is treated as default if no defaultVersion specified. */
-    versions: ApiVersionConfig[];
-    /** Default version when none is specified by client */
-    defaultVersion?: string;
-    /** Version extraction strategy. @default 'header' */
-    strategy?: ApiVersionStrategy;
-    /** Header name for header strategy. @default 'Accept-Version' */
-    headerName?: string;
-    /** Query parameter name for query strategy. @default 'version' */
-    queryParam?: string;
-    /** URL prefix pattern for URL strategy (e.g. '/v{version}'). @default '/v{version}' */
-    urlPattern?: string;
-    /** Custom version extractor (overrides strategy) */
-    extractVersion?: (ctx: Context) => string | undefined;
-    /** Whether to add version headers to responses. @default true */
-    addHeaders?: boolean;
-}
-/**
- * Environment type additions for API versioning.
- *
- * Variables are typed optional because they are only set after the api-version
- * middleware has run. Use `extends ApiVersionEnv` on your app's `Env` to opt in.
- */
-interface ApiVersionEnv extends Env {
-    Variables: {
-        apiVersion?: string;
-        apiVersionConfig?: ApiVersionConfig;
-    };
-}
+import { MiddlewareHandler, Context } from 'hono';
+import { a as ApiVersioningConfig, b as ApiVersionConfig } from '../types-COJwpQfh.js';
+export { A as ApiVersionEnv, c as ApiVersionStrategy, d as ApiVersionTransformer } from '../types-COJwpQfh.js';
 
 /**
  * Create API versioning middleware.
@@ -70,7 +8,7 @@ interface ApiVersionEnv extends Env {
  * @example
  * ```ts
  * import { Hono } from 'hono';
- * import { apiVersion } from 'hono-crud';
+ * import { apiVersion } from 'hono-crud/api-version';
  *
  * const app = new Hono();
  *
@@ -117,4 +55,4 @@ declare function getApiVersionConfig(ctx: Context): ApiVersionConfig | undefined
  */
 declare function apiVersionedResponse(): MiddlewareHandler;
 
-export { type ApiVersionConfig, type ApiVersionEnv, type ApiVersionStrategy, type ApiVersionTransformer, type ApiVersioningConfig, apiVersion, apiVersionedResponse, getApiVersion, getApiVersionConfig };
+export { ApiVersionConfig, ApiVersioningConfig, apiVersion, apiVersionedResponse, getApiVersion, getApiVersionConfig };

package/dist/api-version/index.js

@@ -1 +1 @@
-export{a as apiVersion,d as apiVersionedResponse,b as getApiVersion,c as getApiVersionConfig}from'../chunk-OLSYHJGK.js';import'../chunk-6XVCICWS.js';import'../chunk-6GO5LUOZ.js';
+import {b,a}from'../chunk-XR6JRDGX.js';function C(e,r){return e.req.header(r)??void 0}function h(e,r){return e.req.query(r)??void 0}function l(e,r){let t=e.req.path,a=r.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace("\\{version\\}","([^/]+)"),p=new RegExp(`^${a}`);return t.match(p)?.[1]}function A(e){let{versions:r,strategy:t="header",headerName:d="Accept-Version",queryParam:a$1="version",urlPattern:p="/v{version}",extractVersion:f,addHeaders:c=true}=e,V=e.defaultVersion??r[0]?.version,u=new Map;for(let n of r)u.set(n.version,n);return async(n,m)=>{let o=f?f(n):{header:()=>C(n,d),query:()=>h(n,a$1),url:()=>l(n,p)}[t]();if(o=o??V,!o)throw new b("API version is required",400,"VERSION_REQUIRED");let i=u.get(o);if(!i)throw new b(`Unsupported API version: ${o}`,400,"UNSUPPORTED_VERSION");if(n.set(a.apiVersion,o),n.set(a.apiVersionConfig,i),c&&(n.header("X-API-Version",o),i.deprecated&&n.header("Deprecation",i.deprecated),i.sunset&&n.header("Sunset",i.sunset)),i.middleware&&i.middleware.length>0)for(let y of i.middleware)await y(n,async()=>{});await m();}}function w(e){return e.get(a.apiVersion)}function v(e){return e.get(a.apiVersionConfig)}function E(){return async(e,r)=>{await r();let t=e.get(a.apiVersionConfig);if(!(!t?.responseTransformer||!e.res.headers.get("content-type")?.includes("application/json")))try{let a=await e.res.json(),p=t.responseTransformer(a);e.res=new Response(JSON.stringify(p),{status:e.res.status,headers:e.res.headers});}catch{}}}export{A as apiVersion,E as apiVersionedResponse,w as getApiVersion,v as getApiVersionConfig};

package/dist/audit/index.d.ts

@@ -1,11 +1,27 @@
-import { Context } from 'hono';
-import { A as AuditConfig, f as AuditLogEntry, g as AuditAction } from '../types-tthfGTqv.js';
-import { S as StorageRegistry } from '../registry-3p4qTDGZ.js';
+import { S as StorageRegistry } from '../registry-DYXgzGt0.js';
+import { Context, Env } from 'hono';
+import { m as AuditFieldChange, l as AuditConfig, Z as NormalizedAuditConfig, n as AuditLogEntry, k as AuditAction } from '../types-D72szrPV.js';
 import 'zod';
+import '../path-match-DGLu6wld.js';
 import '../types-B5wq2iKZ.js';
-import '../types-Drjma4gp.js';
+import '../types-lAPVBoYa.js';
 import '@hono/zod-openapi';
 
+/**
+ * Audit configuration normalization + field-change diffing.
+ */
+
+/**
+ * Get normalized audit configuration with defaults.
+ * Accepts the model-side union: `true` enables with defaults, a config
+ * object enables with overrides, `false`/`undefined` disables.
+ */
+declare function getAuditConfig(config?: boolean | AuditConfig): NormalizedAuditConfig;
+/**
+ * Calculate field changes between two records.
+ */
+declare function calculateChanges(oldRecord: Record<string, unknown> | undefined, newRecord: Record<string, unknown> | undefined, excludeFields?: string[]): AuditFieldChange[];
+
 /**
  * Interface for audit log storage adapters.
  * Implement this to store audit logs in your preferred storage.
@@ -82,13 +98,22 @@ declare const getAuditStorage: () => AuditLogStorage | null;
  * default when none was configured.
  */
 declare const getAuditStorageRequired: () => AuditLogStorage;
+/**
+ * Resolves audit storage with priority: explicit param > context > global.
+ * Never creates a default — returns null when nothing is configured.
+ *
+ * @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;
 /**
  * Audit logger class for creating audit log entries.
  */
 declare class AuditLogger {
     private config;
     private storage;
-    constructor(config: AuditConfig | undefined, storage?: AuditLogStorage, ctx?: Context);
+    constructor(config: boolean | AuditConfig | undefined, storage?: AuditLogStorage, ctx?: Context);
     private getStorage;
     /**
      * Check if audit logging is enabled for an action.
@@ -151,6 +176,6 @@ declare class AuditLogger {
  * const logger = createAuditLogger(config, myStorage);
  * ```
  */
-declare function createAuditLogger(config: AuditConfig | undefined, storage?: AuditLogStorage, ctx?: Context): AuditLogger;
+declare function createAuditLogger(config: boolean | AuditConfig | undefined, storage?: AuditLogStorage, ctx?: Context): AuditLogger;
 
-export { type AuditLogStorage, AuditLogger, MemoryAuditLogStorage, auditStorageRegistry, createAuditLogger, getAuditStorage, getAuditStorageRequired, setAuditStorage };
+export { type AuditLogStorage, AuditLogger, MemoryAuditLogStorage, auditStorageRegistry, calculateChanges, createAuditLogger, getAuditConfig, getAuditStorage, getAuditStorageRequired, resolveAuditStorage, setAuditStorage };

package/dist/audit/index.js

@@ -1 +1 @@
-export{f as AuditLogger,a as MemoryAuditLogStorage,b as auditStorageRegistry,g as createAuditLogger,d as getAuditStorage,e as getAuditStorageRequired,c as setAuditStorage}from'../chunk-MCXQ77DB.js';import'../chunk-EX4S3Q4M.js';import'../chunk-OCJC5XWY.js';import'../chunk-VJRDAVID.js';import'../chunk-6GO5LUOZ.js';
+export{g as AuditLogger,a as MemoryAuditLogStorage,b as auditStorageRegistry,h as createAuditLogger,d as getAuditStorage,e as getAuditStorageRequired,f as resolveAuditStorage,c as setAuditStorage}from'../chunk-WBHWKOTP.js';export{b as calculateChanges,a as getAuditConfig}from'../chunk-L5CVVJQH.js';import'../chunk-5P4RVSHT.js';import'../chunk-TLI3TRUA.js';import'../chunk-XR6JRDGX.js';