express-zod-safe 1.5.2 → 1.5.3

package/README.md

@@ -7,7 +7,7 @@
     <img alt="Version" src="https://img.shields.io/npm/v/express-zod-safe.svg?label=Version">
   </a>
   <a href="https://github.com/AngaBlue/exe/blob/master/LICENSE" target="_blank">
-    <img alt="License: MIT" src="https://img.shields.io/npm/l/express-zod-safe?color=green&label=Licence" />
+    <img alt="Licence: MIT" src="https://img.shields.io/npm/l/express-zod-safe?color=green&label=Licence" />
   </a>
 </p>
 

package/dist/index.d.mts

@@ -0,0 +1,95 @@
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+import { ZodTypeAny, ZodRawShape, z, ZodError } from 'zod';
+
+declare const types: readonly ["query", "params", "body"];
+declare const emptyObjectSchema: z.ZodObject<{}, "strict", ZodTypeAny, {}, {}>;
+type EmptyValidationSchema = typeof emptyObjectSchema;
+/**
+ * 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.  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.
+ * @template TQuery - Type definition for query schema.
+ * @template TBody - Type definition for body schema.
+ * @example
+ * // Example usage in an Express.js route
+ * import express from 'express';
+ * import validate from 'express-zod-safe';
+ * import { z } from 'zod';
+ *
+ * const app = express();
+ *
+ * // Define your Zod schemas
+ * const params = {
+ *   userId: z.string().uuid(),
+ * };
+ * const query = {
+ *   age: z.coerce.number().optional(),
+ * };
+ * const body = {
+ *   name: z.string(),
+ *   email: z.string().email(),
+ * };
+ *
+ * // Use the validate middleware in your route
+ * app.post('/user/:userId', validate({ params, query, body }), (req, res) => {
+ *   // Your route logic here
+ *   res.send('User data is valid!');
+ * });
+ *
+ * app.listen(3000, () => console.log('Server running on port 3000'));
+ */
+declare function validate<TParams extends ValidationSchema = EmptyValidationSchema, TQuery extends ValidationSchema = EmptyValidationSchema, TBody extends ValidationSchema = EmptyValidationSchema>(schemas: CompleteValidationSchema<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;
+}
+/**
+ * Represents an Express.js error request handler where the params, query and body are of unknown type as validation failed.
+ */
+type ErrorRequestHandler<P = unknown, ResBody = any, ReqBody = unknown, ReqQuery = unknown, LocalsObj extends Record<string, any> = Record<string, any>> = (err: ErrorListItem[], req: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response<ResBody, LocalsObj>, next: NextFunction) => void | Promise<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.
+ */
+type ValidationSchema = 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. 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 CompleteValidationSchema<TParams extends ValidationSchema = EmptyValidationSchema, TQuery extends ValidationSchema = EmptyValidationSchema, TBody extends ValidationSchema = EmptyValidationSchema> {
+    handler?: ErrorRequestHandler;
+    params?: TParams;
+    query?: TQuery;
+    body?: TBody;
+}
+/**
+ * Represents the output type of a Zod validation schema.
+ * This is used to infer the TypeScript type from a Zod schema,
+ * providing typesafe access to the validated data.
+ *
+ * @template T - The validation type (params, query, or body).
+ */
+type ZodOutput<T extends ValidationSchema> = T extends ZodRawShape ? z.ZodObject<T>['_output'] : T['_output'];
+/**
+ * A utility type to ensure other middleware types don't conflict with the validate middleware.
+ */
+type WeakRequestHandler = RequestHandler<unknown, unknown, unknown, Record<string, unknown>>;
+
+export { type CompleteValidationSchema, type EmptyValidationSchema, type ErrorListItem, type ErrorRequestHandler, type ValidationSchema, type WeakRequestHandler, type ZodOutput, validate as default };

package/dist/{esm/index.d.ts → index.d.ts}

@@ -1,8 +1,9 @@
-import type { NextFunction, Request, RequestHandler, Response } from 'express';
-import { type ZodError, type ZodRawShape, type ZodTypeAny, z } from 'zod';
+import { Request, Response, NextFunction, RequestHandler } from 'express';
+import { ZodTypeAny, ZodRawShape, z, ZodError } from 'zod';
+
 declare const types: readonly ["query", "params", "body"];
 declare const emptyObjectSchema: z.ZodObject<{}, "strict", ZodTypeAny, {}, {}>;
-export type EmptyValidationSchema = typeof emptyObjectSchema;
+type EmptyValidationSchema = typeof emptyObjectSchema;
 /**
  * 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.
@@ -41,7 +42,7 @@ export type EmptyValidationSchema = typeof emptyObjectSchema;
  *
  * app.listen(3000, () => console.log('Server running on port 3000'));
  */
-export default function validate<TParams extends ValidationSchema = EmptyValidationSchema, TQuery extends ValidationSchema = EmptyValidationSchema, TBody extends ValidationSchema = EmptyValidationSchema>(schemas: CompleteValidationSchema<TParams, TQuery, TBody>): RequestHandler<ZodOutput<TParams>, any, ZodOutput<TBody>, ZodOutput<TQuery>>;
+declare function validate<TParams extends ValidationSchema = EmptyValidationSchema, TQuery extends ValidationSchema = EmptyValidationSchema, TBody extends ValidationSchema = EmptyValidationSchema>(schemas: CompleteValidationSchema<TParams, TQuery, TBody>): RequestHandler<ZodOutput<TParams>, any, ZodOutput<TBody>, ZodOutput<TQuery>>;
 /**
  * Describes the types of data that can be validated: 'query', 'params', or 'body'.
  */
@@ -50,19 +51,19 @@ 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.
  */
-export interface ErrorListItem {
+interface ErrorListItem {
     type: DataType;
     errors: ZodError;
 }
 /**
  * Represents an Express.js error request handler where the params, query and body are of unknown type as validation failed.
  */
-export type ErrorRequestHandler<P = unknown, ResBody = any, ReqBody = unknown, ReqQuery = unknown, LocalsObj extends Record<string, any> = Record<string, any>> = (err: ErrorListItem[], req: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response<ResBody, LocalsObj>, next: NextFunction) => void | Promise<void>;
+type ErrorRequestHandler<P = unknown, ResBody = any, ReqBody = unknown, ReqQuery = unknown, LocalsObj extends Record<string, any> = Record<string, any>> = (err: ErrorListItem[], req: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>, res: Response<ResBody, LocalsObj>, next: NextFunction) => void | Promise<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.
  */
-export type ValidationSchema = ZodTypeAny | ZodRawShape;
+type ValidationSchema = 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)
@@ -72,7 +73,7 @@ export type ValidationSchema = ZodTypeAny | ZodRawShape;
  * @template TQuery - Type definition for query schema.
  * @template TBody - Type definition for body schema.
  */
