prisma-generator-express 1.66.0 → 1.68.0

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)
   }
-}
+}

package/src/generators/generateFastifyHandler.ts

@@ -1,5 +1,5 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
@@ -12,34 +12,69 @@ export function generateFastifyHandler(options: {
 
   const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
   const writeOps = OPERATION_METADATA.filter(
-    (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+    (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 `
+  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.${meta.coreName}(buildContext(request))
-  ;(request as FastifyExtended).resultData = data
+  const fx = request as FastifyExtended
+  const data = await executeOperation(
+    { variantKey: fx.guardVariantKey, caller: fx.guardCaller },
+    { guardShape: fx.guardShape },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(request),
+      body: request.body,
+      prisma: requirePrisma(fx.prisma),
+      postgres: fx.postgres,
+      sqlite: fx.sqlite,
+      pagination: fx.routeConfig?.pagination,
+      override: fx.operationOverride,
+      getContext: fx.getContext,
+      findManyPaginatedMode: fx.findManyPaginatedMode,
+    },
+  )
+  fx.resultData = data
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
-  const writeHandlers = writeOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
-    return `
+  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.${meta.coreName}(buildContext(request))
-  const ext = request as FastifyExtended
-  ext.resultData = data
-  ext.resultStatus = ${meta.successStatus}
+  const fx = request as FastifyExtended
+  const data = await executeOperation(
+    { variantKey: fx.guardVariantKey, caller: fx.guardCaller },
+    { guardShape: fx.guardShape },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(request),
+      body: request.body,
+      prisma: requirePrisma(fx.prisma),
+      postgres: fx.postgres,
+      sqlite: fx.sqlite,
+      pagination: fx.routeConfig?.pagination,
+      override: fx.operationOverride,
+      getContext: fx.getContext,
+    },
+  )
+  fx.resultData = data
+  fx.resultStatus = ${meta.successStatus}
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
   const updateEachExportName = `${modelName}UpdateEach`
   const updateEachHandler = `
@@ -54,24 +89,45 @@ export async function ${updateEachExportName}(
 
   return `import type { FastifyRequest, FastifyReply } from 'fastify'
 import * as core from './${modelName}Core${ext}'
-import type { OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
+import type { RuntimeOperationOverride, OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
+import type { PaginationConfig } from '../routeConfig${ext}'
+import {
+  executeOperation,
+  requirePrisma,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 
 type FastifyExtended = FastifyRequest & {
   prisma?: unknown
   postgres?: unknown
   sqlite?: unknown
   parsedQuery?: Record<string, unknown>
-  routeConfig?: { pagination?: OperationContext['paginationConfig'] }
+  routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
+  operationOverride?: RuntimeOperationOverride
+  getContext?: () => Promise<unknown>
   findManyPaginatedMode?: FindManyPaginatedMode
   resultData?: unknown
   resultStatus?: number
 }
 
+function queryChannel(request: FastifyRequest): ArgsChannel {
+  const fx = request as FastifyExtended
+  return {
+    read: () => fx.parsedQuery,
+    write: (next) => {
+      fx.parsedQuery = next
+    },
+  }
+}
+
 function buildContext(request: FastifyRequest): OperationContext {
   const req = request as FastifyExtended
   return {
+    operationOverride: req.operationOverride,
+    resolveOperationContext: req.getContext,
     prisma: req.prisma,
     postgres: req.postgres,
     sqlite: req.sqlite,
@@ -79,6 +135,7 @@ function buildContext(request: FastifyRequest): OperationContext {
     body: request.body,
     guardShape: req.guardShape,
     guardCaller: req.guardCaller,
+    guardVariantKey: req.guardVariantKey,
     paginationConfig: req.routeConfig?.pagination,
     findManyPaginatedMode: req.findManyPaginatedMode,
   }
@@ -87,4 +144,4 @@ ${readHandlers}
 ${writeHandlers}
 ${updateEachHandler}
 `
-}
+}

package/src/generators/generateHonoHandler.ts

@@ -1,5 +1,5 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
@@ -12,27 +12,60 @@ export function generateHonoHandler(options: {
 
   const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
   const writeOps = OPERATION_METADATA.filter(
-    (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+    (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 `
+  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.${meta.coreName}(buildContext(c))
+  const data = await executeOperation(
+    { variantKey: c.get('guardVariantKey'), caller: c.get('guardCaller') },
+    { guardShape: c.get('guardShape') },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(c),
+      body: c.get('body'),
+      prisma: requirePrisma(c.get('prisma')),
+      postgres: c.get('postgres'),
+      sqlite: c.get('sqlite'),
+      pagination: c.get('routeConfig')?.pagination,
+      override: c.get('operationOverride'),
+      getContext: c.get('getContext'),
+    },
+  )
   c.set('resultData', data)
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
-  const writeHandlers = writeOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
-    return `
+  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.${meta.coreName}(buildContext(c))
+  const data = await executeOperation(
+    { variantKey: c.get('guardVariantKey'), caller: c.get('guardCaller') },
+    { guardShape: c.get('guardShape') },
+    {
+      core: core.${meta.coreName},
+      args: queryChannel(c),
+      body: c.get('body'),
+      prisma: requirePrisma(c.get('prisma')),
+      postgres: c.get('postgres'),
+      sqlite: c.get('sqlite'),
+      pagination: c.get('routeConfig')?.pagination,
+      override: c.get('operationOverride'),
+      getContext: c.get('getContext'),
+    },
+  )
   c.set('resultData', data)
   c.set('resultStatus', ${meta.successStatus})
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
   const updateEachExportName = `${modelName}UpdateEach`
   const updateEachHandler = `
@@ -45,12 +78,26 @@ export async function ${updateEachExportName}(c: HandlerContext): Promise<void>
   return `import type { Context } from 'hono'
 import * as core from './${modelName}Core${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
+import {
+  executeOperation,
+  requirePrisma,
+  type ArgsChannel,
+} from '../operationPipeline${ext}'
 import type { HonoInternalVariables } from '../routeConfig.target${ext}'
 
 type HandlerContext = Context<{ Variables: HonoInternalVariables }>
 
+function queryChannel(c: HandlerContext): ArgsChannel {
+  return {
+    read: () => c.get('parsedQuery'),
+    write: (next) => c.set('parsedQuery', next),
+  }
+}
+
 function buildContext(c: HandlerContext): OperationContext {
   return {
+    operationOverride: c.get('operationOverride'),
+    resolveOperationContext: c.get('getContext'),
     prisma: c.get('prisma'),
     postgres: c.get('postgres'),
     sqlite: c.get('sqlite'),
@@ -58,6 +105,7 @@ function buildContext(c: HandlerContext): OperationContext {
     body: c.get('body'),
     guardShape: c.get('guardShape'),
     guardCaller: c.get('guardCaller'),
+    guardVariantKey: c.get('guardVariantKey'),
     paginationConfig: c.get('routeConfig')?.pagination,
   }
 }
@@ -65,4 +113,4 @@ ${readHandlers}
 ${writeHandlers}
 ${updateEachHandler}
 `
-}
+}

package/src/generators/generateHonoOpenApi.ts

@@ -0,0 +1,93 @@
+import type { DMMF } from '@prisma/generator-helper'
+import { generateRouteConfigType } from './generateRouteConfigType'
+import type { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+import type { WriteStrategy } from '../constants'
+import { modelPathSegment, type PathCase } from '../utils/pathCasing'
+
+/**
+ * The per-model OpenAPI part, in a module of its own so the phase 9 boundary
+ * holds by construction: a bundle that does not import this file has no path
+ * to `buildModelOpenApi` or `yaml`, regardless of bundler side-effect
+ * heuristics.
+ */
+export function generateHonoOpenApiRoutes({
+  model,
+  enums,
+  guardShapesImport,
+  clientImport,
+  importStyle,
+  writeStrategy,
+  pathCase,
+}: {
+  model: DMMF.Model
+  enums: DMMF.DatamodelEnum[]
+  guardShapesImport: string | null
+  clientImport?: string
+  importStyle: ImportStyle
+  writeStrategy: WriteStrategy
+  pathCase: PathCase
+}): string {
+  const ext = importExt(importStyle)
+  const modelName = model.name
+  const modelSegment = modelPathSegment(modelName, pathCase)
+  const lower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
+
+  return `import { Hono } from 'hono'
+import type {
+  RouteConfig,
+  HonoEnvBase,
+  GeneratedHonoEnv,
+  PrismaClientLike,
+} from '../routeConfig.target${ext}'
+import { normalizePrefix, getEnv } from '../misc${ext}'
+import { registerOpenApiRoutes } from '../routerParts${ext}'
+import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
+import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
+
+${generateRouteConfigType(modelName, 'HonoBeforeHook', guardShapesImport, importStyle, 'hono', clientImport)}
+
+export function ${lower}OpenApi<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends HonoEnvBase = HonoEnvBase>(config: ${modelName}RouteConfig<TCtx, TPrisma, TEnv> = {}): Hono<GeneratedHonoEnv<TEnv>> {
+  const _env = getEnv()
+  const customPrefix = normalizePrefix(config.customUrlPrefix || '')
+  const modelPrefix = config.addModelPrefix !== false ? '/${modelSegment}' : ''
+  const basePath = customPrefix + modelPrefix
+
+  const openApiDisabled = config.disableOpenApi === true
+    || (config.disableOpenApi !== false && (
+      _env.NODE_ENV === 'production'
+      || _env.DISABLE_OPENAPI === 'true'
+    ))
+
+  const app = new Hono<GeneratedHonoEnv<TEnv>>()
+  if (!openApiDisabled) {
+    let jsonCache: unknown = undefined
+    let yamlCache: string | undefined = undefined
+    registerOpenApiRoutes(app, basePath, () => {
+      if (jsonCache === undefined) {
+        jsonCache = buildModelOpenApi(
+          '${modelName}',
+          MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
+          MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
+          config as unknown as Parameters<typeof buildModelOpenApi>[3],
+          { format: 'json', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
+        )
+      }
+      return jsonCache
+    }, () => {
+      if (yamlCache === undefined) {
+        yamlCache = buildModelOpenApi(
+          '${modelName}',
+          MODEL_FIELDS as unknown as Parameters<typeof buildModelOpenApi>[1],
+          MODEL_ENUMS as unknown as Parameters<typeof buildModelOpenApi>[2],
+          config as unknown as Parameters<typeof buildModelOpenApi>[3],
+          { format: 'yaml', writeStrategy: '${writeStrategy}', pathSegment: '${modelSegment}' },
+        ) as string
+      }
+      return yamlCache
+    })
+  }
+  return app
+}
+`
+}