prisma-generator-express 1.66.0 → 1.67.0

package/src/copy/materializedCount.ts

@@ -4,7 +4,10 @@ import type { PaginationCountSource } from './routeConfig'
 export const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/
 
 type PrismaRawClient = {
-  $queryRawUnsafe?: <T = unknown>(sql: string, ...values: unknown[]) => Promise<T>
+  $queryRawUnsafe?: <T = unknown>(
+    sql: string,
+    ...values: unknown[]
+  ) => Promise<T>
 }
 
 export function quoteIdent(name: string): string {
@@ -47,7 +50,10 @@ export async function countFromMaterializedView(
 ): Promise<number> {
   const raw = client as PrismaRawClient
   if (typeof raw.$queryRawUnsafe !== 'function') {
-    throw new HttpError(500, 'Materialized count source requires $queryRawUnsafe on the Prisma client')
+    throw new HttpError(
+      500,
+      'Materialized count source requires $queryRawUnsafe on the Prisma client',
+    )
   }
   const column = source.column ?? 'total'
   const where = buildMaterializedCountWhere(source.where)
@@ -58,11 +64,17 @@ export async function countFromMaterializedView(
     buildMaterializedCountFqn(source) +
     where.sql +
     ' LIMIT 1'
-  const rows = await raw.$queryRawUnsafe<Array<{ total: unknown }>>(sql, ...where.values)
+  const rows = await raw.$queryRawUnsafe<Array<{ total: unknown }>>(
+    sql,
+    ...where.values,
+  )
   const value = rows[0]?.total
   const total = Number(value)
   if (!Number.isFinite(total)) {
-    throw new HttpError(500, 'Materialized count source did not return a numeric total')
+    throw new HttpError(
+      500,
+      'Materialized count source did not return a numeric total',
+    )
   }
   return Math.trunc(total)
-}
+}

package/src/copy/misc.ts

@@ -1,68 +1,88 @@
-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 {
-  return !UNSAFE_KEYS.has(key)
-}
-
-export function sanitizeKeys<T>(value: T): T {
-  if (Array.isArray(value)) {
-    let mutated = false
-    const out: unknown[] = new Array(value.length)
-    for (let i = 0; i < value.length; i++) {
-      const sanitized = sanitizeKeys(value[i])
-      if (sanitized !== value[i]) mutated = true
-      out[i] = sanitized
-    }
-    return (mutated ? out : value) as T
-  }
-  if (isPlainObject(value)) {
-    const keys = Object.keys(value)
-    let hasUnsafe = false
-    let childrenMutated = false
-    const sanitizedChildren: Record<string, unknown> = {}
-    for (const key of keys) {
-      if (!isSafeKey(key)) {
-        hasUnsafe = true
-        continue
-      }
-      const original = (value as Record<string, unknown>)[key]
-      const sanitized = sanitizeKeys(original)
-      if (sanitized !== original) childrenMutated = true
-      sanitizedChildren[key] = sanitized
-    }
-    if (!hasUnsafe && !childrenMutated) return value
-    return sanitizedChildren 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>)
-}
+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 {
+  return !UNSAFE_KEYS.has(key)
+}
+
+export function sanitizeKeys<T>(value: T): T {
+  if (Array.isArray(value)) {
+    let mutated = false
+    const out: unknown[] = new Array(value.length)
+    for (let i = 0; i < value.length; i++) {
+      const sanitized = sanitizeKeys(value[i])
+      if (sanitized !== value[i]) mutated = true
+      out[i] = sanitized
+    }
+    return (mutated ? out : value) as T
+  }
+  if (isPlainObject(value)) {
+    const keys = Object.keys(value)
+    let hasUnsafe = false
+    let childrenMutated = false
+    const sanitizedChildren: Record<string, unknown> = {}
+    for (const key of keys) {
+      if (!isSafeKey(key)) {
+        hasUnsafe = true
+        continue
+      }
+      const original = (value as Record<string, unknown>)[key]
+      const sanitized = sanitizeKeys(original)
+      if (sanitized !== original) childrenMutated = true
+      sanitizedChildren[key] = sanitized
+    }
+    if (!hasUnsafe && !childrenMutated) return value
+    return sanitizedChildren 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>)
+}
+
+let dropGuardDeprecationWarned = false
+
+export function resolveDropGuardEnv(
+  env: Record<string, string | undefined>,
+): boolean {
+  if (env.PGE_DROP_GUARD === 'true') return true
+  if (env.E2E === 'true') {
+    if (!dropGuardDeprecationWarned) {
+      dropGuardDeprecationWarned = true
+      console.warn(
+        '[prisma-generator-express] E2E=true guard bypass is deprecated. Use PGE_DROP_GUARD=true.',
+      )
+    }
+    return true
+  }
+  return false
+}

package/src/copy/ndjson.ts

@@ -0,0 +1,72 @@
+import type { SseWritable } from './sse'
+
+/**
+ * NDJSON chunked streaming for list reads.
+ *
+ * Contract: one JSON document per line; the final line is
+ * `{"done":true,"rows":N}`. Clients parse by splitting on newlines — there is
+ * no event vocabulary and no client-side merge algorithm. The same guard
+ * shapes, projection defaults, and pagination limits apply as on the JSON
+ * endpoint, because every page goes through the same generated core function.
+ */
+
+export function acceptsNdjson(accept: string | undefined): boolean {
+  if (!accept) return false
+  return accept
+    .toLowerCase()
+    .split(',')
+    .some((entry) => entry.split(';')[0].trim() === 'application/x-ndjson')
+}
+
+export function startNdjson(res: SseWritable): void {
+  res.setHeader('Content-Type', 'application/x-ndjson')
+  res.setHeader('Cache-Control', 'no-cache, no-transform')
+  res.setHeader('X-Stream-Protocol-Version', '1')
+  res.setHeader('X-Accel-Buffering', 'no')
+  res.statusCode = 200
+}
+
+export interface NdjsonStreamOptions {
+  res: SseWritable
+  isClosed: () => boolean
+  fetchPage: (skip: number, take: number) => Promise<unknown>
+  initialSkip: number
+  requestedTake?: number
+  defaultLimit?: number
+  maxLimit: number
+}
+
+export async function runNdjsonFindMany(
+  options: NdjsonStreamOptions,
+): Promise<void> {
+  startNdjson(options.res)
+  const take = Math.min(
+    options.requestedTake ?? options.defaultLimit ?? options.maxLimit,
+    options.maxLimit,
+  )
+  let skip = options.initialSkip
+  let written = 0
+
+  while (
+    written < options.maxLimit &&
+    !options.isClosed() &&
+    !options.res.writableEnded
+  ) {
+    const result = await options.fetchPage(skip, take)
+    if (!Array.isArray(result)) {
+      throw new Error(
+        'NDJSON streaming requires an array result from the core read',
+      )
+    }
+    for (const row of result) {
+      if (written >= options.maxLimit) break
+      options.res.write(JSON.stringify(row) + '\n')
+      written++
+    }
+    if (result.length < take) break
+    skip += result.length
+  }
+
+  options.res.write(JSON.stringify({ done: true, rows: written }) + '\n')
+  options.res.end()
+}

package/src/copy/operationDefinitions.ts

@@ -40,7 +40,17 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     errors: [400, 403, 500, 501, 503],
     responseDesc: 'Array of records',
     transport: 'GET query params',
-    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    argsSchema: [
+      'where',
+      'select',
+      'include',
+      'omit',
+      'orderBy',
+      'cursor',
+      'take',
+      'skip',
+      'distinct',
+    ],
     requiredArgs: [],
     notes: 'Pagination limits may apply when configured.',
   },
@@ -100,7 +110,17 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     errors: [400, 403, 500, 501, 503],
     responseDesc: 'Single record or null',
     transport: 'GET query params',
-    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    argsSchema: [
+      'where',
+      'select',
+      'include',
+      'omit',
+      'orderBy',
+      'cursor',
+      'take',
+      'skip',
+      'distinct',
+    ],
     requiredArgs: [],
     notes: 'Returns null (not 404) when no record matches.',
   },
@@ -120,7 +140,17 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     errors: [400, 403, 404, 500, 501, 503],
     responseDesc: 'Single record',
     transport: 'GET query params',
-    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    argsSchema: [
+      'where',
+      'select',
+      'include',
+      'omit',
+      'orderBy',
+      'cursor',
+      'take',
+      'skip',
+      'distinct',
+    ],
     requiredArgs: [],
     notes: 'Returns 404 when no record matches.',
   },
@@ -140,9 +170,20 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     errors: [400, 403, 409, 500, 501, 503],
     responseDesc: '{ data: Record[], total: number, hasMore: boolean }',
     transport: 'GET query params',
-    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    argsSchema: [
+      'where',
+      'select',
+      'include',
+      'omit',
+      'orderBy',
+      'cursor',
+      'take',
+      'skip',
+      'distinct',
+    ],
     requiredArgs: [],
