prisma-generator-express 1.14.3 → 1.15.1

package/src/helpers/generateFindFirst.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 /**
  * Generates an Express middleware function that includes conditional output validation with Zod.
  * This version dynamically includes the correct type for the query parameter based on the Prisma model.
@@ -29,7 +29,6 @@ export interface FindFirstRequest extends Request {
   prisma: PrismaClient;
   query: ${queryTypeName} & ParsedQs;
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   passToNext?: boolean;
   locals?: {
     data?: ${modelName} | null
@@ -42,15 +41,11 @@ export async function ${functionName}(req: FindFirstRequest, res: Response, next
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
-    const data = await req.prisma.${lowercaseFirstLetter(modelName)}.findFirst(req.query as ${queryTypeName});
+    const data = await req.prisma.${toPascalCase(modelName)}.findFirst(req.query as ${queryTypeName});
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && outputValidator) {
+    } else if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -60,8 +55,8 @@ export async function ${functionName}(req: FindFirstRequest, res: Response, next
     } else {
       return res.status(200).json(data); 
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateFindMany.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 /**
  * Generates an Express middleware function that handles multiple record retrieval with optional output validation using Zod.
  * This version dynamically includes the correct type for the query parameter based on the Prisma model.
@@ -29,7 +29,6 @@ export interface FindManyRequest extends Request {
   prisma: PrismaClient;
   query: ${queryTypeName} & ParsedQs;
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   passToNext?: boolean;
   locals?: {
     data?: ${modelName}[]
@@ -42,15 +41,11 @@ export async function ${functionName}(req: FindManyRequest, res: Response, next:
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
-    const data = await req.prisma.${lowercaseFirstLetter(modelName)}.findMany(req.query as ${queryTypeName});
+    const data = await req.prisma.${toPascalCase(modelName)}.findMany(req.query as ${queryTypeName});
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && outputValidator) {
+    } else if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -60,8 +55,8 @@ export async function ${functionName}(req: FindManyRequest, res: Response, next:
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateFindUnique.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 /**
  * Generates an Express middleware function that includes conditional output validation with Zod.
  * This version dynamically includes the correct type for the query parameter based on the Prisma model.
@@ -29,7 +29,6 @@ export interface FindUniqueRequest extends Request {
   prisma: PrismaClient;
   query: ${queryTypeName} & ParsedQs;
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   passToNext?: boolean;
   locals?: {
     data?: ${modelName} | null
@@ -42,15 +41,11 @@ export async function ${functionName}(req: FindUniqueRequest, res: Response, nex
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
-    const data = await req.prisma.${lowercaseFirstLetter(modelName)}.findUnique(req.query as ${queryTypeName});
+    const data = await req.prisma.${toPascalCase(modelName)}.findUnique(req.query as ${queryTypeName});
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && outputValidator) {
+    } else if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -60,8 +55,8 @@ export async function ${functionName}(req: FindUniqueRequest, res: Response, nex
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateGroupBy.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 import { PrismaClient, Prisma } from '@prisma/client'
 
 /**
@@ -29,7 +29,6 @@ interface GroupByRequest extends Request {
   prisma: PrismaClient;
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -41,14 +40,10 @@ export async function ${functionName}(req: GroupByRequest, res: Response, next:
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
     // @ts-ignore
-    const result = await req.prisma.${lowercaseFirstLetter(modelName)}.groupBy(req.query);
+    const result = await req.prisma.${toPascalCase(modelName)}.groupBy(req.query);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -58,8 +53,8 @@ export async function ${functionName}(req: GroupByRequest, res: Response, next:
     } else {
       return res.status(200).json(result);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateRouteFile.ts

@@ -9,10 +9,7 @@ export function generateRouterFunction({
   const routerFunctionName = `${modelName}Router`
 
   return `import express, {
-  NextFunction,
-  RequestHandler,
-  Request,
-  Response,
+  RequestHandler
 } from 'express'
 import { ParsedQs } from 'qs'
 import { ${modelName}FindFirst } from './${modelName}FindFirst';
@@ -28,16 +25,15 @@ import { ${modelName}DeleteMany } from './${modelName}DeleteMany';
 import { ${modelName}Aggregate } from './${modelName}Aggregate';
 import { ${modelName}Count } from './${modelName}Count';
 import { ${modelName}GroupBy } from './${modelName}GroupBy';
-import { createValidatorMiddleware, ValidatorOptions } from '../createValidatorMiddleware'
-import { createOutputValidatorMiddleware } from '../createOutputValidatorMiddleware'
+import { createValidatorMiddleware } from '../createValidatorMiddleware'
 import { RouteConfig, ValidatorConfig } from '../routeConfig'
 import { parseQueryParams } from "../parseQueryParams";
 
 const defaultBeforeAfter = {
   before: [] as RequestHandler[],
   after: [] as RequestHandler[],
-  input: undefined,
-  output: undefined,
+  inputValidator: undefined,
+  outputValidator: undefined,
 };
 
 /**
@@ -89,104 +85,104 @@ export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
 
 
   if (config.enableAll || config?.findFirst) {
-    const { before = [], after = [], input, output } = config.findFirst || defaultBeforeAfter;
-    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.findFirst || defaultBeforeAfter;
+    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/first', ...after);
     }
   }
 
   if (config.enableAll || config?.findMany) {
-    const { before = [], after = [], input, output } = config.findMany || defaultBeforeAfter;
-    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.findMany || defaultBeforeAfter;
+    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.findUnique) {
-    const { before = [], after = [], input, output } = config.findUnique || defaultBeforeAfter;
-    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.findUnique || defaultBeforeAfter;
+    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/:id', ...after);
     }
   }
 
   if (config.enableAll || config?.create) {
-    const { before = [], after = [], input, output } = config.create || defaultBeforeAfter;
-    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.create || defaultBeforeAfter;
+    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.createMany) {
-    const { before = [], after = [], input, output } = config.createMany || defaultBeforeAfter;
-    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.createMany || defaultBeforeAfter;
+    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.update) {
-    const { before = [], after = [], input, output } = config.update || defaultBeforeAfter;
-    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.update || defaultBeforeAfter;
+    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.updateMany) {
-    const { before = [], after = [], input, output } = config.updateMany || defaultBeforeAfter;
-    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.updateMany || defaultBeforeAfter;
+    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.upsert) {
-    const { before = [], after = [], input, output } = config.upsert || defaultBeforeAfter;
-    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.upsert || defaultBeforeAfter;
+    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.delete) {
-    const { before = [], after = [], input, output } = config.delete || defaultBeforeAfter;
-    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.delete || defaultBeforeAfter;
+    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.deleteMany) {
-    const { before = [], after = [], input, output } = config.deleteMany || defaultBeforeAfter;
-    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.deleteMany || defaultBeforeAfter;
+    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.aggregate) {
-    const { before = [], after = [], input, output } = config.aggregate || defaultBeforeAfter;
-    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.aggregate || defaultBeforeAfter;
+    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/aggregate', ...after);
     }
   }
 
   if (config.enableAll || config?.count) {
-    const { before = [], after = [], input, output } = config.count || defaultBeforeAfter;
-    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.count || defaultBeforeAfter;
+    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/count', ...after);
     }
   }
 
   if (config.enableAll || config?.groupBy) {
-    const { before = [], after = [], input, output } = config.groupBy || defaultBeforeAfter;
-    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.groupBy || defaultBeforeAfter;
+    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/groupby', ...after);
     }

package/src/helpers/generateUpdate.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles updating records and includes conditional output validation with Zod.
@@ -26,7 +26,6 @@ interface UpdateRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -38,13 +37,9 @@ export async function ${functionName}(req: UpdateRequest, res: Response, next: N
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
-    const data = await req.prisma.${lowercaseFirstLetter(modelName)}.update(req.body);
+    const data = await req.prisma.${toPascalCase(modelName)}.update(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -54,8 +49,8 @@ export async function ${functionName}(req: UpdateRequest, res: Response, next: N
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateUpdateMany.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles updating multiple records and includes conditional output validation with Zod.
@@ -26,7 +26,6 @@ interface UpdateManyRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -38,13 +37,9 @@ export async function ${functionName}(req: UpdateManyRequest, res: Response, nex
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
-    const data = await req.prisma.${lowercaseFirstLetter(modelName)}.updateMany(req.body);
+    const data = await req.prisma.${toPascalCase(modelName)}.updateMany(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json({ count: validationResult.data.count });
@@ -54,8 +49,8 @@ export async function ${functionName}(req: UpdateManyRequest, res: Response, nex
     } else {
       return res.status(200).json({ count: data.count });
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateUpsert.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles the upsert operation (create or update)
@@ -27,7 +27,6 @@ interface UpsertRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -39,13 +38,9 @@ export async function ${functionName}(req: UpsertRequest, res: Response, next: N
   try {
     const outputValidator = req.locals?.outputValidator || req.outputValidation;
 
-    if (!outputValidator && !req.omitOutputValidation) {
-      throw new Error('Output validation schema or omission flag must be provided.');
-    }
-
-    const data = await req.prisma.${lowercaseFirstLetter(modelName)}.upsert(req.body);
+    const data = await req.prisma.${toPascalCase(modelName)}.upsert(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -55,8 +50,8 @@ export async function ${functionName}(req: UpsertRequest, res: Response, next: N
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/utils/strings.ts

@@ -1,7 +1,7 @@
 export const capitalize = (str: string) =>
   str.charAt(0).toUpperCase() + str.slice(1)
 
-export function lowercaseFirstLetter(str: string) {
+export function toPascalCase(str: string) {
   if (!str) return str
   return str.charAt(0).toLowerCase() + str.slice(1)
 }