prisma-generator-express 1.51.0 → 1.53.0

package/README.md

@@ -12,7 +12,7 @@ Running `npx prisma generate` produces:
 - Handler functions for all Prisma operations (findMany, create, update, delete, etc.)
 - Router generator with middleware support (before/after hooks per operation)
 - POST read endpoints for all read operations (for complex queries exceeding URL length limits)
-- Express-only progressive read streaming over Server-Sent Events (SSE), using manual stages or auto-include splitting for single-record relation reads
+- Express-only progressive read streaming over Server-Sent Events (SSE), using manual stages or auto-include splitting for supported relation reads, including deep `findMany` / `findManyPaginated` auto-include paths
 - Express-only standalone materialized view router for read-only access to registered PostgreSQL materialized views
 - OpenAPI 3.1 spec (JSON and YAML endpoints registered automatically per router)
 - Documentation helpers for contract view and Scalar UI (require manual mounting)
@@ -74,7 +74,7 @@ Some operations require newer versions:
 
 The Hono target v1 is tested on Node.js runtimes only. See [Cloudflare Workers and edge runtimes](#cloudflare-workers-and-edge-runtimes).
 
-Progressive Endpoint Composition over Server-Sent Events is currently supported by the Express target only. Express supports both manual staged streaming and auto-include streaming for single-record relation reads. Fastify and Hono continue to support normal JSON read and write routes.
+Progressive Endpoint Composition over Server-Sent Events is currently supported by the Express target only. Express supports both manual staged streaming and auto-include streaming for supported relation reads, including single-record reads and deep `findMany` / `findManyPaginated` reads within the configured planner limits. Fastify and Hono continue to support normal JSON read and write routes.
 
 ### Database provider support
 
@@ -1558,11 +1558,11 @@ Progressive SSE has two modes:
 | Mode | Config | Best for |
 | ---- | ------ | -------- |
 | Manual stages | `{ stages: [...] }` or `{ mode: 'manual', stages: [...] }` | Custom page-level composition where each stage runs its own query and returns patches |
-| Auto include | `{ mode: 'autoInclude' }` | Single-record reads where the client already sends a Prisma `include` or relation `select` tree and you want relation fields streamed progressively |
+| Auto include | `{ mode: 'autoInclude' }` | Reads where the client already sends a Prisma `include` or relation `select` tree and you want relation fields streamed progressively |
 
 Manual mode is explicit staged data loading. You define stages yourself and each stage decides what query to run and which field path to patch.
 
-Auto-include mode is generated relation loading. The router keeps the normal GET endpoint, runs the root single-record query first, streams root fields, then loads supported included relations as separate follow-up queries and streams each relation path as it resolves.
+Auto-include mode is generated relation loading. The router keeps the normal GET endpoint, runs the root query first, then loads supported included relations as separate follow-up queries. For single-record reads, relation paths are streamed as field patches. For `findMany` and `findManyPaginated`, root rows are streamed first, direct root relation stages are streamed as index-aligned relation batches, and deeper nested relation stages are merged into the final result.
 
 ### Request format
 
@@ -1594,14 +1594,18 @@ Manual progressive SSE can be configured on Express GET read operations only:
 - `aggregate`
 - `groupBy`
 
-Auto-include progressive SSE only supports single-record read operations:
+Auto-include progressive SSE supports these Express GET read operations:
 
 - `findUnique`
 - `findUniqueOrThrow`
 - `findFirst`
 - `findFirstOrThrow`
+- `findMany`
+- `findManyPaginated`
 
-If auto-include is configured on another operation, the router either falls back to single-result SSE or sends an SSE error depending on `fallback`.
+`findMany` and `findManyPaginated` support deep relation loading by flattening parent rows at each relation path, with fallback cases listed in [Auto-include behavior and limits](#auto-include-behavior-and-limits).
+
+If auto-include is configured on an unsupported operation, the router either falls back to single-result SSE or sends an SSE error depending on `fallback`.
 
 Write operations do not support progressive SSE.
 
@@ -1627,6 +1631,18 @@ Nested field event:
 { "type": "field", "key": "profile.appliedTo", "value": [] }
 ```
 
+Root array event for `findMany` / `findManyPaginated` auto-include:
+
+```json
+{ "type": "rootArray", "data": [{ "id": "user-1" }, { "id": "user-2" }] }
+```
+
+Relation batch event for a direct root relation in `findMany` / `findManyPaginated` auto-include:
+
+```json
+{ "type": "relationBatch", "relationPath": "profile", "values": [{ "id": "profile-1" }, null] }
+```
+
 Final result event:
 
 ```json
@@ -1639,7 +1655,11 @@ Error event:
 { "type": "error", "message": "Could not load progressive response" }
 ```
 
-The final `result.data` is the accumulated object built from all applied patches, unless a manual stage returns a stop result.
+For single-record progressive responses, the final `result.data` is the accumulated object built from all applied patches, unless a manual stage returns a stop result.
+
+For `findMany` auto-include responses, `rootArray.data` is the source of truth for root row identity and order. Each depth-1 `relationBatch.values` array is index-aligned with `rootArray.data`, so `values[i]` belongs to `rootArray.data[i]`. Deeper nested stages emit progress events but do not emit relation batches, because their flattened parent indexes are not root-row indexes. The terminal `result.data` is the fully merged array.
+
+For `findManyPaginated` auto-include responses, `pageMeta` is sent before `rootArray`. The terminal `result.data` has the normal paginated shape: `{ data, total, hasMore }`.
 
 ### Manual staged mode
 
@@ -1890,7 +1910,7 @@ const response = await fetch(`/user/unique?${params}`, {
 })
 ```
 
-Auto-include sends root scalar fields first, then sends relation field events as separate relation queries finish:
+On single-record reads, auto-include sends root scalar fields first, then sends relation field events as separate relation queries finish:
 
 ```json
 { "type": "field", "key": "id", "value": "user-id" }
@@ -1906,9 +1926,121 @@ Auto-include sends root scalar fields first, then sends relation field events as
 
 The final `result` event contains the assembled object.
 
+For `findMany`, auto-include sends the root rows first, then sends one relation batch event for each supported direct root relation stage. Nested relation stages emit progress and are included in the final result:
+
+```ts
+const listConfig = {
+  guard: {
+    variantHeader: 'x-api-variant',
+  },
+
+  findMany: {
+    progressive: {
+      list: {
+        enabled: true,
+        mode: 'autoInclude',
+        fallback: 'singleResult',
+      },
+    },
+  },
+}
+
+const params = encodeQueryParams({
+  where: { isActive: true },
+  take: 50,
+  include: {
+    profile: {
+      select: {
+        id: true,
+        displayName: true,
+      },
+    },
+  },
+})
+
+const response = await fetch(`/user?${params}`, {
+  headers: {
+    Accept: 'text/event-stream',
+    'x-api-variant': 'list',
+  },
+})
+```
+
+Example shallow `findMany` auto-include event sequence:
+
+```json
+{ "type": "rootArray", "data": [{ "id": "user-1" }, { "id": "user-2" }] }
+```
+
+```json
+{ "type": "relationBatch", "relationPath": "profile", "values": [{ "id": "profile-1", "displayName": "Alice" }, null] }
+```
+
+```json
+{ "type": "result", "data": [{ "id": "user-1", "profile": { "id": "profile-1", "displayName": "Alice" } }, { "id": "user-2", "profile": null }] }
+```
+
+Deep `findMany` and `findManyPaginated` requests use the same planner. Nested stages are loaded by flattening the parent rows at each path:
+
+```ts
+const params = encodeQueryParams({
+  take: 20,
+  include: {
+    companies: {
+      include: {
+        users: {
+          include: {
+            profile: {
+              select: {
+                id: true,
+                displayName: true,
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+})
+
+const response = await fetch(`/organization/paginated?${params}`, {
+  headers: {
+    Accept: 'text/event-stream',
+    'x-api-variant': 'list',
+  },
+})
+```
+
+Example deep event sequence:
+
+```json
+{ "type": "pageMeta", "total": 120, "hasMore": true }
+```
+
+```json
+{ "type": "rootArray", "data": [{ "id": "org-1" }, { "id": "org-2" }] }
+```
+
+```json
+{ "type": "relationBatch", "relationPath": "companies", "values": [[{ "id": "company-1" }], []] }
+```
+
+```json
+{ "type": "progress", "stage": "companies.users", "completed": 2, "total": 3 }
+```
+
+```json
+{ "type": "progress", "stage": "companies.users.profile", "completed": 3, "total": 3 }
+```
+
+```json
+{ "type": "result", "data": { "data": [{ "id": "org-1", "companies": [{ "id": "company-1", "users": [{ "id": "user-1", "profile": { "id": "profile-1", "displayName": "Alice" } }] }] }, { "id": "org-2", "companies": [] }], "total": 120, "hasMore": true } }
+```
+
+
 ### Auto-include behavior and limits
 
-Auto-include is designed for supported Prisma `include` and relation `select` trees on single-record reads.
+Auto-include is designed for supported Prisma `include` and relation `select` trees on reads.
 
 Supported root operations:
 
@@ -1916,13 +2048,29 @@ Supported root operations:
 - `findUniqueOrThrow`
 - `findFirst`
 - `findFirstOrThrow`
+- `findMany`
+- `findManyPaginated`
 
-Supported relation shapes:
+Supported single-record relation shapes:
 
 - direct to-one relation includes/selects
 - direct to-many relation includes/selects
 - to-many relation args such as `where`, `orderBy`, `take`, `skip`, `cursor`, and `distinct`
-- nested to-one relation loading through to-one parents
+- nested relation loading through to-one parents
+
+Single-record auto-include falls back when a nested stage crosses a to-many parent. Direct to-many loading is still supported, but nested loading under that array is not handled by the single-record progressive runtime.
+
+Supported `findMany` and `findManyPaginated` relation shapes:
+
+- direct and nested to-one relation includes/selects
+- direct and nested to-many relation includes/selects
+- relation-level `where` and `orderBy`
+- single-column link fields only
+- nested depth up to the configured planner limit
+
+For `findMany` and `findManyPaginated`, each stage loads children with a batched query over the flattened parent rows at that stage's `parentPath`. Direct root stages can stream `relationBatch` events. Deeper stages are merged into the server-side result and visible in the terminal `result` event.
+
+`findMany` and `findManyPaginated` auto-include apply configured pagination limits to the root query before loading relation batches. If the client omits `take`, `pagination.defaultLimit` is applied when configured. If the client sends a large `take`, `pagination.maxLimit` is enforced before the root query runs.
 
 Current MVP fallback cases include:
 
@@ -1932,9 +2080,12 @@ Current MVP fallback cases include:
 - `select` and `omit` at the same level
 - relation filters/order/cursor in the root query
 - relation filters/order/cursor inside staged relation queries when unsupported
-- nested relation loading through a to-many parent
 - omitted required link fields needed to stitch parent and child records
 - planner limits for maximum depth or stage count
+- single-record nested relation loading through a to-many parent
+- `findMany` / `findManyPaginated` relation stages with composite link fields
+- `findMany` / `findManyPaginated` to-many relation stages using `take`, `skip`, `cursor`, or `distinct`
+- `createManyAndReturn` and `updateManyAndReturn`
 
 When fallback happens:
 
@@ -1943,6 +2094,8 @@ When fallback happens:
 
 If `fallback` is omitted, the default behavior is equivalent to `'singleResult'`.
 
+`findMany` and `findManyPaginated` auto-include use a batched relation loading strategy. They do not preserve Prisma's per-parent semantics for to-many `take`, `skip`, `cursor`, or `distinct`, so those cases fall back instead of returning silently different data.
+
 Auto-include does not require `resolveContext` or `progressiveStages`.
 
 ### Hooks and guard behavior
@@ -1980,6 +2133,9 @@ if (!response.body) {
 const reader = response.body.getReader()
 const decoder = new TextDecoder()
 let buffer = ''
+let rows: Array<Record<string, unknown>> = []
+let fields: Record<string, unknown> = {}
+let data: unknown = undefined
 
 while (true) {
   const { value, done } = await reader.read()
@@ -1998,12 +2154,23 @@ while (true) {
 
     const event = JSON.parse(line.slice('data: '.length))
 
+    if (event.type === 'rootArray') {
+      rows = event.data
+    }
+
     if (event.type === 'field') {
-      // patch local field state
+      fields[event.key] = event.value
+    }
+
+    if (event.type === 'relationBatch') {
+      rows = rows.map((row, index) => ({
+        ...row,
+        [event.relationPath]: event.values[index],
+      }))
     }
 
     if (event.type === 'result') {
-      // replace with final result
+      data = event.data
     }
   }
 }
@@ -2017,6 +2184,8 @@ For React Query, include the variant and mode in the query key:
 
 Do not reuse the same query key as the JSON endpoint because the same URL can return different shapes depending on `x-api-variant`.
 
+For deep `findMany` / `findManyPaginated` auto-include, consume the final `result` event as the authoritative nested payload. Only direct root relation stages emit `relationBatch` events.
+
 ### Runtime notes
 
 The SSE response sets:

package/dist/generators/generateRouter.js

@@ -234,13 +234,14 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         }
 
         if (progressiveConfig.mode === 'autoInclude') {
-          const isSingleRecordRead =
+          const isAutoIncludeReadable =
             baseOp === 'findUnique' || baseOp === 'findUniqueOrThrow' ||
-            baseOp === 'findFirst' || baseOp === 'findFirstOrThrow'
+            baseOp === 'findFirst' || baseOp === 'findFirstOrThrow' ||
+            baseOp === 'findMany' || baseOp === 'findManyPaginated'
 
-          if (!isSingleRecordRead) {
+          if (!isAutoIncludeReadable) {
             if (progressiveConfig.fallback === 'error') {
-              emitTerminalSSEError(res, 'auto-progressive fallback: operation not single-record')
+              emitTerminalSSEError(res, 'auto-progressive fallback: operation not supported by auto-include')
               return
             }
             await runSingleResultSSE({
@@ -262,7 +263,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
               res,
               ctx,
               args,
-              baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow',
+              baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'findManyPaginated',
               modelName: '${modelName}',
               delegateKey: '${delegateKey}',
               models: relationModels,

package/dist/generators/generateRouter.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateRouter.js","sourceRoot":"","sources":["../../src/generators/generateRouter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateRouter.js","sourceRoot":"","sources":["../../src/generators/generateRouter.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator for Express, Fastify, and Hono CRUD APIs with OpenAPI documentation",
-  "version": "1.51.0",
+  "version": "1.53.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",

package/src/copy/autoIncludePlanner.ts

@@ -269,15 +269,9 @@ function walk(
       isPlainObject(relationArgs.omit)
 
     if (hasNestedProjection) {
-      const stagesBeforeRecursion = ctx.stages.length
-
       const nested = walk(ctx, relation.type, relationPath, relationArgs, depth + 1)
       if (nested.unsupportedReason) return nested
 
-      if (relation.isList && ctx.stages.length > stagesBeforeRecursion) {
-        return { unsupportedReason: 'nested relation through to-many parent not supported in MVP' }
-      }
-
       if (nested.projectionAfterStrip) {
         ctx.stages[stageIndex].stageArgs.select = nested.projectionAfterStrip
       }

package/src/copy/autoIncludeRuntime.ts

@@ -7,11 +7,16 @@ import {
   sendSSEResult,
   sendSSEError,
   sendSSEProgress,
+  sendSSERootArray,
+  sendSSERelationBatch,
+  sendSSEPageMeta,
   runSingleResultSSE,
   emitTerminalSSEError,
   setByPath,
   getDelegate,
   getExtendedClient,
+  applyPaginationLimits,
+  countForPagination,
   mapError,
   type OperationContext,
   type PrismaDelegate,
@@ -19,20 +24,31 @@ import {
 import { isPlainObject } from './misc'
 import {
   planAutoInclude,
+  type AutoIncludePlan,
   type ModelRelationMap,
   type AutoIncludeStage,
 } from './autoIncludePlanner'
 import type { AutoIncludeProgressiveVariantConfig } from './routeConfig'
 
 const STAGE_CONCURRENCY = 4
+const MAX_IN_CHUNK = 1000
+
 type IntervalHandle = ReturnType<typeof setInterval>
 
+export type AutoIncludeBaseOp =
+  | 'findUnique'
+  | 'findUniqueOrThrow'
+  | 'findFirst'
+  | 'findFirstOrThrow'
+  | 'findMany'
+  | 'findManyPaginated'
+
 export type RunAutoIncludeOptions = {
   req: Request
   res: Response
   ctx: OperationContext
   args: Record<string, unknown>
-  baseOp: 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow'
+  baseOp: AutoIncludeBaseOp
   modelName: string
   delegateKey: string
   models: Record<string, ModelRelationMap>
@@ -41,6 +57,11 @@ export type RunAutoIncludeOptions = {
   signal?: AbortSignal
 }
 
+type RowPair = {
+  internal: Record<string, unknown>
+  public: Record<string, unknown>
+}
+
 function readPath(source: Record<string, unknown>, path: string): unknown {
   if (path === '') return source
   const parts = path.split('.')
@@ -122,7 +143,130 @@ function buildPublicForStage(
   return result
 }
 
-async function runOneStage(options: {
+function normalizeKey(v: unknown): string {
+  if (v === null || v === undefined) return '\u0000'
+  if (typeof v === 'bigint') return 'B' + v.toString()
+  if (v instanceof Date) return 'D' + v.getTime().toString()
+  if (typeof v === 'object') return 'O' + JSON.stringify(v)
+  return typeof v + ':' + String(v)
+}
+
+function groupStagesByDepth(stages: AutoIncludeStage[]): AutoIncludeStage[][] {
+  const byDepth = new Map<number, AutoIncludeStage[]>()
+  for (const s of stages) {
+    const arr = byDepth.get(s.depth)
+    if (arr) arr.push(s)
+    else byDepth.set(s.depth, [s])
+  }
+  return Array.from(byDepth.keys())
+    .sort((a, b) => a - b)
+    .map((d) => byDepth.get(d) as AutoIncludeStage[])
+}
+
+async function runConcurrent<T>(
+  items: T[],
+  limit: number,
+  fn: (item: T) => Promise<void>,
+): Promise<void> {
+  let index = 0
+  const workers: Promise<void>[] = []
+  const workerCount = Math.min(limit, items.length)
+  for (let w = 0; w < workerCount; w++) {
+    workers.push((async () => {
+      for (;;) {
+        const i = index++
+        if (i >= items.length) return
+        await fn(items[i])
+      }
+    })())
+  }
+  await Promise.all(workers)
+}
+
+function handleAutoIncludeFallback(
+  options: RunAutoIncludeOptions,
+  message: string,
+): Promise<void> {
+  if (options.variantConfig.fallback === 'error') {
+    emitTerminalSSEError(options.res, message)
+    return Promise.resolve()
+  }
+  return runSingleResultSSE({
+    req: options.req,
+    res: options.res,
+    coreQueryFn: options.coreQueryFn,
+  })
+}
+
+function findManyUnsupportedReason(plan: AutoIncludePlan): string | null {
+  for (const stage of plan.stages) {
+    const rel = stage.relationField
+    if (rel.parentLinkFields.length !== 1 || rel.childLinkFields.length !== 1) {
+      return 'auto-progressive fallback: composite link fields not supported for findMany batched auto-include'
+    }
+    if (rel.isList) {
+      const sa = stage.stageArgs
+      if (
+        sa.take !== undefined ||
+        sa.skip !== undefined ||
+        sa.cursor !== undefined ||
+        sa.distinct !== undefined
+      ) {
+        return 'auto-progressive fallback: per-parent take/skip/cursor/distinct on to-many relations not supported for findMany batched auto-include'
+      }
+    }
+  }
+  return null
+}
+
+function singleUnsupportedReason(plan: AutoIncludePlan): string | null {
+  const stagesByPath = new Map(plan.stages.map((s) => [s.relationPath, s]))
+  for (const stage of plan.stages) {
+    let parentPath = stage.parentPath
+    while (parentPath) {
+      const parentStage = stagesByPath.get(parentPath)
+      if (parentStage?.relationField.isList) {
+        return 'auto-progressive fallback: nested relation through to-many parent is not supported for single-result auto-include'
+      }
+      const dot = parentPath.lastIndexOf('.')
+      parentPath = dot === -1 ? '' : parentPath.slice(0, dot)
+    }
+  }
+  return null
+}
+
+function collectParentPairs(
+  rootPairs: RowPair[],
+  parentPath: string,
+): RowPair[] {
+  if (parentPath === '') return rootPairs
+  let pairs = rootPairs
+  for (const segment of parentPath.split('.')) {
+    const next: RowPair[] = []
+    for (const pair of pairs) {
+      const internalValue = pair.internal[segment]
+      const publicValue = pair.public[segment]
+      if (Array.isArray(internalValue) && Array.isArray(publicValue)) {
+        const length = Math.min(internalValue.length, publicValue.length)
+        for (let i = 0; i < length; i++) {
+          const internalItem = internalValue[i]
+          const publicItem = publicValue[i]
+          if (isPlainObject(internalItem) && isPlainObject(publicItem)) {
+            next.push({ internal: internalItem, public: publicItem })
+          }
+        }
+        continue
+      }
+      if (isPlainObject(internalValue) && isPlainObject(publicValue)) {
+        next.push({ internal: internalValue, public: publicValue })
+      }
+    }
+    pairs = next
+  }
+  return pairs
+}
+
+async function runOneStageSingle(options: {
   extended: unknown
   models: Record<string, ModelRelationMap>
   stage: AutoIncludeStage
@@ -186,72 +330,15 @@ async function runOneStage(options: {
   sendSSEField(res, stage.relationPath, publicResult)
 }
 
-function groupStagesByDepth(stages: AutoIncludeStage[]): AutoIncludeStage[][] {
-  const byDepth = new Map<number, AutoIncludeStage[]>()
-  for (const s of stages) {
-    const arr = byDepth.get(s.depth)
-    if (arr) arr.push(s)
-    else byDepth.set(s.depth, [s])
-  }
-  return Array.from(byDepth.keys())
-    .sort((a, b) => a - b)
-    .map((d) => byDepth.get(d) as AutoIncludeStage[])
-}
-
-async function runConcurrent<T>(
-  items: T[],
-  limit: number,
-  fn: (item: T) => Promise<void>,
-): Promise<void> {
-  let index = 0
-  const workers: Promise<void>[] = []
-  const workerCount = Math.min(limit, items.length)
-  for (let w = 0; w < workerCount; w++) {
-    workers.push((async () => {
-      for (;;) {
-        const i = index++
-        if (i >= items.length) return
-        await fn(items[i])
-      }
-    })())
-  }
-  await Promise.all(workers)
-}
-
-export async function runAutoIncludeProgressive(
+async function runAutoIncludeSingle(
   options: RunAutoIncludeOptions,
+  plan: AutoIncludePlan,
 ): Promise<void> {
-  const { req, res, ctx, args, baseOp, modelName, delegateKey, models, variantConfig, coreQueryFn, signal } = options
+  const { res, ctx, baseOp, delegateKey, models, signal } = options
 
   const isClientGone = () =>
     signal?.aborted === true || res.writableEnded || res.destroyed
 
-  if (ctx.guardShape) {
-    if (variantConfig.fallback === 'error') {
-      emitTerminalSSEError(res, 'auto-progressive fallback: guard shape disables auto-include')
-      return
-    }
-    return runSingleResultSSE({ req, res, coreQueryFn })
-  }
-
-  const plan = planAutoInclude({
-    rootModelName: modelName,
-    models,
-    args,
-  })
-
-  if (plan.unsupportedReason) {
-    if (variantConfig.fallback === 'error') {
-      emitTerminalSSEError(res, plan.unsupportedReason)
-      return
-    }
-    return runSingleResultSSE({ req, res, coreQueryFn })
-  }
-
-  if (plan.stages.length === 0) {
-    return runSingleResultSSE({ req, res, coreQueryFn })
-  }
-
   let keepalive: IntervalHandle | null = null
   try {
     initSSE(res)
@@ -265,7 +352,7 @@ export async function runAutoIncludeProgressive(
 
     let rootResult: unknown
     try {
-      rootResult = await rootDelegate[baseOp](plan.rootArgs)
+      rootResult = await rootDelegate[baseOp as Exclude<AutoIncludeBaseOp, 'findMany' | 'findManyPaginated'>](plan.rootArgs)
     } catch (err) {
       if (isClientGone()) return
       console.error('[auto-progressive] root query failed:', err)
@@ -309,7 +396,7 @@ export async function runAutoIncludeProgressive(
       await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
         if (isAborted()) return
         try {
-          await runOneStage({
+          await runOneStageSingle({
             extended,
             models,
             stage,
@@ -351,4 +438,465 @@ export async function runAutoIncludeProgressive(
   } finally {
     endSSE(res, keepalive)
   }
+}
+
+function buildStageQueryArgs(
+  stage: AutoIncludeStage,
+  childKey: string,
+  inChunk: unknown[],
+): { args: Record<string, unknown>; injectedChildPath: string | null } {
+  const baseSelect = isPlainObject(stage.stageArgs.select)
+    ? (stage.stageArgs.select as Record<string, unknown>)
+    : null
+  const baseOmit = isPlainObject(stage.stageArgs.omit)
+    ? (stage.stageArgs.omit as Record<string, unknown>)
+    : null
+
+  const finalArgs: Record<string, unknown> = { ...stage.stageArgs }
+  finalArgs.where = mergeWhere(stage.stageArgs.where, { [childKey]: { in: inChunk } })
+
+  let injectedChildPath: string | null = null
+
+  if (baseSelect) {
+    if (baseSelect[childKey] !== true) {
+      finalArgs.select = { ...baseSelect, [childKey]: true }
+      injectedChildPath = stage.relationPath + '.' + childKey
+    }
+  }
+
+  if (baseOmit && baseOmit[childKey] === true) {
+    const nextOmit: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(baseOmit)) {
+      if (k === childKey) continue
+      nextOmit[k] = v
+    }
+    if (Object.keys(nextOmit).length > 0) {
+      finalArgs.omit = nextOmit
+    } else {
+      delete finalArgs.omit
+    }
+    injectedChildPath = stage.relationPath + '.' + childKey
+  }
+
+  return { args: finalArgs, injectedChildPath }
+}
+
+function collectDistinctParentValues(
+  rows: Record<string, unknown>[],
+  parentKey: string,
+): unknown[] {
+  const seen = new Set<string>()
+  const out: unknown[] = []
+  for (const row of rows) {
+    const v = row[parentKey]
+    if (v === undefined || v === null) continue
+    const k = normalizeKey(v)
+    if (seen.has(k)) continue
+    seen.add(k)
+    out.push(v)
+  }
+  return out
+}
+
+function groupRelatedRows(
+  children: unknown[],
+  childKey: string,
+): Map<string, unknown[]> {
+  const grouped = new Map<string, unknown[]>()
+  for (const child of children) {
+    if (!isPlainObject(child)) continue
+    const k = child[childKey]
+    if (k === undefined || k === null) continue
+    const key = normalizeKey(k)
+    let arr = grouped.get(key)
+    if (!arr) {
+      arr = []
+      grouped.set(key, arr)
+    }
+    arr.push(child)
+  }
+  return grouped
+}
+
+async function runOneStageMany(options: {
+  extended: unknown
+  models: Record<string, ModelRelationMap>
+  stage: AutoIncludeStage
+  parentPairs: RowPair[]
+  internalFieldPaths: string[]
+  res: Response
+  isAborted: () => boolean
+}): Promise<void> {
+  const { extended, models, stage, parentPairs, internalFieldPaths, res, isAborted } = options
+
+  if (isAborted()) return
+
+  const rel = stage.relationField
+  const parentKey = rel.parentLinkFields[0]
+  const childKey = rel.childLinkFields[0]
+
+  const targetModel = models[rel.type]
+  if (!targetModel) {
+    throw new Error('Target model not in relation metadata: ' + rel.type)
+  }
+
+  if (parentPairs.length === 0) {
+    if (stage.depth === 1) {
+      sendSSERelationBatch(res, stage.relationPath, [])
+    }
+    return
+  }
+
+  const internalParents = parentPairs.map((p) => p.internal)
+  const distinctValues = collectDistinctParentValues(internalParents, parentKey)
+  const delegate: PrismaDelegate = getDelegate(extended, targetModel.delegateKey)
+
+  const children: unknown[] = []
+  let injectedChildPath: string | null = null
+
+  for (let i = 0; i < distinctValues.length; i += MAX_IN_CHUNK) {
+    if (isAborted()) return
+    const chunk = distinctValues.slice(i, i + MAX_IN_CHUNK)
+    const { args, injectedChildPath: ip } = buildStageQueryArgs(stage, childKey, chunk)
+    if (ip) injectedChildPath = ip
+    const partial = await delegate.findMany(args)
+    if (isAborted()) return
+    if (Array.isArray(partial)) {
+      for (const c of partial) children.push(c)
+    }
+  }
+
+  const effectivePaths = injectedChildPath
+    ? [...internalFieldPaths, injectedChildPath]
+    : internalFieldPaths
+
+  const grouped = groupRelatedRows(children, childKey)
+  const publicValues: unknown[] = new Array(parentPairs.length)
+
+  for (let i = 0; i < parentPairs.length; i++) {
+    const pair = parentPairs[i]
+    const fkVal = pair.internal[parentKey]
+    let internalVal: unknown
+
+    if (fkVal === undefined || fkVal === null) {
+      internalVal = emptyResultFor(rel.isList)
+    } else {
+      const matches = grouped.get(normalizeKey(fkVal)) ?? []
+      if (rel.isList) {
+        internalVal = matches
+      } else {
+        internalVal = matches.length > 0 ? matches[0] : null
+      }
+    }
+
+    const publicVal = buildPublicForStage(internalVal, effectivePaths, stage.relationPath)
+
+    pair.internal[stage.relationName] = internalVal
+    pair.public[stage.relationName] = publicVal
+    publicValues[i] = publicVal
+  }
+
+  if (isAborted()) return
+
+  if (stage.depth === 1) {
+    sendSSERelationBatch(res, stage.relationPath, publicValues)
+  }
+}
+
+function buildRootPairs(
+  rootRows: unknown[],
+  internalFieldPaths: string[],
+): { publicRows: Record<string, unknown>[]; rootPairs: RowPair[] } {
+  const n = rootRows.length
+  const publicRows: Record<string, unknown>[] = new Array(n)
+  const rootPairs: RowPair[] = new Array(n)
+  for (let i = 0; i < n; i++) {
+    const row = rootRows[i]
+    if (!isPlainObject(row)) {
+      const internalEmpty: Record<string, unknown> = {}
+      const publicEmpty: Record<string, unknown> = {}
+      publicRows[i] = publicEmpty
+      rootPairs[i] = { internal: internalEmpty, public: publicEmpty }
+      continue
+    }
+    const internalCopy: Record<string, unknown> = { ...row }
+    const publicCopy: Record<string, unknown> = { ...row }
+    stripInternalAtScope(publicCopy, internalFieldPaths, '')
+    publicRows[i] = publicCopy
+    rootPairs[i] = { internal: internalCopy, public: publicCopy }
+  }
+  return { publicRows, rootPairs }
+}
+
+async function processFindManyStages(args: {
+  extended: unknown
+  models: Record<string, ModelRelationMap>
+  plan: AutoIncludePlan
+  rootPairs: RowPair[]
+  res: Response
+  signal?: AbortSignal
+}): Promise<string | null> {
+  const { extended, models, plan, rootPairs, res, signal } = args
+  const groups = groupStagesByDepth(plan.stages)
+  let completed = 0
+  let stageErrorMessage: string | null = null
+  const isAborted = () =>
+    stageErrorMessage !== null ||
+    signal?.aborted === true ||
+    res.writableEnded ||
+    res.destroyed
+
+  for (const group of groups) {
+    if (signal?.aborted === true || res.writableEnded || res.destroyed) return stageErrorMessage
+    if (stageErrorMessage) break
+
+    await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
+      if (isAborted()) return
+      const parentPairs = collectParentPairs(rootPairs, stage.parentPath)
+      try {
+        await runOneStageMany({
+          extended,
+          models,
+          stage,
+          parentPairs,
+          internalFieldPaths: plan.internalFieldPaths,
+          res,
+          isAborted,
+        })
+      } catch (err) {
+        if (isAborted()) return
+        console.error('[auto-progressive] stage failed:', stage.relationPath, err)
+        stageErrorMessage = mapError(err).message
+        return
+      }
+      if (isAborted()) return
+      completed++
+      sendSSEProgress(res, stage.relationPath, completed, plan.stages.length)
+    })
+  }
+  return stageErrorMessage
+}
+
+async function runPaginatedRoot(
+  extended: unknown,
+  rootDelegate: PrismaDelegate,
+  delegateKey: string,
+  rootArgs: Record<string, unknown>,
+  distinctCountLimit: number | undefined,
+): Promise<{ data: unknown[]; count: number }> {
+  const txClient = extended as {
+    $transaction?: <T>(fn: (tx: unknown) => Promise<T>) => Promise<T>
+  }
+
+  if (typeof txClient.$transaction === 'function') {
+    try {
+      const result = await txClient.$transaction(async (tx: unknown) => {
+        const txDelegate = getDelegate(tx, delegateKey)
+        const d = await txDelegate.findMany(rootArgs)
+        const t = await countForPagination(txDelegate, rootArgs, undefined, undefined, distinctCountLimit)
+        return { d, t }
+      })
+      return { data: result.d as unknown[], count: result.t }
+    } catch (err) {
+      const e = err as { code?: string }
+      if (e?.code !== 'P2028') throw err
+      console.warn('[auto-progressive] Interactive transactions not available, paginated queries are non-atomic')
+    }
+  }
+
+  const [data, count] = await Promise.all([
+    rootDelegate.findMany(rootArgs),
+    countForPagination(rootDelegate, rootArgs, undefined, undefined, distinctCountLimit),
+  ])
+  return { data: data as unknown[], count }
+}
+
+async function runAutoIncludeMany(
+  options: RunAutoIncludeOptions,
+  plan: AutoIncludePlan,
+): Promise<void> {
+  const { res, ctx, delegateKey, models, signal } = options
+
+  const isClientGone = () =>
+    signal?.aborted === true || res.writableEnded || res.destroyed
+
+  let keepalive: IntervalHandle | null = null
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    if (isClientGone()) return
+
+    const extended = await getExtendedClient(ctx)
+    if (isClientGone()) return
+
+    const rootDelegate = getDelegate(extended, delegateKey)
+    const rootArgs = applyPaginationLimits(plan.rootArgs, ctx.paginationConfig)
+
+    let rootResult: unknown
+    try {
+      rootResult = await rootDelegate.findMany(rootArgs)
+    } catch (err) {
+      if (isClientGone()) return
+      console.error('[auto-progressive] root findMany failed:', err)
+      sendSSEError(res, mapError(err).message)
+      return
+    }
+
+    if (isClientGone()) return
+
+    if (!Array.isArray(rootResult)) {
+      sendSSEError(res, 'auto-progressive: unexpected non-array root result for findMany')
+      return
+    }
+
+    const { publicRows, rootPairs } = buildRootPairs(rootResult, plan.internalFieldPaths)
+
+    sendSSERootArray(res, publicRows)
+    sendSSEProgress(res, 'root', 0, plan.stages.length)
+
+    const stageError = await processFindManyStages({
+      extended, models, plan, rootPairs, res, signal,
+    })
+
+    if (isClientGone()) return
+
+    if (stageError) {
+      if (!res.writableEnded && !res.destroyed) {
+        sendSSEError(res, stageError)
+      }
+      return
+    }
+
+    if (res.writableEnded || res.destroyed) return
+    sendSSEResult(res, publicRows)
+  } catch (err) {
+    if (isClientGone()) return
+    console.error('[auto-progressive] many dispatch error:', err)
+    if (!res.writableEnded && !res.destroyed) {
+      sendSSEError(res, mapError(err).message)
+    }
+  } finally {
+    endSSE(res, keepalive)
+  }
+}
+
+async function runAutoIncludePaginated(
+  options: RunAutoIncludeOptions,
+  plan: AutoIncludePlan,
+): Promise<void> {
+  const { res, ctx, delegateKey, models, signal } = options
+
+  const isClientGone = () =>
+    signal?.aborted === true || res.writableEnded || res.destroyed
+
+  let keepalive: IntervalHandle | null = null
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    if (isClientGone()) return
+
+    const extended = await getExtendedClient(ctx)
+    if (isClientGone()) return
+
+    const rootDelegate = getDelegate(extended, delegateKey)
+    const rootArgs = applyPaginationLimits(plan.rootArgs, ctx.paginationConfig)
+    const distinctCountLimit = ctx.paginationConfig?.distinctCountLimit
+
+    let rootRows: unknown[]
+    let total: number
+    try {
+      const { data, count } = await runPaginatedRoot(
+        extended, rootDelegate, delegateKey, rootArgs, distinctCountLimit,
+      )
+      rootRows = data
+      total = count
+    } catch (err) {
+      if (isClientGone()) return
+      console.error('[auto-progressive] root findManyPaginated failed:', err)
+      sendSSEError(res, mapError(err).message)
+      return
+    }
+
+    if (isClientGone()) return
+
+    const skip = typeof rootArgs.skip === 'number' ? rootArgs.skip : 0
+    const takeRaw = typeof rootArgs.take === 'number' ? rootArgs.take : rootRows.length
+    const absTake = Math.abs(takeRaw)
+    const hasMore = rootRows.length >= absTake && skip + rootRows.length < total
+
+    const { publicRows, rootPairs } = buildRootPairs(rootRows, plan.internalFieldPaths)
+
+    sendSSEPageMeta(res, total, hasMore)
+    sendSSERootArray(res, publicRows)
+    sendSSEProgress(res, 'root', 0, plan.stages.length)
+
+    const stageError = await processFindManyStages({
+      extended, models, plan, rootPairs, res, signal,
+    })
+
+    if (isClientGone()) return
+
+    if (stageError) {
+      if (!res.writableEnded && !res.destroyed) {
+        sendSSEError(res, stageError)
+      }
+      return
+    }
+
+    if (res.writableEnded || res.destroyed) return
+    sendSSEResult(res, { data: publicRows, total, hasMore })
+  } catch (err) {
+    if (isClientGone()) return
+    console.error('[auto-progressive] paginated dispatch error:', err)
+    if (!res.writableEnded && !res.destroyed) {
+      sendSSEError(res, mapError(err).message)
+    }
+  } finally {
+    endSSE(res, keepalive)
+  }
+}
+
+export async function runAutoIncludeProgressive(
+  options: RunAutoIncludeOptions,
+): Promise<void> {
+  if (options.ctx.guardShape) {
+    return handleAutoIncludeFallback(
+      options,
+      'auto-progressive fallback: guard shape disables auto-include',
+    )
+  }
+
+  const plan = planAutoInclude({
+    rootModelName: options.modelName,
+    models: options.models,
+    args: options.args,
+  })
+
+  if (plan.unsupportedReason) {
+    return handleAutoIncludeFallback(options, plan.unsupportedReason)
+  }
+
+  if (options.baseOp === 'findMany' || options.baseOp === 'findManyPaginated') {
+    const reason = findManyUnsupportedReason(plan)
+    if (reason) return handleAutoIncludeFallback(options, reason)
+  } else {
+    const reason = singleUnsupportedReason(plan)
+    if (reason) return handleAutoIncludeFallback(options, reason)
+  }
+
+  if (plan.stages.length === 0) {
+    return runSingleResultSSE({
+      req: options.req,
+      res: options.res,
+      coreQueryFn: options.coreQueryFn,
+    })
+  }
+
+  if (options.baseOp === 'findMany') {
+    return runAutoIncludeMany(options, plan)
+  }
+  if (options.baseOp === 'findManyPaginated') {
+    return runAutoIncludePaginated(options, plan)
+  }
+  return runAutoIncludeSingle(options, plan)
 }

package/src/copy/operationRuntime.ts

@@ -491,6 +491,26 @@ export function sendSSEResult(res: SseWritable, data: unknown): boolean {
   return sendSSE(res, { type: 'result', data })
 }
 
+export function sendSSERootArray(res: SseWritable, rows: unknown[]): boolean {
+  return sendSSE(res, { type: 'rootArray', data: rows })
+}
+
+export function sendSSERelationBatch(
+  res: SseWritable,
+  relationPath: string,
+  values: unknown[],
+): boolean {
+  return sendSSE(res, { type: 'relationBatch', relationPath, values })
+}
+
+export function sendSSEPageMeta(
+  res: SseWritable,
+  total: number,
+  hasMore: boolean,
+): boolean {
+  return sendSSE(res, { type: 'pageMeta', total, hasMore })
+}
+
 export function sendSSEError(res: SseWritable, message: string): boolean {
   if (res.writableEnded || res.destroyed) return false
   try {

package/src/generators/generateRouter.ts

@@ -250,13 +250,14 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
         }
 
         if (progressiveConfig.mode === 'autoInclude') {
-          const isSingleRecordRead =
+          const isAutoIncludeReadable =
             baseOp === 'findUnique' || baseOp === 'findUniqueOrThrow' ||
-            baseOp === 'findFirst' || baseOp === 'findFirstOrThrow'
+            baseOp === 'findFirst' || baseOp === 'findFirstOrThrow' ||
+            baseOp === 'findMany' || baseOp === 'findManyPaginated'
 
-          if (!isSingleRecordRead) {
+          if (!isAutoIncludeReadable) {
             if (progressiveConfig.fallback === 'error') {
-              emitTerminalSSEError(res, 'auto-progressive fallback: operation not single-record')
+              emitTerminalSSEError(res, 'auto-progressive fallback: operation not supported by auto-include')
               return
             }
             await runSingleResultSSE({
@@ -278,7 +279,7 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
               res,
               ctx,
               args,
-              baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow',
+              baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'findManyPaginated',
               modelName: '${modelName}',
               delegateKey: '${delegateKey}',
               models: relationModels,