-    notes: 'Wraps findMany with total count. hasMore is reliable for forward offset pagination (skip + take) only. Distinct count over 100k falls back to approximate total. 409 possible on transaction conflict.',
+    notes:
+      'Wraps findMany with total count. hasMore is reliable for forward offset pagination (skip + take) only. Distinct count over 100k falls back to approximate total. 409 possible on transaction conflict.',
   },
   {
     name: 'count',
@@ -162,7 +203,8 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     transport: 'GET query params',
     argsSchema: ['where', 'orderBy', 'cursor', 'take', 'skip', 'select'],
     requiredArgs: [],
-    notes: 'select here means count-specific field selection, not record field selection.',
+    notes:
+      'select here means count-specific field selection, not record field selection.',
   },
   {
     name: 'aggregate',
@@ -178,9 +220,21 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     excludeFromEnableAll: false,
     writeStrategyAffected: false,
     errors: [400, 403, 500, 501, 503],
-    responseDesc: 'Object with requested aggregate fields (_count, _avg, _sum, _min, _max)',
+    responseDesc:
+      'Object with requested aggregate fields (_count, _avg, _sum, _min, _max)',
     transport: 'GET query params',
-    argsSchema: ['where', 'orderBy', 'cursor', 'take', 'skip', '_count', '_avg', '_sum', '_min', '_max'],
+    argsSchema: [
+      'where',
+      'orderBy',
+      'cursor',
+      'take',
+      'skip',
+      '_count',
+      '_avg',
+      '_sum',
+      '_min',
+      '_max',
+    ],
     requiredArgs: [],
     notes: '_avg, _sum only apply to numeric fields.',
   },
@@ -198,11 +252,25 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     excludeFromEnableAll: false,
     writeStrategyAffected: false,
     errors: [400, 403, 500, 501, 503],
-    responseDesc: 'Array of objects, each with grouped field values and requested aggregates',
+    responseDesc:
+      'Array of objects, each with grouped field values and requested aggregates',
     transport: 'GET query params',
-    argsSchema: ['by', 'where', 'orderBy', 'having', 'take', 'skip', '_count', '_avg', '_sum', '_min', '_max'],
+    argsSchema: [
+      'by',
+      'where',
+      'orderBy',
+      'having',
+      'take',
+      'skip',
+      '_count',
+      '_avg',
+      '_sum',
+      '_min',
+      '_max',
+    ],
     requiredArgs: ['by'],
-    notes: 'by is a JSON-encoded array of scalar field names. orderBy is required when using skip or take. Response contains only the by-fields plus requested aggregates.',
+    notes:
+      'by is a JSON-encoded array of scalar field names. orderBy is required when using skip or take. Response contains only the by-fields plus requested aggregates.',
   },
   {
     name: 'create',
@@ -242,7 +310,8 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     transport: 'POST JSON body',
     argsSchema: ['data', 'skipDuplicates'],
     requiredArgs: ['data'],
-    notes: 'data is an array of scalar-only inputs. Nested relation writes are not supported. skipDuplicates silently ignores conflicts (not supported on all providers).',
+    notes:
+      'data is an array of scalar-only inputs. Nested relation writes are not supported. skipDuplicates silently ignores conflicts (not supported on all providers).',
   },
   {
     name: 'createManyAndReturn',
@@ -262,7 +331,8 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     transport: 'POST JSON body',
     argsSchema: ['data', 'skipDuplicates', 'select', 'include', 'omit'],
     requiredArgs: ['data'],
-    notes: 'Like createMany but returns created records. data items are scalar-only. Requires Prisma 5.14.0+, PostgreSQL/CockroachDB/SQLite only. The order of returned records is not guaranteed.',
+    notes:
+      'Like createMany but returns created records. data items are scalar-only. Requires Prisma 5.14.0+, PostgreSQL/CockroachDB/SQLite only. The order of returned records is not guaranteed.',
   },
   {
     name: 'update',
@@ -282,7 +352,8 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     transport: 'PUT JSON body',
     argsSchema: ['where', 'data', 'select', 'include', 'omit'],
     requiredArgs: ['where', 'data'],
-    notes: '404 when the record to update is not found. 409 on unique constraint violation or transaction conflict.',
+    notes:
+      '404 when the record to update is not found. 409 on unique constraint violation or transaction conflict.',
   },
   {
     name: 'updateMany',
@@ -302,7 +373,8 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     transport: 'PUT JSON body',
     argsSchema: ['where', 'data'],
     requiredArgs: ['where', 'data'],
-    notes: 'Updates all matching records with scalar-only data. Nested relation writes are not supported. Returns count, not records. 409 on unique constraint violation.',
+    notes:
+      'Updates all matching records with scalar-only data. Nested relation writes are not supported. Returns count, not records. 409 on unique constraint violation.',
   },
   {
     name: 'updateManyAndReturn',
@@ -322,7 +394,8 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     transport: 'PUT JSON body',
     argsSchema: ['where', 'data', 'select', 'include', 'omit'],
     requiredArgs: ['where', 'data'],
-    notes: 'Like updateMany but returns updated records. data is scalar-only. Requires Prisma 6.2.0+, PostgreSQL/CockroachDB/SQLite only. 409 on unique constraint violation.',
+    notes:
+      'Like updateMany but returns updated records. data is scalar-only. Requires Prisma 6.2.0+, PostgreSQL/CockroachDB/SQLite only. 409 on unique constraint violation.',
   },
   {
     name: 'upsert',
@@ -398,11 +471,13 @@ export const OPERATION_METADATA: readonly OpMetadata[] = [
     excludeFromEnableAll: true,
     writeStrategyAffected: false,
     errors: [400, 403, 409, 500, 501, 503],
-    responseDesc: 'Non-atomic: per-row { status, data } / { status, error } array. Atomic: array of records.',
+    responseDesc:
+      'Non-atomic: per-row { status, data } / { status, error } array. Atomic: array of records.',
     transport: 'POST JSON body (array)',
     argsSchema: [],
     requiredArgs: ['array of { where, data }'],
-    notes: 'Internal batch endpoint. Bypasses guard shapes. Not enabled by enableAll. Non-atomic max 1000 items, atomic max 100 items. Header x-batch-atomic:true switches to transactional mode.',
+    notes:
+      'Internal batch endpoint. Bypasses guard shapes. Not enabled by enableAll. Non-atomic max 1000 items, atomic max 100 items. Header x-batch-atomic:true switches to transactional mode.',
   },
 ]
 
