jwtmoshiur 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jwtmoshiur",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "JWT auto-setup package with token generation and verification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -1,42 +1,36 @@
-# 🔐 JWT Moshiur
+![JWT Moshiur](https://i.postimg.cc/wTPjXQF8/jwtmoshiur.gif)
 
-> Zero-configuration JWT token generator and verifier with automatic project setup.
+# JWT Moshiur
 
-A lightweight, zero-configuration npm package that automatically sets up JWT authentication for your Node.js projects. Install once, get JWT utilities instantly!
+JWT Moshiur is a zero-configuration npm package for quickly adding JWT token generation and verification to Node.js applications. It creates the necessary project files automatically and keeps integration simple.
 
-[![npm version](https://img.shields.io/npm/v/jwtmoshiur.svg)](https://www.npmjs.com/package/jwtmoshiur)
-[![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![npm version](https://img.shields.io/npm/v/jwtmoshiur.svg)](https://www.npmjs.com/package/jwtmoshiur) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-## ✨ Features
+## Overview
 
--  **Zero Configuration** - Automatic setup on installation
--  **Auto Project Setup** - Generates `.env` and utility files
--  **Generate Tokens** - Simple, intuitive token creation
--  **Verify Tokens** - Built-in token validation
--  **Secure** - Uses industry-standard `jsonwebtoken` library
--  **Lightweight** - Minimal dependencies
--  **TypeScript Ready** - Full TypeScript support
--  **Easy Integration** - Works with any Node.js project
+JWT Moshiur simplifies JWT integration by generating a `.env` file and utility scripts during installation. The package supports both JavaScript and TypeScript projects, so you can begin issuing and validating tokens with minimal setup.
 
-##  Installation
+## Installation
 
 ```bash
 npm install jwtmoshiur
 ```
-# After running npm install jwtmoshiur then just run below command and boom 💥
+
+Once installation completes, run the setup command to generate configuration and utility files:
+
 ```bash
 npx jwtmoshiur
 ```
 
-That's it! The package automatically:
--  Creates a `.env` file with secure JWT configuration
--  Generates `utils/generateToken.js` (or `.ts` for TypeScript projects)
--  Generates `utils/verifyToken.js` (or `.ts`)
--  Installs all required dependencies
+After this command, your project will contain:
 
-##  Quick Start
+- `.env` with JWT configuration
+- `utils/generateToken.js` or `utils/generateToken.ts`
+- `utils/verifyToken.js` or `utils/verifyToken.ts`
 
-### 1. Generate a Token
+## Quick Start
+
+### Generate a Token
 
 ```javascript
 const { generateToken } = require('./utils/generateToken');
@@ -48,10 +42,9 @@ const token = generateToken({
 });
 
 console.log(token);
-// eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
 ```
 
-### 2. Verify a Token
+### Verify a Token
 
 ```javascript
 const { verifyToken } = require('./utils/verifyToken');
@@ -59,13 +52,12 @@ const { verifyToken } = require('./utils/verifyToken');
 try {
   const decoded = verifyToken(token);
   console.log(decoded);
-  // { userId: '12345', email: 'user@example.com', role: 'admin', iat: 1715772..., exp: 1715858... }
 } catch (error) {
   console.error('Token is invalid or expired');
 }
 ```
 
-##  Usage Examples
+## Usage Examples
 
 ### Express.js Authentication Middleware
 
@@ -76,30 +68,28 @@ const { generateToken } = require('./utils/generateToken');
 
 const app = express();
 
-// Middleware to protect routes
 const authMiddleware = (req, res, next) => {
-  const token = req.headers.authorization?.split(' ')[1];
-  
+  const authorization = req.headers.authorization;
+  const token = authorization ? authorization.split(' ')[1] : null;
+
   if (!token) {
     return res.status(401).json({ error: 'No token provided' });
   }
-  
+
   try {
     req.user = verifyToken(token);
     next();
-  } catch (error) {
-    res.status(401).json({ error: 'Invalid token' });
+  } catch (err) {
+    return res.status(401).json({ error: 'Invalid token' });
   }
 };
 
-// Login endpoint
 app.post('/login', (req, res) => {
   const user = { id: 1, email: 'user@example.com' };
   const token = generateToken(user);
   res.json({ token });
 });
 
-// Protected endpoint
 app.get('/profile', authMiddleware, (req, res) => {
   res.json({ user: req.user });
 });
@@ -107,29 +97,21 @@ app.get('/profile', authMiddleware, (req, res) => {
 app.listen(3000, () => console.log('Server running on port 3000'));
 ```
 
-### Async/Await Pattern
+### Simple Async/Await Example
 
 ```javascript
 const { generateToken, verifyToken } = require('./utils');
 
 async function authenticateUser(credentials) {
-  try {
-    // Generate token for user
-    const token = generateToken({
-      userId: credentials.id,
-      email: credentials.email,
-      timestamp: Date.now()
-    });
-    
-    // Later, verify the token
-    const payload = verifyToken(token);
-    console.log('User authenticated:', payload.email);
-    
-    return payload;
-  } catch (error) {
-    console.error('Authentication failed:', error.message);
-    throw error;
-  }
+  const token = generateToken({
+    userId: credentials.id,
+    email: credentials.email,
+    timestamp: Date.now()
+  });
+
+  const payload = verifyToken(token);
+  console.log('Authenticated user:', payload.email);
+  return payload;
 }
 ```
 
@@ -138,19 +120,14 @@ async function authenticateUser(credentials) {
 ```javascript
 const { generateToken } = require('./utils/generateToken');
 
-// Create a token that expires in 1 hour
-const shortToken = generateToken(
-  { userId: '123' }
-);
-
-// The expiry is controlled by JWT_EXPIRY in .env
-// Default: 24h
-// Options: 1h, 7d, 30d, etc.
+const token = generateToken({ userId: '123' });
 ```
 
-##  Configuration
+Token expiry is controlled by `JWT_EXPIRY` in `.env`.
+
+## Configuration
 
-Edit your `.env` file to customize JWT settings:
+Update your `.env` file to customize JWT settings:
 
 ```env
 # JWT Moshiur Configuration
@@ -162,26 +139,22 @@ JWT_EXPIRY=24h
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `JWT_SECRET` | Generated | Secret key for signing tokens (change this!) |
-| `JWT_EXPIRY` | `24h` | Token expiration time (`1h`, `7d`, `30d`, etc.) |
+| `JWT_SECRET` | Generated | Secret used to sign tokens |
+| `JWT_EXPIRY` | `24h` | Token expiry period |
 
-** Important:** Always change `JWT_SECRET` to a strong, unique value in production!
+> Use a strong, unique secret in production.
 
-##  API Reference
+## API Reference
 
 ### `generateToken(payload: object): string`
 
 Generates a signed JWT token.
 
-**Parameters:**
-- `payload` (object): Data to encode in the token
-
-**Returns:** JWT token string
-
 **Example:**
+
 ```javascript
-const token = generateToken({ 
-  userId: '123', 
+const token = generateToken({
+  userId: '123',
   email: 'user@example.com',
   role: 'user'
 });
@@ -189,38 +162,30 @@ const token = generateToken({
 
 ### `verifyToken(token: string): object`
 
-Verifies and decodes a JWT token.
-
-**Parameters:**
-- `token` (string): JWT token to verify
-
-**Returns:** Decoded payload object
-
-**Throws:** Error if token is invalid or expired
+Verifies a JWT token and returns the decoded payload.
 
 **Example:**
+
 ```javascript
 try {
   const payload = verifyToken(token);
   console.log('Valid token:', payload);
 } catch (error) {
-  console.log('Invalid token:', error.message);
+  console.error('Invalid token:', error.message);
 }
 ```
 
-##  Manual Setup
+## Manual Setup
 
-If you need to re-run the setup process:
+If you need to run setup again:
 
 ```bash
 npx jwtmoshiur
 ```
 
-This will regenerate the `.env` file and utility files if they don't exist.
-
-##  Project Structure
+## Project Structure
 
-After installation, your project will have:
+After setup, your project will include:
 
 ```
 your-project/
@@ -233,31 +198,37 @@ your-project/
 └── package.json
 ```
 
-##  Security Best Practices
+## Security Guidelines
+
+- Do not commit `.env` to source control.
+- Use a strong JWT secret.
+- Rotate secrets periodically.
+- Use HTTPS in production.
+- Choose an expiry period that fits your security requirements.
+
+## Troubleshooting
+
+#### Setup did not run automatically
+
+Run:
+
+```bash
+npx jwtmoshiur
+```
 
-1. **Never commit `.env` to version control**
-   ```bash
-   # Add to .gitignore
-   .env
-   .env.local
-   ```
+#### Token verification fails
 
-2. **Use strong secrets**
-   ```bash
-   # Generate a strong secret (Linux/Mac)
-   openssl rand -base64 32
-   
-   # Or use a random string generator
-   node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
-   ```
+- Confirm `JWT_SECRET` is present in `.env`
+- Confirm token has not expired
+- Confirm the token was generated with the same secret
 
-3. **Rotate secrets regularly** in production
+#### `.env` file is missing
 
-4. **Use HTTPS** only in production
+Run the setup command manually and verify the file exists.
 
-5. **Set appropriate expiry times** for your use case
+## License
 
-## 🛠️ Troubleshooting
+MIT
 
 ### Issue: Auto setup not working after npm install
 **Solution:** Manually run the setup command: