devdad-express-utils 1.1.0 → 1.1.2

package/README.md

@@ -52,13 +52,35 @@ import { AppError } from "devdad-express-utils";
 throw new AppError("Validation failed", 400, ["Email is required"]);
 ```
 
-#### JavaScript Usage
+### Response Formatting
 
-```javascript
-const { AppError, catchAsync, errorHandler } = require("devdad-express-utils");
+Standardize API responses with consistent JSON structure.
 
-// Or with ES modules
-import { AppError, catchAsync, errorHandler } from "devdad-express-utils";
+```typescript
+import { sendSuccess, sendError, sendPaginated } from "devdad-express-utils";
+
+// Success response
+sendSuccess(res, { id: 1, name: 'John' }, 'User fetched', 200);
+
+// Error response
+sendError(res, 'User not found', 404);
+
+
+```
+
+### Authentication Middleware
+
+JWT-based authentication wrapper.
+
+```typescript
+import { requireAuth } from "devdad-express-utils";
+
+const authMiddleware = requireAuth({ secret: process.env.JWT_SECRET });
+
+app.get('/profile', authMiddleware, (req, res) => {
+  // req.user contains decoded JWT
+  res.json(req.user);
+});
 ```
 
 ## Error Handling Patterns
@@ -142,6 +164,32 @@ Express error handling middleware with detailed logging in development.
 errorHandler(err: any, req: Request, res: Response, next: NextFunction) => void
 ```
 
+### sendSuccess
+
+Sends a standardized success response.
+
+```typescript
+sendSuccess(res: Response, data: any, message?: string, statusCode?: number) => void
+```
+
+### sendError
+
+Sends a standardized error response.
+
+```typescript
+sendError(res: Response, message: string, statusCode?: number, data?: any) => void
+```
+
+
+
+### requireAuth
+
+Middleware for JWT authentication.
+
+```typescript
+requireAuth(options: { secret: string, algorithms?: Algorithm[] }) => (req, res, next) => void
+```
+
 ## Development
 
 ```bash

package/dist/authWrapper.d.ts

@@ -0,0 +1,17 @@
+import { JwtPayload, Algorithm } from "jsonwebtoken";
+import { Request, Response, NextFunction } from "express";
+interface AuthOptions {
+    secret: string;
+    algorithms?: Algorithm[];
+}
+interface AuthenticatedRequest extends Request {
+    user?: JwtPayload | string;
+}
+/**
+ * Middleware to require JWT authentication.
+ * Verifies the JWT token from Authorization header and attaches decoded payload to req.user.
+ * @param {AuthOptions} options - JWT verification options.
+ * @returns {(req: Request, res: Response, next: NextFunction) => void} - Middleware function.
+ */
+export declare const requireAuth: (options: AuthOptions) => (req: AuthenticatedRequest, res: Response, next: NextFunction) => void;
+export {};

package/dist/authWrapper.js

@@ -0,0 +1,48 @@
+import jwt, { JsonWebTokenError, TokenExpiredError, } from "jsonwebtoken";
+import { AppError } from "./AppError.js";
+const defaultAlgorithms = ["HS256"];
+/**
+ * Middleware to require JWT authentication.
+ * Verifies the JWT token from Authorization header and attaches decoded payload to req.user.
+ * @param {AuthOptions} options - JWT verification options.
+ * @returns {(req: Request, res: Response, next: NextFunction) => void} - Middleware function.
+ */
+export const requireAuth = (options) => {
+    return (req, res, next) => {
+        const authHeader = req.headers.authorization;
+        if (!authHeader) {
+            throw new AppError("Access denied. No token provided.", 401);
+        }
+        if (!authHeader.startsWith("Bearer ")) {
+            throw new AppError("Malformed authorization header.", 401);
+        }
+        const token = authHeader.substring(7);
+        if (!token) {
+            throw new AppError("Access denied. No token provided.", 401);
+        }
+        try {
+            let decoded;
+            if (options.algorithms) {
+                decoded = jwt.verify(token, options.secret, {
+                    algorithms: options.algorithms,
+                });
+            }
+            else {
+                decoded = jwt.verify(token, options.secret);
+            }
+            req.user = decoded;
+            next();
+        }
+        catch (error) {
+            if (error instanceof JsonWebTokenError) {
+                throw new AppError("Invalid token.", 401);
+            }
+            else if (error instanceof TokenExpiredError) {
+                throw new AppError("Token expired.", 401);
+            }
+            else {
+                throw new AppError("Authentication failed.", 401);
+            }
+        }
+    };
+};

package/dist/catchAsync.js