-export interface CompleteValidationSchema<TParams extends ValidationSchema = EmptyValidationSchema, TQuery extends ValidationSchema = EmptyValidationSchema, TBody extends ValidationSchema = EmptyValidationSchema> {
+interface CompleteValidationSchema<TParams extends ValidationSchema = EmptyValidationSchema, TQuery extends ValidationSchema = EmptyValidationSchema, TBody extends ValidationSchema = EmptyValidationSchema> {
     handler?: ErrorRequestHandler;
     params?: TParams;
     query?: TQuery;
@@ -85,9 +86,12 @@ export interface CompleteValidationSchema<TParams extends ValidationSchema = Emp
  *
  * @template T - The validation type (params, query, or body).
  */
-export type ZodOutput<T extends ValidationSchema> = T extends ZodRawShape ? z.ZodObject<T>['_output'] : T['_output'];
+type ZodOutput<T extends ValidationSchema> = T extends ZodRawShape ? z.ZodObject<T>['_output'] : T['_output'];
 /**
  * A utility type to ensure other middleware types don't conflict with the validate middleware.
  */
-export type WeakRequestHandler = RequestHandler<unknown, unknown, unknown, Record<string, unknown>>;
-export {};
+type WeakRequestHandler = RequestHandler<unknown, unknown, unknown, Record<string, unknown>>;
+
+// @ts-ignore
+export = validate;
+export type { CompleteValidationSchema, EmptyValidationSchema, ErrorListItem, ErrorRequestHandler, ValidationSchema, WeakRequestHandler, ZodOutput };

package/dist/index.js

@@ -0,0 +1,49 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/index.ts
+var _express = require('express'); var _express2 = _interopRequireDefault(_express);
+var _zod = require('zod');
+var types = ["query", "params", "body"];
+var emptyObjectSchema = _zod.z.object({}).strict();
+function isZodSchema(schema) {
+  return !!schema && typeof schema.safeParseAsync === "function";
+}
+var descriptor = Object.getOwnPropertyDescriptor(_express2.default.request, "query");
+if (descriptor) {
+  Object.defineProperty(_express2.default.request, "query", {
+    get() {
+      if (this._query) return this._query;
+      return _optionalChain([descriptor, 'optionalAccess', _ => _.get, 'optionalAccess', _2 => _2.call, 'call', _3 => _3(this)]);
+    },
+    set(query) {
+      this._query = query;
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+function validate(schemas) {
+  const validation = {
+    params: isZodSchema(schemas.params) ? schemas.params : _zod.z.object(_nullishCoalesce(schemas.params, () => ( {}))).strict(),
+    query: isZodSchema(schemas.query) ? schemas.query : _zod.z.object(_nullishCoalesce(schemas.query, () => ( {}))).strict(),
+    body: isZodSchema(schemas.body) ? schemas.body : _zod.z.object(_nullishCoalesce(schemas.body, () => ( {}))).strict()
+  };
+  return async (req, res, next) => {
+    const errors = [];
+    for (const type of types) {
+      const parsed = await validation[type].safeParseAsync(_nullishCoalesce(req[type], () => ( {})));
+      if (parsed.success) req[type] = parsed.data;
+      else errors.push({ type, errors: parsed.error });
+    }
+    if (errors.length > 0) {
+      if (schemas.handler) return schemas.handler(errors, req, res, next);
+      res.status(400).send(errors.map((error) => ({ type: error.type, errors: error.errors })));
+      return;
+    }
+    return next();
+  };
+}
+
+
+exports.default = validate;
+
+module.exports = exports.default;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/express-zod-safe/express-zod-safe/dist/index.js","../src/index.ts"],"names":[],"mappings":"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","file":"/home/runner/work/express-zod-safe/express-zod-safe/dist/index.js","sourcesContent":[null,"/// <reference types=\"./express.d.ts\" />\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\nimport express from 'express';\nimport { type ZodError, type ZodRawShape, type ZodSchema, type ZodTypeAny, z } from 'zod';\n\nconst types = ['query', 'params', 'body'] as const;\nconst emptyObjectSchema = z.object({}).strict();\nexport type EmptyValidationSchema = typeof emptyObjectSchema;\n\n/**\n * A ZodSchema type guard.\n * @param schema The Zod schema to check.\n * @returns Whether the provided schema is a ZodSchema.\n */\nfunction isZodSchema(schema: unknown): schema is ZodSchema {\n\treturn !!schema && typeof (schema as ZodSchema).safeParseAsync === 'function';\n}\n\n// Override express@^5 request.query getter to provider setter\nconst descriptor = Object.getOwnPropertyDescriptor(express.request, 'query');\nif (descriptor) {\n\tObject.defineProperty(express.request, 'query', {\n\t\tget(this: Request) {\n\t\t\tif (this._query) return this._query;\n\t\t\treturn descriptor?.get?.call(this);\n\t\t},\n\t\tset(this: Request, query: unknown) {\n\t\t\tthis._query = query;\n\t\t},\n\t\tconfigurable: true,\n\t\tenumerable: true\n\t});\n}\n\n/**\n * Generates a middleware function for Express.js that validates request params, query, and body.\n * This function uses Zod schemas to perform validation against the provided schema definitions.\n *\n * @param schemas - An object containing Zod schemas for params, query, and body.  Optional handler for custom error handling.\n * @returns An Express.js middleware function that validates the request based on the provided schemas.\n *          It attaches validated data to the request object and sends error details if validation fails.\n * @template TParams - Type definition for params schema.\n * @template TQuery - Type definition for query schema.\n * @template TBody - Type definition for body schema.\n * @example\n * // Example usage in an Express.js route\n * import express from 'express';\n * import validate from 'express-zod-safe';\n * import { z } from 'zod';\n *\n * const app = express();\n *\n * // Define your Zod schemas\n * const params = {\n *   userId: z.string().uuid(),\n * };\n * const query = {\n *   age: z.coerce.number().optional(),\n * };\n * const body = {\n *   name: z.string(),\n *   email: z.string().email(),\n * };\n *\n * // Use the validate middleware in your route\n * app.post('/user/:userId', validate({ params, query, body }), (req, res) => {\n *   // Your route logic here\n *   res.send('User data is valid!');\n * });\n *\n * app.listen(3000, () => console.log('Server running on port 3000'));\n */\nexport default function validate<\n\tTParams extends ValidationSchema = EmptyValidationSchema,\n\tTQuery extends ValidationSchema = EmptyValidationSchema,\n\tTBody extends ValidationSchema = EmptyValidationSchema\n>(schemas: CompleteValidationSchema<TParams, TQuery, TBody>): RequestHandler<ZodOutput<TParams>, any, ZodOutput<TBody>, ZodOutput<TQuery>> {\n\t// Create validation objects for each type\n\tconst validation = {\n\t\tparams: isZodSchema(schemas.params) ? schemas.params : z.object(schemas.params ?? {}).strict(),\n\t\tquery: isZodSchema(schemas.query) ? schemas.query : z.object(schemas.query ?? {}).strict(),\n\t\tbody: isZodSchema(schemas.body) ? schemas.body : z.object(schemas.body ?? {}).strict()\n\t};\n\n\treturn async (req, res, next): Promise<void> => {\n\t\tconst errors: ErrorListItem[] = [];\n\n\t\t// Validate all types (params, query, body)\n\t\tfor (const type of types) {\n\t\t\tconst parsed = await validation[type].safeParseAsync(req[type] ?? {});\n\t\t\tif (parsed.success) req[type] = parsed.data;\n\t\t\telse errors.push({ type, errors: parsed.error });\n\t\t}\n\n\t\t// Return all errors if there are any\n\t\tif (errors.length > 0) {\n\t\t\t// If a custom error handler is provided, use it\n\t\t\tif (schemas.handler) return schemas.handler(errors, req, res, next);\n\n\t\t\tres.status(400).send(errors.map(error => ({ type: error.type, errors: error.errors })));\n\t\t\treturn;\n\t\t}\n\n\t\treturn next();\n\t};\n}\n\n/**\n * Describes the types of data that can be validated: 'query', 'params', or 'body'.\n */\ntype DataType = (typeof types)[number];\n\n/**\n * Defines the structure of an error item, containing the type of validation that failed (params, query, or body)\n * and the associated ZodError.\n */\nexport interface ErrorListItem {\n\ttype: DataType;\n\terrors: ZodError;\n}\n\n/**\n * Represents an Express.js error request handler where the params, query and body are of unknown type as validation failed.\n */\nexport type ErrorRequestHandler<\n\tP = unknown,\n\tResBody = any,\n\tReqBody = unknown,\n\tReqQuery = unknown,\n\tLocalsObj extends Record<string, any> = Record<string, any>\n> = (\n\terr: ErrorListItem[],\n\treq: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>,\n\tres: Response<ResBody, LocalsObj>,\n\tnext: NextFunction\n) => void | Promise<void>;\n\n/**\n * Represents a generic type for route validation, which can be applied to params, query, or body.\n * Each key-value pair represents a field and its corresponding Zod validation schema.\n */\nexport type ValidationSchema = ZodTypeAny | ZodRawShape;\n\n/**\n * Defines the structure for the schemas provided to the validate middleware.\n * Each property corresponds to a different part of the request (params, query, body)\n * and should be a record of Zod types for validation. Optional handler for custom error handling.\n *\n * @template TParams - Type definition for params schema.\n * @template TQuery - Type definition for query schema.\n * @template TBody - Type definition for body schema.\n */\nexport interface CompleteValidationSchema<\n\tTParams extends ValidationSchema = EmptyValidationSchema,\n\tTQuery extends ValidationSchema = EmptyValidationSchema,\n\tTBody extends ValidationSchema = EmptyValidationSchema\n> {\n\thandler?: ErrorRequestHandler;\n\tparams?: TParams;\n\tquery?: TQuery;\n\tbody?: TBody;\n}\n\n/**\n * Represents the output type of a Zod validation schema.\n * This is used to infer the TypeScript type from a Zod schema,\n * providing typesafe access to the validated data.\n *\n * @template T - The validation type (params, query, or body).\n */\nexport type ZodOutput<T extends ValidationSchema> = T extends ZodRawShape ? z.ZodObject<T>['_output'] : T['_output'];\n\n/**\n * A utility type to ensure other middleware types don't conflict with the validate middleware.\n */\nexport type WeakRequestHandler = RequestHandler<unknown, unknown, unknown, Record<string, unknown>>;\n"]}

package/dist/index.mjs

@@ -0,0 +1,47 @@
+// src/index.ts
+import express from "express";
+import { z } from "zod";
+var types = ["query", "params", "body"];
+var emptyObjectSchema = z.object({}).strict();
+function isZodSchema(schema) {
+  return !!schema && typeof schema.safeParseAsync === "function";
+}
+var descriptor = Object.getOwnPropertyDescriptor(express.request, "query");
+if (descriptor) {
+  Object.defineProperty(express.request, "query", {
+    get() {
+      if (this._query) return this._query;
+      return descriptor?.get?.call(this);
+    },
+    set(query) {
+      this._query = query;
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+function validate(schemas) {
+  const validation = {
+    params: isZodSchema(schemas.params) ? schemas.params : z.object(schemas.params ?? {}).strict(),
+    query: isZodSchema(schemas.query) ? schemas.query : z.object(schemas.query ?? {}).strict(),
+    body: isZodSchema(schemas.body) ? schemas.body : z.object(schemas.body ?? {}).strict()
+  };
+  return async (req, res, next) => {
+    const errors = [];
+    for (const type of types) {
+      const parsed = await validation[type].safeParseAsync(req[type] ?? {});
+      if (parsed.success) req[type] = parsed.data;
+      else errors.push({ type, errors: parsed.error });
+    }
+    if (errors.length > 0) {
+      if (schemas.handler) return schemas.handler(errors, req, res, next);
+      res.status(400).send(errors.map((error) => ({ type: error.type, errors: error.errors })));
+      return;
+    }
+    return next();
+  };
+}
+export {
+  validate as default
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/// <reference types=\"./express.d.ts\" />\nimport type { NextFunction, Request, RequestHandler, Response } from 'express';\nimport express from 'express';\nimport { type ZodError, type ZodRawShape, type ZodSchema, type ZodTypeAny, z } from 'zod';\n\nconst types = ['query', 'params', 'body'] as const;\nconst emptyObjectSchema = z.object({}).strict();\nexport type EmptyValidationSchema = typeof emptyObjectSchema;\n\n/**\n * A ZodSchema type guard.\n * @param schema The Zod schema to check.\n * @returns Whether the provided schema is a ZodSchema.\n */\nfunction isZodSchema(schema: unknown): schema is ZodSchema {\n\treturn !!schema && typeof (schema as ZodSchema).safeParseAsync === 'function';\n}\n\n// Override express@^5 request.query getter to provider setter\nconst descriptor = Object.getOwnPropertyDescriptor(express.request, 'query');\nif (descriptor) {\n\tObject.defineProperty(express.request, 'query', {\n\t\tget(this: Request) {\n\t\t\tif (this._query) return this._query;\n\t\t\treturn descriptor?.get?.call(this);\n\t\t},\n\t\tset(this: Request, query: unknown) {\n\t\t\tthis._query = query;\n\t\t},\n\t\tconfigurable: true,\n\t\tenumerable: true\n\t});\n}\n\n/**\n * Generates a middleware function for Express.js that validates request params, query, and body.\n * This function uses Zod schemas to perform validation against the provided schema definitions.\n *\n * @param schemas - An object containing Zod schemas for params, query, and body.  Optional handler for custom error handling.\n * @returns An Express.js middleware function that validates the request based on the provided schemas.\n *          It attaches validated data to the request object and sends error details if validation fails.\n * @template TParams - Type definition for params schema.\n * @template TQuery - Type definition for query schema.\n * @template TBody - Type definition for body schema.\n * @example\n * // Example usage in an Express.js route\n * import express from 'express';\n * import validate from 'express-zod-safe';\n * import { z } from 'zod';\n *\n * const app = express();\n *\n * // Define your Zod schemas\n * const params = {\n *   userId: z.string().uuid(),\n * };\n * const query = {\n *   age: z.coerce.number().optional(),\n * };\n * const body = {\n *   name: z.string(),\n *   email: z.string().email(),\n * };\n *\n * // Use the validate middleware in your route\n * app.post('/user/:userId', validate({ params, query, body }), (req, res) => {\n *   // Your route logic here\n *   res.send('User data is valid!');\n * });\n *\n * app.listen(3000, () => console.log('Server running on port 3000'));\n */\nexport default function validate<\n\tTParams extends ValidationSchema = EmptyValidationSchema,\n\tTQuery extends ValidationSchema = EmptyValidationSchema,\n\tTBody extends ValidationSchema = EmptyValidationSchema\n>(schemas: CompleteValidationSchema<TParams, TQuery, TBody>): RequestHandler<ZodOutput<TParams>, any, ZodOutput<TBody>, ZodOutput<TQuery>> {\n\t// Create validation objects for each type\n\tconst validation = {\n\t\tparams: isZodSchema(schemas.params) ? schemas.params : z.object(schemas.params ?? {}).strict(),\n\t\tquery: isZodSchema(schemas.query) ? schemas.query : z.object(schemas.query ?? {}).strict(),\n\t\tbody: isZodSchema(schemas.body) ? schemas.body : z.object(schemas.body ?? {}).strict()\n\t};\n\n\treturn async (req, res, next): Promise<void> => {\n\t\tconst errors: ErrorListItem[] = [];\n\n\t\t// Validate all types (params, query, body)\n\t\tfor (const type of types) {\n\t\t\tconst parsed = await validation[type].safeParseAsync(req[type] ?? {});\n\t\t\tif (parsed.success) req[type] = parsed.data;\n\t\t\telse errors.push({ type, errors: parsed.error });\n\t\t}\n\n\t\t// Return all errors if there are any\n\t\tif (errors.length > 0) {\n\t\t\t// If a custom error handler is provided, use it\n\t\t\tif (schemas.handler) return schemas.handler(errors, req, res, next);\n\n\t\t\tres.status(400).send(errors.map(error => ({ type: error.type, errors: error.errors })));\n\t\t\treturn;\n\t\t}\n\n\t\treturn next();\n\t};\n}\n\n/**\n * Describes the types of data that can be validated: 'query', 'params', or 'body'.\n */\ntype DataType = (typeof types)[number];\n\n/**\n * Defines the structure of an error item, containing the type of validation that failed (params, query, or body)\n * and the associated ZodError.\n */\nexport interface ErrorListItem {\n\ttype: DataType;\n\terrors: ZodError;\n}\n\n/**\n * Represents an Express.js error request handler where the params, query and body are of unknown type as validation failed.\n */\nexport type ErrorRequestHandler<\n\tP = unknown,\n\tResBody = any,\n\tReqBody = unknown,\n\tReqQuery = unknown,\n\tLocalsObj extends Record<string, any> = Record<string, any>\n> = (\n\terr: ErrorListItem[],\n\treq: Request<P, ResBody, ReqBody, ReqQuery, LocalsObj>,\n\tres: Response<ResBody, LocalsObj>,\n\tnext: NextFunction\n) => void | Promise<void>;\n\n/**\n * Represents a generic type for route validation, which can be applied to params, query, or body.\n * Each key-value pair represents a field and its corresponding Zod validation schema.\n */\nexport type ValidationSchema = ZodTypeAny | ZodRawShape;\n\n/**\n * Defines the structure for the schemas provided to the validate middleware.\n * Each property corresponds to a different part of the request (params, query, body)\n * and should be a record of Zod types for validation. Optional handler for custom error handling.\n *\n * @template TParams - Type definition for params schema.\n * @template TQuery - Type definition for query schema.\n * @template TBody - Type definition for body schema.\n */\nexport interface CompleteValidationSchema<\n\tTParams extends ValidationSchema = EmptyValidationSchema,\n\tTQuery extends ValidationSchema = EmptyValidationSchema,\n\tTBody extends ValidationSchema = EmptyValidationSchema\n> {\n\thandler?: ErrorRequestHandler;\n\tparams?: TParams;\n\tquery?: TQuery;\n\tbody?: TBody;\n}\n\n/**\n * Represents the output type of a Zod validation schema.\n * This is used to infer the TypeScript type from a Zod schema,\n * providing typesafe access to the validated data.\n *\n * @template T - The validation type (params, query, or body).\n */\nexport type ZodOutput<T extends ValidationSchema> = T extends ZodRawShape ? z.ZodObject<T>['_output'] : T['_output'];\n\n/**\n * A utility type to ensure other middleware types don't conflict with the validate middleware.\n */\nexport type WeakRequestHandler = RequestHandler<unknown, unknown, unknown, Record<string, unknown>>;\n"],"mappings":";AAEA,OAAO,aAAa;AACpB,SAA2E,SAAS;AAEpF,IAAM,QAAQ,CAAC,SAAS,UAAU,MAAM;AACxC,IAAM,oBAAoB,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO;AAQ9C,SAAS,YAAY,QAAsC;AAC1D,SAAO,CAAC,CAAC,UAAU,OAAQ,OAAqB,mBAAmB;AACpE;AAGA,IAAM,aAAa,OAAO,yBAAyB,QAAQ,SAAS,OAAO;AAC3E,IAAI,YAAY;AACf,SAAO,eAAe,QAAQ,SAAS,SAAS;AAAA,IAC/C,MAAmB;AAClB,UAAI,KAAK,OAAQ,QAAO,KAAK;AAC7B,aAAO,YAAY,KAAK,KAAK,IAAI;AAAA,IAClC;AAAA,IACA,IAAmB,OAAgB;AAClC,WAAK,SAAS;AAAA,IACf;AAAA,IACA,cAAc;AAAA,IACd,YAAY;AAAA,EACb,CAAC;AACF;AAwCe,SAAR,SAIL,SAAyI;AAE1I,QAAM,aAAa;AAAA,IAClB,QAAQ,YAAY,QAAQ,MAAM,IAAI,QAAQ,SAAS,EAAE,OAAO,QAAQ,UAAU,CAAC,CAAC,EAAE,OAAO;AAAA,IAC7F,OAAO,YAAY,QAAQ,KAAK,IAAI,QAAQ,QAAQ,EAAE,OAAO,QAAQ,SAAS,CAAC,CAAC,EAAE,OAAO;AAAA,IACzF,MAAM,YAAY,QAAQ,IAAI,IAAI,QAAQ,OAAO,EAAE,OAAO,QAAQ,QAAQ,CAAC,CAAC,EAAE,OAAO;AAAA,EACtF;AAEA,SAAO,OAAO,KAAK,KAAK,SAAwB;AAC/C,UAAM,SAA0B,CAAC;AAGjC,eAAW,QAAQ,OAAO;AACzB,YAAM,SAAS,MAAM,WAAW,IAAI,EAAE,eAAe,IAAI,IAAI,KAAK,CAAC,CAAC;AACpE,UAAI,OAAO,QAAS,KAAI,IAAI,IAAI,OAAO;AAAA,UAClC,QAAO,KAAK,EAAE,MAAM,QAAQ,OAAO,MAAM,CAAC;AAAA,IAChD;AAGA,QAAI,OAAO,SAAS,GAAG;AAEtB,UAAI,QAAQ,QAAS,QAAO,QAAQ,QAAQ,QAAQ,KAAK,KAAK,IAAI;AAElE,UAAI,OAAO,GAAG,EAAE,KAAK,OAAO,IAAI,YAAU,EAAE,MAAM,MAAM,MAAM,QAAQ,MAAM,OAAO,EAAE,CAAC;AACtF;AAAA,IACD;AAEA,WAAO,KAAK;AAAA,EACb;AACD;","names":[]}

package/package.json

@@ -1,10 +1,22 @@
 {
   "name": "express-zod-safe",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "TypeScript-friendly middleware designed for Express applications, leveraging the robustness of Zod schemas to validate incoming request bodies, parameters, and queries.",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/esm/index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/AngaBlue/express-zod-safe.git"
@@ -28,21 +40,22 @@
   },
   "homepage": "https://github.com/AngaBlue/express-zod-safe#readme",
   "devDependencies": {
-    "@angablue/biome-config": "^1.0.4",
+    "@angablue/biome-config": "^1.0.5",
     "@biomejs/biome": "^1.9.4",
-    "@types/node": "^22.15.17",
-    "rimraf": "^6.0.1",
+    "@types/node": "^22.15.26",
+    "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "zod": "^3.24.4"
+    "zod": "^3.25.39"
   },
   "peerDependencies": {
     "@types/express": "^4.0.0 || ^5.0.0",
     "express": "^4.0.0 || ^5.0.0",
     "zod": "^3.0.0"
   },
+  "packageManager": "pnpm@10.11.0",
   "scripts": {
-    "clean": "rimraf dist",
-    "build": "pnpm run clean && tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json",
-    "lint": "biome check --fix"
+    "build": "tsup",
+    "lint": "biome check --fix",
+    "test": "pnpx tsx ./test/index.ts"
   }
 }

package/dist/cjs/index.js

@@ -1,113 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = validate;
-const express_1 = __importDefault(require("express"));
-const zod_1 = require("zod");
-const types = ['query', 'params', 'body'];
-const emptyObjectSchema = zod_1.z.object({}).strict();
-/**
- * A ZodSchema type guard.
- * @param schema The Zod schema to check.
- * @returns Whether the provided schema is a ZodSchema.
- */
-function isZodSchema(schema) {
-    return !!schema && typeof schema.safeParseAsync === 'function';
-}
-// Override express@^5 request.query getter to provider setter
-const descriptor = Object.getOwnPropertyDescriptor(express_1.default.request, 'query');
-if (descriptor) {
-    Object.defineProperty(express_1.default.request, 'query', {
-        get() {
-            var _a;
-            if (this._query)
-                return this._query;
-            return (_a = descriptor === null || descriptor === void 0 ? void 0 : descriptor.get) === null || _a === void 0 ? void 0 : _a.call(this);
-        },
-        set(query) {
-            this._query = query;
-        },
-        configurable: true,
-        enumerable: true
-    });
-}
-/**
- * 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.  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.
- * @template TQuery - Type definition for query schema.
- * @template TBody - Type definition for body schema.
- * @example
- * // Example usage in an Express.js route
- * import express from 'express';
- * import validate from 'express-zod-safe';
- * import { z } from 'zod';
- *
- * const app = express();
- *
- * // Define your Zod schemas
- * const params = {
- *   userId: z.string().uuid(),
- * };
- * const query = {
- *   age: z.coerce.number().optional(),
- * };
- * const body = {
- *   name: z.string(),
- *   email: z.string().email(),
- * };
- *
- * // Use the validate middleware in your route
- * app.post('/user/:userId', validate({ params, query, body }), (req, res) => {
- *   // Your route logic here
- *   res.send('User data is valid!');
- * });
- *
- * app.listen(3000, () => console.log('Server running on port 3000'));
- */
-function validate(schemas) {
-    var _a, _b, _c;
-    // Create validation objects for each type
-    const validation = {
-        params: isZodSchema(schemas.params) ? schemas.params : zod_1.z.object((_a = schemas.params) !== null && _a !== void 0 ? _a : {}).strict(),
-        query: isZodSchema(schemas.query) ? schemas.query : zod_1.z.object((_b = schemas.query) !== null && _b !== void 0 ? _b : {}).strict(),
-        body: isZodSchema(schemas.body) ? schemas.body : zod_1.z.object((_c = schemas.body) !== null && _c !== void 0 ? _c : {}).strict()
-    };
-    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const errors = [];
-        // Validate all types (params, query, body)
-        for (const type of types) {
-            const parsed = yield validation[type].safeParseAsync((_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 a custom error handler is provided, use it
-            if (schemas.handler)
-                return schemas.handler(errors, req, res, next);
-            res.status(400).send(errors.map(error => ({ type: error.type, errors: error.errors })));
-            return;
-        }
-        return next();
-    });
-}
-module.exports = validate;

package/dist/esm/index.js

@@ -1,95 +0,0 @@
-import express from 'express';
-import { z } from 'zod';
-const types = ['query', 'params', 'body'];
-const emptyObjectSchema = z.object({}).strict();
-/**
- * A ZodSchema type guard.
- * @param schema The Zod schema to check.
- * @returns Whether the provided schema is a ZodSchema.
- */
-function isZodSchema(schema) {
-    return !!schema && typeof schema.safeParseAsync === 'function';
-}
-// Override express@^5 request.query getter to provider setter
-const descriptor = Object.getOwnPropertyDescriptor(express.request, 'query');
-if (descriptor) {
-    Object.defineProperty(express.request, 'query', {
-        get() {
-            if (this._query)
-                return this._query;
-            return descriptor?.get?.call(this);
-        },
-        set(query) {
-            this._query = query;
-        },
-        configurable: true,
-        enumerable: true
-    });
-}
-/**
- * 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.  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.
- * @template TQuery - Type definition for query schema.
- * @template TBody - Type definition for body schema.
- * @example
- * // Example usage in an Express.js route
- * import express from 'express';
- * import validate from 'express-zod-safe';
- * import { z } from 'zod';
- *
- * const app = express();
- *
- * // Define your Zod schemas
- * const params = {
- *   userId: z.string().uuid(),
- * };
- * const query = {
- *   age: z.coerce.number().optional(),
- * };
- * const body = {
- *   name: z.string(),
- *   email: z.string().email(),
- * };
- *
- * // Use the validate middleware in your route
- * app.post('/user/:userId', validate({ params, query, body }), (req, res) => {
- *   // Your route logic here
- *   res.send('User data is valid!');
- * });
- *
- * app.listen(3000, () => console.log('Server running on port 3000'));
- */
-export default function validate(schemas) {
-    // Create validation objects for each type
-    const validation = {
-        params: isZodSchema(schemas.params) ? schemas.params : z.object(schemas.params ?? {}).strict(),
-        query: isZodSchema(schemas.query) ? schemas.query : z.object(schemas.query ?? {}).strict(),
-        body: isZodSchema(schemas.body) ? schemas.body : z.object(schemas.body ?? {}).strict()
-    };
-    return async (req, res, next) => {
-        const errors = [];
-        // Validate all types (params, query, body)
-        for (const type of types) {
-            const parsed = await validation[type].safeParseAsync(req[type] ?? {});
-            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 a custom error handler is provided, use it
-            if (schemas.handler)
-                return schemas.handler(errors, req, res, next);
-            res.status(400).send(errors.map(error => ({ type: error.type, errors: error.errors })));
-            return;
-        }
-        return next();
-    };
-}
-module.exports = validate;