prisma-generator-express 1.59.0 → 1.61.0

package/src/copy/pagination.ts

@@ -0,0 +1,151 @@
+import { HttpError, LOG_PREFIX } from './errorMapper'
+import { assertGuard, buildCountShape, type PrismaDelegateLike } from './guardHelpers'
+import { countFromMaterializedView } from './materializedCount'
+import { isPlainObject } from './misc'
+import type { PaginationConfig, PaginationCountSource } from './routeConfig'
+
+export const DISTINCT_COUNT_LIMIT = 100000
+
+export function applyPaginationLimits(
+  query: Record<string, unknown>,
+  config?: PaginationConfig,
+  hasGuardShape?: boolean,
+): Record<string, unknown> {
+  if (!config) return query
+  const result: Record<string, unknown> = { ...query }
+  if (!hasGuardShape && result.take === undefined && config.defaultLimit !== undefined) {
+    result.take = config.defaultLimit
+  }
+  if (config.maxLimit !== undefined && result.take !== undefined) {
+    const takeNum = typeof result.take === 'number' ? result.take : Number(result.take)
+    if (!Number.isFinite(takeNum)) {
+      throw new HttpError(400, 'Invalid take: must be a finite number')
+    }
+    if (!Number.isInteger(takeNum)) {
+      throw new HttpError(400, 'Invalid take: must be an integer')
+    }
+    if (Math.abs(takeNum) > config.maxLimit) {
+      result.take = takeNum < 0 ? -config.maxLimit : config.maxLimit
+    } else {
+      result.take = takeNum
+    }
+  }
+  return result
+}
+
+function mergeCountSource(
+  base: PaginationCountSource | undefined,
+  override: PaginationCountSource | undefined,
+): PaginationCountSource | undefined {
+  if (!base && !override) return undefined
+  if (!base) return override
+  if (!override) return base
+
+  const overrideType = (override as { type?: string }).type
+  const baseType = (base as { type?: string }).type
+  const effectiveType = overrideType ?? baseType
+
+  if (effectiveType === 'delegate' || effectiveType === undefined) {
+    return { type: 'delegate' }
+  }
+
+  return {
+    ...(base as Record<string, unknown>),
+    ...(override as Record<string, unknown>),
+    type: effectiveType,
+  } as PaginationCountSource
+}
+
+export function mergePaginationConfig(
+  base: PaginationConfig | undefined,
+  override: Partial<PaginationConfig> | undefined,
+): PaginationConfig | undefined {
+  if (!base && !override) return undefined
+  const merged: PaginationConfig = {
+    ...(base ?? {}),
+    ...(override ?? {}),
+  }
+  const mergedCountSource = mergeCountSource(base?.countSource, override?.countSource)
+  if (mergedCountSource) {
+    merged.countSource = mergedCountSource
+  } else {
+    delete merged.countSource
+  }
+  return merged
+}
+
+export function normalizeDistinct(value: unknown): string[] {
+  if (typeof value === 'string') return [value]
+  if (Array.isArray(value)) return value.filter((v): v is string => typeof v === 'string')
+  return []
+}
+
+function isEffectivelyEmpty(where: unknown): boolean {
+  if (where === undefined || where === null) return true
+  if (!isPlainObject(where)) return false
+  return Object.keys(where).length === 0
+}
+
+export async function countForPagination(
+  delegate: PrismaDelegateLike,
+  query: Record<string, unknown>,
+  shape: Record<string, unknown> | undefined,
+  caller: string | undefined,
+  distinctCountLimit?: number,
+  countSource?: PaginationCountSource,
+  rawClient?: unknown,
+): Promise<number> {
+  const normalizedDistinct = normalizeDistinct(query.distinct)
+  const whereIsEmpty = isEffectivelyEmpty(query.where)
+  const distinctIsEmpty = normalizedDistinct.length === 0
+
+  if (
+    countSource &&
+    countSource.type === 'materializedView' &&
+    !shape &&
+    whereIsEmpty &&
+    distinctIsEmpty
+  ) {
+    return countFromMaterializedView(rawClient ?? delegate, countSource)
+  }
+
+  const hasDistinct = normalizedDistinct.length > 0
+  const effectiveLimit = distinctCountLimit ?? DISTINCT_COUNT_LIMIT
+  const countShape = shape ? buildCountShape(shape) : undefined
+
+  const runCount = async (): Promise<number> => {
+    const countArgs: Record<string, unknown> = {}
+    if (query.where) countArgs.where = query.where
+    if (countShape) {
+      assertGuard(delegate)
+      return (await delegate.guard(
+        countShape as Record<string, unknown>,
+        caller,
+      ).count(countArgs)) as number
+    }
+    return (await delegate.count(countArgs)) as number
+  }
+
+  if (hasDistinct && shape) return runCount()
+
+  if (hasDistinct) {
+    const selectField = normalizedDistinct[0]
+    const distinctArgs: Record<string, unknown> = {
+      where: query.where,
+      distinct: normalizedDistinct,
+      select: { [selectField]: true },
+      take: effectiveLimit + 1,
+    }
+    const results = (await delegate.findMany(distinctArgs)) as unknown[]
+    if (results.length > effectiveLimit) {
+      console.warn(
+        LOG_PREFIX,
+        'Distinct count exceeds ' + effectiveLimit + ', falling back to approximate total',
+      )
+      return runCount()
+    }
+    return results.length
+  }
+
+  return runCount()
+}

