prisma-generator-express 1.42.0 → 1.44.0

package/src/generators/generateRelationMeta.ts

@@ -0,0 +1,160 @@
+import { DMMF } from '@prisma/generator-helper'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
+
+type RelationDirection = 'parentOwnsFk' | 'childOwnsFk' | 'implicitM2M'
+
+type RelationFieldMeta = {
+  name: string
+  type: string
+  isList: boolean
+  isRequired: boolean
+  direction: RelationDirection
+  parentLinkFields: string[]
+  childLinkFields: string[]
+}
+
+type ModelMeta = {
+  name: string
+  delegateKey: string
+  scalarFields: string[]
+  idFields: string[]
+  relations: Record<string, RelationFieldMeta>
+}
+
+function findOppositeField(
+  models: ReadonlyArray<DMMF.Model>,
+  targetModelName: string,
+  relationName: string | undefined,
+  selfModelName: string,
+  selfFieldName: string,
+): DMMF.Field | null {
+  if (!relationName) return null
+  const target = models.find((m) => m.name === targetModelName)
+  if (!target) return null
+  const isSelfRelation = targetModelName === selfModelName
+  return target.fields.find(
+    (f) =>
+      f.kind === 'object' &&
+      f.relationName === relationName &&
+      f.type === selfModelName &&
+      !(isSelfRelation && f.name === selfFieldName),
+  ) || null
+}
+
+function computeRelation(
+  field: DMMF.Field,
+  selfModelName: string,
+  models: ReadonlyArray<DMMF.Model>,
+): RelationFieldMeta {
+  const selfFrom = (field.relationFromFields ?? []) as string[]
+  const selfTo = (field.relationToFields ?? []) as string[]
+
+  if (selfFrom.length > 0) {
+    return {
+      name: field.name,
+      type: field.type,
+      isList: field.isList,
+      isRequired: field.isRequired,
+      direction: 'parentOwnsFk',
+      parentLinkFields: selfFrom,
+      childLinkFields: selfTo,
+    }
+  }
+
+  const opposite = findOppositeField(models, field.type, field.relationName, selfModelName, field.name)
+  if (opposite) {
+    const oppFrom = (opposite.relationFromFields ?? []) as string[]
+    const oppTo = (opposite.relationToFields ?? []) as string[]
+    if (oppFrom.length > 0) {
+      return {
+        name: field.name,
+        type: field.type,
+        isList: field.isList,
+        isRequired: field.isRequired,
+        direction: 'childOwnsFk',
+        parentLinkFields: oppTo,
+        childLinkFields: oppFrom,
+      }
+    }
+  }
+
+  return {
+    name: field.name,
+    type: field.type,
+    isList: field.isList,
+    isRequired: field.isRequired,
+    direction: 'implicitM2M',
+    parentLinkFields: [],
+    childLinkFields: [],
+  }
+}
+
+function buildModelMeta(
+  model: DMMF.Model,
+  models: ReadonlyArray<DMMF.Model>,
+): ModelMeta {
+  const scalarFields: string[] = []
+  const idFields: string[] = []
+  const relations: Record<string, RelationFieldMeta> = {}
+
+  for (const field of model.fields) {
+    if (field.kind === 'object') {
+      relations[field.name] = computeRelation(field, model.name, models)
+    } else if (field.kind === 'scalar' || field.kind === 'enum') {
+      scalarFields.push(field.name)
+      if (field.isId) idFields.push(field.name)
+    }
+  }
+
+  if (model.primaryKey && Array.isArray(model.primaryKey.fields)) {
+    for (const f of model.primaryKey.fields) {
+      if (!idFields.includes(f)) idFields.push(f)
+    }
+  }
+
+  return {
+    name: model.name,
+    delegateKey: model.name.charAt(0).toLowerCase() + model.name.slice(1),
+    scalarFields,
+    idFields,
+    relations,
+  }
+}
+
+export interface GenerateRelationMetaOptions {
+  model: DMMF.Model
+  allModels: ReadonlyArray<DMMF.Model>
+  importStyle: ImportStyle
+}
+
+export function generateRelationMeta(options: GenerateRelationMetaOptions): string {
+  const ext = importExt(options.importStyle)
+  const meta = buildModelMeta(options.model, options.allModels)
+  return `import type { ModelRelationMap } from '../autoIncludePlanner${ext}'
+
+export const ${options.model.name}Relations: ModelRelationMap = ${JSON.stringify(meta, null, 2)}
+`
+}
+
+export interface GenerateRelationModelsIndexOptions {
+  modelNames: ReadonlyArray<string>
+  importStyle: ImportStyle
+}
+
+export function generateRelationModelsIndex(options: GenerateRelationModelsIndexOptions): string {
+  const ext = importExt(options.importStyle)
+  const imports = options.modelNames
+    .map((n) => `import { ${n}Relations } from './${n}/${n}Relations${ext}'`)
+    .join('\n')
+  const entries = options.modelNames
+    .map((n) => `  ${n}: ${n}Relations,`)
+    .join('\n')
+  return `import type { ModelRelationMap } from './autoIncludePlanner${ext}'
+${imports}
+
+export const relationModels: Record<string, ModelRelationMap> = {
+${entries}
+}
+`
+}