@@ -410,9 +485,12 @@ export const OPERATION_BY_NAME: Record<string, OpMetadata> = Object.fromEntries(
   OPERATION_METADATA.map((m) => [m.name, m]),
 )
 
-export const READ_OPERATIONS: readonly OpMetadata[] = OPERATION_METADATA.filter((m) => m.kind === 'read')
+export const READ_OPERATIONS: readonly OpMetadata[] = OPERATION_METADATA.filter(
+  (m) => m.kind === 'read',
+)
 
-export const WRITE_OPERATIONS: readonly OpMetadata[] = OPERATION_METADATA.filter((m) => m.kind === 'write' || m.kind === 'batch')
+export const WRITE_OPERATIONS: readonly OpMetadata[] =
+  OPERATION_METADATA.filter((m) => m.kind === 'write' || m.kind === 'batch')
 
 export const READ_OPERATION_NAMES = new Set(READ_OPERATIONS.map((m) => m.name))
 
@@ -445,4 +523,4 @@ export function isOperationEnabled(
   if (config[def.configKey] === false) return false
   if (def.excludeFromEnableAll) return !!config[def.configKey]
   return !!(config.enableAll || config[def.configKey])
-}
+}

package/src/copy/operationRuntime.ts

@@ -1,3 +1,5 @@
+import { resolveGuardShapeOnce } from './routeConfig'
+import { assertGuard } from './guardHelpers'
 import { HttpError, LOG_PREFIX } from './errorMapper'
 import { sanitizeKeys, isPlainObject } from './misc'
 import type {
@@ -24,12 +26,15 @@ export type {
 
 export interface OperationContext {
   prisma: unknown
+  operationOverride?: RuntimeOperationOverride
+  resolveOperationContext?: () => unknown | Promise<unknown>
   postgres?: unknown
   sqlite?: unknown
   parsedQuery?: Record<string, unknown>
   body?: unknown
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
   paginationConfig?: PaginationConfig
   findManyPaginatedMode?: FindManyPaginatedMode
 }
@@ -60,7 +65,11 @@ export type PrismaClientLike = {
   $transaction?: <T>(fn: (tx: PrismaClientLike) => Promise<T>) => Promise<T>
 }
 
-type SpeedExtensionFactory = (opts: { postgres?: unknown; sqlite?: unknown; debug?: boolean }) => unknown
+type SpeedExtensionFactory = (opts: {
+  postgres?: unknown
+  sqlite?: unknown
+  debug?: boolean
+}) => unknown
 
 let _speedExtension: SpeedExtensionFactory | null = null
 
@@ -82,10 +91,15 @@ const _prismasqlReady = (async () => {
 
 const _extendedClients = new WeakMap<object, WeakMap<object, unknown>>()
 
-export async function getExtendedClient(ctx: OperationContext): Promise<unknown> {
+export async function getExtendedClient(
+  ctx: OperationContext,
+): Promise<unknown> {
   const base = ctx.prisma as PrismaClientLike | null | undefined
   if (!base) {
-    throw new HttpError(500, 'PrismaClient not found on request. Set req.prisma in middleware.')
+    throw new HttpError(
+      500,
+      'PrismaClient not found on request. Set req.prisma in middleware.',
+    )
   }
   await _prismasqlReady
   if (!_speedExtension) return base
@@ -98,11 +112,13 @@ export async function getExtendedClient(ctx: OperationContext): Promise<unknown>
   }
   try {
     if (typeof base.$extends !== 'function') return base
-    const extended = base.$extends(_speedExtension({
-      postgres: ctx.postgres,
-      sqlite: ctx.sqlite,
-      debug: process.env.DEBUG === 'true',
-    }))
+    const extended = base.$extends(
+      _speedExtension({
+        postgres: ctx.postgres,
+        sqlite: ctx.sqlite,
+        debug: process.env.DEBUG === 'true',
+      }),
+    )
     let map = _extendedClients.get(connector)
     if (!map) {
       map = new WeakMap<object, unknown>()
@@ -111,7 +127,10 @@ export async function getExtendedClient(ctx: OperationContext): Promise<unknown>
     map.set(base as unknown as object, extended)
     return extended
   } catch (error) {
-    console.warn('[speedExtension] Failed to initialize, using base client:', error)
+    console.warn(
+      '[speedExtension] Failed to initialize, using base client:',
+      error,
+    )
     return base
   }
 }
@@ -134,7 +153,10 @@ export function validateBody(body: unknown): Record<string, unknown> {
   return sanitizeKeys(body as Record<string, unknown>)
 }
 
-export function requireBodyField(body: Record<string, unknown>, field: string): void {
+export function requireBodyField(
+  body: Record<string, unknown>,
+  field: string,
+): void {
   if (!(field in body) || body[field] === undefined) {
     throw new HttpError(400, 'Missing required field: ' + field)
   }
@@ -143,7 +165,8 @@ export function requireBodyField(body: Record<string, unknown>, field: string):
 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 (typeof Buffer !== 'undefined' && Buffer.isBuffer(value))
+    return value.toString('base64')
   if (typeof Buffer !== 'undefined' && value instanceof Uint8Array) {
     return Buffer.from(value).toString('base64')
   }
@@ -169,4 +192,69 @@ export function transformResult(value: unknown): unknown {
     return changed ? out : value
   }
   return value
-}
+}
+
+export const OPERATION_OVERRIDE_VERSION = 1
+
+export type OperationOverride<TInput, TResult, TContext, TPrisma> = {
+  invoke(options: {
+    input: TInput
+    args: TInput
+    context: TContext
+    prisma: TPrisma
+    core: () => Promise<TResult>
+  }): TResult | Promise<TResult>
+}['invoke']
+
+export type RuntimeOperationOverride = OperationOverride<
+  Record<string, unknown>,
+  unknown,
+  unknown,
+  Readonly<
+    Record<
+      string,
+      Readonly<Record<string, (...args: never[]) => Promise<unknown>>>
+    >
+  >
+>
+
+export async function executeOperationOverride<TResult>(
+  ctx: OperationContext,
+  model: string,
+  operation: keyof Omit<PrismaDelegate, 'guard'> | 'findManyPaginated',
+  input: Record<string, unknown>,
+  core: () => Promise<TResult>,
+): Promise<TResult> {
+  if (!ctx.operationOverride) return core()
+  if (!ctx.guardShape)
+    throw new HttpError(500, 'An operation override requires a guard shape')
+  const context = await ctx.resolveOperationContext?.()
+  const resolved = await resolveGuardShapeOnce(
+    ctx.guardShape,
+    ctx.guardVariantKey ?? ctx.guardCaller,
+    () => context,
+  )
+  if (!resolved.ok || !isPlainObject(resolved.shape)) {
+    throw new HttpError(
+      500,
+      'An operation override requires a resolved guard shape',
+    )
+  }
+  ctx.guardShape = resolved.shape
+  const delegate = getDelegate(await getExtendedClient(ctx), model)
+  assertGuard(delegate)
+  const guarded = delegate.guard(resolved.shape, ctx.guardCaller)
+  const methods =
+    operation === 'findManyPaginated'
+      ? (['findMany', 'count'] as const)
+      : [operation]
+  const exposed: Record<string, (...args: never[]) => Promise<unknown>> = {}
+  for (const method of methods) exposed[method] = guarded[method].bind(guarded)
+  return (await ctx.operationOverride({
+    input,
+    args: input,
+    context,
+    prisma: Object.freeze({ [model]: Object.freeze(exposed) }),
+    core,
+  })) as TResult
+}