prisma-generator-express 1.35.0 → 1.37.0

package/src/copy/buildModelOpenApi.ts

@@ -69,6 +69,11 @@ function opPath(basePath: string, name: string): string {
   return `${basePath}${def.pathSuffix}`
 }
 
+function postReadPath(basePath: string, name: string): string {
+  if (name === 'findMany') return `${basePath}/read`
+  return opPath(basePath, name)
+}
+
 function errorRef(): RefObject {
   return { $ref: '#/components/schemas/ErrorResponse' }
 }
@@ -162,6 +167,109 @@ function listScalarUpdateOperations(
   }
 }
 
+function findManyBodySchema(): SchemaObject {
+  return {
+    type: 'object',
+    properties: {
+      where: { type: 'object', description: 'Filter conditions' },
+      orderBy: { description: 'Sort order (object or array of objects)' },
+      take: { type: 'integer', description: 'Limit results' },
+      skip: { type: 'integer', description: 'Skip results' },
+      select: { type: 'object', description: 'Select fields' },
+      include: { type: 'object', description: 'Include relations' },
+      omit: { type: 'object', description: 'Omit fields from response' },
+      cursor: { type: 'object', description: 'Cursor for pagination' },
+      distinct: { description: 'Distinct fields (string or array of strings)' },
+    },
+  }
+}
+
+function findUniqueBodySchema(): SchemaObject {
+  return {
+    type: 'object',
+    properties: {
+      where: { type: 'object', description: 'Unique selector' },
+      select: { type: 'object', description: 'Select fields' },
+      include: { type: 'object', description: 'Include relations' },
+      omit: { type: 'object', description: 'Omit fields from response' },
+    },
+    required: ['where'],
+  }
+}
+
+function countBodySchema(): SchemaObject {
+  return {
+    type: 'object',
+    properties: {
+      where: { type: 'object', description: 'Filter conditions' },
+      orderBy: { description: 'Sort order' },
+      take: { type: 'integer', description: 'Limit results' },
+      skip: { type: 'integer', description: 'Skip results' },
+      cursor: { type: 'object', description: 'Cursor for pagination' },
+      select: { description: 'Count specific fields. When provided, returns per-field counts as an object instead of a single integer.' },
+    },
+  }
+}
+
+function aggregateBodySchema(): SchemaObject {
+  return {
+    type: 'object',
+    properties: {
+      where: { type: 'object', description: 'Filter conditions' },
+      orderBy: { description: 'Sort order' },
+      cursor: { type: 'object', description: 'Cursor for pagination' },
+      take: { type: 'integer', description: 'Limit results' },
+      skip: { type: 'integer', description: 'Skip results' },
+      _count: { description: 'Count aggregate (true or field selection object)' },
+      _avg: { type: 'object', description: 'Average aggregate (field selection object)' },
+      _sum: { type: 'object', description: 'Sum aggregate (field selection object)' },
+      _min: { type: 'object', description: 'Min aggregate (field selection object)' },
+      _max: { type: 'object', description: 'Max aggregate (field selection object)' },
+    },
+  }
+}
+
+function groupByBodySchema(): SchemaObject {
+  return {
+    type: 'object',
+    properties: {
+      by: { type: 'array', items: { type: 'string' }, description: 'Fields to group by' },
+      where: { type: 'object', description: 'Filter conditions' },
+      orderBy: { description: 'Sort order. Required when using skip or take.' },
+      having: { type: 'object', description: 'Having conditions (filter object)' },
+      take: { type: 'integer', description: 'Limit results' },
+      skip: { type: 'integer', description: 'Skip results' },
+      _count: { description: 'Count aggregate (true or field selection object)' },
+      _avg: { type: 'object', description: 'Average aggregate (field selection object)' },
+      _sum: { type: 'object', description: 'Sum aggregate (field selection object)' },
+      _min: { type: 'object', description: 'Min aggregate (field selection object)' },
+      _max: { type: 'object', description: 'Max aggregate (field selection object)' },
+    },
+    required: ['by'],
+  }
+}
+
+function getPostReadBodySchema(opName: string): SchemaObject {
+  switch (opName) {
+    case 'findMany':
+    case 'findFirst':
+    case 'findFirstOrThrow':
+    case 'findManyPaginated':
+      return findManyBodySchema()
+    case 'findUnique':
+    case 'findUniqueOrThrow':
+      return findUniqueBodySchema()
+    case 'count':
+      return countBodySchema()
+    case 'aggregate':
+      return aggregateBodySchema()
+    case 'groupBy':
+      return groupByBodySchema()
+    default:
+      return findManyBodySchema()
+  }
+}
+
 export function buildModelOpenApi(
   modelName: string,
   modelFields: ModelField[],
@@ -535,6 +643,41 @@ function getGroupByParams() {
   ]
 }
 
+function addPostReadOperation(
+  spec: OpenApiSpec,
+  path: string,
+  modelName: string,
+  opName: string,
+  summary: string,
+  responseSchema: any,
+  errorCodes: number[],
+  description?: string,
+) {
+  const op: any = {
+    tags: [modelName],
+    summary: summary + ' (POST)',
+    operationId: `${modelName}${opName.charAt(0).toUpperCase() + opName.slice(1)}Post`,
+    description: (description ? description + ' ' : '') +
+      'POST alternative for requests with complex query parameters that may exceed URL length limits. Accepts the same arguments as the GET endpoint but as a JSON request body instead of query parameters.',
+    requestBody: {
+      required: true,
+      content: {
+        'application/json': {
+          schema: getPostReadBodySchema(opName),
+        },
+      },
+    },
+    responses: {
+      '200': {
+        description: 'Success',
+        content: { 'application/json': { schema: responseSchema } },
+      },
+    },
+  }
+  addErrorResponses(op, errorCodes)
+  addPath(spec, path, 'post', op)
+}
+
 function generatePaths(
   spec: OpenApiSpec,
   modelName: string,
@@ -542,6 +685,8 @@ function generatePaths(
   config: RouteConfig,
   fields: ModelField[],
 ) {
+  const postReads = !config.disablePostReads
+
   const createInputRef = {
     $ref: `#/components/schemas/${modelName}CreateInput`,
   }
@@ -588,6 +733,18 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 500, 501, 503])
     addPath(spec, opPath(basePath, 'findMany'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'findMany'),
+        modelName,
+        'findMany',
+        `List ${modelName}`,
+        { type: 'array', items: responseRef },
+        [400, 403, 500, 501, 503],
+      )
+    }
   }
 
   if (opEnabled(config, 'findUnique')) {
@@ -607,6 +764,19 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 500, 501, 503])
     addPath(spec, opPath(basePath, 'findUnique'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'findUnique'),
+        modelName,
+        'findUnique',
+        `Get ${modelName} by unique constraint`,
+        nullableResponseSchema,
+        [400, 403, 500, 501, 503],
+        'Returns null with status 200 when no record matches the unique constraint.',
+      )
+    }
   }
 
   if (opEnabled(config, 'findUniqueOrThrow')) {
@@ -624,6 +794,18 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 404, 500, 501, 503])
     addPath(spec, opPath(basePath, 'findUniqueOrThrow'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'findUniqueOrThrow'),
+        modelName,
+        'findUniqueOrThrow',
+        `Get ${modelName} by unique constraint (throws if not found)`,
+        responseRef,
+        [400, 403, 404, 500, 501, 503],
+      )
+    }
   }
 
   if (opEnabled(config, 'findFirst')) {
@@ -642,6 +824,19 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 500, 501, 503])
     addPath(spec, opPath(basePath, 'findFirst'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'findFirst'),
+        modelName,
+        'findFirst',
+        `Get first ${modelName}`,
+        nullableResponseSchema,
+        [400, 403, 500, 501, 503],
+        'Returns null with status 200 when no record matches.',
+      )
+    }
   }
 
   if (opEnabled(config, 'findFirstOrThrow')) {
@@ -659,6 +854,18 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 404, 500, 501, 503])
     addPath(spec, opPath(basePath, 'findFirstOrThrow'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'findFirstOrThrow'),
+        modelName,
+        'findFirstOrThrow',
+        `Get first ${modelName} (throws if not found)`,
+        responseRef,
+        [400, 403, 404, 500, 501, 503],
+      )
+    }
   }
 
   if (opEnabled(config, 'findManyPaginated')) {
@@ -678,6 +885,19 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 409, 500, 501, 503])
     addPath(spec, opPath(basePath, 'findManyPaginated'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'findManyPaginated'),
+        modelName,
+        'findManyPaginated',
+        `List ${modelName} with pagination`,
+        listRef,
+        [400, 403, 409, 500, 501, 503],
+        'Returns paginated results with total count.',
+      )
+    }
   }
 
   if (opEnabled(config, 'create')) {
@@ -1074,6 +1294,23 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 500, 501, 503])
     addPath(spec, opPath(basePath, 'count'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'count'),
+        modelName,
+        'count',
+        `Count ${modelName}`,
+        {
+          oneOf: [
+            { type: 'integer', description: 'Total count when select is not provided' },
+            { type: 'object', description: 'Per-field count object when select is provided' },
+          ],
+        },
+        [400, 403, 500, 501, 503],
+      )
+    }
   }
 
   if (opEnabled(config, 'aggregate')) {
@@ -1091,6 +1328,18 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 500, 501, 503])
     addPath(spec, opPath(basePath, 'aggregate'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'aggregate'),
+        modelName,
+        'aggregate',
+        `Aggregate ${modelName}`,
+        aggregateRef,
+        [400, 403, 500, 501, 503],
+      )
+    }
   }
 
   if (opEnabled(config, 'groupBy')) {
@@ -1114,6 +1363,19 @@ function generatePaths(
     }
     addErrorResponses(op, [400, 403, 500, 501, 503])
     addPath(spec, opPath(basePath, 'groupBy'), 'get', op)
+
+    if (postReads) {
+      addPostReadOperation(
+        spec,
+        postReadPath(basePath, 'groupBy'),
+        modelName,
+        'groupBy',
+        `Group ${modelName}`,
+        { type: 'array', items: groupByItemRef },
+        [400, 403, 500, 501, 503],
+        'Groups records by the specified fields and returns aggregates.',
+      )
+    }
   }
 }
 

