prisma-generator-express 1.34.4 → 1.36.0

package/dist/generators/generateRouterFastify.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateRouterFastify.js","sourceRoot":"","sources":["../../src/generators/generateRouterFastify.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateRouterFastify.js","sourceRoot":"","sources":["../../src/generators/generateRouterFastify.ts"],"names":[],"mappings":";;AAGA,sEAkpBC;AAppBD,8CAA8C;AAE9C,SAAgB,6BAA6B,CAAC,EAC5C,KAAK,EACL,KAAK,GAIN;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,MAAM,GAAG,IAAA,qBAAW,EAAC,SAAS,CAAC,CAAA;IACrC,MAAM,cAAc,GAAG,SAAS,CAAC,WAAW,EAAE,CAAA;IAC9C,MAAM,kBAAkB,GAAG,GAAG,MAAM,QAAQ,CAAA;IAE5C,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1C,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,eAAe,EAAE,CAAC,CAAC,eAAe;QAClC,WAAW,EAAE,CAAC,CAAC,WAAW,IAAI,KAAK;QACnC,aAAa,EAAE,CAAC,CAAC,aAAa;QAC9B,kBAAkB,EAAE,CAAC,CAAC,kBAAkB;KACzC,CAAC,CAAC,CAAA;IAEH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CACjC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CACjE,CAAA;IAED,MAAM,SAAS,GAAG,KAAK;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SAC9C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;KAChD,CAAC,CAAC,CAAA;IAEL,OAAO;;IAEL,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;YACE,SAAS;;;;;;;;;uBASE,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;;sBAEpC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAyFhC,kBAAkB;;;;;4DAKkB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAkC/D,SAAS;;;;;;;;;;;WAWT,SAAS;;;;;;;;;;;;;;;;;;;gBAmBJ,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;kBAaJ,MAAM;;;;;;;;;;;;;;;;;;;gBAmBR,MAAM;;;;;;;;;;;;;;kBAcJ,MAAM;;;;;;;;;;;;;;;;;;gBAkBR,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;;;;;;;;;gBAiBN,MAAM;;;;;;;;;CASrB,CAAA;AACD,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator for Hono CRUD API with OpenAPI documentation",
-  "version": "1.34.4",
+  "version": "1.36.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",

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/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/generateOperationCore.ts

@@ -499,21 +499,29 @@ export async function findManyPaginated(
   const shape = ctx.guardShape
   const caller = ctx.guardCaller
   const distinctCountLimit = ctx.paginationConfig?.distinctCountLimit
+  const delegate = (extended as any).${modelNameLower}
 
   if (shape) {
-    assertGuard((extended as any).${modelNameLower})
+    assertGuard(delegate)
   }
 
   let items: any[]
   let total: number
 
-  if (typeof extended.$transaction === 'function') {
+  if (shape || typeof extended.$transaction !== 'function') {
+    const [data, count] = await Promise.all([
+      shape
+        ? delegate.guard(shape, caller).findMany(query)
+        : delegate.findMany(query),
+      countForPagination(delegate, query, shape, caller, distinctCountLimit),
+    ])
+    items = data
+    total = count
+  } else {
     try {
       const txResult = await extended.$transaction(async (tx: any) => {
-        const d = shape
-          ? await tx.${modelNameLower}.guard(shape, caller).findMany(query)
-          : await tx.${modelNameLower}.findMany(query)
-        const t = await countForPagination(tx.${modelNameLower}, query, shape, caller, distinctCountLimit)
+        const d = await tx.${modelNameLower}.findMany(query)
+        const t = await countForPagination(tx.${modelNameLower}, query, undefined, undefined, distinctCountLimit)
         return { d, t }
       })
       items = txResult.d
@@ -526,31 +534,12 @@ export async function findManyPaginated(
         console.warn(
           '[prisma-generator-express] Interactive transactions not available, pagination queries are non-atomic',
         )
-        items = shape
-          ? await (extended as any).${modelNameLower}.guard(shape, caller).findMany(query)
-          : await (extended as any).${modelNameLower}.findMany(query)
-        total = await countForPagination(
-          (extended as any).${modelNameLower},
-          query,
-          shape,
-          caller,
-          distinctCountLimit,
-        )
+        items = await delegate.findMany(query)
+        total = await countForPagination(delegate, query, undefined, undefined, distinctCountLimit)
       } else {
         throw txError
       }
     }
-  } else {
-    items = shape
-      ? await (extended as any).${modelNameLower}.guard(shape, caller).findMany(query)
-      : await (extended as any).${modelNameLower}.findMany(query)
-    total = await countForPagination(
-      (extended as any).${modelNameLower},
-      query,
-      shape,
-      caller,
-      distinctCountLimit,
-    )
   }
 
   const skip = (query.skip as number) ?? 0