prisma-generator-express 1.45.0 → 1.46.0

package/src/client/encodeQueryParams.ts

@@ -1,20 +1,5 @@
 import { isObject } from '../copy/misc'
 
-/**
- * Frontend query encoder for prisma-generator-express
- *
- * Encodes complex Prisma query structures as JSON strings in query params.
- * Objects and arrays are JSON-stringified. Primitives are encoded directly.
- *
- * @example
- * const params = encodeQueryParams({
- *   where: { OR: [{ status: 'active' }, { featured: true }] },
- *   take: 10
- * })
- * // where=%7B%22OR%22%3A...&take=10
- * fetch(`/api/posts?${params}`)
- */
-
 function replacer(_key: string, value: unknown): unknown {
   if (typeof value === 'bigint') {
     return value.toString()
@@ -40,6 +25,13 @@ export const encodeQueryParams = (params: Record<string, unknown>): string => {
       continue
     }
 
+    if (typeof value === 'string') {
+      entries.push(
+        `${encodeURIComponent(key)}=${encodeURIComponent(JSON.stringify(value))}`,
+      )
+      continue
+    }
+
     if (Array.isArray(value) || isObject(value)) {
       entries.push(
         `${encodeURIComponent(key)}=${encodeURIComponent(JSON.stringify(value, replacer))}`,

package/src/copy/autoIncludePlanner.ts

@@ -1,3 +1,5 @@
+import { isPlainObject } from './misc'
+
 export type ModelRelationDirection = 'parentOwnsFk' | 'childOwnsFk' | 'implicitM2M'
 
 export type ModelRelationField = {
@@ -14,7 +16,6 @@ export type ModelRelationMap = {
   name: string
   delegateKey: string
   scalarFields: string[]
-  idFields: string[]
   relations: Record<string, ModelRelationField>
 }
 
@@ -47,23 +48,9 @@ export const DEFAULT_AUTO_INCLUDE_MAX_STAGES = 20
 
 const ALLOWED_TO_ONE_ARGS = new Set(['select', 'include', 'omit'])
 const ALLOWED_TO_MANY_ARGS = new Set([
-  'select',
-  'include',
-  'omit',
-  'where',
-  'orderBy',
-  'take',
-  'skip',
-  'cursor',
-  'distinct',
+  'select', 'include', 'omit', 'where', 'orderBy', 'take', 'skip', 'cursor', 'distinct',
 ])
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  if (value === null || typeof value !== 'object') return false
-  if (Array.isArray(value)) return false
-  return true
-}
-
 function isPubliclySelected(projection: Record<string, unknown>, field: string): boolean {
   return projection[field] === true
 }
@@ -224,7 +211,7 @@ function walk(
 
     for (const linkField of relation.parentLinkFields) {
       if (localOmit && localOmit[linkField] === true) {
-        const where = parentPath ? parentPath + '.' : 'root '
+        const where = parentPath ? parentPath + '.' : 'root.'
         return { unsupportedReason: 'required parent link field omitted: ' + where + linkField }
       }
     }

package/src/copy/autoIncludeRuntime.ts

@@ -12,9 +12,11 @@ import {
   setByPath,
   getDelegate,
   getExtendedClient,
+  mapError,
   type OperationContext,
   type PrismaDelegate,
 } from './operationRuntime'
+import { isPlainObject } from './misc'
 import {
   planAutoInclude,
   type ModelRelationMap,
@@ -39,16 +41,12 @@ export type RunAutoIncludeOptions = {
   signal?: AbortSignal
 }
 
-function isObject(v: unknown): v is Record<string, unknown> {
-  return v !== null && typeof v === 'object' && !Array.isArray(v)
-}
-
 function readPath(source: Record<string, unknown>, path: string): unknown {
   if (path === '') return source
   const parts = path.split('.')
   let cursor: unknown = source
   for (const part of parts) {
-    if (!isObject(cursor)) return undefined
+    if (!isPlainObject(cursor)) return undefined
     cursor = cursor[part]
   }
   return cursor
@@ -77,7 +75,7 @@ function mergeWhere(
   userWhere: unknown,
   linkFilter: Record<string, unknown>,
 ): Record<string, unknown> {
-  if (!isObject(userWhere) || Object.keys(userWhere).length === 0) return linkFilter
+  if (!isPlainObject(userWhere) || Object.keys(userWhere).length === 0) return linkFilter
   return { AND: [userWhere, linkFilter] }
 }
 
@@ -108,7 +106,7 @@ function buildPublicForStage(
 ): unknown {
   if (Array.isArray(result)) {
     return result.map((item) => {
-      if (isObject(item)) {
+      if (isPlainObject(item)) {
         const copy: Record<string, unknown> = { ...item }
         stripInternalAtScope(copy, internalFieldPaths, scopePath)
         return copy
@@ -116,7 +114,7 @@ function buildPublicForStage(
       return item
     })
   }
-  if (isObject(result)) {
+  if (isPlainObject(result)) {
     const copy: Record<string, unknown> = { ...result }
     stripInternalAtScope(copy, internalFieldPaths, scopePath)
     return copy
@@ -138,7 +136,7 @@ async function runOneStage(options: {
   if (isAborted()) return
 
   const parentRaw = readPath(internal, stage.parentPath)
-  if (!isObject(parentRaw)) {
+  if (!isPlainObject(parentRaw)) {
     if (stage.parentPath !== '') {
       return
     }
@@ -270,20 +268,14 @@ export async function runAutoIncludeProgressive(
       rootResult = await rootDelegate[baseOp](plan.rootArgs)
     } catch (err) {
       if (isClientGone()) return
-      const code = (err as { code?: string } | null)?.code
-      const isOrThrow = baseOp === 'findUniqueOrThrow' || baseOp === 'findFirstOrThrow'
-      if (isOrThrow && code === 'P2025') {
-        sendSSEError(res, 'Record not found')
-        return
-      }
       console.error('[auto-progressive] root query failed:', err)
-      sendSSEError(res, 'Root query failed')
+      sendSSEError(res, mapError(err).message)
       return
     }
 
     if (isClientGone()) return
 
-    if (rootResult === null || !isObject(rootResult)) {
+    if (rootResult === null || !isPlainObject(rootResult)) {
       sendSSEResult(res, null)
       return
     }
@@ -330,7 +322,7 @@ export async function runAutoIncludeProgressive(
         } catch (err) {
           if (isAborted()) return
           console.error('[auto-progressive] stage failed:', stage.relationPath, err)
-          stageErrorMessage = 'Could not load progressive response'
+          stageErrorMessage = mapError(err).message
           return
         }
         if (isAborted()) return
@@ -354,7 +346,7 @@ export async function runAutoIncludeProgressive(
     if (isClientGone()) return
     console.error('[auto-progressive] dispatch error:', err)
     if (!res.writableEnded && !res.destroyed) {
-      sendSSEError(res, 'Internal server error')
+      sendSSEError(res, mapError(err).message)
     }
   } finally {
     endSSE(res, keepalive)

package/src/copy/buildModelOpenApi.ts

@@ -1,5 +1,6 @@
 import type { RouteConfig } from './routeConfig'
 import { OPERATION_DEFS, isOperationEnabled } from './operationDefinitions'
+import { normalizePrefix, removeTrailingSlash } from './misc'
 
 type SchemaObject = {
   type?: string | string[]
@@ -103,20 +104,6 @@ function addErrorResponses(operation: any, codes: number[]): void {
   }
 }
 
-function normalizePrefix(p: string): string {
-  if (!p) return ''
-  let result = p
-  if (!result.startsWith('/')) result = '/' + result
-  while (result.length > 1 && result.endsWith('/')) result = result.slice(0, -1)
-  if (result === '/') return ''
-  return result
-}
-
-function removeTrailingSlash(path: string): string {
-  if (path === '/') return ''
-  return path.endsWith('/') ? path.slice(0, -1) : path
-}
-
 function queryParam(
   name: string,
   description: string,
@@ -1783,6 +1770,11 @@ function yamlEscapeValue(value: unknown, indent: number = 0): string {
     str === '.inf' ||
     str === '-.inf' ||
     str === '.nan' ||
+    str === '-' ||
+    str === '?' ||
+    str.startsWith('- ') ||
+    str.startsWith('? ') ||
+    /^[!&*|>@`]/.test(str) ||
     str.includes(':') ||
     str.includes('#') ||
     str.includes('{') ||
@@ -1837,6 +1829,11 @@ function yamlEscapeKey(key: string): string {
     key === '.inf' ||
     key === '-.inf' ||
     key === '.nan' ||
+    key === '-' ||
+    key === '?' ||
+    key.startsWith('- ') ||
+    key.startsWith('? ') ||
+    /^[!&*|>@`]/.test(key) ||
     key.includes(':') ||
     key.includes('#') ||
     key.includes('{') ||

package/src/copy/docsRenderer.ts

@@ -1,7 +1,8 @@
 import type { RouteConfig } from './routeConfig'
 import { OPERATION_DEFS, isOperationEnabled, READ_OPERATION_NAMES } from './operationDefinitions'
+import { getEnv, normalizePrefix } from './misc'
 
-const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
+const _env = getEnv()
 
 export interface FieldMeta {
   name: string
@@ -527,16 +528,9 @@ function anchors(): { id: string; label: string }[] {
   ]
 }
 
-function normalizeExamplePrefix(p: string): string {
-  if (!p) return ''
-  let result = p.replace(/\/$/, '')
-  if (result && !result.startsWith('/')) result = '/' + result
-  return result
-}
-
 function buildExampleBasePath(modelName: string, config: DocsConfig): string {
   const prefixSource = config.specBasePath ?? config.customUrlPrefix ?? ''
-  const prefix = normalizeExamplePrefix(prefixSource)
+  const prefix = normalizePrefix(prefixSource)
   const modelPrefix = config.addModelPrefix !== false ? '/' + modelName.toLowerCase() : ''
   return prefix + modelPrefix
 }
@@ -550,7 +544,7 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
   const title = config.docsTitle || modelName + ' API'
   const generatedAt = new Date().toISOString()
 
-  const modelLower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
+  const modelLower = modelName.toLowerCase()
   const exampleBasePath = buildExampleBasePath(modelName, config)
 
   const postReadsEnabled = !config.disablePostReads
@@ -1008,15 +1002,15 @@ export function renderDocs(modelName: string, config: DocsConfig, ctx: DocsModel
     '<strong>POST read endpoints:</strong> All read operations accept POST as an alternative transport. The request body is a plain JSON object with the same argument structure as the GET query params — no JSON-string encoding needed. POST reads use native JSON types (numbers, booleans, objects) directly. findMany POST read is at <span class="font-mono">/read</span>; all other read operations use the same path as their GET counterpart. Disable with <span class="font-mono">disablePostReads: true</span> in route config.',
     '<strong>Request body validation:</strong> All write endpoints require a JSON object body. Sending <span class="font-mono">null</span>, arrays, or non-object JSON values returns 400.',
     '<strong>Documentation in production:</strong> Docs endpoints are disabled by default when <span class="font-mono">NODE_ENV=production</span> or <span class="font-mono">DISABLE_OPENAPI=true</span>. To enable in production, set <span class="font-mono">disableOpenApi: false</span> in the route config.',
-    '<strong>Paginated query atomicity:</strong> findManyPaginated wraps data + count in a database transaction when available. If interactive transactions are not supported (e.g. some edge adapters), the queries run separately and data/total may be slightly inconsistent under concurrent writes.',
-    '<strong>Distinct count approximation:</strong> When findManyPaginated is used with distinct and the number of unique values exceeds 100,000, the total falls back to a non-distinct count which may overcount. The hasMore value is affected accordingly.',
+    '<strong>Paginated query atomicity:</strong> findManyPaginated wraps data + count in a database transaction when available. If interactive transactions are not supported (e.g. some edge adapters), the queries run separately and data/total may be slightly inconsistent under concurrent writes. When a guard shape is configured, the data and count queries run in parallel without a transaction to keep the guard wrapper in scope, so atomicity is not guaranteed in that mode.',
+    '<strong>Distinct count approximation:</strong> When findManyPaginated is used with distinct and the number of unique values exceeds 100,000, the total falls back to a non-distinct count which may overcount. When a guard shape is configured alongside distinct, the total also falls back to a non-distinct count to avoid imposing the public read shape on the internal counting query. The hasMore value is affected accordingly.',
     '<strong>Serialization:</strong> BigInt values are serialized as strings. Bytes/Buffer values are serialized as base64 strings. Decimal values are serialized as strings. DateTime values are serialized as ISO 8601 strings.',
     '<strong>Playground:</strong> The query playground embeds an iframe to a local prisma-query-builder-ui instance. It connects to your real database using the configured DATABASE_URL. It is disabled in production and when queryBuilder is set to false or queryBuilder.enabled is set to false.',
-    '<strong>Prototype pollution protection:</strong> All incoming JSON bodies and query parameters are sanitized to reject __proto__, constructor, and prototype keys.',
+    '<strong>Prototype pollution protection:</strong> All incoming JSON bodies and query parameters are sanitized to strip __proto__, constructor, and prototype keys before reaching handlers.',
     '<strong>Batch operation safety:</strong> deleteMany, updateMany, and updateManyAndReturn require a where field in the request body. Requests without where are rejected with 400 to prevent accidental mass operations.',
     '<strong>Bulk write constraints:</strong> createMany, createManyAndReturn, updateMany, and updateManyAndReturn accept scalar-only data inputs. Nested relation writes are not supported in these operations.',
     '<strong>Provider compatibility:</strong> createManyAndReturn requires Prisma 5.14.0+ and is limited to PostgreSQL, CockroachDB, and SQLite. updateManyAndReturn requires Prisma 6.2.0+ with the same provider restrictions. skipDuplicates is not supported on all database providers.',
-    '<strong>omit compatibility:</strong> The omit parameter requires Prisma 5.13.0+ (preview) or 6.2.0+ (GA). On older Prisma versions, requests using omit will return 400.',
+    '<strong>omit compatibility:</strong> The omit parameter requires Prisma 6.2.0+. On versions 6.0.x–6.1.x, requests using omit return 400.',
   ]
 
   const noUniqueFieldNote = '<div class="bg-gray-50 border border-gray-200 rounded-xl p-3 text-xs text-gray-500">This model has no unique or id fields suitable for a generated example. Use the unique constraint from your schema.</div>'

package/src/copy/misc.ts

@@ -1,29 +1,14 @@
-export function isJsonString(str: string | unknown): boolean {
-  if (typeof str !== 'string') {
-    return false
-  }
-
-  try {
-    JSON.parse(str)
-  } catch (e: unknown) {
-    return false
-  }
-  return true
-}
-
-export function safeJSONparse<T>(
-  data: unknown,
-): T | boolean | undefined | null {
-  if (data === 'false') return false
-  if (data === 'undefined') return undefined
-  if (data === 'null') return null
-  return isJsonString(data) ? JSON.parse(data as string) : data as any
-}
-
 export const isObject = (value: unknown): value is Record<string, unknown> => {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
 
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') return false
+  if (Array.isArray(value)) return false
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
 
 export function isSafeKey(key: string): boolean {
@@ -34,7 +19,7 @@ export function sanitizeKeys<T>(value: T): T {
   if (Array.isArray(value)) {
     return value.map(sanitizeKeys) as T
   }
-  if (isObject(value)) {
+  if (isPlainObject(value)) {
     const result: Record<string, unknown> = {}
     for (const key of Object.keys(value)) {
       if (!isSafeKey(key)) continue
@@ -43,4 +28,24 @@ export function sanitizeKeys<T>(value: T): T {
     return result as T
   }
   return value
+}
+
+export function normalizePrefix(p: string): string {
+  if (!p) return ''
+  let result = p
+  if (!result.startsWith('/')) result = '/' + result
+  while (result.length > 1 && result.endsWith('/')) result = result.slice(0, -1)
+  if (result === '/') return ''
+  return result
+}
+
+export function removeTrailingSlash(path: string): string {
+  if (path === '/') return ''
+  return path.endsWith('/') ? path.slice(0, -1) : path
+}
+
+export function getEnv(): Record<string, string | undefined> {
+  return typeof process !== 'undefined' && process.env
+    ? process.env
+    : ({} as Record<string, string | undefined>)
 }

package/src/copy/operationRuntime.ts

@@ -1,4 +1,4 @@
-import { sanitizeKeys } from './misc'
+import { sanitizeKeys, isPlainObject } from './misc'
 import type {
   ProgressivePatch,
   ProgressiveStopResult,
@@ -264,7 +264,10 @@ export function assertGuard(
   delegate: PrismaDelegate,
 ): asserts delegate is PrismaDelegate & { guard: NonNullable<PrismaDelegate['guard']> } {
   if (typeof delegate.guard !== 'function') {
-    throw new HttpError(500, 'Guard shapes require prisma-guard extension on PrismaClient.')
+    throw new HttpError(
+      500,
+      'Guard shapes require prisma-guard extension on PrismaClient. Install: npm install prisma-guard, then extend your client with guardExtension().',
+    )
   }
 }
 
@@ -318,6 +321,22 @@ export async function countForPagination(
   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) {
+      return (await (delegate.guard as NonNullable<PrismaDelegate['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 = distinctFields[0]
     const distinctArgs: Record<string, unknown> = {
@@ -326,63 +345,62 @@ export async function countForPagination(
       select: { [selectField]: true },
       take: effectiveLimit + 1,
     }
-    const results = shape
-      ? await (delegate.guard as NonNullable<PrismaDelegate['guard']>)(shape, caller).findMany(distinctArgs)
-      : await delegate.findMany(distinctArgs)
-    const resultArray = results as unknown[]
-    if (resultArray.length > effectiveLimit) {
-      console.warn('[prisma-generator-express] Distinct count exceeds ' + effectiveLimit + ', falling back to approximate total')
-      const countArgs: Record<string, unknown> = {}
-      if (query.where) countArgs.where = query.where
-      const total = countShape
-        ? await (delegate.guard as NonNullable<PrismaDelegate['guard']>)(countShape as Record<string, unknown>, caller).count(countArgs)
-        : await delegate.count(countArgs)
-      return total as number
+    const results = (await delegate.findMany(distinctArgs)) as unknown[]
+    if (results.length > effectiveLimit) {
+      console.warn(
+        '[prisma-generator-express] Distinct count exceeds ' +
+          effectiveLimit +
+          ', falling back to approximate total',
+      )
+      return runCount()
     }
-    return resultArray.length
+    return results.length
   }
 
-  const countArgs: Record<string, unknown> = {}
-  if (query.where) countArgs.where = query.where
-  const total = countShape
-    ? await (delegate.guard as NonNullable<PrismaDelegate['guard']>)(countShape as Record<string, unknown>, caller).count(countArgs)
-    : await delegate.count(countArgs)
-  return total as number
+  return runCount()
 }
 
 export function transformResult(value: unknown): unknown {
   if (value === null || value === undefined) return value
   if (typeof value === 'bigint') return value.toString()
   if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) return value.toString('base64')
-  if (value instanceof Uint8Array) return Buffer.from(value).toString('base64')
+  if (typeof Buffer !== 'undefined' && value instanceof Uint8Array) {
+    return Buffer.from(value).toString('base64')
+  }
   if (value instanceof Date) return value
-  if (Array.isArray(value)) return value.map(transformResult)
-  if (typeof value === 'object') {
-    const proto = Object.getPrototypeOf(value)
-    if (proto !== Object.prototype && proto !== null) return value
+  if (Array.isArray(value)) {
+    let changed = false
+    const out: unknown[] = new Array(value.length)
+    for (let i = 0; i < value.length; i++) {
+      const t = transformResult(value[i])
+      if (t !== value[i]) changed = true
+      out[i] = t
+    }
+    return changed ? out : value
+  }
+  if (isPlainObject(value)) {
+    let changed = false
     const out: Record<string, unknown> = {}
-    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-      out[k] = transformResult(v)
+    for (const [k, v] of Object.entries(value)) {
+      const t = transformResult(v)
+      if (t !== v) changed = true
+      out[k] = t
     }
-    return out
+    return changed ? out : value
   }
   return value
 }
 
 export function acceptsEventStream(accept: string | undefined): boolean {
   if (!accept) return false
-  return accept.toLowerCase().includes('text/event-stream')
+  return accept
+    .toLowerCase()
+    .split(',')
+    .some((entry) => entry.split(';')[0].trim() === 'text/event-stream')
 }
 
 const UNSAFE_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
 
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  if (value === null || typeof value !== 'object') return false
-  if (Array.isArray(value)) return false
-  const proto = Object.getPrototypeOf(value)
-  return proto === Object.prototype || proto === null
-}
-
 export function setByPath(target: Record<string, unknown>, path: string, value: unknown): boolean {
   const parts = path.split('.')
   if (parts.length === 0) return false
@@ -445,7 +463,7 @@ export function initSSE(res: SseWritable): void {
 
 export function flushSSE(res: SseWritable): void {
   if (typeof res.flush === 'function') {
-    try { res.flush() } catch { /* ignore */ }
+    try { res.flush() } catch {}
   }
 }
 
@@ -493,7 +511,7 @@ export function startSSEKeepalive(res: SseWritable, intervalMs: number = 15000):
     try {
       res.write(': keepalive\n\n')
       flushSSE(res)
-    } catch { /* ignore */ }
+    } catch {}
   }, intervalMs)
   const maybeUnref = (handle as unknown as { unref?: () => void }).unref
   if (typeof maybeUnref === 'function') maybeUnref.call(handle)
@@ -502,10 +520,10 @@ export function startSSEKeepalive(res: SseWritable, intervalMs: number = 15000):
 
 export function endSSE(res: SseWritable, keepaliveHandle: IntervalHandle | null): void {
   if (keepaliveHandle) {
-    try { clearInterval(keepaliveHandle) } catch { /* ignore */ }
+    try { clearInterval(keepaliveHandle) } catch {}
   }
   if (!res.writableEnded && !res.destroyed) {
-    try { res.end() } catch { /* ignore */ }
+    try { res.end() } catch {}
   }
 }
 
@@ -539,7 +557,7 @@ export async function runSingleResultSSE(options: RunSingleResultSSEOptions): Pr
   } catch (err) {
     console.error('[progressive] single-result error:', err)
     if (!res.writableEnded && !res.destroyed) {
-      sendSSEError(res, 'Internal server error')
+      sendSSEError(res, mapError(err).message)
     }
   } finally {
     endSSE(res, keepalive)
@@ -605,7 +623,7 @@ export async function runProgressiveEndpoint(options: RunProgressiveOptions): Pr
   } catch (err) {
     console.error('[progressive] stage error:', err)
     if (!res.writableEnded && !res.destroyed) {
-      sendSSEError(res, 'Could not load progressive response')
+      sendSSEError(res, mapError(err).message)
     }
   } finally {
     removeReqCloseListener(req, onClose)

package/src/copy/parseQueryParams.ts

@@ -8,16 +8,14 @@ type QueryParams =
   | undefined
 
 const NUMERIC_KEYS = new Set(['take', 'skip'])
-
 const INTEGER_RE = /^-?\d+$/
 
 const parseQueryValue = (value: string, key?: string): unknown => {
   if (value.startsWith('{') || value.startsWith('[') || value.startsWith('"')) {
     try {
       const parsed = JSON.parse(value)
-      return parseQueryParams(sanitizeKeys(parsed) as QueryParams)
+      return sanitizeKeys(parsed)
     } catch {
-      // fall through
     }
   }
   if (value === 'true') return true
@@ -30,14 +28,10 @@ const parseQueryValue = (value: string, key?: string): unknown => {
 }
 
 export const parseQueryParams = (params: QueryParams): unknown => {
-  if (typeof params === 'string') {
-    return parseQueryValue(params)
-  }
+  if (typeof params === 'string') return parseQueryValue(params)
   if (Array.isArray(params)) {
     return params.map((item) =>
-      typeof item === 'string'
-        ? parseQueryValue(item)
-        : parseQueryParams(item as QueryParams),
+      typeof item === 'string' ? parseQueryValue(item) : sanitizeKeys(item),
     )
   }
   if (isObject(params)) {
@@ -45,11 +39,8 @@ export const parseQueryParams = (params: QueryParams): unknown => {
     for (const key of Object.keys(params)) {
       if (!isSafeKey(key)) continue
       const raw = params[key]
-      if (typeof raw === 'string') {
-        parsedParams[key] = parseQueryValue(raw, key)
-      } else {
-        parsedParams[key] = parseQueryParams(raw as QueryParams)
-      }
+      parsedParams[key] =
+        typeof raw === 'string' ? parseQueryValue(raw, key) : sanitizeKeys(raw)
     }
     return parsedParams
   }

package/src/copy/routeConfig.express.ts

@@ -29,24 +29,30 @@ export type {
 export type OperationConfig<TShape = Record<string, unknown>> =
   BaseOperationConfig<RequestHandler, TShape>
 
-export type ReadOperationConfig<TShape = Record<string, unknown>, TCtx = unknown> =
-  BaseOperationConfig<RequestHandler, TShape> & {
-    progressive?: Record<string, ProgressiveVariantConfig>
-    progressiveStages?: Record<string, ProgressiveStage<TCtx>>
-  }
+export type ReadOperationConfig<
+  TShape = Record<string, unknown>,
+  TCtx = unknown,
+  TPrisma = any,
+> = BaseOperationConfig<RequestHandler, TShape> & {
+  progressive?: Record<string, ProgressiveVariantConfig>
+  progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>
+}
 
-type ReadOperationOverrides<TShape, TCtx> = {
-  findFirst?: ReadOperationConfig<TShape, TCtx>
-  findFirstOrThrow?: ReadOperationConfig<TShape, TCtx>
-  findUnique?: ReadOperationConfig<TShape, TCtx>
-  findUniqueOrThrow?: ReadOperationConfig<TShape, TCtx>
-  findMany?: ReadOperationConfig<TShape, TCtx>
-  findManyPaginated?: ReadOperationConfig<TShape, TCtx>
-  count?: ReadOperationConfig<TShape, TCtx>
-  aggregate?: ReadOperationConfig<TShape, TCtx>
-  groupBy?: ReadOperationConfig<TShape, TCtx>
+type ReadOperationOverrides<TShape, TCtx, TPrisma> = {
+  findFirst?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  findFirstOrThrow?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  findUnique?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  findUniqueOrThrow?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  findMany?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  findManyPaginated?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  count?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  aggregate?: ReadOperationConfig<TShape, TCtx, TPrisma>
+  groupBy?: ReadOperationConfig<TShape, TCtx, TPrisma>
 }
 
-export type RouteConfig<TShape = Record<string, unknown>, TCtx = unknown> =
-  BaseRouteConfig<RequestHandler, Request, TShape, TCtx> &
-    ReadOperationOverrides<TShape, TCtx>
+export type RouteConfig<
+  TShape = Record<string, unknown>,
+  TCtx = unknown,
+  TPrisma = any,
+> = BaseRouteConfig<RequestHandler, Request, TShape, TCtx> &
+  ReadOperationOverrides<TShape, TCtx, TPrisma>

package/src/copy/routeConfig.fastify.ts

@@ -16,7 +16,7 @@ export type {
 export type FastifyHookHandler = (
   request: FastifyRequest,
   reply: FastifyReply,
-) => Promise<void> | void
+) => Promise<unknown> | unknown
 
 export type OperationConfig<TShape = Record<string, unknown>> =
   BaseOperationConfig<FastifyHookHandler, TShape>