package/src/copy/docsRenderer.ts

@@ -1,5 +1,5 @@
 import type { RouteConfig } from './routeConfig'
-import { OPERATION_DEFS, isOperationEnabled } from './operationDefinitions'
+import { OPERATION_DEFS, isOperationEnabled, READ_OPERATION_NAMES } from './operationDefinitions'
 
 const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
 
@@ -553,6 +553,8 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
   const modelLower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
   const exampleBasePath = buildExampleBasePath(modelName, config)
 
+  const postReadsEnabled = !config.disablePostReads
+
   const scalarFields = ctx.fields.filter((f) => isScalarField(f) || isEnumField(f))
   const relationFields = ctx.fields.filter((f) => isRelationField(f))
 
@@ -561,7 +563,7 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
   const listRelations = relationFields.filter((f) => f.isList)
   const singleRelations = relationFields.filter((f) => !f.isList)
 
-  const ops = OPERATION_DEFS
+  const getOps = OPERATION_DEFS
     .filter((d) => isOperationEnabled(config as Record<string, any>, d))
     .map((d) => {
       const detail = OP_DETAIL_MAP[d.name]
@@ -581,6 +583,33 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
       }
     })
 
+  const postReadOps = postReadsEnabled
+    ? OPERATION_DEFS
+        .filter((d) => READ_OPERATION_NAMES.has(d.name) && isOperationEnabled(config as Record<string, any>, d))
+        .map((d) => {
+          const detail = OP_DETAIL_MAP[d.name]
+          const postPath = d.name === 'findMany'
+            ? buildFullPath(exampleBasePath, '/read')
+            : buildFullPath(exampleBasePath, d.pathSuffix)
+          return {
+            op: d.name + ' (POST)',
+            method: 'POST',
+            path: postPath,
+            transport: 'POST JSON body',
+            responseDesc: detail ? detail.responseDesc : '',
+            errors: detail ? detail.errors.join(', ') : '',
+            required: detail ? detail.required : [],
+            optional: detail ? detail.optional : [],
+            supportsSelect: detail ? detail.supportsSelect : false,
+            supportsInclude: detail ? detail.supportsInclude : false,
+            supportsOmit: detail ? detail.supportsOmit : false,
+            notes: 'POST alternative for complex queries exceeding URL length limits. Same args as GET but in request body.',
+          }
+        })
+    : []
+
+  const ops = [...getOps, ...postReadOps]
+
   const firstUnique = uniqueFields[0]
   const firstUniqueExample = firstUnique ? exampleValue(ctx, firstUnique.name) : null
   const compoundWhere = !firstUnique ? compoundWhereExample(ctx) : null
@@ -640,6 +669,14 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
     'const res = await fetch(BASE_URL + "' + exampleBasePath + '?" + params)\n' +
     'const data = await res.json()'
 
+  const findManyPostFetchExample =
+    'const res = await fetch(BASE_URL + "' + exampleBasePath + '/read", {\n' +
+    '  method: "POST",\n' +
+    '  headers: { "Content-Type": "application/json" },\n' +
+    '  body: JSON.stringify(' + JSON.stringify(findManyQueryArgs, null, 2) + ')\n' +
+    '})\n' +
+    'const data = await res.json()'
+
   const findUniqueFetchExample = uniqueWhereExample
     ? 'const params = encodeQueryParams({\n' +
       '  where: ' + JSON.stringify(uniqueWhereExample) + ',\n' +
@@ -844,6 +881,7 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
   const transportNotes = [
     'GET endpoints: Prisma args as JSON-encoded query parameter strings via encodeQueryParams.',
     'POST/PUT/DELETE/PATCH endpoints: Prisma args as JSON request body. Body must be a JSON object.',
+    'POST read endpoints: All read operations also accept POST with the same args as JSON body instead of query params. Use when query parameters exceed URL length limits. findMany uses POST /read, all others use the same path as GET.',
     'findManyPaginated returns { data, total, hasMore }. hasMore is reliable for forward offset pagination only.',
     'Batch mutations (createMany, updateMany, deleteMany) return { count }. Batch data inputs are scalar-only — nested relation writes are not supported.',
     'findUnique and findFirst return null (not 404) when no record matches. Use the OrThrow variants for 404 behavior.',
@@ -967,6 +1005,7 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
 
   const runtimeNotes = [
     '<strong>Query parameter parsing:</strong> GET query values are parsed server-side. Strings starting with <span class="font-mono">{</span>, <span class="font-mono">[</span>, or <span class="font-mono">"</span> are JSON-parsed. The strings <span class="font-mono">true</span>, <span class="font-mono">false</span>, <span class="font-mono">null</span> are converted to their JS equivalents. Numeric conversion only applies to <span class="font-mono">take</span> and <span class="font-mono">skip</span>. Use <span class="font-mono">encodeQueryParams</span> to avoid encoding issues.',
+    '<strong>POST read endpoints:</strong> All read operations accept POST as an alternative transport. The request body is a plain JSON object with the same argument structure as the GET query params — no JSON-string encoding needed. POST reads use native JSON types (numbers, booleans, objects) directly. findMany POST read is at <span class="font-mono">/read</span>; all other read operations use the same path as their GET counterpart. Disable with <span class="font-mono">disablePostReads: true</span> in route config.',
     '<strong>Request body validation:</strong> All write endpoints require a JSON object body. Sending <span class="font-mono">null</span>, arrays, or non-object JSON values returns 400.',
     '<strong>Documentation in production:</strong> Docs endpoints are disabled by default when <span class="font-mono">NODE_ENV=production</span> or <span class="font-mono">DISABLE_OPENAPI=true</span>. To enable in production, set <span class="font-mono">disableOpenApi: false</span> in the route config.',
     '<strong>Paginated query atomicity:</strong> findManyPaginated wraps data + count in a database transaction when available. If interactive transactions are not supported (e.g. some edge adapters), the queries run separately and data/total may be slightly inconsistent under concurrent writes.',
@@ -1236,29 +1275,33 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
         ${codeBlock(findManyFetchExample)}
       </div>
       <div>
-        <h3 class="mt-3.5 mb-2 text-sm">11.2 GET — findUnique</h3>
+        <h3 class="mt-3.5 mb-2 text-sm">11.2 POST — findMany (read)</h3>
+        ${codeBlock(findManyPostFetchExample)}
+      </div>
+      <div>
+        <h3 class="mt-3.5 mb-2 text-sm">11.3 GET — findUnique</h3>
         ${findUniqueFetchExample
           ? codeBlock(findUniqueFetchExample)
           : noUniqueFieldNote}
       </div>
       <div>
-        <h3 class="mt-3.5 mb-2 text-sm">11.3 POST — create</h3>
+        <h3 class="mt-3.5 mb-2 text-sm">11.4 POST — create</h3>
         ${codeBlock(createFetchExample)}
       </div>
       <div>
-        <h3 class="mt-3.5 mb-2 text-sm">11.4 PUT — update</h3>
+        <h3 class="mt-3.5 mb-2 text-sm">11.5 PUT — update</h3>
         ${updateFetchExample
           ? codeBlock(updateFetchExample)
           : noUniqueFieldNote}
       </div>
       <div>
-        <h3 class="mt-3.5 mb-2 text-sm">11.5 DELETE — delete</h3>
+        <h3 class="mt-3.5 mb-2 text-sm">11.6 DELETE — delete</h3>
         ${deleteFetchExample
           ? codeBlock(deleteFetchExample)
           : noUniqueFieldNote}
       </div>
       <div>
-        <h3 class="mt-3.5 mb-2 text-sm">11.6 Guard variant header</h3>
+        <h3 class="mt-3.5 mb-2 text-sm">11.7 Guard variant header</h3>
         ${guardFetchExample
           ? codeBlock(guardFetchExample)
           : noUniqueFieldNote}

package/src/copy/operationDefinitions.ts

@@ -88,9 +88,27 @@ export const OPERATION_DEFS: OperationDef[] = [
   },
 ]
 
+export const READ_OPERATION_NAMES = new Set([
+  'findMany',
+  'findUnique',
+  'findUniqueOrThrow',
+  'findFirst',
+  'findFirstOrThrow',
+  'findManyPaginated',
+  'count',
+  'aggregate',
+  'groupBy',
+])
+
+export function getPostReadPathSuffix(opName: string): string {
+  if (opName === 'findMany') return '/read'
+  const def = OPERATION_DEFS.find((d) => d.name === opName)
+  return def ? def.pathSuffix : ''
+}
+
 export function isOperationEnabled(
   config: Record<string, any>,
   def: OperationDef,
 ): boolean {
   return !!(config.enableAll || config[def.configKey])
-}
+}