package/src/copy/scalarTypes.ts

@@ -0,0 +1,2 @@
+export const NUMERIC_SCALAR_TYPES = new Set(['Int', 'BigInt', 'Float', 'Decimal'])
+export const STRING_NUMERIC_TYPES = new Set(['BigInt', 'Decimal'])

package/src/copy/sse.ts

@@ -0,0 +1,296 @@
+import { HttpError, LOG_PREFIX, mapError } from './errorMapper'
+import { isPlainObject } from './misc'
+import { transformResult } from './operationRuntime'
+import type {
+  ProgressiveStage,
+  ProgressiveStopResult,
+  ProgressivePatch,
+} from './routeConfig'
+
+export function acceptsEventStream(accept: string | undefined): boolean {
+  if (!accept) return false
+  return accept
+    .toLowerCase()
+    .split(',')
+    .some((entry) => entry.split(';')[0].trim() === 'text/event-stream')
+}
+
+const UNSAFE_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
+
+export function setByPath(target: Record<string, unknown>, path: string, value: unknown): boolean {
+  const parts = path.split('.')
+  if (parts.length === 0) return false
+  for (const p of parts) {
+    if (p === '' || UNSAFE_PATH_SEGMENTS.has(p)) return false
+  }
+  let cursor: Record<string, unknown> = target
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i]
+    const next = cursor[part]
+    if (!isPlainObject(next)) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn(
+          LOG_PREFIX,
+          'Dropping patch for "' + path +
+          '": cannot traverse non-plain-object at segment "' + part + '"',
+        )
+      }
+      return false
+    }
+    cursor = next
+  }
+  cursor[parts[parts.length - 1]] = value
+  return true
+}
+
+export type EventEmitterLike = {
+  on?: (event: string, listener: () => void) => unknown
+  off?: (event: string, listener: () => void) => unknown
+  removeListener?: (event: string, listener: () => void) => unknown
+  destroyed?: boolean
+}
+
+export type SseWritable = {
+  statusCode: number
+  setHeader: (name: string, value: string) => unknown
+  flushHeaders?: () => unknown
+  flush?: () => unknown
+  write: (chunk: string) => unknown
+  end: () => unknown
+  writableEnded: boolean
+  destroyed: boolean
+}
+
+export function removeReqCloseListener(req: EventEmitterLike, listener: () => void): void {
+  if (typeof req.off === 'function') {
+    req.off('close', listener)
+  } else if (typeof req.removeListener === 'function') {
+    req.removeListener('close', listener)
+  }
+}
+
+export function initSSE(res: SseWritable): void {
+  res.statusCode = 200
+  res.setHeader('Content-Type', 'text/event-stream')
+  res.setHeader('Cache-Control', 'no-cache, no-transform')
+  res.setHeader('Connection', 'keep-alive')
+  res.setHeader('X-Accel-Buffering', 'no')
+  if (typeof res.flushHeaders === 'function') res.flushHeaders()
+}
+
+export function flushSSE(res: SseWritable): void {
+  if (typeof res.flush === 'function') {
+    try { res.flush() } catch {}
+  }
+}
+
+export function sendSSE(res: SseWritable, payload: unknown): boolean {
+  if (res.writableEnded || res.destroyed) return false
+  try {
+    res.write('data: ' + JSON.stringify(transformResult(payload)) + '\n\n')
+    flushSSE(res)
+    return true
+  } catch (err) {
+    console.error(LOG_PREFIX, 'failed to send SSE event:', err)
+    return false
+  }
+}
+
+export function sendSSEProgress(res: SseWritable, stage: string, completed: number, total: number): boolean {
+  return sendSSE(res, { type: 'progress', stage, completed, total })
+}
+
+export function sendSSEField(res: SseWritable, key: string, value: unknown): boolean {
+  return sendSSE(res, { type: 'field', key, value })
+}
+
+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 sendSSENestedRelationBatch(
+  res: SseWritable,
+  relationPath: string,
+  depth: number,
+  attachments: Array<{ locator: Array<number | string>; value: unknown }>,
+): boolean {
+  return sendSSE(res, { type: 'nestedRelationBatch', relationPath, depth, attachments })
+}
+
+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 {
+    res.write('data: ' + JSON.stringify({ type: 'error', message }) + '\n\n')
+    flushSSE(res)
+    return true
+  } catch (err) {
+    console.error(LOG_PREFIX, 'failed to send SSE error event:', err)
+    return false
+  }
+}
+
+export function safeSendError(res: SseWritable, message: string): void {
+  if (!res.writableEnded && !res.destroyed) {
+    sendSSEError(res, message)
+  }
+}
+
+type IntervalHandle = ReturnType<typeof setInterval>
+
+export function startSSEKeepalive(res: SseWritable, intervalMs: number = 15000): IntervalHandle {
+  const handle = setInterval(() => {
+    if (res.writableEnded || res.destroyed) return
+    try {
+      res.write(': keepalive\n\n')
+      flushSSE(res)
+    } catch {}
+  }, intervalMs)
+  const maybeUnref = (handle as unknown as { unref?: () => void }).unref
+  if (typeof maybeUnref === 'function') maybeUnref.call(handle)
+  return handle
+}
+
+export function endSSE(res: SseWritable, keepaliveHandle: IntervalHandle | null): void {
+  if (keepaliveHandle) {
+    clearInterval(keepaliveHandle)
+  }
+  if (!res.writableEnded && !res.destroyed) {
+    try { res.end() } catch {}
+  }
+}
+
+export function emitTerminalSSEError(res: SseWritable, message: string): void {
+  let keepalive: IntervalHandle | null = null
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    sendSSEError(res, message)
+  } finally {
+    endSSE(res, keepalive)
+  }
+}
+
+export interface WithSSEOptions {
+  res: SseWritable
+  signal?: AbortSignal
+  label: string
+}
+
+export async function withSSE(
+  options: WithSSEOptions,
+  fn: () => Promise<void>,
+): Promise<void> {
+  const { res, signal, label } = options
+  let keepalive: IntervalHandle | null = null
+  const isClientGone = () =>
+    signal?.aborted === true || res.writableEnded || res.destroyed
+
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    if (isClientGone()) return
+    await fn()
+  } catch (err) {
+    if (isClientGone()) return
+    console.error(LOG_PREFIX, label + ' dispatch error:', err)
+    safeSendError(res, mapError(err).message)
+  } finally {
+    endSSE(res, keepalive)
+  }
+}
+
+export interface RunSingleResultSSEOptions {
+  req: EventEmitterLike
+  res: SseWritable
+  coreQueryFn: () => Promise<unknown>
+}
+
+export async function runSingleResultSSE(options: RunSingleResultSSEOptions): Promise<void> {
+  const { req, res, coreQueryFn } = options
+  await withSSE({ res, label: 'single-result' }, async () => {
+    if (req.destroyed) return
+    const data = await coreQueryFn()
+    if (res.writableEnded || res.destroyed) return
+    sendSSEResult(res, data)
+  })
+}
+
+function isStopResult(value: unknown): value is ProgressiveStopResult<unknown> {
+  return typeof value === 'object' && value !== null && (value as { stop?: unknown }).stop === true
+}
+
+export interface RunProgressiveOptions {
+  req: EventEmitterLike
+  res: SseWritable
+  ctx: unknown
+  prisma: unknown
+  variant: string
+  stages: string[]
+  stageRegistry: Record<string, ProgressiveStage>
+}
+
+export async function runProgressiveEndpoint(options: RunProgressiveOptions): Promise<void> {
+  const { req, res, ctx, prisma, variant, stages, stageRegistry } = options
+  const controller = new AbortController()
+  const onClose = () => controller.abort()
+  if (typeof req.on === 'function') req.on('close', onClose)
+
+  const accumulated: Record<string, unknown> = {}
+  const signal = controller.signal
+
+  try {
+    await withSSE({ res, signal, label: 'stage' }, async () => {
+      sendSSEProgress(res, 'start', 0, stages.length)
+
+      for (let i = 0; i < stages.length; i++) {
+        if (res.writableEnded || res.destroyed || signal.aborted) return
+        const stageName = stages[i]
+        const stage = stageRegistry[stageName]
+        if (!stage) throw new HttpError(500, 'Missing progressive stage: ' + stageName)
+
+        const result = await stage({ ctx, req, res, prisma, variant, accumulated, signal })
+        if (res.writableEnded || res.destroyed) return
+
+        if (isStopResult(result)) {
+          sendSSEResult(res, result.data)
+          return
+        }
+
+        const patches = Array.isArray(result) ? result : result ? [result] : []
+        for (const patch of patches) {
+          if (!patch || typeof patch !== 'object') continue
+          const p = patch as ProgressivePatch
+          if (typeof p.key !== 'string') continue
+          if (!('value' in p)) continue
+          const applied = setByPath(accumulated, p.key, p.value)
+          if (applied) sendSSEField(res, p.key, p.value)
+        }
+        sendSSEProgress(res, stageName, i + 1, stages.length)
+      }
+      if (res.writableEnded || res.destroyed) return
+      sendSSEResult(res, accumulated)
+    })
+  } finally {
+    removeReqCloseListener(req, onClose)
+  }
+}

