prisma-generator-express 1.59.0 → 1.60.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,23 @@ import {
   sendSSEPageMeta,
   runSingleResultSSE,
   emitTerminalSSEError,
+  safeSendError,
   setByPath,
-  getDelegate,
-  getExtendedClient,
+  withSSE,
+} from './sse'
+import {
   applyPaginationLimits,
   countForPagination,
-  mapError,
-  HttpError,
+} from './pagination'
+import {
+  getDelegate,
+  getExtendedClient,
   type OperationContext,
   type PrismaDelegate,
   type FindManyPaginatedMode,
 } from './operationRuntime'
 import { isPlainObject } from './misc'
+import { mapLimited } from './concurrency'
 import {
   planAutoInclude,
   type AutoIncludePlan,
@@ -36,8 +39,6 @@ import type { AutoIncludeProgressiveVariantConfig } from './routeConfig'
 const STAGE_CONCURRENCY = 4
 const MAX_IN_CHUNK = 1000
 
-type IntervalHandle = ReturnType<typeof setInterval>
-
 export type AutoIncludeBaseOp =
   | 'findUnique'
   | 'findUniqueOrThrow'
@@ -69,6 +70,10 @@ 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 +90,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]
   }
 }
@@ -132,22 +132,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 +162,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,
@@ -322,7 +294,7 @@ 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 }
@@ -336,14 +308,14 @@ async function runOneStageSingle(options: {
 
   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 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 +326,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
 
@@ -374,7 +339,7 @@ async function runAutoIncludeSingle(
       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 +379,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,7 +394,7 @@ 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
         }
@@ -443,23 +408,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(
@@ -487,11 +442,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 {
@@ -559,7 +510,7 @@ 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) {
@@ -681,7 +632,7 @@ async function processFindManyStages(args: {
     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,7 +647,7 @@ 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
       }
@@ -709,6 +660,29 @@ async function processFindManyStages(args: {
   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,160 +704,81 @@ 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 }
-}
-
-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, !!ctx.guardShape)
-
-    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)
-  }
+  return fetchRootAndCount({
+    delegate: getDelegate(extended, delegateKey),
+    rawClient: extended,
+    rootArgs,
+    distinctCountLimit,
+    countSource,
+  })
 }
 
-async function runAutoIncludePaginated(
+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
-
+  await withSSE({ res, signal, label: isPaginated ? 'paginated' : 'many' }, async () => {
     const extended = await getExtendedClient(ctx)
     if (isClientGone()) return
 
     const rootArgs = applyPaginationLimits(plan.rootArgs, ctx.paginationConfig, !!ctx.guardShape)
-    const mode: FindManyPaginatedMode = ctx.findManyPaginatedMode ?? 'promiseAll'
 
     let rootRows: unknown[]
-    let total: number
+    let total = 0
+    let hasMore = false
+
     try {
-      const r = await runPaginatedRoot({
-        extended,
-        delegateKey,
-        rootArgs,
-        ctx,
-        mode,
-      })
-      rootRows = r.data
-      total = r.count
+      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('[auto-progressive] root findManyPaginated failed:', err)
+      console.error(
+        LOG_PREFIX,
+        isPaginated ? 'root findManyPaginated failed:' : 'root findMany 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)
+    if (isPaginated) {
+      sendSSEPageMeta(res, total, hasMore)
+    }
     sendSSERootArray(res, publicRows)
     sendSSEProgress(res, 'root', 0, plan.stages.length)
 
@@ -894,23 +789,17 @@ async function runAutoIncludePaginated(
     if (isClientGone()) return
 
     if (stageError) {
-      if (!res.writableEnded && !res.destroyed) {
-        sendSSEError(res, stageError)
-      }
+      safeSendError(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)
+    if (isPaginated) {
+      sendSSEResult(res, { data: publicRows, total, hasMore })
+    } else {
+      sendSSEResult(res, publicRows)
     }
-  } finally {
-    endSSE(res, keepalive)
-  }
+  })
 }
 
 export async function runAutoIncludeProgressive(
@@ -950,10 +839,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)
 }