prisma-generator-express 1.65.2 → 1.67.0

package/src/copy/routeConfig.ts

@@ -1,5 +1,6 @@
+import type { RuntimeOperationOverride } from './operationRuntime'
 import { GUARD_SHAPE_CONFIG_KEYS } from './guardHelpers'
-import { isPlainObject } from './misc'
+import { getEnv, isPlainObject } from './misc'
 import { resolveShape, type ContextResolver } from './projectionDefaults'
 import {
   resolveGuardVariantKey,
@@ -65,7 +66,29 @@ export type ProgressiveStageResult<T = unknown> =
   | ProgressivePatch[]
   | ProgressiveStopResult<T>
 
-export type ProgressiveStageContext<TContext = unknown, TPrisma = any> = {
+/**
+ * Minimal structural view of a Prisma-compatible client as the generated
+ * runtime uses it: dynamic model delegates called with method args. Real
+ * PrismaClient and $extends results are intended to be usable here; pass
+ * your client's type explicitly for precise inference.
+ */
+/**
+ * DELIBERATELY LOOSE. A real `PrismaClient` — and every `$extends` result —
+ * must satisfy this, and neither is a plain map of method maps: a model
+ * delegate carries `fields` refs, and the client carries `$`-prefixed members.
+ * The f6411dc shape (`Record<string, Record<string, fn>>`) refused the actual
+ * client in every emitted `app.ts` (TS2344). Delegates are resolved at runtime
+ * by `getDelegate`, which owns the narrow contract.
+ */
+export type PrismaClientLike = {
+  $extends?: (extension: never) => unknown
+  $transaction?: (fn: never) => Promise<unknown>
+}
+
+export type ProgressiveStageContext<
+  TContext = unknown,
+  TPrisma extends PrismaClientLike = PrismaClientLike,
+> = {
   ctx: TContext
   req: unknown
   res: unknown
@@ -75,7 +98,11 @@ export type ProgressiveStageContext<TContext = unknown, TPrisma = any> = {
   signal: AbortSignal
 }
 
-export type ProgressiveStage<TContext = unknown, TPrisma = any, T = unknown> = (
+export type ProgressiveStage<
+  TContext = unknown,
+  TPrisma extends PrismaClientLike = PrismaClientLike,
+  T = unknown,
+> = (
   context: ProgressiveStageContext<TContext, TPrisma>,
 ) => Promise<ProgressiveStageResult<T>>
 
@@ -88,6 +115,8 @@ export type ManualProgressiveVariantConfig = {
 export type AutoIncludeProgressiveVariantConfig = {
   enabled?: boolean
   mode: 'autoInclude'
+  /** Auto-include streaming is experimental; routers refuse it unless this is set. */
+  experimental?: boolean
   fallback?: 'singleResult' | 'error'
 }
 
@@ -116,9 +145,17 @@ export type BaseOperationConfig<
   TShape = Record<string, unknown>,
   TAfter = TBefore,
 > = OperationShapeConfig<TShape, TBefore, TAfter> & {
+  authorize?: TBefore
   before?: TBefore[]
   after?: TAfter[]
+  override?: RuntimeOperationOverride
   pagination?: Partial<PaginationConfig>
+  /**
+   * Disables the POST read variant for this operation only. Overrides the
+   * router-level `disablePostReads` (operation value wins, matching the
+   * pagination shallow-merge order).
+   */
+  disablePostReads?: boolean
   /**
    * Confirms that a variant literally named `default` is meant to answer every
    * unrecognised, blank and missing caller.
@@ -201,15 +238,20 @@ export type NormalizedVariantHooks<TBefore, TAfter> = Readonly<
 >
 
 export interface NormalizedOperationConfig<TBefore, TAfter> {
+  authorize?: TBefore
+  override?: RuntimeOperationOverride
   guardShape?: Record<string, unknown>
   guardRouting: NormalizedGuardRouting
   operationBefore: readonly TBefore[]
   operationAfter: readonly TAfter[]
   variantHooks: NormalizedVariantHooks<TBefore, TAfter>
   pagination?: Readonly<Partial<PaginationConfig>>
+  disablePostReads?: boolean
 }
 
 type OperationConfigInput<TBefore, TAfter> = {
+  authorize?: TBefore
+  override?: RuntimeOperationOverride
   before?: TBefore[]
   after?: TAfter[]
   shape?: unknown
@@ -222,6 +264,7 @@ type OperationConfigInput<TBefore, TAfter> = {
     }
   >
   pagination?: Partial<PaginationConfig>
+  disablePostReads?: boolean
 }
 
 /**
@@ -279,19 +322,29 @@ export const HARDENED_GUARD_PROFILE: Readonly<GuardPolicy> = Object.freeze({
 })
 
 /** Fill in the defaults. Absent means upstream, never an opinion. */
-export function resolveGuardPolicy(config: Partial<GuardPolicy> | undefined): GuardPolicy {
+export function resolveGuardPolicy(
+  config: Partial<GuardPolicy> | undefined,
+): GuardPolicy {
   return {
-    requireGuardShape: config?.requireGuardShape ?? UPSTREAM_GUARD_DEFAULTS.requireGuardShape,
-    validateGuardShapes: config?.validateGuardShapes ?? UPSTREAM_GUARD_DEFAULTS.validateGuardShapes,
+    requireGuardShape:
+      config?.requireGuardShape ?? UPSTREAM_GUARD_DEFAULTS.requireGuardShape,
+    validateGuardShapes:
+      config?.validateGuardShapes ??
+      UPSTREAM_GUARD_DEFAULTS.validateGuardShapes,
     requireDefaultVariantOptIn:
-      config?.requireDefaultVariantOptIn ?? UPSTREAM_GUARD_DEFAULTS.requireDefaultVariantOptIn,
-    enableUpdateEach: config?.enableUpdateEach ?? UPSTREAM_GUARD_DEFAULTS.enableUpdateEach,
+      config?.requireDefaultVariantOptIn ??
+      UPSTREAM_GUARD_DEFAULTS.requireDefaultVariantOptIn,
+    enableUpdateEach:
+      config?.enableUpdateEach ?? UPSTREAM_GUARD_DEFAULTS.enableUpdateEach,
     guardResolutionOrder:
-      config?.guardResolutionOrder ?? UPSTREAM_GUARD_DEFAULTS.guardResolutionOrder,
+      config?.guardResolutionOrder ??
+      UPSTREAM_GUARD_DEFAULTS.guardResolutionOrder,
     allowE2EGuardBypass:
-      config?.allowE2EGuardBypass ?? UPSTREAM_GUARD_DEFAULTS.allowE2EGuardBypass,
+      config?.allowE2EGuardBypass ??
+      UPSTREAM_GUARD_DEFAULTS.allowE2EGuardBypass,
     validateResolvedShapes:
-      config?.validateResolvedShapes ?? UPSTREAM_GUARD_DEFAULTS.validateResolvedShapes,
+      config?.validateResolvedShapes ??
+      UPSTREAM_GUARD_DEFAULTS.validateResolvedShapes,
   }
 }
 
@@ -302,8 +355,7 @@ function classifyGuardRouting(shape: unknown): NormalizedGuardRouting {
 
   const keys = Object.keys(shape)
   const isSingle =
-    keys.length === 0 ||
-    keys.every((key) => GUARD_SHAPE_CONFIG_KEYS.has(key))
+    keys.length === 0 || keys.every((key) => GUARD_SHAPE_CONFIG_KEYS.has(key))
 
   return isSingle ? { kind: 'single' } : { kind: 'named', keys }
 }
@@ -330,16 +382,22 @@ function validateShapeConfig(shape: unknown, location: string): void {
 
   if (!isPlainObject(shape)) {
     throw new Error(
-      location + ': shape must be an object or a function, got ' +
-      (shape === null ? 'null' : Array.isArray(shape) ? 'array' : typeof shape),
+      location +
+        ': shape must be an object or a function, got ' +
+        (shape === null
+          ? 'null'
+          : Array.isArray(shape)
+            ? 'array'
+            : typeof shape),
     )
   }
 
   const keys = Object.keys(shape)
   if (keys.length === 0) {
     throw new Error(
-      location + ': shape is empty, so it constrains nothing. Give it at least ' +
-      'one guard key, or use variants.',
+      location +
+        ': shape is empty, so it constrains nothing. Give it at least ' +
+        'one guard key, or use variants.',
     )
   }
 
@@ -347,10 +405,15 @@ function validateShapeConfig(shape: unknown, location: string): void {
   if (reserved.length > 0 && reserved.length !== keys.length) {
     const stray = keys.filter((key) => !GUARD_SHAPE_CONFIG_KEYS.has(key))
     throw new Error(
-      location + ': shape mixes guard keys (' + reserved.join(', ') + ') with ' +
-      'non-guard keys (' + stray.join(', ') + '). A shape whose keys are not all ' +
-      'guard keys is read as a VARIANT MAP, which is rarely intended — check for ' +
-      'a typo, or split them into "variants".',
+      location +
+        ': shape mixes guard keys (' +
+        reserved.join(', ') +
+        ') with ' +
+        'non-guard keys (' +
+        stray.join(', ') +
+        '). A shape whose keys are not all ' +
+        'guard keys is read as a VARIANT MAP, which is rarely intended — check for ' +
+        'a typo, or split them into "variants".',
     )
   }
 }
@@ -372,7 +435,9 @@ function validateShapeConfig(shape: unknown, location: string): void {
  * check exists to make.
  */
 export function validateOperationConfig(
-  config: { shape?: unknown; variants?: unknown; allowDefaultVariant?: unknown } | undefined,
+  config:
+    | { shape?: unknown; variants?: unknown; allowDefaultVariant?: unknown }
+    | undefined,
   location: string,
   policy: Partial<GuardPolicy> = {},
 ): void {
@@ -390,9 +455,10 @@ export function validateOperationConfig(
   if (!config) {
     if (requireGuardShape) {
       throw new Error(
-        location + ': no guard configured. Every generated operation must define ' +
-        '"shape" or "variants"; an unguarded operation would pass the caller\'s ' +
-        'own where/select/include straight to Prisma.',
+        location +
+          ': no guard configured. Every generated operation must define ' +
+          '"shape" or "variants"; an unguarded operation would pass the caller\'s ' +
+          'own where/select/include straight to Prisma.',
       )
     }
     return
@@ -471,14 +537,16 @@ function validateVariantMap(
     if (Object.prototype.hasOwnProperty.call(variants, 'default')) {
       if (allowDefaultVariant !== true) {
         throw new Error(
-          location + ': a variant named "default" answers every unrecognised, ' +
-          'blank and missing caller. Set allowDefaultVariant: true to confirm ' +
-          'that is intended, and make sure it is the most restrictive variant.',
+          location +
+            ': a variant named "default" answers every unrecognised, ' +
+            'blank and missing caller. Set allowDefaultVariant: true to confirm ' +
+            'that is intended, and make sure it is the most restrictive variant.',
         )
       }
     } else if (allowDefaultVariant !== undefined) {
       throw new Error(
-        location + ': allowDefaultVariant is set but no "default" variant exists.',
+        location +
+          ': allowDefaultVariant is set but no "default" variant exists.',
       )
     }
   }
@@ -486,8 +554,10 @@ function validateVariantMap(
   for (const [key, rawEntry] of entries) {
     if (GUARD_SHAPE_CONFIG_KEYS.has(key)) {
       throw new Error(
-        location + ': variant name "' + key +
-        '" collides with a reserved guard shape key',
+        location +
+          ': variant name "' +
+          key +
+          '" collides with a reserved guard shape key',
       )
     }
 
@@ -498,9 +568,7 @@ function validateVariantMap(
     }
 
     if (rawEntry.shape === undefined) {
-      throw new Error(
-        location + ': variant "' + key + '" is missing "shape"',
-      )
+      throw new Error(location + ': variant "' + key + '" is missing "shape"')
     }
 
     /**
@@ -535,9 +603,11 @@ export function describeResolvedGuardShape(resolved: unknown): string | null {
   }
 
   if (!isPlainObject(resolved)) {
-    return 'the shape function returned ' +
+    return (
+      'the shape function returned ' +
       (Array.isArray(resolved) ? 'an array' : typeof resolved) +
       ', which is not a guard shape'
+    )
   }
 
   const keys = Object.keys(resolved)
@@ -547,7 +617,9 @@ export function describeResolvedGuardShape(resolved: unknown): string | null {
 
   const stray = keys.filter((key) => !GUARD_SHAPE_CONFIG_KEYS.has(key))
   if (stray.length > 0) {
-    return 'the shape function returned non-guard keys (' + stray.join(', ') + ')'
+    return (
+      'the shape function returned non-guard keys (' + stray.join(', ') + ')'
+    )
   }
 
   return null
@@ -565,6 +637,8 @@ export function validateUpdateEachConfig(
 export function normalizeOperation<TBefore, TAfter>(
   config: OperationConfigInput<TBefore, TAfter> | undefined,
 ): NormalizedOperationConfig<TBefore, TAfter> {
+  if (config?.override !== undefined && typeof config.override !== 'function')
+    throw new Error('An operation accepts exactly one override function')
   const operationBefore = config?.before ?? []
   const operationAfter = config?.after ?? []
 
@@ -579,6 +653,8 @@ export function normalizeOperation<TBefore, TAfter>(
         kind: 'named',
         keys: entries.map(([key]) => key),
       },
+      override: config.override,
+      authorize: config.authorize,
       operationBefore,
       operationAfter,
       variantHooks: Object.fromEntries(
@@ -591,19 +667,75 @@ export function normalizeOperation<TBefore, TAfter>(
         ]),
       ),
       pagination: config.pagination,
+      disablePostReads: config.disablePostReads,
     }
   }
 
   return {
     guardShape: config?.shape as Record<string, unknown> | undefined,
     guardRouting: classifyGuardRouting(config?.shape),
+    override: config?.override,
+    authorize: config?.authorize,
     operationBefore,
     operationAfter,
     variantHooks: {},
     pagination: config?.pagination,
+    disablePostReads: config?.disablePostReads,
   }
 }
 
+const UNGUARDED_MODELS_WARNED = new Set<string>()
+
+/**
+ * Construction-time safety notice. The generator cannot see route configs —
+ * they are application code, evaluated long after `prisma generate` — so the
+ * emitted router inspects its own config at construction: when operations are
+ * enabled and none carries a guard shape or variants, every column of the
+ * table is reachable by any client.
+ */
+export function warnIfUnguardedRoutes(
+  modelName: string,
+  opKeys: readonly string[],
+  config: unknown,
+  isEnabled: (value: unknown) => boolean,
+): void {
+  // Route configs are interfaces without index signatures, so dynamic key
+  // access needs one narrowing here at the single point that does it.
+  const cfg = (config ?? {}) as Record<string, unknown>
+  const env = getEnv()
+  if (env.PGE_SUPPRESS_WARNINGS === 'true' || env.NODE_ENV === 'production')
+    return
+  let anyEnabled = false
+  for (const key of opKeys) {
+    if (!isEnabled(cfg[key])) continue
+    anyEnabled = true
+    const raw = cfg[key]
+    if (raw && typeof raw === 'object') {
+      const rec = raw as { shape?: unknown; variants?: unknown }
+      if (rec.shape !== undefined || rec.variants !== undefined) return
+    }
+  }
+  if (!anyEnabled || UNGUARDED_MODELS_WARNED.has(modelName)) return
+  UNGUARDED_MODELS_WARNED.add(modelName)
+  console.warn(
+    '[prisma-generator-express] ' +
+      modelName +
+      ': routes enabled without guard shapes - every column of this table is readable/writable by any client. ' +
+      'Configure operation shapes/variants, or set PGE_SUPPRESS_WARNINGS=true to silence.',
+  )
+}
+
+/**
+ * Effective POST-read availability for one operation.
+ * Operation-level value overrides the router-level global; absent means enabled.
+ */
+export function resolvePostReadsEnabled(
+  globalValue: boolean | undefined,
+  opValue: boolean | undefined,
+): boolean {
+  return !(opValue ?? globalValue ?? false)
+}
+
 export function resolveOperationVariantKey(
   routing: NormalizedGuardRouting,
   caller: string | undefined,
@@ -693,9 +825,12 @@ export function validateCountSourceWhere(
     if (value === null) continue
     if (typeof value === 'object') {
       throw new Error(
-        location + ': countSource.where["' + key + '"] must be scalar or null; got ' +
-        (Array.isArray(value) ? 'array' : 'object'),
+        location +
+          ': countSource.where["' +
+          key +
+          '"] must be scalar or null; got ' +
+          (Array.isArray(value) ? 'array' : 'object'),
       )
     }
   }
-}
+}

package/src/copy/scalarTypes.ts

@@ -1,2 +1,7 @@
-export const NUMERIC_SCALAR_TYPES = new Set(['Int', 'BigInt', 'Float', 'Decimal'])
-export const STRING_NUMERIC_TYPES = new Set(['BigInt', 'Decimal'])
+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

@@ -5,6 +5,7 @@ import type {
   ProgressiveStage,
   ProgressiveStopResult,
   ProgressivePatch,
+  PrismaClientLike,
 } from './routeConfig'
 
 export function acceptsEventStream(accept: string | undefined): boolean {
@@ -17,7 +18,11 @@ export function acceptsEventStream(accept: string | undefined): boolean {
 
 const UNSAFE_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
 
-export function setByPath(target: Record<string, unknown>, path: string, value: unknown): boolean {
+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) {
@@ -31,8 +36,11 @@ export function setByPath(target: Record<string, unknown>, path: string, value:
       if (process.env.NODE_ENV !== 'production') {
         console.warn(
           LOG_PREFIX,
-          'Dropping patch for "' + path +
-          '": cannot traverse non-plain-object at segment "' + part + '"',
+          'Dropping patch for "' +
+            path +
+            '": cannot traverse non-plain-object at segment "' +
+            part +
+            '"',
         )
       }
       return false
@@ -61,7 +69,10 @@ export type SseWritable = {
   destroyed: boolean
 }
 
-export function removeReqCloseListener(req: EventEmitterLike, listener: () => void): void {
+export function removeReqCloseListener(
+  req: EventEmitterLike,
+  listener: () => void,
+): void {
   if (typeof req.off === 'function') {
     req.off('close', listener)
   } else if (typeof req.removeListener === 'function') {
@@ -75,12 +86,15 @@ export function initSSE(res: SseWritable): void {
   res.setHeader('Cache-Control', 'no-cache, no-transform')
   res.setHeader('Connection', 'keep-alive')
   res.setHeader('X-Accel-Buffering', 'no')
+  res.setHeader('X-Stream-Protocol-Version', '1')
   if (typeof res.flushHeaders === 'function') res.flushHeaders()
 }
 
 export function flushSSE(res: SseWritable): void {
   if (typeof res.flush === 'function') {
-    try { res.flush() } catch {}
+    try {
+      res.flush()
+    } catch {}
   }
 }
 
@@ -96,11 +110,20 @@ export function sendSSE(res: SseWritable, payload: unknown): boolean {
   }
 }
 
-export function sendSSEProgress(res: SseWritable, stage: string, completed: number, total: number): boolean {
+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 {
+export function sendSSEField(
+  res: SseWritable,
+  key: string,
+  value: unknown,
+): boolean {
   return sendSSE(res, { type: 'field', key, value })
 }
 
@@ -126,7 +149,12 @@ export function sendSSENestedRelationBatch(
   depth: number,
   attachments: Array<{ locator: Array<number | string>; value: unknown }>,
 ): boolean {
-  return sendSSE(res, { type: 'nestedRelationBatch', relationPath, depth, attachments })
+  return sendSSE(res, {
+    type: 'nestedRelationBatch',
+    relationPath,
+    depth,
+    attachments,
+  })
 }
 
 export function sendSSEPageMeta(
@@ -157,7 +185,10 @@ export function safeSendError(res: SseWritable, message: string): void {
 
 type IntervalHandle = ReturnType<typeof setInterval>
 
-export function startSSEKeepalive(res: SseWritable, intervalMs: number = 15000): IntervalHandle {
+export function startSSEKeepalive(
+  res: SseWritable,
+  intervalMs: number = 15000,
+): IntervalHandle {
   const handle = setInterval(() => {
     if (res.writableEnded || res.destroyed) return
     try {
@@ -170,12 +201,17 @@ export function startSSEKeepalive(res: SseWritable, intervalMs: number = 15000):
   return handle
 }
 
-export function endSSE(res: SseWritable, keepaliveHandle: IntervalHandle | null): void {
+export function endSSE(
+  res: SseWritable,
+  keepaliveHandle: IntervalHandle | null,
+): void {
   if (keepaliveHandle) {
     clearInterval(keepaliveHandle)
   }
   if (!res.writableEnded && !res.destroyed) {
-    try { res.end() } catch {}
+    try {
+      res.end()
+    } catch {}
   }
 }
 
@@ -225,7 +261,9 @@ export interface RunSingleResultSSEOptions {
   coreQueryFn: () => Promise<unknown>
 }
 
-export async function runSingleResultSSE(options: RunSingleResultSSEOptions): Promise<void> {
+export async function runSingleResultSSE(
+  options: RunSingleResultSSEOptions,
+): Promise<void> {
   const { req, res, coreQueryFn } = options
   await withSSE({ res, label: 'single-result' }, async () => {
     if (req.destroyed) return
@@ -236,20 +274,26 @@ export async function runSingleResultSSE(options: RunSingleResultSSEOptions): Pr
 }
 
 function isStopResult(value: unknown): value is ProgressiveStopResult<unknown> {
-  return typeof value === 'object' && value !== null && (value as { stop?: unknown }).stop === true
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { stop?: unknown }).stop === true
+  )
 }
 
 export interface RunProgressiveOptions {
   req: EventEmitterLike
   res: SseWritable
   ctx: unknown
-  prisma: unknown
+  prisma: PrismaClientLike
   variant: string
   stages: string[]
   stageRegistry: Record<string, ProgressiveStage>
 }
 
-export async function runProgressiveEndpoint(options: RunProgressiveOptions): Promise<void> {
+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()
@@ -266,9 +310,18 @@ export async function runProgressiveEndpoint(options: RunProgressiveOptions): Pr
         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 (!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)) {
@@ -293,4 +346,4 @@ export async function runProgressiveEndpoint(options: RunProgressiveOptions): Pr
   } finally {
     removeReqCloseListener(req, onClose)
   }
-}
+}