@visulima/crud 3.0.0-alpha.17 → 3.0.0-alpha.18

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## @visulima/crud [3.0.0-alpha.18](https://github.com/visulima/visulima/compare/@visulima/crud@3.0.0-alpha.17...@visulima/crud@3.0.0-alpha.18) (2026-06-13)
+
+### Features
+
+* **crud:** harden crud handler and add prisma 5/6 + policy support ([fc565cf](https://github.com/visulima/visulima/commit/fc565cf4e87b871f466f3789536a1dc9402bac9f))
+
+### Bug Fixes
+
+* **crud:** return 400 on malformed query json ([01247a6](https://github.com/visulima/visulima/commit/01247a63aad83266947588bccf789df4b58370bb))
+
+### Miscellaneous Chores
+
+* **crud:** clear baseline eslint violations ([1964225](https://github.com/visulima/visulima/commit/196422505694b06ad8239bc836a34e45ad8c8ff3))
+* **crud:** reformat README tables and collapse test expect calls ([2957165](https://github.com/visulima/visulima/commit/295716512272b71b6a67b68633204cc4dd78caf9))
+
+### Build System
+
+* regenerate bundled-license manifests and types ordering ([af26588](https://github.com/visulima/visulima/commit/af26588d75aaa937fd4862800560bd4070a4878c))
+
+
+### Dependencies
+
+* **@visulima/pagination:** upgraded to 5.0.0-alpha.14
+* **@visulima/prisma-dmmf-transformer:** upgraded to 3.0.0-alpha.16
+
 ## @visulima/crud [3.0.0-alpha.17](https://github.com/visulima/visulima/compare/@visulima/crud@3.0.0-alpha.16...@visulima/crud@3.0.0-alpha.17) (2026-06-04)
 
 ### Bug Fixes

package/README.md

@@ -36,6 +36,13 @@
 
 ## Features
 
+- Auto-generated RESTful CRUD routes (`list`, `read`, `create`, `update`, `delete`) from your Prisma models.
+- Rich query syntax over the URL: `select`, `include`, `where` (with `$eq`/`$cont`/`$in`/… operators), `orderBy`, `limit`/`page` pagination, `cursor`, `distinct`.
+- Framework-agnostic core (`baseHandler` + the `Adapter` interface) with a ready-made Prisma adapter and Next.js (`nodeHandler`/`edgeHandler`) bindings.
+- OpenAPI 3 generation from your Prisma DMMF via `modelsToOpenApi`.
+- Built-in guardrails: per-model field allowlists (`writableFields`/`selectableFields`/`filterableFields`/`includableRelations`/`readableFields`), body validation schemas (`createSchema`/`updateSchema`, e.g. zod), an `onRequest` access hook, and a `maxPerPage` cap.
+- Prisma 3, 4, 5 and 6 support.
+
 ## Installation
 
 ```sh
@@ -54,28 +61,60 @@ pnpm add @visulima/crud prisma @prisma/client
 
 To use the `@visulima/crud` package, you need to have a [Prisma](https://www.prisma.io/) schema.
 
+> **Important:** build the handler **once** (at module scope), not inside the request callback.
+> `nodeHandler`/`edgeHandler` are async factories that run `adapter.init()`, map the DMMF and open
+> the connection pool — doing that per request is slow. Reuse the returned handler across requests.
+
 ```ts
 // pages/api/[...crud].ts
 
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from "next";
+import { Prisma } from "@prisma/client";
+import type { User, Post } from "@prisma/client";
 import { PrismaAdapter } from "@visulima/crud";
 import { nodeHandler } from "@visulima/crud/next";
-import type { User, Post, Prisma } from "@prisma/client";
 
 import { prisma } from "../../lib/prisma-client";
 
 const prismaAdapter = new PrismaAdapter<User | Post, Prisma.ModelName>({
     prismaClient: prisma,
+    // Required for Prisma 5/6 (the private DMMF internals were removed):
+    dmmf: Prisma.dmmf,
 });
 
-export default async (request, response) => {
-    const handler = await nodeHandler<User | Post, any, NextApiRequest, NextApiResponse, Prisma.ModelName>(prismaAdapter);
+// Created once — `nodeHandler` runs adapter.init() and connects the pool here.
+const handlerPromise = nodeHandler<User | Post, any, NextApiRequest, NextApiResponse, Prisma.ModelName>(prismaAdapter);
+
+export default async (request: NextApiRequest, response: NextApiResponse) => {
+    const handler = await handlerPromise;
 
     await handler(request, response);
 };
 ```
 
+For the **App Router / edge runtime**, use `edgeHandler`, which returns the `Response`:
+
+```ts
+// app/api/[...crud]/route.ts
+import { Prisma } from "@prisma/client";
+import { PrismaAdapter } from "@visulima/crud";
+import { edgeHandler } from "@visulima/crud/next";
+
+import { prisma } from "../../../lib/prisma-client";
+
+const adapter = new PrismaAdapter({ prismaClient: prisma, dmmf: Prisma.dmmf });
+const handlerPromise = edgeHandler(adapter);
+
+const route = async (request: Request) => {
+    const handler = await handlerPromise;
+
+    return handler(request, undefined);
+};
+
+export { route as GET, route as POST, route as PUT, route as PATCH, route as DELETE };
+```
+
 To use it with `api-platform connect` you need to install the `@visulima/api-platform` package.
 
 ```ts
@@ -83,19 +122,23 @@ To use it with `api-platform connect` you need to install the `@visulima/api-pla
 
 // Next.js API route support: https://nextjs.org/docs/api-routes/introduction
 import type { NextApiRequest, NextApiResponse } from "next";
+import { Prisma } from "@prisma/client";
+import type { User, Post } from "@prisma/client";
 import { createNodeRouter } from "@visulima/api-platform";
 import { PrismaAdapter } from "@visulima/crud";
 import { nodeHandler } from "@visulima/crud/next";
-import type { User, Post, Prisma } from "@prisma/client";
 
 import { prisma } from "../../lib/prisma-client";
 
 const prismaAdapter = new PrismaAdapter<User | Post, Prisma.ModelName>({
     prismaClient: prisma,
+    dmmf: Prisma.dmmf,
 });
 
+const handlerPromise = nodeHandler<User | Post, any, NextApiRequest, NextApiResponse, Prisma.ModelName>(prismaAdapter);
+
 const router = createNodeRouter<NextApiRequest, NextApiResponse>().all(async (request, response) => {
-    const handler = await nodeHandler<User | Post, any, NextApiRequest, NextApiResponse, Prisma.ModelName>(prismaAdapter);
+    const handler = await handlerPromise;
 
     await handler(request, response);
 });
@@ -103,6 +146,85 @@ const router = createNodeRouter<NextApiRequest, NextApiResponse>().all(async (re
 export default router.handler();
 ```
 
+### Query syntax
+
+CRUD endpoints accept the following query-string parameters (all optional):
+
+| Param      | Example                           | Description                                                                |
+| ---------- | --------------------------------- | -------------------------------------------------------------------------- |
+| `select`   | `?select=id,name,profile.bio`     | Comma-separated fields to return. Dotted paths select nested fields.       |
+| `include`  | `?include=posts,profile`          | Comma-separated relations to expand.                                       |
+| `where`    | `?where={"name":{"$cont":"ada"}}` | JSON filter object (see operators below). URL-encode it.                   |
+| `orderBy`  | `?orderBy={"createdAt":"$desc"}`  | JSON object with exactly one field and `$asc`/`$desc`.                     |
+| `limit`    | `?limit=20`                       | Page size / `take`. Capped by `maxPerPage` when configured.                |
+| `page`     | `?page=2`                         | 1-based page number; enables paginated (`@visulima/pagination`) responses. |
+| `skip`     | `?skip=40`                        | Offset (`skip`) for non-paginated reads.                                   |
+| `cursor`   | `?cursor={"id":42}`               | JSON cursor for cursor-based pagination.                                   |
+| `distinct` | `?distinct=email`                 | Field name to apply `distinct` on.                                         |
+
+#### `where` operators
+
+| Operator  | Prisma equivalent | Meaning               |
+| --------- | ----------------- | --------------------- |
+| `$eq`     | `equals`          | equals                |
+| `$neq`    | `not`             | not equal             |
+| `$in`     | `in`              | in list               |
+| `$notin`  | `notIn`           | not in list           |
+| `$lt`     | `lt`              | less than             |
+| `$lte`    | `lte`             | less than or equal    |
+| `$gt`     | `gt`              | greater than          |
+| `$gte`    | `gte`             | greater than or equal |
+| `$cont`   | `contains`        | string contains       |
+| `$starts` | `startsWith`      | string starts with    |
+| `$ends`   | `endsWith`        | string ends with      |
+| `$isnull` | `null`            | is null               |
+
+`where` also supports the `$and`, `$or` and `$not` combinators. By default ISO-date-looking
+strings are coerced to `Date` instances so they match `DateTime` columns; pass
+`coerceWhereDates: false` to the `PrismaAdapter` constructor to keep them as strings (needed when
+filtering a _string_ column whose values look like dates).
+
+### Security & access control
+
+CRUD exposes every model with no field-level restrictions by default. Lock it down per model:
+
+```ts
+import { RouteType } from "@visulima/crud";
+
+const handlerPromise = nodeHandler(adapter, {
+    // Global cap so `?limit=100000000` can't dump a whole table.
+    maxPerPage: 100,
+    // Throw to deny a request (row/field access guard).
+    onRequest: async ({ routeType, resourceName }) => {
+        if (routeType === RouteType.DELETE) throw createHttpError(403, "forbidden");
+    },
+    models: {
+        User: {
+            only: [RouteType.READ_ALL, RouteType.READ_ONE, RouteType.UPDATE],
+            // Mass-assignment guard: clients can only write these columns.
+            writableFields: ["name", "email"],
+            // Never return these even if a client requests ?select=passwordHash.
+            readableFields: ["passwordHash"],
+            // Allowlist what may be filtered/sorted and selected/included.
+            filterableFields: ["id", "name", "email"],
+            selectableFields: ["id", "name", "email"],
+            includableRelations: ["posts"],
+            // Validate/transform the body (any zod-like schema works).
+            updateSchema: userUpdateSchema,
+        },
+    },
+});
+```
+
+### Framework-agnostic usage
+
+The `baseHandler` and `Adapter` interface are exported from the root entry, so you can wire CRUD to
+Express, Fastify, Hono or any runtime without Next.js:
+
+```ts
+import { baseHandler, PrismaAdapter } from "@visulima/crud";
+```
+
 ## Supported Node.js Versions
 
 Libraries in this ecosystem make the best effort to track

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./packem_shared/PrismaAdapter-Buz6dEMm.cjs"),r=require("./packem_shared/modelsToOpenApi-CsQL5VTy.cjs"),o=require("./packem_shared/RouteType-DLV_OhhD.cjs");exports.PrismaAdapter=e;exports.modelsToOpenApi=r;exports.RouteType=o.RouteType;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("./packem_shared/PrismaAdapter-DDoEjhQy.cjs"),r=require("./packem_shared/CrudApiError-DkRqkpib.cjs"),u=require("./packem_shared/baseHandler-DnuGeT2-.cjs"),i=require("./packem_shared/modelsToOpenApi-QqR_HHsz.cjs"),o=require("./packem_shared/RouteType-DLV_OhhD.cjs");exports.PrismaAdapter=e;exports.CrudApiError=r;exports.baseHandler=u;exports.modelsToOpenApi=i;exports.RouteType=o.RouteType;

package/dist/index.d.cts

@@ -1,6 +1,7 @@
 import { HttpError } from 'http-errors';
-import { C as Condition, S as SearchCondition, F as FakePrismaClient, P as PaginationData, a as ParsedQueryParameters, A as Adapter, R as RouteType, M as ModelsOptions } from "./packem_shared/types.d-BDmE9rKc.cjs";
-export { type H as CrudHandlerOptions, type b as HandlerParameters, type c as ModelOption, type O as OrderByField, type d as OrderByOperator, type e as PaginationConfig, type f as RecursiveField, type U as UniqueResourceHandlerParameters, type W as WhereCondition, type g as WhereField, type h as WhereOperator } from "./packem_shared/types.d-BDmE9rKc.cjs";
+import { C as Condition, S as SearchCondition, F as FakePrismaClient, P as PaginationData, a as ParsedQueryParameters, A as Adapter, H as HandlerOptions, E as ExecuteHandler, R as RouteType, M as ModelsOptions } from "./packem_shared/types.d-CQwyFrf3.cjs";
+export type { B as BodySchema, b as CreateHandler, D as DeleteHandler, G as GetHandler, c as HandlerParameters, L as ListHandler, d as ModelAccessPolicy, e as ModelOption, O as OrderByField, f as OrderByOperator, g as PaginationConfig, h as RecursiveField, U as UniqueResourceHandlerParameters, i as UpdateHandler, W as WhereCondition, j as WhereField, k as WhereOperator } from "./packem_shared/types.d-CQwyFrf3.cjs";
+import { IncomingMessage, ServerResponse } from 'node:http';
 import { OpenAPIV3 } from 'openapi-types';
 type PrismaRecursiveField = "include" | "select";
 type PrismaRecursive<T extends PrismaRecursiveField> = Record<string, boolean | { [key in T]: PrismaRecursive<T> }>;
@@ -28,7 +29,33 @@ interface PrismaParsedQueryParameters {
   take?: number;
   where?: PrismaWhereField;
 }
+/**
+* The shape of `Prisma.dmmf` exposed by Prisma 5/6 generated clients. Only the
+* model names are needed by this adapter.
+*/
+interface PrismaDmmf {
+  datamodel?: {
+    models?: {
+      name: string;
+    }[];
+  };
+}
 interface AdapterCtorArguments<M extends string, PrismaClient> {
+  /**
+  * When `true` (default) ISO date-looking strings in `where` filters are
+  * coerced to `Date` instances so they match Prisma `DateTime` columns. Set
+  * to `false` to keep them as strings — required when filtering a *string*
+  * column whose values happen to look like dates.
+  */
+  coerceWhereDates?: boolean;
+  /**
+  * The `Prisma.dmmf` object from your generated client
+  * (`import { Prisma } from "@prisma/client"`). Required for Prisma 5/6,
+  * where the private `_dmmf`/`_getDmmf` internals this adapter used to read
+  * were removed. If omitted, the adapter falls back to those internals for
+  * Prisma 3/4 compatibility, then to `prismaClient._runtimeDataModel`.
+  */
+  dmmf?: PrismaDmmf;
   manyRelations?: { [key in M]?: string[] };
   models?: M[];
   primaryKey?: string;
@@ -41,7 +68,11 @@ declare class PrismaAdapter<T, M extends string, PrismaClient> implements Adapte
   private readonly manyRelations;
   private readonly primaryKey;
   private readonly prismaClient;
+  private readonly coerceWhereDates;
+  private readonly ctorDmmf?;
   constructor({
+    coerceWhereDates,
+    dmmf,
     manyRelations,
     models,
     primaryKey,
@@ -64,6 +95,27 @@ declare class PrismaAdapter<T, M extends string, PrismaClient> implements Adapte
   private readonly getPrismaClientModels;
   private getPrismaDelegate;
 }
+/**
+* Framework-agnostic API error used internally by the base CRUD handler.
+*
+* Previously this package deep-imported `ApiError` from `next/dist/server/api-utils/index.js`,
+* which made the "framework-agnostic" core throw on import when `next` was not
+* installed (it is only an optional peer) and was fragile across Next.js majors.
+*
+* `CrudApiError` is a drop-in replacement: it carries an HTTP `statusCode` and a
+* message, and the handler uses `instanceof CrudApiError` to decide whether an
+* error should bypass the adapter's `handleError` hook.
+*/
+declare class CrudApiError extends Error {
+  readonly statusCode: number;
+  constructor(statusCode: number, message: string);
+}
+interface ResponseConfig {
+  data: unknown;
+  status: number;
+}
+declare function baseHandler<R extends Request, Context, T, Q extends ParsedQueryParameters = ParsedQueryParameters, M extends string = string>(responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>, finalExecutor: (responseOrContext: Context) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Context, Response>>;
+declare function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = ParsedQueryParameters, M extends string = string>(responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>, finalExecutor: (responseOrContext: RResponse) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, RResponse>>;
 interface SwaggerType {
   description?: string;
   isArray?: boolean;
@@ -97,6 +149,7 @@ type SwaggerModelsConfig<M extends string> = { [key in M]?: ModelsConfig };
 declare const modelsToOpenApi: <M extends string = string, PrismaClient = FakePrismaClient>({
   crud,
   defaultExposeStrategy,
+  dmmf: ctorDmmf,
   models: ctorModels,
   prismaClient,
   swagger
@@ -111,6 +164,14 @@ interface ModelsToOpenApiParameters<M extends string, PrismaClient> {
     models: ModelsOptions<M>;
   };
   defaultExposeStrategy?: "all" | "none";
+  /**
+  * The full Prisma DMMF document (must contain `mappingsMap`). Required for
+  * Prisma 5/6, where the private `_dmmf`/`_getDmmf` internals this generator
+  * used to read were removed.
+  */
+  dmmf?: {
+    mappingsMap: Record<string, object>;
+  };
   models?: M[];
   prismaClient: FakePrismaClient & PrismaClient;
   swagger?: Partial<{
@@ -118,4 +179,4 @@ interface ModelsToOpenApiParameters<M extends string, PrismaClient> {
     models: SwaggerModelsConfig<M>;
   }>;
 }
-export { type Adapter, type Condition, type ModelsOptions, type ModelsToOpenApiParameters, type PaginationData, type ParsedQueryParameters, PrismaAdapter, RouteType, type SearchCondition, type SwaggerModelsConfig, modelsToOpenApi };
+export { type Adapter, type Condition, CrudApiError, type HandlerOptions as CrudHandlerOptions, type ExecuteHandler, type ModelsOptions, type ModelsToOpenApiParameters, type PaginationData, type ParsedQueryParameters, PrismaAdapter, RouteType, type SearchCondition, type SwaggerModelsConfig, baseHandler, modelsToOpenApi };

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import { HttpError } from 'http-errors';
-import { C as Condition, S as SearchCondition, F as FakePrismaClient, P as PaginationData, a as ParsedQueryParameters, A as Adapter, R as RouteType, M as ModelsOptions } from "./packem_shared/types.d-BDmE9rKc.mjs";
-export { type H as CrudHandlerOptions, type b as HandlerParameters, type c as ModelOption, type O as OrderByField, type d as OrderByOperator, type e as PaginationConfig, type f as RecursiveField, type U as UniqueResourceHandlerParameters, type W as WhereCondition, type g as WhereField, type h as WhereOperator } from "./packem_shared/types.d-BDmE9rKc.mjs";
+import { C as Condition, S as SearchCondition, F as FakePrismaClient, P as PaginationData, a as ParsedQueryParameters, A as Adapter, H as HandlerOptions, E as ExecuteHandler, R as RouteType, M as ModelsOptions } from "./packem_shared/types.d-CQwyFrf3.mjs";
+export type { B as BodySchema, b as CreateHandler, D as DeleteHandler, G as GetHandler, c as HandlerParameters, L as ListHandler, d as ModelAccessPolicy, e as ModelOption, O as OrderByField, f as OrderByOperator, g as PaginationConfig, h as RecursiveField, U as UniqueResourceHandlerParameters, i as UpdateHandler, W as WhereCondition, j as WhereField, k as WhereOperator } from "./packem_shared/types.d-CQwyFrf3.mjs";
+import { IncomingMessage, ServerResponse } from 'node:http';
 import { OpenAPIV3 } from 'openapi-types';
 type PrismaRecursiveField = "include" | "select";
 type PrismaRecursive<T extends PrismaRecursiveField> = Record<string, boolean | { [key in T]: PrismaRecursive<T> }>;
@@ -28,7 +29,33 @@ interface PrismaParsedQueryParameters {
   take?: number;
   where?: PrismaWhereField;
 }
+/**
+* The shape of `Prisma.dmmf` exposed by Prisma 5/6 generated clients. Only the
+* model names are needed by this adapter.
+*/
+interface PrismaDmmf {
+  datamodel?: {
+    models?: {
+      name: string;
+    }[];
+  };
+}
 interface AdapterCtorArguments<M extends string, PrismaClient> {
+  /**
+  * When `true` (default) ISO date-looking strings in `where` filters are
+  * coerced to `Date` instances so they match Prisma `DateTime` columns. Set
+  * to `false` to keep them as strings — required when filtering a *string*
+  * column whose values happen to look like dates.
+  */
+  coerceWhereDates?: boolean;
+  /**
+  * The `Prisma.dmmf` object from your generated client
+  * (`import { Prisma } from "@prisma/client"`). Required for Prisma 5/6,
+  * where the private `_dmmf`/`_getDmmf` internals this adapter used to read
+  * were removed. If omitted, the adapter falls back to those internals for
+  * Prisma 3/4 compatibility, then to `prismaClient._runtimeDataModel`.
+  */
+  dmmf?: PrismaDmmf;
   manyRelations?: { [key in M]?: string[] };
   models?: M[];
   primaryKey?: string;
@@ -41,7 +68,11 @@ declare class PrismaAdapter<T, M extends string, PrismaClient> implements Adapte
   private readonly manyRelations;
   private readonly primaryKey;
   private readonly prismaClient;
+  private readonly coerceWhereDates;
+  private readonly ctorDmmf?;
   constructor({
+    coerceWhereDates,
+    dmmf,
     manyRelations,
     models,
     primaryKey,
@@ -64,6 +95,27 @@ declare class PrismaAdapter<T, M extends string, PrismaClient> implements Adapte
   private readonly getPrismaClientModels;
   private getPrismaDelegate;
 }
+/**
+* Framework-agnostic API error used internally by the base CRUD handler.
+*
+* Previously this package deep-imported `ApiError` from `next/dist/server/api-utils/index.js`,
+* which made the "framework-agnostic" core throw on import when `next` was not
+* installed (it is only an optional peer) and was fragile across Next.js majors.
+*
+* `CrudApiError` is a drop-in replacement: it carries an HTTP `statusCode` and a
+* message, and the handler uses `instanceof CrudApiError` to decide whether an
+* error should bypass the adapter's `handleError` hook.
+*/
+declare class CrudApiError extends Error {
+  readonly statusCode: number;
+  constructor(statusCode: number, message: string);
+}
+interface ResponseConfig {
+  data: unknown;
+  status: number;
+}
+declare function baseHandler<R extends Request, Context, T, Q extends ParsedQueryParameters = ParsedQueryParameters, M extends string = string>(responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>, finalExecutor: (responseOrContext: Context) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Context, Response>>;
+declare function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = ParsedQueryParameters, M extends string = string>(responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>, finalExecutor: (responseOrContext: RResponse) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, RResponse>>;
 interface SwaggerType {
   description?: string;
   isArray?: boolean;
@@ -97,6 +149,7 @@ type SwaggerModelsConfig<M extends string> = { [key in M]?: ModelsConfig };
 declare const modelsToOpenApi: <M extends string = string, PrismaClient = FakePrismaClient>({
   crud,
   defaultExposeStrategy,
+  dmmf: ctorDmmf,
   models: ctorModels,
   prismaClient,
   swagger
@@ -111,6 +164,14 @@ interface ModelsToOpenApiParameters<M extends string, PrismaClient> {
     models: ModelsOptions<M>;
   };
   defaultExposeStrategy?: "all" | "none";
+  /**
+  * The full Prisma DMMF document (must contain `mappingsMap`). Required for
+  * Prisma 5/6, where the private `_dmmf`/`_getDmmf` internals this generator
+  * used to read were removed.
+  */
+  dmmf?: {
+    mappingsMap: Record<string, object>;
+  };
   models?: M[];
   prismaClient: FakePrismaClient & PrismaClient;
   swagger?: Partial<{
@@ -118,4 +179,4 @@ interface ModelsToOpenApiParameters<M extends string, PrismaClient> {
     models: SwaggerModelsConfig<M>;
   }>;
 }
-export { type Adapter, type Condition, type ModelsOptions, type ModelsToOpenApiParameters, type PaginationData, type ParsedQueryParameters, PrismaAdapter, RouteType, type SearchCondition, type SwaggerModelsConfig, modelsToOpenApi };
+export { type Adapter, type Condition, CrudApiError, type HandlerOptions as CrudHandlerOptions, type ExecuteHandler, type ModelsOptions, type ModelsToOpenApiParameters, type PaginationData, type ParsedQueryParameters, PrismaAdapter, RouteType, type SearchCondition, type SwaggerModelsConfig, baseHandler, modelsToOpenApi };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { HttpError } from 'http-errors';
-import { C as Condition, S as SearchCondition, F as FakePrismaClient, P as PaginationData, a as ParsedQueryParameters, A as Adapter, R as RouteType, M as ModelsOptions } from "./packem_shared/types.d-BDmE9rKc.js";
-export { type H as CrudHandlerOptions, type b as HandlerParameters, type c as ModelOption, type O as OrderByField, type d as OrderByOperator, type e as PaginationConfig, type f as RecursiveField, type U as UniqueResourceHandlerParameters, type W as WhereCondition, type g as WhereField, type h as WhereOperator } from "./packem_shared/types.d-BDmE9rKc.js";
+import { C as Condition, S as SearchCondition, F as FakePrismaClient, P as PaginationData, a as ParsedQueryParameters, A as Adapter, H as HandlerOptions, E as ExecuteHandler, R as RouteType, M as ModelsOptions } from "./packem_shared/types.d-CQwyFrf3.js";
+export type { B as BodySchema, b as CreateHandler, D as DeleteHandler, G as GetHandler, c as HandlerParameters, L as ListHandler, d as ModelAccessPolicy, e as ModelOption, O as OrderByField, f as OrderByOperator, g as PaginationConfig, h as RecursiveField, U as UniqueResourceHandlerParameters, i as UpdateHandler, W as WhereCondition, j as WhereField, k as WhereOperator } from "./packem_shared/types.d-CQwyFrf3.js";
+import { IncomingMessage, ServerResponse } from 'node:http';
 import { OpenAPIV3 } from 'openapi-types';
 type PrismaRecursiveField = "include" | "select";
 type PrismaRecursive<T extends PrismaRecursiveField> = Record<string, boolean | { [key in T]: PrismaRecursive<T> }>;
@@ -28,7 +29,33 @@ interface PrismaParsedQueryParameters {
   take?: number;
   where?: PrismaWhereField;
 }
+/**
+* The shape of `Prisma.dmmf` exposed by Prisma 5/6 generated clients. Only the
+* model names are needed by this adapter.
+*/
+interface PrismaDmmf {
+  datamodel?: {
+    models?: {
+      name: string;
+    }[];
+  };
+}
 interface AdapterCtorArguments<M extends string, PrismaClient> {
+  /**
+  * When `true` (default) ISO date-looking strings in `where` filters are
+  * coerced to `Date` instances so they match Prisma `DateTime` columns. Set
+  * to `false` to keep them as strings — required when filtering a *string*
+  * column whose values happen to look like dates.
+  */
+  coerceWhereDates?: boolean;
+  /**
+  * The `Prisma.dmmf` object from your generated client
+  * (`import { Prisma } from "@prisma/client"`). Required for Prisma 5/6,
+  * where the private `_dmmf`/`_getDmmf` internals this adapter used to read
+  * were removed. If omitted, the adapter falls back to those internals for
+  * Prisma 3/4 compatibility, then to `prismaClient._runtimeDataModel`.
+  */
+  dmmf?: PrismaDmmf;
   manyRelations?: { [key in M]?: string[] };
   models?: M[];
   primaryKey?: string;
@@ -41,7 +68,11 @@ declare class PrismaAdapter<T, M extends string, PrismaClient> implements Adapte
   private readonly manyRelations;
   private readonly primaryKey;
   private readonly prismaClient;
+  private readonly coerceWhereDates;
+  private readonly ctorDmmf?;
   constructor({
+    coerceWhereDates,
+    dmmf,
     manyRelations,
     models,
     primaryKey,
@@ -64,6 +95,27 @@ declare class PrismaAdapter<T, M extends string, PrismaClient> implements Adapte
   private readonly getPrismaClientModels;
   private getPrismaDelegate;
 }
+/**
+* Framework-agnostic API error used internally by the base CRUD handler.
+*
+* Previously this package deep-imported `ApiError` from `next/dist/server/api-utils/index.js`,
+* which made the "framework-agnostic" core throw on import when `next` was not
+* installed (it is only an optional peer) and was fragile across Next.js majors.
+*
+* `CrudApiError` is a drop-in replacement: it carries an HTTP `statusCode` and a
+* message, and the handler uses `instanceof CrudApiError` to decide whether an
+* error should bypass the adapter's `handleError` hook.
+*/
+declare class CrudApiError extends Error {
+  readonly statusCode: number;
+  constructor(statusCode: number, message: string);
+}
+interface ResponseConfig {
+  data: unknown;
+  status: number;
+}
+declare function baseHandler<R extends Request, Context, T, Q extends ParsedQueryParameters = ParsedQueryParameters, M extends string = string>(responseExecutor: (responseOrContext: Context, responseConfig: ResponseConfig) => Promise<Response>, finalExecutor: (responseOrContext: Context) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, Context, Response>>;
+declare function baseHandler<R extends IncomingMessage, RResponse extends ServerResponse, T, Q extends ParsedQueryParameters = ParsedQueryParameters, M extends string = string>(responseExecutor: (responseOrContext: RResponse, responseConfig: ResponseConfig) => Promise<void>, finalExecutor: (responseOrContext: RResponse) => Promise<void>, adapter: Adapter<T, Q>, options?: HandlerOptions<M>): Promise<ExecuteHandler<R, RResponse>>;
 interface SwaggerType {
   description?: string;
   isArray?: boolean;
@@ -97,6 +149,7 @@ type SwaggerModelsConfig<M extends string> = { [key in M]?: ModelsConfig };
 declare const modelsToOpenApi: <M extends string = string, PrismaClient = FakePrismaClient>({
   crud,
   defaultExposeStrategy,
+  dmmf: ctorDmmf,
   models: ctorModels,
   prismaClient,
   swagger
@@ -111,6 +164,14 @@ interface ModelsToOpenApiParameters<M extends string, PrismaClient> {
     models: ModelsOptions<M>;
   };
   defaultExposeStrategy?: "all" | "none";
+  /**
+  * The full Prisma DMMF document (must contain `mappingsMap`). Required for
+  * Prisma 5/6, where the private `_dmmf`/`_getDmmf` internals this generator
+  * used to read were removed.
+  */
+  dmmf?: {
+    mappingsMap: Record<string, object>;
+  };
   models?: M[];
   prismaClient: FakePrismaClient & PrismaClient;
   swagger?: Partial<{
@@ -118,4 +179,4 @@ interface ModelsToOpenApiParameters<M extends string, PrismaClient> {
     models: SwaggerModelsConfig<M>;
   }>;
 }
-export { type Adapter, type Condition, type ModelsOptions, type ModelsToOpenApiParameters, type PaginationData, type ParsedQueryParameters, PrismaAdapter, RouteType, type SearchCondition, type SwaggerModelsConfig, modelsToOpenApi };
+export { type Adapter, type Condition, CrudApiError, type HandlerOptions as CrudHandlerOptions, type ExecuteHandler, type ModelsOptions, type ModelsToOpenApiParameters, type PaginationData, type ParsedQueryParameters, PrismaAdapter, RouteType, type SearchCondition, type SwaggerModelsConfig, baseHandler, modelsToOpenApi };

package/dist/index.mjs

@@ -1 +1 @@
-import{default as r}from"./packem_shared/PrismaAdapter-BVs7BWSG.mjs";import{default as t}from"./packem_shared/modelsToOpenApi-ocNrUF5p.mjs";import{RouteType as f}from"./packem_shared/RouteType-BQ2RxFPE.mjs";export{r as PrismaAdapter,f as RouteType,t as modelsToOpenApi};
+import{default as o}from"./packem_shared/PrismaAdapter-Bhocjq94.mjs";import{default as t}from"./packem_shared/CrudApiError-BH1byAwV.mjs";import{default as f}from"./packem_shared/baseHandler-BGTzX4YA.mjs";import{default as m}from"./packem_shared/modelsToOpenApi-pOMrwJIY.mjs";import{RouteType as l}from"./packem_shared/RouteType-BQ2RxFPE.mjs";export{t as CrudApiError,o as PrismaAdapter,l as RouteType,f as baseHandler,m as modelsToOpenApi};

package/dist/next/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("../packem_shared/edgeHandler-CHig8R94.cjs"),r=require("../packem_shared/nodeHandler-Di5MpzCj.cjs");exports.edgeHandler=e;exports.nodeHandler=r;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const e=require("../packem_shared/edgeHandler-DQ2KLGlC.cjs"),r=require("../packem_shared/nodeHandler-tp623oY3.cjs");exports.edgeHandler=e;exports.nodeHandler=r;