prisma-generator-express 1.51.0 → 1.52.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
 - 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 limited `findMany` reads. 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`, direct root relations are loaded in batches and streamed as index-aligned relation batches.
 
 ### Request format
 
@@ -1594,14 +1594,17 @@ 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`
+
+`findMany` support is intentionally narrower than single-record support. It supports direct root relation loading only, with additional fallback cases listed in [Auto-include behavior and limits](#auto-include-behavior-and-limits).
 
-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`.
+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 +1630,18 @@ Nested field event:
 { "type": "field", "key": "profile.appliedTo", "value": [] }
 ```
 
+Root array event for `findMany` auto-include:
+
+```json
+{ "type": "rootArray", "data": [{ "id": "user-1" }, { "id": "user-2" }] }
+```
+
+Relation batch event for `findMany` auto-include:
+
+```json
+{ "type": "relationBatch", "relationPath": "profile", "values": [{ "id": "profile-1" }, null] }
+```
+
 Final result event:
 
 ```json
@@ -1639,7 +1654,9 @@ 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 `relationBatch.values` array is index-aligned with `rootArray.data`, so `values[i]` belongs to `rootArray.data[i]`. The terminal `result.data` is the fully merged array.
 
 ### Manual staged mode
 
@@ -1890,7 +1907,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 +1923,63 @@ 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 per supported relation stage:
+
+```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 `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 }] }
+```
+
 ### 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,14 +1987,24 @@ Supported root operations:
 - `findUniqueOrThrow`
 - `findFirst`
 - `findFirstOrThrow`
+- `findMany`
 
-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
 
+Supported `findMany` relation shapes:
+
+- direct root to-one relation includes/selects
+- direct root to-many relation includes/selects
+- relation-level `where` and `orderBy`
+- single-column link fields only
+
+`findMany` auto-include applies 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:
 
 - `_count` in `select` or `include`
@@ -1935,6 +2016,10 @@ Current MVP fallback cases include:
 - 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
+- `findMany` relation stages with composite link fields
+- `findMany` nested relation stages deeper than direct root relations
+- `findMany` to-many relation stages using `take`, `skip`, `cursor`, or `distinct`
+- `findManyPaginated`, `createManyAndReturn`, and `updateManyAndReturn`
 
 When fallback happens:
 
@@ -1943,6 +2028,8 @@ When fallback happens:
 
 If `fallback` is omitted, the default behavior is equivalent to `'singleResult'`.
 
+`findMany` auto-include uses a batched relation loading strategy. It does 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 +2067,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 +2088,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
     }
   }
 }

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'
 
-          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',
               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.52.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",

package/src/copy/autoIncludeRuntime.ts

@@ -7,11 +7,14 @@ import {
   sendSSEResult,
   sendSSEError,
   sendSSEProgress,
+  sendSSERootArray,
+  sendSSERelationBatch,
   runSingleResultSSE,
   emitTerminalSSEError,
   setByPath,
   getDelegate,
   getExtendedClient,
+  applyPaginationLimits,
   mapError,
   type OperationContext,
   type PrismaDelegate,
@@ -19,20 +22,30 @@ 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'
+
 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>
@@ -122,7 +135,86 @@ 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 (stage.depth > 1) {
+      return 'auto-progressive fallback: nested relations 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
+}
+
+async function runOneStageSingle(options: {
   extended: unknown
   models: Record<string, ModelRelationMap>
   stage: AutoIncludeStage
@@ -186,72 +278,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 +300,7 @@ export async function runAutoIncludeProgressive(
 
     let rootResult: unknown
     try {
-      rootResult = await rootDelegate[baseOp](plan.rootArgs)
+      rootResult = await rootDelegate[baseOp as Exclude<AutoIncludeBaseOp, 'findMany'>](plan.rootArgs)
     } catch (err) {
       if (isClientGone()) return
       console.error('[auto-progressive] root query failed:', err)
@@ -309,7 +344,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 +386,317 @@ 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
+  internalRows: Record<string, unknown>[]
+  publicRows: Record<string, unknown>[]
+  internalFieldPaths: string[]
+  res: Response
+  isAborted: () => boolean
+}): Promise<void> {
+  const {
+    extended, models, stage, internalRows, publicRows,
+    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)
+  }
+
+  const distinctValues = collectDistinctParentValues(internalRows, 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(internalRows.length)
+
+  for (let i = 0; i < internalRows.length; i++) {
+    const row = internalRows[i]
+    const fkVal = row[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)
+
+    internalRows[i][stage.relationName] = internalVal
+    publicRows[i][stage.relationName] = publicVal
+    publicValues[i] = publicVal
+  }
+
+  if (isAborted()) return
+  sendSSERelationBatch(res, stage.relationPath, publicValues)
+}
+
+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 internalRows: Record<string, unknown>[] = new Array(rootResult.length)
+    const publicRows: Record<string, unknown>[] = new Array(rootResult.length)
+
+    for (let i = 0; i < rootResult.length; i++) {
+      const row = rootResult[i]
+      if (!isPlainObject(row)) {
+        internalRows[i] = {}
+        publicRows[i] = {}
+        continue
+      }
+      const internalCopy: Record<string, unknown> = { ...row }
+      const publicCopy: Record<string, unknown> = { ...row }
+      stripInternalAtScope(publicCopy, plan.internalFieldPaths, '')
+      internalRows[i] = internalCopy
+      publicRows[i] = publicCopy
+    }
+
+    sendSSERootArray(res, publicRows)
+    sendSSEProgress(res, 'root', 0, plan.stages.length)
+
+    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 (isClientGone()) return
+      if (stageErrorMessage) break
+
+      await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
+        if (isAborted()) return
+        try {
+          await runOneStageMany({
+            extended,
+            models,
+            stage,
+            internalRows,
+            publicRows,
+            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)
+      })
+    }
+
+    if (isClientGone()) return
+
+    if (stageErrorMessage) {
+      if (!res.writableEnded && !res.destroyed) {
+        sendSSEError(res, stageErrorMessage)
+      }
+      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)
+  }
+}
+
+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') {
+    const reason = findManyUnsupportedReason(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)
+  }
+  return runAutoIncludeSingle(options, plan)
 }

package/src/copy/operationRuntime.ts

@@ -491,6 +491,18 @@ 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 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'
 
-          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',
               modelName: '${modelName}',
               delegateKey: '${delegateKey}',
               models: relationModels,