package/src/generators/generateFastifyHandler.ts

@@ -1,44 +1,7 @@
 import { DMMF } from '@prisma/generator-helper'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
-
-const CORE_NAME_MAP: Record<string, string> = {
-  delete: 'deleteUnique',
-}
-
-function coreFnName(op: string): string {
-  return CORE_NAME_MAP[op] || op
-}
-
-const READ_OPS = [
-  'findMany',
-  'findFirst',
-  'findFirstOrThrow',
-  'findUnique',
-  'findUniqueOrThrow',
-  'findManyPaginated',
-  'aggregate',
-  'count',
-  'groupBy',
-]
-
-const WRITE_OPS = [
-  'create',
-  'createMany',
-  'createManyAndReturn',
-  'update',
-  'updateMany',
-  'updateManyAndReturn',
-  'upsert',
-  'delete',
-  'deleteMany',
-]
-
-const CREATED_OPS = new Set([
-  'create',
-  'createMany',
-  'createManyAndReturn',
-])
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
 export function generateFastifyHandler(options: {
   model: DMMF.Model
@@ -47,31 +10,34 @@ export function generateFastifyHandler(options: {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
 
-  const readHandlers = READ_OPS.map((op) => {
-    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
+  const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
+  const writeOps = OPERATION_METADATA.filter(
+    (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+  )
+
+  const readHandlers = readOps.map((meta) => {
+    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
     return `
 export async function ${exportName}(
   request: FastifyRequest,
   _reply: FastifyReply,
 ): Promise<void> {
-  const data = await core.${coreFnName(op)}(buildContext(request))
+  const data = await core.${meta.coreName}(buildContext(request))
   ;(request as FastifyExtended).resultData = data
 }`
   }).join('\n')
 
-  const writeHandlers = WRITE_OPS.map((op) => {
-    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
-    const statusCode = CREATED_OPS.has(op) ? 201 : 200
-
+  const writeHandlers = writeOps.map((meta) => {
+    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
     return `
 export async function ${exportName}(
   request: FastifyRequest,
   _reply: FastifyReply,
 ): Promise<void> {
-  const data = await core.${coreFnName(op)}(buildContext(request))
+  const data = await core.${meta.coreName}(buildContext(request))
   const ext = request as FastifyExtended
   ext.resultData = data
-  ext.resultStatus = ${statusCode}
+  ext.resultStatus = ${meta.successStatus}
 }`
   }).join('\n')
 

package/src/generators/generateHonoHandler.ts

@@ -1,44 +1,7 @@
 import { DMMF } from '@prisma/generator-helper'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
-
-const CORE_NAME_MAP: Record<string, string> = {
-  delete: 'deleteUnique',
-}
-
-function coreFnName(op: string): string {
-  return CORE_NAME_MAP[op] || op
-}
-
-const READ_OPS = [
-  'findMany',
-  'findFirst',
-  'findFirstOrThrow',
-  'findUnique',
-  'findUniqueOrThrow',
-  'findManyPaginated',
-  'aggregate',
-  'count',
-  'groupBy',
-]
-
-const WRITE_OPS = [
-  'create',
-  'createMany',
-  'createManyAndReturn',
-  'update',
-  'updateMany',
-  'updateManyAndReturn',
-  'upsert',
-  'delete',
-  'deleteMany',
-]
-
-const CREATED_OPS = new Set([
-  'create',
-  'createMany',
-  'createManyAndReturn',
-])
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
 export function generateHonoHandler(options: {
   model: DMMF.Model
@@ -47,24 +10,27 @@ export function generateHonoHandler(options: {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
 
-  const readHandlers = READ_OPS.map((op) => {
-    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
+  const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
+  const writeOps = OPERATION_METADATA.filter(
+    (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+  )
+
+  const readHandlers = readOps.map((meta) => {
+    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
     return `
 export async function ${exportName}(c: HandlerContext): Promise<void> {
-  const data = await core.${coreFnName(op)}(buildContext(c))
+  const data = await core.${meta.coreName}(buildContext(c))
   c.set('resultData', data)
 }`
   }).join('\n')
 
-  const writeHandlers = WRITE_OPS.map((op) => {
-    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
-    const statusCode = CREATED_OPS.has(op) ? 201 : 200
-
+  const writeHandlers = writeOps.map((meta) => {
+    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
     return `
 export async function ${exportName}(c: HandlerContext): Promise<void> {
-  const data = await core.${coreFnName(op)}(buildContext(c))
+  const data = await core.${meta.coreName}(buildContext(c))
   c.set('resultData', data)
-  c.set('resultStatus', ${statusCode})
+  c.set('resultStatus', ${meta.successStatus})
 }`
   }).join('\n')