package/src/generators/generateRouteConfigType.ts

@@ -42,6 +42,12 @@ function capitalize(s: string): string {
   return s.charAt(0).toUpperCase() + s.slice(1)
 }
 
+function requestTypeFor(target: Target): string {
+  if (target === 'fastify') return `import('fastify').FastifyRequest`
+  if (target === 'hono') return `import('hono').Context`
+  return `import('express').Request`
+}
+
 export function generateRouteConfigType(
   modelName: string,
   hookHandlerType: string,
@@ -52,9 +58,14 @@ export function generateRouteConfigType(
   const ext = importExt(importStyle)
   const m = modelName
   const supportsProgressive = target === 'express'
+  const requestType = requestTypeFor(target)
+
+  const progressiveTypeImport = supportsProgressive
+    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
+    : ''
 
   if (!guardShapesImport) {
-    return `export type ${m}RouteConfig<TCtx = unknown> = RouteConfig<Record<string, unknown>, TCtx>\n`
+    return progressiveTypeImport + `export type ${m}RouteConfig<TCtx = unknown> = RouteConfig<Record<string, unknown>, TCtx>\n`
   }
 
   const shapeOps = Object.values(ROUTER_OP_TO_SHAPE_OP).filter((v, i, a) => a.indexOf(v) === i)
@@ -78,10 +89,6 @@ export function generateRouteConfigType(
 
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')
 
-  const progressiveTypeImport = supportsProgressive
-    ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n\n`
-    : ''
-
   return (
     progressiveTypeImport +
     `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
@@ -90,7 +97,7 @@ export function generateRouteConfigType(
     `  | ${omitKeys}\n` +
     `  | 'resolveContext'\n` +
     `> & {\n` +
-    `  resolveContext?: (request: import('express').Request) => TCtx | Promise<TCtx>\n` +
+    `  resolveContext?: (request: ${requestType}) => TCtx | Promise<TCtx>\n` +
     `${overrides}\n}\n`
   )
 }

package/src/generators/generateRouter.ts

@@ -20,6 +20,7 @@ export function generateRouterFunction({
   const modelName = model.name
   const prefix = toCamelCase(modelName)
   const modelNameLower = modelName.toLowerCase()
+  const delegateKey = modelName.charAt(0).toLowerCase() + modelName.slice(1)
   const routerFunctionName = `${prefix}Router`
 
   const fieldsMeta = model.fields.map((f) => ({
@@ -69,7 +70,7 @@ import {
   ${prefix}GroupBy,
 } from './${modelName}Handlers${ext}'
 import * as core from './${modelName}Core${ext}'
-import type { RouteConfig, ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'
+import type { RouteConfig } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
 import { sanitizeKeys } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
@@ -79,7 +80,13 @@ import {
   acceptsEventStream,
   runProgressiveEndpoint,
   runSingleResultSSE,
+  emitTerminalSSEError,
+  removeReqCloseListener,
+  mapError,
+  HttpError,
 } from '../operationRuntime${ext}'
+import { relationModels } from '../relationModels${ext}'
+import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
 
 ${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
 const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
@@ -103,7 +110,7 @@ type ExtendedRequest = Request & {
 
 type LocalsBag = {
   parsedQuery?: Record<string, unknown>
-  routeConfig?: ${modelName}RouteConfig
+  routeConfig?: { pagination?: OperationContext['paginationConfig'] }
   guardShape?: Record<string, unknown>
   guardCaller?: string
   data?: unknown
@@ -200,7 +207,9 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   const setShape = (opConfig: OperationConfigLike): RequestHandler => {
     return (req, res, next) => {
       const locals = readLocals(res)
-      locals.routeConfig = config
+      if (config.pagination) {
+        locals.routeConfig = { pagination: config.pagination }
+      }
       const headerName = config.guard?.variantHeader || 'x-api-variant'
       const headerValue = req.get(headerName)
       const caller = config.guard?.resolveVariant?.(req) ?? headerValue ?? undefined
@@ -210,9 +219,10 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
     }
   }
 
-  const maybeProgressiveSSE = (
+const maybeProgressiveSSE = (
     opConfig: OperationConfigLike,
     coreFn: (ctx: OperationContext) => Promise<unknown>,
+    baseOp: string,
   ): RequestHandler => {
     return async (req, res, next) => {
       if (res.headersSent || res.writableEnded) return next()
@@ -233,13 +243,61 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
           return
         }
 
+        if (progressiveConfig.mode === 'autoInclude') {
+          const isSingleRecordRead =
+            baseOp === 'findUnique' || baseOp === 'findUniqueOrThrow' ||
+            baseOp === 'findFirst' || baseOp === 'findFirstOrThrow'
+
+          if (!isSingleRecordRead) {
+            if (progressiveConfig.fallback === 'error') {
+              emitTerminalSSEError(res, 'auto-progressive fallback: operation not single-record')
+              return
+            }
+            await runSingleResultSSE({
+              req,
+              res,
+              coreQueryFn: () => coreFn(buildContext(req, res)),
+            })
+            return
+          }
+
+          const ctx = buildContext(req, res)
+          const args = (locals.parsedQuery ?? {}) as Record<string, unknown>
+          const controller = new AbortController()
+          const onClose = () => controller.abort()
+          req.on('close', onClose)
+          try {
+            await runAutoIncludeProgressive({
+              req,
+              res,
+              ctx,
+              args,
+              baseOp: baseOp as 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow',
+              modelName: '${modelName}',
+              delegateKey: '${delegateKey}',
+              models: relationModels,
+              variantConfig: progressiveConfig,
+              coreQueryFn: () => coreFn(ctx),
+              signal: controller.signal,
+            })
+          } finally {
+            removeReqCloseListener(req, onClose)
+          }
+          return
+        }
+
         if (!Array.isArray(progressiveConfig.stages)) {
-          return next({ status: 500, message: 'Progressive endpoint requires stages array' })
+          await runSingleResultSSE({
+            req,
+            res,
+            coreQueryFn: () => coreFn(buildContext(req, res)),
+          })
+          return
         }
 
         const stageRegistry = opConfig.progressiveStages ?? {}
         const missingStage = progressiveConfig.stages.find(
-          (name) => typeof stageRegistry[name] !== 'function',
+          (name: string) => typeof stageRegistry[name] !== 'function',
         )
         if (missingStage) {
           return next({ status: 500, message: 'Missing progressive stage: ' + missingStage })
@@ -297,63 +355,63 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
     const opConfig: OperationConfigLike = (config.findFirst as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/first\` : '/first'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirst), ${prefix}FindFirst as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirst, 'findFirst'), ${prefix}FindFirst as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirst as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findFirstOrThrow) {
     const opConfig: OperationConfigLike = (config.findFirstOrThrow as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirstOrThrow), ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findFirstOrThrow, 'findFirstOrThrow'), ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindFirstOrThrow as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findManyPaginated) {
     const opConfig: OperationConfigLike = (config.findManyPaginated as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findManyPaginated), ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findManyPaginated, 'findManyPaginated'), ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindManyPaginated as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.aggregate) {
     const opConfig: OperationConfigLike = (config.aggregate as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.aggregate), ${prefix}Aggregate as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.aggregate, 'aggregate'), ${prefix}Aggregate as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Aggregate as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.count) {
     const opConfig: OperationConfigLike = (config.count as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/count\` : '/count'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.count), ${prefix}Count as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.count, 'count'), ${prefix}Count as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}Count as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.groupBy) {
     const opConfig: OperationConfigLike = (config.groupBy as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.groupBy), ${prefix}GroupBy as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.groupBy, 'groupBy'), ${prefix}GroupBy as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}GroupBy as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findUniqueOrThrow) {
     const opConfig: OperationConfigLike = (config.findUniqueOrThrow as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUniqueOrThrow), ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUniqueOrThrow, 'findUniqueOrThrow'), ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUniqueOrThrow as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findUnique) {
     const opConfig: OperationConfigLike = (config.findUnique as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath ? \`\${basePath}/unique\` : '/unique'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUnique), ${prefix}FindUnique as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findUnique, 'findUnique'), ${prefix}FindUnique as RequestHandler, ...after, respond)
     if (postReadsEnabled) router.post(path, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindUnique as RequestHandler, ...after, respond)
   }
   if (config.enableAll || config.findMany) {
     const opConfig: OperationConfigLike = (config.findMany as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = basePath || '/'
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findMany), ${prefix}FindMany as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.findMany, 'findMany'), ${prefix}FindMany as RequestHandler, ...after, respond)
     if (postReadsEnabled) {
       const postPath = basePath ? \`\${basePath}/read\` : '/read'
       router.post(postPath, parseBodyAsQuery, setShape(opConfig), ...before, ${prefix}FindMany as RequestHandler, ...after, respond)
@@ -416,10 +474,16 @@ export function ${routerFunctionName}<TCtx = unknown>(config: ${modelName}RouteC
   }
 
   router.use((err: unknown, _req: Request, res: Response, next: NextFunction) => {
-    const e = err as { status?: number; message?: string }
-    const status = typeof e.status === 'number' ? e.status : 500
-    const message = e.message || 'Internal server error'
-    if (!res.headersSent) return res.status(status).json({ message })
+    let httpError: HttpError
+    if (err instanceof HttpError) {
+      httpError = err
+    } else if (err && typeof err === 'object' && typeof (err as { status?: number }).status === 'number') {
+      const e = err as { status: number; message?: string }
+      httpError = new HttpError(e.status, e.message || 'Internal server error')
+    } else {
+      httpError = mapError(err)
+    }
+    if (!res.headersSent) return res.status(httpError.status).json({ message: httpError.message })
     next(err)
   })