@@ -5,6 +5,6 @@
  * @returns {(req: Request, res: Response, next: NextFunction) => void} - The wrapped handler that catches errors.
  */
 export const catchAsync = (fn) => (req, res, next) => {
-    fn(req, res, next).catch(next);
+    Promise.resolve(fn(req, res, next)).catch(next);
 };
 //#endregion

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { AppError } from "./AppError.js";
 export { catchAsync } from "./catchAsync.js";
 export { errorHandler } from "./errorHandler.js";
+export { sendSuccess, sendError } from "./responseFormatter.js";
+export { requireAuth } from "./authWrapper.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export { AppError } from "./AppError.js";
 export { catchAsync } from "./catchAsync.js";
 export { errorHandler } from "./errorHandler.js";
+export { sendSuccess, sendError } from "./responseFormatter.js";
+export { requireAuth } from "./authWrapper.js";

package/dist/responseFormatter.d.ts

@@ -0,0 +1,17 @@
+import { Response } from "express";
+/**
+ * Sends a success response.
+ * @param {Response} res - Express response object.
+ * @param {any} data - Response data.
+ * @param {string} [message='Success'] - Response message.
+ * @param {number} [statusCode=200] - HTTP status code.
+ */
+export declare const sendSuccess: (res: Response, data: any, message?: string, statusCode?: number) => void;
+/**
+ * Sends an error response.
+ * @param {Response} res - Express response object.
+ * @param {string} message - Error message.
+ * @param {number} [statusCode=400] - HTTP status code.
+ * @param {any} [data] - Additional error data.
+ */
+export declare const sendError: (res: Response, message: string, statusCode?: number, data?: any) => void;

package/dist/responseFormatter.js

@@ -0,0 +1,30 @@
+/**
+ * Sends a success response.
+ * @param {Response} res - Express response object.
+ * @param {any} data - Response data.
+ * @param {string} [message='Success'] - Response message.
+ * @param {number} [statusCode=200] - HTTP status code.
+ */
+export const sendSuccess = (res, data, message = "Success", statusCode = 200) => {
+    const response = {
+        status: "success",
+        message,
+        data,
+    };
+    res.status(statusCode).json(response);
+};
+/**
+ * Sends an error response.
+ * @param {Response} res - Express response object.
+ * @param {string} message - Error message.
+ * @param {number} [statusCode=400] - HTTP status code.
+ * @param {any} [data] - Additional error data.
+ */
+export const sendError = (res, message, statusCode = 400, data) => {
+    const response = {
+        status: "error",
+        message,
+        ...(data && { data }),
+    };
+    res.status(statusCode).json(response);
+};

package/dist/validateRequest.d.ts

@@ -0,0 +1,9 @@
+import { ValidationChain } from 'express-validator';
+import { Request, Response, NextFunction } from 'express';
+/**
+ * Middleware wrapper for express-validator validations.
+ * Runs the provided validations and throws AppError if any fail.
+ * @param {ValidationChain[]} validations - Array of express-validator validation chains.
+ * @returns {(req: Request, res: Response, next: NextFunction) => Promise<void>} - Middleware function.
+ */
+export declare const validateRequest: (validations: ValidationChain[]) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/validateRequest.js

@@ -0,0 +1,19 @@
+import { validationResult } from 'express-validator';
+import { AppError } from './AppError.js';
+/**
+ * Middleware wrapper for express-validator validations.
+ * Runs the provided validations and throws AppError if any fail.
+ * @param {ValidationChain[]} validations - Array of express-validator validation chains.
+ * @returns {(req: Request, res: Response, next: NextFunction) => Promise<void>} - Middleware function.
+ */
+export const validateRequest = (validations) => {
+    return async (req, res, next) => {
+        await Promise.all(validations.map(validation => validation.run(req)));
+        const errors = validationResult(req);
+        if (!errors.isEmpty()) {
+            const errorMessages = errors.array().map(err => err.msg);
+            throw new AppError('Validation failed', 400, errorMessages);
+        }
+        next();
+    };
+};

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "devdad-express-utils",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Reusable Express.js utilities for error handling, async wrapping, and more",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -18,13 +20,23 @@
     "javascript"
   ],
   "author": "Oliver Metz",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Devdad-Main/Express-Utils.git"
+  },
   "license": "ISC",
   "dependencies": {
-    "express": "^5.1.0"
+    "express": "^5.1.0",
+    "jsonwebtoken": "^9.0.2"
   },
   "devDependencies": {
     "@types/express": "^5.0.5",
-    "typescript": "^5.9.3"
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/supertest": "^6.0.3",
+    "@vitest/ui": "^4.0.14",
+    "supertest": "^7.1.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.14"
   },
   "files": [
     "dist"