prisma-generator-express 1.45.1 → 1.47.0

package/src/copy/routeConfig.hono.ts

@@ -13,13 +13,41 @@ export type {
   OpenApiSecuritySchemeConfig,
 }
 
-export type HonoHookHandler<Env extends { Variables: Record<string, unknown> } = { Variables: Record<string, unknown> }> = (
-  c: Context<Env>,
+export type HonoEnvBase = {
+  Variables: Record<string, unknown>
+  Bindings?: Record<string, unknown>
+}
+
+export type HonoInternalVariables = {
+  prisma?: unknown
+  postgres?: unknown
+  sqlite?: unknown
+  parsedQuery?: Record<string, unknown>
+  body?: unknown
+  routeConfig?: { pagination?: unknown }
+  guardShape?: Record<string, unknown>
+  guardCaller?: string
+  resultData?: unknown
+  resultStatus?: number
+}
+
+export type GeneratedHonoEnv<TEnv extends HonoEnvBase = HonoEnvBase> = {
+  Variables: HonoInternalVariables & TEnv['Variables']
+  Bindings: TEnv['Bindings']
+}
+
+export type HonoHookHandler<TEnv extends HonoEnvBase = HonoEnvBase> = (
+  c: Context<GeneratedHonoEnv<TEnv>>,
   next: Next,
 ) => Promise<Response | void> | Response | void
 
-export type OperationConfig<TShape = Record<string, unknown>> =
-  BaseOperationConfig<HonoHookHandler, TShape>
+export type OperationConfig<
+  TShape = Record<string, unknown>,
+  TEnv extends HonoEnvBase = HonoEnvBase,
+> = BaseOperationConfig<HonoHookHandler<TEnv>, TShape>
 
-export type RouteConfig<TShape = Record<string, unknown>, TCtx = unknown> =
-  BaseRouteConfig<HonoHookHandler, Context, TShape, TCtx>
+export type RouteConfig<
+  TShape = Record<string, unknown>,
+  TCtx = unknown,
+  TEnv extends HonoEnvBase = HonoEnvBase,
+> = BaseRouteConfig<HonoHookHandler<TEnv>, Context<GeneratedHonoEnv<TEnv>>, TShape, TCtx>

package/src/copy/routeConfig.ts

@@ -36,7 +36,7 @@ export type ProgressiveStageResult<T = unknown> =
   | ProgressivePatch[]
   | ProgressiveStopResult<T>
 
-export type ProgressiveStageContext<TContext = unknown, TPrisma = unknown> = {
+export type ProgressiveStageContext<TContext = unknown, TPrisma = any> = {
   ctx: TContext
   req: unknown
   res: unknown
@@ -46,7 +46,7 @@ export type ProgressiveStageContext<TContext = unknown, TPrisma = unknown> = {
   signal: AbortSignal
 }
 
-export type ProgressiveStage<TContext = unknown, TPrisma = unknown, T = unknown> = (
+export type ProgressiveStage<TContext = unknown, TPrisma = any, T = unknown> = (
   context: ProgressiveStageContext<TContext, TPrisma>,
 ) => Promise<ProgressiveStageResult<T>>
 
@@ -117,6 +117,7 @@ export interface BaseRouteConfig<
   upsert?: BaseOperationConfig<HookHandler, TShape>
   delete?: BaseOperationConfig<HookHandler, TShape>
   deleteMany?: BaseOperationConfig<HookHandler, TShape>
+  updateEach?: BaseOperationConfig<HookHandler, TShape>
   aggregate?: BaseOperationConfig<HookHandler, TShape>
   count?: BaseOperationConfig<HookHandler, TShape>
   groupBy?: BaseOperationConfig<HookHandler, TShape>

package/src/generators/generateFastifyHandler.ts

@@ -1,5 +1,4 @@
 import { DMMF } from '@prisma/generator-helper'
-import { toCamelCase } from '../utils/strings'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 
@@ -47,11 +46,9 @@ export function generateFastifyHandler(options: {
 }): string {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
-  const prefix = toCamelCase(modelName)
 
   const readHandlers = READ_OPS.map((op) => {
-    const exportName = `${prefix}${op.charAt(0).toUpperCase() + op.slice(1)}`
-
+    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
     return `
 export async function ${exportName}(
   request: FastifyRequest,
@@ -63,7 +60,7 @@ export async function ${exportName}(
   }).join('\n')
 
   const writeHandlers = WRITE_OPS.map((op) => {
-    const exportName = `${prefix}${op.charAt(0).toUpperCase() + op.slice(1)}`
+    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
     const statusCode = CREATED_OPS.has(op) ? 201 : 200
 
     return `

package/src/generators/generateHonoHandler.ts

@@ -1,5 +1,4 @@
 import { DMMF } from '@prisma/generator-helper'
-import { toCamelCase } from '../utils/strings'
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 
@@ -47,11 +46,9 @@ export function generateHonoHandler(options: {
 }): string {
   const ext = importExt(options.importStyle)
   const modelName = options.model.name
-  const prefix = toCamelCase(modelName)
 
   const readHandlers = READ_OPS.map((op) => {
-    const exportName = `${prefix}${op.charAt(0).toUpperCase() + op.slice(1)}`
-
+    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
     return `
 export async function ${exportName}(c: Context<HonoEnv>): Promise<void> {
   const data = await core.${coreFnName(op)}(buildContext(c))
@@ -60,7 +57,7 @@ export async function ${exportName}(c: Context<HonoEnv>): Promise<void> {
   }).join('\n')
 
   const writeHandlers = WRITE_OPS.map((op) => {
-    const exportName = `${prefix}${op.charAt(0).toUpperCase() + op.slice(1)}`
+    const exportName = `${modelName}${op.charAt(0).toUpperCase() + op.slice(1)}`
     const statusCode = CREATED_OPS.has(op) ? 201 : 200
 
     return `

package/src/generators/generateImportPrismaStatement.ts

@@ -11,20 +11,10 @@ function findClientGenerator(options: GeneratorOptions) {
       gen.provider.value === '@prisma/client' ||
       gen.provider.value === 'prisma-client',
   )
-  if (byProvider) return byProvider
-
-  const withOutput = options.otherGenerators.find(
-    (gen) =>
-      gen.output?.value?.includes('prisma') ||
-      gen.output?.value?.includes('client'),
-  )
-  return withOutput || null
+  return byProvider || null
 }
 
-function getRelativeImportPath(
-  fromDir: string,
-  clientOutputPath: string,
-): string {
+function getRelativeImportPath(fromDir: string, clientOutputPath: string): string {
   let relativeImportPath = path.relative(fromDir, clientOutputPath)
   relativeImportPath = relativeImportPath.split(path.sep).join(path.posix.sep)
   if (!relativeImportPath.startsWith('.')) {
@@ -33,28 +23,6 @@ function getRelativeImportPath(
   return relativeImportPath
 }
 
-export function generateImportPrismaStatement(
-  generatorOptions: GeneratorOptions,
-): string {
-  const clientGenerator = findClientGenerator(generatorOptions)
-
-  if (!clientGenerator || !clientGenerator.output?.value) {
-    throw new Error(
-      'Prisma client generator not found. Ensure a generator with provider "prisma-client-js" exists in your schema.',
-    )
-  }
-
-  const outputValue = generatorOptions.generator.output?.value
-  if (!outputValue) {
-    throw new Error('Generator output path not defined.')
-  }
-
-  const subDir = path.join(outputValue, '_relative')
-  const outputPath = getRelativeImportPath(subDir, clientGenerator.output.value)
-
-  return `import { Prisma, PrismaClient } from '${outputPath}';\n`
-}
-
 export function getRelativeClientPath(
   generatorOptions: GeneratorOptions,
   modelName: string,
@@ -63,7 +31,7 @@ export function getRelativeClientPath(
 
   if (!clientGenerator || !clientGenerator.output?.value) {
     throw new Error(
-      'Prisma client generator not found. Ensure a generator with provider "prisma-client-js" exists in your schema.',
+      'Prisma client generator not found. Ensure a generator block exists with name "client" or provider one of: prisma-client-js, @prisma/client, prisma-client.',
     )
   }
 

package/src/generators/generateOperationCore.ts

@@ -61,6 +61,8 @@ ${validationLines}
 
   return `import {
   OperationContext,
+  PrismaClientLike,
+  HttpError,
   getExtendedClient,
   getDelegate,
   validateBody,
@@ -68,6 +70,7 @@ ${validationLines}
   applyPaginationLimits,
   assertGuard,
   countForPagination,
+  mapError,
 } from '../operationRuntime${ext}'
 
 export async function findMany(ctx: OperationContext): Promise<unknown> {
@@ -123,7 +126,7 @@ export async function findManyPaginated(
       total = txResult.t
     } catch (txError: unknown) {
       const txe = txError as { message?: string; code?: string }
-      if ((typeof txe?.message === 'string' && txe.message.includes('interactive transactions')) || txe?.code === 'P2028') {
+      if (txe?.code === 'P2028') {
         console.warn('[prisma-generator-express] Interactive transactions not available, pagination queries are non-atomic')
         items = (await delegate.findMany(query)) as unknown[]
         total = await countForPagination(delegate, query, undefined, undefined, distinctCountLimit)
@@ -140,5 +143,38 @@ export async function findManyPaginated(
 
   return { data: items, total, hasMore }
 }
+
+export async function updateEach(
+  ctx: OperationContext,
+  atomic: boolean,
+): Promise<unknown> {
+  const body = ctx.body
+  if (!Array.isArray(body)) {
+    throw new HttpError(400, 'updateEach body must be an array of { where, data } items')
+  }
+  const items = body as Record<string, unknown>[]
+  const client = ctx.prisma as PrismaClientLike
+  const delegate = getDelegate(client, '${modelNameLower}')
+
+  if (atomic) {
+    if (typeof client.$transaction !== 'function') {
+      throw new HttpError(500, 'Atomic updateEach requires transaction support on the Prisma client')
+    }
+    const ops = items.map((item) => delegate.update(item))
+    const runArray = client.$transaction as unknown as (
+      promises: unknown[],
+    ) => Promise<unknown[]>
+    return runArray(ops)
+  }
+
+  const settled = await Promise.allSettled(
+    items.map((item) => delegate.update(item)),
+  )
+  return settled.map((result) =>
+    result.status === 'fulfilled'
+      ? { status: 'ok', data: result.value }
+      : { status: 'error', error: mapError(result.reason).message },
+  )
+}
 `
 }

package/src/generators/generateQueryBuilderHelper.ts

@@ -86,6 +86,15 @@ function doStart(options: QueryBuilderOptions): Promise<void> {
       return
     }
 
+    const schemaByteLength = Buffer.byteLength(schemaContent, 'utf8')
+    if (schemaByteLength > 28000) {
+      console.warn(
+        '[query-builder] Schema size is ' + schemaByteLength + ' bytes. ' +
+        'Environment variable size limits may cause spawn failure on Windows (~32KB). ' +
+        'If the query builder fails to start, this is the likely cause.',
+      )
+    }
+
     const schemaCwd = dirname(resolve(schemaPath))
 
     _process = spawn(process.execPath, [cliPath], {

package/src/generators/generateRelationMeta.ts

@@ -18,7 +18,6 @@ type ModelMeta = {
   name: string
   delegateKey: string
   scalarFields: string[]
-  idFields: string[]
   relations: Record<string, RelationFieldMeta>
 }
 
@@ -95,7 +94,6 @@ function buildModelMeta(
   models: ReadonlyArray<DMMF.Model>,
 ): ModelMeta {
   const scalarFields: string[] = []
-  const idFields: string[] = []
   const relations: Record<string, RelationFieldMeta> = {}
 
   for (const field of model.fields) {
@@ -103,13 +101,6 @@ function buildModelMeta(
       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)
     }
   }
 
@@ -117,7 +108,6 @@ function buildModelMeta(
     name: model.name,
     delegateKey: model.name.charAt(0).toLowerCase() + model.name.slice(1),
     scalarFields,
-    idFields,
     relations,
   }
 }

package/src/generators/generateRouteConfigType.ts

@@ -1,6 +1,7 @@
 import { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import type { Target } from '../constants'
+import { capitalize } from '../utils/strings'
 
 const ROUTER_OPERATIONS = [
   'findUnique', 'findUniqueOrThrow', 'findFirst', 'findFirstOrThrow',
@@ -38,16 +39,35 @@ const ROUTER_OP_TO_SHAPE_OP: Record<RouterOperation, string> = {
   deleteMany: 'deleteMany',
 }
 
-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`
+  if (target === 'hono') return `import('hono').Context<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 = any>`
+}
+
+function routeConfigBaseFor(target: Target): string {
+  if (target === 'hono') {
+    return `RouteConfig<Record<string, unknown>, TCtx, TEnv>`
+  }
+  if (target === 'express') {
+    return `RouteConfig<Record<string, unknown>, TCtx, TPrisma>`
+  }
+  return `RouteConfig<Record<string, unknown>, TCtx>`
+}
+
+function hookHandlerTypeRef(target: Target, hookHandlerType: string): string {
+  if (target === 'hono') return `${hookHandlerType}<TEnv>`
+  return hookHandlerType
+}
+
 export function generateRouteConfigType(
   modelName: string,
   hookHandlerType: string,
@@ -58,6 +78,10 @@ export function generateRouteConfigType(
   const ext = importExt(importStyle)
   const m = modelName
   const supportsProgressive = target === 'express'
+
+  const generics = configGenericsFor(target)
+  const baseConfig = routeConfigBaseFor(target)
+  const hookRef = hookHandlerTypeRef(target, hookHandlerType)
   const requestType = requestTypeFor(target)
 
   const progressiveTypeImport = supportsProgressive
@@ -65,7 +89,7 @@ export function generateRouteConfigType(
     : ''
 
   if (!guardShapesImport) {
-    return progressiveTypeImport + `export type ${m}RouteConfig<TCtx = unknown> = RouteConfig<Record<string, unknown>, TCtx>\n`
+    return progressiveTypeImport + `export type ${m}RouteConfig${generics} = ${baseConfig}\n`
   }
 
   const shapeOps = Object.values(ROUTER_OP_TO_SHAPE_OP).filter((v, i, a) => a.indexOf(v) === i)
@@ -76,13 +100,13 @@ export function generateRouteConfigType(
     const c = capitalize(shapeOp)
     const isRead = READ_OPERATIONS.has(routerOp)
     const lines = [
-      `    before?: ${hookHandlerType}[]`,
-      `    after?: ${hookHandlerType}[]`,
+      `    before?: ${hookRef}[]`,
+      `    after?: ${hookRef}[]`,
       `    shape?: ${m}${c}ShapeInput<TCtx>`,
     ]
     if (isRead && supportsProgressive) {
       lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`)
-      lines.push(`    progressiveStages?: Record<string, ProgressiveStage<TCtx>>`)
+      lines.push(`    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`)
     }
     return `  ${routerOp}?: {\n${lines.join('\n')}\n  }`
   }).join('\n')
@@ -92,8 +116,8 @@ export function generateRouteConfigType(
   return (
     progressiveTypeImport +
     `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
-    `export type ${m}RouteConfig<TCtx = unknown> = Omit<\n` +
-    `  RouteConfig<Record<string, unknown>, TCtx>,\n` +
+    `export type ${m}RouteConfig${generics} = Omit<\n` +
+    `  ${baseConfig},\n` +
     `  | ${omitKeys}\n` +
     `  | 'resolveContext'\n` +
     `> & {\n` +