express-zod-safe 1.1.2 → 1.2.0

package/README.md

@@ -67,6 +67,26 @@ app.listen(3000, () => console.log('Server running on port 3000'));
 
 **Note:** The `validate` middleware must be used **after** any other middleware that parses/modifies the request body, such as `express.json()` or `express.urlencoded()`.
 
+### 📦 Custom Error Handling
+By default, the `validate` middleware will send a 400 Bad Request response with a JSON body containing the error message.  However, you can provide your own error handling function to customize the error response.
+
+```ts
+// ... extending the previous example
+
+const handler = (errors, req, res, next) => {
+  return res.status(400).json({
+    message: 'Invalid request data',
+    errors: errors.map((error) => error.message),
+  });
+};
+
+// Use the validate middleware in your route
+app.post('/user/:userId', validate({ handler, params, query, body }), (req, res) => {
+  // Your route logic here
+  res.send('User data is valid!');
+});
+```
+
 ### ⚠️ URL Parameters & Query Strings Coercion
 As mentioned in the example above, all URL parameters and query strings are parsed as strings.  This means that if you have a URL parameter or query string that is expected to be a number, you must use the `z.coerce.number()` method to coerce the value to a number.  This is because Zod will not coerce the value for you, and will instead throw an error if the value is not a string.
 

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import { RequestHandler } from 'express';
-import { z, ZodTypeAny, ZodRawShape } from 'zod';
+import { NextFunction, Request, RequestHandler, Response } from 'express';
+import { ZodError, z, ZodTypeAny, ZodRawShape } from 'zod';
+declare const types: readonly ["query", "params", "body"];
 /**
  * Generates a middleware function for Express.js that validates request params, query, and body.
  * This function uses Zod schemas to perform validation against the provided schema definitions.
  *
- * @param schemas - An object containing Zod schemas for params, query, and body.
+ * @param schemas - An object containing Zod schemas for params, query, and body.  Optional handler for custom error handling.
  * @returns An Express.js middleware function that validates the request based on the provided schemas.
  *          It attaches validated data to the request object and sends error details if validation fails.
  * @template TParams - Type definition for params schema.
@@ -39,6 +40,28 @@ import { z, ZodTypeAny, ZodRawShape } from 'zod';
  * app.listen(3000, () => console.log('Server running on port 3000'));
  */
 declare function validate<TParams extends Validation = {}, TQuery extends Validation = {}, TBody extends Validation = {}>(schemas: ExtendedValidationSchemas<TParams, TQuery, TBody>): RequestHandler<ZodOutput<TParams>, any, ZodOutput<TBody>, ZodOutput<TQuery>>;
+/**
+ * Describes the types of data that can be validated: 'query', 'params', or 'body'.
+ */
+type DataType = (typeof types)[number];
+/**
+ * Defines the structure of an error item, containing the type of validation that failed (params, query, or body)
+ * and the associated ZodError.
+ */
+interface ErrorListItem {
+    type: DataType;
+    errors: ZodError<any>;
+}
+/**
+ * Represents a QueryString object parsed by the qs library.
+ */
+interface ParsedQs {
+    [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
+}
+/**
+ * Represents an Express.js error request handler.
+ */
+type ErrorRequestHandler<P = Record<string, string>, ResBody = any, ReqBody = any, ReqQuery = ParsedQs, LocalsObj extends Record<string, any> = Record<string, any>> = (err: ErrorListItem[], req: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response<ResBody, LocalsObj>, next: NextFunction) => void;
 /**
  * Represents a generic type for route validation, which can be applied to params, query, or body.
  * Each key-value pair represents a field and its corresponding Zod validation schema.
@@ -47,13 +70,14 @@ type Validation = ZodTypeAny | ZodRawShape;
 /**
  * Defines the structure for the schemas provided to the validate middleware.
  * Each property corresponds to a different part of the request (params, query, body)
- * and should be a record of Zod types for validation.
+ * and should be a record of Zod types for validation. Optional handler for custom error handling.
  *
  * @template TParams - Type definition for params schema.
  * @template TQuery - Type definition for query schema.
  * @template TBody - Type definition for body schema.
  */
 interface ExtendedValidationSchemas<TParams, TQuery, TBody> {
+    handler?: ErrorRequestHandler;
     params?: TParams;
     query?: TQuery;
     body?: TBody;

package/dist/index.js

@@ -13,7 +13,7 @@ function isZodSchema(schema) {
  * Generates a middleware function for Express.js that validates request params, query, and body.
  * This function uses Zod schemas to perform validation against the provided schema definitions.
  *
- * @param schemas - An object containing Zod schemas for params, query, and body.
+ * @param schemas - An object containing Zod schemas for params, query, and body.  Optional handler for custom error handling.
  * @returns An Express.js middleware function that validates the request based on the provided schemas.
  *          It attaches validated data to the request object and sends error details if validation fails.
  * @template TParams - Type definition for params schema.
@@ -56,18 +56,23 @@ function validate(schemas) {
         body: isZodSchema(schemas.body) ? schemas.body : zod_1.z.object((_c = schemas.body) !== null && _c !== void 0 ? _c : {}).strict()
     };
     return (req, res, next) => {
+        var _a;
         const errors = [];
         // Validate all types (params, query, body)
         for (const type of types) {
-            const parsed = validation[type].safeParse(req[type]);
+            const parsed = validation[type].safeParse((_a = req[type]) !== null && _a !== void 0 ? _a : {});
             if (parsed.success)
                 req[type] = parsed.data;
             else
                 errors.push({ type, errors: parsed.error });
         }
         // Return all errors if there are any
-        if (errors.length > 0)
+        if (errors.length > 0) {
+            // If a custom error handler is provided, use it
+            if (schemas.handler)
+                return schemas.handler(errors, req, res, next);
             return res.status(400).send(errors.map(error => ({ type: error.type, errors: error.errors })));
+        }
         return next();
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-zod-safe",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "TypeScript-friendly middleware designed for Express applications, leveraging the robustness of Zod schemas to validate incoming request bodies, parameters, and queries.",
   "main": "dist/index.js",
   "repository": {