prisma-generator-express 1.59.0 → 1.61.0

package/src/copy/autoIncludeRuntime.ts

@@ -1,8 +1,6 @@
 import type { Request, Response } from 'express'
+import { HttpError, LOG_PREFIX, mapError } from './errorMapper'
 import {
-  initSSE,
-  endSSE,
-  startSSEKeepalive,
   sendSSEField,
   sendSSEResult,
   sendSSEError,
@@ -13,18 +11,20 @@ import {
   sendSSEPageMeta,
   runSingleResultSSE,
   emitTerminalSSEError,
+  safeSendError,
   setByPath,
+  withSSE,
+} from './sse'
+import { applyPaginationLimits, countForPagination } from './pagination'
+import {
   getDelegate,
   getExtendedClient,
-  applyPaginationLimits,
-  countForPagination,
-  mapError,
-  HttpError,
   type OperationContext,
   type PrismaDelegate,
   type FindManyPaginatedMode,
 } from './operationRuntime'
 import { isPlainObject } from './misc'
+import { mapLimited } from './concurrency'
 import {
   planAutoInclude,
   type AutoIncludePlan,
@@ -32,12 +32,14 @@ import {
   type AutoIncludeStage,
 } from './autoIncludePlanner'
 import type { AutoIncludeProgressiveVariantConfig } from './routeConfig'
+import {
+  isGuardedAutoIncludeBaseOp,
+  runGuardedAutoIncludeProgressive,
+} from './autoIncludeRuntimeGuarded'
 
 const STAGE_CONCURRENCY = 4
 const MAX_IN_CHUNK = 1000
 
-type IntervalHandle = ReturnType<typeof setInterval>
-
 export type AutoIncludeBaseOp =
   | 'findUnique'
   | 'findUniqueOrThrow'
@@ -69,6 +71,13 @@ type ParentEntry = RowPair & {
   locator: Array<number | string>
 }
 
+function createClientGoneChecker(
+  res: Response,
+  signal?: AbortSignal,
+): () => boolean {
+  return () => signal?.aborted === true || res.writableEnded || res.destroyed
+}
+
 function readPath(source: Record<string, unknown>, path: string): unknown {
   if (path === '') return source
   const parts = path.split('.')
@@ -85,16 +94,11 @@ function stripInternalAtScope(
   internalPaths: string[],
   scopePath: string,
 ): void {
+  const prefix = scopePath === '' ? '' : scopePath + '.'
   for (const fullPath of internalPaths) {
-    if (scopePath === '') {
-      if (!fullPath.includes('.')) {
-        delete target[fullPath]
-      }
-      continue
-    }
-    if (!fullPath.startsWith(scopePath + '.')) continue
-    const relative = fullPath.slice(scopePath.length + 1)
-    if (relative.includes('.')) continue
+    if (!fullPath.startsWith(prefix)) continue
+    const relative = fullPath.slice(prefix.length)
+    if (relative === '' || relative.includes('.')) continue
     delete target[relative]
   }
 }
@@ -103,7 +107,8 @@ function mergeWhere(
   userWhere: unknown,
   linkFilter: Record<string, unknown>,
 ): Record<string, unknown> {
-  if (!isPlainObject(userWhere) || Object.keys(userWhere).length === 0) return linkFilter
+  if (!isPlainObject(userWhere) || Object.keys(userWhere).length === 0)
+    return linkFilter
   return { AND: [userWhere, linkFilter] }
 }
 
@@ -132,22 +137,14 @@ function buildPublicForStage(
   internalFieldPaths: string[],
   scopePath: string,
 ): unknown {
-  if (Array.isArray(result)) {
-    return result.map((item) => {
-      if (isPlainObject(item)) {
-        const copy: Record<string, unknown> = { ...item }
-        stripInternalAtScope(copy, internalFieldPaths, scopePath)
-        return copy
-      }
-      return item
-    })
-  }
-  if (isPlainObject(result)) {
-    const copy: Record<string, unknown> = { ...result }
+  const process = (item: unknown): unknown => {
+    if (!isPlainObject(item)) return item
+    const copy: Record<string, unknown> = { ...item }
     stripInternalAtScope(copy, internalFieldPaths, scopePath)
     return copy
   }
-  return result
+  if (Array.isArray(result)) return result.map(process)
+  return process(result)
 }
 
 function normalizeKey(v: unknown): string {
@@ -170,26 +167,6 @@ function groupStagesByDepth(stages: AutoIncludeStage[]): AutoIncludeStage[][] {
     .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,
@@ -297,7 +274,16 @@ async function runOneStageSingle(options: {
   res: Response
   isAborted: () => boolean
 }): Promise<void> {
-  const { extended, models, stage, internal, publicState, internalFieldPaths, res, isAborted } = options
+  const {
+    extended,
+    models,
+    stage,
+    internal,
+    publicState,
+    internalFieldPaths,
+    res,
+    isAborted,
+  } = options
   if (isAborted()) return
 
   const parentRaw = readPath(internal, stage.parentPath)
@@ -322,28 +308,46 @@ async function runOneStageSingle(options: {
 
   const targetModel = models[stage.relationField.type]
   if (!targetModel) {
-    throw new Error('Target model not in relation metadata: ' + stage.relationField.type)
+    throw new HttpError(
+      500,
+      'Target model not in relation metadata: ' + stage.relationField.type,
+    )
   }
 
   const finalArgs: Record<string, unknown> = { ...stage.stageArgs }
   finalArgs.where = mergeWhere(stage.stageArgs.where, linkFilter)
 
-  const delegate: PrismaDelegate = getDelegate(extended, targetModel.delegateKey)
-  const method: 'findMany' | 'findFirst' = stage.relationField.isList ? 'findMany' : 'findFirst'
+  const delegate: PrismaDelegate = getDelegate(
+    extended,
+    targetModel.delegateKey,
+  )
+  const method: 'findMany' | 'findFirst' = stage.relationField.isList
+    ? 'findMany'
+    : 'findFirst'
   const result = await delegate[method](finalArgs)
 
   if (isAborted()) return
 
   const appliedInternal = setByPath(internal, stage.relationPath, result)
   if (!appliedInternal) {
-    throw new Error('Failed to apply internal patch for ' + stage.relationPath)
+    throw new HttpError(
+      500,
+      'Failed to apply internal patch for ' + stage.relationPath,
+    )
   }
 
-  const publicResult = buildPublicForStage(result, internalFieldPaths, stage.relationPath)
+  const publicResult = buildPublicForStage(
+    result,
+    internalFieldPaths,
+    stage.relationPath,
+  )
 
   const appliedPublic = setByPath(publicState, stage.relationPath, publicResult)
   if (!appliedPublic) {
-    throw new Error('Failed to apply public patch for ' + stage.relationPath)
+    throw new HttpError(
+      500,
+      'Failed to apply public patch for ' + stage.relationPath,
+    )
   }
 
   sendSSEField(res, stage.relationPath, publicResult)
@@ -354,16 +358,9 @@ async function runAutoIncludeSingle(
   plan: AutoIncludePlan,
 ): Promise<void> {
   const { res, ctx, baseOp, delegateKey, models, signal } = options
+  const isClientGone = createClientGoneChecker(res, signal)
 
-  const isClientGone = () =>
-    signal?.aborted === true || res.writableEnded || res.destroyed
-
-  let keepalive: IntervalHandle | null = null
-  try {
-    initSSE(res)
-    keepalive = startSSEKeepalive(res)
-    if (isClientGone()) return
-
+  await withSSE({ res, signal, label: 'single' }, async () => {
     const extended = await getExtendedClient(ctx)
     if (isClientGone()) return
 
@@ -371,10 +368,12 @@ async function runAutoIncludeSingle(
 
     let rootResult: unknown
     try {
-      rootResult = await rootDelegate[baseOp as Exclude<AutoIncludeBaseOp, 'findMany' | 'findManyPaginated'>](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)
+      console.error(LOG_PREFIX, 'root query failed:', err)
       sendSSEError(res, mapError(err).message)
       return
     }
@@ -414,7 +413,7 @@ async function runAutoIncludeSingle(
       if (isClientGone()) return
       if (stageErrorMessage) break
 
-      await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
+      await mapLimited(group, STAGE_CONCURRENCY, async (stage) => {
         if (isAborted()) return
         try {
           await runOneStageSingle({
@@ -429,13 +428,18 @@ async function runAutoIncludeSingle(
           })
         } catch (err) {
           if (isAborted()) return
-          console.error('[auto-progressive] stage failed:', stage.relationPath, err)
+          console.error(LOG_PREFIX, 'stage failed:', stage.relationPath, err)
           stageErrorMessage = mapError(err).message
           return
         }
         if (isAborted()) return
         completed++
-        const ok = sendSSEProgress(res, stage.relationPath, completed, plan.stages.length)
+        const ok = sendSSEProgress(
+          res,
+          stage.relationPath,
+          completed,
+          plan.stages.length,
+        )
         if (!ok) return
       })
     }
@@ -443,23 +447,13 @@ async function runAutoIncludeSingle(
     if (isClientGone()) return
 
     if (stageErrorMessage) {
-      if (!res.writableEnded && !res.destroyed) {
-        sendSSEError(res, stageErrorMessage)
-      }
+      safeSendError(res, stageErrorMessage)
       return
     }
 
     if (res.writableEnded || res.destroyed) return
     sendSSEResult(res, publicState)
-  } catch (err) {
-    if (isClientGone()) return
-    console.error('[auto-progressive] dispatch error:', err)
-    if (!res.writableEnded && !res.destroyed) {
-      sendSSEError(res, mapError(err).message)
-    }
-  } finally {
-    endSSE(res, keepalive)
-  }
+  })
 }
 
 function buildStageQueryArgs(
@@ -475,7 +469,9 @@ function buildStageQueryArgs(
     : null
 
   const finalArgs: Record<string, unknown> = { ...stage.stageArgs }
-  finalArgs.where = mergeWhere(stage.stageArgs.where, { [childKey]: { in: inChunk } })
+  finalArgs.where = mergeWhere(stage.stageArgs.where, {
+    [childKey]: { in: inChunk },
+  })
 
   let injectedChildPath: string | null = null
 
@@ -487,11 +483,7 @@ function buildStageQueryArgs(
   }
 
   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
-    }
+    const { [childKey]: _drop, ...nextOmit } = baseOmit
     if (Object.keys(nextOmit).length > 0) {
       finalArgs.omit = nextOmit
     } else {
@@ -549,7 +541,15 @@ async function runOneStageMany(options: {
   res: Response
   isAborted: () => boolean
 }): Promise<void> {
-  const { extended, models, stage, parentEntries, internalFieldPaths, res, isAborted } = options
+  const {
+    extended,
+    models,
+    stage,
+    parentEntries,
+    internalFieldPaths,
+    res,
+    isAborted,
+  } = options
 
   if (isAborted()) return
 
@@ -559,7 +559,10 @@ async function runOneStageMany(options: {
 
   const targetModel = models[rel.type]
   if (!targetModel) {
-    throw new Error('Target model not in relation metadata: ' + rel.type)
+    throw new HttpError(
+      500,
+      'Target model not in relation metadata: ' + rel.type,
+    )
   }
 
   if (parentEntries.length === 0) {
@@ -573,7 +576,10 @@ async function runOneStageMany(options: {
 
   const internalParents = parentEntries.map((p) => p.internal)
   const distinctValues = collectDistinctParentValues(internalParents, parentKey)
-  const delegate: PrismaDelegate = getDelegate(extended, targetModel.delegateKey)
+  const delegate: PrismaDelegate = getDelegate(
+    extended,
+    targetModel.delegateKey,
+  )
 
   const children: unknown[] = []
   let injectedChildPath: string | null = null
@@ -581,7 +587,11 @@ async function runOneStageMany(options: {
   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)
+    const { args, injectedChildPath: ip } = buildStageQueryArgs(
+      stage,
+      childKey,
+      chunk,
+    )
     if (ip) injectedChildPath = ip
     const partial = await delegate.findMany(args)
     if (isAborted()) return
@@ -613,7 +623,11 @@ async function runOneStageMany(options: {
       }
     }
 
-    const publicVal = buildPublicForStage(internalVal, effectivePaths, stage.relationPath)
+    const publicVal = buildPublicForStage(
+      internalVal,
+      effectivePaths,
+      stage.relationPath,
+    )
 
     entry.internal[stage.relationName] = internalVal
     entry.public[stage.relationName] = publicVal
@@ -678,10 +692,11 @@ async function processFindManyStages(args: {
     res.destroyed
 
   for (const group of groups) {
-    if (signal?.aborted === true || res.writableEnded || res.destroyed) return stageErrorMessage
+    if (signal?.aborted === true || res.writableEnded || res.destroyed)
+      return stageErrorMessage
     if (stageErrorMessage) break
 
-    await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
+    await mapLimited(group, STAGE_CONCURRENCY, async (stage) => {
       if (isAborted()) return
       const parentEntries = collectParentEntries(rootPairs, stage.parentPath)
       try {
@@ -696,19 +711,50 @@ async function processFindManyStages(args: {
         })
       } catch (err) {
         if (isAborted()) return
-        console.error('[auto-progressive] stage failed:', stage.relationPath, err)
+        console.error(LOG_PREFIX, 'stage failed:', stage.relationPath, err)
         stageErrorMessage = mapError(err).message
         return
       }
       if (isAborted()) return
       completed++
-      const ok = sendSSEProgress(res, stage.relationPath, completed, plan.stages.length)
+      const ok = sendSSEProgress(
+        res,
+        stage.relationPath,
+        completed,
+        plan.stages.length,
+      )
       if (!ok) return
     })
   }
   return stageErrorMessage
 }
 
+async function fetchRootAndCount(args: {
+  delegate: PrismaDelegate
+  rawClient: unknown
+  rootArgs: Record<string, unknown>
+  distinctCountLimit: number | undefined
+  countSource:
+    | NonNullable<OperationContext['paginationConfig']>['countSource']
+    | undefined
+}): Promise<{ data: unknown[]; count: number }> {
+  const { delegate, rawClient, rootArgs, distinctCountLimit, countSource } =
+    args
+  const [data, count] = await Promise.all([
+    delegate.findMany(rootArgs),
+    countForPagination(
+      delegate,
+      rootArgs,
+      undefined,
+      undefined,
+      distinctCountLimit,
+      countSource,
+      rawClient,
+    ),
+  ])
+  return { data: data as unknown[], count }
+}
+
 async function runPaginatedRoot(args: {
   extended: unknown
   delegateKey: string
@@ -730,196 +776,158 @@ async function runPaginatedRoot(args: {
         'findManyPaginatedMode="transaction" requires transaction support on the Prisma client',
       )
     }
-    const result = await txClient.$transaction(async (tx: unknown) => {
-      const txDelegate = getDelegate(tx, delegateKey)
-      const [data, count] = await Promise.all([
-        txDelegate.findMany(rootArgs),
-        countForPagination(
-          txDelegate,
-          rootArgs,
-          undefined,
-          undefined,
-          distinctCountLimit,
-          countSource,
-          tx,
-        ),
-      ])
-      return { data, count }
-    })
-    return { data: result.data as unknown[], count: result.count }
+    return txClient.$transaction((tx: unknown) =>
+      fetchRootAndCount({
+        delegate: getDelegate(tx, delegateKey),
+        rawClient: tx,
+        rootArgs,
+        distinctCountLimit,
+        countSource,
+      }),
+    )
   }
 
-  const rootDelegate = getDelegate(extended, delegateKey)
-  const [data, count] = await Promise.all([
-    rootDelegate.findMany(rootArgs),
-    countForPagination(
-      rootDelegate,
-      rootArgs,
-      undefined,
-      undefined,
-      distinctCountLimit,
-      countSource,
-      extended,
-    ),
-  ])
-  return { data: data as unknown[], count }
+  return fetchRootAndCount({
+    delegate: getDelegate(extended, delegateKey),
+    rawClient: extended,
+    rootArgs,
+    distinctCountLimit,
+    countSource,
+  })
 }
 
-async function runAutoIncludeMany(
+async function runAutoIncludeManyOrPaginated(
   options: RunAutoIncludeOptions,
   plan: AutoIncludePlan,
+  isPaginated: boolean,
 ): Promise<void> {
   const { res, ctx, delegateKey, models, signal } = options
+  const isClientGone = createClientGoneChecker(res, signal)
 
-  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, !!ctx.guardShape)
-
-    let rootResult: unknown
-    try {
-      rootResult = await rootDelegate.findMany(rootArgs)
-    } catch (err) {
+  await withSSE(
+    { res, signal, label: isPaginated ? 'paginated' : 'many' },
+    async () => {
+      const extended = await getExtendedClient(ctx)
       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)
+      const rootArgs = applyPaginationLimits(
+        plan.rootArgs,
+        ctx.paginationConfig,
+        !!ctx.guardShape,
+      )
 
-    sendSSERootArray(res, publicRows)
-    sendSSEProgress(res, 'root', 0, plan.stages.length)
+      let rootRows: unknown[]
+      let total = 0
+      let hasMore = false
 
-    const stageError = await processFindManyStages({
-      extended, models, plan, rootPairs, res, signal,
-    })
-
-    if (isClientGone()) return
-
-    if (stageError) {
-      if (!res.writableEnded && !res.destroyed) {
-        sendSSEError(res, stageError)
+      try {
+        if (isPaginated) {
+          const mode: FindManyPaginatedMode =
+            ctx.findManyPaginatedMode ?? 'promiseAll'
+          const r = await runPaginatedRoot({
+            extended,
+            delegateKey,
+            rootArgs,
+            ctx,
+            mode,
+          })
+          rootRows = r.data
+          total = r.count
+          const skip = typeof rootArgs.skip === 'number' ? rootArgs.skip : 0
+          const takeRaw =
+            typeof rootArgs.take === 'number' ? rootArgs.take : rootRows.length
+          const absTake = Math.abs(takeRaw)
+          hasMore =
+            absTake > 0 &&
+            rootRows.length >= absTake &&
+            skip + rootRows.length < total
+        } else {
+          const rootDelegate = getDelegate(extended, delegateKey)
+          const result = await rootDelegate.findMany(rootArgs)
+          if (!Array.isArray(result)) {
+            safeSendError(
+              res,
+              'auto-progressive: unexpected non-array root result for findMany',
+            )
+            return
+          }
+          rootRows = result
+        }
+      } catch (err) {
+        if (isClientGone()) return
+        console.error(
+          LOG_PREFIX,
+          isPaginated
+            ? 'root findManyPaginated failed:'
+            : 'root findMany failed:',
+          err,
+        )
+        sendSSEError(res, mapError(err).message)
+        return
       }
-      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
+      if (isClientGone()) return
 
-    const extended = await getExtendedClient(ctx)
-    if (isClientGone()) return
+      const { publicRows, rootPairs } = buildRootPairs(
+        rootRows,
+        plan.internalFieldPaths,
+      )
 
-    const rootArgs = applyPaginationLimits(plan.rootArgs, ctx.paginationConfig, !!ctx.guardShape)
-    const mode: FindManyPaginatedMode = ctx.findManyPaginatedMode ?? 'promiseAll'
+      if (isPaginated) {
+        sendSSEPageMeta(res, total, hasMore)
+      }
+      sendSSERootArray(res, publicRows)
+      sendSSEProgress(res, 'root', 0, plan.stages.length)
 
-    let rootRows: unknown[]
-    let total: number
-    try {
-      const r = await runPaginatedRoot({
+      const stageError = await processFindManyStages({
         extended,
-        delegateKey,
-        rootArgs,
-        ctx,
-        mode,
+        models,
+        plan,
+        rootPairs,
+        res,
+        signal,
       })
-      rootRows = r.data
-      total = r.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 = absTake > 0 && 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 (isClientGone()) return
 
-    if (stageError) {
-      if (!res.writableEnded && !res.destroyed) {
-        sendSSEError(res, stageError)
+      if (stageError) {
+        safeSendError(res, stageError)
+        return
       }
-      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)
-  }
+      if (res.writableEnded || res.destroyed) return
+      if (isPaginated) {
+        sendSSEResult(res, { data: publicRows, total, hasMore })
+      } else {
+        sendSSEResult(res, publicRows)
+      }
+    },
+  )
 }
 
 export async function runAutoIncludeProgressive(
   options: RunAutoIncludeOptions,
 ): Promise<void> {
   if (options.ctx.guardShape) {
+    if (isGuardedAutoIncludeBaseOp(options.baseOp)) {
+      return runGuardedAutoIncludeProgressive({
+        req: options.req,
+        res: options.res,
+        ctx: options.ctx,
+        args: options.args,
+        baseOp: options.baseOp,
+        modelName: options.modelName,
+        delegateKey: options.delegateKey,
+        models: options.models,
+        variantConfig: options.variantConfig,
+        coreQueryFn: options.coreQueryFn,
+        signal: options.signal,
+      })
+    }
     return handleAutoIncludeFallback(
       options,
-      'auto-progressive fallback: guard shape disables auto-include',
+      'auto-progressive fallback: guard shape disables auto-include for baseOp=' +
+        options.baseOp,
     )
   }
 
@@ -950,10 +958,10 @@ export async function runAutoIncludeProgressive(
   }
 
   if (options.baseOp === 'findMany') {
-    return runAutoIncludeMany(options, plan)
+    return runAutoIncludeManyOrPaginated(options, plan, false)
   }
   if (options.baseOp === 'findManyPaginated') {
-    return runAutoIncludePaginated(options, plan)
+    return runAutoIncludeManyOrPaginated(options, plan, true)
   }
   return runAutoIncludeSingle(options, plan)
-}
+}