prisma-generator-express 1.66.0 → 1.68.0

package/src/generators/generateOperationCore.ts

@@ -1,7 +1,8 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
-import { WriteStrategy, FindManyPaginatedMode } from '../constants'
+import type { WriteStrategy, FindManyPaginatedMode } from '../constants'
 
 export interface ModelCoreOptions {
   model: DMMF.Model
@@ -17,7 +18,10 @@ function decideWriteOp(
   defaultMethod: string,
   strategy: WriteStrategy,
 ): WriteOpDecision {
-  if (strategy === 'throwOnNonReturning' && (name === 'createMany' || name === 'updateMany')) {
+  if (
+    strategy === 'throwOnNonReturning' &&
+    (name === 'createMany' || name === 'updateMany')
+  ) {
     return { throw: true, method: defaultMethod }
   }
   if (strategy === 'forceReturn') {
@@ -27,7 +31,10 @@ function decideWriteOp(
   return { method: defaultMethod }
 }
 
-function renderPaginatedBody(modelNameLower: string, mode: FindManyPaginatedMode): string {
+function renderPaginatedBody(
+  modelNameLower: string,
+  mode: FindManyPaginatedMode,
+): string {
   if (mode === 'transaction') {
     return `
   const txClient = extended as { $transaction?: <T>(fn: (tx: unknown) => Promise<T>) => Promise<T> }
@@ -69,16 +76,25 @@ export function generateModelCore(options: ModelCoreOptions): string {
   const modelName = options.model.name
   const modelNameLower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
   const writeStrategy = options.writeStrategy
-  const paginatedBody = renderPaginatedBody(modelNameLower, options.findManyPaginatedMode)
+  const paginatedBody = renderPaginatedBody(
+    modelNameLower,
+    options.findManyPaginatedMode,
+  )
 
   const standardReadOps = [
-    'findFirst', 'findUnique', 'findUniqueOrThrow', 'findFirstOrThrow',
-    'count', 'aggregate', 'groupBy',
+    'findFirst',
+    'findUnique',
+    'findUniqueOrThrow',
+    'findFirstOrThrow',
+    'count',
+    'aggregate',
+    'groupBy',
   ]
 
   const standardReadHandlers = standardReadOps
-    .map((op) => `
-export async function ${op}(ctx: OperationContext): Promise<unknown> {
+    .map(
+      (op) => `
+async function default_${op}(ctx: OperationContext): Promise<unknown> {
   const query = ctx.parsedQuery || {}
   const extended = await getExtendedClient(ctx)
   const delegate = getDelegate(extended, '${modelNameLower}')
@@ -87,38 +103,56 @@ export async function ${op}(ctx: OperationContext): Promise<unknown> {
     return delegate.guard(ctx.guardShape, ctx.guardCaller).${op}(query)
   }
   return delegate.${op}(query)
-}`)
+}`,
+    )
     .join('\n')
 
   const writeOps = [
     { name: 'create', method: 'create', requiredFields: ['data'] },
     { name: 'createMany', method: 'createMany', requiredFields: ['data'] },
-    { name: 'createManyAndReturn', method: 'createManyAndReturn', requiredFields: ['data'] },
+    {
+      name: 'createManyAndReturn',
+      method: 'createManyAndReturn',
+      requiredFields: ['data'],
+    },
     { name: 'update', method: 'update', requiredFields: ['where', 'data'] },
-    { name: 'updateMany', method: 'updateMany', requiredFields: ['where', 'data'] },
-    { name: 'updateManyAndReturn', method: 'updateManyAndReturn', requiredFields: ['where', 'data'] },
+    {
+      name: 'updateMany',
+      method: 'updateMany',
+      requiredFields: ['where', 'data'],
+    },
+    {
+      name: 'updateManyAndReturn',
+      method: 'updateManyAndReturn',
+      requiredFields: ['where', 'data'],
+    },
     { name: 'deleteUnique', method: 'delete', requiredFields: ['where'] },
     { name: 'deleteMany', method: 'deleteMany', requiredFields: ['where'] },
-    { name: 'upsert', method: 'upsert', requiredFields: ['where', 'create', 'update'] },
+    {
+      name: 'upsert',
+      method: 'upsert',
+      requiredFields: ['where', 'create', 'update'],
+    },
   ]
 
-  const writeHandlers = writeOps.map((op) => {
-    const decision = decideWriteOp(op.name, op.method, writeStrategy)
+  const writeHandlers = writeOps
+    .map((op) => {
+      const decision = decideWriteOp(op.name, op.method, writeStrategy)
 
-    if (decision.throw) {
-      return `
-export async function ${op.name}(_ctx: OperationContext): Promise<unknown> {
+      if (decision.throw) {
+        return `
+async function default_${op.name}(_ctx: OperationContext): Promise<unknown> {
   throw new HttpError(501, '${op.name} is disabled by writeStrategy="${writeStrategy}"')
 }`
-    }
+      }
 
-    const method = decision.method
-    const validationLines = op.requiredFields
-      .map((field) => `  requireBodyField(body, '${field}')`)
-      .join('\n')
+      const method = decision.method
+      const validationLines = op.requiredFields
+        .map((field) => `  requireBodyField(body, '${field}')`)
+        .join('\n')
 
-    return `
-export async function ${op.name}(ctx: OperationContext): Promise<unknown> {
+      return `
+async function default_${op.name}(ctx: OperationContext): Promise<unknown> {
   const body = validateBody(ctx.body)
 ${validationLines}
   const extended = await getExtendedClient(ctx)
@@ -129,11 +163,24 @@ ${validationLines}
   }
   return delegate.${method}(body)
 }`
-  }).join('\n')
+    })
+    .join('\n')
+
+  const wrappers = OPERATION_METADATA.filter((op) => op.name !== 'updateEach')
+    .map(
+      (op) => `
+export async function ${op.coreName}(ctx: OperationContext): Promise<${op.name === 'findManyPaginated' ? '{ data: unknown[]; total: number; hasMore: boolean }' : 'unknown'}> {
+  const input = ${op.kind === 'read' ? 'ctx.parsedQuery || {}' : 'validateBody(ctx.body)'}
+${op.requiredBodyFields.map((field) => `  requireBodyField(input, '${field}')`).join('\n')}
+  return executeOperationOverride(ctx, '${modelNameLower}', '${op.name}', input, () => default_${op.coreName}(ctx))
+}`,
+    )
+    .join('\n')
 
   return `import {
-  OperationContext,
-  PrismaClientLike,
+  type OperationContext,
+  executeOperationOverride,
+  type PrismaClientLike,
   getExtendedClient,
   getDelegate,
   validateBody,
@@ -144,7 +191,7 @@ import { applyPaginationLimits, countForPagination } from '../pagination${ext}'
 import { assertGuard } from '../guardHelpers${ext}'
 import { mapLimited } from '../concurrency${ext}'
 
-export async function findMany(ctx: OperationContext): Promise<unknown> {
+async function default_findMany(ctx: OperationContext): Promise<unknown> {
   const rawQuery = ctx.parsedQuery || {}
   const query = applyPaginationLimits(rawQuery, ctx.paginationConfig, !!ctx.guardShape)
   const extended = await getExtendedClient(ctx)
@@ -155,10 +202,11 @@ export async function findMany(ctx: OperationContext): Promise<unknown> {
   }
   return delegate.findMany(query)
 }
+${wrappers}
 ${standardReadHandlers}
 ${writeHandlers}
 
-export async function findManyPaginated(
+async function default_findManyPaginated(
   ctx: OperationContext,
 ): Promise<{ data: unknown[]; total: number; hasMore: boolean }> {
   const rawQuery = ctx.parsedQuery || {}
@@ -252,4 +300,4 @@ export async function updateEach(
   return results
 }
 `
-}
+}

package/src/generators/generateRelationMeta.ts

@@ -32,13 +32,15 @@ function findOppositeField(
   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
+  return (
+    target.fields.find(
+      (f) =>
+        f.kind === 'object' &&
+        f.relationName === relationName &&
+        f.type === selfModelName &&
+        !(isSelfRelation && f.name === selfFieldName),
+    ) || null
+  )
 }
 
 function computeRelation(
@@ -61,7 +63,13 @@ function computeRelation(
     }
   }
 
-  const opposite = findOppositeField(models, field.type, field.relationName, selfModelName, field.name)
+  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[]
@@ -118,7 +126,9 @@ export interface GenerateRelationMetaOptions {
   importStyle: ImportStyle
 }
 
-export function generateRelationMeta(options: GenerateRelationMetaOptions): string {
+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}'
@@ -132,7 +142,9 @@ export interface GenerateRelationModelsIndexOptions {
   importStyle: ImportStyle
 }
 
-export function generateRelationModelsIndex(options: GenerateRelationModelsIndexOptions): string {
+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}'`)
@@ -147,4 +159,4 @@ export const relationModels: Record<string, ModelRelationMap> = {
 ${entries}
 }
 `
-}
+}

package/src/generators/generateRouteConfigType.ts

@@ -1,11 +1,14 @@
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import type { Target } from '../constants'
-import { OPERATION_METADATA, READ_OPERATION_NAMES } from '../copy/operationDefinitions'
+import {
+  OPERATION_METADATA,
+  READ_OPERATION_NAMES,
+} from '../copy/operationDefinitions'
 
-const ROUTER_OPERATIONS = OPERATION_METADATA
-  .filter((m) => m.name !== 'updateEach')
-  .map((m) => m.name)
+const ROUTER_OPERATIONS = OPERATION_METADATA.filter(
+  (m) => m.name !== 'updateEach',
+).map((m) => m.name)
 
 function capitalize(str: string): string {
   return str.charAt(0).toUpperCase() + str.slice(1)
@@ -13,15 +16,15 @@ function capitalize(str: string): string {
 
 function requestTypeFor(target: Target): string {
   if (target === 'fastify') return `import('fastify').FastifyRequest`
-  if (target === 'hono') return `import('hono').Context<TEnv>`
+  if (target === 'hono') return `import('hono').Context<GeneratedHonoEnv<TEnv>>`
   return `import('express').Request`
 }
 
 function configGenericsFor(target: Target): string {
   if (target === 'hono') {
-    return `<TCtx = unknown, TPrisma = any, TEnv extends { Variables: Record<string, unknown> } = { Variables: Record<string, unknown> }>`
+    return `<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike, TEnv extends { Variables: Record<string, unknown> } = { Variables: Record<string, unknown> }>`
   }
-  return `<TCtx = unknown, TPrisma = any>`
+  return `<TCtx = unknown, TPrisma extends PrismaClientLike = PrismaClientLike>`
 }
 
 function routeConfigBaseFor(target: Target): string {
@@ -50,6 +53,7 @@ export function generateRouteConfigType(
   guardShapesImport: string | null,
   importStyle: ImportStyle,
   target: Target,
+  clientImport?: string,
 ): string {
   const ext = importExt(importStyle)
   const m = modelName
@@ -61,14 +65,33 @@ export function generateRouteConfigType(
   const afterRef = afterHookRef(target, hookHandlerType)
   const requestType = requestTypeFor(target)
 
-  const progressiveTypeImport = supportsProgressive
+  const clientPath = clientImport ? `${clientImport}${ext}` : '@prisma/client'
+  const delegate = `${m.charAt(0).toLowerCase() + m.slice(1)}`
+  const modelDelegate = clientImport
+    ? `PrismaClient['${delegate}']`
+    : `(TPrisma extends Record<'${delegate}', infer D> ? D : never)`
+  const overrideImports = `import type { Prisma${clientImport ? ', PrismaClient' : ''} } from '${clientPath}'\nimport type { OperationOverride } from '../operationRuntime${ext}'\n`
+  const overrideType = (op: string) => {
+    const method = op === 'findManyPaginated' ? 'findMany' : op
+    const args = `Prisma.Args<${modelDelegate}, '${method}'>`
+    const result = `Prisma.Result<${modelDelegate}, ${args}, '${method}'>`
+    const output =
+      op === 'findManyPaginated'
+        ? `{ data: ${result}; total: number; hasMore: boolean }`
+        : result
+    const methods =
+      op === 'findManyPaginated' ? "'findMany' | 'count'" : `'${method}'`
+    return `OperationOverride<${args}, ${output}, TCtx, Readonly<{ ${delegate}: Pick<${modelDelegate}, Extract<keyof ${modelDelegate}, ${methods}>> }>>`
+  }
+  const typeImports = supportsProgressive
     ? `import type { ProgressiveVariantConfig, ProgressiveStage } from '../routeConfig.target${ext}'\n`
     : ''
 
   if (!guardShapesImport) {
     return (
-      progressiveTypeImport +
-      `export type ${m}RouteConfig${generics} = ${baseConfig}\n`
+      overrideImports +
+      typeImports +
+      `export type ${m}RouteConfig${generics} = Omit<${baseConfig}, ${ROUTER_OPERATIONS.map((op) => `'${op}'`).join(' | ')}> & {\n${ROUTER_OPERATIONS.map((op) => `  ${op}?: (Omit<Exclude<${baseConfig}['${op}'], false | undefined>, 'override'> & { override?: ${overrideType(op)} }) | false`).join('\n')}\n}\n`
     )
   }
 
@@ -95,6 +118,8 @@ export function generateRouteConfigType(
     const c = capitalize(routerOp)
     const isRead = READ_OPERATION_NAMES.has(routerOp)
     const commonLines = [
+      `    override?: ${overrideType(routerOp)}`,
+      `    authorize?: ${beforeRef}`,
       `    before?: ${beforeRef}[]`,
       `    after?: ${afterRef}[]`,
       `    pagination?: Partial<PaginationConfig>`,
@@ -133,7 +158,8 @@ export function generateRouteConfigType(
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')
 
   return (
-    progressiveTypeImport +
+    overrideImports +
+    typeImports +
     `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
     `${shapeOrFnAliases}\n\n` +
     `export type ${m}RouteConfig${generics} = Omit<\n` +
@@ -144,4 +170,4 @@ export function generateRouteConfigType(
     `  resolveContext?: (request: ${requestType}) => TCtx | Promise<TCtx>\n` +
     `${overrides}\n}\n`
   )
-}
+}