package/src/copy/parseQueryParams.ts

@@ -15,7 +15,7 @@ const parseQueryValue = (value: string, key?: string): unknown => {
   if (value.startsWith('{') || value.startsWith('[') || value.startsWith('"')) {
     try {
       const parsed = JSON.parse(value)
-      return sanitizeKeys(parsed)
+      return parseQueryParams(sanitizeKeys(parsed) as QueryParams)
     } catch {
       // fall through
     }
@@ -34,7 +34,11 @@ export const parseQueryParams = (params: QueryParams): unknown => {
     return parseQueryValue(params)
   }
   if (Array.isArray(params)) {
-    return params.map(parseQueryParams)
+    return params.map((item) =>
+      typeof item === 'string'
+        ? parseQueryValue(item)
+        : parseQueryParams(item as QueryParams),
+    )
   }
   if (isObject(params)) {
     const parsedParams: Record<string, unknown> = {}
@@ -44,7 +48,7 @@ export const parseQueryParams = (params: QueryParams): unknown => {
       if (typeof raw === 'string') {
         parsedParams[key] = parseQueryValue(raw, key)
       } else {
-        parsedParams[key] = sanitizeKeys(raw)
+        parsedParams[key] = parseQueryParams(raw as QueryParams)
       }
     }
     return parsedParams

package/src/copy/routeConfig.ts

@@ -32,6 +32,7 @@ export interface BaseRouteConfig<HookHandler, RequestType> {
   customUrlPrefix?: string
   specBasePath?: string
   disableOpenApi?: boolean
+  disablePostReads?: boolean
   scalarCdnUrl?: string
 
   openApiTitle?: string

package/src/generators/generateRouter.ts

@@ -62,6 +62,7 @@ import {
 } from './${modelName}Handlers'
 import type { RouteConfig } from '../routeConfig.target'
 import { parseQueryParams } from '../parseQueryParams'
+import { sanitizeKeys } from '../misc'
 import { buildModelOpenApi } from '../buildModelOpenApi'
 import { transformResult } from '../operationRuntime'
 
@@ -113,6 +114,8 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
       || _env.NODE_ENV === 'production'
     ))
 
+  const postReadsEnabled = !config.disablePostReads
+
   const qbEnabled = isQueryBuilderEnabled(config)
 
   if (qbEnabled) {
@@ -130,6 +133,14 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     next()
   }
 
+  const parseBodyAsQuery: RequestHandler = (req, res, next) => {
+    if (!req.body || typeof req.body !== 'object' || Array.isArray(req.body)) {
+      return next({ status: 400, message: 'Request body must be a JSON object' })
+    }
+    res.locals.parsedQuery = sanitizeKeys(req.body)
+    next()
+  }
+
   const setShape = (opConfig: any): RequestHandler => {
     return (req, res, next) => {
       res.locals.routeConfig = config
@@ -194,6 +205,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/first\` : '/first'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}FindFirst as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirst as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.findFirstOrThrow) {
@@ -201,6 +215,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.findManyPaginated) {
@@ -208,6 +225,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.aggregate) {
@@ -215,6 +235,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}Aggregate as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Aggregate as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.count) {
@@ -222,6 +245,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/count\` : '/count'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}Count as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Count as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.groupBy) {
@@ -229,6 +255,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}GroupBy as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}GroupBy as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.findUniqueOrThrow) {
@@ -236,6 +265,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.findUnique) {
@@ -243,6 +275,9 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/unique\` : '/unique'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}FindUnique as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUnique as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.findMany) {
@@ -250,6 +285,10 @@ export function ${routerFunctionName}(config: RouteConfig = {}) {
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
     router.get(path, parseQuery, setShape(opConfig), ...before, ${prefix}FindMany as RequestHandler, ...after, respond)
+    if (postReadsEnabled) {
+      const postPath = basePath ? \`\${basePath}/read\` : '/read'
+      router.post(postPath, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindMany as RequestHandler, ...after, respond)
+    }
   }
 
   if (config.enableAll || config.createManyAndReturn) {