prisma-generator-express 1.12.0 → 1.13.0

package/src/helpers/generateAggregate.ts

@@ -23,42 +23,42 @@ import { Request, Response, NextFunction } from 'express';
 import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
 import { ParsedQs } from 'qs'
 import { ZodTypeAny } from 'zod';
+import { ValidatorConfig } from '../routeConfig'
 
 interface AggregateRequest extends Request {
   prisma: PrismaClient;
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ValidatorConfig;
+  };
 }
 
 export type AggregateMiddleware = RequestHandler<ParamsDictionary, any, Partial<${argsTypeName}>, Record<string, any>>;
 
 export async function ${functionName}(req: AggregateRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = res.locals.outputValidator?.schema || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.aggregate(req.query as ${argsTypeName});
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error("Error in handling aggregation request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateCount.ts

@@ -29,36 +29,35 @@ interface CountRequest extends Request {
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type CountMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
 
 export async function ${functionName}(req: CountRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.count(req.query as ${argsTypeName});
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error("Error in handling count request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateCreate.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles creation of records and includes conditional output validation with Zod.
  * This version dynamically includes the correct type for the arguments based on the Prisma model.
@@ -26,37 +27,35 @@ interface CreateRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type CreateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
 
 export async function ${functionName}(req: CreateRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    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)}.create(req.body);
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(201).json(validationResult.data);
+        return res.status(201).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
-    } else if (!req.omitOutputValidation) {
-      throw new Error('Output validation schema must be provided unless explicitly omitted.');
     } else {
-      res.status(201).json(data);
+      return res.status(201).json(data);
     }
   } catch (error: unknown) {
-    console.error("Error in handling create request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateCreateMany.ts

@@ -26,37 +26,35 @@ interface CreateManyRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type CreateManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
 
 export async function ${functionName}(req: CreateManyRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    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)}.createMany(req.body);
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(201).json(validationResult.data);
+        return res.status(201).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
-    } else if (!req.omitOutputValidation) {
-      throw new Error('Output validation schema must be provided unless explicitly omitted.');
     } else {
-      res.status(201).json(data);
+      return res.status(201).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling createMany request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateDelete.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles deleting records
  * and includes conditional output validation with Zod.
@@ -27,38 +28,35 @@ interface DeleteRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type DeleteMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
 
 export async function ${functionName}(req: DeleteRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    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)}.delete(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
-    } else if (!req.omitOutputValidation) {
-      throw new Error('Output validation schema must be provided unless explicitly omitted.');
     } else {
-      res.status(200).json(data);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling delete request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateDeleteMany.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles batch deleting records
  * and includes conditional output validation with Zod.
@@ -27,36 +28,35 @@ interface DeleteManyRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
-export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, Prisma.${modelName}DeleteManyArgs, Record<string, any>>;
+export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
 
 export async function ${functionName}(req: DeleteManyRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.deleteMany(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error('Error in handling batch delete request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateFindFirst.ts

@@ -33,13 +33,16 @@ export interface FindFirstRequest extends Request {
   passToNext?: boolean;
   locals?: {
     data?: ${modelName} | null
+    outputValidator?: ZodTypeAny;
   }
 }
 export type FindFirstMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
 
 export async function ${functionName}(req: FindFirstRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
@@ -47,26 +50,18 @@ export async function ${functionName}(req: FindFirstRequest, res: Response, next
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    } else if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
-    } else if (!req.omitOutputValidation) {
-      throw new Error('Output validation schema must be provided unless explicitly omitted. Attach omitOutputValidation = true to request to suppress this error.');
     } else {
-      res.status(200).json(data); 
+      return res.status(200).json(data); 
     }
   } catch (error: unknown) {
-    console.error('Error in handling request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateFindMany.ts

@@ -33,13 +33,16 @@ export interface FindManyRequest extends Request {
   passToNext?: boolean;
   locals?: {
     data?: ${modelName}[]
+    outputValidator?: ZodTypeAny;
   }
 }
 export type FindManyMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
 
 export async function ${functionName}(req: FindManyRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
@@ -47,26 +50,18 @@ export async function ${functionName}(req: FindManyRequest, res: Response, next:
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    } else if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
-    } else if (!req.omitOutputValidation) {
-      throw new Error('Output validation schema must be provided unless explicitly omitted. Attach omitOutputValidation = true to request to suppress this error.');
     } else {
-      res.status(200).json(data);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateFindUnique.ts

@@ -33,13 +33,16 @@ export interface FindUniqueRequest extends Request {
   passToNext?: boolean;
   locals?: {
     data?: ${modelName} | null
+    outputValidator?: ZodTypeAny;
   }
 }
 export type FindUniqueMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
 
 export async function ${functionName}(req: FindUniqueRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
@@ -47,26 +50,18 @@ export async function ${functionName}(req: FindUniqueRequest, res: Response, nex
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    } else if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
-    } else if (!req.omitOutputValidation) {
-      throw new Error('Output validation schema must be provided unless explicitly omitted. Attach omitOutputValidation = true to request to suppress this error.');
     } else {
-      res.status(200).json(data);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error("Error in handling findUnique request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateGroupBy.ts

@@ -30,37 +30,36 @@ interface GroupByRequest extends Request {
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type GroupByMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
 
 export async function ${functionName}(req: GroupByRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    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);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error('Error in handling groupBy request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }